def get(self):
health_controller = self._driver.manager.health_controller
health_map, is_alive = health_controller.ping_check()
if is_alive:
return pecan.Response(None, 204)
else:
return pecan.Response(None, 503)
def _get_err(error_type, op_name, err_msg=""):
"""
This function is for Raising Exception for REST API.
It has 2 error_type:
- raise: Used when REST API is exposed as wsme_pecan.wsexpose
- json: Used when REST API is exposed as pecan.expose('json')
"""
if not err_msg:
err_msg = "{} Operation is already in progress. Please try " \
"after sometime.".format(op_name)
logging.error(err_msg)
if error_type == "raise":
restapi_exception = exception.RestApiException()
restapi_exception.message = err_msg
restapi_exception.code = 409
raise restapi_exception
else:
error_json = {
"debuginfo": "",
"faultcode": "Client",
"faultstring": err_msg
}
return pecan.Response(json.dumps(error_json),
409,
content_type='application/json')
def get(self, service_id):
'''Get Analytics By Domain Data'''
call_args = getattr(pecan.request.context, "call_args")
domain = call_args.pop('domain')
analytics_controller = \
self._driver.manager.analytics_controller
try:
res = analytics_controller.get_metrics_by_domain(
self.project_id, domain, **call_args)
except errors.ServiceNotFound:
return pecan.Response(status=404)
except Exception:
return pecan.Response(status=500)
else:
return pecan.Response(json_body=res, status=200)
def forwarder(self, *remainder, **kwargs):
""" Forward any requests that don't have a specific match """
# TODO(xiaohhui): Add validator for vim_id.
vim_id = remainder[0]
request = pecan.request
try:
vim_url = syscomm.getMultivimDriver(vim_id, full_path=request.path)
# NOTE: Not sure headers should be set here. According to original
# code, headers are discarded.
retcode, content, status_code, resp = restcall.req_by_msb(
vim_url, request.method, content=request.body)
except exceptions.NotFound as e:
pecan.abort(404, detail=str(e))
except Exception as e:
pecan.abort(500, detail=str(e))
if retcode:
# Execptions are handled within req_by_msb
logger.error("Status code is %s, detail is %s.", status_code,
content)
response = pecan.Response(body=content, status=status_code)
if retcode == 0:
for k in syscomm.getHeadersKeys(resp):
response.headers[k] = resp[k]
return response
def patch_one(self, service_id):
service_updates = json.loads(pecan.request.body.decode('utf-8'))
services_controller = self._driver.manager.services_controller
try:
services_controller.update(self.project_id, service_id,
self.auth_token, service_updates)
except exceptions.ValidationFailed as e:
pecan.abort(400, detail=u'{0}'.format(e))
except LookupError as e: # error handler for no flavor
pecan.abort(400, detail=str(e))
except ValueError as e: # error handler for existing service name
pecan.abort(400, detail=str(e))
except errors.ServiceNotFound as e:
pecan.abort(404, detail=str(e))
except errors.ServiceStatusNeitherDeployedNorFailed as e:
pecan.abort(400, detail=str(e))
except errors.SharedShardsExhausted as e:
# domain - shared domains exhausted
pecan.abort(400, detail=str(e))
except Exception as e:
pecan.abort(400, detail=util.help_escape(str(e)))
service_url = str(
uri.encode(u'{0}/v1.0/services/{1}'.format(pecan.request.host_url,
service_id)))
return pecan.Response(None, 202, headers={"Location": service_url})
def post(self):
request_json = json.loads(pecan.request.body.decode('utf-8'))
project_id = request_json.get('project_id', None)
service_id = request_json.get('service_id', None)
domain_name = request_json.get('domain_name', None)
new_cert = request_json.get('new_cert', None)
cert_status = request_json.get('cert_status', 'deployed')
if not helpers.is_valid_domain_name(domain_name):
pecan.abort(400,
detail='Domain {0} is not valid'.format(domain_name))
# Akamai specific suffix:
if not new_cert.endswith("edgekey.net"):
new_cert = new_cert + ".edgekey.net"
try:
self._driver.manager.services_controller.migrate_domain(
project_id, service_id, domain_name, new_cert, cert_status)
except errors.ServiceNotFound:
pecan.abort(
404,
detail='Service {0} could not be found'.format(service_id))
except (LookupError, ValueError):
pecan.abort(
404,
detail='Domain {0} could not be found'.format(domain_name))
return pecan.Response(None, 202)
def get(self):
services_controller = self._driver.manager.services_controller
call_args = getattr(pecan.request.context, "call_args")
status = call_args.pop('status')
service_projectids = services_controller.get_services_by_status(status)
return pecan.Response(json_body=service_projectids, status=200)
def post(self):
"""Rerun retry-list mod-san requests."""
try:
self._driver.manager.ssl_certificate_controller.\
rerun_san_retry_list()
except Exception as e:
pecan.abort(404, str(e))
return pecan.Response(None, 202)
def get(self):
services_controller = self._driver.manager.services_controller
call_args = getattr(pecan.request.context, "call_args")
provider_url = call_args.pop('provider_url')
domains = services_controller.get_domains_by_provider_url(provider_url)
return pecan.Response(json_body=domains, status=200)
def get(self):
ssl_certificate_controller = (
self._driver.manager.ssl_certificate_controller)
call_args = getattr(pecan.request.context, "call_args")
status = call_args.pop('status')
cert_domains = ssl_certificate_controller.get_certs_by_status(status)
return pecan.Response(json_body=cert_domains, status=200)
def delete(self, service_id):
services_controller = self._driver.manager.services_controller
try:
services_controller.delete(self.project_id, service_id)
except LookupError as e:
pecan.abort(404, detail=str(e))
except ValueError as e:
pecan.abort(404, detail=str(e))
return pecan.Response(None, 202)
def post(self):
request_json = json.loads(pecan.request.body.decode('utf-8'))
job_type = request_json.pop('job_type')
try:
self._driver.manager.background_job_controller.post_job(
job_type, request_json)
except ValueError as e:
pecan.abort(400, str(e))
except NotImplementedError as e:
pecan.abort(400, str(e))
return pecan.Response(None, 202)
def post(self):
"""Rerun retry-list mod-san requests."""
sent, ignored = None, None
try:
sent, ignored = self._driver.manager.ssl_certificate_controller.\
rerun_san_retry_list()
except Exception as e:
pecan.abort(404, str(e))
return pecan.Response(json_body={
"processing": sent,
"failed_validation": ignored
},
status=202)
def delete(self, domain_name):
# For now we only support 'san' cert type
cert_type = pecan.request.GET.get('cert_type', 'san')
certificate_controller = \
self._driver.manager.ssl_certificate_controller
try:
certificate_controller.delete_ssl_certificate(
self.project_id, domain_name, cert_type
)
except ValueError as e:
pecan.abort(400, detail='Delete ssl certificate failed. '
'Reason: %s' % str(e))
return pecan.Response(None, 202)
def put(self, project_id):
service_state_json = json.loads(pecan.request.body.decode('utf-8'))
project_limit = service_state_json.get('limit', None)
services_controller = self._driver.manager.services_controller
try:
services_controller.services_limit(project_id, project_limit)
except Exception as e:
pecan.abort(404,
detail=('Services limit {0} on tenant: {1} failed, '
'Reason: {2}'.format(project_limit, project_id,
str(e))))
return pecan.Response(None, 201)
def patch_one(self, domain_name):
ssl_certificate_controller = (
self._driver.manager.ssl_certificate_controller)
certificate_updates = json.loads(pecan.request.body.decode('utf-8'))[0]
try:
ssl_certificate_controller.update_certificate_status(
domain_name, certificate_updates)
except ValueError:
pecan.abort(
status_code=404,
detail='Certificate could not be found for domain: {0}'.format(
domain_name))
except Exception as e:
pecan.abort(status_code=400, detail=util.help_escape(str(e)))
return pecan.Response(body=None, status=204)
def post(self, query):
request_json = json.loads(pecan.request.body.decode('utf-8'))
if query == 'san_cert_hostname_limit':
try:
self._driver.manager.ssl_certificate_controller. \
set_san_cert_hostname_limit(request_json)
return pecan.Response(None, 202)
except Exception as e:
pecan.abort(400, str(e))
else:
try:
res = (self._driver.manager.ssl_certificate_controller.
update_san_cert_configuration(query, request_json))
return res
except Exception as e:
pecan.abort(400, str(e))
def post(self):
ssl_certificate_controller = (
self._driver.manager.ssl_certificate_controller)
certificate_info_dict = json.loads(pecan.request.body.decode('utf-8'))
try:
cert_obj = ssl_certificate.load_from_json(certificate_info_dict)
ssl_certificate_controller.create_ssl_certificate(self.project_id,
cert_obj)
except LookupError as e:
pecan.abort(400, detail='Provisioning ssl certificate failed. '
'Reason: %s' % str(e))
except ValueError as e:
pecan.abort(400, detail='Provisioning ssl certificate failed. '
'Reason: %s' % str(e))
return pecan.Response(None, 202)
def post(self):
service_state_json = json.loads(pecan.request.body.decode('utf-8'))
project_id = service_state_json['project_id']
service_id = service_state_json['service_id']
status = service_state_json['status']
services_controller = self._driver.manager.services_controller
try:
services_controller.set_service_provider_details(
project_id, service_id, status)
except Exception as e:
pecan.abort(404,
detail=('Setting state of service {0} on tenant: {1} '
'to {2} has failed, '
'Reason: {3}'.format(service_id, project_id,
status, str(e))))
return pecan.Response(None, 201)
def post(self):
service_state_json = json.loads(pecan.request.body.decode('utf-8'))
service_action = service_state_json.get('action', None)
project_id = service_state_json.get('project_id', None)
domain_name = service_state_json.get('domain', None)
services_controller = self._driver.manager.services_controller
try:
services_controller.services_action(project_id, service_action,
domain_name)
except Exception as e:
pecan.abort(404,
detail=('Services action {0} on tenant: {1} failed, '
'Reason: {2}'.format(service_action,
project_id, str(e))))
return pecan.Response(None, 202)
def post(self):
request_json = json.loads(pecan.request.body.decode('utf-8'))
job_type = request_json.pop('job_type')
sent = []
ignored = []
try:
sent, ignored = self._driver.manager.background_job_controller.\
post_job(job_type, request_json)
except NotImplementedError as e:
pecan.abort(400, str(e))
return pecan.Response(
json_body={
"sent": sent,
"ignored": ignored
},
status=202,
)
def delete(self, service_id):
purge_url = pecan.request.GET.get('url', '/*')
purge_all = pecan.request.GET.get('all', False)
hard = pecan.request.GET.get('hard', 'True')
if purge_url:
try:
purge_url.encode('ascii')
except (UnicodeDecodeError, UnicodeEncodeError):
pecan.abort(400, detail='non ascii character present in url')
if hard and hard.lower() == 'false':
hard = 'False'
if hard and hard.lower() == 'true':
hard = 'True'
try:
hard = ast.literal_eval(hard)
except ValueError:
pecan.abort(400, detail='hard can only be set to True or False')
if hard not in [True, False]:
pecan.abort(400, detail='hard can only be set to True or False')
purge_all = (True
if purge_all and purge_all.lower() == 'true' else False)
if purge_all and purge_url != '/*':
pecan.abort(400,
detail='Cannot provide all=true '
'and a url at the same time')
services_controller = self._driver.manager.services_controller
try:
services_controller.purge(self.project_id, service_id, hard,
purge_url)
except errors.ServiceStatusNotDeployed as e:
pecan.abort(400, detail=str(e))
except LookupError as e:
pecan.abort(404, detail=str(e))
service_url = str(
uri.encode(u'{0}/v1.0/services/{1}'.format(pecan.request.host_url,
service_id)))
return pecan.Response(None, 202, headers={"Location": service_url})
def post(self):
services_controller = self._driver.manager.services_controller
service_json_dict = json.loads(pecan.request.body.decode('utf-8'))
service_id = None
try:
service_obj = services_controller.create(self.project_id,
self.auth_token,
service_json_dict)
service_id = service_obj.service_id
except errors.SharedShardsExhausted as e:
# domain - shared domains exhausted
pecan.abort(400, detail=str(e))
except LookupError as e: # error handler for no flavor
pecan.abort(400, detail=str(e))
except ValueError as e: # error handler for existing service name
pecan.abort(400, detail=str(e))
except errors.ServicesOverLimit as e:
# error handler for services count exceeding limit
pecan.abort(403, detail=str(e))
service_url = str(
uri.encode(u'{0}/v1.0/services/{1}'.format(pecan.request.host_url,
service_id)))
return pecan.Response(None, 202, headers={"Location": service_url})
def patch_one(self, service_id):
request_json = json.loads(pecan.request.body.decode('utf-8'))
project_id = request_json.get('project_id', None)
domain_name = request_json.get('domain_name', None)
operator_url = request_json.get('operator_url', None)
provider_url = request_json.get('provider_url', None)
if not helpers.is_valid_domain_name(domain_name):
pecan.abort(400,
detail='Domain {0} is not valid'.format(domain_name))
changes_made = False
try:
changes_made = self._driver.manager.services_controller.\
update_access_url_service(
project_id,
service_id,
access_url_changes={
'domain_name': domain_name,
'operator_url': operator_url,
'provider_url': provider_url
}
)
except errors.ServiceNotFound:
pecan.abort(
404,
detail='Service {0} could not be found'.format(service_id))
except (errors.InvalidOperation, errors.InvalidResourceName) as e:
pecan.abort(400, detail='{0}'.format(e))
except (LookupError, ValueError):
pecan.abort(
404,
detail='Domain {0} could not be found'.format(domain_name))
status_code = 201 if changes_made is True else 202
return pecan.Response(None, status=status_code)
def get(self):
return pecan.Response(None, 204)
