async def get_maintenances(
client: AdminAPI, req: Optional[MaintenancesFilter] = None
) -> MaintenanceDefinitionResponse:
"""
Wrapper for getMaintenances() Thrift method
"""
return await client.getMaintenances(req or MaintenancesFilter())
async def test_smoke(self):
ni = 0
async with MockAdminAPI() as client:
nodes_config_resp = await client.getNodesConfig(
NodesFilter(node=NodeID(node_index=ni))
)
nodes_state_resp = await client.getNodesState(
NodesStateRequest(filter=NodesFilter(node=NodeID(node_index=ni)))
)
maintenances_resp = await client.getMaintenances(MaintenancesFilter())
nc = nodes_config_resp.nodes[0]
ns = nodes_state_resp.states[0]
mnt_ids = set()
for mnt in maintenances_resp.maintenances:
for s in mnt.shards:
if s.node.node_index == ni:
mnt_ids.add(mnt.group_id)
for n in mnt.sequencer_nodes:
if n.node_index == ni:
mnt_ids.add(mnt.group_id)
mnts = tuple(
sorted(
(
mnt
for mnt in maintenances_resp.maintenances
if mnt.group_id in mnt_ids
),
key=operator.attrgetter("group_id"),
)
)
nv = NodeView(node_config=nc, node_state=ns, maintenances=mnts)
self._validate(nv, nc, ns, mnts)
async def test_smoke(self):
async with MockAdminAPI() as client:
cv = await get_cluster_view(client)
await apply_maintenance(
client=client,
shards=[
ShardID(node=cv.get_node_view_by_node_index(0).node_id,
shard_index=1)
],
sequencer_nodes=[cv.get_node_view_by_node_index(0).node_id],
)
await apply_maintenance(
client=client,
node_ids=[cv.get_node_id(node_index=1)],
user="******",
reason="whatever",
)
(cv, nc_resp, ns_resp, mnts_resp) = await asyncio.gather(
get_cluster_view(client),
client.getNodesConfig(NodesFilter()),
client.getNodesState(NodesStateRequest()),
client.getMaintenances(MaintenancesFilter()),
)
self._validate(cv, nc_resp.nodes, ns_resp.states,
tuple(mnts_resp.maintenances))
async def get_maintenances(
client: AdminAPI,
group_ids: Optional[Collection[str]] = None,
user: Optional[str] = None,
) -> Collection[MaintenanceDefinition]:
"""
Queries AdminAPI for maintenances with specified filters.
Uses AND logic for different arguments.
"""
group_ids = group_ids or []
resp: MaintenanceDefinitionResponse = await admin_api.get_maintenances(
client=client,
req=MaintenancesFilter(group_ids=list(group_ids), user=user))
return resp.maintenances
async def test_smoke(self):
ni = 0
async with MockAdminAPI() as client:
cv = await get_cluster_view(client)
maintenances_resp = await apply_maintenance(
client=client,
shards=[
ShardID(
node=cv.get_node_view_by_node_index(0).node_id, shard_index=1
)
],
sequencer_nodes=[cv.get_node_view_by_node_index(0).node_id],
)
(
nodes_config_resp,
nodes_state_resp,
maintenances_resp,
) = await asyncio.gather(
client.getNodesConfig(NodesFilter(node=NodeID(node_index=ni))),
client.getNodesState(
NodesStateRequest(filter=NodesFilter(node=NodeID(node_index=ni)))
),
client.getMaintenances(MaintenancesFilter()),
)
nc = [n for n in nodes_config_resp.nodes if n.node_index == ni][0]
ns = [n for n in nodes_state_resp.states if n.node_index == ni][0]
mnt_ids = set()
for mnt in maintenances_resp.maintenances:
for s in mnt.shards:
if s.node.node_index == ni:
mnt_ids.add(mnt.group_id)
for n in mnt.sequencer_nodes:
if n.node_index == ni:
mnt_ids.add(mnt.group_id)
mnts = tuple(
sorted(
(
mnt
for mnt in maintenances_resp.maintenances
if mnt.group_id in mnt_ids
),
key=operator.attrgetter("group_id"),
)
)
nv = NodeView(node_config=nc, node_state=ns, maintenances=mnts)
self._validate(nv, nc, ns, mnts)
async def smoke(self, client) -> None:
cv = await get_cluster_view(client)
storages_node_views = [
nv for nv in cv.get_all_node_views() if nv.is_storage
]
sequencers_node_views = [
nv for nv in cv.get_all_node_views() if nv.is_sequencer
]
# combined maintenance, storages and sequencers
await apply_maintenance(
client=client,
shards=[
ShardID(node=storages_node_views[0].node_id, shard_index=1)
],
sequencer_nodes=[sequencers_node_views[0].node_id],
)
# storage-only maintenance
await apply_maintenance(
client=client,
shards=[
ShardID(node=storages_node_views[1].node_id, shard_index=1)
],
)
# sequencer-only maintenance
await apply_maintenance(
client=client, sequencer_nodes=[sequencers_node_views[2].node_id])
# maintenance for whole nodes
await apply_maintenance(
client=client,
node_ids=[
storages_node_views[3].node_id,
sequencers_node_views[4].node_id
],
user="******",
reason="whatever",
)
(cv, nc_resp, ns_resp, mnts_resp) = await asyncio.gather(
get_cluster_view(client),
client.getNodesConfig(NodesFilter()),
client.getNodesState(NodesStateRequest()),
client.getMaintenances(MaintenancesFilter()),
)
self._validate(cv, nc_resp.nodes, ns_resp.states,
tuple(mnts_resp.maintenances))
async def remove_maintenances(
client: AdminAPI,
group_ids: Optional[Collection[str]] = None,
user: Optional[str] = None,
log_user: Optional[str] = "__ldops__",
log_reason: Optional[str] = "",
) -> Collection[MaintenanceDefinition]:
if group_ids is None:
group_ids = []
req = RemoveMaintenancesRequest(
filter=MaintenancesFilter(group_ids=list(set(group_ids)), user=user),
user=log_user,
reason=log_reason,
)
resp: RemoveMaintenancesResponse = await admin_api.remove_maintenances(
client=client, req=req)
return resp.maintenances
async def test_mismatch(self):
async with MockAdminAPI() as client:
(
nodes_config_resp,
nodes_state_resp,
maintenances_resp,
) = await asyncio.gather(
client.getNodesConfig(NodesFilter(node=NodeID(node_index=0))),
client.getNodesState(
NodesStateRequest(filter=NodesFilter(node=NodeID(node_index=1)))
),
client.getMaintenances(MaintenancesFilter()),
)
with self.assertRaises(ValueError):
NodeView(
node_config=nodes_config_resp.nodes[0],
node_state=nodes_state_resp.states[0],
maintenances=maintenances_resp.maintenances,
)
