move light node to webapi

Author: HarukaMa

webapi/chain_routes.py

@@ -1,4 +1,7 @@
+import copy
+import functools
 import math
+from collections import OrderedDict
 from decimal import Decimal
 from io import BytesIO
 from typing import Any, Optional
@@ -7,12 +10,13 @@
 from starlette.requests import Request
 
 from aleo_types import u64, DeployTransaction, ExecuteTransaction, FeeTransaction, RejectedDeploy, RejectedExecute, Fee, \
-    FinalizeOperation, UpdateKeyValue, RemoveKeyValue, Value, Plaintext, Address
+    FinalizeOperation, UpdateKeyValue, RemoveKeyValue, Value, Plaintext, Address, NodeType
 from aleo_types.cached import cached_get_mapping_id, cached_get_key_id
 from aleo_types.vm_block import AcceptedDeploy, AcceptedExecute
 from db import Database
+from node.light_node import LightNodeState
 from util import arc0137
-from webapi.utils import CJSONResponse, public_cache_seconds, function_definition
+from webapi.utils import CJSONResponse, public_cache_seconds, function_definition, get_relative_time
 from webui.classes import UIAddress
 
 
@@ -556,4 +560,78 @@ async def solution_route(request: Request):
     height = await db.get_solution_block_height(solution_id)
     if height is None:
         return CJSONResponse({"error": "Solution not found"}, status_code=404)
-    return CJSONResponse(height)
+    return CJSONResponse(height)
+
+
+async def nodes_route(request: Request):
+    lns: LightNodeState = request.app.state.lns
+    db: Database = request.app.state.db
+    lns.cleanup()
+    nodes = lns.states
+    data: dict[str, dict[str, Any]] = {}
+    for k, v in nodes.items():
+        if k.startswith("127.0.0.1"):
+            continue
+        data[k] = copy.deepcopy(v)
+        data[k]["last_ping"] = get_relative_time(v["last_ping"])
+    validators = 0
+    clients = 0
+    provers = 0
+    unknowns = 0
+    connected = 0
+    def sort_cmp(a: tuple[str, dict[str, Any]], b: tuple[str, dict[str, Any]]) -> int:
+        # sort by: height, address, node type, ip address
+        a_height = a[1].get("height", None)
+        b_height = b[1].get("height", None)
+        if a_height is not None and b_height is not None:
+            return int(b_height) - int(a_height)
+        if a_height is None and b_height is not None:
+            return 1
+        if a_height is not None and b_height is None:
+            return -1
+        a_address = a[1].get("address", None)
+        b_address = b[1].get("address", None)
+        if a_address is not None and b_address is not None:
+            if a_address == b_address:
+                return 0
+            return 1 if a_address > b_address else -1
+        if a_address is None and b_address is not None:
+            return 1
+        if a_address is not None and b_address is None:
+            return -1
+        a_type = a[1].get("node_type", None)
+        b_type = b[1].get("node_type", None)
+        if a_type is None and b_type is not None:
+            return 1
+        if a_type is not None and b_type is None:
+            return -1
+        if a_type == b_type:
+            if a[0] == b[0]:
+                return 0
+            return 1 if a[0] > b[0] else -1
+        return a_type.value - b_type.value
+
+    res: OrderedDict[str, dict[str, Any]] = OrderedDict(sorted(data.items(), key=functools.cmp_to_key(sort_cmp)))
+    for node in res.values():
+        node_type = node.get("node_type", None)
+        if node_type is None:
+            unknowns += 1
+        elif node_type == NodeType.Validator:
+            validators += 1
+        elif node_type == NodeType.Client:
+            clients += 1
+        elif node_type == NodeType.Prover:
+            provers += 1
+        if node.get("direction", "") != "disconnected":
+            connected += 1
+    result: dict[str, Any] = {
+        "nodes": [[k, v] for k, v in res.items()],
+        "validators": validators,
+        "clients": clients,
+        "provers": provers,
+        "unknowns": unknowns,
+        "connected": connected,
+    }
+    result["resolved_addresses"] = await UIAddress.resolve_recursive_detached(result, db, {})
+
+    return CJSONResponse(result)

webapi/utils.py

@@ -98,6 +98,26 @@ class CJSONResponse(Response):
     def render(self, content: Any):
         return json.dumps(content, cls=CustomEncoder).encode("utf-8")
 
+
+def get_relative_time(timestamp: int):
+    now = time.time()
+    delta = int(now - timestamp)
+    if delta == 0:
+        return "just now"
+    elif delta == 1:
+        return "1 second ago"
+    elif delta < 60:
+        return f"{int(delta)} seconds ago"
+    delta = delta // 60
+    if delta == 1:
+        return "1 minute ago"
+    elif delta < 60:
+        return f"{int(delta)} minutes ago"
+    delta = delta // 60
+    if delta == 1:
+        return "1 hour ago"
+    return f"{int(delta)} hours ago"
+
 async def get_remote_height(session: aiohttp.ClientSession, rpc_root: str) -> str:
     try:
         async with session.get(f"{rpc_root}/{os.environ.get('NETWORK')}/block/height/latest") as resp:

webapi/webapi.py

@@ -16,11 +16,12 @@
 from middleware.asgi_logger import AccessLoggerMiddleware
 from middleware.auth import AuthMiddleware
 from middleware.server_timing import ServerTimingMiddleware
+from node.light_node import LightNodeState
 from util.set_proc_title import set_proc_title
 from .address_routes import address_route, ans_route
 from .chain_routes import blocks_route, get_summary, recent_blocks_route, index_update_route, block_route, search_route, \
     transaction_route, \
-    validators_route, transition_route, solution_route
+    validators_route, transition_route, solution_route, nodes_route
 from .error_routes import bad_request, not_found, internal_error
 from .program_routes import programs_route, program_route
 from .utils import public_cache_seconds, out_of_sync_check, CJSONResponse
@@ -69,6 +70,7 @@ async def summary_route(request: Request):
     Route("/transition/{id}", transition_route),
     Route("/solution/{id}", solution_route),
     Route("/search", search_route),
+    Route("/nodes", nodes_route),
 
     Route("/programs", programs_route),
     Route("/program/{id}", program_route),
@@ -94,7 +96,8 @@ async def noop(_: Any): pass
     # noinspection PyUnresolvedReferences
     app.state.db = db
     # noinspection PyUnresolvedReferences
-    # app.state.lns.connect(os.environ.get("P2P_NODE_HOST", "127.0.0.1"), int(os.environ.get("P2P_NODE_PORT", "4130")), None)
+    app.state.lns.connect(os.environ.get("P2P_NODE_HOST", "127.0.0.1"), int(os.environ.get("P2P_NODE_PORT", "4133")), None)
+    app.state.lns.start_listener()
     app.state.session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=1))
     set_proc_title("aleo-explorer: webapi")
 
@@ -122,7 +125,7 @@ async def run():
     logging.getLogger("uvicorn.access").handlers = []
     server = UvicornServer(config=config)
     # noinspection PyUnresolvedReferences
-    # app.state.lns = LightNodeState()
+    app.state.lns = LightNodeState()
 
     server.start()
     while True:

webui/chain_routes.py

@@ -1,9 +1,8 @@
-import copy
-import functools
-from collections import OrderedDict
+import os
 from io import BytesIO
 from typing import Any, cast, Optional, ParamSpec, TypeVar, Callable, Awaitable
 
+import aiohttp
 import aleo_explorer_rust
 from starlette.exceptions import HTTPException
 from starlette.requests import Request
@@ -20,13 +19,12 @@
     NodeType, FeeComponent, Fee, Option, Address
 from aleo_types.cached import cached_get_key_id, cached_get_mapping_id
 from db import Database
-from node.light_node import LightNodeState
 from util import arc0021
 from util.global_cache import get_program
 from util.typing_exc import Unreachable
 from .classes import UIAddress
 from .template import htmx_template
-from .utils import function_signature, out_of_sync_check, function_definition, get_relative_time
+from .utils import function_signature, out_of_sync_check, function_definition
 
 try:
     from line_profiler import profile
@@ -966,73 +964,22 @@ async def solution_route(request: Request):
 
 @htmx_template("nodes.jinja2")
 async def nodes_route(request: Request):
