Synnefo » snf-ganeti

from ganeti import rapi

from ganeti import ht

from ganeti import compat

from ganeti.rapi import baserlib

  """/2/info resource.

  """

    """Returns cluster information.

    """

    return client.QueryClusterInfo()

  """/2/os resource.

  """

    """Return a list of all OSes.

    Can return error 500 in case of a problem.

    Example: ["debian-etch"]

    """

    op = opcodes.OpOsDiagnose(output_fields=["name", "variants"], names=[])

    # we use custom feedback function, instead of print we log the status

    result = cli.PollJob(job_id, cl, feedback_fn=baserlib.FeedbackFn)

    diagnose_data = result[0]

  """/2/redistribute-config resource.

  """

    """Redistribute configuration to all nodes.

    """

class R_2_cluster_modify(baserlib.R_Generic):

    op = baserlib.FillOpcode(opcodes.OpClusterSetParams, self.request_body,

                             None)

class R_2_jobs(baserlib.R_Generic):

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

    """

    job_id = self.items[0]

    return result

      raise http.HttpBadRequest("The 'previous_log_serial' parameter should"

                                " be a number")

    result = client.WaitForJobChangeOnce(job_id, fields,

                                         prev_job_info, prev_log_serial,

                                         timeout=_WFJC_TIMEOUT)

    """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())

                                 drained=drained,

                                 force=bool(self.useForce()))

class R_2_nodes_name_evacuate(baserlib.R_Generic):

      "dry_run": self.dryRun(),

      })

class R_2_nodes_name_migrate(baserlib.R_Generic):

      "node_name": node_name,

      })

class R_2_nodes_name_storage(baserlib.R_Generic):

    op = opcodes.OpNodeQueryStorage(nodes=[node_name],

                                    storage_type=storage_type,

                                    output_fields=output_fields.split(","))

class R_2_nodes_name_storage_modify(baserlib.R_Generic):

                                     storage_type=storage_type,

                                     name=name,

                                     changes=changes)

class R_2_nodes_name_storage_repair(baserlib.R_Generic):

    op = opcodes.OpRepairNodeStorage(node_name=node_name,

                                     storage_type=storage_type,

                                     name=name)

def _ParseCreateGroupRequest(data, dry_run):

    """Returns a list of all node groups.

    """

    if self.useBulk():

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

    """

    baserlib.CheckType(self.request_body, dict, "Body contents")

    op = _ParseCreateGroupRequest(self.request_body, self.dryRun())

class R_2_groups_name(baserlib.R_Generic):

    """

    group_name = self.items[0]

    result = baserlib.HandleItemQueryErrors(client.QueryGroups,

                                            names=[group_name], fields=G_FIELDS,

    op = opcodes.OpGroupRemove(group_name=self.items[0],

                               dry_run=bool(self.dryRun()))

def _ParseModifyGroupRequest(name, data):

    op = _ParseModifyGroupRequest(self.items[0], self.request_body)

def _ParseRenameGroupRequest(name, data, dry_run):

    baserlib.CheckType(self.request_body, dict, "Body contents")

    op = _ParseRenameGroupRequest(self.items[0], self.request_body,

                                  self.dryRun())

class R_2_groups_name_assign_nodes(baserlib.R_Generic):

      "force": self.useForce(),

      })

def _ParseInstanceCreateRequestVersion1(data, dry_run):

    """Returns a list of all available instances.

    """

    use_locking = self.useLocking()

    if self.useBulk():

      raise http.HttpBadRequest("Unsupported request data version %s" %

                                data_version)

class R_2_instances_name(baserlib.R_Generic):

    """Send information about an instance.

    """

    instance_name = self.items[0]

    result = baserlib.HandleItemQueryErrors(client.QueryInstances,

    op = opcodes.OpInstanceRemove(instance_name=self.items[0],

                                  ignore_failures=False,

                                  dry_run=bool(self.dryRun()))

class R_2_instances_name_info(baserlib.R_Generic):

    op = opcodes.OpInstanceQueryData(instances=[instance_name],

                                     static=static)

class R_2_instances_name_reboot(baserlib.R_Generic):

                                  ignore_secondaries=ignore_secondaries,

                                  dry_run=bool(self.dryRun()))

class R_2_instances_name_startup(baserlib.R_Generic):

                                   dry_run=bool(self.dryRun()),

                                   no_remember=no_remember)

def _ParseShutdownInstanceRequest(name, data, dry_run, no_remember):

    op = _ParseShutdownInstanceRequest(self.items[0], self.request_body,

                                       bool(self.dryRun()), no_remember)

def _ParseInstanceReinstallRequest(name, data):

    ops = _ParseInstanceReinstallRequest(self.items[0], body)

def _ParseInstanceReplaceDisksRequest(name, data):

    """

    op = _ParseInstanceReplaceDisksRequest(self.items[0], self.request_body)

class R_2_instances_name_activate_disks(baserlib.R_Generic):

    op = opcodes.OpInstanceActivateDisks(instance_name=instance_name,

                                         ignore_size=ignore_size)

class R_2_instances_name_deactivate_disks(baserlib.R_Generic):

    op = opcodes.OpInstanceDeactivateDisks(instance_name=instance_name)

class R_2_instances_name_prepare_export(baserlib.R_Generic):

    op = opcodes.OpBackupPrepare(instance_name=instance_name,

                                 mode=mode)

def _ParseExportInstanceRequest(name, data):

    op = _ParseExportInstanceRequest(self.items[0], self.request_body)

def _ParseMigrateInstanceRequest(name, data):

    op = _ParseMigrateInstanceRequest(self.items[0], self.request_body)

class R_2_instances_name_failover(baserlib.R_Generic):

      "instance_name": self.items[0],

      })

def _ParseRenameInstanceRequest(name, data):

    op = _ParseRenameInstanceRequest(self.items[0], self.request_body)

def _ParseModifyInstanceRequest(name, data):

    op = _ParseModifyInstanceRequest(self.items[0], self.request_body)

class R_2_instances_name_disk_grow(baserlib.R_Generic):

      "disk": int(self.items[1]),

      })

class R_2_instances_name_console(baserlib.R_Generic):

             L{objects.InstanceConsole}

    """

    ((console, ), ) = client.QueryInstances([self.items[0]], ["console"], False)

  GET_ACCESS = [rapi.RAPI_ACCESS_WRITE]

  def _Query(self, fields, filter_):

  def GET(self):

    """Returns resource information.

    else:

      fields = _SplitQueryFields(raw_fields[0])

class _R_Tags(baserlib.R_Generic):

      if not self.name:

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

      if kind == constants.TAG_INSTANCE:

        fn = cl.QueryInstances

      elif kind == constants.TAG_NODEGROUP:

                                " the 'tag' parameter")

    op = opcodes.OpTagsSet(kind=self.TAG_LEVEL, name=self.name,

                           tags=self.queryargs["tag"], dry_run=self.dryRun())

  def DELETE(self):

    """Delete a tag.

                                " tag(s) using the 'tag' parameter")

    op = opcodes.OpTagsDel(kind=self.TAG_LEVEL, name=self.name,

                           tags=self.queryargs["tag"], dry_run=self.dryRun())

class R_2_instances_name_tags(_R_Tags):