[#353] Added Netmap command for CliWrapper

Signed-off-by: Dmitriy Zayakin <d.zayakin@yadro.com>

requirements.txt

@@ -10,6 +10,7 @@ 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,6 +12,7 @@ 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:
@@ -42,6 +43,7 @@ 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:
@@ -73,6 +75,7 @@ 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:
@@ -104,6 +107,7 @@ 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, NodeNetInfo, NodeNetmapInfo, NodeStatus
+from frostfs_testlib.storage.dataclasses.storage_object_info import Interfaces, NodeInfo, NodeNetInfo, NodeNetmapInfo, NodeStatus
 
 
 class NetmapParser:
@@ -20,8 +20,6 @@ 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 = {}
 
@@ -64,7 +62,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 == None:
+                if search_result is None:
                     result_netmap[key] = None
                     continue
                 if key == "node_data_ips":
@@ -83,9 +81,22 @@ class NetmapParser:
         return dataclasses_netmap
 
     @staticmethod
-    def snapshot_one_node(output: str, cluster_node: ClusterNode) -> NodeNetmapInfo | None:
+    def snapshot_one_node(output: str, rpc_endpoint: str) -> NodeNetmapInfo | None:
         snapshot_nodes = NetmapParser.snapshot_all_nodes(output=output)
-        snapshot_node = [node for node in snapshot_nodes if node.node == cluster_node.get_interface(Interfaces.MGMT)]
+        for snapshot in snapshot_nodes:
-        if not snapshot_node:
+            for endpoint in snapshot.external_address:
-            return None
+                if rpc_endpoint.split(":")[0] in endpoint:
-        return snapshot_node[0]
+                    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)

src/frostfs_testlib/storage/dataclasses/storage_object_info.py

@@ -1,6 +1,9 @@
+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
 
@@ -75,8 +78,37 @@ class NodeNetInfo:
     withdrawal_fee: str = None
     homomorphic_hashing_disabled: str = None
     maintenance_mode_allowed: str = None
-    eigen_trust_alpha: str = None
+
-    eigen_trust_iterations: 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))]
 
 
 @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 interfaces
+from frostfs_testlib.storage.grpc_operations import implementations, interfaces, interfaces_wrapper
-from frostfs_testlib.storage.grpc_operations.implementations import container, object
 
 
-class CliClientWrapper(interfaces.GrpcClientWrapper):
+class CliClientWrapper(interfaces_wrapper.GrpcClientWrapper):
     def __init__(self, cli: FrostfsCli) -> None:
         self.cli = cli
-        self.object: interfaces.ObjectInterface = object.ObjectOperations(self.cli)
+        self.object: interfaces.ObjectInterface = implementations.ObjectOperations(self.cli)
-        self.container: interfaces.ContainerInterface = container.ContainerOperations(self.cli)
+        self.container: interfaces.ContainerInterface = implementations.ContainerOperations(self.cli)
+        self.netmap: interfaces.NetmapInterface = implementations.NetmapOperations(self.cli)
 
 
-class RpcClientWrapper(interfaces.GrpcClientWrapper):
+class RpcClientWrapper(interfaces_wrapper.GrpcClientWrapper):
     pass  # The next series

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,171 @@
+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

@@ -1,424 +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.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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,125 @@
+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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,223 @@
+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

@@ -0,0 +1,10 @@
+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