From ea501bab4c28a69a9a6f10653dc0d662fb91d642 Mon Sep 17 00:00:00 2001
From: satroutr <engg.sanj@gmail.com>
Date: Mon, 20 Aug 2018 14:35:24 +0530
Subject: [PATCH 1/2] [CDN-1144]No Branded Edgekey Domain Created During SNI
 Certificate Creation process

The CNAME was pointing to CPS rather than pointing to provider url
this will fix to point it to the provider url
removed duplicate code for DV SNI
We dont have any unit test testing the function get_provider_url
added the test for the particular function
---
 poppy/provider/akamai/services.py             | 14 ++--
 .../provider/akamai/test_serviceController.py | 81 +++++++++++++++++++
 2 files changed, 89 insertions(+), 6 deletions(-)
 create mode 100644 tests/unit/provider/akamai/test_serviceController.py

diff --git a/poppy/provider/akamai/services.py b/poppy/provider/akamai/services.py
index 14b485ec..cd881ad0 100644
--- a/poppy/provider/akamai/services.py
+++ b/poppy/provider/akamai/services.py
@@ -1085,6 +1085,12 @@ def _get_configuration_number(self, domain_obj):
         return configuration_number
 
     def _get_provider_access_url(self, domain_obj, dp, edge_host_name=None):
+        """
+        :param domain_obj: domain object
+        :param dp:
+        :param edge_host_name: Provider access URL
+        :return: returns provider access URL
+        """
         provider_access_url = None
         if domain_obj.protocol == 'http':
             provider_access_url = self.driver.akamai_access_url_link
@@ -1093,10 +1099,10 @@ def _get_provider_access_url(self, domain_obj, dp, edge_host_name=None):
                 provider_access_url = '.'.join(
                     ['.'.join(dp.split('.')[1:]),
                      self.driver.akamai_https_access_url_suffix])
-            elif domain_obj.certificate == 'san':
+            elif domain_obj.certificate in ['san', 'sni']:
                 if edge_host_name is None:
                     raise ValueError(
-                        "No EdgeHost name provided for SAN Cert")
+                        "No EdgeHost name provided for Cert")
                 # ugly fix for existing san cert domains, but we will
                 # have to take it for now
                 elif edge_host_name.endswith(
@@ -1106,10 +1112,6 @@ def _get_provider_access_url(self, domain_obj, dp, edge_host_name=None):
                     provider_access_url = '.'.join(
                         [edge_host_name,
                          self.driver.akamai_https_access_url_suffix])
-            elif domain_obj.certificate == 'sni':
-                if edge_host_name is None:
-                    raise ValueError("No EdgeHost name provided for SNI Cert")
-                provider_access_url = edge_host_name
             elif domain_obj.certificate == 'custom':
                 provider_access_url = '.'.join(
                     [dp, self.driver.akamai_https_access_url_suffix])
diff --git a/tests/unit/provider/akamai/test_serviceController.py b/tests/unit/provider/akamai/test_serviceController.py
new file mode 100644
index 00000000..38282fa8
--- /dev/null
+++ b/tests/unit/provider/akamai/test_serviceController.py
@@ -0,0 +1,81 @@
+from unittest import TestCase
+import ddt
+import mock
+import uuid
+
+from nose.tools import assert_true
+
+from poppy.provider.akamai import services
+from tests.unit import base
+from poppy.model.helpers import domain
+from poppy.model.helpers import origin
+from poppy.model.service import Service
+from poppy.model import service
+
+
+# from poppy.provider.akamai import driver
+
+@ddt.ddt
+class TestServiceController(base.TestCase):
+    def setUp(self):
+
+        super(TestServiceController, self).setUp()
+        driver_patcher = mock.patch('poppy.provider.akamai.driver')
+        mock_driver = driver_patcher.start()
+        self.addCleanup(driver_patcher.stop)
+        self.driver = mock_driver()
+        self.policy_client = self.driver.policy_api_client
+        self.ccu_client = self.driver.ccu_api_client
+        self.driver.provider_name = 'Akamai'
+        self.driver.http_conf_number = 1
+        self.driver.akamai_https_access_url_suffix = str(uuid.uuid1())
+        self.driver.akamai_http_access_url_suffix = str(uuid.uuid1())
+        self.driver.akamai_access_url_link = "abc.com.test.edgesuite.net"
+        self.san_cert_cnames = [str(x) for x in range(7)]
+        self.driver.san_cert_cnames = self.san_cert_cnames
+        self.driver.metrics_resolution = 86400
+        self.controller = services.ServiceController(self.driver)
+        service_id = str(uuid.uuid4())
+        domains_old = domain.Domain(domain='cdn.poppy.org')
+        current_origin = origin.Origin(origin='poppy.org')
+        self.service_obj = Service(service_id=service_id,
+                                   name='poppy cdn service',
+                                   domains=[domains_old],
+                                   origins=[current_origin],
+                                   flavor_id='cdn')
+
+    def test_get_provider_access_url_shared_custom(self):
+
+        certificates = ["shared", "custom"]
+        for certificate in certificates:
+            _domain = domain.Domain('densely.sage.com', 'https', certificate=certificate)
+            dp = 'test.xxxx.secure.raxcdn.com'
+            edge_host_name = None
+            https_url = self.controller._get_provider_access_url(_domain, dp, edge_host_name)
+            if certificate == 'shared':
+                expected_out = 'xxxx.secure.raxcdn.com.' + self.driver.akamai_https_access_url_suffix
+            else:
+                expected_out = 'test.xxxx.secure.raxcdn.com.' + self.driver.akamai_https_access_url_suffix
+            self.assertEqual(https_url, expected_out)
+
+    def test_get_provider_access_url_san_sni(self):
+        certificates = ["san", "sni"]
+        for certificate in certificates:
+            _domain = domain.Domain('densely.sage.com', 'https', certificate=certificate)
+            dp = 'test.abc.com'
+            edge_host_name = "test.com"
+            https_url = self.controller._get_provider_access_url(_domain, dp, edge_host_name)
+            expected_out = 'test.com.' + self.driver.akamai_https_access_url_suffix
+            self.assertEqual(https_url, expected_out)
+
+    def test_get_provider_access_url_http(self):
+
+        _domain = domain.Domain('densely.sage.com', 'http', certificate=None)
+        dp = 'test.abc.com'
+        edge_host_name = None
+        http_url = self.controller._get_provider_access_url(_domain, dp, edge_host_name)
+        expected_out = 'abc.com.test.edgesuite.net'
+        self.assertEqual(http_url, expected_out)
+
+
+

From 27417f86854d9e0a04726acc263ef0a2ce9f8f6e Mon Sep 17 00:00:00 2001
From: satroutr <engg.sanj@gmail.com>
Date: Tue, 21 Aug 2018 14:07:32 +0530
Subject: [PATCH 2/2] [Docstring]Distributed task

Added the docstring for distributed tasks
---
 .../distributed_task/taskflow/task/common.py  | 49 +++++++++++++
 .../taskflow/task/create_service_tasks.py     | 45 ++++++++++++
 .../task/create_ssl_certificate_tasks.py      | 29 ++++++++
 .../taskflow/task/delete_service_tasks.py     | 63 +++++++++++++++++
 .../task/delete_ssl_certificate_tasks.py      | 24 +++++++
 .../taskflow/task/purge_service_tasks.py      | 13 ++++
 .../task/update_service_state_tasks.py        | 38 +++++++++++
 .../taskflow/task/update_service_tasks.py     | 68 ++++++++++++++++++-
 8 files changed, 328 insertions(+), 1 deletion(-)

diff --git a/poppy/distributed_task/taskflow/task/common.py b/poppy/distributed_task/taskflow/task/common.py
index 70645508..08cffaab 100644
--- a/poppy/distributed_task/taskflow/task/common.py
+++ b/poppy/distributed_task/taskflow/task/common.py
@@ -53,6 +53,14 @@
 
 
 def create_log_delivery_container(project_id, auth_token):
+    """If log delivery is enabled create a container in the object storage.
+
+    :param unicode project_id: project id of the user
+    :param unicode auth_token: auth token generated by keystone
+
+    :return: log responders
+    :rtype: list
+    """
     # log delivery enabled, create log delivery container for the user
     conf.register_opts(LOG_DELIVERY_OPTIONS, group=LOG_DELIVERY_GROUP)
     conf.register_opts(DEFAULT_OPTIONS, group=DEFAULT_GROUP)
@@ -148,6 +156,18 @@ def create_log_delivery_container(project_id, auth_token):
 class ContextUpdateTask(task.Task):
 
     def execute(self, context_dict):
+        """Stores the context of each flow.
+
+        The following are all made available by executing this task:
+            - request_id
+            - user_identity
+            - auth_token
+            - user
+            - tenant
+            - service_id
+
+        :param dict context_dict: dict of context
+        """
         context = context_utils.RequestContext.from_dict(context_dict)
         context.update_store()
 
@@ -155,6 +175,15 @@ def execute(self, context_dict):
 class UpdateProviderDetailTask(task.Task):
 
     def execute(self, provider_details_dict, project_id, service_id):
+        """Update service details to storage
+
+        Storage gets updated with the service deatils and if log delivery
+        is enabled logs get pushed to the object storage container.
+
+        :param dict provider_details_dict: dict of the provider detail
+        :param unicode project_id: project id of the user
+        :param unicode service_id: uuid of the service
+        """
         provider_details_dict = dict([
             (k, provider_details.ProviderDetail.init_from_dict(detail))
             for k, detail
@@ -201,6 +230,12 @@ class UpdateProviderDetailIfNotEmptyTask(task.Task):
     default_provides = "provider_details_updated"
 
     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))
@@ -224,6 +259,7 @@ def execute(self, changed_provider_details_dict, project_id, service_id):
                  '{0}'.format(changed_provider_details_dict))
 
     def revert(self, *args, **kwargs):
