def _validate(
self,
cv: ClusterView,
ncs: List[NodeConfig],
nss: List[NodeState],
mnts: Tuple[MaintenanceDefinition, ...],
):
nis = sorted(nc.node_index for nc in ncs)
ni_to_nc = {nc.node_index: nc for nc in ncs}
ni_to_ns = {ns.node_index: ns for ns in nss}
ni_to_mnts: Dict[int,
List[MaintenanceDefinition]] = {ni: []
for ni in nis}
for mnt in mnts:
mnt_nis = set()
for s in mnt.shards:
assert s.node.node_index is not None
mnt_nis.add(s.node.node_index)
for n in mnt.sequencer_nodes:
assert n.node_index is not None
mnt_nis.add(n.node_index)
for ni in mnt_nis:
ni_to_mnts[ni].append(mnt)
self.assertEqual(sorted(cv.get_all_node_indexes()),
sorted(ni_to_nc.keys()))
self.assertEqual(
sorted(cv.get_all_node_views(),
key=operator.attrgetter("node_index")),
sorted(
(NodeView(
node_config=ni_to_nc[ni],
node_state=ni_to_ns[ni],
maintenances=tuple(ni_to_mnts[ni]),
) for ni in ni_to_nc.keys()),
key=operator.attrgetter("node_index"),
),
)
self.assertEqual(sorted(cv.get_all_node_names()),
sorted(nc.name for nc in ncs))
self.assertEqual(sorted(cv.get_all_maintenance_ids()),
sorted(mnt.group_id for mnt in mnts))
self.assertEqual(
sorted(cv.get_all_maintenances(),
key=operator.attrgetter("group_id")),
sorted(mnts, key=operator.attrgetter("group_id")),
)
for ni in nis:
nn = ni_to_nc[ni].name
nc = ni_to_nc[ni]
ns = ni_to_ns[ni]
mnts = tuple(ni_to_mnts[ni])
nv = NodeView(node_config=ni_to_nc[ni],
node_state=ni_to_ns[ni],
maintenances=mnts)
self.assertEqual(cv.get_node_view_by_node_index(ni), nv)
self.assertEqual(cv.get_node_name_by_node_index(ni), nn)
self.assertEqual(cv.get_node_config_by_node_index(ni), nc)
self.assertEqual(cv.get_node_state_by_node_index(ni), ns)
self.assertEqual(cv.get_maintenances_by_node_index(ni), mnts)
self.assertEqual(cv.get_node_view_by_node_name(nn), nv)
self.assertEqual(cv.get_node_index_by_node_name(nn), ni)
self.assertEqual(cv.get_node_config_by_node_name(nn), nc)
self.assertEqual(cv.get_node_state_by_node_name(nn), ns)
self.assertEqual(cv.get_maintenances_by_node_name(nn), mnts)
self.assertEqual(cv.get_node_view(node_name=nn), nv)
self.assertEqual(cv.get_node_index(node_name=nn), ni)
self.assertEqual(cv.get_node_config(node_name=nn), nc)
self.assertEqual(cv.get_node_state(node_name=nn), ns)
self.assertEqual(cv.get_maintenances(node_name=nn), mnts)
self.assertEqual(cv.get_node_view(node_index=ni), nv)
self.assertEqual(cv.get_node_name(node_index=ni), nn)
self.assertEqual(cv.get_node_config(node_index=ni), nc)
self.assertEqual(cv.get_node_state(node_index=ni), ns)
self.assertEqual(cv.get_maintenances(node_index=ni), mnts)
with self.assertRaises(ValueError):
cv.get_node_view(None, None)
with self.assertRaises(ValueError):
cv.get_node_config(None, None)
with self.assertRaises(ValueError):
cv.get_node_state(None, None)
with self.assertRaises(ValueError):
cv.get_maintenances(None, None)
# mismatch node_index and node_name
if len(nis) > 1:
nn = ni_to_nc[nis[0]].name
ni = nis[1]
with self.assertRaises(ValueError):
cv.get_node_view(ni, nn)
with self.assertRaises(ValueError):
cv.get_node_config(ni, nn)
with self.assertRaises(ValueError):
cv.get_node_state(ni, nn)
with self.assertRaises(ValueError):
cv.get_maintenances(ni, nn)
# non-existent node_index
with self.assertRaises(KeyError):
cv.get_node_view(node_index=max(nis) + 1)
# non-existent node_name
with self.assertRaises(KeyError):
nns = {nc.name for nc in ncs}
while True:
nn = gen_word()
if nn not in nns:
break
cv.get_node_view(node_name=nn)
for mnt in mnts:
assert mnt.group_id is not None
self.assertEqual(cv.get_maintenance_by_id(mnt.group_id), mnt)
def _validate(
self,
cv: ClusterView,
ncs: List[NodeConfig],
nss: List[NodeState],
mnts: Tuple[MaintenanceDefinition, ...],
) -> None:
nis = sorted(nc.node_index for nc in ncs)
ni_to_nc = {nc.node_index: nc for nc in ncs}
ni_to_ns = {ns.node_index: ns for ns in nss}
ni_to_mnts: Dict[int,
List[MaintenanceDefinition]] = {ni: []
for ni in nis}
for mnt in mnts:
mnt_nis = set()
for s in mnt.shards:
assert s.node.node_index is not None
mnt_nis.add(s.node.node_index)
for n in mnt.sequencer_nodes:
assert n.node_index is not None
mnt_nis.add(n.node_index)
for ni in mnt_nis:
ni_to_mnts[ni].append(mnt)
self.assertEqual(sorted(cv.get_all_node_indexes()),
sorted(ni_to_nc.keys()))
self.assertEqual(
sorted(cv.get_all_node_views(),
key=operator.attrgetter("node_index")),
sorted(
(NodeView(
node_config=ni_to_nc[ni],
node_state=ni_to_ns[ni],
maintenances=tuple(ni_to_mnts[ni]),
) for ni in ni_to_nc.keys()),
key=operator.attrgetter("node_index"),
),
)
self.assertEqual(sorted(cv.get_all_node_names()),
sorted(nc.name for nc in ncs))
self.assertEqual(
sorted(cv.get_all_maintenance_ids()),
# pyre-fixme[6]: Expected `Iterable[Variable[_LT (bound to
# _SupportsLessThan)]]` for 1st param but got
# `Generator[typing.Optional[str], None, None]`.
sorted(mnt.group_id for mnt in mnts),
)
self.assertEqual(
sorted(cv.get_all_maintenances(),
key=operator.attrgetter("group_id")),
sorted(mnts, key=operator.attrgetter("group_id")),
)
for ni in nis:
nn = ni_to_nc[ni].name
nc = ni_to_nc[ni]
ns = ni_to_ns[ni]
node_mnts = tuple(ni_to_mnts[ni])
nv = NodeView(
node_config=ni_to_nc[ni],
node_state=ni_to_ns[ni],
maintenances=node_mnts,
)
self.assertEqual(cv.get_node_view_by_node_index(ni), nv)
self.assertEqual(cv.get_node_name_by_node_index(ni), nn)
self.assertEqual(cv.get_node_config_by_node_index(ni), nc)
self.assertEqual(cv.get_node_state_by_node_index(ni), ns)
self.assertEqual(cv.get_node_maintenances_by_node_index(ni),
node_mnts)
self.assertEqual(cv.get_node_view_by_node_name(nn), nv)
self.assertEqual(cv.get_node_index_by_node_name(nn), ni)
self.assertEqual(cv.get_node_config_by_node_name(nn), nc)
self.assertEqual(cv.get_node_state_by_node_name(nn), ns)
self.assertEqual(cv.get_node_maintenances_by_node_name(nn),
node_mnts)
self.assertEqual(cv.get_node_view(node_name=nn), nv)
self.assertEqual(cv.get_node_index(node_name=nn), ni)
self.assertEqual(cv.get_node_config(node_name=nn), nc)
self.assertEqual(cv.get_node_state(node_name=nn), ns)
self.assertEqual(cv.get_node_maintenances(node_name=nn), node_mnts)
self.assertEqual(cv.get_node_view(node_index=ni), nv)
self.assertEqual(cv.get_node_name(node_index=ni), nn)
self.assertEqual(cv.get_node_config(node_index=ni), nc)
self.assertEqual(cv.get_node_state(node_index=ni), ns)
self.assertEqual(cv.get_node_maintenances(node_index=ni),
node_mnts)
with self.assertRaises(ValueError):
cv.get_node_view(None, None)
with self.assertRaises(ValueError):
cv.get_node_config(None, None)
with self.assertRaises(ValueError):
cv.get_node_state(None, None)
with self.assertRaises(ValueError):
cv.get_node_maintenances(None, None)
# mismatch node_index and node_name
if len(nis) > 1:
nn = ni_to_nc[nis[0]].name
ni = nis[1]
with self.assertRaises(ValueError):
cv.get_node_view(ni, nn)
with self.assertRaises(ValueError):
cv.get_node_config(ni, nn)
with self.assertRaises(ValueError):
cv.get_node_state(ni, nn)
with self.assertRaises(ValueError):
cv.get_node_maintenances(ni, nn)
# non-existent node_index
with self.assertRaises(NodeNotFoundError):
cv.get_node_view(node_index=max(nis) + 1)
# non-existent node_name
with self.assertRaises(NodeNotFoundError):
nns = {nc.name for nc in ncs}
nn: str = ""
while True:
nn = gen_word()
if nn not in nns:
break
cv.get_node_view(node_name=nn)
for mnt in mnts:
group_id: str = mnt.group_id or ""
self.assertEqual(cv.get_maintenance_by_id(group_id), mnt)
self.assertTupleEqual(
cv.get_node_indexes_by_maintenance_id(group_id),
tuple(
sorted(
set({
n.node_index
for n in mnt.sequencer_nodes
if n.node_index is not None
}).union({
s.node.node_index
for s in mnt.shards
if s.node.node_index is not None
}))),
)
self.assertEqual(group_id,
cv.get_maintenance_view_by_id(group_id).group_id)
self.assertListEqual(
# pyre-fixme[6]: Expected `Iterable[Variable[_LT (bound to
# _SupportsLessThan)]]` for 1st param but got
# `Generator[typing.Optional[str], None, None]`.
sorted(m.group_id for m in mnts),
sorted(mv.group_id for mv in cv.get_all_maintenance_views()),
)
# expand_shards
self.assertEqual(
cv.expand_shards(shards=[
ShardID(node=NodeID(node_index=nis[0]), shard_index=0)
]),
(ShardID(
node=NodeID(
node_index=ni_to_nc[nis[0]].node_index,
name=ni_to_nc[nis[0]].name,
address=ni_to_nc[nis[0]].data_address,
),
shard_index=0,
), ),
)
num_shards: int = getattr(ni_to_nc[nis[0]], "storage",
StorageConfig()).num_shards
self.assertEqual(
len(
cv.expand_shards(shards=[
ShardID(node=NodeID(node_index=nis[0]),
shard_index=ALL_SHARDS)
])),
num_shards,
)
self.assertEqual(
len(
cv.expand_shards(shards=[
ShardID(node=NodeID(node_index=nis[0]),
shard_index=ALL_SHARDS),
ShardID(node=NodeID(node_index=nis[0]),
shard_index=ALL_SHARDS),
ShardID(node=NodeID(node_index=nis[1]),
shard_index=ALL_SHARDS),
])),
getattr(ni_to_nc[nis[0]], "storage", StorageConfig()).num_shards +
getattr(ni_to_nc[nis[1]], "storage", StorageConfig()).num_shards,
)
self.assertEqual(
len(
cv.expand_shards(
shards=[
ShardID(node=NodeID(node_index=nis[0]),
shard_index=ALL_SHARDS),
ShardID(node=NodeID(node_index=nis[1]), shard_index=0),
],
node_ids=[NodeID(node_index=0)],
)),
getattr(ni_to_nc[nis[0]], "storage", StorageConfig()).num_shards +
1,
)
# normalize_node_id
self.assertEqual(
cv.normalize_node_id(NodeID(node_index=nis[0])),
NodeID(
node_index=nis[0],
address=ni_to_nc[nis[0]].data_address,
name=ni_to_nc[nis[0]].name,
),
)
self.assertEqual(
cv.normalize_node_id(NodeID(name=ni_to_nc[nis[0]].name)),
NodeID(
node_index=nis[0],
address=ni_to_nc[nis[0]].data_address,
name=ni_to_nc[nis[0]].name,
),
)
# get_node_id
self.assertEqual(cv.get_node_id(node_index=0).node_index, 0)
# search_maintenances
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
]
self.assertEqual(len(cv.search_maintenances()), len(mnts))
self.assertEqual(len(cv.search_maintenances(node_ids=[])), 0)
self.assertEqual(
len(
cv.search_maintenances(sequencer_nodes=[
storages_node_views[3].node_id,
sequencers_node_views[4].node_id,
])),
1,
)
self.assertEqual(
len(
cv.search_maintenances(node_ids=[
storages_node_views[3].node_id,
sequencers_node_views[4].node_id,
])),
1,
)
self.assertEqual(
len(
cv.search_maintenances(shards=[
ShardID(node=storages_node_views[1].node_id, shard_index=1)
])),
1,
)
# shard_target_state
self.assertEqual(
len(
cv.search_maintenances(
shard_target_state=ShardOperationalState.MAY_DISAPPEAR)),
3,
)
self.assertEqual(
len(
cv.search_maintenances(
shard_target_state=ShardOperationalState.DRAINED)),
0,
)
# sequencer_target_state
self.assertEqual(
len(
cv.search_maintenances(
sequencer_target_state=SequencingState.ENABLED)),
0,
)
self.assertEqual(
len(
cv.search_maintenances(
sequencer_target_state=SequencingState.DISABLED)),
3,
)
self.assertEqual(len(cv.search_maintenances(user="******")), 1)
self.assertEqual(len(cv.search_maintenances(reason="whatever")), 1)
self.assertEqual(len(cv.search_maintenances(skip_safety_checks=True)),
0)
self.assertEqual(len(cv.search_maintenances(skip_safety_checks=False)),
4)
self.assertEqual(
len(cv.search_maintenances(force_restore_rebuilding=True)), 0)
self.assertEqual(
len(cv.search_maintenances(force_restore_rebuilding=False)), 4)
self.assertEqual(
len(cv.search_maintenances(allow_passive_drains=True)), 0)
self.assertEqual(
len(cv.search_maintenances(allow_passive_drains=False)), 4)
self.assertEqual(
len(cv.search_maintenances(group_id=mnts[0].group_id)), 1)
self.assertEqual(
len(
cv.search_maintenances(
progress=MaintenanceProgress.IN_PROGRESS)), 4)