graphs: validate edges as well as nodes

Author: pinheadmz

src/cli/graph.py

@@ -42,4 +42,4 @@ def validate(graph: Path):
     """
     Validate a <graph file> against the schema.
     """
-    print(rpc_call("graph_validate", {"graph_path": graph.as_posix()}))
+    print(rpc_call("graph_validate", {"graph_path": Path(graph).as_posix()}))

src/schema/graph_schema.json

@@ -0,0 +1,34 @@
+{
+  "node": {
+    "type": "object",
+    "properties": {
+      "degree": {"type": "number"},
+      "x": {"type": "number"},
+      "y": {"type": "number"},
+      "version": {"type": "string"},
+      "image": {"type": "string"},
+      "bitcoin_config": {"type": "string", "default": ""},
+      "tc_netem": {"type": "string"},
+      "exporter": {"type": "boolean", "default": false},
+      "collect_logs": {"type": "boolean", "default": false},
+      "build_args": {"type": "string", "default": ""},
+      "ln": {"type": "string"},
+      "ln-image": {"type": "string"},
+      "ln-cb-image": {"type": "string"}
+    },
+    "additionalProperties": false,
+    "oneOf": [
+      {"required": ["version"]},
+      {"required": ["image"]}
+    ],
+    "required": []
+  },
+  "edge": {
+    "type": "object",
+    "properties": {
+      "channel": {"type": "string"}
+    },
+    "additionalProperties": false,
+    "required": []
+  }
+}

src/schema/node_schema.json

@@ -28,7 +28,6 @@
 from warnet.utils import (
     create_cycle_graph,
     gen_config_dir,
-    load_schema,
     validate_graph_schema,
 )
 from warnet.warnet import Warnet
@@ -531,11 +530,10 @@ def graph_generate(
             raise ServerError(message=msg) from e
 
     def graph_validate(self, graph_path: str) -> str:
-        schema = load_schema()
         with open(graph_path) as f:
-            graph = nx.parse_graphml(f.read(), node_type=int)
+            graph = nx.parse_graphml(f.read(), node_type=int, force_multigraph=True)
         try:
-            validate_graph_schema(schema, graph)
+            validate_graph_schema(graph)
         except (jsonschema.ValidationError, jsonschema.SchemaError) as e:
             raise ServerError(message=f"Schema of {graph_path} is invalid: {e}") from e
         return f"Schema of {graph_path} is valid"

src/warnet/server.py

@@ -61,7 +61,7 @@ def _parse_version(self, version):
     def parse_graph_node(self, node):
         # Dynamically parse properties based on the schema
         graph_properties = {}
-        for property, specs in self.warnet.node_schema["properties"].items():
+        for property, specs in self.warnet.graph_schema["node"]["properties"].items():
             value = node.get(property, specs.get("default"))
             if property == "version":
                 self._parse_version(value)

src/warnet/tank.py

@@ -33,7 +33,7 @@
 WEIGHTED_TAGS = [
     tag for index, tag in enumerate(reversed(SUPPORTED_TAGS)) for _ in range(index + 1)
 ]
-NODE_SCHEMA_PATH = SCHEMA / "node_schema.json"
+GRAPH_SCHEMA_PATH = SCHEMA / "graph_schema.json"
 
 
 class NonErrorFilter(logging.Filter):
@@ -496,13 +496,16 @@ def convert_unsupported_attributes(graph: nx.Graph):
 
 
 def load_schema():
-    with open(NODE_SCHEMA_PATH) as schema_file:
+    with open(GRAPH_SCHEMA_PATH) as schema_file:
         return json.load(schema_file)
 
 
-def validate_graph_schema(node_schema: dict, graph: nx.Graph):
+def validate_graph_schema(graph: nx.Graph):
     """
     Validate a networkx.Graph against the node schema
     """
-    for i in list(graph.nodes):
-        validate(instance=graph.nodes[i], schema=node_schema)
+    graph_schema = load_schema()
+    for n in list(graph.nodes):
+        validate(instance=graph.nodes[n], schema=graph_schema["node"])
+    for e in list(graph.edges):
+        validate(instance=graph.edges[e], schema=graph_schema["edge"])

src/warnet/utils.py

@@ -36,7 +36,7 @@ def __init__(self, config_dir, backend, network_name: str):
         self.tanks: list[Tank] = []
         self.deployment_file: Path | None = None
         self.backend = backend
-        self.node_schema = load_schema()
+        self.graph_schema = load_schema()
 
     def _warnet_dict_representation(self) -> dict:
         repr = {}
@@ -106,8 +106,8 @@ def from_graph_file(
         with open(destination, "wb") as f:
             f.write(graph_file)
         self.network_name = network
-        self.graph = networkx.parse_graphml(graph_file.decode("utf-8"), node_type=int)
-        validate_graph_schema(self.node_schema, self.graph)
+        self.graph = networkx.parse_graphml(graph_file.decode("utf-8"), node_type=int, force_multigraph=True)
+        validate_graph_schema(self.graph)
         self.tanks_from_graph()
         logger.info(f"Created Warnet using directory {self.config_dir}")
         return self
@@ -116,7 +116,7 @@ def from_graph_file(
     def from_graph(cls, graph, backend="compose", network="warnet"):
         self = cls(Path(), backend, network)
         self.graph = graph
-        validate_graph_schema(self.node_schema, self.graph)
+        validate_graph_schema(self.graph)
         self.tanks_from_graph()
         logger.info(f"Created Warnet using directory {self.config_dir}")
         return self
@@ -127,8 +127,8 @@ def from_network(cls, network_name, backend="compose"):
         self = cls(config_dir, backend, network_name)
         self.network_name = network_name
         # Get network graph edges from graph file (required for network restarts)
-        self.graph = networkx.read_graphml(Path(self.config_dir / self.graph_name), node_type=int)
-        validate_graph_schema(self.node_schema, self.graph)
+        self.graph = networkx.read_graphml(Path(self.config_dir / self.graph_name), node_type=int, force_multigraph=True)
+        validate_graph_schema(self.graph)
         self.tanks_from_graph()
         for tank in self.tanks:
             tank._ipv4 = self.container_interface.get_tank_ipv4(tank.index)