Synnefo » snf-ganeti

                          (node, node_result['node-net-test'][node]))

    hyp_result = node_result.get('hypervisor', None)

    return bad

  def _VerifyInstance(self, instance, instanceconfig, node_vol_is,

      feedback_fn("  - ERROR: %s" % msg)

    vg_name = self.cfg.GetVGName()

    nodelist = utils.NiceSort(self.cfg.GetNodeList())

    nodeinfo = [self.cfg.GetNodeInfo(nname) for nname in nodelist]

    instancelist = utils.NiceSort(self.cfg.GetInstanceList())

    feedback_fn("* Gathering data (%d nodes)" % len(nodelist))

    all_volumeinfo = rpc.call_volume_list(nodelist, vg_name)

    all_vglist = rpc.call_vg_list(nodelist)

    node_verify_param = {

      'filelist': file_names,

      'nodelist': nodelist,

      'node-net-test': [(node.name, node.primary_ip, node.secondary_ip)

                        for node in nodeinfo]

      }

    all_nvinfo = rpc.call_node_verify(nodelist, node_verify_param,

                                      self.cfg.GetClusterName())

    all_rversion = rpc.call_version(nodelist)

    for node in nodelist:

      feedback_fn("* Verifying node %s" % node)

    if self.dynamic_fields.intersection(self.op.output_fields):

      live_data = {}

      for name in nodenames:

        nodeinfo = node_data.get(name, None)

        if nodeinfo:

                       (fname, to_node))

    to_copy = []

      to_copy.append(constants.VNC_PASSWORD_FILE)

    for fname in to_copy:

      result = rpc.call_upload_file([node], fname)

      "master": self.cfg.GetMasterNode(),

      "architecture": (platform.architecture()[0], platform.machine()),

      "hypervisor_type": self.cfg.GetHypervisorType(),

      }

    return result

  _ShutdownInstanceDisks.

  """

  ins_l = ins_l[instance.primary_node]

  if not type(ins_l) is list:

    raise errors.OpExecError("Can't contact node '%s'" %

  return result

  """Checks if a node has enough free memory.

  This function check if a given node has the needed amount of free

  information from the node, this function raise an OpPrereqError

  exception.

  """

  if not nodeinfo or not isinstance(nodeinfo, dict):

    raise errors.OpPrereqError("Could not contact node %s for resource"

                             " information" % (node,))

    _CheckNodeFreeMemory(self.cfg, instance.primary_node,

                         "starting instance %s" % instance.name,

  def Exec(self, feedback_fn):

    """Start the instance.

    if instance.status != "down":

      raise errors.OpPrereqError("Instance '%s' is marked to be up" %

                                 self.op.instance_name)

    if remote_info:

      raise errors.OpPrereqError("Instance '%s' is running on the node %s" %

                                 (self.op.instance_name,

    if instance.status != "down":

      raise errors.OpPrereqError("Instance '%s' is marked to be up" %

                                 self.op.instance_name)

    if remote_info:

      raise errors.OpPrereqError("Instance '%s' is running on the node %s" %

                                 (self.op.instance_name,

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

      "hvm_cdrom_image_path", "hvm_nic_type",

      "hvm_disk_type", "vnc_bind_address",

      ])

    _CheckOutputFields(static=self.static_fields,

                       dynamic=self.dynamic_fields,

    # begin data gathering

    nodes = frozenset([inst.primary_node for inst in instance_list])

    bad_nodes = []

    if self.dynamic_fields.intersection(self.op.output_fields):

      live_data = {}

      for name in nodes:

        result = node_data[name]

        if result:

            val = "default"

          else:

            val = "-"

        else:

          raise errors.ParameterError(field)

        iout.append(val)

    target_node = secondary_nodes[0]

    # check memory requirements on the secondary node

    _CheckNodeFreeMemory(self.cfg, target_node, "failing over instance %s" %

    # check bridge existance

    brlist = [nic.bridge for nic in instance.nics]

    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",

      if not hasattr(self.op, attr):

        setattr(self.op, attr, None)

      raise errors.OpPrereqError("Cluster does not support lvm-based"

                                 " instances")

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

      src_node = self.op.src_node

      src_path = self.op.src_path

    # Check lv size requirements

    if req_size is not None:

      nodenames = [pnode.name] + self.secondaries

      for node in nodenames:

        info = nodeinfo.get(node, None)

        if not info:

    if self.op.start:

      _CheckNodeFreeMemory(self.cfg, self.pnode.name,

                           "creating instance %s" % self.op.instance_name,

    # hvm_cdrom_image_path verification

    if self.op.hvm_cdrom_image_path is not None:

                                   self.op.vnc_bind_address)

    # Xen HVM device type checks

      if self.op.hvm_nic_type not in constants.HT_HVM_VALID_NIC_TYPES:

        raise errors.OpPrereqError("Invalid NIC type %s specified for Xen HVM"

                                   " hypervisor" % self.op.hvm_nic_type)

    if self.inst_ip is not None:

      nic.ip = self.inst_ip

    if ht_kind in constants.HTS_REQ_PORT:

      network_port = self.cfg.AllocatePort()

    else:

                            vnc_bind_address=self.op.vnc_bind_address,

                            hvm_nic_type=self.op.hvm_nic_type,

                            hvm_disk_type=self.op.hvm_disk_type,

                            )

    feedback_fn("* creating instance disks...")

    instance = self.instance

    node = instance.primary_node

    if node_insts is False:

      raise errors.OpExecError("Can't connect to node %s." % node)

    logger.Debug("connecting to console of %s on %s" % (instance.name, node))

    console_cmd = hyper.GetShellCommandForConsole(instance)

    # build ssh cmdline

                                 (self.op.disk, instance.name))

    nodenames = [instance.primary_node] + list(instance.secondary_nodes)

    for node in nodenames:

      info = nodeinfo.get(node, None)

      if not info:

    result = {}

    for instance in self.wanted_instances:

      remote_info = rpc.call_instance_info(instance.primary_node,

      if remote_info and "state" in remote_info:

        remote_state = "up"

      else:

        "nics": [(nic.mac, nic.ip, nic.bridge) for nic in instance.nics],

        "disks": disks,

        "vcpus": instance.vcpus,

        }

      if htkind == constants.HT_XEN_PVM30:

        idict["kernel_path"] = instance.kernel_path

        idict["initrd_path"] = instance.initrd_path

      pnode = self.instance.primary_node

      nodelist = [pnode]

      nodelist.extend(instance.secondary_nodes)

      if pnode not in nodeinfo or not isinstance(nodeinfo[pnode], dict):

        # Assume the primary node is unreachable and go ahead

                           " node %s" % node)

    # Xen HVM device type checks

      if self.op.hvm_nic_type is not None:

        if self.op.hvm_nic_type not in constants.HT_HVM_VALID_NIC_TYPES:

          raise errors.OpPrereqError("Invalid NIC type %s specified for Xen"

    """

    cfg = self.cfg

    # cluster data

    data = {

      "version": 1,

      "cluster_name": self.cfg.GetClusterName(),

      # we don't have job IDs

      }

    # node data

    node_results = {}

    node_list = cfg.GetNodeList()

    for nname in node_list:

      ninfo = cfg.GetNodeInfo(nname)

      if nname not in node_data or not isinstance(node_data[nname], dict):

        "nics": nic_data,

        "disks": [{"size": dsk.size, "mode": "w"} for dsk in iinfo.disks],

        "disk_template": iinfo.disk_template,

        }

      instance_data[iinfo.name] = pir