forked from TrueCloudLab/frostfs-testlib
356 lines
12 KiB
Python
356 lines
12 KiB
Python
import json
|
|
import logging
|
|
import re
|
|
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.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
|
|
from frostfs_testlib.storage.dataclasses.storage_object_info import StorageObjectInfo
|
|
from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
|
|
from frostfs_testlib.utils import json_utils
|
|
from frostfs_testlib.utils.file_utils import generate_file, get_file_hash
|
|
|
|
logger = logging.getLogger("NeoLogger")
|
|
|
|
|
|
@dataclass
|
|
class StorageContainerInfo:
|
|
id: str
|
|
wallet: WalletInfo
|
|
|
|
|
|
class StorageContainer:
|
|
def __init__(
|
|
self,
|
|
storage_container_info: StorageContainerInfo,
|
|
shell: Shell,
|
|
cluster: Cluster,
|
|
) -> None:
|
|
self.shell = shell
|
|
self.storage_container_info = storage_container_info
|
|
self.cluster = cluster
|
|
|
|
def get_id(self) -> str:
|
|
return self.storage_container_info.id
|
|
|
|
def get_wallet(self) -> str:
|
|
return self.storage_container_info.wallet
|
|
|
|
@reporter.step("Generate new object and put in container")
|
|
def generate_object(
|
|
self,
|
|
size: int,
|
|
expire_at: Optional[int] = None,
|
|
bearer_token: Optional[str] = None,
|
|
endpoint: Optional[str] = None,
|
|
) -> StorageObjectInfo:
|
|
with reporter.step(f"Generate object with size {size}"):
|
|
file_path = generate_file(size)
|
|
file_hash = get_file_hash(file_path)
|
|
|
|
container_id = self.get_id()
|
|
wallet = self.get_wallet()
|
|
with reporter.step(f"Put object with size {size} to container {container_id}"):
|
|
if endpoint:
|
|
object_id = put_object(
|
|
wallet=wallet,
|
|
path=file_path,
|
|
cid=container_id,
|
|
expire_at=expire_at,
|
|
shell=self.shell,
|
|
endpoint=endpoint,
|
|
bearer=bearer_token,
|
|
)
|
|
else:
|
|
object_id = put_object_to_random_node(
|
|
wallet=wallet,
|
|
path=file_path,
|
|
cid=container_id,
|
|
expire_at=expire_at,
|
|
shell=self.shell,
|
|
cluster=self.cluster,
|
|
bearer=bearer_token,
|
|
)
|
|
|
|
storage_object = StorageObjectInfo(
|
|
container_id,
|
|
object_id,
|
|
size=size,
|
|
wallet=wallet,
|
|
file_path=file_path,
|
|
file_hash=file_hash,
|
|
)
|
|
|
|
return storage_object
|
|
|
|
|
|
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,
|
|
shell: Shell,
|
|
endpoint: str,
|
|
rule: str = DEFAULT_PLACEMENT_RULE,
|
|
basic_acl: str = "",
|
|
attributes: Optional[dict] = None,
|
|
session_token: str = "",
|
|
name: Optional[str] = None,
|
|
options: Optional[dict] = None,
|
|
await_mode: bool = True,
|
|
wait_for_creation: bool = True,
|
|
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
|
|
"""
|
|
|
|
cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
|
|
result = cli.container.create(
|
|
rpc_endpoint=endpoint,
|
|
policy=rule,
|
|
basic_acl=basic_acl,
|
|
attributes=attributes,
|
|
name=name,
|
|
session=session_token,
|
|
await_mode=await_mode,
|
|
timeout=timeout,
|
|
**options or {},
|
|
)
|
|
|
|
cid = _parse_cid(result.stdout)
|
|
|
|
logger.info("Container created; waiting until it is persisted in the sidechain")
|
|
|
|
if wait_for_creation:
|
|
wait_for_container_creation(wallet, cid, shell, endpoint)
|
|
|
|
return cid
|
|
|
|
|
|
def wait_for_container_creation(wallet: WalletInfo, 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:
|
|
return
|
|
logger.info(f"There is no {cid} in {containers} yet; sleep {sleep_interval} and continue")
|
|
sleep(sleep_interval)
|
|
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):
|
|
for _ in range(attempts):
|
|
try:
|
|
get_container(wallet, cid, shell=shell, endpoint=endpoint)
|
|
sleep(sleep_interval)
|
|
continue
|
|
except Exception as err:
|
|
if "container not found" not in str(err):
|
|
raise AssertionError(f'Expected "container not found" in error, got\n{err}')
|
|
return
|
|
raise AssertionError(f"Expected container deleted during {attempts * sleep_interval} sec.")
|
|
|
|
|
|
@reporter.step("List Containers")
|
|
def list_containers(wallet: WalletInfo, 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
|
|
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)
|
|
result = cli.container.list(rpc_endpoint=endpoint, timeout=timeout)
|
|
return result.stdout.split()
|
|
|
|
|
|
@reporter.step("List Objects in container")
|
|
def list_objects(
|
|
wallet: WalletInfo,
|
|
shell: Shell,
|
|
container_id: str,
|
|
endpoint: str,
|
|
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:
|
|
wallet (WalletInfo): 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
|
|
timeout: Timeout for the operation.
|
|
Returns:
|
|
(list): list of containers
|
|
"""
|
|
cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
|
|
result = cli.container.list_objects(rpc_endpoint=endpoint, 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,
|
|
cid: str,
|
|
shell: Shell,
|
|
endpoint: str,
|
|
json_mode: bool = True,
|
|
timeout: Optional[str] = CLI_DEFAULT_TIMEOUT,
|
|
) -> Union[dict, str]:
|
|
"""
|
|
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
|
|
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
|
|
json_mode (bool): return container in JSON format
|
|
timeout: Timeout for the operation.
|
|
Returns:
|
|
(dict, str): dict of container attributes
|
|
"""
|
|
|
|
cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
|
|
result = cli.container.get(rpc_endpoint=endpoint, cid=cid, json_mode=json_mode, timeout=timeout)
|
|
|
|
if not json_mode:
|
|
return result.stdout
|
|
|
|
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("Delete Container")
|
|
# TODO: make the error message about a non-found container more user-friendly
|
|
def delete_container(
|
|
wallet: WalletInfo,
|
|
cid: str,
|
|
shell: Shell,
|
|
endpoint: str,
|
|
force: bool = False,
|
|
session_token: Optional[str] = None,
|
|
await_mode: bool = False,
|
|
) -> None:
|
|
"""
|
|
A wrapper for `frostfs-cli container delete` call.
|
|
Args:
|
|
await_mode: Block execution until container is removed.
|
|
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
|
|
This function doesn't return anything.
|
|
"""
|
|
|
|
cli = FrostfsCli(shell, FROSTFS_CLI_EXEC, wallet.config_path)
|
|
cli.container.delete(
|
|
cid=cid,
|
|
rpc_endpoint=endpoint,
|
|
force=force,
|
|
session=session_token,
|
|
await_mode=await_mode,
|
|
)
|
|
|
|
|
|
def _parse_cid(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]
|
|
|
|
|
|
@reporter.step("Search container by name")
|
|
def search_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)
|
|
|
|
|
|
@reporter.step("Search for nodes with a container")
|
|
def search_nodes_with_container(
|
|
wallet: WalletInfo,
|
|
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)
|
|
result = cli.container.search_node(rpc_endpoint=endpoint, cid=cid, timeout=timeout)
|
|
|
|
pattern = r"[0-9]+(?:\.[0-9]+){3}"
|
|
nodes_ip = list(set(re.findall(pattern, result.stdout)))
|
|
|
|
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
|