-    lns: LightNodeState = request.app.state.lns
-    lns.cleanup()
-    nodes = lns.states
-    data: dict[str, dict[str, Any]] = {}
-    for k, v in nodes.items():
-        if k.startswith("127.0.0.1"):
-            continue
-        data[k] = copy.deepcopy(v)
-        data[k]["last_ping"] = get_relative_time(v["last_ping"])
-    validators = 0
-    clients = 0
-    provers = 0
-    unknowns = 0
-    connected = 0
-    def sort_cmp(a: tuple[str, dict[str, Any]], b: tuple[str, dict[str, Any]]) -> int:
-        # sort by: height, address, node type, ip address
-        a_height = a[1].get("height", None)
-        b_height = b[1].get("height", None)
-        if a_height is not None and b_height is not None:
-            return int(b_height) - int(a_height)
-        if a_height is None and b_height is not None:
-            return 1
-        if a_height is not None and b_height is None:
-            return -1
-        a_address = a[1].get("address", None)
-        b_address = b[1].get("address", None)
-        if a_address is not None and b_address is not None:
-            if a_address == b_address:
-                return 0
-            return 1 if a_address > b_address else -1
-        if a_address is None and b_address is not None:
-            return 1
-        if a_address is not None and b_address is None:
-            return -1
-        a_type = a[1].get("node_type", None)
-        b_type = b[1].get("node_type", None)
-        if a_type is None and b_type is not None:
-            return 1
-        if a_type is not None and b_type is None:
-            return -1
-        if a_type == b_type:
-            if a[0] == b[0]:
-                return 0
-            return 1 if a[0] > b[0] else -1
-        return a_type.value - b_type.value
-
-    res: OrderedDict[str, dict[str, Any]] = OrderedDict(sorted(data.items(), key=functools.cmp_to_key(sort_cmp)))
-    for node in res.values():
-        node_type = node.get("node_type", None)
-        if node_type is None:
-            unknowns += 1
-        elif node_type == NodeType.Validator:
-            validators += 1
-        elif node_type == NodeType.Client:
-            clients += 1
-        elif node_type == NodeType.Prover:
-            provers += 1
-        if node.get("direction", "") != "disconnected":
-            connected += 1
-    ctx = {
-        "nodes": res,
-        "validators": validators,
-        "clients": clients,
-        "provers": provers,
-        "unknowns": unknowns,
-        "connected": connected,
-    }
+    host = os.environ.get("HOST", "127.0.0.1")
+    port = int(os.environ.get("WEBAPI_PORT", 8002));
+    session = aiohttp.ClientSession(headers={
+        "Authorization": "Token " + os.environ.get("WEBAPI_TOKEN", "token"),
+    })
+    try:
+        async with session.get(f"http://{host}:{port}/nodes") as response:
+            ctx = await response.json()
+            ctx["nodes"] = dict(ctx["nodes"])
+        for node in ctx["nodes"].values():
+            if (node_type := node.get("node_type", None)) is not None:
+                node["node_type"] = NodeType(node_type)
+    except:
+        from traceback import print_exc
+        print_exc()
+        ctx = {}
     return ctx, {'Cache-Control': 'no-cache'}
 
 

webui/webui.py

@@ -1,9 +1,7 @@
 import asyncio
 import logging
 import multiprocessing
-import os
 
-import aiohttp
 import uvicorn
 from starlette.applications import Starlette
 from starlette.middleware import Middleware
@@ -178,9 +176,6 @@ async def noop(_: Any): pass
     await db.connect()
     # noinspection PyUnresolvedReferences
     app.state.db = db
-    # noinspection PyUnresolvedReferences
-    app.state.lns.connect(os.environ.get("P2P_NODE_HOST", "127.0.0.1"), int(os.environ.get("P2P_NODE_PORT", "4133")), None)
-    app.state.lns.start_listener()
     app.state.session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=1))
     set_proc_title("aleo-explorer: webui")
 
@@ -209,8 +204,6 @@ async def run():
     )
     logging.getLogger("uvicorn.access").handlers = []
     server = UvicornServer(config=config)
-    # noinspection PyUnresolvedReferences
-    app.state.lns = LightNodeState()
 
     server.start()
     while True: