def get_local_address_for(self, loc):
host, port = parse_host_port(loc)
host = ensure_ip(host)
if ":" in host:
local_host = get_ipv6(host)
else:
local_host = get_ip(host)
return unparse_host_port(local_host, None)
def ensure_concrete_host(host, default_host=None):
"""
Ensure the given host string (or IP) denotes a concrete host, not a
wildcard listening address.
"""
if host in ("0.0.0.0", ""):
return default_host or get_ip()
elif host == "::":
return default_host or get_ipv6()
else:
return host
assert_can_connect_from_everywhere_4,
assert_can_connect_from_everywhere_4_6,
assert_can_connect_from_everywhere_6,
assert_can_connect_locally_4,
assert_can_connect_locally_6,
tls_security,
captured_logger,
inc,
throws,
)
from distributed.utils_test import loop # noqa F401
EXTERNAL_IP4 = get_ip()
if has_ipv6():
EXTERNAL_IP6 = get_ipv6()
def echo(comm, x):
return x
class CountedObject:
"""
A class which counts the number of live instances.
"""
n_instances = 0
# Use __new__, as __init__ can be bypassed by pickle.
def __new__(cls):
from distributed.utils_test import loop # noqa: F401
from distributed.protocol import (to_serialize, Serialized, serialize,
deserialize)
from distributed.comm import (tcp, inproc, connect, listen, CommClosedError,
parse_address, parse_host_port,
unparse_host_port, resolve_address,
get_address_host, get_local_address_for)
EXTERNAL_IP4 = get_ip()
if has_ipv6():
with warnings.catch_warnings(record=True):
warnings.simplefilter('always')
EXTERNAL_IP6 = get_ipv6()
ca_file = get_cert('tls-ca-cert.pem')
# The Subject field of our test certs
cert_subject = (
(('countryName', 'XY'),),
(('localityName', 'Dask-distributed'),),
(('organizationName', 'Dask'),),
(('commonName', 'localhost'),)
)
def check_tls_extra(info):
assert isinstance(info, dict)
async def test_server_listen():
"""
Test various Server.listen() arguments and their effect.
"""
import socket
try:
EXTERNAL_IP4 = get_ip()
if has_ipv6():
EXTERNAL_IP6 = get_ipv6()
except socket.gaierror:
raise pytest.skip(reason="no network access")
from contextlib import asynccontextmanager
@asynccontextmanager
async def listen_on(cls, *args, **kwargs):
server = cls({})
await server.listen(*args, **kwargs)
try:
yield server
finally:
server.stop()
# Note server.address is the concrete, contactable address
async with listen_on(Server, 7800) as server:
assert server.port == 7800
assert server.address == "tcp://%s:%d" % (EXTERNAL_IP4, server.port)
await assert_can_connect(server.address)
await assert_can_connect_from_everywhere_4_6(server.port)
async with listen_on(Server) as server:
assert server.port > 0
assert server.address == "tcp://%s:%d" % (EXTERNAL_IP4, server.port)
await assert_can_connect(server.address)
await assert_can_connect_from_everywhere_4_6(server.port)
async with listen_on(MyServer) as server:
assert server.port == MyServer.default_port
assert server.address == "tcp://%s:%d" % (EXTERNAL_IP4, server.port)
await assert_can_connect(server.address)
await assert_can_connect_from_everywhere_4_6(server.port)
async with listen_on(Server, ("", 7801)) as server:
assert server.port == 7801
assert server.address == "tcp://%s:%d" % (EXTERNAL_IP4, server.port)
await assert_can_connect(server.address)
await assert_can_connect_from_everywhere_4_6(server.port)
async with listen_on(Server, "tcp://:7802") as server:
assert server.port == 7802
assert server.address == "tcp://%s:%d" % (EXTERNAL_IP4, server.port)
await assert_can_connect(server.address)
await assert_can_connect_from_everywhere_4_6(server.port)
# Only IPv4
async with listen_on(Server, ("0.0.0.0", 7810)) as server:
assert server.port == 7810
assert server.address == "tcp://%s:%d" % (EXTERNAL_IP4, server.port)
await assert_can_connect(server.address)
await assert_can_connect_from_everywhere_4(server.port)
async with listen_on(Server, ("127.0.0.1", 7811)) as server:
assert server.port == 7811
assert server.address == "tcp://127.0.0.1:%d" % server.port
await assert_can_connect(server.address)
await assert_can_connect_locally_4(server.port)
async with listen_on(Server, "tcp://127.0.0.1:7812") as server:
assert server.port == 7812
assert server.address == "tcp://127.0.0.1:%d" % server.port
await assert_can_connect(server.address)
await assert_can_connect_locally_4(server.port)
# Only IPv6
if has_ipv6():
async with listen_on(Server, ("::", 7813)) as server:
assert server.port == 7813
assert server.address == "tcp://[%s]:%d" % (EXTERNAL_IP6,
server.port)
await assert_can_connect(server.address)
await assert_can_connect_from_everywhere_6(server.port)
async with listen_on(Server, ("::1", 7814)) as server:
assert server.port == 7814
assert server.address == "tcp://[::1]:%d" % server.port
await assert_can_connect(server.address)
await assert_can_connect_locally_6(server.port)
async with listen_on(Server, "tcp://[::1]:7815") as server:
assert server.port == 7815
assert server.address == "tcp://[::1]:%d" % server.port
await assert_can_connect(server.address)
await assert_can_connect_locally_6(server.port)
# TLS
sec = tls_security()
async with listen_on(Server, "tls://",
**sec.get_listen_args("scheduler")) as server:
assert server.address.startswith("tls://")
await assert_can_connect(server.address,
**sec.get_connection_args("client"))
# InProc
async with listen_on(Server, "inproc://") as server:
inproc_addr1 = server.address
assert inproc_addr1.startswith("inproc://%s/%d/" %
(get_ip(), os.getpid()))
await assert_can_connect(inproc_addr1)
async with listen_on(Server, "inproc://") as server2:
inproc_addr2 = server2.address
assert inproc_addr2.startswith("inproc://%s/%d/" %
(get_ip(), os.getpid()))
await assert_can_connect(inproc_addr2)
await assert_can_connect(inproc_addr1)
await assert_cannot_connect(inproc_addr2)
