565a6e0a5b
Enable Keystone v3 auth support in the compat client. This is needed for the Trove integration and scenario tests which use the compat client. The Keystone v2 APIs have been removed in the Queens release and this stop-gap fix of putting Keystone v3 support in the compat client is needed to fix the Trove gate. Change-Id: I60ea2188443d8905c03c24607703e69c6490420b
389 lines
14 KiB
Python
389 lines
14 KiB
Python
# Copyright (c) 2011 OpenStack Foundation
|
|
# All Rights Reserved.
|
|
#
|
|
# 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.
|
|
|
|
import httplib2
|
|
import logging
|
|
import os
|
|
import sys
|
|
import time
|
|
|
|
try:
|
|
import json
|
|
except ImportError:
|
|
import simplejson as json
|
|
|
|
|
|
from troveclient.compat import auth
|
|
from troveclient.compat import exceptions
|
|
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
RDC_PP = os.environ.get("RDC_PP", "False") == "True"
|
|
|
|
|
|
expected_errors = (400, 401, 403, 404, 408, 409, 413, 422, 500, 501)
|
|
|
|
|
|
def log_to_streamhandler(stream=None):
|
|
stream = stream or sys.stderr
|
|
ch = logging.StreamHandler(stream)
|
|
LOG.setLevel(logging.DEBUG)
|
|
LOG.addHandler(ch)
|
|
|
|
|
|
if 'REDDWARFCLIENT_DEBUG' in os.environ and os.environ['REDDWARFCLIENT_DEBUG']:
|
|
log_to_streamhandler()
|
|
|
|
|
|
class TroveHTTPClient(httplib2.Http):
|
|
|
|
USER_AGENT = 'python-troveclient'
|
|
|
|
def __init__(self, user, password, tenant, auth_url, service_name,
|
|
service_url=None,
|
|
auth_strategy=None, insecure=False,
|
|
timeout=None, proxy_tenant_id=None,
|
|
proxy_token=None, region_name=None,
|
|
endpoint_type='publicURL', service_type=None,
|
|
timings=False):
|
|
|
|
super(TroveHTTPClient, self).__init__(timeout=timeout)
|
|
|
|
self.username = user
|
|
self.password = password
|
|
self.tenant = tenant
|
|
if auth_url:
|
|
self.auth_url = auth_url.rstrip('/')
|
|
else:
|
|
self.auth_url = None
|
|
self.region_name = region_name
|
|
self.endpoint_type = endpoint_type
|
|
self.service_url = service_url
|
|
self.service_type = service_type
|
|
self.service_name = service_name
|
|
self.timings = timings
|
|
|
|
self.times = [] # [("item", starttime, endtime), ...]
|
|
|
|
self.auth_token = None
|
|
self.proxy_token = proxy_token
|
|
self.proxy_tenant_id = proxy_tenant_id
|
|
|
|
# httplib2 overrides
|
|
self.force_exception_to_status_code = True
|
|
self.disable_ssl_certificate_validation = insecure
|
|
|
|
auth_cls = auth.get_authenticator_cls(auth_strategy)
|
|
|
|
self.authenticator = auth_cls(self, auth_strategy,
|
|
self.auth_url, self.username,
|
|
self.password, self.tenant,
|
|
region=region_name,
|
|
service_type=service_type,
|
|
service_name=service_name,
|
|
service_url=service_url)
|
|
if hasattr(self.authenticator, 'auth'):
|
|
self.auth = self.authenticator.auth
|
|
|
|
def get_timings(self):
|
|
return self.times
|
|
|
|
def http_log(self, args, kwargs, resp, body):
|
|
if not RDC_PP:
|
|
self.simple_log(args, kwargs, resp, body)
|
|
else:
|
|
self.pretty_log(args, kwargs, resp, body)
|
|
|
|
def simple_log(self, args, kwargs, resp, body):
|
|
if not LOG.isEnabledFor(logging.DEBUG):
|
|
return
|
|
|
|
string_parts = ['curl -i']
|
|
for element in args:
|
|
if element in ('GET', 'POST'):
|
|
string_parts.append(' -X %s' % element)
|
|
else:
|
|
string_parts.append(' %s' % element)
|
|
|
|
for element in kwargs['headers']:
|
|
header = ' -H "%s: %s"' % (element, kwargs['headers'][element])
|
|
string_parts.append(header)
|
|
|
|
LOG.debug("REQ: %s\n", "".join(string_parts))
|
|
if 'body' in kwargs:
|
|
LOG.debug("REQ BODY: %s\n", kwargs['body'])
|
|
LOG.debug("RESP:%s %s\n", resp, body)
|
|
|
|
def pretty_log(self, args, kwargs, resp, body):
|
|
if not LOG.isEnabledFor(logging.DEBUG):
|
|
return
|
|
|
|
string_parts = ['curl -i']
|
|
for element in args:
|
|
if element in ('GET', 'POST'):
|
|
string_parts.append(' -X %s' % element)
|
|
else:
|
|
string_parts.append(' %s' % element)
|
|
|
|
for element in kwargs['headers']:
|
|
header = ' -H "%s: %s"' % (element, kwargs['headers'][element])
|
|
string_parts.append(header)
|
|
|
|
curl_cmd = "".join(string_parts)
|
|
LOG.debug("REQUEST:")
|
|
if 'body' in kwargs:
|
|
LOG.debug("%s -d '%s'", curl_cmd, kwargs['body'])
|
|
try:
|
|
req_body = json.dumps(json.loads(kwargs['body']),
|
|
sort_keys=True, indent=4)
|
|
except Exception:
|
|
req_body = kwargs['body']
|
|
LOG.debug("BODY: %s\n", req_body)
|
|
else:
|
|
LOG.debug(curl_cmd)
|
|
|
|
try:
|
|
resp_body = json.dumps(json.loads(body), sort_keys=True, indent=4)
|
|
except Exception:
|
|
resp_body = body
|
|
LOG.debug("RESPONSE HEADERS: %s", resp)
|
|
LOG.debug("RESPONSE BODY : %s", resp_body)
|
|
|
|
def request(self, *args, **kwargs):
|
|
kwargs.setdefault('headers', kwargs.get('headers', {}))
|
|
kwargs['headers']['User-Agent'] = self.USER_AGENT
|
|
self.morph_request(kwargs)
|
|
|
|
resp, body = super(TroveHTTPClient, self).request(*args, **kwargs)
|
|
# compat between requests and httplib2
|
|
resp.status_code = resp.status
|
|
|
|
# Save this in case anyone wants it.
|
|
self.last_response = (resp, body)
|
|
self.http_log(args, kwargs, resp, body)
|
|
|
|
if body:
|
|
try:
|
|
body = self.morph_response_body(body)
|
|
except exceptions.ResponseFormatError:
|
|
# Acceptable only if the response status is an error code.
|
|
# Otherwise its the API or client misbehaving.
|
|
self.raise_error_from_status(resp, None)
|
|
raise # Not accepted!
|
|
else:
|
|
body = None
|
|
|
|
if resp.status in expected_errors:
|
|
raise exceptions.from_response(resp, body)
|
|
|
|
return resp, body
|
|
|
|
def raise_error_from_status(self, resp, body):
|
|
if resp.status in expected_errors:
|
|
raise exceptions.from_response(resp, body)
|
|
|
|
def morph_request(self, kwargs):
|
|
kwargs['headers']['Accept'] = 'application/json'
|
|
kwargs['headers']['Content-Type'] = 'application/json'
|
|
if 'body' in kwargs:
|
|
kwargs['body'] = json.dumps(kwargs['body'])
|
|
|
|
def morph_response_body(self, body_string):
|
|
try:
|
|
return json.loads(body_string)
|
|
except ValueError:
|
|
raise exceptions.ResponseFormatError()
|
|
|
|
def _time_request(self, url, method, **kwargs):
|
|
start_time = time.time()
|
|
resp, body = self.request(url, method, **kwargs)
|
|
self.times.append(("%s %s" % (method, url),
|
|
start_time, time.time()))
|
|
return resp, body
|
|
|
|
def _cs_request(self, url, method, **kwargs):
|
|
def request():
|
|
kwargs.setdefault('headers', {})['X-Auth-Token'] = self.auth_token
|
|
if self.tenant:
|
|
kwargs['headers']['X-Auth-Project-Id'] = self.tenant
|
|
|
|
resp, body = self._time_request(self.service_url + url, method,
|
|
**kwargs)
|
|
return resp, body
|
|
|
|
if not self.auth_token or not self.service_url:
|
|
self.authenticate()
|
|
|
|
# Perform the request once. If we get a 401 back then it
|
|
# might be because the auth token expired, so try to
|
|
# re-authenticate and try again. If it still fails, bail.
|
|
try:
|
|
return request()
|
|
except exceptions.Unauthorized:
|
|
self.authenticate()
|
|
return request()
|
|
|
|
def get(self, url, **kwargs):
|
|
return self._cs_request(url, 'GET', **kwargs)
|
|
|
|
def patch(self, url, **kwargs):
|
|
return self._cs_request(url, 'PATCH', **kwargs)
|
|
|
|
def post(self, url, **kwargs):
|
|
return self._cs_request(url, 'POST', **kwargs)
|
|
|
|
def put(self, url, **kwargs):
|
|
return self._cs_request(url, 'PUT', **kwargs)
|
|
|
|
def delete(self, url, **kwargs):
|
|
return self._cs_request(url, 'DELETE', **kwargs)
|
|
|
|
def authenticate(self):
|
|
"""Auths the client and gets a token. May optionally set a service url.
|
|
|
|
The client will get auth errors until the authentication step
|
|
occurs. Additionally, if a service_url was not explicitly given in
|
|
the clients __init__ method, one will be obtained from the auth
|
|
service.
|
|
|
|
"""
|
|
catalog = self.authenticator.authenticate()
|
|
if self.service_url:
|
|
possible_service_url = None
|
|
else:
|
|
if self.endpoint_type == "publicURL":
|
|
possible_service_url = catalog.get_public_url()
|
|
elif self.endpoint_type == "adminURL":
|
|
possible_service_url = catalog.get_management_url()
|
|
self.authenticate_with_token(catalog.get_token(), possible_service_url)
|
|
|
|
def authenticate_with_token(self, token, service_url=None):
|
|
self.auth_token = token
|
|
if not self.service_url:
|
|
if not service_url:
|
|
raise exceptions.ServiceUrlNotGiven()
|
|
else:
|
|
self.service_url = service_url
|
|
|
|
|
|
class Dbaas(object):
|
|
"""Top-level object to access the Rackspace Database as a Service API.
|
|
|
|
Create an instance with your creds::
|
|
|
|
>> red = Dbaas(USERNAME, API_KEY, TENANT, AUTH_URL, SERVICE_NAME, \
|
|
SERVICE_URL)
|
|
|
|
Then call methods on its managers::
|
|
|
|
>> red.instances.list()
|
|
...
|
|
>> red.flavors.list()
|
|
...
|
|
|
|
&c.
|
|
"""
|
|
|
|
def __init__(self, username, api_key, tenant=None, auth_url=None,
|
|
service_type='database', service_name=None,
|
|
service_url=None, insecure=False, auth_strategy='keystone',
|
|
region_name=None, client_cls=TroveHTTPClient):
|
|
|
|
from troveclient.compat import versions
|
|
from troveclient.v1 import accounts
|
|
from troveclient.v1 import backups
|
|
from troveclient.v1 import clusters
|
|
from troveclient.v1 import configurations
|
|
from troveclient.v1 import databases
|
|
from troveclient.v1 import datastores
|
|
from troveclient.v1 import diagnostics
|
|
from troveclient.v1 import flavors
|
|
from troveclient.v1 import hosts
|
|
from troveclient.v1 import instances
|
|
from troveclient.v1 import limits
|
|
from troveclient.v1 import management
|
|
from troveclient.v1 import metadata
|
|
from troveclient.v1 import modules
|
|
from troveclient.v1 import quota
|
|
from troveclient.v1 import root
|
|
from troveclient.v1 import security_groups
|
|
from troveclient.v1 import storage
|
|
from troveclient.v1 import users
|
|
|
|
self.client = client_cls(username, api_key, tenant, auth_url,
|
|
service_type=service_type,
|
|
service_name=service_name,
|
|
service_url=service_url,
|
|
insecure=insecure,
|
|
auth_strategy=auth_strategy,
|
|
region_name=region_name)
|
|
self.versions = versions.Versions(self)
|
|
self.databases = databases.Databases(self)
|
|
self.flavors = flavors.Flavors(self)
|
|
self.instances = instances.Instances(self)
|
|
self.limits = limits.Limits(self)
|
|
self.users = users.Users(self)
|
|
self.root = root.Root(self)
|
|
self.hosts = hosts.Hosts(self)
|
|
self.quota = quota.Quotas(self)
|
|
self.backups = backups.Backups(self)
|
|
self.clusters = clusters.Clusters(self)
|
|
self.security_groups = security_groups.SecurityGroups(self)
|
|
self.security_group_rules = security_groups.SecurityGroupRules(self)
|
|
self.datastores = datastores.Datastores(self)
|
|
self.datastore_versions = datastores.DatastoreVersions(self)
|
|
self.datastore_version_members = (datastores.
|
|
DatastoreVersionMembers(self))
|
|
self.storage = storage.StorageInfo(self)
|
|
self.management = management.Management(self)
|
|
self.mgmt_cluster = management.MgmtClusters(self)
|
|
self.mgmt_flavor = management.MgmtFlavors(self)
|
|
self.accounts = accounts.Accounts(self)
|
|
self.diagnostics = diagnostics.DiagnosticsInterrogator(self)
|
|
self.hwinfo = diagnostics.HwInfoInterrogator(self)
|
|
self.configurations = configurations.Configurations(self)
|
|
config_parameters = configurations.ConfigurationParameters(self)
|
|
self.configuration_parameters = config_parameters
|
|
self.metadata = metadata.Metadata(self)
|
|
self.modules = modules.Modules(self)
|
|
self.mgmt_configs = management.MgmtConfigurationParameters(self)
|
|
self.mgmt_datastore_versions = management.MgmtDatastoreVersions(self)
|
|
|
|
class Mgmt(object):
|
|
def __init__(self, dbaas):
|
|
self.instances = dbaas.management
|
|
self.hosts = dbaas.hosts
|
|
self.accounts = dbaas.accounts
|
|
self.storage = dbaas.storage
|
|
self.datastore_version = dbaas.mgmt_datastore_versions
|
|
|
|
self.mgmt = Mgmt(self)
|
|
|
|
def set_management_url(self, url):
|
|
self.client.management_url = url
|
|
|
|
def get_timings(self):
|
|
return self.client.get_timings()
|
|
|
|
def authenticate(self):
|
|
"""Authenticate against the server.
|
|
|
|
This is called to perform an authentication to retrieve a token.
|
|
|
|
Returns on success; raises :exc:`exceptions.Unauthorized` if the
|
|
credentials are wrong.
|
|
"""
|
|
self.client.authenticate()
|