[explorer/nodewatch] task: add new route

explorer/nodewatch/nodewatch/NetworkRepository.py

@@ -23,6 +23,10 @@ def __init__(
 		height=0,
 		finalized_height=0,
 		balance=0,
+		is_healthy=None,
+		is_https_enable=None,
+		is_wss_enable=None,
+		rest_version=None,
 		roles=0xFF):
 		"""Creates a descriptor."""
 
@@ -37,6 +41,10 @@ def __init__(
 		self.height = height
 		self.finalized_height = finalized_height
 		self.balance = balance
+		self.is_healthy = is_healthy
+		self.is_https_enable = is_https_enable
+		self.is_wss_enable = is_wss_enable
+		self.rest_version = rest_version
 		self.roles = roles
 
 	@property
@@ -57,6 +65,10 @@ def to_json(self):
 			'height': self.height,
 			'finalizedHeight': self.finalized_height,
 			'balance': self.balance,
+			'isHealthy': self.is_healthy,
+			'isHttpsEnable': self.is_https_enable,
+			'isWssEnable': self.is_wss_enable,
+			'restVersion': self.rest_version,
 			'roles': self.roles
 		}
 
@@ -150,37 +162,31 @@ def load_node_descriptors(self, nodes_data_filepath):
 		# sort by name
 		self.node_descriptors.sort(key=lambda descriptor: descriptor.name)
 
-	def _create_descriptor_from_json(self, json_node):
-		# network crawler extracts as much extra data as possible, but it might not always be available for all nodes
-		extra_data = (0, 0, 0)
-		if 'extraData' in json_node:
-			json_extra_data = json_node['extraData']
-			extra_data = (json_extra_data.get('height', 0), json_extra_data.get('finalizedHeight', 0), json_extra_data.get('balance', 0))
+	def _handle_nem_node(self, json_node, extra_data):
+		network_identifier = json_node['metaData']['networkId']
+		if network_identifier < 0:
+			network_identifier += 0x100
 
-		if self.is_nem:
-			network_identifier = json_node['metaData']['networkId']
-			if network_identifier < 0:
-				network_identifier += 0x100
-
-			if self._network.identifier != network_identifier:
-				return None
-
-			node_protocol = json_node['endpoint']['protocol']
-			node_host = json_node['endpoint']['host']
-			node_port = json_node['endpoint']['port']
-
-			json_identity = json_node['identity']
-			main_public_key = PublicKey(json_identity['public-key'])
-			node_public_key = PublicKey(json_identity['node-public-key']) if 'node-public-key' in json_identity else None
-			return NodeDescriptor(
-				self._network.public_key_to_address(main_public_key),
-				main_public_key,
-				node_public_key,
-				f'{node_protocol}://{node_host}:{node_port}',
-				json_identity['name'],
-				json_node['metaData']['version'],
-				*extra_data)
+		if self._network.identifier != network_identifier:
+			return None
+
+		node_protocol = json_node['endpoint']['protocol']
+		node_host = json_node['endpoint']['host']
+		node_port = json_node['endpoint']['port']
 
+		json_identity = json_node['identity']
+		main_public_key = PublicKey(json_identity['public-key'])
+		node_public_key = PublicKey(json_identity['node-public-key']) if 'node-public-key' in json_identity else None
+		return NodeDescriptor(
+			self._network.public_key_to_address(main_public_key),
+			main_public_key,
+			node_public_key,
+			f'{node_protocol}://{node_host}:{node_port}',
+			json_identity['name'],
+			json_node['metaData']['version'],
+			*extra_data)
+
+	def _handle_symbol_node(self, json_node, extra_data):
 		symbol_endpoint = ''
 		roles = json_node['roles']
 		has_api = bool(roles & 2)
@@ -192,6 +198,15 @@ def _create_descriptor_from_json(self, json_node):
 		if self._network.generation_hash_seed != Hash256(json_node['networkGenerationHashSeed']):
 			return None
 
+		api_node_info_data = (None, None, None, None)
+		if 'apiNodeInfo' in json_node:
+			json_api_node_info_data = json_node['apiNodeInfo']
+			api_node_info_data = (
+				json_api_node_info_data.get('isHealth', None),
+				json_api_node_info_data.get('isHttpsEnable', None),
+				json_api_node_info_data.get('isWssEnable', None),
+				json_api_node_info_data.get('restVersion', None))
+
 		main_public_key = PublicKey(json_node['publicKey'])
 		node_public_key = PublicKey(json_node['nodePublicKey']) if 'nodePublicKey' in json_node else None
 		return NodeDescriptor(
@@ -202,8 +217,21 @@ def _create_descriptor_from_json(self, json_node):
 			json_node['friendlyName'],
 			self._format_symbol_version(json_node['version']),
 			*extra_data,
+			*api_node_info_data,
 			roles)
 
