forked from TrueCloudLab/frostfs-testcases
936 lines
45 KiB
Python
936 lines
45 KiB
Python
import json
|
|
from dataclasses import dataclass
|
|
import time
|
|
|
|
import allure
|
|
from frostfs_testlib.shell.interfaces import Shell
|
|
from frostfs_testlib.steps.node_management import check_node_in_map, include_node_to_network_map, remove_nodes_from_map_morph, storage_node_set_status
|
|
from frostfs_testlib.storage.grpc_operations.client_wrappers import CliClientWrapper
|
|
from frostfs_testlib.utils import datetime_utils
|
|
import pytest
|
|
import yaml
|
|
from frostfs_testlib import plugins, reporter
|
|
from frostfs_testlib.cli import FrostfsAdm, FrostfsCli
|
|
from frostfs_testlib.cli.netmap_parser import NetmapParser
|
|
from frostfs_testlib.credentials.interfaces import User
|
|
from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT, FROSTFS_ADM_CONFIG_PATH, FROSTFS_ADM_EXEC, FROSTFS_CLI_EXEC
|
|
from frostfs_testlib.resources.common import COMPLEX_OBJECT_CHUNKS_COUNT, COMPLEX_OBJECT_TAIL_SIZE, HOSTING_CONFIG_FILE, MORPH_BLOCK_TIME
|
|
from frostfs_testlib.s3 import AwsCliClient, S3ClientWrapper
|
|
from frostfs_testlib.s3.interfaces import BucketContainerResolver, VersioningStatus
|
|
from frostfs_testlib.steps.cli.object import get_object, put_object
|
|
from frostfs_testlib.storage.cluster import Cluster, ClusterNode, StorageNode
|
|
from frostfs_testlib.storage.controllers import ClusterStateController, ShardsWatcher
|
|
from frostfs_testlib.storage.controllers.state_managers.config_state_manager import ConfigStateManager
|
|
from frostfs_testlib.storage.dataclasses.object_size import ObjectSize
|
|
from frostfs_testlib.storage.dataclasses.storage_object_info import NodeNetmapInfo
|
|
from frostfs_testlib.testing.cluster_test_base import ClusterTestBase
|
|
from frostfs_testlib.testing.test_control import wait_for_success
|
|
from frostfs_testlib.utils.cli_utils import parse_netmap_output
|
|
from frostfs_testlib.utils.file_utils import generate_file, get_file_hash
|
|
|
|
|
|
def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
|
|
if "ec_policy" not in metafunc.fixturenames:
|
|
return
|
|
|
|
with open(HOSTING_CONFIG_FILE, "r") as file:
|
|
hosting_config = yaml.full_load(file)
|
|
|
|
node_count = len(hosting_config["hosts"])
|
|
|
|
ec_map = {
|
|
4: ["EC 1.1", "EC 2.1", "EC 3.1", "EC 2.2"],
|
|
8: ["EC 5.3", "EC 3.2", "EC 7.1", "EC 4.4", "EC 3.1"],
|
|
16: ["EC 12.4", "EC 8.4", "EC 5.3", "EC 4.4"],
|
|
100: ["EC 12.4", "EC 8.4", "EC 5.3", "EC 4.4"],
|
|
}
|
|
|
|
metafunc.parametrize("ec_policy, node_count", ((ec_policy, node_count) for ec_policy in ec_map[node_count]))
|
|
|
|
|
|
@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
|
|
|
|
|
|
@allure.title("Initialized remote FrostfsAdm")
|
|
@pytest.fixture
|
|
def frostfs_remote_adm(cluster: Cluster) -> FrostfsAdm:
|
|
node = cluster.cluster_nodes[0]
|
|
shell = node.host.get_shell()
|
|
return FrostfsAdm(shell, frostfs_adm_exec_path=FROSTFS_ADM_EXEC, config_file=FROSTFS_ADM_CONFIG_PATH)
|
|
|
|
|
|
@pytest.mark.replication
|
|
@pytest.mark.ec_replication
|
|
class TestECReplication(ClusterTestBase):
|
|
def get_node_cli(self, cluster_node: ClusterNode, config: str) -> FrostfsCli:
|
|
shell = cluster_node.host.get_shell()
|
|
cli = FrostfsCli(shell, frostfs_cli_exec_path=FROSTFS_CLI_EXEC, config_file=config)
|
|
self.cli_change_shards_mode: dict[FrostfsCli, str] = {cli: cluster_node.storage_node.get_control_endpoint()}
|
|
return cli
|
|
|
|
@pytest.fixture()
|
|
def restore_nodes_shards_mode(self):
|
|
yield
|
|
|
|
for cli, endpoint in self.cli_change_shards_mode.items():
|
|
cli.shards.set_mode(endpoint, mode='read-write', all=True)
|
|
|
|
time.sleep(datetime_utils.parse_time(MORPH_BLOCK_TIME))
|
|
|
|
@pytest.fixture()
|
|
def rep_count(self, object_size: ObjectSize) -> int:
|
|
rep_count = 3
|
|
if object_size.name == "complex":
|
|
rep_count *= int(COMPLEX_OBJECT_CHUNKS_COUNT) + 1 if COMPLEX_OBJECT_TAIL_SIZE else int(COMPLEX_OBJECT_CHUNKS_COUNT)
|
|
return rep_count
|
|
|
|
@wait_for_success(120, 5)
|
|
def wait_replication(self, total_chunks: int, local_cli: FrostfsCli, cid: str, oid: str, success: bool = True) -> None:
|
|
if not success:
|
|
assert not self.check_replication(total_chunks, local_cli, cid, oid)
|
|
else:
|
|
assert self.check_replication(total_chunks, local_cli, cid, oid)
|
|
|
|
@allure.title("Search shard")
|
|
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
|
|
|
|
@allure.title("Restore chunk maximum params in network params ")
|
|
@pytest.fixture
|
|
def restore_network_config(self, frostfs_remote_adm: FrostfsAdm) -> None:
|
|
yield
|
|
frostfs_remote_adm.morph.set_config(set_key_value='"MaxECDataCount=12" "MaxECParityCount=5"')
|
|
|
|
@reporter.step("Get object nodes output ")
|
|
def get_object_nodes(self, cli: FrostfsCli, cid: str, oid: str, endpoint: str = None) -> dict:
|
|
if not endpoint:
|
|
endpoint = self.cluster.default_rpc_endpoint
|
|
object_nodes = json.loads(cli.object.nodes(endpoint, cid, oid=oid, json=True, timeout=CLI_DEFAULT_TIMEOUT).stdout)
|
|
if object_nodes.get("errors"):
|
|
raise object_nodes["errors"]
|
|
return object_nodes
|
|
|
|
@reporter.step("Get all chunks object ")
|
|
def get_all_chunks_object(self, cli: FrostfsCli, cid: str, oid: str, endpoint: str = None) -> list[Chunk]:
|
|
chunks = self.get_object_nodes(cli, cid, oid, endpoint)
|
|
return [Chunk(**chunk) for chunk in chunks["data_objects"]]
|
|
|
|
@reporter.step("Get parity chunk ")
|
|
def get_parity_chunk_object(self, cli: FrostfsCli, cid: str, oid: str, endpoint: str = None) -> Chunk:
|
|
chunks = self.get_object_nodes(cli, cid, oid, endpoint)["data_objects"]
|
|
return Chunk(**chunks[-1])
|
|
|
|
@reporter.step("Get data chunk ")
|
|
def get_data_chunk_object(self, cli: FrostfsCli, cid: str, oid: str, endpoint: str = None) -> Chunk:
|
|
chunks = self.get_object_nodes(cli, cid, oid, endpoint)["data_objects"]
|
|
return Chunk(**chunks[0])
|
|
|
|
@reporter.step("Search node without chunks ")
|
|
def search_node_not_chunks(self, chunks: list[Chunk], local_cli: FrostfsCli, endpoint: str = None) -> list[ClusterNode]:
|
|
if not endpoint:
|
|
self.cluster.default_rpc_endpoint
|
|
netmap = parse_netmap_output(local_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 self.cluster.cluster_nodes:
|
|
if node_info.node == cluster_node.host_ip:
|
|
result.append(cluster_node)
|
|
return result
|
|
|
|
@reporter.step("Create container, policy={policy}")
|
|
def create_container(self, user_cli: FrostfsCli, endpoint: str, policy: str) -> str:
|
|
return (
|
|
user_cli.container.create(endpoint, policy=policy, await_mode=True, timeout=CLI_DEFAULT_TIMEOUT)
|
|
.stdout.split(" ")[1]
|
|
.strip()
|
|
.split("\n")[0]
|
|
)
|
|
|
|
@reporter.step("Search node chunk {chunk}")
|
|
def get_chunk_node(self, frostfs_cli: FrostfsCli, chunk: Chunk) -> tuple[ClusterNode, NodeNetmapInfo]:
|
|
netmap = parse_netmap_output(frostfs_cli.netmap.snapshot(self.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 self.cluster.cluster_nodes:
|
|
if cluster_node.host_ip == node_info.node:
|
|
return (cluster_node, node_info)
|
|
|
|
@reporter.step("Check replication chunks={total_chunks} chunks ")
|
|
def check_replication(self, total_chunks: int, local_cli: FrostfsCli, cid: str, oid: str) -> bool:
|
|
object_nodes_info = local_cli.object.nodes(
|
|
self.cluster.default_rpc_endpoint, cid, oid=oid, json=True, timeout=CLI_DEFAULT_TIMEOUT
|
|
).stdout
|
|
object_nodes_info = json.loads(object_nodes_info)
|
|
return len(object_nodes_info["data_objects"]) == total_chunks
|
|
|
|
@allure.title("Disable Policer on all nodes")
|
|
@pytest.fixture()
|
|
def disable_policer(
|
|
self,
|
|
cluster_state_controller: ClusterStateController,
|
|
) -> None:
|
|
with reporter.step(f"Disable policer for nodes"):
|
|
cluster_state_controller.manager(ConfigStateManager).set_on_all_nodes(
|
|
service_type=StorageNode, values={"policer": {"unsafe_disable": True}}
|
|
)
|
|
yield
|
|
with reporter.step(f"Enable policer for nodes"):
|
|
cluster_state_controller.start_stopped_hosts()
|
|
cluster_state_controller.manager(ConfigStateManager).revert_all()
|
|
|
|
@wait_for_success(300, 15)
|
|
@reporter.step("Check count nodes chunks")
|
|
def wait_sync_count_chunks_nodes(self, grpc_client: CliClientWrapper, cid: str, oid: str, count: int):
|
|
all_chunks_after_include_node = grpc_client.object.chunks.get_all(self.cluster.default_rpc_endpoint, cid, oid)
|
|
chunks_nodes = [node for chunk in all_chunks_after_include_node for node in chunk.confirmed_nodes]
|
|
assert len(chunks_nodes) == count
|
|
|
|
@wait_for_success(300, 15)
|
|
def include_node_in_map(self, alive_storage_node: StorageNode, include_storage_node: StorageNode):
|
|
self.tick_epoch(alive_storage_node, 2)
|
|
check_node_in_map(include_storage_node, self.shell, alive_storage_node)
|
|
|
|
@allure.title("Create container with EC policy (size={object_size})")
|
|
def test_create_container_with_ec_policy(
|
|
self,
|
|
default_user: User,
|
|
frostfs_cli: FrostfsCli,
|
|
object_size: ObjectSize,
|
|
rep_count: int,
|
|
) -> None:
|
|
test_file = generate_file(object_size.value)
|
|
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
|
|
|
|
with reporter.step("Put object in container."):
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Check replication chunks."):
|
|
assert self.check_replication(rep_count, frostfs_cli, cid, oid)
|
|
|
|
@allure.title("Lose node with chunk data")
|
|
@pytest.mark.failover
|
|
def test_lose_node_with_data_chunk(
|
|
self,
|
|
frostfs_cli: FrostfsCli,
|
|
default_user: User,
|
|
simple_object_size: ObjectSize,
|
|
cluster_state_controller: ClusterStateController,
|
|
disable_policer: None,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 3.1")
|
|
|
|
with reporter.step("Put object in container."):
|
|
test_file = generate_file(simple_object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Check chunk replication on 4 nodes."):
|
|
assert self.check_replication(4, frostfs_cli, cid, oid)
|
|
|
|
with reporter.step("Search node data chunk"):
|
|
chunk = self.get_data_chunk_object(frostfs_cli, cid, oid)
|
|
chunk_node = self.get_chunk_node(frostfs_cli, chunk)[0]
|
|
|
|
with reporter.step("Stop node with data chunk."):
|
|
cluster_state_controller.stop_node_host(chunk_node, "hard")
|
|
|
|
with reporter.step("Get object"):
|
|
node = list(set(self.cluster.cluster_nodes) - {chunk_node})[0]
|
|
get_object(default_user.wallet, cid, oid, self.shell, node.storage_node.get_rpc_endpoint())
|
|
|
|
with reporter.step("Start stopped node, and check replication chunks."):
|
|
cluster_state_controller.start_node_host(chunk_node)
|
|
assert self.check_replication(4, frostfs_cli, cid, oid)
|
|
|
|
@allure.title("Lose node with chunk parity")
|
|
@pytest.mark.failover
|
|
def test_lose_node_with_parity_chunk(
|
|
self,
|
|
frostfs_cli: FrostfsCli,
|
|
default_user: User,
|
|
simple_object_size: ObjectSize,
|
|
cluster_state_controller: ClusterStateController,
|
|
disable_policer: None,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 3.1")
|
|
|
|
with reporter.step("Put object in container."):
|
|
test_file = generate_file(simple_object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Check chunk replication on 4 nodes."):
|
|
assert self.check_replication(4, frostfs_cli, cid, oid)
|
|
|
|
with reporter.step("Search node with parity chunk"):
|
|
chunk = self.get_parity_chunk_object(frostfs_cli, cid, oid)
|
|
chunk_node = self.get_chunk_node(frostfs_cli, chunk)[0]
|
|
|
|
with reporter.step("Stop node parity chunk."):
|
|
cluster_state_controller.stop_node_host(chunk_node, "hard")
|
|
|
|
with reporter.step("Get object, expect success."):
|
|
node = list(set(self.cluster.cluster_nodes) - {chunk_node})[0]
|
|
get_object(default_user.wallet, cid, oid, self.shell, node.storage_node.get_rpc_endpoint())
|
|
|
|
with reporter.step("Start stoped node, and check replication chunks."):
|
|
cluster_state_controller.start_node_host(chunk_node)
|
|
assert self.check_replication(4, frostfs_cli, cid, oid)
|
|
|
|
@allure.title("Lose nodes with chunk data and parity")
|
|
@pytest.mark.failover
|
|
def test_lose_nodes_data_chunk_and_parity(
|
|
self,
|
|
frostfs_cli: FrostfsCli,
|
|
default_user: User,
|
|
simple_object_size: ObjectSize,
|
|
cluster_state_controller: ClusterStateController,
|
|
disable_policer: None,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 3.1")
|
|
|
|
with reporter.step("Put object in container."):
|
|
test_file = generate_file(simple_object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Check count chunks, expect 4."):
|
|
assert self.check_replication(4, frostfs_cli, cid, oid)
|
|
|
|
with reporter.step("Search node data chunk and node parity chunk"):
|
|
data_chunk = self.get_data_chunk_object(frostfs_cli, cid, oid)
|
|
node_data_chunk = self.get_chunk_node(frostfs_cli, data_chunk)[0]
|
|
parity_chunk = self.get_parity_chunk_object(frostfs_cli, cid, oid)
|
|
node_parity_chunk = self.get_chunk_node(frostfs_cli, parity_chunk)[0]
|
|
|
|
with reporter.step("Stop node with data chunk."):
|
|
cluster_state_controller.stop_node_host(node_data_chunk, "hard")
|
|
|
|
with reporter.step("Get object"):
|
|
node = list(set(self.cluster.cluster_nodes) - {node_data_chunk, node_parity_chunk})[0]
|
|
get_object(default_user.wallet, cid, oid, self.shell, node.storage_node.get_rpc_endpoint())
|
|
|
|
with reporter.step("Start stopped host and check chunks."):
|
|
cluster_state_controller.start_node_host(node_data_chunk)
|
|
assert self.check_replication(4, frostfs_cli, cid, oid)
|
|
|
|
with reporter.step("Stop node with parity chunk and one all node."):
|
|
cluster_state_controller.stop_node_host(node_data_chunk, "hard")
|
|
cluster_state_controller.stop_node_host(node_parity_chunk, "hard")
|
|
|
|
with reporter.step("Get object, expect error."):
|
|
with pytest.raises(RuntimeError):
|
|
get_object(default_user.wallet, cid, oid, self.shell, node.storage_node.get_rpc_endpoint())
|
|
|
|
with reporter.step("Start stopped nodes and check replication chunk."):
|
|
cluster_state_controller.start_stopped_hosts()
|
|
assert self.check_replication(4, frostfs_cli, cid, oid)
|
|
|
|
@allure.title("Policer work with chunk")
|
|
@pytest.mark.failover
|
|
def test_work_policer_with_nodes(
|
|
self,
|
|
simple_object_size: ObjectSize,
|
|
frostfs_cli: FrostfsCli,
|
|
grpc_client: CliClientWrapper,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = grpc_client.container.create(self.cluster.default_rpc_endpoint, policy="EC 2.1", await_mode=True)
|
|
|
|
with reporter.step("Put object on container."):
|
|
test_file = generate_file(simple_object_size.value)
|
|
oid = grpc_client.object.put(test_file, cid, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Check count chunks nodes on 3."):
|
|
assert self.check_replication(3, frostfs_cli, cid, oid)
|
|
|
|
with reporter.step("Search node with chunk."):
|
|
data_chunk = grpc_client.object.chunks.get_first_data(self.cluster.default_rpc_endpoint, cid, oid=oid)
|
|
node_data_chunk = grpc_client.object.chunks.get_chunk_node(self.cluster, data_chunk)[0]
|
|
first_all_chunks = grpc_client.object.chunks.get_all(self.cluster.default_rpc_endpoint, cid, oid)
|
|
|
|
with reporter.step("Remove chunk node from network map"):
|
|
remove_nodes_from_map_morph(
|
|
shell=self.shell, cluster=self.cluster, remove_nodes=[node_data_chunk.storage_node]
|
|
)
|
|
|
|
with reporter.step("Tick epoch."):
|
|
alive_node = list(set(self.cluster.cluster_nodes) - {node_data_chunk})[0]
|
|
self.tick_epoch(alive_node.storage_node, 2)
|
|
|
|
with reporter.step("Wait replication chunk with different node."):
|
|
node = grpc_client.object.chunks.search_node_without_chunks(first_all_chunks, self.cluster, alive_node.storage_node.get_rpc_endpoint())[0]
|
|
self.wait_replication(3, frostfs_cli, cid, oid)
|
|
|
|
with reporter.step("Get new chunks"):
|
|
second_all_chunks = grpc_client.object.chunks.get_all(node.storage_node.get_rpc_endpoint(), cid, oid)
|
|
|
|
with reporter.step("Check that oid no change."):
|
|
assert [chunk for chunk in second_all_chunks if data_chunk.object_id == chunk.object_id]
|
|
|
|
with reporter.step("Include node in netmap"):
|
|
include_node_to_network_map(
|
|
node_to_include=node_data_chunk.storage_node,
|
|
alive_node=alive_node.storage_node,
|
|
shell=self.shell,
|
|
cluster=self.cluster)
|
|
|
|
self.wait_sync_count_chunks_nodes(grpc_client, cid, oid, 3)
|
|
|
|
@allure.title("EC X.Y combinations (nodes={node_count},policy={ec_policy},size={object_size})")
|
|
def test_create_container_with_difference_count_nodes(
|
|
self,
|
|
node_count: int,
|
|
ec_policy: str,
|
|
object_size: ObjectSize,
|
|
default_user: User,
|
|
frostfs_cli: FrostfsCli,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
expected_chunks = int(ec_policy.split(" ")[1].split(".")[0]) + int(ec_policy.split(" ")[1].split(".")[1])
|
|
if "complex" in object_size.name:
|
|
expected_chunks *= 4
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, ec_policy)
|
|
|
|
with reporter.step("Put object in container."):
|
|
test_file = generate_file(object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Check count object chunks."):
|
|
chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
assert len(chunks) == expected_chunks
|
|
|
|
with reporter.step("get object and check hash."):
|
|
file_with_node = get_object(default_user.wallet, cid, oid, self.shell, self.cluster.default_rpc_endpoint)
|
|
assert get_file_hash(test_file) == get_file_hash(file_with_node)
|
|
|
|
@allure.title("Request PUT with copies_number flag")
|
|
def test_put_object_with_copies_number(
|
|
self,
|
|
frostfs_cli: FrostfsCli,
|
|
default_user: User,
|
|
simple_object_size: ObjectSize,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
|
|
|
|
with reporter.step("Put object in container with copies number = 1"):
|
|
test_file = generate_file(simple_object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint, copies_number=1)
|
|
|
|
with reporter.step("Check that count chunks > 1."):
|
|
chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
assert len(chunks) > 1
|
|
|
|
@allure.title("Request PUT and 1 node off")
|
|
@pytest.mark.failover
|
|
def test_put_object_with_off_cnr_node(
|
|
self,
|
|
frostfs_cli: FrostfsCli,
|
|
cluster_state_controller: ClusterStateController,
|
|
default_user: User,
|
|
simple_object_size: ObjectSize,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 3.1")
|
|
|
|
with reporter.step("Stop one node in container nodes"):
|
|
cluster_state_controller.stop_node_host(self.cluster.cluster_nodes[1], "hard")
|
|
|
|
with reporter.step("Put object in container, expect success for EC container."):
|
|
test_file = generate_file(simple_object_size.value)
|
|
put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
@allure.title("Request PUT (size={object_size})")
|
|
def test_put_object_with_ec_cnr(
|
|
self,
|
|
frostfs_cli: FrostfsCli,
|
|
default_user: User,
|
|
object_size: ObjectSize,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
|
|
|
|
with reporter.step("Put object in container with --prepare-locally."):
|
|
test_file = generate_file(object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Get chunks object."):
|
|
chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Check header chunks object"):
|
|
for chunk in chunks:
|
|
chunk_head = frostfs_cli.object.head(self.cluster.default_rpc_endpoint, cid, chunk.object_id, raw=True).stdout
|
|
assert "EC header:" in chunk_head
|
|
|
|
@allure.title("Request PUT with copies number")
|
|
def test_put_object_with_copies_number(
|
|
self,
|
|
frostfs_cli: FrostfsCli,
|
|
default_user: User,
|
|
simple_object_size: ObjectSize,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
|
|
|
|
with reporter.step("Put object in container with --copies-number=1."):
|
|
test_file = generate_file(simple_object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint, copies_number=1)
|
|
|
|
with reporter.step("Check len chunks object."):
|
|
chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
assert len(chunks) > 1
|
|
|
|
@allure.title("Request GET (size={object_size})")
|
|
def test_get_object_in_ec_cnr(
|
|
self,
|
|
default_user: User,
|
|
frostfs_cli: FrostfsCli,
|
|
object_size: ObjectSize,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1 CBF 1")
|
|
|
|
with reporter.step("Put object in container"):
|
|
test_file = generate_file(object_size.value)
|
|
hash_origin_file = get_file_hash(test_file)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Get id all chunks."):
|
|
chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Search chunk node and not chunks node."):
|
|
chunk_node = self.get_chunk_node(frostfs_cli, chunks[0])
|
|
not_chunk_node = self.search_node_not_chunks(chunks, frostfs_cli, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("GET request with chunk node, expect success"):
|
|
file_one = get_object(default_user.wallet, cid, oid, self.shell, chunk_node[0].storage_node.get_rpc_endpoint())
|
|
hash_file_one = get_file_hash(file_one)
|
|
assert hash_file_one == hash_origin_file
|
|
|
|
with reporter.step("Get request with not chunk node"):
|
|
file_two = get_object(default_user.wallet, cid, oid, self.shell, not_chunk_node[0].storage_node.get_rpc_endpoint())
|
|
hash_file_two = get_file_hash(file_two)
|
|
assert hash_file_two == hash_file_one == hash_origin_file
|
|
|
|
@allure.title("Request SEARCH with flags 'root' (size={object_size})")
|
|
def test_search_object_in_ec_cnr_root_flags(
|
|
self,
|
|
default_user: User,
|
|
frostfs_cli: FrostfsCli,
|
|
object_size: ObjectSize,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
|
|
|
|
with reporter.step("Put object in container"):
|
|
test_file = generate_file(object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Search operation with --root flags"):
|
|
search_output = frostfs_cli.object.search(
|
|
self.cluster.default_rpc_endpoint, cid, root=True, timeout=CLI_DEFAULT_TIMEOUT
|
|
).stdout.split("\n")[1:]
|
|
assert search_output[0] == oid
|
|
|
|
@allure.title("Request SEARCH check valid chunk id (size={object_size})")
|
|
def test_search_object_in_ec_cnr_chunk_id(
|
|
self,
|
|
default_user: User,
|
|
frostfs_cli: FrostfsCli,
|
|
object_size: ObjectSize,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
|
|
|
|
with reporter.step("Put object in container"):
|
|
test_file = generate_file(object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Search operation object"):
|
|
search_output = frostfs_cli.object.search(self.cluster.default_rpc_endpoint, cid, timeout=CLI_DEFAULT_TIMEOUT).stdout
|
|
chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
for chunk in chunks:
|
|
assert chunk.object_id in search_output
|
|
|
|
@allure.title("Request SEARCH check no chunk index info (size={object_size})")
|
|
def test_search_object_in_ec_cnr(
|
|
self,
|
|
default_user: User,
|
|
frostfs_cli: FrostfsCli,
|
|
object_size: ObjectSize,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
|
|
|
|
with reporter.step("Put object in container"):
|
|
test_file = generate_file(object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Search operation all chunk"):
|
|
chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
for chunk in chunks:
|
|
chunk_search = frostfs_cli.object.search(
|
|
self.cluster.default_rpc_endpoint, cid, oid=chunk.object_id, timeout=CLI_DEFAULT_TIMEOUT
|
|
).stdout
|
|
assert "index" not in chunk_search
|
|
|
|
@allure.title("Request DELETE (size={object_size})")
|
|
@pytest.mark.failover
|
|
def test_delete_object_in_ec_cnr(
|
|
self,
|
|
default_user: User,
|
|
frostfs_cli: FrostfsCli,
|
|
object_size: ObjectSize,
|
|
cluster_state_controller: ClusterStateController,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
|
|
|
|
with reporter.step("Put object in container."):
|
|
test_file = generate_file(object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Check object chunks nodes."):
|
|
chunks_object = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
replication_count = 3 if object_size.name == "simple" else 3 * 4
|
|
assert len(chunks_object) == replication_count
|
|
|
|
with reporter.step("Delete object"):
|
|
frostfs_cli.object.delete(self.cluster.default_rpc_endpoint, cid, oid, timeout=CLI_DEFAULT_TIMEOUT)
|
|
|
|
with reporter.step("Check that delete all chunks."):
|
|
for chunk in chunks_object:
|
|
with pytest.raises(RuntimeError, match="object already removed"):
|
|
frostfs_cli.object.head(self.cluster.default_rpc_endpoint, cid, chunk.object_id, timeout=CLI_DEFAULT_TIMEOUT)
|
|
|
|
with reporter.step("Put second object."):
|
|
oid_second = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Check second object chunks nodes."):
|
|
chunks_second_object = self.get_all_chunks_object(frostfs_cli, cid, oid_second, self.cluster.default_rpc_endpoint)
|
|
assert len(chunks_second_object) == replication_count
|
|
|
|
with reporter.step("Stop nodes with chunk."):
|
|
chunk_node = self.get_chunk_node(frostfs_cli, chunks_second_object[0])
|
|
cluster_state_controller.stop_node_host(chunk_node[0], "hard")
|
|
|
|
with reporter.step("Delete second object"):
|
|
cluster_nodes = list(set(self.cluster.cluster_nodes) - {chunk_node[0]})
|
|
frostfs_cli.object.delete(cluster_nodes[0].storage_node.get_rpc_endpoint(), cid, oid_second, timeout=CLI_DEFAULT_TIMEOUT)
|
|
|
|
with reporter.step("Check that delete all chunk second object."):
|
|
for chunk in chunks_second_object:
|
|
with pytest.raises(RuntimeError, match="object already removed"):
|
|
frostfs_cli.object.head(self.cluster.default_rpc_endpoint, cid, chunk.object_id, timeout=CLI_DEFAULT_TIMEOUT)
|
|
|
|
@allure.title("Request LOCK (size={object_size})")
|
|
@pytest.mark.failover
|
|
def test_lock_object_in_ec_cnr(
|
|
self,
|
|
frostfs_cli: FrostfsCli,
|
|
object_size: ObjectSize,
|
|
default_user: User,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
|
|
|
|
with reporter.step("Put object in container."):
|
|
test_file = generate_file(object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Check object chunks nodes."):
|
|
chunks_object = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
replication_count = 3 if object_size.name == "simple" else 3 * 4
|
|
assert len(chunks_object) == replication_count
|
|
|
|
with reporter.step("Put LOCK in object."):
|
|
epoch = frostfs_cli.netmap.epoch(self.cluster.default_rpc_endpoint, timeout=CLI_DEFAULT_TIMEOUT).stdout.strip()
|
|
frostfs_cli.object.lock(
|
|
self.cluster.default_rpc_endpoint, cid, oid, timeout=CLI_DEFAULT_TIMEOUT, expire_at=(int(epoch) + 5)
|
|
).stdout
|
|
|
|
with reporter.step("Check don`t delete chunk"):
|
|
for chunk in chunks_object:
|
|
with pytest.raises(RuntimeError, match="Lock EC chunk failed"):
|
|
frostfs_cli.object.delete(self.cluster.default_rpc_endpoint, cid, chunk.object_id, timeout=CLI_DEFAULT_TIMEOUT)
|
|
|
|
with reporter.step("Check enable LOCK object"):
|
|
with pytest.raises(RuntimeError, match="object is locked"):
|
|
frostfs_cli.object.delete(self.cluster.default_rpc_endpoint, cid, oid, timeout=CLI_DEFAULT_TIMEOUT)
|
|
|
|
with reporter.step("Remove node in netmap."):
|
|
chunk_node = self.get_chunk_node(frostfs_cli, chunks_object[0])
|
|
alive_node = list(set(self.cluster.cluster_nodes) - {chunk_node[0]})[0]
|
|
remove_nodes_from_map_morph(self.shell, self.cluster, [chunk_node[0].storage_node], alive_node.storage_node)
|
|
|
|
with reporter.step("Check don`t delete chunk."):
|
|
for chunk in chunks_object:
|
|
with pytest.raises(RuntimeError, match="Lock EC chunk failed|object not found"):
|
|
frostfs_cli.object.delete(self.cluster.default_rpc_endpoint, cid, chunk.object_id, timeout=CLI_DEFAULT_TIMEOUT)
|
|
|
|
with reporter.step("Check enable LOCK object"):
|
|
with pytest.raises(RuntimeError, match="object is locked"):
|
|
frostfs_cli.object.delete(self.cluster.default_rpc_endpoint, cid, oid, timeout=CLI_DEFAULT_TIMEOUT)
|
|
|
|
with reporter.step("Include node in netmap"):
|
|
storage_node_set_status(chunk_node[0].storage_node, "online")
|
|
self.include_node_in_map(alive_node.storage_node, chunk_node[0].storage_node)
|
|
|
|
@allure.title("Output MaxEC* params in frostf-scli (type={type_shards})")
|
|
@pytest.mark.parametrize("type_shards", ["Maximum count of data shards", "Maximum count of parity shards"])
|
|
def test_maxec_info_with_output_cli(self, frostfs_cli: FrostfsCli, type_shards: str) -> None:
|
|
with reporter.step("Get and check params"):
|
|
net_info = frostfs_cli.netmap.netinfo(self.cluster.default_rpc_endpoint).stdout
|
|
assert type_shards in net_info
|
|
|
|
@allure.title("Change MaxEC*Count params")
|
|
def test_change_max_data_shards_params(
|
|
self,
|
|
frostfs_remote_adm: FrostfsAdm,
|
|
frostfs_cli: FrostfsCli,
|
|
restore_network_config: None,
|
|
) -> None:
|
|
with reporter.step("Get now params MaxECDataCount and MaxECParityCount"):
|
|
node_netinfo = NetmapParser.netinfo(
|
|
frostfs_cli.netmap.netinfo(self.cluster.default_rpc_endpoint, timeout=CLI_DEFAULT_TIMEOUT).stdout
|
|
)
|
|
|
|
with reporter.step("Change params"):
|
|
frostfs_remote_adm.morph.set_config(set_key_value='"MaxECDataCount=5" "MaxECParityCount=3"')
|
|
|
|
with reporter.step("Get update params"):
|
|
update_net_info = NetmapParser.netinfo(
|
|
frostfs_cli.netmap.netinfo(self.cluster.default_rpc_endpoint, timeout=CLI_DEFAULT_TIMEOUT).stdout
|
|
)
|
|
|
|
with reporter.step("Check old and new params difference"):
|
|
assert (
|
|
update_net_info.maximum_count_of_data_shards not in node_netinfo.maximum_count_of_data_shards
|
|
and update_net_info.maximum_count_of_parity_shards not in node_netinfo.maximum_count_of_parity_shards
|
|
)
|
|
|
|
@allure.title("Check maximum count data and parity shards")
|
|
def test_change_over_max_parity_shards_params(
|
|
self,
|
|
frostfs_remote_adm: FrostfsAdm,
|
|
) -> None:
|
|
with reporter.step("Change over maximum params shards count."):
|
|
with pytest.raises(RuntimeError, match="MaxECDataCount and MaxECParityCount must be <= 256"):
|
|
frostfs_remote_adm.morph.set_config(set_key_value='"MaxECDataCount=130" "MaxECParityCount=130"')
|
|
|
|
@allure.title("Create container with EC policy and SELECT (SELECT={select})")
|
|
@pytest.mark.parametrize("select", [2, 4])
|
|
def test_create_container_with_select(
|
|
self,
|
|
select: int,
|
|
frostfs_cli: FrostfsCli,
|
|
) -> None:
|
|
with reporter.step("Create container"):
|
|
policy = f"EC 1.1 CBF 1 SELECT {select} FROM *"
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, policy)
|
|
|
|
with reporter.step("Check container nodes decomposed"):
|
|
container_nodes = (
|
|
frostfs_cli.container.search_node(self.cluster.default_rpc_endpoint, cid, timeout=CLI_DEFAULT_TIMEOUT)
|
|
.stdout.strip()
|
|
.split("\n")[1:]
|
|
)
|
|
assert len(container_nodes) == select
|
|
|
|
@allure.title("Create container with EC policy and CBF (CBF={cbf})")
|
|
@pytest.mark.parametrize("cbf, expected_nodes", [(1, 2), (2, 4)])
|
|
def test_create_container_with_cbf(
|
|
self,
|
|
cbf: int,
|
|
expected_nodes: int,
|
|
frostfs_cli: FrostfsCli,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
policy = f"EC 1.1 CBF {cbf}"
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, policy)
|
|
|
|
with reporter.step("Check expected container nodes."):
|
|
container_nodes = (
|
|
frostfs_cli.container.search_node(self.cluster.default_rpc_endpoint, cid, timeout=CLI_DEFAULT_TIMEOUT)
|
|
.stdout.strip()
|
|
.split("\n")[1:]
|
|
)
|
|
assert len(container_nodes) == expected_nodes
|
|
|
|
@allure.title("Create container with EC policy and FILTER")
|
|
def test_create_container_with_filter(
|
|
self,
|
|
default_user: User,
|
|
frostfs_cli: FrostfsCli,
|
|
simple_object_size: ObjectSize,
|
|
) -> None:
|
|
with reporter.step("Create Container."):
|
|
policy = "EC 1.1 IN RUS SELECT 2 FROM RU AS RUS FILTER Country EQ Russia AS RU"
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, policy)
|
|
|
|
with reporter.step("Put object in container."):
|
|
test_file = generate_file(simple_object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Check object is decomposed exclusively on Russian nodes"):
|
|
data_chunk = self.get_data_chunk_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
parity_chunk = self.get_parity_chunk_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
node_data_chunk = self.get_chunk_node(frostfs_cli, data_chunk)
|
|
node_parity_chunk = self.get_chunk_node(frostfs_cli, parity_chunk)
|
|
for node in [node_data_chunk[1], node_parity_chunk[1]]:
|
|
assert "Russia" in node.country
|
|
|
|
@allure.title("Evacuation shard with chunk (type={type})")
|
|
@pytest.mark.parametrize("type, get_chunk", [("data", get_data_chunk_object), ("parity", get_parity_chunk_object)])
|
|
def test_evacuation_data_shard(
|
|
self,
|
|
restore_nodes_shards_mode: None,
|
|
default_user: User,
|
|
frostfs_cli: FrostfsCli,
|
|
max_object_size: int,
|
|
type: str,
|
|
get_chunk,
|
|
) -> None:
|
|
with reporter.step("Create container."):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 1.1 CBF 1")
|
|
|
|
with reporter.step("Put object in container."):
|
|
test_file = generate_file(max_object_size - 1000)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Get object chunks."):
|
|
chunk = get_chunk(self, frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
chunk_node = self.get_chunk_node(frostfs_cli, chunk)
|
|
frostfs_node_cli = self.get_node_cli(
|
|
chunk_node[0],
|
|
config=chunk_node[0].storage_node.get_remote_wallet_config_path(),
|
|
)
|
|
|
|
with reporter.step("Search shards chunk"):
|
|
shard_id = self.get_shard_chunk(chunk_node[0], chunk)
|
|
|
|
with reporter.step("Enable evacuation for shard"):
|
|
frostfs_node_cli.shards.set_mode(chunk_node[0].storage_node.get_control_endpoint(), mode="read-only", id=shard_id)
|
|
frostfs_node_cli.shards.evacuation_start(chunk_node[0].storage_node.get_control_endpoint(), shard_id, await_mode=True)
|
|
|
|
with reporter.step("Get object after evacuation shard"):
|
|
get_object(default_user.wallet, cid, oid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
@allure.title("[NEGATIVE] Don`t create more 1 EC policy")
|
|
def test_more_one_ec_policy(
|
|
self,
|
|
frostfs_cli: FrostfsCli,
|
|
) -> None:
|
|
with reporter.step("Create container with policy - 'EC 2.1 EC 1.1'"):
|
|
with pytest.raises(RuntimeError, match="can't parse placement policy"):
|
|
self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1 EC 1.1 CBF 1 SELECT 4 FROM *")
|
|
|
|
@allure.title("Create bucket with EC policy (s3_client={s3_client})")
|
|
@pytest.mark.parametrize("s3_policy, s3_client", [("pytest_tests/resources/files/policy.json", AwsCliClient)], indirect=True)
|
|
def test_create_bucket_with_ec_location(
|
|
self,
|
|
s3_client: S3ClientWrapper,
|
|
bucket_container_resolver: BucketContainerResolver,
|
|
frostfs_cli: FrostfsCli,
|
|
) -> None:
|
|
with reporter.step("Create bucket with EC location constrain"):
|
|
bucket = s3_client.create_bucket(location_constraint="ec3.1")
|
|
|
|
with reporter.step("Resolve container bucket"):
|
|
cid = bucket_container_resolver.resolve(self.cluster.cluster_nodes[0], bucket)
|
|
|
|
with reporter.step("Validate container policy"):
|
|
container = frostfs_cli.container.get(
|
|
self.cluster.default_rpc_endpoint, cid, json_mode=True, timeout=CLI_DEFAULT_TIMEOUT
|
|
).stdout
|
|
assert container
|
|
|
|
@allure.title("Bucket object count chunks (s3_client={s3_client}, size={object_size})")
|
|
@pytest.mark.parametrize("s3_policy, s3_client", [("pytest_tests/resources/files/policy.json", AwsCliClient)], indirect=True)
|
|
def test_count_chunks_bucket_with_ec_location(
|
|
self,
|
|
s3_client: S3ClientWrapper,
|
|
bucket_container_resolver: BucketContainerResolver,
|
|
frostfs_cli: FrostfsCli,
|
|
object_size: ObjectSize,
|
|
) -> None:
|
|
with reporter.step("Create bucket with EC location constrain"):
|
|
bucket = s3_client.create_bucket(location_constraint="ec3.1")
|
|
|
|
with reporter.step("Enable versioning object"):
|
|
s3_client.put_bucket_versioning(bucket, VersioningStatus.ENABLED)
|
|
bucket_status = s3_client.get_bucket_versioning_status(bucket)
|
|
assert bucket_status == VersioningStatus.ENABLED.value
|
|
|
|
with reporter.step("Put object in bucket"):
|
|
test_file = generate_file(object_size.value)
|
|
bucket_object = s3_client.put_object(bucket, test_file)
|
|
|
|
with reporter.step("Watch replication count chunks"):
|
|
cid = bucket_container_resolver.resolve(self.cluster.cluster_nodes[0], bucket)
|
|
chunks = self.get_all_chunks_object(frostfs_cli, cid, bucket_object, self.cluster.default_rpc_endpoint)
|
|
expect_chunks = 4 if object_size.name == "simple" else 16
|
|
assert len(chunks) == expect_chunks
|
|
|
|
@allure.title("Replication chunk after drop (size={object_size})")
|
|
def test_drop_chunk_and_replication(
|
|
self,
|
|
frostfs_cli: FrostfsCli,
|
|
default_user: User,
|
|
object_size: ObjectSize,
|
|
rep_count: int,
|
|
) -> None:
|
|
with reporter.step("Create container"):
|
|
cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1 CBF 1")
|
|
|
|
with reporter.step("Put object"):
|
|
test_file = generate_file(object_size.value)
|
|
oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Get all chunks"):
|
|
chunk = self.get_data_chunk_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
|
|
|
|
with reporter.step("Search chunk node"):
|
|
chunk_node = self.get_chunk_node(frostfs_cli, chunk)
|
|
shell_chunk_node = chunk_node[0].host.get_shell()
|
|
|
|
with reporter.step("Get replication count"):
|
|
assert self.check_replication(rep_count, frostfs_cli, cid, oid)
|
|
|
|
with reporter.step("Delete chunk"):
|
|
frostfs_node_cli = FrostfsCli(
|
|
shell_chunk_node,
|
|
frostfs_cli_exec_path=FROSTFS_CLI_EXEC,
|
|
config_file=chunk_node[0].storage_node.get_remote_wallet_config_path(),
|
|
)
|
|
frostfs_node_cli.control.drop_objects(chunk_node[0].storage_node.get_control_endpoint(), f"{cid}/{chunk.object_id}")
|
|
|
|
with reporter.step("Wait replication count after drop one chunk"):
|
|
self.wait_replication(rep_count, frostfs_cli, cid, oid)
|