Synnefo » snf-ganeti » ganeti-local

    # either single node cluster, or a misconfiguration, but I won't

    # break any other node, so I can proceed

    return True

  if not isinstance(results, dict):

    # this should not happen (unless internal error in rpc)

    logging.critical("Can't complete rpc call, aborting master startup")

  # activate ip

  master_node = ssconf.SimpleConfigReader().GetMasterNode()

    logging.error("Can't activate master IP address")

  master.setup_queue()

from ganeti import objects

from ganeti import ssconf

def _InitSSHSetup(node):

  """Setup the SSH configuration for the cluster.

  # start the master ip

  # TODO: Review rpc call from bootstrap

def InitConfig(version, cluster_config, master_node_config,

  begun in cmdlib.LUDestroyOpcode.

  """

    logging.warning("Could not disable the master role")

    logging.warning("Could not shutdown the node daemon and cleanup the node")

  logging.info("setting master to %s, old master: %s", new_master, old_master)

    logging.error("could disable the master role on the old master"

                 " %s, please disable manually", old_master)

  # Here we have a phase where no master should be running

    logging.error("could not distribute the new simple store master file"

                  " to the other nodes, please check.")

    logging.error("could not start the master role on the new master"

                  " %s, please check", new_master)

    rcode = 1

import platform

import logging

from ganeti import ssh

from ganeti import logger

from ganeti import utils

  REQ_MASTER = True

  REQ_BGL = True

    """Constructor for LogicalUnit.

    This needs to be overriden in derived classes in order to check op

    self.op = op

    self.cfg = context.cfg

    self.context = context

    # Dicts used to declare locking needs to mcpu

    self.needed_locks = None

    self.acquired_locks = {}

  """

  # check bridges existance

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

    raise errors.OpPrereqError("one or more target bridges %s does not"

                               " exist on destination node '%s'" %

                               (brlist, instance.primary_node))

    """

    master = self.cfg.GetMasterNode()

      raise errors.OpExecError("Could not disable the master role")

    priv_key, pub_key, _ = ssh.GetUserFiles(constants.GANETI_RUNAS)

    utils.CreateBackup(priv_key)

    local_checksums = utils.FingerprintFiles(file_names)

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

    node_verify_param = {

      'filelist': file_names,

      'nodelist': nodelist,

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

                        for node in nodeinfo]

      }

    for node in nodelist:

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

    if not nv_dict:

      return result

    to_act = set()

    for node in nodes:

    # shutdown the master IP

    master = self.cfg.GetMasterNode()

      raise errors.OpExecError("Could not disable the master role")

    try:

      logger.Debug("Copying updated ssconf data to all nodes")

      for keyname in [ss.SS_CLUSTER_NAME, ss.SS_MASTER_IP]:

        fname = ss.KeyToFilename(keyname)

        for to_node in dist_nodes:

          if not result[to_node]:

            logger.Error("copy of file %s to node %s failed" %

                         (fname, to_node))

    finally:

        logger.Error("Could not re-enable the master role on the master,"

                     " please restart manually.")

    # if vg_name not None, checks given volume group on all nodes

    if self.op.vg_name:

      node_list = self.acquired_locks[locking.LEVEL_NODE]

      for node in node_list:

        vgstatus = utils.CheckVolumeGroupSize(vglist[node], self.op.vg_name,

                                              constants.MIN_VG_SIZE)

    max_time = 0

    done = True

    cumul_degraded = False

    if not rstats:

      lu.proc.LogWarning("Can't get any data from node %s" % node)

      retries += 1

  result = True

  if on_primary or dev.AssembleOnSecondary():

    if not rstats:

      logger.ToStderr("Node %s: Disk degraded, not found or node down" % node)

      result = False

    """

    node_list = self.acquired_locks[locking.LEVEL_NODE]

    if node_data == False:

      raise errors.OpExecError("Can't gather the list of OSes")

    pol = self._DiagnoseByOS(node_list, node_data)

    self.context.RemoveNode(node.name)

