fix: create a default caching rule with ttl

- if no caching is specified, lets create a default caching rule on
  request_url of '/*' with the default ttl value derived from poppy.conf

Change-Id: Ib12a3ea1e3cac044b067f06a2c716847caf88b67

etc/poppy.conf

@@ -114,6 +114,9 @@ auth_endpoint = ""
 timeout = 30
 delay = 1
 
+[drivers:provider]
+default_cache_ttl = 86400
+
 [drivers:provider:fastly]
 apikey = "MYAPIKEY"
 scheme = "https"

poppy/manager/default/services.py

@@ -26,6 +26,7 @@ from poppy.distributed_task.taskflow.flow import purge_service
 from poppy.distributed_task.taskflow.flow import update_service
 from poppy.distributed_task.taskflow.flow import update_service_state
 from poppy.manager import base
+from poppy.model.helpers import cachingrule
 from poppy.model.helpers import rule
 from poppy.model import service
 from poppy.openstack.common import log
@@ -49,7 +50,15 @@ DNS_OPTIONS = [
         help='Maximum Number of seconds to sleep between retries'),
 ]
 
+PROVIDER_OPTIONS = [
+    cfg.IntOpt(
+        'default_cache_ttl',
+        default=86400,
+        help='Default ttl to be set, when no caching rules are specified'),
+]
+
 DNS_GROUP = 'drivers:dns'
+PROVIDER_GROUP = 'drivers:provider'
 
 
 class DefaultServicesController(base.ServicesController):
@@ -67,7 +76,10 @@ class DefaultServicesController(base.ServicesController):
 
         self.driver.conf.register_opts(DNS_OPTIONS,
                                        group=DNS_GROUP)
+        self.driver.conf.register_opts(PROVIDER_OPTIONS,
+                                       group=PROVIDER_GROUP)
         self.dns_conf = self.driver.conf[DNS_GROUP]
+        self.provider_conf = self.driver.conf[PROVIDER_GROUP]
 
     def determine_sleep_times(self):
 
@@ -99,7 +111,7 @@ class DefaultServicesController(base.ServicesController):
                 domain_name))
         return service_details
 
-    def _append_defaults(self, service_json):
+    def _append_defaults(self, service_json, operation='create'):
         # default origin rule
         for origin in service_json.get('origins', []):
             if origin.get('rules') is None:
@@ -112,13 +124,23 @@ class DefaultServicesController(base.ServicesController):
                     name="default",
                     request_url='/*')
                 origin['rules'].append(default_rule.to_dict())
+        if operation == 'create':
+            # default caching rule
+            if not service_json.get('caching'):
+                # add the /* default request_url rule
+                default_rule = rule.Rule(
+                    name="default",
+                    request_url='/*')
+                default_ttl = self.provider_conf.default_cache_ttl
+                default_cache = cachingrule.CachingRule(name='default',
+                                                        ttl=default_ttl,
+                                                        rules=[default_rule])
+                service_json['caching'] = [default_cache.to_dict()]
 
-        # default caching rule
         for caching_entry in service_json.get('caching', []):
             if caching_entry.get('rules') is None:
                 # add a rules section
                 caching_entry['rules'] = []
-
             if caching_entry.get('rules') == []:
                 # add the /* default request_url rule
                 default_rule = rule.Rule(
@@ -152,7 +174,6 @@ class DefaultServicesController(base.ServicesController):
         :param service_obj
         :raises LookupError, ValueError
         """
-
         try:
             flavor = self.flavor_controller.get(service_json.get('flavor_id'))
         # raise a lookup error if the flavor is not found
@@ -160,7 +181,7 @@ class DefaultServicesController(base.ServicesController):
             raise e
 
         # add any default rules so its explicitly defined
-        self._append_defaults(service_json)
+        self._append_defaults(service_json, operation='create')
 
         # convert to an object
         service_obj = service.Service.init_from_dict(service_json)
@@ -243,7 +264,7 @@ class DefaultServicesController(base.ServicesController):
             service_old_json, service_updates)
 
         # add any default rules so its explicitly defined
-        self._append_defaults(service_new_json)
+        self._append_defaults(service_new_json, operation='update')
 
         # validate the updates
         schema = service_schema.ServiceSchema.get_schema("service", "POST")

tests/api/services/data_default_service_values.json

@@ -38,6 +38,18 @@
                     ],
                     "hostheadertype": "domain"
                 }
+            ],
+            "caching_list": [
+                {
+                    "name": "default",
+                    "ttl": 86400,
+                    "rules": [
+                        {
+                            "name" : "default",
+                            "request_url" : "/*"
+                        }
+                    ]
+                }
             ]
         }
     },

tests/api/services/test_services.py

@@ -15,6 +15,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import six
 import time
 import urlparse
 import uuid
@@ -89,7 +90,17 @@ class TestCreateService(providers.TestProviderBase):
                 item[u'hostheadervalue'] = item['origin']
         self.assertEqual(body['origins'], origin_list)
 
-        self.assertEqual(body['caching'], caching_list)
+        if caching_list:
+            self.assertEqual(body['caching'], caching_list)
+        else:
+            self.assertEqual(body['caching'][0]['name'],
+                             'default')
+            self.assertEqual(body['caching'][0]['rules'][0]['name'],
+                             'default')
+            self.assertEqual(body['caching'][0]['rules'][0]['request_url'],
+                             '/*')
+            self.assertTrue(isinstance(body['caching'][0]['ttl'],
+                                       six.integer_types))
 
         # Verify the service is updated at all Providers for the flavor
         if self.test_config.provider_validation:

tests/api/utils/schema/services.py

@@ -53,7 +53,7 @@ origin = {
 cache = {'type': 'object',
          'properties': {
              'name': {'type': 'string'},
-             'ttl': {'type': 'number', 'minimum': 0, 'maximum': 3600},
+             'ttl': {'type': 'number', 'minimum': 0},
              'rules': {'type': 'array'}},
          'required': ['name', 'ttl'],
          'additionalProperties': False}

tests/unit/manager/default/test_services.py

@@ -21,6 +21,7 @@ import ddt
 import mock
 from oslo_config import cfg
 import requests
+import six
 
 from poppy.distributed_task.taskflow.task import common
 from poppy.distributed_task.taskflow.task import create_service_tasks
@@ -285,6 +286,30 @@ class DefaultManagerServiceTests(base.TestCase):
 
         bootstrap_mock_update()
 
+    def test_defaults_caching(self):
+        service_json = {
+            'caching': []
+        }
+        self.sc._append_defaults(service_json, operation='create')
+        changed_service_json = {
+            'caching': [
+                {
+                    'name': 'default',
+                    'rules': [
+                        {
+                            'name': 'default',
+                            'request_url': '/*'
+                        }
+                    ]
+                }
+            ]
+        }
+
+        self.assertTrue(isinstance(service_json['caching'][0]['ttl'],
+                        six.integer_types))
+        del service_json['caching'][0]['ttl']
+        self.assertEqual(service_json, changed_service_json)
+
     def test_create(self):
         # fake one return value
         self.sc.flavor_controller.get.return_value = flavor.Flavor(