refactoring - external access

app/controller/crawlerApp.py

@@ -60,7 +60,7 @@ def put(self, datacenter, instance, task):
 
     def crawlerFactory(self, instance, task, require):
         connector = ExternalMaestroData()\
-                        .get_request(path="connections/%s" % instance)\
+                        .list_request(path="connections/%s" % instance)\
                         .get_results()
 
         if connector == None:

app/repository/externalMaestro.py

@@ -2,32 +2,38 @@
 from app.libs.logger import logger
 from .maestroRequest import MaestroRequest
 
+
 class ExternalMaestro(object):
 
-    def __init__(self, base):
+    def __init__(self, base, tftm="json"):
         self._base = base
         self._headers = {}
         self._results = None
+        self._format = tftm
 
     def set_headers(self, headers):
         self._headers = headers
         return self
 
-    def get_uri(self):
-        self._base
+    def set_fomart(self, format):
+        self._format = format
+        return self
 
     def get_results(self, lens=None):
-        results = self._results.get_results()
+        results = self._results.get_json()
         if lens:
             results = results.get(lens)
 
         return results
 
-    def get_request(self, path, query={}):
+    def get_raw(self, lens=None):
+        return self._results.get_raw()
+
+    def list_request(self, path, query={}):
         self._results = self.request(path, {'query': query}, 'get')
         return self
 
-    def get_aggregation(self, path, entity, pipeline):
+    def list_aggregation(self, path, entity, pipeline):
         jpipeline = json.dumps(pipeline)
         self._results = self.request(path, {'entity': entity, 'pipeline': jpipeline}, 'post')
         return self
@@ -39,18 +45,22 @@ def put_request(self, path, body={}):
     def post_request(self, path, body={}):
         self._results = self.request(path, body, 'post')
         return self
-    
+
     def request(self, path, query, verb):
-        path = "%s/%s" % (self._base, path)
-        MaestroRqt = MaestroRequest().set_headers(self._headers)
+
+        MaestroRqt = MaestroRequest(verb, self._headers)
+        params = {
+            'path': "%s/%s" % (self._base, path),
+            self._format: query
+        }
 
         try:
-            MaestroRqt.exec_request(path, query, verb)
+            MaestroRqt.exec_request(**params)
             logger.debug("MaestroRequest External path - %s", path)
         except Exception as error:
             self.error_handling(task='ExternalMaestro', msg=str(error))
 
         return MaestroRqt
 
     def error_handling(self, task, msg):
-        logger.error("Discovery:  [%s] - %s", task, msg)
+        logger.error("MaestroExternal:  [%s] - %s", task, msg)

app/repository/externalMaestroData.py

@@ -17,4 +17,4 @@ def error_handling(self, task, msg):
         if self.ent_id :
             return notify_error(task=task, msg=msg, conn_id=self.ent_id)
 
-        logger.error("Discovery:  [%s] - %s", task, msg)
+        logger.error("MaestroData:  [%s] - %s", task, msg)

app/repository/maestroRequest.py

@@ -5,27 +5,20 @@
 
 class MaestroRequest(object):
 
-    def __init__(self):
+    def __init__(self, verb='get', headers={}):
         self.__context = None
-        self.__headers = {}
+        self.__headers = headers
         self.__path = None
+        self.__verb = verb
 
-    def exec_request(self, path, json, verb):
-        self.__context = getattr(requests, verb)(path, json=json, headers=self.__headers)
-        return self
-
-    def exec_request_data(self, path, data, verb):
-        self.__context = getattr(requests, verb)(path, data=data, headers=self.__headers)
-        return self
-
-    def set_headers(self, headers):
-        self.__headers = headers
+    def exec_request(self, path, json=None, data=None):
+        self.__context = getattr(requests, self.__verb)(path, json=json, data=data, headers=self.__headers)
         return self
 
     def get_status(self):
         return self.__context.status_code
 
-    def get_results(self):
+    def get_json(self):
         if self.__context.status_code is 200:
             return self.__context.json()
 

app/services/translate/mapper.py

@@ -15,7 +15,7 @@ def setResultPath(self, data):
 
     def getConnection(self, id):
         content = ExternalMaestroData(id)\
-                    .get_request(path="connections/%s" % id)\
+                    .list_request(path="connections/%s" % id)\
                     .get_results()
 
         return content

app/tasks/notification.py

@@ -13,7 +13,6 @@ def task_notification(msg, conn_id, task, status='success'):
     body = {'status': status, 'task': task, 'msg': msg}
 
     ExternalMaestro(base)\
-        .post_request(path="connection/%s" % conn_id, body=body)\
-        .get_results()
+        .post_request(path="connection/%s" % conn_id, body=body)
 
     return {'conn_id': conn_id, 'task': task}