def test_no_given_address(self):
addresses = get_possible_addresses([])
six.assertCountEqual(self, addresses, [
Address("127.0.0.1", 5701),
Address("127.0.0.1", 5702),
Address("127.0.0.1", 5703)
])
def assert_heartbeat_stopped_and_restored():
self.assertEqual(1, len(connection_added_collector.connections))
self.assertEqual(1, len(connection_removed_collector.connections))
stopped_connection = connection_added_collector.connections[0]
restored_connection = connection_removed_collector.connections[0]
self.assertEqual(stopped_connection.connected_address, Address(member2.host, member2.port))
self.assertEqual(restored_connection.connected_address, Address(member2.host, member2.port))
def _parse_address(address):
if ":" in address:
host, port = address.split(":")
return [Address(host, int(port))]
return [
Address(address, p) for p in xrange(DEFAULT_PORT, DEFAULT_PORT + 3)
]
def test_load_addresses_with_duplicate_addresses(self):
self.network_config.addresses.append("192.168.0.1:5701")
self.network_config.addresses.append("192.168.0.1:5701")
provider = DefaultAddressProvider(self.network_config)
addresses = provider.load_addresses()
six.assertCountEqual(self, addresses, [Address("192.168.0.1", 5701),
Address("192.168.0.1", 5701)])
def test_no_given_address(self):
addresses = get_possible_addresses([])
self.assertItemsEqual(addresses, [
Address("127.0.0.1", 5701),
Address("127.0.0.1", 5702),
Address("127.0.0.1", 5703)
])
def test_no_given_address(self):
self.network_config.addresses = []
provider_addresses = get_provider_addresses([self.address_provider])
addresses = get_possible_addresses(provider_addresses)
six.assertCountEqual(self, addresses, [
Address("127.0.0.1", 5701),
Address("127.0.0.1", 5702),
Address("127.0.0.1", 5703)
])
def setUp(self):
self.private_address = Address("127.0.0.1", 5701)
self.public_address = Address("192.168.0.1", 5701)
self.lookup[self.private_address] = self.public_address
self.lookup[Address("127.0.0.2", 5701)] = Address("192.168.0.2", 5701)
self.cloud_discovery = HazelcastCloudDiscovery("", "", 0)
self.cloud_discovery.discover_nodes = lambda: self.lookup
self.translator = HazelcastCloudAddressTranslator("", "", 0)
self.translator.cloud_discovery = self.cloud_discovery
def test_load_addresses_with_duplicate_addresses(self):
initial_list = ["192.168.0.1:5701", "192.168.0.1:5701"]
provider = DefaultAddressProvider(initial_list)
primaries, secondaries = provider.load_addresses()
self.assertCountEqual(
primaries,
[Address("192.168.0.1", 5701),
Address("192.168.0.1", 5701)])
self.assertCountEqual(secondaries, [])
def test_load_addresses_with_empty_addresses(self):
initial_list = []
provider = DefaultAddressProvider(initial_list)
primaries, secondaries = provider.load_addresses()
self.assertCountEqual(primaries, [Address("127.0.0.1", 5701)])
self.assertCountEqual(
secondaries,
[Address("127.0.0.1", 5702),
Address("127.0.0.1", 5703)])
def test_load_addresses_without_port(self):
initial_list = ["192.168.0.1"]
provider = DefaultAddressProvider(initial_list)
primaries, secondaries = provider.load_addresses()
self.assertCountEqual(primaries, [Address("192.168.0.1", 5701)])
self.assertCountEqual(
secondaries,
[Address("192.168.0.1", 5702),
Address("192.168.0.1", 5703)])
def test_multiple_providers_with_empty_network_config_addresses(self):
default_address_provider = DefaultAddressProvider(self.network_config)
providers = [default_address_provider, self.cloud_address_provider]
provider_addresses = get_provider_addresses(providers)
six.assertCountEqual(self, provider_addresses,
[Address("10.0.0.1", 5701)])
addresses = get_possible_addresses(provider_addresses)
six.assertCountEqual(self, addresses, [Address("10.0.0.1", 5701)])
def test_single_given_address_with_no_port(self):
addresses = ["127.0.0.1"]
addresses = get_possible_addresses(addresses)
self.assertItemsEqual(addresses, [
Address("127.0.0.1", 5701),
Address("127.0.0.1", 5702),
Address("127.0.0.1", 5703)
])
def test_multiple_addresses(self):
addresses = ["127.0.0.1:5701", "10.0.0.1"]
addresses = get_possible_addresses(addresses)
self.assertItemsEqual(addresses, [
Address("127.0.0.1", 5701),
Address("10.0.0.1", 5701),
Address("10.0.0.1", 5702),
Address("10.0.0.1", 5703)
])
def test_load_addresses_with_multiple_addresses(self):
initial_list = [
"192.168.0.1:5701", "192.168.0.1:5702", "192.168.0.2:5701"
]
provider = DefaultAddressProvider(initial_list)
primaries, secondaries = provider.load_addresses()
six.assertCountEqual(self, primaries, [
Address("192.168.0.1", 5701),
Address("192.168.0.1", 5702),
Address("192.168.0.2", 5701)
])
six.assertCountEqual(self, secondaries, [])
def test_multiple_providers_with_empty_load_addresses(self):
default_address_provider = DefaultAddressProvider(self.network_config)
self.cloud_address_provider.load_addresses = lambda: []
providers = [default_address_provider, self.cloud_address_provider]
provider_addresses = get_provider_addresses(providers)
six.assertCountEqual(self, provider_addresses, [])
addresses = get_possible_addresses(provider_addresses)
six.assertCountEqual(self, addresses, [
Address("127.0.0.1", 5701),
Address("127.0.0.1", 5702),
Address("127.0.0.1", 5703)
])
def test_addresses_and_members(self):
self.network_config.addresses = ["127.0.0.1:5701"]
member_list = [
Member(Address("10.0.0.1", 5703), "uuid1"),
Member(Address("10.0.0.2", 5701), "uuid2")
]
provider_addresses = get_provider_addresses([self.address_provider])
addresses = get_possible_addresses(provider_addresses, member_list)
six.assertCountEqual(self, addresses, [
Address("127.0.0.1", 5701),
Address("10.0.0.1", 5703),
Address("10.0.0.2", 5701)
])
def test_addresses_and_members(self):
addresses = ["127.0.0.1:5701"]
member_list = [
Member(Address("10.0.0.1", 5703), "uuid1"),
Member(Address("10.0.0.2", 5701), "uuid2")
]
addresses = get_possible_addresses(addresses, member_list)
self.assertItemsEqual(addresses, [
Address("127.0.0.1", 5701),
Address("10.0.0.1", 5703),
Address("10.0.0.2", 5701)
])
def __init__(self, reactor, connection_manager, connection_id, address,
config, message_callback):
asyncore.dispatcher.__init__(self, map=reactor.map)
Connection.__init__(self, connection_manager, connection_id,
message_callback)
self._reactor = reactor
self.connected_address = address
self._write_queue = deque()
self._write_buf = io.BytesIO()
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
# set the socket timeout to 0 explicitly
self.socket.settimeout(0)
self._set_socket_options(config)
if config.ssl_enabled:
self._wrap_as_ssl_socket(config)
try:
self.connect((address.host, address.port))
except socket.error as e:
# If the connection attempt failed
# immediately, remove the connection from
# the dispatchers map and clean resources.
self._inner_close()
raise e
timeout = config.connection_timeout
if timeout > 0:
self._close_timer = reactor.add_timer(timeout,
self._close_timer_cb)
self.local_address = Address(*self.socket.getsockname())
self._write_queue.append(b"CP2")
def __init__(self, reactor, connection_manager, connection_id, address,
config, message_callback):
asyncore.dispatcher.__init__(self, map=reactor.map)
Connection.__init__(self, connection_manager, connection_id,
message_callback)
self._reactor = reactor
self.connected_address = address
self._write_queue = deque()
self._write_buf = io.BytesIO()
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
# set the socket timeout to 0 explicitly
self.socket.settimeout(0)
self._set_socket_options(config)
if config.ssl_enabled:
self._wrap_as_ssl_socket(config)
self.connect((address.host, address.port))
timeout = config.connection_timeout
if timeout > 0:
self._close_timer = reactor.add_timer(timeout,
self._close_timer_cb)
self.local_address = Address(*self.socket.getsockname())
self._write_queue.append(b"CP2")
def test_heartbeat_stopped_and_restored(self):
member2 = self.rc.startMember(self.cluster.id)
addr = Address(member2.host, member2.port)
wait_for_partition_table(self.client)
open_connection_to_address(self.client, member2.uuid)
def connection_collector():
connections = []
def collector(c, *args):
connections.append(c)
collector.connections = connections
return collector
connection_added_collector = connection_collector()
connection_removed_collector = connection_collector()
self.client._connection_manager.add_listener(
connection_added_collector, connection_removed_collector)
self.simulate_heartbeat_lost(self.client, addr, 2)
def assert_heartbeat_stopped_and_restored():
self.assertEqual(1, len(connection_added_collector.connections))
self.assertEqual(1, len(connection_removed_collector.connections))
stopped_connection = connection_added_collector.connections[0]
restored_connection = connection_removed_collector.connections[0]
self.assertEqual(stopped_connection.connected_address,
Address(member2.host, member2.port))
self.assertEqual(restored_connection.connected_address,
Address(member2.host, member2.port))
self.assertTrueEventually(assert_heartbeat_stopped_and_restored)
def decode(msg):
msg.next_frame()
initial_frame = msg.next_frame()
port = FixSizedTypesCodec.decode_int(initial_frame.buf, _PORT_DECODE_OFFSET)
host = StringCodec.decode(msg)
CodecUtil.fast_forward_to_end_frame(msg)
return Address(host, port)
def test_heartbeat_stopped(self):
def connection_collector():
connections = []
def collector(c):
connections.append(c)
collector.connections = connections
return collector
heartbeat_stopped_collector = connection_collector()
heartbeat_restored_collector = connection_collector()
self.client.heartbeat.add_listener(on_heartbeat_stopped=heartbeat_stopped_collector,
on_heartbeat_restored=heartbeat_restored_collector)
member2 = self.rc.startMember(self.cluster.id)
addr = Address(member2.host, member2.port)
open_connection_to_address(self.client, addr)
self.simulate_heartbeat_lost(self.client, addr, 2)
def assert_heartbeat_stopped_and_restored():
self.assertEqual(1, len(heartbeat_stopped_collector.connections))
self.assertEqual(1, len(heartbeat_restored_collector.connections))
connection_stopped = heartbeat_stopped_collector.connections[0]
connection_restored = heartbeat_restored_collector.connections[0]
self.assertEqual(connection_stopped._address, (member2.host, member2.port))
self.assertEqual(connection_restored._address, (member2.host, member2.port))
self.assertTrueEventually(assert_heartbeat_stopped_and_restored)
def test_multiple_providers_with_duplicate_network_config_addresses(self):
self.network_config.addresses.append("127.0.0.1:5701")
self.network_config.addresses.append("127.0.0.1:5701")
default_address_provider = DefaultAddressProvider(self.network_config)
providers = [default_address_provider, self.cloud_address_provider]
provider_addresses = get_provider_addresses(providers)
six.assertCountEqual(self, provider_addresses, [
Address("10.0.0.1", 5701),
Address("127.0.0.1", 5701),
Address("127.0.0.1", 5701)
])
addresses = get_possible_addresses(provider_addresses)
six.assertCountEqual(
self, addresses,
[Address("10.0.0.1", 5701),
Address("127.0.0.1", 5701)])
def assert_heartbeat_stopped_and_restored():
nonlocal assertion_succeeded
self.assertGreaterEqual(
len(connection_added_collector.connections), 1)
self.assertGreaterEqual(
len(connection_removed_collector.connections), 1)
stopped_connection = connection_removed_collector.connections[0]
restored_connection = connection_added_collector.connections[0]
self.assertEqual(
stopped_connection.connected_address,
Address(member2.host, member2.port),
)
self.assertEqual(
restored_connection.connected_address,
Address(member2.host, member2.port),
)
assertion_succeeded = True
def _parse_response(self, https_response):
json_value = json.loads(https_response.read().decode("utf-8"))
private_to_public_addresses = dict()
for value in json_value:
private_address = value[self._PRIVATE_ADDRESS_PROPERTY]
public_address = value[self._PUBLIC_ADDRESS_PROPERTY]
public_addr = _parse_address(public_address)[0]
private_to_public_addresses[Address(private_address, public_addr.port)] = public_addr
return private_to_public_addresses
def test_constructor_with_unreachable_addresses(self):
addr = Address("192.168.0.1", 5701)
config = _Config()
start = time.time()
conn = AsyncoreConnection(MagicMock(map=dict()), MagicMock(), None, addr, config, None)
try:
# Server is unreachable, but this call should return
# before connection timeout
self.assertLess(time.time() - start, config.connection_timeout)
finally:
conn.close(None, None)
def test_resources_cleaned_up_after_immediate_failure(self):
addr = Address("invalid-address", 5701)
config = _Config()
mock_reactor = MagicMock(map={})
try:
AsyncoreConnection(mock_reactor, MagicMock(), None, addr, config,
None)
self.fail(
"Connection attempt to an invalid address should fail immediately"
)
except socket.error:
# Constructor of the connection should remove itself from the
# dispatchers map of the reactor.
self.assertEqual(0, len(mock_reactor.map))
def setUp(self):
self.expected_addresses[Address("10.0.0.1", 5701)] = Address("198.51.100.1", 5701)
self.expected_addresses[Address("10.0.0.1", 5702)] = Address("198.51.100.1", 5702)
self.expected_addresses[Address("10.0.0.2", 5701)] = Address("198.51.100.2", 5701)
self.expected_addresses[self.private_address] = self.public_address
self.cloud_discovery = HazelcastCloudDiscovery("", 0)
self.cloud_discovery.discover_nodes = lambda: self.expected_addresses
self.provider = HazelcastCloudAddressProvider("", 0)
self.provider.cloud_discovery = self.cloud_discovery
def test_python_pickle_serialization(self):
obj = Address("localhost", 5701)
data = self.service.to_data(obj)
obj2 = self.service.to_object(data)
self.assertEqual(obj, obj2)
def test_multiple_addresses_non_unique(self):
self.network_config.addresses = ["127.0.0.1:5701", "127.0.0.1:5701"]
provider_addresses = get_provider_addresses([self.address_provider])
addresses = get_possible_addresses(provider_addresses)
six.assertCountEqual(self, addresses, [Address("127.0.0.1", 5701)])
