.devenv.hosting.yaml

@@ -1,109 +0,0 @@
-hosts:
-- address: localhost
-  hostname: localhost
-  attributes:
-    sudo_shell: false
-  plugin_name: docker
-  healthcheck_plugin_name: basic
-  attributes:
-    skip_readiness_check: True
-    force_transactions: True
-  services:
-  - name: frostfs-storage_01
-    attributes:
-      container_name: s01
-      config_path: /etc/frostfs/storage/config.yml
-      wallet_path: ../frostfs-dev-env/services/storage/wallet01.json
-      local_wallet_config_path: ./TemporaryDir/empty-password.yml
-      local_wallet_path: ../frostfs-dev-env/services/storage/wallet01.json
-      wallet_password: ""
-      volume_name: storage_storage_s01
-      endpoint_data0: s01.frostfs.devenv:8080
-      control_endpoint: s01.frostfs.devenv:8081
-      un_locode: "RU MOW"
-  - name: frostfs-storage_02
-    attributes:
-      container_name: s02
-      config_path: /etc/frostfs/storage/config.yml
-      wallet_path: ../frostfs-dev-env/services/storage/wallet02.json
-      local_wallet_config_path: ./TemporaryDir/empty-password.yml
-      local_wallet_path: ../frostfs-dev-env/services/storage/wallet02.json
-      wallet_password: ""
-      volume_name: storage_storage_s02
-      endpoint_data0: s02.frostfs.devenv:8080
-      control_endpoint: s02.frostfs.devenv:8081
-      un_locode: "RU LED"
-  - name: frostfs-storage_03
-    attributes:
-      container_name: s03
-      config_path: /etc/frostfs/storage/config.yml
-      wallet_path: ../frostfs-dev-env/services/storage/wallet03.json
-      local_wallet_config_path: ./TemporaryDir/empty-password.yml
-      local_wallet_path: ../frostfs-dev-env/services/storage/wallet03.json
-      wallet_password: ""
-      volume_name: storage_storage_s03
-      endpoint_data0: s03.frostfs.devenv:8080
-      control_endpoint: s03.frostfs.devenv:8081
-      un_locode: "SE STO"
-  - name: frostfs-storage_04
-    attributes:
-      container_name: s04
-      config_path: /etc/frostfs/storage/config.yml
-      wallet_path: ../frostfs-dev-env/services/storage/wallet04.json
-      local_wallet_config_path: ./TemporaryDir/empty-password.yml
-      local_wallet_path: ../frostfs-dev-env/services/storage/wallet04.json
-      wallet_password: ""
-      volume_name: storage_storage_s04
-      endpoint_data0: s04.frostfs.devenv:8080
-      control_endpoint: s04.frostfs.devenv:8081
-      un_locode: "FI HEL"
-  - name: frostfs-s3_01
-    attributes:
-      container_name: s3_gate
-      config_path: ../frostfs-dev-env/services/s3_gate/.s3.env
-      wallet_path: ../frostfs-dev-env/services/s3_gate/wallet.json
-      local_wallet_config_path: ./TemporaryDir/password-s3.yml
-      local_wallet_path: ../frostfs-dev-env/services/s3_gate/wallet.json
-      wallet_password: "s3"
-      endpoint_data0: https://s3.frostfs.devenv:8080
-  - name: frostfs-http_01
-    attributes:
-      container_name: http_gate
-      config_path: ../frostfs-dev-env/services/http_gate/.http.env
-      wallet_path: ../frostfs-dev-env/services/http_gate/wallet.json
-      local_wallet_config_path: ./TemporaryDir/password-other.yml
-      local_wallet_path: ../frostfs-dev-env/services/http_gate/wallet.json
-      wallet_password: "one"
-      endpoint_data0: http://http.frostfs.devenv
-  - name: frostfs-ir_01
-    attributes:
-      container_name: ir01
-      config_path: ../frostfs-dev-env/services/ir/.ir.env
-      wallet_path: ../frostfs-dev-env/services/ir/az.json
-      local_wallet_config_path: ./TemporaryDir/password-other.yml
-      local_wallet_path: ../frostfs-dev-env/services/ir/az.json
-      wallet_password: "one"
-  - name: neo-go_01
-    attributes:
-      container_name: morph_chain
-      config_path: ../frostfs-dev-env/services/morph_chain/protocol.privnet.yml
-      wallet_path: ../frostfs-dev-env/services/morph_chain/node-wallet.json
-      local_wallet_config_path: ./TemporaryDir/password-other.yml
-      local_wallet_path: ../frostfs-dev-env/services/morph_chain/node-wallet.json
-      wallet_password: "one"
-      endpoint_internal0: http://morph-chain.frostfs.devenv:30333
-  - name: main-chain_01
-    attributes:
-      container_name: main_chain
-      config_path: ../frostfs-dev-env/services/chain/protocol.privnet.yml
-      wallet_path: ../frostfs-dev-env/services/chain/node-wallet.json
-      local_wallet_config_path: ./TemporaryDir/password-other.yml
-      local_wallet_path: ../frostfs-dev-env/services/chain/node-wallet.json
-      wallet_password: "one"
-      endpoint_internal0: http://main-chain.frostfs.devenv:30333
-  - name: coredns_01
-    attributes:
-        container_name: coredns
-  clis:
-  - name: frostfs-cli
-    exec_path: frostfs-cli

.forgejo/workflows/dco.yml

@@ -1,21 +0,0 @@
-name: DCO action
-on: [pull_request]
-
-jobs:
-  dco:
-    name: DCO
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Setup Go
-        uses: actions/setup-go@v3
-        with:
-          go-version: '1.21'
-
-      - name: Run commit format checker
-        uses: https://git.frostfs.info/TrueCloudLab/dco-go@v3
-        with:
-          from: 'origin/${{ github.event.pull_request.base.ref }}'

.github/CODEOWNERS

@@ -0,0 +1 @@
+*       @aprasolova @vdomnich-yadro @dansingjulia @yadro-vavdeev @abereziny

.github/workflows/dco.yml

@@ -0,0 +1,21 @@
+name: DCO check
+
+on:
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  commits_check_job:
+    runs-on: ubuntu-latest
+    name: Commits Check
+    steps:
+    - name: Get PR Commits
+      id: 'get-pr-commits'
+      uses: tim-actions/get-pr-commits@master
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+    - name: DCO Check
+      uses: tim-actions/dco@master
+      with:
+        commits: ${{ steps.get-pr-commits.outputs.commits }}

CODEOWNERS

@@ -1 +0,0 @@
-*       @JuliaKovshova @abereziny @d.zayakin @anikeev-yadro @anurindm @ylukoyan @i.niyazov

pyproject.toml

@@ -27,8 +27,8 @@ dependencies = [
     "testrail-api>=1.12.0",
     "pytest==7.1.2",
     "tenacity==8.0.1",
-    "boto3==1.35.30",
+    "boto3==1.16.33",
-    "boto3-stubs[essential]==1.35.30",
+    "boto3-stubs[essential]==1.16.33",
 ]
 requires-python = ">=3.10"
 
@@ -51,26 +51,19 @@ basic = "frostfs_testlib.healthcheck.basic_healthcheck:BasicHealthcheck"
 config = "frostfs_testlib.storage.controllers.state_managers.config_state_manager:ConfigStateManager"
 
 [project.entry-points."frostfs.testlib.services"]
-frostfs-storage = "frostfs_testlib.storage.dataclasses.frostfs_services:StorageNode"
+s = "frostfs_testlib.storage.dataclasses.frostfs_services:StorageNode"
-frostfs-s3 = "frostfs_testlib.storage.dataclasses.frostfs_services:S3Gate"
+s3-gate = "frostfs_testlib.storage.dataclasses.frostfs_services:S3Gate"
-frostfs-http = "frostfs_testlib.storage.dataclasses.frostfs_services:HTTPGate"
+http-gate = "frostfs_testlib.storage.dataclasses.frostfs_services:HTTPGate"
-neo-go = "frostfs_testlib.storage.dataclasses.frostfs_services:MorphChain"
+morph-chain = "frostfs_testlib.storage.dataclasses.frostfs_services:MorphChain"
-frostfs-ir = "frostfs_testlib.storage.dataclasses.frostfs_services:InnerRing"
+ir = "frostfs_testlib.storage.dataclasses.frostfs_services:InnerRing"
-
-[project.entry-points."frostfs.testlib.credentials_providers"]
-authmate = "frostfs_testlib.credentials.authmate_s3_provider:AuthmateS3CredentialsProvider"
-wallet_factory = "frostfs_testlib.credentials.wallet_factory_provider:WalletFactoryProvider"
-
-[project.entry-points."frostfs.testlib.bucket_cid_resolver"]
-frostfs = "frostfs_testlib.s3.curl_bucket_resolver:CurlBucketContainerResolver"
 
 [tool.isort]
 profile = "black"
 src_paths = ["src", "tests"]
-line_length = 140
+line_length = 120
 
 [tool.black]
-line-length = 140
+line-length = 120
 target-version = ["py310"]
 
 [tool.bumpver]
@@ -90,6 +83,3 @@ filterwarnings = [
     "ignore:Blowfish has been deprecated:cryptography.utils.CryptographyDeprecationWarning",
 ]
 testpaths = ["tests"]
-
-[project.entry-points.pytest11]
-testlib = "frostfs_testlib"

requirements.txt

@@ -8,8 +8,8 @@ docstring_parser==0.15
 testrail-api==1.12.0
 tenacity==8.0.1
 pytest==7.1.2
-boto3==1.35.30
+boto3==1.16.33
-boto3-stubs[essential]==1.35.30
+boto3-stubs[essential]==1.16.33
 
 # Dev dependencies
 black==22.8.0

src/frostfs_testlib/__init__.py

@@ -1,4 +1 @@
 __version__ = "2.0.1"
-
-from .fixtures import configure_testlib, hosting, temp_directory
-from .hooks import pytest_collection_modifyitems

src/frostfs_testlib/analytics/__init__.py

@@ -1,5 +1,5 @@
 from frostfs_testlib.analytics import test_case
 from frostfs_testlib.analytics.test_case import TestCasePriority
 from frostfs_testlib.analytics.test_collector import TestCase, TestCaseCollector
-from frostfs_testlib.analytics.test_exporter import TСExporter
+from frostfs_testlib.analytics.test_exporter import TestExporter
 from frostfs_testlib.analytics.testrail_exporter import TestrailExporter

src/frostfs_testlib/analytics/test_exporter.py

@@ -3,8 +3,7 @@ from abc import ABC, abstractmethod
 from frostfs_testlib.analytics.test_collector import TestCase
 
 
-# TODO: REMOVE ME
+class TestExporter(ABC):
-class TСExporter(ABC):
     test_cases_cache = []
     test_suites_cache = []
 
@@ -47,7 +46,9 @@ class TСExporter(ABC):
         """
 
     @abstractmethod
-    def update_test_case(self, test_case: TestCase, test_case_in_tms, test_suite, test_suite_section) -> None:
+    def update_test_case(
+        self, test_case: TestCase, test_case_in_tms, test_suite, test_suite_section
+    ) -> None:
         """
         Update test case in TMS
         """
@@ -59,7 +60,9 @@ class TСExporter(ABC):
 
         for test_case in test_cases:
             test_suite = self.get_or_create_test_suite(test_case.suite_name)
-            test_section = self.get_or_create_suite_section(test_suite, test_case.suite_section_name)
+            test_section = self.get_or_create_suite_section(
+                test_suite, test_case.suite_section_name
+            )
             test_case_in_tms = self.search_test_case_id(test_case.id)
             steps = [{"content": value, "expected": " "} for key, value in test_case.steps.items()]
 

src/frostfs_testlib/analytics/testrail_exporter.py

@@ -1,10 +1,10 @@
 from testrail_api import TestRailAPI
 
 from frostfs_testlib.analytics.test_collector import TestCase
-from frostfs_testlib.analytics.test_exporter import TСExporter
+from frostfs_testlib.analytics.test_exporter import TestExporter
 
 
-class TestrailExporter(TСExporter):
+class TestrailExporter(TestExporter):
     def __init__(
         self,
         tr_url: str,
@@ -62,13 +62,19 @@ class TestrailExporter(TСExporter):
         It's help do not call TMS each time then we search test case
         """
         for test_suite in self.test_suites_cache:
-            self.test_cases_cache.extend(self.api.cases.get_cases(self.tr_project_id, suite_id=test_suite["id"]))
+            self.test_cases_cache.extend(
+                self.api.cases.get_cases(self.tr_project_id, suite_id=test_suite["id"])
+            )
 
     def search_test_case_id(self, test_case_id: str) -> object:
         """
         Find test cases in TestRail (cache) by ID
         """
-        test_cases = [test_case for test_case in self.test_cases_cache if test_case["custom_autotest_name"] == test_case_id]
+        test_cases = [
+            test_case
+            for test_case in self.test_cases_cache
+            if test_case["custom_autotest_name"] == test_case_id
+        ]
 
         if len(test_cases) > 1:
             raise RuntimeError(f"Too many results found in test rail for id {test_case_id}")
@@ -81,7 +87,9 @@ class TestrailExporter(TСExporter):
         """
         Get suite name with exact name from Testrail or create if not exist
         """
-        test_rail_suites = [suite for suite in self.test_suites_cache if suite["name"] == test_suite_name]
+        test_rail_suites = [
+            suite for suite in self.test_suites_cache if suite["name"] == test_suite_name
+        ]
 
         if not test_rail_suites:
             test_rail_suite = self.api.suites.add_suite(
@@ -94,13 +102,17 @@ class TestrailExporter(TСExporter):
         elif len(test_rail_suites) == 1:
             return test_rail_suites.pop()
         else:
-            raise RuntimeError(f"Too many results found in test rail for suite name {test_suite_name}")
+            raise RuntimeError(
+                f"Too many results found in test rail for suite name {test_suite_name}"
+            )
 
     def get_or_create_suite_section(self, test_rail_suite, section_name) -> object:
         """
         Get suite section with exact name from Testrail or create new one if not exist
         """
-        test_rail_sections = [section for section in test_rail_suite["sections"] if section["name"] == section_name]
+        test_rail_sections = [
+            section for section in test_rail_suite["sections"] if section["name"] == section_name
+        ]
 
         if not test_rail_sections:
             test_rail_section = self.api.sections.add_section(
@@ -116,7 +128,9 @@ class TestrailExporter(TСExporter):
         elif len(test_rail_sections) == 1:
             return test_rail_sections.pop()
         else:
-            raise RuntimeError(f"Too many results found in test rail for section name {section_name}")
+            raise RuntimeError(
+                f"Too many results found in test rail for section name {section_name}"
+            )
 
     def prepare_request_body(self, test_case: TestCase, test_suite, test_suite_section) -> dict:
         """
@@ -150,7 +164,9 @@ class TestrailExporter(TСExporter):
 
         self.api.cases.add_case(**request_body)
 
-    def update_test_case(self, test_case: TestCase, test_case_in_tms, test_suite, test_suite_section) -> None:
+    def update_test_case(
+        self, test_case: TestCase, test_case_in_tms, test_suite, test_suite_section
+    ) -> None:
         """
         Update test case in Testrail
         """

src/frostfs_testlib/cli/__init__.py

@@ -1,5 +1,4 @@
 from frostfs_testlib.cli.frostfs_adm import FrostfsAdm
 from frostfs_testlib.cli.frostfs_authmate import FrostfsAuthmate
 from frostfs_testlib.cli.frostfs_cli import FrostfsCli
-from frostfs_testlib.cli.generic_cli import GenericCli
 from frostfs_testlib.cli.neogo import NeoGo, NetworkType

src/frostfs_testlib/cli/frostfs_adm/morph.py

@@ -69,7 +69,9 @@ class FrostfsAdmMorph(CliCommand):
             **{param: param_value for param, param_value in locals().items() if param not in ["self"]},
         )
 
-    def set_config(self, set_key_value: str, rpc_endpoint: Optional[str] = None, alphabet_wallets: Optional[str] = None) -> CommandResult:
+    def set_config(
+        self, set_key_value: str, rpc_endpoint: Optional[str] = None, alphabet_wallets: Optional[str] = None
+    ) -> CommandResult:
         """Add/update global config value in the FrostFS network.
 
         Args:
@@ -108,7 +110,7 @@ class FrostfsAdmMorph(CliCommand):
             **{param: param_value for param, param_value in locals().items() if param not in ["self"]},
         )
 
-    def dump_hashes(self, rpc_endpoint: str, domain: Optional[str] = None) -> CommandResult:
+    def dump_hashes(self, rpc_endpoint: str) -> CommandResult:
         """Dump deployed contract hashes.
 
         Args:
@@ -123,7 +125,7 @@ class FrostfsAdmMorph(CliCommand):
         )
 
     def force_new_epoch(
-        self, rpc_endpoint: Optional[str] = None, alphabet_wallets: Optional[str] = None, delta: Optional[int] = None
+        self, rpc_endpoint: Optional[str] = None, alphabet_wallets: Optional[str] = None
     ) -> CommandResult:
         """Create new FrostFS epoch event in the side chain.
 
@@ -342,124 +344,9 @@ class FrostfsAdmMorph(CliCommand):
 
         return self._execute(
             f"morph remove-nodes {' '.join(node_netmap_keys)}",
-            **{param: param_value for param, param_value in locals().items() if param not in ["self", "node_netmap_keys"]},
+            **{
-        )
+                param: param_value
-
+                for param, param_value in locals().items()
-    def add_rule(
+                if param not in ["self", "node_netmap_keys"]
-        self,
+            },
-        chain_id: str,
-        target_name: str,
-        target_type: str,
-        rule: Optional[list[str]] = None,
-        path: Optional[str] = None,
-        chain_id_hex: Optional[bool] = None,
-        chain_name: Optional[str] = None,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Drop objects from the node's local storage
-
-        Args:
-        chain-id: Assign ID to the parsed chain
-        chain-id-hex: Flag to parse chain ID as hex
-        path: Path to encoded chain in JSON or binary format
-        rule: Rule statement
-        target-name: Resource name in APE resource name format
-        target-type: Resource type(container/namespace)
-        timeout: Timeout for an operation (default 15s)
-        wallet: Path to the wallet or binary key
-
-        Returns:
-            Command`s result.
-        """
-        return self._execute(
-            "morph ape add-rule-chain",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def get_rule(
-        self,
-        chain_id: str,
-        target_name: str,
-        target_type: str,
-        chain_id_hex: Optional[bool] = None,
-        chain_name: Optional[str] = None,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Drop objects from the node's local storage
-
-        Args:
-        chain-id string      Chain id
-        chain-id-hex         Flag to parse chain ID as hex
-        target-name string   Resource name in APE resource name format
-        target-type string   Resource type(container/namespace)
-        timeout duration     Timeout for an operation (default 15s)
-        wallet string        Path to the wallet or binary key
-
-        Returns:
-            Command`s result.
-        """
-        return self._execute(
-            "morph ape get-rule-chain",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def list_rules(
-        self,
-        target_type: str,
-        target_name: Optional[str] = None,
-        rpc_endpoint: Optional[str] = None,
-        chain_name: Optional[str] = None,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Drop objects from the node's local storage
-
-        Args:
-        target-name: Resource name in APE resource name format
-        target-type: Resource type(container/namespace)
-        timeout: Timeout for an operation (default 15s)
-        wallet: Path to the wallet or binary key
-
-        Returns:
-            Command`s result.
-        """
-        return self._execute(
-            "morph ape list-rule-chains",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def remove_rule(
-        self,
-        chain_id: str,
-        target_name: str,
-        target_type: str,
-        all: Optional[bool] = None,
-        chain_name: Optional[str] = None,
-        chain_id_hex: Optional[bool] = None,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Drop objects from the node's local storage
-
-        Args:
-        all: Remove all chains
-        chain-id: Assign ID to the parsed chain
-        chain-id-hex: Flag to parse chain ID as hex
-        target-name: Resource name in APE resource name format
-        target-type: Resource type(container/namespace)
-        timeout: Timeout for an operation (default 15s)
-        wallet: Path to the wallet or binary key
-
-        Returns:
-            Command`s result.
-        """
-        return self._execute(
-            "morph ape rm-rule-chain",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
         )

src/frostfs_testlib/cli/frostfs_cli/ape_manager.py

@@ -1,70 +0,0 @@
-from typing import Optional
-
-from frostfs_testlib.cli.cli_command import CliCommand
-from frostfs_testlib.shell import CommandResult
-
-
-class FrostfsCliApeManager(CliCommand):
-    """Operations with APE manager."""
-
-    def add(
-        self,
-        rpc_endpoint: str,
-        chain_id: Optional[str] = None,
-        chain_id_hex: Optional[str] = None,
-        path: Optional[str] = None,
-        rule: Optional[str] | Optional[list[str]] = None,
-        target_name: Optional[str] = None,
-        target_type: Optional[str] = None,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Add rule chain for a target."""
-
-        return self._execute(
-            "ape-manager add",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def list(
-        self,
-        rpc_endpoint: str,
-        target_name: Optional[str] = None,
-        target_type: Optional[str] = None,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Generate APE override by target and APE chains. Util command.
-
-        Generated APE override can be dumped to a file in JSON format that is passed to
-        "create" command.
-        """
-
-        return self._execute(
-            "ape-manager list",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def remove(
-        self,
-        rpc_endpoint: str,
-        chain_id: Optional[str] = None,
-        chain_id_hex: Optional[str] = None,
-        target_name: Optional[str] = None,
-        target_type: Optional[str] = None,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Generate APE override by target and APE chains. Util command.
-
-        Generated APE override can be dumped to a file in JSON format that is passed to
-        "create" command.
-        """
-
-        return self._execute(
-            "ape-manager remove",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )

src/frostfs_testlib/cli/frostfs_cli/bearer.py

@@ -1,54 +0,0 @@
-from typing import Optional
-
-from frostfs_testlib.cli.cli_command import CliCommand
-from frostfs_testlib.shell import CommandResult
-
-
-class FrostfsCliBearer(CliCommand):
-    def create(
-        self,
-        rpc_endpoint: str,
-        out: str,
-        issued_at: Optional[str] = None,
-        expire_at: Optional[str] = None,
-        not_valid_before: Optional[str] = None,
-        ape: Optional[str] = None,
-        eacl: Optional[str] = None,
-        owner: Optional[str] = None,
-        json: Optional[bool] = False,
-        impersonate: Optional[bool] = False,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-    ) -> CommandResult:
-        """Create bearer token.
-
-        All epoch flags can be specified relative to the current epoch with the +n syntax.
-        In this case --rpc-endpoint flag should be specified and the epoch in bearer token
-        is set to current epoch + n.
-        """
-        return self._execute(
-            "bearer create",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def generate_ape_override(
-        self,
-        chain_id: Optional[str] = None,
-        chain_id_hex: Optional[str] = None,
-        cid: Optional[str] = None,
-        output: Optional[str] = None,
-        path: Optional[str] = None,
-        rule: Optional[str] = None,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-    ) -> CommandResult:
-        """Generate APE override by target and APE chains. Util command.
-
-        Generated APE override can be dumped to a file in JSON format that is passed to
-        "create" command.
-        """
-
-        return self._execute(
-            "bearer generate-ape-override",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )

src/frostfs_testlib/cli/frostfs_cli/cli.py

@@ -2,8 +2,6 @@ from typing import Optional
 
 from frostfs_testlib.cli.frostfs_cli.accounting import FrostfsCliAccounting
 from frostfs_testlib.cli.frostfs_cli.acl import FrostfsCliACL
-from frostfs_testlib.cli.frostfs_cli.ape_manager import FrostfsCliApeManager
-from frostfs_testlib.cli.frostfs_cli.bearer import FrostfsCliBearer
 from frostfs_testlib.cli.frostfs_cli.container import FrostfsCliContainer
 from frostfs_testlib.cli.frostfs_cli.control import FrostfsCliControl
 from frostfs_testlib.cli.frostfs_cli.netmap import FrostfsCliNetmap
@@ -43,5 +41,3 @@ class FrostfsCli:
         self.version = FrostfsCliVersion(shell, frostfs_cli_exec_path, config=config_file)
         self.tree = FrostfsCliTree(shell, frostfs_cli_exec_path, config=config_file)
         self.control = FrostfsCliControl(shell, frostfs_cli_exec_path, config=config_file)
-        self.bearer = FrostfsCliBearer(shell, frostfs_cli_exec_path, config=config_file)
-        self.ape_manager = FrostfsCliApeManager(shell, frostfs_cli_exec_path, config=config_file)

src/frostfs_testlib/cli/frostfs_cli/container.py

@@ -8,16 +8,12 @@ class FrostfsCliContainer(CliCommand):
     def create(
         self,
         rpc_endpoint: str,
-        wallet: Optional[str] = None,
+        wallet: 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,
@@ -39,8 +35,6 @@ class FrostfsCliContainer(CliCommand):
             basic_acl: Hex encoded basic ACL value or keywords like 'public-read-write',
                 'private', 'eacl-public-read' (default "private").
             disable_timestamp: Disable timestamp container attribute.
-            force: Skip placement validity check.
-            trace: Generate trace ID and print it.
             name: Container name attribute.
             nonce: UUIDv4 nonce value for container.
             policy: QL-encoded or JSON-encoded placement policy or path to file with it.
@@ -51,8 +45,6 @@ class FrostfsCliContainer(CliCommand):
             wallet: WIF (NEP-2) string or path to the wallet or binary key.
             xhdr: Dict with request X-Headers.
             timeout: Timeout for the operation (default 15s).
-            nns_zone: Container nns zone attribute.
-            nns_name: Container nns name attribute.
 
         Returns:
             Command's result.
@@ -65,15 +57,15 @@ class FrostfsCliContainer(CliCommand):
     def delete(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
-        wallet: Optional[str] = None,
         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,
+        timeout: Optional[str] = None,
     ) -> CommandResult:
         """
         Delete an existing container.
@@ -83,13 +75,13 @@ class FrostfsCliContainer(CliCommand):
             address: Address of wallet account.
             await_mode: Block execution until container is removed.
             cid: Container ID.
-            trace: Generate trace ID and print it.
             force: Do not check whether container contains locks and remove immediately.
             rpc_endpoint: Remote node address (as 'multiaddr' or '<host>:<port>').
             session: Path to a JSON-encoded container session token.
             ttl: TTL value in request meta header (default 2).
             wallet: WIF (NEP-2) string or path to the wallet or binary key.
             xhdr: Dict with request X-Headers.
+            timeout: Timeout for the operation (default 15s).
 
         Returns:
             Command's result.
@@ -103,14 +95,12 @@ class FrostfsCliContainer(CliCommand):
     def get(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
-        generate_key: Optional[bool] = None,
         await_mode: bool = False,
         to: Optional[str] = None,
         json_mode: bool = False,
-        trace: bool = False,
         ttl: Optional[int] = None,
         xhdr: Optional[dict] = None,
         timeout: Optional[str] = None,
@@ -123,14 +113,12 @@ class FrostfsCliContainer(CliCommand):
             await_mode: Block execution until container is removed.
             cid: Container ID.
             json_mode: Print or dump container in JSON format.
-            trace: Generate trace ID and print it.
             rpc_endpoint: Remote node address (as 'multiaddr' or '<host>:<port>').
             to: Path to dump encoded container.
             ttl: TTL value in request meta header (default 2).
             wallet: WIF (NEP-2) string or path to the wallet or binary key.
             xhdr: Dict with request X-Headers.
             timeout: Timeout for the operation (default 15s).
-            generate_key: Generate a new private key.
 
         Returns:
             Command's result.
@@ -143,10 +131,9 @@ class FrostfsCliContainer(CliCommand):
     def get_eacl(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
-        generate_key: Optional[bool] = None,
         await_mode: bool = False,
         to: Optional[str] = None,
         session: Optional[str] = None,
@@ -163,14 +150,11 @@ class FrostfsCliContainer(CliCommand):
             cid: Container ID.
             rpc_endpoint: Remote node address (as 'multiaddr' or '<host>:<port>').
             to: Path to dump encoded container.
-            json_mode: Print or dump container in JSON format.
-            trace: Generate trace ID and print it.
             session: Path to a JSON-encoded container session token.
             ttl: TTL value in request meta header (default 2).
             wallet: WIF (NEP-2) string or path to the wallet or binary key.
             xhdr: Dict with request X-Headers.
             timeout: Timeout for the operation (default 15s).
-            generate_key: Generate a new private key.
 
         Returns:
             Command's result.
@@ -184,10 +168,8 @@ class FrostfsCliContainer(CliCommand):
     def list(
         self,
         rpc_endpoint: str,
-        name: Optional[str] = None,
+        wallet: str,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
-        generate_key: Optional[bool] = None,
         owner: Optional[str] = None,
         ttl: Optional[int] = None,
         xhdr: Optional[dict] = None,
@@ -199,15 +181,12 @@ class FrostfsCliContainer(CliCommand):
 
         Args:
             address: Address of wallet account.
-            name: List containers by the attribute name.
             owner: Owner of containers (omit to use owner from private key).
             rpc_endpoint: Remote node address (as 'multiaddr' or '<host>:<port>').
             ttl: TTL value in request meta header (default 2).
             wallet: WIF (NEP-2) string or path to the wallet or binary key.
             xhdr: Dict with request X-Headers.
-            trace: Generate trace ID and print it.
             timeout: Timeout for the operation (default 15s).
-            generate_key: Generate a new private key.
 
         Returns:
             Command's result.
@@ -220,12 +199,9 @@ class FrostfsCliContainer(CliCommand):
     def list_objects(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
-        bearer: Optional[str] = None,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        trace: bool = False,
         ttl: Optional[int] = None,
         xhdr: Optional[dict] = None,
         timeout: Optional[str] = None,
@@ -236,14 +212,11 @@ class FrostfsCliContainer(CliCommand):
         Args:
             address: Address of wallet account.
             cid: Container ID.
-            bearer: File with signed JSON or binary encoded bearer token.
             rpc_endpoint: Remote node address (as 'multiaddr' or '<host>:<port>').
             ttl: TTL value in request meta header (default 2).
             wallet: WIF (NEP-2) string or path to the wallet or binary key.
             xhdr: Dict with request X-Headers.
-            trace: Generate trace ID and print it.
             timeout: Timeout for the operation (default 15s).
-            generate_key: Generate a new private key.
 
         Returns:
             Command's result.
@@ -253,12 +226,11 @@ class FrostfsCliContainer(CliCommand):
             **{param: value for param, value in locals().items() if param not in ["self"]},
         )
 
-    # TODO Deprecated method with 0.42
     def set_eacl(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
         await_mode: bool = False,
         table: Optional[str] = None,
@@ -294,12 +266,11 @@ class FrostfsCliContainer(CliCommand):
     def search_node(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
-        wallet: Optional[str] = None,
         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,
@@ -317,9 +288,8 @@ class FrostfsCliContainer(CliCommand):
             from_file: string File path with encoded container
             timeout: duration Timeout for the operation (default 15 s)
             short: shorten the output of node information.
-            trace: Generate trace ID and print it.
             xhdr: Dict with request X-Headers.
-            generate_key: Generate a new private key.
+            generate_key: Generate a new private key
 
         Returns:
 
@@ -328,5 +298,9 @@ class FrostfsCliContainer(CliCommand):
 
         return self._execute(
             f"container nodes {from_str}",
-            **{param: value for param, value in locals().items() if param not in ["self", "from_file", "from_str"]},
+            **{
+                param: value
+                for param, value in locals().items()
+                if param not in ["self", "from_file", "from_str"]
+            },
         )

src/frostfs_testlib/cli/frostfs_cli/control.py

@@ -39,12 +39,14 @@ class FrostfsCliControl(CliCommand):
         address: Optional[str] = None,
         timeout: Optional[str] = None,
     ) -> CommandResult:
-        """Health check for FrostFS storage nodes
+        """Set status of the storage node in FrostFS network map
 
         Args:
         wallet: Path to the wallet or binary key
         address: Address of wallet account
         endpoint: Remote node control address (as 'multiaddr' or '<host>:<port>')
+        force: Force turning to local maintenance
+        status: New netmap status keyword ('online', 'offline', 'maintenance')
         timeout: Timeout for an operation (default 15s)
 
         Returns:
@@ -54,179 +56,3 @@ class FrostfsCliControl(CliCommand):
             "control healthcheck",
             **{param: value for param, value in locals().items() if param not in ["self"]},
         )
-
-    def drop_objects(
-        self,
-        endpoint: str,
-        objects: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Drop objects from the node's local storage
-
-        Args:
-        wallet: Path to the wallet or binary key
-        address: Address of wallet account
-        endpoint: Remote node control address (as 'multiaddr' or '<host>:<port>')
-        objects: List of object addresses to be removed in string format
-        timeout: Timeout for an operation (default 15s)
-
-        Returns:
-            Command`s result.
-        """
-        return self._execute(
-            "control drop-objects",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def add_rule(
-        self,
-        endpoint: str,
-        chain_id: str,
-        target_name: str,
-        target_type: str,
-        rule: Optional[list[str]] = None,
-        path: Optional[str] = None,
-        chain_id_hex: Optional[bool] = None,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Drop objects from the node's local storage
-
-        Args:
-        address: Address of wallet account
-        chain-id: Assign ID to the parsed chain
-        chain-id-hex: Flag to parse chain ID as hex
-        endpoint: Remote node control address (as 'multiaddr' or '<host>:<port>')
-        path: Path to encoded chain in JSON or binary format
-        rule: Rule statement
-        target-name: Resource name in APE resource name format
-        target-type: Resource type(container/namespace)
-        timeout: Timeout for an operation (default 15s)
-        wallet: Path to the wallet or binary key
-
-        Returns:
-            Command`s result.
-        """
-        return self._execute(
-            "control add-rule",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def get_rule(
-        self,
-        endpoint: str,
-        chain_id: str,
-        target_name: str,
-        target_type: str,
-        chain_id_hex: Optional[bool] = None,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Drop objects from the node's local storage
-
-        Args:
-        address string       Address of wallet account
-        chain-id string      Chain id
-        chain-id-hex         Flag to parse chain ID as hex
-        endpoint string      Remote node control address (as 'multiaddr' or '<host>:<port>')
-        target-name string   Resource name in APE resource name format
-        target-type string   Resource type(container/namespace)
-        timeout duration     Timeout for an operation (default 15s)
-        wallet string        Path to the wallet or binary key
-
-        Returns:
-            Command`s result.
-        """
-        return self._execute(
-            "control get-rule",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def list_rules(
-        self,
-        endpoint: str,
-        target_name: str,
-        target_type: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Drop objects from the node's local storage
-
-        Args:
-        address: Address of wallet account
-        endpoint: Remote node control address (as 'multiaddr' or '<host>:<port>')
-        target-name: Resource name in APE resource name format
-        target-type: Resource type(container/namespace)
-        timeout: Timeout for an operation (default 15s)
-        wallet: Path to the wallet or binary key
-
-        Returns:
-            Command`s result.
-        """
-        return self._execute(
-            "control list-rules",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def list_targets(
-        self,
-        endpoint: str,
-        chain_name: str,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Drop objects from the node's local storage
-
-        Args:
-        address: Address of wallet account
-        chain-name: Chain name(ingress|s3)
-        endpoint: Remote node control address (as 'multiaddr' or '<host>:<port>')
-        timeout: Timeout for an operation (default 15s)
-        wallet: Path to the wallet or binary key
-
-        Returns:
-            Command`s result.
-        """
-        return self._execute(
-            "control list-targets",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def remove_rule(
-        self,
-        endpoint: str,
-        chain_id: str,
-        target_name: str,
-        target_type: str,
-        all: Optional[bool] = None,
-        chain_id_hex: Optional[bool] = None,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Drop objects from the node's local storage
-
-        Args:
-        address: Address of wallet account
-        all: Remove all chains
-        chain-id: Assign ID to the parsed chain
-        chain-id-hex: Flag to parse chain ID as hex
-        endpoint: Remote node control address (as 'multiaddr' or '<host>:<port>')
-        target-name: Resource name in APE resource name format
-        target-type: Resource type(container/namespace)
-        timeout: Timeout for an operation (default 15s)
-        wallet: Path to the wallet or binary key
-
-        Returns:
-            Command`s result.
-        """
-        return self._execute(
-            "control remove-rule",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )

src/frostfs_testlib/cli/frostfs_cli/netmap.py

@@ -8,7 +8,7 @@ class FrostfsCliNetmap(CliCommand):
     def epoch(
         self,
         rpc_endpoint: str,
-        wallet: Optional[str] = None,
+        wallet: str,
         address: Optional[str] = None,
         generate_key: bool = False,
         ttl: Optional[int] = None,
@@ -38,7 +38,7 @@ class FrostfsCliNetmap(CliCommand):
     def netinfo(
         self,
         rpc_endpoint: str,
-        wallet: Optional[str] = None,
+        wallet: str,
         address: Optional[str] = None,
         generate_key: bool = False,
         ttl: Optional[int] = None,
@@ -68,7 +68,7 @@ class FrostfsCliNetmap(CliCommand):
     def nodeinfo(
         self,
         rpc_endpoint: str,
-        wallet: Optional[str] = None,
+        wallet: str,
         address: Optional[str] = None,
         generate_key: bool = False,
         json: bool = False,
@@ -100,7 +100,7 @@ class FrostfsCliNetmap(CliCommand):
     def snapshot(
         self,
         rpc_endpoint: str,
-        wallet: Optional[str] = None,
+        wallet: str,
         address: Optional[str] = None,
         generate_key: bool = False,
         ttl: Optional[int] = None,

src/frostfs_testlib/cli/frostfs_cli/object.py

@@ -8,12 +8,11 @@ class FrostfsCliObject(CliCommand):
     def delete(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
         oid: str,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
         bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
         session: Optional[str] = None,
         ttl: Optional[int] = None,
         xhdr: Optional[dict] = None,
@@ -26,7 +25,6 @@ class FrostfsCliObject(CliCommand):
             address: Address of wallet account.
             bearer: File with signed JSON or binary encoded bearer token.
             cid: Container ID.
-            generate_key: Generate new private key.
             oid: Object ID.
             rpc_endpoint: Remote node address (as 'multiaddr' or '<host>:<port>').
             session: Filepath to a JSON- or binary-encoded token of the object DELETE session.
@@ -46,12 +44,11 @@ class FrostfsCliObject(CliCommand):
     def get(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
         oid: str,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
         bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
         file: Optional[str] = None,
         header: Optional[str] = None,
         no_progress: bool = False,
@@ -69,7 +66,6 @@ class FrostfsCliObject(CliCommand):
             bearer: File with signed JSON or binary encoded bearer token.
             cid: Container ID.
             file: File to write object payload to. Default: stdout.
-            generate_key: Generate new private key.
             header: File to write header to. Default: stdout.
             no_progress: Do not show progress bar.
             oid: Object ID.
@@ -92,12 +88,11 @@ class FrostfsCliObject(CliCommand):
     def hash(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
         oid: str,
-        wallet: Optional[str] = None,
         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,
@@ -113,7 +108,6 @@ class FrostfsCliObject(CliCommand):
             address: Address of wallet account.
             bearer: File with signed JSON or binary encoded bearer token.
             cid: Container ID.
-            generate_key: Generate new private key.
             oid: Object ID.
             range: Range to take hash from in the form offset1:length1,...
             rpc_endpoint: Remote node address (as 'multiaddr' or '<host>:<port>').
@@ -130,18 +124,19 @@ class FrostfsCliObject(CliCommand):
         """
         return self._execute(
             "object hash",
-            **{param: value for param, value in locals().items() if param not in ["self", "params"]},
+            **{
+                param: value for param, value in locals().items() if param not in ["self", "params"]
+            },
         )
 
     def head(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
         oid: str,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
         bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
         file: Optional[str] = None,
         json_mode: bool = False,
         main_only: bool = False,
@@ -160,7 +155,6 @@ class FrostfsCliObject(CliCommand):
             bearer: File with signed JSON or binary encoded bearer token.
             cid: Container ID.
             file: File to write object payload to. Default: stdout.
-            generate_key: Generate new private key.
             json_mode: Marshal output in JSON.
             main_only: Return only main fields.
             oid: Object ID.
@@ -184,14 +178,13 @@ class FrostfsCliObject(CliCommand):
     def lock(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
         oid: str,
-        wallet: Optional[str] = None,
         lifetime: Optional[int] = None,
         expire_at: Optional[int] = None,
         address: Optional[str] = None,
         bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
         session: Optional[str] = None,
         ttl: Optional[int] = None,
         xhdr: Optional[dict] = None,
@@ -204,7 +197,6 @@ class FrostfsCliObject(CliCommand):
             address: Address of wallet account.
             bearer: File with signed JSON or binary encoded bearer token.
             cid: Container ID.
-            generate_key: Generate new private key.
             oid: Object ID.
             lifetime: Lock lifetime.
             expire_at: Lock expiration epoch.
@@ -226,13 +218,12 @@ class FrostfsCliObject(CliCommand):
     def put(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
         file: str,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
         attributes: Optional[dict] = None,
         bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
         copies_number: Optional[int] = None,
         disable_filename: bool = False,
         disable_timestamp: bool = False,
@@ -257,7 +248,6 @@ class FrostfsCliObject(CliCommand):
             disable_timestamp: Do not set well-known timestamp attribute.
             expire_at: Last epoch in the life of the object.
             file: File with object payload.
-            generate_key: Generate new private key.
             no_progress: Do not show progress bar.
             notify: Object notification in the form of *epoch*:*topic*; '-'
                                 topic means using default.
@@ -279,13 +269,12 @@ class FrostfsCliObject(CliCommand):
     def range(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
         oid: str,
         range: str,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
         bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
         file: Optional[str] = None,
         json_mode: bool = False,
         raw: bool = False,
@@ -302,7 +291,6 @@ class FrostfsCliObject(CliCommand):
             bearer: File with signed JSON or binary encoded bearer token.
             cid: Container ID.
             file: File to write object payload to. Default: stdout.
-            generate_key: Generate new private key.
             json_mode: Marshal output in JSON.
             oid: Object ID.
             range: Range to take data from in the form offset:length.
@@ -325,11 +313,10 @@ class FrostfsCliObject(CliCommand):
     def search(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
         bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
         filters: Optional[list] = None,
         oid: Optional[str] = None,
         phy: bool = False,
@@ -347,7 +334,6 @@ class FrostfsCliObject(CliCommand):
             bearer: File with signed JSON or binary encoded bearer token.
             cid: Container ID.
             filters: Repeated filter expressions or files with protobuf JSON.
-            generate_key: Generate new private key.
             oid: Object ID.
             phy: Search physically stored objects.
             root: Search for user objects.
@@ -369,16 +355,15 @@ class FrostfsCliObject(CliCommand):
     def nodes(
         self,
         rpc_endpoint: str,
+        wallet: str,
         cid: str,
-        oid: Optional[str] = None,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
         bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
+        generate_key: Optional = None,
+        oid: Optional[str] = None,
         trace: bool = False,
         root: bool = False,
         verify_presence_all: bool = False,
-        json: bool = False,
         ttl: Optional[int] = None,
         xhdr: Optional[dict] = None,
         timeout: Optional[str] = None,

src/frostfs_testlib/cli/frostfs_cli/session.py

@@ -9,6 +9,7 @@ class FrostfsCliSession(CliCommand):
         self,
         rpc_endpoint: str,
         wallet: str,
+        wallet_password: str,
         out: str,
         lifetime: Optional[int] = None,
         address: Optional[str] = None,
@@ -29,7 +30,12 @@ class FrostfsCliSession(CliCommand):
         Returns:
             Command's result.
         """
-        return self._execute(
+        return self._execute_with_password(
             "session create",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
+            wallet_password,
+            **{
+                param: value
+                for param, value in locals().items()
+                if param not in ["self", "wallet_password"]
+            },
         )

src/frostfs_testlib/cli/frostfs_cli/shards.py

@@ -39,10 +39,10 @@ class FrostfsCliShards(CliCommand):
     def set_mode(
         self,
         endpoint: str,
+        wallet: str,
+        wallet_password: str,
         mode: str,
-        id: Optional[list[str]] = None,
+        id: Optional[list[str]],
-        wallet: Optional[str] = None,
-        wallet_password: Optional[str] = None,
         address: Optional[str] = None,
         all: bool = False,
         clear_errors: bool = False,
@@ -65,11 +65,6 @@ class FrostfsCliShards(CliCommand):
         Returns:
             Command's result.
         """
-        if not wallet_password:
-            return self._execute(
-                "control shards set-mode",
-                **{param: value for param, value in locals().items() if param not in ["self"]},
-            )
         return self._execute_with_password(
             "control shards set-mode",
             wallet_password,
@@ -142,120 +137,3 @@ class FrostfsCliShards(CliCommand):
             wallet_password,
             **{param: value for param, value in locals().items() if param not in ["self", "wallet_password"]},
         )
-
-    def evacuation_start(
-        self,
-        endpoint: str,
-        id: Optional[str] = None,
-        scope: Optional[str] = None,
-        all: bool = False,
-        no_errors: bool = True,
-        await_mode: bool = False,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-        no_progress: bool = False,
-    ) -> CommandResult:
-        """
-        Objects evacuation from shard to other shards.
-
-        Args:
-            address: Address of wallet account
-            all: Process all shards
-            await: Block execution until evacuation is completed
-            endpoint: Remote node control address (as 'multiaddr' or '<host>:<port>')
-            id: List of shard IDs in base58 encoding
-            no_errors: Skip invalid/unreadable objects (default true)
-            no_progress: Print progress if await provided
-            scope: Evacuation scope; possible values: trees, objects, all (default "all")
-            timeout: Timeout for an operation (default 15s)
-
-        Returns:
-            Command's result.
-        """
-        return self._execute(
-            "control shards evacuation start",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def evacuation_reset(
-        self,
-        endpoint: str,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """
-        Reset evacuate objects from shard to other shards status.
-
-        Args:
-            address: Address of wallet account
-            endpoint: Remote node control address (as 'multiaddr' or '<host>:<port>')
-            timeout: Timeout for an operation (default 15s)
-        Returns:
-            Command's result.
-        """
-        return self._execute(
-            "control shards evacuation reset",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def evacuation_stop(
-        self,
-        endpoint: str,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """
-        Stop running evacuate process from shard to other shards.
-
-        Args:
-            address: Address of wallet account
-            endpoint: Remote node control address (as 'multiaddr' or '<host>:<port>')
-            timeout: Timeout for an operation (default 15s)
-
-        Returns:
-            Command's result.
-        """
-        return self._execute(
-            "control shards evacuation stop",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def evacuation_status(
-        self,
-        endpoint: str,
-        address: Optional[str] = None,
-        timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """
-        Get evacuate objects from shard to other shards status.
-
-        Args:
-            address: Address of wallet account
-            endpoint: Remote node control address (as 'multiaddr' or '<host>:<port>')
-            timeout: Timeout for an operation (default 15s)
-
-        Returns:
-            Command's result.
-        """
-        return self._execute(
-            "control shards evacuation status",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )
-
-    def detach(self, endpoint: str, address: Optional[str] = None, id: Optional[str] = None, timeout: Optional[str] = None):
-        """
-        Detach and close the shards
-
-        Args:
-            address: Address of wallet account
-            endpoint: Remote node control address (as 'multiaddr' or '<host>:<port>')
-            id: List of shard IDs in base58 encoding
-            timeout: Timeout for an operation (default 15s)
-
-        Returns:
-            Command's result.
-        """
-        return self._execute(
-            "control shards detach",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )

src/frostfs_testlib/cli/frostfs_cli/tree.py

@@ -27,27 +27,3 @@ class FrostfsCliTree(CliCommand):
             "tree healthcheck",
             **{param: value for param, value in locals().items() if param not in ["self"]},
         )
-    
-    def list(
-            self,
-            cid: str,
-            rpc_endpoint: Optional[str] = None,
-            wallet: Optional[str] = None,
-            timeout: Optional[str] = None,
-    ) -> CommandResult:
-        """Get Tree List
-
-        Args:
-            cid: Container ID.
-            rpc_endpoint: Remote node address (as 'multiaddr' or '<host>:<port>').
-            wallet: WIF (NEP-2) string or path to the wallet or binary key.
-            timeout: duration Timeout for the operation (default 15 s)
-
-        Returns:
-            Command's result.
-
-        """
-        return self._execute(
-            "tree list",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )

src/frostfs_testlib/cli/frostfs_cli/util.py

@@ -6,12 +6,12 @@ from frostfs_testlib.shell import CommandResult
 
 class FrostfsCliUtil(CliCommand):
     def sign_bearer_token(
-        self,
+            self,
-        from_file: str,
+            wallet: str,
-        to_file: str,
+            from_file: str,
-        wallet: Optional[str] = None,
+            to_file: str,
-        address: Optional[str] = None,
+            address: Optional[str] = None,
-        json: Optional[bool] = False,
+            json: Optional[bool] = False,
     ) -> CommandResult:
         """
         Sign bearer token to use it in requests.
@@ -33,9 +33,9 @@ class FrostfsCliUtil(CliCommand):
 
     def sign_session_token(
         self,
+        wallet: str,
         from_file: str,
         to_file: str,
-        wallet: Optional[str] = None,
         address: Optional[str] = None,
     ) -> CommandResult:
         """
@@ -54,11 +54,3 @@ class FrostfsCliUtil(CliCommand):
             "util sign session-token",
             **{param: value for param, value in locals().items() if param not in ["self"]},
         )
-
-    def convert_eacl(self, from_file: str, to_file: str, json: Optional[bool] = False, ape: Optional[bool] = False):
-        """Convert representation of extended ACL table."""
-
-        return self._execute(
-            "util convert eacl",
-            **{param: value for param, value in locals().items() if param not in ["self"]},
-        )

src/frostfs_testlib/cli/generic_cli.py

@@ -1,30 +0,0 @@
-from typing import Optional
-
-from frostfs_testlib.hosting.interfaces import Host
-from frostfs_testlib.shell.interfaces import CommandOptions, Shell
-
-
-class GenericCli(object):
-    def __init__(self, cli_name: str, host: Host) -> None:
-        self.host = host
-        self.cli_name = cli_name
-
-    def __call__(
-        self,
-        args: Optional[str] = "",
-        pipes: Optional[str] = "",
-        shell: Optional[Shell] = None,
-        options: Optional[CommandOptions] = None,
-    ):
-        if not shell:
-            shell = self.host.get_shell()
-
-        cli_config = self.host.get_cli_config(self.cli_name, True)
-        extra_args = ""
-        exec_path = self.cli_name
-        if cli_config:
-            extra_args = " ".join(cli_config.extra_args)
-            exec_path = cli_config.exec_path
-
-        cmd = f"{exec_path} {args} {extra_args} {pipes}"
-        return shell.exec(cmd, options)

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 NodeNetInfo, NodeNetmapInfo, NodeStatus
+from frostfs_testlib.storage.dataclasses.storage_object_info import NodeNetInfo, NodeNetmapInfo
 
 
 class NetmapParser:
@@ -15,8 +15,6 @@ class NetmapParser:
             "epoch_duration": r"Epoch duration: (?P<epoch_duration>\d+)",
             "inner_ring_candidate_fee": r"Inner Ring candidate fee: (?P<inner_ring_candidate_fee>\d+)",
             "maximum_object_size": r"Maximum object size: (?P<maximum_object_size>\d+)",
-            "maximum_count_of_data_shards": r"Maximum count of data shards: (?P<maximum_count_of_data_shards>\d+)",
-            "maximum_count_of_parity_shards": r"Maximum count of parity shards: (?P<maximum_count_of_parity_shards>\d+)",
             "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)",
@@ -46,7 +44,7 @@ class NetmapParser:
         regexes = {
             "node_id": r"\d+: (?P<node_id>\w+)",
             "node_data_ips": r"(?P<node_data_ips>/ip4/.+?)$",
-            "node_status": r"(?P<node_status>ONLINE|MAINTENANCE|OFFLINE)",
+            "node_status": r"(?P<node_status>ONLINE|OFFLINE)",
             "cluster_name": r"ClusterName: (?P<cluster_name>\w+)",
             "continent": r"Continent: (?P<continent>\w+)",
             "country": r"Country: (?P<country>\w+)",
@@ -64,17 +62,14 @@ 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:
-                    result_netmap[key] = None
-                    continue
                 if key == "node_data_ips":
                     result_netmap[key] = search_result[key].strip().split(" ")
                     continue
                 if key == "external_address":
                     result_netmap[key] = search_result[key].strip().split(",")
                     continue
-                if key == "node_status":
+                if search_result == None:
-                    result_netmap[key] = NodeStatus(search_result[key].strip().lower())
+                    result_netmap[key] = None
                     continue
                 result_netmap[key] = search_result[key].strip()
 

src/frostfs_testlib/credentials/authmate_s3_provider.py

@@ -1,47 +0,0 @@
-import re
-from typing import Optional
-
-from frostfs_testlib import reporter
-from frostfs_testlib.cli import FrostfsAuthmate
-from frostfs_testlib.credentials.interfaces import S3Credentials, S3CredentialsProvider, User
-from frostfs_testlib.resources.cli import FROSTFS_AUTHMATE_EXEC
-from frostfs_testlib.shell import LocalShell
-from frostfs_testlib.steps.cli.container import list_containers
-from frostfs_testlib.storage.cluster import ClusterNode
-from frostfs_testlib.storage.dataclasses.frostfs_services import S3Gate
-from frostfs_testlib.utils import string_utils
-
-
-class AuthmateS3CredentialsProvider(S3CredentialsProvider):
-    @reporter.step("Init S3 Credentials using Authmate CLI")
-    def provide(self, user: User, cluster_node: ClusterNode, location_constraints: Optional[str] = None) -> S3Credentials:
-        cluster_nodes: list[ClusterNode] = self.cluster.cluster_nodes
-        shell = LocalShell()
-        wallet = user.wallet
-        endpoint = cluster_node.storage_node.get_rpc_endpoint()
-
-        gate_public_keys = [node.service(S3Gate).get_wallet_public_key() for node in cluster_nodes]
-        # unique short bucket name
-        bucket = string_utils.unique_name("bucket-")
-
-        frostfs_authmate: FrostfsAuthmate = FrostfsAuthmate(shell, FROSTFS_AUTHMATE_EXEC)
-        issue_secret_output = frostfs_authmate.secret.issue(
-            wallet=wallet.path,
-            peer=endpoint,
-            gate_public_key=gate_public_keys,
-            wallet_password=wallet.password,
-            container_policy=location_constraints,
-            container_friendly_name=bucket,
-        ).stdout
-
-        aws_access_key_id = str(re.search(r"access_key_id.*:\s.(?P<aws_access_key_id>\w*)", issue_secret_output).group("aws_access_key_id"))
-        aws_secret_access_key = str(
-            re.search(r"secret_access_key.*:\s.(?P<aws_secret_access_key>\w*)", issue_secret_output).group("aws_secret_access_key")
-        )
-        cid = str(re.search(r"container_id.*:\s.(?P<container_id>\w*)", issue_secret_output).group("container_id"))
-
-        containers_list = list_containers(wallet, shell, endpoint)
-        assert cid in containers_list, f"Expected cid {cid} in {containers_list}"
-
-        user.s3_credentials = S3Credentials(aws_access_key_id, aws_secret_access_key)
-        return user.s3_credentials

src/frostfs_testlib/credentials/interfaces.py

@@ -1,51 +0,0 @@
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from typing import Any, Optional
-
-from frostfs_testlib.plugins import load_plugin
-from frostfs_testlib.storage.cluster import Cluster, ClusterNode
-from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
-
-
-@dataclass
-class S3Credentials:
-    access_key: str
-    secret_key: str
-
-
-@dataclass
-class User:
-    name: str
-    attributes: dict[str, Any] = field(default_factory=dict)
-    wallet: WalletInfo | None = None
-    s3_credentials: S3Credentials | None = None
-
-
-class S3CredentialsProvider(ABC):
-    def __init__(self, cluster: Cluster) -> None:
-        self.cluster = cluster
-
-    @abstractmethod
-    def provide(self, user: User, cluster_node: ClusterNode, location_constraints: Optional[str] = None, **kwargs) -> S3Credentials:
-        raise NotImplementedError("Directly called abstract class?")
-
-
-class GrpcCredentialsProvider(ABC):
-    def __init__(self, cluster: Cluster) -> None:
-        self.cluster = cluster
-
-    @abstractmethod
-    def provide(self, user: User, cluster_node: ClusterNode, **kwargs) -> WalletInfo:
-        raise NotImplementedError("Directly called abstract class?")
-
-
-class CredentialsProvider(object):
-    S3: S3CredentialsProvider
-    GRPC: GrpcCredentialsProvider
-
-    def __init__(self, cluster: Cluster) -> None:
-        config = cluster.cluster_nodes[0].host.config
-        s3_cls = load_plugin("frostfs.testlib.credentials_providers", config.s3_creds_plugin_name)
-        self.S3 = s3_cls(cluster)
-        grpc_cls = load_plugin("frostfs.testlib.credentials_providers", config.grpc_creds_plugin_name)
-        self.GRPC = grpc_cls(cluster)

src/frostfs_testlib/credentials/wallet_factory_provider.py

@@ -1,14 +0,0 @@
-from frostfs_testlib import reporter
-from frostfs_testlib.credentials.interfaces import GrpcCredentialsProvider, User
-from frostfs_testlib.resources.common import ASSETS_DIR, DEFAULT_WALLET_PASS
-from frostfs_testlib.shell.local_shell import LocalShell
-from frostfs_testlib.storage.cluster import ClusterNode
-from frostfs_testlib.storage.dataclasses.wallet import WalletFactory, WalletInfo
-
-
-class WalletFactoryProvider(GrpcCredentialsProvider):
-    @reporter.step("Init gRPC Credentials using wallet generation")
-    def provide(self, user: User, cluster_node: ClusterNode) -> WalletInfo:
-        wallet_factory = WalletFactory(ASSETS_DIR, LocalShell())
-        user.wallet = wallet_factory.create_wallet(file_name=user.name, password=DEFAULT_WALLET_PASS)
-        return user.wallet

src/frostfs_testlib/defaults.py

@@ -1,5 +1,5 @@
 class Options:
-    DEFAULT_SHELL_TIMEOUT = 120
+    DEFAULT_SHELL_TIMEOUT = 90
 
     @staticmethod
     def get_default_shell_timeout():

src/frostfs_testlib/fixtures.py

@@ -1,45 +0,0 @@
-import logging
-import os
-from importlib.metadata import entry_points
-
-import pytest
-import yaml
-
-from frostfs_testlib import reporter
-from frostfs_testlib.hosting.hosting import Hosting
-from frostfs_testlib.resources.common import ASSETS_DIR, HOSTING_CONFIG_FILE
-from frostfs_testlib.storage import get_service_registry
-
-
-@pytest.fixture(scope="session")
-def configure_testlib():
-    reporter.get_reporter().register_handler(reporter.AllureHandler())
-    reporter.get_reporter().register_handler(reporter.StepsLogger())
-    logging.getLogger("paramiko").setLevel(logging.INFO)
-
-    # Register Services for cluster
-    registry = get_service_registry()
-    services = entry_points(group="frostfs.testlib.services")
-    for svc in services:
-        registry.register_service(svc.name, svc.load())
-
-
-@pytest.fixture(scope="session")
-def temp_directory(configure_testlib):
-    with reporter.step("Prepare tmp directory"):
-        full_path = ASSETS_DIR
-        if not os.path.exists(full_path):
-            os.mkdir(full_path)
-
-    return full_path
-
-
-@pytest.fixture(scope="session")
-def hosting(configure_testlib) -> Hosting:
-    with open(HOSTING_CONFIG_FILE, "r") as file:
-        hosting_config = yaml.full_load(file)
-
-    hosting_instance = Hosting()
-    hosting_instance.configure(hosting_config)
-
-    return hosting_instance

src/frostfs_testlib/healthcheck/basic_healthcheck.py

@@ -47,14 +47,6 @@ class BasicHealthcheck(Healthcheck):
 
         self._perform(cluster_node, checks)
 
-    @wait_for_success(900, 30, title="Wait for tree healthcheck on {cluster_node}")
-    def tree_healthcheck(self, cluster_node: ClusterNode) -> str | None:
-        checks = {
-            self._tree_healthcheck: {},
-        }
-
-        self._perform(cluster_node, checks)
-
     @wait_for_success(120, 5, title="Wait for service healthcheck on {cluster_node}")
     def services_healthcheck(self, cluster_node: ClusterNode):
         svcs_to_check = cluster_node.services

src/frostfs_testlib/healthcheck/interfaces.py

@@ -19,7 +19,3 @@ class Healthcheck(ABC):
     @abstractmethod
     def services_healthcheck(self, cluster_node: ClusterNode):
         """Perform service status check on target cluster node"""
-
-    @abstractmethod
-    def tree_healthcheck(self, cluster_node: ClusterNode):
-        """Perform tree healthcheck on target cluster node"""

src/frostfs_testlib/hooks.py

@@ -1,13 +0,0 @@
-import pytest
-
-
-@pytest.hookimpl
-def pytest_collection_modifyitems(items: list[pytest.Item]):
-    # All tests which reside in frostfs nodeid are granted with frostfs marker, excluding
-    # nodeid = full path of the test
-    # 1. plugins
-    # 2. testlib itself
-    for item in items:
-        location = item.location[0]
-        if "frostfs" in location and "plugin" not in location and "testlib" not in location:
-            item.add_marker("frostfs")

src/frostfs_testlib/hosting/config.py

@@ -10,7 +10,9 @@ class ParsedAttributes:
     def parse(cls, attributes: dict[str, Any]):
         # Pick attributes supported by the class
         field_names = set(field.name for field in fields(cls))
-        supported_attributes = {key: value for key, value in attributes.items() if key in field_names}
+        supported_attributes = {
+            key: value for key, value in attributes.items() if key in field_names
+        }
         return cls(**supported_attributes)
 
 
@@ -27,7 +29,6 @@ class CLIConfig:
     name: str
     exec_path: str
     attributes: dict[str, str] = field(default_factory=dict)
-    extra_args: list[str] = field(default_factory=list)
 
 
 @dataclass
@@ -60,12 +61,8 @@ class HostConfig:
     """
 
     plugin_name: str
-    hostname: str
     healthcheck_plugin_name: str
     address: str
-    s3_creds_plugin_name: str = field(default="authmate")
-    grpc_creds_plugin_name: str = field(default="wallet_factory")
-    product: str = field(default="frostfs")
     services: list[ServiceConfig] = field(default_factory=list)
     clis: list[CLIConfig] = field(default_factory=list)
     attributes: dict[str, str] = field(default_factory=dict)

src/frostfs_testlib/hosting/docker_host.py

@@ -164,9 +164,6 @@ class DockerHost(Host):
 
         return volume_path
 
-    def send_signal_to_service(self, service_name: str, signal: str) -> None:
-        raise NotImplementedError("Not implemented for docker")
-
     def delete_metabase(self, service_name: str) -> None:
         raise NotImplementedError("Not implemented for docker")
 
@@ -188,12 +185,6 @@ class DockerHost(Host):
     def is_file_exist(self, file_path: str) -> None:
         raise NotImplementedError("Not implemented for docker")
 
-    def wipefs_storage_node_data(self, service_name: str) -> None:
-        raise NotImplementedError("Not implemented for docker")
-
-    def finish_wipefs(self, service_name: str) -> None:
-        raise NotImplementedError("Not implemented for docker")
-
     def delete_storage_node_data(self, service_name: str, cache_only: bool = False) -> None:
         volume_path = self.get_data_directory(service_name)
 
@@ -249,7 +240,6 @@ class DockerHost(Host):
         until: Optional[datetime] = None,
         unit: Optional[str] = None,
         exclude_filter: Optional[str] = None,
-        priority: Optional[str] = None,
     ) -> str:
         client = self._get_docker_client()
         filtered_logs = ""

src/frostfs_testlib/hosting/interfaces.py

@@ -54,7 +54,7 @@ class Host(ABC):
             raise ValueError(f"Unknown service name: '{service_name}'")
         return service_config
 
-    def get_cli_config(self, cli_name: str, allow_empty: bool = False) -> CLIConfig:
+    def get_cli_config(self, cli_name: str) -> CLIConfig:
         """Returns config of CLI tool with specified name.
 
         The CLI must be located on this host.
@@ -66,7 +66,7 @@ class Host(ABC):
             Config of the CLI tool.
         """
         cli_config = self._cli_config_by_name.get(cli_name)
-        if cli_config is None and not allow_empty:
+        if cli_config is None:
             raise ValueError(f"Unknown CLI name: '{cli_name}'")
         return cli_config
 
@@ -117,17 +117,6 @@ class Host(ABC):
             service_name: Name of the service to stop.
         """
 
-    @abstractmethod
-    def send_signal_to_service(self, service_name: str, signal: str) -> None:
-        """Send signal to service with specified name using kill -<signal>
-
-        The service must be hosted on this host.
-
-        Args:
-            service_name: Name of the service to stop.
-            signal: signal name. See kill -l to all names
-        """
-
     @abstractmethod
     def mask_service(self, service_name: str) -> None:
         """Prevent the service from start by any activity by masking it.
@@ -189,21 +178,6 @@ class Host(ABC):
             cache_only: To delete cache only.
         """
 
-    @abstractmethod
-    def wipefs_storage_node_data(self, service_name: str) -> None:
-        """Erases all data of the storage node with specified name.
-
-        Args:
-            service_name: Name of storage node service.
-        """
-
-    def finish_wipefs(self, service_name: str) -> None:
-        """Erases all data of the storage node with specified name.
-
-        Args:
-            service_name: Name of storage node service.
-        """
-
     @abstractmethod
     def delete_fstree(self, service_name: str) -> None:
         """
@@ -323,7 +297,6 @@ class Host(ABC):
         until: Optional[datetime] = None,
         unit: Optional[str] = None,
         exclude_filter: Optional[str] = None,
-        priority: Optional[str] = None,
     ) -> str:
         """Get logs from host filtered by regex.
 
@@ -332,8 +305,6 @@ class Host(ABC):
             since: If set, limits the time from which logs should be collected. Must be in UTC.
             until: If set, limits the time until which logs should be collected. Must be in UTC.
             unit: required unit.
-            priority: logs level, 0 - emergency, 7 - debug. All messages with that code and higher.
-            For example, if we specify the -p 2 option, journalctl will show all messages with levels 2, 1 and 0.
 
         Returns:
             Found entries as str if any found.

src/frostfs_testlib/http/http_client.py

@@ -1,97 +0,0 @@
-import json
-import logging
-import logging.config
-
-import httpx
-
-from frostfs_testlib import reporter
-
-timeout = httpx.Timeout(60, read=150)
-LOGGING_CONFIG = {
-    "disable_existing_loggers": False,
-    "version": 1,
-    "handlers": {"default": {"class": "logging.StreamHandler", "formatter": "http", "stream": "ext://sys.stderr"}},
-    "formatters": {
-        "http": {
-            "format": "%(levelname)s [%(asctime)s] %(name)s - %(message)s",
-            "datefmt": "%Y-%m-%d %H:%M:%S",
-        }
-    },
-    "loggers": {
-        "httpx": {
-            "handlers": ["default"],
-            "level": "DEBUG",
-        },
-        "httpcore": {
-            "handlers": ["default"],
-            "level": "ERROR",
-        },
-    },
-}
-
-logging.config.dictConfig(LOGGING_CONFIG)
-logger = logging.getLogger("NeoLogger")
-
-
-class HttpClient:
-    @reporter.step("Send {method} request to {url}")
-    def send(self, method: str, url: str, expected_status_code: int = None, **kwargs: dict) -> httpx.Response:
-        transport = httpx.HTTPTransport(verify=False, retries=5)
-        client = httpx.Client(timeout=timeout, transport=transport)
-        response = client.request(method, url, **kwargs)
-
-        self._attach_response(response)
-        logger.info(f"Response: {response.status_code} => {response.text}")
-
-        if expected_status_code:
-            assert response.status_code == expected_status_code, (
-                f"Got {response.status_code} response code" f" while {expected_status_code} expected"
-            )
-
-        return response
-
-    @classmethod
-    def _attach_response(cls, response: httpx.Response):
-        request = response.request
-
-        try:
-            request_headers = json.dumps(dict(request.headers), indent=4)
-        except json.JSONDecodeError:
-            request_headers = str(request.headers)
-
-        try:
-            request_body = request.read()
-            try:
-                request_body = request_body.decode("utf-8")
-            except UnicodeDecodeError as e:
-                request_body = f"Unable to decode binary data to text using UTF-8 encoding: {str(e)}"
-        except Exception as e:
-            request_body = f"Error reading request body: {str(e)}"
-
-        request_body = "" if request_body is None else request_body
-
-        try:
-            response_headers = json.dumps(dict(response.headers), indent=4)
-        except json.JSONDecodeError:
-            response_headers = str(response.headers)
-
-        report = (
-            f"Method: {request.method}\n\n"
-            f"URL: {request.url}\n\n"
-            f"Request Headers: {request_headers}\n\n"
-            f"Request Body: {request_body}\n\n"
-            f"Response Status Code: {response.status_code}\n\n"
-            f"Response Headers: {response_headers}\n\n"
-            f"Response Body: {response.text}\n\n"
-        )
-        curl_request = cls._create_curl_request(request.url, request.method, request.headers, request_body)
-
-        reporter.attach(report, "Requests Info")
-        reporter.attach(curl_request, "CURL")
-
-    @classmethod
-    def _create_curl_request(cls, url: str, method: str, headers: httpx.Headers, data: str) -> str:
-        headers = " ".join(f'-H "{name.title()}: {value}"' for name, value in headers.items())
-        data = f" -d '{data}'" if data else ""
-        # Option -k means no verify SSL
-        return f"curl {url} -X {method} {headers}{data} -k"

src/frostfs_testlib/load/interfaces/scenario_runner.py

@@ -1,6 +1,5 @@
 from abc import ABC, abstractmethod
 
-from frostfs_testlib.load.interfaces.loader import Loader
 from frostfs_testlib.load.k6 import K6
 from frostfs_testlib.load.load_config import LoadParams
 from frostfs_testlib.storage.cluster import ClusterNode
@@ -49,7 +48,3 @@ class ScenarioRunner(ABC):
     @abstractmethod
     def get_results(self) -> dict:
         """Get results from K6 run"""
-
-    @abstractmethod
-    def get_loaders(self) -> list[Loader]:
-        """Return loaders"""

src/frostfs_testlib/load/interfaces/summarized.py

@@ -50,7 +50,6 @@ class SummarizedStats:
     throughput: float = field(default_factory=float)
     latencies: SummarizedLatencies = field(default_factory=SummarizedLatencies)
     errors: SummarizedErorrs = field(default_factory=SummarizedErorrs)
-    total_bytes: int = field(default_factory=int)
     passed: bool = True
 
     def calc_stats(self):
@@ -86,7 +85,6 @@ class SummarizedStats:
                 target.latencies.by_node[node_key] = operation.latency
                 target.throughput += operation.throughput
                 target.errors.threshold = load_params.error_threshold
-                target.total_bytes += operation.total_bytes
                 if operation.failed_iterations:
                     target.errors.by_node[node_key] = operation.failed_iterations
 

src/frostfs_testlib/load/k6.py

@@ -4,19 +4,18 @@ import math
 import os
 from dataclasses import dataclass
 from datetime import datetime
-from threading import Event
 from time import sleep
 from typing import Any
 from urllib.parse import urlparse
 
 from frostfs_testlib import reporter
-from frostfs_testlib.credentials.interfaces import User
 from frostfs_testlib.load.interfaces.loader import Loader
 from frostfs_testlib.load.load_config import K6ProcessAllocationStrategy, LoadParams, LoadScenario, LoadType
 from frostfs_testlib.processes.remote_process import RemoteProcess
 from frostfs_testlib.resources.common import STORAGE_USER_NAME
 from frostfs_testlib.resources.load_params import K6_STOP_SIGNAL_TIMEOUT, K6_TEARDOWN_PERIOD
 from frostfs_testlib.shell import Shell
+from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
 from frostfs_testlib.testing.test_control import wait_for_success
 
 EXIT_RESULT_CODE = 0
@@ -43,16 +42,16 @@ class K6:
         k6_dir: str,
         shell: Shell,
         loader: Loader,
-        user: User,
+        wallet: WalletInfo,
     ):
         if load_params.scenario is None:
             raise RuntimeError("Scenario should not be none")
 
-        self.load_params = load_params
+        self.load_params: LoadParams = load_params
         self.endpoints = endpoints
-        self.loader = loader
+        self.loader: Loader = loader
-        self.shell = shell
+        self.shell: Shell = shell
-        self.user = user
+        self.wallet = wallet
         self.preset_output: str = ""
         self.summary_json: str = os.path.join(
             self.load_params.working_dir,
@@ -62,22 +61,26 @@ class K6:
         self._k6_dir: str = k6_dir
 
         command = (
-            f"{self._generate_env_variables()}{self._k6_dir}/k6 run {self._generate_k6_variables()} "
+            f"{self._k6_dir}/k6 run {self._generate_env_variables()} "
             f"{self._k6_dir}/scenarios/{self.load_params.scenario.value}.js"
         )
-        remote_user = STORAGE_USER_NAME if self.load_params.scenario == LoadScenario.LOCAL else None
+        user = STORAGE_USER_NAME if self.load_params.scenario == LoadScenario.LOCAL else None
-        process_id = self.load_params.load_id if self.load_params.scenario != LoadScenario.VERIFY else f"{self.load_params.load_id}_verify"
+        process_id = (
-        self._k6_process = RemoteProcess.create(command, self.shell, self.load_params.working_dir, remote_user, process_id)
+            self.load_params.load_id
+            if self.load_params.scenario != LoadScenario.VERIFY
+            else f"{self.load_params.load_id}_verify"
+        )
+        self._k6_process = RemoteProcess.create(command, self.shell, self.load_params.working_dir, user, process_id)
 
     def _get_fill_percents(self):
-        fill_percents = self.shell.exec("df -H --output=source,pcent,target | grep frostfs | grep data").stdout.split("\n")
+        fill_percents = self.shell.exec("df -H --output=source,pcent,target | grep frostfs").stdout.split("\n")
         return [line.split() for line in fill_percents][:-1]
     
     def check_fill_percent(self):
         fill_percents = self._get_fill_percents()
         percent_mean = 0
         for line in fill_percents:
-            percent_mean += float(line[1].split("%")[0])
+            percent_mean += float(line[1].split('%')[0])
         percent_mean = percent_mean / len(fill_percents)
         logger.info(f"{self.loader.ip} mean fill percent is {percent_mean}")
         return percent_mean >= self.load_params.fill_percent
@@ -100,8 +103,8 @@ class K6:
                 preset_grpc: [
                     preset_grpc,
                     f"--endpoint {','.join(self.endpoints)}",
-                    f"--wallet {self.user.wallet.path} ",
+                    f"--wallet {self.wallet.path} ",
-                    f"--config {self.user.wallet.config_path} ",
+                    f"--config {self.wallet.config_path} ",
                 ],
                 preset_s3: [
                     preset_s3,
@@ -122,9 +125,9 @@ class K6:
             self.preset_output = result.stdout.strip("\n")
             return self.preset_output
 
-    @reporter.step("Generate K6 variables")
+    @reporter.step("Generate K6 command")
-    def _generate_k6_variables(self) -> str:
+    def _generate_env_variables(self) -> str:
-        env_vars = self.load_params.get_k6_vars()
+        env_vars = self.load_params.get_env_vars()
 
         env_vars[f"{self.load_params.load_type.value.upper()}_ENDPOINTS"] = ",".join(self.endpoints)
         env_vars["SUMMARY_JSON"] = self.summary_json
@@ -132,14 +135,6 @@ class K6:
         reporter.attach("\n".join(f"{param}: {value}" for param, value in env_vars.items()), "K6 ENV variables")
         return " ".join([f"-e {param}='{value}'" for param, value in env_vars.items() if value is not None])
 
-    @reporter.step("Generate env variables")
-    def _generate_env_variables(self) -> str:
-        env_vars = self.load_params.get_env_vars()
-        if not env_vars:
-            return ""
-        reporter.attach("\n".join(f"{param}: {value}" for param, value in env_vars.items()), "ENV variables")
-        return " ".join([f"{param}='{value}'" for param, value in env_vars.items() if value is not None]) + " "
-
     def get_start_time(self) -> datetime:
         return datetime.fromtimestamp(self._k6_process.start_time())
 
@@ -150,7 +145,7 @@ class K6:
         with reporter.step(f"Start load from loader {self.loader.ip} on endpoints {self.endpoints}"):
             self._k6_process.start()
 
-    def wait_until_finished(self, event: Event, soft_timeout: int = 0) -> None:
+    def wait_until_finished(self, event, soft_timeout: int = 0) -> None:
         with reporter.step(f"Wait until load is finished from loader {self.loader.ip} on endpoints {self.endpoints}"):
             if self.load_params.scenario == LoadScenario.VERIFY:
                 timeout = self.load_params.verify_time or 0
@@ -164,7 +159,9 @@ class K6:
             remaining_time = timeout - working_time
 
             setup_teardown_time = (
-                int(K6_TEARDOWN_PERIOD) + self.load_params.get_init_time() + int(self.load_params.setup_timeout.replace("s", "").strip())
+                int(K6_TEARDOWN_PERIOD)
+                + self.load_params.get_init_time()
+                + int(self.load_params.setup_timeout.replace("s", "").strip())
             )
             remaining_time_including_setup_and_teardown = remaining_time + setup_teardown_time
             timeout = remaining_time_including_setup_and_teardown

src/frostfs_testlib/load/load_config.py

@@ -25,16 +25,6 @@ def convert_time_to_seconds(time: int | str | None) -> int:
     return seconds
 
 
-def force_list(input: str | list[str]):
-    if input is None:
-        return None
-
-    if isinstance(input, list):
-        return list(map(str.strip, input))
-
-    return [input.strip()]
-
-
 class LoadType(Enum):
     gRPC = "grpc"
     S3 = "s3"
@@ -104,18 +94,16 @@ def metadata_field(
     string_repr: Optional[bool] = True,
     distributed: Optional[bool] = False,
     formatter: Optional[Callable] = None,
-    env_variable: Optional[str] = None,
 ):
     return field(
         default=None,
         metadata={
             "applicable_scenarios": applicable_scenarios,
             "preset_argument": preset_param,
-            "scenario_variable": scenario_variable,
+            "env_variable": scenario_variable,
             "string_repr": string_repr,
             "distributed": distributed,
             "formatter": formatter,
-            "env_variable": env_variable,
         },
     )
 
@@ -129,8 +117,6 @@ class NodesSelectionStrategy(Enum):
     ALL_EXCEPT_UNDER_TEST = "ALL_EXCEPT_UNDER_TEST"
     # Select ONE random node except under test (useful for failover).
     RANDOM_SINGLE_EXCEPT_UNDER_TEST = "RANDOM_SINGLE_EXCEPT_UNDER_TEST"
-    # Select node under test
-    NODE_UNDER_TEST = "NODE_UNDER_TEST"
 
 
 class EndpointSelectionStrategy(Enum):
@@ -152,29 +138,8 @@ class K6ProcessAllocationStrategy(Enum):
     PER_ENDPOINT = "PER_ENDPOINT"
 
 
-class MetaConfig:
-    def _get_field_formatter(self, field_name: str) -> Callable | None:
-        data_fields = fields(self)
-        formatters = [
-            field.metadata["formatter"]
-            for field in data_fields
-            if field.name == field_name and "formatter" in field.metadata and field.metadata["formatter"] != None
-        ]
-        if formatters:
-            return formatters[0]
-
-        return None
-
-    def __setattr__(self, field_name, value):
-        formatter = self._get_field_formatter(field_name)
-        if formatter:
-            value = formatter(value)
-
-        super().__setattr__(field_name, value)
-
-
 @dataclass
-class Preset(MetaConfig):
+class Preset:
     # ------ COMMON ------
     # Amount of objects which should be created
     objects_count: Optional[int] = metadata_field(all_load_scenarios, "preload_obj", None, False)
@@ -182,22 +147,18 @@ class Preset(MetaConfig):
     pregen_json: Optional[str] = metadata_field(all_load_scenarios, "out", "PREGEN_JSON", False)
     # Workers count for preset
     workers: Optional[int] = metadata_field(all_load_scenarios, "workers", None, False)
-    # Acl for container/buckets
-    acl: Optional[str] = metadata_field(all_load_scenarios, "acl", None, False)
 
     # ------ GRPC ------
     # Amount of containers which should be created
     containers_count: Optional[int] = metadata_field(grpc_preset_scenarios, "containers", None, False)
     # Container placement policy for containers for gRPC
-    container_placement_policy: Optional[list[str]] = metadata_field(grpc_preset_scenarios, "policy", None, False, formatter=force_list)
+    container_placement_policy: Optional[str] = metadata_field(grpc_preset_scenarios, "policy", None, False)
-    # Number of retries for creation of container
-    container_creation_retry: Optional[int] = metadata_field(grpc_preset_scenarios, "retry", None, False)
 
     # ------ S3 ------
     # Amount of buckets which should be created
     buckets_count: Optional[int] = metadata_field(s3_preset_scenarios, "buckets", None, False)
     # S3 region (AKA placement policy for S3 buckets)
-    s3_location: Optional[list[str]] = metadata_field(s3_preset_scenarios, "location", None, False, formatter=force_list)
+    s3_location: Optional[str] = metadata_field(s3_preset_scenarios, "location", None, False)
 
     # Delay between containers creation and object upload for preset
     object_upload_delay: Optional[int] = metadata_field(all_load_scenarios, "sleep", None, False)
@@ -205,22 +166,9 @@ class Preset(MetaConfig):
     # Flag to control preset erorrs
     ignore_errors: Optional[bool] = metadata_field(all_load_scenarios, "ignore-errors", None, False)
 
-    # Flag to ensure created containers store data on local endpoints
-    local: Optional[bool] = metadata_field(grpc_preset_scenarios, "local", None, False)
-
 
 @dataclass
-class PrometheusParams(MetaConfig):
+class LoadParams:
-    # Prometheus server URL
-    server_url: Optional[str] = metadata_field(all_load_scenarios, env_variable="K6_PROMETHEUS_RW_SERVER_URL", string_repr=False)
-    # Prometheus trend stats
-    trend_stats: Optional[str] = metadata_field(all_load_scenarios, env_variable="K6_PROMETHEUS_RW_TREND_STATS", string_repr=False)
-    # Additional tags
-    metrics_tags: Optional[str] = metadata_field(all_load_scenarios, None, "METRIC_TAGS", False)
-
-
-@dataclass
-class LoadParams(MetaConfig):
     # ------- CONTROL PARAMS -------
     # Load type can be gRPC, HTTP, S3.
     load_type: LoadType
@@ -268,18 +216,12 @@ class LoadParams(MetaConfig):
     )
     # Percentage of filling of all data disks on all nodes
     fill_percent: Optional[float] = None
-    # if specified, max payload size in GB of the storage engine. If the storage engine is already full, no new objects will be saved.
-    max_total_size_gb: Optional[float] = metadata_field([LoadScenario.LOCAL, LoadScenario.S3_LOCAL], None, "MAX_TOTAL_SIZE_GB")
-    # if set, the payload is generated on the fly and is not read into memory fully.
-    streaming: Optional[int] = metadata_field(all_load_scenarios, None, "STREAMING", False)
-    # Output format
-    output: Optional[str] = metadata_field(all_load_scenarios, None, "K6_OUT", False)
-    # Prometheus params
-    prometheus: Optional[PrometheusParams] = None
 
     # ------- COMMON SCENARIO PARAMS -------
     # Load time is the maximum duration for k6 to give load. Default is the BACKGROUND_LOAD_DEFAULT_TIME value.
-    load_time: Optional[int] = metadata_field(all_load_scenarios, None, "DURATION", False, formatter=convert_time_to_seconds)
+    load_time: Optional[int] = metadata_field(
+        all_load_scenarios, None, "DURATION", False, formatter=convert_time_to_seconds
+    )
     # Object size in KB for load and preset.
     object_size: Optional[int] = metadata_field(all_load_scenarios, "size", "WRITE_OBJ_SIZE", False)
     # For read operations, controls from which set get objects to read
@@ -290,14 +232,14 @@ class LoadParams(MetaConfig):
     registry_file: Optional[str] = metadata_field(all_scenarios, None, "REGISTRY_FILE", False)
     # In case if we want to use custom registry file left from another load run
     custom_registry: Optional[str] = None
-    # In case if we want to use custom registry file left from another load run
-    force_fresh_registry: Optional[bool] = None
     # Specifies the minimum duration of every single execution (i.e. iteration).
     # Any iterations that are shorter than this value will cause that VU to
     # sleep for the remainder of the time until the specified minimum duration is reached.
     min_iteration_duration: Optional[str] = metadata_field(all_load_scenarios, None, "K6_MIN_ITERATION_DURATION", False)
     # Prepare/cut objects locally on client before sending
-    prepare_locally: Optional[bool] = metadata_field([LoadScenario.gRPC, LoadScenario.gRPC_CAR], None, "PREPARE_LOCALLY", False)
+    prepare_locally: Optional[bool] = metadata_field(
+        [LoadScenario.gRPC, LoadScenario.gRPC_CAR], None, "PREPARE_LOCALLY", False
+    )
     # Specifies K6 setupTimeout time. Currently hardcoded in xk6 as 5 seconds for all scenarios
     # https://k6.io/docs/using-k6/k6-options/reference/#setup-timeout
     setup_timeout: Optional[str] = metadata_field(all_scenarios, None, "K6_SETUP_TIMEOUT", False)
@@ -327,25 +269,35 @@ class LoadParams(MetaConfig):
     delete_rate: Optional[int] = metadata_field(constant_arrival_rate_scenarios, None, "DELETE_RATE", True, True)
 
     # Amount of preAllocatedVUs for write operations.
-    preallocated_writers: Optional[int] = metadata_field(constant_arrival_rate_scenarios, None, "PRE_ALLOC_WRITERS", True, True)
+    preallocated_writers: Optional[int] = metadata_field(
+        constant_arrival_rate_scenarios, None, "PRE_ALLOC_WRITERS", True, True
+    )
     # Amount of maxVUs for write operations.
     max_writers: Optional[int] = metadata_field(constant_arrival_rate_scenarios, None, "MAX_WRITERS", False, True)
 
     # Amount of preAllocatedVUs for read operations.
-    preallocated_readers: Optional[int] = metadata_field(constant_arrival_rate_scenarios, None, "PRE_ALLOC_READERS", True, True)
+    preallocated_readers: Optional[int] = metadata_field(
+        constant_arrival_rate_scenarios, None, "PRE_ALLOC_READERS", True, True
+    )
     # Amount of maxVUs for read operations.
     max_readers: Optional[int] = metadata_field(constant_arrival_rate_scenarios, None, "MAX_READERS", False, True)
 
     # Amount of preAllocatedVUs for read operations.
-    preallocated_deleters: Optional[int] = metadata_field(constant_arrival_rate_scenarios, None, "PRE_ALLOC_DELETERS", True, True)
+    preallocated_deleters: Optional[int] = metadata_field(
+        constant_arrival_rate_scenarios, None, "PRE_ALLOC_DELETERS", True, True
+    )
     # Amount of maxVUs for delete operations.
     max_deleters: Optional[int] = metadata_field(constant_arrival_rate_scenarios, None, "MAX_DELETERS", False, True)
 
     # Multipart
     # Number of parts to upload in parallel
-    writers_multipart: Optional[int] = metadata_field([LoadScenario.S3_MULTIPART], None, "WRITERS_MULTIPART", False, True)
+    writers_multipart: Optional[int] = metadata_field(
+        [LoadScenario.S3_MULTIPART], None, "WRITERS_MULTIPART", False, True
+    )
     # part size must be greater than (5 MB)
-    write_object_part_size: Optional[int] = metadata_field([LoadScenario.S3_MULTIPART], None, "WRITE_OBJ_PART_SIZE", False)
+    write_object_part_size: Optional[int] = metadata_field(
+        [LoadScenario.S3_MULTIPART], None, "WRITE_OBJ_PART_SIZE", False
+    )
 
     # Period of time to apply the rate value.
     time_unit: Optional[str] = metadata_field(constant_arrival_rate_scenarios, None, "TIME_UNIT", False)
@@ -360,7 +312,7 @@ class LoadParams(MetaConfig):
     # Config file location (filled automatically)
     config_file: Optional[str] = metadata_field([LoadScenario.LOCAL, LoadScenario.S3_LOCAL], None, "CONFIG_FILE", False)
     # Config directory location (filled automatically)
-    config_dir: Optional[str] = metadata_field([LoadScenario.LOCAL, LoadScenario.S3_LOCAL], None, "CONFIG_DIR", False)
+    config_dir: Optional[str] = metadata_field([LoadScenario.S3_LOCAL], None, "CONFIG_DIR", False)
 
     def set_id(self, load_id):
         self.load_id = load_id
@@ -378,17 +330,6 @@ class LoadParams(MetaConfig):
         if self.preset:
             self.preset.pregen_json = os.path.join(self.working_dir, f"{load_id}_prepare.json")
 
-    def get_k6_vars(self):
-        env_vars = {
-            meta_field.metadata["scenario_variable"]: meta_field.value
-            for meta_field in self._get_meta_fields(self)
-            if self.scenario in meta_field.metadata["applicable_scenarios"]
-            and meta_field.metadata["scenario_variable"]
-            and meta_field.value is not None
-        }
-
-        return env_vars
-
     def get_env_vars(self):
         env_vars = {
             meta_field.metadata["env_variable"]: meta_field.value
@@ -445,11 +386,6 @@ class LoadParams(MetaConfig):
             # For preset calls, bool values are passed with just --<argument_name> if the value is True
             return f"--{meta_field.metadata['preset_argument']}" if meta_field.value else ""
 
-        if isinstance(meta_field.value, list):
-            return (
-                " ".join(f"--{meta_field.metadata['preset_argument']} '{value}'" for value in meta_field.value) if meta_field.value else ""
-            )
-
         return f"--{meta_field.metadata['preset_argument']} '{meta_field.value}'"
 
     @staticmethod
@@ -469,6 +405,25 @@ class LoadParams(MetaConfig):
 
         return fields_with_data or []
 
+    def _get_field_formatter(self, field_name: str) -> Callable | None:
+        data_fields = fields(self)
+        formatters = [
+            field.metadata["formatter"]
+            for field in data_fields
+            if field.name == field_name and "formatter" in field.metadata and field.metadata["formatter"] != None
+        ]
+        if formatters:
+            return formatters[0]
+
+        return None
+
+    def __setattr__(self, field_name, value):
+        formatter = self._get_field_formatter(field_name)
+        if formatter:
+            value = formatter(value)
+
+        super().__setattr__(field_name, value)
+
     def __str__(self) -> str:
         load_type_str = self.scenario.value if self.scenario else self.load_type.value
         # TODO: migrate load_params defaults to testlib
@@ -479,7 +434,9 @@ class LoadParams(MetaConfig):
             static_params = [f"{load_type_str}"]
 
         dynamic_params = [
-            f"{meta_field.name}={meta_field.value}" for meta_field in self._get_applicable_fields() if meta_field.metadata["string_repr"]
+            f"{meta_field.name}={meta_field.value}"
+            for meta_field in self._get_applicable_fields()
+            if meta_field.metadata["string_repr"]
         ]
         params = ", ".join(static_params + dynamic_params)
 

src/frostfs_testlib/load/load_metrics.py

@@ -39,10 +39,6 @@ class OperationMetric(ABC):
     def throughput(self) -> float:
         return self._get_metric_rate(self._THROUGHPUT)
 
-    @property
-    def total_bytes(self) -> float:
-        return self._get_metric(self._THROUGHPUT)
-
     def _get_metric(self, metric: str) -> int:
         metrics_method_map = {
             "counter": self._get_counter_metric,
@@ -111,66 +107,66 @@ class DeleteOperationMetric(OperationMetric):
 
 
 class GrpcWriteOperationMetric(WriteOperationMetric):
-    _SUCCESS = "frostfs_obj_put_success"
+    _SUCCESS = "frostfs_obj_put_total"
     _ERRORS = "frostfs_obj_put_fails"
     _LATENCY = "frostfs_obj_put_duration"
 
 
 class GrpcReadOperationMetric(ReadOperationMetric):
-    _SUCCESS = "frostfs_obj_get_success"
+    _SUCCESS = "frostfs_obj_get_total"
     _ERRORS = "frostfs_obj_get_fails"
     _LATENCY = "frostfs_obj_get_duration"
 
 
 class GrpcDeleteOperationMetric(DeleteOperationMetric):
-    _SUCCESS = "frostfs_obj_delete_success"
+    _SUCCESS = "frostfs_obj_delete_total"
     _ERRORS = "frostfs_obj_delete_fails"
     _LATENCY = "frostfs_obj_delete_duration"
 
 
 class S3WriteOperationMetric(WriteOperationMetric):
-    _SUCCESS = "aws_obj_put_success"
+    _SUCCESS = "aws_obj_put_total"
     _ERRORS = "aws_obj_put_fails"
     _LATENCY = "aws_obj_put_duration"
 
 
 class S3ReadOperationMetric(ReadOperationMetric):
-    _SUCCESS = "aws_obj_get_success"
+    _SUCCESS = "aws_obj_get_total"
     _ERRORS = "aws_obj_get_fails"
     _LATENCY = "aws_obj_get_duration"
 
 
 class S3DeleteOperationMetric(DeleteOperationMetric):
-    _SUCCESS = "aws_obj_delete_success"
+    _SUCCESS = "aws_obj_delete_total"
     _ERRORS = "aws_obj_delete_fails"
     _LATENCY = "aws_obj_delete_duration"
 
 
 class S3LocalWriteOperationMetric(WriteOperationMetric):
-    _SUCCESS = "s3local_obj_put_success"
+    _SUCCESS = "s3local_obj_put_total"
     _ERRORS = "s3local_obj_put_fails"
     _LATENCY = "s3local_obj_put_duration"
 
 
 class S3LocalReadOperationMetric(ReadOperationMetric):
-    _SUCCESS = "s3local_obj_get_success"
+    _SUCCESS = "s3local_obj_get_total"
     _ERRORS = "s3local_obj_get_fails"
     _LATENCY = "s3local_obj_get_duration"
 
 
 class LocalWriteOperationMetric(WriteOperationMetric):
-    _SUCCESS = "local_obj_put_success"
+    _SUCCESS = "local_obj_put_total"
     _ERRORS = "local_obj_put_fails"
     _LATENCY = "local_obj_put_duration"
 
 
 class LocalReadOperationMetric(ReadOperationMetric):
-    _SUCCESS = "local_obj_get_success"
+    _SUCCESS = "local_obj_get_total"
     _ERRORS = "local_obj_get_fails"
 
 
 class LocalDeleteOperationMetric(DeleteOperationMetric):
-    _SUCCESS = "local_obj_delete_success"
+    _SUCCESS = "local_obj_delete_total"
     _ERRORS = "local_obj_delete_fails"
 
 

src/frostfs_testlib/load/load_report.py

@@ -120,11 +120,6 @@ class LoadReport:
             throughput, unit = calc_unit(stats.throughput)
             throughput_html = self._row("Throughput", f"{throughput:.2f} {unit}/sec")
 
-        bytes_html = ""
-        if stats.total_bytes > 0:
-            total_bytes, total_bytes_unit = calc_unit(stats.total_bytes)
-            bytes_html = self._row("Total transferred", f"{total_bytes:.2f} {total_bytes_unit}")
-
         per_node_errors_html = ""
         for node_key, errors in stats.errors.by_node.items():
             if self.load_params.k6_process_allocation_strategy == K6ProcessAllocationStrategy.PER_ENDPOINT:
@@ -153,7 +148,6 @@ class LoadReport:
         <tr><th colspan="2" bgcolor="gainsboro">Metrics</th></tr>
         {self._row("Total operations", stats.operations)}
         {self._row("OP/sec", f"{stats.rate:.2f}")}
-        {bytes_html}
         {throughput_html}
         {latency_html}
         <tr><th colspan="2" bgcolor="gainsboro">Errors</th></tr>

src/frostfs_testlib/load/load_verifiers.py

@@ -57,8 +57,6 @@ class LoadVerifier:
             invalid_objects = verify_metrics.read.failed_iterations
             total_left_objects = load_metrics.write.success_iterations - delete_success
 
-            if invalid_objects > 0:
-                issues.append(f"There were {invalid_objects} verification fails (hash mismatch).")
             # Due to interruptions we may see total verified objects to be less than written on writers count
             if abs(total_left_objects - verified_objects) > writers:
                 issues.append(

src/frostfs_testlib/load/runners.py

@@ -1,20 +1,23 @@
 import copy
 import itertools
 import math
+import re
 import time
 from dataclasses import fields
-from threading import Event
 from typing import Optional
 from urllib.parse import urlparse
 
+import yaml
+
 from frostfs_testlib import reporter
-from frostfs_testlib.credentials.interfaces import S3Credentials, User
+from frostfs_testlib.cli.frostfs_authmate.authmate import FrostfsAuthmate
 from frostfs_testlib.load.interfaces.loader import Loader
 from frostfs_testlib.load.interfaces.scenario_runner import ScenarioRunner
 from frostfs_testlib.load.k6 import K6
 from frostfs_testlib.load.load_config import K6ProcessAllocationStrategy, LoadParams, LoadType
 from frostfs_testlib.load.loaders import NodeLoader, RemoteLoader
 from frostfs_testlib.resources import optionals
+from frostfs_testlib.resources.cli import FROSTFS_AUTHMATE_EXEC
 from frostfs_testlib.resources.common import STORAGE_USER_NAME
 from frostfs_testlib.resources.load_params import BACKGROUND_LOAD_VUS_COUNT_DIVISOR, LOAD_NODE_SSH_USER, LOAD_NODES
 from frostfs_testlib.shell.command_inspectors import SuInspector
@@ -22,15 +25,16 @@ from frostfs_testlib.shell.interfaces import CommandOptions, InteractiveInput
 from frostfs_testlib.storage.cluster import ClusterNode
 from frostfs_testlib.storage.controllers.cluster_state_controller import ClusterStateController
 from frostfs_testlib.storage.dataclasses.frostfs_services import S3Gate, StorageNode
+from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
 from frostfs_testlib.testing import parallel, run_optionally
 from frostfs_testlib.testing.test_control import retry
 from frostfs_testlib.utils import datetime_utils
 from frostfs_testlib.utils.file_keeper import FileKeeper
+from threading import Event
 
 
 class RunnerBase(ScenarioRunner):
     k6_instances: list[K6]
-    loaders: list[Loader]
 
     @reporter.step("Run preset on loaders")
     def preset(self):
@@ -50,22 +54,20 @@ class RunnerBase(ScenarioRunner):
     def get_k6_instances(self):
         return self.k6_instances
 
-    def get_loaders(self) -> list[Loader]:
-        return self.loaders
-
 
 class DefaultRunner(RunnerBase):
-    user: User
+    loaders: list[Loader]
+    loaders_wallet: WalletInfo
 
     def __init__(
         self,
-        user: User,
+        loaders_wallet: WalletInfo,
         load_ip_list: Optional[list[str]] = None,
     ) -> None:
         if load_ip_list is None:
             load_ip_list = LOAD_NODES
         self.loaders = RemoteLoader.from_ip_list(load_ip_list)
-        self.user = user
+        self.loaders_wallet = loaders_wallet
 
     @run_optionally(optionals.OPTIONAL_BACKGROUND_LOAD_ENABLED)
     @reporter.step("Preparation steps")
@@ -76,35 +78,54 @@ class DefaultRunner(RunnerBase):
         nodes_under_load: list[ClusterNode],
         k6_dir: str,
     ):
-        if load_params.force_fresh_registry and load_params.custom_registry:
-            with reporter.step("Forcing fresh registry files"):
-                parallel(self._force_fresh_registry, self.loaders, load_params)
-
         if load_params.load_type != LoadType.S3:
             return
 
         with reporter.step("Init s3 client on loaders"):
-            s3_credentials = self.user.s3_credentials
+            storage_node = nodes_under_load[0].service(StorageNode)
-            parallel(self._aws_configure_on_loader, self.loaders, s3_credentials)
+            s3_public_keys = [node.service(S3Gate).get_wallet_public_key() for node in cluster_nodes]
+            grpc_peer = storage_node.get_rpc_endpoint()
 
-    def _force_fresh_registry(self, loader: Loader, load_params: LoadParams):
+            parallel(self._prepare_loader, self.loaders, load_params, grpc_peer, s3_public_keys, k6_dir)
-        with reporter.step(f"Forcing fresh registry on {loader.ip}"):
-            shell = loader.get_shell()
-            shell.exec(f"rm -f {load_params.registry_file}")
 
-    def _aws_configure_on_loader(
+    def _prepare_loader(
         self,
         loader: Loader,
-        s3_credentials: S3Credentials,
+        load_params: LoadParams,
+        grpc_peer: str,
+        s3_public_keys: list[str],
+        k6_dir: str,
     ):
-        with reporter.step(f"Aws configure on {loader.ip}"):
+        with reporter.step(f"Init s3 client on {loader.ip}"):
+            shell = loader.get_shell()
+            frostfs_authmate_exec: FrostfsAuthmate = FrostfsAuthmate(shell, FROSTFS_AUTHMATE_EXEC)
+            issue_secret_output = frostfs_authmate_exec.secret.issue(
+                wallet=self.loaders_wallet.path,
+                peer=grpc_peer,
+                gate_public_key=s3_public_keys,
+                container_placement_policy=load_params.preset.container_placement_policy,
+                container_policy=f"{k6_dir}/scenarios/files/policy.json",
+                wallet_password=self.loaders_wallet.password,
+            ).stdout
+            aws_access_key_id = str(
+                re.search(r"access_key_id.*:\s.(?P<aws_access_key_id>\w*)", issue_secret_output).group(
+                    "aws_access_key_id"
+                )
+            )
+            aws_secret_access_key = str(
+                re.search(
+                    r"secret_access_key.*:\s.(?P<aws_secret_access_key>\w*)",
+                    issue_secret_output,
+                ).group("aws_secret_access_key")
+            )
+
             configure_input = [
-                InteractiveInput(prompt_pattern=r"AWS Access Key ID.*", input=s3_credentials.access_key),
+                InteractiveInput(prompt_pattern=r"AWS Access Key ID.*", input=aws_access_key_id),
-                InteractiveInput(prompt_pattern=r"AWS Secret Access Key.*", input=s3_credentials.secret_key),
+                InteractiveInput(prompt_pattern=r"AWS Secret Access Key.*", input=aws_secret_access_key),
                 InteractiveInput(prompt_pattern=r".*", input=""),
                 InteractiveInput(prompt_pattern=r".*", input=""),
             ]
-            loader.get_shell().exec("aws configure", CommandOptions(interactive_inputs=configure_input))
+            shell.exec("aws configure", CommandOptions(interactive_inputs=configure_input))
 
     @reporter.step("Init k6 instances")
     def init_k6_instances(self, load_params: LoadParams, endpoints: list[str], k6_dir: str):
@@ -146,10 +167,12 @@ class DefaultRunner(RunnerBase):
                 k6_dir,
                 shell,
                 loader,
-                self.user,
+                self.loaders_wallet,
             )
 
-    def _get_distributed_load_params_list(self, original_load_params: LoadParams, workers_count: int) -> list[LoadParams]:
+    def _get_distributed_load_params_list(
+        self, original_load_params: LoadParams, workers_count: int
+    ) -> list[LoadParams]:
         divisor = int(BACKGROUND_LOAD_VUS_COUNT_DIVISOR)
         distributed_load_params: list[LoadParams] = []
 
@@ -231,22 +254,21 @@ class DefaultRunner(RunnerBase):
 
 
 class LocalRunner(RunnerBase):
+    loaders: list[Loader]
     cluster_state_controller: ClusterStateController
     file_keeper: FileKeeper
-    user: User
+    wallet: WalletInfo
 
     def __init__(
         self,
         cluster_state_controller: ClusterStateController,
         file_keeper: FileKeeper,
         nodes_under_load: list[ClusterNode],
-        user: User,
     ) -> None:
         self.cluster_state_controller = cluster_state_controller
         self.file_keeper = file_keeper
         self.loaders = [NodeLoader(node) for node in nodes_under_load]
         self.nodes_under_load = nodes_under_load
-        self.user = user
 
     @run_optionally(optionals.OPTIONAL_BACKGROUND_LOAD_ENABLED)
     @reporter.step("Preparation steps")
@@ -292,12 +314,14 @@ class LocalRunner(RunnerBase):
         with reporter.step("Download K6"):
             shell.exec(f"sudo rm -rf {k6_dir};sudo mkdir {k6_dir}")
             shell.exec(f"sudo curl -so {k6_dir}/k6.tar.gz {load_params.k6_url}")
-            shell.exec(f"sudo tar xf {k6_dir}/k6.tar.gz --strip-components 2 -C {k6_dir}")
+            shell.exec(f"sudo tar xf {k6_dir}/k6.tar.gz -C {k6_dir}")
             shell.exec(f"sudo chmod -R 777 {k6_dir}")
 
-        with reporter.step("chmod 777 wallet related files on loader"):
+        with reporter.step("Create empty_passwd"):
-            shell.exec(f"sudo chmod -R 777 {self.user.wallet.config_path}")
+            self.wallet = WalletInfo(f"{k6_dir}/scenarios/files/wallet.json", "", "/tmp/empty_passwd.yml")
-            shell.exec(f"sudo chmod -R 777 {self.user.wallet.path}")
+            content = yaml.dump({"password": ""})
+            shell.exec(f'echo "{content}" | sudo tee {self.wallet.config_path}')
+            shell.exec(f"sudo chmod -R 777 {self.wallet.config_path}")
 
     @reporter.step("Init k6 instances")
     def init_k6_instances(self, load_params: LoadParams, endpoints: list[str], k6_dir: str):
@@ -330,7 +354,7 @@ class LocalRunner(RunnerBase):
             k6_dir,
             shell,
             loader,
-            self.user,
+            self.wallet,
         )
 
     def start(self):
@@ -420,7 +444,7 @@ class S3LocalRunner(LocalRunner):
                 k6_dir,
                 shell,
                 loader,
-                self.user,
+                self.wallet,
             )
 
     @run_optionally(optionals.OPTIONAL_BACKGROUND_LOAD_ENABLED)
@@ -433,10 +457,17 @@ class S3LocalRunner(LocalRunner):
         k6_dir: str,
     ):
         self.k6_dir = k6_dir
-        parallel(self.prepare_node, nodes_under_load, k6_dir, load_params, cluster_nodes)
+        with reporter.step("Init s3 client on loaders"):
+            storage_node = nodes_under_load[0].service(StorageNode)
+            s3_public_keys = [node.service(S3Gate).get_wallet_public_key() for node in cluster_nodes]
+            grpc_peer = storage_node.get_rpc_endpoint()
+
+        parallel(self.prepare_node, nodes_under_load, k6_dir, load_params, s3_public_keys, grpc_peer)
 
     @reporter.step("Prepare node {cluster_node}")
-    def prepare_node(self, cluster_node: ClusterNode, k6_dir: str, load_params: LoadParams, cluster_nodes: list[ClusterNode]):
+    def prepare_node(
+        self, cluster_node: ClusterNode, k6_dir: str, load_params: LoadParams, s3_public_keys: list[str], grpc_peer: str
+    ):
         LocalRunner.prepare_node(self, cluster_node, k6_dir, load_params)
         self.endpoints = cluster_node.s3_gate.get_all_endpoints()
         shell = cluster_node.host.get_shell()
@@ -457,9 +488,29 @@ class S3LocalRunner(LocalRunner):
             shell.exec(f"sudo python3 -m pip install -I {k6_dir}/requests.tar.gz")
 
         with reporter.step(f"Init s3 client on {cluster_node.host_ip}"):
+            frostfs_authmate_exec: FrostfsAuthmate = FrostfsAuthmate(shell, FROSTFS_AUTHMATE_EXEC)
+            issue_secret_output = frostfs_authmate_exec.secret.issue(
+                wallet=self.wallet.path,
+                peer=grpc_peer,
+                gate_public_key=s3_public_keys,
+                container_placement_policy=load_params.preset.container_placement_policy,
+                container_policy=f"{k6_dir}/scenarios/files/policy.json",
+                wallet_password=self.wallet.password,
+            ).stdout
+            aws_access_key_id = str(
+                re.search(r"access_key_id.*:\s.(?P<aws_access_key_id>\w*)", issue_secret_output).group(
+                    "aws_access_key_id"
+                )
+            )
+            aws_secret_access_key = str(
+                re.search(
+                    r"secret_access_key.*:\s.(?P<aws_secret_access_key>\w*)",
+                    issue_secret_output,
+                ).group("aws_secret_access_key")
+            )
             configure_input = [
-                InteractiveInput(prompt_pattern=r"AWS Access Key ID.*", input=self.user.s3_credentials.access_key),
+                InteractiveInput(prompt_pattern=r"AWS Access Key ID.*", input=aws_access_key_id),
-                InteractiveInput(prompt_pattern=r"AWS Secret Access Key.*", input=self.user.s3_credentials.secret_key),
+                InteractiveInput(prompt_pattern=r"AWS Secret Access Key.*", input=aws_secret_access_key),
                 InteractiveInput(prompt_pattern=r".*", input=""),
                 InteractiveInput(prompt_pattern=r".*", input=""),
             ]

src/frostfs_testlib/resources/cli.py

@@ -9,4 +9,4 @@ FROSTFS_ADM_EXEC = os.getenv("FROSTFS_ADM_EXEC", "frostfs-adm")
 # Config for frostfs-adm utility. Optional if tests are running against devenv
 FROSTFS_ADM_CONFIG_PATH = os.getenv("FROSTFS_ADM_CONFIG_PATH")
 
-CLI_DEFAULT_TIMEOUT = os.getenv("CLI_DEFAULT_TIMEOUT", "100s")
+CLI_DEFAULT_TIMEOUT = os.getenv("CLI_DEFAULT_TIMEOUT", None)

src/frostfs_testlib/resources/common.py

@@ -46,11 +46,3 @@ with open(DEFAULT_WALLET_CONFIG, "w") as file:
 MAX_REQUEST_ATTEMPTS = 5
 RETRY_MODE = "standard"
 CREDENTIALS_CREATE_TIMEOUT = "1m"
-
-
-HOSTING_CONFIG_FILE = os.getenv(
-    "HOSTING_CONFIG_FILE", os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".devenv.hosting.yaml"))
-)
-
-MORE_LOG = os.getenv("MORE_LOG", "1")
-EXPIRATION_EPOCH_ATTRIBUTE = "__SYSTEM__EXPIRATION_EPOCH"

src/frostfs_testlib/resources/error_patterns.py

@@ -23,14 +23,6 @@ INVALID_RANGE_OVERFLOW = "invalid '{range}' range: uint64 overflow"
 INVALID_OFFSET_SPECIFIER = "invalid '{range}' range offset specifier"
 INVALID_LENGTH_SPECIFIER = "invalid '{range}' range length specifier"
 
-S3_BUCKET_DOES_NOT_ALLOW_ACL = "The bucket does not allow ACLs"
+S3_MALFORMED_XML_REQUEST = (
-S3_MALFORMED_XML_REQUEST = "The XML you provided was not well-formed or did not validate against our published schema."
+    "The XML you provided was not well-formed or did not validate against our published schema."
-
+)
-RULE_ACCESS_DENIED_CONTAINER = "access to container operation {operation} is denied by access policy engine: Access denied"
-# Errors from node missing reasons if request was forwarded. Commenting for now
-# RULE_ACCESS_DENIED_OBJECT = "access to object operation denied: ape denied request: method {operation}: Access denied"
-RULE_ACCESS_DENIED_OBJECT = "access to object operation denied: ape denied request"
-NO_RULE_FOUND_CONTAINER = "access to container operation {operation} is denied by access policy engine: NoRuleFound"
-# Errors from node missing reasons if request was forwarded. Commenting for now
-# NO_RULE_FOUND_OBJECT = "access to object operation denied: ape denied request: method {operation}: NoRuleFound"
-NO_RULE_FOUND_OBJECT = "access to object operation denied: ape denied request"

src/frostfs_testlib/resources/load_params.py

@@ -26,7 +26,6 @@ BACKGROUND_LOAD_CONTAINER_PLACEMENT_POLICY = os.getenv(
 )
 BACKGROUND_LOAD_S3_LOCATION = os.getenv("BACKGROUND_LOAD_S3_LOCATION", "node-off")
 PRESET_CONTAINERS_COUNT = os.getenv("CONTAINERS_COUNT", "40")
-PRESET_CONTAINER_CREATION_RETRY_COUNT = os.getenv("CONTAINER_CREATION_RETRY_COUNT", "20")
 # TODO: At lease one object is required due to bug in xk6 (buckets with no objects produce millions exceptions in read)
 PRESET_OBJECTS_COUNT = os.getenv("OBJ_COUNT", "1")
 K6_DIRECTORY = os.getenv("K6_DIRECTORY", "/etc/k6")

src/frostfs_testlib/resources/optionals.py

@@ -16,10 +16,11 @@ OPTIONAL_NODE_UNDER_LOAD = os.getenv("OPTIONAL_NODE_UNDER_LOAD")
 OPTIONAL_FAILOVER_ENABLED = str_to_bool(os.getenv("OPTIONAL_FAILOVER_ENABLED", "true"))
 
 # Set this to True to disable background load. I.E. node which supposed to be stopped will not be actually stopped.
-OPTIONAL_BACKGROUND_LOAD_ENABLED = str_to_bool(os.getenv("OPTIONAL_BACKGROUND_LOAD_ENABLED", "true"))
+OPTIONAL_BACKGROUND_LOAD_ENABLED = str_to_bool(
+    os.getenv("OPTIONAL_BACKGROUND_LOAD_ENABLED", "true")
+)
 
 # Set this to False for disable autouse fixture like node healthcheck during developing time.
-OPTIONAL_AUTOUSE_FIXTURES_ENABLED = str_to_bool(os.getenv("OPTIONAL_AUTOUSE_FIXTURES_ENABLED", "true"))
+OPTIONAL_AUTOUSE_FIXTURES_ENABLED = str_to_bool(
-
+    os.getenv("OPTIONAL_AUTOUSE_FIXTURES_ENABLED", "true")
-# Use cache for fixtures with @cachec_fixture decorator
+)
-OPTIONAL_CACHE_FIXTURES = str_to_bool(os.getenv("OPTIONAL_CACHE_FIXTURES", "false"))

src/frostfs_testlib/resources/s3_acl_grants.py

@@ -1,9 +0,0 @@
-ALL_USERS_GROUP_URI = "http://acs.amazonaws.com/groups/global/AllUsers"
-ALL_USERS_GROUP_WRITE_GRANT = {"Grantee": {"Type": "Group", "URI": ALL_USERS_GROUP_URI}, "Permission": "WRITE"}
-ALL_USERS_GROUP_READ_GRANT = {"Grantee": {"Type": "Group", "URI": ALL_USERS_GROUP_URI}, "Permission": "READ"}
-CANONICAL_USER_FULL_CONTROL_GRANT = {"Grantee": {"Type": "CanonicalUser"}, "Permission": "FULL_CONTROL"}
-
-# https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl
-PRIVATE_GRANTS = []
-PUBLIC_READ_GRANTS = [ALL_USERS_GROUP_READ_GRANT]
-PUBLIC_READ_WRITE_GRANTS = [ALL_USERS_GROUP_WRITE_GRANT, ALL_USERS_GROUP_READ_GRANT]

src/frostfs_testlib/s3/curl_bucket_resolver.py

@@ -1,16 +0,0 @@
-import re
-
-from frostfs_testlib.cli.generic_cli import GenericCli
-from frostfs_testlib.s3.interfaces import BucketContainerResolver
-from frostfs_testlib.storage.cluster import ClusterNode
-
-
-class CurlBucketContainerResolver(BucketContainerResolver):
-    def resolve(self, node: ClusterNode, bucket_name: str, **kwargs: dict) -> str:
-        curl = GenericCli("curl", node.host)
-        output = curl(f"-I http://127.0.0.1:8084/{bucket_name}")
-        pattern = r"X-Container-Id: (\S+)"
-        cid = re.findall(pattern, output.stdout)
-        if cid:
-            return cid[0]
-        return None

src/frostfs_testlib/s3/interfaces.py

@@ -1,10 +1,8 @@
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 from datetime import datetime
 from typing import Literal, Optional, Union
 
-from frostfs_testlib.storage.cluster import ClusterNode
 from frostfs_testlib.testing.readable import HumanReadableABC, HumanReadableEnum
-from frostfs_testlib.utils.file_utils import TestFile
 
 
 def _make_objs_dict(key_names):
@@ -33,35 +31,15 @@ ACL_COPY = [
 ]
 
 
-class BucketContainerResolver(ABC):
-    @abstractmethod
-    def resolve(self, node: ClusterNode, bucket_name: str, **kwargs: dict) -> str:
-        """
-        Resolve Container ID from bucket name
-
-        Args:
-            node: node from where we want to resolve
-            bucket_name: name of the bucket
-            **kwargs: any other required params
-
-        Returns: Container ID
-        """
-        raise NotImplementedError("Call from abstract class")
-
-
 class S3ClientWrapper(HumanReadableABC):
     @abstractmethod
-    def __init__(self, access_key_id: str, secret_access_key: str, s3gate_endpoint: str, profile: str, region: str) -> None:
+    def __init__(self, access_key_id: str, secret_access_key: str, s3gate_endpoint: str, profile: str) -> None:
         pass
 
     @abstractmethod
     def set_endpoint(self, s3gate_endpoint: str):
         """Set endpoint"""
 
-    @abstractmethod
-    def set_iam_endpoint(self, iam_endpoint: str):
-        """Set iam endpoint"""
-
     @abstractmethod
     def create_bucket(
         self,
@@ -157,10 +135,6 @@ class S3ClientWrapper(HumanReadableABC):
     def get_bucket_policy(self, bucket: str) -> str:
         """Returns the policy of a specified bucket."""
 
-    @abstractmethod
-    def delete_bucket_policy(self, bucket: str) -> str:
-        """Deletes the policy of a specified bucket."""
-
     @abstractmethod
     def put_bucket_policy(self, bucket: str, policy: dict) -> None:
         """Applies S3 bucket policy to an S3 bucket."""
@@ -195,9 +169,7 @@ class S3ClientWrapper(HumanReadableABC):
         """
 
     @abstractmethod
-    def list_objects(
+    def list_objects(self, bucket: str, full_output: bool = False) -> Union[dict, list[str]]:
-        self, bucket: str, full_output: bool = False, page_size: Optional[int] = None, prefix: Optional[str] = None
-    ) -> Union[dict, list[str]]:
         """Returns some or all (up to 1,000) of the objects in a bucket with each request.
         You can use the request parameters as selection criteria to return a subset of the objects in a bucket.
         A 200 OK response can contain valid or invalid XML. Make sure to design your application
@@ -296,7 +268,7 @@ class S3ClientWrapper(HumanReadableABC):
         version_id: Optional[str] = None,
         object_range: Optional[tuple[int, int]] = None,
         full_output: bool = False,
-    ) -> dict | TestFile:
+    ) -> Union[dict, str]:
         """Retrieves objects from S3."""
 
     @abstractmethod
@@ -324,11 +296,15 @@ class S3ClientWrapper(HumanReadableABC):
         abort a given multipart upload multiple times in order to completely free all storage consumed by all parts."""
 
     @abstractmethod
-    def upload_part(self, bucket: str, key: str, upload_id: str, part_num: int, filepath: str) -> str:
+    def upload_part(
+        self, bucket: str, key: str, upload_id: str, part_num: int, filepath: str
+    ) -> str:
         """Uploads a part in a multipart upload."""
 
     @abstractmethod
-    def upload_part_copy(self, bucket: str, key: str, upload_id: str, part_num: int, copy_source: str) -> str:
+    def upload_part_copy(
+        self, bucket: str, key: str, upload_id: str, part_num: int, copy_source: str
+    ) -> str:
         """Uploads a part by copying data from an existing object as data source."""
 
     @abstractmethod
@@ -372,18 +348,6 @@ class S3ClientWrapper(HumanReadableABC):
     def delete_object_tagging(self, bucket: str, key: str) -> None:
         """Removes the entire tag set from the specified object."""
 
-    @abstractmethod
-    def put_bucket_lifecycle_configuration(self, bucket: str, lifecycle_configuration: dict, dumped_configuration: str) -> dict:
-        """Adds or updates bucket lifecycle configuration"""
-
-    @abstractmethod
-    def get_bucket_lifecycle_configuration(self, bucket: str) -> dict:
-        """Gets bucket lifecycle configuration"""
-
-    @abstractmethod
-    def delete_bucket_lifecycle(self, bucket: str) -> dict:
-        """Deletes bucket lifecycle"""
-
     @abstractmethod
     def get_object_attributes(
         self,
@@ -418,194 +382,3 @@ class S3ClientWrapper(HumanReadableABC):
         """cp directory TODO: Add proper description"""
 
     # END OF OBJECT METHODS #
-
-    # IAM METHODS #
-
-    @abstractmethod
-    def iam_add_user_to_group(self, user_name: str, group_name: str) -> dict:
-        """Adds the specified user to the specified group"""
-
-    @abstractmethod
-    def iam_attach_group_policy(self, group_name: str, policy_arn: str) -> dict:
-        """Attaches the specified managed policy to the specified IAM group"""
-
-    @abstractmethod
-    def iam_attach_user_policy(self, user_name: str, policy_arn: str) -> dict:
-        """Attaches the specified managed policy to the specified user"""
-
-    @abstractmethod
-    def iam_create_access_key(self, user_name: str) -> dict:
-        """Creates a new AWS secret access key and access key ID for the specified user"""
-
-    @abstractmethod
-    def iam_create_group(self, group_name: str) -> dict:
-        """Creates a new group"""
-
-    @abstractmethod
-    def iam_create_policy(self, policy_name: str, policy_document: dict) -> dict:
-        """Creates a new managed policy for your AWS account"""
-
-    @abstractmethod
-    def iam_create_user(self, user_name: str) -> dict:
-        """Creates a new IAM user for your AWS account"""
-
-    @abstractmethod
-    def iam_delete_access_key(self, access_key_id: str, user_name: str) -> dict:
-        """Deletes the access key pair associated with the specified IAM user"""
-
-    @abstractmethod
-    def iam_delete_group(self, group_name: str) -> dict:
-        """Deletes the specified IAM group"""
-
-    @abstractmethod
-    def iam_delete_group_policy(self, group_name: str, policy_name: str) -> dict:
-        """Deletes the specified inline policy that is embedded in the specified IAM group"""
-
-    @abstractmethod
-    def iam_delete_policy(self, policy_arn: str) -> dict:
-        """Deletes the specified managed policy"""
-
-    @abstractmethod
-    def iam_delete_user(self, user_name: str) -> dict:
-        """Deletes the specified IAM user"""
-
-    @abstractmethod
-    def iam_delete_user_policy(self, user_name: str, policy_name: str) -> dict:
-        """Deletes the specified inline policy that is embedded in the specified IAM user"""
-
-    @abstractmethod
-    def iam_detach_group_policy(self, group_name: str, policy_arn: str) -> dict:
-        """Removes the specified managed policy from the specified IAM group"""
-
-    @abstractmethod
-    def iam_detach_user_policy(self, user_name: str, policy_arn: str) -> dict:
-        """Removes the specified managed policy from the specified user"""
-
-    @abstractmethod
-    def iam_get_group(self, group_name: str) -> dict:
-        """Returns a list of IAM users that are in the specified IAM group"""
-
-    @abstractmethod
-    def iam_get_group_policy(self, group_name: str, policy_name: str) -> dict:
-        """Retrieves the specified inline policy document that is embedded in the specified IAM group"""
-
-    @abstractmethod
-    def iam_get_policy(self, policy_arn: str) -> dict:
-        """Retrieves information about the specified managed policy"""
-
-    @abstractmethod
-    def iam_get_policy_version(self, policy_arn: str, version_id: str) -> dict:
-        """Retrieves information about the specified version of the specified managed policy"""
-
-    @abstractmethod
-    def iam_get_user(self, user_name: str) -> dict:
-        """Retrieves information about the specified IAM user"""
-
-    @abstractmethod
-    def iam_get_user_policy(self, user_name: str, policy_name: str) -> dict:
-        """Retrieves the specified inline policy document that is embedded in the specified IAM user"""
-
-    @abstractmethod
-    def iam_list_access_keys(self, user_name: str) -> dict:
-        """Returns information about the access key IDs associated with the specified IAM user"""
-
-    @abstractmethod
-    def iam_list_attached_group_policies(self, group_name: str) -> dict:
-        """Lists all managed policies that are attached to the specified IAM group"""
-
-    @abstractmethod
-    def iam_list_attached_user_policies(self, user_name: str) -> dict:
-        """Lists all managed policies that are attached to the specified IAM user"""
-
-    @abstractmethod
-    def iam_list_entities_for_policy(self, policy_arn: str) -> dict:
-        """Lists all IAM users, groups, and roles that the specified managed policy is attached to"""
-
-    @abstractmethod
-    def iam_list_group_policies(self, group_name: str) -> dict:
-        """Lists the names of the inline policies that are embedded in the specified IAM group"""
-
-    @abstractmethod
-    def iam_list_groups(self) -> dict:
-        """Lists the IAM groups"""
-
-    @abstractmethod
-    def iam_list_groups_for_user(self, user_name: str) -> dict:
-        """Lists the IAM groups that the specified IAM user belongs to"""
-
-    @abstractmethod
-    def iam_list_policies(self) -> dict:
-        """Lists all the managed policies that are available in your AWS account"""
-
-    @abstractmethod
-    def iam_list_policy_versions(self, policy_arn: str) -> dict:
-        """Lists information about the versions of the specified managed policy"""
-
-    @abstractmethod
-    def iam_list_user_policies(self, user_name: str) -> dict:
-        """Lists the names of the inline policies embedded in the specified IAM user"""
-
-    @abstractmethod
-    def iam_list_users(self) -> dict:
-        """Lists the IAM users"""
-
-    @abstractmethod
-    def iam_put_group_policy(self, group_name: str, policy_name: str, policy_document: dict) -> dict:
-        """Adds or updates an inline policy document that is embedded in the specified IAM group"""
-
-    @abstractmethod
-    def iam_put_user_policy(self, user_name: str, policy_name: str, policy_document: dict) -> dict:
-        """Adds or updates an inline policy document that is embedded in the specified IAM user"""
-
-    @abstractmethod
-    def iam_remove_user_from_group(self, group_name: str, user_name: str) -> dict:
-        """Removes the specified user from the specified group"""
-
-    @abstractmethod
-    def iam_update_group(self, group_name: str, new_name: Optional[str] = None, new_path: Optional[str] = None) -> dict:
-        """Updates the name and/or the path of the specified IAM group"""
-
-    @abstractmethod
-    def iam_update_user(self, user_name: str, new_name: Optional[str] = None, new_path: Optional[str] = None) -> dict:
-        """Updates the name and/or the path of the specified IAM user"""
-
-    @abstractmethod
-    def iam_tag_user(self, user_name: str, tags: list) -> dict:
-        """Adds one or more tags to an IAM user"""
-
-    @abstractmethod
-    def iam_list_user_tags(self, user_name: str) -> dict:
-        """List tags of IAM user"""
-
-    @abstractmethod
-    def iam_untag_user(self, user_name: str, tag_keys: list) -> dict:
-        """Removes the specified tags from the user"""
-
-    # MFA methods
-    @abstractmethod
-    def iam_create_virtual_mfa_device(
-        self, virtual_mfa_device_name: str, outfile: Optional[str] = None, bootstrap_method: Optional[str] = None
-    ) -> tuple:
-        """Creates a new virtual MFA device"""
-
-    @abstractmethod
-    def iam_deactivate_mfa_device(self, user_name: str, serial_number: str) -> dict:
-        """Deactivates the specified MFA device and removes it from association with the user name"""
-
-    @abstractmethod
-    def iam_delete_virtual_mfa_device(self, serial_number: str) -> dict:
-        """Deletes a virtual MFA device"""
-
-    @abstractmethod
-    def iam_enable_mfa_device(self, user_name: str, serial_number: str, authentication_code1: str, authentication_code2: str) -> dict:
-        """Enables the specified MFA device and associates it with the specified IAM user"""
-
-    @abstractmethod
-    def iam_list_virtual_mfa_devices(self) -> dict:
-        """Lists the MFA devices for an IAM user"""
-
-    @abstractmethod
-    def sts_get_session_token(
-        self, duration_seconds: Optional[str] = None, serial_number: Optional[str] = None, token_code: Optional[str] = None
-    ) -> tuple:
-        """Get session token for user"""

src/frostfs_testlib/shell/local_shell.py

@@ -1,18 +1,15 @@
 import logging
 import subprocess
 import tempfile
-from contextlib import nullcontext
 from datetime import datetime
 from typing import IO, Optional
 
 import pexpect
 
 from frostfs_testlib import reporter
-from frostfs_testlib.resources.common import MORE_LOG
 from frostfs_testlib.shell.interfaces import CommandInspector, CommandOptions, CommandResult, Shell
 
 logger = logging.getLogger("frostfs.testlib.shell")
-step_context = reporter.step if MORE_LOG == "1" else nullcontext
 
 
 class LocalShell(Shell):
@@ -31,10 +28,10 @@ class LocalShell(Shell):
         for inspector in [*self.command_inspectors, *extra_inspectors]:
             command = inspector.inspect(original_command, command)
 
-        with step_context(f"Executing command: {command}"):
+        logger.info(f"Executing command: {command}")
-            if options.interactive_inputs:
+        if options.interactive_inputs:
-                return self._exec_interactive(command, options)
+            return self._exec_interactive(command, options)
-            return self._exec_non_interactive(command, options)
+        return self._exec_non_interactive(command, options)
 
     def _exec_interactive(self, command: str, options: CommandOptions) -> CommandResult:
         start_time = datetime.utcnow()
@@ -63,7 +60,9 @@ class LocalShell(Shell):
 
         if options.check and result.return_code != 0:
             raise RuntimeError(
-                f"Command: {command}\nreturn code: {result.return_code}\n" f"Output: {result.stdout}\n" f"Stderr: {result.stderr}\n"
+                f"Command: {command}\nreturn code: {result.return_code}\n"
+                f"Output: {result.stdout}\n"
+                f"Stderr: {result.stderr}\n"
             )
         return result
 
@@ -94,7 +93,9 @@ class LocalShell(Shell):
                 stderr="",
                 return_code=exc.returncode,
             )
-            raise RuntimeError(f"Command: {command}\nError with retcode: {exc.returncode}\n Output: {exc.output}") from exc
+            raise RuntimeError(
+                f"Command: {command}\nError:\n" f"return code: {exc.returncode}\n" f"output: {exc.output}"
+            ) from exc
         except OSError as exc:
             raise RuntimeError(f"Command: {command}\nOutput: {exc.strerror}") from exc
         finally:
@@ -128,19 +129,22 @@ class LocalShell(Shell):
         end_time: datetime,
         result: Optional[CommandResult],
     ) -> None:
-        if not result:
+        # TODO: increase logging level if return code is non 0, should be warning at least
-            logger.warning(f"Command: {command}\n" f"Error: result is None")
+        logger.info(
-            return
+            f"Command: {command}\n"
-
+            f"{'Success:' if result and result.return_code == 0 else 'Error:'}\n"
-        status, log_method = ("Success", logger.info) if result.return_code == 0 else ("Error", logger.warning)
+            f"return code: {result.return_code if result else ''} "
-        log_method(f"Command: {command}\n" f"{status} with retcode {result.return_code}\n" f"Output: \n{result.stdout}")
+            f"\nOutput: {result.stdout if result else ''}"
-
-        elapsed_time = end_time - start_time
-        command_attachment = (
-            f"COMMAND: {command}\n"
-            f"RETCODE: {result.return_code}\n\n"
-            f"STDOUT:\n{result.stdout}\n"
-            f"STDERR:\n{result.stderr}\n"
-            f"Start / End / Elapsed\t {start_time.time()} / {end_time.time()} / {elapsed_time}"
         )
-        reporter.attach(command_attachment, "Command execution.txt")
+
+        if result:
+            elapsed_time = end_time - start_time
+            command_attachment = (
+                f"COMMAND: {command}\n"
+                f"RETCODE: {result.return_code}\n\n"
+                f"STDOUT:\n{result.stdout}\n"
+                f"STDERR:\n{result.stderr}\n"
+                f"Start / End / Elapsed\t {start_time.time()} / {end_time.time()} / {elapsed_time}"
+            )
+            with reporter.step(f"COMMAND: {command}"):
+                reporter.attach(command_attachment, "Command execution.txt")

src/frostfs_testlib/steps/acl.py

@@ -11,20 +11,25 @@ import base58
 from frostfs_testlib import reporter
 from frostfs_testlib.cli import FrostfsCli
 from frostfs_testlib.resources.cli import FROSTFS_CLI_EXEC
-from frostfs_testlib.resources.common import ASSETS_DIR
+from frostfs_testlib.resources.common import ASSETS_DIR, DEFAULT_WALLET_CONFIG
 from frostfs_testlib.shell import Shell
-from frostfs_testlib.storage.dataclasses.acl import EACL_LIFETIME, FROSTFS_CONTRACT_CACHE_TIMEOUT, EACLPubKey, EACLRole, EACLRule
+from frostfs_testlib.storage.dataclasses.acl import (
-from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
+    EACL_LIFETIME,
+    FROSTFS_CONTRACT_CACHE_TIMEOUT,
+    EACLPubKey,
+    EACLRole,
+    EACLRule,
+)
 from frostfs_testlib.utils import wallet_utils
 
 logger = logging.getLogger("NeoLogger")
 
 
 @reporter.step("Get extended ACL")
-def get_eacl(wallet: WalletInfo, cid: str, shell: Shell, endpoint: str) -> Optional[str]:
+def get_eacl(wallet_path: str, cid: str, shell: Shell, endpoint: str) -> Optional[str]:
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, DEFAULT_WALLET_CONFIG)
     try:
-        result = cli.container.get_eacl(rpc_endpoint=endpoint, cid=cid)
+        result = cli.container.get_eacl(wallet=wallet_path, rpc_endpoint=endpoint, cid=cid)
     except RuntimeError as exc:
         logger.info("Extended ACL table is not set for this container")
         logger.info(f"Got exception while getting eacl: {exc}")
@@ -36,15 +41,16 @@ def get_eacl(wallet: WalletInfo, cid: str, shell: Shell, endpoint: str) -> Optio
 
 @reporter.step("Set extended ACL")
 def set_eacl(
-    wallet: WalletInfo,
+    wallet_path: str,
     cid: str,
     eacl_table_path: str,
     shell: Shell,
     endpoint: str,
     session_token: Optional[str] = None,
 ) -> None:
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, DEFAULT_WALLET_CONFIG)
     cli.container.set_eacl(
+        wallet=wallet_path,
         rpc_endpoint=endpoint,
         cid=cid,
         table=eacl_table_path,
@@ -60,7 +66,7 @@ def _encode_cid_for_eacl(cid: str) -> str:
 
 def create_eacl(cid: str, rules_list: List[EACLRule], shell: Shell) -> str:
     table_file_path = os.path.join(os.getcwd(), ASSETS_DIR, f"eacl_table_{str(uuid.uuid4())}.json")
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, DEFAULT_WALLET_CONFIG)
     cli.acl.extended_create(cid=cid, out=table_file_path, rule=rules_list)
 
     with open(table_file_path, "r") as file:
@@ -71,7 +77,7 @@ def create_eacl(cid: str, rules_list: List[EACLRule], shell: Shell) -> str:
 
 
 def form_bearertoken_file(
-    wallet: WalletInfo,
+    wif: str,
     cid: str,
     eacl_rule_list: List[Union[EACLRule, EACLPubKey]],
     shell: Shell,
@@ -86,7 +92,7 @@ def form_bearertoken_file(
     enc_cid = _encode_cid_for_eacl(cid) if cid else None
     file_path = os.path.join(os.getcwd(), ASSETS_DIR, str(uuid.uuid4()))
 
-    eacl = get_eacl(wallet, cid, shell, endpoint)
+    eacl = get_eacl(wif, cid, shell, endpoint)
     json_eacl = dict()
     if eacl:
         eacl = eacl.replace("eACL: ", "").split("Signature")[0]
@@ -127,7 +133,7 @@ def form_bearertoken_file(
     if sign:
         sign_bearer(
             shell=shell,
-            wallet=wallet,
+            wallet_path=wif,
             eacl_rules_file_from=file_path,
             eacl_rules_file_to=file_path,
             json=True,
@@ -158,9 +164,11 @@ def eacl_rules(access: str, verbs: list, user: str) -> list[str]:
     return rules
 
 
-def sign_bearer(shell: Shell, wallet: WalletInfo, eacl_rules_file_from: str, eacl_rules_file_to: str, json: bool) -> None:
+def sign_bearer(shell: Shell, wallet_path: str, eacl_rules_file_from: str, eacl_rules_file_to: str, json: bool) -> None:
-    frostfscli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    frostfscli = FrostfsCli(shell=shell, frostfs_cli_exec_path=FROSTFS_CLI_EXEC, config_file=DEFAULT_WALLET_CONFIG)
-    frostfscli.util.sign_bearer_token(eacl_rules_file_from, eacl_rules_file_to, json=json)
+    frostfscli.util.sign_bearer_token(
+        wallet=wallet_path, from_file=eacl_rules_file_from, to_file=eacl_rules_file_to, json=json
+    )
 
 
 @reporter.step("Wait for eACL cache expired")
@@ -170,7 +178,9 @@ def wait_for_cache_expired():
 
 
 @reporter.step("Return bearer token in base64 to caller")
-def bearer_token_base64_from_file(bearer_path: str) -> str:
+def bearer_token_base64_from_file(
+    bearer_path: str,
+) -> str:
     with open(bearer_path, "rb") as file:
         signed = file.read()
     return base64.b64encode(signed).decode("utf-8")

src/frostfs_testlib/steps/cli/container.py

@@ -1,15 +1,15 @@
 import json
 import logging
 import re
+import requests
 from dataclasses import dataclass
 from time import sleep
 from typing import Optional, Union
 
 from frostfs_testlib import reporter
 from frostfs_testlib.cli import FrostfsCli
-from frostfs_testlib.plugins import load_plugin
 from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT, FROSTFS_CLI_EXEC
-from frostfs_testlib.s3.interfaces import BucketContainerResolver
+from frostfs_testlib.resources.common import DEFAULT_WALLET_CONFIG
 from frostfs_testlib.shell import Shell
 from frostfs_testlib.steps.cli.object import put_object, put_object_to_random_node
 from frostfs_testlib.storage.cluster import Cluster, ClusterNode
@@ -24,7 +24,7 @@ logger = logging.getLogger("NeoLogger")
 @dataclass
 class StorageContainerInfo:
     id: str
-    wallet: WalletInfo
+    wallet_file: WalletInfo
 
 
 class StorageContainer:
@@ -41,8 +41,11 @@ class StorageContainer:
     def get_id(self) -> str:
         return self.storage_container_info.id
 
-    def get_wallet(self) -> str:
+    def get_wallet_path(self) -> str:
-        return self.storage_container_info.wallet
+        return self.storage_container_info.wallet_file.path
+
+    def get_wallet_config_path(self) -> str:
+        return self.storage_container_info.wallet_file.config_path
 
     @reporter.step("Generate new object and put in container")
     def generate_object(
@@ -57,34 +60,37 @@ class StorageContainer:
             file_hash = get_file_hash(file_path)
 
         container_id = self.get_id()
-        wallet = self.get_wallet()
+        wallet_path = self.get_wallet_path()
+        wallet_config = self.get_wallet_config_path()
         with reporter.step(f"Put object with size {size} to container {container_id}"):
             if endpoint:
                 object_id = put_object(
-                    wallet=wallet,
+                    wallet=wallet_path,
                     path=file_path,
                     cid=container_id,
                     expire_at=expire_at,
                     shell=self.shell,
                     endpoint=endpoint,
                     bearer=bearer_token,
+                    wallet_config=wallet_config,
                 )
             else:
                 object_id = put_object_to_random_node(
-                    wallet=wallet,
+                    wallet=wallet_path,
                     path=file_path,
                     cid=container_id,
                     expire_at=expire_at,
                     shell=self.shell,
                     cluster=self.cluster,
                     bearer=bearer_token,
+                    wallet_config=wallet_config,
                 )
 
             storage_object = StorageObjectInfo(
                 container_id,
                 object_id,
                 size=size,
-                wallet=wallet,
+                wallet_file_path=wallet_path,
                 file_path=file_path,
                 file_hash=file_hash,
             )
@@ -95,18 +101,18 @@ class StorageContainer:
 DEFAULT_PLACEMENT_RULE = "REP 2 IN X CBF 1 SELECT 4 FROM * AS X"
 SINGLE_PLACEMENT_RULE = "REP 1 IN X CBF 1 SELECT 4 FROM * AS X"
 REP_2_FOR_3_NODES_PLACEMENT_RULE = "REP 2 IN X CBF 1 SELECT 3 FROM * AS X"
-DEFAULT_EC_PLACEMENT_RULE = "EC 3.1"
 
 
 @reporter.step("Create Container")
 def create_container(
-    wallet: WalletInfo,
+    wallet: str,
     shell: Shell,
     endpoint: str,
     rule: str = DEFAULT_PLACEMENT_RULE,
     basic_acl: str = "",
     attributes: Optional[dict] = None,
     session_token: str = "",
+    session_wallet: str = "",
     name: Optional[str] = None,
     options: Optional[dict] = None,
     await_mode: bool = True,
@@ -117,7 +123,7 @@ def create_container(
     A wrapper for `frostfs-cli container create` call.
 
     Args:
-        wallet (WalletInfo): a wallet on whose behalf a container is created
+        wallet (str): a wallet on whose behalf a container is created
         rule (optional, str): placement rule for container
         basic_acl (optional, str): an ACL for container, will be
                             appended to `--basic-acl` key
@@ -139,9 +145,10 @@ def create_container(
         (str): CID of the created container
     """
 
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, DEFAULT_WALLET_CONFIG)
     result = cli.container.create(
         rpc_endpoint=endpoint,
+        wallet=session_wallet if session_wallet else wallet,
         policy=rule,
         basic_acl=basic_acl,
         attributes=attributes,
@@ -162,7 +169,9 @@ def create_container(
     return cid
 
 
-def wait_for_container_creation(wallet: WalletInfo, cid: str, shell: Shell, endpoint: str, attempts: int = 15, sleep_interval: int = 1):
+def wait_for_container_creation(
+    wallet: str, cid: str, shell: Shell, endpoint: str, attempts: int = 15, sleep_interval: int = 1
+):
     for _ in range(attempts):
         containers = list_containers(wallet, shell, endpoint)
         if cid in containers:
@@ -172,7 +181,9 @@ def wait_for_container_creation(wallet: WalletInfo, cid: str, shell: Shell, endp
     raise RuntimeError(f"After {attempts * sleep_interval} seconds container {cid} hasn't been persisted; exiting")
 
 
-def wait_for_container_deletion(wallet: WalletInfo, cid: str, shell: Shell, endpoint: str, attempts: int = 30, sleep_interval: int = 1):
+def wait_for_container_deletion(
+    wallet: str, cid: str, shell: Shell, endpoint: str, attempts: int = 30, sleep_interval: int = 1
+):
     for _ in range(attempts):
         try:
             get_container(wallet, cid, shell=shell, endpoint=endpoint)
@@ -186,26 +197,29 @@ def wait_for_container_deletion(wallet: WalletInfo, cid: str, shell: Shell, endp
 
 
 @reporter.step("List Containers")
-def list_containers(wallet: WalletInfo, shell: Shell, endpoint: str, timeout: Optional[str] = CLI_DEFAULT_TIMEOUT) -> list[str]:
+def list_containers(
+    wallet: str, shell: Shell, endpoint: str, timeout: Optional[str] = CLI_DEFAULT_TIMEOUT
+) -> list[str]:
     """
     A wrapper for `frostfs-cli container list` call. It returns all the
     available containers for the given wallet.
     Args:
-        wallet (WalletInfo): a wallet on whose behalf we list the containers
+        wallet (str): a wallet on whose behalf we list the containers
         shell: executor for cli command
         endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
         timeout: Timeout for the operation.
     Returns:
         (list): list of containers
     """
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, DEFAULT_WALLET_CONFIG)
-    result = cli.container.list(rpc_endpoint=endpoint, timeout=timeout)
+    result = cli.container.list(rpc_endpoint=endpoint, wallet=wallet, timeout=timeout)
+    logger.info(f"Containers: \n{result}")
     return result.stdout.split()
 
 
 @reporter.step("List Objects in container")
 def list_objects(
-    wallet: WalletInfo,
+    wallet: str,
     shell: Shell,
     container_id: str,
     endpoint: str,
@@ -215,7 +229,7 @@ def list_objects(
     A wrapper for `frostfs-cli container list-objects` call. It returns all the
     available objects in container.
     Args:
-        wallet (WalletInfo): a wallet on whose behalf we list the containers objects
+        wallet (str): a wallet on whose behalf we list the containers objects
         shell: executor for cli command
         container_id: cid of container
         endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
@@ -223,15 +237,15 @@ def list_objects(
     Returns:
         (list): list of containers
     """
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, DEFAULT_WALLET_CONFIG)
-    result = cli.container.list_objects(rpc_endpoint=endpoint, cid=container_id, timeout=timeout)
+    result = cli.container.list_objects(rpc_endpoint=endpoint, wallet=wallet, cid=container_id, timeout=timeout)
     logger.info(f"Container objects: \n{result}")
     return result.stdout.split()
 
 
 @reporter.step("Get Container")
 def get_container(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     shell: Shell,
     endpoint: str,
@@ -242,7 +256,7 @@ def get_container(
     A wrapper for `frostfs-cli container get` call. It extracts container's
     attributes and rearranges them into a more compact view.
     Args:
-        wallet (WalletInfo): path to a wallet on whose behalf we get the container
+        wallet (str): path to a wallet on whose behalf we get the container
         cid (str): ID of the container to get
         shell: executor for cli command
         endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
@@ -252,8 +266,8 @@ def get_container(
         (dict, str): dict of container attributes
     """
 
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, DEFAULT_WALLET_CONFIG)
-    result = cli.container.get(rpc_endpoint=endpoint, cid=cid, json_mode=json_mode, timeout=timeout)
+    result = cli.container.get(rpc_endpoint=endpoint, wallet=wallet, cid=cid, json_mode=json_mode, timeout=timeout)
 
     if not json_mode:
         return result.stdout
@@ -270,34 +284,37 @@ def get_container(
 @reporter.step("Delete Container")
 # TODO: make the error message about a non-found container more user-friendly
 def delete_container(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     shell: Shell,
     endpoint: str,
     force: bool = False,
     session_token: Optional[str] = None,
     await_mode: bool = False,
+    timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
 ) -> None:
     """
     A wrapper for `frostfs-cli container delete` call.
     Args:
-        await_mode: Block execution until container is removed.
+        wallet (str): path to a wallet on whose behalf we delete the container
-        wallet (WalletInfo): path to a wallet on whose behalf we delete the container
         cid (str): ID of the container to delete
         shell: executor for cli command
         endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
         force (bool): do not check whether container contains locks and remove immediately
         session_token: a path to session token file
+        timeout: Timeout for the operation.
     This function doesn't return anything.
     """
 
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, DEFAULT_WALLET_CONFIG)
     cli.container.delete(
+        wallet=wallet,
         cid=cid,
         rpc_endpoint=endpoint,
         force=force,
         session=session_token,
         await_mode=await_mode,
+        timeout=timeout,
     )
 
 
@@ -327,17 +344,28 @@ def _parse_cid(output: str) -> str:
     return splitted[1]
 
 
+@reporter.step("Search container by name")
+def search_container_by_name(name: str, node: ClusterNode):
+    node_shell = node.host.get_shell()
+    output = node_shell.exec(f"curl -I HEAD http://127.0.0.1:8084/{name}")
+    pattern = r"X-Container-Id: (\S+)"
+    cid = re.findall(pattern, output.stdout)
+    if cid:
+        return cid[0]
+    return None
+
+
 @reporter.step("Search for nodes with a container")
 def search_nodes_with_container(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     shell: Shell,
     endpoint: str,
     cluster: Cluster,
     timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
 ) -> list[ClusterNode]:
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, DEFAULT_WALLET_CONFIG)
-    result = cli.container.search_node(rpc_endpoint=endpoint, cid=cid, timeout=timeout)
+    result = cli.container.search_node(rpc_endpoint=endpoint, wallet=wallet, cid=cid, timeout=timeout)
 
     pattern = r"[0-9]+(?:\.[0-9]+){3}"
     nodes_ip = list(set(re.findall(pattern, result.stdout)))

src/frostfs_testlib/steps/cli/object.py

@@ -9,21 +9,18 @@ from frostfs_testlib import reporter
 from frostfs_testlib.cli import FrostfsCli
 from frostfs_testlib.cli.neogo import NeoGo
 from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT, FROSTFS_CLI_EXEC, NEOGO_EXECUTABLE
-from frostfs_testlib.resources.common import ASSETS_DIR
+from frostfs_testlib.resources.common import ASSETS_DIR, DEFAULT_WALLET_CONFIG
 from frostfs_testlib.shell import Shell
 from frostfs_testlib.storage.cluster import Cluster, ClusterNode
-from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
-from frostfs_testlib.testing import wait_for_success
 from frostfs_testlib.utils import json_utils
-from frostfs_testlib.utils.cli_utils import parse_netmap_output
+from frostfs_testlib.utils.cli_utils import parse_cmd_table, parse_netmap_output
-from frostfs_testlib.utils.file_utils import TestFile
 
 logger = logging.getLogger("NeoLogger")
 
 
 @reporter.step("Get object from random node")
 def get_object_from_random_node(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     oid: str,
     shell: Shell,
@@ -31,6 +28,7 @@ def get_object_from_random_node(
     bearer: Optional[str] = None,
     write_object: Optional[str] = None,
     xhdr: Optional[dict] = None,
+    wallet_config: Optional[str] = None,
     no_progress: bool = True,
     session: Optional[str] = None,
     timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
@@ -46,6 +44,7 @@ def get_object_from_random_node(
         cluster: cluster object
         bearer (optional, str): path to Bearer Token file, appends to `--bearer` key
         write_object (optional, str): path to downloaded file, appends to `--file` key
+        wallet_config(optional, str): path to the wallet config
         no_progress(optional, bool): do not show progress bar
         xhdr (optional, dict): Request X-Headers in form of Key=Value
         session (optional, dict): path to a JSON-encoded container session token
@@ -63,6 +62,7 @@ def get_object_from_random_node(
         bearer,
         write_object,
         xhdr,
+        wallet_config,
         no_progress,
         session,
         timeout,
@@ -71,7 +71,7 @@ def get_object_from_random_node(
 
 @reporter.step("Get object from {endpoint}")
 def get_object(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     oid: str,
     shell: Shell,
@@ -79,21 +79,23 @@ def get_object(
     bearer: Optional[str] = None,
     write_object: Optional[str] = None,
     xhdr: Optional[dict] = None,
+    wallet_config: Optional[str] = None,
     no_progress: bool = True,
     session: Optional[str] = None,
     timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
-) -> TestFile:
+) -> str:
     """
     GET from FrostFS.
 
     Args:
-        wallet (WalletInfo): wallet on whose behalf GET is done
+        wallet (str): wallet on whose behalf GET is done
         cid (str): ID of Container where we get the Object from
         oid (str): Object ID
         shell: executor for cli command
         bearer: path to Bearer Token file, appends to `--bearer` key
         write_object: path to downloaded file, appends to `--file` key
         endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
+        wallet_config(optional, str): path to the wallet config
         no_progress(optional, bool): do not show progress bar
         xhdr (optional, dict): Request X-Headers in form of Key=Value
         session (optional, dict): path to a JSON-encoded container session token
@@ -104,14 +106,15 @@ def get_object(
 
     if not write_object:
         write_object = str(uuid.uuid4())
-    test_file = TestFile(os.path.join(ASSETS_DIR, write_object))
+    file_path = os.path.join(ASSETS_DIR, write_object)
 
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet_config or DEFAULT_WALLET_CONFIG)
     cli.object.get(
         rpc_endpoint=endpoint,
+        wallet=wallet,
         cid=cid,
         oid=oid,
-        file=test_file,
+        file=file_path,
         bearer=bearer,
         no_progress=no_progress,
         xhdr=xhdr,
@@ -119,18 +122,19 @@ def get_object(
         timeout=timeout,
     )
 
-    return test_file
+    return file_path
 
 
 @reporter.step("Get Range Hash from {endpoint}")
 def get_range_hash(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     oid: str,
     range_cut: str,
     shell: Shell,
     endpoint: str,
     bearer: Optional[str] = None,
+    wallet_config: Optional[str] = None,
     xhdr: Optional[dict] = None,
     session: Optional[str] = None,
     timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
@@ -147,15 +151,17 @@ def get_range_hash(
         range_cut: Range to take hash from in the form offset1:length1,...,
                         value to pass to the `--range` parameter
         endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
+        wallet_config: path to the wallet config
         xhdr: Request X-Headers in form of Key=Values
         session: Filepath to a JSON- or binary-encoded token of the object RANGEHASH session.
         timeout: Timeout for the operation.
     Returns:
         None
     """
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet_config or DEFAULT_WALLET_CONFIG)
     result = cli.object.hash(
         rpc_endpoint=endpoint,
+        wallet=wallet,
         cid=cid,
         oid=oid,
         range=range_cut,
@@ -171,7 +177,7 @@ def get_range_hash(
 
 @reporter.step("Put object to random node")
 def put_object_to_random_node(
-    wallet: WalletInfo,
+    wallet: str,
     path: str,
     cid: str,
     shell: Shell,
@@ -180,6 +186,7 @@ def put_object_to_random_node(
     copies_number: Optional[int] = None,
     attributes: Optional[dict] = None,
     xhdr: Optional[dict] = None,
+    wallet_config: Optional[str] = None,
     expire_at: Optional[int] = None,
     no_progress: bool = True,
     session: Optional[str] = None,
@@ -198,6 +205,7 @@ def put_object_to_random_node(
         copies_number: Number of copies of the object to store within the RPC call
         attributes: User attributes in form of Key1=Value1,Key2=Value2
         cluster: cluster under test
+        wallet_config: path to the wallet config
         no_progress: do not show progress bar
         expire_at: Last epoch in the life of the object
         xhdr: Request X-Headers in form of Key=Value
@@ -218,6 +226,7 @@ def put_object_to_random_node(
         copies_number,
         attributes,
         xhdr,
+        wallet_config,
         expire_at,
         no_progress,
         session,
@@ -227,7 +236,7 @@ def put_object_to_random_node(
 
 @reporter.step("Put object at {endpoint} in container {cid}")
 def put_object(
-    wallet: WalletInfo,
+    wallet: str,
     path: str,
     cid: str,
     shell: Shell,
@@ -236,6 +245,7 @@ def put_object(
     copies_number: Optional[int] = None,
     attributes: Optional[dict] = None,
     xhdr: Optional[dict] = None,
+    wallet_config: Optional[str] = None,
     expire_at: Optional[int] = None,
     no_progress: bool = True,
     session: Optional[str] = None,
@@ -253,6 +263,7 @@ def put_object(
         copies_number: Number of copies of the object to store within the RPC call
         attributes: User attributes in form of Key1=Value1,Key2=Value2
         endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
+        wallet_config: path to the wallet config
         no_progress: do not show progress bar
         expire_at: Last epoch in the life of the object
         xhdr: Request X-Headers in form of Key=Value
@@ -262,9 +273,10 @@ def put_object(
         (str): ID of uploaded Object
     """
 
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet_config or DEFAULT_WALLET_CONFIG)
     result = cli.object.put(
         rpc_endpoint=endpoint,
+        wallet=wallet,
         file=path,
         cid=cid,
         attributes=attributes,
@@ -285,12 +297,13 @@ def put_object(
 
 @reporter.step("Delete object {cid}/{oid} from {endpoint}")
 def delete_object(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     oid: str,
     shell: Shell,
     endpoint: str,
     bearer: str = "",
+    wallet_config: Optional[str] = None,
     xhdr: Optional[dict] = None,
     session: Optional[str] = None,
     timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
@@ -305,6 +318,7 @@ def delete_object(
         shell: executor for cli command
         bearer: path to Bearer Token file, appends to `--bearer` key
         endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
+        wallet_config: path to the wallet config
         xhdr: Request X-Headers in form of Key=Value
         session: path to a JSON-encoded container session token
         timeout: Timeout for the operation.
@@ -312,9 +326,10 @@ def delete_object(
         (str): Tombstone ID
     """
 
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet_config or DEFAULT_WALLET_CONFIG)
     result = cli.object.delete(
         rpc_endpoint=endpoint,
+        wallet=wallet,
         cid=cid,
         oid=oid,
         bearer=bearer,
@@ -330,12 +345,13 @@ def delete_object(
 
 @reporter.step("Get Range")
 def get_range(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     oid: str,
     range_cut: str,
     shell: Shell,
     endpoint: str,
+    wallet_config: Optional[str] = None,
     bearer: str = "",
     xhdr: Optional[dict] = None,
     session: Optional[str] = None,
@@ -352,35 +368,37 @@ def get_range(
         shell: executor for cli command
         endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
         bearer: path to Bearer Token file, appends to `--bearer` key
+        wallet_config: path to the wallet config
         xhdr: Request X-Headers in form of Key=Value
         session: path to a JSON-encoded container session token
         timeout: Timeout for the operation.
     Returns:
         (str, bytes) - path to the file with range content and content of this file as bytes
     """
-    test_file = TestFile(os.path.join(ASSETS_DIR, str(uuid.uuid4())))
+    range_file_path = os.path.join(ASSETS_DIR, str(uuid.uuid4()))
 
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet_config or DEFAULT_WALLET_CONFIG)
     cli.object.range(
         rpc_endpoint=endpoint,
+        wallet=wallet,
         cid=cid,
         oid=oid,
         range=range_cut,
-        file=test_file,
+        file=range_file_path,
         bearer=bearer,
         xhdr=xhdr,
         session=session,
         timeout=timeout,
     )
 
-    with open(test_file, "rb") as file:
+    with open(range_file_path, "rb") as file:
         content = file.read()
-    return test_file, content
+    return range_file_path, content
 
 
 @reporter.step("Lock Object")
 def lock_object(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     oid: str,
     shell: Shell,
@@ -390,6 +408,7 @@ def lock_object(
     address: Optional[str] = None,
     bearer: Optional[str] = None,
     session: Optional[str] = None,
+    wallet_config: Optional[str] = None,
     ttl: Optional[int] = None,
     xhdr: Optional[dict] = None,
     timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
@@ -416,12 +435,13 @@ def lock_object(
         Lock object ID
     """
 
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet_config or DEFAULT_WALLET_CONFIG)
     result = cli.object.lock(
         rpc_endpoint=endpoint,
         lifetime=lifetime,
         expire_at=expire_at,
         address=address,
+        wallet=wallet,
         cid=cid,
         oid=oid,
         bearer=bearer,
@@ -439,13 +459,14 @@ def lock_object(
 
 @reporter.step("Search object")
 def search_object(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     shell: Shell,
     endpoint: str,
     bearer: str = "",
     filters: Optional[dict] = None,
     expected_objects_list: Optional[list] = None,
+    wallet_config: Optional[str] = None,
     xhdr: Optional[dict] = None,
     session: Optional[str] = None,
     phy: bool = False,
@@ -463,6 +484,7 @@ def search_object(
         endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
         filters: key=value pairs to filter Objects
         expected_objects_list: a list of ObjectIDs to compare found Objects with
+        wallet_config: path to the wallet config
         xhdr: Request X-Headers in form of Key=Value
         session: path to a JSON-encoded container session token
         phy: Search physically stored objects.
@@ -473,9 +495,10 @@ def search_object(
         list of found ObjectIDs
     """
 
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet_config or DEFAULT_WALLET_CONFIG)
     result = cli.object.search(
         rpc_endpoint=endpoint,
+        wallet=wallet,
         cid=cid,
         bearer=bearer,
         xhdr=xhdr,
@@ -490,18 +513,23 @@ def search_object(
 
     if expected_objects_list:
         if sorted(found_objects) == sorted(expected_objects_list):
-            logger.info(f"Found objects list '{found_objects}' " f"is equal for expected list '{expected_objects_list}'")
+            logger.info(
+                f"Found objects list '{found_objects}' " f"is equal for expected list '{expected_objects_list}'"
+            )
         else:
-            logger.warning(f"Found object list {found_objects} " f"is not equal to expected list '{expected_objects_list}'")
+            logger.warning(
+                f"Found object list {found_objects} " f"is not equal to expected list '{expected_objects_list}'"
+            )
 
     return found_objects
 
 
 @reporter.step("Get netmap netinfo")
 def get_netmap_netinfo(
-    wallet: WalletInfo,
+    wallet: str,
     shell: Shell,
     endpoint: str,
+    wallet_config: Optional[str] = None,
     address: Optional[str] = None,
     ttl: Optional[int] = None,
     xhdr: Optional[dict] = None,
@@ -511,7 +539,7 @@ def get_netmap_netinfo(
     Get netmap netinfo output from node
 
     Args:
-        wallet (WalletInfo): wallet on whose behalf request is done
+        wallet (str): wallet on whose behalf request is done
         shell: executor for cli command
         endpoint (optional, str): FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
         address: Address of wallet account
@@ -524,8 +552,9 @@ def get_netmap_netinfo(
         (dict): dict of parsed command output
     """
 
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet_config or DEFAULT_WALLET_CONFIG)
     output = cli.netmap.netinfo(
+        wallet=wallet,
         rpc_endpoint=endpoint,
         address=address,
         ttl=ttl,
@@ -549,7 +578,7 @@ def get_netmap_netinfo(
 
 @reporter.step("Head object")
 def head_object(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     oid: str,
     shell: Shell,
@@ -559,6 +588,7 @@ def head_object(
     json_output: bool = True,
     is_raw: bool = False,
     is_direct: bool = False,
+    wallet_config: Optional[str] = None,
     session: Optional[str] = None,
     timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
 ):
@@ -566,7 +596,7 @@ def head_object(
     HEAD an Object.
 
     Args:
-        wallet (WalletInfo): wallet on whose behalf HEAD is done
+        wallet (str): wallet on whose behalf HEAD is done
         cid (str): ID of Container where we get the Object from
         oid (str): ObjectID to HEAD
         shell: executor for cli command
@@ -578,6 +608,7 @@ def head_object(
                                     turns into `--raw` key
         is_direct(optional, bool): send request directly to the node or not; this flag
                                     turns into `--ttl 1` key
+        wallet_config(optional, str): path to the wallet config
         xhdr (optional, dict): Request X-Headers in form of Key=Value
         session (optional, dict): path to a JSON-encoded container session token
         timeout: Timeout for the operation.
@@ -588,9 +619,10 @@ def head_object(
         (str): HEAD response as a plain text
     """
 
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet_config or DEFAULT_WALLET_CONFIG)
     result = cli.object.head(
         rpc_endpoint=endpoint,
+        wallet=wallet,
         cid=cid,
         oid=oid,
         bearer=bearer,
@@ -616,32 +648,32 @@ def head_object(
         fst_line_idx = result.stdout.find("\n")
         decoded = json.loads(result.stdout[fst_line_idx:])
 
-    # if response
-    if "chunks" in decoded.keys():
-        logger.info("decoding ec chunks")
-        return decoded["chunks"]
-
     # If response is Complex Object header, it has `splitId` key
     if "splitId" in decoded.keys():
+        logger.info("decoding split header")
         return json_utils.decode_split_header(decoded)
 
     # If response is Last or Linking Object header,
     # it has `header` dictionary and non-null `split` dictionary
     if "split" in decoded["header"].keys():
         if decoded["header"]["split"]:
+            logger.info("decoding linking object")
             return json_utils.decode_linking_object(decoded)
 
     if decoded["header"]["objectType"] == "STORAGE_GROUP":
+        logger.info("decoding storage group")
         return json_utils.decode_storage_group(decoded)
 
     if decoded["header"]["objectType"] == "TOMBSTONE":
+        logger.info("decoding tombstone")
         return json_utils.decode_tombstone(decoded)
 
+    logger.info("decoding simple header")
     return json_utils.decode_simple_header(decoded)
 
 
 @reporter.step("Run neo-go dump-keys")
-def neo_go_dump_keys(shell: Shell, wallet: WalletInfo) -> dict:
+def neo_go_dump_keys(shell: Shell, wallet: str) -> dict:
     """
     Run neo-go dump keys command
 
@@ -690,56 +722,48 @@ def neo_go_query_height(shell: Shell, endpoint: str) -> dict:
     latest_block = first_line.split(":")
     # taking second line from command's output contain wallet key
     second_line = output.split("\n")[1]
-    if second_line != "":
+    validated_state = second_line.split(":")
-        validated_state = second_line.split(":")
+    return {
-        return {
+        latest_block[0].replace(":", ""): int(latest_block[1]),
-            latest_block[0].replace(":", ""): int(latest_block[1]),
+        validated_state[0].replace(":", ""): int(validated_state[1]),
-            validated_state[0].replace(":", ""): int(validated_state[1]),
+    }
-        }
-    return {latest_block[0].replace(":", ""): int(latest_block[1])}
 
 
-@wait_for_success()
 @reporter.step("Search object nodes")
 def get_object_nodes(
     cluster: Cluster,
+    wallet: str,
     cid: str,
     oid: str,
-    alive_node: ClusterNode,
+    shell: Shell,
+    endpoint: str,
     bearer: str = "",
     xhdr: Optional[dict] = None,
     is_direct: bool = False,
     verify_presence_all: bool = False,
+    wallet_config: Optional[str] = None,
     timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
 ) -> list[ClusterNode]:
-    shell = alive_node.host.get_shell()
+    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet_config or DEFAULT_WALLET_CONFIG)
-    endpoint = alive_node.storage_node.get_rpc_endpoint()
-    wallet = alive_node.storage_node.get_remote_wallet_path()
-    wallet_config = alive_node.storage_node.get_remote_wallet_config_path()
 
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet_config)
+    result_object_nodes = cli.object.nodes(
-
-    response = cli.object.nodes(
         rpc_endpoint=endpoint,
+        wallet=wallet,
         cid=cid,
         oid=oid,
         bearer=bearer,
         ttl=1 if is_direct else None,
-        json=True,
         xhdr=xhdr,
         timeout=timeout,
         verify_presence_all=verify_presence_all,
     )
 
-    response_json = json.loads(response.stdout)
+    parsing_output = parse_cmd_table(result_object_nodes.stdout, "|")
-    # Currently, the command will show expected and confirmed nodes.
+    list_object_nodes = [
-    # And we (currently) count only nodes which are both expected and confirmed
+        node
-    object_nodes_id = {
+        for node in parsing_output
-        required_node
+        if node["should_contain_object"] == "true" and node["actually_contains_object"] == "true"
-        for data_object in response_json["data_objects"]
+    ]
-        for required_node in data_object["required_nodes"]
-        if required_node in data_object["confirmed_nodes"]
-    }
 
     netmap_nodes_list = parse_netmap_output(
         cli.netmap.snapshot(
@@ -748,11 +772,17 @@ def get_object_nodes(
         ).stdout
     )
     netmap_nodes = [
-        netmap_node for object_node in object_nodes_id for netmap_node in netmap_nodes_list if object_node == netmap_node.node_id
+        netmap_node
+        for object_node in list_object_nodes
+        for netmap_node in netmap_nodes_list
+        if object_node["node_id"] == netmap_node.node_id
     ]
 
-    object_nodes = [
+    result = [
-        cluster_node for netmap_node in netmap_nodes for cluster_node in cluster.cluster_nodes if netmap_node.node == cluster_node.host_ip
+        cluster_node
+        for netmap_node in netmap_nodes
+        for cluster_node in cluster.cluster_nodes
+        if netmap_node.node == cluster_node.host_ip
     ]
 
-    return object_nodes
+    return result

src/frostfs_testlib/steps/cli/tree.py

@@ -1,35 +0,0 @@
-import logging
-from typing import Optional
-
-from frostfs_testlib import reporter
-from frostfs_testlib.cli import FrostfsCli
-from frostfs_testlib.plugins import load_plugin
-from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT, FROSTFS_CLI_EXEC
-from frostfs_testlib.shell import Shell
-from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
-
-logger = logging.getLogger("NeoLogger")
-
-
-
-@reporter.step("Get Tree List")
-def get_tree_list(
-    wallet: WalletInfo,
-    cid: str,
-    shell: Shell,
-    endpoint: str,
-    timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
-) -> None:
-    """
-    A wrapper for `frostfs-cli tree list` call.
-    Args:
-        wallet (WalletInfo): path to a wallet on whose behalf we delete the container
-        cid (str): ID of the container to delete
-        shell: executor for cli command
-        endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
-        timeout: Timeout for the operation.
-    This function doesn't return anything.
-    """
-
-    cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
-    cli.tree.list(cid=cid, rpc_endpoint=endpoint, timeout=timeout)

src/frostfs_testlib/steps/complex_object_actions.py

@@ -14,11 +14,11 @@ from typing import Optional, Tuple
 
 from frostfs_testlib import reporter
 from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT
+from frostfs_testlib.resources.common import DEFAULT_WALLET_CONFIG
 from frostfs_testlib.shell import Shell
 from frostfs_testlib.steps.cli.object import head_object
 from frostfs_testlib.storage.cluster import Cluster, StorageNode
 from frostfs_testlib.storage.dataclasses.storage_object_info import StorageObjectInfo
-from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
 
 logger = logging.getLogger("NeoLogger")
 
@@ -44,7 +44,7 @@ def get_storage_object_chunks(
 
     with reporter.step(f"Get complex object chunks (f{storage_object.oid})"):
         split_object_id = get_link_object(
-            storage_object.wallet,
+            storage_object.wallet_file_path,
             storage_object.cid,
             storage_object.oid,
             shell,
@@ -53,7 +53,7 @@ def get_storage_object_chunks(
             timeout=timeout,
         )
         head = head_object(
-            storage_object.wallet,
+            storage_object.wallet_file_path,
             storage_object.cid,
             split_object_id,
             shell,
@@ -96,7 +96,7 @@ def get_complex_object_split_ranges(
     chunks_ids = get_storage_object_chunks(storage_object, shell, cluster)
     for chunk_id in chunks_ids:
         head = head_object(
-            storage_object.wallet,
+            storage_object.wallet_file_path,
             storage_object.cid,
             chunk_id,
             shell,
@@ -114,12 +114,13 @@ def get_complex_object_split_ranges(
 
 @reporter.step("Get Link Object")
 def get_link_object(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     oid: str,
     shell: Shell,
     nodes: list[StorageNode],
     bearer: str = "",
+    wallet_config: str = DEFAULT_WALLET_CONFIG,
     is_direct: bool = True,
     timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
 ):
@@ -153,6 +154,7 @@ def get_link_object(
                 is_raw=True,
                 is_direct=is_direct,
                 bearer=bearer,
+                wallet_config=wallet_config,
                 timeout=timeout,
             )
             if resp["link"]:
@@ -165,7 +167,7 @@ def get_link_object(
 
 @reporter.step("Get Last Object")
 def get_last_object(
-    wallet: WalletInfo,
+    wallet: str,
     cid: str,
     oid: str,
     shell: Shell,

src/frostfs_testlib/steps/epoch.py

@@ -4,7 +4,13 @@ from typing import Optional
 
 from frostfs_testlib import reporter
 from frostfs_testlib.cli import FrostfsAdm, FrostfsCli, NeoGo
-from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT, FROSTFS_ADM_CONFIG_PATH, FROSTFS_ADM_EXEC, FROSTFS_CLI_EXEC, NEOGO_EXECUTABLE
+from frostfs_testlib.resources.cli import (
+    CLI_DEFAULT_TIMEOUT,
+    FROSTFS_ADM_CONFIG_PATH,
+    FROSTFS_ADM_EXEC,
+    FROSTFS_CLI_EXEC,
+    NEOGO_EXECUTABLE,
+)
 from frostfs_testlib.resources.common import MORPH_BLOCK_TIME
 from frostfs_testlib.shell import Shell
 from frostfs_testlib.steps.payment_neogo import get_contract_hash
@@ -69,7 +75,7 @@ def get_epoch(shell: Shell, cluster: Cluster, alive_node: Optional[StorageNode]
 
 
 @reporter.step("Tick Epoch")
-def tick_epoch(shell: Shell, cluster: Cluster, alive_node: Optional[StorageNode] = None, delta: Optional[int] = None):
+def tick_epoch(shell: Shell, cluster: Cluster, alive_node: Optional[StorageNode] = None):
     """
     Tick epoch using frostfs-adm or NeoGo if frostfs-adm is not available (DevEnv)
     Args:
@@ -88,17 +94,12 @@ def tick_epoch(shell: Shell, cluster: Cluster, alive_node: Optional[StorageNode]
             frostfs_adm_exec_path=FROSTFS_ADM_EXEC,
             config_file=FROSTFS_ADM_CONFIG_PATH,
         )
-        frostfs_adm.morph.force_new_epoch(delta=delta)
+        frostfs_adm.morph.force_new_epoch()
         return
 
     # Otherwise we tick epoch using transaction
     cur_epoch = get_epoch(shell, cluster)
 
-    if delta:
-        next_epoch = cur_epoch + delta
-    else:
-        next_epoch = cur_epoch + 1
-
     # Use first node by default
     ir_node = cluster.services(InnerRing)[0]
     # In case if no local_wallet_path is provided, we use wallet_path
@@ -115,7 +116,7 @@ def tick_epoch(shell: Shell, cluster: Cluster, alive_node: Optional[StorageNode]
         wallet_password=ir_wallet_pass,
         scripthash=get_contract_hash(morph_chain, "netmap.frostfs", shell=shell),
         method="newEpoch",
-        arguments=f"int:{next_epoch}",
+        arguments=f"int:{cur_epoch + 1}",
         multisig_hash=f"{ir_address}:Global",
         address=ir_address,
         rpc_endpoint=morph_endpoint,

src/frostfs_testlib/steps/http/http_gate.py

@@ -11,19 +11,19 @@ from urllib.parse import quote_plus
 import requests
 
 from frostfs_testlib import reporter
-from frostfs_testlib.cli import GenericCli
+from frostfs_testlib.resources.common import SIMPLE_OBJECT_SIZE
-from frostfs_testlib.resources.common import ASSETS_DIR, SIMPLE_OBJECT_SIZE
 from frostfs_testlib.s3.aws_cli_client import command_options
 from frostfs_testlib.shell import Shell
 from frostfs_testlib.shell.local_shell import LocalShell
 from frostfs_testlib.steps.cli.object import get_object
 from frostfs_testlib.steps.storage_policy import get_nodes_without_object
-from frostfs_testlib.storage.cluster import ClusterNode, StorageNode
+from frostfs_testlib.storage.cluster import StorageNode
 from frostfs_testlib.testing.test_control import retry
-from frostfs_testlib.utils.file_utils import TestFile, get_file_hash
+from frostfs_testlib.utils.file_utils import get_file_hash
 
 logger = logging.getLogger("NeoLogger")
 
+ASSETS_DIR = os.getenv("ASSETS_DIR", "TemporaryDir/")
 local_shell = LocalShell()
 
 
@@ -31,7 +31,8 @@ local_shell = LocalShell()
 def get_via_http_gate(
     cid: str,
     oid: str,
-    node: ClusterNode,
+    endpoint: str,
+    http_hostname: str,
     request_path: Optional[str] = None,
     timeout: Optional[int] = 300,
 ):
@@ -39,17 +40,18 @@ def get_via_http_gate(
     This function gets given object from HTTP gate
     cid:          container id to get object from
     oid:          object ID
-    node:         node to make request
+    endpoint:     http gate endpoint
+    http_hostname: http host name on the node
     request_path: (optional) http request, if ommited - use default [{endpoint}/get/{cid}/{oid}]
     """
 
     # if `request_path` parameter omitted, use default
     if request_path is None:
-        request = f"{node.http_gate.get_endpoint()}/get/{cid}/{oid}"
+        request = f"{endpoint}/get/{cid}/{oid}"
     else:
-        request = f"{node.http_gate.get_endpoint()}{request_path}"
+        request = f"{endpoint}{request_path}"
 
-    resp = requests.get(request, stream=True, timeout=timeout, verify=False)
+    resp = requests.get(request, headers={"Host": http_hostname}, stream=True, timeout=timeout, verify=False)
 
     if not resp.ok:
         raise Exception(
@@ -63,21 +65,22 @@ def get_via_http_gate(
     logger.info(f"Request: {request}")
     _attach_allure_step(request, resp.status_code)
 
-    test_file = TestFile(os.path.join(os.getcwd(), ASSETS_DIR, f"{cid}_{oid}"))
+    file_path = os.path.join(os.getcwd(), ASSETS_DIR, f"{cid}_{oid}")
-    with open(test_file, "wb") as file:
+    with open(file_path, "wb") as file:
         shutil.copyfileobj(resp.raw, file)
-    return test_file
+    return file_path
 
 
 @reporter.step("Get via Zip HTTP Gate")
-def get_via_zip_http_gate(cid: str, prefix: str, node: ClusterNode, timeout: Optional[int] = 300):
+def get_via_zip_http_gate(cid: str, prefix: str, endpoint: str, http_hostname: str, timeout: Optional[int] = 300):
     """
     This function gets given object from HTTP gate
     cid:      container id to get object from
     prefix:   common prefix
-    node:     node to make request
+    endpoint: http gate endpoint
+    http_hostname: http host name on the node
     """
-    request = f"{node.http_gate.get_endpoint()}/zip/{cid}/{prefix}"
+    request = f"{endpoint}/zip/{cid}/{prefix}"
     resp = requests.get(request, stream=True, timeout=timeout, verify=False)
 
     if not resp.ok:
@@ -92,11 +95,11 @@ def get_via_zip_http_gate(cid: str, prefix: str, node: ClusterNode, timeout: Opt
     logger.info(f"Request: {request}")
     _attach_allure_step(request, resp.status_code)
 
-    test_file = TestFile(os.path.join(os.getcwd(), ASSETS_DIR, f"{cid}_archive.zip"))
+    file_path = os.path.join(os.getcwd(), ASSETS_DIR, f"{cid}_archive.zip")
-    with open(test_file, "wb") as file:
+    with open(file_path, "wb") as file:
         shutil.copyfileobj(resp.raw, file)
 
-    with zipfile.ZipFile(test_file, "r") as zip_ref:
+    with zipfile.ZipFile(file_path, "r") as zip_ref:
         zip_ref.extractall(ASSETS_DIR)
 
     return os.path.join(os.getcwd(), ASSETS_DIR, prefix)
@@ -106,7 +109,8 @@ def get_via_zip_http_gate(cid: str, prefix: str, node: ClusterNode, timeout: Opt
 def get_via_http_gate_by_attribute(
     cid: str,
     attribute: dict,
-    node: ClusterNode,
+    endpoint: str,
+    http_hostname: str,
     request_path: Optional[str] = None,
     timeout: Optional[int] = 300,
 ):
@@ -115,17 +119,18 @@ def get_via_http_gate_by_attribute(
     cid:          CID to get object from
     attribute:    attribute {name: attribute} value pair
     endpoint:     http gate endpoint
+    http_hostname: http host name on the node
     request_path: (optional) http request path, if ommited - use default [{endpoint}/get_by_attribute/{Key}/{Value}]
     """
     attr_name = list(attribute.keys())[0]
     attr_value = quote_plus(str(attribute.get(attr_name)))
     # if `request_path` parameter ommited, use default
     if request_path is None:
-        request = f"{node.http_gate.get_endpoint()}/get_by_attribute/{cid}/{quote_plus(str(attr_name))}/{attr_value}"
+        request = f"{endpoint}/get_by_attribute/{cid}/{quote_plus(str(attr_name))}/{attr_value}"
     else:
-        request = f"{node.http_gate.get_endpoint()}{request_path}"
+        request = f"{endpoint}{request_path}"
 
-    resp = requests.get(request, stream=True, timeout=timeout, verify=False)
+    resp = requests.get(request, stream=True, timeout=timeout, verify=False, headers={"Host": http_hostname})
 
     if not resp.ok:
         raise Exception(
@@ -139,14 +144,17 @@ def get_via_http_gate_by_attribute(
     logger.info(f"Request: {request}")
     _attach_allure_step(request, resp.status_code)
 
-    test_file = TestFile(os.path.join(os.getcwd(), ASSETS_DIR, f"{cid}_{str(uuid.uuid4())}"))
+    file_path = os.path.join(os.getcwd(), ASSETS_DIR, f"{cid}_{str(uuid.uuid4())}")
-    with open(test_file, "wb") as file:
+    with open(file_path, "wb") as file:
         shutil.copyfileobj(resp.raw, file)
-    return test_file
+    return file_path
 
 
+# TODO: pass http_hostname as a header
 @reporter.step("Upload via HTTP Gate")
-def upload_via_http_gate(cid: str, path: str, endpoint: str, headers: Optional[dict] = None, timeout: Optional[int] = 300) -> str:
+def upload_via_http_gate(
+    cid: str, path: str, endpoint: str, headers: Optional[dict] = None, timeout: Optional[int] = 300
+) -> str:
     """
     This function upload given object through HTTP gate
     cid:      CID to get object from
@@ -189,6 +197,7 @@ def is_object_large(filepath: str) -> bool:
         return False
 
 
+# TODO: pass http_hostname as a header
 @reporter.step("Upload via HTTP Gate using Curl")
 def upload_via_http_gate_curl(
     cid: str,
@@ -238,20 +247,21 @@ def upload_via_http_gate_curl(
 
 @retry(max_attempts=3, sleep_interval=1)
 @reporter.step("Get via HTTP Gate using Curl")
-def get_via_http_curl(cid: str, oid: str, node: ClusterNode) -> TestFile:
+def get_via_http_curl(cid: str, oid: str, endpoint: str, http_hostname: str) -> str:
     """
     This function gets given object from HTTP gate using curl utility.
     cid:      CID to get object from
     oid:      object OID
-    node:     node for request
+    endpoint: http gate endpoint
+    http_hostname: http host name of the node
     """
-    request = f"{node.http_gate.get_endpoint()}/get/{cid}/{oid}"
+    request = f"{endpoint}/get/{cid}/{oid}"
-    test_file = TestFile(os.path.join(os.getcwd(), ASSETS_DIR, f"{cid}_{oid}_{str(uuid.uuid4())}"))
+    file_path = os.path.join(os.getcwd(), ASSETS_DIR, f"{cid}_{oid}_{str(uuid.uuid4())}")
 
-    curl = GenericCli("curl", node.host)
+    cmd = f'curl -k -H "Host: {http_hostname}"  {request} > {file_path}'
-    curl(f"-k ", f"{request} > {test_file}", shell=local_shell)
+    local_shell.exec(cmd)
 
-    return test_file
+    return file_path
 
 
 def _attach_allure_step(request: str, status_code: int, req_type="GET"):
@@ -264,11 +274,12 @@ def _attach_allure_step(request: str, status_code: int, req_type="GET"):
 def try_to_get_object_and_expect_error(
     cid: str,
     oid: str,
-    node: ClusterNode,
     error_pattern: str,
+    endpoint: str,
+    http_hostname: str,
 ) -> None:
     try:
-        get_via_http_gate(cid=cid, oid=oid, node=node)
+        get_via_http_gate(cid=cid, oid=oid, endpoint=endpoint, http_hostname=http_hostname)
         raise AssertionError(f"Expected error on getting object with cid: {cid}")
     except Exception as err:
         match = error_pattern.casefold() in str(err).casefold()
@@ -281,10 +292,13 @@ def get_object_by_attr_and_verify_hashes(
     file_name: str,
     cid: str,
     attrs: dict,
-    node: ClusterNode,
+    endpoint: str,
+    http_hostname: str,
 ) -> None:
-    got_file_path_http = get_via_http_gate(cid=cid, oid=oid, node=node)
+    got_file_path_http = get_via_http_gate(cid=cid, oid=oid, endpoint=endpoint, http_hostname=http_hostname)
-    got_file_path_http_attr = get_via_http_gate_by_attribute(cid=cid, attribute=attrs, node=node)
+    got_file_path_http_attr = get_via_http_gate_by_attribute(
+        cid=cid, attribute=attrs, endpoint=endpoint, http_hostname=http_hostname
+    )
     assert_hashes_are_equal(file_name, got_file_path_http, got_file_path_http_attr)
 
 
@@ -295,7 +309,8 @@ def verify_object_hash(
     cid: str,
     shell: Shell,
     nodes: list[StorageNode],
-    request_node: ClusterNode,
+    endpoint: str,
+    http_hostname: str,
     object_getter=None,
 ) -> None:
 
@@ -321,7 +336,7 @@ def verify_object_hash(
         shell=shell,
         endpoint=random_node.get_rpc_endpoint(),
     )
-    got_file_path_http = object_getter(cid=cid, oid=oid, node=request_node)
+    got_file_path_http = object_getter(cid=cid, oid=oid, endpoint=endpoint, http_hostname=http_hostname)
 
     assert_hashes_are_equal(file_name, got_file_path, got_file_path_http)
 
@@ -350,9 +365,10 @@ def attr_into_str_header_curl(attrs: dict) -> list:
 def try_to_get_object_via_passed_request_and_expect_error(
     cid: str,
     oid: str,
-    node: ClusterNode,
     error_pattern: str,
+    endpoint: str,
     http_request_path: str,
+    http_hostname: str,
     attrs: Optional[dict] = None,
 ) -> None:
     try:
@@ -360,15 +376,17 @@ def try_to_get_object_via_passed_request_and_expect_error(
             get_via_http_gate(
                 cid=cid,
                 oid=oid,
-                node=node,
+                endpoint=endpoint,
                 request_path=http_request_path,
+                http_hostname=http_hostname,
             )
         else:
             get_via_http_gate_by_attribute(
                 cid=cid,
                 attribute=attrs,
-                node=node,
+                endpoint=endpoint,
                 request_path=http_request_path,
+                http_hostname=http_hostname,
             )
         raise AssertionError(f"Expected error on getting object with cid: {cid}")
     except Exception as err:

src/frostfs_testlib/steps/metrics.py

@@ -1,45 +0,0 @@
-import re
-
-from frostfs_testlib import reporter
-from frostfs_testlib.storage.cluster import ClusterNode
-from frostfs_testlib.testing.test_control import wait_for_success
-
-
-@reporter.step("Check metrics result")
-@wait_for_success(interval=10)
-def check_metrics_counter(
-    cluster_nodes: list[ClusterNode],
-    operator: str = "==",
-    counter_exp: int = 0,
-    parse_from_command: bool = False,
-    **metrics_greps: str,
-):
-    counter_act = 0
-    for cluster_node in cluster_nodes:
-        counter_act += get_metrics_value(cluster_node, parse_from_command, **metrics_greps)
-    assert eval(
-        f"{counter_act} {operator} {counter_exp}"
-    ), f"Expected: {counter_exp} {operator} Actual: {counter_act} in nodes: {cluster_nodes}"
-
-
-@reporter.step("Get metrics value from node: {node}")
-def get_metrics_value(node: ClusterNode, parse_from_command: bool = False, **metrics_greps: str):
-    try:
-        command_result = node.metrics.storage.get_metrics_search_by_greps(**metrics_greps)
-        if parse_from_command:
-            metrics_counter = calc_metrics_count_from_stdout(command_result.stdout, **metrics_greps)
-        else:
-            metrics_counter = calc_metrics_count_from_stdout(command_result.stdout)
-    except RuntimeError as e:
-        metrics_counter = 0
-
-    return metrics_counter
-
-
-@reporter.step("Parse metrics count and calc sum of result")
-def calc_metrics_count_from_stdout(metric_result_stdout: str, command: str = None):
-    if command:
-        result = re.findall(rf"{command}\s*([\d.e+-]+)", metric_result_stdout)
-    else:
-        result = re.findall(r"}\s*([\d.e+-]+)", metric_result_stdout)
-    return sum(map(lambda x: int(float(x)), result))

src/frostfs_testlib/steps/network.py

@@ -4,18 +4,16 @@ from frostfs_testlib.storage.cluster import ClusterNode
 
 class IpHelper:
     @staticmethod
-    def drop_input_traffic_to_node(node: ClusterNode, block_ip: list[tuple]) -> None:
+    def drop_input_traffic_to_node(node: ClusterNode, block_ip: list[str]) -> None:
         shell = node.host.get_shell()
-        for ip, table in block_ip:
+        for ip in block_ip:
-            if not table:
+            shell.exec(f"ip route add blackhole {ip}")
-                shell.exec(f"ip r a blackhole {ip}")
-                continue
-            shell.exec(f"ip r a blackhole {ip} table {table}")
 
     @staticmethod
     def restore_input_traffic_to_node(node: ClusterNode) -> None:
         shell = node.host.get_shell()
-        unlock_ip = shell.exec("ip r l table all | grep blackhole", CommandOptions(check=False)).stdout
+        unlock_ip = shell.exec("ip route list | grep blackhole", CommandOptions(check=False))
-
+        if unlock_ip.return_code != 0:
-        for active_blackhole in unlock_ip.strip().split("\n"):
+            return
-            shell.exec(f"ip r d {active_blackhole}")
+        for ip in unlock_ip.stdout.strip().split("\n"):
+            shell.exec(f"ip route del blackhole {ip.split(' ')[1]}")

src/frostfs_testlib/steps/node_management.py

@@ -13,7 +13,7 @@ from frostfs_testlib.resources.common import MORPH_BLOCK_TIME
 from frostfs_testlib.shell import Shell
 from frostfs_testlib.steps.epoch import tick_epoch, wait_for_epochs_align
 from frostfs_testlib.storage.cluster import Cluster, StorageNode
-from frostfs_testlib.testing.test_control import wait_for_success
+from frostfs_testlib.storage.dataclasses.frostfs_services import S3Gate
 from frostfs_testlib.utils import datetime_utils
 
 logger = logging.getLogger("NeoLogger")
@@ -52,24 +52,9 @@ def storage_node_healthcheck(node: StorageNode) -> HealthStatus:
     Returns:
         health status as HealthStatus object.
     """
-
+    command = "control healthcheck"
-    host = node.host
+    output = _run_control_command_with_retries(node, command)
-    service_config = host.get_service_config(node.name)
+    return HealthStatus.from_stdout(output)
-    wallet_path = service_config.attributes["wallet_path"]
-    wallet_password = service_config.attributes["wallet_password"]
-    control_endpoint = service_config.attributes["control_endpoint"]
-
-    shell = host.get_shell()
-    wallet_config_path = f"/tmp/{node.name}-config.yaml"
-    wallet_config = f'wallet: {wallet_path}\npassword: "{wallet_password}"'
-    shell.exec(f"echo '{wallet_config}' > {wallet_config_path}")
-
-    cli_config = host.get_cli_config("frostfs-cli")
-
-    cli = FrostfsCli(shell, cli_config.exec_path, wallet_config_path)
-    result = cli.control.healthcheck(control_endpoint)
-
-    return HealthStatus.from_stdout(result.stdout)
 
 
 @reporter.step("Set status for {node}")
@@ -81,21 +66,8 @@ def storage_node_set_status(node: StorageNode, status: str, retries: int = 0) ->
         status: online or offline.
         retries (optional, int): number of retry attempts if it didn't work from the first time
     """
-    host = node.host
+    command = f"control set-status --status {status}"
-    service_config = host.get_service_config(node.name)
+    _run_control_command_with_retries(node, command, retries)
-    wallet_path = service_config.attributes["wallet_path"]
-    wallet_password = service_config.attributes["wallet_password"]
-    control_endpoint = service_config.attributes["control_endpoint"]
-
-    shell = host.get_shell()
-    wallet_config_path = f"/tmp/{node.name}-config.yaml"
-    wallet_config = f'wallet: {wallet_path}\npassword: "{wallet_password}"'
-    shell.exec(f"echo '{wallet_config}' > {wallet_config_path}")
-
-    cli_config = host.get_cli_config("frostfs-cli")
-
-    cli = FrostfsCli(shell, cli_config.exec_path, wallet_config_path)
-    cli.control.set_status(control_endpoint, status)
 
 
 @reporter.step("Get netmap snapshot")
@@ -112,11 +84,14 @@ def get_netmap_snapshot(node: StorageNode, shell: Shell) -> str:
     storage_wallet_path = node.get_wallet_path()
 
     cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, config_file=storage_wallet_config)
-    return cli.netmap.snapshot(rpc_endpoint=node.get_rpc_endpoint(), wallet=storage_wallet_path).stdout
+    return cli.netmap.snapshot(
+        rpc_endpoint=node.get_rpc_endpoint(),
+        wallet=storage_wallet_path,
+    ).stdout
 
 
 @reporter.step("Get shard list for {node}")
-def node_shard_list(node: StorageNode, json: Optional[bool] = None) -> list[str]:
+def node_shard_list(node: StorageNode) -> list[str]:
     """
     The function returns list of shards for specified storage node.
     Args:
@@ -124,72 +99,31 @@ def node_shard_list(node: StorageNode, json: Optional[bool] = None) -> list[str]
     Returns:
         list of shards.
     """
-    host = node.host
+    command = "control shards list"
-    service_config = host.get_service_config(node.name)
+    output = _run_control_command_with_retries(node, command)
-    wallet_path = service_config.attributes["wallet_path"]
+    return re.findall(r"Shard (.*):", output)
-    wallet_password = service_config.attributes["wallet_password"]
-    control_endpoint = service_config.attributes["control_endpoint"]
-
-    shell = host.get_shell()
-    wallet_config_path = f"/tmp/{node.name}-config.yaml"
-    wallet_config = f'wallet: {wallet_path}\npassword: "{wallet_password}"'
-    shell.exec(f"echo '{wallet_config}' > {wallet_config_path}")
-
-    cli_config = host.get_cli_config("frostfs-cli")
-
-    cli = FrostfsCli(shell, cli_config.exec_path, wallet_config_path)
-    result = cli.shards.list(endpoint=control_endpoint, json_mode=json)
-
-    return re.findall(r"Shard (.*):", result.stdout)
 
 
 @reporter.step("Shard set for {node}")
-def node_shard_set_mode(node: StorageNode, shard: list[str], mode: str) -> None:
+def node_shard_set_mode(node: StorageNode, shard: str, mode: str) -> str:
     """
     The function sets mode for specified shard.
     Args:
         node: node on which shard mode should be set.
     """
-    host = node.host
+    command = f"control shards set-mode --id {shard} --mode {mode}"
-    service_config = host.get_service_config(node.name)
+    return _run_control_command_with_retries(node, command)
-    wallet_path = service_config.attributes["wallet_path"]
-    wallet_password = service_config.attributes["wallet_password"]
-    control_endpoint = service_config.attributes["control_endpoint"]
-
-    shell = host.get_shell()
-    wallet_config_path = f"/tmp/{node.name}-config.yaml"
-    wallet_config = f'wallet: {wallet_path}\npassword: "{wallet_password}"'
-    shell.exec(f"echo '{wallet_config}' > {wallet_config_path}")
-
-    cli_config = host.get_cli_config("frostfs-cli")
-
-    cli = FrostfsCli(shell, cli_config.exec_path, wallet_config_path)
-    cli.shards.set_mode(endpoint=control_endpoint, mode=mode, id=shard)
 
 
 @reporter.step("Drop object from {node}")
-def drop_object(node: StorageNode, cid: str, oid: str) -> None:
+def drop_object(node: StorageNode, cid: str, oid: str) -> str:
     """
     The function drops object from specified node.
     Args:
-        node: node from which object should be dropped.
+        node_id str: node from which object should be dropped.
     """
-    host = node.host
+    command = f"control drop-objects  -o {cid}/{oid}"
-    service_config = host.get_service_config(node.name)
+    return _run_control_command_with_retries(node, command)
-    wallet_path = service_config.attributes["wallet_path"]
-    wallet_password = service_config.attributes["wallet_password"]
-    control_endpoint = service_config.attributes["control_endpoint"]
-
-    shell = host.get_shell()
-    wallet_config_path = f"/tmp/{node.name}-config.yaml"
-    wallet_config = f'wallet: {wallet_path}\npassword: "{wallet_password}"'
-    shell.exec(f"echo '{wallet_config}' > {wallet_config_path}")
-
-    cli_config = host.get_cli_config("frostfs-cli")
-
-    cli = FrostfsCli(shell, cli_config.exec_path, wallet_config_path)
-    objects = f"{cid}/{oid}"
-    cli.control.drop_objects(control_endpoint, objects)
 
 
 @reporter.step("Delete data from host for node {node}")
@@ -200,7 +134,12 @@ def delete_node_data(node: StorageNode) -> None:
 
 
 @reporter.step("Exclude node {node_to_exclude} from network map")
-def exclude_node_from_network_map(node_to_exclude: StorageNode, alive_node: StorageNode, shell: Shell, cluster: Cluster) -> None:
+def exclude_node_from_network_map(
+    node_to_exclude: StorageNode,
+    alive_node: StorageNode,
+    shell: Shell,
+    cluster: Cluster,
+) -> None:
     node_netmap_key = node_to_exclude.get_wallet_public_key()
 
     storage_node_set_status(node_to_exclude, status="offline")
@@ -214,7 +153,12 @@ def exclude_node_from_network_map(node_to_exclude: StorageNode, alive_node: Stor
 
 
 @reporter.step("Include node {node_to_include} into network map")
-def include_node_to_network_map(node_to_include: StorageNode, alive_node: StorageNode, shell: Shell, cluster: Cluster) -> None:
+def include_node_to_network_map(
+    node_to_include: StorageNode,
+    alive_node: StorageNode,
+    shell: Shell,
+    cluster: Cluster,
+) -> None:
     storage_node_set_status(node_to_include, status="online")
 
     # Per suggestion of @fyrchik we need to wait for 2 blocks after we set status and after tick epoch.
@@ -224,7 +168,7 @@ def include_node_to_network_map(node_to_include: StorageNode, alive_node: Storag
     tick_epoch(shell, cluster)
     time.sleep(datetime_utils.parse_time(MORPH_BLOCK_TIME) * 2)
 
-    await_node_in_map(node_to_include, shell, alive_node)
+    check_node_in_map(node_to_include, shell, alive_node)
 
 
 @reporter.step("Check node {node} in network map")
@@ -238,11 +182,6 @@ def check_node_in_map(node: StorageNode, shell: Shell, alive_node: Optional[Stor
     assert node_netmap_key in snapshot, f"Expected node with key {node_netmap_key} to be in network map"
 
 
-@wait_for_success(300, 15, title="Await node {node} in network map")
-def await_node_in_map(node: StorageNode, shell: Shell, alive_node: Optional[StorageNode] = None) -> None:
-    check_node_in_map(node, shell, alive_node)
-
-
 @reporter.step("Check node {node} NOT in network map")
 def check_node_not_in_map(node: StorageNode, shell: Shell, alive_node: Optional[StorageNode] = None) -> None:
     alive_node = alive_node or node
@@ -256,7 +195,7 @@ def check_node_not_in_map(node: StorageNode, shell: Shell, alive_node: Optional[
 
 @reporter.step("Wait for node {node} is ready")
 def wait_for_node_to_be_ready(node: StorageNode) -> None:
-    timeout, attempts = 60, 15
+    timeout, attempts = 30, 6
     for _ in range(attempts):
         try:
             health_check = storage_node_healthcheck(node)
@@ -269,7 +208,12 @@ def wait_for_node_to_be_ready(node: StorageNode) -> None:
 
 
 @reporter.step("Remove nodes from network map trough cli-adm morph command")
-def remove_nodes_from_map_morph(shell: Shell, cluster: Cluster, remove_nodes: list[StorageNode], alive_node: Optional[StorageNode] = None):
+def remove_nodes_from_map_morph(
+    shell: Shell,
+    cluster: Cluster,
+    remove_nodes: list[StorageNode],
+    alive_node: Optional[StorageNode] = None,
+):
     """
     Move node to the Offline state in the candidates list and tick an epoch to update the netmap
     using frostfs-adm
@@ -288,5 +232,44 @@ def remove_nodes_from_map_morph(shell: Shell, cluster: Cluster, remove_nodes: li
 
     if FROSTFS_ADM_EXEC and FROSTFS_ADM_CONFIG_PATH:
         # If frostfs-adm is available, then we tick epoch with it (to be consistent with UAT tests)
-        frostfsadm = FrostfsAdm(shell=remote_shell, frostfs_adm_exec_path=FROSTFS_ADM_EXEC, config_file=FROSTFS_ADM_CONFIG_PATH)
+        frostfsadm = FrostfsAdm(
+            shell=remote_shell,
+            frostfs_adm_exec_path=FROSTFS_ADM_EXEC,
+            config_file=FROSTFS_ADM_CONFIG_PATH,
+        )
         frostfsadm.morph.remove_nodes(node_netmap_keys)
+
+
+def _run_control_command_with_retries(node: StorageNode, command: str, retries: int = 0) -> str:
+    for attempt in range(1 + retries):  # original attempt + specified retries
+        try:
+            return _run_control_command(node, command)
+        except AssertionError as err:
+            if attempt < retries:
+                logger.warning(f"Command {command} failed with error {err} and will be retried")
+                continue
+            raise AssertionError(f"Command {command} failed with error {err}") from err
+
+
+def _run_control_command(node: StorageNode, command: str) -> None:
+    host = node.host
+
+    service_config = host.get_service_config(node.name)
+    wallet_path = service_config.attributes["wallet_path"]
+    wallet_password = service_config.attributes["wallet_password"]
+    control_endpoint = service_config.attributes["control_endpoint"]
+
+    shell = host.get_shell()
+    wallet_config_path = f"/tmp/{node.name}-config.yaml"
+    wallet_config = f'password: "{wallet_password}"'
+    shell.exec(f"echo '{wallet_config}' > {wallet_config_path}")
+
+    cli_config = host.get_cli_config("frostfs-cli")
+
+    # TODO: implement cli.control
+    # cli = FrostfsCli(shell, cli_config.exec_path, wallet_config_path)
+    result = shell.exec(
+        f"{cli_config.exec_path} {command} --endpoint {control_endpoint} "
+        f"--wallet {wallet_path} --config {wallet_config_path}"
+    )
+    return result.stdout

src/frostfs_testlib/steps/s3/s3_helper.py

@@ -1,17 +1,25 @@
+import json
 import logging
 import os
+import re
+import uuid
 from datetime import datetime, timedelta
 from typing import Optional
 
 from dateutil.parser import parse
 
 from frostfs_testlib import reporter
+from frostfs_testlib.cli import FrostfsAuthmate
+from frostfs_testlib.resources.cli import FROSTFS_AUTHMATE_EXEC
+from frostfs_testlib.resources.common import CREDENTIALS_CREATE_TIMEOUT
 from frostfs_testlib.s3 import S3ClientWrapper, VersioningStatus
-from frostfs_testlib.s3.interfaces import BucketContainerResolver
+from frostfs_testlib.shell import CommandOptions, InteractiveInput, Shell
-from frostfs_testlib.shell import Shell
+from frostfs_testlib.shell.interfaces import SshCredentials
-from frostfs_testlib.steps.cli.container import search_nodes_with_container
+from frostfs_testlib.steps.cli.container import search_container_by_name, search_nodes_with_container
 from frostfs_testlib.storage.cluster import Cluster, ClusterNode
+from frostfs_testlib.storage.dataclasses.frostfs_services import S3Gate
 from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
+from frostfs_testlib.utils.cli_utils import _run_with_passwd
 
 logger = logging.getLogger("NeoLogger")
 
@@ -30,7 +38,9 @@ def check_objects_in_bucket(
         assert bucket_object in bucket_objects, f"Expected object {bucket_object} in objects list {bucket_objects}"
 
     for bucket_object in unexpected_objects:
-        assert bucket_object not in bucket_objects, f"Expected object {bucket_object} not in objects list {bucket_objects}"
+        assert (
+            bucket_object not in bucket_objects
+        ), f"Expected object {bucket_object} not in objects list {bucket_objects}"
 
 
 @reporter.step("Try to get object and got error")
@@ -48,6 +58,7 @@ def set_bucket_versioning(s3_client: S3ClientWrapper, bucket: str, status: Versi
     if status == VersioningStatus.UNDEFINED:
         return
 
+    s3_client.get_bucket_versioning_status(bucket)
     s3_client.put_bucket_versioning(bucket, status=status)
     bucket_status = s3_client.get_bucket_versioning_status(bucket)
     assert bucket_status == status.value, f"Expected {bucket_status} status. Got {status.value}"
@@ -57,7 +68,9 @@ def object_key_from_file_path(full_path: str) -> str:
     return os.path.basename(full_path)
 
 
-def assert_tags(actual_tags: list, expected_tags: Optional[list] = None, unexpected_tags: Optional[list] = None) -> None:
+def assert_tags(
+    actual_tags: list, expected_tags: Optional[list] = None, unexpected_tags: Optional[list] = None
+) -> None:
     expected_tags = [{"Key": key, "Value": value} for key, value in expected_tags] if expected_tags else []
     unexpected_tags = [{"Key": key, "Value": value} for key, value in unexpected_tags] if unexpected_tags else []
     if expected_tags == []:
@@ -120,28 +133,69 @@ def assert_object_lock_mode(
         ).days == retain_period, f"Expected retention period is {retain_period} days"
 
 
-def _format_grants_as_strings(grants: list[dict]) -> list:
+def assert_s3_acl(acl_grants: list, permitted_users: str):
-    grantee_format = "{g_type}::{uri}:{permission}"
+    if permitted_users == "AllUsers":
-    return set(
+        grantees = {"AllUsers": 0, "CanonicalUser": 0}
-        [
+        for acl_grant in acl_grants:
-            grantee_format.format(
+            if acl_grant.get("Grantee", {}).get("Type") == "Group":
-                g_type=grant.get("Grantee", {}).get("Type", ""),
+                uri = acl_grant.get("Grantee", {}).get("URI")
-                uri=grant.get("Grantee", {}).get("URI", ""),
+                permission = acl_grant.get("Permission")
-                permission=grant.get("Permission", ""),
+                assert (uri, permission) == (
-            )
+                    "http://acs.amazonaws.com/groups/global/AllUsers",
-            for grant in grants
+                    "FULL_CONTROL",
-        ]
+                ), "All Groups should have FULL_CONTROL"
+                grantees["AllUsers"] += 1
+            if acl_grant.get("Grantee", {}).get("Type") == "CanonicalUser":
+                permission = acl_grant.get("Permission")
+                assert permission == "FULL_CONTROL", "Canonical User should have FULL_CONTROL"
+                grantees["CanonicalUser"] += 1
+        assert grantees["AllUsers"] >= 1, "All Users should have FULL_CONTROL"
+        assert grantees["CanonicalUser"] >= 1, "Canonical User should have FULL_CONTROL"
+
+    if permitted_users == "CanonicalUser":
+        for acl_grant in acl_grants:
+            if acl_grant.get("Grantee", {}).get("Type") == "CanonicalUser":
+                permission = acl_grant.get("Permission")
+                assert permission == "FULL_CONTROL", "Only CanonicalUser should have FULL_CONTROL"
+            else:
+                logger.error("FULL_CONTROL is given to All Users")
+
+
+@reporter.step("Init S3 Credentials")
+def init_s3_credentials(
+    wallet: WalletInfo,
+    shell: Shell,
+    cluster: Cluster,
+    policy: Optional[dict] = None,
+    s3gates: Optional[list[S3Gate]] = None,
+    container_placement_policy: Optional[str] = None,
+):
+    gate_public_keys = []
+    bucket = str(uuid.uuid4())
+    if not s3gates:
+        s3gates = [cluster.s3_gates[0]]
+    for s3gate in s3gates:
+        gate_public_keys.append(s3gate.get_wallet_public_key())
+    frostfs_authmate_exec: FrostfsAuthmate = FrostfsAuthmate(shell, FROSTFS_AUTHMATE_EXEC)
+    issue_secret_output = frostfs_authmate_exec.secret.issue(
+        wallet=wallet.path,
+        peer=cluster.default_rpc_endpoint,
+        gate_public_key=gate_public_keys,
+        wallet_password=wallet.password,
+        container_policy=policy,
+        container_friendly_name=bucket,
+        container_placement_policy=container_placement_policy,
+    ).stdout
+    aws_access_key_id = str(
+        re.search(r"access_key_id.*:\s.(?P<aws_access_key_id>\w*)", issue_secret_output).group("aws_access_key_id")
     )
-
+    aws_secret_access_key = str(
-
+        re.search(r"secret_access_key.*:\s.(?P<aws_secret_access_key>\w*)", issue_secret_output).group(
-@reporter.step("Verify ACL permissions")
+            "aws_secret_access_key"
-def verify_acl_permissions(actual_acl_grants: list[dict], expected_acl_grants: list[dict], strict: bool = True):
+        )
-    actual_grants = _format_grants_as_strings(actual_acl_grants)
+    )
-    expected_grants = _format_grants_as_strings(expected_acl_grants)
+    cid = str(re.search(r"container_id.*:\s.(?P<container_id>\w*)", issue_secret_output).group("container_id"))
-
+    return cid, aws_access_key_id, aws_secret_access_key
-    assert expected_grants <= actual_grants, "Permissions mismatch"
-    if strict:
-        assert expected_grants == actual_grants, "Extra permissions found, must not be there"
 
 
 @reporter.step("Delete bucket with all objects")
@@ -173,14 +227,13 @@ def delete_bucket_with_objects(s3_client: S3ClientWrapper, bucket: str):
 def search_nodes_with_bucket(
     cluster: Cluster,
     bucket_name: str,
-    wallet: WalletInfo,
+    wallet: str,
     shell: Shell,
     endpoint: str,
-    bucket_container_resolver: BucketContainerResolver,
 ) -> list[ClusterNode]:
     cid = None
     for cluster_node in cluster.cluster_nodes:
-        cid = bucket_container_resolver.resolve(cluster_node, bucket_name)
+        cid = search_container_by_name(name=bucket_name, node=cluster_node)
         if cid:
             break
     nodes_list = search_nodes_with_container(wallet=wallet, cid=cid, shell=shell, endpoint=endpoint, cluster=cluster)

src/frostfs_testlib/steps/session_token.py

@@ -4,12 +4,13 @@ import logging
 import os
 import uuid
 from dataclasses import dataclass
+from enum import Enum
 from typing import Any, Optional
 
 from frostfs_testlib import reporter
 from frostfs_testlib.cli import FrostfsCli
 from frostfs_testlib.resources.cli import FROSTFS_CLI_EXEC
-from frostfs_testlib.resources.common import ASSETS_DIR
+from frostfs_testlib.resources.common import ASSETS_DIR, DEFAULT_WALLET_CONFIG
 from frostfs_testlib.shell import Shell
 from frostfs_testlib.storage.dataclasses.storage_object_info import StorageObjectInfo
 from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
@@ -230,7 +231,8 @@ def get_object_signed_token(
 def create_session_token(
     shell: Shell,
     owner: str,
-    wallet: WalletInfo,
+    wallet_path: str,
+    wallet_password: str,
     rpc_endpoint: str,
 ) -> str:
     """
@@ -245,18 +247,19 @@ def create_session_token(
         The path to the generated session token file.
     """
     session_token = os.path.join(os.getcwd(), ASSETS_DIR, str(uuid.uuid4()))
-    frostfscli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    frostfscli = FrostfsCli(shell=shell, frostfs_cli_exec_path=FROSTFS_CLI_EXEC)
     frostfscli.session.create(
         rpc_endpoint=rpc_endpoint,
         address=owner,
+        wallet=wallet_path,
+        wallet_password=wallet_password,
         out=session_token,
-        wallet=wallet.path,
     )
     return session_token
 
 
 @reporter.step("Sign Session Token")
-def sign_session_token(shell: Shell, session_token_file: str, wallet: WalletInfo) -> str:
+def sign_session_token(shell: Shell, session_token_file: str, wlt: WalletInfo) -> str:
     """
     This function signs the session token by the given wallet.
 
@@ -269,6 +272,6 @@ def sign_session_token(shell: Shell, session_token_file: str, wallet: WalletInfo
         The path to the signed token.
     """
     signed_token_file = os.path.join(os.getcwd(), ASSETS_DIR, str(uuid.uuid4()))
-    frostfscli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
+    frostfscli = FrostfsCli(shell=shell, frostfs_cli_exec_path=FROSTFS_CLI_EXEC, config_file=DEFAULT_WALLET_CONFIG)
-    frostfscli.util.sign_session_token(session_token_file, signed_token_file)
+    frostfscli.util.sign_session_token(wallet=wlt.path, from_file=session_token_file, to_file=signed_token_file)
     return signed_token_file

src/frostfs_testlib/steps/storage_object.py

@@ -30,14 +30,14 @@ def delete_objects(storage_objects: list[StorageObjectInfo], shell: Shell, clust
     with reporter.step("Delete objects"):
         for storage_object in storage_objects:
             storage_object.tombstone = delete_object(
-                storage_object.wallet,
+                storage_object.wallet_file_path,
                 storage_object.cid,
                 storage_object.oid,
                 shell=shell,
                 endpoint=cluster.default_rpc_endpoint,
             )
             verify_head_tombstone(
-                wallet=storage_object.wallet,
+                wallet_path=storage_object.wallet_file_path,
                 cid=storage_object.cid,
                 oid_ts=storage_object.tombstone,
                 oid=storage_object.oid,
@@ -52,7 +52,7 @@ def delete_objects(storage_objects: list[StorageObjectInfo], shell: Shell, clust
         for storage_object in storage_objects:
             with pytest.raises(Exception, match=OBJECT_ALREADY_REMOVED):
                 get_object(
-                    storage_object.wallet,
+                    storage_object.wallet_file_path,
                     storage_object.cid,
                     storage_object.oid,
                     shell=shell,

src/frostfs_testlib/steps/storage_policy.py

@@ -12,15 +12,13 @@ from frostfs_testlib.shell import Shell
 from frostfs_testlib.steps.cli.object import head_object
 from frostfs_testlib.steps.complex_object_actions import get_last_object
 from frostfs_testlib.storage.cluster import StorageNode
-from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
 from frostfs_testlib.utils import string_utils
 
 logger = logging.getLogger("NeoLogger")
 
 
-# TODO: Unused, remove or make use of
 @reporter.step("Get Object Copies")
-def get_object_copies(complexity: str, wallet: WalletInfo, cid: str, oid: str, shell: Shell, nodes: list[StorageNode]) -> int:
+def get_object_copies(complexity: str, wallet: str, cid: str, oid: str, shell: Shell, nodes: list[StorageNode]) -> int:
     """
     The function performs requests to all nodes of the container and
     finds out if they store a copy of the object. The procedure is
@@ -45,7 +43,7 @@ def get_object_copies(complexity: str, wallet: WalletInfo, cid: str, oid: str, s
 
 
 @reporter.step("Get Simple Object Copies")
-def get_simple_object_copies(wallet: WalletInfo, cid: str, oid: str, shell: Shell, nodes: list[StorageNode]) -> int:
+def get_simple_object_copies(wallet: str, cid: str, oid: str, shell: Shell, nodes: list[StorageNode]) -> int:
     """
     To figure out the number of a simple object copies, only direct
     HEAD requests should be made to the every node of the container.
@@ -74,7 +72,7 @@ def get_simple_object_copies(wallet: WalletInfo, cid: str, oid: str, shell: Shel
 
 
 @reporter.step("Get Complex Object Copies")
-def get_complex_object_copies(wallet: WalletInfo, cid: str, oid: str, shell: Shell, nodes: list[StorageNode]) -> int:
+def get_complex_object_copies(wallet: str, cid: str, oid: str, shell: Shell, nodes: list[StorageNode]) -> int:
     """
     To figure out the number of a complex object copies, we firstly
     need to retrieve its Last object. We consider that the number of
@@ -111,7 +109,8 @@ def get_nodes_with_object(cid: str, oid: str, shell: Shell, nodes: list[StorageN
 
     nodes_list = []
     for node in nodes:
-        wallet = WalletInfo.from_node(node)
+        wallet = node.get_wallet_path()
+        wallet_config = node.get_wallet_config_path()
         try:
             res = head_object(
                 wallet,
@@ -120,6 +119,7 @@ def get_nodes_with_object(cid: str, oid: str, shell: Shell, nodes: list[StorageN
                 shell=shell,
                 endpoint=node.get_rpc_endpoint(),
                 is_direct=True,
+                wallet_config=wallet_config,
             )
             if res is not None:
                 logger.info(f"Found object {oid} on node {node}")
@@ -131,7 +131,9 @@ def get_nodes_with_object(cid: str, oid: str, shell: Shell, nodes: list[StorageN
 
 
 @reporter.step("Get Nodes Without Object")
-def get_nodes_without_object(wallet: WalletInfo, cid: str, oid: str, shell: Shell, nodes: list[StorageNode]) -> list[StorageNode]:
+def get_nodes_without_object(
+    wallet: str, cid: str, oid: str, shell: Shell, nodes: list[StorageNode]
+) -> list[StorageNode]:
     """
     The function returns list of nodes which do not store
     the given object.

src/frostfs_testlib/steps/tombstone.py

@@ -1,23 +1,31 @@
+import json
 import logging
 
+from neo3.wallet import wallet
+
 from frostfs_testlib import reporter
 from frostfs_testlib.shell import Shell
 from frostfs_testlib.steps.cli.object import head_object
-from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
 
 logger = logging.getLogger("NeoLogger")
 
 
 @reporter.step("Verify Head Tombstone")
-def verify_head_tombstone(wallet: WalletInfo, cid: str, oid_ts: str, oid: str, shell: Shell, endpoint: str):
+def verify_head_tombstone(wallet_path: str, cid: str, oid_ts: str, oid: str, shell: Shell, endpoint: str):
-    header = head_object(wallet, cid, oid_ts, shell=shell, endpoint=endpoint)["header"]
+    header = head_object(wallet_path, cid, oid_ts, shell=shell, endpoint=endpoint)["header"]
 
     s_oid = header["sessionToken"]["body"]["object"]["target"]["objects"]
     logger.info(f"Header Session OIDs is {s_oid}")
     logger.info(f"OID is {oid}")
 
     assert header["containerID"] == cid, "Tombstone Header CID is wrong"
-    assert header["ownerID"] == wallet.get_address_from_json(0), "Tombstone Owner ID is wrong"
+
+    with open(wallet_path, "r") as file:
+        wlt_data = json.loads(file.read())
+    wlt = wallet.Wallet.from_json(wlt_data, password="")
+    addr = wlt.accounts[0].address
+
+    assert header["ownerID"] == addr, "Tombstone Owner ID is wrong"
     assert header["objectType"] == "TOMBSTONE", "Header Type isn't Tombstone"
     assert header["sessionToken"]["body"]["object"]["verb"] == "DELETE", "Header Session Type isn't DELETE"
     assert header["sessionToken"]["body"]["object"]["target"]["container"] == cid, "Header Session ID is wrong"

src/frostfs_testlib/storage/cluster.py

@@ -9,9 +9,9 @@ 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.configuration.interfaces import ServiceConfigurationYml
+from frostfs_testlib.storage.configuration.service_configuration import ServiceConfiguration
 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.metrics import Metrics
 from frostfs_testlib.storage.dataclasses.node_base import NodeBase, ServiceClass
 from frostfs_testlib.storage.dataclasses.storage_object_info import Interfaces
 from frostfs_testlib.storage.service_registry import ServiceRegistry
@@ -25,13 +25,11 @@ class ClusterNode:
     class_registry: ServiceRegistry
     id: int
     host: Host
-    metrics: Metrics
 
     def __init__(self, host: Host, id: int) -> None:
         self.host = host
         self.id = id
         self.class_registry = get_service_registry()
-        self.metrics = Metrics(host=self.host, metrics_endpoint=self.storage_node.get_metrics_endpoint())
 
     @property
     def host_ip(self):
@@ -74,7 +72,6 @@ class ClusterNode:
     def s3_gate(self) -> S3Gate:
         return self.service(S3Gate)
 
-    # TODO: Deprecated. Use config with ServiceConfigurationYml interface
     def get_config(self, config_file_path: str) -> dict:
         shell = self.host.get_shell()
 
@@ -84,17 +81,16 @@ class ClusterNode:
         config = yaml.safe_load(config_text)
         return config
 
-    # TODO: Deprecated. Use config with ServiceConfigurationYml interface
     def save_config(self, new_config: dict, config_file_path: str) -> None:
         shell = self.host.get_shell()
 
         config_str = yaml.dump(new_config)
         shell.exec(f"echo '{config_str}' | sudo tee {config_file_path}")
 
-    def config(self, service_type: ServiceClass) -> ServiceConfigurationYml:
+    def config(self, service_type: type[ServiceClass]) -> ServiceConfigurationYml:
-        return self.service(service_type).config
+        return ServiceConfiguration(self.service(service_type))
 
-    def service(self, service_type: ServiceClass) -> ServiceClass:
+    def service(self, service_type: type[ServiceClass]) -> ServiceClass:
         """
         Get a service cluster node of specified type.
 
@@ -109,7 +105,7 @@ class ClusterNode:
         service_entry = self.class_registry.get_entry(service_type)
         service_name = service_entry["hosting_service_name"]
 
-        pattern = f"{service_name}_{self.id:02}"
+        pattern = f"{service_name}{self.id:02}"
         config = self.host.get_service_config(pattern)
 
         return service_type(
@@ -124,7 +120,7 @@ class ClusterNode:
         svcs_names_on_node = [svc.name for svc in self.host.config.services]
         for entry in self.class_registry._class_mapping.values():
             hosting_svc_name = entry["hosting_service_name"]
-            pattern = f"{hosting_svc_name}_{self.id:02}"
+            pattern = f"{hosting_svc_name}{self.id:02}"
             if pattern in svcs_names_on_node:
                 config = self.host.get_service_config(pattern)
                 svcs.append(
@@ -144,16 +140,30 @@ class ClusterNode:
         return self.host.config.interfaces[interface.value]
 
     def get_data_interfaces(self) -> list[str]:
-        return [ip_address for name_interface, ip_address in self.host.config.interfaces.items() if "data" in name_interface]
+        return [
+            ip_address for name_interface, ip_address in self.host.config.interfaces.items() if "data" in name_interface
+        ]
 
     def get_data_interface(self, search_interface: str) -> list[str]:
-        return [self.host.config.interfaces[interface] for interface in self.host.config.interfaces.keys() if search_interface == interface]
+        return [
+            self.host.config.interfaces[interface]
+            for interface in self.host.config.interfaces.keys()
+            if search_interface == interface
+        ]
 
     def get_internal_interfaces(self) -> list[str]:
-        return [ip_address for name_interface, ip_address in self.host.config.interfaces.items() if "internal" in name_interface]
+        return [
+            ip_address
+            for name_interface, ip_address in self.host.config.interfaces.items()
+            if "internal" in name_interface
+        ]
 
     def get_internal_interface(self, search_internal: str) -> list[str]:
-        return [self.host.config.interfaces[interface] for interface in self.host.config.interfaces.keys() if search_internal == interface]
+        return [
+            self.host.config.interfaces[interface]
+            for interface in self.host.config.interfaces.keys()
+            if search_internal == interface
+        ]
 
 
 class Cluster:
@@ -164,6 +174,8 @@ class Cluster:
     default_rpc_endpoint: str
     default_s3_gate_endpoint: str
     default_http_gate_endpoint: str
+    default_http_hostname: str
+    default_s3_hostname: str
 
     def __init__(self, hosting: Hosting) -> None:
         self._hosting = hosting
@@ -172,6 +184,8 @@ class Cluster:
         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()
+        self.default_http_hostname = self.services(StorageNode)[0].get_http_hostname()
+        self.default_s3_hostname = self.services(StorageNode)[0].get_s3_hostname()
 
     @property
     def hosts(self) -> list[Host]:
@@ -253,13 +267,13 @@ class Cluster:
         service_name = service["hosting_service_name"]
         cls: type[NodeBase] = service["cls"]
 
-        pattern = f"{service_name}_\d*$"
+        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]
+            service_type = re.findall(".*\D", config.name)[0]
             # exclude unsupported services
             if service_type != service_name:
                 continue

src/frostfs_testlib/storage/configuration/service_configuration.py

@@ -5,74 +5,51 @@ from typing import Any
 import yaml
 
 from frostfs_testlib import reporter
-from frostfs_testlib.shell.interfaces import CommandOptions, Shell
+from frostfs_testlib.shell.interfaces import CommandOptions
 from frostfs_testlib.storage.configuration.interfaces import ServiceConfigurationYml
-
+from frostfs_testlib.storage.dataclasses.node_base import ServiceClass
-
-def extend_dict(extend_me: dict, extend_by: dict):
-    if isinstance(extend_by, dict):
-        for k, v in extend_by.items():
-            if k in extend_me:
-                extend_dict(extend_me.get(k), v)
-            else:
-                extend_me[k] = v
-    else:
-        extend_me += extend_by
 
 
 class ServiceConfiguration(ServiceConfigurationYml):
-    def __init__(self, service_name: str, shell: Shell, config_dir: str, main_config_path: str) -> None:
+    def __init__(self, service: "ServiceClass") -> None:
-        self.service_name = service_name
+        self.service = service
-        self.shell = shell
+        self.shell = self.service.host.get_shell()
-        self.main_config_path = main_config_path
+        self.confd_path = os.path.join(self.service.config_dir, "conf.d")
-        self.confd_path = os.path.join(config_dir, "conf.d")
         self.custom_file = os.path.join(self.confd_path, "99_changes.yml")
 
     def _path_exists(self, path: str) -> bool:
         return not self.shell.exec(f"test -e {path}", options=CommandOptions(check=False)).return_code
 
-    def _get_config_files(self):
+    def _get_data_from_file(self, path: str) -> dict:
-        config_files = [self.main_config_path]
+        content = self.shell.exec(f"cat {path}").stdout
+        data = yaml.safe_load(content)
+        return data
 
-        if self._path_exists(self.confd_path):
+    def get(self, key: str) -> str:
-            files = self.shell.exec(f"find {self.confd_path} -type f").stdout.strip().split()
+        with reporter.step(f"Get {key} configuration value for {self.service}"):
-            # Sorting files in backwards order from latest to first one
+            config_files = [self.service.main_config_path]
-            config_files.extend(sorted(files, key=lambda x: -int(re.findall("^\d+", os.path.basename(x))[0])))
 
-        return config_files
+            if self._path_exists(self.confd_path):
+                files = self.shell.exec(f"find {self.confd_path} -type f").stdout.strip().split()
+                # Sorting files in backwards order from latest to first one
+                config_files.extend(sorted(files, key=lambda x: -int(re.findall("^\d+", os.path.basename(x))[0])))
 
-    def _get_configuration(self, config_files: list[str]) -> dict:
+            result = None
-        if not config_files:
+            for file in files:
-            return [{}]
+                data = self._get_data_from_file(file)
+                result = self._find_option(key, data)
+                if result is not None:
+                    break
 
-        splitter = "+++++"
-        files_str = " ".join(config_files)
-        all_content = self.shell.exec(
-            f"echo Getting config files; for file in {files_str}; do (echo {splitter}; sudo cat ${{file}}); done"
-        ).stdout
-        files_content = all_content.split("+++++")[1:]
-        files_data = [yaml.safe_load(file_content) for file_content in files_content]
-
-        mergedData = {}
-        for data in files_data:
-            extend_dict(mergedData, data)
-
-        return mergedData
-
-    def get(self, key: str) -> str | Any:
-        with reporter.step(f"Get {key} configuration value for {self.service_name}"):
-            config_files = self._get_config_files()
-            configuration = self._get_configuration(config_files)
-            result = self._find_option(key, configuration)
         return result
 
     def set(self, values: dict[str, Any]):
-        with reporter.step(f"Change configuration for {self.service_name}"):
+        with reporter.step(f"Change configuration for {self.service}"):
             if not self._path_exists(self.confd_path):
                 self.shell.exec(f"mkdir {self.confd_path}")
 
             if self._path_exists(self.custom_file):
-                data = self._get_configuration([self.custom_file])
+                data = self._get_data_from_file(self.custom_file)
             else:
                 data = {}
 
@@ -84,5 +61,5 @@ class ServiceConfiguration(ServiceConfigurationYml):
             self.shell.exec(f"chmod 777 {self.custom_file}")
 
     def revert(self):
-        with reporter.step(f"Revert changed options for {self.service_name}"):
+        with reporter.step(f"Revert changed options for {self.service}"):
             self.shell.exec(f"rm -rf {self.custom_file}")

src/frostfs_testlib/storage/constants.py

@@ -8,19 +8,20 @@ class ConfigAttributes:
     SHARD_CONFIG_PATH = "shard_config_path"
     LOGGER_CONFIG_PATH = "logger_config_path"
     LOCAL_WALLET_PATH = "local_wallet_path"
-    LOCAL_WALLET_CONFIG = "local_wallet_config_path"
+    LOCAL_WALLET_CONFIG = "local_config_path"
-    REMOTE_WALLET_CONFIG = "remote_wallet_config_path"
     ENDPOINT_DATA_0 = "endpoint_data0"
     ENDPOINT_DATA_1 = "endpoint_data1"
-    ENDPOINT_DATA_0_NS = "endpoint_data0_namespace"
     ENDPOINT_INTERNAL = "endpoint_internal0"
     ENDPOINT_PROMETHEUS = "endpoint_prometheus"
     CONTROL_ENDPOINT = "control_endpoint"
     UN_LOCODE = "un_locode"
+    HTTP_HOSTNAME = "http_hostname"
+    S3_HOSTNAME = "s3_hostname"
 
 
-class PlacementRule:
+class _FrostfsServicesNames:
-    DEFAULT_PLACEMENT_RULE = "REP 2 IN X CBF 1 SELECT 4 FROM * AS X"
+    STORAGE = "s"
-    SINGLE_PLACEMENT_RULE = "REP 1 IN X CBF 1 SELECT 4 FROM * AS X"
+    S3_GATE = "s3-gate"
-    REP_2_FOR_3_NODES_PLACEMENT_RULE = "REP 2 IN X CBF 1 SELECT 3 FROM * AS X"
+    HTTP_GATE = "http-gate"
-    DEFAULT_EC_PLACEMENT_RULE = "EC 3.1"
+    MORPH_CHAIN = "morph-chain"
+    INNER_RING = "ir"

src/frostfs_testlib/storage/controllers/background_load_controller.py

@@ -1,5 +1,6 @@
 import copy
 from datetime import datetime
+from typing import Optional
 
 import frostfs_testlib.resources.optionals as optionals
 from frostfs_testlib import reporter
@@ -9,6 +10,7 @@ from frostfs_testlib.load.load_report import LoadReport
 from frostfs_testlib.load.load_verifiers import LoadVerifier
 from frostfs_testlib.storage.cluster import ClusterNode
 from frostfs_testlib.storage.dataclasses.frostfs_services import S3Gate, StorageNode
+from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
 from frostfs_testlib.testing.parallel import parallel
 from frostfs_testlib.testing.test_control import run_optionally
 
@@ -21,6 +23,7 @@ class BackgroundLoadController:
     cluster_nodes: list[ClusterNode]
     nodes_under_load: list[ClusterNode]
     load_counter: int
+    loaders_wallet: WalletInfo
     load_summaries: dict
     endpoints: list[str]
     runner: ScenarioRunner
@@ -31,6 +34,7 @@ class BackgroundLoadController:
         self,
         k6_dir: str,
         load_params: LoadParams,
+        loaders_wallet: WalletInfo,
         cluster_nodes: list[ClusterNode],
         nodes_under_load: list[ClusterNode],
         runner: ScenarioRunner,
@@ -41,6 +45,7 @@ class BackgroundLoadController:
         self.cluster_nodes = cluster_nodes
         self.nodes_under_load = nodes_under_load
         self.load_counter = 1
+        self.loaders_wallet = loaders_wallet
         self.runner = runner
         self.started = False
         self.load_reporters = []
@@ -59,7 +64,10 @@ class BackgroundLoadController:
                     )
                 ),
                 EndpointSelectionStrategy.FIRST: list(
-                    set(node_under_load.service(StorageNode).get_rpc_endpoint() for node_under_load in self.nodes_under_load)
+                    set(
+                        node_under_load.service(StorageNode).get_rpc_endpoint()
+                        for node_under_load in self.nodes_under_load
+                    )
                 ),
             },
             # for some reason xk6 appends http protocol on its own
@@ -187,19 +195,15 @@ class BackgroundLoadController:
             read_from=self.load_params.read_from,
             registry_file=self.load_params.registry_file,
             verify_time=self.load_params.verify_time,
-            custom_registry=self.load_params.custom_registry,
             load_type=self.load_params.load_type,
             load_id=self.load_params.load_id,
             vu_init_time=0,
             working_dir=self.load_params.working_dir,
             endpoint_selection_strategy=self.load_params.endpoint_selection_strategy,
             k6_process_allocation_strategy=self.load_params.k6_process_allocation_strategy,
-            setup_timeout=self.load_params.setup_timeout,
+            setup_timeout="1s",
         )
 
-        if self.verification_params.custom_registry:
-            self.verification_params.registry_file = self.load_params.custom_registry
-
         if self.verification_params.verify_time is None:
             raise RuntimeError("verify_time should not be none")
 

src/frostfs_testlib/storage/controllers/cluster_state_controller.py

@@ -1,5 +1,4 @@
 import datetime
-import itertools
 import logging
 import time
 from typing import TypeVar
@@ -12,15 +11,12 @@ from frostfs_testlib.healthcheck.interfaces import Healthcheck
 from frostfs_testlib.hosting.interfaces import HostStatus
 from frostfs_testlib.plugins import load_all
 from frostfs_testlib.resources.cli import FROSTFS_ADM_CONFIG_PATH, FROSTFS_ADM_EXEC, FROSTFS_CLI_EXEC
-from frostfs_testlib.resources.common import MORPH_BLOCK_TIME
+from frostfs_testlib.resources.common import DEFAULT_WALLET_CONFIG, MORPH_BLOCK_TIME
 from frostfs_testlib.shell import CommandOptions, Shell, SshConnectionProvider
 from frostfs_testlib.steps.network import IpHelper
-from frostfs_testlib.steps.node_management import include_node_to_network_map, remove_nodes_from_map_morph
 from frostfs_testlib.storage.cluster import Cluster, ClusterNode, S3Gate, StorageNode
 from frostfs_testlib.storage.controllers.disk_controller import DiskController
 from frostfs_testlib.storage.dataclasses.node_base import NodeBase, ServiceClass
-from frostfs_testlib.storage.dataclasses.storage_object_info import NodeStatus
-from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
 from frostfs_testlib.testing import parallel
 from frostfs_testlib.testing.test_control import retry, run_optionally, wait_for_success
 from frostfs_testlib.utils.datetime_utils import parse_time
@@ -40,8 +36,7 @@ class ClusterStateController:
     def __init__(self, shell: Shell, cluster: Cluster, healthcheck: Healthcheck) -> None:
         self.stopped_nodes: list[ClusterNode] = []
         self.detached_disks: dict[str, DiskController] = {}
-        self.dropped_traffic: set[ClusterNode] = set()
+        self.dropped_traffic: list[ClusterNode] = []
-        self.excluded_from_netmap: list[StorageNode] = []
         self.stopped_services: set[NodeBase] = set()
         self.cluster = cluster
         self.healthcheck = healthcheck
@@ -173,15 +168,6 @@ class ClusterStateController:
         if service_type == StorageNode:
             self.wait_after_storage_startup()
 
-    @run_optionally(optionals.OPTIONAL_FAILOVER_ENABLED)
-    @reporter.step("Send sighup to all {service_type} services")
-    def sighup_services_of_type(self, service_type: type[ServiceClass]):
-        services = self.cluster.services(service_type)
-        parallel([service.send_signal_to_service for service in services], signal="SIGHUP")
-
-        if service_type == StorageNode:
-            self.wait_after_storage_startup()
-
     @wait_for_success(600, 60)
     def wait_s3gate(self, s3gate: S3Gate):
         with reporter.step(f"Wait for {s3gate} reconnection"):
@@ -216,27 +202,21 @@ class ClusterStateController:
 
     @run_optionally(optionals.OPTIONAL_FAILOVER_ENABLED)
     @reporter.step("Stop {service_type} service on {node}")
-    def stop_service_of_type(self, node: ClusterNode, service_type: ServiceClass, mask: bool = True):
+    def stop_service_of_type(self, node: ClusterNode, service_type: type[ServiceClass], mask: bool = True):
         service = node.service(service_type)
         service.stop_service(mask)
         self.stopped_services.add(service)
 
-    @run_optionally(optionals.OPTIONAL_FAILOVER_ENABLED)
-    @reporter.step("Send sighup to {service_type} service on {node}")
-    def sighup_service_of_type(self, node: ClusterNode, service_type: ServiceClass):
-        service = node.service(service_type)
-        service.send_signal_to_service("SIGHUP")
-
     @run_optionally(optionals.OPTIONAL_FAILOVER_ENABLED)
     @reporter.step("Start {service_type} service on {node}")
-    def start_service_of_type(self, node: ClusterNode, service_type: ServiceClass):
+    def start_service_of_type(self, node: ClusterNode, service_type: type[ServiceClass]):
         service = node.service(service_type)
         service.start_service()
         self.stopped_services.discard(service)
 
     @run_optionally(optionals.OPTIONAL_FAILOVER_ENABLED)
     @reporter.step("Start all stopped {service_type} services")
-    def start_stopped_services_of_type(self, service_type: ServiceClass):
+    def start_stopped_services_of_type(self, service_type: type[ServiceClass]):
         stopped_svc = self._get_stopped_by_type(service_type)
         if not stopped_svc:
             return
@@ -325,23 +305,28 @@ class ClusterStateController:
         self.suspended_services = {}
 
     @reporter.step("Drop traffic to {node}, nodes - {block_nodes}")
-    def drop_traffic(self, node: ClusterNode, wakeup_timeout: int, name_interface: str, block_nodes: list[ClusterNode] = None) -> None:
+    def drop_traffic(
-        interfaces_tables = self._parse_interfaces(block_nodes, name_interface)
+        self,
-        IpHelper.drop_input_traffic_to_node(node, interfaces_tables)
+        node: ClusterNode,
+        wakeup_timeout: int,
+        name_interface: str,
+        block_nodes: list[ClusterNode] = None,
+    ) -> None:
+        list_ip = self._parse_interfaces(block_nodes, name_interface)
+        IpHelper.drop_input_traffic_to_node(node, list_ip)
         time.sleep(wakeup_timeout)
-        self.dropped_traffic.add(node)
+        self.dropped_traffic.append(node)
 
     @reporter.step("Start traffic to {node}")
-    def restore_traffic(self, node: ClusterNode) -> None:
+    def restore_traffic(
+        self,
+        node: ClusterNode,
+    ) -> None:
         IpHelper.restore_input_traffic_to_node(node=node)
-        self.dropped_traffic.discard(node)
 
     @reporter.step("Restore blocked nodes")
     def restore_all_traffic(self):
-        if not self.dropped_traffic:
-            return
         parallel(self._restore_traffic_to_node, self.dropped_traffic)
-        self.dropped_traffic.clear()
 
     @run_optionally(optionals.OPTIONAL_FAILOVER_ENABLED)
     @reporter.step("Hard reboot host {node} via magic SysRq option")
@@ -419,69 +404,51 @@ class ClusterStateController:
     @reporter.step("Set MaintenanceModeAllowed - {status}")
     def set_maintenance_mode_allowed(self, status: str, cluster_node: ClusterNode) -> None:
         frostfs_adm = FrostfsAdm(
-            shell=cluster_node.host.get_shell(), frostfs_adm_exec_path=FROSTFS_ADM_EXEC, config_file=FROSTFS_ADM_CONFIG_PATH
+            shell=cluster_node.host.get_shell(),
+            frostfs_adm_exec_path=FROSTFS_ADM_EXEC,
+            config_file=FROSTFS_ADM_CONFIG_PATH,
         )
         frostfs_adm.morph.set_config(set_key_value=f"MaintenanceModeAllowed={status}")
 
-    @reporter.step("Set node status to {status} in CSC")
+    @reporter.step("Set mode node to {status}")
-    def set_node_status(self, cluster_node: ClusterNode, wallet: WalletInfo, status: NodeStatus, await_tick: bool = True) -> None:
+    def set_mode_node(self, cluster_node: ClusterNode, wallet: str, status: str, await_tick: bool = True) -> None:
         rpc_endpoint = cluster_node.storage_node.get_rpc_endpoint()
         control_endpoint = cluster_node.service(StorageNode).get_control_endpoint()
 
-        frostfs_adm, frostfs_cli, frostfs_cli_remote = self._get_cli(self.shell, wallet, cluster_node)
+        frostfs_adm, frostfs_cli, frostfs_cli_remote = self._get_cli(local_shell=self.shell, cluster_node=cluster_node)
-        node_netinfo = NetmapParser.netinfo(frostfs_cli.netmap.netinfo(rpc_endpoint).stdout)
+        node_netinfo = NetmapParser.netinfo(frostfs_cli.netmap.netinfo(rpc_endpoint=rpc_endpoint, wallet=wallet).stdout)
 
-        if node_netinfo.maintenance_mode_allowed == "false":
+        with reporter.step("If status maintenance, then check that the option is enabled"):
-            with reporter.step("Enable maintenance mode"):
+            if node_netinfo.maintenance_mode_allowed == "false":
-                frostfs_adm.morph.set_config("MaintenanceModeAllowed=true")
+                frostfs_adm.morph.set_config(set_key_value="MaintenanceModeAllowed=true")
 
-        with reporter.step(f"Set node status to {status} using FrostfsCli"):
+        with reporter.step(f"Change the status to {status}"):
-            frostfs_cli_remote.control.set_status(control_endpoint, status.value)
+            frostfs_cli_remote.control.set_status(endpoint=control_endpoint, status=status)
 
         if not await_tick:
             return
 
-        with reporter.step("Tick 2 epoch with 2 block await."):
+        with reporter.step("Tick 1 epoch, and await 2 block"):
-            for _ in range(2):
+            frostfs_adm.morph.force_new_epoch()
-                frostfs_adm.morph.force_new_epoch()
+            time.sleep(parse_time(MORPH_BLOCK_TIME) * 2)
-                time.sleep(parse_time(MORPH_BLOCK_TIME) * 2)
 
-        self.await_node_status(status, wallet, cluster_node)
+        self.check_node_status(status=status, wallet=wallet, cluster_node=cluster_node)
 
-    @wait_for_success(80, 8, title="Wait for node status become {status}")
+    @wait_for_success(80, 8, title="Wait for storage status become {status}")
-    def await_node_status(self, status: NodeStatus, wallet: WalletInfo, cluster_node: ClusterNode, checker_node: ClusterNode = None):
+    def check_node_status(self, status: str, wallet: str, cluster_node: ClusterNode):
-        frostfs_cli = FrostfsCli(self.shell, FROSTFS_CLI_EXEC, wallet.config_path)
+        frostfs_cli = FrostfsCli(
-        if not checker_node:
+            shell=self.shell, frostfs_cli_exec_path=FROSTFS_CLI_EXEC, config_file=DEFAULT_WALLET_CONFIG
-            checker_node = cluster_node
+        )
-        netmap = NetmapParser.snapshot_all_nodes(frostfs_cli.netmap.snapshot(checker_node.storage_node.get_rpc_endpoint()).stdout)
+        netmap = NetmapParser.snapshot_all_nodes(
+            frostfs_cli.netmap.snapshot(rpc_endpoint=cluster_node.storage_node.get_rpc_endpoint(), wallet=wallet).stdout
+        )
         netmap = [node for node in netmap if cluster_node.host_ip == node.node]
-        if status == NodeStatus.OFFLINE:
+        if status == "offline":
             assert cluster_node.host_ip not in netmap, f"{cluster_node.host_ip} not in Offline"
         else:
-            assert netmap[0].node_status == status, f"Node status should be '{status}', but was '{netmap[0].node_status}'"
+            assert netmap[0].node_status == status.upper(), f"Node state - {netmap[0].node_status} != {status} expect"
 
-    def remove_node_from_netmap(self, removes_nodes: list[StorageNode]) -> None:
+    def _get_cli(self, local_shell: Shell, cluster_node: ClusterNode) -> tuple[FrostfsAdm, FrostfsCli, FrostfsCli]:
-        alive_storage = list(set(self.cluster.storage_nodes) - set(removes_nodes))[0]
-        remove_nodes_from_map_morph(self.shell, self.cluster, removes_nodes, alive_storage)
-        self.excluded_from_netmap.extend(removes_nodes)
-
-    def include_node_to_netmap(self, include_node: StorageNode, alive_node: StorageNode):
-        include_node_to_network_map(include_node, alive_node, self.shell, self.cluster)
-        self.excluded_from_netmap.pop(self.excluded_from_netmap.index(include_node))
-
-    def include_all_excluded_nodes(self):
-        if not self.excluded_from_netmap:
-            return
-        alive_node = list(set(self.cluster.storage_nodes) - set(self.excluded_from_netmap))[0]
-        if not alive_node:
-            return
-
-        for exclude_node in self.excluded_from_netmap.copy():
-            self.include_node_to_netmap(exclude_node, alive_node)
-
-    def _get_cli(
-        self, local_shell: Shell, local_wallet: WalletInfo, cluster_node: ClusterNode
-    ) -> tuple[FrostfsAdm, FrostfsCli, FrostfsCli]:
         # TODO Move to service config
         host = cluster_node.host
         service_config = host.get_service_config(cluster_node.storage_node.name)
@@ -493,9 +460,17 @@ class ClusterStateController:
         wallet_config = f'wallet: {wallet_path}\npassword: "{wallet_password}"'
         shell.exec(f"echo '{wallet_config}' > {wallet_config_path}")
 
-        frostfs_adm = FrostfsAdm(shell=shell, frostfs_adm_exec_path=FROSTFS_ADM_EXEC, config_file=FROSTFS_ADM_CONFIG_PATH)
+        frostfs_adm = FrostfsAdm(
-        frostfs_cli = FrostfsCli(local_shell, FROSTFS_CLI_EXEC, local_wallet.config_path)
+            shell=shell, frostfs_adm_exec_path=FROSTFS_ADM_EXEC, config_file=FROSTFS_ADM_CONFIG_PATH
-        frostfs_cli_remote = FrostfsCli(shell=shell, frostfs_cli_exec_path=FROSTFS_CLI_EXEC, config_file=wallet_config_path)
+        )
+        frostfs_cli = FrostfsCli(
+            shell=local_shell, frostfs_cli_exec_path=FROSTFS_CLI_EXEC, config_file=DEFAULT_WALLET_CONFIG
+        )
+        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):
@@ -517,38 +492,26 @@ class ClusterStateController:
 
         return disk_controller
 
-    @reporter.step("Restore traffic {node}")
     def _restore_traffic_to_node(self, node):
         IpHelper.restore_input_traffic_to_node(node)
 
-    def _parse_interfaces(self, nodes: list[ClusterNode], name_interface: str) -> list[tuple]:
+    def _parse_interfaces(self, nodes: list[ClusterNode], name_interface: str):
-        interfaces_and_tables = set()
+        interfaces = []
         for node in nodes:
-            shell = node.host.get_shell()
+            dict_interfaces = node.host.config.interfaces
-            lines = shell.exec(f"ip r l table all | grep '{name_interface}'").stdout.splitlines()
+            for type, ip in dict_interfaces.items():
-
+                if name_interface in type:
-            ips = []
+                    interfaces.append(ip)
-            tables = []
+        return interfaces
-
-            for line in lines:
-                if "src" not in line or "table local" in line:
-                    continue
-                parts = line.split()
-                ips.append(parts[-1])
-                if "table" in line:
-                    tables.append(parts[parts.index("table") + 1])
-            tables.append(None)
-
-            [interfaces_and_tables.add((ip, table)) for ip, table in itertools.product(ips, tables)]
-
-        return interfaces_and_tables
 
     @reporter.step("Ping node")
     def _ping_host(self, node: ClusterNode):
         options = CommandOptions(check=False)
         return self.shell.exec(f"ping {node.host.config.address} -c 1", options).return_code
 
-    @retry(max_attempts=60, sleep_interval=10, expected_result=HostStatus.ONLINE, title="Waiting for {node} to go online")
+    @retry(
+        max_attempts=60, sleep_interval=10, expected_result=HostStatus.ONLINE, title="Waiting for {node} to go online"
+    )
     def _wait_for_host_online(self, node: ClusterNode):
         try:
             ping_result = self._ping_host(node)
@@ -559,7 +522,9 @@ class ClusterStateController:
             logger.warning(f"Host ping fails with error {err}")
             return HostStatus.OFFLINE
 
-    @retry(max_attempts=60, sleep_interval=10, expected_result=HostStatus.OFFLINE, title="Waiting for {node} to go offline")
+    @retry(
+        max_attempts=60, sleep_interval=10, expected_result=HostStatus.OFFLINE, title="Waiting for {node} to go offline"
+    )
     def _wait_for_host_offline(self, node: ClusterNode):
         try:
             ping_result = self._ping_host(node)
@@ -569,8 +534,3 @@ class ClusterStateController:
         except Exception as err:
             logger.warning(f"Host ping fails with error {err}")
             return HostStatus.ONLINE
-
-    @reporter.step("Get contract by domain - {domain_name}")
-    def get_domain_contracts(self, cluster_node: ClusterNode, domain_name: str):
-        frostfs_adm = FrostfsAdm(shell=cluster_node.host.get_shell(), frostfs_adm_exec_path=FROSTFS_ADM_EXEC)
-        return frostfs_adm.morph.dump_hashes(cluster_node.morph_chain.get_http_endpoint(), domain_name).stdout

src/frostfs_testlib/storage/controllers/shards_watcher.py

@@ -2,22 +2,22 @@ import json
 from typing import Any
 
 from frostfs_testlib.cli.frostfs_cli.shards import FrostfsCliShards
-from frostfs_testlib.shell.interfaces import CommandResult
 from frostfs_testlib.storage.cluster import ClusterNode
 from frostfs_testlib.testing.test_control import wait_for_success
 
 
 class ShardsWatcher:
+    shards_snapshots: list[dict[str, Any]] = []
+
     def __init__(self, node_under_test: ClusterNode) -> None:
-        self.shards_snapshots: list[dict[str, Any]] = []
         self.storage_node = node_under_test.storage_node
         self.take_shards_snapshot()
 
-    def take_shards_snapshot(self) -> None:
+    def take_shards_snapshot(self):
         snapshot = self.get_shards_snapshot()
         self.shards_snapshots.append(snapshot)
 
-    def get_shards_snapshot(self) -> dict[str, Any]:
+    def get_shards_snapshot(self):
         shards_snapshot: dict[str, Any] = {}
 
         shards = self.get_shards()
@@ -26,17 +26,17 @@ class ShardsWatcher:
 
         return shards_snapshot
 
-    def _get_current_snapshot(self) -> dict[str, Any]:
+    def _get_current_snapshot(self):
         return self.shards_snapshots[-1]
 
-    def _get_previous_snapshot(self) -> dict[str, Any]:
+    def _get_previous_snapshot(self):
         return self.shards_snapshots[-2]
 
-    def _is_shard_present(self, shard_id) -> bool:
+    def _is_shard_present(self, shard_id):
         snapshot = self._get_current_snapshot()
         return shard_id in snapshot
 
-    def get_shards_with_new_errors(self) -> dict[str, Any]:
+    def get_shards_with_new_errors(self):
         current_snapshot = self._get_current_snapshot()
         previous_snapshot = self._get_previous_snapshot()
         shards_with_new_errors: dict[str, Any] = {}
@@ -46,7 +46,7 @@ class ShardsWatcher:
 
         return shards_with_new_errors
 
-    def get_shards_with_errors(self) -> dict[str, Any]:
+    def get_shards_with_errors(self):
         snapshot = self.get_shards_snapshot()
         shards_with_errors: dict[str, Any] = {}
         for shard_id, shard in snapshot.items():
@@ -55,7 +55,7 @@ class ShardsWatcher:
 
         return shards_with_errors
 
-    def get_shard_status(self, shard_id: str):  # -> Any:
+    def get_shard_status(self, shard_id: str):
         snapshot = self.get_shards_snapshot()
 
         assert shard_id in snapshot, f"Shard {shard_id} is missing: {snapshot}"
@@ -63,26 +63,28 @@ class ShardsWatcher:
         return snapshot[shard_id]["mode"]
 
     @wait_for_success(60, 2)
-    def await_for_all_shards_status(self, status: str) -> None:
+    def await_for_all_shards_status(self, status: str):
         snapshot = self.get_shards_snapshot()
 
         for shard_id in snapshot:
             assert snapshot[shard_id]["mode"] == status, f"Shard {shard_id} have wrong shard status"
 
     @wait_for_success(60, 2)
-    def await_for_shard_status(self, shard_id: str, status: str) -> None:
+    def await_for_shard_status(self, shard_id: str, status: str):
         assert self.get_shard_status(shard_id) == status
 
     @wait_for_success(60, 2)
-    def await_for_shard_have_new_errors(self, shard_id: str) -> None:
+    def await_for_shard_have_new_errors(self, shard_id: str):
         self.take_shards_snapshot()
         assert self._is_shard_present(shard_id)
         shards_with_new_errors = self.get_shards_with_new_errors()
 
-        assert shard_id in shards_with_new_errors, f"Expected shard {shard_id} to have new errors, but haven't {self.shards_snapshots[-1]}"
+        assert (
+            shard_id in shards_with_new_errors
+        ), f"Expected shard {shard_id} to have new errors, but haven't {self.shards_snapshots[-1]}"
 
     @wait_for_success(300, 5)
-    def await_for_shards_have_no_new_errors(self) -> None:
+    def await_for_shards_have_no_new_errors(self):
         self.take_shards_snapshot()
         shards_with_new_errors = self.get_shards_with_new_errors()
         assert len(shards_with_new_errors) == 0
@@ -102,15 +104,15 @@ class ShardsWatcher:
 
         return json.loads(response.stdout.split(">", 1)[1])
 
-    def set_shard_mode(self, shard_id: str, mode: str, clear_errors: bool = True) -> CommandResult:
+    def set_shard_mode(self, shard_id: str, mode: str, clear_errors: bool = True):
         shards_cli = FrostfsCliShards(
             self.storage_node.host.get_shell(),
             self.storage_node.host.get_cli_config("frostfs-cli").exec_path,
         )
         return shards_cli.set_mode(
-            endpoint=self.storage_node.get_control_endpoint(),
+            self.storage_node.get_control_endpoint(),
-            wallet=self.storage_node.get_remote_wallet_path(),
+            self.storage_node.get_remote_wallet_path(),
-            wallet_password=self.storage_node.get_wallet_password(),
+            self.storage_node.get_wallet_password(),
             mode=mode,
             id=[shard_id],
             clear_errors=clear_errors,

src/frostfs_testlib/storage/controllers/state_managers/config_state_manager.py

@@ -14,19 +14,14 @@ class ConfigStateManager(StateManager):
         self.cluster = self.csc.cluster
 
     @reporter.step("Change configuration for {service_type} on all nodes")
-    def set_on_all_nodes(self, service_type: type[ServiceClass], values: dict[str, Any], sighup: bool = False):
+    def set_on_all_nodes(self, service_type: type[ServiceClass], values: dict[str, Any]):
         services = self.cluster.services(service_type)
         nodes = self.cluster.nodes(services)
         self.services_with_changed_config.update([(node, service_type) for node in nodes])
 
-        if not sighup:
+        self.csc.stop_services_of_type(service_type)
-            self.csc.stop_services_of_type(service_type)
-
         parallel([node.config(service_type).set for node in nodes], values=values)
-        if not sighup:
+        self.csc.start_services_of_type(service_type)
-            self.csc.start_services_of_type(service_type)
-        else:
-            self.csc.sighup_services_of_type(service_type)
 
     @reporter.step("Change configuration for {service_type} on {node}")
     def set_on_node(self, node: ClusterNode, service_type: type[ServiceClass], values: dict[str, Any]):
@@ -37,26 +32,18 @@ class ConfigStateManager(StateManager):
         self.csc.start_service_of_type(node, service_type)
 
     @reporter.step("Revert all configuration changes")
-    def revert_all(self, sighup: bool = False):
+    def revert_all(self):
         if not self.services_with_changed_config:
             return
 
-        parallel(self._revert_svc, self.services_with_changed_config, sighup)
+        parallel(self._revert_svc, self.services_with_changed_config)
         self.services_with_changed_config.clear()
 
-        if not sighup:
+        self.csc.start_all_stopped_services()
-            self.csc.start_all_stopped_services()
 
     # TODO: parallel can't have multiple parallel_items :(
     @reporter.step("Revert all configuration {node_and_service}")
-    def _revert_svc(self, node_and_service: tuple[ClusterNode, ServiceClass], sighup: bool = False):
+    def _revert_svc(self, node_and_service: tuple[ClusterNode, ServiceClass]):
         node, service_type = node_and_service
-        service = node.service(service_type)
+        self.csc.stop_service_of_type(node, service_type)
-
-        if not sighup:
-            self.csc.stop_service_of_type(node, service_type)
-
         node.config(service_type).revert()
-
-        if sighup:
-            service.send_signal_to_service("SIGHUP")

src/frostfs_testlib/storage/dataclasses/acl.py

@@ -1,8 +1,8 @@
 import logging
 from dataclasses import dataclass
+from enum import Enum
 from typing import Any, Dict, List, Optional, Union
 
-from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
 from frostfs_testlib.testing.readable import HumanReadableEnum
 from frostfs_testlib.utils import wallet_utils
 
@@ -65,7 +65,11 @@ class EACLFilters:
 
     def __str__(self):
         return ",".join(
-            [f"{filter.header_type.value}:" f"{filter.key}{filter.match_type.value}{filter.value}" for filter in self.filters]
+            [
+                f"{filter.header_type.value}:"
+                f"{filter.key}{filter.match_type.value}{filter.value}"
+                for filter in self.filters
+            ]
             if self.filters
             else []
         )
@@ -80,7 +84,7 @@ class EACLPubKey:
 class EACLRule:
     operation: Optional[EACLOperation] = None
     access: Optional[EACLAccess] = None
-    role: Optional[Union[EACLRole, WalletInfo]] = None
+    role: Optional[Union[EACLRole, str]] = None
     filters: Optional[EACLFilters] = None
 
     def to_dict(self) -> Dict[str, Any]:
@@ -92,9 +96,9 @@ class EACLRule:
         }
 
     def __str__(self):
-        role = ""
+        role = (
-        if isinstance(self.role, EACLRole):
+            self.role.value
-            role = self.role.value
+            if isinstance(self.role, EACLRole)
-        if isinstance(self.role, WalletInfo):
+            else f'pubkey:{wallet_utils.get_wallet_public_key(self.role, "")}'
-            role = f"pubkey:{wallet_utils.get_wallet_public_key(self.role.path, self.role.password)}"
+        )
         return f'{self.access.value} {self.operation.value} {self.filters or ""} {role}'

src/frostfs_testlib/storage/dataclasses/ape.py

@@ -1,152 +0,0 @@
-import logging
-from dataclasses import dataclass
-from enum import Enum
-from typing import Optional
-
-from frostfs_testlib.testing.readable import HumanReadableEnum
-from frostfs_testlib.utils import string_utils
-
-logger = logging.getLogger("NeoLogger")
-EACL_LIFETIME = 100500
-FROSTFS_CONTRACT_CACHE_TIMEOUT = 30
-
-
-class ObjectOperations(HumanReadableEnum):
-    PUT = "object.put"
-    GET = "object.get"
-    HEAD = "object.head"
-    GET_RANGE = "object.range"
-    GET_RANGE_HASH = "object.hash"
-    SEARCH = "object.search"
-    DELETE = "object.delete"
-    WILDCARD_ALL = "object.*"
-
-    @staticmethod
-    def get_all():
-        return [op for op in ObjectOperations if op != ObjectOperations.WILDCARD_ALL]
-
-
-class ContainerOperations(HumanReadableEnum):
-    PUT = "container.put"
-    GET = "container.get"
-    LIST = "container.list"
-    DELETE = "container.delete"
-    WILDCARD_ALL = "container.*"
-
-    @staticmethod
-    def get_all():
-        return [op for op in ObjectOperations if op != ObjectOperations.WILDCARD_ALL]
-
-
-@dataclass
-class Operations:
-    GET_CONTAINER = "GetContainer"
-    PUT_CONTAINER = "PutContainer"
-    DELETE_CONTAINER = "DeleteContainer"
-    LIST_CONTAINER = "ListContainers"
-    GET_OBJECT = "GetObject"
-    DELETE_OBJECT = "DeleteObject"
-    HASH_OBJECT = "HashObject"
-    RANGE_OBJECT = "RangeObject"
-    SEARCH_OBJECT = "SearchObject"
-    HEAD_OBJECT = "HeadObject"
-    PUT_OBJECT = "PutObject"
-
-
-class Verb(HumanReadableEnum):
-    ALLOW = "allow"
-    DENY = "deny"
-
-
-class Role(HumanReadableEnum):
-    OWNER = "owner"
-    IR = "ir"
-    CONTAINER = "container"
-    OTHERS = "others"
-
-
-class ConditionType(HumanReadableEnum):
-    RESOURCE = "ResourceCondition"
-    REQUEST = "RequestCondition"
-
-
-# See https://git.frostfs.info/TrueCloudLab/policy-engine/src/branch/master/schema/native/consts.go#L40-L53
-class ConditionKey(HumanReadableEnum):
-    ROLE = '"\\$Actor:role"'
-    PUBLIC_KEY = '"\\$Actor:publicKey"'
-    OBJECT_TYPE = '"\\$Object:objectType"'
-    OBJECT_ID = '"\\$Object:objectID"'
-
-
-class MatchType(HumanReadableEnum):
-    EQUAL = "="
-    NOT_EQUAL = "!="
-
-
-@dataclass
-class Condition:
-    condition_key: ConditionKey | str
-    condition_value: str
-    condition_type: ConditionType = ConditionType.REQUEST
-    match_type: MatchType = MatchType.EQUAL
-
-    def as_string(self):
-        key = self.condition_key.value if isinstance(self.condition_key, ConditionKey) else self.condition_key
-        value = self.condition_value.value if isinstance(self.condition_value, Enum) else self.condition_value
-
-        return f"{self.condition_type.value}:{key}{self.match_type.value}{value}"
-
-    @staticmethod
-    def by_role(*args, **kwargs) -> "Condition":
-        return Condition(ConditionKey.ROLE, *args, **kwargs)
-
-    @staticmethod
-    def by_key(*args, **kwargs) -> "Condition":
-        return Condition(ConditionKey.PUBLIC_KEY, *args, **kwargs)
-
-    @staticmethod
-    def by_object_type(*args, **kwargs) -> "Condition":
-        return Condition(ConditionKey.OBJECT_TYPE, *args, **kwargs)
-
-    @staticmethod
-    def by_object_id(*args, **kwargs) -> "Condition":
-        return Condition(ConditionKey.OBJECT_ID, *args, **kwargs)
-
-
-class Rule:
-    def __init__(
-        self,
-        access: Verb,
-        operations: list[ObjectOperations] | ObjectOperations,
-        conditions: list[Condition] | Condition = None,
-        chain_id: Optional[str] = None,
-    ) -> None:
-        self.access = access
-        self.operations = operations
-
-        if not conditions:
-            self.conditions = []
-        elif isinstance(conditions, Condition):
-            self.conditions = [conditions]
-        else:
-            self.conditions = conditions
-
-        if not isinstance(self.conditions, list):
-            raise RuntimeError("Conditions must be a list")
-
-        if not operations:
-            self.operations = []
-        elif isinstance(operations, (ObjectOperations, ContainerOperations)):
-            self.operations = [operations]
-        else:
-            self.operations = operations
-
-        if not isinstance(self.operations, list):
-            raise RuntimeError("Operations must be a list")
-
-        self.chain_id = chain_id if chain_id else string_utils.unique_name("chain-id-")
-
-    def as_string(self):
-        conditions = " ".join([cond.as_string() for cond in self.conditions])
-        operations = " ".join([op.value for op in self.operations])
-        return f"{self.access.value} {operations} {conditions} *"

src/frostfs_testlib/storage/dataclasses/frostfs_services.py

@@ -5,7 +5,6 @@ from frostfs_testlib.storage.constants import ConfigAttributes
 from frostfs_testlib.storage.dataclasses.node_base import NodeBase
 from frostfs_testlib.storage.dataclasses.shard import Shard
 
-
 class InnerRing(NodeBase):
     """
     Class represents inner ring node in a cluster
@@ -18,7 +17,11 @@ class InnerRing(NodeBase):
 
     def service_healthcheck(self) -> bool:
         health_metric = "frostfs_ir_ir_health"
-        output = self.host.get_shell().exec(f"curl -s localhost:6662 | grep {health_metric} | sed 1,2d").stdout
+        output = (
+            self.host.get_shell()
+            .exec(f"curl -s localhost:6662 | grep {health_metric} | sed 1,2d")
+            .stdout
+        )
         return health_metric in output
 
     def get_netmap_cleaner_threshold(self) -> str:
@@ -39,21 +42,19 @@ class S3Gate(NodeBase):
     def get_endpoint(self) -> str:
         return self._get_attribute(ConfigAttributes.ENDPOINT_DATA_0)
 
-    def get_ns_endpoint(self, ns_name: str) -> str:
-        return self._get_attribute(f"{ConfigAttributes.ENDPOINT_DATA_0}_namespace").format(namespace=ns_name)
-
     def get_all_endpoints(self) -> list[str]:
         return [
             self._get_attribute(ConfigAttributes.ENDPOINT_DATA_0),
             self._get_attribute(ConfigAttributes.ENDPOINT_DATA_1),
         ]
 
-    def get_ns_endpoint(self, ns_name: str) -> str:
-        return self._get_attribute(ConfigAttributes.ENDPOINT_DATA_0_NS).format(namespace=ns_name)
-
     def service_healthcheck(self) -> bool:
         health_metric = "frostfs_s3_gw_state_health"
-        output = self.host.get_shell().exec(f"curl -s localhost:8086 | grep {health_metric} | sed 1,2d").stdout
+        output = (
+            self.host.get_shell()
+            .exec(f"curl -s localhost:8086 | grep {health_metric} | sed 1,2d")
+            .stdout
+        )
         return health_metric in output
 
     @property
@@ -71,7 +72,11 @@ class HTTPGate(NodeBase):
 
     def service_healthcheck(self) -> bool:
         health_metric = "frostfs_http_gw_state_health"
-        output = self.host.get_shell().exec(f"curl -s localhost:5662 | grep {health_metric}  | sed 1,2d").stdout
+        output = (
+            self.host.get_shell()
+            .exec(f"curl -s localhost:5662 | grep {health_metric}  | sed 1,2d")
+            .stdout
+        )
         return health_metric in output
 
     @property
@@ -130,26 +135,32 @@ class StorageNode(NodeBase):
 
     def service_healthcheck(self) -> bool:
         health_metric = "frostfs_node_state_health"
-        output = self.host.get_shell().exec(f"curl -s localhost:6672 | grep {health_metric} | sed 1,2d").stdout
+        output = (
+            self.host.get_shell()
+            .exec(f"curl -s localhost:6672 | grep {health_metric} | sed 1,2d")
+            .stdout
+        )
         return health_metric in output
 
-    # TODO: Deprecated. Use new approach with config
     def get_shard_config_path(self) -> str:
         return self._get_attribute(ConfigAttributes.SHARD_CONFIG_PATH)
 
-    # TODO: Deprecated. Use new approach with config
     def get_shards_config(self) -> tuple[str, dict]:
         return self.get_config(self.get_shard_config_path())
 
     def get_shards(self) -> list[Shard]:
-        shards = self.config.get("storage:shard")
+        config = self.get_shards_config()[1]
+        config["storage"]["shard"].pop("default")
+        return [Shard.from_object(shard) for shard in config["storage"]["shard"].values()]
 
-        if not shards:
+    def get_shards_from_env(self) -> list[Shard]:
-            raise RuntimeError(f"Cannot get shards information for {self.name} on {self.host.config.address}")
+        config = self.get_shards_config()[1]
+        configObj = ConfigObj(StringIO(config))
 
-        if "default" in shards:
+        pattern = f"{SHARD_PREFIX}\d*"
-            shards.pop("default")
+        num_shards = len(set(re.findall(pattern, self.get_shards_config())))
-        return [Shard.from_object(shard) for shard in shards.values()]
+
+        return [Shard.from_config_object(configObj, shard_id) for shard_id in range(num_shards)]
 
     def get_control_endpoint(self) -> str:
         return self._get_attribute(ConfigAttributes.CONTROL_ENDPOINT)
@@ -160,6 +171,15 @@ class StorageNode(NodeBase):
     def get_data_directory(self) -> str:
         return self.host.get_data_directory(self.name)
 
+    def get_storage_config(self) -> str:
+        return self.host.get_storage_config(self.name)
+
+    def get_http_hostname(self) -> str:
+        return self._get_attribute(ConfigAttributes.HTTP_HOSTNAME)
+
+    def get_s3_hostname(self) -> str:
+        return self._get_attribute(ConfigAttributes.S3_HOSTNAME)
+
     def delete_blobovnicza(self):
         self.host.delete_blobovnicza(self.name)
 

src/frostfs_testlib/storage/dataclasses/metrics.py

@@ -1,36 +0,0 @@
-from frostfs_testlib.hosting import Host
-from frostfs_testlib.shell.interfaces import CommandResult
-
-
-class Metrics:
-    def __init__(self, host: Host, metrics_endpoint: str) -> None:
-        self.storage = StorageMetrics(host, metrics_endpoint)
-
-
-
-class StorageMetrics:
-    """
-    Class represents storage metrics in a cluster
-    """
-    def __init__(self, host: Host, metrics_endpoint: str) -> None:
-        self.host = host
-        self.metrics_endpoint = metrics_endpoint
-
-    def get_metrics_search_by_greps(self, **greps) -> CommandResult:
-        """
-        Get a metrics, search by: cid, metric_type, shard_id etc.
-        Args:
-            greps: dict of grep-command-name and value
-            for example get_metrics_search_by_greps(command='container_objects_total', cid='123456')
-        Return:
-            result of metrics
-        """
-        shell = self.host.get_shell()
-        additional_greps = " |grep ".join([grep_command for grep_command in greps.values()])
-        result = shell.exec(f"curl -s {self.metrics_endpoint} | grep {additional_greps}")
-        return result
-    
-    def get_all_metrics(self) -> CommandResult:
-        shell = self.host.get_shell()
-        result = shell.exec(f"curl -s {self.metrics_endpoint}")
-        return result

src/frostfs_testlib/storage/dataclasses/node_base.py

@@ -10,7 +10,6 @@ from frostfs_testlib import reporter
 from frostfs_testlib.hosting.config import ServiceConfig
 from frostfs_testlib.hosting.interfaces import Host
 from frostfs_testlib.shell.interfaces import CommandResult
-from frostfs_testlib.storage.configuration.service_configuration import ServiceConfiguration, ServiceConfigurationYml
 from frostfs_testlib.storage.constants import ConfigAttributes
 from frostfs_testlib.testing.readable import HumanReadableABC
 from frostfs_testlib.utils import wallet_utils
@@ -65,10 +64,6 @@ class NodeBase(HumanReadableABC):
         with reporter.step(f"Start {self.name} service on {self.host.config.address}"):
             self.host.start_service(self.name)
 
-    def send_signal_to_service(self, signal: str):
-        with reporter.step(f"Send -{signal} signal to {self.name} service on {self.host.config.address}"):
-            self.host.send_signal_to_service(self.name, signal)
-
     @abstractmethod
     def service_healthcheck(self) -> bool:
         """Service healthcheck."""
@@ -119,14 +114,6 @@ class NodeBase(HumanReadableABC):
             ConfigAttributes.CONFIG_PATH,
         )
 
-    def get_remote_wallet_config_path(self) -> str:
-        """
-        Returns node config file path located on remote host
-        """
-        return self._get_attribute(
-            ConfigAttributes.REMOTE_WALLET_CONFIG,
-        )
-
     def get_wallet_config_path(self) -> str:
         return self._get_attribute(
             ConfigAttributes.LOCAL_WALLET_CONFIG,
@@ -138,11 +125,8 @@ class NodeBase(HumanReadableABC):
         Returns config path for logger located on remote host
         """
         config_attributes = self.host.get_service_config(self.name)
-        return (
+        return self._get_attribute(
-            self._get_attribute(ConfigAttributes.LOGGER_CONFIG_PATH)
+            ConfigAttributes.LOGGER_CONFIG_PATH) if ConfigAttributes.LOGGER_CONFIG_PATH in config_attributes.attributes else None
-            if ConfigAttributes.LOGGER_CONFIG_PATH in config_attributes.attributes
-            else None
-        )
 
     @property
     def config_dir(self) -> str:
@@ -152,11 +136,7 @@ class NodeBase(HumanReadableABC):
     def main_config_path(self) -> str:
         return self._get_attribute(ConfigAttributes.CONFIG_PATH)
 
-    @property
+    # TODO: Deprecated
-    def config(self) -> ServiceConfigurationYml:
-        return ServiceConfiguration(self.name, self.host.get_shell(), self.config_dir, self.main_config_path)
-
-    # TODO: Deprecated. Use config with ServiceConfigurationYml interface
     def get_config(self, config_file_path: Optional[str] = None) -> tuple[str, dict]:
         if config_file_path is None:
             config_file_path = self._get_attribute(ConfigAttributes.CONFIG_PATH)
@@ -169,7 +149,7 @@ class NodeBase(HumanReadableABC):
         config = yaml.safe_load(config_text)
         return config_file_path, config
 
-    # TODO: Deprecated. Use config with ServiceConfigurationYml interface
+    # TODO: Deprecated
     def save_config(self, new_config: dict, config_file_path: Optional[str] = None) -> None:
         if config_file_path is None:
             config_file_path = self._get_attribute(ConfigAttributes.CONFIG_PATH)
@@ -189,7 +169,9 @@ class NodeBase(HumanReadableABC):
 
         if attribute_name not in config.attributes:
             if default_attribute_name is None:
-                raise RuntimeError(f"Service {self.name} has no {attribute_name} in config and fallback attribute isn't set either")
+                raise RuntimeError(
+                    f"Service {self.name} has no {attribute_name} in config and fallback attribute isn't set either"
+                )
 
             return config.attributes[default_attribute_name]
 
@@ -199,7 +181,9 @@ class NodeBase(HumanReadableABC):
         return self.host.get_service_config(self.name)
 
     def get_service_uptime(self, service: str) -> datetime:
-        result = self.host.get_shell().exec(f"systemctl show {service} --property ActiveEnterTimestamp | cut -d '=' -f 2")
+        result = self.host.get_shell().exec(
+            f"systemctl show {service} --property ActiveEnterTimestamp | cut -d '=' -f 2"
+        )
         start_time = parser.parse(result.stdout.strip())
         current_time = datetime.now(tz=timezone.utc)
         active_time = current_time - start_time

src/frostfs_testlib/storage/dataclasses/policy.py

@@ -1,13 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class PlacementPolicy:
-    name: str
-    value: str
-
-    def __str__(self) -> str:
-        return self.name
-
-    def __repr__(self) -> str:
-        return self.__str__()

src/frostfs_testlib/storage/dataclasses/shard.py

@@ -1,6 +1,16 @@
+import json
+import pathlib
+import re
 from dataclasses import dataclass
+from io import StringIO
 
+import allure
+import pytest
+import yaml
 from configobj import ConfigObj
+from frostfs_testlib.cli import FrostfsCli
+from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT
+from frostfs_testlib.resources.common import DEFAULT_WALLET_CONFIG
 
 SHARD_PREFIX = "FROSTFS_STORAGE_SHARD_"
 BLOBSTOR_PREFIX = "_BLOBSTOR_"
@@ -56,7 +66,9 @@ class Shard:
         var_prefix = f"{SHARD_PREFIX}{shard_id}"
 
         blobstor_count = Shard._get_blobstor_count_from_section(config_object, shard_id)
-        blobstors = [Blobstor.from_config_object(config_object, shard_id, blobstor_id) for blobstor_id in range(blobstor_count)]
+        blobstors = [
+            Blobstor.from_config_object(config_object, shard_id, blobstor_id) for blobstor_id in range(blobstor_count)
+        ]
 
         write_cache_enabled = config_object.as_bool(f"{var_prefix}_WRITECACHE_ENABLED")
 
@@ -69,13 +81,7 @@ class Shard:
     @staticmethod
     def from_object(shard):
         metabase = shard["metabase"]["path"] if "path" in shard["metabase"] else shard["metabase"]
-        writecache_enabled = True
-        if "enabled" in shard["writecache"]:
-            writecache_enabled = shard["writecache"]["enabled"]
-
         writecache = shard["writecache"]["path"] if "path" in shard["writecache"] else shard["writecache"]
-        if not writecache_enabled:
-            writecache = ""
 
         # Currently due to issue we need to check if pilorama exists in keys
         # TODO: make pilorama mandatory after fix
@@ -88,5 +94,6 @@ class Shard:
             blobstor=[Blobstor(path=blobstor["path"], path_type=blobstor["type"]) for blobstor in shard["blobstor"]],
             metabase=metabase,
             writecache=writecache,
-            pilorama=pilorama,
+            pilorama=pilorama
         )
+

src/frostfs_testlib/storage/dataclasses/storage_object_info.py

@@ -1,7 +1,6 @@
 from dataclasses import dataclass
 from typing import Optional
 
-from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
 from frostfs_testlib.testing.readable import HumanReadableEnum
 
 
@@ -20,7 +19,7 @@ class LockObjectInfo(ObjectRef):
 @dataclass
 class StorageObjectInfo(ObjectRef):
     size: Optional[int] = None
-    wallet: Optional[WalletInfo] = None
+    wallet_file_path: Optional[str] = None
     file_path: Optional[str] = None
     file_hash: Optional[str] = None
     attributes: Optional[list[dict[str, str]]] = None
@@ -28,7 +27,7 @@ class StorageObjectInfo(ObjectRef):
     locks: Optional[list[LockObjectInfo]] = None
 
 
-class NodeStatus(HumanReadableEnum):
+class ModeNode(HumanReadableEnum):
     MAINTENANCE: str = "maintenance"
     ONLINE: str = "online"
     OFFLINE: str = "offline"
@@ -37,7 +36,7 @@ class NodeStatus(HumanReadableEnum):
 @dataclass
 class NodeNetmapInfo:
     node_id: str = None
-    node_status: NodeStatus = None
+    node_status: ModeNode = None
     node_data_ips: list[str] = None
     cluster_name: str = None
     continent: str = None
@@ -70,26 +69,8 @@ class NodeNetInfo:
     epoch_duration: str = None
     inner_ring_candidate_fee: str = None
     maximum_object_size: str = None
-    maximum_count_of_data_shards: str = None
-    maximum_count_of_parity_shards: str = None
     withdrawal_fee: str = None
     homomorphic_hashing_disabled: str = None
     maintenance_mode_allowed: str = None
     eigen_trust_alpha: str = None
     eigen_trust_iterations: str = None
-
-
-@dataclass
-class Chunk:
-    def __init__(self, object_id: str, required_nodes: list, confirmed_nodes: list, ec_parent_object_id: str, ec_index: int) -> None:
-        self.object_id = object_id
-        self.required_nodes = required_nodes
-        self.confirmed_nodes = confirmed_nodes
-        self.ec_parent_object_id = ec_parent_object_id
-        self.ec_index = ec_index
-
-    def __str__(self) -> str:
-        return self.object_id
-
-    def __repr__(self) -> str:
-        return self.object_id

src/frostfs_testlib/storage/dataclasses/wallet.py

@@ -1,15 +1,13 @@
 import json
 import logging
 import os
+import uuid
 from dataclasses import dataclass
 from typing import Optional
 
-import yaml
+from frostfs_testlib.resources.common import DEFAULT_WALLET_CONFIG, DEFAULT_WALLET_PASS
-
-from frostfs_testlib import reporter
-from frostfs_testlib.resources.common import ASSETS_DIR, DEFAULT_WALLET_CONFIG, DEFAULT_WALLET_PASS
 from frostfs_testlib.shell import Shell
-from frostfs_testlib.storage.cluster import NodeBase
+from frostfs_testlib.storage.cluster import Cluster, NodeBase
 from frostfs_testlib.utils.wallet_utils import get_last_address_from_wallet, init_wallet
 
 logger = logging.getLogger("frostfs.testlib.utils")
@@ -23,13 +21,9 @@ class WalletInfo:
 
     @staticmethod
     def from_node(node: NodeBase):
-        wallet_path = node.get_wallet_path()
+        return WalletInfo(
-        wallet_password = node.get_wallet_password()
+            node.get_wallet_path(), node.get_wallet_password(), node.get_wallet_config_path()
-        wallet_config_file = os.path.join(ASSETS_DIR, os.path.basename(node.get_wallet_config_path()))
+        )
-        with open(wallet_config_file, "w") as file:
-            file.write(yaml.dump({"wallet": wallet_path, "password": wallet_password}))
-
-        return WalletInfo(wallet_path, wallet_password, wallet_config_file)
 
     def get_address(self) -> str:
         """
@@ -53,17 +47,22 @@ class WalletInfo:
         """
         with open(self.path, "r") as wallet:
             wallet_json = json.load(wallet)
-        assert abs(account_id) + 1 <= len(wallet_json["accounts"]), f"There is no index '{account_id}' in wallet: {wallet_json}"
+        assert abs(account_id) + 1 <= len(
+            wallet_json["accounts"]
+        ), f"There is no index '{account_id}' in wallet: {wallet_json}"
 
         return wallet_json["accounts"][account_id]["address"]
 
 
 class WalletFactory:
-    def __init__(self, wallets_dir: str, shell: Shell) -> None:
+    def __init__(self, wallets_dir: str, shell: Shell, cluster: Cluster) -> None:
         self.shell = shell
         self.wallets_dir = wallets_dir
+        self.cluster = cluster
 
-    def create_wallet(self, file_name: str, password: Optional[str] = None) -> WalletInfo:
+    def create_wallet(
+        self, file_name: Optional[str] = None, password: Optional[str] = None
+    ) -> WalletInfo:
         """
         Creates new default wallet.
 
@@ -75,6 +74,8 @@ class WalletFactory:
             WalletInfo object of new wallet.
         """
 
+        if file_name is None:
+            file_name = str(uuid.uuid4())
         if password is None:
             password = ""
 
@@ -84,8 +85,6 @@ class WalletFactory:
         init_wallet(wallet_path, password)
 
         with open(wallet_config_path, "w") as config_file:
-            config_file.write(f'wallet: {wallet_path}\npassword: "{password}"')
+            config_file.write(f'password: "{password}"')
-
-        reporter.attach(wallet_path, os.path.basename(wallet_path))
 
         return WalletInfo(wallet_path, password, wallet_config_path)

src/frostfs_testlib/storage/grpc_operations/client_wrappers.py

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

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

@@ -1,165 +0,0 @@
-import json
-from typing import Optional
-
-from frostfs_testlib import reporter
-from frostfs_testlib.cli.frostfs_cli.cli import FrostfsCli
-from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT
-from frostfs_testlib.storage.cluster import Cluster, ClusterNode
-from frostfs_testlib.storage.controllers.shards_watcher import ShardsWatcher
-from frostfs_testlib.storage.dataclasses.storage_object_info import Chunk, NodeNetmapInfo
-from frostfs_testlib.storage.grpc_operations import interfaces
-from frostfs_testlib.testing.test_control import wait_for_success
-from frostfs_testlib.utils.cli_utils import parse_netmap_output
-
-
-class ChunksOperations(interfaces.ChunksInterface):
-    def __init__(self, cli: FrostfsCli) -> None:
-        self.cli = cli
-
-    @reporter.step("Search node without chunks")
-    def search_node_without_chunks(self, chunks: list[Chunk], cluster: Cluster, endpoint: str = None) -> list[ClusterNode]:
-        if not endpoint:
-            endpoint = cluster.default_rpc_endpoint
-        netmap = parse_netmap_output(self.cli.netmap.snapshot(endpoint, timeout=CLI_DEFAULT_TIMEOUT).stdout)
-        chunks_node_key = []
-        for chunk in chunks:
-            chunks_node_key.extend(chunk.confirmed_nodes)
-        for node_info in netmap.copy():
-            if node_info.node_id in chunks_node_key and node_info in netmap:
-                netmap.remove(node_info)
-        result = []
-        for node_info in netmap:
-            for cluster_node in cluster.cluster_nodes:
-                if node_info.node == cluster_node.host_ip:
-                    result.append(cluster_node)
-        return result
-
-    @reporter.step("Search node with chunk {chunk}")
-    def get_chunk_node(self, cluster: Cluster, chunk: Chunk) -> tuple[ClusterNode, NodeNetmapInfo]:
-        netmap = parse_netmap_output(self.cli.netmap.snapshot(cluster.default_rpc_endpoint, timeout=CLI_DEFAULT_TIMEOUT).stdout)
-        for node_info in netmap:
-            if node_info.node_id in chunk.confirmed_nodes:
-                for cluster_node in cluster.cluster_nodes:
-                    if cluster_node.host_ip == node_info.node:
-                        return (cluster_node, node_info)
-
-    @wait_for_success(300, 5, fail_testcase=None)
-    @reporter.step("Search shard with chunk {chunk}")
-    def get_shard_chunk(self, node: ClusterNode, chunk: Chunk) -> str:
-        oid_path = f"{chunk.object_id[0]}/{chunk.object_id[1]}/{chunk.object_id[2]}/{chunk.object_id[3]}"
-        node_shell = node.storage_node.host.get_shell()
-        shards_watcher = ShardsWatcher(node)
-
-        with reporter.step("Search object file"):
-            for shard_id, shard_info in shards_watcher.shards_snapshots[-1].items():
-                check_dir = node_shell.exec(f" [ -d {shard_info['blobstor'][1]['path']}/{oid_path} ] && echo 1 || echo 0").stdout
-                if "1" in check_dir.strip():
-                    return shard_id
-
-    @reporter.step("Get all chunks")
-    def get_all(
-        self,
-        rpc_endpoint: str,
-        cid: str,
-        oid: str,
-        address: Optional[str] = None,
-        bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        trace: bool = True,
-        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]:
-        object_nodes = self.cli.object.nodes(
-            rpc_endpoint=rpc_endpoint,
-            cid=cid,
-            address=address,
-            bearer=bearer,
-            generate_key=generate_key,
-            oid=oid,
-            trace=trace,
-            root=root,
-            verify_presence_all=verify_presence_all,
-            json=json,
-            ttl=ttl,
-            xhdr=xhdr,
-            timeout=timeout,
-        )
-        return self._parse_object_nodes(object_nodes.stdout.split("\n")[0])
-
-    @reporter.step("Get last parity chunk")
-    def get_parity(
-        self,
-        rpc_endpoint: str,
-        cid: str,
-        address: Optional[str] = None,
-        bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        oid: Optional[str] = None,
-        trace: bool = True,
-        root: bool = False,
-        verify_presence_all: bool = False,
-        json: bool = True,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = None,
-    ) -> Chunk:
-        object_nodes = self.cli.object.nodes(
-            rpc_endpoint=rpc_endpoint,
-            cid=cid,
-            address=address,
-            bearer=bearer,
-            generate_key=generate_key,
-            oid=oid,
-            trace=trace,
-            root=root,
-            verify_presence_all=verify_presence_all,
-            json=json,
-            ttl=ttl,
-            xhdr=xhdr,
-            timeout=timeout,
-        )
-        return self._parse_object_nodes(object_nodes.stdout.split("\n")[0])[-1]
-
-    @reporter.step("Get first data chunk")
-    def get_first_data(
-        self,
-        rpc_endpoint: str,
-        cid: str,
-        oid: Optional[str] = None,
-        address: Optional[str] = None,
-        bearer: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        trace: bool = True,
-        root: bool = False,
-        verify_presence_all: bool = False,
-        json: bool = True,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
-    ) -> Chunk:
-        object_nodes = self.cli.object.nodes(
-            rpc_endpoint=rpc_endpoint,
-            cid=cid,
-            address=address,
-            bearer=bearer,
-            generate_key=generate_key,
-            oid=oid,
-            trace=trace,
-            root=root,
-            verify_presence_all=verify_presence_all,
-            json=json,
-            ttl=ttl,
-            xhdr=xhdr,
-            timeout=timeout,
-        )
-        return self._parse_object_nodes(object_nodes.stdout.split("\n")[0])[0]
-
-    def _parse_object_nodes(self, object_nodes: str) -> list[Chunk]:
-        parse_result = json.loads(object_nodes)
-        if parse_result.get("errors"):
-            raise parse_result["errors"]
-        return [Chunk(**chunk) for chunk in parse_result["data_objects"]]

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

@@ -1,330 +0,0 @@
-import json
-import logging
-import re
-from typing import List, Optional, Union
-
-from frostfs_testlib import reporter
-from frostfs_testlib.cli.frostfs_cli.cli import FrostfsCli
-from frostfs_testlib.plugins import load_plugin
-from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT
-from frostfs_testlib.s3.interfaces import BucketContainerResolver
-from frostfs_testlib.storage.cluster import Cluster, ClusterNode
-from frostfs_testlib.storage.grpc_operations import interfaces
-from frostfs_testlib.utils import json_utils
-
-logger = logging.getLogger("NeoLogger")
-
-
-class ContainerOperations(interfaces.ContainerInterface):
-    def __init__(self, cli: FrostfsCli) -> None:
-        self.cli = cli
-
-    @reporter.step("Create Container")
-    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] = CLI_DEFAULT_TIMEOUT,
-    ) -> str:
-        """
-        A wrapper for `frostfs-cli container create` call.
-
-        Args:
-            wallet (WalletInfo): a wallet on whose behalf a container is created
-            rule (optional, str): placement rule for container
-            basic_acl (optional, str): an ACL for container, will be
-                                appended to `--basic-acl` key
-            attributes (optional, dict): container attributes , will be
-                                appended to `--attributes` key
-            session_token (optional, str): a path to session token file
-            session_wallet(optional, str): a path to the wallet which signed
-                                the session token; this parameter makes sense
-                                when paired with `session_token`
-            shell: executor for cli command
-            endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
-            options (optional, dict): any other options to pass to the call
-            name (optional, str): container name attribute
-            await_mode (bool): block execution until container is persisted
-            wait_for_creation (): Wait for container shows in container list
-            timeout: Timeout for the operation.
-
-        Returns:
-            (str): CID of the created container
-        """
-        result = self.cli.container.create(
-            rpc_endpoint=endpoint,
-            policy=policy,
-            nns_zone=nns_zone,
-            nns_name=nns_name,
-            address=address,
-            attributes=attributes,
-            basic_acl=basic_acl,
-            await_mode=await_mode,
-            disable_timestamp=disable_timestamp,
-            force=force,
-            trace=trace,
-            name=name,
-            nonce=nonce,
-            session=session,
-            subnet=subnet,
-            ttl=ttl,
-            xhdr=xhdr,
-            timeout=timeout,
-        )
-
-        cid = self._parse_cid(result.stdout)
-
-        logger.info("Container created; waiting until it is persisted in the sidechain")
-
-        return cid
-
-    @reporter.step("List Containers")
-    def list(
-        self,
-        endpoint: str,
-        name: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        owner: Optional[str] = None,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
-        **params,
-    ) -> List[str]:
-        """
-        A wrapper for `frostfs-cli container list` call. It returns all the
-        available containers for the given wallet.
-        Args:
-            shell: executor for cli command
-            endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
-            timeout: Timeout for the operation.
-        Returns:
-            (list): list of containers
-        """
-        result = self.cli.container.list(
-            rpc_endpoint=endpoint,
-            name=name,
-            address=address,
-            generate_key=generate_key,
-            owner=owner,
-            ttl=ttl,
-            xhdr=xhdr,
-            timeout=timeout,
-            **params,
-        )
-        return result.stdout.split()
-
-    @reporter.step("List Objects in container")
-    def list_objects(
-        self,
-        endpoint: str,
-        cid: str,
-        bearer: Optional[str] = None,
-        wallet: Optional[str] = None,
-        address: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        trace: bool = False,
-        ttl: Optional[int] = None,
-        xhdr: Optional[dict] = None,
-        timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
-    ) -> List[str]:
-        """
-        A wrapper for `frostfs-cli container list-objects` call. It returns all the
-        available objects in container.
-        Args:
-            container_id: cid of container
-            endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
-            timeout: Timeout for the operation.
-        Returns:
-            (list): list of containers
-        """
-        result = self.cli.container.list_objects(
-            rpc_endpoint=endpoint,
-            cid=cid,
-            bearer=bearer,
-            wallet=wallet,
-            address=address,
-            generate_key=generate_key,
-            trace=trace,
-            ttl=ttl,
-            xhdr=xhdr,
-            timeout=timeout,
-        )
-        logger.info(f"Container objects: \n{result}")
-        return result.stdout.split()
-
-    @reporter.step("Delete container")
-    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,
-    ):
-        try:
-            return self.cli.container.delete(
-                rpc_endpoint=endpoint,
-                cid=cid,
-                address=address,
-                await_mode=await_mode,
-                session=session,
-                ttl=ttl,
-                xhdr=xhdr,
-                force=force,
-                trace=trace,
-            ).stdout
-        except RuntimeError as e:
-            print(f"Error request:\n{e}")
-
-    @reporter.step("Get container")
-    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] = CLI_DEFAULT_TIMEOUT,
-    ) -> Union[dict, str]:
-        result = self.cli.container.get(
-            rpc_endpoint=endpoint,
-            cid=cid,
-            address=address,
-            generate_key=generate_key,
-            await_mode=await_mode,
-            to=to,
-            json_mode=json_mode,
-            trace=trace,
-            ttl=ttl,
-            xhdr=xhdr,
-            timeout=timeout,
-        )
-        container_info = json.loads(result.stdout)
-        attributes = dict()
-        for attr in container_info["attributes"]:
-            attributes[attr["key"]] = attr["value"]
-        container_info["attributes"] = attributes
-        container_info["ownerID"] = json_utils.json_reencode(container_info["ownerID"]["value"])
-        return container_info
-
-    @reporter.step("Get eacl container")
-    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] = CLI_DEFAULT_TIMEOUT,
-    ):
-        return self.cli.container.get_eacl(
-            rpc_endpoint=endpoint,
-            cid=cid,
-            address=address,
-            generate_key=generate_key,
-            await_mode=await_mode,
-            to=to,
-            session=session,
-            ttl=ttl,
-            xhdr=xhdr,
-            timeout=CLI_DEFAULT_TIMEOUT,
-        ).stdout
-
-    @reporter.step("Get nodes container")
-    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] = CLI_DEFAULT_TIMEOUT,
-    ) -> List[ClusterNode]:
-        result = self.cli.container.search_node(
-            rpc_endpoint=endpoint,
-            cid=cid,
-            address=address,
-            ttl=ttl,
-            from_file=from_file,
-            trace=trace,
-            short=short,
-            xhdr=xhdr,
-            generate_key=generate_key,
-            timeout=timeout,
-        ).stdout
-
-        pattern = r"[0-9]+(?:\.[0-9]+){3}"
-        nodes_ip = list(set(re.findall(pattern, result)))
-
-        with reporter.step(f"nodes ips = {nodes_ip}"):
-            nodes_list = cluster.get_nodes_by_ip(nodes_ip)
-
-        with reporter.step(f"Return nodes - {nodes_list}"):
-            return nodes_list
-
-    @reporter.step("Resolve container by name")
-    def resolve_container_by_name(name: str, node: ClusterNode):
-        resolver_cls = load_plugin("frostfs.testlib.bucket_cid_resolver", node.host.config.product)
-        resolver: BucketContainerResolver = resolver_cls()
-        return resolver.resolve(node, name)
-
-    def _parse_cid(self, output: str) -> str:
-        """
-        Parses container ID from a given CLI output. The input string we expect:
-                container ID: 2tz86kVTDpJxWHrhw3h6PbKMwkLtBEwoqhHQCKTre1FN
-                awaiting...
-                container has been persisted on sidechain
-        We want to take 'container ID' value from the string.
-
-        Args:
-            output (str): CLI output to parse
-
-        Returns:
-            (str): extracted CID
-        """
-        try:
-            # taking first line from command's output
-            first_line = output.split("\n")[0]
-        except Exception:
-            first_line = ""
-            logger.error(f"Got empty output: {output}")
-        splitted = first_line.split(": ")
-        if len(splitted) != 2:
-            raise ValueError(f"no CID was parsed from command output: \t{first_line}")
-        return splitted[1]

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

@@ -1,624 +0,0 @@
-import json
-import logging
-import os
-import re
-import uuid
-from typing import Any, Optional
-
-from frostfs_testlib import reporter, utils
-from frostfs_testlib.cli.frostfs_cli.cli import FrostfsCli
-from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT
-from frostfs_testlib.resources.common import ASSETS_DIR
-from frostfs_testlib.shell.interfaces import CommandResult
-from frostfs_testlib.storage.cluster import Cluster, ClusterNode
-from frostfs_testlib.storage.grpc_operations import interfaces
-from frostfs_testlib.storage.grpc_operations.implementations.chunks import ChunksOperations
-from frostfs_testlib.testing.test_control import wait_for_success
-from frostfs_testlib.utils import cli_utils, file_utils
-
-logger = logging.getLogger("NeoLogger")
-
-
-class ObjectOperations(interfaces.ObjectInterface):
-    def __init__(self, cli: FrostfsCli) -> None:
-        self.cli = cli
-        self.chunks: interfaces.ChunksInterface = ChunksOperations(self.cli)
-
-    @reporter.step("Delete object")
-    def delete(
-        self,
-        cid: str,
-        oid: str,
-        endpoint: str,
-        bearer: str = "",
-        xhdr: Optional[dict] = None,
-        session: Optional[str] = None,
-        timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
-    ) -> str:
-        """
-        DELETE an Object.
-
-        Args:
-            cid: ID of Container where we get the Object from
-            oid: ID of Object we are going to delete
-            bearer: path to Bearer Token file, appends to `--bearer` key
-            endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
-            xhdr: Request X-Headers in form of Key=Value
-            session: path to a JSON-encoded container session token
-            timeout: Timeout for the operation.
-        Returns:
-            (str): Tombstone ID
-        """
-        result = self.cli.object.delete(
-            rpc_endpoint=endpoint,
-            cid=cid,
-            oid=oid,
-            bearer=bearer,
-            xhdr=xhdr,
-            session=session,
-            timeout=timeout,
-        )
-
-        id_str = result.stdout.split("\n")[1]
-        tombstone = id_str.split(":")[1]
-        return tombstone.strip()
-
-    @reporter.step("Get object")
-    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] = CLI_DEFAULT_TIMEOUT,
-    ) -> file_utils.TestFile:
-        """
-        GET from FrostFS.
-
-        Args:
-            cid (str): ID of Container where we get the Object from
-            oid (str): Object ID
-            bearer: path to Bearer Token file, appends to `--bearer` key
-            write_object: path to downloaded file, appends to `--file` key
-            endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
-            no_progress(optional, bool): do not show progress bar
-            xhdr (optional, dict): Request X-Headers in form of Key=Value
-            session (optional, dict): path to a JSON-encoded container session token
-            timeout: Timeout for the operation.
-        Returns:
-            (str): path to downloaded file
-        """
-        if not write_object:
-            write_object = str(uuid.uuid4())
-        test_file = file_utils.TestFile(os.path.join(ASSETS_DIR, write_object))
-
-        self.cli.object.get(
-            rpc_endpoint=endpoint,
-            cid=cid,
-            oid=oid,
-            file=test_file,
-            bearer=bearer,
-            no_progress=no_progress,
-            xhdr=xhdr,
-            session=session,
-            timeout=timeout,
-        )
-
-        return test_file
-
-    @reporter.step("Get object from random node")
-    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] = CLI_DEFAULT_TIMEOUT,
-    ) -> str:
-        """
-        GET from FrostFS random storage node
-
-        Args:
-            cid: ID of Container where we get the Object from
-            oid: Object ID
-            cluster: cluster object
-            bearer (optional, str): path to Bearer Token file, appends to `--bearer` key
-            write_object (optional, str): path to downloaded file, appends to `--file` key
-            no_progress(optional, bool): do not show progress bar
-            xhdr (optional, dict): Request X-Headers in form of Key=Value
-            session (optional, dict): path to a JSON-encoded container session token
-            timeout: Timeout for the operation.
-        Returns:
-            (str): path to downloaded file
-        """
-        endpoint = cluster.get_random_storage_rpc_endpoint()
-        return self.get(
-            cid,
-            oid,
-            endpoint,
-            bearer,
-            write_object,
-            xhdr,
-            no_progress,
-            session,
-            timeout,
-        )
-
-    @reporter.step("Get hash object")
-    def hash(
-        self,
-        rpc_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] = CLI_DEFAULT_TIMEOUT,
-    ) -> str:
-        """
-        Get object hash.
-
-        Args:
-            address: Address of wallet account.
-            bearer: File with signed JSON or binary encoded bearer token.
-            cid: Container ID.
-            generate_key: Generate new private key.
-            oid: Object ID.
-            range: Range to take hash from in the form offset1:length1,...
-            rpc_endpoint: Remote node address (as 'multiaddr' or '<host>:<port>').
-            salt: Salt in hex format.
-            ttl: TTL value in request meta header (default 2).
-            session: Filepath to a JSON- or binary-encoded token of the object RANGEHASH session.
-            hash_type: Hash type. Either 'sha256' or 'tz' (default "sha256").
-            wallet: WIF (NEP-2) string or path to the wallet or binary key.
-            xhdr: Dict with request X-Headers.
-            timeout: Timeout for the operation (default 15s).
-
-        Returns:
-            Command's result.
-        """
-        result = self.cli.object.hash(
-            rpc_endpoint=rpc_endpoint,
-            cid=cid,
-            oid=oid,
-            address=address,
-            bearer=bearer,
-            generate_key=generate_key,
-            range=range,
-            salt=salt,
-            ttl=ttl,
-            xhdr=xhdr,
-            session=session,
-            hash_type=hash_type,
-            timeout=timeout,
-        )
-        return result.stdout
-
-    @reporter.step("Head object")
-    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] = CLI_DEFAULT_TIMEOUT,
-    ) -> CommandResult | Any:
-        """
-        HEAD an Object.
-
-        Args:
-            cid (str): ID of Container where we get the Object from
-            oid (str): ObjectID to HEAD
-            bearer (optional, str): path to Bearer Token file, appends to `--bearer` key
-            endpoint(optional, str): FrostFS endpoint to send request to
-            json_output(optional, bool): return response in JSON format or not; this flag
-                                        turns into `--json` key
-            is_raw(optional, bool): send "raw" request or not; this flag
-                                        turns into `--raw` key
-            is_direct(optional, bool): send request directly to the node or not; this flag
-                                        turns into `--ttl 1` key
-            xhdr (optional, dict): Request X-Headers in form of Key=Value
-            session (optional, dict): path to a JSON-encoded container session token
-            timeout: Timeout for the operation.
-        Returns:
-            depending on the `json_output` parameter value, the function returns
-            (dict): HEAD response in JSON format
-            or
-            (str): HEAD response as a plain text
-        """
-        result = self.cli.object.head(
-            rpc_endpoint=endpoint,
-            cid=cid,
-            oid=oid,
-            bearer=bearer,
-            json_mode=json_output,
-            raw=is_raw,
-            ttl=1 if is_direct else None,
-            xhdr=xhdr,
-            session=session,
-            timeout=timeout,
-        )
-
-        if not json_output:
-            return result
-
-        try:
-            decoded = json.loads(result.stdout)
-        except Exception as exc:
-            # If we failed to parse output as JSON, the cause might be
-            # the plain text string in the beginning of the output.
-            # Here we cut off first string and try to parse again.
-            logger.info(f"failed to parse output: {exc}")
-            logger.info("parsing output in another way")
-            fst_line_idx = result.stdout.find("\n")
-            decoded = json.loads(result.stdout[fst_line_idx:])
-
-        # if response
-        if "chunks" in decoded.keys():
-            logger.info("decoding ec chunks")
-            return decoded["chunks"]
-
-        # If response is Complex Object header, it has `splitId` key
-        if "splitId" in decoded.keys():
-            logger.info("decoding split header")
-            return utils.json_utils.decode_split_header(decoded)
-
-        # If response is Last or Linking Object header,
-        # it has `header` dictionary and non-null `split` dictionary
-        if "split" in decoded["header"].keys():
-            if decoded["header"]["split"]:
-                logger.info("decoding linking object")
-                return utils.json_utils.decode_linking_object(decoded)
-
-        if decoded["header"]["objectType"] == "STORAGE_GROUP":
-            logger.info("decoding storage group")
-            return utils.json_utils.decode_storage_group(decoded)
-
-        if decoded["header"]["objectType"] == "TOMBSTONE":
-            logger.info("decoding tombstone")
-            return utils.json_utils.decode_tombstone(decoded)
-
-        logger.info("decoding simple header")
-        return utils.json_utils.decode_simple_header(decoded)
-
-    @reporter.step("Lock Object")
-    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] = CLI_DEFAULT_TIMEOUT,
-    ) -> str:
-        """
-        Locks object in container.
-
-        Args:
-            address: Address of wallet account.
-            bearer: File with signed JSON or binary encoded bearer token.
-            cid: Container ID.
-            oid: Object ID.
-            lifetime: Lock lifetime.
-            expire_at: Lock expiration epoch.
-            shell: executor for cli command
-            endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
-            session: Path to a JSON-encoded container session token.
-            ttl: TTL value in request meta header (default 2).
-            wallet: WIF (NEP-2) string or path to the wallet or binary key.
-            xhdr: Dict with request X-Headers.
-            timeout: Timeout for the operation.
-
-        Returns:
-            Lock object ID
-        """
-        result = self.cli.object.lock(
-            rpc_endpoint=endpoint,
-            lifetime=lifetime,
-            expire_at=expire_at,
-            address=address,
-            cid=cid,
-            oid=oid,
-            bearer=bearer,
-            xhdr=xhdr,
-            session=session,
-            ttl=ttl,
-            timeout=timeout,
-        )
-
-        # Splitting CLI output to separate lines and taking the penultimate line
-        id_str = result.stdout.strip().split("\n")[0]
-        oid = id_str.split(":")[1]
-        return oid.strip()
-
-    @reporter.step("Put object")
-    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] = CLI_DEFAULT_TIMEOUT,
-    ) -> str:
-        """
-        PUT of given file.
-
-        Args:
-            path: path to file to be PUT
-            cid: ID of Container where we get the Object from
-            bearer: path to Bearer Token file, appends to `--bearer` key
-            copies_number: Number of copies of the object to store within the RPC call
-            attributes: User attributes in form of Key1=Value1,Key2=Value2
-            endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
-            no_progress: do not show progress bar
-            expire_at: Last epoch in the life of the object
-            xhdr: Request X-Headers in form of Key=Value
-            session: path to a JSON-encoded container session token
-            timeout: Timeout for the operation.
-        Returns:
-            (str): ID of uploaded Object
-        """
-        result = self.cli.object.put(
-            rpc_endpoint=endpoint,
-            file=path,
-            cid=cid,
-            attributes=attributes,
-            bearer=bearer,
-            copies_number=copies_number,
-            expire_at=expire_at,
-            no_progress=no_progress,
-            xhdr=xhdr,
-            session=session,
-            timeout=timeout,
-        )
-
-        # Splitting CLI output to separate lines and taking the penultimate line
-        id_str = result.stdout.strip().split("\n")[-2]
-        oid = id_str.split(":")[1]
-        return oid.strip()
-
-    @reporter.step("Put object to random node")
-    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] = CLI_DEFAULT_TIMEOUT,
-    ) -> str:
-        """
-        PUT of given file to a random storage node.
-
-        Args:
-            path: path to file to be PUT
-            cid: ID of Container where we get the Object from
-            cluster: cluster under test
-            bearer: path to Bearer Token file, appends to `--bearer` key
-            copies_number: Number of copies of the object to store within the RPC call
-            attributes: User attributes in form of Key1=Value1,Key2=Value2
-            cluster: cluster under test
-            no_progress: do not show progress bar
-            expire_at: Last epoch in the life of the object
-            xhdr: Request X-Headers in form of Key=Value
-            session: path to a JSON-encoded container session token
-            timeout: Timeout for the operation.
-        Returns:
-            ID of uploaded Object
-        """
-        endpoint = cluster.get_random_storage_rpc_endpoint()
-        return self.put(
-            path,
-            cid,
-            endpoint,
-            bearer,
-            copies_number,
-            attributes,
-            xhdr,
-            expire_at,
-            no_progress,
-            session,
-            timeout=timeout,
-        )
-
-    @reporter.step("Get Range")
-    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] = CLI_DEFAULT_TIMEOUT,
-    ) -> tuple[file_utils.TestFile, bytes]:
-        """
-        GETRANGE an Object.
-
-        Args:
-            wallet: wallet on whose behalf GETRANGE is done
-            cid: ID of Container where we get the Object from
-            oid: ID of Object we are going to request
-            range_cut: range to take data from in the form offset:length
-            shell: executor for cli command
-            endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
-            bearer: path to Bearer Token file, appends to `--bearer` key
-            xhdr: Request X-Headers in form of Key=Value
-            session: path to a JSON-encoded container session token
-            timeout: Timeout for the operation.
-        Returns:
-            (str, bytes) - path to the file with range content and content of this file as bytes
-        """
-        test_file = file_utils.TestFile(os.path.join(ASSETS_DIR, str(uuid.uuid4())))
-
-        self.cli.object.range(
-            rpc_endpoint=endpoint,
-            cid=cid,
-            oid=oid,
-            range=range_cut,
-            file=test_file,
-            bearer=bearer,
-            xhdr=xhdr,
-            session=session,
-            timeout=timeout,
-        )
-
-        with open(test_file, "rb") as file:
-            content = file.read()
-        return test_file, content
-
-    @reporter.step("Search object")
-    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] = CLI_DEFAULT_TIMEOUT,
-        address: Optional[str] = None,
-        generate_key: Optional[bool] = None,
-        ttl: Optional[int] = None,
-    ) -> list:
-        """
-        SEARCH an Object.
-
-        Args:
-            wallet: wallet on whose behalf SEARCH is done
-            cid: ID of Container where we get the Object from
-            shell: executor for cli command
-            bearer: path to Bearer Token file, appends to `--bearer` key
-            endpoint: FrostFS endpoint to send request to, appends to `--rpc-endpoint` key
-            filters: key=value pairs to filter Objects
-            expected_objects_list: a list of ObjectIDs to compare found Objects with
-            xhdr: Request X-Headers in form of Key=Value
-            session: path to a JSON-encoded container session token
-            phy: Search physically stored objects.
-            root: Search for user objects.
-            timeout: Timeout for the operation.
-
-        Returns:
-            list of found ObjectIDs
-        """
-        result = self.cli.object.search(
-            rpc_endpoint=endpoint,
-            cid=cid,
-            bearer=bearer,
-            oid=oid,
-            xhdr=xhdr,
-            filters=[f"{filter_key} EQ {filter_val}" for filter_key, filter_val in filters.items()] if filters else None,
-            session=session,
-            phy=phy,
-            root=root,
-            address=address,
-            generate_key=generate_key,
-            ttl=ttl,
-            timeout=timeout,
-        )
-
-        found_objects = re.findall(r"(\w{43,44})", result.stdout)
-
-        if expected_objects_list:
-            if sorted(found_objects) == sorted(expected_objects_list):
-                logger.info(f"Found objects list '{found_objects}' " f"is equal for expected list '{expected_objects_list}'")
-            else:
-                logger.warning(f"Found object list {found_objects} " f"is not equal to expected list '{expected_objects_list}'")
-
-        return found_objects
-
-    @wait_for_success()
-    @reporter.step("Search object nodes")
-    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] = CLI_DEFAULT_TIMEOUT,
-    ) -> list[ClusterNode]:
-        endpoint = alive_node.storage_node.get_rpc_endpoint()
-
-        response = self.cli.object.nodes(
-            rpc_endpoint=endpoint,
-            cid=cid,
-            oid=oid,
-            bearer=bearer,
-            ttl=1 if is_direct else None,
-            json=True,
-            xhdr=xhdr,
-            timeout=timeout,
-            verify_presence_all=verify_presence_all,
-        )
-
-        response_json = json.loads(response.stdout)
-        # Currently, the command will show expected and confirmed nodes.
-        # And we (currently) count only nodes which are both expected and confirmed
-        object_nodes_id = {
-            required_node
-            for data_object in response_json["data_objects"]
-            for required_node in data_object["required_nodes"]
-            if required_node in data_object["confirmed_nodes"]
-        }
-
-        netmap_nodes_list = cli_utils.parse_netmap_output(
-            self.cli.netmap.snapshot(
-                rpc_endpoint=endpoint,
-            ).stdout
-        )
-        netmap_nodes = [
-            netmap_node for object_node in object_nodes_id for netmap_node in netmap_nodes_list if object_node == netmap_node.node_id
-        ]
-
-        object_nodes = [
-            cluster_node
-            for netmap_node in netmap_nodes
-            for cluster_node in cluster.cluster_nodes
-            if netmap_node.node == cluster_node.host_ip
-        ]
-
-        return object_nodes

src/frostfs_testlib/storage/grpc_operations/interfaces.py

@@ -1,392 +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 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
-
-
-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/testing/cluster_test_base.py

@@ -25,10 +25,14 @@ class ClusterTestBase:
         for _ in range(epochs_to_tick):
             self.tick_epoch(alive_node, wait_block)
 
-    def tick_epoch(self, alive_node: Optional[StorageNode] = None, wait_block: int = None, delta: Optional[int] = None):
+    def tick_epoch(
-        epoch.tick_epoch(self.shell, self.cluster, alive_node=alive_node, delta=delta)
+        self,
+        alive_node: Optional[StorageNode] = None,
+        wait_block: int = None,
+    ):
+        epoch.tick_epoch(self.shell, self.cluster, alive_node=alive_node)
         if wait_block:
-            self.wait_for_blocks(wait_block)
+            time.sleep(datetime_utils.parse_time(MORPH_BLOCK_TIME) * wait_block)
 
     def wait_for_epochs_align(self):
         epoch.wait_for_epochs_align(self.shell, self.cluster)
@@ -38,6 +42,3 @@ class ClusterTestBase:
 
     def ensure_fresh_epoch(self):
         return epoch.ensure_fresh_epoch(self.shell, self.cluster)
-
-    def wait_for_blocks(self, blocks_count: int = 1):
-        time.sleep(datetime_utils.parse_time(MORPH_BLOCK_TIME) * blocks_count)

src/frostfs_testlib/testing/parallel.py

@@ -1,22 +1,7 @@
 import itertools
-import traceback
 from concurrent.futures import Future, ThreadPoolExecutor
-from contextlib import contextmanager
 from typing import Callable, Collection, Optional, Union
 
-MAX_WORKERS = 50
-
-
-@contextmanager
-def parallel_workers_limit(workers_count: int):
-    global MAX_WORKERS
-    original_value = MAX_WORKERS
-    MAX_WORKERS = workers_count
-    try:
-        yield
-    finally:
-        MAX_WORKERS = original_value
-
 
 def parallel(
     fn: Union[Callable, list[Callable]],
@@ -56,42 +41,7 @@ def parallel(
     # Check for exceptions
     exceptions = [future.exception() for future in futures if future.exception()]
     if exceptions:
-        # Prettify exception in parallel with all underlying stack traces
+        message = "\n".join([str(e) for e in exceptions])
-        # For example, we had 3 RuntimeError exceptions during parallel. This format will give us something like
-        #
-        # RuntimeError: The following exceptions occured during parallel run:
-        # 1) Exception one text
-        # 2) Exception two text
-        # 3) Exception three text
-        # TRACES:
-        # ==== 1 ====
-        # Traceback (most recent call last):
-        #   File "/usr/lib/python3.10/concurrent/futures/thread.py", line 58, in run
-        #     result = self.fn(*self.args, **self.kwargs)
-        #   File "frostfs_testcases/pytest_tests/testsuites/object/test_object_tombstone.py", line 17, in check_service
-        #     raise RuntimeError(f"Exception one text")
-        # RuntimeError: Exception one text
-        #
-        # ==== 2 ====
-        # Traceback (most recent call last):
-        #   File "/usr/lib/python3.10/concurrent/futures/thread.py", line 58, in run
-        #     result = self.fn(*self.args, **self.kwargs)
-        #   File "frostfs_testcases/pytest_tests/testsuites/object/test_object_tombstone.py", line 17, in check_service
-        #     raise RuntimeError(f"Exception two text")
-        # RuntimeError: Exception two text
-        #
-        # ==== 3 ====
-        # Traceback (most recent call last):
-        #   File "/usr/lib/python3.10/concurrent/futures/thread.py", line 58, in run
-        #     result = self.fn(*self.args, **self.kwargs)
-        #   File "frostfs_testcases/pytest_tests/testsuites/object/test_object_tombstone.py", line 17, in check_service
-        #     raise RuntimeError(f"Exception three text")
-        # RuntimeError: Exception three text
-        short_summary = "\n".join([f"{i}) {str(e)}" for i, e in enumerate(exceptions, 1)])
-        stack_traces = "\n".join(
-            [f"==== {i} ====\n{''.join(traceback.TracebackException.from_exception(e).format())}" for i, e in enumerate(exceptions, 1)]
-        )
-        message = f"{short_summary}\nTRACES:\n{stack_traces}"
         raise RuntimeError(f"The following exceptions occured during parallel run:\n{message}")
     return futures
 
@@ -104,7 +54,7 @@ def _run_by_fn_list(fn_list: list[Callable], *args, **kwargs) -> list[Future]:
 
     futures: list[Future] = []
 
-    with ThreadPoolExecutor(max_workers=min(len(fn_list), MAX_WORKERS)) as executor:
+    with ThreadPoolExecutor(max_workers=len(fn_list)) as executor:
         for fn in fn_list:
             task_args = _get_args(*args)
             task_kwargs = _get_kwargs(**kwargs)
@@ -117,7 +67,7 @@ def _run_by_fn_list(fn_list: list[Callable], *args, **kwargs) -> list[Future]:
 def _run_by_items(fn: Callable, parallel_items: Collection, *args, **kwargs) -> list[Future]:
     futures: list[Future] = []
 
-    with ThreadPoolExecutor(max_workers=min(len(parallel_items), MAX_WORKERS)) as executor:
+    with ThreadPoolExecutor(max_workers=len(parallel_items)) as executor:
         for item in parallel_items:
             task_args = _get_args(*args)
             task_kwargs = _get_kwargs(**kwargs)

src/frostfs_testlib/testing/test_control.py

@@ -1,16 +1,13 @@
 import inspect
 import logging
-import os
 from functools import wraps
 from time import sleep, time
 from typing import Any
 
-import yaml
 from _pytest.outcomes import Failed
 from pytest import fail
 
 from frostfs_testlib import reporter
-from frostfs_testlib.resources.common import ASSETS_DIR
 from frostfs_testlib.utils.func_utils import format_by_args
 
 logger = logging.getLogger("NeoLogger")
@@ -131,42 +128,6 @@ def run_optionally(enabled: bool, mock_value: Any = True):
     return deco
 
 
-def cached_fixture(enabled: bool):
-    """
-    Decorator to cache fixtures.
-    MUST be placed after @pytest.fixture and before @allure decorators.
-
-    Args:
-    enabled: if true, decorated func will be cached.
-    """
-
-    def deco(func):
-        @wraps(func)
-        def func_impl(*a, **kw):
-            # TODO: *a and *kw should be parsed to some kind of hashsum and used in filename to prevent cache load from different parameters
-            cache_file = os.path.join(ASSETS_DIR, f"fixture_cache_{func.__name__}.yml")
-
-            if enabled and os.path.exists(cache_file):
-                with open(cache_file, "r") as cache_input:
-                    return yaml.load(cache_input, Loader=yaml.Loader)
-
-            result = func(*a, **kw)
-
-            if enabled:
-                with open(cache_file, "w") as cache_output:
-                    yaml.dump(result, cache_output)
-            return result
-
-        # TODO: cache yielding fixtures
-        @wraps(func)
-        def gen_impl(*a, **kw):
-            raise NotImplementedError("Not implemented for yielding fixtures")
-
-        return gen_impl if inspect.isgeneratorfunction(func) else func_impl
-
-    return deco
-
-
 def wait_for_success(
     max_wait_time: int = 60,
     interval: int = 1,

src/frostfs_testlib/utils/cli_utils.py

@@ -9,12 +9,13 @@ import csv
 import json
 import logging
 import re
+import subprocess
 import sys
 from contextlib import suppress
 from datetime import datetime
 from io import StringIO
 from textwrap import shorten
-from typing import Any, Optional, Union
+from typing import Dict, List, TypedDict, Union
 
 import pexpect
 
@@ -40,7 +41,7 @@ def _run_with_passwd(cmd: str) -> str:
     return cmd.decode()
 
 
-def _configure_aws_cli(cmd: str, key_id: str, access_key: str, region: str, out_format: str = "json") -> str:
+def _configure_aws_cli(cmd: str, key_id: str, access_key: str, out_format: str = "json") -> str:
     child = pexpect.spawn(cmd)
     child.delaybeforesend = 1
 
@@ -51,7 +52,7 @@ def _configure_aws_cli(cmd: str, key_id: str, access_key: str, region: str, out_
     child.sendline(access_key)
 
     child.expect("Default region name.*")
-    child.sendline("region")
+    child.sendline("")
 
     child.expect("Default output format.*")
     child.sendline(out_format)
@@ -74,75 +75,14 @@ def _attach_allure_log(cmd: str, output: str, return_code: int, start_time: date
         reporter.attach(command_attachment, "Command execution")
 
 
-def log_command_execution(cmd: str, output: Union[str, dict], params: Optional[dict] = None, **kwargs) -> None:
+def log_command_execution(cmd: str, output: Union[str, TypedDict]) -> None:
     logger.info(f"{cmd}: {output}")
-
+    with suppress(Exception):
-    if not params:
+        json_output = json.dumps(output, indent=4, sort_keys=True)
-        params = {}
+        output = json_output
-
+    command_attachment = f"COMMAND: '{cmd}'\n" f"OUTPUT:\n {output}\n"
-    output_params = params
+    with reporter.step(f'COMMAND: {shorten(cmd, width=60, placeholder="...")}'):
-
+        reporter.attach(command_attachment, "Command execution")
-    try:
-        json_params = json.dumps(params, indent=4, sort_keys=True, default=str)
-    except TypeError as err:
-        logger.warning(f"Failed to serialize '{cmd}' request parameters:\n{params}\nException: {err}")
-    else:
-        output_params = json_params
-
-    output = json.dumps(output, indent=4, sort_keys=True, default=str)
-
-    command_execution = f"COMMAND: '{cmd}'\n" f"URL: {kwargs['endpoint']}\n" f"PARAMS:\n{output_params}\n" f"OUTPUT:\n{output}\n"
-    aws_command = _convert_request_to_aws_cli_command(cmd, params, **kwargs)
-
-    reporter.attach(command_execution, "Command execution")
-    reporter.attach(aws_command, "AWS CLI Command")
-
-
-def _convert_request_to_aws_cli_command(command: str, params: dict, **kwargs) -> str:
-    overriden_names = [_convert_json_name_to_aws_cli(name) for name in kwargs.keys()]
-    command = command.replace("_", "-")
-    options = []
-
-    for name, value in params.items():
-        name = _convert_json_name_to_aws_cli(name)
-
-        # To override parameters for AWS CLI
-        if name in overriden_names:
-            continue
-
-        if option := _create_option(name, value):
-            options.append(option)
-
-    for name, value in kwargs.items():
-        name = _convert_json_name_to_aws_cli(name)
-        if option := _create_option(name, value):
-            options.append(option)
-
-    options = " ".join(options)
-    api = "s3api" if "s3" in kwargs["endpoint"] else "iam"
-    return f"aws --no-verify-ssl --no-paginate {api} {command} {options}"
-
-
-def _convert_json_name_to_aws_cli(name: str) -> str:
-    specific_names = {"CORSConfiguration": "cors-configuration"}
-
-    if aws_cli_name := specific_names.get(name):
-        return aws_cli_name
-    return re.sub(r"([a-z])([A-Z])", r"\1 \2", name).lower().replace(" ", "-").replace("_", "-")
-
-
-def _create_option(name: str, value: Any) -> str | None:
-    if isinstance(value, bool) and value:
-        return f"--{name}"
-
-    if isinstance(value, dict):
-        value = json.dumps(value, indent=4, sort_keys=True, default=str)
-        return f"--{name} '{value}'"
-
-    if value:
-        return f"--{name} {value}"
-
-    return None
 
 
 def parse_netmap_output(output: str) -> list[NodeNetmapInfo]: