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 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, 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 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, service_old, service_obj, project_id):
"""Delete certificates of domains deleted.
: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
"""
service_controller, dns = \
memoized_controllers.task_controllers('poppy', 'dns')
# get old domains
service_old_json = json.loads(service_old)
service_old = service.load_from_json(service_old_json)
old_domains = set([
domain.domain for domain in service_old.domains
if domain.protocol == 'https'
and
domain.certificate in ['san', 'sni']
])
# get new domains
service_new_json = json.loads(service_obj)
service_new = service.load_from_json(service_new_json)
new_domains = set([
domain.domain for domain in service_new.domains
if domain.protocol == 'https'
and
domain.certificate in ['san', 'sni']
])
removed_domains = old_domains.difference(new_domains)
LOG.info("update_service Old domains: {0}".format(old_domains))
LOG.info("update_service New domains: {0}".format(new_domains))
LOG.info("update_service Deleted domains: {0}".format(removed_domains))
kwargs = {
'project_id': project_id,
'cert_type': 'san',
'context_dict': context_utils.get_current().to_dict()
}
for domain in removed_domains:
kwargs['domain_name'] = domain
LOG.info(
"update_service removing certificate "
"for deleted domain {0}".format(domain)
)
service_controller.distributed_task_controller.submit_task(
delete_ssl_certificate.delete_ssl_certificate,
**kwargs
)
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 test_update_create_new_sub_customer_new_policy(self, service_json):
provider_service_id = json.dumps([{
'policy_name': str(uuid.uuid1()),
'protocol': 'http',
'certificate': None
}])
controller = services.ServiceController(self.driver)
controller.subcustomer_api_client.get.side_effect = [
mock.Mock(status_code=400,
ok=False,
text='Error retrieving sub customer!'),
mock.Mock(status_code=200,
ok=True,
content=json.dumps({"geo": "US"})),
mock.Mock(status_code=200,
ok=True,
content=json.dumps({"geo": "US"})),
mock.Mock(status_code=200,
ok=True,
content=json.dumps({"geo": "US"}))
]
controller.subcustomer_api_client.delete.return_value = \
mock.Mock(status_code=200,
ok=True)
controller.policy_api_client.get.return_value = mock.Mock(
status_code=200, text=json.dumps(dict(rules=[])))
controller.policy_api_client.put.return_value = mock.Mock(
status_code=200, text='Put successful')
controller.policy_api_client.delete.return_value = mock.Mock(
status_code=200, text='Delete successful')
service_obj = service.load_from_json(service_json)
resp = controller.update(provider_service_id, service_obj)
self.assertIn('id', resp[self.driver.provider_name])
def test_update_with_exception(self, service_json, mock_controllerclient,
mock_driver):
# test create with exceptions
driver = mock_driver()
driver.attach_mock(mock_controllerclient, 'client')
driver.client.configure_mock(
**{'get.return_value': fake_maxcdn_client_get_return_value})
controller_with_update_exception = services.ServiceController(driver)
controller_with_update_exception.client.configure_mock(
**{
'put.side_effect':
RuntimeError('Updating service mysteriously failed.')
})
resp = controller_with_update_exception.update(
self.provider_service_id, service_json)
self.assertIn('error', resp[driver.provider_name])
controller_with_update_exception.client.reset_mock()
controller_with_update_exception.client.configure_mock(
**{
'put.side_effect': None,
'put.return_value': fake_maxcdn_client_400_return_value
})
service_obj = service.load_from_json(service_json)
resp = controller_with_update_exception.update(
self.provider_service_id, service_obj)
self.assertIn('error', resp[driver.provider_name])
def test_update_service(self, service_json,
mock_set_service_provider_details,
mock_check):
with mock.patch.object(
services.ServicesController,
'get_provider_details') as mock_provider_det:
mock_provider_det.return_value = {
"MaxCDN": "{\"id\": 11942, \"access_urls\": "
"[{\"provider_url\": \"maxcdn.provider.com\", "
"\"domain\": \"xk.cd\"}], "
"\"domains_certificate_status\":"
"{\"mypullzone.com\": "
"\"failed\"} }",
}
self.mock_session.execute.return_value = iter([{}])
service_obj = req_service.load_from_json(service_json)
actual_response = self.sc.update_service(
self.project_id,
self.service_id,
service_obj
)
# Expect the response to be None as there are no
# providers passed into the driver to respond to this call
self.assertEqual(actual_response, None)
def test_update_with_get_error(self, service_json):
provider_service_id = json.dumps([{'policy_name': str(uuid.uuid1()),
'protocol': 'http'}])
controller = services.ServiceController(self.driver)
controller.subcustomer_api_client.get.return_value = \
mock.Mock(status_code=200,
ok=True,
content=json.dumps({"geo": "US"}))
controller.subcustomer_api_client.delete.return_value = \
mock.Mock(status_code=200,
ok=True)
controller.policy_api_client.get.return_value = mock.Mock(
status_code=400,
text='Some get error happened'
)
controller.policy_api_client.put.return_value = mock.Mock(
status_code=200,
text='Put successful'
)
controller.policy_api_client.delete.return_value = mock.Mock(
status_code=200,
text='Delete successful'
)
service_obj = service.load_from_json(service_json)
resp = controller.update(
provider_service_id, service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_service_exist(self, value, mock_check, mock_session,
mock_execute):
service_obj = req_service.load_from_json(value)
self.sc.get = mock.Mock(return_value=service_obj)
self.assertRaises(ValueError, self.sc.create, self.project_id,
service_obj)
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 test_update_with_service_id_json_load_error(self, service_json):
# This should trigger a json.loads error
provider_service_id = None
service_obj = service.load_from_json(service_json)
resp = self.controller.update(
provider_service_id, service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_update(self, update_json):
provider_details_dict = {
"MaxCDN": {"id": 11942, "access_urls": ["mypullzone.netdata.com"]},
"Mock": {"id": 73242, "access_urls": ["mycdn.mock.com"]},
"CloudFront": {"id": "5ABC892", "access_urls": ["cf123.cloudcf.com"]},
"Fastly": {"id": 3488, "access_urls": ["mockcf123.fastly.prod.com"]},
}
providers_details = {}
for name in provider_details_dict:
details = provider_details_dict[name]
provider_detail_obj = provider_details.ProviderDetail(
provider_service_id=details["id"],
access_urls=details["access_urls"],
status=details.get("status", u"unknown"),
)
providers_details[name] = provider_detail_obj
providers = self.sc._driver.providers
self.sc.storage_controller.get_provider_details.return_value = providers_details
service_obj = service.load_from_json(self.service_json)
service_obj.status = u"deployed"
self.sc.storage_controller.get.return_value = service_obj
service_updates = json.dumps(
[{"op": "replace", "path": "/domains/0", "value": {"domain": "added.mocksite4.com"}}]
)
self.sc.update(self.project_id, self.service_id, self.auth_token, service_updates)
# ensure the manager calls the storage driver with the appropriate data
self.sc.storage_controller.update.assert_called_once()
# and that the providers are notified.
providers.map.assert_called_once()
def test_update_with_exception(self, service_json, mock_controllerclient,
mock_driver):
# test create with exceptions
driver = mock_driver()
driver.attach_mock(mock_controllerclient, 'client')
driver.client.configure_mock(**{'get.return_value':
fake_maxcdn_client_get_return_value
})
controller_with_update_exception = services.ServiceController(driver)
controller_with_update_exception.client.configure_mock(**{
'put.side_effect':
RuntimeError('Updating service mysteriously failed.')})
resp = controller_with_update_exception.update(
self.provider_service_id,
service_json)
self.assertIn('error', resp[driver.provider_name])
controller_with_update_exception.client.reset_mock()
controller_with_update_exception.client.configure_mock(**{
'put.side_effect': None,
'put.return_value': fake_maxcdn_client_400_return_value
})
service_obj = service.load_from_json(service_json)
resp = controller_with_update_exception.update(
self.provider_service_id,
service_obj)
self.assertIn('error', resp[driver.provider_name])
def test_upsert(self, service_json):
provider_service_id = json.dumps([{'policy_name': "densely.sage.com",
'protocol': 'http',
'certificate': None}])
controller = services.ServiceController(self.driver)
controller.subcustomer_api_client.get.return_value = \
mock.Mock(status_code=200,
ok=True,
content=json.dumps({"geo": "US"}))
controller.subcustomer_api_client.delete.return_value = \
mock.Mock(status_code=200,
ok=True)
controller.policy_api_client.get.return_value = mock.Mock(
status_code=404,
text='Service not found'
)
controller.policy_api_client.put.return_value = mock.Mock(
status_code=200,
text='Put successful'
)
service_obj = service.load_from_json(service_json)
resp = controller.update(
provider_service_id, service_obj)
self.assertIn('id', resp[self.driver.provider_name])
def test_create_exception(self, service_json):
# generic exception: Exception
service_obj = service.load_from_json(service_json)
self.controller.client.create_distribution.side_effect = Exception(
'Creating service failed.')
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_update(self, service_json):
provider_service_id = uuid.uuid1()
controller = services.ServiceController(self.driver)
controller.client.list_versions.return_value = [self.version]
service_obj = service.load_from_json(service_json)
resp = controller.update(provider_service_id, service_obj)
self.assertIn('id', resp[self.driver.provider_name])
def test_create_service(self, value, mock_check):
service_obj = req_service.load_from_json(value)
responses = self.sc.create_service(self.project_id, service_obj)
# Expect the response to be None as there are no providers passed
# into the driver to respond to this call
self.assertEqual(responses, None)
def test_create_with_multiple_domains(self, service_json):
service_obj = service.load_from_json(service_json)
self.controller.subcustomer_api_client.get.return_value = \
mock.Mock(status_code=200,
ok=True,
content=json.dumps({"geo": "US"}))
self.controller.policy_api_client.put.return_value = mock.Mock(
status_code=200, text='Put successful')
for curr_domain in service_obj.domains:
if (curr_domain.certificate in ['san', 'sni']
and curr_domain.protocol == 'https'):
cert_key = ('san cert' if curr_domain.certificate == 'san' else
'sni_cert')
curr_domain.cert_info = ssl_certificate.SSLCertificate(
'flavor_id',
curr_domain.domain,
curr_domain.certificate,
service_obj.project_id,
cert_details={
'Akamai':
dict(cert_domain='1',
extra_info={
'status': 'deployed',
cert_key: '1',
'created_at': str(datetime.datetime.now())
})
})
provider_responses = self.controller.create(service_obj)
for provider_name in provider_responses:
provider_response = provider_responses[provider_name]
num_of_domains = len(service_obj.domains)
num_of_links = len(provider_response['links'])
# make sure we have same number of domains and links
self.assertEqual(num_of_domains, num_of_links)
self.assertIn('id', provider_responses[provider_name])
def test_create_exception(self, service_json):
# generic exception: Exception
service_obj = service.load_from_json(service_json)
self.controller.client.create_distribution.side_effect = Exception(
'Creating service failed.')
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
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 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 test_update(self, service_json):
new_driver = driver.CDNProvider(self.conf)
# instantiate
controller = services.ServiceController(new_driver)
# test create, everything goes through successfully
service_obj = service.load_from_json(service_json)
resp = controller.update(self.provider_service_id, service_obj)
self.assertIn('id', resp[new_driver.provider_name])
def test_update(self, service_json):
provider_service_id = uuid.uuid1()
controller = services.ServiceController(self.driver)
controller.client.list_versions.return_value = [self.version]
service_obj = service.load_from_json(service_json)
resp = controller.update(
provider_service_id, service_obj)
self.assertIn('id', resp[self.driver.provider_name])
def test_create_with_exception(self, service_json):
# ASSERTIONS
# create_service
service_obj = service.load_from_json(service_json)
self.controller.policy_api_client.put.side_effect = RuntimeError("Creating service failed.")
resp = self.controller.create(service_obj)
self.assertIn("error", resp[self.driver.provider_name])
def test_create_service_exist(self, value,
mock_check, mock_session, mock_execute):
service_obj = req_service.load_from_json(value)
self.sc.get = mock.Mock(return_value=service_obj)
self.assertRaises(ValueError,
self.sc.create,
self.project_id, service_obj)
def test_create(self, service_json):
service_obj = service.load_from_json(service_json)
self.controller.policy_api_client.put.return_value = mock.Mock(
status_code=200,
text='Put successful'
)
self.controller.create(service_obj)
self.controller.policy_api_client.put.assert_called_once()
def test_upsert(self, service_json):
provider_service_id = json.dumps([{"policy_name": "densely.sage.com", "protocol": "http", "certificate": None}])
controller = services.ServiceController(self.driver)
controller.policy_api_client.get.return_value = mock.Mock(status_code=404, text="Service not found")
controller.policy_api_client.put.return_value = mock.Mock(status_code=200, text="Put successful")
service_obj = service.load_from_json(service_json)
resp = controller.update(provider_service_id, service_obj)
self.assertIn("id", resp[self.driver.provider_name])
def test_create_with_4xx_return(self, service_json):
service_obj = service.load_from_json(service_json)
# test exception
self.controller.policy_api_client.put.return_value = mock.Mock(
status_code=400, text='Some create service error happened')
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_with_activate_version_exception(self, service_json):
self.controller.client.reset_mock()
self.controller.client.create_backend.side_effect = None
service_obj = service.load_from_json(service_json)
self.controller.client.active_version.side_effect = fastly.FastlyError(
Exception('Active_version failed.'))
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_update_with_domain_protocol_change(self, service_json):
provider_service_id = json.dumps([{"policy_name": "densely.sage.com", "protocol": "http", "certificate": None}])
controller = services.ServiceController(self.driver)
controller.policy_api_client.get.return_value = mock.Mock(status_code=200, text=json.dumps(dict(rules=[])))
controller.policy_api_client.put.return_value = mock.Mock(status_code=200, text="Put successful")
controller.policy_api_client.delete.return_value = mock.Mock(status_code=200, text="Delete successful")
service_obj = service.load_from_json(service_json)
resp = controller.update(provider_service_id, service_obj)
self.assertIn("id", resp[self.driver.provider_name])
def test_create_with_activate_version_exception(self, service_json):
self.controller.client.reset_mock()
self.controller.client.create_backend.side_effect = None
service_obj = service.load_from_json(service_json)
self.controller.client.active_version.side_effect = fastly.FastlyError(
Exception('Active_version failed.'))
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_with_create_service_exception(self, service_json):
# ASSERTIONS
# create_service
service_obj = service.load_from_json(service_json)
self.controller.client.create_service.side_effect = fastly.FastlyError(
Exception('Creating service failed.'))
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_server_error(self, service_json):
# create_distribution: CloudFrontServerError
service_obj = service.load_from_json(service_json)
side_effect = cloudfront.exception.CloudFrontServerError(
503, 'Service Unavailable')
self.controller.client.create_distribution.side_effect = side_effect
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_with_create_service_exception(self, service_json):
# ASSERTIONS
# create_service
service_obj = service.load_from_json(service_json)
self.controller.client.create_service.side_effect = fastly.FastlyError(
Exception('Creating service failed.'))
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_update(self, service_json):
new_driver = driver.CDNProvider(self.conf)
# instantiate
controller = services.ServiceController(new_driver)
# test create, everything goes through successfully
service_obj = service.load_from_json(service_json)
resp = controller.update(self.provider_service_id,
service_obj)
self.assertIn('id', resp[new_driver.provider_name])
def test_update_with_get_error(self, service_json):
provider_service_id = json.dumps([{"policy_name": str(uuid.uuid1()), "protocol": "http"}])
controller = services.ServiceController(self.driver)
controller.policy_api_client.get.return_value = mock.Mock(status_code=400, text="Some get error happened")
controller.policy_api_client.put.return_value = mock.Mock(status_code=200, text="Put successful")
controller.policy_api_client.delete.return_value = mock.Mock(status_code=200, text="Delete successful")
service_obj = service.load_from_json(service_json)
resp = controller.update(provider_service_id, service_obj)
self.assertIn("error", resp[self.driver.provider_name])
def test_create_with_exception(self, service_json):
# ASSERTIONS
# create_service
service_obj = service.load_from_json(service_json)
self.controller.policy_api_client.put.side_effect = (
RuntimeError('Creating service failed.'))
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_service_deployed(self, service_json):
# clear run
service_obj = service.load_from_json(service_json)
self.controller.client.create_distribution.return_value = (mock.Mock(
domain_name="jibberish.cloudfront.com",
id=uuid.uuid1(),
status="Deployed"))
resp = self.controller.create(service_obj)
self.assertIn('links', resp[self.driver.provider_name])
def test_create_server_error(self, service_json):
# create_distribution: CloudFrontServerError
service_obj = service.load_from_json(service_json)
side_effect = cloudfront.exception.CloudFrontServerError(
503, 'Service Unavailable')
self.controller.client.create_distribution.side_effect = side_effect
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_update_general_exception(self, service_json):
provider_service_id = uuid.uuid1()
controller = services.ServiceController(self.driver)
controller.client.list_versions.return_value = [self.version]
controller.client.get_service_details.side_effect = (
Exception('Mock -- Something went wrong!'))
service_obj = service.load_from_json(service_json)
resp = controller.update(provider_service_id, service_obj)
self.assertIn('error', resp[self.driver.provider_name])
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 test_create_service_deployed(self, service_json):
# clear run
service_obj = service.load_from_json(service_json)
self.controller.client.create_distribution.return_value = (
mock.Mock(domain_name="jibberish.cloudfront.com",
id=uuid.uuid1(),
status="Deployed")
)
resp = self.controller.create(service_obj)
self.assertIn('links', resp[self.driver.provider_name])
def test_create(self, service_json):
service_obj = service.load_from_json(service_json)
self.controller.policy_api_client.put.return_value = mock.Mock(
status_code=200,
text='Put successful'
)
self.controller.create(service_obj)
self.controller.policy_api_client.put.assert_called_once()
# make sure all the caching rules are processed
self.assertTrue(service_obj.caching == [])
def test_create_with_general_exception(self, service_json):
self.controller.client.reset_mock()
self.controller.client.check_domains.side_effect = None
service_obj = service.load_from_json(service_json)
# test a general exception
self.controller.client.create_service.side_effect = Exception(
'Wild exception occurred.')
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_with_create_backend_exception(self, service_json):
self.controller.client.reset_mock()
self.controller.client.create_domain.side_effect = None
service_obj = service.load_from_json(service_json)
# create backends
self.controller.client.create_backend.side_effect = fastly.FastlyError(
Exception('Creating backend failed.'))
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_with_general_exception(self, service_json):
self.controller.client.reset_mock()
self.controller.client.check_domains.side_effect = None
service_obj = service.load_from_json(service_json)
# test a general exception
self.controller.client.create_service.side_effect = Exception(
'Wild exception occurred.')
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_with_4xx_return(self, service_json):
service_obj = service.load_from_json(service_json)
# test exception
self.controller.policy_api_client.put.return_value = mock.Mock(
status_code=400, text="Some create service error happened"
)
resp = self.controller.create(service_obj)
self.assertIn("error", resp[self.driver.provider_name])
def test_update_service(self, service_json, mock_check, mock_session,
mock_execute):
mock_check.return_value = False
service_obj = req_service.load_from_json(service_json)
actual_response = self.sc.update(self.project_id, self.service_id,
service_obj)
# Expect the response to be None as there are no providers passed
# into the driver to respond to this call
self.assertEqual(actual_response, None)
def test_create_with_get_sub_customer_exception(self, service_json):
service_obj = service.load_from_json(service_json)
self.controller.subcustomer_api_client.get.return_value = \
mock.Mock(status_code=400,
ok=False,
content=json.dumps({"geo": "US"}))
self.controller.policy_api_client.put.side_effect = (
RuntimeError('Creating service failed.'))
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
def test_create_with_create_backend_exception(self, service_json):
self.controller.client.reset_mock()
self.controller.client.create_domain.side_effect = None
service_obj = service.load_from_json(service_json)
# create backends
self.controller.client.create_backend.side_effect = fastly.FastlyError(
Exception('Creating backend failed.'))
resp = self.controller.create(service_obj)
self.assertIn('error', resp[self.driver.provider_name])
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, service_old, service_obj, project_id):
service_controller, dns = \
memoized_controllers.task_controllers('poppy', 'dns')
# get old domains
service_old_json = json.loads(service_old)
service_old = service.load_from_json(service_old_json)
old_domains = set([
domain.domain for domain in service_old.domains
if domain.protocol == 'https' and domain.certificate == 'san'
])
# get new domains
service_new_json = json.loads(service_obj)
service_new = service.load_from_json(service_new_json)
new_domains = set([
domain.domain for domain in service_new.domains
if domain.protocol == 'https' and domain.certificate == 'san'
])
removed_domains = old_domains.difference(new_domains)
LOG.info("update_service Old domains: {0}".format(old_domains))
LOG.info("update_service New domains: {0}".format(new_domains))
LOG.info("update_service Deleted domains: {0}".format(removed_domains))
kwargs = {
'project_id': project_id,
'cert_type': 'san',
'context_dict': context_utils.get_current().to_dict()
}
for domain in removed_domains:
kwargs['domain_name'] = domain
LOG.info(
"update_service removing certificate "
"for deleted domain {0}".format(domain)
)
service_controller.distributed_task_controller.submit_task(
delete_ssl_certificate.delete_ssl_certificate,
**kwargs
)
