Merge pull request #13 from bandprotocol/BST-549-refactor-app

[refactor] Refactored app

Author: warittornc

app/config.py

@@ -1,15 +1,20 @@
+from typing import Literal
+
 from pydantic import BaseSettings, HttpUrl
 
+MODES = Literal["production", "development"]
+LOG_LEVELS = Literal["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG", "NOTSET"]
+
 
 class Settings(BaseSettings):
-    MODE: str = "development"
-    LOG_LEVEL: str = "INFO"
+    MODE: MODES = "development"
+    LOG_LEVEL: LOG_LEVELS = "INFO"
 
     # VERIFICATION
     VERIFY_REQUEST_URL: HttpUrl
     ALLOWED_DATA_SOURCE_IDS: list[int]
     CACHE_SIZE: int = 1000
-    TTL_TIME: str = "10m"
+    TTL: str = "10m"
     MAX_DELAY_VERIFICATION: int = 0
 
     # ADAPTER

app/main.py

@@ -1,59 +1,54 @@
 import logging
-from functools import lru_cache
-from fastapi import Depends, FastAPI, Request
+from typing import Any
+
+from fastapi import Depends, Request, FastAPI, HTTPException
 from httpx import HTTPStatusError
 from pytimeparse.timeparse import timeparse
-from fastapi import HTTPException
 
 from adapter import init_adapter
-from app import config
+from app.config import Settings
 from app.report import init_db
-from app.report.middlewares import CollectVerifyData, CollectRequestData
-from app.report.models import Verify
+from app.report.middlewares import CollectRequestData
+from app.report.models import Verify, StatusReport, GatewayInfo
 from app.utils.cache import Cache
-from app.utils.types import VerifyErrorType
-from app.utils.helper import is_allow_data_source_id, get_band_signature_hash, verify_request, get_band_signature_hash
+from app.utils.helper import is_data_source_id_allowed, verify_request_from_bandchain, get_band_signature_hash
 from app.utils.log_config import init_loggers
+from app.utils.types import VerifyErrorType
 
 app = FastAPI()
 
+# Get setting
+settings = Settings()
 
-@lru_cache()
-def get_settings():
-    return config.Settings()
-
-
-settings = get_settings()
-
-# create logger
+# Setup logger
 init_loggers(log_level=settings.LOG_LEVEL)
 log = logging.getLogger("pds_gateway_log")
-
-
 log.info(f"GATEWAY_MODE: {settings.MODE}")
 
-
-app.state.cache_data = Cache(settings.CACHE_SIZE, timeparse(settings.TTL_TIME))
+# Setup app state
+app.state.cache_data = Cache(settings.CACHE_SIZE, timeparse(settings.TTL))
 app.state.db = init_db(settings.MONGO_DB_URL, settings.COLLECTION_DB_NAME, log)
 app.state.adapter = init_adapter(settings.ADAPTER_TYPE, settings.ADAPTER_NAME)
 
 
