Synnefo » snf-ganeti

  if brlist:

    result = lu.rpc.call_bridges_exist(target_node, brlist)

    result.Raise("Error checking bridges on destination node '%s'" %

def _CheckInstanceBridgesExist(lu, instance, node=None):

  result = rpc.call_blockdev_getmirrorstatus(node_name, instance.disks)

  result.Raise("Failed to get disk status from node %s" % node_name,

  for idx, bdev_status in enumerate(result.payload):

    if bdev_status and bdev_status.ldisk_status == constants.LDS_FAULTY:

      result = self.rpc.call_node_has_ip_address(new_node.name,

                                                 new_node.secondary_ip)

      result.Raise("Failure checking secondary ip on node %s" % new_node.name,

      if not result.payload:

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

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

  """

  nodeinfo = lu.rpc.call_node_info([node], lu.cfg.GetVGName(), hypervisor_name)

  free_mem = nodeinfo[node].payload.get('memory_free', None)

  if not isinstance(free_mem, int):

    raise errors.OpPrereqError("Can't compute free memory on node %s, result"

                                              instance.name,

                                              instance.hypervisor)

    remote_info.Raise("Error checking node %s" % instance.primary_node,

    if not remote_info.payload: # not running already

      _CheckNodeFreeMemory(self, instance.primary_node,

                           "starting instance %s" % instance.name,

                                              instance.name,

                                              instance.hypervisor)

    remote_info.Raise("Error checking node %s" % instance.primary_node,

    if remote_info.payload:

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

                                 (self.op.instance_name,

                                   self.op.pnode, errors.ECODE_NOENT)

      result = self.rpc.call_os_get(pnode.name, self.op.os_type)

      result.Raise("OS '%s' not in supported OS list for primary node %s" %

      if not self.op.force_variant:

        _CheckOSVariant(result.payload, self.op.os_type)

                                              instance.name,

                                              instance.hypervisor)

    remote_info.Raise("Error checking node %s" % instance.primary_node,

    if remote_info.payload:

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

                                 (self.op.instance_name,

                                              instance.name,

                                              instance.hypervisor)

    remote_info.Raise("Error checking node %s" % instance.primary_node,

    if remote_info.payload:

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

                                 (self.op.instance_name,

      _CheckNodeNotDrained(self, target_node)

      result = self.rpc.call_instance_migratable(instance.primary_node,

                                                 instance)

    self.instance = instance

    # os verification

    result = self.rpc.call_os_get(pnode.name, self.op.os_type)

    result.Raise("OS '%s' not in supported os list for primary node %s" %

    if not self.op.force_variant:

      _CheckOSVariant(result.payload, self.op.os_type)

    else:

      return "No error information"

    """If the result has failed, raise an OpExecError.

    This is used so that LU code doesn't have to check for each

      ec = errors.OpPrereqError

    else:

      ec = errors.OpExecError

class Client: