import logging import os import random from time import sleep from typing import Optional, Tuple import allure import pytest from frostfs_testlib.cli import FrostfsCli from frostfs_testlib.cli.netmap_parser import NetmapParser from frostfs_testlib.resources.cli import FROSTFS_CLI_EXEC from frostfs_testlib.resources.common import DEFAULT_WALLET_CONFIG, MORPH_BLOCK_TIME from frostfs_testlib.resources.error_patterns import OBJECT_NOT_FOUND from frostfs_testlib.resources.wellknown_acl import PUBLIC_ACL from frostfs_testlib.steps.cli.container import create_container, search_nodes_with_container from frostfs_testlib.steps.cli.object import ( delete_object, get_object, get_object_from_random_node, head_object, put_object, put_object_to_random_node, search_object, ) from frostfs_testlib.steps.node_management import ( check_node_in_map, delete_node_data, drop_object, exclude_node_from_network_map, get_locode_from_random_node, include_node_to_network_map, node_shard_list, node_shard_set_mode, storage_node_set_status, wait_for_node_to_be_ready, ) from frostfs_testlib.steps.storage_policy import get_nodes_with_object from frostfs_testlib.storage.cluster import ClusterNode, StorageNode from frostfs_testlib.storage.controllers import ClusterStateController from frostfs_testlib.storage.dataclasses.object_size import ObjectSize from frostfs_testlib.storage.dataclasses.storage_object_info import ModeNode from frostfs_testlib.testing.cluster_test_base import ClusterTestBase from frostfs_testlib.utils import datetime_utils, string_utils from frostfs_testlib.utils.failover_utils import wait_object_replication from frostfs_testlib.utils.file_utils import generate_file from pytest_tests.helpers.utility import wait_for_gc_pass_on_storage_nodes logger = logging.getLogger("NeoLogger") check_nodes: list[StorageNode] = [] @allure.title("Add one node to cluster") @pytest.mark.add_nodes @pytest.mark.node_mgmt class TestNodeManagement(ClusterTestBase): @pytest.fixture @allure.title("Create container and pick the node with data") def create_container_and_pick_node( self, default_wallet: str, simple_object_size: ObjectSize ) -> Tuple[str, StorageNode]: file_path = generate_file(simple_object_size.value) placement_rule = "REP 1 IN X CBF 1 SELECT 1 FROM * AS X" endpoint = self.cluster.default_rpc_endpoint cid = create_container( default_wallet, shell=self.shell, endpoint=endpoint, rule=placement_rule, basic_acl=PUBLIC_ACL, ) oid = put_object_to_random_node(default_wallet, file_path, cid, self.shell, self.cluster) nodes = get_nodes_with_object(cid, oid, shell=self.shell, nodes=self.cluster.storage_nodes) assert len(nodes) == 1 node = nodes[0] yield cid, node shards = node_shard_list(node) assert shards for shard in shards: node_shard_set_mode(node, shard, "read-write") node_shard_list(node) @allure.step("Tick epoch with retries") def tick_epoch_with_retries(self, attempts: int = 3, timeout: int = 3, wait_block: int = None): for attempt in range(attempts): try: self.tick_epoch(wait_block=wait_block) except RuntimeError: sleep(timeout) if attempt >= attempts - 1: raise continue return @pytest.fixture def after_run_start_all_nodes(self): yield self.return_nodes() @pytest.fixture def return_nodes_after_test_run(self): yield self.return_nodes() @allure.step("Return node to cluster") def return_nodes(self, alive_node: Optional[StorageNode] = None) -> None: for node in list(check_nodes): with allure.step(f"Start node {node}"): node.start_service() with allure.step(f"Waiting status ready for node {node}"): wait_for_node_to_be_ready(node) # We need to wait for node to establish notifications from morph-chain # Otherwise it will hang up when we will try to set status sleep(datetime_utils.parse_time(MORPH_BLOCK_TIME)) with allure.step(f"Move node {node} to online state"): storage_node_set_status(node, status="online", retries=2) check_nodes.remove(node) sleep(datetime_utils.parse_time(MORPH_BLOCK_TIME)) self.tick_epoch_with_retries(3, wait_block=2) check_node_in_map(node, shell=self.shell, alive_node=alive_node) @allure.title("Add one node to cluster") @pytest.mark.add_nodes def test_add_nodes( self, default_wallet: str, simple_object_size: ObjectSize, return_nodes_after_test_run, ): """ This test remove one node from frostfs_testlib.storage.cluster then add it back. Test uses base control operations with storage nodes (healthcheck, netmap-snapshot, set-status). """ wallet = default_wallet placement_rule_3 = "REP 3 IN X CBF 1 SELECT 3 FROM * AS X" placement_rule_4 = "REP 4 IN X CBF 1 SELECT 4 FROM * AS X" source_file_path = generate_file(simple_object_size.value) storage_nodes = self.cluster.storage_nodes random_node = random.choice(storage_nodes[1:]) alive_node = random.choice( [storage_node for storage_node in storage_nodes if storage_node.id != random_node.id] ) check_node_in_map(random_node, shell=self.shell, alive_node=alive_node) # Add node to recovery list before messing with it check_nodes.append(random_node) exclude_node_from_network_map(random_node, alive_node, shell=self.shell, cluster=self.cluster) delete_node_data(random_node) cid = create_container( wallet, rule=placement_rule_3, basic_acl=PUBLIC_ACL, shell=self.shell, endpoint=alive_node.get_rpc_endpoint(), ) oid = put_object( wallet, source_file_path, cid, shell=self.shell, endpoint=alive_node.get_rpc_endpoint(), ) wait_object_replication(cid, oid, 3, shell=self.shell, nodes=storage_nodes) self.return_nodes(alive_node) with allure.step("Check data could be replicated to new node"): random_node = random.choice(list(set(storage_nodes) - {random_node, alive_node})) # Add node to recovery list before messing with it check_nodes.append(random_node) exclude_node_from_network_map(random_node, alive_node, shell=self.shell, cluster=self.cluster) wait_object_replication( cid, oid, 3, shell=self.shell, nodes=list(set(storage_nodes) - {random_node}), ) include_node_to_network_map(random_node, alive_node, shell=self.shell, cluster=self.cluster) wait_object_replication(cid, oid, 3, shell=self.shell, nodes=storage_nodes) with allure.step("Check container could be created with new node"): cid = create_container( wallet, rule=placement_rule_4, basic_acl=PUBLIC_ACL, shell=self.shell, endpoint=alive_node.get_rpc_endpoint(), ) oid = put_object( wallet, source_file_path, cid, shell=self.shell, endpoint=alive_node.get_rpc_endpoint(), ) wait_object_replication(cid, oid, 4, shell=self.shell, nodes=storage_nodes) @pytest.mark.node_mgmt @allure.title("Drop object using control command") def test_drop_object(self, default_wallet, complex_object_size: ObjectSize, simple_object_size: ObjectSize): """ Test checks object could be dropped using `frostfs-cli control drop-objects` command. """ wallet = default_wallet endpoint = self.cluster.default_rpc_endpoint file_path_simple = generate_file(simple_object_size.value) file_path_complex = generate_file(complex_object_size.value) locode = get_locode_from_random_node(self.cluster) rule = f"REP 1 IN SE CBF 1 SELECT 1 FROM LOC AS SE FILTER 'UN-LOCODE' EQ '{locode}' AS LOC" cid = create_container(wallet, rule=rule, shell=self.shell, endpoint=endpoint) oid_simple = put_object_to_random_node(wallet, file_path_simple, cid, shell=self.shell, cluster=self.cluster) oid_complex = put_object_to_random_node(wallet, file_path_complex, cid, shell=self.shell, cluster=self.cluster) for oid in (oid_simple, oid_complex): get_object_from_random_node(wallet, cid, oid, shell=self.shell, cluster=self.cluster) head_object(wallet, cid, oid, shell=self.shell, endpoint=endpoint) nodes_with_object = get_nodes_with_object(cid, oid_simple, shell=self.shell, nodes=self.cluster.storage_nodes) random_node = random.choice(nodes_with_object) for oid in (oid_simple, oid_complex): with allure.step(f"Drop object {oid}"): get_object_from_random_node(wallet, cid, oid, shell=self.shell, cluster=self.cluster) head_object(wallet, cid, oid, shell=self.shell, endpoint=endpoint) drop_object(random_node, cid, oid) self.wait_for_obj_dropped(wallet, cid, oid, endpoint, get_object) self.wait_for_obj_dropped(wallet, cid, oid, endpoint, head_object) @pytest.mark.node_mgmt @pytest.mark.skip(reason="Need to clarify scenario") @allure.title("Control Operations with storage nodes") def test_shards( self, default_wallet, create_container_and_pick_node, simple_object_size: ObjectSize, ): wallet = default_wallet file_path = generate_file(simple_object_size.value) cid, node = create_container_and_pick_node original_oid = put_object_to_random_node(wallet, file_path, cid, self.shell, self.cluster) # for mode in ('read-only', 'degraded'): for mode in ("degraded",): shards = node_shard_list(node) assert shards for shard in shards: node_shard_set_mode(node, shard, mode) shards = node_shard_list(node) assert shards with pytest.raises(RuntimeError): put_object_to_random_node(wallet, file_path, cid, self.shell, self.cluster) with pytest.raises(RuntimeError): delete_object(wallet, cid, original_oid, self.shell, self.cluster.default_rpc_endpoint) get_object_from_random_node(wallet, cid, original_oid, self.shell, self.cluster) for shard in shards: node_shard_set_mode(node, shard, "read-write") shards = node_shard_list(node) assert shards oid = put_object_to_random_node(wallet, file_path, cid, self.shell, self.cluster) delete_object(wallet, cid, oid, self.shell, self.cluster.default_rpc_endpoint) @pytest.mark.node_mgmt @allure.title("Put object with stopped node") def test_stop_node(self, default_wallet, return_nodes_after_test_run, simple_object_size: ObjectSize): wallet = default_wallet placement_rule = "REP 3 IN X SELECT 4 FROM * AS X" source_file_path = generate_file(simple_object_size.value) storage_nodes = self.cluster.storage_nodes random_node = random.choice(storage_nodes[1:]) alive_node = random.choice( [storage_node for storage_node in storage_nodes if storage_node.id != random_node.id] ) cid = create_container( wallet, rule=placement_rule, basic_acl=PUBLIC_ACL, shell=self.shell, endpoint=random_node.get_rpc_endpoint(), ) with allure.step("Stop the random node"): check_nodes.append(random_node) random_node.stop_service() with allure.step("Try to put an object and expect success"): put_object( wallet, source_file_path, cid, shell=self.shell, endpoint=alive_node.get_rpc_endpoint(), ) self.return_nodes(alive_node) @allure.step("Wait for object to be dropped") def wait_for_obj_dropped(self, wallet: str, cid: str, oid: str, endpoint: str, checker) -> None: for _ in range(3): try: checker(wallet, cid, oid, shell=self.shell, endpoint=endpoint) wait_for_gc_pass_on_storage_nodes() except Exception as err: if string_utils.is_str_match_pattern(err, OBJECT_NOT_FOUND): return raise AssertionError(f'Expected "{OBJECT_NOT_FOUND}" error, got\n{err}') raise AssertionError(f"Object {oid} was not dropped from node") @pytest.mark.maintenance class TestMaintenanceMode(ClusterTestBase): change_node: ClusterNode = None @pytest.fixture() @allure.title("Init Frostfs CLI remote") def frostfs_cli_remote(self, node_under_test: ClusterNode) -> FrostfsCli: host = node_under_test.host service_config = host.get_service_config(node_under_test.storage_node.name) wallet_path = service_config.attributes["wallet_path"] wallet_password = service_config.attributes["wallet_password"] shell = host.get_shell() wallet_config_path = f"/tmp/{node_under_test.storage_node.name}-config.yaml" wallet_config = f'wallet: {wallet_path}\npassword: "{wallet_password}"' shell.exec(f"echo '{wallet_config}' > {wallet_config_path}") cli = FrostfsCli(shell=shell, frostfs_cli_exec_path=FROSTFS_CLI_EXEC, config_file=wallet_config_path) return cli @pytest.fixture() @allure.title("Init Frostfs CLI remote") def frostfs_cli(self) -> FrostfsCli: cli = FrostfsCli(shell=self.shell, frostfs_cli_exec_path=FROSTFS_CLI_EXEC, config_file=DEFAULT_WALLET_CONFIG) return cli @pytest.fixture() def restore_online_mode_node(self, cluster_state_controller: ClusterStateController, default_wallet: str): yield cluster_state_controller.set_mode_node(cluster_node=self.change_node, wallet=default_wallet, status="online") self.tick_epoch(wait_block=2) def basic_operations(self, wallet, cid, oid, shell, endpoint, matchs, object_size): file_path = generate_file(object_size) default_kw = {"wallet": wallet, "cid": cid, "shell": shell, "endpoint": endpoint} operations = { get_object: {"oid": oid}, search_object: {}, delete_object: {"oid": oid}, put_object: {"path": file_path}, } for index, operation, kw in enumerate(operations.items()): with allure.step(f"Run {operation.__name__} object, waiting response - {matchs[index]}"): default_kw.update(kw) if operation == search_object and "Found" in matchs[index]: operation(**default_kw) continue with pytest.raises(RuntimeError, match=matchs[index]): operation(**default_kw) os.remove(file_path) @allure.title("Test of basic node operations in maintenance mode") def test_maintenance_mode( self, default_wallet: str, simple_object_size: ObjectSize, cluster_state_controller: ClusterStateController, restore_online_mode_node: None, ): with allure.step("Create container and create\put object"): cid = create_container( wallet=default_wallet, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint, rule="REP 1 CBF 1", ) node = search_nodes_with_container( wallet=default_wallet, cid=cid, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint, cluster=self.cluster, ) self.change_node = node[0] file_path = generate_file(simple_object_size.value) oid = put_object( wallet=default_wallet, path=file_path, cid=cid, shell=self.shell, endpoint=self.change_node.storage_node.get_rpc_endpoint(), ) with allure.step("Enable MaintenanceModeAllowed:"): cluster_state_controller.set_mode_node( cluster_node=self.change_node, wallet=default_wallet, status="maintenance" ) other_nodes = list(set(self.cluster.cluster_nodes) - set(node)) node_and_match = { self.change_node: ["node is under maintenance"] * 4, other_nodes[0]: [ "object not found", "Found 0 objects", "object not found", "node is under maintenance", ], } with allure.step("Run basic operations"): for cluster_node, matchs in node_and_match.items(): self.basic_operations( wallet=default_wallet, cid=cid, oid=oid, shell=self.shell, endpoint=cluster_node.storage_node.get_rpc_endpoint(), matchs=matchs, object_size=simple_object_size.value, ) @pytest.mark.sanity @allure.title("MAINTENANCE and OFFLINE mode transitions") def test_mode_transitions( self, cluster_state_controller: ClusterStateController, node_under_test: ClusterNode, default_wallet: str, frostfs_cli: FrostfsCli, restore_online_mode_node: None, ): self.change_node = node_under_test cluster_nodes = list(set(self.cluster.cluster_nodes) - {node_under_test}) with allure.step("Tick epoch"): self.tick_epochs(epochs_to_tick=2, alive_node=cluster_nodes[0].storage_node, wait_block=2) with allure.step("Set node mode to offline"): cluster_state_controller.set_mode_node( cluster_node=node_under_test, wallet=default_wallet, status=ModeNode.OFFLINE.value, ) with allure.step("Tick epoch to update the network map"): self.tick_epochs(epochs_to_tick=2, alive_node=cluster_nodes[0].storage_node, wait_block=2) with ((allure.step("Check node mode = offline, after update the network map"))): netmap = frostfs_cli.netmap.snapshot( rpc_endpoint=cluster_nodes[0].storage_node.get_rpc_endpoint(), wallet=default_wallet ).stdout netmap = NetmapParser.snapshot_all_nodes(netmap) assert node_under_test.host_ip not in [ netmap_node.node for netmap_node in netmap ], f"Node {node_under_test.host_ip} not in state offline" with allure.step("Restart storage service"): cluster_state_controller.stop_storage_service(node_under_test) cluster_state_controller.start_storage_service(node_under_test) with allure.step("Tick epoch after restart storage service and set mode to offline"): self.tick_epochs(epochs_to_tick=2, alive_node=cluster_nodes[0].storage_node, wait_block=2) with (allure.step("Check node mode = online, after restart storage service")): netmap = frostfs_cli.netmap.snapshot( rpc_endpoint=cluster_nodes[0].storage_node.get_rpc_endpoint(), wallet=default_wallet ).stdout node_state = NetmapParser.snapshot_one_node(netmap, node_under_test).node_status assert node_state == ModeNode.ONLINE.value.upper(), ( f"Node actual state - {node_state}, " f"expect - {ModeNode.ONLINE.value}" ) with allure.step("Tick epoch"): self.tick_epochs(epochs_to_tick=2, alive_node=cluster_nodes[0].storage_node, wait_block=2) with allure.step("Set node mode to maintenance"): cluster_state_controller.set_mode_node( cluster_node=node_under_test, wallet=default_wallet, status=ModeNode.MAINTENANCE.value ) with allure.step("Restart storage service"): cluster_state_controller.stop_storage_service(node_under_test) cluster_state_controller.start_storage_service(node_under_test) with allure.step("Tick epoch after restart storage service"): self.tick_epochs(epochs_to_tick=2, alive_node=cluster_nodes[0].storage_node, wait_block=2) with allure.step("Check node mode = maintenance, after restart storage service and tick epoch"): netmap = frostfs_cli.netmap.snapshot( rpc_endpoint=cluster_nodes[0].storage_node.get_rpc_endpoint(), wallet=default_wallet ).stdout node_state = NetmapParser.snapshot_one_node(netmap, node_under_test).node_status assert node_state == ModeNode.MAINTENANCE.value.upper(), ( f"Node actual state - {node_state}, " f"expect - {ModeNode.MAINTENANCE.value}" ) with allure.step("Tick epoch"): self.tick_epochs(epochs_to_tick=2, alive_node=cluster_nodes[0].storage_node, wait_block=2) with allure.step("Set node mode to offline"): netmap = frostfs_cli.netmap.snapshot( rpc_endpoint=cluster_nodes[0].storage_node.get_rpc_endpoint(), wallet=default_wallet ).stdout node_state = NetmapParser.snapshot_one_node(netmap, node_under_test).node_status assert node_state == ModeNode.OFFLINE.value.upper(), ( f"Node actual state - {node_state}, " f"expect - {ModeNode.OFFLINE.value}" ) with allure.step("Stop storage service"): cluster_state_controller.stop_storage_service(node_under_test) with allure.step("Tick epoch"): self.tick_epochs(epochs_to_tick=2, alive_node=cluster_nodes[0].storage_node, wait_block=2) with allure.step("Start storage service"): cluster_state_controller.start_storage_service(node_under_test) with allure.step("Check node mode = offline, after tick epoch and start storage service"): netmap = frostfs_cli.netmap.snapshot( rpc_endpoint=cluster_nodes[0].storage_node.get_rpc_endpoint(), wallet=default_wallet ).stdout node_state = NetmapParser.snapshot_one_node(netmap, node_under_test).node_status assert node_state == ModeNode.OFFLINE.value.upper(), ( f"Node actual state - {node_state}, " f"expect - {ModeNode.OFFLINE.value}" ) with allure.step("Tick epoch"): self.tick_epochs(epochs_to_tick=2, alive_node=cluster_nodes[0].storage_node, wait_block=2) with allure.step("Check node mode = online, after start storage service and tick epoch"): netmap = frostfs_cli.netmap.snapshot( rpc_endpoint=cluster_nodes[0].storage_node.get_rpc_endpoint(), wallet=default_wallet ).stdout node_state = NetmapParser.snapshot_one_node(netmap, node_under_test).node_status assert node_state == ModeNode.ONLINE.value.upper(), ( f"Node actual state - {node_state}, " f"expect - {ModeNode.ONLINE.value}" ) with allure.step("Tick epoch"): self.tick_epochs(epochs_to_tick=2, alive_node=cluster_nodes[0].storage_node, wait_block=2) with allure.step("Set node mode to maintenance"): cluster_state_controller.set_mode_node( cluster_node=node_under_test, wallet=default_wallet, status=ModeNode.MAINTENANCE.value ) with allure.step("Stop storage service"): cluster_state_controller.stop_storage_service(node_under_test) with allure.step("Tick epoch"): self.tick_epochs(epochs_to_tick=2, alive_node=cluster_nodes[0].storage_node, wait_block=2) with allure.step("Start storage service"): cluster_state_controller.start_storage_service(node_under_test) with allure.step("Check node mode = maintenance"): netmap = frostfs_cli.netmap.snapshot( rpc_endpoint=cluster_nodes[0].storage_node.get_rpc_endpoint(), wallet=default_wallet ).stdout node_state = NetmapParser.snapshot_one_node(netmap, node_under_test).node_status assert ( node_state == ModeNode.MAINTENANCE.value.upper() ), f"Node actual state - {node_state}, expect - {ModeNode.MAINTENANCE.value}" with allure.step("Tick epoch"): self.tick_epochs(epochs_to_tick=2, alive_node=cluster_nodes[0].storage_node, wait_block=2) with allure.step("Check node mode = maintenance"): netmap = frostfs_cli.netmap.snapshot( rpc_endpoint=cluster_nodes[0].storage_node.get_rpc_endpoint(), wallet=default_wallet ).stdout node_state = NetmapParser.snapshot_one_node(netmap, node_under_test).node_status assert node_state == ModeNode.MAINTENANCE.value.upper(), ( f"Node actual state - {node_state}, " f"expect - {ModeNode.MAINTENANCE.value}" ) @allure.title("A node cannot go into maintenance if maintenance is prohibited globally in the network") def test_maintenance_globally_forbidden( self, cluster_state_controller: ClusterStateController, node_under_test: ClusterNode, frostfs_cli_remote: FrostfsCli, frostfs_cli: FrostfsCli, default_wallet: str, restore_online_mode_node: None, ): self.change_node = node_under_test control_endpoint = node_under_test.service(StorageNode).get_control_endpoint() with allure.step("Set MaintenanceModeAllowed = false"): cluster_state_controller.set_maintenance_mode_allowed("false", node_under_test) with allure.step("Set status node - maintenance"): with pytest.raises(RuntimeError, match="maintenance mode is not allowed by the network"): frostfs_cli_remote.control.set_status(endpoint=control_endpoint, status="maintenance") with allure.step("Set MaintenanceModeAllowed = true"): cluster_state_controller.set_maintenance_mode_allowed("true", node_under_test) with allure.step("Set status node - maintenance"): output = frostfs_cli_remote.control.set_status(endpoint=control_endpoint, status="maintenance") assert "update request successfully sent" in output.stdout, f"Response = {output}" with allure.step("Tick epoch"): self.tick_epoch(wait_block=2) with allure.step("Check state node = maintenance "): netmap_node = NetmapParser.snapshot_one_node( frostfs_cli.netmap.snapshot( rpc_endpoint=node_under_test.storage_node.get_rpc_endpoint(), wallet=default_wallet ).stdout, node_under_test, ) assert ( netmap_node.node_status == ModeNode.MAINTENANCE.value.upper() ), f"Node actual state - {netmap_node.node_status}, expect - {ModeNode.MAINTENANCE.value}" with allure.step("Set status node - online "): frostfs_cli_remote.control.set_status(endpoint=control_endpoint, status="online") with allure.step("Tick epoch"): self.tick_epoch() with allure.step("Check state node: online"): netmap_node = NetmapParser.snapshot_one_node( frostfs_cli.netmap.snapshot( rpc_endpoint=node_under_test.storage_node.get_rpc_endpoint(), wallet=default_wallet ).stdout, node_under_test, ) assert ( netmap_node.node_status == ModeNode.ONLINE.value.upper() ), f"Node actual state - {netmap_node.node_status}, expect - {ModeNode.ONLINE.value}"