-@CollectVerifyData(db=app.state.db)
-async def verify(request: Request, settings: config.Settings = settings):
-    if settings.MODE == "production":
-        # pass verify if already cache
-        if app.state.cache_data.get_data(get_band_signature_hash(request.headers)):
-            return Verify(response_code=200, is_delay=False)
-
-        verified = await verify_request(request.headers, settings.VERIFY_REQUEST_URL, settings.MAX_DELAY_VERIFICATION)
-
-        if not is_allow_data_source_id(int(verified["data_source_id"]), settings.ALLOWED_DATA_SOURCE_IDS):
-            raise HTTPException(
-                status_code=401,
-                detail={
-                    "verify_error_type": VerifyErrorType.UNSUPPORTED_DS_ID.value,
-                    "error_msg": f'wrong data_source_id. expected {settings.ALLOWED_DATA_SOURCE_IDS}, got {verified["data_source_id"]}.',
-                },
+async def verify_request(req: Request) -> Verify:
+    """Verifies if the request originated from BandChain"""
+    # Skip verification if request has already been cached
+    if settings.MODE == "production" and app.state.cache_data.get_data(get_band_signature_hash(req.headers)):
+        # Verify the request is from BandChain
+        verified = await verify_request_from_bandchain(
+            req.headers, settings.VERIFY_REQUEST_URL, settings.MAX_DELAY_VERIFICATION
+        )
+
+        # Checks if the data source requesting is whitelisted
+        if not is_data_source_id_allowed(int(verified["data_source_id"]), settings.ALLOWED_DATA_SOURCE_IDS):
+            return Verify(
+                response_code=401,
+                is_delay=None,
+                error_type=VerifyErrorType.UNSUPPORTED_DS_ID.value,
+                error_msg="wrong data_source_id. expected {allowed}, got {actual}.".format(
+                    allowed=settings.ALLOWED_DATA_SOURCE_IDS, actual=verified["data_source_id"]
+                ),
             )
 
         return Verify(response_code=200, is_delay=verified["is_delay"])
@@ -63,30 +58,26 @@ async def verify(request: Request, settings: config.Settings = settings):
 
 @app.get("/")
 @CollectRequestData(db=app.state.db)
-async def request(
-    request: Request, settings: config.Settings = Depends(get_settings), verify: Verify = Depends(verify)
-):
+async def request_data(request: Request, verify: Verify = Depends(verify_request)) -> Any:
+    """Requests data from the premium data source"""
+    assert verify
+
     if settings.MODE == "production":
-        # get cache data
-        latest_data = app.state.cache_data.get_data(get_band_signature_hash(request.headers))
-        if latest_data:
-            latest_data["cached_data"] = True
+        # Get cached data and if it exists return it
+        if latest_data := app.state.cache_data.get_data(get_band_signature_hash(request.headers)):
             return latest_data
 
     try:
         output = await app.state.adapter.unified_call(dict(request.query_params))
         if settings.MODE == "production":
-            # cache data
+            # Cache data
             app.state.cache_data.set_data(get_band_signature_hash(request.headers), output)
-
         return output
-
     except HTTPStatusError as e:
         raise HTTPException(
             status_code=e.response.status_code,
             detail={"error_msg": f"{e}"},
         )
-
     except Exception as e:
         raise HTTPException(
             status_code=500,
@@ -95,21 +86,23 @@ async def request(
 
 
 @app.get("/status")
-async def get_report_status(settings: config.Settings = Depends(get_settings)):
-    res = {
-        "gateway_info": {
-            "allow_data_source_ids": settings.ALLOWED_DATA_SOURCE_IDS,
-            "max_delay_verification": settings.MAX_DELAY_VERIFICATION,
-        }
-    }
+async def get_status_report() -> StatusReport:
+    """Gets a status report: gateway info, latest request and latest failed request"""
+    gateway_info = GatewayInfo(
+        allow_data_source_ids=settings.ALLOWED_DATA_SOURCE_IDS,
+        max_delay_verification=settings.MAX_DELAY_VERIFICATION,
+    )
 
     if app.state.db:
         try:
-            res["latest_request"] = await app.state.db.get_latest_request_info()
-            res["latest_failed_request"] = await app.state.db.get_latest_verify_failed()
-
-            return res
+            latest_request = await app.state.db.get_latest_request_info()
+            latest_failed_request = await app.state.db.get_latest_failed_request_info()
         except Exception as e:
-            raise HTTPException(f"{e}", status_code=500)
+            raise HTTPException(status_code=500, detail=f"{e}")
+    else:
+        latest_request = None
+        latest_failed_request = None
 
-    return res
+    return StatusReport(
+        gateway_info=gateway_info, latest_request=latest_request, latest_failed_request=latest_failed_request
+    )

app/report/__init__.py

@@ -1,14 +1,2 @@
-from logging import Logger
 from .db import DB
-
-
-def init_db(url: str, collection_name: str, log: Logger) -> DB:
-    if url and collection_name:
-        db = DB(url, collection_name)
-        log.info(f"DB : init report data on mongo db")
-        return db
-    else:
-        log.info(
-            f"DB : No DB config -> if you want to save data on db please add [MONGO_DB_URL, COLLECTION_DB_NAME] in env"
-        )
-        return None
+from .db_helper import init_db

app/report/db.py

@@ -1,36 +1,66 @@
+from typing import Optional
+
 from motor import motor_asyncio
 
 from app.report.models import Report
 
 
 class DB:
-    def __init__(self, mongo_db_url: str, db_name: str):
+    """A MongoDB wrapper class for storing Reports.
+
+    Attributes:
+        report: AsyncIOMotorClient instance to connect with MongoDB and get the "report" collection.
+    """
+
+    def __init__(self, mongo_db_url: str, db_name: str) -> None:
+        """Initializes DB with the MongoDB URL and database name.
+
+        Args:
+            mongo_db_url: MongoDB URL.
+            db_name: Database name.
+        """
         self.report = motor_asyncio.AsyncIOMotorClient(mongo_db_url)[db_name].get_collection("report")
 
-    async def get_latest_request_info(self):
-        cursor = self.report.find({}, {"_id": 0, "user_ip": 0}).sort("created_at", -1).limit(1)
+    async def get_latest_request_info(self) -> Optional[Report]:
+        """Gets the latest request information from the database.
+
+        Returns:
+            A report containing the latest report
+        """
+        cursor = self.report.find().sort("created_at", -1).limit(1)
         latest_request_info = await cursor.to_list(length=1)
 
         if len(latest_request_info) == 0:
-            return {}
+            return None
+
+        return Report(**latest_request_info[0])
 
-        return latest_request_info[0]
+    async def get_latest_failed_request_info(self) -> Optional[Report]:
+        """Gets the detail of the latest failed request from the database
 
-    async def get_latest_verify_failed(self):
+        Returns:
+            A report containing the latest failed report
+        """
         cursor = (
             self.report.find(
                 {"$or": [{"verify.response_code": {"$ne": 200}}, {"provider_response.response_code": {"$ne": 200}}]},
-                {"_id": 0, "user_ip": 0},
+                {"_id": 0},
             )
             .sort("created_at", -1)
             .limit(1)
         )
+
         latest_request_info = await cursor.to_list(length=1)
 
         if len(latest_request_info) == 0:
-            return {}
+            return None
+
+        return Report(**latest_request_info[0])
 
-        return latest_request_info[0]
+    def save(self, report: Report) -> None:
+        """Saves the given report to the database.
 
-    def save_report(self, report: Report):
+        Args:
+            report: The Report object to be saved.
+        """
         self.report.insert_one(report.to_dict())

app/report/db_helper.py

@@ -0,0 +1,26 @@
+from logging import Logger
+from typing import Optional
+
+from app.report import DB
+
+
+def init_db(url: Optional[str], collection_name: Optional[str], log: Logger) -> Optional[DB]:
+    """Initializes the database if the URL and collection name are provided.
+
+    Args:
+        url: The URL of the MongoDB instance.
+        collection_name: The name of the collection to store reports in.
+        log: The logger instance.
+
+    Returns:
+        The DB instance if the url and collection_name are provided, or None if not.
+    """
+    if url and collection_name:
+        db = DB(url, collection_name)
+        log.info(f"DB: Report data is being stored on MongoDB collection {collection_name}.")
+        return db
+    else:
+        log.info(
+            f"DB: No DB config -> if you want to save data on db please add [MONGO_DB_URL, COLLECTION_DB_NAME] in env"
+        )
+        return None