Synnefo » snf-ganeti

      return queue.QueryJobs(job_ids, fields)

    elif method == luxi.REQ_QUERY_INSTANCES:

      return self._Query(op)

    elif method == luxi.REQ_QUERY_NODES:

      return self._Query(op)

    elif method == luxi.REQ_QUERY_EXPORTS:

      return self._Query(op)

    elif method == luxi.REQ_QUERY_CONFIG_VALUES:

  if with_secondaries is not None:

    fields.append("snodes")

  instances = []

  for fields in result:

  """Get a dict mapping nodes to boot IDs.

  """

  return dict([(name, (bootid, offline)) for name, bootid, offline in result])

           "FormatError", "SplitNodeOption", "SubmitOrSend",

           "JobSubmittedException", "FormatTimestamp", "ParseTimespec",

           "ValidateBeParams", "ToStderr", "ToStdout", "UsesRPC",

           ]

                         help="Submit the job and return the job ID, but"

                         " don't wait for the job to finish")

def ARGS_FIXED(val):

  """Macro-like function denoting a fixed number of arguments"""

  """Logical unit for querying instances.

  """

  REQ_BGL = False

  _FIELDS_STATIC = utils.FieldSet(*["name", "os", "pnode", "snodes",

                                    "admin_state", "admin_ram",

    else:

      self.wanted = locking.ALL_SET

    if self.do_locking:

      self.needed_locks[locking.LEVEL_INSTANCE] = self.wanted

      self.needed_locks[locking.LEVEL_NODE] = []

    bad_nodes = []

    off_nodes = []

      live_data = {}

      node_data = self.rpc.call_all_instances_info(nodes, hv_list)

      for name in nodes:

  def QueryJobs(self, job_ids, fields):

    return self.CallMethod(REQ_QUERY_JOBS, (job_ids, fields))

  def QueryConfigValues(self, fields):

    return self.CallMethod(REQ_QUERY_CONFIG_VALUES, fields)

class OpQueryNodes(OpCode):

  """Compute the list of nodes."""

  OP_ID = "OP_NODE_QUERY"

class OpQueryNodeVolumes(OpCode):

class OpQueryInstances(OpCode):

  """Compute the list of instances."""

  OP_ID = "OP_INSTANCE_QUERY"

class OpQueryInstanceData(OpCode):

class OpQueryExports(OpCode):

  """Compute the list of exported images."""

  OP_ID = "OP_BACKUP_QUERY"

class OpExportInstance(OpCode):

    """

    client = luxi.Client()

    nodeslist = [row[0] for row in nodesdata]

    if 'bulk' in self.queryargs:

      return baserlib.MapBulkFields(bulkdata, N_FIELDS)

    return baserlib.BuildUriList(nodeslist, "/2/nodes/%s",

    """

    client = luxi.Client()

    instanceslist = [row[0] for row in instancesdata]

    if 'bulk' in self.queryargs:

      return baserlib.MapBulkFields(bulkdata, I_FIELDS)

    else:

  @return: the desired exit code

  """

  retcode = 0

  for node in exports:

    ToStdout("Node: %s", node)

  if mode == _SHUTDOWN_CLUSTER:

    if names:

      raise errors.OpPrereqError("Cluster filter mode takes no arguments")

    inames = [row[0] for row in idata]

  elif mode in (_SHUTDOWN_NODES_BOTH,

                _SHUTDOWN_NODES_SEC):

    if not names:

      raise errors.OpPrereqError("No node names passed")

    ipri = [row[1] for row in ndata]

    pri_names = list(itertools.chain(*ipri))

    isec = [row[2] for row in ndata]

  elif mode == _SHUTDOWN_INSTANCES:

    if not names:

      raise errors.OpPrereqError("No instance names passed")

    inames = [row[0] for row in idata]

  else:

  """

  # TODO: change LUQueryInstances to that it actually returns None

  # instead of raising an exception, or devise a better mechanism

  for orig_name, row in zip(names, result):

    if row[0] is None:

      raise errors.OpPrereqError("Instance '%s' does not exist" % orig_name)

  else:

    selected_fields = opts.output.split(",")

  if not opts.no_headers:

    headers = {

            ], "[-s] [<instance>...]",

           "Show information on the specified instance(s)"),

  'list': (ListInstances, ARGS_ANY,

           "[<instance>...]",

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

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

  if not opts.readd:

    try:

    except (errors.OpPrereqError, errors.OpExecError):

      pass

    else:

  else:

    selected_fields = opts.output.split(",")

  if not opts.no_headers:

    headers = _LIST_HEADERS

  src_node = args[0]

  op = opcodes.OpQueryNodes(output_fields=selected_fields, names=[src_node])

  src_node, sinst = result[0]

  if not sinst:

    return constants.EXIT_SUCCESS

  if dst_node is not None:

    dst_node = result[0][0]

    if src_node == dst_node:

  force = opts.force

  selected_fields = ["name", "pinst_list"]

  node, pinst = result[0]

  if not pinst:

    else:

      names = []

    try:

      result = self.ExecOp(op)

    except errors.GenericError, err:

      err_code, msg = cli.FormatError(err)

      Log("instance %s" % instance, indent=1)

      # read the full name of the instance

      nam_op = opcodes.OpQueryInstances(output_fields=["name"],

      full_name = self.ExecOp(nam_op)[0][0]

      if self.opts.iallocator: