def revert(self, provider_details, retry_sleep_time, responders,
project_id, service_id, **kwargs):
"""If failed to delete association dns mapping
failed revert the reestablish dns mapping task.
CNAME created at rackspace dns which used by customer for
their by vanity domain failed to delete. Will reestablish
the dns mapping.
:param dict provider_details: dict 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
"""
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']
for responder in responders:
for provider_name in responder:
provider_details_dict[provider_name] = (
pd.ProviderDetail(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 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 create_service():
flow = graph_flow.Flow('Creating poppy-service').add(
create_service_tasks.CreateProviderServicesTask(),
linear_flow.Flow(
'Create Service DNS Mapping flow',
retry=retry.ParameterizedForEach(
rebind=['time_seconds'], provides='retry_sleep_time')).add(
create_service_tasks.CreateServiceDNSMappingTask(
rebind=['responders'])),
create_service_tasks.CreateLogDeliveryContainerTask(),
create_service_tasks.GatherProviderDetailsTask(
rebind=['responders', 'dns_responder', 'log_responders']),
common.UpdateProviderDetailTask(rebind=['provider_details_dict']))
return flow
def revert(self, provider_details, retry_sleep_time,
responders, 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']
for responder in responders:
for provider_name in responder:
provider_details_dict[provider_name] = (
pd.ProviderDetail(
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 bootstrap_mock_create(mock_bootstrap):
mock_bootstrap.return_value = self.bootstrap_obj
create_provider = create_service_tasks.CreateProviderServicesTask()
responders = create_provider.execute(
json.dumps(provider_details_json), self.project_id,
self.service_id)
create_dns = create_service_tasks.CreateServiceDNSMappingTask()
dns_responder = create_dns.execute(responders, 0, self.project_id,
self.service_id)
gather_provider = create_service_tasks.GatherProviderDetailsTask()
log_responder = \
create_service_tasks.CreateLogDeliveryContainerTask()
provider_details_dict = \
gather_provider.execute(responders,
dns_responder,
log_responder)
update_provider_details = common.UpdateProviderDetailTask()
update_provider_details.execute(provider_details_dict,
self.project_id, self.service_id)
def revert(self, responders, retry_sleep_time,
project_id, service_id, **kwargs):
"""Reverts the create dnsmapping task is failed.
:param list responders: list of responder
:param int retry_sleep_time: sleep time
:param unicode project_id: project id of user
:param unicode service_id: service id of the service(generated uuid)
"""
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')
try:
service_obj = self.storage_controller.get_service(
project_id,
service_id
)
except ValueError:
msg = 'Creating service {0} from Poppy failed. ' \
'No such service exists'.format(service_id)
LOG.info(msg)
raise Exception(msg)
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)
