mirror of
https://github.com/logos-messaging/logos-messaging-nim.git
synced 2026-06-27 20:10:02 +00:00
aca652008a
Each layer now separates its constructible core from its public surface:
- core module (waku.nim / messaging_client.nim /
reliable_channel_manager.nim): the type plus new/start/stop and the
private construction helpers.
- api/ folder: one module per differentiated set of operations
(waku: topics/relay/filter/lightpush/store/peer_manager/discovery/
debug/health) plus an events surface.
The waku api is reshaped to be the complete operation surface the C
bindings need, so the library no longer reaches into node internals:
relayPublish returns the message hash, relaySubscribe takes an optional
handler, filter/lightpush auto-select the service peer, connectedPeersInfo
returns structured data, pingPeer honours the timeout, plus
relayNumPeersInMesh / relayNumConnectedPeers / isOnline. library/ is now a
thin C-ABI shim: each {.ffi.} proc only marshals cstring/JSON/callbacks and
delegates to ctx.myLib[].waku.<op> (or messagingClient.<op>).
app_callbacks re-exports the modules defining its handler types, which the
included FFI files previously relied on by leakage.
Events move next to the surface that owns them, with each dependency kept
pointing the right way:
- waku/events/ relocated under waku/api/events/.
- channel events live in channels/api/events.nim.
- the four messaging-level message events move to messaging/api/events;
MessageSeenEvent stays in waku because it is emitted by waku core, so
moving it would make waku depend on the messaging layer.
- delivery_events renamed to filter_subscribe_events to match the
OnFilterSubscribe/Unsubscribe events it actually declares.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
105 lines
3.2 KiB
Nim
105 lines
3.2 KiB
Nim
import std/[strutils, tables, json]
|
|
import chronicles, chronos, results, ffi
|
|
import logos_delivery, library/declare_lib
|
|
|
|
type PeerInfo = object
|
|
protocols: seq[string]
|
|
addresses: seq[string]
|
|
|
|
proc waku_get_peerids_from_peerstore(
|
|
ctx: ptr FFIContext[LogosDelivery], callback: FFICallBack, userData: pointer
|
|
) {.ffi.} =
|
|
## returns a comma-separated string of peerIDs
|
|
let peerIds = (await ctx.myLib[].waku.peerIdsFromPeerstore()).valueOr:
|
|
return err(error)
|
|
return ok(peerIds.join(","))
|
|
|
|
proc waku_connect(
|
|
ctx: ptr FFIContext[LogosDelivery],
|
|
callback: FFICallBack,
|
|
userData: pointer,
|
|
peerMultiAddr: cstring,
|
|
timeoutMs: cuint,
|
|
) {.ffi.} =
|
|
let peers = ($peerMultiAddr).split(",")
|
|
(await ctx.myLib[].waku.connect(peers, uint32(timeoutMs))).isOkOr:
|
|
return err(error)
|
|
return ok("")
|
|
|
|
proc waku_disconnect_peer_by_id(
|
|
ctx: ptr FFIContext[LogosDelivery],
|
|
callback: FFICallBack,
|
|
userData: pointer,
|
|
peerId: cstring,
|
|
) {.ffi.} =
|
|
(await ctx.myLib[].waku.disconnectPeerById($peerId)).isOkOr:
|
|
error "DISCONNECT_PEER_BY_ID failed", error = error
|
|
return err(error)
|
|
return ok("")
|
|
|
|
proc waku_disconnect_all_peers(
|
|
ctx: ptr FFIContext[LogosDelivery], callback: FFICallBack, userData: pointer
|
|
) {.ffi.} =
|
|
(await ctx.myLib[].waku.disconnectAllPeers()).isOkOr:
|
|
return err(error)
|
|
return ok("")
|
|
|
|
proc waku_dial_peer(
|
|
ctx: ptr FFIContext[LogosDelivery],
|
|
callback: FFICallBack,
|
|
userData: pointer,
|
|
peerMultiAddr: cstring,
|
|
protocol: cstring,
|
|
timeoutMs: cuint,
|
|
) {.ffi.} =
|
|
(await ctx.myLib[].waku.dialPeer($peerMultiAddr, $protocol, int(timeoutMs))).isOkOr:
|
|
error "DIAL_PEER failed", error = error
|
|
return err(error)
|
|
return ok("")
|
|
|
|
proc waku_dial_peer_by_id(
|
|
ctx: ptr FFIContext[LogosDelivery],
|
|
callback: FFICallBack,
|
|
userData: pointer,
|
|
peerId: cstring,
|
|
protocol: cstring,
|
|
timeoutMs: cuint,
|
|
) {.ffi.} =
|
|
(await ctx.myLib[].waku.dialPeerById($peerId, $protocol, int(timeoutMs))).isOkOr:
|
|
error "DIAL_PEER_BY_ID failed", error = error
|
|
return err(error)
|
|
return ok("")
|
|
|
|
proc waku_get_connected_peers_info(
|
|
ctx: ptr FFIContext[LogosDelivery], callback: FFICallBack, userData: pointer
|
|
) {.ffi.} =
|
|
## returns a JSON string mapping peerIDs to objects with protocols and addresses
|
|
let peers = (await ctx.myLib[].waku.connectedPeersInfo()).valueOr:
|
|
return err(error)
|
|
|
|
var peersMap = initTable[string, PeerInfo]()
|
|
for peer in peers:
|
|
peersMap[peer.peerId] =
|
|
PeerInfo(protocols: peer.protocols, addresses: peer.addresses)
|
|
|
|
return ok($(%*peersMap))
|
|
|
|
proc waku_get_connected_peers(
|
|
ctx: ptr FFIContext[LogosDelivery], callback: FFICallBack, userData: pointer
|
|
) {.ffi.} =
|
|
## returns a comma-separated string of peerIDs
|
|
let peerIds = (await ctx.myLib[].waku.connectedPeers()).valueOr:
|
|
return err(error)
|
|
return ok(peerIds.join(","))
|
|
|
|
proc waku_get_peerids_by_protocol(
|
|
ctx: ptr FFIContext[LogosDelivery],
|
|
callback: FFICallBack,
|
|
userData: pointer,
|
|
protocol: cstring,
|
|
) {.ffi.} =
|
|
## returns a comma-separated string of peerIDs that mount the given protocol
|
|
let peerIds = (await ctx.myLib[].waku.peerIdsByProtocol($protocol)).valueOr:
|
|
return err(error)
|
|
return ok(peerIds.join(","))
|