requirements.txt

@@ -10,7 +10,6 @@ tenacity==8.0.1
 pytest==7.1.2
 boto3==1.35.30
 boto3-stubs[essential]==1.35.30
-pydantic==2.10.6
 
 # Dev dependencies
 black==22.8.0

src/frostfs_testlib/cli/frostfs_cli/netmap.py

@@ -12,7 +12,6 @@ class FrostfsCliNetmap(CliCommand):
         address: Optional[str] = None,
         generate_key: bool = False,
         ttl: Optional[int] = None,
-        trace: Optional[bool] = False,
         xhdr: Optional[dict] = None,
         timeout: Optional[str] = None,
     ) -> CommandResult:
@@ -43,7 +42,6 @@ class FrostfsCliNetmap(CliCommand):
         address: Optional[str] = None,
         generate_key: bool = False,
         ttl: Optional[int] = None,
-        trace: Optional[bool] = False,
         xhdr: Optional[dict] = None,
         timeout: Optional[str] = None,
     ) -> CommandResult:
@@ -75,7 +73,6 @@ class FrostfsCliNetmap(CliCommand):
         generate_key: bool = False,
         json: bool = False,
         ttl: Optional[int] = None,
-        trace: Optional[bool] = False,
         xhdr: Optional[dict] = None,
         timeout: Optional[str] = None,
     ) -> CommandResult:
@@ -107,7 +104,6 @@ class FrostfsCliNetmap(CliCommand):
         address: Optional[str] = None,
         generate_key: bool = False,
         ttl: Optional[int] = None,
-        trace: Optional[bool] = False,
         xhdr: Optional[dict] = None,
         timeout: Optional[str] = None,
     ) -> CommandResult:

src/frostfs_testlib/cli/netmap_parser.py

@@ -1,7 +1,7 @@
 import re
 
 from frostfs_testlib.storage.cluster import ClusterNode
-from frostfs_testlib.storage.dataclasses.storage_object_info import Interfaces, NodeInfo, NodeNetInfo, NodeNetmapInfo, NodeStatus
+from frostfs_testlib.storage.dataclasses.storage_object_info import Interfaces, NodeNetInfo, NodeNetmapInfo, NodeStatus
 
 
 class NetmapParser:
@@ -20,6 +20,8 @@ class NetmapParser:
             "withdrawal_fee": r"Withdrawal fee: (?P<withdrawal_fee>\d+)",
             "homomorphic_hashing_disabled": r"Homomorphic hashing disabled: (?P<homomorphic_hashing_disabled>true|false)",
             "maintenance_mode_allowed": r"Maintenance mode allowed: (?P<maintenance_mode_allowed>true|false)",
+            "eigen_trust_alpha": r"EigenTrustAlpha: (?P<eigen_trust_alpha>\d+\w+$)",
+            "eigen_trust_iterations": r"EigenTrustIterations: (?P<eigen_trust_iterations>\d+)",
         }
         parse_result = {}
 
@@ -62,7 +64,7 @@ class NetmapParser:
         for node in netmap_nodes:
             for key, regex in regexes.items():
                 search_result = re.search(regex, node, flags=re.MULTILINE)
-                if search_result is None:
+                if search_result == None:
                     result_netmap[key] = None
                     continue
                 if key == "node_data_ips":
@@ -81,22 +83,9 @@ class NetmapParser:
         return dataclasses_netmap
 
     @staticmethod
-    def snapshot_one_node(output: str, rpc_endpoint: str) -> NodeNetmapInfo | None:
+    def snapshot_one_node(output: str, cluster_node: ClusterNode) -> NodeNetmapInfo | None:
         snapshot_nodes = NetmapParser.snapshot_all_nodes(output=output)
-        for snapshot in snapshot_nodes:
-            for endpoint in snapshot.external_address:
-                if rpc_endpoint.split(":")[0] in endpoint:
-                    return snapshot
-
-    @staticmethod
-    def node_info(output: dict) -> NodeNetmapInfo:
-        data_dict = {"attributes": {}}
-
-        for key, value in output.items():
-            if key != "attributes":
-                data_dict[key] = value
-
-        for attribute in output["attributes"]:
-            data_dict["attributes"][attribute["key"]] = attribute["value"]
-
-        return NodeInfo(**data_dict)
+        snapshot_node = [node for node in snapshot_nodes if node.node == cluster_node.get_interface(Interfaces.MGMT)]
+        if not snapshot_node:
+            return None
+        return snapshot_node[0]

src/frostfs_testlib/storage/constants.py

@@ -5,7 +5,6 @@ class ConfigAttributes:
     WALLET_CONFIG = "wallet_config"
     CONFIG_DIR = "service_config_dir"
     CONFIG_PATH = "config_path"
-    WORKING_DIR = "working_dir"
     SHARD_CONFIG_PATH = "shard_config_path"
     LOGGER_CONFIG_PATH = "logger_config_path"
     LOCAL_WALLET_PATH = "local_wallet_path"
@@ -16,7 +15,6 @@ class ConfigAttributes:
     ENDPOINT_DATA_0_NS = "endpoint_data0_namespace"
     ENDPOINT_INTERNAL = "endpoint_internal0"
     ENDPOINT_PROMETHEUS = "endpoint_prometheus"
-    ENDPOINT_PPROF = "endpoint_pprof"
     CONTROL_ENDPOINT = "control_endpoint"
     UN_LOCODE = "un_locode"
 

