185 lines
6.5 KiB
Python
185 lines
6.5 KiB
Python
# -*- coding:utf-8 -*-
|
|
from traceback import format_exc
|
|
from ahserver.serverenv import ServerEnv
|
|
from appPublic.registerfunction import RegisterFunction
|
|
from appPublic.log import exception
|
|
import json
|
|
|
|
|
|
async def status_handler(request, params_kw, *args, **kwargs):
|
|
import sys, os
|
|
sys.path.insert(0, os.getcwd())
|
|
from workers.graph_engine import health_check
|
|
health = health_check()
|
|
return json.dumps({
|
|
"service": "graph-service",
|
|
"backend": health["backend"],
|
|
"graphs_loaded": health["graphs_loaded"],
|
|
"data_dir": health["data_dir"],
|
|
"endpoints": [
|
|
"/api/status", "/api/graph/add_node", "/api/graph/add_edge",
|
|
"/api/graph/neighbors", "/api/graph/path", "/api/graph/query",
|
|
"/api/graph/stats", "/api/graph/save", "/api/graph/load"
|
|
]
|
|
}, indent=2, ensure_ascii=False)
|
|
|
|
|
|
async def debug_handler(request, params_kw, *args, **kwargs):
|
|
"""Debug endpoint to see params_kw contents"""
|
|
return json.dumps({
|
|
"params_kw": params_kw,
|
|
"params_kw_keys": list(params_kw.keys()),
|
|
"request_method": request.method,
|
|
"request_content_type": request.content_type
|
|
}, indent=2, ensure_ascii=False)
|
|
|
|
|
|
async def add_node_handler(request, params_kw, *args, **kwargs):
|
|
import sys, os
|
|
sys.path.insert(0, os.getcwd())
|
|
from workers.graph_engine import add_node
|
|
try:
|
|
graph = params_kw.get("graph", "default")
|
|
node_id = params_kw.get("node_id")
|
|
attrs = params_kw.get("attrs", {})
|
|
|
|
if not node_id:
|
|
return json.dumps({"error": "node_id required", "debug": {"params_kw": params_kw}})
|
|
|
|
result = add_node(graph, node_id, **attrs)
|
|
return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
|
|
except Exception as e:
|
|
exception(f"{e}, {format_exc()}")
|
|
return json.dumps({"error": str(e)})
|
|
|
|
|
|
async def add_edge_handler(request, params_kw, *args, **kwargs):
|
|
import sys, os
|
|
sys.path.insert(0, os.getcwd())
|
|
from workers.graph_engine import add_edge
|
|
try:
|
|
graph = params_kw.get("graph", "default")
|
|
source = params_kw.get("source")
|
|
target = params_kw.get("target")
|
|
attrs = params_kw.get("attrs", {})
|
|
|
|
if not source or not target:
|
|
return json.dumps({"error": "source and target required"})
|
|
|
|
result = add_edge(graph, source, target, **attrs)
|
|
return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
|
|
except Exception as e:
|
|
exception(f"{e}, {format_exc()}")
|
|
return json.dumps({"error": str(e)})
|
|
|
|
|
|
async def neighbors_handler(request, params_kw, *args, **kwargs):
|
|
import sys, os
|
|
sys.path.insert(0, os.getcwd())
|
|
from workers.graph_engine import get_neighbors
|
|
try:
|
|
graph = params_kw.get("graph", "default")
|
|
node_id = params_kw.get("node_id")
|
|
direction = params_kw.get("direction", "both")
|
|
depth = int(params_kw.get("depth", 1))
|
|
|
|
if not node_id:
|
|
return json.dumps({"error": "node_id required"})
|
|
|
|
result = get_neighbors(graph, node_id, direction, depth)
|
|
return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
|
|
except Exception as e:
|
|
exception(f"{e}, {format_exc()}")
|
|
return json.dumps({"error": str(e)})
|
|
|
|
|
|
async def path_handler(request, params_kw, *args, **kwargs):
|
|
import sys, os
|
|
sys.path.insert(0, os.getcwd())
|
|
from workers.graph_engine import find_path
|
|
try:
|
|
graph = params_kw.get("graph", "default")
|
|
source = params_kw.get("source")
|
|
target = params_kw.get("target")
|
|
max_depth = int(params_kw.get("max_depth", 10))
|
|
|
|
if not source or not target:
|
|
return json.dumps({"error": "source and target required"})
|
|
|
|
result = find_path(graph, source, target, max_depth)
|
|
return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
|
|
except Exception as e:
|
|
exception(f"{e}, {format_exc()}")
|
|
return json.dumps({"error": str(e)})
|
|
|
|
|
|
async def query_handler(request, params_kw, *args, **kwargs):
|
|
import sys, os
|
|
sys.path.insert(0, os.getcwd())
|
|
from workers.graph_engine import query_nodes
|
|
try:
|
|
graph = params_kw.get("graph", "default")
|
|
filters = params_kw.get("filters")
|
|
limit = int(params_kw.get("limit", 100))
|
|
|
|
result = query_nodes(graph, filters, limit)
|
|
return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
|
|
except Exception as e:
|
|
exception(f"{e}, {format_exc()}")
|
|
return json.dumps({"error": str(e)})
|
|
|
|
|
|
async def stats_handler(request, params_kw, *args, **kwargs):
|
|
import sys, os
|
|
sys.path.insert(0, os.getcwd())
|
|
from workers.graph_engine import get_stats
|
|
try:
|
|
graph = params_kw.get("graph", "default")
|
|
result = get_stats(graph)
|
|
return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
|
|
except Exception as e:
|
|
exception(f"{e}, {format_exc()}")
|
|
return json.dumps({"error": str(e)})
|
|
|
|
|
|
async def save_handler(request, params_kw, *args, **kwargs):
|
|
import sys, os
|
|
sys.path.insert(0, os.getcwd())
|
|
from workers.graph_engine import save_graph
|
|
try:
|
|
graph = params_kw.get("graph", "default")
|
|
result = save_graph(graph)
|
|
return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
|
|
except Exception as e:
|
|
exception(f"{e}, {format_exc()}")
|
|
return json.dumps({"error": str(e)})
|
|
|
|
|
|
async def load_handler(request, params_kw, *args, **kwargs):
|
|
import sys, os
|
|
sys.path.insert(0, os.getcwd())
|
|
from workers.graph_engine import load_graph
|
|
try:
|
|
graph = params_kw.get("graph", "default")
|
|
result = load_graph(graph)
|
|
return json.dumps({"status": "SUCCEEDED", **result}, ensure_ascii=False)
|
|
except Exception as e:
|
|
exception(f"{e}, {format_exc()}")
|
|
return json.dumps({"error": str(e)})
|
|
|
|
|
|
def load_graph_service():
|
|
"""Register API handlers"""
|
|
env = ServerEnv()
|
|
rf = RegisterFunction()
|
|
rf.register("status", status_handler)
|
|
rf.register("debug", debug_handler)
|
|
rf.register("add_node", add_node_handler)
|
|
rf.register("add_edge", add_edge_handler)
|
|
rf.register("neighbors", neighbors_handler)
|
|
rf.register("path", path_handler)
|
|
rf.register("query", query_handler)
|
|
rf.register("stats", stats_handler)
|
|
rf.register("save", save_handler)
|
|
rf.register("load", load_handler)
|