Removing unused files with new client

fixes bug 1243452
Change-Id: Ia51e6d48e486baa818ebe3108d37bb1de537702d

troveclient/auth.py

@@ -1,255 +0,0 @@
-#    Copyright 2012 OpenStack Foundation
-#
-#    Licensed 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 __future__ import print_function
-from troveclient import exceptions
-
-import six
-
-
-def get_authenticator_cls(cls_or_name):
-    """Factory method to retrieve Authenticator class."""
-    if isinstance(cls_or_name, type):
-        return cls_or_name
-    elif isinstance(cls_or_name, six.string_types):
-        if cls_or_name == "keystone":
-            return KeyStoneV2Authenticator
-        elif cls_or_name == "rax":
-            return RaxAuthenticator
-        elif cls_or_name == "auth1.1":
-            return Auth1_1
-        elif cls_or_name == "fake":
-            return FakeAuth
-
-    raise ValueError("Could not determine authenticator class from the given "
-                     "value %r." % cls_or_name)
-
-
-class Authenticator(object):
-    """
-    Helper class to perform Keystone or other miscellaneous authentication.
-
-    The "authenticate" method returns a ServiceCatalog, which can be used
-    to obtain a token.
-
-    """
-
-    URL_REQUIRED = True
-
-    def __init__(self, client, type, url, username, password, tenant,
-                 region=None, service_type=None, service_name=None,
-                 service_url=None):
-        self.client = client
-        self.type = type
-        self.url = url
-        self.username = username
-        self.password = password
-        self.tenant = tenant
-        self.region = region
-        self.service_type = service_type
-        self.service_name = service_name
-        self.service_url = service_url
-
-    def _authenticate(self, url, body, root_key='access'):
-        """Authenticate and extract the service catalog."""
-        # Make sure we follow redirects when trying to reach Keystone
-        tmp_follow_all_redirects = self.client.follow_all_redirects
-        self.client.follow_all_redirects = True
-
-        try:
-            resp, body = self.client._time_request(url, "POST", body=body)
-        finally:
-            self.client.follow_all_redirects = tmp_follow_all_redirects
-
-        if resp.status == 200:  # content must always present
-            try:
-                return ServiceCatalog(body, region=self.region,
-                                      service_type=self.service_type,
-                                      service_name=self.service_name,
-                                      service_url=self.service_url,
-                                      root_key=root_key)
-            except exceptions.AmbiguousEndpoints:
-                print("Found more than one valid endpoint. Use a more "
-                      "restrictive filter")
-                raise
-            except KeyError:
-                raise exceptions.AuthorizationFailure()
-            except exceptions.EndpointNotFound:
-                print("Could not find any suitable endpoint. Correct region?")
-                raise
-
-        elif resp.status == 305:
-            return resp['location']
-        else:
-            raise exceptions.from_response(resp, body)
-
-    def authenticate(self):
-        raise NotImplementedError("Missing authenticate method.")
-
-
-class KeyStoneV2Authenticator(Authenticator):
-    def authenticate(self):
-        if self.url is None:
-            raise exceptions.AuthUrlNotGiven()
-        return self._v2_auth(self.url)
-
-    def _v2_auth(self, url):
-        """Authenticate against a v2.0 auth service."""
-        body = {"auth": {
-            "passwordCredentials": {
-                "username": self.username,
-                "password": self.password}
-        }
-        }
-
-        if self.tenant:
-            body['auth']['tenantName'] = self.tenant
-
-        return self._authenticate(url, body)
-
-
-class Auth1_1(Authenticator):
-    def authenticate(self):
-        """Authenticate against a v2.0 auth service."""
-        if self.url is None:
-            raise exceptions.AuthUrlNotGiven()
-        auth_url = self.url
-        body = {
-            "credentials": {
-                "username": self.username,
-                "key": self.password
-            }}
-        return self._authenticate(auth_url, body, root_key='auth')
-
-
-class RaxAuthenticator(Authenticator):
-    def authenticate(self):
-        if self.url is None:
-            raise exceptions.AuthUrlNotGiven()
-        return self._rax_auth(self.url)
-
-    def _rax_auth(self, url):
-        """Authenticate against the Rackspace auth service."""
-        body = {'auth': {
-            'RAX-KSKEY:apiKeyCredentials': {
-                'username': self.username,
-                'apiKey': self.password,
-                'tenantName': self.tenant}
-        }
-        }
-
-        return self._authenticate(self.url, body)
-
-
-class FakeAuth(Authenticator):
-    """Useful for faking auth."""
-
-    def authenticate(self):
-        class FakeCatalog(object):
-            def __init__(self, auth):
-                self.auth = auth
-
-            def get_public_url(self):
-                return "%s/%s" % ('http://localhost:8779/v1.0',
-                                  self.auth.tenant)
-
-            def get_token(self):
-                return self.auth.tenant
-
-        return FakeCatalog(self)
-
-
-class ServiceCatalog(object):
-    """Represents a Keystone Service Catalog which describes a service.
-
-    This class has methods to obtain a valid token as well as a public service
-    url and a management url.
-
-    """
-
-    def __init__(self, resource_dict, region=None, service_type=None,
-                 service_name=None, service_url=None, root_key='access'):
-        self.catalog = resource_dict
-        self.region = region
-        self.service_type = service_type
-        self.service_name = service_name
-        self.service_url = service_url
-        self.management_url = None
-        self.public_url = None
-        self.root_key = root_key
-        self._load()
-
-    def _load(self):
-        if not self.service_url:
-            self.public_url = self._url_for(attr='region',
-                                            filter_value=self.region,
-                                            endpoint_type="publicURL")
-            self.management_url = self._url_for(attr='region',
-                                                filter_value=self.region,
-                                                endpoint_type="adminURL")
-        else:
-            self.public_url = self.service_url
-            self.management_url = self.service_url
-
-    def get_token(self):
-        return self.catalog[self.root_key]['token']['id']
-
-    def get_management_url(self):
-        return self.management_url
-
-    def get_public_url(self):
-        return self.public_url
-
-    def _url_for(self, attr=None, filter_value=None,
-                 endpoint_type='publicURL'):
-        """
-        Fetch the public URL from the Trove service for a particular
-        endpoint attribute. If none given, return the first.
-        """
-        matching_endpoints = []
-        if 'endpoints' in self.catalog:
-            # We have a bastardized service catalog. Treat it special. :/
-            for endpoint in self.catalog['endpoints']:
-                if not filter_value or endpoint[attr] == filter_value:
-                    matching_endpoints.append(endpoint)
-            if not matching_endpoints:
-                raise exceptions.EndpointNotFound()
-
-        # We don't always get a service catalog back ...
-        if 'serviceCatalog' not in self.catalog[self.root_key]:
-            raise exceptions.EndpointNotFound()
-
-        # Full catalog ...
-        catalog = self.catalog[self.root_key]['serviceCatalog']
-
-        for service in catalog:
-            if service.get("type") != self.service_type:
-                continue
-
-            if (self.service_name and self.service_type == 'database' and
-                    service.get('name') != self.service_name):
-                continue
-
-            endpoints = service['endpoints']
-            for endpoint in endpoints:
-                if not filter_value or endpoint.get(attr) == filter_value:
-                    endpoint["serviceName"] = service.get("name")
-                    matching_endpoints.append(endpoint)
-
-        if not matching_endpoints:
-            raise exceptions.EndpointNotFound()
-        elif len(matching_endpoints) > 1:
-            raise exceptions.AmbiguousEndpoints(endpoints=matching_endpoints)
-        else:
-            return matching_endpoints[0].get(endpoint_type, None)

