def test_init(self):
# Smoke INET
SocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv6Address(self.ip6_addr),
port=self.port,
)
# Smoke UNIX
SocketAddress(address_family=SocketAddressFamily.UNIX,
path=self.unix_path)
# Non-specified port
with self.assertRaises(ValueError):
SocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv6Address(self.ip6_addr),
)
# Non-specified address
with self.assertRaises(ValueError):
SocketAddress(address_family=SocketAddressFamily.INET,
port=self.port)
# Invalid UNIX path
with self.assertRaises(ValueError):
SocketAddress(address_family=SocketAddressFamily.UNIX)
def test_str(self):
# Valid IPv6
self.assertEqual(
str(
SocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv6Address(self.ip6_addr),
port=self.port,
)),
f"[{self.ip6_addr}]:{self.port}",
)
# Valid IPv4
self.assertEqual(
str(
SocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv4Address(self.ip4_addr),
port=self.port,
)),
f"{self.ip4_addr}:{self.port}",
)
# Valid UNIX
self.assertEqual(
str(
SocketAddress(address_family=SocketAddressFamily.UNIX,
path=self.unix_path)),
f"unix:{self.unix_path}",
)
def test_from_host_port(self, mock_getaddrinfo):
self.assertEqual(
SocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv4Address(self.ip4_addr),
port=self.port,
),
SocketAddress.from_host_port(host="example.tld", port=self.port),
)
def thrift_address(self) -> SocketAddress:
da: SocketAddress = self.data_address
if da.address_family == SocketAddressFamily.UNIX:
assert da.path is not None
return SocketAddress(
address_family=da.address_family,
path=os.path.join(os.path.dirname(da.path), "socket_admin"),
)
elif da.address_family == SocketAddressFamily.INET:
assert da.address is not None
return SocketAddress(address_family=da.address_family,
address=da.address,
port=6440)
else:
raise AssertionError("unreachable") # pragma: nocover
def thrift_address(self) -> SocketAddress:
da: SocketAddress = self.data_address
if da.address_family == SocketAddressFamily.UNIX:
assert da.path is not None
return SocketAddress(
address_family=da.address_family,
# pyre-fixme[6]: Expected `_PathLike[AnyStr]` for 1st param but got
# `Optional[str]`.
path=os.path.join(os.path.dirname(da.path), "socket_admin"),
)
elif da.address_family == SocketAddressFamily.INET:
assert da.address is not None
return SocketAddress(address_family=da.address_family,
address=da.address,
port=6440)
else:
assert False, "unreachable" # pragma: nocover
async def get_cluster_by_hostname(hostname: str,
port: int = DEFAULT_THRIFT_PORT) -> Cluster:
"""
Convenience method which automatically resolves given hostname and returns
Cluster instance
"""
return await get_cluster(admin_server_addr=SocketAddress.from_host_port(
host=hostname, port=port))
def thrift_address(self) -> SocketAddress:
da = self.data_address
if da.address_family != SocketAddressFamily.INET:
raise ValueError(
"Can't calculate Thrift Address from Data Address")
else:
return SocketAddress(address_family=da.address_family,
address=da.address,
port=6440)
def from_thrift(cls, node_id: NodeID) -> "Node":
"""
Parses Thrift-representation of NodeID and returns instance
"""
return cls(
node_index=node_id.node_index,
data_addr=SocketAddress.from_thrift(node_id.address)
if node_id.address else None,
name=node_id.name,
)
def from_thrift(cls, node_id: NodeID) -> "Node":
"""
Parses Thrift-representation of NodeID and returns instance
"""
return cls(
node_index=node_id.node_index,
# pyre-fixme[6]: Expected `SocketAddress` for 1st param but got
# `Optional[SocketAddress]`.
data_addr=SocketAddress.from_thrift(node_id.address)
if node_id.address else None,
name=node_id.name,
)
def test_unix_socket(self):
nc = NodeConfig(
node_index=0,
data_address=SocketAddress(address_family=SocketAddressFamily.UNIX,
path="/path/to/unix.sock").to_thrift(),
roles=set(),
location_per_scope={},
name="",
)
ns = NodeState(node_index=0)
mnts = []
self._validate(NodeView(nc, ns, mnts), nc, ns, mnts)
def test_from_thrift(self):
# Valid IPv6
self.assertEqual(
SocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv6Address(self.ip6_addr),
port=self.port,
),
SocketAddress.from_thrift(
ThriftSocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv6Address(self.ip6_addr).compressed,
port=self.port,
)),
)
# Valid IPv4
self.assertEqual(
SocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv4Address(self.ip4_addr),
port=self.port,
),
SocketAddress.from_thrift(
ThriftSocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv4Address(self.ip4_addr).compressed,
port=self.port,
)),
)
# Valid UNIX
self.assertEqual(
SocketAddress(address_family=SocketAddressFamily.UNIX,
path=self.unix_path),
SocketAddress.from_thrift(
ThriftSocketAddress(address_family=SocketAddressFamily.UNIX,
address=self.unix_path)),
)
# Invalid Thrift struct
with self.assertRaises(AddressValueError):
SocketAddress.from_thrift(
ThriftSocketAddress(
address_family=SocketAddressFamily.INET,
address="invalid ip-address",
port=self.port,
))
def test_to_thrift(self):
# Valid IPv6
self.assertEqual(
SocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv6Address(self.ip6_addr),
port=self.port,
).to_thrift(),
ThriftSocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv6Address(self.ip6_addr).compressed,
port=self.port,
),
)
# Valid IPv4
self.assertEqual(
SocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv4Address(self.ip4_addr),
port=self.port,
).to_thrift(),
ThriftSocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv4Address(self.ip4_addr).compressed,
port=self.port,
),
)
# Valid UNIX
self.assertEqual(
SocketAddress(address_family=SocketAddressFamily.UNIX,
path=self.unix_path).to_thrift(),
ThriftSocketAddress(address_family=SocketAddressFamily.UNIX,
address=self.unix_path),
)
def test_no_name(self):
addr = gen_SocketAddress()
self.assertEqual(
NodeView(
node_config=NodeConfig(
node_index=0,
data_address=addr,
roles=set(),
location_per_scope={},
name="",
),
node_state=NodeState(node_index=0),
maintenances=[],
).node_name,
str(SocketAddress.from_thrift(addr)),
)
def test_from_ip_port(self):
# Valid IPv6
self.assertEqual(
SocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv6Address(self.ip6_addr),
port=self.port,
),
SocketAddress.from_ip_port(ipaddr=self.ip6_addr, port=self.port),
)
# Valid IPv4
self.assertEqual(
SocketAddress(
address_family=SocketAddressFamily.INET,
address=IPv4Address(self.ip4_addr),
port=self.port,
),
SocketAddress.from_ip_port(ipaddr=self.ip4_addr, port=self.port),
)
# Definitely invalid IP-address
with self.assertRaises(AddressValueError):
SocketAddress.from_ip_port(ipaddr="invalid", port=self.port),
def data_address(self) -> SocketAddress:
return SocketAddress.from_thrift(self.node_config.data_address)
def _validate(
self,
nv: NodeView,
nc: NodeConfig,
ns: NodeState,
mnts: Tuple[MaintenanceDefinition, ...],
):
self.assertEqual(nv.node_config, nc)
self.assertEqual(nv.node_state, ns)
self.assertEqual(nv.maintenances, mnts)
self.assertEqual(nv.node_index, nc.node_index)
if nc.name:
self.assertEqual(nv.node_name, nc.name)
else:
self.assertEqual(
nv.node_name, str(SocketAddress.from_thrift(nc.data_address))
)
self.assertEqual(nv.data_address, SocketAddress.from_thrift(nc.data_address))
if nv.thrift_address.address_family == SocketAddressFamily.INET:
assert nv.thrift_address.address is not None
from_nc = SocketAddress.from_thrift(nc.data_address)
assert from_nc.address is not None
self.assertEqual(nv.thrift_address.port, 6440)
self.assertEqual(
nv.thrift_address.address.compressed, from_nc.address.compressed
)
self.assertEqual(
nv.node_id,
NodeID(node_index=nc.node_index, address=nc.data_address, name=nc.name),
)
self.assertEqual(nv.location, nc.location)
self.assertEqual(nv.location_per_scope, nc.location_per_scope)
self.assertEqual(nv.roles, nc.roles)
for r in Role:
self.assertEqual(nv.has_role(r), r in nc.roles)
self.assertEqual(nv.is_sequencer, Role.SEQUENCER in nc.roles)
self.assertEqual(nv.is_storage, Role.STORAGE in nc.roles)
self.assertEqual(nv.daemon_state, ns.daemon_state)
if Role.SEQUENCER in nc.roles:
assert nc.sequencer is not None
self.assertEqual(nv.sequencer_config, nc.sequencer)
self.assertEqual(nv.sequencer_weight, nc.sequencer.weight)
assert ns.sequencer_state is not None
self.assertEqual(nv.sequencer_state, ns.sequencer_state)
self.assertEqual(nv.sequencing_state, ns.sequencer_state.state)
else:
self.assertIsNone(nv.sequencer_config)
self.assertIsNone(nv.sequencer_state)
self.assertIsNone(nv.sequencer_weight)
self.assertIsNone(nv.sequencing_state)
if Role.STORAGE in nc.roles:
assert nc.storage is not None
assert ns.shard_states is not None
self.assertEqual(nv.storage_config, nc.storage)
self.assertEqual(nv.storage_weight, nc.storage.weight)
self.assertEqual(nv.num_shards, nc.storage.num_shards)
self.assertEqual(nv.shard_states, ns.shard_states)
self.assertListEqual(
nv.shards_data_health, [s.data_health for s in ns.shard_states]
)
self.assertEqual(
nv.shards_data_health_count,
Counter(s.data_health for s in ns.shard_states),
)
self.assertListEqual(
nv.shards_current_storage_state,
[s.current_storage_state for s in ns.shard_states],
)
self.assertEqual(
nv.shards_current_storage_state_count,
Counter(s.current_storage_state for s in ns.shard_states),
)
self.assertListEqual(
nv.shards_current_operational_state,
[s.current_operational_state for s in ns.shard_states],
)
self.assertEqual(
nv.shards_current_operational_state_count,
Counter(s.current_operational_state for s in ns.shard_states),
)
self.assertListEqual(
nv.shards_membership_storage_state,
[s.storage_state for s in ns.shard_states],
)
self.assertEqual(
nv.shards_membership_storage_state_count,
Counter(s.storage_state for s in ns.shard_states),
)
self.assertListEqual(
nv.shards_metadata_state, [s.metadata_state for s in ns.shard_states]
)
self.assertEqual(
nv.shards_metadata_state_count,
Counter(s.metadata_state for s in ns.shard_states),
)
else:
self.assertIsNone(nv.storage_config)
self.assertIsNone(nv.storage_weight)
self.assertIsNone(nv.num_shards)
self.assertEqual(nv.shard_states, [])
def _get_node_by_node_config(nc: NodeConfig) -> Node:
return Node(
node_index=nc.node_index,
data_addr=SocketAddress.from_thrift(nc.data_address),
name=nc.name,
)
def data_address(self) -> SocketAddress:
return SocketAddress.from_thrift(self.nc.data_address)
