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)