def test_memoization_service_controller(self):
service_controller_first = \
memoized_controllers.task_controllers('poppy')
service_controller_cached = \
memoized_controllers.task_controllers('poppy')
self.assertEqual(id(service_controller_first),
id(service_controller_cached))
def all_controllers():
service_controller, storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
service_controller, dns_controller = \
memoized_controllers.task_controllers('poppy', 'dns')
service_controller, ssl_cert_controller = \
memoized_controllers.task_controllers('poppy', 'ssl_certificate')
return service_controller, storage_controller, dns_controller, \
ssl_cert_controller
def all_controllers():
service_controller, storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
service_controller, dns_controller = \
memoized_controllers.task_controllers('poppy', 'dns')
service_controller, ssl_cert_controller = \
memoized_controllers.task_controllers('poppy', 'ssl_certificate')
return service_controller, storage_controller, dns_controller, \
ssl_cert_controller
def test_memoization_dns_controller(self):
service_controller_first, dns_controller_first = \
memoized_controllers.task_controllers('poppy', 'storage')
service_controller_cached, dns_controller_cached = \
memoized_controllers.task_controllers('poppy', 'storage')
self.assertEqual(id(service_controller_first),
id(service_controller_cached))
self.assertEqual(id(dns_controller_first),
id(dns_controller_cached))
def execute(self, providers_list_json, project_id, service_id):
"""Create the responders from provider list.
:param unicode providers_list_json: json provided by the user/opium
:param unicode project_id: project id of the user
:param unicode service_id: service id is the uuid generated
:return: returns responders
:rtype: list[dict]
"""
service_controller, self.storage_controller = \
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)
try:
service_obj = self.storage_controller.get_service(
project_id,
service_id
)
for domain in service_obj.domains:
if domain.certificate in ['san', 'sni']:
cert_for_domain = (
self.ssl_certificate_storage.get_certs_by_domain(
domain.domain,
project_id=project_id,
flavor_id=service_obj.flavor_id,
cert_type=domain.certificate
))
if cert_for_domain == []:
cert_for_domain = None
domain.cert_info = cert_for_domain
except ValueError:
msg = 'Creating service {0} from Poppy failed. ' \
'No such service exists'.format(service_id)
LOG.info(msg)
raise Exception(msg)
responders = []
# try to create all service from each provider
for provider in providers_list:
LOG.info('Starting to create service from {0}'.format(provider))
responder = service_controller.provider_wrapper.create(
service_controller._driver.providers[provider],
service_obj)
responders.append(responder)
LOG.info('Create service from {0} complete...'.format(provider))
return responders
def execute(self, project_id, responders, upgrade=False):
"""Send mail to users.
:param unicode project_id: project id of the user
:param list[dict] responders: list of responder
:param bool upgrade: upgrade from http to https
"""
service_controller = memoized_controllers.task_controllers('poppy')
notification_content = ""
for responder in responders:
for provider in responder:
notification_content += (
"Project ID: %s, Provider: %s, Detail: %s" %
(project_id, provider, str(responder[provider])))
if upgrade is True:
notification_content += (
" The domain was upgraded from HTTP to HTTPS SAN. "
"If applicable, take note of the domain name and "
"delete the old HTTP policy in the provider.")
for n_driver in service_controller._driver.notification:
service_controller.notification_wrapper.send(
n_driver, n_driver.obj.notification_subject,
notification_content)
return
def execute(self,
providers_list_json,
cert_obj_json,
enqueue=True,
https_upgrade=False):
"""Create responder from provider list of certificate creation.
:param unicode providers_list_json: list of providers(list converted to json)
:param unicode cert_obj_json: dict of certificate(dict converted to json)
:param bool enqueue: allows to push the queue directly to zookeeper
:param bool https_upgrade: upgrade from http to https
:return: list of responders
:rtype: list[dict]
"""
service_controller = memoized_controllers.task_controllers('poppy')
# call provider create_ssl_certificate function
providers_list = json.loads(providers_list_json)
cert_obj = ssl_certificate.load_from_json(json.loads(cert_obj_json))
responders = []
# try to create all certificates from each provider
for provider in providers_list:
LOG.info('Starting to create ssl certificate: {0}'
'from {1}'.format(cert_obj.to_dict(), provider))
responder = service_controller.provider_wrapper.create_certificate(
service_controller._driver.providers[provider], cert_obj,
enqueue, https_upgrade)
responders.append(responder)
return responders
def execute(self, providers_list_json, project_id, service_id):
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
providers_list = json.loads(providers_list_json)
try:
service_obj = self.storage_controller.get(project_id, service_id)
for domain in service_obj.domains:
if domain.certificate == 'san':
cert_for_domain = (
self.storage_controller.get_certs_by_domain(
domain.domain,
project_id=project_id,
flavor_id=service_obj.flavor_id,
cert_type=domain.certificate))
if cert_for_domain == []:
cert_for_domain = None
domain.cert_info = cert_for_domain
except ValueError:
msg = 'Creating service {0} from Poppy failed. ' \
'No such service exists'.format(service_id)
LOG.info(msg)
raise Exception(msg)
responders = []
# try to create all service from each provider
for provider in providers_list:
LOG.info('Starting to create service from {0}'.format(provider))
responder = service_controller.provider_wrapper.create(
service_controller._driver.providers[provider], service_obj)
responders.append(responder)
LOG.info('Create service from {0} complete...'.format(provider))
return responders
def execute(self, provider_details, purge_url):
service_controller = memoized_controllers.task_controllers('poppy')
provider_details = json.loads(provider_details)
purge_url = None if purge_url == 'None' else purge_url
responders = []
# try to purge all service from each provider presented
# in provider_details
for provider in provider_details:
# NOTE(tonytan4ever): if the purge_url is None, it means to purge
# all content, else only purge a specific purge url
provider_details[provider] = (
req_provider_details.load_from_json(
provider_details[provider]))
LOG.info('Starting to purge service from {0},'
'purge_url: {1}'.format(provider,
'all' if purge_url is None
else purge_url))
responder = service_controller.provider_wrapper.purge(
service_controller._driver.providers[provider.lower()],
provider_details,
purge_url)
responders.append(responder)
LOG.info('Purge service {0} on {1} complete...'.format(
provider,
'all' if purge_url is None else purge_url))
return responders
def execute(self, responders, retry_sleep_time, project_id, service_id):
service_controller, dns = \
memoized_controllers.task_controllers('poppy', 'dns')
dns_responder = dns.create(responders)
for provider_name in dns_responder:
if 'error' in dns_responder[provider_name]:
msg = 'Create DNS for {0} ' \
'failed!'.format(provider_name)
LOG.info(msg)
if 'error_class' in dns_responder[provider_name]:
exception_repr = \
dns_responder[provider_name]['error_class']
exception_class = exc_loader(exception_repr)
if any([
exception_class == exception
for exception in dns._driver.retry_exceptions
]):
LOG.info('Due to {0} Exception, '
'Task {1} will '
'be retried'.format(exception_class,
self.__class__))
raise exception_class(msg)
else:
LOG.info("DNS Creation Successful "
"for Provider {0} : "
"{1}".format(provider_name,
dns_responder[provider_name]))
return dns_responder
def execute(self, provider_details_dict_error_tuple, project_id,
service_id, service_old, service_obj):
"""Update provider details of service.
:param tuple provider_details_dict_error_tuple: tuple of provider details and error msg
:param unicode project_id: project id of user
:param unicode service_id: uuid of service
:param unicode service_old: json object of the old service
:param unicode service_obj: json object of the service
"""
(provider_details_dict, error_flag) = provider_details_dict_error_tuple
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
service_old_json = json.loads(service_old)
service_old = service.load_from_json(service_old_json)
service_obj_json = json.loads(service_obj)
service_obj = service.load_from_json(service_obj_json)
# de-serialize provider_details_dict
provider_details_dict = dict([
(k, provider_details.ProviderDetail.init_from_dict(detail))
for k, detail
in provider_details_dict.items()])
# save old provider details
old_provider_details = service_old.provider_details
if error_flag:
# update the old provider details with errors
for provider_name in provider_details_dict:
error_info = provider_details_dict[provider_name].error_info
error_message = \
provider_details_dict[provider_name].error_message
old_provider_details[provider_name].error_info = error_info
old_provider_details[provider_name].error_message = \
error_message
old_provider_details[provider_name].status = 'failed'
service_obj.provider_details = old_provider_details
else:
# update the provider details
service_obj.provider_details = provider_details_dict
for domain in service_obj.domains:
if hasattr(domain, 'cert_info'):
# we don't want store cert_info in database
# just generate it on demand
delattr(domain, 'cert_info')
# update the service object
LOG.info("Service to be updated to {0} "
"for project_id: {1} "
"and service_id: {2}".format(service_obj.to_dict(),
project_id,
service_id))
self.storage_controller.update_service(
project_id,
service_id,
service_obj
)
LOG.info('Update provider detail service worker process complete...')
def execute(self, responders, retry_sleep_time, project_id, service_id):
service_controller, dns = memoized_controllers.task_controllers("poppy", "dns")
dns_responder = dns.create(responders)
for provider_name in dns_responder:
if "error" in dns_responder[provider_name]:
msg = "Create DNS for {0} " "failed!".format(provider_name)
LOG.info(msg)
if "error_class" in dns_responder[provider_name]:
exception_repr = dns_responder[provider_name]["error_class"]
exception_class = exc_loader(exception_repr)
if any([exception_class == exception for exception in dns._driver.retry_exceptions]):
LOG.info(
"Due to {0} Exception, "
"Task {1} will "
"be retried".format(exception_class, self.__class__)
)
raise exception_class(msg)
else:
LOG.info(
"DNS Creation Successful "
"for Provider {0} : "
"{1}".format(provider_name, dns_responder[provider_name])
)
return dns_responder
def execute(self, provider_details, project_id):
"""Create responder from provider details.
Initiated request to akamai to remove associated service.
:param unicode provider_details: details of the provider
:param unicode project_id: project_id os the user
:return: list of responder
:rtype: list[dict]
"""
service_controller = memoized_controllers.task_controllers('poppy')
provider_details = json.loads(provider_details)
responders = []
# try to delete all service from each provider presented
# in provider_details
for provider in provider_details:
provider_details[provider] = (req_provider_details.load_from_json(
provider_details[provider]))
LOG.info('Starting to delete service from {0}'.format(provider))
responder = service_controller.provider_wrapper.delete(
service_controller._driver.providers[provider.lower()],
provider_details, project_id)
responders.append(responder)
LOG.info('Deleting service from {0} complete...'.format(provider))
return responders
def execute(self, provider_details_dict, project_id, service_id):
provider_details_dict = dict([
(k, provider_details.ProviderDetail.init_from_dict(detail))
for k, detail in provider_details_dict.items()
])
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
service_obj = self.storage_controller.get_service(
project_id, service_id)
service_obj.provider_details = provider_details_dict
enabled = lambda provider: any([
True if 'log_delivery' in access_url else False
for access_url in provider.access_urls
])
if not all(map(enabled, provider_details_dict.values())):
service_obj.log_delivery.enabled = False
LOG.info("Service to be updated to {0} "
"for project_id: {1} "
"and service_id: {2}".format(service_obj.to_dict(),
project_id, service_id))
self.storage_controller.update_service(project_id, service_id,
service_obj)
LOG.info('Update service detail task complete...')
def execute(self, service_old, service_obj):
"""Update service with each provider present in provider_details.
:param unicode service_old: json object of the old service
:param unicode service_obj: json object of the service
:return: list of responders
:rtype: list[dict]
"""
service_controller = memoized_controllers.task_controllers('poppy')
service_old_json = json.loads(service_old)
service_obj_json = json.loads(service_obj)
service_old = service.load_from_json(service_old_json)
service_obj = service.load_from_json(service_obj_json)
responders = []
# update service with each provider present in provider_details
for provider in service_old.provider_details:
LOG.info(u'Starting to update service from {0}'.format(provider))
responder = service_controller.provider_wrapper.update(
service_controller._driver.providers[provider.lower()],
service_old.provider_details, service_obj)
responders.append(responder)
LOG.info(u'Updating service from {0} complete'.format(provider))
return responders
def __init__(self):
super(PropertyGetLatestVersionTask, self).__init__()
service_controller, self.providers = \
memoized_controllers.task_controllers('poppy', 'providers')
self.akamai_driver = self.providers['akamai'].obj
self.sc = self.akamai_driver.service_controller
self.akamai_conf = self.akamai_driver.akamai_conf
def execute(self, service_obj, hard, provider_details, purge_url):
service_controller = memoized_controllers.task_controllers('poppy')
service_json = json.loads(service_obj)
service_obj = service.load_from_json(service_json)
hard = json.loads(hard)
provider_details = json.loads(provider_details)
responders = []
# try to purge all service from each provider presented
# in provider_details
for provider in provider_details:
# NOTE(tonytan4ever): if the purge_url is None, it means to purge
# all content, else only purge a specific purge url
provider_details[provider] = (req_provider_details.load_from_json(
provider_details[provider]))
LOG.info('Starting to purge service from {0},'
'purge_url: {1}'.format(
provider, 'all' if purge_url is None else purge_url))
responder = service_controller.provider_wrapper.purge(
service_controller._driver.providers[provider.lower()],
service_obj,
provider_details,
hard=hard,
purge_url=purge_url)
responders.append(responder)
LOG.info('Purge service {0} on {1} complete...'.format(
provider, 'all' if purge_url is None else purge_url))
return responders
def execute(self, changed_provider_details_dict, project_id, service_id):
"""Update the provider details in service details.
:param dict changed_provider_details_dict: dict of odict of provider details
:param unicode project_id: project id of the user
:param unicode service_id: uuid of service
"""
if changed_provider_details_dict != {}:
provider_details_dict = dict([
(k, provider_details.ProviderDetail.init_from_dict(detail))
for k, detail
in changed_provider_details_dict.items()])
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
self.storage_controller.update_provider_details(
project_id,
service_id,
provider_details_dict)
LOG.info("Provider Details to be updated to {0} "
"for project_id: {1} "
"and service_id: {2}".format(changed_provider_details_dict,
project_id,
service_id))
LOG.info('Updating service detail task '
'complete for Changed Provider Details : '
'{0}'.format(changed_provider_details_dict))
def execute(self, providers_list, domain_name, cert_type,
project_id, flavor_id):
service_controller, self.ssl_certificate_manager = \
memoized_controllers.task_controllers('poppy', 'ssl_certificate')
self.storage_controller = self.ssl_certificate_manager.storage
try:
cert_obj = self.storage_controller.get_certs_by_domain(domain_name)
except ValueError:
cert_obj = ssl_certificate.SSLCertificate(flavor_id, domain_name,
cert_type, project_id)
responders = []
# try to delete all certificates from each provider
for provider in providers_list:
LOG.info(
'Starting to delete ssl certificate: {0} from {1}.'.format(
cert_obj.to_dict(), provider))
responder = service_controller.provider_wrapper.delete_certificate(
service_controller._driver.providers[provider.lower()],
cert_obj,
)
if responder:
if 'error' in responder[provider]:
msg = "Failed to delete ssl certificate: {0} : due to {1}:" \
"The delete operation will be retried".format(
cert_obj.to_dict(), responder[provider]['error'])
LOG.info(msg)
raise Exception(msg)
responders.append(responder)
return responders
def execute(self, project_id, auth_token, service_id):
"""If enabled it creates a object storage container to store logs.
:param unicode project_id: project id of user
:param unicode auth_token: auth_token from keystone
:param unicode service_id: the uuid generated
:return: Log responders
:rtype: list or list[dict]
"""
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
try:
service_obj = self.storage_controller.get_service(
project_id,
service_id
)
self.storage_controller._driver.close_connection()
except ValueError:
msg = 'Creating service {0} from Poppy failed. ' \
'No such service exists'.format(service_id)
LOG.info(msg)
raise Exception(msg)
# if log delivery is not enabled, return
if not service_obj.log_delivery.enabled:
return []
# log delivery enabled, create log delivery container for the user
log_responders = common.create_log_delivery_container(
project_id, auth_token)
return log_responders
def execute(self, project_id, service_id):
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
service_obj = self.storage_controller.get_service(
project_id,
service_id
)
kwargs = {
'project_id': project_id,
'context_dict': context_utils.get_current().to_dict()
}
for domain in service_obj.domains:
if (
domain.protocol == 'https' and
domain.certificate in ['san', 'sni']
):
kwargs["domain_name"] = domain.domain
kwargs["cert_type"] = domain.certificate
LOG.info(
"Delete service submit task {0} cert delete "
"domain {1}.".format(
domain.certificate,
domain.domain,
)
)
service_controller.distributed_task_controller.submit_task(
delete_ssl_certificate.delete_ssl_certificate,
**kwargs
)
def execute(self, provider_details_dict, project_id, service_id):
provider_details_dict = dict([
(k, provider_details.ProviderDetail.init_from_dict(detail))
for k, detail
in provider_details_dict.items()])
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
service_obj = self.storage_controller.get_service(
project_id,
service_id
)
service_obj.provider_details = provider_details_dict
enabled = lambda provider: any([True if 'log_delivery'
in access_url else False
for access_url
in provider.access_urls])
if not all(map(enabled, provider_details_dict.values())):
service_obj.log_delivery.enabled = False
LOG.info("Service to be updated to {0} "
"for project_id: {1} "
"and service_id: {2}".format(service_obj.to_dict(),
project_id,
service_id))
self.storage_controller.update_service(
project_id,
service_id,
service_obj
)
LOG.info('Update service detail task complete...')
def execute(self, responders, retry_sleep_time, service_old, service_obj):
service_controller, dns = \
memoized_controllers.task_controllers('poppy', 'dns')
service_obj_json = json.loads(service_obj)
service_obj = service.load_from_json(service_obj_json)
service_old_json = json.loads(service_old)
service_old = service.load_from_json(service_old_json)
dns_responder = dns.update(service_old, service_obj, responders)
for provider_name in dns_responder:
try:
if 'error' in dns_responder[provider_name]:
msg = 'Update DNS for {0} ' \
'failed!'.format(provider_name)
LOG.info(msg)
if 'error_class' in dns_responder[provider_name]:
exception_repr = \
dns_responder[provider_name]['error_class']
exception_class = exc_loader(exception_repr)
if any([isinstance(exception_class(), exception) for
exception in dns._driver.retry_exceptions]):
LOG.info('Due to {0} Exception, '
'Task {1} will '
'be retried'.format(exception_class,
self.__class__))
raise exception_class(msg)
except KeyError:
# NOTE(TheSriram): This means the provider updates failed, and
# just access_urls were returned
pass
return dns_responder
def __init__(self):
super(PropertyGetLatestVersionTask, self).__init__()
service_controller, self.providers = \
memoized_controllers.task_controllers('poppy', 'providers')
self.akamai_driver = self.providers['akamai'].obj
self.sc = self.akamai_driver.service_controller
self.akamai_conf = self.akamai_driver.akamai_conf
def execute(self, responders, retry_sleep_time, project_id, service_id):
service_controller, dns = \
memoized_controllers.task_controllers('poppy', 'dns')
dns_responder = dns.create(responders)
for provider_name in dns_responder:
if 'error' in dns_responder[provider_name]:
msg = 'Create DNS for {0} ' \
'failed!'.format(provider_name)
LOG.info(msg)
if 'error_class' in dns_responder[provider_name]:
exception_repr = \
dns_responder[provider_name]['error_class']
exception_class = exc_loader(exception_repr)
if any([exception_class == exception for
exception in dns._driver.retry_exceptions]):
LOG.info('Due to {0} Exception, '
'Task {1} will '
'be retried'.format(exception_class,
self.__class__))
raise exception_class(msg)
else:
LOG.info("DNS Creation Successful "
"for Provider {0} : "
"{1}".format(provider_name,
dns_responder[provider_name]))
return dns_responder
def execute(self, provider_details, retry_sleep_time):
service_controller, dns = memoized_controllers.task_controllers("poppy", "dns")
provider_details = json.loads(provider_details)
for provider in provider_details:
provider_details[provider] = req_provider_details.load_from_json(provider_details[provider])
# delete associated cname records from DNS
dns_responder = dns.delete(provider_details)
for provider_name in dns_responder:
if "error" in dns_responder[provider_name]:
msg = "Delete DNS for {0} " "failed!".format(provider_name)
LOG.info(msg)
if "error_class" in dns_responder[provider_name]:
exception_repr = dns_responder[provider_name]["error_class"]
exception_class = exc_loader(exception_repr)
if any([isinstance(exception_class(), exception) for exception in dns._driver.retry_exceptions]):
LOG.info(
"Due to {0} Exception, "
"Task {1} will "
"be retried".format(exception_class, self.__class__)
)
raise exception_class(msg)
return dns_responder
def execute(self, providers_list_json, project_id, service_id):
service_controller, self.storage_controller = memoized_controllers.task_controllers("poppy", "storage")
providers_list = json.loads(providers_list_json)
try:
service_obj = self.storage_controller.get(project_id, service_id)
for domain in service_obj.domains:
if domain.certificate == "san":
cert_for_domain = self.storage_controller.get_certs_by_domain(
domain.domain,
project_id=project_id,
flavor_id=service_obj.flavor_id,
cert_type=domain.certificate,
)
if cert_for_domain == []:
cert_for_domain = None
domain.cert_info = cert_for_domain
except ValueError:
msg = "Creating service {0} from Poppy failed. " "No such service exists".format(service_id)
LOG.info(msg)
raise Exception(msg)
responders = []
# try to create all service from each provider
for provider in providers_list:
LOG.info("Starting to create service from {0}".format(provider))
responder = service_controller.provider_wrapper.create(
service_controller._driver.providers[provider], service_obj
)
responders.append(responder)
LOG.info("Create service from {0} complete...".format(provider))
return responders
def execute(self, project_id, service_id):
"""Submit the task to delete the certificate.
Delete the details of certificate from cassandra and remove
the entry of the certificate.
:param unicode project_id: project id of the user
:param unicode service_id: uuid of service
"""
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
service_obj = self.storage_controller.get_service(
project_id, service_id)
kwargs = {
'project_id': project_id,
'context_dict': context_utils.get_current().to_dict(),
'flavor_id': service_obj.flavor_id,
'providers_list': service_obj.provider_details.keys()
}
for domain in service_obj.domains:
if (domain.protocol == 'https'
and domain.certificate in ['san', 'sni']):
kwargs["domain_name"] = domain.domain
kwargs["cert_type"] = domain.certificate
LOG.info("Delete service submit task {0} cert delete "
"domain {1}.".format(
domain.certificate,
domain.domain,
))
service_controller.distributed_task_controller.submit_task(
delete_ssl_certificate.delete_ssl_certificate, **kwargs)
def execute(self, project_id, responders, domain_name, cert_type):
service_controller = memoized_controllers.task_controllers('poppy')
notification_content = (
"Project ID: %s, Domain Name: %s, Cert type: %s" %
(project_id, domain_name, cert_type))
notification_content = ""
for responder in responders:
for provider in responder:
notification_content += (
"Project ID: {0}, Provider: {1}, "
"Detail: {2}, Cert type: {3}".format(
project_id,
provider,
str(responder[provider]),
cert_type
)
)
for n_driver in service_controller._driver.notification:
service_controller.notification_wrapper.send(
n_driver,
"Poppy Certificate Deleted",
notification_content)
return
def revert(self, responders, retry_sleep_time,
service_old, service_obj,
project_id, service_id, **kwargs):
if self.name in kwargs['flow_failures'].keys():
retries = conf[DNS_GROUP].retries
current_progress = (1.0 / retries)
if hasattr(self, 'retry_progress') \
and hasattr(self, 'retry_index'):
self.retry_index = self.retry_index + 1
self.retry_progress = current_progress * self.retry_index
if not hasattr(self, 'retry_progress') \
and not hasattr(self, 'retry_index'):
self.retry_progress = current_progress
self.retry_index = 1
if self.retry_progress == 1.0:
LOG.warn('Maximum retry attempts of '
'{0} reached for Task {1}'.format(retries, self.name))
LOG.warn('Setting of state of service_id: '
'{0} and project_id: {1} '
'to failed'.format(service_id, project_id))
provider_details_dict = {}
result = kwargs['result']
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
service_obj_json = json.loads(service_obj)
service_obj = service.load_from_json(service_obj_json)
for responder in responders:
for provider_name in responder:
provider_service_id = (
service_controller._driver.
providers[provider_name.lower()].obj.
service_controller.
get_provider_service_id(service_obj))
provider_details_dict[provider_name] = (
provider_details.ProviderDetail(
provider_service_id=provider_service_id,
error_info=result.traceback_str,
status='failed',
error_message='Failed after '
'{0} DNS '
'retries'.format(retries),
error_class=str(result.exc_info[0])))
# serialize provider_details_dict
for provider_name in provider_details_dict:
provider_details_dict[provider_name] = (
provider_details_dict[provider_name].to_dict())
update_provider_details = common.UpdateProviderDetailTask()
update_provider_details.execute(provider_details_dict,
project_id,
service_id)
else:
LOG.warn('Sleeping for {0} seconds and '
'retrying'.format(retry_sleep_time))
if retry_sleep_time is not None:
time.sleep(retry_sleep_time)
def __init__(self):
super(UpdateCertStatusTask, self).__init__()
service_controller, self.ssl_certificate_manager = \
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, domain_name, cert_type):
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
try:
self.storage_controller.delete_cert(project_id, domain_name,
cert_type)
except ValueError as e:
LOG.exception(e)
def __init__(self):
super(UpdateCertStatusTask, self).__init__()
service_controller, self.ssl_certificate_manager = \
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):
cert_obj = ssl_certificate.load_from_json(json.loads(cert_obj_json))
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
try:
self.storage_controller.create_cert(project_id, cert_obj)
except ValueError as e:
LOG.exception(e)
def execute(self, project_id, cert_obj_json):
cert_obj = ssl_certificate.load_from_json(json.loads(cert_obj_json))
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
try:
self.storage_controller.create_cert(project_id, cert_obj)
except ValueError as e:
LOG.exception(e)
def execute(self, domain_name, cert_type, flavor_id, project_id):
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
res = self.storage_controller.get_certs_by_domain(
domain_name, project_id=project_id,
flavor_id=flavor_id, cert_type=cert_type)
if res is None:
return ""
return json.dumps(res.to_dict())
def execute(self, project_id, domain_name, cert_type):
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
try:
self.storage_controller.delete_cert(project_id,
domain_name,
cert_type)
except ValueError as e:
LOG.exception(e)
def revert(self, responders, retry_sleep_time, service_old, service_obj,
project_id, service_id, **kwargs):
if self.name in kwargs['flow_failures'].keys():
retries = conf[DNS_GROUP].retries
current_progress = (1.0 / retries)
if hasattr(self, 'retry_progress') \
and hasattr(self, 'retry_index'):
self.retry_index = self.retry_index + 1
self.retry_progress = current_progress * self.retry_index
if not hasattr(self, 'retry_progress') \
and not hasattr(self, 'retry_index'):
self.retry_progress = current_progress
self.retry_index = 1
if self.retry_progress == 1.0:
LOG.warning('Maximum retry attempts of '
'{0} reached for Task {1}'.format(
retries, self.name))
LOG.warning('Setting of state of service_id: '
'{0} and project_id: {1} '
'to failed'.format(service_id, project_id))
provider_details_dict = {}
result = kwargs['result']
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
service_obj_json = json.loads(service_obj)
service_obj = service.load_from_json(service_obj_json)
for responder in responders:
for provider_name in responder:
provider_service_id = (
service_controller._driver.providers[
provider_name.lower()].obj.service_controller.
get_provider_service_id(service_obj))
provider_details_dict[provider_name] = (
provider_details.ProviderDetail(
provider_service_id=provider_service_id,
error_info=result.traceback_str,
status='failed',
error_message='Failed after '
'{0} DNS '
'retries'.format(retries),
error_class=str(result.exc_info[0])))
# serialize provider_details_dict
for provider_name in provider_details_dict:
provider_details_dict[provider_name] = (
provider_details_dict[provider_name].to_dict())
update_provider_details = common.UpdateProviderDetailTask()
update_provider_details.execute(provider_details_dict,
project_id, service_id)
else:
LOG.warning('Sleeping for {0} seconds and '
'retrying'.format(retry_sleep_time))
if retry_sleep_time is not None:
time.sleep(retry_sleep_time)
def execute(self, providers_list_json, project_id, service_id):
service_controller, self.storage_controller = \
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)
try:
service_obj = self.storage_controller.get_service(
project_id,
service_id
)
for domain in service_obj.domains:
if domain.certificate == 'san':
cert_for_domain = (
self.ssl_certificate_storage.get_certs_by_domain(
domain.domain,
project_id=project_id,
flavor_id=service_obj.flavor_id,
cert_type=domain.certificate
))
if cert_for_domain == []:
cert_for_domain = None
domain.cert_info = cert_for_domain
except ValueError:
msg = 'Creating service {0} from Poppy failed. ' \
'No such service exists'.format(service_id)
LOG.info(msg)
raise Exception(msg)
responders = []
# try to create all service from each provider
for provider in providers_list:
LOG.info('Starting to create service from {0}'.format(provider))
responder = service_controller.provider_wrapper.create(
service_controller._driver.providers[provider],
service_obj)
responders.append(responder)
LOG.info('Create service from {0} complete...'.format(provider))
return responders
def __init__(self):
super(PropertyUpdateTask, self).__init__()
service_controller, self.providers = \
memoized_controllers.task_controllers('poppy', 'providers')
self.akamai_driver = self.providers['akamai'].obj
self.sc = self.akamai_driver.service_controller
self.akamai_conf = self.akamai_driver.akamai_conf
self.existing_hosts = []
self.existing_edgehostnames = []
def __init__(self):
super(PropertyUpdateTask, self).__init__()
service_controller, self.providers = \
memoized_controllers.task_controllers('poppy', 'providers')
self.akamai_driver = self.providers['akamai'].obj
self.sc = self.akamai_driver.service_controller
self.akamai_conf = self.akamai_driver.akamai_conf
self.existing_hosts = []
self.existing_edgehostnames = []
def execute(self, service_obj, project_id, retry_sleep_time):
"""Break the DNS chain for service.
While updating the service state break the link between CNAME
created at rackspace DNS.
:param unicode service_obj: json object of the service
:param unicode project_id: project id of the user
:param int retry_sleep_time: sleep time
"""
service_obj_json = json.loads(service_obj)
service_obj = service.load_from_json(service_obj_json)
service_controller, dns = \
memoized_controllers.task_controllers('poppy', 'dns')
LOG.info(u'Starting to disable service - '
u'service_id: {0}, '
u'project_id: {1}'.format(service_obj.service_id, project_id))
dns_responder = dns.disable(service_obj)
for provider_name in dns_responder:
try:
if 'error' in dns_responder[provider_name]:
msg = 'Breaking DNS Chain for {0} ' \
'failed!'.format(provider_name)
LOG.info(msg)
if 'error_class' in dns_responder[provider_name]:
exception_repr = \
dns_responder[provider_name]['error_class']
exception_class = exc_loader(exception_repr)
if any([
exception_class == exception
for exception in dns._driver.retry_exceptions
]):
LOG.info('Due to {0} Exception, '
'Task {1} will '
'be retried'.format(
exception_class, self.__class__))
raise exception_class(msg)
else:
LOG.info("Breaking DNS Chain Successful "
"for Provider {0} : "
"{1}".format(provider_name,
dns_responder[provider_name]))
except KeyError:
# NOTE(TheSriram): This means the provider updates failed, and
# just access_urls were returned
pass
LOG.info(u'Disabled service - '
u'service_id: {0}, '
u'project_id: {1}'.format(service_obj.service_id, project_id))
return
def execute(self, project_id, responders, domain_name, cert_type):
service_controller = memoized_controllers.task_controllers("poppy")
notification_content = "Project ID: %s, Domain Name: %s, Cert type: %s" % (project_id, domain_name, cert_type)
for n_driver in service_controller._driver.notification:
service_controller.notification_wrapper.send(
n_driver, n_driver.obj.notification_subject, notification_content
)
return
def execute(self, domain_name, cert_type, flavor_id, project_id):
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
res = self.storage_controller.get_certs_by_domain(
domain_name,
project_id=project_id,
flavor_id=flavor_id,
cert_type=cert_type)
if res is None:
return ""
return json.dumps(res.to_dict())
def execute(self, responders, retry_sleep_time,
service_old, service_obj, project_id, service_id):
"""Updates the mapping between dns service and provider url.
Update mapping of CNAME and provider url and returns the access url.
:param list[dict] responders: list of dict of responder
:param int retry_sleep_time: sleep time
:param unicode service_old: json object of the old service
:param unicode service_obj: json object of the service
:param unicode project_id: project id of user
:param unicode service_id: uuid of the service
:return: dict of dns_responder
:rtype: dict
"""
service_controller, dns = \
memoized_controllers.task_controllers('poppy', 'dns')
service_obj_json = json.loads(service_obj)
service_obj = service.load_from_json(service_obj_json)
service_old_json = json.loads(service_old)
service_old = service.load_from_json(service_old_json)
dns_responder = dns.update(service_old, service_obj, responders)
for provider_name in dns_responder:
try:
if 'error' in dns_responder[provider_name]:
msg = 'Update DNS for {0} ' \
'failed!'.format(provider_name)
LOG.info(msg)
if 'error_class' in dns_responder[provider_name]:
exception_repr = \
dns_responder[provider_name]['error_class']
exception_class = exc_loader(exception_repr)
if any([exception_class == exception for
exception in dns._driver.retry_exceptions]):
LOG.info('Due to {0} Exception, '
'Task {1} will '
'be retried'.format(exception_class,
self.__class__))
raise exception_class(msg)
else:
LOG.info("DNS Update Successful "
"for Provider {0} : "
"{1}".format(provider_name,
dns_responder[provider_name]))
except KeyError:
# NOTE(TheSriram): This means the provider updates failed, and
# just access_urls were returned
pass
return dns_responder
def execute(self, domain_name, cert_type, flavor_id, project_id):
service_controller, self.ssl_certificate_manager = \
memoized_controllers.task_controllers('poppy', 'ssl_certificate')
self.storage = self.ssl_certificate_manager.storage
try:
res = self.storage.get_certs_by_domain(
domain_name, project_id=project_id,
flavor_id=flavor_id, cert_type=cert_type)
return json.dumps(res.to_dict())
except ValueError:
return ""
def execute(self, service_obj):
service_obj_json = json.loads(service_obj)
service_obj = service.load_from_json(service_obj_json)
service_controller, dns = \
memoized_controllers.task_controllers('poppy', 'dns')
LOG.info(u'Starting to disable service')
dns.disable(service_obj)
LOG.info(u'Disabled service')
return
def execute(self, project_id, service_id):
"""Delete service details from cassandra.
Delete the service details from cassandra and remove all entries
about the service
:param unicode project_id: project id of the user
:param unicode service_id: uuid of service
"""
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
self.storage_controller.delete_service(project_id, service_id)
def execute(self, provider_details, retry_sleep_time, responders,
project_id, service_id):
"""Deletes the mapping between dns service and provider url.
The result is assiciation of cname created at rackspace dns
which used by customer for their by vanity domain will be removed.
:param unicode provider_details: json of providers
:param int retry_sleep_time: sleep time
:param list[dict] responders: list of responder
:param unicode project_id: project id of the user
:param unicode service_id: uuid of the service
:return: dict of dns_responder
:rtype: dict
"""
service_controller, dns = \
memoized_controllers.task_controllers('poppy', 'dns')
provider_details = json.loads(provider_details)
for provider in provider_details:
provider_details[provider] = (req_provider_details.load_from_json(
provider_details[provider]))
# delete associated cname records from DNS
dns_responder = dns.delete(provider_details)
for provider_name in dns_responder:
if 'error' in dns_responder[provider_name]:
msg = 'Delete DNS for {0} ' \
'failed!'.format(provider_name)
LOG.info(msg)
if 'error_class' in dns_responder[provider_name]:
exception_repr = \
dns_responder[provider_name]['error_class']
exception_class = exc_loader(exception_repr)
if any([
exception_class == exception
for exception in dns._driver.retry_exceptions
]):
LOG.info('Due to {0} Exception, '
'Task {1} will '
'be retried'.format(exception_class,
self.__class__))
raise exception_class(msg)
else:
LOG.info("DNS Deletion Successful "
"for Provider {0} : "
"{1}".format(provider_name,
dns_responder[provider_name]))
return dns_responder
def execute(self, provider_details_dict_error_tuple, project_id,
service_id, service_old, service_obj):
(provider_details_dict, error_flag) = provider_details_dict_error_tuple
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
service_old_json = json.loads(service_old)
service_old = service.load_from_json(service_old_json)
service_obj_json = json.loads(service_obj)
service_obj = service.load_from_json(service_obj_json)
# de-serialize provider_details_dict
provider_details_dict = dict([
(k, provider_details.ProviderDetail.init_from_dict(detail))
for k, detail
in provider_details_dict.items()])
# save old provider details
old_provider_details = service_old.provider_details
if error_flag:
# update the old provider details with errors
for provider_name in provider_details_dict:
error_info = provider_details_dict[provider_name].error_info
error_message = \
provider_details_dict[provider_name].error_message
old_provider_details[provider_name].error_info = error_info
old_provider_details[provider_name].error_message = \
error_message
old_provider_details[provider_name].status = 'failed'
service_obj.provider_details = old_provider_details
else:
# update the provider details
service_obj.provider_details = provider_details_dict
for domain in service_obj.domains:
if hasattr(domain, 'cert_info'):
# we don't want store cert_info in database
# just generate it on demand
delattr(domain, 'cert_info')
# update the service object
LOG.info("Service to be updated to {0} "
"for project_id: {1} "
"and service_id: {2}".format(service_obj.to_dict(),
project_id,
service_id))
self.storage_controller.update_service(
project_id,
service_id,
service_obj
)
LOG.info('Update provider detail service worker process complete...')
def execute(self, project_id, service_obj, state):
service_obj_json = json.loads(service_obj)
service_obj = service.load_from_json(service_obj_json)
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
LOG.info(u'Starting to update service state to %s, for '
'project_id: %s, service_id: %s'
% (state, project_id, service_obj.service_id))
self.storage_controller.update_state(
project_id, service_obj.service_id, state)
LOG.info(u'Update service state complete.')
def execute(self, project_id, cert_obj_json, responders):
service_controller, self.storage_controller = memoized_controllers.task_controllers("poppy", "storage")
cert_details = {}
for responder in responders:
for provider in responder:
cert_details[provider] = json.dumps(responder[provider])
cert_obj = ssl_certificate.load_from_json(json.loads(cert_obj_json))
self.storage_controller.update_cert_info(
cert_obj.domain_name, cert_obj.cert_type, cert_obj.flavor_id, cert_details
)
return
def execute(self, provider_details):
service_controller = memoized_controllers.task_controllers("poppy")
provider_details = json.loads(provider_details)
responders = []
# try to delete all service from each provider presented
# in provider_details
for provider in provider_details:
provider_details[provider] = req_provider_details.load_from_json(provider_details[provider])
LOG.info("Starting to delete service from {0}".format(provider))
responder = service_controller.provider_wrapper.delete(
service_controller._driver.providers[provider.lower()], provider_details
)
responders.append(responder)
LOG.info("Deleting service from {0} complete...".format(provider))
return responders
def execute(self, changed_provider_details_dict, project_id, service_id):
if changed_provider_details_dict != {}:
provider_details_dict = dict([
(k, provider_details.ProviderDetail.init_from_dict(detail))
for k, detail
in changed_provider_details_dict.items()])
service_controller, self.storage_controller = \
memoized_controllers.task_controllers('poppy', 'storage')
self.storage_controller.update_provider_details(
project_id,
service_id,
provider_details_dict)
LOG.info('Updating service detail task'
'complete for Changed Provider Details :'
'{0}'.format(changed_provider_details_dict))
def execute(self, service_obj, project_id, retry_sleep_time):
service_obj_json = json.loads(service_obj)
service_obj = service.load_from_json(service_obj_json)
service_controller, dns = \
memoized_controllers.task_controllers('poppy', 'dns')
LOG.info(u'Starting to disable service - '
u'service_id: {0}, '
u'project_id: {1}'.format(service_obj.service_id,
project_id))
dns_responder = dns.disable(service_obj)
for provider_name in dns_responder:
try:
if 'error' in dns_responder[provider_name]:
msg = 'Breaking DNS Chain for {0} ' \
'failed!'.format(provider_name)
LOG.info(msg)
if 'error_class' in dns_responder[provider_name]:
exception_repr = \
dns_responder[provider_name]['error_class']
exception_class = exc_loader(exception_repr)
if any([exception_class == exception for
exception in dns._driver.retry_exceptions]):
LOG.info('Due to {0} Exception, '
'Task {1} will '
'be retried'.format(exception_class,
self.__class__))
raise exception_class(msg)
else:
LOG.info("Breaking DNS Chain Successful "
"for Provider {0} : "
"{1}".format(provider_name,
dns_responder[provider_name]))
except KeyError:
# NOTE(TheSriram): This means the provider updates failed, and
# just access_urls were returned
pass
LOG.info(u'Disabled service - '
u'service_id: {0}, '
u'project_id: {1}'.format(service_obj.service_id,
project_id))
return
def execute(self, project_id, responders):
service_controller = memoized_controllers.task_controllers('poppy')
notification_content = ""
for responder in responders:
for provider in responder:
notification_content += (
"Project ID: %s, Provider: %s, Detail: %s" %
(project_id, provider, str(responder[provider])))
for n_driver in service_controller._driver.notification:
service_controller.notification_wrapper.send(
n_driver,
n_driver.obj.notification_subject,
notification_content)
return
def execute(self, providers_list_json, cert_obj_json):
service_controller = memoized_controllers.task_controllers("poppy")
# call provider create_ssl_certificate function
providers_list = json.loads(providers_list_json)
cert_obj = ssl_certificate.load_from_json(json.loads(cert_obj_json))
responders = []
# try to create all service from each provider
for provider in providers_list:
LOG.info("Starting to create ssl certificate: {0}".format(cert_obj.to_dict()))
LOG.info("from {0}".format(provider))
responder = service_controller.provider_wrapper.create_certificate(
service_controller._driver.providers[provider], cert_obj
)
responders.append(responder)
return responders
def execute(self, project_id, auth_token, service_id):
service_controller, self.storage_controller = memoized_controllers.task_controllers("poppy", "storage")
try:
service_obj = self.storage_controller.get(project_id, service_id)
self.storage_controller._driver.close_connection()
except ValueError:
msg = "Creating service {0} from Poppy failed. " "No such service exists".format(service_id)
LOG.info(msg)
raise Exception(msg)
# if log delivery is not enabled, return
if not service_obj.log_delivery.enabled:
return []
# log delivery enabled, create log delivery container for the user
log_responders = common.create_log_delivery_container(project_id, auth_token)
return log_responders
