Source code for libcloud.common.linode

# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# See the License for the specific language governing permissions and
# limitations under the License.

from libcloud.utils.py3 import httplib
from libcloud.common.base import JsonResponse, ConnectionKey
from libcloud.common.gandi import BaseObject
from libcloud.common.types import LibcloudError, InvalidCredsError

__all__ = [

# Endpoint for the Linode API
API_ROOT = "/"


# Constants that map a RAM figure to a PlanID (updated 2014-08-25)
    1024: "1",
    2048: "2",
    4096: "4",
    8192: "6",
    16384: "7",
    32768: "8",
    49152: "9",
    65536: "10",
    98304: "12",

# Available filesystems for disk creation
LINODE_DISK_FILESYSTEMS = ["ext3", "ext4", "swap", "raw"]
LINODE_DISK_FILESYSTEMS_V4 = ["ext3", "ext4", "swap", "raw", "initrd"]

[docs]class LinodeException(Exception): """Error originating from the Linode API This class wraps a Linode API error, a list of which is available in the API documentation. All Linode API errors are a numeric code and a human-readable description. """ def __init__(self, code, message): self.code = code self.message = message self.args = (code, message) def __str__(self): return "(%u) %s" % (self.code, self.message) def __repr__(self): return "<LinodeException code %u '%s'>" % (self.code, self.message)
[docs]class LinodeResponse(JsonResponse): """ Linode API response Wraps the HTTP response returned by the Linode API. libcloud does not take advantage of batching, so a response will always reflect the above format. A few weird quirks are caught here as well. """ objects = None def __init__(self, response, connection): """Instantiate a LinodeResponse from the HTTP response :keyword response: The raw response returned by urllib :return: parsed :class:`LinodeResponse`""" self.errors = [] super().__init__(response, connection) self.invalid = LinodeException(0xFF, "Invalid JSON received from server") # Move parse_body() to here; we can't be sure of failure until we've # parsed the body into JSON. self.objects, self.errors = self.parse_body() if not self.success(): # Raise the first error, as there will usually only be one raise self.errors[0]
[docs] def parse_body(self): """Parse the body of the response into JSON objects If the response chokes the parser, action and data will be returned as None and errorarray will indicate an invalid JSON exception. :return: ``list`` of objects and ``list`` of errors""" js = super().parse_body() try: if isinstance(js, dict): # solitary response - promote to list js = [js] ret = [] errs = [] for obj in js: if "DATA" not in obj or "ERRORARRAY" not in obj or "ACTION" not in obj: ret.append(None) errs.append(self.invalid) continue ret.append(obj["DATA"]) errs.extend(self._make_excp(e) for e in obj["ERRORARRAY"]) return (ret, errs) except Exception: return (None, [self.invalid])
[docs] def success(self): """Check the response for success The way we determine success is by the presence of an error in ERRORARRAY. If one is there, we assume the whole request failed. :return: ``bool`` indicating a successful request""" return len(self.errors) == 0
def _make_excp(self, error): """Convert an API error to a LinodeException instance :keyword error: JSON object containing ``ERRORCODE`` and ``ERRORMESSAGE`` :type error: dict""" if "ERRORCODE" not in error or "ERRORMESSAGE" not in error: return None if error["ERRORCODE"] == 4: return InvalidCredsError(error["ERRORMESSAGE"]) return LinodeException(error["ERRORCODE"], error["ERRORMESSAGE"])
[docs]class LinodeConnection(ConnectionKey): """ A connection to the Linode API Wraps SSL connections to the Linode API, automagically injecting the parameters that the API needs for each request. """ host = API_HOST responseCls = LinodeResponse
[docs] def add_default_params(self, params): """ Add parameters that are necessary for every request This method adds ``api_key`` and ``api_responseFormat`` to the request. """ params["api_key"] = self.key # Be explicit about this in case the default changes. params["api_responseFormat"] = "json" return params
[docs]class LinodeExceptionV4(Exception): def __init__(self, message): self.message = message def __str__(self): return "%s" % self.message def __repr__(self): return "<LinodeException '%s'>" % self.message
[docs]class LinodeResponseV4(JsonResponse): valid_response_codes = [ httplib.OK, httplib.NO_CONTENT, ]
[docs] def parse_body(self): """Parse the body of the response into JSON objects :return: ``dict`` of objects""" return super().parse_body()
[docs] def parse_error(self): """ Parse the error body and raise the appropriate exception """ status = int(self.status) data = self.parse_body() # Use only the first error, as there'll be only one most of the time error = data["errors"][0] reason = error.get("reason") # The field in the request that caused this error field = error.get("field") if field is not None: error_msg = "{}-{}".format(reason, field) else: error_msg = reason if status in [httplib.UNAUTHORIZED, httplib.FORBIDDEN]: raise InvalidCredsError(value=error_msg) raise LibcloudError( "%s Status code: %d." % (error_msg, status), driver=self.connection.driver )
[docs] def success(self): """Check the response for success :return: ``bool`` indicating a successful request""" return self.status in self.valid_response_codes
[docs]class LinodeConnectionV4(ConnectionKey): """ A connection to the Linode API Wraps SSL connections to the Linode API """ host = API_HOST responseCls = LinodeResponseV4
[docs] def add_default_headers(self, headers): """ Add headers that are necessary for every request This method adds ``token`` to the request. """ headers["Authorization"] = "Bearer %s" % (self.key) headers["Content-Type"] = "application/json" return headers
[docs] def add_default_params(self, params): """ Add parameters that are necessary for every request This method adds ``page_size`` to the request to reduce the total number of paginated requests to the API. """ # pylint: disable=maybe-no-member params["page_size"] = 25 return params
[docs]class LinodeDisk(BaseObject): def __init__(self, id, state, name, filesystem, driver, size, extra=None): super().__init__(id, state, driver) = name self.size = size self.filesystem = filesystem self.extra = extra or {} def __repr__(self): return ( "<LinodeDisk: id=%s, name=%s, state=%s, size=%s," " filesystem=%s, driver=%s ...>" ) % (,, self.state, self.size, self.filesystem,, )
[docs]class LinodeIPAddress: def __init__(self, inet, public, version, driver, extra=None): self.inet = inet self.public = public self.version = version self.driver = driver self.extra = extra or {} def __repr__(self): return ("<IPAddress: address=%s, public=%r, version=%s, driver=%s ...>") % ( self.inet, self.public, self.version,, )