+
         try:
             if getattr(self, 'storage_controller') \
                     and self.storage_controller._driver.session:
@@ -237,6 +273,19 @@ class UpdateProviderDetailErrorTask(task.Task):
     default_provides = "changed_provider_details_dict"
 
     def execute(self, responders, service_id, provider_details, hard):
+        """Update the provider details of service.
+
+        Updates the provider details for a service
+        and includes any error information.
+
+        :param list[dict] responders: list of responder
+        :param unicode service_id: uuid of service
+        :param unicode provider_details: json object of provider
+        :param unicode hard: parameter passed to force delete
+
+        :return: dict of changed_provider_details_dict
+        :rtype: dict
+        """
         provider_details = json.loads(provider_details)
         for provider in provider_details:
             # NOTE(tonytan4ever): if the purge_url is None, it means to purge
diff --git a/poppy/distributed_task/taskflow/task/create_service_tasks.py b/poppy/distributed_task/taskflow/task/create_service_tasks.py
index e3c126ff..3667dec8 100644
--- a/poppy/distributed_task/taskflow/task/create_service_tasks.py
+++ b/poppy/distributed_task/taskflow/task/create_service_tasks.py
@@ -46,6 +46,15 @@ class CreateProviderServicesTask(task.Task):
     default_provides = "responders"
 
     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')
 
@@ -104,6 +113,19 @@ class CreateServiceDNSMappingTask(task.Task):
     default_provides = "dns_responder"
 
     def execute(self, responders, retry_sleep_time, project_id, service_id):
+        """Creates the mapping between dns service and provider url.
+
+        The resulting domain is the cname created at rackspace dns which
+        used by customer for their by vanity domain.
+
+        :param list[dict] responders: list of responder
+        :param int retry_sleep_time: sleep time
+        :param unicode project_id: project id of the user
+        :param unicode service_id: uuid
+
+        :return: dict of dns_responder
+        :rtype: dict
+        """
         service_controller, dns = \
             memoized_controllers.task_controllers('poppy', 'dns')
 
