Merge pull request #33 from BenjamenMeyer/enhancement_subservices

Enhancement: Enable Sub-Services for better API end-point management

Author: BenjamenMeyer

stackinabox/services/service.py

@@ -23,6 +23,93 @@ class InvalidRouteRegexError(StackInABoxServiceErrors):
     pass
 
 
+class StackInABoxServiceRouter(object):
+
+    def __init__(self, name, uri, obj, parent_obj):
+        self.service_name = name
+        self.uri = uri
+        self.obj = obj
+        self.parent_obj = parent_obj
+        self.methods = {}
+
+        # Ensure we do not have any circular references
+        assert(self.obj != self.parent_obj)
+
+    @property
+    def is_subservice(self):
+        if self.obj is not None:
+            return True
+
+        return False
+
+    def set_subservice(self, obj):
+        if self.obj is not None:
+            raise RouteAlreadyRegisteredError(
+                'Service Router ({0} - {1}): Route {2} already has a '
+                'sub-service handler'
+                .format(id(self), self.service_name, self.uri))
+
+        if len(self.methods):
+            logger.debug(
+                'WARNING: Service Router ({0} - {1}): Methods detected '
+                'on Route {2}. Sub-Service {3} may be hidden.'
+                .format(id(self), self.service_name, self.uri, obj.name))
+
+        # Ensure we do not have any circular references
+        assert(obj != self.parent_obj)
+        self.obj = obj
+        self.obj.base_url = '{0}/{1}'.format(self.uri, self.service_name)
+
+    def update_uris(self, new_uri):
+        self.uri = new_uri
+        if self.obj:
+            self.obj.base_url = '{0}/{1}'.format(self.uri, self.service_name)
+
+    def register_method(self, method, fn):
+        if method not in self.methods.keys():
+            logger.debug('Service Router ({0} - {1}): Adding method {2} on '
+                         'route {3}'
+                         .format(id(self),
+                                 self.service_name,
+                                 method,
+                                 self.uri))
+            self.methods[method] = fn
+
+        else:
+            raise RouteAlreadyRegisteredError(
+                'Service Router ({0} - {1}): Method {2} already registered '
+                'on Route {3}'
+                .format(id(self),
+                        self.service_name,
+                        method,
+                        self.uri))
+
+    def __call__(self, method, request, uri, headers):
+        if method in self.methods:
+            logger.debug('Service Router ({0} - {1}): Located Method {2} on '
+                         'Route {3}. Calling...'
+                         .format(id(self),
+                                 self.service_name,
+                                 method,
+                                 self.uri))
+            return self.methods[method](self.parent_obj,
+                                        request,
+                                        uri,
+                                        headers)
+        else:
+            logger.debug('Service Router ({0} - {1}): Located Subservice {2} '
+                         'on Route {3}. Calling...'
+                         .format(id(self),
+                                 self.service_name,
+                                 self.obj.name,
+                                 self.uri))
+
+            return self.obj.sub_request(method,
+                                        request,
+                                        uri,
+                                        headers)
+
+
 class StackInABoxService(object):
     DELETE = 'DELETE'
     GET = 'GET'
@@ -51,33 +138,41 @@ def __init__(self, name):
                      .format(self.__id, self.name))
 
     @staticmethod
-    def __is_regex(uri):
+    def is_regex(uri):
         regex_type = type(re.compile(''))
         return isinstance(uri, regex_type)
 
     @staticmethod
-    def validate_regex(regex):
+    def validate_regex(regex, sub_service):
         # The regex generated by stackinabox starts with ^
         # and ends with $. Enforce that the provided regex does the same.
 
         if regex.pattern.startswith('^') is False:
             logger.debug('StackInABoxService: Pattern must start with ^')
             raise InvalidRouteRegexError('Pattern must start with ^')
 
-        if regex.pattern.endswith('$') is False:
+        # Note: pattern may end with $ even if sub_service is True
+        if regex.pattern.endswith('$') is False and sub_service is False:
             logger.debug('StackInABoxService: Pattern must end with $')
             raise InvalidRouteRegexError('Pattern must end with $')
 
+        # Enforce that if the pattern does not end with $ that it is a service
+        if regex.pattern.endswith('$') is True and sub_service is True:
+            logger.debug(
+                'StackInABoxService: Sub-Service RegEx Pattern must not '
+                'end with $')
+            raise InvalidRouteRegexError('Pattern must end with $')
+
     @staticmethod