+	def _create_descriptor_from_json(self, json_node):
+		# network crawler extracts as much extra data as possible, but it might not always be available for all nodes
+		extra_data = (0, 0, 0)
+		if 'extraData' in json_node:
+			json_extra_data = json_node['extraData']
+			extra_data = (json_extra_data.get('height', 0), json_extra_data.get('finalizedHeight', 0), json_extra_data.get('balance', 0))
+
+		if self.is_nem:
+			return self._handle_nem_node(json_node, extra_data)
+
+		return self._handle_symbol_node(json_node, extra_data)
+
 	@staticmethod
 	def _format_symbol_version(version):
 		version_parts = [(version >> 24) & 0xFF, (version >> 16) & 0xFF, (version >> 8) & 0xFF, version & 0xFF]

explorer/nodewatch/nodewatch/RoutesFacade.py

@@ -1,5 +1,6 @@
 import asyncio
 import datetime
+import random
 
 from zenlog import log
 
@@ -65,15 +66,46 @@ def html_nodes(self):
 			'explorer_endpoint': self.explorer_endpoint
 		})
 
-	def json_nodes(self, role, exact_match=False):
-		"""Returns all nodes with matching role."""
+	def json_nodes(self, **kwargs):
+		"""Returns all nodes with condition."""
 
-		def role_filter(descriptor):
-			return role == descriptor.roles if exact_match else role == (role & descriptor.roles)
+		role = kwargs.get('role', None)
+		exact_match = kwargs.get('exact_match', False)
+		limit = kwargs.get('limit', None)
+		ssl = kwargs.get('ssl', None)
+		order = kwargs.get('order', None)
 
-		return list(map(
+		def filter_custom(descriptor):
+			role_condition = True
+
+			if role is not None:
+				role_condition = role == descriptor.roles if exact_match else role == (role & descriptor.roles)
+
+			if ssl is not None:
+				ssl_condition = (descriptor.is_https_enable == ssl and descriptor.is_wss_enable == ssl)
+				return role_condition and ssl_condition
+
+			return role_condition
+
+		nodes = list(map(
 			lambda descriptor: descriptor.to_json(),
-			filter(role_filter, self.repository.node_descriptors)))
+			filter(filter_custom, self.repository.node_descriptors)))
+
+		if order is not None:
+			if order == 'random':
+				random.shuffle(nodes)
+
+		if limit is not None:
+			nodes = nodes[:limit]
+
+		return nodes
+
+	def json_node(self, filter_field, public_key):
+		"""Returns a node with matching public key."""
+
+		matching_items = [item.to_json() for item in self.repository.node_descriptors if item.to_json()[filter_field] == public_key]
+
+		return next(iter(matching_items), None)
 
 	def json_height_chart(self):
 		"""Builds a JSON height chart."""

explorer/nodewatch/nodewatch/__init__.py

@@ -1,3 +1,4 @@
+from enum import Enum
 from pathlib import Path
 
 from apscheduler.schedulers.background import BackgroundScheduler
@@ -11,6 +12,19 @@
 from .RoutesFacade import MIN_HEIGHT_CLUSTER_SIZE, TIMESTAMP_FORMAT, NemRoutesFacade, SymbolRoutesFacade
 
 
+class Field(Enum):
+	MAIN_PUBLIC_KEY = 'mainPublicKey'
+	NODE_PUBLIC_KEY = 'nodePublicKey'
+
+
+def str_to_bool(value):
+	if value.lower() == 'true':
+		return True
+	if value.lower() == 'false':
+		return False
+	return None
+
+
 def create_app():
 	# pylint: disable=too-many-locals
 
@@ -61,7 +75,7 @@ def nem_summary():  # pylint: disable=unused-variable
 
 	@app.route('/api/nem/nodes')
 	def api_nem_nodes():  # pylint: disable=unused-variable
-		return jsonify(nem_routes_facade.json_nodes(1))
+		return jsonify(nem_routes_facade.json_nodes(role=1))
 
 	@app.route('/api/nem/chart/height')
 	def api_nem_chart_height():  # pylint: disable=unused-variable