src/frostfs_testlib/storage/controllers/cluster_state_controller.py

@@ -1,7 +1,7 @@
+import datetime
 import itertools
 import logging
 import time
-from datetime import datetime, timezone
 from typing import TypeVar
 
 import frostfs_testlib.resources.optionals as optionals
@@ -390,23 +390,31 @@ class ClusterStateController:
     @reporter.step("Get node time")
     def get_node_date(self, node: ClusterNode) -> datetime:
         shell = node.host.get_shell()
-        return datetime.strptime(shell.exec('date +"%Y-%m-%d %H:%M:%S"').stdout.strip(), "%Y-%m-%d %H:%M:%S")
+        return datetime.datetime.strptime(shell.exec("hwclock -r").stdout.strip(), "%Y-%m-%d %H:%M:%S.%f%z")
 
     @reporter.step("Set node time to {in_date}")
     def change_node_date(self, node: ClusterNode, in_date: datetime) -> None:
         shell = node.host.get_shell()
-        in_date_frmt = in_date.strftime("%Y-%m-%d %H:%M:%S")
-        shell.exec(f"timedatectl set-time '{in_date_frmt}'")
+        shell.exec(f"date -s @{time.mktime(in_date.timetuple())}")
+        shell.exec("hwclock --systohc")
         node_time = self.get_node_date(node)
         with reporter.step(f"Verify difference between {node_time} and {in_date} is less than a minute"):
-            assert (node_time - in_date).total_seconds() < 60
+            assert (self.get_node_date(node) - in_date) < datetime.timedelta(minutes=1)
 
-    @reporter.step("Restore time")
+    @reporter.step(f"Restore time")
     def restore_node_date(self, node: ClusterNode) -> None:
         shell = node.host.get_shell()
-        now_time = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+        now_time = datetime.datetime.now(datetime.timezone.utc)
         with reporter.step(f"Set {now_time} time"):
-            shell.exec(f"timedatectl set-time '{now_time}'")
+            shell.exec(f"date -s @{time.mktime(now_time.timetuple())}")
+            shell.exec("hwclock --systohc")
+
+    @reporter.step("Change the synchronizer status to {status}")
+    def set_sync_date_all_nodes(self, status: str):
+        if status == "active":
+            parallel(self._enable_date_synchronizer, self.cluster.cluster_nodes)
+            return
+        parallel(self._disable_date_synchronizer, self.cluster.cluster_nodes)
 
     @reporter.step("Set MaintenanceModeAllowed - {status}")
     def set_maintenance_mode_allowed(self, status: str, cluster_node: ClusterNode) -> None:
@@ -492,6 +500,16 @@ class ClusterStateController:
         frostfs_cli_remote = FrostfsCli(shell=shell, frostfs_cli_exec_path=FROSTFS_CLI_EXEC, config_file=wallet_config_path)
         return frostfs_adm, frostfs_cli, frostfs_cli_remote
 
+    def _enable_date_synchronizer(self, cluster_node: ClusterNode):
+        shell = cluster_node.host.get_shell()
+        shell.exec("timedatectl set-ntp true")
+        cluster_node.host.wait_for_service_to_be_in_state("systemd-timesyncd", "active", 15)
+
+    def _disable_date_synchronizer(self, cluster_node: ClusterNode):
+        shell = cluster_node.host.get_shell()
+        shell.exec("timedatectl set-ntp false")
+        cluster_node.host.wait_for_service_to_be_in_state("systemd-timesyncd", "inactive", 15)
+
     def _get_disk_controller(self, node: StorageNode, device: str, mountpoint: str) -> DiskController:
         disk_controller_id = DiskController.get_id(node, device)
         if disk_controller_id in self.detached_disks.keys():

src/frostfs_testlib/storage/dataclasses/node_base.py

@@ -82,9 +82,6 @@ class NodeBase(HumanReadableABC):
     def get_metrics_endpoint(self) -> str:
         return self._get_attribute(ConfigAttributes.ENDPOINT_PROMETHEUS)
 
-    def get_pprof_endpoint(self) -> str:
-        return self._get_attribute(ConfigAttributes.ENDPOINT_PPROF)
-
     def stop_service(self, mask: bool = True):
         if mask:
             with reporter.step(f"Mask {self.name} service on {self.host.config.address}"):
@@ -147,13 +144,6 @@ class NodeBase(HumanReadableABC):
             else None
         )
 
-    def get_working_dir_path(self) -> Optional[str]:
-        """
-        Returns working directory path located on remote host
-        """
-        config_attributes = self.host.get_service_config(self.name)
-        return self._get_attribute(ConfigAttributes.WORKING_DIR) if ConfigAttributes.WORKING_DIR in config_attributes.attributes else None
-
     @property
     def config_dir(self) -> str:
         return self._get_attribute(ConfigAttributes.CONFIG_DIR)

src/frostfs_testlib/storage/dataclasses/storage_object_info.py

@@ -1,9 +1,6 @@
-import re
 from dataclasses import dataclass
 from typing import Optional
 
-from pydantic import BaseModel, Field, field_validator
-
 from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
 from frostfs_testlib.testing.readable import HumanReadableEnum
 
@@ -78,37 +75,8 @@ class NodeNetInfo:
     withdrawal_fee: str = None
     homomorphic_hashing_disabled: str = None
     maintenance_mode_allowed: str = None
