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