code restructured | code for platform authorizer and platform processes is separated

Author: prashantramangupta

build.sh

@@ -0,0 +1,11 @@
+NETWORKS = {
+    999: {
+        'db': {'DB_HOST': '',
+               'DB_USER': '',
+               'DB_PASSWORD': '',
+               'DB_NAME': '',
+               'DB_PORT': 3306
+               }
+    }
+}
+METRICS_NETWORK_ID  = 999

constant.py

@@ -0,0 +1,15 @@
+from repository import Repository
+
+
+class Token:
+    def __init__(self, net_id):
+        self.net_id = net_id
+        self.repo = Repository(net_id)
+
+    def validate_token(self, daemon_id, token):
+        print("validate_token::daemon_id: ", daemon_id);
+        qry = "SELECT * FROM daemon_token WHERE daemon_id = %s and token = %s "
+        res = self.repo.execute(qry, [daemon_id, token])
+        if len(res) > 0:
+            return {'validated': True}
+        return {'validated': False}

lambda_handler.py

@@ -0,0 +1,2 @@
+rm daemon_authorizer.zip
+zip -r daemon_authorizer.zip * -x \*venv\*

platform-usage-authorizer/authorizer.py

@@ -0,0 +1,61 @@
+import json
+import os
+
+from authorizer import Token
+from constant import METRICS_NETWORK_ID
+
+
+def request_handler(event, context):
+    if 'path' not in event:
+        return get_response("400", {"status": "failed", "error": "Bad Request"})
+    try:
+        path = event['path'].lower()
+        data = None
+        if "/event" == path:
+            payload_dict = event['headers']
+            print("Processing [" + str(path) + "] with body [" + str(payload_dict) + "]")
+            net_id = METRICS_NETWORK_ID
+            token_instance = Token(net_id)
+            data = token_instance.validate_token(daemon_id=payload_dict['x-daemonid'],
+                                                 token=payload_dict['x-token'])
+            print(data)
+        response = get_lambda_authorizer_response_format(event=event, allow=data.get('validated', False))
+        return response
+    except Exception as e:
+        print(repr(e))
+        return get_lambda_authorizer_response_format(event=event, allow=False)
+
+
+# Generate response JSON that API gateway expects from the lambda function
+def get_response(status_code, message):
+    return {
+        'statusCode': status_code,
+        'body': json.dumps(message),
+        'headers': {
+            'Content-Type': 'application/json',
+            "X-Requested-With": '*',
+            "Access-Control-Allow-Headers": 'Access-Control-Allow-Origin, Content-Type,X-Amz-Date,Authorization,X-Api-Key,x-requested-with',
+            "Access-Control-Allow-Origin": '*',
+            "Access-Control-Allow-Methods": 'GET,OPTIONS,POST'
+        }
+    }
+
+
+def get_lambda_authorizer_response_format(event, allow):
+    response = {
+        "principalId": os.environ['principalId'],
+        "policyDocument": {
+            "Version": '2012-10-17',
+            "Statement": [
+                {
+                    "Action": 'execute-api:Invoke',
+                    "Resource": event['methodArn']
+                }
+            ]
+        }
+    }
+    if allow:
+        response["policyDocument"]["Statement"][0]["Effect"] = 'Allow'
+    else:
+        response["policyDocument"]["Statement"][0]["Effect"] = 'Deny'
+    return response

platform-usage-authorizer/build.sh

@@ -0,0 +1,2 @@
+rm platform_usage_process.zip
+zip -r platform_usage_process.zip * -x \*venv\*

platform-usage-authorizer/lambda_handler.py

