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)])