Synnefo » snf-ganeti » ganeti-local

    """Query information about all instances.

    """

  @staticmethod

  def perspective_instance_list(params):

    """Query the list of running instances.

    """

  # node --------------------------

    """Query node information.

    """

  @staticmethod

  def perspective_node_add(params):

  raise errors.QuitGanetiException(False, 'Shutdown scheduled')

  """Gives back a hash with different informations about the node.

  """

  outputarray = {}

  outputarray['vg_size'] = vginfo['vg_size']

  outputarray['vg_free'] = vginfo['vg_free']

  hyp_info = hyper.GetNodeInfo()

  if hyp_info is not None:

    outputarray.update(hyp_info)

def VerifyNode(what, cluster_name):

  """Verify the status of the local node.

  """

  result = {}

  if 'hypervisor' in what:

  if 'filelist' in what:

    result['filelist'] = utils.FingerprintFiles(what['filelist'])

  return True

  """Provides a list of instances.

  """

  """Gives back the informations about an instance as a dictionary.

  """

  output = {}

  if iinfo is not None:

    output['memory'] = iinfo[2]

    output['state'] = iinfo[4]

  return output

  """Gather data about all instances.

  This is the equivalent of `GetInstanceInfo()`, except that it

  computes data for all instances at once, thus being faster if one

  needs data about more than one instance.

  """

  output = {}

  return output

    swap_disk: the instance-visible name of the swap device

  """

  inst_os = OSFromDisk(instance.os)

  create_script = inst_os.create_script

                                inst_os.path, create_script, instance.name,

                                real_os_dev.dev_path, real_swap_dev.dev_path,

                                logfile)

  result = utils.RunCmd(command, env=env)

  if result.failed:

def StartInstance(instance, extra_args):

  """Start an instance.

  """

  if instance.name in running_instances:

    return True

  block_devices = _GatherBlockDevs(instance)

  try:

    hyper.StartInstance(instance, block_devices, extra_args)

def ShutdownInstance(instance):

  """Shut an instance down.

  """

  if instance.name not in running_instances:

    return True

  try:

    hyper.StopInstance(instance)

  except errors.HypervisorError, err:

  time.sleep(1)

  for dummy in range(11):

      break

    time.sleep(10)

  else:

      return False

    time.sleep(1)

      logging.error("could not shutdown instance '%s' even by destroy",

                    instance.name)

      return False

    reboot_type - how to reboot [soft,hard,full]

  """

  if instance.name not in running_instances:

    logging.error("Cannot reboot instance that is not running")

    return False

  if reboot_type == constants.INSTANCE_REBOOT_SOFT:

    try:

      hyper.RebootInstance(instance)

  else:

    raise errors.ParameterError("reboot_type invalid")

  return True

      - msg is a string with details in case of failure

  """

  try:

    hyper.MigrateInstance(instance.name, target, live)

    False in case of error, True otherwise.

  """

  inst_os = OSFromDisk(instance.os)

  import_script = inst_os.import_script

                               logfile)

  command = '|'.join([utils.ShellQuoteArgs(remotecmd), comprcmd, impcmd])

  result = utils.RunCmd(command, env=env)

                          (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

    }

  """Return a Hypervisor instance.

  This function parses the cluster hypervisor configuration file and

  instantiates a class based on the value of this file.

  """

  if ht_kind not in _HYPERVISOR_MAP:

    raise errors.HypervisorError("Unknown hypervisor type '%s'" % ht_kind)

    "name",

    "primary_node",

    "os",

    "status",

    "memory",

    "vcpus",

    "master_netdev",

    "cluster_name",

    "file_storage_dir",

    ]

  def ToDict(self):

    "hvm_pae", "hvm_cdrom_image_path", "vnc_bind_address",

    "file_storage_dir", "file_driver",

    "iallocator", "hvm_nic_type", "hvm_disk_type",

    ]

  @type node: string

  @param node: the node on which the instance is currently running

  @param instance: the instance definition

  @type target: string

  @param target: the target node name

  return c.getresult().get(node, False)

  """Returns information about a single instance.

  This is a single-node call.

  """

  c = Client("instance_info", [instance])

  c.connect(node)

  return c.getresult().get(node, False)

  """

  c.connect_list(node_list)

  c.run()

  return c.getresult()

  """Returns the list of running instances on a given node.

  """

  c.connect_list(node_list)

  c.run()

  return c.getresult()

  return c.getresult().get(node, False)

  """Return node information.

  This will return memory information and volume group size and free

  This is a multi-node call.

  """

  c.connect_list(node_list)

  c.run()

  retux = c.getresult()

_VALUE_TRUE = "true"

_LIST_DEF_FIELDS = [

  ]

      "hvm_nic_type": "HVM_NIC_type",

      "hvm_disk_type": "HVM_disk_type",

      "vnc_bind_address": "VNC_bind_address",

      }

  else:

    headers = None

    buf.write("  Nodes:\n")

    buf.write("    - primary: %s\n" % instance["pnode"])

    buf.write("    - secondaries: %s\n" % ", ".join(instance["snodes"]))

    buf.write("  Operating system: %s\n" % instance["os"])

    if instance.has_key("network_port"):

      buf.write("  Allocated network port: %s\n" % instance["network_port"])

           "Lists the instances and their status. The available fields are"

           " (see the man page for details): status, oper_state, oper_ram,"

           " name, os, pnode, snodes, admin_state, admin_ram, disk_template,"

           " The default field"

           " list is (in order): %s." % ", ".join(_LIST_DEF_FIELDS),

           ),