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 )