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()
|