Synnefo » snf-ganeti

  """

  kind, name = _ExtractTagsObject(opts, args)

  result = cl.QueryTags(kind, name)

  result = list(result)

  result.sort()

  # This ensures we're running on the master daemon

  cl = GetClient()

  (cluster_name, master_node) = \

    cl.QueryConfigValues(["cluster_name", "master_node"])

  # Don't keep a reference to the client. The master daemon will go away.

  del cl

  assert master_node in online_nodes

  """

  if cl is None:

  qfilter = []

  qfilter = qlang.MakeSimpleFilter("node", opts.nodes)

  return GenericList(constants.QR_EXPORT, selected_fields, None, opts.units,

                     opts.separator, not opts.no_headers,

  @return: the desired exit code

  """

  return GenericListFields(constants.QR_EXPORT, args, opts.separator,

                           not opts.no_headers, cl=cl)

  @return: the desired exit code

  """

  result = cl.QueryClusterInfo()

  ToStdout("Software version: %s", result["software_version"])

  ToStdout("Internode protocol: %s", result["protocol_version"])

  @return: the desired exit code

  """

  result = cl.QueryClusterInfo()

  if result["tags"]:

                               errors.ECODE_INVAL)

  cl = GetClient()

  try:

    cluster_name = cl.QueryConfigValues(["cluster_name"])[0]

  """

  cl = GetClient()

  command = " ".join(args)

  if qcl is None:

    # Query client

  if opts.groups:

    node_query_list = \

  Currently it works only for ipolicy specs.

  """

  result = cl.QueryClusterInfo()

  ToStdout(_GetCreateCommand(result))

    "ndparams": (_FmtDict, False),

    }

  return GenericList(constants.QR_GROUP, desired_fields, args, None,

                     opts.separator, not opts.no_headers,

  @return: the desired exit code

  """

  return GenericListFields(constants.QR_GROUP, args, opts.separator,

                           not opts.no_headers, cl=cl)

  """Shows info about node group.

  """

  selected_fields = ["name",

                     "ndparams", "custom_ndparams",

                     "diskparams", "custom_diskparams",

  Currently it works only for ipolicy specs.

  """

  selected_fields = ["name"]

  if opts.include_defaults:

    selected_fields += ["ipolicy"]

  # pylint: disable=W0142

  if client is None:

  if mode == _EXPAND_CLUSTER:

    if names:

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

    if opts.multi_mode is None:

      opts.multi_mode = _EXPAND_INSTANCES

    cl = GetClient()

    if not inames:

      if opts.multi_mode == _EXPAND_CLUSTER:

        ToStdout("Cluster is empty, no instances to shutdown")

                                                      for item in value),

                               False))

  return GenericList(constants.QR_INSTANCE, selected_fields, args, opts.units,

                     opts.separator, not opts.no_headers,

  instance_name = args[0]

  force = opts.force

  cl = GetClient()

  if not force:

    usertext = ("This will remove the volumes of the instance %s"

                " (including mirrors), thus removing all the data"

  instance_name = args[0]

  cl = GetClient()

  try:

    cluster_name = cl.QueryConfigValues(["cluster_name"])[0]

    ((console_data, oper_state), ) = \

  finally:

    # Ensure client connection is closed while external commands are run

    cl.Close()

  del cl

  if not console_data:

    if oper_state:

  qfilter = qlang.MakeSimpleFilter("status", opts.status_filter)

  return GenericList(constants.QR_JOB, selected_fields, args, None,

                     opts.separator, not opts.no_headers,

  @return: the desired exit code

  """

  return GenericListFields(constants.QR_JOB, args, opts.separator,

                           not opts.no_headers, cl=cl)

    ]

  qfilter = qlang.MakeSimpleFilter("id", _ParseJobIds(args))

  result = cl.Query(constants.QR_JOB, selected_fields, qfilter).data

  first = True

  """

  cl = GetClient()

  (network, mode, link) = args[:3]

  # TODO: Change logic to support "--submit"

  for group in groups:

  """

  cl = GetClient()

  (network, ) = args[:1]

  # TODO: Change logic to support "--submit"

  for group in groups:

    "tags": (",".join, False),

    }

  return GenericList(constants.QR_NETWORK, desired_fields, args, None,

                     opts.separator, not opts.no_headers,

                     verbose=opts.verbose, format_override=fmtoverride,

  @return: the desired exit code

  """

  return GenericListFields(constants.QR_NETWORK, args, opts.separator,

                           not opts.no_headers, cl=cl)

  @return: the desired exit code

  """

  result = cl.QueryNetworks(fields=["name", "network", "gateway",

                                    "network6", "gateway6",

                                    "mac_prefix",

  """

  cl = GetClient()

  node = netutils.GetHostname(name=args[0]).name

  readd = opts.readd

  try:

    # Passing [] to QueryGroups means query the default group:

    node_groups = [opts.nodegroup] if opts.nodegroup is not None else []

    (ssh_port, ) = output[0]

  except (errors.OpPrereqError, errors.OpExecError):

    pass

  try:

    node_exists, sip, is_master, ssh_port = output[0]

  except (errors.OpPrereqError, errors.OpExecError):

    node_exists = ""

  fmtoverride = dict.fromkeys(["pinst_list", "sinst_list", "tags"],

                              (",".join, False))

  return GenericList(constants.QR_NODE, selected_fields, args, opts.units,

                     opts.separator, not opts.no_headers,

  @return: the desired exit code

  """

  return GenericListFields(constants.QR_NODE, args, opts.separator,

                           not opts.no_headers, cl=cl)

  cl = GetClient()

  result = qcl.QueryNodes(names=args, fields=fields, use_locking=False)

  qcl.Close()

  # these fields are static data anyway, so it doesn't matter, but

  # locking=True should be safer

  result = qcl.QueryNodes(names=args, fields=selected_fields,

                          use_locking=False)

  qcl.Close()

  force = opts.force

  selected_fields = ["name", "pinst_list"]

  result = qcl.QueryNodes(names=args, fields=selected_fields, use_locking=False)

  qcl.Close()

  ((node, pinst), ) = result

  @return: the desired exit code

  """

  result = cl.QueryNodes(fields=["name", "pip", "sip",

                                 "pinst_list", "sinst_list",

                                 "master_candidate", "drained", "offline",

    """Returns cluster information.

    """

    return client.QueryClusterInfo()

    @return: a dictionary with jobs id and uri.

    """

    if self.useBulk():

      bulkdata = client.QueryJobs(None, J_FIELDS_BULK)

    """

    job_id = self.items[0]

    if result is None:

      raise http.HttpNotFound()

    return baserlib.MapFields(J_FIELDS, result)

    """Returns a list of all nodes.

    """

    if self.useBulk():

      bulkdata = client.QueryNodes([], N_FIELDS, False)

    """

    node_name = self.items[0]

    result = baserlib.HandleItemQueryErrors(client.QueryNodes,

                                            names=[node_name], fields=N_FIELDS,

    """

    node_name = self.items[0]

    result = client.QueryNodes(names=[node_name], fields=["role"],

                               use_locking=self.useLocking())

    """Returns a list of all networks.

    """

    if self.useBulk():

      bulkdata = client.QueryNetworks([], NET_FIELDS, False)

    """

    network_name = self.items[0]

    result = baserlib.HandleItemQueryErrors(client.QueryNetworks,

                                            names=[network_name],

    """Returns a list of all node groups.

    """

    if self.useBulk():

      bulkdata = client.QueryGroups([], G_FIELDS, False)

    """

    group_name = self.items[0]

    result = baserlib.HandleItemQueryErrors(client.QueryGroups,

                                            names=[group_name], fields=G_FIELDS,

    """Returns a list of all available instances.

    """

    use_locking = self.useLocking()

    if self.useBulk():

    """Send information about an instance.

    """

    instance_name = self.items[0]

    result = baserlib.HandleItemQueryErrors(client.QueryInstances,

    """

    instance_name = self.items[0]

    ((console, oper_state), ) = \

        client.QueryInstances([instance_name], ["console", "oper_state"], False)

      if not self.name:

        raise http.HttpBadRequest("Missing name on tag request")

      tags = list(cl.QueryTags(kind, self.name))

    elif kind == constants.TAG_CLUSTER:

      elif what == constants.QR_JOB:

        return queue.QueryJobs(fields, qfilter)

      elif what in constants.QR_VIA_LUXI:

        result = luxi_client.Query(what, fields, qfilter).ToDict()

      else:

        raise errors.OpPrereqError("Resource type '%s' unknown" % what,

    else:

      names = []

    try:

      result = qcl.QueryNodes(names, ["name", "offline", "drained"], False)

    except errors.GenericError, err:

      err_code, msg = cli.FormatError(err)

                 islice(cycle(self.nodes), 2, None),

                 self.instances)

    for pnode, snode, enode, instance in mytor:

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

      # read the full name of the instance