@@ -0,0 +1,70 @@
+import json
+
+from register import Token
+from constant import METRICS_NETWORK_ID
+from metrics import Metrics
+
+
+def request_handler(event, context):
+    if 'path' not in event:
+        return get_response("400", {"status": "failed",
+                                    "error": "Bad Request"})
+    try:
+        path = event['path'].lower()
+        data = None
+        payload_dict = payload_check(payload=event['body'], path=path)
+        net_id = METRICS_NETWORK_ID
+        if "/register" == path:
+            token_instance = Token(net_id)
+            data = token_instance.process_token(daemon_id=payload_dict['daemonId'])
+        elif "/event" == path:
+            obj_metrics = Metrics(net_id=net_id)
+            if payload_dict['type'] == 'request':
+                obj_metrics.handle_request_type(payload_dict)
+            elif payload_dict['type'] == 'response':
+                obj_metrics.handle_response_type(payload_dict)
+            data = {}
+
+        if data is None:
+            response = get_response("400", {"status": "failed",
+                                            "error": "Bad Request",
+                                            "api": event['path'],
+                                            "payload": payload_dict})
+        else:
+            if data.get('error', '') == '':
+                response = get_response("200", {"status": "success", "data": data})
+            else:
+                error = data['error']
+                data.pop('error')
+                response = get_response("200", {"status": "failed", "data": data, "error": error})
+
+        return response
+    except Exception as e:
+        response = get_response(500, {"status": "failed",
+                                      "error": repr(e),
+                                      "api": event['path'],
+                                      "payload": payload_dict})
+        return response
+
+
+def payload_check(payload, path):
+    payload_dict = None
+    if payload is not None and len(payload) > 0:
+        payload_dict = json.loads(payload)
+    print("Processing [" + str(path) + "] with body [" + str(payload) + "]")
+    return payload_dict
+
+
+# Generate response JSON that API gateway expects from the lambda function
+def get_response(status_code, message):
+    return {
+        'statusCode': status_code,
+        'body': json.dumps(message),
+        'headers': {
+            'Content-Type': 'application/json',
+            "X-Requested-With": '*',
+            "Access-Control-Allow-Headers": 'Access-Control-Allow-Origin, Content-Type,X-Amz-Date,Authorization,X-Api-Key,x-requested-with',
+            "Access-Control-Allow-Origin": '*',
+            "Access-Control-Allow-Methods": 'GET,OPTIONS,POST'
+        }
+    }

requirement.txt renamed to platform-usage-authorizer/requirement.txt

@@ -0,0 +1,41 @@
+from datetime import datetime as dt
+
+from repository import Repository
+
+
+class Metrics:
+    def __init__(self, net_id):
+        self.net_id = net_id
+        self.repo = Repository(net_id)
+
+    def handle_request_type(self, params):
+        try:
+            insrt_dm_rq_sts = "INSERT INTO daemon_request_stats (ethereum_json_rpc_endpoint, group_id, input_data_size, " \
+                              "organization_id, registry_address_key, request_id, request_received_time, service_id, " \
+                              "service_method, row_created, row_updated) " \
+                              "VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"
+            dm_req_params = (params['ethereum_json_rpc_endpoint'], params['group_id'], params['input_data_size'],
+                       params['organization_id'], params['registry_address_key'], params['request_id'],
+                       params['request_received_time'][:19], params['service_id'], params['service_method'],
+                       dt.utcnow(),
+                       dt.utcnow())
+            self.repo.execute(insrt_dm_rq_sts, dm_req_params)
+        except Exception as e:
+            print(repr(e))
+            raise e
+
+    def handle_response_type(self, params):
+        try:
+            insrt_dm_rs_sts = "INSERT INTO daemon_response_stats (error_message, ethereum_json_rpc_endpoint, group_id, " \
+                              "organization_id, registry_address_key, request_id, request_received_time, response_code, " \
+                              "response_sent_time, response_time, service_id, service_method, row_created, row_updated) " \
+                              "VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"
+            dm_rs_params = (params['error_message'], params['ethereum_json_rpc_endpoint'], params['group_id'],
+                            params['organization_id'], params['registry_address_key'], params['request_id'],
+                            params['request_received_time'][:19], params['response_code'], params['response_sent_time'][:19],
+                            params['response_time'], params['service_id'], params['service_method'], dt.utcnow(),
+                            dt.utcnow())
+            self.repo.execute(insrt_dm_rs_sts, dm_rs_params)
+        except Exception as e:
+            print(repr(e))
+            raise e