backedn dev

Reviewed-on: #3

.env

@@ -0,0 +1,8 @@
+# Environment variables for NetApp ONTAP clusters
+CLUSTER1_HOSTNAME=172.16.57.2
+CLUSTER1_USERNAME=admin
+CLUSTER1_PASSWORD=Netapp12
+
+CLUSTER2_HOSTNAME=172.16.56.2
+CLUSTER2_USERNAME=admin
+CLUSTER2_PASSWORD=Netapp12

.gitignore

@@ -129,7 +129,7 @@ celerybeat.pid
 *.sage.py
 
 # Environments
-.env
+#.env
 .venv
 env/
 venv/

pyproject.toml

@@ -12,5 +12,6 @@ requires-python = ">=3.13"
 dependencies = [
     "fastapi[standard]>=0.116.2",
     "httpx>=0.28.1",
+    "python-dotenv>=1.1.1",
     "redis>=6.4.0",
 ]

requirements.txt

@@ -1,6 +1,7 @@
 fastapi[standard]>=0.116.2
 httpx>=0.28.1
 redis>=6.4.0
+python-dotenv>=1.1.1
 pydantic
 redis[hiredis]
-dotenv
+dotenv

src/aggregate/__init__.py

@@ -0,0 +1,4 @@
+from src.example.router import router as example_router
+from .aggregate_router import router as aggregate_router
+
+__all__ = ["example_router", "aggregate_router"]

src/aggregate/aggregate_router.py

@@ -0,0 +1,16 @@
+# contains the router for the aggregates endpoint
+from fastapi import APIRouter, Query, Request
+from typing import List
+from .aggregate_schema import AggregateSchema, MetricEnum
+from .aggregate_service import get_aggregates
+
+
+router = APIRouter(tags=["aggregates"])
+
+
+@router.get("/aggregates", response_model=List[AggregateSchema])
+async def aggregates_endpoint(
+    request: Request,
+    metric: MetricEnum = Query(MetricEnum.relative, description="Metric type"),
+):
+    return await get_aggregates(request, metric)

src/aggregate/aggregate_schema.py

@@ -0,0 +1,15 @@
+# contains the schema definitions for aggregates
+from pydantic import BaseModel
+from enum import Enum
+
+
+class AggregateSchema(BaseModel):
+    aggregate: str
+    node: str
+    available: int
+    available_str: str
+
+
+class MetricEnum(str, Enum):
+    relative = "relative"
+    absolute = "absolute"

src/aggregate/aggregate_service.py

@@ -0,0 +1,38 @@
+# contains the business logic for aggregates
+
+from typing import List
+
+from fastapi import Request
+from .aggregate_schema import AggregateSchema, MetricEnum
+from logging import getLogger
+from ..utils import round_bytes, get_data_from_ontap
+
+logger = getLogger("uvicorn")
+logger.setLevel("DEBUG")
+
+
+async def get_aggregates(request: Request, metric: str = "relative") -> List[AggregateSchema]:
+    # Dummy data for demonstration
+    # You can use the metric parameter to filter or modify results as needed
+    # For now, just return the same data and show metric usage
+    logger.debug(f"Metric used: {metric}")
+    client = request.app.requests_client
+    __aggregates = await get_data_from_ontap(client, logger, "172.16.57.2", "admin", "Netapp12", "storage/aggregates", "fields=name,uuid,space,node,home_node")
+    logger.debug(__aggregates)
+    __aggregates = __aggregates.get("records")
+    if metric == MetricEnum.relative:
+        __aggregates = sorted(__aggregates, key=lambda r: r["space"]["block_storage"].get("used_percent"), reverse=True)
+    elif metric == MetricEnum.absolute:
+        __aggregates = sorted(__aggregates, key=lambda r: r["space"]["block_storage"].get("available"), reverse=False)
+
+    aggregates: list = [
+        AggregateSchema(
+            aggregate=a["name"],
+            node=a["node"]["name"],
+            available=a["space"]["block_storage"]["available"],
+            available_str=round_bytes(a["space"]["block_storage"]["available"]),
+        )
+        for a in __aggregates
+    ]
+
+    return aggregates

src/example/__init__.py

@@ -1,3 +0,0 @@
-from .router import router as example_router
-
-__all__ = ["example_router"]

src/example/constants.py

@@ -1,2 +1,2 @@
 # contains a constant definition
-FOO: int = 42
+FOO: int = 42

src/example/router.py

@@ -1,9 +1,10 @@
-# contains the router for the example endpoint
+# contains the router for the aggregate endpoint
 from fastapi import APIRouter
 from .schema import ExampleSchema
 
-router = APIRouter(tags=["example"])
+router = APIRouter(tags=["aggregate"])
+
 
 @router.get("/example")
 async def example_endpoint() -> ExampleSchema:
-    return ExampleSchema(example_field="foo", another_field=42)
+    return ExampleSchema(example_field="foo", another_field=42)

src/example/schema.py

@@ -1,6 +1,7 @@
-# contains the schema definitions for the example service
+# contains the schema definitions for the aggregate service
 from pydantic import BaseModel
 
+
 class ExampleSchema(BaseModel):
     example_field: str
     another_field: int

src/example/service.py

@@ -1,3 +1,3 @@
-# contains the business logic for the example service
+# contains the business logic for the aggregate service
 async def example_service() -> str:
-    return "This is an example service"
+    return "This is an aggregate service"

src/service.py

@@ -0,0 +1,16 @@
+from dotenv import dotenv_values
+import logging
+
+from src.schema import ConfigSchema
+
+logger = logging.getLogger("uvicorn")
+
+
+def load_config() -> ConfigSchema:
+    logger.info("Loading config from .env file")
+    config = dotenv_values(".env")
+    return ConfigSchema(
+        hostname=config["CLUSTER1_HOSTNAME"],
+        username=config["CLUSTER1_USERNAME"],
+        password=config["CLUSTER1_PASSWORD"],
+    )

src/utils.py

@@ -1,4 +1,28 @@
 import logging
+import httpx
+
+def round_bytes(size_in_bytes: int) -> str:
+    # Helper function to convert bytes to a human-readable format
+    for unit in ["B", "KiB", "MiB", "GiB", "TiB", "PiB"]:
+        if size_in_bytes < 1024:
+            return f"{size_in_bytes:.2f}{unit}"
+        size_in_bytes /= 1024
+    return f"{size_in_bytes:.2f}EB"
+
+
+async def get_data_from_ontap(client, logger, hostname: str, username: str, password: str, endpoint: str, query_string: str = ""):
+    url = f"https://{hostname}/api/{endpoint}"
+    if query_string:
+        url += f"?{query_string}"
+    async with client as _client:
+        try:
+            logger.debug(f"Fetching data from ONTAP: {url}")
+            response = await _client.get(url, auth=(username, password))
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP error occurred: {e}")
+            return None
 
 def setup_logging() -> None:
     """Configure logging for the application"""
@@ -6,4 +30,4 @@ def setup_logging() -> None:
         level=logging.DEBUG,
         format="[%(asctime)s] [%(levelname)5s] %(message)s"
     )
-    print(f"Logger is initialized.")
+    print(f"Logger is initialized.")