Synnefo » snf-ganeti » ganeti-local

  REQ_BGL = False

  def _ExpandNode(self, node):

    """Expands and checks one node name.

    """

    node_full = self.cfg.ExpandNodeName(node)

    if node_full is None:

      raise errors.OpPrereqError("Unknown node %s" % node)

    return node_full

  def ExpandNames(self):

    """ExpandNames for CreateInstance.

    Figure out the right locks for instance creation.

    """

    self.needed_locks = {}

    # set optional parameters to none if they don't exist

    for attr in ["kernel_path", "initrd_path", "pnode", "snode",

                 "iallocator", "hvm_boot_order", "hvm_acpi", "hvm_pae",

                 "hvm_cdrom_image_path", "hvm_nic_type", "hvm_disk_type",

                 "vnc_bind_address"]:

      if not hasattr(self.op, attr):

        setattr(self.op, attr, None)

    # verify creation mode

    if self.op.mode not in (constants.INSTANCE_CREATE,

                            constants.INSTANCE_IMPORT):

      raise errors.OpPrereqError("Invalid instance creation mode '%s'" %

                                 self.op.mode)

    # disk template and mirror node verification

    if self.op.disk_template not in constants.DISK_TEMPLATES:

      raise errors.OpPrereqError("Invalid disk template name")

    #### instance parameters check

    # instance name verification

    hostname1 = utils.HostInfo(self.op.instance_name)

    self.op.instance_name = instance_name = hostname1.name

    # this is just a preventive check, but someone might still add this

    # instance in the meantime, and creation will fail at lock-add time

    if instance_name in self.cfg.GetInstanceList():

      raise errors.OpPrereqError("Instance '%s' is already in the cluster" %

                                 instance_name)

    self.add_locks[locking.LEVEL_INSTANCE] = instance_name

    # ip validity checks

    ip = getattr(self.op, "ip", None)

    if ip is None or ip.lower() == "none":

      inst_ip = None

    elif ip.lower() == "auto":

      inst_ip = hostname1.ip

    else:

      if not utils.IsValidIP(ip):

        raise errors.OpPrereqError("given IP address '%s' doesn't look"

                                   " like a valid IP" % ip)

      inst_ip = ip

    self.inst_ip = self.op.ip = inst_ip

    # used in CheckPrereq for ip ping check

    self.check_ip = hostname1.ip

    # MAC address verification

    if self.op.mac != "auto":

      if not utils.IsValidMac(self.op.mac.lower()):

        raise errors.OpPrereqError("invalid MAC address specified: %s" %

                                   self.op.mac)

    # boot order verification

    if self.op.hvm_boot_order is not None:

      if len(self.op.hvm_boot_order.strip("acdn")) != 0:

        raise errors.OpPrereqError("invalid boot order specified,"

                                   " must be one or more of [acdn]")

    # file storage checks

    if (self.op.file_driver and

        not self.op.file_driver in constants.FILE_DRIVER):

      raise errors.OpPrereqError("Invalid file driver name '%s'" %

                                 self.op.file_driver)

    if self.op.file_storage_dir and os.path.isabs(self.op.file_storage_dir):

      raise errors.OpPrereqError("File storage directory path not absolute")

    ### Node/iallocator related checks

    if [self.op.iallocator, self.op.pnode].count(None) != 1:

      raise errors.OpPrereqError("One and only one of iallocator and primary"

                                 " node must be given")

    if self.op.iallocator:

      self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET

    else:

      self.op.pnode = self._ExpandNode(self.op.pnode)

      nodelist = [self.op.pnode]

      if self.op.snode is not None:

        self.op.snode = self._ExpandNode(self.op.snode)

        nodelist.append(self.op.snode)

      self.needed_locks[locking.LEVEL_NODE] = nodelist

    # in case of import lock the source node too

    if self.op.mode == constants.INSTANCE_IMPORT:

      src_node = getattr(self.op, "src_node", None)

      src_path = getattr(self.op, "src_path", None)

      if src_node is None or src_path is None:

        raise errors.OpPrereqError("Importing an instance requires source"

                                   " node and path options")

      if not os.path.isabs(src_path):

        raise errors.OpPrereqError("The source path must be absolute")

      self.op.src_node = src_node = self._ExpandNode(src_node)

      if self.needed_locks[locking.LEVEL_NODE] is not locking.ALL_SET:

        self.needed_locks[locking.LEVEL_NODE].append(src_node)

    else: # INSTANCE_CREATE

      if getattr(self.op, "os_type", None) is None:

        raise errors.OpPrereqError("No guest OS specified")

      src_node = self.op.src_node

      src_path = self.op.src_path

    # ip ping checks (we use the same ip that was resolved in ExpandNames)

      if utils.TcpPing(self.check_ip, constants.DEFAULT_NODED_PORT):

                                   (self.check_ip, instance_name))

    self.pnode = pnode = self.cfg.GetNodeInfo(self.op.pnode)

    assert self.pnode is not None, \

      "Cannot retrieve locked node %s" % self.op.pnode

      if self.op.snode is None:

      if self.op.snode == pnode.name:

      self.secondaries.append(self.op.snode)

      # FIXME (als): shouldn't these checks happen on the destination node?

    # Declare that we don't want to remove the instance lock anymore, as we've

    # added the instance to the config

    del self.remove_locks[locking.LEVEL_INSTANCE]

      # Make sure the instance lock gets removed

      self.remove_locks[locking.LEVEL_INSTANCE] = iobj.name