Refactor event manager and api manager

Author: Inbal Tako

requirements.txt

@@ -1,4 +1,3 @@
 requests~=2.23.0
 pycrypto~=2.6.1
-aiohttp~=3.6.2
 crypto~=1.4.1

securenative/__init__.py

@@ -1,5 +0,0 @@
-from securenative.config import sdk_version
-import securenative.event_types
-from securenative.sdk import SecureNative, SecureNativeOptions
-from securenative.event_options import Event, User
-from securenative.singleton import init, flush, track, verify_webhook, verify

securenative/api_manager.py

@@ -0,0 +1,29 @@
+from securenative.enums.api_route import ApiRoute
+from securenative.enums.failover_strategy import FailOverStrategy
+from securenative.enums.risk_level import RiskLevel
+from securenative.logger import Logger
+from securenative.models.sdk_event import SDKEvent
+from securenative.models.verify_result import VerifyResult
+
+
+class ApiManager(object):
+
+    def __init__(self, event_manager, securenative_options):
+        self.event_manager = event_manager
+        self.options = securenative_options
+
+    def track(self, event_options):
+        Logger.debug("Track event call")
+        event = SDKEvent(event_options, self.options)
+        self.event_manager.send_async(event, ApiRoute.TRACK, True)
+
+    def verify(self, event_options):
+        Logger.debug("Verify event call")
+        event = SDKEvent(event_options, self.options)
+        try:
+            self.event_manager.send_sync(VerifyResult, event, ApiRoute.VERIFY)
+        except Exception as e:
+            Logger.debug("Failed to call verify; {}".format(e))
+            if self.options.fail_over_startegy is FailOverStrategy.FAIL_OPEN:
+                return VerifyResult(RiskLevel.LOW, 0, None)
+            return VerifyResult(RiskLevel.HIGH, 1, None)

securenative/event_manager.py

@@ -1,35 +1,50 @@
+import copy
 import json
 import threading
-import copy
+import time
 
-from securenative.http.http_client import HttpClient
-from securenative.sdk_options import SecureNativeOptions
+from securenative.config.securenative_options import SecureNativeOptions
+from securenative.exceptions.securenative_http_exception import SecureNativeHttpException
+from securenative.http.securenative_http_client import SecureNativeHttpClient
+from securenative.logger import Logger
 
 
 class QueueItem:
-    def __init__(self, url, body):
+    def __init__(self, url, body, retry):
         self.url = url
         self.body = body
+        self.retry = retry
 
 
 class EventManager:
-    def __init__(self, api_key, options=SecureNativeOptions(), http_client=HttpClient()):
-        if api_key is None:
+    def __init__(self, options=SecureNativeOptions(), http_client=None):
+        if options.api_url is None:
             raise ValueError('API key cannot be None, please get your API key from SecureNative console.')
 
-        self.http_client = http_client
-        self.api_key = api_key
+        if not http_client:
+            self.http_client = SecureNativeHttpClient(options)
+        else:
+            self.http_client = http_client
+
         self.options = options
         self.queue = list()
+        self.send_enabled = False
+        self.attempt = 0
+        self.coefficients = [1, 1, 2, 3, 5, 8, 13]
 
