Move shared code to testlib

Signed-off-by: Andrey Berezin <a.berezin@yadro.com>

src/frostfs_testlib/storage/cluster.py

@@ -0,0 +1,237 @@
+import random
+import re
+
+import yaml
+
+from frostfs_testlib.hosting import Host, Hosting
+from frostfs_testlib.hosting.config import ServiceConfig
+from frostfs_testlib.storage import get_service_registry
+from frostfs_testlib.storage.constants import ConfigAttributes
+from frostfs_testlib.storage.dataclasses.frostfs_services import (
+    HTTPGate,
+    InnerRing,
+    MorphChain,
+    S3Gate,
+    StorageNode,
+)
+from frostfs_testlib.storage.dataclasses.node_base import NodeBase, ServiceClass
+from frostfs_testlib.storage.service_registry import ServiceRegistry
+
+
+class ClusterNode:
+    """
+    Represents physical node where multiple different services may be located
+    """
+
+    class_registry: ServiceRegistry
+    id: int
+    host: Host
+
+    def __init__(self, host: Host, id: int) -> None:
+        self.host = host
+        self.id = id
+        self.class_registry = get_service_registry()
+
+    @property
+    def host_ip(self):
+        return self.host.config.address
+
+    def __eq__(self, other):
+        return self.host.config.address == other.host.config.address
+
+    def __hash__(self):
+        return id(self.host.config.address)
+
+    def __str__(self):
+        return self.host.config.address
+
+    def __repr__(self) -> str:
+        return self.host.config.address
+
+    # for backward compatibility and to not touch other codebase too much
+    @property
+    def storage_node(self) -> StorageNode:
+        return self.service(StorageNode)
+
+    # for backward compatibility and to not touch other codebase too much
+    @property
+    def ir_node(self) -> InnerRing:
+        return self.service(InnerRing)
+
+    # for backward compatibility and to not touch other codebase too much
+    @property
+    def morph_chain(self) -> MorphChain:
+        return self.service(MorphChain)
+
+    # for backward compatibility and to not touch other codebase too much
+    @property
+    def http_gate(self) -> HTTPGate:
+        return self.service(HTTPGate)
+
+    # for backward compatibility and to not touch other codebase too much
+    @property
+    def s3_gate(self) -> S3Gate:
+        return self.service(S3Gate)
+
+    def service(self, service_type: type[ServiceClass]) -> ServiceClass:
+        """
+        Get a service cluster node of specified type.
+
+        Args:
+            service_type: type of the service which should be returned,
+                          for frostfs it can be StorageNode, S3Gate, HttpGate, MorphChain and InnerRing.
+
+        Returns:
+            service of service_type class.
+        """
+
+        service_entry = self.class_registry.get_entry(service_type)
+        service_name = service_entry["hosting_service_name"]
+
+        pattern = f"{service_name}{self.id}"
+        config = self.host.get_service_config(pattern)
+
+        return service_type(
+            self.id,
+            config.name,
+            self.host,
+        )
+
+    def get_list_of_services(self) -> list[str]:
+        return [
+            config.attributes[ConfigAttributes.SERVICE_NAME] for config in self.host.config.services
+        ]
+
+
+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.class_registry = get_service_registry()
+        self.default_rpc_endpoint = self.services(StorageNode)[0].get_rpc_endpoint()
+        self.default_s3_gate_endpoint = self.services(S3Gate)[0].get_endpoint()
+        self.default_http_gate_endpoint = self.services(HTTPGate)[0].get_endpoint()
+
+    @property
+    def hosts(self) -> list[Host]:
+        """
+        Returns list of Hosts
+        """
+        return self._hosting.hosts
+
+    # for backward compatibility and to not touch other codebase too much
+    @property
+    def storage_nodes(self) -> list[StorageNode]:
+        return self.services(StorageNode)
+
+    # for backward compatibility and to not touch other codebase too much
+    @property
+    def ir_nodes(self) -> list[InnerRing]:
+        return self.services(InnerRing)
+
+    # for backward compatibility and to not touch other codebase too much
+    @property
+    def s3_gates(self) -> list[S3Gate]:
+        return self.services(S3Gate)
+
+    @property
+    def http_gates(self) -> list[HTTPGate]:
+        return self.services(HTTPGate)
+
+    @property
+    def morph_chain(self) -> list[MorphChain]:
+        return self.services(MorphChain)
+
+    def services(self, service_type: type[ServiceClass]) -> list[ServiceClass]:
+        """
+        Get all services in a cluster of specified type.
+
+        Args:
+            service_type: type of the services which should be returned,
+                          for frostfs it can be StorageNode, S3Gate, HttpGate, MorphChain and InnerRing.
+
+        Returns:
+            list of services of service_type class.
+        """
+
+        service = self.class_registry.get_entry(service_type)
+        service_name = service["hosting_service_name"]
+        cls: type[NodeBase] = service["cls"]
+
+        pattern = f"{service_name}\d*$"
+        configs = self.hosting.find_service_configs(pattern)
+
+        found_nodes = []
+        for config in configs:
+            # config.name is something like s3-gate01. Cut last digits to know service type
+            service_type = re.findall(".*\D", config.name)[0]
+            # exclude unsupported services
+            if service_type != service_name:
+                continue
+
+            found_nodes.append(
+                cls(
+                    self._get_id(config.name),
+                    config.name,
+                    self.hosting.get_host_by_service(config.name),
+                )
+            )
+        return found_nodes
+
+    @property
+    def cluster_nodes(self) -> list[ClusterNode]:
+        """
+        Returns list of Cluster Nodes
+        """
+
+        return [ClusterNode(host, id) for id, host in enumerate(self.hosts, start=1)]
+
+    @property
+    def hosting(self) -> Hosting:
+        return self._hosting
+
+    def _create_wallet_config(self, service: ServiceConfig) -> None:
+        wallet_path = service.attributes[ConfigAttributes.LOCAL_WALLET_CONFIG]
+        wallet_password = service.attributes[ConfigAttributes.WALLET_PASSWORD]
+        with open(wallet_path, "w") as file:
+            yaml.dump({"password": wallet_password}, file)
+
+    def create_wallet_configs(self, hosting: Hosting) -> None:
+        configs = hosting.find_service_configs(".*")
+        for config in configs:
+            if ConfigAttributes.LOCAL_WALLET_CONFIG in config.attributes:
+                self._create_wallet_config(config)
+
+    def is_local_devenv(self) -> bool:
+        if len(self.hosting.hosts) == 1:
+            host = self.hosting.hosts[0]
+            if host.config.address == "localhost" and host.config.plugin_name == "docker":
+                return True
+        return False
+
+    def _get_id(self, node_name) -> int:
+        pattern = "\d*$"
+
+        matches = re.search(pattern, node_name)
+        if not matches:
+            raise RuntimeError(f"Can't parse Id of the node {node_name}")
+        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: list[StorageNode] = self.services(StorageNode)
+        return [node.get_rpc_endpoint() for node in nodes]
+
+    def get_morph_endpoints(self) -> list[str]:
+        nodes: list[MorphChain] = self.services(MorphChain)
+        return [node.get_endpoint() for node in nodes]