# # # Copyright (C) 2010, 2011, 2012 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 # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA # 02110-1301, USA. """Ganeti RAPI client. @attention: To use the RAPI client, the application B{must} call C{pycurl.global_init} during initialization and C{pycurl.global_cleanup} before exiting the process. This is very important in multi-threaded programs. See curl_global_init(3) and curl_global_cleanup(3) for details. The decorator L{UsesRapiClient} can be used. """ # No Ganeti-specific modules should be imported. The RAPI client is supposed to # be standalone. import logging import simplejson import socket import urllib import threading import pycurl import time try: from cStringIO import StringIO except ImportError: from StringIO import StringIO GANETI_RAPI_PORT = 5080 GANETI_RAPI_VERSION = 2 HTTP_DELETE = "DELETE" HTTP_GET = "GET" HTTP_PUT = "PUT" HTTP_POST = "POST" HTTP_OK = 200 HTTP_NOT_FOUND = 404 HTTP_APP_JSON = "application/json" REPLACE_DISK_PRI = "replace_on_primary" REPLACE_DISK_SECONDARY = "replace_on_secondary" REPLACE_DISK_CHG = "replace_new_secondary" REPLACE_DISK_AUTO = "replace_auto" NODE_EVAC_PRI = "primary-only" NODE_EVAC_SEC = "secondary-only" NODE_EVAC_ALL = "all" NODE_ROLE_DRAINED = "drained" NODE_ROLE_MASTER_CANDIATE = "master-candidate" NODE_ROLE_MASTER = "master" NODE_ROLE_OFFLINE = "offline" NODE_ROLE_REGULAR = "regular" JOB_STATUS_QUEUED = "queued" JOB_STATUS_WAITING = "waiting" JOB_STATUS_CANCELING = "canceling" JOB_STATUS_RUNNING = "running" JOB_STATUS_CANCELED = "canceled" JOB_STATUS_SUCCESS = "success" JOB_STATUS_ERROR = "error" JOB_STATUS_PENDING = frozenset([ JOB_STATUS_QUEUED, JOB_STATUS_WAITING, JOB_STATUS_CANCELING, ]) JOB_STATUS_FINALIZED = frozenset([ JOB_STATUS_CANCELED, JOB_STATUS_SUCCESS, JOB_STATUS_ERROR, ]) JOB_STATUS_ALL = frozenset([ JOB_STATUS_RUNNING, ]) | JOB_STATUS_PENDING | JOB_STATUS_FINALIZED # Legacy name JOB_STATUS_WAITLOCK = JOB_STATUS_WAITING # Internal constants _REQ_DATA_VERSION_FIELD = "__version__" _QPARAM_DRY_RUN = "dry-run" _QPARAM_FORCE = "force" # Feature strings INST_CREATE_REQV1 = "instance-create-reqv1" INST_REINSTALL_REQV1 = "instance-reinstall-reqv1" NODE_MIGRATE_REQV1 = "node-migrate-reqv1" NODE_EVAC_RES1 = "node-evac-res1" # Old feature constant names in case they're references by users of this module _INST_CREATE_REQV1 = INST_CREATE_REQV1 _INST_REINSTALL_REQV1 = INST_REINSTALL_REQV1 _NODE_MIGRATE_REQV1 = NODE_MIGRATE_REQV1 _NODE_EVAC_RES1 = NODE_EVAC_RES1 #: Resolver errors ECODE_RESOLVER = "resolver_error" #: Not enough resources (iallocator failure, disk space, memory, etc.) ECODE_NORES = "insufficient_resources" #: Temporarily out of resources; operation can be tried again ECODE_TEMP_NORES = "temp_insufficient_resources" #: Wrong arguments (at syntax level) ECODE_INVAL = "wrong_input" #: Wrong entity state ECODE_STATE = "wrong_state" #: Entity not found ECODE_NOENT = "unknown_entity" #: Entity already exists ECODE_EXISTS = "already_exists" #: Resource not unique (e.g. MAC or IP duplication) ECODE_NOTUNIQUE = "resource_not_unique" #: Internal cluster error ECODE_FAULT = "internal_error" #: Environment error (e.g. node disk error) ECODE_ENVIRON = "environment_error" #: List of all failure types ECODE_ALL = frozenset([ ECODE_RESOLVER, ECODE_NORES, ECODE_TEMP_NORES, ECODE_INVAL, ECODE_STATE, ECODE_NOENT, ECODE_EXISTS, ECODE_NOTUNIQUE, ECODE_FAULT, ECODE_ENVIRON, ]) # Older pycURL versions don't have all error constants try: _CURLE_SSL_CACERT = pycurl.E_SSL_CACERT _CURLE_SSL_CACERT_BADFILE = pycurl.E_SSL_CACERT_BADFILE except AttributeError: _CURLE_SSL_CACERT = 60 _CURLE_SSL_CACERT_BADFILE = 77 _CURL_SSL_CERT_ERRORS = frozenset([ _CURLE_SSL_CACERT, _CURLE_SSL_CACERT_BADFILE, ]) class Error(Exception): """Base error class for this module. """ pass class GanetiApiError(Error): """Generic error raised from Ganeti API. """ def __init__(self, msg, code=None): Error.__init__(self, msg) self.code = code class CertificateError(GanetiApiError): """Raised when a problem is found with the SSL certificate. """ pass def _AppendIf(container, condition, value): """Appends to a list if a condition evaluates to truth. """ if condition: container.append(value) return condition def _AppendDryRunIf(container, condition): """Appends a "dry-run" parameter if a condition evaluates to truth. """ return _AppendIf(container, condition, (_QPARAM_DRY_RUN, 1)) def _AppendForceIf(container, condition): """Appends a "force" parameter if a condition evaluates to truth. """ return _AppendIf(container, condition, (_QPARAM_FORCE, 1)) def _AppendReason(container, reason): """Appends an element to the reason trail. If the user provided a reason, it is added to the reason trail. """ return _AppendIf(container, reason, ("reason", reason)) def _SetItemIf(container, condition, item, value): """Sets an item if a condition evaluates to truth. """ if condition: container[item] = value return condition def UsesRapiClient(fn): """Decorator for code using RAPI client to initialize pycURL. """ def wrapper(*args, **kwargs): # curl_global_init(3) and curl_global_cleanup(3) must be called with only # one thread running. This check is just a safety measure -- it doesn't # cover all cases. assert threading.activeCount() == 1, \ "Found active threads when initializing pycURL" pycurl.global_init(pycurl.GLOBAL_ALL) try: return fn(*args, **kwargs) finally: pycurl.global_cleanup() return wrapper def GenericCurlConfig(verbose=False, use_signal=False, use_curl_cabundle=False, cafile=None, capath=None, proxy=None, verify_hostname=False, connect_timeout=None, timeout=None, _pycurl_version_fn=pycurl.version_info): """Curl configuration function generator. @type verbose: bool @param verbose: Whether to set cURL to verbose mode @type use_signal: bool @param use_signal: Whether to allow cURL to use signals @type use_curl_cabundle: bool @param use_curl_cabundle: Whether to use cURL's default CA bundle @type cafile: string @param cafile: In which file we can find the certificates @type capath: string @param capath: In which directory we can find the certificates @type proxy: string @param proxy: Proxy to use, None for default behaviour and empty string for disabling proxies (see curl_easy_setopt(3)) @type verify_hostname: bool @param verify_hostname: Whether to verify the remote peer certificate's commonName @type connect_timeout: number @param connect_timeout: Timeout for establishing connection in seconds @type timeout: number @param timeout: Timeout for complete transfer in seconds (see curl_easy_setopt(3)). """ if use_curl_cabundle and (cafile or capath): raise Error("Can not use default CA bundle when CA file or path is set") def _ConfigCurl(curl, logger): """Configures a cURL object @type curl: pycurl.Curl @param curl: cURL object """ logger.debug("Using cURL version %s", pycurl.version) # pycurl.version_info returns a tuple with information about the used # version of libcurl. Item 5 is the SSL library linked to it. # e.g.: (3, '7.18.0', 463360, 'x86_64-pc-linux-gnu', 1581, 'GnuTLS/2.0.4', # 0, '1.2.3.3', ...) sslver = _pycurl_version_fn()[5] if not sslver: raise Error("No SSL support in cURL") lcsslver = sslver.lower() if lcsslver.startswith("openssl/"): pass elif lcsslver.startswith("nss/"): # TODO: investigate compatibility beyond a simple test pass elif lcsslver.startswith("gnutls/"): if capath: raise Error("cURL linked against GnuTLS has no support for a" " CA path (%s)" % (pycurl.version, )) else: raise NotImplementedError("cURL uses unsupported SSL version '%s'" % sslver) curl.setopt(pycurl.VERBOSE, verbose) curl.setopt(pycurl.NOSIGNAL, not use_signal) # Whether to verify remote peer's CN if verify_hostname: # curl_easy_setopt(3): "When CURLOPT_SSL_VERIFYHOST is 2, that # certificate must indicate that the server is the server to which you # meant to connect, or the connection fails. [...] When the value is 1, # the certificate must contain a Common Name field, but it doesn't matter # what name it says. [...]" curl.setopt(pycurl.SSL_VERIFYHOST, 2) else: curl.setopt(pycurl.SSL_VERIFYHOST, 0) if cafile or capath or use_curl_cabundle: # Require certificates to be checked curl.setopt(pycurl.SSL_VERIFYPEER, True) if cafile: curl.setopt(pycurl.CAINFO, str(cafile)) if capath: curl.setopt(pycurl.CAPATH, str(capath)) # Not changing anything for using default CA bundle else: # Disable SSL certificate verification curl.setopt(pycurl.SSL_VERIFYPEER, False) if proxy is not None: curl.setopt(pycurl.PROXY, str(proxy)) # Timeouts if connect_timeout is not None: curl.setopt(pycurl.CONNECTTIMEOUT, connect_timeout) if timeout is not None: curl.setopt(pycurl.TIMEOUT, timeout) return _ConfigCurl class GanetiRapiClient(object): # pylint: disable=R0904 """Ganeti RAPI client. """ USER_AGENT = "Ganeti RAPI Client" _json_encoder = simplejson.JSONEncoder(sort_keys=True) def __init__(self, host, port=GANETI_RAPI_PORT, username=None, password=None, logger=logging, curl_config_fn=None, curl_factory=None): """Initializes this class. @type host: string @param host: the ganeti cluster master to interact with @type port: int @param port: the port on which the RAPI is running (default is 5080) @type username: string @param username: the username to connect with @type password: string @param password: the password to connect with @type curl_config_fn: callable @param curl_config_fn: Function to configure C{pycurl.Curl} object @param logger: Logging object """ self._username = username self._password = password self._logger = logger self._curl_config_fn = curl_config_fn self._curl_factory = curl_factory try: socket.inet_pton(socket.AF_INET6, host) address = "[%s]:%s" % (host, port) except socket.error: address = "%s:%s" % (host, port) self._base_url = "https://%s" % address if username is not None: if password is None: raise Error("Password not specified") elif password: raise Error("Specified password without username") def _CreateCurl(self): """Creates a cURL object. """ # Create pycURL object if no factory is provided if self._curl_factory: curl = self._curl_factory() else: curl = pycurl.Curl() # Default cURL settings curl.setopt(pycurl.VERBOSE, False) curl.setopt(pycurl.FOLLOWLOCATION, False) curl.setopt(pycurl.MAXREDIRS, 5) curl.setopt(pycurl.NOSIGNAL, True) curl.setopt(pycurl.USERAGENT, self.USER_AGENT) curl.setopt(pycurl.SSL_VERIFYHOST, 0) curl.setopt(pycurl.SSL_VERIFYPEER, False) curl.setopt(pycurl.HTTPHEADER, [ "Accept: %s" % HTTP_APP_JSON, "Content-type: %s" % HTTP_APP_JSON, ]) assert ((self._username is None and self._password is None) ^ (self._username is not None and self._password is not None)) if self._username: # Setup authentication curl.setopt(pycurl.HTTPAUTH, pycurl.HTTPAUTH_BASIC) curl.setopt(pycurl.USERPWD, str("%s:%s" % (self._username, self._password))) # Call external configuration function if self._curl_config_fn: self._curl_config_fn(curl, self._logger) return curl @staticmethod def _EncodeQuery(query): """Encode query values for RAPI URL. @type query: list of two-tuples @param query: Query arguments @rtype: list @return: Query list with encoded values """ result = [] for name, value in query: if value is None: result.append((name, "")) elif isinstance(value, bool): # Boolean values must be encoded as 0 or 1 result.append((name, int(value))) elif isinstance(value, (list, tuple, dict)): raise ValueError("Invalid query data type %r" % type(value).__name__) else: result.append((name, value)) return result def _SendRequest(self, method, path, query, content): """Sends an HTTP request. This constructs a full URL, encodes and decodes HTTP bodies, and handles invalid responses in a pythonic way. @type method: string @param method: HTTP method to use @type path: string @param path: HTTP URL path @type query: list of two-tuples @param query: query arguments to pass to urllib.urlencode @type content: str or None @param content: HTTP body content @rtype: str @return: JSON-Decoded response @raises CertificateError: If an invalid SSL certificate is found @raises GanetiApiError: If an invalid response is returned """ assert path.startswith("/") curl = self._CreateCurl() if content is not None: encoded_content = self._json_encoder.encode(content) else: encoded_content = "" # Build URL urlparts = [self._base_url, path] if query: urlparts.append("?") urlparts.append(urllib.urlencode(self._EncodeQuery(query))) url = "".join(urlparts) self._logger.debug("Sending request %s %s (content=%r)", method, url, encoded_content) # Buffer for response encoded_resp_body = StringIO() # Configure cURL curl.setopt(pycurl.CUSTOMREQUEST, str(method)) curl.setopt(pycurl.URL, str(url)) curl.setopt(pycurl.POSTFIELDS, str(encoded_content)) curl.setopt(pycurl.WRITEFUNCTION, encoded_resp_body.write) try: # Send request and wait for response try: curl.perform() except pycurl.error, err: if err.args[0] in _CURL_SSL_CERT_ERRORS: raise CertificateError("SSL certificate error %s" % err, code=err.args[0]) raise GanetiApiError(str(err), code=err.args[0]) finally: # Reset settings to not keep references to large objects in memory # between requests curl.setopt(pycurl.POSTFIELDS, "") curl.setopt(pycurl.WRITEFUNCTION, lambda _: None) # Get HTTP response code http_code = curl.getinfo(pycurl.RESPONSE_CODE) # Was anything written to the response buffer? if encoded_resp_body.tell(): response_content = simplejson.loads(encoded_resp_body.getvalue()) else: response_content = None if http_code != HTTP_OK: if isinstance(response_content, dict): msg = ("%s %s: %s" % (response_content["code"], response_content["message"], response_content["explain"])) else: msg = str(response_content) raise GanetiApiError(msg, code=http_code) return response_content def GetVersion(self): """Gets the Remote API version running on the cluster. @rtype: int @return: Ganeti Remote API version """ return self._SendRequest(HTTP_GET, "/version", None, None) def GetFeatures(self): """Gets the list of optional features supported by RAPI server. @rtype: list @return: List of optional features """ try: return self._SendRequest(HTTP_GET, "/%s/features" % GANETI_RAPI_VERSION, None, None) except GanetiApiError, err: # Older RAPI servers don't support this resource if err.code == HTTP_NOT_FOUND: return [] raise def GetOperatingSystems(self, reason=None): """Gets the Operating Systems running in the Ganeti cluster. @rtype: list of str @return: operating systems @type reason: string @param reason: the reason for executing this operation """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, "/%s/os" % GANETI_RAPI_VERSION, query, None) def GetInfo(self, reason=None): """Gets info about the cluster. @type reason: string @param reason: the reason for executing this operation @rtype: dict @return: information about the cluster """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, "/%s/info" % GANETI_RAPI_VERSION, query, None) def RedistributeConfig(self, reason=None): """Tells the cluster to redistribute its configuration files. @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, "/%s/redistribute-config" % GANETI_RAPI_VERSION, query, None) def ModifyCluster(self, reason=None, **kwargs): """Modifies cluster parameters. More details for parameters can be found in the RAPI documentation. @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendReason(query, reason) body = kwargs return self._SendRequest(HTTP_PUT, "/%s/modify" % GANETI_RAPI_VERSION, query, body) def GetClusterTags(self, reason=None): """Gets the cluster tags. @type reason: string @param reason: the reason for executing this operation @rtype: list of str @return: cluster tags """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, "/%s/tags" % GANETI_RAPI_VERSION, query, None) def AddClusterTags(self, tags, dry_run=False, reason=None): """Adds tags to the cluster. @type tags: list of str @param tags: tags to add to the cluster @type dry_run: bool @param dry_run: whether to perform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [("tag", t) for t in tags] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, "/%s/tags" % GANETI_RAPI_VERSION, query, None) def DeleteClusterTags(self, tags, dry_run=False, reason=None): """Deletes tags from the cluster. @type tags: list of str @param tags: tags to delete @type dry_run: bool @param dry_run: whether to perform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [("tag", t) for t in tags] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_DELETE, "/%s/tags" % GANETI_RAPI_VERSION, query, None) def GetInstances(self, bulk=False, reason=None): """Gets information about instances on the cluster. @type bulk: bool @param bulk: whether to return all information about all instances @type reason: string @param reason: the reason for executing this operation @rtype: list of dict or list of str @return: if bulk is True, info about the instances, else a list of instances """ query = [] _AppendIf(query, bulk, ("bulk", 1)) _AppendReason(query, reason) instances = self._SendRequest(HTTP_GET, "/%s/instances" % GANETI_RAPI_VERSION, query, None) if bulk: return instances else: return [i["id"] for i in instances] def GetInstance(self, instance, reason=None): """Gets information about an instance. @type instance: str @param instance: instance whose info to return @type reason: string @param reason: the reason for executing this operation @rtype: dict @return: info about the instance """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, ("/%s/instances/%s" % (GANETI_RAPI_VERSION, instance)), query, None) def GetInstanceInfo(self, instance, static=None, reason=None): """Gets information about an instance. @type instance: string @param instance: Instance name @type reason: string @param reason: the reason for executing this operation @rtype: string @return: Job ID """ query = [] if static is not None: query.append(("static", static)) _AppendReason(query, reason) return self._SendRequest(HTTP_GET, ("/%s/instances/%s/info" % (GANETI_RAPI_VERSION, instance)), query, None) @staticmethod def _UpdateWithKwargs(base, **kwargs): """Updates the base with params from kwargs. @param base: The base dict, filled with required fields @note: This is an inplace update of base """ conflicts = set(kwargs.iterkeys()) & set(base.iterkeys()) if conflicts: raise GanetiApiError("Required fields can not be specified as" " keywords: %s" % ", ".join(conflicts)) base.update((key, value) for key, value in kwargs.iteritems() if key != "dry_run") def InstanceAllocation(self, mode, name, disk_template, disks, nics, **kwargs): """Generates an instance allocation as used by multiallocate. More details for parameters can be found in the RAPI documentation. It is the same as used by CreateInstance. @type mode: string @param mode: Instance creation mode @type name: string @param name: Hostname of the instance to create @type disk_template: string @param disk_template: Disk template for instance (e.g. plain, diskless, file, or drbd) @type disks: list of dicts @param disks: List of disk definitions @type nics: list of dicts @param nics: List of NIC definitions @return: A dict with the generated entry """ # All required fields for request data version 1 alloc = { "mode": mode, "name": name, "disk_template": disk_template, "disks": disks, "nics": nics, } self._UpdateWithKwargs(alloc, **kwargs) return alloc def InstancesMultiAlloc(self, instances, reason=None, **kwargs): """Tries to allocate multiple instances. More details for parameters can be found in the RAPI documentation. @param instances: A list of L{InstanceAllocation} results """ query = [] body = { "instances": instances, } self._UpdateWithKwargs(body, **kwargs) _AppendDryRunIf(query, kwargs.get("dry_run")) _AppendReason(query, reason) return self._SendRequest(HTTP_POST, "/%s/instances-multi-alloc" % GANETI_RAPI_VERSION, query, body) def CreateInstance(self, mode, name, disk_template, disks, nics, reason=None, **kwargs): """Creates a new instance. More details for parameters can be found in the RAPI documentation. @type mode: string @param mode: Instance creation mode @type name: string @param name: Hostname of the instance to create @type disk_template: string @param disk_template: Disk template for instance (e.g. plain, diskless, file, or drbd) @type disks: list of dicts @param disks: List of disk definitions @type nics: list of dicts @param nics: List of NIC definitions @type dry_run: bool @keyword dry_run: whether to perform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendDryRunIf(query, kwargs.get("dry_run")) _AppendReason(query, reason) if _INST_CREATE_REQV1 in self.GetFeatures(): body = self.InstanceAllocation(mode, name, disk_template, disks, nics, **kwargs) body[_REQ_DATA_VERSION_FIELD] = 1 else: raise GanetiApiError("Server does not support new-style (version 1)" " instance creation requests") return self._SendRequest(HTTP_POST, "/%s/instances" % GANETI_RAPI_VERSION, query, body) def DeleteInstance(self, instance, dry_run=False, reason=None, **kwargs): """Deletes an instance. @type instance: str @param instance: the instance to delete @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] body = kwargs _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_DELETE, ("/%s/instances/%s" % (GANETI_RAPI_VERSION, instance)), query, body) def ModifyInstance(self, instance, reason=None, **kwargs): """Modifies an instance. More details for parameters can be found in the RAPI documentation. @type instance: string @param instance: Instance name @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ body = kwargs query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/instances/%s/modify" % (GANETI_RAPI_VERSION, instance)), query, body) def ActivateInstanceDisks(self, instance, ignore_size=None, reason=None): """Activates an instance's disks. @type instance: string @param instance: Instance name @type ignore_size: bool @param ignore_size: Whether to ignore recorded size @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendIf(query, ignore_size, ("ignore_size", 1)) _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/instances/%s/activate-disks" % (GANETI_RAPI_VERSION, instance)), query, None) def DeactivateInstanceDisks(self, instance, reason=None): """Deactivates an instance's disks. @type instance: string @param instance: Instance name @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/instances/%s/deactivate-disks" % (GANETI_RAPI_VERSION, instance)), query, None) def RecreateInstanceDisks(self, instance, disks=None, nodes=None, reason=None): """Recreate an instance's disks. @type instance: string @param instance: Instance name @type disks: list of int @param disks: List of disk indexes @type nodes: list of string @param nodes: New instance nodes, if relocation is desired @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ body = {} _SetItemIf(body, disks is not None, "disks", disks) _SetItemIf(body, nodes is not None, "nodes", nodes) query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_POST, ("/%s/instances/%s/recreate-disks" % (GANETI_RAPI_VERSION, instance)), query, body) def GrowInstanceDisk(self, instance, disk, amount, wait_for_sync=None, reason=None): """Grows a disk of an instance. More details for parameters can be found in the RAPI documentation. @type instance: string @param instance: Instance name @type disk: integer @param disk: Disk index @type amount: integer @param amount: Grow disk by this amount (MiB) @type wait_for_sync: bool @param wait_for_sync: Wait for disk to synchronize @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ body = { "amount": amount, } _SetItemIf(body, wait_for_sync is not None, "wait_for_sync", wait_for_sync) query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_POST, ("/%s/instances/%s/disk/%s/grow" % (GANETI_RAPI_VERSION, instance, disk)), query, body) def GetInstanceTags(self, instance, reason=None): """Gets tags for an instance. @type instance: str @param instance: instance whose tags to return @type reason: string @param reason: the reason for executing this operation @rtype: list of str @return: tags for the instance """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, ("/%s/instances/%s/tags" % (GANETI_RAPI_VERSION, instance)), query, None) def AddInstanceTags(self, instance, tags, dry_run=False, reason=None): """Adds tags to an instance. @type instance: str @param instance: instance to add tags to @type tags: list of str @param tags: tags to add to the instance @type dry_run: bool @param dry_run: whether to perform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [("tag", t) for t in tags] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/instances/%s/tags" % (GANETI_RAPI_VERSION, instance)), query, None) def DeleteInstanceTags(self, instance, tags, dry_run=False, reason=None): """Deletes tags from an instance. @type instance: str @param instance: instance to delete tags from @type tags: list of str @param tags: tags to delete @type dry_run: bool @param dry_run: whether to perform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [("tag", t) for t in tags] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_DELETE, ("/%s/instances/%s/tags" % (GANETI_RAPI_VERSION, instance)), query, None) def RebootInstance(self, instance, reboot_type=None, ignore_secondaries=None, dry_run=False, reason=None, **kwargs): """Reboots an instance. @type instance: str @param instance: instance to reboot @type reboot_type: str @param reboot_type: one of: hard, soft, full @type ignore_secondaries: bool @param ignore_secondaries: if True, ignores errors for the secondary node while re-assembling disks (in hard-reboot mode only) @type dry_run: bool @param dry_run: whether to perform a dry run @type reason: string @param reason: the reason for the reboot @rtype: string @return: job id """ query = [] body = kwargs _AppendDryRunIf(query, dry_run) _AppendIf(query, reboot_type, ("type", reboot_type)) _AppendIf(query, ignore_secondaries is not None, ("ignore_secondaries", ignore_secondaries)) _AppendReason(query, reason) return self._SendRequest(HTTP_POST, ("/%s/instances/%s/reboot" % (GANETI_RAPI_VERSION, instance)), query, body) def ShutdownInstance(self, instance, dry_run=False, no_remember=False, reason=None, **kwargs): """Shuts down an instance. @type instance: str @param instance: the instance to shut down @type dry_run: bool @param dry_run: whether to perform a dry run @type no_remember: bool @param no_remember: if true, will not record the state change @type reason: string @param reason: the reason for the shutdown @rtype: string @return: job id """ query = [] body = kwargs _AppendDryRunIf(query, dry_run) _AppendIf(query, no_remember, ("no_remember", 1)) _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/instances/%s/shutdown" % (GANETI_RAPI_VERSION, instance)), query, body) def StartupInstance(self, instance, dry_run=False, no_remember=False, reason=None): """Starts up an instance. @type instance: str @param instance: the instance to start up @type dry_run: bool @param dry_run: whether to perform a dry run @type no_remember: bool @param no_remember: if true, will not record the state change @type reason: string @param reason: the reason for the startup @rtype: string @return: job id """ query = [] _AppendDryRunIf(query, dry_run) _AppendIf(query, no_remember, ("no_remember", 1)) _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/instances/%s/startup" % (GANETI_RAPI_VERSION, instance)), query, None) def ReinstallInstance(self, instance, os=None, no_startup=False, osparams=None, reason=None): """Reinstalls an instance. @type instance: str @param instance: The instance to reinstall @type os: str or None @param os: The operating system to reinstall. If None, the instance's current operating system will be installed again @type no_startup: bool @param no_startup: Whether to start the instance automatically @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendReason(query, reason) if _INST_REINSTALL_REQV1 in self.GetFeatures(): body = { "start": not no_startup, } _SetItemIf(body, os is not None, "os", os) _SetItemIf(body, osparams is not None, "osparams", osparams) return self._SendRequest(HTTP_POST, ("/%s/instances/%s/reinstall" % (GANETI_RAPI_VERSION, instance)), query, body) # Use old request format if osparams: raise GanetiApiError("Server does not support specifying OS parameters" " for instance reinstallation") query = [] _AppendIf(query, os, ("os", os)) _AppendIf(query, no_startup, ("nostartup", 1)) return self._SendRequest(HTTP_POST, ("/%s/instances/%s/reinstall" % (GANETI_RAPI_VERSION, instance)), query, None) def ReplaceInstanceDisks(self, instance, disks=None, mode=REPLACE_DISK_AUTO, remote_node=None, iallocator=None, reason=None): """Replaces disks on an instance. @type instance: str @param instance: instance whose disks to replace @type disks: list of ints @param disks: Indexes of disks to replace @type mode: str @param mode: replacement mode to use (defaults to replace_auto) @type remote_node: str or None @param remote_node: new secondary node to use (for use with replace_new_secondary mode) @type iallocator: str or None @param iallocator: instance allocator plugin to use (for use with replace_auto mode) @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [ ("mode", mode), ] # TODO: Convert to body parameters if disks is not None: _AppendIf(query, True, ("disks", ",".join(str(idx) for idx in disks))) _AppendIf(query, remote_node is not None, ("remote_node", remote_node)) _AppendIf(query, iallocator is not None, ("iallocator", iallocator)) _AppendReason(query, reason) return self._SendRequest(HTTP_POST, ("/%s/instances/%s/replace-disks" % (GANETI_RAPI_VERSION, instance)), query, None) def PrepareExport(self, instance, mode, reason=None): """Prepares an instance for an export. @type instance: string @param instance: Instance name @type mode: string @param mode: Export mode @type reason: string @param reason: the reason for executing this operation @rtype: string @return: Job ID """ query = [("mode", mode)] _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/instances/%s/prepare-export" % (GANETI_RAPI_VERSION, instance)), query, None) def ExportInstance(self, instance, mode, destination, shutdown=None, remove_instance=None, x509_key_name=None, destination_x509_ca=None, reason=None): """Exports an instance. @type instance: string @param instance: Instance name @type mode: string @param mode: Export mode @type reason: string @param reason: the reason for executing this operation @rtype: string @return: Job ID """ body = { "destination": destination, "mode": mode, } _SetItemIf(body, shutdown is not None, "shutdown", shutdown) _SetItemIf(body, remove_instance is not None, "remove_instance", remove_instance) _SetItemIf(body, x509_key_name is not None, "x509_key_name", x509_key_name) _SetItemIf(body, destination_x509_ca is not None, "destination_x509_ca", destination_x509_ca) query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/instances/%s/export" % (GANETI_RAPI_VERSION, instance)), query, body) def MigrateInstance(self, instance, mode=None, cleanup=None, target_node=None, reason=None): """Migrates an instance. @type instance: string @param instance: Instance name @type mode: string @param mode: Migration mode @type cleanup: bool @param cleanup: Whether to clean up a previously failed migration @type target_node: string @param target_node: Target Node for externally mirrored instances @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ body = {} _SetItemIf(body, mode is not None, "mode", mode) _SetItemIf(body, cleanup is not None, "cleanup", cleanup) _SetItemIf(body, target_node is not None, "target_node", target_node) query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/instances/%s/migrate" % (GANETI_RAPI_VERSION, instance)), query, body) def FailoverInstance(self, instance, iallocator=None, ignore_consistency=None, target_node=None, reason=None): """Does a failover of an instance. @type instance: string @param instance: Instance name @type iallocator: string @param iallocator: Iallocator for deciding the target node for shared-storage instances @type ignore_consistency: bool @param ignore_consistency: Whether to ignore disk consistency @type target_node: string @param target_node: Target node for shared-storage instances @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ body = {} _SetItemIf(body, iallocator is not None, "iallocator", iallocator) _SetItemIf(body, ignore_consistency is not None, "ignore_consistency", ignore_consistency) _SetItemIf(body, target_node is not None, "target_node", target_node) query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/instances/%s/failover" % (GANETI_RAPI_VERSION, instance)), query, body) def RenameInstance(self, instance, new_name, ip_check=None, name_check=None, reason=None): """Changes the name of an instance. @type instance: string @param instance: Instance name @type new_name: string @param new_name: New instance name @type ip_check: bool @param ip_check: Whether to ensure instance's IP address is inactive @type name_check: bool @param name_check: Whether to ensure instance's name is resolvable @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ body = { "new_name": new_name, } _SetItemIf(body, ip_check is not None, "ip_check", ip_check) _SetItemIf(body, name_check is not None, "name_check", name_check) query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/instances/%s/rename" % (GANETI_RAPI_VERSION, instance)), query, body) def GetInstanceConsole(self, instance, reason=None): """Request information for connecting to instance's console. @type instance: string @param instance: Instance name @type reason: string @param reason: the reason for executing this operation @rtype: dict @return: dictionary containing information about instance's console """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, ("/%s/instances/%s/console" % (GANETI_RAPI_VERSION, instance)), query, None) def GetJobs(self, bulk=False): """Gets all jobs for the cluster. @type bulk: bool @param bulk: Whether to return detailed information about jobs. @rtype: list of int @return: List of job ids for the cluster or list of dicts with detailed information about the jobs if bulk parameter was true. """ query = [] _AppendIf(query, bulk, ("bulk", 1)) if bulk: return self._SendRequest(HTTP_GET, "/%s/jobs" % GANETI_RAPI_VERSION, query, None) else: return [int(j["id"]) for j in self._SendRequest(HTTP_GET, "/%s/jobs" % GANETI_RAPI_VERSION, None, None)] def GetJobStatus(self, job_id): """Gets the status of a job. @type job_id: string @param job_id: job id whose status to query @rtype: dict @return: job status """ return self._SendRequest(HTTP_GET, "/%s/jobs/%s" % (GANETI_RAPI_VERSION, job_id), None, None) def WaitForJobCompletion(self, job_id, period=5, retries=-1): """Polls cluster for job status until completion. Completion is defined as any of the following states listed in L{JOB_STATUS_FINALIZED}. @type job_id: string @param job_id: job id to watch @type period: int @param period: how often to poll for status (optional, default 5s) @type retries: int @param retries: how many time to poll before giving up (optional, default -1 means unlimited) @rtype: bool @return: C{True} if job succeeded or C{False} if failed/status timeout @deprecated: It is recommended to use L{WaitForJobChange} wherever possible; L{WaitForJobChange} returns immediately after a job changed and does not use polling """ while retries != 0: job_result = self.GetJobStatus(job_id) if job_result and job_result["status"] == JOB_STATUS_SUCCESS: return True elif not job_result or job_result["status"] in JOB_STATUS_FINALIZED: return False if period: time.sleep(period) if retries > 0: retries -= 1 return False def WaitForJobChange(self, job_id, fields, prev_job_info, prev_log_serial): """Waits for job changes. @type job_id: string @param job_id: Job ID for which to wait @return: C{None} if no changes have been detected and a dict with two keys, C{job_info} and C{log_entries} otherwise. @rtype: dict """ body = { "fields": fields, "previous_job_info": prev_job_info, "previous_log_serial": prev_log_serial, } return self._SendRequest(HTTP_GET, "/%s/jobs/%s/wait" % (GANETI_RAPI_VERSION, job_id), None, body) def CancelJob(self, job_id, dry_run=False): """Cancels a job. @type job_id: string @param job_id: id of the job to delete @type dry_run: bool @param dry_run: whether to perform a dry run @rtype: tuple @return: tuple containing the result, and a message (bool, string) """ query = [] _AppendDryRunIf(query, dry_run) return self._SendRequest(HTTP_DELETE, "/%s/jobs/%s" % (GANETI_RAPI_VERSION, job_id), query, None) def GetNodes(self, bulk=False, reason=None): """Gets all nodes in the cluster. @type bulk: bool @param bulk: whether to return all information about all instances @type reason: string @param reason: the reason for executing this operation @rtype: list of dict or str @return: if bulk is true, info about nodes in the cluster, else list of nodes in the cluster """ query = [] _AppendIf(query, bulk, ("bulk", 1)) _AppendReason(query, reason) nodes = self._SendRequest(HTTP_GET, "/%s/nodes" % GANETI_RAPI_VERSION, query, None) if bulk: return nodes else: return [n["id"] for n in nodes] def GetNode(self, node, reason=None): """Gets information about a node. @type node: str @param node: node whose info to return @type reason: string @param reason: the reason for executing this operation @rtype: dict @return: info about the node """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, "/%s/nodes/%s" % (GANETI_RAPI_VERSION, node), query, None) def EvacuateNode(self, node, iallocator=None, remote_node=None, dry_run=False, early_release=None, mode=None, accept_old=False, reason=None): """Evacuates instances from a Ganeti node. @type node: str @param node: node to evacuate @type iallocator: str or None @param iallocator: instance allocator to use @type remote_node: str @param remote_node: node to evaucate to @type dry_run: bool @param dry_run: whether to perform a dry run @type early_release: bool @param early_release: whether to enable parallelization @type mode: string @param mode: Node evacuation mode @type accept_old: bool @param accept_old: Whether caller is ready to accept old-style (pre-2.5) results @type reason: string @param reason: the reason for executing this operation @rtype: string, or a list for pre-2.5 results @return: Job ID or, if C{accept_old} is set and server is pre-2.5, list of (job ID, instance name, new secondary node); if dry_run was specified, then the actual move jobs were not submitted and the job IDs will be C{None} @raises GanetiApiError: if an iallocator and remote_node are both specified """ if iallocator and remote_node: raise GanetiApiError("Only one of iallocator or remote_node can be used") query = [] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) if _NODE_EVAC_RES1 in self.GetFeatures(): # Server supports body parameters body = {} _SetItemIf(body, iallocator is not None, "iallocator", iallocator) _SetItemIf(body, remote_node is not None, "remote_node", remote_node) _SetItemIf(body, early_release is not None, "early_release", early_release) _SetItemIf(body, mode is not None, "mode", mode) else: # Pre-2.5 request format body = None if not accept_old: raise GanetiApiError("Server is version 2.4 or earlier and caller does" " not accept old-style results (parameter" " accept_old)") # Pre-2.5 servers can only evacuate secondaries if mode is not None and mode != NODE_EVAC_SEC: raise GanetiApiError("Server can only evacuate secondary instances") _AppendIf(query, iallocator, ("iallocator", iallocator)) _AppendIf(query, remote_node, ("remote_node", remote_node)) _AppendIf(query, early_release, ("early_release", 1)) return self._SendRequest(HTTP_POST, ("/%s/nodes/%s/evacuate" % (GANETI_RAPI_VERSION, node)), query, body) def MigrateNode(self, node, mode=None, dry_run=False, iallocator=None, target_node=None, reason=None): """Migrates all primary instances from a node. @type node: str @param node: node to migrate @type mode: string @param mode: if passed, it will overwrite the live migration type, otherwise the hypervisor default will be used @type dry_run: bool @param dry_run: whether to perform a dry run @type iallocator: string @param iallocator: instance allocator to use @type target_node: string @param target_node: Target node for shared-storage instances @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) if _NODE_MIGRATE_REQV1 in self.GetFeatures(): body = {} _SetItemIf(body, mode is not None, "mode", mode) _SetItemIf(body, iallocator is not None, "iallocator", iallocator) _SetItemIf(body, target_node is not None, "target_node", target_node) assert len(query) <= 1 return self._SendRequest(HTTP_POST, ("/%s/nodes/%s/migrate" % (GANETI_RAPI_VERSION, node)), query, body) else: # Use old request format if target_node is not None: raise GanetiApiError("Server does not support specifying target node" " for node migration") _AppendIf(query, mode is not None, ("mode", mode)) return self._SendRequest(HTTP_POST, ("/%s/nodes/%s/migrate" % (GANETI_RAPI_VERSION, node)), query, None) def GetNodeRole(self, node, reason=None): """Gets the current role for a node. @type node: str @param node: node whose role to return @type reason: string @param reason: the reason for executing this operation @rtype: str @return: the current role for a node """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, ("/%s/nodes/%s/role" % (GANETI_RAPI_VERSION, node)), query, None) def SetNodeRole(self, node, role, force=False, auto_promote=None, reason=None): """Sets the role for a node. @type node: str @param node: the node whose role to set @type role: str @param role: the role to set for the node @type force: bool @param force: whether to force the role change @type auto_promote: bool @param auto_promote: Whether node(s) should be promoted to master candidate if necessary @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendForceIf(query, force) _AppendIf(query, auto_promote is not None, ("auto-promote", auto_promote)) _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/nodes/%s/role" % (GANETI_RAPI_VERSION, node)), query, role) def PowercycleNode(self, node, force=False, reason=None): """Powercycles a node. @type node: string @param node: Node name @type force: bool @param force: Whether to force the operation @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendForceIf(query, force) _AppendReason(query, reason) return self._SendRequest(HTTP_POST, ("/%s/nodes/%s/powercycle" % (GANETI_RAPI_VERSION, node)), query, None) def ModifyNode(self, node, reason=None, **kwargs): """Modifies a node. More details for parameters can be found in the RAPI documentation. @type node: string @param node: Node name @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_POST, ("/%s/nodes/%s/modify" % (GANETI_RAPI_VERSION, node)), query, kwargs) def GetNodeStorageUnits(self, node, storage_type, output_fields, reason=None): """Gets the storage units for a node. @type node: str @param node: the node whose storage units to return @type storage_type: str @param storage_type: storage type whose units to return @type output_fields: str @param output_fields: storage type fields to return @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id where results can be retrieved """ query = [ ("storage_type", storage_type), ("output_fields", output_fields), ] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, ("/%s/nodes/%s/storage" % (GANETI_RAPI_VERSION, node)), query, None) def ModifyNodeStorageUnits(self, node, storage_type, name, allocatable=None, reason=None): """Modifies parameters of storage units on the node. @type node: str @param node: node whose storage units to modify @type storage_type: str @param storage_type: storage type whose units to modify @type name: str @param name: name of the storage unit @type allocatable: bool or None @param allocatable: Whether to set the "allocatable" flag on the storage unit (None=no modification, True=set, False=unset) @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [ ("storage_type", storage_type), ("name", name), ] _AppendIf(query, allocatable is not None, ("allocatable", allocatable)) _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/nodes/%s/storage/modify" % (GANETI_RAPI_VERSION, node)), query, None) def RepairNodeStorageUnits(self, node, storage_type, name, reason=None): """Repairs a storage unit on the node. @type node: str @param node: node whose storage units to repair @type storage_type: str @param storage_type: storage type to repair @type name: str @param name: name of the storage unit to repair @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [ ("storage_type", storage_type), ("name", name), ] _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/nodes/%s/storage/repair" % (GANETI_RAPI_VERSION, node)), query, None) def GetNodeTags(self, node, reason=None): """Gets the tags for a node. @type node: str @param node: node whose tags to return @type reason: string @param reason: the reason for executing this operation @rtype: list of str @return: tags for the node """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, ("/%s/nodes/%s/tags" % (GANETI_RAPI_VERSION, node)), query, None) def AddNodeTags(self, node, tags, dry_run=False, reason=None): """Adds tags to a node. @type node: str @param node: node to add tags to @type tags: list of str @param tags: tags to add to the node @type dry_run: bool @param dry_run: whether to perform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [("tag", t) for t in tags] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/nodes/%s/tags" % (GANETI_RAPI_VERSION, node)), query, tags) def DeleteNodeTags(self, node, tags, dry_run=False, reason=None): """Delete tags from a node. @type node: str @param node: node to remove tags from @type tags: list of str @param tags: tags to remove from the node @type dry_run: bool @param dry_run: whether to perform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [("tag", t) for t in tags] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_DELETE, ("/%s/nodes/%s/tags" % (GANETI_RAPI_VERSION, node)), query, None) def GetNetworks(self, bulk=False, reason=None): """Gets all networks in the cluster. @type bulk: bool @param bulk: whether to return all information about the networks @rtype: list of dict or str @return: if bulk is true, a list of dictionaries with info about all networks in the cluster, else a list of names of those networks """ query = [] _AppendIf(query, bulk, ("bulk", 1)) _AppendReason(query, reason) networks = self._SendRequest(HTTP_GET, "/%s/networks" % GANETI_RAPI_VERSION, query, None) if bulk: return networks else: return [n["name"] for n in networks] def GetNetwork(self, network, reason=None): """Gets information about a network. @type network: str @param network: name of the network whose info to return @type reason: string @param reason: the reason for executing this operation @rtype: dict @return: info about the network """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, "/%s/networks/%s" % (GANETI_RAPI_VERSION, network), query, None) def CreateNetwork(self, network_name, network, gateway=None, network6=None, gateway6=None, mac_prefix=None, add_reserved_ips=None, tags=None, dry_run=False, reason=None): """Creates a new network. @type network_name: str @param network_name: the name of network to create @type dry_run: bool @param dry_run: whether to peform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) if add_reserved_ips: add_reserved_ips = add_reserved_ips.split(",") if tags: tags = tags.split(",") body = { "network_name": network_name, "gateway": gateway, "network": network, "gateway6": gateway6, "network6": network6, "mac_prefix": mac_prefix, "add_reserved_ips": add_reserved_ips, "tags": tags, } return self._SendRequest(HTTP_POST, "/%s/networks" % GANETI_RAPI_VERSION, query, body) def ConnectNetwork(self, network_name, group_name, mode, link, vlan="", dry_run=False, reason=None): """Connects a Network to a NodeGroup with the given netparams """ body = { "group_name": group_name, "network_mode": mode, "network_link": link, "network_vlan": vlan, } query = [] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/networks/%s/connect" % (GANETI_RAPI_VERSION, network_name)), query, body) def DisconnectNetwork(self, network_name, group_name, dry_run=False, reason=None): """Connects a Network to a NodeGroup with the given netparams """ body = { "group_name": group_name, } query = [] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/networks/%s/disconnect" % (GANETI_RAPI_VERSION, network_name)), query, body) def ModifyNetwork(self, network, reason=None, **kwargs): """Modifies a network. More details for parameters can be found in the RAPI documentation. @type network: string @param network: Network name @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/networks/%s/modify" % (GANETI_RAPI_VERSION, network)), None, kwargs) def DeleteNetwork(self, network, dry_run=False, reason=None): """Deletes a network. @type network: str @param network: the network to delete @type dry_run: bool @param dry_run: whether to peform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_DELETE, ("/%s/networks/%s" % (GANETI_RAPI_VERSION, network)), query, None) def GetNetworkTags(self, network, reason=None): """Gets tags for a network. @type network: string @param network: Node group whose tags to return @type reason: string @param reason: the reason for executing this operation @rtype: list of strings @return: tags for the network """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, ("/%s/networks/%s/tags" % (GANETI_RAPI_VERSION, network)), query, None) def AddNetworkTags(self, network, tags, dry_run=False, reason=None): """Adds tags to a network. @type network: str @param network: network to add tags to @type tags: list of string @param tags: tags to add to the network @type dry_run: bool @param dry_run: whether to perform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [("tag", t) for t in tags] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/networks/%s/tags" % (GANETI_RAPI_VERSION, network)), query, None) def DeleteNetworkTags(self, network, tags, dry_run=False, reason=None): """Deletes tags from a network. @type network: str @param network: network to delete tags from @type tags: list of string @param tags: tags to delete @type dry_run: bool @param dry_run: whether to perform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [("tag", t) for t in tags] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_DELETE, ("/%s/networks/%s/tags" % (GANETI_RAPI_VERSION, network)), query, None) def GetGroups(self, bulk=False, reason=None): """Gets all node groups in the cluster. @type bulk: bool @param bulk: whether to return all information about the groups @type reason: string @param reason: the reason for executing this operation @rtype: list of dict or str @return: if bulk is true, a list of dictionaries with info about all node groups in the cluster, else a list of names of those node groups """ query = [] _AppendIf(query, bulk, ("bulk", 1)) _AppendReason(query, reason) groups = self._SendRequest(HTTP_GET, "/%s/groups" % GANETI_RAPI_VERSION, query, None) if bulk: return groups else: return [g["name"] for g in groups] def GetGroup(self, group, reason=None): """Gets information about a node group. @type group: str @param group: name of the node group whose info to return @type reason: string @param reason: the reason for executing this operation @rtype: dict @return: info about the node group """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, "/%s/groups/%s" % (GANETI_RAPI_VERSION, group), query, None) def CreateGroup(self, name, alloc_policy=None, dry_run=False, reason=None): """Creates a new node group. @type name: str @param name: the name of node group to create @type alloc_policy: str @param alloc_policy: the desired allocation policy for the group, if any @type dry_run: bool @param dry_run: whether to peform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) body = { "name": name, "alloc_policy": alloc_policy, } return self._SendRequest(HTTP_POST, "/%s/groups" % GANETI_RAPI_VERSION, query, body) def ModifyGroup(self, group, reason=None, **kwargs): """Modifies a node group. More details for parameters can be found in the RAPI documentation. @type group: string @param group: Node group name @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/groups/%s/modify" % (GANETI_RAPI_VERSION, group)), query, kwargs) def DeleteGroup(self, group, dry_run=False, reason=None): """Deletes a node group. @type group: str @param group: the node group to delete @type dry_run: bool @param dry_run: whether to peform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_DELETE, ("/%s/groups/%s" % (GANETI_RAPI_VERSION, group)), query, None) def RenameGroup(self, group, new_name, reason=None): """Changes the name of a node group. @type group: string @param group: Node group name @type new_name: string @param new_name: New node group name @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ body = { "new_name": new_name, } query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/groups/%s/rename" % (GANETI_RAPI_VERSION, group)), query, body) def AssignGroupNodes(self, group, nodes, force=False, dry_run=False, reason=None): """Assigns nodes to a group. @type group: string @param group: Node group name @type nodes: list of strings @param nodes: List of nodes to assign to the group @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendForceIf(query, force) _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) body = { "nodes": nodes, } return self._SendRequest(HTTP_PUT, ("/%s/groups/%s/assign-nodes" % (GANETI_RAPI_VERSION, group)), query, body) def GetGroupTags(self, group, reason=None): """Gets tags for a node group. @type group: string @param group: Node group whose tags to return @type reason: string @param reason: the reason for executing this operation @rtype: list of strings @return: tags for the group """ query = [] _AppendReason(query, reason) return self._SendRequest(HTTP_GET, ("/%s/groups/%s/tags" % (GANETI_RAPI_VERSION, group)), query, None) def AddGroupTags(self, group, tags, dry_run=False, reason=None): """Adds tags to a node group. @type group: str @param group: group to add tags to @type tags: list of string @param tags: tags to add to the group @type dry_run: bool @param dry_run: whether to perform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [("tag", t) for t in tags] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_PUT, ("/%s/groups/%s/tags" % (GANETI_RAPI_VERSION, group)), query, None) def DeleteGroupTags(self, group, tags, dry_run=False, reason=None): """Deletes tags from a node group. @type group: str @param group: group to delete tags from @type tags: list of string @param tags: tags to delete @type dry_run: bool @param dry_run: whether to perform a dry run @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [("tag", t) for t in tags] _AppendDryRunIf(query, dry_run) _AppendReason(query, reason) return self._SendRequest(HTTP_DELETE, ("/%s/groups/%s/tags" % (GANETI_RAPI_VERSION, group)), query, None) def Query(self, what, fields, qfilter=None, reason=None): """Retrieves information about resources. @type what: string @param what: Resource name, one of L{constants.QR_VIA_RAPI} @type fields: list of string @param fields: Requested fields @type qfilter: None or list @param qfilter: Query filter @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendReason(query, reason) body = { "fields": fields, } _SetItemIf(body, qfilter is not None, "qfilter", qfilter) # TODO: remove "filter" after 2.7 _SetItemIf(body, qfilter is not None, "filter", qfilter) return self._SendRequest(HTTP_PUT, ("/%s/query/%s" % (GANETI_RAPI_VERSION, what)), query, body) def QueryFields(self, what, fields=None, reason=None): """Retrieves available fields for a resource. @type what: string @param what: Resource name, one of L{constants.QR_VIA_RAPI} @type fields: list of string @param fields: Requested fields @type reason: string @param reason: the reason for executing this operation @rtype: string @return: job id """ query = [] _AppendReason(query, reason) if fields is not None: _AppendIf(query, True, ("fields", ",".join(fields))) return self._SendRequest(HTTP_GET, ("/%s/query/%s/fields" % (GANETI_RAPI_VERSION, what)), query, None)