forked from TrueCloudLab/frostfs-testlib
356 lines
11 KiB
Python
356 lines
11 KiB
Python
from typing import Optional
|
|
|
|
from frostfs_testlib.cli.cli_command import CliCommand
|
|
from frostfs_testlib.shell import CommandResult
|
|
|
|
|
|
class FrostfsAdmMorph(CliCommand):
|
|
def deposit_notary(
|
|
self,
|
|
rpc_endpoint: str,
|
|
account: str,
|
|
gas: str,
|
|
storage_wallet: Optional[str] = None,
|
|
till: Optional[str] = None,
|
|
) -> CommandResult:
|
|
"""Deposit GAS for notary service.
|
|
|
|
Args:
|
|
account: Wallet account address.
|
|
gas: Amount of GAS to deposit.
|
|
rpc_endpoint: N3 RPC node endpoint.
|
|
storage_wallet: Path to storage node wallet.
|
|
till: Notary deposit duration in blocks.
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
return self._execute(
|
|
"morph deposit-notary",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def dump_balances(
|
|
self,
|
|
rpc_endpoint: str,
|
|
alphabet: Optional[str] = None,
|
|
proxy: Optional[str] = None,
|
|
script_hash: Optional[str] = None,
|
|
storage: Optional[str] = None,
|
|
) -> CommandResult:
|
|
"""Dump GAS balances.
|
|
|
|
Args:
|
|
alphabet: Dump balances of alphabet contracts.
|
|
proxy: Dump balances of the proxy contract.
|
|
rpc_endpoint: N3 RPC node endpoint.
|
|
script_hash: Use script-hash format for addresses.
|
|
storage: Dump balances of storage nodes from the current netmap.
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
return self._execute(
|
|
"morph dump-balances",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def dump_config(self, rpc_endpoint: str) -> CommandResult:
|
|
"""Section for morph network configuration commands.
|
|
|
|
Args:
|
|
rpc_endpoint: N3 RPC node endpoint
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
return self._execute(
|
|
"morph dump-config",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def dump_containers(
|
|
self,
|
|
rpc_endpoint: str,
|
|
cid: Optional[str] = None,
|
|
container_contract: Optional[str] = None,
|
|
dump: str = "./testlib_dump_container",
|
|
) -> CommandResult:
|
|
"""Dump FrostFS containers to file.
|
|
|
|
Args:
|
|
cid: Containers to dump.
|
|
container_contract: Container contract hash (for networks without NNS).
|
|
dump: File where to save dumped containers (default: ./testlib_dump_container).
|
|
rpc_endpoint: N3 RPC node endpoint.
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
return self._execute(
|
|
"morph dump-containers",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def dump_hashes(self, rpc_endpoint: str) -> CommandResult:
|
|
"""Dump deployed contract hashes.
|
|
|
|
Args:
|
|
rpc_endpoint: N3 RPC node endpoint.
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
return self._execute(
|
|
"morph dump-hashes",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def force_new_epoch(
|
|
self, rpc_endpoint: Optional[str] = None, alphabet: Optional[str] = None
|
|
) -> CommandResult:
|
|
"""Create new FrostFS epoch event in the side chain.
|
|
|
|
Args:
|
|
alphabet: Path to alphabet wallets dir.
|
|
rpc_endpoint: N3 RPC node endpoint.
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
return self._execute(
|
|
"morph force-new-epoch",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def generate_alphabet(
|
|
self,
|
|
rpc_endpoint: str,
|
|
alphabet_wallets: str,
|
|
size: int = 7,
|
|
) -> CommandResult:
|
|
"""Generate alphabet wallets for consensus nodes of the morph network.
|
|
|
|
Args:
|
|
alphabet_wallets: Path to alphabet wallets dir.
|
|
size: Amount of alphabet wallets to generate (default 7).
|
|
rpc_endpoint: N3 RPC node endpoint.
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
return self._execute(
|
|
"morph generate-alphabet",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def generate_storage_wallet(
|
|
self,
|
|
rpc_endpoint: str,
|
|
alphabet_wallets: str,
|
|
storage_wallet: str,
|
|
initial_gas: Optional[str] = None,
|
|
) -> CommandResult:
|
|
"""Generate storage node wallet for the morph network.
|
|
|
|
Args:
|
|
alphabet_wallets: Path to alphabet wallets dir.
|
|
initial_gas: Initial amount of GAS to transfer.
|
|
rpc_endpoint: N3 RPC node endpoint.
|
|
storage_wallet: Path to new storage node wallet.
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
return self._execute(
|
|
"morph generate-storage-wallet",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def init(
|
|
self,
|
|
rpc_endpoint: str,
|
|
alphabet_wallets: str,
|
|
contracts: str,
|
|
protocol: str,
|
|
container_alias_fee: int = 500,
|
|
container_fee: int = 1000,
|
|
epoch_duration: int = 240,
|
|
homomorphic_disabled: bool = False,
|
|
local_dump: Optional[str] = None,
|
|
max_object_size: int = 67108864,
|
|
) -> CommandResult:
|
|
"""Section for morph network configuration commands.
|
|
|
|
Args:
|
|
alphabet_wallets: Path to alphabet wallets dir.
|
|
container_alias_fee: Container alias fee (default 500).
|
|
container_fee: Container registration fee (default 1000).
|
|
contracts: Path to archive with compiled FrostFS contracts
|
|
(default fetched from latest github release).
|
|
epoch_duration: Amount of side chain blocks in one FrostFS epoch (default 240).
|
|
homomorphic_disabled: Disable object homomorphic hashing.
|
|
local_dump: Path to the blocks dump file.
|
|
max_object_size: Max single object size in bytes (default 67108864).
|
|
protocol: Path to the consensus node configuration.
|
|
rpc_endpoint: N3 RPC node endpoint.
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
return self._execute(
|
|
"morph init",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def refill_gas(
|
|
self,
|
|
rpc_endpoint: str,
|
|
alphabet_wallets: str,
|
|
storage_wallet: str,
|
|
gas: Optional[str] = None,
|
|
) -> CommandResult:
|
|
"""Refill GAS of storage node's wallet in the morph network
|
|
|
|
Args:
|
|
alphabet_wallets: Path to alphabet wallets dir.
|
|
gas: Additional amount of GAS to transfer.
|
|
rpc_endpoint: N3 RPC node endpoint.
|
|
storage_wallet: Path to new storage node wallet.
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
return self._execute(
|
|
"morph refill-gas",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def restore_containers(
|
|
self,
|
|
rpc_endpoint: str,
|
|
alphabet_wallets: str,
|
|
cid: str,
|
|
dump: str,
|
|
) -> CommandResult:
|
|
"""Restore FrostFS containers from file.
|
|
|
|
Args:
|
|
alphabet_wallets: Path to alphabet wallets dir.
|
|
cid: Containers to restore.
|
|
dump: File to restore containers from.
|
|
rpc_endpoint: N3 RPC node endpoint.
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
return self._execute(
|
|
"morph restore-containers",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def set_policy(
|
|
self,
|
|
rpc_endpoint: str,
|
|
alphabet_wallets: str,
|
|
exec_fee_factor: Optional[int] = None,
|
|
storage_price: Optional[int] = None,
|
|
fee_per_byte: Optional[int] = None,
|
|
) -> CommandResult:
|
|
"""Set global policy values.
|
|
|
|
Args:
|
|
alphabet_wallets: Path to alphabet wallets dir.
|
|
exec_fee_factor: ExecFeeFactor=<n1>.
|
|
storage_price: StoragePrice=<n2>.
|
|
fee_per_byte: FeePerByte=<n3>.
|
|
rpc_endpoint: N3 RPC node endpoint.
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
non_param_attribute = ""
|
|
if exec_fee_factor:
|
|
non_param_attribute += f"ExecFeeFactor={exec_fee_factor} "
|
|
if storage_price:
|
|
non_param_attribute += f"StoragePrice={storage_price} "
|
|
if fee_per_byte:
|
|
non_param_attribute += f"FeePerByte={fee_per_byte} "
|
|
return self._execute(
|
|
f"morph restore-containers {non_param_attribute}",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self", "exec_fee_factor", "storage_price", "fee_per_byte"]
|
|
},
|
|
)
|
|
|
|
def update_contracts(
|
|
self,
|
|
rpc_endpoint: str,
|
|
alphabet_wallets: str,
|
|
contracts: Optional[str] = None,
|
|
) -> CommandResult:
|
|
"""Update FrostFS contracts.
|
|
|
|
Args:
|
|
alphabet_wallets: Path to alphabet wallets dir.
|
|
contracts: Path to archive with compiled FrostFS contracts
|
|
(default fetched from latest github release).
|
|
rpc_endpoint: N3 RPC node endpoint.
|
|
|
|
Returns:
|
|
Command's result.
|
|
"""
|
|
return self._execute(
|
|
"morph update-contracts",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|