-        if self.options.auto_send and self.options.is_sdk_enabled:
+        if self.options.auto_send and not self.options.disable:
             interval_seconds = max(options.interval // 1000, 1)
             threading.Timer(interval_seconds, self.flush).start()
 
     def send_async(self, event, resource_path):
+        if self.options.disable:
+            Logger.warn("SDK is disabled. no operation will be performed")
+            return
+
         item = QueueItem(
-            self._build_url(resource_path),
-            json.dumps(event.as_dict())
+            resource_path,
+            json.dumps(event.as_dict()),
+            False
         )
 
         self.queue.insert(0, item)
@@ -41,17 +56,70 @@ def flush(self):
         self.queue = list()
 
         for item in queue_copy:
-            self.http_client.post(item.url, self.api_key, item.body)
+            self.http_client.post(item.url, item.body)
+
+    def send_sync(self, event, resource_path, retry):
+        if self.options.disable:
+            Logger.warn("SDK is disabled. no operation will be performed")
+            return
 
-    def send_sync(self, event, resources_path):
-        return self.http_client.post(
-            self._build_url(resources_path),
-            self.api_key,
+        Logger.debug("Attempting to send event {}".format(event.as_dict()))
+        res = self.http_client.post(
+            resource_path,
             json.dumps(event.as_dict())
         )
+        if res.status != 200:
+            Logger.info("SecureNative failed to call endpoint {} with event {}. adding back to queue")
 
-    def _build_url(self, resource_path):
-        return self.options.api_url + "/" + resource_path
+            item = QueueItem(
+                resource_path,
+                json.dumps(event.as_dict()),
+                retry
+            )
+            self.queue.insert(0, item)
+            if self._is_queue_full():
+                self.queue = self.queue[:len(self.queue - 1)]
 
     def _is_queue_full(self):
         return len(self.queue) > self.options.max_events
+
+    def _send_events(self):
+        if len(self.queue) > 0 and self.send_enabled:
+            for item in self.queue:
+                try:
+                    res = self.http_client.post(item.url, item.body)
+                    if res.status is 401:
+                        item.retry = False
+                    elif res.status != 200:
+                        raise SecureNativeHttpException(res.status)
+
+                    Logger.debug("Event successfully sent; {}".format(item.body))
+                    self.queue.remove(item)
+                except Exception as e:
+                    Logger.error("Failed to send event; {}".format(e))
+                    if item.retry:
+                        if len(self.coefficients) == self.attempt + 1:
+                            self.attempt = 0
+
+                        back_off = self.coefficients[self.attempt] * self.options.interval
+                        Logger.debug("Automatic back-off of {}".format(back_off))
+                        self.send_enabled = False
+                        time.sleep(back_off)
+                        self.send_enabled = True
+                    else:
+                        self.queue.remove(item)
+
+    def start_event_persist(self):
+        Logger.debug("Starting automatic event persistence")
+        if self.options.auto_send or self.send_enabled:
+            self.send_enabled = True
+            #  TODO add scheduler
+        else:
+            Logger.debug("Automatic event persistence is disabled, you should persist events manually")
+
+    def stop_event_persist(self):
+        if self.send_enabled:
+            Logger.debug("Attempting to stop automatic event persistence")
+            #  TODO shut down scheduler
+
+            Logger.debug("Stopped event persistence")

securenative/logger.py

@@ -1,8 +1,24 @@
 import logging
 
-enable_sn_logging = False
 
+class Logger(object):  # TODO!
 
-def sn_logging(msg):
-    if enable_sn_logging:
+    @staticmethod
+    def init_logger(level):
+        pass
+
+    @staticmethod
+    def info(msg):
         logging.info(msg)
+
+    @staticmethod
+    def debug(msg):
+        pass
+
+    @staticmethod
+    def warn(msg):
+        pass
+
+    @staticmethod
+    def error(msg):
+        pass

securenative/models/verify_result.py

@@ -1,4 +1,4 @@
-class VerifyRequest(object):
+class VerifyResult(object):
 
     def __init__(self, risk_level=None, score=None, triggers=None):
         self.risk_level = risk_level

securenative/sdk.py

@@ -0,0 +1,71 @@
+from securenative.api_manager import ApiManager
+from securenative.config.configuration_builder import ConfigurationBuilder
+from securenative.config.configuration_manager import ConfigurationManager
+from securenative.context.context_builder import ContextBuilder
+from securenative.event_manager import EventManager
+from securenative.exceptions.securenative_config_exception import SecureNativeConfigException
+from securenative.exceptions.securenative_sdk_exception import SecureNativeSDKException
+from securenative.logger import Logger
+from securenative.utils.utils import Utils
+
+
+class SecureNative:
+
+    def __init__(self, options):
+        if Utils.is_null_or_empty(options.api_key):
+            raise SecureNativeSDKException("You must pass your SecureNative api key")
+
+        self._options = options
+        self._event_manager = EventManager(self._options)
+
+        if self._options.api_url:
+            self._event_manager.start_event_persist()
+
+        self._api_manager = ApiManager(self._event_manager, self._options)
+        self._securenative = None
+        Logger.init_logger(self._options.log_level)
+
+    def init(self, options):
+        if self._securenative is None:
+            self._securenative = SecureNative(options)
+            return self._securenative
+        else:
+            Logger.debug('This SDK was already initialized.')
+            raise SecureNativeSDKException(u'This SDK was already initialized.')
+
+    def init(self, api_key):
+        if Utils.is_null_or_empty(api_key):
+            raise SecureNativeConfigException("You must pass your SecureNative api key")
+
+        if self._securenative is None:
+            builder = ConfigurationBuilder().default_config_builder()
+            options = builder.with_api_key(api_key)
+            self._securenative = SecureNative(options)
+            return self._securenative
+        else:
+            Logger.debug('This SDK was already initialized.')
+            raise SecureNativeSDKException(u'This SDK was already initialized.')
+
+    def init(self):
+        options = ConfigurationManager.load_config()
+        return self.init(options)
+
+    def get_instance(self):
+        return self._securenative
+
+    def get_options(self):
+        return self._options
+
+    @staticmethod
+    def config_builder():
+        return ConfigurationBuilder.default_config_builder()
+
+    @staticmethod
+    def context_builder():
+        return ContextBuilder.default_context_builder()
+
+    def track(self, event_options):
+        self._api_manager.track(event_options)
+
+    def verify(self, event_options):
+        self._api_manager.verify(event_options)