@@ -134,6 +156,13 @@ def execute(self, responders, retry_sleep_time, project_id, 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
@@ -208,6 +237,14 @@ class CreateLogDeliveryContainerTask(task.Task):
     default_provides = "log_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')
 
@@ -246,6 +283,14 @@ class GatherProviderDetailsTask(task.Task):
     default_provides = "provider_details_dict"
 
     def execute(self, responders, dns_responder, log_responders):
+        """Gathers the status of create service, create dns and log delivery.
+
+        :param list[dict] responders:
+        :param dict dns_responder:
+        :param list[dict] log_responders: list of log_responder
+        :return: dict of provider_details_dict
+        :rtype: dict[str, collections.OrderedDict]
+        """
         provider_details_dict = {}
         for responder in responders:
             for provider_name in responder:
diff --git a/poppy/distributed_task/taskflow/task/create_ssl_certificate_tasks.py b/poppy/distributed_task/taskflow/task/create_ssl_certificate_tasks.py
index f2f52219..75fbe192 100644
--- a/poppy/distributed_task/taskflow/task/create_ssl_certificate_tasks.py
+++ b/poppy/distributed_task/taskflow/task/create_ssl_certificate_tasks.py
@@ -33,6 +33,16 @@ class CreateProviderSSLCertificateTask(task.Task):
 
     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
@@ -58,6 +68,12 @@ def execute(self, providers_list_json, cert_obj_json, enqueue=True,
 class SendNotificationTask(task.Task):
 
     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 = ""
@@ -86,6 +102,12 @@ def execute(self, project_id, responders, upgrade=False):
 class UpdateCertInfoTask(task.Task):
 
     def execute(self, project_id, cert_obj_json, responders):
+        """Update certificate information to cassandra.
+
+        :param unicode project_id: project id of the user
+        :param unicode cert_obj_json: dict of certificate(dict converted to json)
+        :param list[dict] responders: list of responder
+        """
         service_controller, self.ssl_certificate_manager = \
             memoized_controllers.task_controllers('poppy', 'ssl_certificate')
         self.storage_controller = self.ssl_certificate_manager.storage
@@ -110,6 +132,13 @@ class CreateStorageSSLCertificateTask(task.Task):
     """This task is meant to be used in san rerun flow."""
 
     def execute(self, project_id, cert_obj_json):
+        """Create certificate if san rerun executed.
+
+        When san rerun executed, create the certificate information at cassandra.
+
+        :param unicode project_id: project id of the user
+        :param unicode cert_obj_json: dict of certificate(dict converted to json)
+        """
         cert_obj = ssl_certificate.load_from_json(json.loads(cert_obj_json))
 
         service_controller, self.ssl_certificate_manager = \
diff --git a/poppy/distributed_task/taskflow/task/delete_service_tasks.py b/poppy/distributed_task/taskflow/task/delete_service_tasks.py
index ab5a4053..7d390668 100644
--- a/poppy/distributed_task/taskflow/task/delete_service_tasks.py
+++ b/poppy/distributed_task/taskflow/task/delete_service_tasks.py
@@ -51,6 +51,16 @@ class DeleteProviderServicesTask(task.Task):
     default_provides = "responders"
 
     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)
 
@@ -76,6 +86,20 @@ class DeleteServiceDNSMappingTask(task.Task):
 
     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')
 
@@ -115,6 +139,19 @@ def execute(self, provider_details, retry_sleep_time,
 
     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)
@@ -167,6 +204,15 @@ class GatherProviderDetailsTask(task.Task):
     default_provides = "provider_details_dict"
 
     def execute(self, responders, dns_responder, provider_details):
+        """Gathers the status of service, dns.
+
+        :param list[dict] responders: list of responder
+        :param dict dns_responder: dict of dns_responder
+        :param unicode provider_details: json of providers
+
+        :return: dict of provider details
+        :rtype: dict
+        """
         provider_details = json.loads(provider_details)
         for provider in provider_details:
             provider_details[provider] = (
@@ -204,11 +250,20 @@ def execute(self, responders, dns_responder, provider_details):
 class DeleteStorageServiceTask(task.Task):
 
     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 revert(self, *args, **kwargs):
+        """If failed to delete service from cassandra restore back."""
         try:
             if getattr(self, 'storage_controller') \
                     and self.storage_controller._driver.session:
@@ -222,6 +277,14 @@ class DeleteCertificatesForService(task.Task):
     """Delete SAN and SNI certificates for a service."""
 
     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')
 
diff --git a/poppy/distributed_task/taskflow/task/delete_ssl_certificate_tasks.py b/poppy/distributed_task/taskflow/task/delete_ssl_certificate_tasks.py
index d0cab884..2d4043c1 100644
--- a/poppy/distributed_task/taskflow/task/delete_ssl_certificate_tasks.py
+++ b/poppy/distributed_task/taskflow/task/delete_ssl_certificate_tasks.py
@@ -31,6 +31,17 @@ class DeleteProviderSSLCertificateTask(task.Task):
 
     def execute(self, providers_list, domain_name, cert_type,
                 project_id, flavor_id):
+        """Build responder from provider list of certificate details.
+
+        :param list providers_list: list of providers
+        :param unicode domain_name: domain name of the user
+        :param unicode cert_type: type of the certificate
+        :param unicode project_id: project id of the user
+        :param unicode flavor_id: flavor of the service
+
+        :return: list of responder
+        :rtype: list[dict]
+        """
         service_controller = memoized_controllers.task_controllers('poppy')
 
         cert_obj = ssl_certificate.SSLCertificate(flavor_id, domain_name,
@@ -54,6 +65,13 @@ def execute(self, providers_list, domain_name, cert_type,
 class SendNotificationTask(task.Task):
 
     def execute(self, project_id, responders, domain_name, cert_type):
+        """Send mail to user for certificate deletion.
+
+        :param unicode project_id: project id of the user
+        :param list[dict] responders: list of responder
+        :param unicode domain_name: domain name of the user
+        :param unicode cert_type: certificate type of the user
+        """
         service_controller = memoized_controllers.task_controllers('poppy')
 
         notification_content = (
@@ -85,6 +103,12 @@ def execute(self, project_id, responders, domain_name, cert_type):
 class DeleteStorageSSLCertificateTask(task.Task):
 
     def execute(self, project_id, domain_name, cert_type):
+        """Delete certificate details from cassandra.
+
+        :param unicode project_id: project id of the user
+        :param unicode domain_name: domain name of the user
+        :param unicode cert_type: certificate type of the user
+        """
         service_controller, self.ssl_certificate_manager = \
             memoized_controllers.task_controllers('poppy', 'ssl_certificate')
         self.storage_controller = self.ssl_certificate_manager.storage
diff --git a/poppy/distributed_task/taskflow/task/purge_service_tasks.py b/poppy/distributed_task/taskflow/task/purge_service_tasks.py
index a97df06b..7f284dd7 100644
--- a/poppy/distributed_task/taskflow/task/purge_service_tasks.py
+++ b/poppy/distributed_task/taskflow/task/purge_service_tasks.py
@@ -35,6 +35,19 @@ class PurgeProviderServicesTask(task.Task):
     default_provides = "responders"
 
     def execute(self, service_obj, hard, provider_details, purge_url):
+        """delete/abruptly remove details of service.
+
+        If purge url is not provided delete all the content, else
+        delete only the content of the purge url provided.
+
+        :param unicode service_obj: json of service dict
+        :param unicode hard: passed by user if wants to hard purge all content
+        :param unicode provider_details: json of the provider dict
+        :param unicode purge_url: url need to purge
+
+        :return: list of responder
+        :rtype: list[dict]
+        """
         service_controller = memoized_controllers.task_controllers('poppy')
         service_json = json.loads(service_obj)
         service_obj = service.load_from_json(service_json)
diff --git a/poppy/distributed_task/taskflow/task/update_service_state_tasks.py b/poppy/distributed_task/taskflow/task/update_service_state_tasks.py
index 8b29c428..214db7d3 100644
--- a/poppy/distributed_task/taskflow/task/update_service_state_tasks.py
+++ b/poppy/distributed_task/taskflow/task/update_service_state_tasks.py
@@ -42,6 +42,14 @@
 
 class UpdateServiceStateTask(task.Task):
     def execute(self, project_id, service_obj, state):
+        """Update the operator status of service to cassandra.
+
+        Update the status of the operator to the storage for services.
+
+        :param unicode project_id: project id of the user
+        :param unicode service_obj: json object of the service
+        :param bool state: operator status of service
+        """
         service_obj_json = json.loads(service_obj)
         service_obj = service.load_from_json(service_obj_json)
 
@@ -58,6 +66,15 @@ def execute(self, project_id, service_obj, state):
 
 class FixDNSChainTask(task.Task):
     def execute(self, service_obj, project_id, retry_sleep_time):
+        """Enable/Fix DNS record for service.
+
+        While updating the service state reestablish 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)
 
@@ -104,6 +121,12 @@ def execute(self, service_obj, project_id, retry_sleep_time):
                                            project_id))
 
     def revert(self, service_obj, project_id, retry_sleep_time, **kwargs):
+        """Revert if fixing dns record of service failed.
+
+        :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
+        """
         if self.name in kwargs['flow_failures'].keys():
             retries = conf[DNS_GROUP].retries
             current_progress = (1.0 / retries)
@@ -150,6 +173,15 @@ def revert(self, service_obj, project_id, retry_sleep_time, **kwargs):
 
 class BreakDNSChainTask(task.Task):
     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)
 
@@ -197,6 +229,12 @@ def execute(self, service_obj, project_id, retry_sleep_time):
         return
 
     def revert(self, service_obj, project_id, retry_sleep_time, **kwargs):
+        """Revert if breaking the dns record chain fails.
+
+        :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
+        """
         if self.name in kwargs['flow_failures'].keys():
             retries = conf[DNS_GROUP].retries
             current_progress = (1.0 / retries)
diff --git a/poppy/distributed_task/taskflow/task/update_service_tasks.py b/poppy/distributed_task/taskflow/task/update_service_tasks.py
index 6741f7c6..c74bf680 100644
--- a/poppy/distributed_task/taskflow/task/update_service_tasks.py
+++ b/poppy/distributed_task/taskflow/task/update_service_tasks.py
@@ -50,6 +50,14 @@ class UpdateProviderServicesTask(task.Task):
     default_provides = "responders"
 
     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)
@@ -76,6 +84,20 @@ class UpdateServiceDNSMappingTask(task.Task):
 
     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)
@@ -117,6 +139,15 @@ def execute(self, responders, retry_sleep_time,
     def revert(self, responders, retry_sleep_time,
                service_old, service_obj,
                project_id, service_id, **kwargs):
+        """Revert if updating the mapping between dns service and provider url fails.
+
+        :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
+        """
         if self.name in kwargs['flow_failures'].keys():
             retries = conf[DNS_GROUP].retries
             current_progress = (1.0 / retries)
@@ -181,6 +212,16 @@ class UpdateLogDeliveryContainerTask(task.Task):
     default_provides = "log_responders"
 
     def execute(self, project_id, auth_token, service_old, service_obj):
+        """If enabled it updates a object storage container to store logs.
+
+        :param unicode project_id: project id of user
+        :param unicode auth_token: auth token generated by keystone
+        :param unicode service_old: json object of the old service
+        :param unicode service_obj: json object of the service
+
+        :return: log responders
+        :rtype: list or None
+        """
         service_old_json = json.loads(service_old)
         service_obj_json = json.loads(service_obj)
 
@@ -201,6 +242,18 @@ class GatherProviderDetailsTask(task.Task):
 
     def execute(self, responders, dns_responder, log_responders, project_id,
                 service_id, service_obj):
+        """Gathers the status of update service, update dns and log delivery.
+
+        :param list[dict] responders: list of dict of responder
+        :param dict dns_responder: dict of dns_responder
+        :param list log_responders: list of log_responder
+        :param unicode project_id: project id of the user
+        :param unicode service_id: uuid of the service
+        :param unicode service_obj: json object of the service
+
+        :return: provider_details_dict_error_tuple tuple of dict and string
+        :rtype: tuple
+        """
 
         service_controller, self.storage_controller = \
             memoized_controllers.task_controllers('poppy', 'storage')
@@ -289,6 +342,14 @@ class UpdateProviderDetailsTask_Errors(task.Task):
 
     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 = \
@@ -351,9 +412,14 @@ def revert(self, *args, **kwargs):
 
 
 class DeleteCertsForRemovedDomains(task.Task):
-    """Delete certificates domains deleted during service update."""
 
     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')