def get_plans(self, reference):
"""Get the plans for a given charm.
@param the Reference to a charm.
@return a tuple of plans or an empty tuple if no plans.
@raise ServerError
"""
response = make_request(
'{}charm?charm-url={}'.format(self.url,
'cs:' + reference.path()),
timeout=self.timeout, client=self._client)
try:
return tuple(map(lambda plan: Plan(
url=plan['url'], plan=plan['plan'],
created_on=datetime.datetime.strptime(
plan['created-on'],
"%Y-%m-%dT%H:%M:%SZ"
),
description=plan.get('description'),
price=plan.get('price')), response))
except Exception as err:
log.error(
'cannot process plans: invalid JSON response: {!r}'.format(
response))
raise ServerError(
'unable to get list of plans for {}: {}'.format(
reference.path(), err))
def get_wallet(self, wallet_name):
"""Get a single wallet.
@param the name of the wallet.
@return the wallet's total.
@raise ServerError
"""
response = make_request(
'{}wallet/{}'.format(self.url, wallet_name),
timeout=self.timeout,
client=self._client)
try:
total = response['total']
return {
'credit': response['credit'],
'limit': response['limit'],
'total': WalletTotal(
limit=total['limit'],
budgeted=total['budgeted'],
available=total['available'],
unallocated=total['unallocated'],
usage=total['usage'],
consumed=total['consumed'])
}
except Exception as exc:
log.error(
'cannot get wallet from server: {!r}'.format(exc))
raise ServerError(
'unable to get list of wallets: {!r}'.format(exc))
def create_case(self, name, email, subject, description, businessImpact,
priority, phone):
""" Send a case creation to SalesForces to create a ticket.
@param name of the person creating the case.
@param email of the person creating the case.
@param subject of the case.
@param description of the case.
@param businessImpact of the case.
@param priority of the case.
@param phone of the person creating the case.
@return Nothing if this is ok.
@raise ServerError when something goes wrong.
@raise ValueError when data passed in are invalid
"""
if not ('@' in parseaddr(email)[1]):
raise ValueError('invalid email: {}'.format(email))
if '' == name or name is None:
raise ValueError('empty name')
if '' == subject or subject is None:
raise ValueError('empty subject')
if '' == description or description is None:
raise ValueError('empty description')
if '' == businessImpact or businessImpact is None:
raise ValueError('empty business impact')
if priority is None:
raise ValueError('Ensure the priority is from the set of '
'known priorities')
if '' == phone or phone is None:
raise ValueError('empty phone')
try:
r = requests.post(self.url,
data={
'orgid': self.orgId,
'recordType': self.recordType,
'name': name,
'email': email,
'subject': subject,
'description': description,
self.BUSINESS_IMPACT: businessImpact,
'priority': priority,
'phone': phone,
'external': 1
},
timeout=self.timeout)
r.raise_for_status()
except Timeout:
message = 'Request timed out: {url} timeout: {timeout}'
message = message.format(url=self.url, timeout=self.timeout)
log.error(message)
raise ServerError(message)
except RequestException as err:
log.info('cannot create case: {}'.format(err))
raise ServerError('cannot create case: {}'.format(err))
def list_wallets(self):
"""Get the list of wallets.
@return an dict containing a list of wallets, a total, and available
credit.
@raise ServerError
"""
response = make_request(
'{}wallet'.format(self.url),
timeout=self.timeout,
client=self._client)
try:
total = response['total']
return {
'credit': response['credit'],
'total': WalletTotal(
limit=total['limit'],
budgeted=total['budgeted'],
available=total['available'],
unallocated=total['unallocated'],
usage=total['usage'],
consumed=total['consumed']),
'wallets': tuple(Wallet(
owner=wallet['owner'],
wallet=wallet['wallet'],
limit=wallet['limit'],
budgeted=wallet['budgeted'],
unallocated=wallet['unallocated'],
available=wallet['available'],
consumed=wallet['consumed'],
default='default' in wallet)
for wallet in response['wallets']),
}
except Exception as err:
log.error(
'cannot process wallets: invalid JSON response: {!r}'.format(
response))
raise ServerError(
'unable to get list of wallets: {!r}'.format(err))
def fetch_macaroon(self):
""" Fetches the macaroon from the JIMM controller.
@return The base64 encoded macaroon.
"""
try:
# We don't use make_request b/c we don't want the request to be
# fully handled. This lets us get the macaroon out of the request
# and keep it.
url = "{}model".format(self.url)
response = requests.get(url, timeout=self.timeout)
except requests.exceptions.Timeout:
message = 'Request timed out: {url} timeout: {timeout}'
message = message.format(url=url, timeout=self.timeout)
log.error(message)
return None
except Exception as e:
log.info('Unable to contact JIMM due to: {}'.format(e))
return None
try:
json_response = response.json()
except ValueError:
log.info(
'cannot process macaroon: '
'cannot unmarshal response: {!r}'.format(response.content))
return None
try:
raw_macaroon = json_response['Info']['Macaroon']
except (KeyError, TypeError):
log.info(
'cannot process macaroon: invalid JSON response: {!r}'.format(
json_response))
return None
return json.dumps(raw_macaroon)
def make_request(url,
method='GET',
query=None,
body=None,
auth=None,
timeout=10,
client=None,
macaroons=None):
"""Make a request with the provided data.
@param url The url to make the request to.
@param method The HTTP request method (defaulting to "GET").
@param query A dict of the query key and values.
@param body The optional body as a string or as a JSON decoded dict.
@param auth The optional username and password as a tuple,
not used if client is not None
@param timeout The request timeout in seconds, defaulting to 10 seconds.
@param client (httpbakery.Client) holds a context for making http
requests with macaroons.
@param macaroons Optional JSON serialized, base64 encoded macaroons to be
included in the request header.
POST/PUT request bodies are assumed to be in JSON format.
Return the response content as a JSON decoded object, or an empty dict.
Raise a ServerError if a problem occurs in the request/response process.
Raise a ValueError if invalid parameters are provided.
"""
headers = {}
kwargs = {'timeout': timeout, 'headers': headers}
# Handle the request body.
if body is not None:
if isinstance(body, collections.Mapping):
body = json.dumps(body)
kwargs['data'] = body
# Handle request methods.
if method in ('GET', 'HEAD'):
if query:
url = '{}?{}'.format(url, urlencode(query, True))
elif method in ('DELETE', 'PATCH', 'POST', 'PUT'):
headers['Content-Type'] = 'application/json'
else:
raise ValueError('invalid method {}'.format(method))
if macaroons is not None:
headers['Macaroons'] = macaroons
kwargs['auth'] = auth if client is None else client.auth()
api_method = getattr(requests, method.lower())
# Perform the request.
try:
response = api_method(url, **kwargs)
except requests.exceptions.Timeout:
raise timeout_error(url, timeout)
except Exception as err:
msg = _server_error_message(url, err)
raise ServerError(msg)
# Handle error responses.
try:
response.raise_for_status()
except HTTPError as err:
msg = _server_error_message(url, err.response.text)
raise ServerError(err.response.status_code, msg)
except requests.exceptions.RequestException as err:
msg = _server_error_message(url, err.message)
raise ServerError(msg)
# Some requests just result in a status with no response body.
if not response.content:
return {}
# Assume the response body is a JSON encoded string.
try:
return response.json()
except Exception as err:
msg = 'Error decoding JSON response: {} message: {}'.format(url, err)
log.error(msg)
raise ServerError(msg)
def _server_error_message(url, message):
"""Log and return a server error message."""
msg = _error_message.format(url=url, message=message)
log.error(msg)
return msg
def make_request(
url, method='GET', query=None, body=None, auth=None, macaroons=None,
timeout=10):
"""Make a request with the provided data.
@param url The url to make the request to.
@param method The HTTP request method (defaulting to "GET").
@param query A dict of the query key and values.
@param body The optional body as a string or as a JSON decoded dict.
@param auth The optional username and password as a tuple.
@param timeout The request timeout in seconds, defaulting to 10 seconds.
POST/PUT request bodies are assumed to be in JSON format.
Return the response content as a JSON decoded object, or an empty dict.
Raise a ServerError if a problem occurs in the request/response process.
Raise a ValueError if invalid parameters are provided.
"""
kwargs = {'auth': auth, 'timeout': timeout, 'headers': {}}
# Handle the request body.
if body is not None:
if isinstance(body, collections.Mapping):
body = json.dumps(body)
kwargs['data'] = body
# Handle request methods.
if method in ('GET', 'HEAD'):
if query:
url = '{}?{}'.format(url, urlencode(query, True))
elif method in ('POST', 'PUT'):
kwargs['headers'] = {'Content-Type': 'application/json'}
else:
raise ValueError('invalid method {}'.format(method))
if macaroons is not None:
kwargs['headers']['Bakery-Protocol-Version'] = 1
kwargs['headers']['Macaroons'] = macaroons
api_method = getattr(requests, method.lower())
# Perform the request.
try:
response = api_method(url, **kwargs)
except requests.exceptions.Timeout:
raise timeout_error(url, timeout)
except Exception as err:
msg = _server_error_message(url, err)
raise ServerError(msg)
# Handle error responses.
try:
response.raise_for_status()
except HTTPError as err:
msg = _server_error_message(url, err.response.text)
raise ServerError(err.response.status_code, msg)
except requests.exceptions.RequestException as err:
msg = _server_error_message(url, err.message)
raise ServerError(msg)
# Some requests just result in a status with no response body.
if not response.content:
return {}
# Assume the response body is a JSON encoded string.
try:
return response.json()
except Exception as err:
msg = 'Error decoding JSON response: {} message: {}'.format(url, err)
log.error(msg)
raise ServerError(msg)
def _server_error_message(url, message):
"""Log and return a server error message."""
msg = _error_message.format(url=url, message=message)
log.error(msg)
return msg
