Synnefo

#

#

# Copyright (C) 2010, 2011 Google Inc.

# Copyright (C) 2013, GRNET S.A.

#

# 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."""

# No Ganeti-specific modules should be imported. The RAPI client is supposed to

# be standalone.

import requests

import logging

import simplejson

import time

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_FINALIZED = frozenset([

  JOB_STATUS_CANCELED,

  JOB_STATUS_SUCCESS,

  JOB_STATUS_ERROR,

  ])

JOB_STATUS_ALL = frozenset([

  JOB_STATUS_QUEUED,

  JOB_STATUS_WAITING,

  JOB_STATUS_CANCELING,

  JOB_STATUS_RUNNING,

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

#: 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"

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 _SetItemIf(container, condition, item, value):

  """Sets an item if a condition evaluates to truth.

  """

  if condition:

    container[item] = value

  return condition

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

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

    @param logger: Logging object

    """

    self._logger = logger

    self._base_url = "https://%s:%s" % (host, port)

    if username is not None:

      if password is None:

        raise Error("Password not specified")

    elif password:

      raise Error("Specified password without username")

    self._auth = (username, password)

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

    url = "%s%s" % (self._base_url, path)

    headers = {}

    if content is not None:

      encoded_content = self._json_encoder.encode(content)

      headers = {"content-type": HTTP_APP_JSON,

                 "accept": HTTP_APP_JSON}

    else:

      encoded_content = ""

    if query is not None:

        query = dict(query)

    self._logger.debug("Sending request %s %s (query=%r) (content=%r)",

                       method, url, query, encoded_content)

    req_method = getattr(requests, method.lower())

    r = req_method(url, auth=self._auth, headers=headers, params=query,

                   data=encoded_content, verify=False)

    http_code = r.status_code

    if r.content is not None:

        response_content = simplejson.loads(r.content)

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

    """Gets the Operating Systems running in the Ganeti cluster.

    @rtype: list of str

    @return: operating systems

    """

    return self._SendRequest(HTTP_GET, "/%s/os" % GANETI_RAPI_VERSION,

                             None, None)

  def GetInfo(self):

    """Gets info about the cluster.

    @rtype: dict

    @return: information about the cluster

    """

    return self._SendRequest(HTTP_GET, "/%s/info" % GANETI_RAPI_VERSION,

                             None, None)

  def RedistributeConfig(self):

    """Tells the cluster to redistribute its configuration files.

    @rtype: string

    @return: job id

    """

    return self._SendRequest(HTTP_PUT,

                             "/%s/redistribute-config" % GANETI_RAPI_VERSION,

                             None, None)

  def ModifyCluster(self, **kwargs):

    """Modifies cluster parameters.

    More details for parameters can be found in the RAPI documentation.

    @rtype: string

    @return: job id

    """

    body = kwargs

    return self._SendRequest(HTTP_PUT,

                             "/%s/modify" % GANETI_RAPI_VERSION, None, body)

  def GetClusterTags(self):

    """Gets the cluster tags.

    @rtype: list of str

    @return: cluster tags

    """

    return self._SendRequest(HTTP_GET, "/%s/tags" % GANETI_RAPI_VERSION,

                             None, None)

  def AddClusterTags(self, tags, dry_run=False):

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

    @rtype: string

    @return: job id

    """

    query = [("tag", t) for t in tags]

    _AppendDryRunIf(query, dry_run)

    return self._SendRequest(HTTP_PUT, "/%s/tags" % GANETI_RAPI_VERSION,

                             query, None)

  def DeleteClusterTags(self, tags, dry_run=False):

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

    @rtype: string

    @return: job id

    """

    query = [("tag", t) for t in tags]

    _AppendDryRunIf(query, dry_run)

    return self._SendRequest(HTTP_DELETE, "/%s/tags" % GANETI_RAPI_VERSION,

                             query, None)

  def GetInstances(self, bulk=False):

    """Gets information about instances on the cluster.

    @type bulk: bool

    @param bulk: whether to return all information about all instances

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

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

    """Gets information about an instance.

    @type instance: str

    @param instance: instance whose info to return

    @rtype: dict

    @return: info about the instance

    """

    return self._SendRequest(HTTP_GET,

                             ("/%s/instances/%s" %

                              (GANETI_RAPI_VERSION, instance)), None, None)

  def GetInstanceInfo(self, instance, static=None):

    """Gets information about an instance.

    @type instance: string

    @param instance: Instance name

    @rtype: string

    @return: Job ID

    """

    if static is not None:

      query = [("static", static)]

    else:

      query = None

    return self._SendRequest(HTTP_GET,

                             ("/%s/instances/%s/info" %

                              (GANETI_RAPI_VERSION, instance)), query, None)

  def CreateInstance(self, mode, name, disk_template, disks, nics,

                     **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

    @rtype: string

    @return: job id

    """

    query = []

    _AppendDryRunIf(query, kwargs.get("dry_run"))

    if _INST_CREATE_REQV1 in self.GetFeatures():

      # All required fields for request data version 1

      body = {

        _REQ_DATA_VERSION_FIELD: 1,

        "mode": mode,

        "name": name,

        "disk_template": disk_template,

        "disks": disks,

        "nics": nics,

        }

      conflicts = set(kwargs.iterkeys()) & set(body.iterkeys())

      if conflicts:

        raise GanetiApiError("Required fields cannot be specified as"

                             " keywords: %s" % ", ".join(conflicts))

      body.update((key, value) for key, value in kwargs.iteritems()

                  if key != "dry_run")

    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, shutdown_timeout=None):

    """Deletes an instance.

    @type instance: str

    @param instance: the instance to delete

    @rtype: string

    @return: job id

    """

    query = []

    _AppendDryRunIf(query, dry_run)

    body = None

    if shutdown_timeout is not None:

        body = {"shutdown_timeout": shutdown_timeout}

    return self._SendRequest(HTTP_DELETE,

                             ("/%s/instances/%s" %

                              (GANETI_RAPI_VERSION, instance)), query, body)

  def ModifyInstance(self, instance, **kwargs):

    """Modifies an instance.

    More details for parameters can be found in the RAPI documentation.

    @type instance: string

    @param instance: Instance name

    @rtype: string

    @return: job id

    """

    body = kwargs

    return self._SendRequest(HTTP_PUT,

                             ("/%s/instances/%s/modify" %

                              (GANETI_RAPI_VERSION, instance)), None, body)

  def ActivateInstanceDisks(self, instance, ignore_size=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

    @rtype: string

    @return: job id

    """

    query = []

    _AppendIf(query, ignore_size, ("ignore_size", 1))

    return self._SendRequest(HTTP_PUT,

                             ("/%s/instances/%s/activate-disks" %

                              (GANETI_RAPI_VERSION, instance)), query, None)

  def DeactivateInstanceDisks(self, instance):

    """Deactivates an instance's disks.

    @type instance: string

    @param instance: Instance name

    @rtype: string

    @return: job id

    """

    return self._SendRequest(HTTP_PUT,

                             ("/%s/instances/%s/deactivate-disks" %

                              (GANETI_RAPI_VERSION, instance)), None, None)

  def RecreateInstanceDisks(self, instance, disks=None, nodes=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

    @rtype: string

    @return: job id

    """

    body = {}

    _SetItemIf(body, disks is not None, "disks", disks)

    _SetItemIf(body, nodes is not None, "nodes", nodes)

    return self._SendRequest(HTTP_POST,

                             ("/%s/instances/%s/recreate-disks" %

                              (GANETI_RAPI_VERSION, instance)), None, body)

  def GrowInstanceDisk(self, instance, disk, amount, wait_for_sync=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

    @rtype: string

    @return: job id

    """

    body = {

      "amount": amount,

      }

    _SetItemIf(body, wait_for_sync is not None, "wait_for_sync", wait_for_sync)

    return self._SendRequest(HTTP_POST,

                             ("/%s/instances/%s/disk/%s/grow" %

                              (GANETI_RAPI_VERSION, instance, disk)),

                             None, body)

  def GetInstanceTags(self, instance):

    """Gets tags for an instance.

    @type instance: str

    @param instance: instance whose tags to return

    @rtype: list of str

    @return: tags for the instance

    """

    return self._SendRequest(HTTP_GET,

                             ("/%s/instances/%s/tags" %

                              (GANETI_RAPI_VERSION, instance)), None, None)

  def AddInstanceTags(self, instance, tags, dry_run=False):

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

    @rtype: string

    @return: job id

    """

    query = [("tag", t) for t in tags]

    _AppendDryRunIf(query, dry_run)

    return self._SendRequest(HTTP_PUT,

                             ("/%s/instances/%s/tags" %

                              (GANETI_RAPI_VERSION, instance)), query, None)

  def DeleteInstanceTags(self, instance, tags, dry_run=False):

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

    @rtype: string

    @return: job id

    """

    query = [("tag", t) for t in tags]

    _AppendDryRunIf(query, dry_run)

    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, shutdown_timeout=None):

    """Reboots an instance.

    @type instance: str

    @param instance: instance to rebot

    @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

    @rtype: string

    @return: job id

    """

    query = []

    _AppendDryRunIf(query, dry_run)

    _AppendIf(query, reboot_type, ("type", reboot_type))

    _AppendIf(query, ignore_secondaries is not None,

              ("ignore_secondaries", ignore_secondaries))

    body = None

    if shutdown_timeout is not None:

        body = {"shutdown_timeout": shutdown_timeout}

    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,

                       timeout=None):

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

    @rtype: string

    @return: job id

    """

    query = []

    _AppendDryRunIf(query, dry_run)

    _AppendIf(query, no_remember, ("no-remember", 1))

    body = None

    if timeout is not None:

        body = {"timeout": timeout}

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

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