import random import re from dataclasses import dataclass from typing import Any import data_formatters from neofs_testlib.blockchain import RPCClient from neofs_testlib.hosting import Host, Hosting from neofs_testlib.hosting.config import ServiceConfig from test_control import wait_for_success @dataclass class NodeBase: """ Represents a node of some underlying service """ id: str name: str host: Host def __init__(self, id, name, host) -> None: self.id = id self.name = name self.host = host self.construct() def construct(self): pass def __eq__(self, other): return self.name == other.name def __hash__(self): return id(self.name) def __str__(self): return self.label def __repr__(self) -> str: return self.label @property def label(self) -> str: return self.name @wait_for_success(60, 1) def start_service(self): self.host.start_service(self.name) @wait_for_success(60, 1) def stop_service(self): self.host.stop_service(self.name) def get_wallet_password(self) -> str: return self._get_attribute(_ConfigAttributes.WALLET_PASSWORD) def get_wallet_path(self) -> str: return self._get_attribute( _ConfigAttributes.LOCAL_WALLET_PATH, _ConfigAttributes.WALLET_PATH, ) def get_wallet_config_path(self): return self._get_attribute( _ConfigAttributes.LOCAL_WALLET_CONFIG, _ConfigAttributes.WALLET_CONFIG, ) def get_wallet_public_key(self): storage_wallet_path = self.get_wallet_path() storage_wallet_pass = self.get_wallet_password() return data_formatters.get_wallet_public_key(storage_wallet_path, storage_wallet_pass) def _get_attribute(self, attribute_name: str, default_attribute_name: str = None) -> list[str]: config = self.host.get_service_config(self.name) if default_attribute_name: return config.attributes.get( attribute_name, config.attributes.get(default_attribute_name) ) else: return config.attributes.get(attribute_name) def _get_service_config(self) -> ServiceConfig: return self.host.get_service_config(self.name) class InnerRingNode(NodeBase): """ Class represents inner ring node in a cluster Inner ring node is not always the same as physical host (or physical node, if you will): It can be service running in a container or on physical host For testing perspective, it's not relevant how it is actually running, since neofs network will still treat it as "node" """ pass class S3Gate(NodeBase): """ Class represents S3 gateway in a cluster """ def get_endpoint(self) -> str: return self._get_attribute(_ConfigAttributes.ENDPOINT) @property def label(self) -> str: return f"{self.name}: {self.get_endpoint()}" class HTTPGate(NodeBase): """ Class represents HTTP gateway in a cluster """ def get_endpoint(self) -> str: return self._get_attribute(_ConfigAttributes.ENDPOINT) @property def label(self) -> str: return f"{self.name}: {self.get_endpoint()}" class MorphChain(NodeBase): """ Class represents side-chain aka morph-chain consensus node in a cluster Consensus node is not always the same as physical host (or physical node, if you will): It can be service running in a container or on physical host For testing perspective, it's not relevant how it is actually running, since neofs network will still treat it as "node" """ rpc_client: RPCClient = None def construct(self): self.rpc_client = RPCClient(self.get_endpoint()) def get_endpoint(self) -> str: return self._get_attribute(_ConfigAttributes.ENDPOINT) @property def label(self) -> str: return f"{self.name}: {self.get_endpoint()}" class MainChain(NodeBase): """ Class represents main-chain consensus node in a cluster Consensus node is not always the same as physical host: It can be service running in a container or on physical host (or physical node, if you will): For testing perspective, it's not relevant how it is actually running, since neofs network will still treat it as "node" """ rpc_client: RPCClient = None def construct(self): self.rpc_client = RPCClient(self.get_endpoint()) def get_endpoint(self) -> str: return self._get_attribute(_ConfigAttributes.ENDPOINT) @property def label(self) -> str: return f"{self.name}: {self.get_endpoint()}" class StorageNode(NodeBase): """ Class represents storage node in a storage cluster Storage node is not always the same as physical host: It can be service running in a container or on physical host (or physical node, if you will): For testing perspective, it's not relevant how it is actually running, since neofs network will still treat it as "node" """ def get_rpc_endpoint(self) -> str: return self._get_attribute(_ConfigAttributes.RPC_ENDPOINT) def get_control_endpoint(self) -> str: return self._get_attribute(_ConfigAttributes.CONTROL_ENDPOINT) def get_un_locode(self): return self._get_attribute(_ConfigAttributes.UN_LOCODE) @property def label(self) -> str: return f"{self.name}: {self.get_rpc_endpoint()}" class Cluster: """ This class represents a Cluster object for the whole storage based on provided hosting """ default_rpc_endpoint: str default_s3_gate_endpoint: str default_http_gate_endpoint: str def __init__(self, hosting: Hosting) -> None: self._hosting = hosting self.default_rpc_endpoint = self.storage_nodes[0].get_rpc_endpoint() self.default_s3_gate_endpoint = self.s3gates[0].get_endpoint() self.default_http_gate_endpoint = self.http_gates[0].get_endpoint() @property def hosts(self) -> list[Host]: """ Returns list of Hosts """ return self._hosting.hosts @property def hosting(self) -> Hosting: return self._hosting @property def storage_nodes(self) -> list[StorageNode]: """ Returns list of Storage Nodes (not physical nodes) """ return self._get_nodes(_ServicesNames.STORAGE) @property def s3gates(self) -> list[S3Gate]: """ Returns list of S3 gates """ return self._get_nodes(_ServicesNames.S3_GATE) @property def http_gates(self) -> list[S3Gate]: """ Returns list of HTTP gates """ return self._get_nodes(_ServicesNames.HTTP_GATE) @property def morph_chain_nodes(self) -> list[MorphChain]: """ Returns list of morph-chain consensus nodes (not physical nodes) """ return self._get_nodes(_ServicesNames.MORPH_CHAIN) @property def main_chain_nodes(self) -> list[MainChain]: """ Returns list of main-chain consensus nodes (not physical nodes) """ return self._get_nodes(_ServicesNames.MAIN_CHAIN) @property def ir_nodes(self) -> list[InnerRingNode]: """ Returns list of inner-ring nodes (not physical nodes) """ return self._get_nodes(_ServicesNames.INNER_RING) def _get_nodes(self, service_name) -> list[StorageNode]: configs = self.hosting.find_service_configs(f"{service_name}\d*$") class_mapping: dict[str, Any] = { _ServicesNames.STORAGE: StorageNode, _ServicesNames.INNER_RING: InnerRingNode, _ServicesNames.MORPH_CHAIN: MorphChain, _ServicesNames.S3_GATE: S3Gate, _ServicesNames.HTTP_GATE: HTTPGate, _ServicesNames.MAIN_CHAIN: MainChain, } cls = class_mapping.get(service_name) return [ cls( self._get_id(config.name), config.name, self.hosting.get_host_by_service(config.name), ) for config in configs ] def _get_id(self, node_name) -> str: pattern = "\d*$" matches = re.search(pattern, node_name) if matches: return int(matches.group()) def get_random_storage_rpc_endpoint(self) -> str: return random.choice(self.get_storage_rpc_endpoints()) def get_storage_rpc_endpoints(self) -> list[str]: nodes = self.storage_nodes return [node.get_rpc_endpoint() for node in nodes] def get_morph_endpoints(self) -> list[str]: nodes = self.morph_chain_nodes return [node.get_endpoint() for node in nodes] class _ServicesNames: STORAGE = "s" S3_GATE = "s3-gate" HTTP_GATE = "http-gate" MORPH_CHAIN = "morph-chain" INNER_RING = "ir" MAIN_CHAIN = "main-chain" class _ConfigAttributes: WALLET_PASSWORD = "wallet_password" WALLET_PATH = "wallet_path" WALLET_CONFIG = "wallet_config" LOCAL_WALLET_PATH = "local_wallet_path" LOCAL_WALLET_CONFIG = "local_config_path" RPC_ENDPOINT = "rpc_endpoint" ENDPOINT = "endpoint" CONTROL_ENDPOINT = "control_endpoint" UN_LOCODE = "un_locode"