libcloud-notifications mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From anthonys...@apache.org
Subject [39/56] [abbrv] libcloud git commit: Removed sdist
Date Mon, 14 Nov 2016 23:51:26 GMT
http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/gogrid.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/gogrid.py b/apache-libcloud-1.0.0rc2/libcloud/common/gogrid.py
deleted file mode 100644
index e2448de..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/common/gogrid.py
+++ /dev/null
@@ -1,183 +0,0 @@
-# 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
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import hashlib
-import time
-
-from libcloud.utils.py3 import b
-
-from libcloud.common.types import InvalidCredsError, LibcloudError
-from libcloud.common.types import MalformedResponseError
-from libcloud.common.base import ConnectionUserAndKey, JsonResponse
-from libcloud.compute.base import NodeLocation
-
-HOST = 'api.gogrid.com'
-PORTS_BY_SECURITY = {True: 443, False: 80}
-API_VERSION = '1.8'
-
-__all__ = [
-    "GoGridResponse",
-    "GoGridConnection",
-    "GoGridIpAddress",
-    "BaseGoGridDriver",
-]
-
-
-class GoGridResponse(JsonResponse):
-
-    def __init__(self, *args, **kwargs):
-        self.driver = BaseGoGridDriver
-        super(GoGridResponse, self).__init__(*args, **kwargs)
-
-    def success(self):
-        if self.status == 403:
-            raise InvalidCredsError('Invalid credentials', self.driver)
-        if self.status == 401:
-            raise InvalidCredsError('API Key has insufficient rights',
-                                    self.driver)
-        if not self.body:
-            return None
-        try:
-            return self.parse_body()['status'] == 'success'
-        except ValueError:
-            raise MalformedResponseError('Malformed reply',
-                                         body=self.body,
-                                         driver=self.driver)
-
-    def parse_error(self):
-        try:
-            return self.parse_body()["list"][0]["message"]
-        except (ValueError, KeyError):
-            return None
-
-
-class GoGridConnection(ConnectionUserAndKey):
-    """
-    Connection class for the GoGrid driver
-    """
-
-    host = HOST
-    responseCls = GoGridResponse
-
-    def add_default_params(self, params):
-        params["api_key"] = self.user_id
-        params["v"] = API_VERSION
-        params["format"] = 'json'
-        params["sig"] = self.get_signature(self.user_id, self.key)
-
-        return params
-
-    def get_signature(self, key, secret):
-        """ create sig from md5 of key + secret + time """
-        m = hashlib.md5(b(key + secret + str(int(time.time()))))
-        return m.hexdigest()
-
-    def request(self, action, params=None, data='', headers=None, method='GET',
-                raw=False):
-        return super(GoGridConnection, self).request(action, params, data,
-                                                     headers, method, raw)
-
-
-class GoGridIpAddress(object):
-    """
-    IP Address
-    """
-
-    def __init__(self, id, ip, public, state, subnet):
-        self.id = id
-        self.ip = ip
-        self.public = public
-        self.state = state
-        self.subnet = subnet
-
-
-class BaseGoGridDriver(object):
-    """GoGrid has common object model for services they
-    provide, like locations and IP, so keep handling of
-    these things in a single place."""
-
-    name = "GoGrid"
-
-    def _get_ip(self, element):
-        return element.get('ip').get('ip')
-
-    def _to_ip(self, element):
-        ip = GoGridIpAddress(id=element['id'],
-                             ip=element['ip'],
-                             public=element['public'],
-                             subnet=element['subnet'],
-                             state=element["state"]["name"])
-        ip.location = self._to_location(element['datacenter'])
-        return ip
-
-    def _to_ips(self, object):
-        return [self._to_ip(el)
-                for el in object['list']]
-
-    def _to_location(self, element):
-        location = NodeLocation(id=element['id'],
-                                name=element['name'],
-                                country="US",
-                                driver=self.connection.driver)
-        return location
-
-    def _to_locations(self, object):
-        return [self._to_location(el)
-                for el in object['list']]
-
-    def ex_list_ips(self, **kwargs):
-        """Return list of IP addresses assigned to
-        the account.
-
-        :keyword    public: set to True to list only
-                    public IPs or False to list only
-                    private IPs. Set to None or not specify
-                    at all not to filter by type
-        :type       public: ``bool``
-
-        :keyword    assigned: set to True to list only addresses
-                    assigned to servers, False to list unassigned
-                    addresses and set to None or don't set at all
-                    not no filter by state
-        :type       assigned: ``bool``
-
-        :keyword    location: filter IP addresses by location
-        :type       location: :class:`NodeLocation`
-
-        :rtype: ``list`` of :class:`GoGridIpAddress`
-        """
-
-        params = {}
-
-        if "public" in kwargs and kwargs["public"] is not None:
-            params["ip.type"] = {True: "Public",
-                                 False: "Private"}[kwargs["public"]]
-        if "assigned" in kwargs and kwargs["assigned"] is not None:
-            params["ip.state"] = {True: "Assigned",
-                                  False: "Unassigned"}[kwargs["assigned"]]
-        if "location" in kwargs and kwargs['location'] is not None:
-            params['datacenter'] = kwargs['location'].id
-
-        response = self.connection.request('/api/grid/ip/list', params=params)
-        ips = self._to_ips(response.object)
-        return ips
-
-    def _get_first_ip(self, location=None):
-        ips = self.ex_list_ips(public=True, assigned=False, location=location)
-        try:
-            return ips[0].ip
-        except IndexError:
-            raise LibcloudError('No public unassigned IPs left',
-                                self.driver)