-    def __get_service_regex(base_url, service_url):
+    def get_service_regex(base_url, service_url, sub_service):
         # if the specified service_url is already a regex
         # then just use. Otherwise create what we need
-        if StackInABoxService.__is_regex(service_url):
+        if StackInABoxService.is_regex(service_url):
             logger.debug('StackInABoxService: Received regex {0} for use...'
                          .format(service_url.pattern))
 
             # Validate the regex against StackInABoxService requirement
-            StackInABoxService.validate_regex(service_url)
+            StackInABoxService.validate_regex(service_url, sub_service)
 
             return service_url
         else:
@@ -100,8 +195,10 @@ def base_url(self, value):
                              value))
         self.__base_url = value
         for k, v in six.iteritems(self.routes):
-            v['regex'] = StackInABoxService.__get_service_regex(value,
-                                                                v['uri'])
+            v['regex'] = StackInABoxService.get_service_regex(
+                value,
+                v['uri'],
+                v['handlers'].is_subservice)
 
     def reset(self):
         logger.debug('StackInABoxService ({0}): Reset'
@@ -110,10 +207,8 @@ def reset(self):
         logger.debug('StackInABoxService ({0}): Hosting Service {1}'
                      .format(self.__id, self.name))
 
-    def request(self, method, request, uri, headers):
-        logger.debug('StackInABoxService ({0}:{1}): Received {2} - {3}'
-                     .format(self.__id, self.name, method, uri))
-        uri_path = uri
+    def try_handle_route(self, route_uri, method, request, uri, headers):
+        uri_path = route_uri
         if '?' in uri:
             logger.debug('StackInABoxService ({0}:{1}): Found query string '
                          'removing for match operation.'
@@ -137,38 +232,47 @@ def request(self, method, request, uri, headers):
                 logger.debug('StackInABoxService ({0}:{1}): Checking if '
                              'route {2} handles method {2}...'
                              .format(self.__id, self.name, v['uri'], method))
-                if method in v['handlers']:
-                    logger.debug('StackInABoxService ({0}:{1}): Calling '
-                                 'handler for route {2} on method {3}...'
-                                 .format(self.__id,
-                                         self.name,
-                                         v['uri'],
-                                         method))
-                    return v['handlers'][method](self,
-                                                 request,
-                                                 uri,
-                                                 headers)
+                return v['handlers'](method,
+                                     request,
+                                     uri,
+                                     headers)
         return (500, headers, 'Server Error')
 
-    def register(self, method, uri, call_back):
-        found = False
+    def request(self, method, request, uri, headers):
+        logger.debug('StackInABoxService ({0}:{1}): Request Received {2} - {3}'
+                     .format(self.__id, self.name, method, uri))
+        return self.try_handle_route(uri, method, request, uri, headers)
+
+    def sub_request(self, method, request, uri, headers):
+        logger.debug('StackInABoxService ({0}:{1}): Sub-Request Received '
+                     '{2} - {3}'
+                     .format(self.__id, self.name, method, uri))
+        return self.request(method, request, uri, headers)
 
+    def create_route(self, uri, sub_service):
         if uri not in self.routes.keys():
             logger.debug('Service ({0}): Creating routes'
                          .format(self.name))
             self.routes[uri] = {
-                'regex': StackInABoxService.__get_service_regex(self.base_url,
-                                                                uri),
+                'regex': StackInABoxService.get_service_regex(self.base_url,
+                                                              uri,
+                                                              sub_service),
                 'uri': uri,
-                'handlers': {
-                }
+                'handlers': StackInABoxServiceRouter(self.name,
+                                                     uri,
+                                                     None,
+                                                     self)
             }
 
-        if method not in self.routes[uri]['handlers'].keys():
-            logger.debug('Service ({0}): Adding route for {1}'
-                         .format(self.name, method))
-            self.routes[uri]['handlers'][method] = call_back
-        else:
-            raise RouteAlreadyRegisteredError(
-                'Service ({0}): Route {1} already registered'
-                .format(self.name, uri))
+    def register(self, method, uri, call_back):
+        found = False
+
+        self.create_route(uri, False)
+        self.routes[uri]['handlers'].register_method(method,
+                                                     call_back)
+
+    def register_subservice(self, uri, service):
+        found = False
+
+        self.create_route(uri, True)
+        self.routes[uri]['handlers'].set_subservice(service)

stackinabox/tests/test_service.py

@@ -1,8 +1,12 @@
 import re
 import unittest
 
+import httpretty
+import requests
 
+from stackinabox.stack import StackInABox
 from stackinabox.services.service import *
+import stackinabox.util_httpretty
 
 
 class TestServiceRegex(unittest.TestCase):
@@ -13,7 +17,18 @@ def setUp(self):
     def tearDown(self):
         super(TestServiceRegex, self).tearDown()
 
-    def test_stackinabox_service_regex(self):
+    def test_instantiation(self):
+        name = 'test-service'
+
+        service = StackInABoxService(name)
+        self.assertEqual(service.name, name)
+        self.assertTrue(service.base_url.startswith('/'))
+        self.assertTrue(service.base_url.endswith(name))
+        self.assertEqual(len(service.base_url),
+                         (len(name) + 1))
+        self.assertEqual(len(service.routes), 0)
+
+    def test_stackinabox_validate_regex(self):
 
         positive_cases = [
             re.compile('^/$')
@@ -25,11 +40,34 @@ def test_stackinabox_service_regex(self):
         ]
 
         for case in positive_cases:
-            StackInABoxService.validate_regex(case)
+            StackInABoxService.validate_regex(case, False)
 
         for case in negative_cases:
             with self.assertRaises(InvalidRouteRegexError):
-                StackInABoxService.validate_regex(case)
+                StackInABoxService.validate_regex(case, False)
+
+    def test_stackinabox_service_regex(self):
+
+        case_regex = [
+            re.compile('^/$')
+        ]
+
+        case_nonregex = [
+            '/',
+        ]
+
+        for case in case_regex:
+            self.assertEqual(StackInABoxService.get_service_regex('base',
+                                                                  case,
+                                                                  False),
+                             case)
+
+        for case in case_nonregex:
+            case_regex = re.compile('^{0}$'.format(case))
+            self.assertEqual(StackInABoxService.get_service_regex('base',
+                                                                  case,
+                                                                  False),
+                             case_regex)
 
 
 class AnotherAdvancedService(StackInABoxService):
@@ -46,13 +84,25 @@ def second_handler(self, request, uri, headers):
         return (200, headers, 'howdy')
 
 
+class YetAnotherService(StackInABoxService):
+
+    def __init__(self):
+        super(YetAnotherService, self).__init__('yaas')
+        self.register(StackInABoxService.GET, '^/french$',
+                      YetAnotherService.yaas_handler)
+
+    def yaas_handler(self, request, uri, headers):
+        return (200, headers, 'bonjour')
+
+
 class TestServiceRouteRegistration(unittest.TestCase):
 
     def setUp(self):
         super(TestServiceRouteRegistration, self).setUp()
 
     def tearDown(self):
         super(TestServiceRouteRegistration, self).tearDown()
+        StackInABox.reset_services()
 
     def test_bad_registration(self):
 
@@ -61,3 +111,20 @@ def test_bad_registration(self):
         with self.assertRaises(RouteAlreadyRegisteredError):
             service.register(StackInABoxService.GET, '/',
                              AnotherAdvancedService.second_handler)
+
+    @httpretty.activate
+    def test_subservice_registration(self):
+        service = AnotherAdvancedService()
+        subservice = YetAnotherService()
+        service.register_subservice(re.compile('^/french'),
+                                    subservice)
+
+        StackInABox.register_service(service)
+
+        stackinabox.util_httpretty.httpretty_registration('localhost')
+
+        res = requests.get('http://localhost/aas/french')
+        self.assertEqual(res.status_code,
+                         200)
+        self.assertEqual(res.text,
+                         'bonjour')

tox.ini

@@ -12,6 +12,7 @@ commands = nosetests {posargs}
 [testenv:py34]
 deps = -r{toxinidir}/tools/test-requirements.txt
 commands = nosetests {posargs}
+setenv = VIRTUAL_ENV={envdir} LC_ALL = en_US.utf-8
 
 [testenv:pep8]
 deps = setuptools>=1.1.6