def __init__(self, bootnodes):
privkey = keys.PrivateKey(keccak(b"seed"))
self.messages = []
enr_db = MemoryEnrDb(default_identity_scheme_registry)
socket = trio.socket.socket(family=trio.socket.AF_INET,
type=trio.socket.SOCK_DGRAM)
event_bus = None
super().__init__(privkey, AddressFactory(), bootnodes, event_bus,
socket, enr_db)
async def test_memory_checks_identity_scheme():
empty_identity_scheme_registry = IdentitySchemeRegistry()
memory_db = MemoryEnrDb(empty_identity_scheme_registry)
enr = ENRFactory()
with pytest.raises(ValueError):
await memory_db.insert(enr)
with pytest.raises(ValueError):
await memory_db.insert_or_update(enr)
async def _manually_driven_discovery(seed, socket, nursery):
discovery = ManuallyDrivenDiscoveryService(
keys.PrivateKey(keccak(seed)),
Address(*socket.getsockname()),
bootstrap_nodes=[],
event_bus=None,
socket=socket,
enr_db=MemoryEnrDb(default_identity_scheme_registry))
async with background_trio_service(discovery):
# At this point we know the service has started (i.e. its run() method has been scheduled),
# but maybe it hasn't had a chance to run yet, so we wait until the _local_enr is set to
# ensure run() has actually executed.
with trio.fail_after(1):
while discovery._local_enr is None:
await trio.hazmat.checkpoint()
yield discovery
def __init__(
self,
privkey: datatypes.PrivateKey,
address: AddressAPI,
bootstrap_nodes: Sequence[NodeAPI],
event_bus: EndpointAPI,
socket: trio.socket.SocketType,
enr_field_providers: Sequence[ENR_FieldProvider] = tuple(),
) -> None:
self.privkey = privkey
self.address = address
self.bootstrap_nodes = bootstrap_nodes
self._event_bus = event_bus
self.this_node = Node(self.pubkey, address)
self.routing = RoutingTable(self.this_node)
self.enr_response_channels = ExpectedResponseChannels[Tuple[ENR,
Hash32]]()
self.pong_channels = ExpectedResponseChannels[Tuple[Hash32, int]]()
self.neighbours_channels = ExpectedResponseChannels[List[NodeAPI]]()
self.ping_channels = ExpectedResponseChannels[None]()
self.enr_field_providers = enr_field_providers
# FIXME: Use a persistent EnrDb implementation.
self._enr_db = MemoryEnrDb(default_identity_scheme_registry)
# FIXME: Use a concurrency-safe EnrDb implementation.
self._enr_db_lock = trio.Lock()
self._local_enr: ENR = None
self._local_enr_next_refresh: float = time.monotonic()
self._local_enr_lock = trio.Lock()
self.parity_pong_tokens: Dict[Hash32, Hash32] = {}
if socket.family != trio.socket.AF_INET:
raise ValueError("Invalid socket family")
elif socket.type != trio.socket.SOCK_DGRAM:
raise ValueError("Invalid socket type")
self.socket = socket
self.pending_enrs_producer, self.pending_enrs_consumer = trio.open_memory_channel[
Tuple[NodeAPI, int]](self._max_pending_enrs)
async def enr_db(enr, remote_enr):
db = MemoryEnrDb(default_identity_scheme_registry)
await db.insert(enr)
await db.insert(remote_enr)
return db
async def enr_db(local_enr, remote_enr):
enr_db = MemoryEnrDb(default_identity_scheme_registry)
await enr_db.insert(local_enr)
await enr_db.insert(remote_enr)
return enr_db
def memory_db():
return MemoryEnrDb(default_identity_scheme_registry)
async def enr_db(initial_enr):
enr_db = MemoryEnrDb(default_identity_scheme_registry)
await enr_db.insert(initial_enr)
return enr_db