mirror of
https://github.com/logos-messaging/logos-delivery.git
synced 2026-07-24 05:23:16 +00:00
6837ae0c1f
* bump nim-libp2p pin to v2.0.0 tag * bump json_rpc to v0.6.1, lsquic to v0.5.1, boringssl to v0.0.8 (latest tags) * add libp2p_mix dep; repoint libp2p/protocols/mix -> libp2p_mix * pin nimble.lock: websock / protobuf_serialization / npeg / jwt * Makefile: add -d:libp2p_quic_support * regenerate nix/deps.nix (adds libp2p_mix, refreshes pins) * migrate rng ref HmacDrbgContext -> libp2p Rng across prod/channels/tests (interface-only; same DRBG) * waku_switch: TransportConfig factory; unified 2.0.0 connection limits (withMaxInOut, withMaxConnections); local MaxConnections * waku_relay/rendezvous/discv5/kademlia: v2.0.0 API (rng, config, ServiceDiscovery rename) * call Service.setup() on post-build switch services (2.0.0 split setup/start) * drop libp2p/utils/semaphore -> chronos AsyncSemaphore * add logos_delivery/waku/compat/option_valueor shim (Option[T] valueOr/withValue, dropped upstream) * add std/options where a transitive re-export was removed * add newStandardSwitch shim (libp2p removed it in 2.0.0); mounts yamux+mplex to match prod muxer * PeerId.random(rng); common.rng()/crypto.newRng(); hoist shared rng (instantiation cleanup) * update expectations for 2.0.0 defaults: DEFAULT_PROTOCOLS += /ipfs/id/push/1.0.0; agent "nim-libp2p" * drop relay reboot/reconnect test (asserted a Switch restart capability that is simply not supported) * fix up a few tests that were flaking on MacOS (libp2p upgrade may have exposed these)
112 lines
2.9 KiB
Nim
112 lines
2.9 KiB
Nim
import logos_delivery/waku/compat/option_valueor
|
|
{.push raises: [].}
|
|
|
|
import
|
|
std/[options, sequtils],
|
|
results,
|
|
chronicles,
|
|
chronos,
|
|
metrics,
|
|
libp2p/protocols/protocol,
|
|
libp2p/stream/connection,
|
|
libp2p/crypto/crypto,
|
|
eth/p2p/discoveryv5/enr
|
|
import ../common/nimchronos, ../waku_core, ./rpc, ../common/callbacks
|
|
|
|
from ../waku_core/codecs import WakuMetadataCodec
|
|
export WakuMetadataCodec
|
|
|
|
logScope:
|
|
topics = "waku metadata"
|
|
|
|
const RpcResponseMaxBytes* = 1024
|
|
|
|
type WakuMetadata* = ref object of LPProtocol
|
|
clusterId*: uint32
|
|
getShards: GetShards
|
|
|
|
proc respond(
|
|
m: WakuMetadata, conn: Connection
|
|
): Future[Result[void, string]] {.async, gcsafe.} =
|
|
let response = WakuMetadataResponse(
|
|
clusterId: some(m.clusterId.uint32), shards: m.getShards().mapIt(it.uint32)
|
|
)
|
|
|
|
let res = catch:
|
|
await conn.writeLP(response.encode().buffer)
|
|
res.isOkOr:
|
|
return err(error.msg)
|
|
|
|
return ok()
|
|
|
|
proc request*(
|
|
m: WakuMetadata, conn: Connection
|
|
): Future[Result[WakuMetadataResponse, string]] {.async, gcsafe.} =
|
|
let request = WakuMetadataRequest(
|
|
clusterId: some(m.clusterId), shards: m.getShards().mapIt(it.uint32)
|
|
)
|
|
|
|
let writeRes = catch:
|
|
await conn.writeLP(request.encode().buffer)
|
|
let readRes = catch:
|
|
await conn.readLp(RpcResponseMaxBytes)
|
|
|
|
# close no matter what
|
|
let closeRes = catch:
|
|
await conn.closeWithEof()
|
|
closeRes.isOkOr:
|
|
return err("close failed: " & error.msg)
|
|
|
|
writeRes.isOkOr:
|
|
return err("write failed: " & error.msg)
|
|
|
|
let buffer = readRes.valueOr:
|
|
return err("read failed: " & error.msg)
|
|
|
|
let response = WakuMetadataResponse.decode(buffer).valueOr:
|
|
return err("decode failed: " & $error)
|
|
|
|
return ok(response)
|
|
|
|
proc initProtocolHandler(m: WakuMetadata) =
|
|
proc handler(conn: Connection, proto: string) {.async: (raises: [CancelledError]).} =
|
|
defer:
|
|
# close, no data is expected
|
|
await conn.closeWithEof()
|
|
|
|
let res = catch:
|
|
await conn.readLp(RpcResponseMaxBytes)
|
|
let buffer = res.valueOr:
|
|
error "Connection reading error", error = error.msg
|
|
return
|
|
|
|
let response = WakuMetadataResponse.decode(buffer).valueOr:
|
|
error "Response decoding error", error = error
|
|
return
|
|
|
|
info "Received WakuMetadata request",
|
|
remoteClusterId = response.clusterId,
|
|
remoteShards = response.shards,
|
|
localClusterId = m.clusterId,
|
|
localShards = m.getShards(),
|
|
peer = conn.peerId
|
|
|
|
try:
|
|
discard await m.respond(conn)
|
|
except CatchableError:
|
|
error "Failed to respond to WakuMetadata request",
|
|
error = getCurrentExceptionMsg()
|
|
|
|
m.handler = handler
|
|
m.codec = WakuMetadataCodec
|
|
|
|
proc new*(T: type WakuMetadata, clusterId: uint32, getShards: GetShards): T =
|
|
let wm = WakuMetadata(clusterId: clusterId, getShards: getShards)
|
|
|
|
wm.initProtocolHandler()
|
|
|
|
info "Created WakuMetadata protocol",
|
|
clusterId = wm.clusterId, shards = wm.getShards()
|
|
|
|
return wm
|