-
-
-class Attributes(BaseModel):
-    cluster_name: str = Field(alias="ClusterName")
-    continent: str = Field(alias="Continent")
-    country: str = Field(alias="Country")
-    country_code: str = Field(alias="CountryCode")
-    external_addr: list[str] = Field(alias="ExternalAddr")
-    location: str = Field(alias="Location")
-    node: str = Field(alias="Node")
-    subdiv: str = Field(alias="SubDiv")
-    subdiv_code: str = Field(alias="SubDivCode")
-    un_locode: str = Field(alias="UN-LOCODE")
-    role: str = Field(alias="role")
-
-    @field_validator("external_addr", mode="before")
-    @classmethod
-    def convert_external_addr(cls, value: str) -> list[str]:
-        return [f"{ip}:{port}" for ip, port in re.findall(r"/ip4/([\d\.]+)/(?:tcp|tls)/(\d+)", value)]
-
-
-class NodeInfo(BaseModel):
-    public_key: str = Field(alias="publicKey")
-    addresses: list[str] = Field(alias="addresses")
-    state: str = Field(alias="state")
-    attributes: Attributes = Field(alias="attributes")
-
-    @field_validator("addresses", mode="before")
-    @classmethod
-    def convert_external_addr(cls, value: str) -> list[str]:
-        return [f"{ip}:{port}" for ip, port in re.findall(r"/ip4/([\d\.]+)/(?:tcp|tls)/(\d+)", ",".join(value))]
+    eigen_trust_alpha: str = None
+    eigen_trust_iterations: str = None
 
 
 @dataclass

src/frostfs_testlib/storage/grpc_operations/client_wrappers.py

@@ -1,14 +1,14 @@
 from frostfs_testlib.cli.frostfs_cli.cli import FrostfsCli
-from frostfs_testlib.storage.grpc_operations import implementations, interfaces, interfaces_wrapper
+from frostfs_testlib.storage.grpc_operations import interfaces
+from frostfs_testlib.storage.grpc_operations.implementations import container, object
 
 
-class CliClientWrapper(interfaces_wrapper.GrpcClientWrapper):
+class CliClientWrapper(interfaces.GrpcClientWrapper):
     def __init__(self, cli: FrostfsCli) -> None:
         self.cli = cli
-        self.object: interfaces.ObjectInterface = implementations.ObjectOperations(self.cli)
-        self.container: interfaces.ContainerInterface = implementations.ContainerOperations(self.cli)
-        self.netmap: interfaces.NetmapInterface = implementations.NetmapOperations(self.cli)
+        self.object: interfaces.ObjectInterface = object.ObjectOperations(self.cli)
+        self.container: interfaces.ContainerInterface = container.ContainerOperations(self.cli)
 
 
-class RpcClientWrapper(interfaces_wrapper.GrpcClientWrapper):
+class RpcClientWrapper(interfaces.GrpcClientWrapper):
     pass  # The next series

src/frostfs_testlib/storage/grpc_operations/implementations/__init__.py

@@ -1,4 +0,0 @@
-from .chunks import ChunksOperations
-from .container import ContainerOperations
-from .netmap import NetmapOperations
-from .object import ObjectOperations

src/frostfs_testlib/storage/grpc_operations/implementations/netmap.py