@@ -93,11 +107,33 @@ def symbol_summary():  # pylint: disable=unused-variable
 
 	@app.route('/api/symbol/nodes/api')
 	def api_symbol_nodes_api():  # pylint: disable=unused-variable
-		return jsonify(symbol_routes_facade.json_nodes(2, exact_match=True))
+		return jsonify(symbol_routes_facade.json_nodes(role=2, exact_match=True))
 
 	@app.route('/api/symbol/nodes/peer')
 	def api_symbol_nodes_peer():  # pylint: disable=unused-variable
-		return jsonify(symbol_routes_facade.json_nodes(1))
+		return jsonify(symbol_routes_facade.json_nodes(role=1))
+
+	@app.route('/api/symbol/nodes')
+	def api_symbol_nodes():  # pylint: disable=unused-variable
+		ssl = request.args.get('ssl', None)
+		limit = request.args.get('limit', None)
+		order = request.args.get('order', None)
+
+		if ssl is not None:
+			ssl = str_to_bool(ssl)
+
+		if limit is not None:
+			limit = int(limit)
+
+		return jsonify(symbol_routes_facade.json_nodes(ssl=ssl, limit=limit, order=order))
+
+	@app.route('/api/symbol/nodes/mainPublicKey/<main_public_key>')
+	def api_symbol_nodes_get_main_public_key(main_public_key):  # pylint: disable=unused-variable
+		return jsonify(symbol_routes_facade.json_node(filter_field=Field.MAIN_PUBLIC_KEY.value, public_key=main_public_key))
+
+	@app.route('/api/symbol/nodes/nodePublicKey/<node_public_key>')
+	def api_symbol_nodes_get_node_public_key(node_public_key):  # pylint: disable=unused-variable
+		return jsonify(symbol_routes_facade.json_node(filter_field=Field.NODE_PUBLIC_KEY.value, public_key=node_public_key))
 
 	@app.route('/api/symbol/chart/height')
 	def api_symbol_chart_height():  # pylint: disable=unused-variable

explorer/nodewatch/tests/resources/symbol_nodes.json

@@ -91,5 +91,49 @@
     "host": "02.symbol-node.net",
     "friendlyName": "Apple",
     "nodePublicKey": "FBEAFCB15D2674ECB8DC1CD2C028C4AC0D463489069FDD415F30BB71EAE69864"
+  },
+  {
+    "apiNodeInfo": {
+      "isHealth": true,
+      "isHttpsEnable": true,
+      "isWssEnable": true,
+      "restVersion": "2.4.2"
+    },
+    "extraData": {
+      "balance": 101027.849383,
+      "finalizedHeight": 1486740,
+      "height": 1486762
+    },
+    "friendlyName": "xym pool",
+    "host": "xym.pool.me",
+    "networkGenerationHashSeed": "57F7DA205008026C776CB6AED843393F04CD458E0AA2D9F1D5F31A402072B2D6",
+    "networkIdentifier": 104,
+    "nodePublicKey": "FE7D3DBE8DDD219E1B20247DEBF150D9411EA5A312989103B037EFBD9D237DE0",
+    "port": 7900,
+    "publicKey": "A54CC798373F42B569AF21845CD0EBE755AB42EA04B3B8E2BE897166F89A971C",
+    "roles": 3,
+    "version": 16777987
+  },
+  {
+    "apiNodeInfo": {
+      "isHealth": true,
+      "isHttpsEnable": false,
+      "isWssEnable": false,
+      "restVersion": "2.4.2"
+    },
+    "extraData": {
+      "balance": 99.98108,
+      "finalizedHeight": 1486740,
+      "height": 1486760
+    },
+    "friendlyName": "yasmine farm",
+    "host": "yasmine.farm.tokyo",
+    "networkGenerationHashSeed": "57F7DA205008026C776CB6AED843393F04CD458E0AA2D9F1D5F31A402072B2D6",
+    "networkIdentifier": 104,
+    "nodePublicKey": "D05BE3101F2916AA34839DDC1199BE45092103A9B66172FA3D05911DC041AADA",
+    "port": 7900,
+    "publicKey": "5B20F8F228FF0E064DB0DE7951155F6F41EF449D0EC10960067C2BF2DCD61874",
+    "roles": 3,
+    "version": 16777988
   }
 ]