#
#
-# Copyright (C) 2006, 2007, 2008 Google Inc.
+# Copyright (C) 2006, 2007, 2008, 2009, 2010 Google Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
"""Remote API version 2 baserlib.library.
PUT or POST?
- ------------
+ ============
According to RFC2616 the main difference between PUT and POST is that
POST can create new resources but PUT can only create the resource the
from ganeti import http
from ganeti import constants
from ganeti import cli
+from ganeti import utils
from ganeti import rapi
from ganeti.rapi import baserlib
"network_port",
"disk.sizes", "disk_usage",
"beparams", "hvparams",
- "oper_state", "oper_ram", "status",
+ "oper_state", "oper_ram", "oper_vcpus", "status",
+ "custom_hvparams", "custom_beparams", "custom_nicparams",
] + _COMMON_FIELDS
N_FIELDS = ["name", "offline", "master_candidate", "drained",
"ctotal", "cnodes", "csockets",
"pip", "sip", "role",
"pinst_list", "sinst_list",
+ "master_capable", "vm_capable",
+ "group.uuid",
] + _COMMON_FIELDS
_NR_DRAINED = "drained"
"R": _NR_REGULAR,
}
+# Request data version field
+_REQ_DATA_VERSION = "__version__"
+
+# Feature string for instance creation request data version 1
+_INST_CREATE_REQV1 = "instance-create-reqv1"
+
+# Feature string for instance reinstall request version 1
+_INST_REINSTALL_REQV1 = "instance-reinstall-reqv1"
+
+# Timeout for /2/jobs/[job_id]/wait. Gives job up to 10 seconds to change.
+_WFJC_TIMEOUT = 10
+
class R_version(baserlib.R_Generic):
"""/version resource.
return client.QueryClusterInfo()
+class R_2_features(baserlib.R_Generic):
+ """/2/features resource.
+
+ """
+ @staticmethod
+ def GET():
+ """Returns list of optional RAPI features implemented.
+
+ """
+ return [_INST_CREATE_REQV1, _INST_REINSTALL_REQV1]
+
+
class R_2_os(baserlib.R_Generic):
"""/2/os resource.
"""
cl = baserlib.GetClient()
- op = opcodes.OpDiagnoseOS(output_fields=["name", "valid", "variants"],
- names=[])
+ op = opcodes.OpDiagnoseOS(output_fields=["name", "variants"], names=[])
job_id = baserlib.SubmitJob([op], cl)
# we use custom feedback function, instead of print we log the status
result = cli.PollJob(job_id, cl, feedback_fn=baserlib.FeedbackFn)
raise http.HttpBadGateway(message="Can't get OS list")
os_names = []
- for (name, valid, variants) in diagnose_data:
- if valid:
- os_names.extend(cli.CalculateOSNames(name, variants))
+ for (name, variants) in diagnose_data:
+ os_names.extend(cli.CalculateOSNames(name, variants))
return os_names
return result
+class R_2_jobs_id_wait(baserlib.R_Generic):
+ """/2/jobs/[job_id]/wait resource.
+
+ """
+ # WaitForJobChange provides access to sensitive information and blocks
+ # machine resources (it's a blocking RAPI call), hence restricting access.
+ GET_ACCESS = [rapi.RAPI_ACCESS_WRITE]
+
+ def GET(self):
+ """Waits for job changes.
+
+ """
+ job_id = self.items[0]
+
+ fields = self.getBodyParameter("fields")
+ prev_job_info = self.getBodyParameter("previous_job_info", None)
+ prev_log_serial = self.getBodyParameter("previous_log_serial", None)
+
+ if not isinstance(fields, list):
+ raise http.HttpBadRequest("The 'fields' parameter should be a list")
+
+ if not (prev_job_info is None or isinstance(prev_job_info, list)):
+ raise http.HttpBadRequest("The 'previous_job_info' parameter should"
+ " be a list")
+
+ if not (prev_log_serial is None or
+ isinstance(prev_log_serial, (int, long))):
+ raise http.HttpBadRequest("The 'previous_log_serial' parameter should"
+ " be a number")
+
+ client = baserlib.GetClient()
+ result = client.WaitForJobChangeOnce(job_id, fields,
+ prev_job_info, prev_log_serial,
+ timeout=_WFJC_TIMEOUT)
+ if not result:
+ raise http.HttpNotFound()
+
+ if result == constants.JOB_NOTCHANGED:
+ # No changes
+ return None
+
+ (job_info, log_entries) = result
+
+ return {
+ "job_info": job_info,
+ "log_entries": log_entries,
+ }
+
+
class R_2_nodes(baserlib.R_Generic):
"""/2/nodes resource.
"""
node_name = self.items[0]
client = baserlib.GetClient()
- result = client.QueryNodes(names=[node_name], fields=N_FIELDS,
- use_locking=self.useLocking())
+
+ result = baserlib.HandleItemQueryErrors(client.QueryNodes,
+ names=[node_name], fields=N_FIELDS,
+ use_locking=self.useLocking())
return baserlib.MapFields(N_FIELDS, result[0])
@return: a job id
"""
- if not isinstance(self.req.request_body, basestring):
+ if not isinstance(self.request_body, basestring):
raise http.HttpBadRequest("Invalid body contents, not a string")
node_name = self.items[0]
- role = self.req.request_body
+ role = self.request_body
if role == _NR_REGULAR:
candidate = False
node_name = self.items[0]
remote_node = self._checkStringVariable("remote_node", default=None)
iallocator = self._checkStringVariable("iallocator", default=None)
+ early_r = bool(self._checkIntVariable("early_release", default=0))
+ dry_run = bool(self.dryRun())
- op = opcodes.OpEvacuateNode(node_name=node_name,
- remote_node=remote_node,
- iallocator=iallocator)
+ cl = baserlib.GetClient()
- return baserlib.SubmitJob([op])
+ op = opcodes.OpNodeEvacuationStrategy(nodes=[node_name],
+ iallocator=iallocator,
+ remote_node=remote_node)
+
+ job_id = baserlib.SubmitJob([op], cl)
+ # we use custom feedback function, instead of print we log the status
+ result = cli.PollJob(job_id, cl, feedback_fn=baserlib.FeedbackFn)
+
+ jobs = []
+ for iname, node in result:
+ if dry_run:
+ jid = None
+ else:
+ op = opcodes.OpReplaceDisks(instance_name=iname,
+ remote_node=node, disks=[],
+ mode=constants.REPLACE_DISK_CHG,
+ early_release=early_r)
+ jid = baserlib.SubmitJob([op])
+ jobs.append((jid, iname, node))
+
+ return jobs
class R_2_nodes_name_migrate(baserlib.R_Generic):
"""
node_name = self.items[0]
- live = bool(self._checkIntVariable("live", default=1))
- op = opcodes.OpMigrateNode(node_name=node_name, live=live)
+ if "live" in self.queryargs and "mode" in self.queryargs:
+ raise http.HttpBadRequest("Only one of 'live' and 'mode' should"
+ " be passed")
+ elif "live" in self.queryargs:
+ if self._checkIntVariable("live", default=1):
+ mode = constants.HT_MIGRATION_LIVE
+ else:
+ mode = constants.HT_MIGRATION_NONLIVE
+ else:
+ mode = self._checkStringVariable("mode", default=None)
+
+ op = opcodes.OpMigrateNode(node_name=node_name, mode=mode)
return baserlib.SubmitJob([op])
return baserlib.SubmitJob([op])
+def _ParseInstanceCreateRequestVersion1(data, dry_run):
+ """Parses an instance creation request version 1.
+
+ @rtype: L{opcodes.OpCreateInstance}
+ @return: Instance creation opcode
+
+ """
+ # Disks
+ disks_input = baserlib.CheckParameter(data, "disks", exptype=list)
+
+ disks = []
+ for idx, i in enumerate(disks_input):
+ baserlib.CheckType(i, dict, "Disk %d specification" % idx)
+
+ # Size is mandatory
+ try:
+ size = i[constants.IDISK_SIZE]
+ except KeyError:
+ raise http.HttpBadRequest("Disk %d specification wrong: missing disk"
+ " size" % idx)
+
+ disk = {
+ constants.IDISK_SIZE: size,
+ }
+
+ # Optional disk access mode
+ try:
+ disk_access = i[constants.IDISK_MODE]
+ except KeyError:
+ pass
+ else:
+ disk[constants.IDISK_MODE] = disk_access
+
+ disks.append(disk)
+
+ assert len(disks_input) == len(disks)
+
+ # Network interfaces
+ nics_input = baserlib.CheckParameter(data, "nics", exptype=list)
+
+ nics = []
+ for idx, i in enumerate(nics_input):
+ baserlib.CheckType(i, dict, "NIC %d specification" % idx)
+
+ nic = {}
+
+ for field in constants.INIC_PARAMS:
+ try:
+ value = i[field]
+ except KeyError:
+ continue
+
+ nic[field] = value
+
+ nics.append(nic)
+
+ assert len(nics_input) == len(nics)
+
+ # HV/BE parameters
+ hvparams = baserlib.CheckParameter(data, "hvparams", default={})
+ utils.ForceDictType(hvparams, constants.HVS_PARAMETER_TYPES)
+
+ beparams = baserlib.CheckParameter(data, "beparams", default={})
+ utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES)
+
+ return opcodes.OpCreateInstance(
+ mode=baserlib.CheckParameter(data, "mode"),
+ instance_name=baserlib.CheckParameter(data, "name"),
+ os_type=baserlib.CheckParameter(data, "os"),
+ osparams=baserlib.CheckParameter(data, "osparams", default={}),
+ force_variant=baserlib.CheckParameter(data, "force_variant",
+ default=False),
+ no_install=baserlib.CheckParameter(data, "no_install", default=False),
+ pnode=baserlib.CheckParameter(data, "pnode", default=None),
+ snode=baserlib.CheckParameter(data, "snode", default=None),
+ disk_template=baserlib.CheckParameter(data, "disk_template"),
+ disks=disks,
+ nics=nics,
+ src_node=baserlib.CheckParameter(data, "src_node", default=None),
+ src_path=baserlib.CheckParameter(data, "src_path", default=None),
+ start=baserlib.CheckParameter(data, "start", default=True),
+ wait_for_sync=True,
+ ip_check=baserlib.CheckParameter(data, "ip_check", default=True),
+ name_check=baserlib.CheckParameter(data, "name_check", default=True),
+ file_storage_dir=baserlib.CheckParameter(data, "file_storage_dir",
+ default=None),
+ file_driver=baserlib.CheckParameter(data, "file_driver",
+ default=constants.FD_LOOP),
+ source_handshake=baserlib.CheckParameter(data, "source_handshake",
+ default=None),
+ source_x509_ca=baserlib.CheckParameter(data, "source_x509_ca",
+ default=None),
+ source_instance_name=baserlib.CheckParameter(data, "source_instance_name",
+ default=None),
+ iallocator=baserlib.CheckParameter(data, "iallocator", default=None),
+ hypervisor=baserlib.CheckParameter(data, "hypervisor", default=None),
+ hvparams=hvparams,
+ beparams=beparams,
+ dry_run=dry_run,
+ )
+
+
class R_2_instances(baserlib.R_Generic):
"""/2/instances resource.
return baserlib.BuildUriList(instanceslist, "/2/instances/%s",
uri_fields=("id", "uri"))
- def POST(self):
- """Create an instance.
+ def _ParseVersion0CreateRequest(self):
+ """Parses an instance creation request version 0.
- @return: a job id
+ Request data version 0 is deprecated and should not be used anymore.
- """
- if not isinstance(self.req.request_body, dict):
- raise http.HttpBadRequest("Invalid body contents, not a dictionary")
+ @rtype: L{opcodes.OpCreateInstance}
+ @return: Instance creation opcode
- beparams = baserlib.MakeParamsDict(self.req.request_body,
+ """
+ # Do not modify anymore, request data version 0 is deprecated
+ beparams = baserlib.MakeParamsDict(self.request_body,
constants.BES_PARAMETERS)
- hvparams = baserlib.MakeParamsDict(self.req.request_body,
+ hvparams = baserlib.MakeParamsDict(self.request_body,
constants.HVS_PARAMETERS)
fn = self.getBodyParameter
raise http.HttpBadRequest("Disk %d specification wrong: should"
" be an integer" % idx)
disks.append({"size": d})
+
# nic processing (one nic only)
nics = [{"mac": fn("mac", constants.VALUE_AUTO)}]
if fn("ip", None) is not None:
if fn("bridge", None) is not None:
nics[0]["bridge"] = fn("bridge")
- op = opcodes.OpCreateInstance(
+ # Do not modify anymore, request data version 0 is deprecated
+ return opcodes.OpCreateInstance(
mode=constants.INSTANCE_CREATE,
instance_name=fn('name'),
disks=disks,
hvparams=hvparams,
beparams=beparams,
file_storage_dir=fn('file_storage_dir', None),
- file_driver=fn('file_driver', 'loop'),
+ file_driver=fn('file_driver', constants.FD_LOOP),
dry_run=bool(self.dryRun()),
)
+ def POST(self):
+ """Create an instance.
+
+ @return: a job id
+
+ """
+ if not isinstance(self.request_body, dict):
+ raise http.HttpBadRequest("Invalid body contents, not a dictionary")
+
+ # Default to request data version 0
+ data_version = self.getBodyParameter(_REQ_DATA_VERSION, 0)
+
+ if data_version == 0:
+ op = self._ParseVersion0CreateRequest()
+ elif data_version == 1:
+ op = _ParseInstanceCreateRequestVersion1(self.request_body,
+ self.dryRun())
+ else:
+ raise http.HttpBadRequest("Unsupported request data version %s" %
+ data_version)
+
return baserlib.SubmitJob([op])
"""
client = baserlib.GetClient()
instance_name = self.items[0]
- result = client.QueryInstances(names=[instance_name], fields=I_FIELDS,
- use_locking=self.useLocking())
+
+ result = baserlib.HandleItemQueryErrors(client.QueryInstances,
+ names=[instance_name],
+ fields=I_FIELDS,
+ use_locking=self.useLocking())
return baserlib.MapFields(I_FIELDS, result[0])
return baserlib.SubmitJob([op])
+def _ParseInstanceReinstallRequest(name, data):
+ """Parses a request for reinstalling an instance.
+
+ """
+ if not isinstance(data, dict):
+ raise http.HttpBadRequest("Invalid body contents, not a dictionary")
+
+ ostype = baserlib.CheckParameter(data, "os")
+ start = baserlib.CheckParameter(data, "start", exptype=bool,
+ default=True)
+ osparams = baserlib.CheckParameter(data, "osparams", default=None)
+
+ ops = [
+ opcodes.OpShutdownInstance(instance_name=name),
+ opcodes.OpReinstallInstance(instance_name=name, os_type=ostype,
+ osparams=osparams),
+ ]
+
+ if start:
+ ops.append(opcodes.OpStartupInstance(instance_name=name, force=False))
+
+ return ops
+
+
class R_2_instances_name_reinstall(baserlib.R_Generic):
"""/2/instances/[instance_name]/reinstall resource.
automatically.
"""
- instance_name = self.items[0]
- ostype = self._checkStringVariable('os')
- nostartup = self._checkIntVariable('nostartup')
- ops = [
- opcodes.OpShutdownInstance(instance_name=instance_name),
- opcodes.OpReinstallInstance(instance_name=instance_name, os_type=ostype),
- ]
- if not nostartup:
- ops.append(opcodes.OpStartupInstance(instance_name=instance_name,
- force=False))
+ if self.request_body:
+ if self.queryargs:
+ raise http.HttpBadRequest("Can't combine query and body parameters")
+
+ body = self.request_body
+ else:
+ if not self.queryargs:
+ raise http.HttpBadRequest("Missing query parameters")
+ # Legacy interface, do not modify/extend
+ body = {
+ "os": self._checkStringVariable("os"),
+ "start": not self._checkIntVariable("nostartup"),
+ }
+
+ ops = _ParseInstanceReinstallRequest(self.items[0], body)
+
return baserlib.SubmitJob(ops)
return baserlib.SubmitJob([op])
+class R_2_instances_name_prepare_export(baserlib.R_Generic):
+ """/2/instances/[instance_name]/prepare-export resource.
+
+ """
+ def PUT(self):
+ """Prepares an export for an instance.
+
+ @return: a job id
+
+ """
+ instance_name = self.items[0]
+ mode = self._checkStringVariable("mode")
+
+ op = opcodes.OpPrepareExport(instance_name=instance_name,
+ mode=mode)
+
+ return baserlib.SubmitJob([op])
+
+
+def _ParseExportInstanceRequest(name, data):
+ """Parses a request for an instance export.
+
+ @rtype: L{opcodes.OpExportInstance}
+ @return: Instance export opcode
+
+ """
+ mode = baserlib.CheckParameter(data, "mode",
+ default=constants.EXPORT_MODE_LOCAL)
+ target_node = baserlib.CheckParameter(data, "destination")
+ shutdown = baserlib.CheckParameter(data, "shutdown", exptype=bool)
+ remove_instance = baserlib.CheckParameter(data, "remove_instance",
+ exptype=bool, default=False)
+ x509_key_name = baserlib.CheckParameter(data, "x509_key_name", default=None)
+ destination_x509_ca = baserlib.CheckParameter(data, "destination_x509_ca",
+ default=None)
+
+ return opcodes.OpExportInstance(instance_name=name,
+ mode=mode,
+ target_node=target_node,
+ shutdown=shutdown,
+ remove_instance=remove_instance,
+ x509_key_name=x509_key_name,
+ destination_x509_ca=destination_x509_ca)
+
+
+class R_2_instances_name_export(baserlib.R_Generic):
+ """/2/instances/[instance_name]/export resource.
+
+ """
+ def PUT(self):
+ """Exports an instance.
+
+ @return: a job id
+
+ """
+ if not isinstance(self.request_body, dict):
+ raise http.HttpBadRequest("Invalid body contents, not a dictionary")
+
+ op = _ParseExportInstanceRequest(self.items[0], self.request_body)
+
+ return baserlib.SubmitJob([op])
+
+
+def _ParseMigrateInstanceRequest(name, data):
+ """Parses a request for an instance migration.
+
+ @rtype: L{opcodes.OpMigrateInstance}
+ @return: Instance migration opcode
+
+ """
+ mode = baserlib.CheckParameter(data, "mode", default=None)
+ cleanup = baserlib.CheckParameter(data, "cleanup", exptype=bool,
+ default=False)
+
+ return opcodes.OpMigrateInstance(instance_name=name, mode=mode,
+ cleanup=cleanup)
+
+
+class R_2_instances_name_migrate(baserlib.R_Generic):
+ """/2/instances/[instance_name]/migrate resource.
+
+ """
+ def PUT(self):
+ """Migrates an instance.
+
+ @return: a job id
+
+ """
+ baserlib.CheckType(self.request_body, dict, "Body contents")
+
+ op = _ParseMigrateInstanceRequest(self.items[0], self.request_body)
+
+ return baserlib.SubmitJob([op])
+
+
+def _ParseRenameInstanceRequest(name, data):
+ """Parses a request for renaming an instance.
+
+ @rtype: L{opcodes.OpRenameInstance}
+ @return: Instance rename opcode
+
+ """
+ new_name = baserlib.CheckParameter(data, "new_name")
+ ip_check = baserlib.CheckParameter(data, "ip_check", default=True)
+ name_check = baserlib.CheckParameter(data, "name_check", default=True)
+
+ return opcodes.OpRenameInstance(instance_name=name, new_name=new_name,
+ name_check=name_check, ip_check=ip_check)
+
+
+class R_2_instances_name_rename(baserlib.R_Generic):
+ """/2/instances/[instance_name]/rename resource.
+
+ """
+ def PUT(self):
+ """Changes the name of an instance.
+
+ @return: a job id
+
+ """
+ baserlib.CheckType(self.request_body, dict, "Body contents")
+
+ op = _ParseRenameInstanceRequest(self.items[0], self.request_body)
+
+ return baserlib.SubmitJob([op])
+
+
+def _ParseModifyInstanceRequest(name, data):
+ """Parses a request for modifying an instance.
+
+ @rtype: L{opcodes.OpSetInstanceParams}
+ @return: Instance modify opcode
+
+ """
+ osparams = baserlib.CheckParameter(data, "osparams", default={})
+ force = baserlib.CheckParameter(data, "force", default=False)
+ nics = baserlib.CheckParameter(data, "nics", default=[])
+ disks = baserlib.CheckParameter(data, "disks", default=[])
+ disk_template = baserlib.CheckParameter(data, "disk_template", default=None)
+ remote_node = baserlib.CheckParameter(data, "remote_node", default=None)
+ os_name = baserlib.CheckParameter(data, "os_name", default=None)
+ force_variant = baserlib.CheckParameter(data, "force_variant", default=False)
+
+ # HV/BE parameters
+ hvparams = baserlib.CheckParameter(data, "hvparams", default={})
+ utils.ForceDictType(hvparams, constants.HVS_PARAMETER_TYPES,
+ allowed_values=[constants.VALUE_DEFAULT])
+
+ beparams = baserlib.CheckParameter(data, "beparams", default={})
+ utils.ForceDictType(beparams, constants.BES_PARAMETER_TYPES,
+ allowed_values=[constants.VALUE_DEFAULT])
+
+ return opcodes.OpSetInstanceParams(instance_name=name, hvparams=hvparams,
+ beparams=beparams, osparams=osparams,
+ force=force, nics=nics, disks=disks,
+ disk_template=disk_template,
+ remote_node=remote_node, os_name=os_name,
+ force_variant=force_variant)
+
+
+class R_2_instances_name_modify(baserlib.R_Generic):
+ """/2/instances/[instance_name]/modify resource.
+
+ """
+ def PUT(self):
+ """Changes some parameters of an instance.
+
+ @return: a job id
+
+ """
+ baserlib.CheckType(self.request_body, dict, "Body contents")
+
+ op = _ParseModifyInstanceRequest(self.items[0], self.request_body)
+
+ return baserlib.SubmitJob([op])
+
+
class _R_Tags(baserlib.R_Generic):
""" Quasiclass for tagging resources
"""
baserlib.R_Generic.__init__(self, items, queryargs, req)
- if self.TAG_LEVEL != constants.TAG_CLUSTER:
- self.name = items[0]
+ if self.TAG_LEVEL == constants.TAG_CLUSTER:
+ self.name = None
else:
- self.name = ""
+ self.name = items[0]
def GET(self):
"""Returns a list of tags.