http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/google.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/google.py b/apache-libcloud-1.0.0rc2/libcloud/common/google.py
deleted file mode 100644
index ca248d5..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/common/google.py
+++ /dev/null
@@ -1,828 +0,0 @@
-# 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
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Module for Google Connection and Authentication classes.
-
-Information about setting up your Google OAUTH2 credentials:
-
-For libcloud, there are two basic methods for authenticating to Google using
-OAUTH2: Service Accounts and Client IDs for Installed Applications.
-
-Both are initially set up from the Cloud Console Console -
-https://cloud.google.com/console
-
-Setting up Service Account authentication (note that you need the PyCrypto
-package installed to use this):
-
-- Go to the Console
-- Go to your project and then to "APIs & auth" on the left
-- Click on "Credentials"
-- Click on "Create New Client ID..."
-- Select "Service account" and click on "Create Client ID"
-- Download the Private Key (should happen automatically).  The key you download
-  is in JSON format.
-- Move the .json file to a safe location.
-- Optionally, you may choose to Generate a PKCS12 key from the Console.
-  It needs to be converted to the PEM format.  Please note, the PKCS12 format
-  is deprecated and may be removed in a future release.
-  - Convert the key using OpenSSL (the default password is 'notasecret').
-  - Move the .pem file to a safe location.
-- To Authenticate, you will need to pass the Service Account's "Email
-  address" in as the user_id and the path to the .pem file as the key.
-
-Setting up Installed Application authentication:
-
-- Go to the Console
-- Go to your project and then to "APIs & auth" on the left
-- Click on "Credentials"
-- Select "Installed application" and "Other" then click on
-  "Create Client ID"
-- To Authenticate, pass in the "Client ID" as the user_id and the "Client
-  secret" as the key
-- The first time that you do this, the libcloud will give you a URL to
-  visit.  Copy and paste the URL into a browser.
-- When you go to the URL it will ask you to log in (if you aren't already)
-  and ask you if you want to allow the project access to your account.
-- Click on Accept and you will be given a code.
-- Paste that code at the prompt given to you by the Google libcloud
-  connection.
-- At that point, a token & refresh token will be stored in your home
-  directory and will be used for authentication.
-
-Please remember to secure your keys and access tokens.
-"""
-
-from __future__ import with_statement
-
-try:
-    import simplejson as json
-except ImportError:
-    import json
-
-import base64
-import errno
-import time
-import datetime
-import os
-import socket
-import sys
-
-from libcloud.utils.connection import get_response_object
-from libcloud.utils.py3 import b, httplib, urlencode, urlparse, PY3
-from libcloud.common.base import (ConnectionUserAndKey, JsonResponse,
-                                  PollingConnection)
-from libcloud.common.types import (ProviderError,
-                                   LibcloudError)
-
-try:
-    from Crypto.Hash import SHA256
-    from Crypto.PublicKey import RSA
-    from Crypto.Signature import PKCS1_v1_5
-    import Crypto.Random
-    Crypto.Random.atfork()
-except ImportError:
-    # The pycrypto library is unavailable
-    SHA256 = None
-    RSA = None
-    PKCS1_v1_5 = None
-
-UTC_TIMESTAMP_FORMAT = '%Y-%m-%dT%H:%M:%SZ'
-
-
-def _utcnow():
-    """
-    Mocked in libcloud.test.common.google.GoogleTestCase.
-    """
-    return datetime.datetime.utcnow()
-
-
-def _utc_timestamp(datetime_obj):
-    return datetime_obj.strftime(UTC_TIMESTAMP_FORMAT)
-
-
-def _from_utc_timestamp(timestamp):
-    return datetime.datetime.strptime(timestamp, UTC_TIMESTAMP_FORMAT)
-
-
-def _get_gce_metadata(path=''):
-    try:
-        url = 'http://metadata/computeMetadata/v1/' + path.lstrip('/')
-        headers = {'Metadata-Flavor': 'Google'}
-        response = get_response_object(url, headers=headers)
-        return response.status, '', response.body
-    except Exception as e:
-        return -1, str(e), None
-
-
-class GoogleAuthError(LibcloudError):
-    """Generic Error class for various authentication errors."""
-    def __init__(self, value):
-        self.value = value
-
-    def __repr__(self):
-        return repr(self.value)
-
-
-class GoogleBaseError(ProviderError):
-    def __init__(self, value, http_code, code, driver=None):
-        self.code = code
-        super(GoogleBaseError, self).__init__(value, http_code, driver)
-
-
-class InvalidRequestError(GoogleBaseError):
-    pass
-
-
-class JsonParseError(GoogleBaseError):
-    pass
-
-
-class ResourceNotFoundError(GoogleBaseError):
-    def __init__(self, value, http_code, code, driver=None):
-        self.code = code
-        if isinstance(value, dict) and 'message' in value and \
-                value['message'].count('/') == 1 and \
-                value['message'].count('projects/') == 1:
-            value['message'] = value['message'] + ". A missing project " \
-                "error may be an authentication issue. " \
-                "Please  ensure your auth credentials match " \
-                "your project. "
-        super(GoogleBaseError, self).__init__(value, http_code, driver)
-
-
-class QuotaExceededError(GoogleBaseError):
-    pass
-
-
-class ResourceExistsError(GoogleBaseError):
-    pass
-
-
-class ResourceInUseError(GoogleBaseError):
-    pass
-
-
-class GoogleResponse(JsonResponse):
-    """
-    Google Base Response class.
-    """
-    def success(self):
-        """
-        Determine if the request was successful.
-
-        For the Google response class, tag all responses as successful and
-        raise appropriate Exceptions from parse_body.
-
-        :return: C{True}
-        """
-        return True
-
-    def _get_error(self, body):
-        """
-        Get the error code and message from a JSON response.
-
-        Return just the first error if there are multiple errors.
-
-        :param  body: The body of the JSON response dictionary
-        :type   body: ``dict``
-
-        :return:  Tuple containing error code and message
-        :rtype:   ``tuple`` of ``str`` or ``int``
-        """
-        if 'errors' in body['error']:
-            err = body['error']['errors'][0]
-        else:
-            err = body['error']
-
-        if 'code' in err:
-            code = err.get('code')
-            message = err.get('message')
-        else:
-            code = err.get('reason', None)
-            message = body.get('error_description', err)
-
-        return (code, message)
-
-    def parse_body(self):
-        """
-        Parse the JSON response body, or raise exceptions as appropriate.
-
-        :return:  JSON dictionary
-        :rtype:   ``dict``
-        """
-        if len(self.body) == 0 and not self.parse_zero_length_body:
-            return self.body
-
-        json_error = False
-        try:
-            body = json.loads(self.body)
-        except:
-            # If there is both a JSON parsing error and an unsuccessful http
-            # response (like a 404), we want to raise the http error and not
-            # the JSON one, so don't raise JsonParseError here.
-            body = self.body
-            json_error = True
-
-        valid_http_codes = [
-            httplib.OK,
-            httplib.CREATED,
-            httplib.ACCEPTED,
-            httplib.CONFLICT,
-        ]
-        if self.status in valid_http_codes:
-            if json_error:
-                raise JsonParseError(body, self.status, None)
-            elif 'error' in body:
-                (code, message) = self._get_error(body)
-                if code == 'QUOTA_EXCEEDED':
-                    raise QuotaExceededError(message, self.status, code)
-                elif code == 'RESOURCE_ALREADY_EXISTS':
-                    raise ResourceExistsError(message, self.status, code)
-                elif code == 'alreadyExists':
-                    raise ResourceExistsError(message, self.status, code)
-                elif code.startswith('RESOURCE_IN_USE'):
-                    raise ResourceInUseError(message, self.status, code)
-                else:
-                    raise GoogleBaseError(message, self.status, code)
-            else:
-                return body
-
-        elif self.status == httplib.NOT_FOUND:
-            if (not json_error) and ('error' in body):
-                (code, message) = self._get_error(body)
-            else:
-                message = body
-                code = None
-            raise ResourceNotFoundError(message, self.status, code)
-
-        elif self.status == httplib.BAD_REQUEST:
-            if (not json_error) and ('error' in body):
-                (code, message) = self._get_error(body)
-            else:
-                message = body
-                code = None
-            raise InvalidRequestError(message, self.status, code)
-
-        else:
-            if (not json_error) and ('error' in body):
-                (code, message) = self._get_error(body)
-            else:
-                message = body
-                code = None
-            raise GoogleBaseError(message, self.status, code)
-
-
-class GoogleBaseDriver(object):
-    name = "Google API"
-
-
-class GoogleBaseAuthConnection(ConnectionUserAndKey):
-    """
-    Base class for Google Authentication.  Should be subclassed for specific
-    types of authentication.
-    """
-    driver = GoogleBaseDriver
-    responseCls = GoogleResponse
-    name = 'Google Auth'
-    host = 'accounts.google.com'
-    auth_path = '/o/oauth2/auth'
-
-    def __init__(self, user_id, key=None, scopes=None,
-                 redirect_uri='urn:ietf:wg:oauth:2.0:oob',
-                 login_hint=None, **kwargs):
-        """
-        :param  user_id: The email address (for service accounts) or Client ID
-                         (for installed apps) to be used for authentication.
-        :type   user_id: ``str``
-
-        :param  key: The RSA Key (for service accounts) or file path containing
-                     key or Client Secret (for installed apps) to be used for
-                     authentication.
-        :type   key: ``str``
-
-        :param  scopes: A list of urls defining the scope of authentication
-                       to grant.
-        :type   scopes: ``list``
-
-        :keyword  redirect_uri: The Redirect URI for the authentication
-                                request.  See Google OAUTH2 documentation for
-                                more info.
-        :type     redirect_uri: ``str``
-
-        :keyword  login_hint: Login hint for authentication request.  Useful
-                              for Installed Application authentication.
-        :type     login_hint: ``str``
-        """
-        scopes = scopes or []
-
-        self.scopes = " ".join(scopes)
-        self.redirect_uri = redirect_uri
-        self.login_hint = login_hint
-
-        super(GoogleBaseAuthConnection, self).__init__(user_id, key, **kwargs)
-
-    def add_default_headers(self, headers):
-        headers['Content-Type'] = "application/x-www-form-urlencoded"
-        headers['Host'] = self.host
-        return headers
-
-    def _token_request(self, request_body):
-        """
-        Return an updated token from a token request body.
-
-        :param  request_body: A dictionary of values to send in the body of the
-                              token request.
-        :type   request_body: ``dict``
-
-        :return:  A dictionary with updated token information
-        :rtype:   ``dict``
-        """
-        data = urlencode(request_body)
-        try:
-            response = self.request('/o/oauth2/token', method='POST',
-                                    data=data)
-        except AttributeError:
-            raise GoogleAuthError('Invalid authorization response, please '
-                                  'check your credentials and time drift.')
-        token_info = response.object
-        if 'expires_in' in token_info:
-            expire_time = _utcnow() + datetime.timedelta(
-                seconds=token_info['expires_in'])
-            token_info['expire_time'] = _utc_timestamp(expire_time)
-        return token_info
-
-    def refresh_token(self, token_info):
-        """
-        Refresh the current token.
-
-        Fetch an updated refresh token from internal metadata service.
-
-        :param  token_info: Dictionary containing token information.
-                            (Not used, but here for compatibility)
-        :type   token_info: ``dict``
-
-        :return:  A dictionary containing updated token information.
-        :rtype:   ``dict``
-        """
-        return self.get_new_token()
-
-
-class GoogleInstalledAppAuthConnection(GoogleBaseAuthConnection):
-    """Authentication connection for "Installed Application" authentication."""
-    def get_code(self):
-        """
-        Give the user a URL that they can visit to authenticate and obtain a
-        code.  This method will ask for that code that the user can paste in.
-
-        Mocked in libcloud.test.common.google.GoogleTestCase.
-
-        :return:  Code supplied by the user after authenticating
-        :rtype:   ``str``
-        """
-        auth_params = {'response_type': 'code',
-                       'client_id': self.user_id,
-                       'redirect_uri': self.redirect_uri,
-                       'scope': self.scopes,
-                       'state': 'Libcloud Request'}
-        if self.login_hint:
-            auth_params['login_hint'] = self.login_hint
-
-        data = urlencode(auth_params)
-
-        url = 'https://%s%s?%s' % (self.host, self.auth_path, data)
-        print('\nPlease Go to the following URL and sign in:')
-        print(url)
-        if PY3:
-            code = input('Enter Code: ')
-        else:
-            code = raw_input('Enter Code: ')
-        return code
-
-    def get_new_token(self):
-        """
-        Get a new token. Generally used when no previous token exists or there
-        is no refresh token
-
-        :return:  Dictionary containing token information
-        :rtype:   ``dict``
-        """
-        # Ask the user for a code
-        code = self.get_code()
-
-        token_request = {'code': code,
-                         'client_id': self.user_id,
-                         'client_secret': self.key,
-                         'redirect_uri': self.redirect_uri,
-                         'grant_type': 'authorization_code'}
-
-        return self._token_request(token_request)
-
-    def refresh_token(self, token_info):
-        """
-        Use the refresh token supplied in the token info to get a new token.
-
-        :param  token_info: Dictionary containing current token information
-        :type   token_info: ``dict``
-
-        :return:  A dictionary containing updated token information.
-        :rtype:   ``dict``
-        """
-        if 'refresh_token' not in token_info:
-            return self.get_new_token()
-        refresh_request = {'refresh_token': token_info['refresh_token'],
-                           'client_id': self.user_id,
-                           'client_secret': self.key,
-                           'grant_type': 'refresh_token'}
-
-        new_token = self._token_request(refresh_request)
-        if 'refresh_token' not in new_token:
-            new_token['refresh_token'] = token_info['refresh_token']
-        return new_token
-
-
-class GoogleServiceAcctAuthConnection(GoogleBaseAuthConnection):
-    """Authentication class for "Service Account" authentication."""
-    def __init__(self, user_id, key, *args, **kwargs):
-        """
-        Check to see if PyCrypto is available, and convert key file path into a
-        key string if the key is in a file.
-
-        :param  user_id: Email address to be used for Service Account
-                authentication.
-        :type   user_id: ``str``
-
-        :param  key: The RSA Key or path to file containing the key.
-        :type   key: ``str``
-        """
-        if SHA256 is None:
-            raise GoogleAuthError('PyCrypto library required for '
-                                  'Service Account Authentication.')
-        # Check to see if 'key' is a file and read the file if it is.
-        if key.find("PRIVATE KEY---") == -1:
-            # key is a file
-            keypath = os.path.expanduser(key)
-            is_file_path = os.path.exists(keypath) and os.path.isfile(keypath)
-            if not is_file_path:
-                raise ValueError("Missing (or not readable) key "
-                                 "file: '%s'" % key)
-            with open(keypath, 'r') as f:
-                contents = f.read()
-            try:
-                key = json.loads(contents)
-                key = key['private_key']
-            except ValueError:
-                key = contents
-
-        super(GoogleServiceAcctAuthConnection, self).__init__(
-            user_id, key, *args, **kwargs)
-
-    def get_new_token(self):
-        """
-        Get a new token using the email address and RSA Key.
-
-        :return:  Dictionary containing token information
-        :rtype:   ``dict``
-        """
-        # The header is always the same
-        header = {'alg': 'RS256', 'typ': 'JWT'}
-        header_enc = base64.urlsafe_b64encode(b(json.dumps(header)))
-
-        # Construct a claim set
-        claim_set = {'iss': self.user_id,
-                     'scope': self.scopes,
-                     'aud': 'https://accounts.google.com/o/oauth2/token',
-                     'exp': int(time.time()) + 3600,
-                     'iat': int(time.time())}
-        claim_set_enc = base64.urlsafe_b64encode(b(json.dumps(claim_set)))
-
-        # The message contains both the header and claim set
-        message = b'.'.join((header_enc, claim_set_enc))
-        # Then the message is signed using the key supplied
-        key = RSA.importKey(self.key)
-        hash_func = SHA256.new(message)
-        signer = PKCS1_v1_5.new(key)
-        signature = base64.urlsafe_b64encode(signer.sign(hash_func))
-
-        # Finally the message and signature are sent to get a token
-        jwt = b'.'.join((message, signature))
-        request = {'grant_type': 'urn:ietf:params:oauth:grant-type:jwt-bearer',
-                   'assertion': jwt}
-
-        return self._token_request(request)
-
-
-class GoogleGCEServiceAcctAuthConnection(GoogleBaseAuthConnection):
-    """Authentication class for self-authentication when used with a GCE
-    instance that supports serviceAccounts.
-    """
-    def get_new_token(self):
-        """
-        Get a new token from the internal metadata service.
-
-        :return:  Dictionary containing token information
-        :rtype:   ``dict``
-        """
-        path = '/instance/service-accounts/default/token'
-        http_code, http_reason, token_info = _get_gce_metadata(path)
-        if http_code == httplib.NOT_FOUND:
-            raise ValueError("Service Accounts are not enabled for this "
-                             "GCE instance.")
-        if http_code != httplib.OK:
-            raise ValueError("Internal GCE Authorization failed: "
-                             "'%s'" % str(http_reason))
-        token_info = json.loads(token_info)
-        if 'expires_in' in token_info:
-            expire_time = _utcnow() + datetime.timedelta(
-                seconds=token_info['expires_in'])
-            token_info['expire_time'] = _utc_timestamp(expire_time)
-        return token_info
-
-
-class GoogleAuthType(object):
-    """
-    SA (Service Account),
-    IA (Installed Application),
-    GCE (Auth from a GCE instance with service account enabled)
-    GCS_S3 (Cloud Storage S3 interoperability authentication)
-    """
-    SA = 'SA'
-    IA = 'IA'
-    GCE = 'GCE'
-    GCS_S3 = 'GCS_S3'
-
-    ALL_TYPES = [SA, IA, GCE, GCS_S3]
-    OAUTH2_TYPES = [SA, IA, GCE]
-
-    @classmethod
-    def guess_type(cls, user_id):
-        if cls._is_sa(user_id):
-            return cls.SA
-        elif cls._is_gce():
-            return cls.GCE
-        elif cls._is_gcs_s3(user_id):
-            return cls.GCS_S3
-        else:
-            return cls.IA
-
-    @classmethod
-    def is_oauth2(cls, auth_type):
-        return auth_type in cls.OAUTH2_TYPES
-
-    @staticmethod
-    def _is_gce():
-        """
-        Checks if we can access the GCE metadata server.
-        Mocked in libcloud.test.common.google.GoogleTestCase.
-        """
-        http_code, http_reason, body = _get_gce_metadata()
-        if http_code == httplib.OK and body:
-            return True
-        return False
-
-    @staticmethod
-    def _is_gcs_s3(user_id):
-        """
-        Checks S3 key format: 20 alphanumeric chars starting with GOOG.
-        """
-        return len(user_id) == 20 and user_id.startswith('GOOG')
-
-    @staticmethod
-    def _is_sa(user_id):
-        return user_id.endswith('.gserviceaccount.com')
-
-
-class GoogleOAuth2Credential(object):
-    default_credential_file = '~/.google_libcloud_auth'
-
-    def __init__(self, user_id, key, auth_type=None, credential_file=None,
-                 scopes=None, **kwargs):
-        self.auth_type = auth_type or GoogleAuthType.guess_type(user_id)
-        if self.auth_type not in GoogleAuthType.ALL_TYPES:
-            raise GoogleAuthError('Invalid auth type: %s' % self.auth_type)
-        if not GoogleAuthType.is_oauth2(self.auth_type):
-            raise GoogleAuthError(('Auth type %s cannot be used with OAuth2' %
-                                   self.auth_type))
-        self.user_id = user_id
-        self.key = key
-
-        default_credential_file = '.'.join([self.default_credential_file,
-                                            user_id])
-        self.credential_file = credential_file or default_credential_file
-        # Default scopes to read/write for compute, storage, and dns.
-        self.scopes = scopes or [
-            'https://www.googleapis.com/auth/compute',
-            'https://www.googleapis.com/auth/devstorage.full_control',
-            'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
-        ]
-
-        self.token = self._get_token_from_file()
-
-        if self.auth_type == GoogleAuthType.GCE:
-            self.oauth2_conn = GoogleGCEServiceAcctAuthConnection(
-                self.user_id, self.scopes, **kwargs)
-        elif self.auth_type == GoogleAuthType.SA:
-            self.oauth2_conn = GoogleServiceAcctAuthConnection(
-                self.user_id, self.key, self.scopes, **kwargs)
-        elif self.auth_type == GoogleAuthType.IA:
-            self.oauth2_conn = GoogleInstalledAppAuthConnection(
-                self.user_id, self.key, self.scopes, **kwargs)
-        else:
-            raise GoogleAuthError('Invalid auth_type: %s' %
-                                  str(self.auth_type))
-
-        if self.token is None:
-            self.token = self.oauth2_conn.get_new_token()
-            self._write_token_to_file()
-
-    @property
-    def access_token(self):
-        if self.token_expire_utc_datetime < _utcnow():
-            self._refresh_token()
-        return self.token['access_token']
-
-    @property
-    def token_expire_utc_datetime(self):
-        return _from_utc_timestamp(self.token['expire_time'])
-
-    def _refresh_token(self):
-        self.token = self.oauth2_conn.refresh_token(self.token)
-        self._write_token_to_file()
-
-    def _get_token_from_file(self):
-        """
-        Read credential file and return token information.
-        Mocked in libcloud.test.common.google.GoogleTestCase.
-
-        :return:  Token information dictionary, or None
-        :rtype:   ``dict`` or ``None``
-        """
-        token = None
-        filename = os.path.realpath(os.path.expanduser(self.credential_file))
-
-        try:
-            with open(filename, 'r') as f:
-                data = f.read()
-            token = json.loads(data)
-        except IOError:
-            pass
-        return token
-
-    def _write_token_to_file(self):
-        """
-        Write token to credential file.
-        Mocked in libcloud.test.common.google.GoogleTestCase.
-        """
-        filename = os.path.realpath(os.path.expanduser(self.credential_file))
-        data = json.dumps(self.token)
-        with os.fdopen(os.open(filename, os.O_CREAT | os.O_WRONLY,
-                               int('600', 8)), 'w') as f:
-            f.write(data)
-
-
-class GoogleBaseConnection(ConnectionUserAndKey, PollingConnection):
-    """Base connection class for interacting with Google APIs."""
-    driver = GoogleBaseDriver
-    responseCls = GoogleResponse
-    host = 'www.googleapis.com'
-    poll_interval = 2.0
-    timeout = 180
-
-    def __init__(self, user_id, key=None, auth_type=None,
-                 credential_file=None, scopes=None, **kwargs):
-        """
-        Determine authentication type, set up appropriate authentication
-        connection and get initial authentication information.
-
-        :param  user_id: The email address (for service accounts) or Client ID
-                         (for installed apps) to be used for authentication.
-        :type   user_id: ``str``
-
-        :param  key: The RSA Key (for service accounts) or file path containing
-                     key or Client Secret (for installed apps) to be used for
-                     authentication.
-        :type   key: ``str``
-
-        :keyword  auth_type: See GoogleAuthType class for list and description
-                             of accepted values.
-                             If not supplied, auth_type will be guessed based
-                             on value of user_id or if the code is running
-                             on a GCE instance.
-        :type     auth_type: ``str``
-
-        :keyword  credential_file: Path to file for caching authentication
-                                   information.
-        :type     credential_file: ``str``
-
-        :keyword  scopes: List of OAuth2 scope URLs. The empty default sets
-                          read/write access to Compute, Storage, and DNS.
-        :type     scopes: ``list``
-        """
-        super(GoogleBaseConnection, self).__init__(user_id, key, **kwargs)
-
-        self.oauth2_credential = GoogleOAuth2Credential(
-            user_id, key, auth_type, credential_file, scopes, **kwargs)
-
-        python_ver = '%s.%s.%s' % (sys.version_info[0], sys.version_info[1],
-                                   sys.version_info[2])
-        ver_platform = 'Python %s/%s' % (python_ver, sys.platform)
-        self.user_agent_append(ver_platform)
-
-    def add_default_headers(self, headers):
-        """
-        @inherits: :class:`Connection.add_default_headers`
-        """
-        headers['Content-Type'] = 'application/json'
-        headers['Host'] = self.host
-        return headers
-
-    def pre_connect_hook(self, params, headers):
-        """
-        Check to make sure that token hasn't expired.  If it has, get an
-        updated token.  Also, add the token to the headers.
-
-        @inherits: :class:`Connection.pre_connect_hook`
-        """
-        headers['Authorization'] = ('Bearer ' +
-                                    self.oauth2_credential.access_token)
-        return params, headers
-
-    def encode_data(self, data):
-        """Encode data to JSON"""
-        return json.dumps(data)
-
-    def request(self, *args, **kwargs):
-        """
-        @inherits: :class:`Connection.request`
-        """
-        # Adds some retry logic for the occasional
-        # "Connection Reset by peer" error.
-        retries = 4
-        tries = 0
-        while tries < (retries - 1):
-            try:
-                return super(GoogleBaseConnection, self).request(
-                    *args, **kwargs)
-            except socket.error:
-                e = sys.exc_info()[1]
-                if e.errno == errno.ECONNRESET:
-                    tries = tries + 1
-                else:
-                    raise e
-        # One more time, then give up.
-        return super(GoogleBaseConnection, self).request(*args, **kwargs)
-
-    def has_completed(self, response):
-        """
-        Determine if operation has completed based on response.
-
-        :param  response: JSON response
-        :type   response: I{responseCls}
-
-        :return:  True if complete, False otherwise
-        :rtype:   ``bool``
-        """
-        if response.object['status'] == 'DONE':
-            return True
-        else:
-            return False
-
-    def get_poll_request_kwargs(self, response, context, request_kwargs):
-        """
-        @inherits: :class:`PollingConnection.get_poll_request_kwargs`
-        """
-        return {'action': response.object['selfLink']}
-
-    def morph_action_hook(self, action):
-        """
-        Update action to correct request path.
-
-        In many places, the Google API returns a full URL to a resource.
-        This will strip the scheme and host off of the path and just return
-        the request.  Otherwise, it will prepend the base request_path to
-        the action.
-
-        :param  action: The action to be called in the http request
-        :type   action: ``str``
-
-        :return:  The modified request based on the action
-        :rtype:   ``str``
-        """
-        if action.startswith('https://'):
-            u = urlparse.urlsplit(action)
-            request = urlparse.urlunsplit(('', '', u[2], u[3], u[4]))
-        else:
-            request = self.request_path + action
-        return request

http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/hostvirtual.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/hostvirtual.py b/apache-libcloud-1.0.0rc2/libcloud/common/hostvirtual.py
deleted file mode 100644
index e7ce14d..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/common/hostvirtual.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# 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
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-try:
-    import simplejson as json
-except ImportError:
-    import json
-
-from libcloud.utils.py3 import httplib
-from libcloud.common.base import ConnectionKey, JsonResponse
-from libcloud.compute.types import InvalidCredsError
-from libcloud.common.types import LibcloudError
-
-API_HOST = 'vapi.vr.org'
-
-
-class HostVirtualException(LibcloudError):
-    def __init__(self, code, message):
-        self.code = code
-        self.message = message
-        self.args = (code, message)
-
-    def __str__(self):
-        return self.__repr__()
-
-    def __repr__(self):
-        return '<HostVirtualException in %d: %s>' % (self.code, self.message)
-
-
-class HostVirtualConnection(ConnectionKey):
-    host = API_HOST
-
-    allow_insecure = False
-
-    def add_default_params(self, params):
-        params['key'] = self.key
-        return params
-
-
-class HostVirtualResponse(JsonResponse):
-    valid_response_codes = [httplib.OK, httplib.ACCEPTED, httplib.CREATED,
-                            httplib.NO_CONTENT]
-
-    def parse_body(self):
-        if not self.body:
-            return None
-
-        data = json.loads(self.body)
-        return data
-
-    def parse_error(self):
-        data = self.parse_body()
-
-        if self.status == httplib.UNAUTHORIZED:
-            raise InvalidCredsError('%(code)s:%(message)s' % (data['error']))
-        elif self.status == httplib.PRECONDITION_FAILED:
-            raise HostVirtualException(
-                data['error']['code'], data['error']['message'])
-        elif self.status == httplib.NOT_FOUND:
-            raise HostVirtualException(
-                data['error']['code'], data['error']['message'])
-
-        return self.body
-
-    def success(self):
-        return self.status in self.valid_response_codes

http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/linode.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/linode.py b/apache-libcloud-1.0.0rc2/libcloud/common/linode.py
deleted file mode 100644
index c991695..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/common/linode.py
+++ /dev/null
@@ -1,186 +0,0 @@
-# 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
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from libcloud.common.base import ConnectionKey, JsonResponse
-from libcloud.common.types import InvalidCredsError
-
-from libcloud.utils.py3 import PY3
-from libcloud.utils.py3 import b
-
-__all__ = [
-    'API_HOST',
-    'API_ROOT',
-    'LinodeException',
-    'LinodeResponse',
-    'LinodeConnection'
-]
-
-# Endpoint for the Linode API
-API_HOST = 'api.linode.com'
-API_ROOT = '/'
-
-# Constants that map a RAM figure to a PlanID (updated 2014-08-25)
-LINODE_PLAN_IDS = {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']
-
-
-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)
-
-
-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.connection = connection
-
-        self.headers = dict(response.getheaders())
-        self.error = response.reason
-        self.status = response.status
-
-        # This attribute is set when using LoggingConnection.
-        original_data = getattr(response, '_original_data', None)
-
-        if original_data:
-            # LoggingConnection already decompresses data so it can log it
-            # which means we don't need to decompress it here.
-            self.body = response._original_data
-        else:
-            self.body = self._decompress_response(body=response.read(),
-                                                  headers=self.headers)
-
-        if PY3:
-            self.body = b(self.body).decode('utf-8')
-
-        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]
-
-    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(LinodeResponse, self).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:
-            return (None, [self.invalid])
-
-    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"])
-
-
-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
-
-    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

http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/liquidweb.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/liquidweb.py b/apache-libcloud-1.0.0rc2/libcloud/common/liquidweb.py
deleted file mode 100644
index 123e82f..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/common/liquidweb.py
+++ /dev/null
@@ -1,229 +0,0 @@
-# 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
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import base64
-
-from libcloud.common.base import JsonResponse
-from libcloud.common.base import ConnectionUserAndKey
-from libcloud.utils.py3 import b
-from libcloud.common.types import ProviderError
-
-
-__all__ = [
-    'API_HOST',
-    'LiquidWebException',
-    'LiquidWebResponse',
-    'LiquidWebConnection',
-]
-
-
-# Endpoint for liquidweb api.
-API_HOST = 'api.stormondemand.com'
-
-
-class LiquidWebException(ProviderError):
-    """The base class for other Liquidweb exceptions"""
-
-    def __init__(self, value, http_code, extra=None):
-        """
-        :param value: message contained in error
-        :type  value: ``str``
-
-        :param http_code: error code
-        :type  http_code: ``int``
-
-        :param extra: extra fields specific to error type
-        :type  extra: ``list``
-        """
-        self.extra = extra
-        super(LiquidWebException, self).__init__(value, http_code, driver=None)
-
-    def __str__(self):
-        return "%s  %s" % (self.code, self.value)
-
-    def __repr__(self):
-        return "LiquidWebException %s %s" % (self.code, self.value)
-
-
-class APIException(LiquidWebException):
-
-    def __init__(self, error_class, full_msg, http_code, extra=None):
-        self.error_class = error_class
-        super(APIException, self).__init__(full_msg, http_code, extra=extra)
-
-    def __str__(self):
-        return "%s: %s" % (self.error_class, self.value)
-
-    def __repr__(self):
-        return "%s: %s" % (self.error_class, self.value)
-
-
-EXCEPTIONS_FIELDS = {
-    'LW::Exception::API::Internal': {
-        'fields': []
-    },
-    'LW::Exception::API::InvalidEncoding': {
-        'fields': ['encoding']
-    },
-    'LW::Exception::API::InvalidMethod': {
-        'fields': ['method']
-    },
-    'LW::Exception::API::Maintenance': {
-        'fields': []
-    },
-    'LW::Exception::API::RateLimit': {
-        'fields': ['account', 'ip', 'method']
-    },
-    'LW::Exception::Authorization': {
-        'fields': ['username']
-    },
-    'LW::Exception::DNS::NoResponse': {
-        'fields': ['nameservers']
-    },
-    'LW::Exception::DNS::Servfail': {
-        'fields': ['nameservers']
-    },
-    'LW::Exception::Deserialize': {
-        'fields': ['data', 'encoding']
-    },
-    'LW::Exception::DuplicateRecord': {
-        'fields': ['field', 'input', 'statement']
-    },
-    'LW::Exception::Forbidden': {
-        'fields': []
-    },
-    'LW::Exception::Incapable': {
-        'fields': ['capability', 'thing']
-    },
-    'LW::Exception::Input': {
-        'fields': ['field']
-    },
-    'LW::Exception::Input::Disallowed': {
-        'fields': ['field']
-    },
-    'LW::Exception::Input::Multiple': {
-        'fields': ['errors', 'field', 'type']
-    },
-    'LW::Exception::Input::NotInRealm': {
-        'fields': ['field', 'valid', 'value']
-    },
-    'LW::Exception::Input::OutOfBounds': {
-        'fields': ['field', 'max', 'min', 'value']
-    },
-    'LW::Exception::Input::Required': {
-        'fields': ['field', 'position']
-    },
-    'LW::Exception::Input::Unknown': {
-        'fields': ['field', 'value']
-    },
-    'LW::Exception::Input::Validation': {
-        'fields': ['field', 'type', 'value']
-    },
-    'LW::Exception::Permission': {
-        'fields': ['account', 'identifier']
-    },
-    'LW::Exception::RecordNotFound': {
-        'fields': ['field', 'input']
-    },
-    'LW::Exception::RemoteService::Authorization': {
-        'fields': ['url']
-    },
-    'LW::Exception::Resource': {
-        'fields': ['resource']
-    },
-    'LW::Exception::Resource::Insufficient': {
-        'fields': ['available', 'requested', 'resource']
-    },
-    'LW::Exception::Resource::Unavailable': {
-        'fields': ['resource']
-    },
-    'LW::Exception::Serialize': {
-        'fields': ['data', 'encoding']
-    },
-    'LW::Exception::Workflow::Conflict': {
-        'fields': ['conflict', 'workflow']
-    }
-}
-
-
-class LiquidWebResponse(JsonResponse):
-    objects = None
-    errors = None
-    error_dict = {}
-
-    def __init__(self, response, connection):
-        self.errors = []
-        super(LiquidWebResponse, self).__init__(response=response,
-                                                connection=connection)
-        self.objects, self.errors = self.parse_body_and_errors()
-        if self.errors:
-            error = self.errors.pop()
-            raise self._make_excp(error, self.status)
-
-    def parse_body_and_errors(self):
-        data = []
-        errors = []
-        js = super(LiquidWebResponse, self).parse_body()
-        if 'items' in js:
-            data.append(js['items'])
-
-        if 'name' in js:
-            data.append(js)
-
-        if 'deleted' in js:
-            data.append(js['deleted'])
-
-        if 'error_class' in js:
-            errors.append(js)
-
-        return (data, errors)
-
-    def success(self):
-        """
-        Returns ``True`` if our request is successful.
-        """
-        return (len(self.errors) == 0)
-
-    def _make_excp(self, error, status):
-        """
-        Raise LiquidWebException.
-        """
-        exc_type = error.get('error_class')
-        message = error.get('full_message')
-        try:
-            _type = EXCEPTIONS_FIELDS[exc_type]
-            fields = _type.get('fields')
-            extra = {}
-        except KeyError:
-            fields = []
-
-        for field in fields:
-            extra[field] = error.get(field)
-        return APIException(exc_type, message, status, extra=extra)
-
-
-class LiquidWebConnection(ConnectionUserAndKey):
-    host = API_HOST
-    responseCls = LiquidWebResponse
-
-    def add_default_headers(self, headers):
-        b64string = b('%s:%s' % (self.user_id, self.key))
-        encoded = base64.b64encode(b64string).decode('utf-8')
-        authorization = 'Basic ' + encoded
-
-        headers['Authorization'] = authorization
-        headers['Content-Type'] = 'application/json'
-
-        return headers

http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/luadns.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/luadns.py b/apache-libcloud-1.0.0rc2/libcloud/common/luadns.py
deleted file mode 100644
index e079835..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/common/luadns.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import base64
-
-
-from libcloud.common.base import ConnectionUserAndKey, JsonResponse
-from libcloud.utils.py3 import b
-
-__all__ = [
-    'API_HOST',
-    'LuadnsException',
-    'LuadnsResponse',
-    'LuadnsConnection'
-]
-
-# Endpoint for luadns api
-API_HOST = 'api.luadns.com'
-
-
-class LuadnsResponse(JsonResponse):
-    errors = []
-    objects = []
-
-    def __init__(self, response, connection):
-        super(LuadnsResponse, self).__init__(response=response,
-                                             connection=connection)
-        self.errors, self.objects = self.parse_body_and_errors()
-        if not self.success():
-            raise LuadnsException(code=self.status,
-                                  message=self.errors.pop()['message'])
-
-    def parse_body_and_errors(self):
-        js = super(LuadnsResponse, self).parse_body()
-        if 'message' in js:
-            self.errors.append(js)
-        else:
-            self.objects.append(js)
-
-        return self.errors, self.objects
-
-    def success(self):
-        return len(self.errors) == 0
-
-
-class LuadnsConnection(ConnectionUserAndKey):
-    host = API_HOST
-    responseCls = LuadnsResponse
-
-    def add_default_headers(self, headers):
-        b64string = b('%s:%s' % (self.user_id, self.key))
-        encoded = base64.b64encode(b64string).decode('utf-8')
-        authorization = 'Basic ' + encoded
-
-        headers['Accept'] = 'application/json'
-        headers['Authorization'] = authorization
-
-        return headers
-
-
-class LuadnsException(Exception):
-
-    def __init__(self, code, message):
-        self.code = code
-        self.message = message
-        self.args = (code, message)
-
-    def __str__(self):
-        return "%s %s" % (self.code, self.message)
-
-    def __repr__(self):
-        return "Luadns %s %s" % (self.code, self.message)

http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/nfsn.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/nfsn.py b/apache-libcloud-1.0.0rc2/libcloud/common/nfsn.py
deleted file mode 100644
index 4286f0c..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/common/nfsn.py
+++ /dev/null
@@ -1,114 +0,0 @@
-# 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
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-import hashlib
-import random
-import string
-import time
-
-from libcloud.common.base import ConnectionUserAndKey
-from libcloud.common.base import JsonResponse
-from libcloud.common.types import InvalidCredsError, ProviderError
-from libcloud.utils.py3 import basestring, httplib, urlencode
-
-
-SALT_CHARACTERS = string.ascii_letters + string.digits
-
-
-class NFSNException(ProviderError):
-    def __init__(self, value, http_code, code, driver=None):
-        self.code = code
-        super(NFSNException, self).__init__(value, http_code, driver)
-
-
-class NFSNResponse(JsonResponse):
-
-    def parse_error(self):
-        if self.status == httplib.UNAUTHORIZED:
-            raise InvalidCredsError('Invalid provider credentials')
-
-        body = self.parse_body()
-
-        if isinstance(body, basestring):
-            return body + ' (HTTP Code: %d)' % self.status
-
-        error = body.get('error', None)
-        debug = body.get('debug', None)
-        # If we only have one of "error" or "debug", use the one that we have.
-        # If we have both, use both, with a space character in between them.
-        value = 'No message specified'
-        if error is not None:
-            value = error
-        if debug is not None:
-            value = debug
-        if error is not None and value is not None:
-            value = error + ' ' + value
-        value = value + ' (HTTP Code: %d)' % self.status
-
-        return value
-
-
-class NFSNConnection(ConnectionUserAndKey):
-    host = 'api.nearlyfreespeech.net'
-    responseCls = NFSNResponse
-    allow_insecure = False
-
-    def _header(self, action, data):
-        """ Build the contents of the X-NFSN-Authentication HTTP header. See
-        https://members.nearlyfreespeech.net/wiki/API/Introduction for
-        more explanation. """
-        login = self.user_id
-        timestamp = self._timestamp()
-        salt = self._salt()
-        api_key = self.key
-        data = urlencode(data)
-        data_hash = hashlib.sha1(data.encode('utf-8')).hexdigest()
-
-        string = ';'.join((login, timestamp, salt, api_key, action, data_hash))
-        string_hash = hashlib.sha1(string.encode('utf-8')).hexdigest()
-
-        return ';'.join((login, timestamp, salt, string_hash))
-
-    def request(self, action, params=None, data='', headers=None,
-                method='GET'):
-        """ Add the X-NFSN-Authentication header to an HTTP request. """
-        if not headers:
-            headers = {}
-        if not params:
-            params = {}
-        header = self._header(action, data)
-
-        headers['X-NFSN-Authentication'] = header
-        if method == 'POST':
-            headers['Content-Type'] = 'application/x-www-form-urlencoded'
-
-        return ConnectionUserAndKey.request(self, action, params, data,
-                                            headers, method)
-
-    def encode_data(self, data):
-        """ NFSN expects the body to be regular key-value pairs that are not
-        JSON-encoded. """
-        if data:
-            data = urlencode(data)
-        return data
-
-    def _salt(self):
-        """ Return a 16-character alphanumeric string. """
-        r = random.SystemRandom()
-        return ''.join(r.choice(SALT_CHARACTERS) for _ in range(16))
-
-    def _timestamp(self):
-        """ Return the current number of seconds since the Unix epoch,
-        as a string. """
-        return str(int(time.time()))

http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/nsone.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/nsone.py b/apache-libcloud-1.0.0rc2/libcloud/common/nsone.py
deleted file mode 100644
index 5eb4e17..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/common/nsone.py
+++ /dev/null
@@ -1,62 +0,0 @@
-from libcloud.common.base import ConnectionKey, JsonResponse
-
-
-__all__ = [
-    'API_HOST',
-    'NsOneException',
-    'NsOneResponse',
-    'NsOneConnection'
-]
-
-# Endpoint for nsone api
-API_HOST = 'api.nsone.net'
-
-
-class NsOneResponse(JsonResponse):
-    errors = []
-    objects = []
-
-    def __init__(self, response, connection):
-        super(NsOneResponse, self).__init__(response=response,
-                                            connection=connection)
-        self.errors, self.objects = self.parse_body_and_errors()
-        if not self.success():
-            raise NsOneException(code=self.status,
-                                 message=self.errors.pop()['message'])
-
-    def parse_body_and_errors(self):
-        js = super(NsOneResponse, self).parse_body()
-        if 'message' in js:
-            self.errors.append(js)
-        else:
-            self.objects.append(js)
-
-        return self.errors, self.objects
-
-    def success(self):
-        return len(self.errors) == 0
-
-
-class NsOneConnection(ConnectionKey):
-    host = API_HOST
-    responseCls = NsOneResponse
-
-    def add_default_headers(self, headers):
-        headers['Content-Type'] = 'application/json'
-        headers['X-NSONE-KEY'] = self.key
-
-        return headers
-
-
-class NsOneException(Exception):
-
-    def __init__(self, code, message):
-        self.code = code
-        self.message = message
-        self.args = (code, message)
-
-    def __str__(self):
-        return "%s %s" % (self.code, self.message)
-
-    def __repr__(self):
-        return "NsOneException %s %s" % (self.code, self.message)

http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/onapp.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/onapp.py b/apache-libcloud-1.0.0rc2/libcloud/common/onapp.py
deleted file mode 100644
index 259e315..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/common/onapp.py
+++ /dev/null
@@ -1,49 +0,0 @@
-from base64 import b64encode
-
-from libcloud.utils.py3 import b
-from libcloud.utils.py3 import httplib
-from libcloud.common.base import ConnectionUserAndKey, JsonResponse
-
-
-class OnAppResponse(JsonResponse):
-    """
-    OnApp response class
-    """
-
-    def success(self):
-        """
-        Determine if our request was successful.
-
-        The meaning of this can be arbitrary; did we receive OK status? Did
-        the node get created? Were we authenticated?
-
-        :rtype: ``bool``
-        :return: ``True`` or ``False``
-        """
-        return self.status in [httplib.OK, httplib.CREATED, httplib.NO_CONTENT]
-
-
-class OnAppConnection(ConnectionUserAndKey):
-    """
-    OnApp connection class
-    """
-
-    responseCls = OnAppResponse
-
-    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("%s:%s" % (self.user_id, self.key))
-        encoded = b64encode(b64string).decode("utf-8")
-
-        headers["Authorization"] = "Basic " + encoded
-        return headers

http://git-wip-us.apache.org/repos/asf/libcloud/blob/8afcda91/apache-libcloud-1.0.0rc2/libcloud/common/openstack.py
----------------------------------------------------------------------
diff --git a/apache-libcloud-1.0.0rc2/libcloud/common/openstack.py b/apache-libcloud-1.0.0rc2/libcloud/common/openstack.py
deleted file mode 100644
index e63ee8a..0000000
--- a/apache-libcloud-1.0.0rc2/libcloud/common/openstack.py
+++ /dev/null
@@ -1,430 +0,0 @@
-# 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
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Common utilities for OpenStack
-"""
-
-try:
-    from lxml import etree as ET
-except ImportError:
-    from xml.etree import ElementTree as ET
-
-from libcloud.utils.py3 import httplib
-
-from libcloud.common.base import ConnectionUserAndKey, Response
-from libcloud.common.types import ProviderError
-from libcloud.compute.types import (LibcloudError, MalformedResponseError)
-from libcloud.compute.types import KeyPairDoesNotExistError
-from libcloud.common.openstack_identity import get_class_for_auth_version
-
-# Imports for backward compatibility reasons
-from libcloud.common.openstack_identity import OpenStackServiceCatalog
-
-
-try:
-    import simplejson as json
-except ImportError:
-    import json
-
-AUTH_API_VERSION = '1.1'
-
-# Auth versions which contain token expiration information.
-AUTH_VERSIONS_WITH_EXPIRES = [
-    '1.1',
-    '2.0',
-    '2.0_apikey',
-    '2.0_password',
-    '3.x',
-    '3.x_password'
-]
-
-__all__ = [
-    'OpenStackBaseConnection',
-    'OpenStackResponse',
-    'OpenStackException',
-    'OpenStackDriverMixin'
-]
-
-
-class OpenStackBaseConnection(ConnectionUserAndKey):
-
-    """
-    Base class for OpenStack connections.
-
-    :param user_id: User name to use when authenticating
-    :type user_id: ``str``
-
-    :param key: Secret to use when authenticating.
-    :type key: ``str``
-
-    :param secure: Use HTTPS?  (True by default.)
-    :type secure: ``bool``
-
-    :param ex_force_base_url: Base URL for connection requests.  If
-                              not specified, this will be determined by
-                              authenticating.
-    :type ex_force_base_url: ``str``
-
-    :param ex_force_auth_url: Base URL for authentication requests.
-    :type ex_force_auth_url: ``str``
-
-    :param ex_force_auth_version: Authentication version to use.  If
-                                  not specified, defaults to AUTH_API_VERSION.
-    :type ex_force_auth_version: ``str``
-
-    :param ex_force_auth_token: Authentication token to use for connection
-                                requests.  If specified, the connection will
-                                not attempt to authenticate, and the value
-                                of ex_force_base_url will be used to
-                                determine the base request URL.  If
-                                ex_force_auth_token is passed in,
-                                ex_force_base_url must also be provided.
-    :type ex_force_auth_token: ``str``
-
-    :param ex_tenant_name: When authenticating, provide this tenant name to the
-                           identity service. A scoped token will be returned.
-                           Some cloud providers require the tenant name to be
-                           provided at authentication time. Others will use a
-                           default tenant if none is provided.
-    :type ex_tenant_name: ``str``
-
-    :param ex_force_service_type: Service type to use when selecting an
-                                  service. If not specified, a provider
-                                  specific default will be used.
-    :type ex_force_service_type: ``str``
-
-    :param ex_force_service_name: Service name to use when selecting an
-                                  service. If not specified, a provider
-                                  specific default will be used.
-    :type ex_force_service_name: ``str``
-
-    :param ex_force_service_region: Region to use when selecting an service.
-                                    If not specified, a provider specific
-                                    default will be used.
-    :type ex_force_service_region: ``str``
-    """
-
-    auth_url = None
-    auth_token = None
-    auth_token_expires = None
-    auth_user_info = None
-    service_catalog = None
-    service_type = None
-    service_name = None
-    service_region = None
-    _auth_version = None
-
-    def __init__(self, user_id, key, secure=True,
-                 host=None, port=None, timeout=None, proxy_url=None,
-                 ex_force_base_url=None,
-                 ex_force_auth_url=None,
-                 ex_force_auth_version=None,
-                 ex_force_auth_token=None,
-                 ex_tenant_name=None,
-                 ex_force_service_type=None,
-                 ex_force_service_name=None,
-                 ex_force_service_region=None,
-                 retry_delay=None, backoff=None):
-        super(OpenStackBaseConnection, self).__init__(
-            user_id, key, secure=secure, timeout=timeout,
-            retry_delay=retry_delay, backoff=backoff, proxy_url=proxy_url)
-
-        if ex_force_auth_version:
-            self._auth_version = ex_force_auth_version
-
-        self._ex_force_base_url = ex_force_base_url
-        self._ex_force_auth_url = ex_force_auth_url
-        self._ex_force_auth_token = ex_force_auth_token
-        self._ex_tenant_name = ex_tenant_name
-        self._ex_force_service_type = ex_force_service_type
-        self._ex_force_service_name = ex_force_service_name
-        self._ex_force_service_region = ex_force_service_region
-        self._osa = None
-
-        if ex_force_auth_token and not ex_force_base_url:
-            raise LibcloudError(
-                'Must also provide ex_force_base_url when specifying '
-                'ex_force_auth_token.')
-
-        if ex_force_auth_token:
-            self.auth_token = ex_force_auth_token
-
-        if not self._auth_version:
-            self._auth_version = AUTH_API_VERSION
-
-        auth_url = self._get_auth_url()
-
-        if not auth_url:
-            raise LibcloudError('OpenStack instance must ' +
-                                'have auth_url set')
-
-    def get_auth_class(self):
-        """
-        Retrieve identity / authentication class instance.
-
-        :rtype: :class:`OpenStackIdentityConnection`
-        """
-        if not self._osa:
-            auth_url = self._get_auth_url()
-
-            cls = get_class_for_auth_version(auth_version=self._auth_version)
-            self._osa = cls(auth_url=auth_url,
-                            user_id=self.user_id,
-                            key=self.key,
-                            tenant_name=self._ex_tenant_name,
-                            timeout=self.timeout,
-                            parent_conn=self)
-
-        return self._osa
-
-    def request(self, action, params=None, data='', headers=None,
-                method='GET', raw=False):
-        headers = headers or {}
-        params = params or {}
-
-        # Include default content-type for POST and PUT request (if available)
-        default_content_type = getattr(self, 'default_content_type', None)
-        if method.upper() in ['POST', 'PUT'] and default_content_type:
-            headers = {'Content-Type': default_content_type}
-
-        return super(OpenStackBaseConnection, self).request(action=action,
-                                                            params=params,
-                                                            data=data,
-                                                            method=method,
-                                                            headers=headers,
-                                                            raw=raw)
-
-    def _get_auth_url(self):
-        """
-        Retrieve auth url for this instance using either "ex_force_auth_url"
-        constructor kwarg of "auth_url" class variable.
-        """
-        auth_url = self.auth_url
-
-        if self._ex_force_auth_url is not None:
-            auth_url = self._ex_force_auth_url
-
-        return auth_url
-
-    def get_service_catalog(self):
-        if self.service_catalog is None:
-            self._populate_hosts_and_request_paths()
-
-        return self.service_catalog
-
-    def get_service_name(self):
-        """
-        Gets the service name used to look up the endpoint in the service
-        catalog.
-
-        :return: name of the service in the catalog
-        """
-        if self._ex_force_service_name:
-            return self._ex_force_service_name
-
-        return self.service_name
-
-    def get_endpoint(self):
-        """
-        Selects the endpoint to use based on provider specific values,
-        or overrides passed in by the user when setting up the driver.
-
-        :returns: url of the relevant endpoint for the driver
-        """
-        service_type = self.service_type
-        service_name = self.service_name
-        service_region = self.service_region
-
-        if self._ex_force_service_type:
-            service_type = self._ex_force_service_type
-        if self._ex_force_service_name:
-            service_name = self._ex_force_service_name
-        if self._ex_force_service_region:
-            service_region = self._ex_force_service_region
-
-        endpoint = self.service_catalog.get_endpoint(service_type=service_type,
-                                                     name=service_name,
-                                                     region=service_region)
-
-        url = endpoint.url
-
-        if not url:
-            raise LibcloudError('Could not find specified endpoint')
-
-        return url
-
-    def add_default_headers(self, headers):
-        headers['X-Auth-Token'] = self.auth_token
-        headers['Accept'] = self.accept_format
-        return headers
-
-    def morph_action_hook(self, action):
-        self._populate_hosts_and_request_paths()
-        return super(OpenStackBaseConnection, self).morph_action_hook(action)
-
-    def _set_up_connection_info(self, url):
-        result = self._tuple_from_url(url)
-        (self.host, self.port, self.secure, self.request_path) = result
-
-    def _populate_hosts_and_request_paths(self):
-        """
-        OpenStack uses a separate host for API calls which is only provided
-        after an initial authentication request.
-        """
-        osa = self.get_auth_class()
-
-        if self._ex_force_auth_token:
-            # If ex_force_auth_token is provided we always hit the api directly
-            # and never try to authenticate.
-            #
-            # Note: When ex_force_auth_token is provided, ex_force_base_url
-            # must be provided as well.
-            self._set_up_connection_info(url=self._ex_force_base_url)
-            return
-
-        if not osa.is_token_valid():
-            # Token is not available or it has expired. Need to retrieve a
-            # new one.
-            if self._auth_version == '2.0_apikey':
-                kwargs = {'auth_type': 'api_key'}
-            elif self._auth_version == '2.0_password':
-                kwargs = {'auth_type': 'password'}
-            else:
-                kwargs = {}
-
-            osa = osa.authenticate(**kwargs)  # may throw InvalidCreds
-
-            self.auth_token = osa.auth_token
-            self.auth_token_expires = osa.auth_token_expires
-            self.auth_user_info = osa.auth_user_info
-
-            # Pull out and parse the service catalog
-            osc = OpenStackServiceCatalog(service_catalog=osa.urls,
-                                          auth_version=self._auth_version)
-            self.service_catalog = osc
-
-        url = self._ex_force_base_url or self.get_endpoint()
-        self._set_up_connection_info(url=url)
-
-
-class OpenStackException(ProviderError):
-    pass
-
-
-class OpenStackResponse(Response):
-    node_driver = None
-
-    def success(self):
-        i = int(self.status)
-        return i >= 200 and i <= 299
-
-    def has_content_type(self, content_type):
-        content_type_value = self.headers.get('content-type') or ''
-        content_type_value = content_type_value.lower()
-        return content_type_value.find(content_type.lower()) > -1
-
-    def parse_body(self):
-        if self.status == httplib.NO_CONTENT or not self.body:
-            return None
-
-        if self.has_content_type('application/xml'):
-            try:
-                return ET.XML(self.body)
-            except:
-                raise MalformedResponseError(
-                    'Failed to parse XML',
-                    body=self.body,
-                    driver=self.node_driver)
-
-        elif self.has_content_type('application/json'):
-            try:
-                return json.loads(self.body)
-            except:
-                raise MalformedResponseError(
-                    'Failed to parse JSON',
-                    body=self.body,
-                    driver=self.node_driver)
-        else:
-            return self.body
-
-    def parse_error(self):
-        text = None
-        body = self.parse_body()
-
-        if self.has_content_type('application/xml'):
-            text = '; '.join([err.text or '' for err in body.getiterator()
-                              if err.text])
-        elif self.has_content_type('application/json'):
-            values = list(body.values())
-
-            context = self.connection.context
-            driver = self.connection.driver
-            key_pair_name = context.get('key_pair_name', None)
-
-            if len(values) > 0 and values[0]['code'] == 404 and key_pair_name:
-                raise KeyPairDoesNotExistError(name=key_pair_name,
-                                               driver=driver)
-            elif len(values) > 0 and 'message' in values[0]:
-                text = ';'.join([fault_data['message'] for fault_data
-                                 in values])
-            else:
-                text = body
-        else:
-            # while we hope a response is always one of xml or json, we have
-            # seen html or text in the past, its not clear we can really do
-            # something to make it more readable here, so we will just pass
-            # it along as the whole response body in the text variable.
-            text = body
-
-        return '%s %s %s' % (self.status, self.error, text)
-
-
-class OpenStackDriverMixin(object):
-
-    def __init__(self, *args, **kwargs):
-        self._ex_force_base_url = kwargs.get('ex_force_base_url', None)
-        self._ex_force_auth_url = kwargs.get('ex_force_auth_url', None)
-        self._ex_force_auth_version = kwargs.get('ex_force_auth_version', None)
-        self._ex_force_auth_token = kwargs.get('ex_force_auth_token', None)
-        self._ex_tenant_name = kwargs.get('ex_tenant_name', None)
-        self._ex_force_service_type = kwargs.get('ex_force_service_type', None)
-        self._ex_force_service_name = kwargs.get('ex_force_service_name', None)
-        self._ex_force_service_region = kwargs.get('ex_force_service_region',
-                                                   None)
-
-    def openstack_connection_kwargs(self):
-        """
-
-        :rtype: ``dict``
-        """
-        rv = {}
-        if self._ex_force_base_url:
-            rv['ex_force_base_url'] = self._ex_force_base_url
-        if self._ex_force_auth_token:
-            rv['ex_force_auth_token'] = self._ex_force_auth_token
-        if self._ex_force_auth_url:
-            rv['ex_force_auth_url'] = self._ex_force_auth_url
-        if self._ex_force_auth_version:
-            rv['ex_force_auth_version'] = self._ex_force_auth_version
-        if self._ex_tenant_name:
-            rv['ex_tenant_name'] = self._ex_tenant_name
-        if self._ex_force_service_type:
-            rv['ex_force_service_type'] = self._ex_force_service_type
-        if self._ex_force_service_name:
-            rv['ex_force_service_name'] = self._ex_force_service_name
-        if self._ex_force_service_region:
-            rv['ex_force_service_region'] = self._ex_force_service_region
-        return rv


Mime
View raw message