Source code for libcloud.common.abiquo

# 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.
Abiquo Utilities Module for the Abiquo Driver.

Common utilities needed by the :class:`AbiquoNodeDriver`.
import base64

from libcloud.utils.py3 import b, httplib, urlparse
from libcloud.common.base import XmlResponse, PollingConnection, ConnectionUserAndKey
from libcloud.common.types import LibcloudError, InvalidCredsError
from libcloud.compute.base import NodeState

[docs]def get_href(element, rel): """ Search a RESTLink element in the :class:`AbiquoResponse`. Abiquo, as a REST API, it offers self-discovering functionality. That means that you could walk through the whole API only navigating from the links offered by the entities. This is a basic method to find the 'relations' of an entity searching into its links. For instance, a Rack entity serialized as XML as the following:: <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <rack> <link href="http://host/api/admin/datacenters/1" type="application/vnd.abiquo.datacenter+xml" rel="datacenter"/> <link href="http://host/api/admin/datacenters/1/racks/1" type="application/vnd.abiquo.rack+xml" rel="edit"/> <link href="http://host/api/admin/datacenters/1/racks/1/machines" type="application/vnd.abiquo.machines+xml" rel="machines"/> <haEnabled>false</haEnabled> <id>1</id> <longDescription></longDescription> <name>racacaca</name> <nrsq>10</nrsq> <shortDescription></shortDescription> <vlanIdMax>4094</vlanIdMax> <vlanIdMin>2</vlanIdMin> <vlanPerVdcReserved>1</vlanPerVdcReserved> <vlansIdAvoided></vlansIdAvoided> </rack> offers link to datacenters (rel='datacenter'), to itself (rel='edit') and to the machines defined in it (rel='machines') A call to this method with the 'rack' element using 'datacenter' as 'rel' will return: '' :type element: :class:`xml.etree.ElementTree` :param element: Xml Entity returned by Abiquo API (required) :type rel: ``str`` :param rel: relation link name :rtype: ``str`` :return: the 'href' value according to the 'rel' input parameter """ links = element.findall("link") for link in links: if link.attrib["rel"] == rel: href = link.attrib["href"] # href is something like: # # 'http://localhost:80/api/admin/enterprises' # # we are only interested in '/admin/enterprises/' part needle = "/api/" url_path = urlparse.urlparse(href).path index = url_path.find(needle) result = url_path[index + len(needle) - 1 :] return result
[docs]class AbiquoResponse(XmlResponse): """ Abiquo XML Response. Wraps the response in XML bodies or extract the error data in case of error. """ # Map between abiquo state and Libcloud State NODE_STATE_MAP = { "NOT_ALLOCATED": NodeState.TERMINATED, "ALLOCATED": NodeState.PENDING, "CONFIGURED": NodeState.PENDING, "ON": NodeState.RUNNING, "PAUSED": NodeState.PENDING, "OFF": NodeState.PENDING, "LOCKED": NodeState.PENDING, "UNKNOWN": NodeState.UNKNOWN, }
[docs] def parse_error(self): """ Parse the error messages. Response body can easily be handled by this class parent :class:`XmlResponse`, but there are use cases which Abiquo API does not respond an XML but an HTML. So we need to handle these special cases. """ if self.status == httplib.UNAUTHORIZED: raise InvalidCredsError(driver=self.connection.driver) elif self.status == httplib.FORBIDDEN: raise ForbiddenError(self.connection.driver) elif self.status == httplib.NOT_ACCEPTABLE: raise LibcloudError("Not Acceptable") else: parsebody = self.parse_body() if parsebody is not None and hasattr(parsebody, "findall"): errors = self.parse_body().findall("error") # Most of the exceptions only have one error raise LibcloudError(errors[0].findtext("message")) else: raise LibcloudError(self.body)
[docs] def success(self): """ Determine if the request was successful. Any of the 2XX HTTP response codes are accepted as successful requests :rtype: ``bool`` :return: successful request or not. """ return self.status in [ httplib.OK, httplib.CREATED, httplib.NO_CONTENT, httplib.ACCEPTED, ]
[docs] def async_success(self): """ Determinate if async request was successful. An async_request retrieves for a task object that can be successfully retrieved (self.status == OK), but the asynchronous task (the body of the HTTP response) which we are asking for has finished with an error. So this method checks if the status code is 'OK' and if the task has finished successfully. :rtype: ``bool`` :return: successful asynchronous request or not """ if self.success(): # So we have a 'task' object in the body task = self.parse_body() return task.findtext("state") == "FINISHED_SUCCESSFULLY" else: return False
[docs]class AbiquoConnection(ConnectionUserAndKey, PollingConnection): """ A Connection to Abiquo API. Basic :class:`ConnectionUserAndKey` connection with :class:`PollingConnection` features for asynchronous tasks. """ responseCls = AbiquoResponse def __init__( self, user_id, key, secure=True, host=None, port=None, url=None, timeout=None, retry_delay=None, backoff=None, proxy_url=None, ): super().__init__( user_id=user_id, key=key, secure=secure, host=host, port=port, url=url, timeout=timeout, retry_delay=retry_delay, backoff=backoff, proxy_url=proxy_url, ) # This attribute stores data cached across multiple request self.cache = {}
[docs] def add_default_headers(self, headers): """ Add Basic Authentication header to all the requests. It injects the 'Authorization: Basic Base64String===' header in each request :type headers: ``dict`` :param headers: Default input headers :rtype: ``dict`` :return: Default input headers with the 'Authorization' header """ b64string = b("{}:{}".format(self.user_id, self.key)) encoded = base64.b64encode(b64string).decode("utf-8") authorization = "Basic " + encoded headers["Authorization"] = authorization return headers
[docs] def get_poll_request_kwargs(self, response, context, request_kwargs): """ Manage polling request arguments. Return keyword arguments which are passed to the :class:`NodeDriver.request` method when polling for the job status. The Abiquo Asynchronous Response returns and 'acceptedrequest' XmlElement as the following:: <acceptedrequest> <link href="http://uri/to/task" rel="status"/> <message>You can follow the progress in the link</message> </acceptedrequest> We need to extract the href URI to poll. :type response: :class:`xml.etree.ElementTree` :keyword response: Object returned by poll request. :type request_kwargs: ``dict`` :keyword request_kwargs: Default request arguments and headers :rtype: ``dict`` :return: Modified keyword arguments """ accepted_request_obj = response.object link_poll = get_href(accepted_request_obj, "status") hdr_poll = {"Accept": "application/vnd.abiquo.task+xml"} # Override the 'action', 'method' and 'headers' # keys of the previous dict request_kwargs["action"] = link_poll request_kwargs["method"] = "GET" request_kwargs["headers"] = hdr_poll return request_kwargs
[docs] def has_completed(self, response): """ Decide if the asynchronous job has ended. :type response: :class:`xml.etree.ElementTree` :param response: Response object returned by poll request :rtype: ``bool`` :return: Whether the job has completed """ task = response.object task_state = task.findtext("state") return task_state in [ "FINISHED_SUCCESSFULLY", "ABORTED", "FINISHED_UNSUCCESSFULLY", ]
[docs]class ForbiddenError(LibcloudError): """ Exception used when credentials are ok but user has not permissions. """ def __init__(self, driver): message = "User has not permission to perform this task." super().__init__(message, driver)