class DomainController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(DomainController, self).__init__(driver) self._conf = driver.conf @pecan.expose('json') @decorators.validate(domain_name=rule.Rule( helpers.is_valid_domain_by_name(), helpers.abort_with_message)) def get_one(self, domain_name): services_controller = self._driver.manager.services_controller try: service_obj = services_controller.get_service_by_domain_name( domain_name) except LookupError: pecan.abort(404, detail='Domain %s cannot be found' % domain_name) # convert a service model into a response service model return resp_service_model.Model(service_obj, self) @pecan.expose('json') @decorators.validate(request=rule.Rule(helpers.is_valid_provider_url(), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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)
class AkamaiSanCertConfigController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] @pecan.expose('json') @decorators.validate(san_cert_name=rule.Rule( helpers.is_valid_domain_by_name(), helpers.abort_with_message)) def get_one(self, san_cert_name): try: res = (self._driver.manager.ssl_certificate_controller. get_san_cert_configuration(san_cert_name)) except Exception as e: pecan.abort(400, str(e)) return res @pecan.expose('json') @decorators.validate( san_cert_name=rule.Rule(helpers.is_valid_domain_by_name(), helpers.abort_with_message), request=rule.Rule( helpers.json_matches_service_schema( ssl_certificate.SSLCertificateSchema.get_schema( "config", "POST")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) def post(self, san_cert_name): config_json = json.loads(pecan.request.body.decode('utf-8')) try: res = (self._driver.manager.ssl_certificate_controller. update_san_cert_configuration(san_cert_name, config_json)) except Exception as e: pecan.abort(400, str(e)) return res
class ServicesAnalyticsController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] @pecan.expose('json') @decorators.validate(service_id=rule.Rule(helpers.is_valid_service_id(), helpers.abort_with_message), request=rule.Rule( helpers.is_valid_analytics_request(), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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)
class ServicesController(base.Controller): @pecan.expose('json') def get_all(self): context = local.store.context tenant_id = context.tenant marker = pecan.request.GET.get('marker') limit = pecan.request.GET.get('limit') services_controller = self._driver.manager.services_controller return services_controller.list(tenant_id, marker, limit) @pecan.expose('json') def get_one(self, service_name): context = local.store.context tenant_id = context.tenant services_controller = self._driver.manager.services_controller return services_controller.get(tenant_id, service_name) @pecan.expose('json') @decorators.validate( service_name=rule.Rule(helpers.is_valid_service_name(), helpers.abort_with_message), request=rule.Rule( helpers.json_matches_schema( service.ServiceSchema.get_schema("service", "PUT")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) def put(self, service_name): context = local.store.context tenant_id = context.tenant services_controller = self._driver.manager.services_controller service_json = json.loads(pecan.request.body.decode('utf-8')) return services_controller.create(tenant_id, service_name, service_json) @pecan.expose('json') def delete(self, service_name): context = local.store.context tenant_id = context.tenant services_controller = self._driver.manager.services_controller return services_controller.delete(tenant_id, service_name) @pecan.expose('json') @decorators.validate( service_name=rule.Rule(helpers.is_valid_service_name(), helpers.abort_with_message), request=rule.Rule( helpers.json_matches_schema( service.ServiceSchema.get_schema("service", "PATCH")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) def patch_one(self, service_name): context = local.store.context tenant_id = context.tenant services_controller = self._driver.manager.services_controller service_json = json.loads(pecan.request.body.decode('utf-8')) return services_controller.update(tenant_id, service_name, service_json)
class AdminProviderDetailsController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(AdminProviderDetailsController, self).__init__(driver) @pecan.expose('json') @decorators.validate( service_id=rule.Rule(helpers.is_valid_service_id(), helpers.abort_with_message), request=rule.Rule( helpers.json_matches_service_schema( provider_details_update.ProviderDetailsUpdateSchema.get_schema( "update_provider_access_url", "PATCH")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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)
class AkamaiSanCertConfigController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] @pecan.expose('json') @decorators.validate(query=rule.Rule( helpers.is_valid_domain_by_name_or_akamai_setting(), helpers.abort_with_message)) def get_one(self, query): if query == 'san_cert_hostname_limit': try: return (self._driver.manager.ssl_certificate_controller. get_san_cert_hostname_limit()) except Exception as e: pecan.abort(400, str(e)) else: try: return (self._driver.manager.ssl_certificate_controller. get_san_cert_configuration(query)) except Exception as e: pecan.abort(400, str(e)) @pecan.expose('json') @decorators.validate( query=rule.Rule(helpers.is_valid_domain_by_name_or_akamai_setting(), helpers.abort_with_message), request=rule.Rule( helpers.json_matches_service_schema( ssl_certificate.SSLCertificateSchema.get_schema( "config", "POST")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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))
class DummyEndpoint(object): # This should throw a ValidationProgrammingError # when called because the user did not actually # call validate_upper. # Note: the lambda in this function can never actually be # called, so we use no cover here @decorators.validate(value=rule.Rule(is_upper, lambda error_info: abort(404)) ) # pragma: no cover def get_value_programming_error(self, value): # This function body should never be # callable since the validation error # should not allow it to be called assert False # pragma: no cover @decorators.validate(value1=rule.Rule(is_upper(), lambda error_info: abort(404)), value2=rule.Rule(is_upper(), lambda error_info: abort(404)), value3=rule.Rule(is_upper(), lambda error_info: abort(404)) ) # pragma: no cover def get_value_happy_path(self, value1, value2, value3): return value1 + value2 + value3 @decorators.validate( value1=rule.Rule(is_upper(), lambda: abort(404)), value2=rule.Rule(is_upper(empty_ok=True), lambda error_info: abort(404), get_other_val), ) # pragma: no cover def get_value_with_getter(self, value1): global other_vals return value1 + other_vals.get('value2') # Falcon-style endpoint @decorators.validate(request=rule.Rule(is_request(), lambda error_info: abort(404)), response=rule.Rule(is_response(), lambda error_info: abort(404)), value=rule.Rule(is_upper(), lambda error_info: abort(404))) def get_falcon_style(self, request, response, value): return value # Falcon-style w/ declared rules @decorators.validate(request=RequestRule, response=ResponseRule, value=UppercaseRule) def get_falcon_with_declared_rules(self, request, response, value): return value
class BackgroundJobController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(BackgroundJobController, self).__init__(driver) @pecan.expose('json') @decorators.validate(request=rule.Rule( helpers.json_matches_service_schema( background_jobs.BackgroundJobSchema.get_schema( "background_jobs", "POST")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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)
class SSLCertificateController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] @pecan.expose('json') @decorators.validate( request=rule.Rule( helpers.json_matches_service_schema( ssl_certificate_validation.SSLCertificateSchema.get_schema( "ssl_certificate", "POST")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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)
class DummyFalconEndpoint(object): # falcon style endpoint @decorators.validate(request=rule.Rule(request_fit_schema, lambda error_info: abort(404)), response=rule.Rule(is_response(), lambda error_info: abort(404))) def get_falcon_style(self, request, response): return "Hello, World!" @decorators.validate(request=rule.Rule(request_fit_schema, helpers.custom_abort_falcon), response=rule.Rule(is_response(), helpers.custom_abort_falcon)) def get_falcon_style_custom_abort(self, request, response): return "Hello, World!"
class BackgroundJobController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(BackgroundJobController, self).__init__(driver) self.__class__.san_mapping = AkamaiSanMappingListController(driver) @pecan.expose('json') @decorators.validate(request=rule.Rule( helpers.json_matches_service_schema( background_jobs.BackgroundJobSchema.get_schema( "background_jobs", "POST")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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, )
class OperatorServiceActionController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(OperatorServiceActionController, self).__init__(driver) @pecan.expose('json') @decorators.validate(request=rule.Rule( helpers.json_matches_service_schema( service_action.ServiceActionSchema.get_schema( "service_action", "POST")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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)
class MockPecanEndpoint(object): testing_schema = service.ServiceSchema.get_schema("service", "PUT") @decorators.validation_function def is_valid_json(r): """Test for a valid JSON string.""" if len(r.body) == 0: return else: try: json.loads(r.body.decode('utf-8')) except Exception as e: e raise exceptions.ValidationFailed('Invalid JSON string') else: return @pecan.expose(generic=True) @helpers.with_schema_pecan(pecan.request, schema=testing_schema) def index(self): return "Hello, World!" @index.when(method='PUT') @decorators.validate( request=rule.Rule(is_valid_json(), lambda error_info: pecan.abort(400), stoplight_helpers.pecan_getter) ) def index_put(self): return "Hello, World!"
class ServiceStatusController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(ServiceStatusController, self).__init__(driver) @pecan.expose('json') @decorators.validate(request=rule.Rule( helpers.json_matches_service_schema( service_status.ServiceStatusSchema.get_schema( "service_status", "POST")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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 status_code = None try: status_code = services_controller.set_service_provider_details( project_id, service_id, self.auth_token, 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, status_code)
class AdminCertController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(AdminCertController, self).__init__(driver) @pecan.expose('json') @decorators.validate(request=rule.Rule( helpers.is_valid_certificate_status(), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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) @pecan.expose('json') @decorators.validate( domain_name=rule.Rule(helpers.is_valid_domain_by_name(), helpers.abort_with_message), request=rule.Rule( helpers.json_matches_service_schema( ssl_certificate.SSLCertificateSchema.get_schema( "admin_cert_status", "PATCH")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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)
class AkamaiRetryListController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(AkamaiRetryListController, self).__init__(driver) @pecan.expose('json') def get_all(self): retry_list = None try: retry_list = (self._driver.manager.ssl_certificate_controller. get_san_retry_list()) except Exception as e: pecan.abort(404, str(e)) return retry_list @pecan.expose('json') 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) @pecan.expose('json') @decorators.validate(request=rule.Rule( helpers.json_matches_service_schema( ssl_certificate.SSLCertificateSchema.get_schema( "retry_list", "PUT")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) def put(self): """The input of the queue data must be a list of dictionaries: (after json loaded) [ { "domain_name": <domain_name>, "project_id": <project_id>, "flavor_id": <flavor_id> } ] """ try: queue_data = json.loads(pecan.request.body.decode('utf-8')) res, deleted = (self._driver.manager.ssl_certificate_controller. update_san_retry_list(queue_data)) except Exception as e: pecan.abort(400, str(e)) # queue is the new queue, and deleted is deleted items return {"queue": res, "deleted": deleted}
class OperatorServiceLimitController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(OperatorServiceLimitController, self).__init__(driver) @pecan.expose('json') @decorators.validate(request=rule.Rule( helpers.json_matches_service_schema( service_limit.ServiceLimitSchema.get_schema( "service_limit", "PUT")), helpers.abort_with_message, stoplight_helpers.pecan_getter), project_id=rule.Rule(helpers.is_valid_project_id(), helpers.abort_with_message)) 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) @pecan.expose('json') @decorators.validate(project_id=rule.Rule(helpers.is_valid_project_id(), helpers.abort_with_message)) def get_one(self, project_id): services_controller = self._driver.manager.services_controller service_limits = services_controller.get_services_limit(project_id) return service_limits
class DummyPecanEndpoint(object): @pecan.expose(generic=True) @helpers.with_schema_pecan(pecan.request, schema=testing_schema) def index(self): return "Hello, World!" @index.when(method='PUT') @decorators.validate(request=rule.Rule(is_valid_json(), lambda error_info: pecan.abort(400), stoplight_helpers.pecan_getter)) def index_put(self): return "Hello, World!"
class ServiceAssetsController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] @pecan.expose('json') @decorators.validate(service_id=rule.Rule(helpers.is_valid_service_id(), helpers.abort_with_message)) 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})
class AdminCertController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(AdminCertController, self).__init__(driver) @pecan.expose('json') @decorators.validate(request=rule.Rule( helpers.is_valid_certificate_status(), helpers.abort_with_message, stoplight_helpers.pecan_getter)) def get(self): services_controller = self._driver.manager.services_controller call_args = getattr(pecan.request.context, "call_args") status = call_args.pop('status') cert_domains = services_controller.get_certs_by_status(status) return pecan.Response(json_body=cert_domains, status=200)
class DomainMigrationController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(DomainMigrationController, self).__init__(driver) @pecan.expose('json') @decorators.validate(request=rule.Rule( helpers.json_matches_service_schema( domain_migration.DomainMigrationServiceSchema.get_schema( "domain_migration", "POST")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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)
class DomainController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(DomainController, self).__init__(driver) self._conf = driver.conf @pecan.expose('json') @decorators.validate(domain_name=rule.Rule( helpers.is_valid_domain_by_name(), helpers.abort_with_message)) def get_one(self, domain_name): services_controller = self._driver.manager.services_controller try: service_obj = services_controller.get_service_by_domain_name( domain_name) except LookupError: pecan.abort(404, detail='Domain %s cannot be found' % domain_name) # convert a service model into a response service model return resp_service_model.Model(service_obj, self)
class AdminServiceController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(AdminServiceController, self).__init__(driver) self.__class__.action = OperatorServiceActionController(driver) self.__class__.status = ServiceStatusController(driver) @pecan.expose('json') @decorators.validate(request=rule.Rule(helpers.is_valid_service_status(), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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)
class AkamaiSanMappingListController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(AkamaiSanMappingListController, self).__init__(driver) self.manager = self._driver.manager @pecan.expose('json') def get_all(self): try: return ( self.manager.background_job_controller.get_san_mapping_list()) except Exception as e: pecan.abort(404, str(e)) @pecan.expose('json') @decorators.validate(request=rule.Rule( helpers.json_matches_service_schema( ssl_certificate.SSLCertificateSchema.get_schema( "san_mapping_list", "PUT")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) def put(self): """The input of the queue data must be a list of dictionaries: (after json loaded) [ { "domain_name": <domain_name>, "san_cert_name": <san_cert_name> } ] """ try: san_mapping_list = json.loads(pecan.request.body.decode('utf-8')) res, deleted = (self.manager.background_job_controller. put_san_mapping_list(san_mapping_list)) # queue is the new queue, and deleted is deleted items return {"queue": res, "deleted": deleted} except Exception as e: pecan.abort(400, str(e))
pass @decorators.validation_function def is_request(candidate): if not isinstance(candidate, DummyRequest): raise exceptions.ValidationFailed('Input must be a request') @decorators.validation_function def is_response(candidate): if not isinstance(candidate, DummyResponse): raise exceptions.ValidationFailed('Input must be a response') RequestRule = rule.Rule(is_request(), lambda error_info: base.abort(404)) ResponseRule = rule.Rule(is_response(), lambda error_info: base.abort(404)) UppercaseRule = rule.Rule(is_upper(), lambda error_info: base.abort(404)) class DummyEndpoint(object): # This should throw a ValidationProgrammingError # when called because the user did not actually # call validate_upper. # Note: the lambda in this function can never actually be # called, so we use no cover here @decorators.validate(value=rule.Rule(is_upper, lambda error_info: base.abort(404))
class ServicesController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] def __init__(self, driver): super(ServicesController, self).__init__(driver) self._conf = driver.conf self._conf.register_opts(LIMITS_OPTIONS, group=LIMITS_GROUP) self.limits_conf = self._conf[LIMITS_GROUP] self.max_services_per_page = self.limits_conf.max_services_per_page # Add assets controller here # need to initialize a nested controller with a parameter driver, # so added it in __init__ method. # see more in: http://pecan.readthedocs.org/en/latest/rest.html self.__class__.assets = ServiceAssetsController(driver) self.__class__.analytics = ServicesAnalyticsController(driver) @pecan.expose('json') def get_all(self): marker = pecan.request.GET.get('marker', None) limit = pecan.request.GET.get('limit', 10) try: limit = int(limit) if limit <= 0: pecan.abort(400, detail=u'Limit should be greater than 0') if limit > self.max_services_per_page: error = u'Limit should be less than or equal to {0}'.format( self.max_services_per_page) pecan.abort(400, detail=error) except ValueError: error = (u'Limit should be an integer greater than 0 and less' u' or equal to {0}'.format(self.max_services_per_page)) pecan.abort(400, detail=error) try: if marker is not None: marker = str(uuid.UUID(marker)) except ValueError: pecan.abort(400, detail="Marker must be a valid UUID") services_controller = self._driver.manager.services_controller service_resultset = services_controller.list(self.project_id, marker, limit) results = [ resp_service_model.Model(s, self) for s in service_resultset ] links = [] if len(results) >= limit: links.append( link.Model( u'{0}/services?marker={1}&limit={2}'.format( self.base_url, results[-1]['id'], limit), 'next')) return {'links': links, 'services': results} @pecan.expose('json') @decorators.validate(service_id=rule.Rule(helpers.is_valid_service_id(), helpers.abort_with_message)) def get_one(self, service_id): services_controller = self._driver.manager.services_controller try: service_obj = services_controller.get(self.project_id, service_id) except ValueError: pecan.abort(404, detail='service %s could not be found' % service_id) # convert a service model into a response service model return resp_service_model.Model(service_obj, self) @pecan.expose('json') @decorators.validate(request=rule.Rule( helpers.json_matches_service_schema( service.ServiceSchema.get_schema("service", "POST")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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}) @pecan.expose('json') @decorators.validate(service_id=rule.Rule(helpers.is_valid_service_id(), helpers.abort_with_message)) 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) @pecan.expose('json') @decorators.validate(service_id=rule.Rule(helpers.is_valid_service_id(), helpers.abort_with_message), request=rule.Rule( helpers.json_matches_service_schema( service.ServiceSchema.get_schema( "service", "PATCH")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) 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})
class SSLCertificateController(base.Controller, hooks.HookController): __hooks__ = [poppy_hooks.Context(), poppy_hooks.Error()] @pecan.expose('json') @decorators.validate( request=rule.Rule( helpers.json_matches_service_schema( ssl_certificate_validation.SSLCertificateSchema.get_schema( "ssl_certificate", "POST")), helpers.abort_with_message, stoplight_helpers.pecan_getter)) def post(self): ssl_certificate_controller = ( self._driver.manager.ssl_certificate_controller) certificate_info_dict = json.loads(pecan.request.body.decode('utf-8')) try: project_id = certificate_info_dict.get('project_id') cert_obj = ssl_certificate.load_from_json(certificate_info_dict) cert_obj.project_id = project_id ssl_certificate_controller.create_ssl_certificate(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) @pecan.expose('json') @decorators.validate( domain_name=rule.Rule( helpers.is_valid_domain_by_name(), helpers.abort_with_message) ) 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) @pecan.expose('json') @decorators.validate( domain_name=rule.Rule( helpers.is_valid_domain_by_name(), helpers.abort_with_message) ) def get_one(self, domain_name): certificate_controller = \ self._driver.manager.ssl_certificate_controller total_cert_info = [] try: # NOTE(TheSriram): we can also enforce project_id constraints certs_info = certificate_controller.get_certs_info_by_domain( domain_name=domain_name, project_id=None) except ValueError: pecan.abort(404, detail='certificate ' 'could not be found ' 'for domain : %s' % domain_name) else: # convert a cert model into a response cert model try: if iter(certs_info): for cert in certs_info: total_cert_info.append(ssl_cert_model.Model(cert)) return total_cert_info except TypeError: return ssl_cert_model.Model(certs_info)