mirror of
https://github.com/logos-messaging/logos-messaging-nim.git
synced 2026-06-29 13:00:06 +00:00
68ef4c70d0
Reverses the earlier dedup-by-re-export: event TYPE definitions now live in the
interface classes, and the emptied decomposed event files are removed.
- MessageSeenEvent -> logos_delivery/api/kernel_api.nim
- Message{Sent,Error,Propagated,Received}Event -> api/messaging_client_api.nim
- ChannelMessage{Received,Sent,Error}Event -> api/reliable_channel_manager_api.nim
- EventConnectionStatusChange -> api/logos_delivery_api.nim
Deleted (became empty after the move):
- logos_delivery/waku/api/events/message_events.nim
- logos_delivery/messaging/api/events.nim
- logos_delivery/channels/api/events.nim
health_events.nim keeps its two remaining events (content/shard topic health).
Rewiring: each layer re-exports its interface module (waku->kernel_api,
messaging_client->messaging_client_api, reliable_channel->reliable_channel_manager_api,
which also re-exports messaging_client_api). Deep emitters/listeners
(subscription_manager, waku_node, waku_node/relay, node_health_monitor,
recv_service, send_service) import the owning interface module directly.
kernel_api stays below node level (types/topics/message/store-common) so the
node->kernel_api imports are acyclic. liblogosdelivery builds.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
204 lines
7.5 KiB
Nim
204 lines
7.5 KiB
Nim
import std/options
|
|
import chronos, results
|
|
import brokers/event_broker
|
|
|
|
import logos_delivery/api/types as api_types
|
|
import logos_delivery/waku/waku_core/topics/pubsub_topic
|
|
import logos_delivery/waku/waku_core/message
|
|
import logos_delivery/waku/waku_store/common as store_types
|
|
|
|
export event_broker
|
|
export api_types, pubsub_topic, store_types
|
|
|
|
type IKernel* = ref object of RootObj
|
|
|
|
EventBroker:
|
|
# Internal event emitted when a message arrives from the network via any protocol
|
|
type MessageSeenEvent* = object
|
|
topic*: PubsubTopic
|
|
message*: WakuMessage
|
|
|
|
# --- topic construction ---
|
|
method buildContentTopic*(
|
|
self: IKernel, appName: string, appVersion: uint32, name: string, encoding: string
|
|
): Future[Result[ContentTopic, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.buildContentTopic not implemented")
|
|
|
|
method buildPubsubTopic*(
|
|
self: IKernel, topicName: string
|
|
): Future[Result[PubsubTopic, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.buildPubsubTopic not implemented")
|
|
|
|
method defaultPubsubTopic*(
|
|
self: IKernel
|
|
): Future[Result[PubsubTopic, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.defaultPubsubTopic not implemented")
|
|
|
|
# --- relay ---
|
|
method relayPublish*(
|
|
self: IKernel, pubsubTopic: PubsubTopic, message: WakuMessage, timeoutMs: uint32
|
|
): Future[Result[int, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.relayPublish not implemented")
|
|
|
|
method relaySubscribe*(
|
|
self: IKernel, pubsubTopic: PubsubTopic
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.relaySubscribe not implemented")
|
|
|
|
method relayUnsubscribe*(
|
|
self: IKernel, pubsubTopic: PubsubTopic
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.relayUnsubscribe not implemented")
|
|
|
|
method relayAddProtectedShard*(
|
|
self: IKernel, clusterId: uint16, shardId: uint16, publicKey: string
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.relayAddProtectedShard not implemented")
|
|
|
|
method relayConnectedPeers*(
|
|
self: IKernel, pubsubTopic: PubsubTopic
|
|
): Future[Result[seq[string], string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.relayConnectedPeers not implemented")
|
|
|
|
method relayPeersInMesh*(
|
|
self: IKernel, pubsubTopic: PubsubTopic
|
|
): Future[Result[seq[string], string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.relayPeersInMesh not implemented")
|
|
|
|
# --- filter ---
|
|
method filterSubscribe*(
|
|
self: IKernel,
|
|
pubsubTopic: Option[PubsubTopic],
|
|
contentTopics: seq[ContentTopic],
|
|
peer: string,
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.filterSubscribe not implemented")
|
|
|
|
method filterUnsubscribe*(
|
|
self: IKernel,
|
|
pubsubTopic: Option[PubsubTopic],
|
|
contentTopics: seq[ContentTopic],
|
|
peer: string,
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.filterUnsubscribe not implemented")
|
|
|
|
method filterUnsubscribeAll*(
|
|
self: IKernel, peer: string
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.filterUnsubscribeAll not implemented")
|
|
|
|
# --- lightpush ---
|
|
method lightpushPublish*(
|
|
self: IKernel, pubsubTopic: PubsubTopic, message: WakuMessage, peer: string
|
|
): Future[Result[string, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.lightpushPublish not implemented")
|
|
|
|
# --- store ---
|
|
method storeQuery*(
|
|
self: IKernel, request: StoreQueryRequest, peer: string, timeoutMs: int
|
|
): Future[Result[StoreQueryResponse, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.storeQuery not implemented")
|
|
|
|
# --- peer management ---
|
|
method connect*(
|
|
self: IKernel, peers: seq[string], timeoutMs: uint32
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.connect not implemented")
|
|
|
|
method disconnectPeerById*(
|
|
self: IKernel, peerId: string
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.disconnectPeerById not implemented")
|
|
|
|
method disconnectAllPeers*(
|
|
self: IKernel
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.disconnectAllPeers not implemented")
|
|
|
|
method dialPeer*(
|
|
self: IKernel, peerAddr: string, protocol: string, timeoutMs: int
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.dialPeer not implemented")
|
|
|
|
method dialPeerById*(
|
|
self: IKernel, peerId: string, protocol: string, timeoutMs: int
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.dialPeerById not implemented")
|
|
|
|
method peerIdsFromPeerstore*(
|
|
self: IKernel
|
|
): Future[Result[seq[string], string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.peerIdsFromPeerstore not implemented")
|
|
|
|
method connectedPeersInfo*(
|
|
self: IKernel
|
|
): Future[Result[seq[string], string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.connectedPeersInfo not implemented")
|
|
|
|
method connectedPeers*(
|
|
self: IKernel
|
|
): Future[Result[seq[string], string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.connectedPeers not implemented")
|
|
|
|
method peerIdsByProtocol*(
|
|
self: IKernel, protocol: string
|
|
): Future[Result[seq[string], string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.peerIdsByProtocol not implemented")
|
|
|
|
# --- discovery ---
|
|
method dnsDiscovery*(
|
|
self: IKernel, enrTreeUrl: string, nameServer: string, timeoutMs: int
|
|
): Future[Result[seq[string], string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.dnsDiscovery not implemented")
|
|
|
|
method discv5UpdateBootnodes*(
|
|
self: IKernel, bootnodes: seq[string]
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.discv5UpdateBootnodes not implemented")
|
|
|
|
method startDiscv5*(
|
|
self: IKernel
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.startDiscv5 not implemented")
|
|
|
|
method stopDiscv5*(
|
|
self: IKernel
|
|
): Future[Result[bool, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.stopDiscv5 not implemented")
|
|
|
|
method peerExchangeRequest*(
|
|
self: IKernel, numPeers: uint64
|
|
): Future[Result[int, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.peerExchangeRequest not implemented")
|
|
|
|
# --- debug / info ---
|
|
method version*(
|
|
self: IKernel
|
|
): Future[Result[string, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.version not implemented")
|
|
|
|
method listenAddresses*(
|
|
self: IKernel
|
|
): Future[Result[seq[string], string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.listenAddresses not implemented")
|
|
|
|
method myEnr*(
|
|
self: IKernel
|
|
): Future[Result[string, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.myEnr not implemented")
|
|
|
|
method myPeerId*(
|
|
self: IKernel
|
|
): Future[Result[string, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.myPeerId not implemented")
|
|
|
|
method metrics*(
|
|
self: IKernel
|
|
): Future[Result[string, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.metrics not implemented")
|
|
|
|
method pingPeer*(
|
|
self: IKernel, peerAddr: string, timeoutMs: int
|
|
): Future[Result[int64, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IKernel.pingPeer not implemented")
|