Synnefo » snf-ganeti » ganeti-local

  return _BuildInstanceHookEnv(**args)

  """Check that the brigdes needed by an instance exist.

  """

                  " state, not changing")

  """Sleep and poll for an instance's disk to sync.

  """

    return True

  if not oneshot:

  node = instance.primary_node

  for dev in instance.disks:

  retries = 0

  while True:

    cumul_degraded = False

    rstats = rpc.call_blockdev_getmirrorstatus(node, instance.disks)

    if not rstats:

      retries += 1

      if retries >= 10:

        raise errors.RemoteError("Can't contact node %s for mirror data,"

    for i in range(len(rstats)):

      mstat = rstats[i]

      if mstat is None:

        continue

      # we ignore the ldisk parameter

      perc_done, est_time, is_degraded, _ = mstat

          max_time = est_time

        else:

          rem_time = "no time estimate"

    if done or oneshot:

      break

    time.sleep(min(60, max_time))

  if done:

  return not cumul_degraded

  """Check that mirrors are not degraded.

  The ldisk parameter, if True, will change the test from the

  the device(s)) to the ldisk (representing the local storage status).

  """

  if ldisk:

    idx = 6

  else:

      result = result and (not rstats[idx])

  if dev.children:

    for child in dev.children:

  return result

    """Activate the disks.

    """

    if not disks_ok:

      raise errors.OpExecError("Cannot activate block devices")

    return disks_info

  """Prepare the block devices for an instance.

  This sets up the block devices on all nodes.

  # 1st pass, assemble on all nodes in secondary mode

  for inst_disk in instance.disks:

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

      result = rpc.call_blockdev_assemble(node, node_disk, iname, False)

      if not result:

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

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

      if node != instance.primary_node:

        continue

      result = rpc.call_blockdev_assemble(node, node_disk, iname, True)

      if not result:

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

  # this is a workaround that would be fixed better by

  # improving the logical/physical id handling

  for disk in instance.disks:

  return disks_ok, device_info

  """Start the disks of an instance.

  """

                                           ignore_secondaries=force)

  if not disks_ok:

    if force is not None and not force:

      logger.Error("If the message above refers to a secondary node,"

                   " you can retry the operation using '--force'.")

    """

    instance = self.instance

  """Shutdown block devices of an instance.

  This function checks if an instance is running, before calling

    raise errors.OpExecError("Instance is running, can't shutdown"

                             " block devices.")

  """Shutdown block devices of an instance.

  This does the shutdown on all nodes of the instance.

  result = True

  for disk in instance.disks:

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

      if not rpc.call_blockdev_shutdown(node, top_disk):

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

                     (disk.iv_name, node))

  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.

  @type node: C{str}

  @param node: the node to check

  @type reason: C{str}

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

      "Cannot retrieve locked instance %s" % self.op.instance_name

    # check bridges existance

                         "starting instance %s" % instance.name,

                         instance.memory, instance.hypervisor)

    node_current = instance.primary_node

    if not rpc.call_instance_start(node_current, instance, extra_args):

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

      "Cannot retrieve locked instance %s" % self.op.instance_name

    # check bridges existance

  def Exec(self, feedback_fn):

    """Reboot the instance.

    else:

      if not rpc.call_instance_shutdown(node_current, instance):

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

      if not rpc.call_instance_start(node_current, instance, extra_args):

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

    self.cfg.MarkInstanceUp(instance.name)

    if not rpc.call_instance_shutdown(node_current, instance):

      logger.Error("could not shutdown instance")

class LUReinstallInstance(LogicalUnit):

      inst.os = self.op.os_type

      self.cfg.Update(inst)

    try:

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

      if not rpc.call_instance_os_add(inst.primary_node, inst, "sda", "sdb"):

                                 " on node %s" %

                                 (inst.name, inst.primary_node))

    finally:

class LURenameInstance(LogicalUnit):

                                 " Ganeti)" % (old_file_storage_dir,

                                               new_file_storage_dir))

    try:

      if not rpc.call_instance_run_rename(inst.primary_node, inst, old_name,

                                          "sda", "sdb"):

               (inst.name, inst.primary_node))

        logger.Error(msg)

    finally:

class LURemoveInstance(LogicalUnit):

    logger.Info("removing block devices for instance %s" % instance.name)

      if self.op.ignore_failures:

        feedback_fn("Warning: can't remove instance's disks")

      else:

    target_node = secondary_nodes[0]

    # check memory requirements on the secondary node

                         instance.name, instance.memory,

                         instance.hypervisor)

    feedback_fn("* checking disk consistency between source and target")

    for dev in instance.disks:

      # for drbd, these are drbd over lvm

        if instance.status == "up" and not self.op.ignore_consistency:

          raise errors.OpExecError("Disk %s is degraded on target node,"

                                   " aborting failover." % dev.iv_name)

                                 (instance.name, source_node))

    feedback_fn("* deactivating the instance's disks on source node")

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

    instance.primary_node = target_node

      logger.Info("Starting instance %s on node %s" %

                  (instance.name, target_node))

                                               ignore_secondaries=True)

      if not disks_ok:

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

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

      if not rpc.call_instance_start(target_node, instance, None):

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

                                 (instance.name, target_node))

  """Create a tree of block devices on the primary node.

  This always creates all devices.

  """

  if device.children:

    for child in device.children:

        return False

  new_id = rpc.call_blockdev_create(node, device, device.size,

                                    instance.name, True, info)

  if not new_id:

  return True

  """Create a tree of block devices on a secondary node.

  If this device type has to be created on secondaries, create it and

    force = True

  if device.children:

    for child in device.children:

                                        child, force, info):

        return False

  if not force:

    return True

  new_id = rpc.call_blockdev_create(node, device, device.size,

                                    instance.name, False, info)

  if not new_id:

  return True

  """Generate a suitable LV name.

  This will generate a logical volume name for the given instance.

  """

  results = []

  for val in exts:

    results.append("%s%s" % (new_id, val))

  return results

                         p_minor, s_minor):

  """Generate a drbd8 device complete with its children.

  """

  dev_data = objects.Disk(dev_type=constants.LD_LV, size=size,

                          logical_id=(vgname, names[0]))

  dev_meta = objects.Disk(dev_type=constants.LD_LV, size=128,

  return drbd_dev

                          instance_name, primary_node,

                          secondary_nodes, disk_sz, swap_sz,

                          file_storage_dir, file_driver):

  """

  #TODO: compute space requirements

  if template_name == constants.DT_DISKLESS:

    disks = []

  elif template_name == constants.DT_PLAIN:

    if len(secondary_nodes) != 0:

      raise errors.ProgrammerError("Wrong template configuration")

    sda_dev = objects.Disk(dev_type=constants.LD_LV, size=disk_sz,

                           logical_id=(vgname, names[0]),

                           iv_name = "sda")

      raise errors.ProgrammerError("Wrong template configuration")

    remote_node = secondary_nodes[0]

    (minor_pa, minor_pb,

      [primary_node, primary_node, remote_node, remote_node], instance_name)

                                        disk_sz, names[0:2], "sda",

                                        minor_pa, minor_sa)

                                        swap_sz, names[2:4], "sdb",

                                        minor_pb, minor_sb)

    disks = [drbd_sda_dev, drbd_sdb_dev]

  return "originstname+%s" % instance.name

  """Create all disks for an instance.

  This abstracts away some work from AddInstance.

                (device.iv_name, instance.name))

    #HARDCODE

    for secondary_node in instance.secondary_nodes:

                                        device, False, info):

        logger.Error("failed to create volume %s (%s) on secondary node %s!" %

                     (device.iv_name, device, secondary_node))

        return False

    #HARDCODE

                                    instance, device, info):

      logger.Error("failed to create volume %s on primary!" %

                   device.iv_name)

  return True

  """Remove all disks for an instance.

  This abstracts away some work from `AddInstance()` and

  result = True

  for device in instance.disks:

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

      if not rpc.call_blockdev_remove(node, disk):

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

                     " continuing anyway" %

    # memory check on primary node

    if self.op.start:

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

                           self.op.mem_size, self.op.hypervisor)

                                        string_file_storage_dir, instance))

                                  self.op.disk_template,

                                  instance, pnode_name,

                                  self.secondaries, self.op.disk_size,

                            )

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

      self.cfg.ReleaseDRBDMinors(instance)

      raise errors.OpExecError("Device creation failed, reverting...")

    self.cfg.ReleaseDRBDMinors(instance)

    if self.op.wait_for_sync:

    elif iobj.disk_template in constants.DTS_NET_MIRROR:

      # make sure the disks are not degraded (still sync-ing is ok)

      time.sleep(15)

      feedback_fn("* checking mirrors status")

    else:

      disk_abort = False

    if disk_abort:

      self.cfg.RemoveInstance(iobj.name)

      # Make sure the instance lock gets removed

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

      if not dev.iv_name in self.op.disks:

        continue

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

                                   oth_node==instance.primary_node):

        raise errors.OpExecError("Peer node (%s) has degraded storage, unsafe"

                                 " to replace disks on this node (%s)" %

      size = dev.size

      cfg.SetDiskID(dev, tgt_node)

      lv_names = [".%s_%s" % (dev.iv_name, suf) for suf in ["data", "meta"]]

      lv_data = objects.Disk(dev_type=constants.LD_LV, size=size,

                             logical_id=(vgname, names[0]))

      lv_meta = objects.Disk(dev_type=constants.LD_LV, size=128,

      # _Create...OnPrimary (which forces the creation), even if we

      # are talking about the secondary node

      for new_lv in new_lvs:

                                        _GetInstanceInfoText(instance)):

          raise errors.OpExecError("Failed to create new LV named '%s' on"

                                   " node '%s'" %

    # does a combined result over all disks, so we don't check its

    # return value

    self.proc.LogStep(5, steps_total, "sync devices")

    # so check manually all the devices

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

      if not dev.iv_name in self.op.disks:

        continue

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

        raise errors.OpExecError("Primary node (%s) has degraded storage,"

                                 " unsafe to replace the secondary" %

                                 pri_node)

      # _Create...OnPrimary (which forces the creation), even if we

      # are talking about the secondary node

      for new_lv in dev.children:

                                        _GetInstanceInfoText(instance)):

          raise errors.OpExecError("Failed to create new LV named '%s' on"

                                   " node '%s'" %

      new_drbd = objects.Disk(dev_type=constants.LD_DRBD8,

                              logical_id=new_logical_id,

                              children=dev.children)

                                        new_drbd, False,

        self.cfg.ReleaseDRBDMinors(instance.name)

        raise errors.OpExecError("Failed to create new DRBD on"

                                 " node '%s'" % new_node)

    # does a combined result over all disks, so we don't check its

    # return value

    self.proc.LogStep(5, steps_total, "sync devices")

    # so check manually all the devices

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

    # Activate the instance disks if we're replacing them on a down instance

    if instance.status == "down":

    if instance.disk_template == constants.DT_DRBD8:

      if self.op.remote_node is None:

    # Deactivate the instance disks if we're replacing them on a down instance

    if instance.status == "down":

    return ret

    finally:

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

        if not rpc.call_instance_start(src_node, instance, None):

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

    # TODO: check for size