troveclient/compat/auth.py

@@ -13,6 +13,7 @@
 #    under the License.
 
 from __future__ import print_function
+from six import string_types
 from troveclient.compat import exceptions
 
 
@@ -20,7 +21,7 @@ def get_authenticator_cls(cls_or_name):
     """Factory method to retrieve Authenticator class."""
     if isinstance(cls_or_name, type):
         return cls_or_name
-    elif isinstance(cls_or_name, basestring):
+    elif isinstance(cls_or_name, string_types):
         if cls_or_name == "keystone":
             return KeyStoneV2Authenticator
         elif cls_or_name == "rax":

troveclient/compat/tests/test_auth.py

@@ -18,10 +18,10 @@
 #    under the License.
 
 from testtools import TestCase
-from troveclient import auth
+from troveclient.compat import auth
 from mock import Mock
 
-from troveclient import exceptions
+from troveclient.compat import exceptions
 
 """
 Unit tests for the classes and functions in auth.py.

troveclient/xml.py

@@ -1,292 +0,0 @@
-from lxml import etree
-from numbers import Number
-
-from troveclient import exceptions
-from troveclient.client import TroveHTTPClient
-
-XML_NS = {None: "http://docs.openstack.org/database/api/v1.0"}
-
-# If XML element is listed here then this searches through the ancestors.
-LISTIFY = {
-    "accounts": [[]],
-    "databases": [[]],
-    "flavors": [[]],
-    "instances": [[]],
-    "links": [[]],
-    "hosts": [[]],
-    "devices": [[]],
-    "users": [[]],
-    "versions": [[]],
-    "attachments": [[]],
-    "limits": [[]],
-    "security_groups": [[]],
-    "backups": [[]]
-}
-
-
-class IntDict(object):
-    pass
-
-
-TYPE_MAP = {
-    "instance": {
-        "volume": {
-            "used": float,
-            "size": int,
-        },
-        "deleted": bool,
-        "server": {
-            "local_id": int,
-            "deleted": bool,
-        },
-    },
-    "instances": {
-        "deleted": bool,
-    },
-    "deleted": bool,
-    "flavor": {
-        "ram": int,
-    },
-    "diagnostics": {
-        "vmHwm": int,
-        "vmPeak": int,
-        "vmSize": int,
-        "threads": int,
-        "vmRss": int,
-        "fdSize": int,
-    },
-    "security_group_rule": {
-        "from_port": int,
-        "to_port": int,
-    },
-    "quotas": IntDict,
-}
-TYPE_MAP["flavors"] = TYPE_MAP["flavor"]
-
-REQUEST_AS_LIST = set(['databases', 'users'])
-
-
-def element_ancestors_match_list(element, list):
-    """
-    For element root at <foo><blah><root></blah></foo> matches against
-    list ["blah", "foo"].
-    """
-    itr_elem = element.getparent()
-    for name in list:
-        if itr_elem is None:
-            break
-        if name != normalize_tag(itr_elem):
-            return False
-        itr_elem = itr_elem.getparent()
-    return True
-
-
-def element_must_be_list(parent_element, name):
-    """Determines if an element to be created should be a dict or list."""
-    if name in LISTIFY:
-        list_of_lists = LISTIFY[name]
-        for tag_list in list_of_lists:
-            if element_ancestors_match_list(parent_element, tag_list):
-                return True
-    return False
-
-
-def element_to_json(name, element):
-    if element_must_be_list(element, name):
-        return element_to_list(element)
-    else:
-        return element_to_dict(element)
-
-
-def root_element_to_json(name, element):
-    """Returns a tuple of the root JSON value, plus the links if found."""
-    if name == "rootEnabled":  # Why oh why were we inconsistent here? :'(
-        if element.text.strip() == "False":
-            return False, None
-        elif element.text.strip() == "True":
-            return True, None
-    if element_must_be_list(element, name):
-        return element_to_list(element, True)
-    else:
-        return element_to_dict(element), None
-
-
-def element_to_list(element, check_for_links=False):
-    """
-    For element "foo" in <foos><foo/><foo/></foos>
-    Returns [{}, {}]
-    """
-    links = None
-    result = []
-    for child_element in element:
-        # The "links" element gets jammed into the root element.
-        if check_for_links and normalize_tag(child_element) == "links":
-            links = element_to_list(child_element)
-        else:
-            result.append(element_to_dict(child_element))
-    if check_for_links:
-        return result, links
-    else:
-        return result
-
-
-def element_to_dict(element):
-    result = {}
-    for name, value in element.items():
-        result[name] = value
-    for child_element in element:
-        name = normalize_tag(child_element)
-        result[name] = element_to_json(name, child_element)
-    if len(result) == 0 and element.text:
-        string_value = element.text.strip()
-        if len(string_value):
-            if string_value == 'None':
-                return None
-            return string_value
-    return result
-
-
-def standardize_json_lists(json_dict):
-    """
-    In XML, we might see something like {'instances':{'instances':[...]}},
-    which we must change to just {'instances':[...]} to be compatable with
-    the true JSON format.
-
-    If any items are dictionaries with only one item which is a list,
-    simply remove the dictionary and insert its list directly.
-    """
-    found_items = []
-    for key, value in json_dict.items():
-        value = json_dict[key]
-        if isinstance(value, dict):
-            if len(value) == 1 and isinstance(value.values()[0], list):
-                found_items.append(key)
-            else:
-                standardize_json_lists(value)
-    for key in found_items:
-        json_dict[key] = json_dict[key].values()[0]
-
-
-def normalize_tag(elem):
-    """Given an element, returns the tag minus the XMLNS junk.
-
-    IOW, .tag may sometimes return the XML namespace at the start of the
-    string. This gets rids of that.
-    """
-    try:
-        prefix = "{" + elem.nsmap[None] + "}"
-        if elem.tag.startswith(prefix):
-            return elem.tag[len(prefix):]
-    except KeyError:
-        pass
-    return elem.tag
-
-
-def create_root_xml_element(name, value):
-    """Create the first element using a name and a dictionary."""
-    element = etree.Element(name, nsmap=XML_NS)
-    if name in REQUEST_AS_LIST:
-        add_subelements_from_list(element, name, value)
-    else:
-        populate_element_from_dict(element, value)
-    return element
-
-
-def create_subelement(parent_element, name, value):
-    """Attaches a new element onto the parent element."""
-    if isinstance(value, dict):
-        create_subelement_from_dict(parent_element, name, value)
-    elif isinstance(value, list):
-        create_subelement_from_list(parent_element, name, value)
-    else:
-        raise TypeError("Can't handle type %s." % type(value))
-
-
-def create_subelement_from_dict(parent_element, name, dict):
-    element = etree.SubElement(parent_element, name)
-    populate_element_from_dict(element, dict)
-
-
-def create_subelement_from_list(parent_element, name, list):
-    element = etree.SubElement(parent_element, name)
-    add_subelements_from_list(element, name, list)
-
-
-def add_subelements_from_list(element, name, list):
-    if name.endswith("s"):
-        item_name = name[:len(name) - 1]
-    else:
-        item_name = name
-    for item in list:
-        create_subelement(element, item_name, item)
-
-
-def populate_element_from_dict(element, dict):
-    for key, value in dict.items():
-        if isinstance(value, basestring):
-            element.set(key, value)
-        elif isinstance(value, Number):
-            element.set(key, str(value))
-        elif isinstance(value, None.__class__):
-            element.set(key, '')
-        else:
-            create_subelement(element, key, value)
-
-
-def modify_response_types(value, type_translator):
-    """
-    This will convert some string in response dictionary to ints or bool
-    so that our respose is compatiable with code expecting JSON style responses
-    """
-    if isinstance(value, str):
-        if value == 'True':
-            return True
-        elif value == 'False':
-            return False
-        else:
-            return type_translator(value)
-    elif isinstance(value, dict):
-        for k, v in value.iteritems():
-            if type_translator is not IntDict:
-                if v.__class__ is dict and v.__len__() == 0:
-                    value[k] = None
-                elif k in type_translator:
-                    value[k] = modify_response_types(value[k],
-                                                     type_translator[k])
-            else:
-                value[k] = int(value[k])
-        return value
-    elif isinstance(value, list):
-        return [modify_response_types(element, type_translator)
-                for element in value]
-
-
-class TroveXmlClient(TroveHTTPClient):
-
-    @classmethod
-    def morph_request(self, kwargs):
-        kwargs['headers']['Accept'] = 'application/xml'
-        kwargs['headers']['Content-Type'] = 'application/xml'
-        if 'body' in kwargs:
-            body = kwargs['body']
-            root_name = body.keys()[0]
-            xml = create_root_xml_element(root_name, body[root_name])
-            xml_string = etree.tostring(xml, pretty_print=True)
-            kwargs['body'] = xml_string
-
-    @classmethod
-    def morph_response_body(self, body_string):
-        # The root XML element always becomes a dictionary with a single
-        # field, which has the same key as the elements name.
-        result = {}
-        try:
-            root_element = etree.XML(body_string)
-        except etree.XMLSyntaxError:
-            raise exceptions.ResponseFormatError()
-        root_name = normalize_tag(root_element)
-        root_value, links = root_element_to_json(root_name, root_element)
-        result = {root_name: root_value}
-        if links:
-            result['links'] = links
-        modify_response_types(result, TYPE_MAP)
-        return result