x/poppy
Code Issues Proposed changes

Refactor storage layer to separate cert controller

Browse Source 
Move all certificate logic into it's own controller in
the storage layer.

Change-Id: Icc7e457ea2ab8bc9a149e6dedda3e23a202dcf7c
This commit is contained in:
Isaac Mungai 2016-04-26 15:40:54 -04:00
parent 6cb236b17c
commit c1cb52e8c8
31 changed files with 1094 additions and 670 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
poppy/distributed_task/taskflow/task/create_service_tasks.py
View File

@ -49,13 +49,18 @@ class CreateProviderServicesTask(task.Task):
service_controller, self.storage_controller = \ service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage') memoized_controllers.task_controllers('poppy', 'storage')
_, self.ssl_certificate_manager = \
memoized_controllers.task_controllers('poppy', 'ssl_certificate')
self.ssl_certificate_storage = self.ssl_certificate_manager.storage
providers_list = json.loads(providers_list_json) providers_list = json.loads(providers_list_json)
try: try:
service_obj = self.storage_controller.get(project_id, service_id) service_obj = self.storage_controller.get(project_id, service_id)
for domain in service_obj.domains: for domain in service_obj.domains:
if domain.certificate == 'san': if domain.certificate == 'san':
cert_for_domain = ( cert_for_domain = (
self.storage_controller.get_certs_by_domain( self.ssl_certificate_storage.get_certs_by_domain(
domain.domain, domain.domain,
project_id=project_id, project_id=project_id,
flavor_id=service_obj.flavor_id, flavor_id=service_obj.flavor_id,

25
poppy/distributed_task/taskflow/task/create_ssl_certificate_tasks.py
View File

@ -77,8 +77,9 @@ class SendNotificationTask(task.Task):
class UpdateCertInfoTask(task.Task): class UpdateCertInfoTask(task.Task):
def execute(self, project_id, cert_obj_json, responders): def execute(self, project_id, cert_obj_json, responders):
service_controller, self.storage_controller = \ service_controller, self.ssl_certificate_manager = \
memoized_controllers.task_controllers('poppy', 'storage') memoized_controllers.task_controllers('poppy', 'ssl_certificate')
self.storage_controller = self.ssl_certificate_manager.storage
cert_details = {} cert_details = {}
for responder in responders: for responder in responders:
@ -86,24 +87,28 @@ class UpdateCertInfoTask(task.Task):
cert_details[provider] = json.dumps(responder[provider]) cert_details[provider] = json.dumps(responder[provider])
cert_obj = ssl_certificate.load_from_json(json.loads(cert_obj_json)) cert_obj = ssl_certificate.load_from_json(json.loads(cert_obj_json))
self.storage_controller.update_cert_info(cert_obj.domain_name, self.storage_controller.update_certificate(
cert_obj.cert_type, cert_obj.domain_name,
cert_obj.flavor_id, cert_obj.cert_type,
cert_details) cert_obj.flavor_id,
cert_details
)
return return
class CreateStorageSSLCertificateTask(task.Task): class CreateStorageSSLCertificateTask(task.Task):
'''This task is meant to be used in san rerun flow.''' """This task is meant to be used in san rerun flow."""
def execute(self, project_id, cert_obj_json): def execute(self, project_id, cert_obj_json):
cert_obj = ssl_certificate.load_from_json(json.loads(cert_obj_json)) cert_obj = ssl_certificate.load_from_json(json.loads(cert_obj_json))
service_controller, self.storage_controller = \ service_controller, self.ssl_certificate_manager = \
memoized_controllers.task_controllers('poppy', 'storage') memoized_controllers.task_controllers('poppy', 'ssl_certificate')
self.storage_controller = self.ssl_certificate_manager.storage
try: try:
self.storage_controller.create_cert(project_id, cert_obj) self.storage_controller.create_certificate(project_id, cert_obj)
except ValueError as e: except ValueError as e:
LOG.exception(e) LOG.exception(e)

14
poppy/distributed_task/taskflow/task/delete_ssl_certificate_tasks.py
View File

@ -57,12 +57,16 @@ class SendNotificationTask(task.Task):
class DeleteStorageSSLCertificateTask(task.Task): class DeleteStorageSSLCertificateTask(task.Task):
def execute(self, project_id, domain_name, cert_type): def execute(self, project_id, domain_name, cert_type):
service_controller, self.storage_controller = \ service_controller, self.ssl_certificate_manager = \
memoized_controllers.task_controllers('poppy', 'storage') memoized_controllers.task_controllers('poppy', 'ssl_certificate')
self.storage_controller = self.ssl_certificate_manager.storage
try: try:
self.storage_controller.delete_cert(project_id, self.storage_controller.delete_certificate(
domain_name, project_id,
cert_type) domain_name,
cert_type
)
except ValueError as e: except ValueError as e:
LOG.exception(e) LOG.exception(e)

38
poppy/manager/base/services.py
View File

@ -33,19 +33,19 @@ class ServicesControllerBase(controller.ManagerControllerBase):
self.notification_wrapper = notifications.NotificationWrapper() self.notification_wrapper = notifications.NotificationWrapper()
@abc.abstractmethod @abc.abstractmethod
def list(self, project_id, marker=None, limit=None): def get_services(self, project_id, marker=None, limit=None):
"""list """Get a list of services.
:param project_id :param project_id
:param marker :param marker
:limit :param limit
:raises: NotImplementedError :raises: NotImplementedError
""" """
raise NotImplementedError raise NotImplementedError
@abc.abstractmethod @abc.abstractmethod
def get(self, project_id, service_id): def get_service(self, project_id, service_id):
"""GET """Get a service.
:param project_id :param project_id
:param service_id :param service_id
@ -54,22 +54,26 @@ class ServicesControllerBase(controller.ManagerControllerBase):
raise NotImplementedError raise NotImplementedError
@abc.abstractmethod @abc.abstractmethod
def create(self, project_id, auth_token, service_obj): def create_service(self, project_id, auth_token, service_obj):
"""create """Create a service.
:param project_id :param project_id
:param auth_token
:param service_obj :param service_obj
:raises: NotImplementedError :raises: NotImplementedError
""" """
raise NotImplementedError raise NotImplementedError
@abc.abstractmethod @abc.abstractmethod
def update(self, project_id, service_id, service_obj): def update_service(self, project_id, service_id,
"""POST auth_token, service_updates, force_update=False):
"""Update a service.
:param project_id :param project_id
:param service_id :param service_id
:param service_obj :param auth_token
:param service_updates
:param force_update
:raises: NotImplementedError :raises: NotImplementedError
""" """
raise NotImplementedError raise NotImplementedError
@ -85,8 +89,8 @@ class ServicesControllerBase(controller.ManagerControllerBase):
""" """
@abc.abstractmethod @abc.abstractmethod
def delete(self, project_id, service_id): def delete_service(self, project_id, service_id):
"""DELETE """Delete a service.
:param project_id :param project_id
:param service_id :param service_id
@ -96,5 +100,13 @@ class ServicesControllerBase(controller.ManagerControllerBase):
@abc.abstractmethod @abc.abstractmethod
def purge(self, project_id, service_id, hard=False, purge_url=None): def purge(self, project_id, service_id, hard=False, purge_url=None):
'''If purge_url is none, all content of this service will be purge.''' """Purge assets for a service.
If purge_url is none, all content of this service will be purged.
:param project_id
:param service_id
:param hard
:param purge_url
"""
raise NotImplementedError raise NotImplementedError

29
poppy/manager/base/ssl_certificate.py
View File

@ -22,17 +22,38 @@ from poppy.manager.base import controller
@six.add_metaclass(abc.ABCMeta) @six.add_metaclass(abc.ABCMeta)
class SSLCertificateController(controller.ManagerControllerBase): class SSLCertificateController(controller.ManagerControllerBase):
"""Home controller base class.""" """SSL certificate controller base class."""
def __init__(self, manager): def __init__(self, manager):
super(SSLCertificateController, self).__init__(manager) super(SSLCertificateController, self).__init__(manager)
@abc.abstractmethod @abc.abstractmethod
def create_ssl_certificate(self, project_id, domain_name, **extras): def create_ssl_certificate(self, project_id, cert_obj):
"""create_ssl_certificate """Create ssl certificate.
:param project_id :param project_id
:param domain_name :param cert_obj
:raises: NotImplementedError :raises: NotImplementedError
""" """
raise NotImplementedError raise NotImplementedError
@abc.abstractmethod
def delete_ssl_certificate(self, project_id, domain_name, cert_type):
"""Delete ssl certificate.
:param project_id
:param domain_name
:param cert_type
:raises: NotImplementedError
"""
raise NotImplementedError
@abc.abstractmethod
def get_certs_info_by_domain(self, domain_name, project_id):
"""Get ssl certificate by domain.
:param domain_name:
:param project_id:
:raises: NotImplementedError
"""
raise NotImplementedError

90
poppy/manager/default/services.py
View File

@ -50,6 +50,9 @@ class DefaultServicesController(base.ServicesController):
super(DefaultServicesController, self).__init__(manager) super(DefaultServicesController, self).__init__(manager)
self.storage_controller = self._driver.storage.services_controller self.storage_controller = self._driver.storage.services_controller
self.ssl_certificate_storage = (
self._driver.storage.certificates_controller
)
self.flavor_controller = self._driver.storage.flavors_controller self.flavor_controller = self._driver.storage.flavors_controller
self.dns_controller = self._driver.dns.services_controller self.dns_controller = self._driver.dns.services_controller
self.distributed_task_controller = ( self.distributed_task_controller = (
@ -100,13 +103,6 @@ class DefaultServicesController(base.ServicesController):
return services_project_ids return services_project_ids
def get_certs_by_status(self, status):
services_project_ids = \
self.storage_controller.get_certs_by_status(status)
return services_project_ids
def get_domains_by_provider_url(self, provider_url): def get_domains_by_provider_url(self, provider_url):
domains = \ domains = \
@ -151,26 +147,26 @@ class DefaultServicesController(base.ServicesController):
request_url='/*') request_url='/*')
caching_entry['rules'].append(default_rule.to_dict()) caching_entry['rules'].append(default_rule.to_dict())
def list(self, project_id, marker=None, limit=None): def get_services(self, project_id, marker=None, limit=None):
"""list. """Get a list of services.
:param project_id :param project_id
:param marker :param marker
:param limit :param limit
:return list :return list
""" """
return self.storage_controller.list(project_id, marker, limit) return self.storage_controller.get_services(project_id, marker, limit)
def get(self, project_id, service_id): def get_service(self, project_id, service_id):
"""get. """get.
:param project_id :param project_id
:param service_id :param service_id
:return controller :return controller
""" """
return self.storage_controller.get(project_id, service_id) return self.storage_controller.get_service(project_id, service_id)
def create(self, project_id, auth_token, service_json): def create_service(self, project_id, auth_token, service_json):
"""create. """create.
:param project_id :param project_id
@ -232,8 +228,7 @@ class DefaultServicesController(base.ServicesController):
raise e raise e
try: try:
self.storage_controller.create(project_id, self.storage_controller.create_service(project_id, service_obj)
service_obj)
except ValueError as e: except ValueError as e:
raise e raise e
@ -252,8 +247,8 @@ class DefaultServicesController(base.ServicesController):
return service_obj return service_obj
def update(self, project_id, service_id, def update_service(self, project_id, service_id,
auth_token, service_updates, force_update=False): auth_token, service_updates, force_update=False):
"""update. """update.
:param project_id :param project_id
@ -265,7 +260,10 @@ class DefaultServicesController(base.ServicesController):
""" """
# get the current service object # get the current service object
try: try:
service_old = self.storage_controller.get(project_id, service_id) service_old = self.storage_controller.get_service(
project_id,
service_id
)
except ValueError: except ValueError:
raise errors.ServiceNotFound("Service not found") raise errors.ServiceNotFound("Service not found")
@ -292,7 +290,7 @@ class DefaultServicesController(base.ServicesController):
# old domains need to bind as well # old domains need to bind as well
elif domain.certificate == 'san': elif domain.certificate == 'san':
cert_for_domain = ( cert_for_domain = (
self.storage_controller.get_certs_by_domain( self.ssl_certificate_storage.get_certs_by_domain(
domain.domain, domain.domain,
project_id=project_id, project_id=project_id,
flavor_id=service_old.flavor_id, flavor_id=service_old.flavor_id,
@ -354,7 +352,7 @@ class DefaultServicesController(base.ServicesController):
store) store)
elif domain.certificate == 'san': elif domain.certificate == 'san':
cert_for_domain = ( cert_for_domain = (
self.storage_controller.get_certs_by_domain( self.ssl_certificate_storage.get_certs_by_domain(
domain.domain, domain.domain,
project_id=project_id, project_id=project_id,
flavor_id=service_new.flavor_id, flavor_id=service_new.flavor_id,
@ -404,7 +402,7 @@ class DefaultServicesController(base.ServicesController):
project_id, project_id,
new_cert_detail new_cert_detail
) )
self.storage_controller.create_cert( self.ssl_certificate_storage.create_certificate(
project_id, project_id,
new_cert_obj new_cert_obj
) )
@ -434,7 +432,11 @@ class DefaultServicesController(base.ServicesController):
for provider in provider_details: for provider in provider_details:
provider_details[provider].status = u'update_in_progress' provider_details[provider].status = u'update_in_progress'
service_new.provider_details = provider_details service_new.provider_details = provider_details
self.storage_controller.update(project_id, service_id, service_new) self.storage_controller.update_service(
project_id,
service_id,
service_new
)
kwargs = { kwargs = {
'project_id': project_id, 'project_id': project_id,
@ -458,13 +460,16 @@ class DefaultServicesController(base.ServicesController):
def set_service_provider_details(self, project_id, service_id, def set_service_provider_details(self, project_id, service_id,
auth_token, status): auth_token, status):
old_service = self.storage_controller.get(project_id, service_id) old_service = self.storage_controller.get_service(
project_id,
service_id
)
if ( if (
old_service.status == 'create_in_progress' and old_service.status == 'create_in_progress' and
old_service.provider_details == {} old_service.provider_details == {}
): ):
self.update( self.update_service(
project_id, service_id, auth_token, [], force_update=True) project_id, service_id, auth_token, [], force_update=True)
return 202 return 202
self.storage_controller.set_service_provider_details( self.storage_controller.set_service_provider_details(
@ -495,7 +500,7 @@ class DefaultServicesController(base.ServicesController):
if action == 'delete': if action == 'delete':
LOG.info('Deleting service: %s, project_id: %s' % ( LOG.info('Deleting service: %s, project_id: %s' % (
service_obj.service_id, project_id)) service_obj.service_id, project_id))
self.delete(project_id, service_obj.service_id) self.delete_service(project_id, service_obj.service_id)
elif action == 'enable': elif action == 'enable':
LOG.info('Enabling service: %s, project_id: %s' % ( LOG.info('Enabling service: %s, project_id: %s' % (
service_obj.service_id, project_id)) service_obj.service_id, project_id))
@ -539,7 +544,11 @@ class DefaultServicesController(base.ServicesController):
return return
marker = None marker = None
service_batch = self.storage_controller.list(project_id, marker, 10) service_batch = self.storage_controller.get_services(
project_id,
marker,
10
)
while len(service_batch) > 0: while len(service_batch) > 0:
marker = service_batch[-1].service_id marker = service_batch[-1].service_id
# process previous batch # process previous batch
@ -547,19 +556,23 @@ class DefaultServicesController(base.ServicesController):
self._action_per_service_obj(project_id=project_id, self._action_per_service_obj(project_id=project_id,
action=action, action=action,
service_obj=service_obj) service_obj=service_obj)
service_batch = self.storage_controller.list(project_id, marker, service_batch = self.storage_controller.get_services(
10) project_id,
marker,
10
)
return return
def delete(self, project_id, service_id): def delete_service(self, project_id, service_id):
"""delete. """delete.
:param project_id :param project_id
:param service_id :param service_id
:raises LookupError :raises LookupError
""" """
service_obj = self.storage_controller.get(project_id, service_id) service_obj = self.storage_controller.get_service(
project_id, service_id)
# get provider details for this service # get provider details for this service
provider_details = self._get_provider_details(project_id, service_id) provider_details = self._get_provider_details(project_id, service_id)
@ -569,7 +582,11 @@ class DefaultServicesController(base.ServicesController):
service_obj.provider_details[provider].status = ( service_obj.provider_details[provider].status = (
u'delete_in_progress') u'delete_in_progress')
self.storage_controller.update(project_id, service_id, service_obj) self.storage_controller.update_service(
project_id,
service_id,
service_obj
)
kwargs = { kwargs = {
"provider_details": json.dumps( "provider_details": json.dumps(
@ -588,7 +605,10 @@ class DefaultServicesController(base.ServicesController):
def purge(self, project_id, service_id, hard=False, purge_url=None): def purge(self, project_id, service_id, hard=False, purge_url=None):
"""If purge_url is none, all content of this service will be purge.""" """If purge_url is none, all content of this service will be purge."""
try: try:
service_obj = self.storage_controller.get(project_id, service_id) service_obj = self.storage_controller.get_service(
project_id,
service_id
)
except ValueError as e: except ValueError as e:
# This except is hit when service object does not exist # This except is hit when service object does not exist
raise LookupError(str(e)) raise LookupError(str(e))
@ -607,7 +627,11 @@ class DefaultServicesController(base.ServicesController):
service_obj.provider_details[provider].status = ( service_obj.provider_details[provider].status = (
u'update_in_progress') u'update_in_progress')
self.storage_controller.update(project_id, service_id, service_obj) self.storage_controller.update_service(
project_id,
service_id,
service_obj
)
# possible validation of purge url here... # possible validation of purge url here...
kwargs = { kwargs = {

37
poppy/manager/default/ssl_certificate.py
View File

@ -36,8 +36,10 @@ class DefaultSSLCertificateController(base.SSLCertificateController):
super(DefaultSSLCertificateController, self).__init__(manager) super(DefaultSSLCertificateController, self).__init__(manager)
self.distributed_task_controller = ( self.distributed_task_controller = (
self._driver.distributed_task.services_controller) self._driver.distributed_task.services_controller
self.storage_controller = self._driver.storage.services_controller )
self.storage = self._driver.storage.certificates_controller
self.service_storage = self._driver.storage.services_controller
self.flavor_controller = self._driver.storage.flavors_controller self.flavor_controller = self._driver.storage.flavors_controller
def create_ssl_certificate(self, project_id, cert_obj): def create_ssl_certificate(self, project_id, cert_obj):
@ -57,9 +59,10 @@ class DefaultSSLCertificateController(base.SSLCertificateController):
raise e raise e
try: try:
self.storage_controller.create_cert( self.storage.create_certificate(
project_id, project_id,
cert_obj) cert_obj
)
# ValueError will be raised if the cert_info has already existed # ValueError will be raised if the cert_info has already existed
except ValueError as e: except ValueError as e:
raise e raise e
@ -76,8 +79,7 @@ class DefaultSSLCertificateController(base.SSLCertificateController):
**kwargs) **kwargs)
return kwargs return kwargs
def delete_ssl_certificate(self, project_id, domain_name, def delete_ssl_certificate(self, project_id, domain_name, cert_type):
cert_type):
kwargs = { kwargs = {
'project_id': project_id, 'project_id': project_id,
'domain_name': domain_name, 'domain_name': domain_name,
@ -91,7 +93,7 @@ class DefaultSSLCertificateController(base.SSLCertificateController):
def get_certs_info_by_domain(self, domain_name, project_id): def get_certs_info_by_domain(self, domain_name, project_id):
try: try:
certs_info = self.storage_controller.get_certs_by_domain( certs_info = self.storage.get_certs_by_domain(
domain_name=domain_name, domain_name=domain_name,
project_id=project_id) project_id=project_id)
if not certs_info: if not certs_info:
@ -122,7 +124,7 @@ class DefaultSSLCertificateController(base.SSLCertificateController):
def update_san_retry_list(self, queue_data_list): def update_san_retry_list(self, queue_data_list):
for r in queue_data_list: for r in queue_data_list:
service_obj = self.storage_controller\ service_obj = self.service_storage\
.get_service_details_by_domain_name(r['domain_name']) .get_service_details_by_domain_name(r['domain_name'])
if service_obj is None and r.get('validate_service', True): if service_obj is None and r.get('validate_service', True):
raise LookupError(u'Domain {0} does not exist on any service, ' raise LookupError(u'Domain {0} does not exist on any service, '
@ -131,7 +133,7 @@ class DefaultSSLCertificateController(base.SSLCertificateController):
'to retry this san-retry request forcefully'. 'to retry this san-retry request forcefully'.
format(r['domain_name'], r)) format(r['domain_name'], r))
cert_for_domain = self.storage_controller.get_certs_by_domain( cert_for_domain = self.storage.get_certs_by_domain(
r['domain_name']) r['domain_name'])
if cert_for_domain != []: if cert_for_domain != []:
if cert_for_domain.get_cert_status() == "deployed": if cert_for_domain.get_cert_status() == "deployed":
@ -154,7 +156,7 @@ class DefaultSSLCertificateController(base.SSLCertificateController):
akamai_driver.mod_san_queue.put_queue_data(new_queue_data)] akamai_driver.mod_san_queue.put_queue_data(new_queue_data)]
deleted = tuple(x for x in orig if x not in res) deleted = tuple(x for x in orig if x not in res)
# other provider's retry-list implementaiton goes here # other provider's retry-list implementation goes here
return res, deleted return res, deleted
def rerun_san_retry_list(self): def rerun_san_retry_list(self):
@ -168,10 +170,10 @@ class DefaultSSLCertificateController(base.SSLCertificateController):
# remove duplicates # remove duplicates
# see http://bit.ly/1mX2Vcb for details # see http://bit.ly/1mX2Vcb for details
def remove_duplicates(data): def remove_duplicates(data):
'''Remove duplicates from the data (normally a list). """Remove duplicates from the data (normally a list).
The data must be sortable and have an equality operator The data must be sortable and have an equality operator
''' """
data = sorted(data) data = sorted(data)
return [k for k, _ in itertools.groupby(data)] return [k for k, _ in itertools.groupby(data)]
retry_list = remove_duplicates(retry_list) retry_list = remove_duplicates(retry_list)
@ -179,7 +181,7 @@ class DefaultSSLCertificateController(base.SSLCertificateController):
# double check in POST. This check should really be first done in # double check in POST. This check should really be first done in
# PUT # PUT
for r in retry_list: for r in retry_list:
service_obj = self.storage_controller\ service_obj = self.service_storage\
.get_service_details_by_domain_name(r['domain_name']) .get_service_details_by_domain_name(r['domain_name'])
if service_obj is None and r.get('validate_service', True): if service_obj is None and r.get('validate_service', True):
raise LookupError(u'Domain {0} does not exist on any ' raise LookupError(u'Domain {0} does not exist on any '
@ -189,7 +191,7 @@ class DefaultSSLCertificateController(base.SSLCertificateController):
' san-retry request forcefully'. ' san-retry request forcefully'.
format(r['domain_name'], r)) format(r['domain_name'], r))
cert_for_domain = self.storage_controller.get_certs_by_domain( cert_for_domain = self.storage.get_certs_by_domain(
r['domain_name']) r['domain_name'])
if cert_for_domain != []: if cert_for_domain != []:
if cert_for_domain.get_cert_status() == "deployed": if cert_for_domain.get_cert_status() == "deployed":
@ -207,7 +209,7 @@ class DefaultSSLCertificateController(base.SSLCertificateController):
) )
cert_for_domain = ( cert_for_domain = (
self.storage_controller.get_certs_by_domain( self.storage.get_certs_by_domain(
cert_obj.domain_name, cert_obj.domain_name,
project_id=cert_obj.project_id, project_id=cert_obj.project_id,
flavor_id=cert_obj.flavor_id, flavor_id=cert_obj.flavor_id,
@ -303,3 +305,8 @@ class DefaultSSLCertificateController(base.SSLCertificateController):
res = {} res = {}
return res return res
def get_certs_by_status(self, status):
services_project_ids = self.storage.get_certs_by_status(status)
return services_project_ids

35
poppy/provider/akamai/background_jobs/check_cert_status_and_update/check_cert_status_and_update_tasks.py
View File

@ -32,9 +32,11 @@ class GetCertInfoTask(task.Task):
default_provides = "cert_obj_json" default_provides = "cert_obj_json"
def execute(self, domain_name, cert_type, flavor_id, project_id): def execute(self, domain_name, cert_type, flavor_id, project_id):
service_controller, self.storage_controller = \ service_controller, self.ssl_certificate_manager = \
memoized_controllers.task_controllers('poppy', 'storage') memoized_controllers.task_controllers('poppy', 'ssl_certificate')
res = self.storage_controller.get_certs_by_domain( self.storage = self.ssl_certificate_manager.storage
res = self.storage.get_certs_by_domain(
domain_name, project_id=project_id, domain_name, project_id=project_id,
flavor_id=flavor_id, cert_type=cert_type) flavor_id=flavor_id, cert_type=cert_type)
if res is None: if res is None:
@ -103,26 +105,33 @@ class UpdateCertStatusTask(task.Task):
def __init__(self): def __init__(self):
super(UpdateCertStatusTask, self).__init__() super(UpdateCertStatusTask, self).__init__()
service_controller, self.storage_controller = \ service_controller, self.ssl_certificate_manager = \
memoized_controllers.task_controllers('poppy', 'storage') memoized_controllers.task_controllers('poppy', 'ssl_certificate')
self.storage_controller = (
self.ssl_certificate_manager.storage
)
self.service_storage = service_controller.storage_controller
def execute(self, project_id, cert_obj_json, status_change_to): def execute(self, project_id, cert_obj_json, status_change_to):
if cert_obj_json != "": if cert_obj_json != "":
cert_obj = ssl_certificate.load_from_json(json.loads(cert_obj_json) cert_obj = ssl_certificate.load_from_json(
) json.loads(cert_obj_json)
)
cert_details = cert_obj.cert_details cert_details = cert_obj.cert_details
if status_change_to != "": if status_change_to != "":
cert_details['Akamai']['extra_info']['status'] = ( cert_details['Akamai']['extra_info']['status'] = (
status_change_to) status_change_to)
cert_details['Akamai'] = json.dumps(cert_details['Akamai']) cert_details['Akamai'] = json.dumps(cert_details['Akamai'])
self.storage_controller.update_cert_info(cert_obj.domain_name, self.storage_controller.update_certificate(
cert_obj.cert_type, cert_obj.domain_name,
cert_obj.flavor_id, cert_obj.cert_type,
cert_details) cert_obj.flavor_id,
cert_details
)
service_obj = ( service_obj = (
self.storage_controller. self.service_storage.
get_service_details_by_domain_name(cert_obj.domain_name) get_service_details_by_domain_name(cert_obj.domain_name)
) )
# Update provider details # Update provider details
@ -131,7 +140,7 @@ class UpdateCertStatusTask(task.Task):
domains_certificate_status.\ domains_certificate_status.\
set_domain_certificate_status(cert_obj.domain_name, set_domain_certificate_status(cert_obj.domain_name,
status_change_to) status_change_to)
self.storage_controller.update_provider_details( self.service_storage.update_provider_details(
project_id, project_id,
service_obj.service_id, service_obj.service_id,
service_obj.provider_details service_obj.provider_details

2
poppy/storage/base/__init__.py
View File

@ -13,6 +13,7 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
from poppy.storage.base import certificates
from poppy.storage.base import driver from poppy.storage.base import driver
from poppy.storage.base import flavors from poppy.storage.base import flavors
from poppy.storage.base import services from poppy.storage.base import services
@ -20,5 +21,6 @@ from poppy.storage.base import services
Driver = driver.StorageDriverBase Driver = driver.StorageDriverBase
CertificatesController = certificates.CertificatesControllerBase
FlavorsController = flavors.FlavorsControllerBase FlavorsController = flavors.FlavorsControllerBase
ServicesController = services.ServicesControllerBase ServicesController = services.ServicesControllerBase

56
poppy/storage/base/certificates.py Normal file
View File

@ -0,0 +1,56 @@
# Copyright (c) 2016 Rackspace, Inc.
#
# 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 abc
import six
from poppy.storage.base import controller
@six.add_metaclass(abc.ABCMeta)
class CertificatesControllerBase(controller.StorageControllerBase):
@abc.abstractmethod
def create_certificate(self, project_id, cert_obj):
"""Create a certificate
:param project_id
:param cert_obj
:raise NotImplementedError
"""
raise NotImplementedError
def delete_certificate(self, project_id, domain_name, cert_type):
"""Delete a certificate.
:param project_id
:param domain_name
:param cert_type
:raise NotImplementedError
"""
raise NotImplementedError
@abc.abstractmethod
def update_certificate(self, domain_name, cert_type, flavor_id,
cert_details):
"""update_cert_info.
:param domain_name
:param cert_type
:param flavor_id
:param cert_details
"""
raise NotImplementedError

14
poppy/storage/base/driver.py
View File

@ -62,8 +62,8 @@ class StorageDriverBase(object):
raise NotImplementedError raise NotImplementedError
@abc.abstractproperty @abc.abstractproperty
def services_controller(self): def certificates_controller(self):
"""Returns the driver's hostname controller. """Returns the driver's certificates controller.
:raise NotImplementedError :raise NotImplementedError
""" """
@ -71,7 +71,15 @@ class StorageDriverBase(object):
@abc.abstractproperty @abc.abstractproperty
def flavors_controller(self): def flavors_controller(self):
"""Returns the driver's hostname controller. """Returns the driver's flavors controller.
:raise NotImplementedError
"""
raise NotImplementedError
@abc.abstractproperty
def services_controller(self):
"""Returns the driver's services controller.
:raise NotImplementedError :raise NotImplementedError
""" """

56
poppy/storage/base/services.py
View File

@ -28,8 +28,8 @@ class ServicesControllerBase(controller.StorageControllerBase):
super(ServicesControllerBase, self).__init__(driver) super(ServicesControllerBase, self).__init__(driver)
@abc.abstractmethod @abc.abstractmethod
def list(self, project_id, marker=None, limit=None): def get_services(self, project_id, marker=None, limit=None):
"""list """Get a list of services for a project.
:param project_id :param project_id
:param marker :param marker
@ -39,19 +39,18 @@ class ServicesControllerBase(controller.StorageControllerBase):
raise NotImplementedError raise NotImplementedError
@abc.abstractmethod @abc.abstractmethod
def create(self, project_id, service_id, service_json): def create_service(self, project_id, service_obj):
"""create """Create a service.
:param project_id :param project_id
:param service_id :param service_obj
:param service_json
:raise NotImplementedError :raise NotImplementedError
""" """
raise NotImplementedError raise NotImplementedError
@abc.abstractmethod @abc.abstractmethod
def update(self, project_id, service_id, service_json): def update_service(self, project_id, service_id, service_json):
"""update """Update a service.
:param project_id :param project_id
:param service_id :param service_id
@ -64,7 +63,7 @@ class ServicesControllerBase(controller.StorageControllerBase):
@abc.abstractmethod @abc.abstractmethod
def update_state(self, project_id, service_id, state): def update_state(self, project_id, service_id, state):
"""update_state """Update service state.
Update service state Update service state
@ -76,8 +75,8 @@ class ServicesControllerBase(controller.StorageControllerBase):
raise NotImplementedError raise NotImplementedError
@abc.abstractmethod @abc.abstractmethod
def delete(self, project_id, service_id): def delete_service(self, project_id, service_id):
"""delete """Delete a service.
:param project_id :param project_id
:param service_id :param service_id
@ -86,8 +85,8 @@ class ServicesControllerBase(controller.StorageControllerBase):
raise NotImplementedError raise NotImplementedError
@abc.abstractmethod @abc.abstractmethod
def get(self): def get_service(self, project_id, service_id):
"""get """Get a service object.
:raise NotImplementedError :raise NotImplementedError
""" """
@ -95,7 +94,7 @@ class ServicesControllerBase(controller.StorageControllerBase):
@abc.abstractmethod @abc.abstractmethod
def get_provider_details(self, project_id, service_id): def get_provider_details(self, project_id, service_id):
"""get_provider_details """Get provider details for a service.
:param project_id :param project_id
:param service_id :param service_id
@ -104,36 +103,17 @@ class ServicesControllerBase(controller.StorageControllerBase):
raise NotImplementedError raise NotImplementedError
@abc.abstractmethod @abc.abstractmethod
def update_provider_details(self, provider_details): def update_provider_details(self, project_id, service_id,
"""update_provider_details provider_details):
"""Update provider details for a service.
:param provider_details
:raise NotImplementedError
"""
raise NotImplementedError
@abc.abstractmethod
def create_cert(self, project_id, cert_obj):
"""create_cert
:param project_id :param project_id
:param cert_obj :param service_id
:param provider_details
:raise NotImplementedError :raise NotImplementedError
""" """
raise NotImplementedError raise NotImplementedError
@abc.abstractmethod
def update_cert_info(self, domain_name, cert_type, flavor_id,
cert_details):
"""update_cert_info.
:param domain_name
:param cert_type
:param flavor_id
:param cert_info
"""
raise NotImplementedError
@staticmethod @staticmethod
def format_result(result): def format_result(result):
"""format_result """format_result

295
poppy/storage/cassandra/certificates.py Normal file
View File

@ -0,0 +1,295 @@
# Copyright (c) 2016 Rackspace, Inc.
#
# 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 json
from cassandra import query
from oslo_log import log
from six.moves import filterfalse
from poppy.model import ssl_certificate
from poppy.storage import base
LOG = log.getLogger(__name__)
CQL_CREATE_CERT = '''
INSERT INTO certificate_info (project_id,
flavor_id,
cert_type,
domain_name,
cert_details
)
VALUES (%(project_id)s,
%(flavor_id)s,
%(cert_type)s,
%(domain_name)s,
%(cert_details)s)
'''
CQL_SEARCH_CERT_BY_DOMAIN = '''
SELECT project_id,
flavor_id,
cert_type,
domain_name,
cert_details
FROM certificate_info
WHERE domain_name = %(domain_name)s
'''
CQL_GET_CERTS_BY_STATUS = '''
SELECT domain_name
FROM cert_status WHERE status = %(status)s
'''
CQL_DELETE_CERT = '''
DELETE FROM certificate_info
WHERE domain_name = %(domain_name)s
'''
CQL_DELETE_CERT_STATUS = '''
DELETE FROM cert_status
WHERE domain_name = %(domain_name)s
'''
CQL_INSERT_CERT_STATUS = '''
INSERT INTO cert_status (domain_name,
status
)
VALUES (%(domain_name)s,
%(status)s)
'''
CQL_UPDATE_CERT_DETAILS = '''
UPDATE certificate_info
set cert_details = %(cert_details)s
WHERE domain_name = %(domain_name)s
IF cert_type = %(cert_type)s AND flavor_id = %(flavor_id)s
'''
class CertificatesController(base.CertificatesController):
"""Certificates Controller."""
@property
def session(self):
"""Get session.
:returns session
"""
return self._driver.database
def create_certificate(self, project_id, cert_obj):
if self.cert_already_exist(domain_name=cert_obj.domain_name,
comparing_cert_type=cert_obj.cert_type,
comparing_flavor_id=cert_obj.flavor_id,
comparing_project_id=project_id):
raise ValueError('Certificate already exists '
'for {0} '.format(cert_obj.domain_name))
args = {
'project_id': project_id,
'flavor_id': cert_obj.flavor_id,
'cert_type': cert_obj.cert_type,
'domain_name': cert_obj.domain_name,
# when create the cert, cert domain has not been assigned yet
# In future we can tweak the logic to assign cert_domain
# 'cert_domain': '',
'cert_details': cert_obj.cert_details
}
stmt = query.SimpleStatement(
CQL_CREATE_CERT,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
def delete_certificate(self, project_id, domain_name, cert_type):
args = {
'domain_name': domain_name.lower()
}
stmt = query.SimpleStatement(
CQL_SEARCH_CERT_BY_DOMAIN,
consistency_level=self._driver.consistency_level)
result_set = self.session.execute(stmt, args)
complete_results = list(result_set)
if complete_results:
for r in complete_results:
r_project_id = str(r.get('project_id'))
r_cert_type = str(r.get('cert_type'))
if r_project_id == str(project_id) and \
r_cert_type == str(cert_type):
args = {
'domain_name': str(r.get('domain_name'))
}
stmt = query.SimpleStatement(
CQL_DELETE_CERT,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
stmt = query.SimpleStatement(
CQL_DELETE_CERT_STATUS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
else:
raise ValueError(
"No certificate found for: {0},"
"type: {1}".format(domain_name, cert_type))
def update_certificate(self, domain_name, cert_type, flavor_id,
cert_details):
args = {
'domain_name': domain_name,
'cert_type': cert_type,
'flavor_id': flavor_id,
'cert_details': cert_details
}
stmt = query.SimpleStatement(
CQL_UPDATE_CERT_DETAILS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
try:
provider_status = json.loads(cert_details.values()[0])
cert_status = provider_status['extra_info']['status']
except (IndexError, IndexError, ValueError) as e:
LOG.error("Certificate details "
"in inconsistent "
"state: {0}".format(cert_details))
LOG.error(e)
else:
cert_args = {
'domain_name': domain_name,
'status': cert_status
}
stmt = query.SimpleStatement(
CQL_INSERT_CERT_STATUS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, cert_args)
def get_certs_by_status(self, status):
LOG.info("Getting domains which have "
"certificate in status : {0}".format(status))
args = {
'status': status
}
stmt = query.SimpleStatement(
CQL_GET_CERTS_BY_STATUS,
consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args)
complete_results = list(resultset)
return complete_results
def get_certs_by_domain(self, domain_name, project_id=None,
flavor_id=None,
cert_type=None):
LOG.info("Check if cert on '{0}' exists".format(domain_name))
args = {
'domain_name': domain_name.lower()
}
stmt = query.SimpleStatement(
CQL_SEARCH_CERT_BY_DOMAIN,
consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args)
complete_results = list(resultset)
certs = []
if complete_results:
for r in complete_results:
r_project_id = str(r.get('project_id'))
r_flavor_id = str(r.get('flavor_id'))
r_cert_type = str(r.get('cert_type'))
r_cert_details = {}
# in case cert_details is None
cert_details = r.get('cert_details', {}) or {}
# Need to convert cassandra dict into real dict
# And the value of cert_details is a string dict
for key in cert_details:
r_cert_details[key] = json.loads(cert_details[key])
LOG.info(
"Certificate for domain: {0} with flavor_id: {1}, "
"cert_details : {2} and cert_type: {3} present "
"on project_id: {4}".format(
domain_name,
r_flavor_id,
r_cert_details,
r_cert_type,
r_project_id
)
)
ssl_cert = ssl_certificate.SSLCertificate(
domain_name=domain_name,
flavor_id=r_flavor_id,
cert_details=r_cert_details,
cert_type=r_cert_type,
project_id=r_project_id
)
certs.append(ssl_cert)
non_none_attrs_gen = filterfalse(
lambda x: list(x.values())[0] is None, [{'project_id': project_id},
{'flavor_id': flavor_id},
{'cert_type': cert_type}])
non_none_attrs_list = list(non_none_attrs_gen)
non_none_attrs_dict = {}
if non_none_attrs_list:
for attr in non_none_attrs_list:
non_none_attrs_dict.update(attr)
def argfilter(certificate):
all_conditions = True
if non_none_attrs_dict:
for k, v in non_none_attrs_dict.items():
if getattr(certificate, k) != v:
all_conditions = False
return all_conditions
total_certs = [cert for cert in certs if argfilter(cert)]
if len(total_certs) == 1:
return total_certs[0]
else:
return total_certs
def cert_already_exist(self, domain_name, comparing_cert_type,
comparing_flavor_id, comparing_project_id):
"""cert_already_exist
Check if a cert with this domain name and type has already been
created, or if the domain has been taken by other customers
:param domain_name
:param comparing_cert_type
:param comparing_flavor_id
:param comparing_project_id
:returns Boolean if the cert with same type exists with another user.
"""
cert = self.get_certs_by_domain(
domain_name=domain_name,
cert_type=comparing_cert_type,
flavor_id=comparing_flavor_id
)
if cert:
return True
else:
return False

4
poppy/storage/cassandra/controllers.py
View File

@ -23,8 +23,10 @@ Field Mappings:
updated and documented in each controller class. updated and documented in each controller class.
""" """
from poppy.storage.cassandra import certificates
from poppy.storage.cassandra import flavors from poppy.storage.cassandra import flavors
from poppy.storage.cassandra import services from poppy.storage.cassandra import services
ServicesController = services.ServicesController CertificatesController = certificates.CertificatesController
FlavorsController = flavors.FlavorsController FlavorsController = flavors.FlavorsController
ServicesController = services.ServicesController

16
poppy/storage/cassandra/driver.py
View File

@ -220,12 +220,12 @@ class CassandraStorageDriver(base.Driver):
return _connection(self.cassandra_conf, self.datacenter) return _connection(self.cassandra_conf, self.datacenter)
@property @property
def services_controller(self): def certificates_controller(self):
"""services_controller. """certificates_controller.
:returns service controller :returns certificates controller
""" """
return controllers.ServicesController(self) return controllers.CertificatesController(self)
@property @property
def flavors_controller(self): def flavors_controller(self):
@ -235,6 +235,14 @@ class CassandraStorageDriver(base.Driver):
""" """
return controllers.FlavorsController(self) return controllers.FlavorsController(self)
@property
def services_controller(self):
"""services_controller.
:returns service controller
"""
return controllers.ServicesController(self)
@property @property
def database(self): def database(self):
"""database. """database.

327
poppy/storage/cassandra/services.py
View File

@ -22,16 +22,8 @@ except ImportError: # pragma: no cover
import collections # pragma: no cover import collections # pragma: no cover
from cassandra import query from cassandra import query
import six
from oslo_log import log from oslo_log import log
if six.PY2:
from itertools import ifilterfalse as filterfalse
else:
from itertools import filterfalse
from poppy.model.helpers import cachingrule from poppy.model.helpers import cachingrule
from poppy.model.helpers import domain from poppy.model.helpers import domain
from poppy.model.helpers import origin from poppy.model.helpers import origin
@ -40,7 +32,6 @@ from poppy.model.helpers import restriction
from poppy.model.helpers import rule from poppy.model.helpers import rule
from poppy.model import log_delivery as ld from poppy.model import log_delivery as ld
from poppy.model import service from poppy.model import service
from poppy.model import ssl_certificate
from poppy.storage import base from poppy.storage import base
LOG = log.getLogger(__name__) LOG = log.getLogger(__name__)
@ -190,62 +181,6 @@ CQL_CREATE_SERVICE = '''
%(log_delivery)s) %(log_delivery)s)
''' '''
CQL_CREATE_CERT = '''
INSERT INTO certificate_info (project_id,
flavor_id,
cert_type,
domain_name,
cert_details
)
VALUES (%(project_id)s,
%(flavor_id)s,
%(cert_type)s,
%(domain_name)s,
%(cert_details)s)
'''
CQL_VERIFY_CERT = '''
SELECT project_id,
flavor_id,
cert_type,
domain_name
FROM certificate_info
WHERE domain_name = %(domain_name)s
'''
CQL_SEARCH_CERT_BY_DOMAIN = '''
SELECT project_id,
flavor_id,
cert_type,
domain_name,
cert_details
FROM certificate_info
WHERE domain_name = %(domain_name)s
'''
CQL_DELETE_CERT = '''
DELETE FROM certificate_info
WHERE domain_name = %(domain_name)s
'''
CQL_INSERT_CERT_STATUS = '''
INSERT INTO cert_status (domain_name,
status
)
VALUES (%(domain_name)s,
%(status)s)
'''
CQL_DELETE_CERT_STATUS = '''
DELETE FROM cert_status
WHERE domain_name = %(domain_name)s
'''
CQL_GET_CERTS_BY_STATUS = '''
SELECT domain_name
FROM cert_status WHERE status = %(status)s
'''
CQL_UPDATE_SERVICE = CQL_CREATE_SERVICE CQL_UPDATE_SERVICE = CQL_CREATE_SERVICE
@ -320,7 +255,7 @@ class ServicesController(base.ServicesController):
""" """
return self._driver.database return self._driver.database
def list(self, project_id, marker, limit): def get_services(self, project_id, marker, limit):
"""list. """list.
:param project_id :param project_id
@ -347,11 +282,11 @@ class ServicesController(base.ServicesController):
return services return services
def get(self, project_id, service_id): def get_service(self, project_id, service_id):
"""get. """get.
:param project_id :param project_id
:param service_name :param service_id
:returns result The requested service :returns result The requested service
:raises ValueError :raises ValueError
@ -364,8 +299,8 @@ class ServicesController(base.ServicesController):
stmt = query.SimpleStatement( stmt = query.SimpleStatement(
CQL_GET_SERVICE, CQL_GET_SERVICE,
consistency_level=self._driver.consistency_level) consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args) result_set = self.session.execute(stmt, args)
complete_result = list(resultset) complete_result = list(result_set)
if len(complete_result) != 1: if len(complete_result) != 1:
raise ValueError('No service found: %s' raise ValueError('No service found: %s'
% service_id) % service_id)
@ -418,30 +353,6 @@ class ServicesController(base.ServicesController):
LOG.exception(ex) LOG.exception(ex)
return False return False
def cert_already_exist(self, domain_name, comparing_cert_type,
comparing_flavor_id,
comparing_project_id):
"""cert_already_exist
Check if a cert with this domain name and type has already been
created, or if the domain has been taken by other customers
:param domain_name
:param comparing_cert_type
:param comparing_flavor_id
:param comparing_project_id
:returns Boolean if the cert with same type exists with another user.
"""
cert = self.get_certs_by_domain(domain_name=domain_name,
cert_type=comparing_cert_type,
flavor_id=comparing_flavor_id)
if cert:
return True
else:
return False
def get_service_count(self, project_id): def get_service_count(self, project_id):
"""get_service_count """get_service_count
@ -484,8 +395,8 @@ class ServicesController(base.ServicesController):
CQL_GET_SERVICE_STATUS, CQL_GET_SERVICE_STATUS,
consistency_level=self._driver.consistency_level) consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args) result_set = self.session.execute(stmt, args)
complete_results = list(resultset) complete_results = list(result_set)
for result in complete_results: for result in complete_results:
result['service_id'] = str(result['service_id']) result['service_id'] = str(result['service_id'])
@ -519,9 +430,9 @@ class ServicesController(base.ServicesController):
CQL_GET_BY_PROVIDER_URL, CQL_GET_BY_PROVIDER_URL,
consistency_level=self._driver.consistency_level) consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, get_domain_provider_url_args) result_set = self.session.execute(stmt, get_domain_provider_url_args)
return list(resultset) return list(result_set)
def delete_provider_url(self, provider_url, domain_name): def delete_provider_url(self, provider_url, domain_name):
@ -562,8 +473,8 @@ class ServicesController(base.ServicesController):
stmt = query.SimpleStatement( stmt = query.SimpleStatement(
CQL_GET_SERVICE_LIMIT, CQL_GET_SERVICE_LIMIT,
consistency_level=self._driver.consistency_level) consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args) result_set = self.session.execute(stmt, args)
complete_results = list(resultset) complete_results = list(result_set)
if complete_results: if complete_results:
LOG.info("Checking for service limit for project_id: '{0}' " LOG.info("Checking for service limit for project_id: '{0}' "
"existence yielded {1}".format(project_id, "existence yielded {1}".format(project_id,
@ -625,7 +536,7 @@ class ServicesController(base.ServicesController):
:param project_id :param project_id
:param service_id :param service_id
:param status
""" """
LOG.info("Setting service " LOG.info("Setting service "
@ -656,132 +567,7 @@ class ServicesController(base.ServicesController):
service_id=service_id, service_id=service_id,
provider_details=provider_details_dict) provider_details=provider_details_dict)
def get_certs_by_status(self, status): def create_service(self, project_id, service_obj):
LOG.info("Getting domains which have "
"certificate in status : {0}".format(status))
args = {
'status': status
}
stmt = query.SimpleStatement(
CQL_GET_CERTS_BY_STATUS,
consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args)
complete_results = list(resultset)
return complete_results
def get_certs_by_domain(self, domain_name, project_id=None, flavor_id=None,
cert_type=None):
LOG.info("Check if cert on '{0}' exists".format(domain_name))
args = {
'domain_name': domain_name.lower()
}
stmt = query.SimpleStatement(
CQL_SEARCH_CERT_BY_DOMAIN,
consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args)
complete_results = list(resultset)
certs = []
if complete_results:
for r in complete_results:
r_project_id = str(r.get('project_id'))
r_flavor_id = str(r.get('flavor_id'))
r_cert_type = str(r.get('cert_type'))
r_cert_details = {}
# in case cert_details is None
cert_details = r.get('cert_details', {}) or {}
# Need to convert cassandra dict into real dict
# And the value of cert_details is a string dict
for key in cert_details:
r_cert_details[key] = json.loads(cert_details[key])
LOG.info("Certificate for domain: {0} "
"with flavor_id: {1}, "
"cert_details : {2} and "
"cert_type: {3} present "
"on project_id: {4}".format(domain_name,
r_flavor_id,
r_cert_details,
r_cert_type,
r_project_id))
ssl_cert = ssl_certificate.SSLCertificate(
domain_name=domain_name,
flavor_id=r_flavor_id,
cert_details=r_cert_details,
cert_type=r_cert_type,
project_id=r_project_id)
certs.append(ssl_cert)
non_none_attrs_gen = filterfalse(
lambda x: list(x.values())[0] is None, [{'project_id': project_id},
{'flavor_id': flavor_id},
{'cert_type': cert_type}])
non_none_attrs_list = list(non_none_attrs_gen)
non_none_attrs_dict = {}
if non_none_attrs_list:
for attr in non_none_attrs_list:
non_none_attrs_dict.update(attr)
def argfilter(certificate):
all_conditions = True
if non_none_attrs_dict:
for k, v in non_none_attrs_dict.items():
if getattr(certificate, k) != v:
all_conditions = False
return all_conditions
total_certs = [cert for cert in certs if argfilter(cert)]
if len(total_certs) == 1:
return total_certs[0]
else:
return total_certs
def delete_cert(self, project_id, domain_name, cert_type):
"""delete_cert
Delete a certificate.
:param project_id
:param domain_name
:param cert_type
:raises ValueError
"""
args = {
'domain_name': domain_name.lower()
}
stmt = query.SimpleStatement(
CQL_SEARCH_CERT_BY_DOMAIN,
consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args)
complete_results = list(resultset)
if complete_results:
for r in complete_results:
r_project_id = str(r.get('project_id'))
r_cert_type = str(r.get('cert_type'))
if r_project_id == str(project_id) and \
r_cert_type == str(cert_type):
args = {
'domain_name': str(r.get('domain_name'))
}
stmt = query.SimpleStatement(
CQL_DELETE_CERT,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
stmt = query.SimpleStatement(
CQL_DELETE_CERT_STATUS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
else:
raise ValueError("No certificate found for: {0},"
"type: {1}".format(domain_name, cert_type))
def create(self, project_id, service_obj):
"""create. """create.
:param project_id :param project_id
@ -842,7 +628,7 @@ class ServicesController(base.ServicesController):
self.session.execute(batch) self.session.execute(batch)
def update(self, project_id, service_id, service_obj): def update_service(self, project_id, service_id, service_obj):
"""update. """update.
:param project_id :param project_id
@ -876,8 +662,8 @@ class ServicesController(base.ServicesController):
CQL_GET_SERVICE, CQL_GET_SERVICE,
consistency_level=self._driver.consistency_level) consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args) result_set = self.session.execute(stmt, args)
complete_results = list(resultset) complete_results = list(result_set)
result = complete_results[0] result = complete_results[0]
# updates an existing service # updates an existing service
@ -938,9 +724,7 @@ class ServicesController(base.ServicesController):
self.session.execute(stmt, args) self.session.execute(stmt, args)
def update_state(self, project_id, service_id, state): def update_state(self, project_id, service_id, state):
"""update_state """Update service state
Update service state
:param project_id :param project_id
:param service_id :param service_id
@ -949,13 +733,13 @@ class ServicesController(base.ServicesController):
:returns service_obj :returns service_obj
""" """
service_obj = self.get(project_id, service_id) service_obj = self.get_service(project_id, service_id)
service_obj.operator_status = state service_obj.operator_status = state
self.update(project_id, service_id, service_obj) self.update_service(project_id, service_id, service_obj)
return service_obj return service_obj
def delete(self, project_id, service_id): def delete_service(self, project_id, service_id):
"""delete. """delete.
Archive local configuration storage Archive local configuration storage
@ -1033,29 +817,6 @@ class ServicesController(base.ServicesController):
consistency_level=self._driver.consistency_level) consistency_level=self._driver.consistency_level)
self.session.execute(stmt, delete_args) self.session.execute(stmt, delete_args)
def create_cert(self, project_id, cert_obj):
if self.cert_already_exist(domain_name=cert_obj.domain_name,
comparing_cert_type=cert_obj.cert_type,
comparing_flavor_id=cert_obj.flavor_id,
comparing_project_id=project_id):
raise ValueError('Certificate already exists '
'for {0} '.format(cert_obj.domain_name))
args = {
'project_id': project_id,
'flavor_id': cert_obj.flavor_id,
'cert_type': cert_obj.cert_type,
'domain_name': cert_obj.domain_name,
# when create the cert, cert domain has not been assigned yet
# In future we can tweak the logic to assign cert_domain
# 'cert_domain': '',
'cert_details': cert_obj.cert_details
}
stmt = query.SimpleStatement(
CQL_CREATE_CERT,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
def get_provider_details(self, project_id, service_id): def get_provider_details(self, project_id, service_id):
"""get_provider_details. """get_provider_details.
@ -1108,6 +869,7 @@ class ServicesController(base.ServicesController):
"""get_provider_details_by_domain_name. """get_provider_details_by_domain_name.
:param domain_name :param domain_name
:param project_id
:returns Provider details :returns Provider details
""" """
@ -1119,8 +881,8 @@ class ServicesController(base.ServicesController):
stmt = query.SimpleStatement( stmt = query.SimpleStatement(
CQL_SEARCH_BY_DOMAIN, CQL_SEARCH_BY_DOMAIN,
consistency_level=self._driver.consistency_level) consistency_level=self._driver.consistency_level)
resultset = self.session.execute(stmt, args) result_set = self.session.execute(stmt, args)
complete_results = list(resultset) complete_results = list(result_set)
# If there is not service with this domain # If there is not service with this domain
# return None # return None
details = None details = None
@ -1131,8 +893,8 @@ class ServicesController(base.ServicesController):
"present under " "present under "
"project_id: {1}".format(domain_name, "project_id: {1}".format(domain_name,
project_id)) project_id))
service = r.get('service_id') service_id = r.get('service_id')
details = self.get(proj_id, service) details = self.get_service(proj_id, service_id)
return details return details
def update_provider_details(self, project_id, service_id, def update_provider_details(self, project_id, service_id,
@ -1212,45 +974,6 @@ class ServicesController(base.ServicesController):
consistency_level=self._driver.consistency_level) consistency_level=self._driver.consistency_level)
self.session.execute(stmt, provider_url_args) self.session.execute(stmt, provider_url_args)
def update_cert_info(self, domain_name, cert_type, flavor_id,
cert_details):
"""update_cert_info.
:param domain_name
:param cert_type
:param flavor_id
:param cert_info
"""
args = {
'domain_name': domain_name,
'cert_type': cert_type,
'flavor_id': flavor_id,
'cert_details': cert_details
}
stmt = query.SimpleStatement(
CQL_UPDATE_CERT_DETAILS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, args)
try:
provider_status = json.loads(cert_details.values()[0])
cert_status = provider_status['extra_info']['status']
except (IndexError, IndexError, ValueError) as e:
LOG.error("Certificate details "
"in inconsistent "
"state: {0}".format(cert_details))
LOG.error(e)
else:
cert_args = {
'domain_name': domain_name,
'status': cert_status
}
stmt = query.SimpleStatement(
CQL_INSERT_CERT_STATUS,
consistency_level=self._driver.consistency_level)
self.session.execute(stmt, cert_args)
@staticmethod @staticmethod
def format_result(result): def format_result(result):
"""format_result. """format_result.

77
poppy/storage/mockdb/certificates.py Normal file
View File

@ -0,0 +1,77 @@
# Copyright (c) 2016 Rackspace, Inc.
#
# 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 random
from poppy.model import ssl_certificate
from poppy.storage import base
class CertificatesController(base.CertificatesController):
def __init__(self, driver):
super(CertificatesController, self).__init__(driver)
self.certs = {}
def create_certificate(self, project_id, cert_obj):
key = (cert_obj.flavor_id, cert_obj.domain_name, cert_obj.cert_type)
if key not in self.certs:
self.certs[key] = cert_obj
else:
raise ValueError
def delete_certificate(self, project_id, domain_name, cert_type):
if "non_exist" in domain_name:
raise ValueError("No certs on this domain")
def update_certificate(self, domain_name, cert_type, flavor_id,
cert_details):
key = (flavor_id, domain_name, cert_type)
if key in self.certs:
self.certs[key].cert_details = cert_details
def get_certs_by_domain(self, domain_name, project_id=None,
flavor_id=None,
cert_type=None,
status=u'create_in_progress'):
certs = []
for cert in self.certs:
if domain_name in cert:
certs.append(self.certs[cert])
if project_id:
if flavor_id is not None and cert_type is not None:
return ssl_certificate.SSLCertificate(
"premium",
"blog.testabcd.com",
"san",
project_id=project_id,
cert_details={
'Akamai': {
u'cert_domain': u'secure2.san1.test_123.com',
u'extra_info': {
u'action': u'Waiting for customer domain '
'validation for blog.testabc.com',
u'akamai_spsId': str(random.randint(1, 100000)
),
u'create_at': u'2015-09-29 16:09:12.429147',
u'san cert': u'secure2.san1.test_123.com',
u'status': status}
}
}
)
return [cert for cert in certs if cert.project_id == project_id]
else:
return certs

4
poppy/storage/mockdb/controllers.py
View File

@ -23,8 +23,10 @@ Field Mappings:
updated and documented in each controller class. updated and documented in each controller class.
""" """
from poppy.storage.mockdb import certificates
from poppy.storage.mockdb import flavors from poppy.storage.mockdb import flavors
from poppy.storage.mockdb import services from poppy.storage.mockdb import services
ServicesController = services.ServicesController CertificatesController = certificates.CertificatesController
FlavorsController = flavors.FlavorsController FlavorsController = flavors.FlavorsController
ServicesController = services.ServicesController

8
poppy/storage/mockdb/driver.py
View File

@ -59,13 +59,17 @@ class MockDBStorageDriver(base.Driver):
return _connection() return _connection()
@property @property
def services_controller(self): def certificates_controller(self):
return controllers.ServicesController(self) return controllers.CertificatesController(self)
@property @property
def flavors_controller(self): def flavors_controller(self):
return controllers.FlavorsController(self) return controllers.FlavorsController(self)
@property
def services_controller(self):
return controllers.ServicesController(self)
@property @property
def database(self): def database(self):
return self.connection return self.connection

89
poppy/storage/mockdb/services.py
View File

@ -14,7 +14,6 @@
# limitations under the License. # limitations under the License.
import json import json
import random
from poppy.model.helpers import domain from poppy.model.helpers import domain
from poppy.model.helpers import origin from poppy.model.helpers import origin
@ -22,28 +21,32 @@ from poppy.model.helpers import provider_details
from poppy.model.helpers import restriction from poppy.model.helpers import restriction
from poppy.model.helpers import rule from poppy.model.helpers import rule
from poppy.model import service from poppy.model import service
from poppy.model import ssl_certificate
from poppy.storage import base from poppy.storage import base
created_services = {}
created_service_ids = []
claimed_domains = []
project_id_service_limit = {}
service_count_per_project_id = {}
class ServicesController(base.ServicesController): class ServicesController(base.ServicesController):
def __init__(self, driver): def __init__(self, driver):
super(ServicesController, self).__init__(driver) super(ServicesController, self).__init__(driver)
self.created_service_ids = [] self.created_service_ids = created_service_ids
self.created_services = {} self.created_services = created_services
self.claimed_domains = [] self.claimed_domains = claimed_domains
self.projectid_service_limit = {} self.project_id_service_limit = project_id_service_limit
self.default_max_service_limit = 20 self.default_max_service_limit = 20
self.service_count_per_project_id = {} self.service_count_per_project_id = service_count_per_project_id
self.certs = {}
@property @property
def session(self): def session(self):
return self._driver.database return self._driver.database
def list(self, project_id, marker=None, limit=None): def get_services(self, project_id, marker=None, limit=None):
services = [] services = []
for service_id in self.created_services: for service_id in self.created_services:
services.append(self.created_services[service_id]) services.append(self.created_services[service_id])
@ -55,7 +58,7 @@ class ServicesController(base.ServicesController):
return services_result return services_result
def get(self, project_id, service_id): def get_service(self, project_id, service_id):
# get the requested service from storage # get the requested service from storage
if service_id not in self.created_service_ids: if service_id not in self.created_service_ids:
raise ValueError("service {0} does not exist".format(service_id)) raise ValueError("service {0} does not exist".format(service_id))
@ -65,7 +68,7 @@ class ServicesController(base.ServicesController):
service_result._status = 'deployed' service_result._status = 'deployed'
return service_result return service_result
def create(self, project_id, service_obj): def create_service(self, project_id, service_obj):
if service_obj.service_id in self.created_service_ids: if service_obj.service_id in self.created_service_ids:
raise ValueError("Service %s already exists." % raise ValueError("Service %s already exists." %
service_obj.service_id) service_obj.service_id)
@ -80,11 +83,11 @@ class ServicesController(base.ServicesController):
self.service_count_per_project_id[project_id] = 1 self.service_count_per_project_id[project_id] = 1
def set_service_limit(self, project_id, project_limit): def set_service_limit(self, project_id, project_limit):
self.projectid_service_limit[project_id] = project_limit self.project_id_service_limit[project_id] = project_limit
def get_service_limit(self, project_id): def get_service_limit(self, project_id):
try: try:
return self.projectid_service_limit[project_id] return self.project_id_service_limit[project_id]
except KeyError: except KeyError:
return self.default_max_service_limit return self.default_max_service_limit
@ -106,7 +109,7 @@ class ServicesController(base.ServicesController):
return complete_results return complete_results
def update(self, project_id, service_id, service_json): def update_service(self, project_id, service_id, service_json):
# update configuration in storage # update configuration in storage
if service_json.service_id in self.created_service_ids \ if service_json.service_id in self.created_service_ids \
and service_json.service_id == service_id: and service_json.service_id == service_id:
@ -132,14 +135,14 @@ class ServicesController(base.ServicesController):
:returns service_obj :returns service_obj
""" """
service_obj = self.get(project_id, service_id) service_obj = self.get_service(project_id, service_id)
service_obj.operator_status = state service_obj.operator_status = state
self.update(project_id, service_id, service_obj) self.update_service(project_id, service_id, service_obj)
return self.get(project_id, service_id) return self.get_service(project_id, service_id)
def delete(self, project_id, service_id): def delete_service(self, project_id, service_id):
if (service_id in self.created_service_ids): if service_id in self.created_service_ids:
self.created_service_ids.remove(service_id) self.created_service_ids.remove(service_id)
try: try:
self.service_count_per_project_id[project_id] -= 1 self.service_count_per_project_id[project_id] -= 1
@ -179,12 +182,6 @@ class ServicesController(base.ServicesController):
def domain_exists_elsewhere(self, domain_name, service_id): def domain_exists_elsewhere(self, domain_name, service_id):
return domain_name in self.claimed_domains return domain_name in self.claimed_domains
def update_cert_info(self, domain_name, cert_type, flavor_id,
cert_details):
key = (flavor_id, domain_name, cert_type)
if key in self.certs:
self.certs[key].cert_details = cert_details
def get_service_details_by_domain_name(self, domain_name, def get_service_details_by_domain_name(self, domain_name,
project_id=None): project_id=None):
for service_id in self.created_services: for service_id in self.created_services:
@ -195,48 +192,6 @@ class ServicesController(base.ServicesController):
service_result._status = 'deployed' service_result._status = 'deployed'
return service_result return service_result
def create_cert(self, project_id, cert_obj):
key = (cert_obj.flavor_id, cert_obj.domain_name, cert_obj.cert_type)
if key not in self.certs:
self.certs[key] = cert_obj
else:
raise ValueError
def get_certs_by_domain(self, domain_name, project_id=None, flavor_id=None,
cert_type=None, status=u'create_in_progress'):
certs = []
for cert in self.certs:
if domain_name in cert:
certs.append(self.certs[cert])
if project_id:
if flavor_id is not None and cert_type is not None:
return ssl_certificate.SSLCertificate(
"premium",
"blog.testabcd.com",
"san",
project_id=project_id,
cert_details={
'Akamai': {
u'cert_domain': u'secure2.san1.test_123.com',
u'extra_info': {
u'action': u'Waiting for customer domain '
'validation for blog.testabc.com',
u'akamai_spsId': str(random.randint(1, 100000)
),
u'create_at': u'2015-09-29 16:09:12.429147',
u'san cert': u'secure2.san1.test_123.com',
u'status': status}
}
}
)
return [cert for cert in certs if cert.project_id == project_id]
else:
return certs
def delete_cert(self, project_id, domain_name, cert_type):
if "non_exist" in domain_name:
raise ValueError("No certs on this domain")
@staticmethod @staticmethod
def format_result(result): def format_result(result):
service_id = result.get('service_id') service_id = result.get('service_id')

9
poppy/transport/pecan/controllers/v1/admin.py
View File

@ -425,16 +425,17 @@ class AdminCertController(base.Controller, hooks.HookController):
stoplight_helpers.pecan_getter) stoplight_helpers.pecan_getter)
) )
def get(self): def get(self):
services_controller = self._driver.manager.services_controller ssl_certificate_controller = (
self._driver.manager.ssl_certificate_controller
)
call_args = getattr(pecan.request.context, call_args = getattr(pecan.request.context,
"call_args") "call_args")
status = call_args.pop('status') status = call_args.pop('status')
cert_domains = services_controller.get_certs_by_status( cert_domains = ssl_certificate_controller.get_certs_by_status(
status) status)
return pecan.Response(json_body=cert_domains, return pecan.Response(json_body=cert_domains, status=200)
status=200)
class AdminServiceController(base.Controller, hooks.HookController): class AdminServiceController(base.Controller, hooks.HookController):

16
poppy/transport/pecan/controllers/v1/services.py
View File

@ -173,7 +173,7 @@ class ServicesController(base.Controller, hooks.HookController):
pecan.abort(400, detail="Marker must be a valid UUID") pecan.abort(400, detail="Marker must be a valid UUID")
services_controller = self._driver.manager.services_controller services_controller = self._driver.manager.services_controller
service_resultset = services_controller.list( service_resultset = services_controller.get_services(
self.project_id, marker, limit) self.project_id, marker, limit)
results = [ results = [
resp_service_model.Model(s, self) resp_service_model.Model(s, self)
@ -202,7 +202,7 @@ class ServicesController(base.Controller, hooks.HookController):
def get_one(self, service_id): def get_one(self, service_id):
services_controller = self._driver.manager.services_controller services_controller = self._driver.manager.services_controller
try: try:
service_obj = services_controller.get( service_obj = services_controller.get_service(
self.project_id, service_id) self.project_id, service_id)
except ValueError: except ValueError:
pecan.abort(404, detail='service %s could not be found' % pecan.abort(404, detail='service %s could not be found' %
@ -222,9 +222,11 @@ class ServicesController(base.Controller, hooks.HookController):
service_json_dict = json.loads(pecan.request.body.decode('utf-8')) service_json_dict = json.loads(pecan.request.body.decode('utf-8'))
service_id = None service_id = None
try: try:
service_obj = services_controller.create(self.project_id, service_obj = services_controller.create_service(
self.auth_token, self.project_id,
service_json_dict) self.auth_token,
service_json_dict
)
service_id = service_obj.service_id service_id = service_obj.service_id
except errors.SharedShardsExhausted as e: except errors.SharedShardsExhausted as e:
# domain - shared domains exhausted # domain - shared domains exhausted
@ -253,7 +255,7 @@ class ServicesController(base.Controller, hooks.HookController):
services_controller = self._driver.manager.services_controller services_controller = self._driver.manager.services_controller
try: try:
services_controller.delete(self.project_id, service_id) services_controller.delete_service(self.project_id, service_id)
except LookupError as e: except LookupError as e:
pecan.abort(404, detail=str(e)) pecan.abort(404, detail=str(e))
except ValueError as e: except ValueError as e:
@ -277,7 +279,7 @@ class ServicesController(base.Controller, hooks.HookController):
services_controller = self._driver.manager.services_controller services_controller = self._driver.manager.services_controller
try: try:
services_controller.update( services_controller.update_service(
self.project_id, service_id, self.auth_token, service_updates) self.project_id, service_id, self.auth_token, service_updates)
except exceptions.ValidationFailed as e: except exceptions.ValidationFailed as e:
pecan.abort(400, detail=u'{0}'.format(e)) pecan.abort(400, detail=u'{0}'.format(e))

30
tests/functional/transport/pecan/base.py
View File

@ -20,6 +20,7 @@ from oslo_config import cfg
import webtest import webtest
from poppy import bootstrap from poppy import bootstrap
from poppy.storage.mockdb import services
from tests.functional import base from tests.functional import base
@ -34,24 +35,33 @@ class BaseFunctionalTest(base.TestCase):
)))) ))))
conf_path = os.path.join(tests_path, 'etc', 'default_functional.conf') conf_path = os.path.join(tests_path, 'etc', 'default_functional.conf')
cfg.CONF(args=[], default_config_files=[conf_path]) cfg.CONF(args=[], default_config_files=[conf_path])
b_obj = bootstrap.Bootstrap(cfg.CONF) self.b_obj = bootstrap.Bootstrap(cfg.CONF)
# mock the persistence part for taskflow distributed_task # mock the persistence part for taskflow distributed_task
mock_persistence = mock.Mock() mock_persistence = mock.Mock()
mock_persistence.__enter__ = mock.Mock() mock_persistence.__enter__ = mock.Mock()
mock_persistence.__exit__ = mock.Mock() mock_persistence.__exit__ = mock.Mock()
b_obj.distributed_task.persistence = mock.Mock() self.b_obj.distributed_task.persistence = mock.Mock()
b_obj.distributed_task.persistence.return_value = mock_persistence self.b_obj.distributed_task.persistence.return_value = mock_persistence
b_obj.distributed_task.job_board = mock.Mock() self.b_obj.distributed_task.job_board = mock.Mock()
b_obj.distributed_task.job_board.return_value = ( self.b_obj.distributed_task.job_board.return_value = (
mock_persistence.copy()) mock_persistence.copy())
b_obj.distributed_task.is_alive = mock.Mock(return_value=True) self.b_obj.distributed_task.is_alive = mock.Mock(return_value=True)
# Note(tonytan4ever):Need this hack to preserve mockdb storage # Note(tonytan4ever):Need this hack to preserve mockdb storage
# controller's service cache # controller's service cache
b_obj.manager.ssl_certificate_controller.storage_controller = ( # b_obj.manager.ssl_certificate_controller.storage_controller = (
b_obj.manager.services_controller.storage_controller # b_obj.manager.services_controller.storage_controller
) # )
poppy_wsgi = b_obj.transport.app poppy_wsgi = self.b_obj.transport.app
self.app = webtest.app.TestApp(poppy_wsgi) self.app = webtest.app.TestApp(poppy_wsgi)
def tearDown(self):
super(BaseFunctionalTest, self).tearDown()
services.created_services = {}
services.created_service_ids = []
services.claimed_domains = []
services.project_id_service_limit = {}
services.service_count_per_project_id = {}
FunctionalTest = BaseFunctionalTest FunctionalTest = BaseFunctionalTest

5
tests/functional/transport/pecan/controllers/test_get_ssl_certficate_by_status.py
View File

@ -21,7 +21,8 @@ from hypothesis import strategies
import mock import mock
import six import six
from poppy.manager.default.services import DefaultServicesController from poppy.manager.default.ssl_certificate import \
DefaultSSLCertificateController
from tests.functional.transport.pecan import base from tests.functional.transport.pecan import base
@ -56,7 +57,7 @@ class SSLCertificatebyStatusTest(base.FunctionalTest):
@ddt.data(u'create_in_progress', u'deployed', u'failed', u'cancelled') @ddt.data(u'create_in_progress', u'deployed', u'failed', u'cancelled')
def test_get_service_status_valid_queryparam(self, status): def test_get_service_status_valid_queryparam(self, status):
# valid status # valid status
with mock.patch.object(DefaultServicesController, with mock.patch.object(DefaultSSLCertificateController,
'get_certs_by_status'): 'get_certs_by_status'):
response = self.app.get('/v1.0/admin/certificates' response = self.app.get('/v1.0/admin/certificates'
'?status={0}'.format(status), '?status={0}'.format(status),

12
tests/functional/transport/pecan/controllers/test_retry_list.py
View File

@ -20,7 +20,7 @@ import uuid
import ddt import ddt
import mock import mock
from poppy.storage.mockdb import services from poppy.storage.mockdb import certificates
from tests.functional.transport.pecan import base from tests.functional.transport.pecan import base
@ -100,10 +100,10 @@ class TestRetryList(base.FunctionalTest):
def test_put_retry_list_negative_with_deployed_domain(self): def test_put_retry_list_negative_with_deployed_domain(self):
# A cert already in deployed status will cause 400. # A cert already in deployed status will cause 400.
with mock.patch('poppy.storage.mockdb.services.ServicesController.' with mock.patch('poppy.storage.mockdb.certificates.'
'get_certs_by_domain', 'CertificatesController.get_certs_by_domain',
new=functools. new=functools.
partial(services.ServicesController. partial(certificates.CertificatesController.
get_certs_by_domain, get_certs_by_domain,
status='deployed')): status='deployed')):
self.service_name = str(uuid.uuid1()) self.service_name = str(uuid.uuid1())
@ -228,7 +228,7 @@ class TestRetryList(base.FunctionalTest):
'X-Project-ID': self.project_id}) 'X-Project-ID': self.project_id})
self.assertEqual(202, response.status_code) self.assertEqual(202, response.status_code)
# This time the service is present, so the request goes thru # This time the service is present, so the request goes through
put_data = [ put_data = [
{ {
"domain_name": "test-san1.cnamecdn.com", "domain_name": "test-san1.cnamecdn.com",
@ -249,7 +249,7 @@ class TestRetryList(base.FunctionalTest):
headers={ headers={
'Content-Type': 'application/json', 'Content-Type': 'application/json',
'X-Project-ID': self.project_id}, 'X-Project-ID': self.project_id},
expect_errors=True) )
self.assertEqual(200, response.status_code) self.assertEqual(200, response.status_code)
def test_post_retry_list(self): def test_post_retry_list(self):

199
tests/unit/distributed_task/taskflow/test_flows.py
View File

@ -72,7 +72,10 @@ class TestFlowRuns(base.TestCase):
memoized_controllers.task_controllers('poppy', 'storage') memoized_controllers.task_controllers('poppy', 'storage')
service_controller, dns_controller = \ service_controller, dns_controller = \
memoized_controllers.task_controllers('poppy', 'dns') memoized_controllers.task_controllers('poppy', 'dns')
return service_controller, storage_controller, dns_controller service_controller, ssl_cert_controller = \
memoized_controllers.task_controllers('poppy', 'ssl_certificate')
return service_controller, storage_controller, dns_controller, \
ssl_cert_controller
def dns_exceptions_and_succeed(self): def dns_exceptions_and_succeed(self):
# NOTE(TheSriram): create a chain of mocked return values, # NOTE(TheSriram): create a chain of mocked return values,
@ -193,12 +196,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_create_flow(service_controller, self.patch_create_flow(service_controller,
@ -235,12 +243,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_update_flow(service_controller, storage_controller, self.patch_update_flow(service_controller, storage_controller,
@ -270,12 +283,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_delete_flow(service_controller, storage_controller, self.patch_delete_flow(service_controller, storage_controller,
@ -306,12 +324,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_purge_flow(service_controller, storage_controller, self.patch_purge_flow(service_controller, storage_controller,
@ -343,12 +366,17 @@ class TestFlowRuns(base.TestCase):
disable_kwargs = enable_kwargs.copy() disable_kwargs = enable_kwargs.copy()
disable_kwargs['state'] = 'disable' disable_kwargs['state'] = 'disable'
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_service_state_flow(service_controller, self.patch_service_state_flow(service_controller,
@ -374,12 +402,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_create_flow(service_controller, storage_controller, self.patch_create_flow(service_controller, storage_controller,
@ -424,12 +457,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_update_flow(service_controller, storage_controller, self.patch_update_flow(service_controller, storage_controller,
@ -469,12 +507,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_delete_flow(service_controller, storage_controller, self.patch_delete_flow(service_controller, storage_controller,
@ -513,12 +556,17 @@ class TestFlowRuns(base.TestCase):
disable_kwargs = enable_kwargs.copy() disable_kwargs = enable_kwargs.copy()
disable_kwargs['state'] = 'disable' disable_kwargs['state'] = 'disable'
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_service_state_flow(service_controller, self.patch_service_state_flow(service_controller,
@ -574,12 +622,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_update_flow(service_controller, storage_controller, self.patch_update_flow(service_controller, storage_controller,
@ -621,12 +674,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_update_flow(service_controller, storage_controller, self.patch_update_flow(service_controller, storage_controller,
@ -654,12 +712,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_create_flow(service_controller, storage_controller, self.patch_create_flow(service_controller, storage_controller,
@ -687,12 +750,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_create_flow(service_controller, storage_controller, self.patch_create_flow(service_controller, storage_controller,
@ -730,12 +798,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_delete_flow(service_controller, storage_controller, self.patch_delete_flow(service_controller, storage_controller,
@ -770,12 +843,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_delete_flow(service_controller, storage_controller, self.patch_delete_flow(service_controller, storage_controller,
@ -812,12 +890,17 @@ class TestFlowRuns(base.TestCase):
disable_kwargs = enable_kwargs.copy() disable_kwargs = enable_kwargs.copy()
disable_kwargs['state'] = 'disable' disable_kwargs['state'] = 'disable'
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_service_state_flow(service_controller, self.patch_service_state_flow(service_controller,
@ -860,12 +943,17 @@ class TestFlowRuns(base.TestCase):
disable_kwargs = enable_kwargs.copy() disable_kwargs = enable_kwargs.copy()
disable_kwargs['state'] = 'disable' disable_kwargs['state'] = 'disable'
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_service_state_flow(service_controller, self.patch_service_state_flow(service_controller,
storage_controller, storage_controller,
@ -902,12 +990,17 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_create_ssl_certificate_flow(service_controller, self.patch_create_ssl_certificate_flow(service_controller,
@ -934,12 +1027,17 @@ class TestFlowRuns(base.TestCase):
'cert_obj_json': json.dumps(cert_obj_json.to_dict()), 'cert_obj_json': json.dumps(cert_obj_json.to_dict()),
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_recreate_ssl_certificate_flow(service_controller, self.patch_recreate_ssl_certificate_flow(service_controller,
@ -962,16 +1060,25 @@ class TestFlowRuns(base.TestCase):
'context_dict': context_utils.RequestContext().to_dict() 'context_dict': context_utils.RequestContext().to_dict()
} }
service_controller, storage_controller, dns_controller = \ (
self.all_controllers() service_controller,
storage_controller,
dns_controller,
ssl_cert_controller
) = self.all_controllers()
with MonkeyPatchControllers(service_controller, with MonkeyPatchControllers(service_controller,
dns_controller, dns_controller,
storage_controller, storage_controller,
ssl_cert_controller,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.patch_create_ssl_certificate_flow(service_controller, self.patch_create_ssl_certificate_flow(
storage_controller, service_controller,
dns_controller) storage_controller,
engines.run(delete_ssl_certificate.delete_ssl_certificate(), dns_controller
store=kwargs) )
engines.run(
delete_ssl_certificate.delete_ssl_certificate(),
store=kwargs
)

67
tests/unit/manager/default/test_services.py
View File

@ -76,10 +76,11 @@ class MonkeyPatchControllers(object):
def __init__(self, service_controller, def __init__(self, service_controller,
dns_controller, dns_controller,
storage_controller, func): storage_controller, ssl_cert_controller, func):
self.service_controller = service_controller self.service_controller = service_controller
self.dns_controller = dns_controller self.dns_controller = dns_controller
self.storage_controller = storage_controller self.storage_controller = storage_controller
self.ssl_cert_controller = ssl_cert_controller
self.func = func self.func = func
def __enter__(self): def __enter__(self):
@ -89,6 +90,8 @@ class MonkeyPatchControllers(object):
return self.service_controller, self.storage_controller return self.service_controller, self.storage_controller
if controller == 'dns': if controller == 'dns':
return self.service_controller, self.dns_controller return self.service_controller, self.dns_controller
if controller == 'ssl_certificate':
return self.service_controller, self.ssl_cert_controller
else: else:
return self.service_controller return self.service_controller
@ -437,14 +440,17 @@ class DefaultManagerServiceTests(base.TestCase):
self.sc.storage_controller.get_service_count = mock.Mock( self.sc.storage_controller.get_service_count = mock.Mock(
return_value=1) return_value=1)
service_obj = self.sc.create(self.project_id, service_obj = self.sc.create_service(
self.auth_token, self.project_id,
self.service_json) self.auth_token,
self.service_json
)
# ensure the manager calls the storage driver with the appropriate data # ensure the manager calls the storage driver with the appropriate data
self.sc.storage_controller.create.assert_called_once_with( self.sc.storage_controller.create_service.assert_called_once_with(
self.project_id, self.project_id,
service_obj) service_obj
)
@ddt.file_data('data_provider_details.json') @ddt.file_data('data_provider_details.json')
def test_create_service_worker(self, provider_details_json): def test_create_service_worker(self, provider_details_json):
@ -518,6 +524,7 @@ class DefaultManagerServiceTests(base.TestCase):
with MonkeyPatchControllers(self.sc, with MonkeyPatchControllers(self.sc,
self.sc.dns_controller, self.sc.dns_controller,
self.sc.storage_controller, self.sc.storage_controller,
self.sc.ssl_certificate_storage,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.mock_create_service(provider_details_json) self.mock_create_service(provider_details_json)
@ -621,6 +628,7 @@ class DefaultManagerServiceTests(base.TestCase):
with MonkeyPatchControllers(self.sc, with MonkeyPatchControllers(self.sc,
self.sc.dns_controller, self.sc.dns_controller,
self.sc.storage_controller, self.sc.storage_controller,
self.sc.ssl_certificate_storage,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
# NOTE(TheSriram): Successful update # NOTE(TheSriram): Successful update
@ -675,7 +683,7 @@ class DefaultManagerServiceTests(base.TestCase):
service_obj = service.load_from_json(self.service_json) service_obj = service.load_from_json(self.service_json)
service_obj.status = u'deployed' service_obj.status = u'deployed'
self.sc.storage_controller.get.return_value = service_obj self.sc.storage_controller.get_service.return_value = service_obj
service_updates = json.dumps([ service_updates = json.dumps([
{ {
"op": "replace", "op": "replace",
@ -684,13 +692,15 @@ class DefaultManagerServiceTests(base.TestCase):
} }
]) ])
self.sc.update(self.project_id, self.sc.update_service(
self.service_id, self.project_id,
self.auth_token, self.service_id,
service_updates) self.auth_token,
service_updates
)
# ensure the manager calls the storage driver with the appropriate data # ensure the manager calls the storage driver with the appropriate data
self.sc.storage_controller.update.assert_called_once() self.sc.storage_controller.update_service.assert_called_once()
@ddt.file_data('data_provider_details.json') @ddt.file_data('data_provider_details.json')
def test_delete(self, provider_details_json): def test_delete(self, provider_details_json):
@ -710,16 +720,21 @@ class DefaultManagerServiceTests(base.TestCase):
self.service_obj.provider_details = self.provider_details self.service_obj.provider_details = self.provider_details
sc = self.sc.storage_controller sc = self.sc.storage_controller
sc.get.return_value = self.service_obj sc.get_service.return_value = self.service_obj
self.sc.delete(self.project_id, self.service_id) self.sc.delete_service(self.project_id, self.service_id)
# ensure the manager calls the storage driver with the appropriate data # ensure the manager calls the storage driver with the appropriate data
sc.get.assert_called_once_with(self.project_id, self.service_id) sc.get_service.assert_called_once_with(
sc.update.assert_called_once_with(self.project_id, self.project_id,
self.service_id, self.service_id
self.service_obj) )
sc.update_service.assert_called_once_with(
self.project_id,
self.service_id,
self.service_obj
)
# break into 2 lines. # break into 2 lines.
sc = self.sc.storage_controller sc = self.sc.storage_controller
@ -791,6 +806,7 @@ class DefaultManagerServiceTests(base.TestCase):
with MonkeyPatchControllers(self.sc, with MonkeyPatchControllers(self.sc,
self.sc.dns_controller, self.sc.dns_controller,
self.sc.storage_controller, self.sc.storage_controller,
self.sc.ssl_certificate_storage,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.mock_delete_service() self.mock_delete_service()
@ -854,6 +870,7 @@ class DefaultManagerServiceTests(base.TestCase):
with MonkeyPatchControllers(self.sc, with MonkeyPatchControllers(self.sc,
self.sc.dns_controller, self.sc.dns_controller,
self.sc.storage_controller, self.sc.storage_controller,
self.sc.ssl_certificate_storage,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.mock_delete_service() self.mock_delete_service()
@ -878,7 +895,7 @@ class DefaultManagerServiceTests(base.TestCase):
) )
self.service_obj.provider_details = self.provider_details self.service_obj.provider_details = self.provider_details
self.sc.storage_controller.get.return_value = ( self.sc.storage_controller.get_service.return_value = (
self.service_obj self.service_obj
) )
@ -952,6 +969,7 @@ class DefaultManagerServiceTests(base.TestCase):
with MonkeyPatchControllers(self.sc, with MonkeyPatchControllers(self.sc,
self.sc.dns_controller, self.sc.dns_controller,
self.sc.storage_controller, self.sc.storage_controller,
self.sc.ssl_certificate_storage,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.mock_purge_service(hard=True) self.mock_purge_service(hard=True)
self.mock_purge_service(hard=False) self.mock_purge_service(hard=False)
@ -1005,6 +1023,7 @@ class DefaultManagerServiceTests(base.TestCase):
with MonkeyPatchControllers(self.sc, with MonkeyPatchControllers(self.sc,
self.sc.dns_controller, self.sc.dns_controller,
self.sc.storage_controller, self.sc.storage_controller,
self.sc.ssl_certificate_storage,
memoized_controllers.task_controllers): memoized_controllers.task_controllers):
self.mock_purge_service(hard=True) self.mock_purge_service(hard=True)
self.mock_purge_service(hard=False) self.mock_purge_service(hard=False)
@ -1051,15 +1070,19 @@ class DefaultManagerServiceTests(base.TestCase):
return_value=list() return_value=list()
) )
self.mock_storage.services_controller.get.return_value = ( self.mock_storage.services_controller.get_service.return_value = (
mock_service_obj mock_service_obj
) )
self.sc.set_service_provider_details( self.sc.set_service_provider_details(
"project_id", "service_id", "auth_token", "deployed" "project_id", "service_id", "auth_token", "deployed"
) )
self.assertTrue(self.mock_storage.services_controller.get.called) self.assertTrue(
self.assertTrue(self.mock_storage.services_controller.update.called) self.mock_storage.services_controller.get_service.called
)
self.assertTrue(
self.mock_storage.services_controller.update_service.called
)
self.assertTrue( self.assertTrue(
self.mock_distributed_task.services_controller.submit_task.called self.mock_distributed_task.services_controller.submit_task.called
) )

6
tests/unit/provider/akamai/background_jobs/akamai_mocks.py
View File

@ -87,6 +87,12 @@ class MockManager(mock.Mock):
def services_controller(self): def services_controller(self):
return self.get_services_controller() return self.get_services_controller()
@staticmethod
def get_ssl_certificate_controller():
sc = mock.Mock()
sc.ssl_certificate_controller = MockStorageController()
return sc
@staticmethod @staticmethod
def get_services_controller(): def get_services_controller():
sc = mock.Mock() sc = mock.Mock()

8
tests/unit/provider/akamai/background_jobs/test_flows.py
View File

@ -43,12 +43,18 @@ class TestAkamaiBJFlowRuns(base.TestCase):
akamai_mocks.MockManager.get_services_controller(). akamai_mocks.MockManager.get_services_controller().
storage_controller storage_controller
) )
if args[1] == 'ssl_certificate':
return (
akamai_mocks.MockManager.get_services_controller(),
akamai_mocks.MockManager.
get_ssl_certificate_controller().
ssl_certificate_controller
)
mock_task_controllers = mock.Mock() mock_task_controllers = mock.Mock()
mock_task_controllers.task_controllers.side_effect = ( mock_task_controllers.task_controllers.side_effect = (
task_controllers_side_effect task_controllers_side_effect
) )
memo_controllers_patcher = mock.patch( memo_controllers_patcher = mock.patch(
# 'poppy.distributed_task.utils.memoized_controllers',
'poppy.provider.akamai.background_jobs.' 'poppy.provider.akamai.background_jobs.'
'check_cert_status_and_update.' 'check_cert_status_and_update.'
'check_cert_status_and_update_tasks.memoized_controllers', 'check_cert_status_and_update_tasks.memoized_controllers',

106
tests/unit/storage/cassandra/test_certificates.py Normal file
View File

@ -0,0 +1,106 @@
# Copyright (c) 2014 Rackspace, Inc.
#
# 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 uuid
import cassandra
import ddt
import mock
from oslo_config import cfg
from poppy.model import ssl_certificate
from poppy.storage.cassandra import certificates
from poppy.storage.cassandra import driver
from tests.unit import base
@ddt.ddt
class CassandraStorageServiceTests(base.TestCase):
def setUp(self):
super(CassandraStorageServiceTests, self).setUp()
# mock arguments to use
self.project_id = '123456'
self.service_id = uuid.uuid4()
self.service_name = 'mocksite'
# create mocked config and driver
conf = cfg.ConfigOpts()
conf.register_opt(
cfg.StrOpt(
'datacenter',
default='',
help='datacenter where the C* cluster hosted'))
conf.register_opts(driver.CASSANDRA_OPTIONS,
group=driver.CASSANDRA_GROUP)
cassandra_driver = driver.CassandraStorageDriver(conf)
migrations_patcher = mock.patch(
'cdeploy.migrator.Migrator'
)
migrations_patcher.start()
self.addCleanup(migrations_patcher.stop)
# stubbed cassandra driver
self.cc = certificates.CertificatesController(cassandra_driver)
@ddt.file_data('data_get_certs_by_domain.json')
@mock.patch.object(certificates.CertificatesController, 'session')
@mock.patch.object(cassandra.cluster.Session, 'execute')
def test_get_certs_by_domain(self, cert_details_json,
mock_session, mock_execute):
# mock the response from cassandra
mock_execute.execute.return_value = cert_details_json[0]
actual_response = self.cc.get_certs_by_domain(
domain_name="www.mydomain.com"
)
self.assertEqual(len(actual_response), 2)
self.assertTrue(all([isinstance(ssl_cert,
ssl_certificate.SSLCertificate)
for ssl_cert in actual_response]))
mock_execute.execute.return_value = cert_details_json[1]
actual_response = self.cc.get_certs_by_domain(
domain_name="www.example.com",
flavor_id="flavor1")
self.assertEqual(len(actual_response), 2)
self.assertTrue(all([isinstance(ssl_cert,
ssl_certificate.SSLCertificate)
for ssl_cert in actual_response]))
mock_execute.execute.return_value = cert_details_json[2]
actual_response = self.cc.get_certs_by_domain(
domain_name="www.mydomain.com",
flavor_id="flavor1",
cert_type="san")
self.assertTrue(isinstance(actual_response,
ssl_certificate.SSLCertificate))
@mock.patch.object(certificates.CertificatesController, 'session')
@mock.patch.object(cassandra.cluster.Session, 'execute')
def test_get_certs_by_status(self, mock_session, mock_execute):
# mock the response from cassandra
mock_execute.execute.return_value = \
[{"domain_name": "www.example.com"}]
actual_response = self.cc.get_certs_by_status(
status="deployed")
self.assertEqual(actual_response,
[{"domain_name": "www.example.com"}])
mock_execute.execute.return_value = \
[{"domain_name": "www.example1.com"}]
actual_response = self.cc.get_certs_by_status(
status="failed")
self.assertEqual(actual_response,
[{"domain_name": "www.example1.com"}])

83
tests/unit/storage/cassandra/test_services.py
View File

@ -26,7 +26,6 @@ import mock
from oslo_config import cfg from oslo_config import cfg
from poppy.model.helpers import provider_details from poppy.model.helpers import provider_details
from poppy.model import ssl_certificate
from poppy.storage.cassandra import driver from poppy.storage.cassandra import driver
from poppy.storage.cassandra import services from poppy.storage.cassandra import services
from poppy.transport.pecan.models.request import service as req_service from poppy.transport.pecan.models.request import service as req_service
@ -73,7 +72,7 @@ class CassandraStorageServiceTests(base.TestCase):
value[0]['service_id'] = self.service_id value[0]['service_id'] = self.service_id
mock_execute.execute.return_value = value mock_execute.execute.return_value = value
actual_response = self.sc.get(self.project_id, self.service_id) actual_response = self.sc.get_service(self.project_id, self.service_id)
# TODO(amitgandhinz): assert the response # TODO(amitgandhinz): assert the response
# matches the expectation (using jsonschema) # matches the expectation (using jsonschema)
@ -86,8 +85,12 @@ class CassandraStorageServiceTests(base.TestCase):
# mock the response from cassandra # mock the response from cassandra
mock_execute.execute.return_value = [] mock_execute.execute.return_value = []
self.assertRaises(ValueError, self.sc.get, self.assertRaises(
self.project_id, self.service_id) ValueError,
self.sc.get_service,
self.project_id,
self.service_id
)
@ddt.file_data('../data/data_create_service.json') @ddt.file_data('../data/data_create_service.json')
@mock.patch.object(services.ServicesController, @mock.patch.object(services.ServicesController,
@ -98,7 +101,7 @@ class CassandraStorageServiceTests(base.TestCase):
def test_create_service(self, value, def test_create_service(self, value,
mock_check, mock_session, mock_execute): mock_check, mock_session, mock_execute):
service_obj = req_service.load_from_json(value) service_obj = req_service.load_from_json(value)
responses = self.sc.create(self.project_id, service_obj) responses = self.sc.create_service(self.project_id, service_obj)
# Expect the response to be None as there are no providers passed # Expect the response to be None as there are no providers passed
# into the driver to respond to this call # into the driver to respond to this call
@ -117,9 +120,11 @@ class CassandraStorageServiceTests(base.TestCase):
service_obj = req_service.load_from_json(value) service_obj = req_service.load_from_json(value)
self.sc.get = mock.Mock(return_value=service_obj) self.sc.get = mock.Mock(return_value=service_obj)
self.assertRaises(ValueError, self.assertRaises(
self.sc.create, ValueError,
self.project_id, service_obj) self.sc.create_service,
self.project_id, service_obj
)
@ddt.file_data('data_list_services.json') @ddt.file_data('data_list_services.json')
@mock.patch.object(services.ServicesController, 'session') @mock.patch.object(services.ServicesController, 'session')
@ -130,7 +135,7 @@ class CassandraStorageServiceTests(base.TestCase):
mock_execute.prepare.return_value = mock.Mock() mock_execute.prepare.return_value = mock.Mock()
mock_execute.execute.return_value = value mock_execute.execute.return_value = value
actual_response = self.sc.list(self.project_id, None, None) actual_response = self.sc.get_services(self.project_id, None, None)
# TODO(amitgandhinz): assert the response # TODO(amitgandhinz): assert the response
# matches the expectation (using jsonschema) # matches the expectation (using jsonschema)
@ -142,7 +147,10 @@ class CassandraStorageServiceTests(base.TestCase):
def test_delete_service(self, mock_session, mock_execute): def test_delete_service(self, mock_session, mock_execute):
# mock the response from cassandra # mock the response from cassandra
mock_execute.execute.return_value = iter([{}]) mock_execute.execute.return_value = iter([{}])
actual_response = self.sc.delete(self.project_id, self.service_id) actual_response = self.sc.delete_service(
self.project_id,
self.service_id
)
# Expect the response to be None as there are no providers passed # Expect the response to be None as there are no providers passed
# into the driver to respond to this call # into the driver to respond to this call
@ -173,9 +181,11 @@ class CassandraStorageServiceTests(base.TestCase):
} }
mock_session.execute.return_value = iter([{}]) mock_session.execute.return_value = iter([{}])
service_obj = req_service.load_from_json(service_json) service_obj = req_service.load_from_json(service_json)
actual_response = self.sc.update(self.project_id, actual_response = self.sc.update_service(
self.service_id, self.project_id,
service_obj) self.service_id,
service_obj
)
# Expect the response to be None as there are no # Expect the response to be None as there are no
# providers passed into the driver to respond to this call # providers passed into the driver to respond to this call
@ -196,53 +206,6 @@ class CassandraStorageServiceTests(base.TestCase):
self.assertTrue("CloudFront" in actual_response) self.assertTrue("CloudFront" in actual_response)
self.assertTrue("Fastly" in actual_response) self.assertTrue("Fastly" in actual_response)
@ddt.file_data('data_get_certs_by_domain.json')
@mock.patch.object(services.ServicesController, 'session')
@mock.patch.object(cassandra.cluster.Session, 'execute')
def test_get_certs_by_domain(self, cert_details_json,
mock_session, mock_execute):
# mock the response from cassandra
mock_execute.execute.return_value = cert_details_json[0]
actual_response = self.sc.get_certs_by_domain(
domain_name="www.mydomain.com")
self.assertEqual(len(actual_response), 2)
self.assertTrue(all([isinstance(ssl_cert,
ssl_certificate.SSLCertificate)
for ssl_cert in actual_response]))
mock_execute.execute.return_value = cert_details_json[1]
actual_response = self.sc.get_certs_by_domain(
domain_name="www.example.com",
flavor_id="flavor1")
self.assertEqual(len(actual_response), 2)
self.assertTrue(all([isinstance(ssl_cert,
ssl_certificate.SSLCertificate)
for ssl_cert in actual_response]))
mock_execute.execute.return_value = cert_details_json[2]
actual_response = self.sc.get_certs_by_domain(
domain_name="www.mydomain.com",
flavor_id="flavor1",
cert_type="san")
self.assertTrue(isinstance(actual_response,
ssl_certificate.SSLCertificate))
@mock.patch.object(services.ServicesController, 'session')
@mock.patch.object(cassandra.cluster.Session, 'execute')
def test_get_certs_by_status(self, mock_session, mock_execute):
# mock the response from cassandra
mock_execute.execute.return_value = \
[{"domain_name": "www.example.com"}]
actual_response = self.sc.get_certs_by_status(
status="deployed")
self.assertEqual(actual_response,
[{"domain_name": "www.example.com"}])
mock_execute.execute.return_value = \
[{"domain_name": "www.example1.com"}]
actual_response = self.sc.get_certs_by_status(
status="failed")
self.assertEqual(actual_response,
[{"domain_name": "www.example1.com"}])
@ddt.file_data('data_provider_details.json') @ddt.file_data('data_provider_details.json')
@mock.patch.object(services.ServicesController, 'session') @mock.patch.object(services.ServicesController, 'session')
@mock.patch.object(cassandra.cluster.Session, 'execute') @mock.patch.object(cassandra.cluster.Session, 'execute')