Merge pull request #1 from splitio/qos-fixes

These changes are all deployed and working in the testing apps. Merging to dev

Author: mredolatti

.gitignore

@@ -90,3 +90,6 @@ ENV/
 
 #vim backup files
 *.swp
+
+#IDE
+.idea

identify/http_clients/sync_client.py

@@ -6,7 +6,8 @@
 from identify.http_clients import base_client
 from identify.util.logger import LOGGER
 from identify.util.exceptions import HTTPResponseError, HTTPNotFoundError, \
-    HTTPIncorrectParametersError, HTTPUnauthorizedError
+    HTTPIncorrectParametersError, HTTPUnauthorizedError, \
+    IdentifyBackendUnreachableError
 
 
 class SyncHttpClient(base_client.BaseHttpClient):
@@ -37,7 +38,11 @@ def setup_method(self, method, body=None):
 
     def _handle_invalid_response(self, response):
         '''
-        TODO
+        Handle responses that are not okay and throw an appropriate exception.
+        If the code doesn't match the known ones, a generic HTTPResponseError
+        is thrown
+
+        :param response: requests' module response object
         '''
         status_codes_exceptions = {
             404: HTTPNotFoundError,
@@ -51,6 +56,18 @@ def _handle_invalid_response(self, response):
         else:
             raise HTTPResponseError
 
+    def _handle_connection_error(self, e):
+        '''
+        Handle error when attempting to connect to identify backend.
+        Logs exception thrown by requests module, and raises an
+        IdentifyBackendUnreachableError error, so that it can be caught
+        by using the top level IdentifyException
+        '''
+        LOGGER.debug(e)
+        raise IdentifyBackendUnreachableError(
+            'Unable to reach Identify backend'
+        )
+
     def make_request(self, endpoint, body=None, **kwargs):
         '''
         This method delegates bulding of headers, url and querystring (!)
@@ -81,7 +98,7 @@ def make_request(self, endpoint, body=None, **kwargs):
         try:
             response = method(url, headers=headers)
         except Exception as e:
-            return self._connection_error(e)
+            return self._handle_connection_error(e)
         finally:
             LOGGER.debug('RESPONSE: ' + response.text)
 

identify/main/__init__.py

@@ -1,15 +1,12 @@
 from identify.main.identify_sync_client import SyncIdentifyClient
-from identify.util import logger
 
 
 def get_client(config):
     '''
     Entry point for the Identify API client
     '''
     _async = config.get('async', False)
-    if _async: raise Exception('Async client not yet implemented')
-
-    if 'log_level' in config:
-        logger.set_level(config['log_level'])
+    if _async:
+        raise Exception('Async client not yet implemented')
 
     return SyncIdentifyClient(config)

identify/main/identify_client.py

@@ -12,42 +12,18 @@ class BaseIdentifyClient:
     def __init__(self, config):
         pass
 
-    @abc.abstractmethod
-    def get_traffic_types(self):
-        pass
-
-    @abc.abstractmethod
-    def get_environments(self):
-        pass
-
-    @abc.abstractmethod
-    def get_attributes_for_traffic_type(self, traffic_type_id):
-        pass
-
-    @abc.abstractmethod
-    def create_attribute_for_traffic_type(self, traffic_type_id, attr_data):
-        pass
-
-    @abc.abstractmethod
-    def delete_attribute_from_schema(self, traffic_type_id, attribute_id):
+    @abc.abstractproperty
+    def traffic_type(self):
         pass
 
-    @abc.abstractmethod
-    def add_identities(self, traffic_type_id, environment_id, entities):
+    @abc.abstractproperty
+    def environment(self):
         pass
 
-    @abc.abstractmethod
-    def add_identity(self, traffic_type_id, environment_id, key, values):
+    @abc.abstractproperty
+    def attribute(self):
         pass
 
-    @abc.abstractmethod
-    def update_identity(self, traffic_type_id, environment_id, key, values):
-        pass
-
-    @abc.abstractmethod
-    def patch_identity(self, traffic_type_id, environment_id, key, values):
-        pass
-
-    @abc.abstractmethod
-    def delete_attributes_from_key(self, traffic_type_id, environment_id, key):
+    @abc.abstractproperty
+    def identity(self):
         pass

identify/main/identify_sync_client.py

@@ -2,11 +2,11 @@
     unicode_literals
 from identify.main.identify_client import BaseIdentifyClient
 from identify.http_clients.sync_client import SyncHttpClient
-from identify.resources.traffic_type import TrafficType
-from identify.resources.environment import Environment
-from identify.resources.attribute import Attribute
-from identify.resources.identity import Identity
 from identify.util.exceptions import InsufficientConfigArgumentsException
+from identify.microclients import TrafficTypeMicroClient
+from identify.microclients import EnvironmentMicroClient
+from identify.microclients import IdentityMicroClient
+from identify.microclients import AttributeMicroClient
 
 
 class SyncIdentifyClient(BaseIdentifyClient):
@@ -33,167 +33,25 @@ def __init__(self, config):
                 % ','.join(missing)
             )
 
-        self._client = SyncHttpClient(self._base_url, self._apikey)
+        http_client = SyncHttpClient(self._base_url, self._apikey)
 
-    def get_traffic_types(self):
-        '''
-        Returns a list of TrafficType objects.
-        '''
-        return TrafficType.retrieve_all(self._client)
+        self._traffic_type_client = TrafficTypeMicroClient(http_client)
+        self._environment_client = EnvironmentMicroClient(http_client)
+        self._attribute_client = AttributeMicroClient(http_client)
+        self._identity_client = IdentityMicroClient(http_client)
 
-    def get_environments(self):
-        '''
-        Returns a list of environments.
-        '''
-        return Environment.retrieve_all(self._client)
+    @property
+    def traffic_type(self):
+        return self._traffic_type_client
 
-    def get_attributes_for_traffic_type(self, traffic_type_id):
-        '''
-        Returns a list of attributes for a particular traffic type.
+    @property
+    def environment(self):
+        return self._environment_client
 
-        :param traffic_type_id: Id of the traffic type whose attributes are to
-            be retrieved.
-        '''
-        return Attribute.retrieve_all(
-            self._client,
-            trafficTypeId=traffic_type_id
-        )
-
-    def create_attribute_for_traffic_type(self, traffic_type_id, attr_data):
-        '''
-        Creates an attribute for a specific traffic type.
+    @property
+    def attribute(self):
+        return self._attribute_client
 
-        :param traffic_type_id: Id of the traffic type for which an attribute
-            will be created.
-        :param attr_data: Dictionary with the the data to create the new
-            attribute. Should include the followind fields:
-                - 'id': Id of the new attribute
-                - 'displayName': Display Name of the new attribute
-                - 'description': Description of the new attribute
-                - 'dataType': Data type of the new attribute
-        '''
-        return Attribute.create(
-            self._client,
-            attr_data.get('id'),
-            traffic_type_id,
-            attr_data.get('displayName'),
-            attr_data.get('description'),
-            attr_data.get('dataType')
-        )
-
-    def delete_attribute_from_schema(self, traffic_type_id, attribute_id):
-        '''
-        Delete an attribute from a particular traffic type.
-
-        :param traffic_type_id: Trafic id of the schema whose attribute
-            will be removed.
-        :param attribute_id: Id of the attribute to be removed.
-        '''
-        return Attribute.delete(self._client, attribute_id, traffic_type_id)
-
-    def add_identities(self, traffic_type_id, environment_id, identities):
-        '''
-        Create Identities for a specific traffic type and environment.
-
-        :param traffic_type_id: Traffic type id
-        :param environment_id: Environment where the identities will be created.
-        :param identities: Identities to be added. Should be in a dict with
-            the following format:
-                {
-                    'key1': {
-                        attribute_id_1a: value_1a,
-                        attribute_id_1b: value_1b,
-                    },
-                    'key2': {
-                        attribute_id_2a: value_2a,
-                        attribute_id_2b: value_2b,
-                    }
-                }
-        '''
-        return Identity.create_many(
-            self._client,
-            traffic_type_id,
-            environment_id,
-            identities
-        )
-
-    def add_identity(self, traffic_type_id, environment_id, key, values):
-        '''
-        Create a new Identity.
-
-        :param traffic_type_id: Traffic Type Id
-        :param environment_id: Environment where the identity will be created.
-        :key: Identity key
-        :values: Attribute values for the identity. Should be a dict with
-             the following format:
-                 {
-                    attribute_id1: value1,
-                    attribute_id2: value2,
-                 }
-        '''
-        return Identity.create(
-            self._client,
-            key,
-            traffic_type_id,
-            environment_id,
-            values
-        )
-
-    def update_identity(self, traffic_type_id, environment_id, key, values):
-        '''
-        Update an Identity.
-
-        :param traffic_type_id: Traffic Type Id
-        :param environment_id: Environment where the identity will be updated.
-        :key: Identity key
-        :values: Attribute values for the identity. Should be a dict with
-             the following format:
-                 {
-                    attribute_id1: value1,
-                    attribute_id2: value2,
-                 }
-        '''
-        return Identity.update(
-            self._client,
-            key,
-            traffic_type_id,
-            environment_id,
-            values
-        )
-
-    def patch_identity(self, traffic_type_id, environment_id, key, values):
-        '''
-        Patch an Identity.
-
-        :param traffic_type_id: Traffic Type Id
-        :param environment_id: Environment where the identity will be patched.
-        :key: Identity key
-        :values: Attribute values for the identity. Should be a dict with
-             the following format:
-                 {
-                    attribute_id1: value1,
-                    attribute_id2: value2,
-                 }
-        '''
-        return Identity.patch(
-            self._client,
-            key,
-            traffic_type_id,
-            environment_id,
-            values
-        )
-
-    def delete_attributes_from_key(self, traffic_type_id, environment_id, key):
-        '''
-        Delete all attributes for a specific key.
-
-        :param traffic_type_id: Traffic Type Id,
-        :param environment_id: Enviroment Id,
-        :key: Key whose attributes will be deleted.
-        '''
-        return Identity.delete_all_attributes(
-            self._client,
-            traffic_type_id,
-            environment_id,
-            key
-        )
+    @property
+    def identity(self):
+        return self._identity_client

identify/microclients/__init__.py

@@ -0,0 +1,4 @@
+from identify.microclients.traffic_type_microclient import TrafficTypeMicroClient
+from identify.microclients.environment_microclient import EnvironmentMicroClient
+from identify.microclients.attribute_microclient import AttributeMicroClient
+from identify.microclients.identity_microclient import IdentityMicroClient