@@ -1,171 +0,0 @@
-import json as module_json
-from typing import List, Optional
-
-from frostfs_testlib.cli.frostfs_cli.cli import FrostfsCli
-from frostfs_testlib.cli.netmap_parser import NetmapParser
-from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT
-from frostfs_testlib.storage.dataclasses.storage_object_info import NodeNetInfo, NodeNetmapInfo
-
-from .. import interfaces
-
-
-class NetmapOperations(interfaces.NetmapInterface):
-    def __init__(self, cli: FrostfsCli) -> None:
-        self.cli = cli
-
-    def epoch(
-        self,
-        rpc_endpoint: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: bool = False,
-        ttl: Optional[int] = None,
-        trace: Optional[bool] = True,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
-    ) -> int:
-        """
-        Get current epoch number.
-        """
-        output = (
-            self.cli.netmap.epoch(
-                rpc_endpoint=rpc_endpoint,
-                wallet=wallet,
-                address=address,
-                generate_key=generate_key,
-                ttl=ttl,
-                trace=trace,
-                xhdr=xhdr,
-                timeout=timeout,
-            )
-            .stdout.split("Trace ID")[0]
-            .strip()
-        )
-
-        return int(output)
-
-    def netinfo(
-        self,
-        rpc_endpoint: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: bool = False,
-        ttl: Optional[int] = None,
-        trace: Optional[bool] = True,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> NodeNetInfo:
-        """
-        Get target node info.
-        """
-        output = (
-            self.cli.netmap.netinfo(
-                rpc_endpoint=rpc_endpoint,
-                wallet=wallet,
-                address=address,
-                generate_key=generate_key,
-                ttl=ttl,
-                trace=trace,
-                xhdr=xhdr,
-                timeout=timeout,
-            )
-            .stdout.split("Trace ID")[0]
-            .strip()
-        )
-
-        return NetmapParser.netinfo(output)
-
-    def nodeinfo(
-        self,
-        rpc_endpoint: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: bool = False,
-        json: bool = True,
-        ttl: Optional[int] = None,
-        trace: Optional[bool] = True,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
-    ) -> NodeNetmapInfo:
-        """
-        Get target node info.
-        """
-        output = (
-            self.cli.netmap.nodeinfo(
-                rpc_endpoint=rpc_endpoint,
-                wallet=wallet,
-                address=address,
-                generate_key=generate_key,
-                json=json,
-                ttl=ttl,
-                trace=trace,
-                xhdr=xhdr,
-                timeout=timeout,
-            )
-            .stdout.split("Trace ID")[0]
-            .strip()
-        )
-
-        return NetmapParser.node_info(module_json.loads(output))
-
-    def snapshot(
-        self,
-        rpc_endpoint: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: bool = False,
-        ttl: Optional[int] = None,
-        trace: Optional[bool] = True,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
-    ) -> List[NodeNetmapInfo]:
-        """
-        Get target node info.
-        """
-        output = (
-            self.cli.netmap.snapshot(
-                rpc_endpoint=rpc_endpoint,
-                wallet=wallet,
-                address=address,
-                generate_key=generate_key,
-                ttl=ttl,
-                trace=trace,
-                xhdr=xhdr,
-                timeout=timeout,
-            )
-            .stdout.split("Trace ID")[0]
-            .strip()
-        )
-
-        return NetmapParser.snapshot_all_nodes(output)
-
-    def snapshot_one_node(
-        self,
-        rpc_endpoint: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: bool = False,
-        ttl: Optional[int] = None,
-        trace: Optional[bool] = True,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
-    ) -> List[NodeNetmapInfo]:
-        """
-        Get target one node info.
-        """
-        output = (
-            self.cli.netmap.snapshot(
-                rpc_endpoint=rpc_endpoint,
-                wallet=wallet,
-                address=address,
-                generate_key=generate_key,
-                ttl=ttl,
-                trace=trace,
-                xhdr=xhdr,
-                timeout=timeout,
-            )
-            .stdout.split("Trace ID")[0]
-            .strip()
-        )
-
-        return NetmapParser.snapshot_one_node(output, rpc_endpoint)

src/frostfs_testlib/storage/grpc_operations/interfaces.py

@@ -0,0 +1,424 @@
+from abc import ABC, abstractmethod
+from typing import Any, List, Optional
+
+from frostfs_testlib.shell.interfaces import CommandResult
+from frostfs_testlib.storage.cluster import Cluster, ClusterNode
+from frostfs_testlib.storage.constants import PlacementRule
+from frostfs_testlib.storage.dataclasses.storage_object_info import Chunk, NodeNetmapInfo
+from frostfs_testlib.utils import file_utils
+
+
+class ChunksInterface(ABC):
+    @abstractmethod
+    def search_node_without_chunks(self, chunks: list[Chunk], cluster: Cluster, endpoint: str = None) -> list[ClusterNode]:
+        pass
+
+    @abstractmethod
+    def get_chunk_node(self, cluster: Cluster, chunk: Chunk) -> tuple[ClusterNode, NodeNetmapInfo]:
+        pass
+
+    @abstractmethod
+    def get_shard_chunk(self, node: ClusterNode, chunk: Chunk) -> str:
+        pass
+
+    @abstractmethod
+    def get_all(
+        self,
+        rpc_endpoint: str,
+        cid: str,
+        oid: str,
+        wallet: Optional[str] = None,
+        address: Optional[str] = None,
+        bearer: Optional[str] = None,
+        generate_key: Optional[bool] = None,
+        trace: bool = False,
+        root: bool = False,
+        verify_presence_all: bool = False,
+        json: bool = True,
+        ttl: Optional[int] = None,
+        xhdr: Optional[dict] = None,
+        timeout: Optional[str] = None,
+    ) -> list[Chunk]:
+        pass
+
+    @abstractmethod
+    def get_parity(
+        self,
+        rpc_endpoint: str,
+        cid: str,
+        wallet: Optional[str] = None,
+        address: Optional[str] = None,
+        bearer: Optional[str] = None,
+        generate_key: Optional[bool] = None,
+        oid: Optional[str] = None,
+        trace: bool = False,
+        root: bool = False,
+        verify_presence_all: bool = False,
+        json: bool = True,
+        ttl: Optional[int] = None,
+        xhdr: Optional[dict] = None,
+        timeout: Optional[str] = None,
+    ) -> Chunk:
+        pass
+
+    @abstractmethod
+    def get_first_data(
+        self,
+        rpc_endpoint: str,
+        cid: str,
+        wallet: Optional[str] = None,
+        address: Optional[str] = None,
+        bearer: Optional[str] = None,
+        generate_key: Optional[bool] = None,
+        oid: Optional[str] = None,
+        trace: bool = False,
+        root: bool = False,
+        verify_presence_all: bool = False,
+        json: bool = True,
+        ttl: Optional[int] = None,
+        xhdr: Optional[dict] = None,
+        timeout: Optional[str] = None,
+    ) -> Chunk:
+        pass
+
+
+class ObjectInterface(ABC):
+    def __init__(self) -> None:
+        self.chunks: ChunksInterface
+
+    @abstractmethod
+    def delete(
+        self,
+        cid: str,
+        oid: str,
+        endpoint: str,
+        bearer: str = "",
+        xhdr: Optional[dict] = None,
+        session: Optional[str] = None,
+        timeout: Optional[str] = None,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    def get(
+        self,
+        cid: str,
+        oid: str,
+        endpoint: str,
+        bearer: Optional[str] = None,
+        write_object: Optional[str] = None,
+        xhdr: Optional[dict] = None,
+        no_progress: bool = True,
+        session: Optional[str] = None,
+        timeout: Optional[str] = None,
+    ) -> file_utils.TestFile:
+        pass
+
+    @abstractmethod
+    def get_from_random_node(
+        self,
+        cid: str,
+        oid: str,
+        cluster: Cluster,
+        bearer: Optional[str] = None,
+        write_object: Optional[str] = None,
+        xhdr: Optional[dict] = None,
+        no_progress: bool = True,
+        session: Optional[str] = None,
+        timeout: Optional[str] = None,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    def hash(
+        self,
+        endpoint: str,
+        cid: str,
+        oid: str,
+        address: Optional[str] = None,
+        bearer: Optional[str] = None,
+        generate_key: Optional[bool] = None,
+        range: Optional[str] = None,
+        salt: Optional[str] = None,
+        ttl: Optional[int] = None,
+        session: Optional[str] = None,
+        hash_type: Optional[str] = None,
+        xhdr: Optional[dict] = None,
+        timeout: Optional[str] = None,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    def head(
+        self,
+        cid: str,
+        oid: str,
+        endpoint: str,
+        bearer: str = "",
+        xhdr: Optional[dict] = None,
+        json_output: bool = True,
+        is_raw: bool = False,
+        is_direct: bool = False,
+        session: Optional[str] = None,
+        timeout: Optional[str] = None,
+    ) -> CommandResult | Any:
+        pass
+
+    @abstractmethod
+    def lock(
+        self,
+        cid: str,
+        oid: str,
+        endpoint: str,
+        lifetime: Optional[int] = None,
+        expire_at: Optional[int] = None,
+        address: Optional[str] = None,
+        bearer: Optional[str] = None,
+        session: Optional[str] = None,
+        ttl: Optional[int] = None,
+        xhdr: Optional[dict] = None,
+        timeout: Optional[str] = None,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    def put(
+        self,
+        path: str,
+        cid: str,
+        endpoint: str,
+        bearer: Optional[str] = None,
+        copies_number: Optional[int] = None,
+        attributes: Optional[dict] = None,
+        xhdr: Optional[dict] = None,
+        expire_at: Optional[int] = None,
+        no_progress: bool = True,
+        session: Optional[str] = None,
+        timeout: Optional[str] = None,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    def patch(
+        self,
+        cid: str,
+        oid: str,
+        endpoint: str,
+        ranges: Optional[list[str]] = None,
+        payloads: Optional[list[str]] = None,
+        new_attrs: Optional[str] = None,
+        replace_attrs: bool = False,
+        bearer: Optional[str] = None,
+        xhdr: Optional[dict] = None,
+        session: Optional[str] = None,
+        timeout: Optional[str] = None,
+        trace: bool = False,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    def put_to_random_node(
+        self,
+        path: str,
+        cid: str,
+        cluster: Cluster,
+        bearer: Optional[str] = None,
+        copies_number: Optional[int] = None,
+        attributes: Optional[dict] = None,
+        xhdr: Optional[dict] = None,
+        expire_at: Optional[int] = None,
+        no_progress: bool = True,
+        session: Optional[str] = None,
+        timeout: Optional[str] = None,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    def range(
+        self,
+        cid: str,
+        oid: str,
+        range_cut: str,
+        endpoint: str,
+        bearer: str = "",
+        xhdr: Optional[dict] = None,
+        session: Optional[str] = None,
+        timeout: Optional[str] = None,
+    ) -> tuple[file_utils.TestFile, bytes]:
+        pass
+
+    @abstractmethod
+    def search(
+        self,
+        cid: str,
+        endpoint: str,
+        bearer: str = "",
+        oid: Optional[str] = None,
+        filters: Optional[dict] = None,
+        expected_objects_list: Optional[list] = None,
+        xhdr: Optional[dict] = None,
+        session: Optional[str] = None,
+        phy: bool = False,
+        root: bool = False,
+        timeout: Optional[str] = None,
+        address: Optional[str] = None,
+        generate_key: Optional[bool] = None,
+        ttl: Optional[int] = None,
+    ) -> List:
+        pass
+
+    @abstractmethod
+    def nodes(
+        self,
+        cluster: Cluster,
+        cid: str,
+        oid: str,
+        alive_node: ClusterNode,
+        bearer: str = "",
+        xhdr: Optional[dict] = None,
+        is_direct: bool = False,
+        verify_presence_all: bool = False,
+        timeout: Optional[str] = None,
+    ) -> List[ClusterNode]:
+        pass
+
+    @abstractmethod
+    def parts(
+        self,
+        cid: str,
+        oid: str,
+        alive_node: ClusterNode,
+        bearer: str = "",
+        xhdr: Optional[dict] = None,
+        is_direct: bool = False,
+        verify_presence_all: bool = False,
+        timeout: Optional[str] = None,
+    ) -> List[str]:
+        pass
+
+
+class ContainerInterface(ABC):
+    @abstractmethod
+    def create(
+        self,
+        endpoint: str,
+        nns_zone: Optional[str] = None,
+        nns_name: Optional[str] = None,
+        address: Optional[str] = None,
+        attributes: Optional[dict] = None,
+        basic_acl: Optional[str] = None,
+        await_mode: bool = False,
+        disable_timestamp: bool = False,
+        force: bool = False,
+        trace: bool = False,
+        name: Optional[str] = None,
+        nonce: Optional[str] = None,
+        policy: Optional[str] = None,
+        session: Optional[str] = None,
+        subnet: Optional[str] = None,
+        ttl: Optional[int] = None,
+        xhdr: Optional[dict] = None,
+        timeout: Optional[str] = None,
+    ) -> str:
+        """
+        Create a new container and register it in the FrostFS.
+        It will be stored in the sidechain when the Inner Ring accepts it.
+        """
+        raise NotImplementedError("No implemethed method create")
+
+    @abstractmethod
+    def delete(
+        self,
+        endpoint: str,
+        cid: str,
+        address: Optional[str] = None,
+        await_mode: bool = False,
+        session: Optional[str] = None,
+        ttl: Optional[int] = None,
+        xhdr: Optional[dict] = None,
+        force: bool = False,
+        trace: bool = False,
+    ) -> List[str]:
+        """
+        Delete an existing container.
+        Only the owner of the container has permission to remove the container.
+        """
+        raise NotImplementedError("No implemethed method delete")
+
+    @abstractmethod
+    def get(
+        self,
+        endpoint: str,
+        cid: str,
+        address: Optional[str] = None,
+        generate_key: Optional[bool] = None,
+        await_mode: bool = False,
+        to: Optional[str] = None,
+        json_mode: bool = True,
+        trace: bool = False,
+        ttl: Optional[int] = None,
+        xhdr: Optional[dict] = None,
+        timeout: Optional[str] = None,
+    ) -> List[str]:
+        """Get container field info."""
+        raise NotImplementedError("No implemethed method get")
+
+    @abstractmethod
+    def get_eacl(
+        self,
+        endpoint: str,
+        cid: str,
+        address: Optional[str] = None,
+        generate_key: Optional[bool] = None,
+        await_mode: bool = False,
+        json_mode: bool = True,
+        trace: bool = False,
+        to: Optional[str] = None,
+        session: Optional[str] = None,
+        ttl: Optional[int] = None,
+        xhdr: Optional[dict] = None,
+        timeout: Optional[str] = None,
+    ) -> List[str]:
+        """Get extended ACL table of container."""
+        raise NotImplementedError("No implemethed method get-eacl")
+
+    @abstractmethod
+    def list(
+        self,
+        endpoint: str,
+        name: Optional[str] = None,
+        address: Optional[str] = None,
+        generate_key: Optional[bool] = None,
+        trace: bool = False,
+        owner: Optional[str] = None,
+        ttl: Optional[int] = None,
+        xhdr: Optional[dict] = None,
+        timeout: Optional[str] = None,
+        **params,
+    ) -> List[str]:
+        """List all created containers."""
+        raise NotImplementedError("No implemethed method list")
+
+    @abstractmethod
+    def nodes(
+        self,
+        endpoint: str,
+        cid: str,
+        cluster: Cluster,
+        address: Optional[str] = None,
+        ttl: Optional[int] = None,
+        from_file: Optional[str] = None,
+        trace: bool = False,
+        short: Optional[bool] = True,
+        xhdr: Optional[dict] = None,
+        generate_key: Optional[bool] = None,
+        timeout: Optional[str] = None,
+    ) -> List[ClusterNode]:
+        """Show the nodes participating in the container in the current epoch."""
+        raise NotImplementedError("No implemethed method nodes")
+
+
+class GrpcClientWrapper(ABC):
+    def __init__(self) -> None:
+        self.object: ObjectInterface
+        self.container: ContainerInterface

src/frostfs_testlib/storage/grpc_operations/interfaces/__init__.py

@@ -1,4 +0,0 @@
-from .chunks import ChunksInterface
-from .container import ContainerInterface
-from .netmap import NetmapInterface
-from .object import ObjectInterface

src/frostfs_testlib/storage/grpc_operations/interfaces/chunks.py

@@ -1,79 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Optional
-
-from frostfs_testlib.storage.cluster import Cluster, ClusterNode
-from frostfs_testlib.storage.dataclasses.storage_object_info import Chunk, NodeNetmapInfo
-
-
-class ChunksInterface(ABC):
-    @abstractmethod
-    def search_node_without_chunks(self, chunks: list[Chunk], cluster: Cluster, endpoint: str = None) -> list[ClusterNode]:
-        pass
-
-    @abstractmethod
-    def get_chunk_node(self, cluster: Cluster, chunk: Chunk) -> tuple[ClusterNode, NodeNetmapInfo]:
-        pass
-
-    @abstractmethod
-    def get_shard_chunk(self, node: ClusterNode, chunk: Chunk) -> str:
-        pass
-
-    @abstractmethod
-    def get_all(
-        self,
-        rpc_endpoint: str,
-        cid: str,
-        oid: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        trace: bool = False,
-        root: bool = False,
-        verify_presence_all: bool = False,
-        json: bool = True,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> list[Chunk]:
-        pass
-
-    @abstractmethod
-    def get_parity(
-        self,
-        rpc_endpoint: str,
-        cid: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        oid: Optional[str] = None,
-        trace: bool = False,
-        root: bool = False,
-        verify_presence_all: bool = False,
-        json: bool = True,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> Chunk:
-        pass
-
-    @abstractmethod
-    def get_first_data(
-        self,
-        rpc_endpoint: str,
-        cid: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        oid: Optional[str] = None,
-        trace: bool = False,
-        root: bool = False,
-        verify_presence_all: bool = False,
-        json: bool = True,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> Chunk:
-        pass

src/frostfs_testlib/storage/grpc_operations/interfaces/container.py

@@ -1,125 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List, Optional
-
-from frostfs_testlib.storage.cluster import Cluster, ClusterNode
-
-
-class ContainerInterface(ABC):
-    @abstractmethod
-    def create(
-        self,
-        endpoint: str,
-        nns_zone: Optional[str] = None,
-        nns_name: Optional[str] = None,
-        address: Optional[str] = None,
-        attributes: Optional[dict] = None,
-        basic_acl: Optional[str] = None,
-        await_mode: bool = False,
-        disable_timestamp: bool = False,
-        force: bool = False,
-        trace: bool = False,
-        name: Optional[str] = None,
-        nonce: Optional[str] = None,
-        policy: Optional[str] = None,
-        session: Optional[str] = None,
-        subnet: Optional[str] = None,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> str:
-        """
-        Create a new container and register it in the FrostFS.
-        It will be stored in the sidechain when the Inner Ring accepts it.
-        """
-        raise NotImplementedError("No implemethed method create")
-
-    @abstractmethod
-    def delete(
-        self,
-        endpoint: str,
-        cid: str,
-        address: Optional[str] = None,
-        await_mode: bool = False,
-        session: Optional[str] = None,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        force: bool = False,
-        trace: bool = False,
-    ) -> List[str]:
-        """
-        Delete an existing container.
-        Only the owner of the container has permission to remove the container.
-        """
-        raise NotImplementedError("No implemethed method delete")
-
-    @abstractmethod
-    def get(
-        self,
-        endpoint: str,
-        cid: str,
-        address: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        await_mode: bool = False,
-        to: Optional[str] = None,
-        json_mode: bool = True,
-        trace: bool = False,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> List[str]:
-        """Get container field info."""
-        raise NotImplementedError("No implemethed method get")
-
-    @abstractmethod
-    def get_eacl(
-        self,
-        endpoint: str,
-        cid: str,
-        address: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        await_mode: bool = False,
-        json_mode: bool = True,
-        trace: bool = False,
-        to: Optional[str] = None,
-        session: Optional[str] = None,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> List[str]:
-        """Get extended ACL table of container."""
-        raise NotImplementedError("No implemethed method get-eacl")
-
-    @abstractmethod
-    def list(
-        self,
-        endpoint: str,
-        name: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        trace: bool = False,
-        owner: Optional[str] = None,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-        **params,
-    ) -> List[str]:
-        """List all created containers."""
-        raise NotImplementedError("No implemethed method list")
-
-    @abstractmethod
-    def nodes(
-        self,
-        endpoint: str,
-        cid: str,
-        cluster: Cluster,
-        address: Optional[str] = None,
-        ttl: Optional[int] = None,
-        from_file: Optional[str] = None,
-        trace: bool = False,
-        short: Optional[bool] = True,
-        xhdr: Optional[dict] = None,
-        generate_key: Optional[bool] = None,
-        timeout: Optional[str] = None,
-    ) -> List[ClusterNode]:
-        """Show the nodes participating in the container in the current epoch."""
-        raise NotImplementedError("No implemethed method nodes")

src/frostfs_testlib/storage/grpc_operations/interfaces/netmap.py

@@ -1,89 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List, Optional
-
-from frostfs_testlib.storage.dataclasses.storage_object_info import NodeNetInfo, NodeNetmapInfo
-
-
-class NetmapInterface(ABC):
-    @abstractmethod
-    def epoch(
-        self,
-        rpc_endpoint: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: bool = False,
-        ttl: Optional[int] = None,
-        trace: Optional[bool] = False,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> int:
-        """
-        Get current epoch number.
-        """
-        raise NotImplementedError("No implemethed method epoch")
-
-    @abstractmethod
-    def netinfo(
-        self,
-        rpc_endpoint: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: bool = False,
-        json: bool = True,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> NodeNetInfo:
-        """
-        Get target node info.
-        """
-        raise NotImplementedError("No implemethed method netinfo")
-
-    @abstractmethod
-    def nodeinfo(
-        self,
-        rpc_endpoint: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: bool = False,
-        json: bool = True,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> NodeNetmapInfo:
-        """
-        Get target node info.
-        """
-        raise NotImplementedError("No implemethed method nodeinfo")
-
-    @abstractmethod
-    def snapshot(
-        self,
-        rpc_endpoint: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: bool = False,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> List[NodeNetmapInfo]:
-        """
-        Get target node info.
-        """
-        raise NotImplementedError("No implemethed method snapshot")
-
-    @abstractmethod
-    def snapshot_one_node(
-        self,
-        rpc_endpoint: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: bool = False,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> List[NodeNetmapInfo]:
-        """
-        Get target one node info.
-        """
-        raise NotImplementedError("No implemethed method snapshot")

src/frostfs_testlib/storage/grpc_operations/interfaces/object.py

@@ -1,223 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, List, Optional
-
-from frostfs_testlib.shell.interfaces import CommandResult
-from frostfs_testlib.storage.cluster import Cluster, ClusterNode
-from frostfs_testlib.utils import file_utils
-
-from .chunks import ChunksInterface
-
-
-class ObjectInterface(ABC):
-    def __init__(self) -> None:
-        self.chunks: ChunksInterface
-
-    @abstractmethod
-    def delete(
-        self,
-        cid: str,
-        oid: str,
-        endpoint: str,
-        bearer: str = "",
-        xhdr: Optional[dict] = None,
-        session: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> str:
-        pass
-
-    @abstractmethod
-    def get(
-        self,
-        cid: str,
-        oid: str,
-        endpoint: str,
-        bearer: Optional[str] = None,
-        write_object: Optional[str] = None,
-        xhdr: Optional[dict] = None,
-        no_progress: bool = True,
-        session: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> file_utils.TestFile:
-        pass
-
-    @abstractmethod
-    def get_from_random_node(
-        self,
-        cid: str,
-        oid: str,
-        cluster: Cluster,
-        bearer: Optional[str] = None,
-        write_object: Optional[str] = None,
-        xhdr: Optional[dict] = None,
-        no_progress: bool = True,
-        session: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> str:
-        pass
-
-    @abstractmethod
-    def hash(
-        self,
-        endpoint: str,
-        cid: str,
-        oid: str,
-        address: Optional[str] = None,
-        bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        range: Optional[str] = None,
-        salt: Optional[str] = None,
-        ttl: Optional[int] = None,
-        session: Optional[str] = None,
-        hash_type: Optional[str] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> str:
-        pass
-
-    @abstractmethod
-    def head(
-        self,
-        cid: str,
-        oid: str,
-        endpoint: str,
-        bearer: str = "",
-        xhdr: Optional[dict] = None,
-        json_output: bool = True,
-        is_raw: bool = False,
-        is_direct: bool = False,
-        session: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult | Any:
-        pass
-
-    @abstractmethod
-    def lock(
-        self,
-        cid: str,
-        oid: str,
-        endpoint: str,
-        lifetime: Optional[int] = None,
-        expire_at: Optional[int] = None,
-        address: Optional[str] = None,
-        bearer: Optional[str] = None,
-        session: Optional[str] = None,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> str:
-        pass
-
-    @abstractmethod
-    def put(
-        self,
-        path: str,
-        cid: str,
-        endpoint: str,
-        bearer: Optional[str] = None,
-        copies_number: Optional[int] = None,
-        attributes: Optional[dict] = None,
-        xhdr: Optional[dict] = None,
-        expire_at: Optional[int] = None,
-        no_progress: bool = True,
-        session: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> str:
-        pass
-
-    @abstractmethod
-    def patch(
-        self,
-        cid: str,
-        oid: str,
-        endpoint: str,
-        ranges: Optional[list[str]] = None,
-        payloads: Optional[list[str]] = None,
-        new_attrs: Optional[str] = None,
-        replace_attrs: bool = False,
-        bearer: Optional[str] = None,
-        xhdr: Optional[dict] = None,
-        session: Optional[str] = None,
-        timeout: Optional[str] = None,
-        trace: bool = False,
-    ) -> str:
-        pass
-
-    @abstractmethod
-    def put_to_random_node(
-        self,
-        path: str,
-        cid: str,
-        cluster: Cluster,
-        bearer: Optional[str] = None,
-        copies_number: Optional[int] = None,
-        attributes: Optional[dict] = None,
-        xhdr: Optional[dict] = None,
-        expire_at: Optional[int] = None,
-        no_progress: bool = True,
-        session: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> str:
-        pass
-
-    @abstractmethod
-    def range(
-        self,
-        cid: str,
-        oid: str,
-        range_cut: str,
-        endpoint: str,
-        bearer: str = "",
-        xhdr: Optional[dict] = None,
-        session: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> tuple[file_utils.TestFile, bytes]:
-        pass
-
-    @abstractmethod
-    def search(
-        self,
-        cid: str,
-        endpoint: str,
-        bearer: str = "",
-        oid: Optional[str] = None,
-        filters: Optional[dict] = None,
-        expected_objects_list: Optional[list] = None,
-        xhdr: Optional[dict] = None,
-        session: Optional[str] = None,
-        phy: bool = False,
-        root: bool = False,
-        timeout: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        ttl: Optional[int] = None,
-    ) -> List:
-        pass
-
-    @abstractmethod
-    def nodes(
-        self,
-        cluster: Cluster,
-        cid: str,
-        oid: str,
-        alive_node: ClusterNode,
-        bearer: str = "",
-        xhdr: Optional[dict] = None,
-        is_direct: bool = False,
-        verify_presence_all: bool = False,
-        timeout: Optional[str] = None,
-    ) -> List[ClusterNode]:
-        pass
-
-    @abstractmethod
-    def parts(
-        self,
-        cid: str,
-        oid: str,
-        alive_node: ClusterNode,
-        bearer: str = "",
-        xhdr: Optional[dict] = None,
-        is_direct: bool = False,
-        verify_presence_all: bool = False,
-        timeout: Optional[str] = None,
-    ) -> List[str]:
-        pass

src/frostfs_testlib/storage/grpc_operations/interfaces_wrapper.py

@@ -1,10 +0,0 @@
-from abc import ABC
-
-from . import interfaces
-
-
-class GrpcClientWrapper(ABC):
-    def __init__(self) -> None:
-        self.object: interfaces.ObjectInterface
-        self.container: interfaces.ContainerInterface
-        self.netmap: interfaces.NetmapInterface

src/frostfs_testlib/utils/version_utils.py

@@ -64,7 +64,7 @@ def parallel_binary_verions(host: Host) -> dict[str, str]:
         try:
             result = shell.exec(f"{binary_path} {binary['param']}")
             version = parse_version(result.stdout) or parse_version(result.stderr) or "Unknown"
-            versions_at_host[binary_name] = version.strip()
+            versions_at_host[binary_name] = version
         except Exception as exc:
             logger.error(f"Cannot get version for {binary_path} because of\n{exc}")
             versions_at_host[binary_name] = "Unknown"