class LUQueryNodes(NoHooksLU):

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

      live_data = {}

      for name in nodenames:

        nodeinfo = node_data.get(name, None)

        if nodeinfo:

    """

    nodenames = self.nodes

    ilist = [self.cfg.GetInstanceInfo(iname) for iname

             in self.cfg.GetInstanceList()]

    node = new_node.name

    # check connectivity

    if result:

      if constants.PROTOCOL_VERSION == result:

        logger.Info("communication to node %s fine, sw version %s match" %

      finally:

        f.close()

    if not result:

      raise errors.OpExecError("Cannot transfer ssh keys to the new node")

    utils.AddHostToEtcHosts(new_node.name)

    if new_node.secondary_ip != new_node.primary_ip:

        raise errors.OpExecError("Node claims it doesn't have the secondary ip"

                                 " you gave (%s). Please fix and re-run this"

                                 " command." % new_node.secondary_ip)

      # TODO: do a node-net-test as well?

    }

    for verifier in node_verify_list:

      if not result[verifier]:

        raise errors.OpExecError("Cannot communicate with %s's node daemon"

    logger.Debug("Copying hosts and known_hosts to all nodes")

    for fname in (constants.ETC_HOSTS, constants.SSH_KNOWN_HOSTS_FILE):

      for to_node in dist_nodes:

        if not result[to_node]:

          logger.Error("copy of file %s to node %s failed" %

    if constants.HT_XEN_HVM in self.cfg.GetClusterInfo().enabled_hypervisors:

      to_copy.append(constants.VNC_PASSWORD_FILE)

    for fname in to_copy:

      if not result[node]:

        logger.Error("could not copy file %s to node %s" % (fname, node))

  for inst_disk in instance.disks:

    for node, node_disk in inst_disk.ComputeNodeTree(instance.primary_node):

      lu.cfg.SetDiskID(node_disk, node)

      if not result:

        logger.Error("could not prepare block device %s on node %s"

                     " (is_primary=False, pass=1)" % (inst_disk.iv_name, node))

      if node != instance.primary_node:

        continue

      lu.cfg.SetDiskID(node_disk, node)

      if not result:

        logger.Error("could not prepare block device %s on node %s"

                     " (is_primary=True, pass=2)" % (inst_disk.iv_name, node))

  _ShutdownInstanceDisks.

  """

  ins_l = ins_l[instance.primary_node]

  if not type(ins_l) is list:

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

  for disk in instance.disks:

    for node, top_disk in disk.ComputeNodeTree(instance.primary_node):

      lu.cfg.SetDiskID(top_disk, node)

        logger.Error("could not shutdown block device %s on node %s" %

                     (disk.iv_name, node))

        if not ignore_primary or node != instance.primary_node:

      we cannot check the node

  """

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

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

                             " information" % (node,))

    _StartInstanceDisks(self, instance, force)

      _ShutdownInstanceDisks(self, instance)

      raise errors.OpExecError("Could not start instance")

    if reboot_type in [constants.INSTANCE_REBOOT_SOFT,

                       constants.INSTANCE_REBOOT_HARD]:

        raise errors.OpExecError("Could not reboot instance")

    else:

        raise errors.OpExecError("could not shutdown instance for full reboot")

      _ShutdownInstanceDisks(self, instance)

      _StartInstanceDisks(self, instance, ignore_secondaries)

        _ShutdownInstanceDisks(self, instance)

        raise errors.OpExecError("Could not start instance for full reboot")

    instance = self.instance

    node_current = instance.primary_node

    self.cfg.MarkInstanceDown(instance.name)

      logger.Error("could not shutdown instance")

    _ShutdownInstanceDisks(self, 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 pnode is None:

        raise errors.OpPrereqError("Primary node '%s' is unknown" %

                                   self.op.pnode)

      if not os_obj:

        raise errors.OpPrereqError("OS '%s' not in supported OS list for"

                                   " primary node"  % self.op.os_type)

    _StartInstanceDisks(self, inst, None)

    try:

      feedback_fn("Running the instance OS create scripts...")

        raise errors.OpExecError("Could not install OS for instance %s"

                                 " on node %s" %

                                 (inst.name, inst.primary_node))

    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 inst.disk_template == constants.DT_FILE:

      new_file_storage_dir = os.path.dirname(inst.disks[0].logical_id[1])

      if not result:

        raise errors.OpExecError("Could not connect to node '%s' to rename"

    _StartInstanceDisks(self, inst, None)

    try:

        msg = ("Could not run OS rename script for instance %s on node %s"

               " (but the instance has been renamed in Ganeti)" %

               (inst.name, inst.primary_node))

    logger.Info("shutting down instance %s on node %s" %

                (instance.name, instance.primary_node))

      if self.op.ignore_failures:

        feedback_fn("Warning: can't shutdown instance")

      else:

    bad_nodes = []

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

      live_data = {}

      for name in nodes:

        result = node_data[name]

        if result:

    # check bridge existance

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

      raise errors.OpPrereqError("One or more target bridges %s does not"

                                 " exist on destination node '%s'" %

                                 (brlist, target_node))

    logger.Info("Shutting down instance %s on node %s" %

                (instance.name, source_node))

      if self.op.ignore_consistency:

        logger.Error("Could not shutdown instance %s on node %s. Proceeding"

                     " anyway. Please make sure node %s is down"  %

        raise errors.OpExecError("Can't activate the instance's disks")

      feedback_fn("* starting the instance on the target node")

        _ShutdownInstanceDisks(self, instance)

        raise errors.OpExecError("Could not start instance %s on node %s." %

                                 (instance.name, target_node))

        return False

  lu.cfg.SetDiskID(device, node)

  if not new_id:

    return False

  if device.physical_id is None:

  if not force:

    return True

  lu.cfg.SetDiskID(device, node)

  if not new_id:

    return False

  if device.physical_id is None:

  if instance.disk_template == constants.DT_FILE:

    file_storage_dir = os.path.dirname(instance.disks[0].logical_id[1])

    if not result:

      logger.Error("Could not connect to node '%s'" % instance.primary_node)

  for device in instance.disks:

    for node, disk in device.ComputeNodeTree(instance.primary_node):

      lu.cfg.SetDiskID(disk, node)

        logger.Error("could not remove block device %s on node %s,"

                     " continuing anyway" %

                     (device.iv_name, node))

  if instance.disk_template == constants.DT_FILE:

    file_storage_dir = os.path.dirname(instance.disks[0].logical_id[1])

      logger.Error("could not remove directory '%s'" % file_storage_dir)

      result = False

             {"size": self.op.swap_size, "mode": "w"}]

    nics = [{"mac": self.op.mac, "ip": getattr(self.op, "ip", None),

             "bridge": self.op.bridge}]

                     mode=constants.IALLOCATOR_MODE_ALLOC,

                     name=self.op.instance_name,

                     disk_template=self.op.disk_template,

      src_node = self.op.src_node

      src_path = self.op.src_path

      if not export_info:

        raise errors.OpPrereqError("No export found in dir %s" % 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:

                                     (node, info['vg_free'], req_size))

    # os verification

    if not os_obj:

      raise errors.OpPrereqError("OS '%s' not in supported os list for"

                                 " primary node"  % self.op.os_type)

      raise errors.OpPrereqError("Can't set instance kernel to none")

    # bridge check on primary node

      raise errors.OpPrereqError("target bridge '%s' does not exist on"

                                 " destination node '%s'" %

                                 (self.op.bridge, pnode.name))

    if iobj.disk_template != constants.DT_DISKLESS:

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

        feedback_fn("* running the instance OS create scripts...")

          raise errors.OpExecError("could not add os for instance %s"

                                   " on node %s" %

                                   (instance, pnode_name))

        src_node = self.op.src_node

        src_image = self.src_image

        cluster_name = self.cfg.GetClusterName()

          raise errors.OpExecError("Could not import os for instance"

                                   " %s on node %s" %

                                   (instance, pnode_name))

    if self.op.start:

      logger.Info("starting instance %s on node %s" % (instance, pnode_name))

      feedback_fn("* starting instance...")

        raise errors.OpExecError("Could not start instance")

    instance = self.instance

    node = instance.primary_node

    if node_insts is False:

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

    """Compute a new secondary node using an IAllocator.

    """

                     mode=constants.IALLOCATOR_MODE_RELOC,

                     name=self.op.instance_name,

                     relocate_from=[self.sec_node])

    self.proc.LogStep(1, steps_total, "check device existence")

    info("checking volume groups")

    my_vg = cfg.GetVGName()

    if not results:

      raise errors.OpExecError("Can't list volume groups on the nodes")

    for node in oth_node, tgt_node:

      for node in tgt_node, oth_node:

        info("checking %s on %s" % (dev.iv_name, node))

        cfg.SetDiskID(dev, node)

          raise errors.OpExecError("Can't find device %s on node %s" %

                                   (dev.iv_name, node))

    self.proc.LogStep(4, steps_total, "change drbd configuration")

    for dev, old_lvs, new_lvs in iv_names.itervalues():

      info("detaching %s drbd from local storage" % dev.iv_name)

        raise errors.OpExecError("Can't detach drbd from local storage on node"

                                 " %s for device %s" % (tgt_node, dev.iv_name))

      #dev.children = []

      # build the rename list based on what LVs exist on the node

      rlist = []

      for to_ren in old_lvs:

        if find_res is not None: # device exists

          rlist.append((to_ren, ren_fn(to_ren, temp_suffix)))

      info("renaming the old LVs on the target node")

        raise errors.OpExecError("Can't rename old LVs on node %s" % tgt_node)

      # now we rename the new LVs to the old LVs

      info("renaming the new LVs on the target node")

      rlist = [(new, old.physical_id) for old, new in zip(old_lvs, new_lvs)]

        raise errors.OpExecError("Can't rename new LVs on node %s" % tgt_node)

      for old, new in zip(old_lvs, new_lvs):

      # now that the new lvs have the old name, we can add them to the device

      info("adding new mirror component on %s" % tgt_node)

        for new_lv in new_lvs:

            warning("Can't rollback device %s", hint="manually cleanup unused"

                    " logical volumes")

        raise errors.OpExecError("Can't add local storage to drbd")

    # so check manually all the devices

    for name, (dev, old_lvs, new_lvs) in iv_names.iteritems():

      cfg.SetDiskID(dev, instance.primary_node)

      if is_degr:

        raise errors.OpExecError("DRBD device %s is degraded!" % name)

      info("remove logical volumes for %s" % name)

      for lv in old_lvs:

        cfg.SetDiskID(lv, tgt_node)

          warning("Can't remove old LV", hint="manually remove unused LVs")

          continue

    self.proc.LogStep(1, steps_total, "check device existence")

    info("checking volume groups")

    my_vg = cfg.GetVGName()

    if not results:

      raise errors.OpExecError("Can't list volume groups on the nodes")

    for node in pri_node, new_node:

        continue

      info("checking %s on %s" % (dev.iv_name, pri_node))

      cfg.SetDiskID(dev, pri_node)

        raise errors.OpExecError("Can't find device %s on node %s" %

                                 (dev.iv_name, pri_node))

      # we have new devices, shutdown the drbd on the old secondary

      info("shutting down drbd for %s on old node" % dev.iv_name)

      cfg.SetDiskID(dev, old_node)

        warning("Failed to shutdown drbd for %s on old node" % dev.iv_name,

                hint="Please cleanup this device manually as soon as possible")

      dev.physical_id = (None, None, None, None) + dev.physical_id[4:]

      # and 'find' the device, which will 'fix' it to match the

      # standalone state

        done += 1

      else:

        warning("Failed to detach drbd %s from network, unusual case" %

      # is correct

      cfg.SetDiskID(dev, pri_node)

      logging.debug("Disk to attach: %s", dev)

        warning("can't attach drbd %s to new secondary!" % dev.iv_name,

                "please do a gnt-instance info to see the status of disks")

    # so check manually all the devices

    for name, (dev, old_lvs, _) in iv_names.iteritems():

      cfg.SetDiskID(dev, pri_node)

      if is_degr:

        raise errors.OpExecError("DRBD device %s is degraded!" % name)

      info("remove logical volumes for %s" % name)

      for lv in old_lvs:

        cfg.SetDiskID(lv, old_node)

          warning("Can't remove LV on old secondary",

                  hint="Cleanup stale volumes by hand")

                                 (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:

    disk = instance.FindDisk(self.op.disk)

    for node in (instance.secondary_nodes + (instance.primary_node,)):

      self.cfg.SetDiskID(disk, node)

        raise errors.OpExecError("grow request failed to node %s" % node)

      elif not result[0]:

        raise errors.OpExecError("grow request failed to node %s: %s" %

    """

    self.cfg.SetDiskID(dev, instance.primary_node)

    if dev.dev_type in constants.LDS_DRBD:

      # we change the snode then (otherwise we use the one passed in)

      if dev.logical_id[0] == instance.primary_node:

    if snode:

      self.cfg.SetDiskID(dev, snode)

    else:

      dev_sstatus = None

    """Gather and return data"""

    result = {}

    for instance in self.wanted_instances:

      if remote_info and "state" in remote_info:

        remote_state = "up"

      else:

      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

      that node.

    """

class LUExportInstance(LogicalUnit):

    src_node = instance.primary_node

    if self.op.shutdown:

      # shutdown the instance, but not the disks

        raise errors.OpExecError("Could not shutdown instance %s on node %s" %

                                 (instance.name, src_node))

      for disk in instance.disks:

        if disk.iv_name == "sda":

          # new_dev_name will be a snapshot of an lvm leaf of the one we passed

          if not new_dev_name:

            logger.Error("could not snapshot block device %s on node %s" %

    finally:

      if self.op.shutdown and instance.status == "up":

          _ShutdownInstanceDisks(self, instance)

          raise errors.OpExecError("Could not start instance")

    cluster_name = self.cfg.GetClusterName()

    for dev in snap_disks:

                                      instance, cluster_name):

        logger.Error("could not export block device %s from node %s to node %s"

                     % (dev.logical_id[1], src_node, dst_node.name))

        logger.Error("could not remove snapshot block device %s from node %s" %

                     (dev.logical_id[1], src_node))

      logger.Error("could not finalize export for instance %s on node %s" %

                   (instance.name, dst_node.name))

    # if we proceed the backup would be removed because OpQueryExports

    # substitutes an empty list with the full cluster node list.

    if nodelist:

      for node in exportlist:

        if instance.name in exportlist[node]:

            logger.Error("could not remove older export for instance %s"

                         " on node %s" % (instance.name, node))

      fqdn_warn = True

      instance_name = self.op.instance_name

    found = False

    for node in exportlist:

      if instance_name in exportlist[node]:

        found = True

          logger.Error("could not remove export for instance %s"

                       " on node %s" % (instance_name, node))

      if not utils.TestDelay(self.op.duration):

        raise errors.OpExecError("Error during master delay test")

    if self.op.on_nodes:

      if not result:

        raise errors.OpExecError("Complete failure from rpc call")

      for node, node_result in result.items():

    "relocate_from",

    ]

    # init buffer variables

    self.in_text = self.out_text = self.in_data = self.out_data = None

    # init all input fields so that pylint is happy

    This is the data that is independent of the actual operation.

    """

    cluster_info = cfg.GetClusterInfo()

    # cluster data

    data = {

      "version": 1,

      "cluster_tags": list(cluster_info.GetTags()),

      "enable_hypervisors": list(cluster_info.enabled_hypervisors),

      # we don't have job IDs

    node_list = cfg.GetNodeList()

    # FIXME: here we have only one hypervisor information, but

    # instance can belong to different hypervisors

    for nname in node_list:

      ninfo = cfg.GetNodeInfo(nname)

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

    done.

    """

    if instance is None:

      raise errors.ProgrammerError("Unknown instance '%s' passed to"

                                   " IAllocator" % self.name)

    self.in_text = serializer.Dump(self.in_data)

    """Run an instance allocator and return the results.

    """

    data = self.in_text

    if not isinstance(result, (list, tuple)) or len(result) != 4:

      raise errors.OpExecError("Invalid result from master iallocator runner")

    """

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

                       mode=self.op.mode,

                       name=self.op.name,

                       mem_size=self.op.mem_size,

                       vcpus=self.op.vcpus,

                       )

    else:

                       mode=self.op.mode,

                       name=self.op.name,

                       relocate_from=list(self.relocate_from),

    except ValueError:

      pass

    for node in nodelist:

      if not result[node]:

        logging.error("copy of file %s to node %s failed",

from ganeti import jstore

from ganeti import rpc

JOBQUEUE_THREADS = 25

    assert node_name != self._my_hostname

    # Clean queue directory on added node

    # Upload the whole queue excluding archived jobs

    files = [self._GetJobPath(job_id) for job_id in self._GetJobIDsUnlocked()]

      finally:

        fd.close()

      if not result[node_name]:

        logging.error("Failed to upload %s to %s", file_name, node_name)

    """

    utils.WriteFile(file_name, data=data)

    self._CheckRpcResult(result, self._nodes,

                         "Updating %s" % file_name)

  def _RenameFileUnlocked(self, old, new):

    os.rename(old, new)

    self._CheckRpcResult(result, self._nodes,

                         "Moving %s to %s" % (old, new))

    self.context = context

    self._feedback_fn = None

    self.exclusive_BGL = False

  def _ExecLU(self, lu):

    """Logical Unit execution sequence.

    """

    write_count = self.context.cfg.write_count

    lu.CheckPrereq()

    h_results = hm.RunPhase(constants.HOOKS_PHASE_PRE)

    lu.HooksCallBack(constants.HOOKS_PHASE_PRE, h_results,

                     self._feedback_fn, None)

                             shared=not lu_class.REQ_BGL)

    try:

      self.exclusive_BGL = lu_class.REQ_BGL

      lu.ExpandNames()

      assert lu.needed_locks is not None, "needed_locks not set by LU"

      result = self._LockAndExecLU(lu, locking.LEVEL_INSTANCE)

"""

import os

import socket

      self.results[node] = nc.get_response()