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>
71 lines
2.5 KiB
Nim
71 lines
2.5 KiB
Nim
import chronos, results
|
|
|
|
import brokers/event_broker
|
|
|
|
import logos_delivery/api/types as api_types
|
|
import logos_delivery/channels/types as channel_types
|
|
|
|
# The channel layer re-uses the messaging-layer message events (the `requestId`
|
|
# is shared across layers), so it re-exports the messaging interface's event
|
|
# surface and only adds the channel-level events that have no lower-layer
|
|
# analogue (reassembled payload / senderId / channelId).
|
|
import logos_delivery/api/messaging_client_api
|
|
|
|
export event_broker, api_types
|
|
export channel_types, messaging_client_api
|
|
|
|
type
|
|
IReliableChannelManager* = ref object of RootObj
|
|
|
|
SendHandler* = proc(envelope: MessageEnvelope): Future[Result[RequestId, string]] {.
|
|
async: (raises: [CatchableError]), gcsafe
|
|
.}
|
|
## Egress dispatch boundary. Typically wraps `MessagingClient.send`;
|
|
## tests inject a fake that records calls and returns canned
|
|
## `RequestId`s so the send state machine can be exercised end-to-end
|
|
## without a network.
|
|
|
|
EventBroker:
|
|
type ChannelMessageReceivedEvent* = object
|
|
channelId*: ChannelId
|
|
senderId*: SdsParticipantID
|
|
payload*: seq[byte]
|
|
|
|
EventBroker:
|
|
## Emitted when every segment of a channel-level `send()` reached
|
|
## `Confirmed`. Channel-level analogue of `MessageSentEvent`; the
|
|
## `requestId` is the channel-layer parent returned by `send()`.
|
|
type ChannelMessageSentEvent* = object
|
|
channelId*: ChannelId
|
|
requestId*: RequestId
|
|
|
|
EventBroker:
|
|
## Emitted when a channel-level `send()` finalises with at least one
|
|
## segment in `Failed`. Channel-level analogue of `MessageErrorEvent`.
|
|
type ChannelMessageErrorEvent* = object
|
|
channelId*: ChannelId
|
|
requestId*: RequestId
|
|
error*: string
|
|
|
|
method createReliableChannel*(
|
|
self: IReliableChannelManager,
|
|
channelId: ChannelId,
|
|
contentTopic: ContentTopic,
|
|
senderId: SdsParticipantID,
|
|
sendHandler: SendHandler = nil,
|
|
): Result[ChannelId, string] {.base.} =
|
|
return err("Interface IReliableChannelManager.createReliableChannel not implemented")
|
|
|
|
method closeChannel*(
|
|
self: IReliableChannelManager, channelId: ChannelId
|
|
): Future[Result[void, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IReliableChannelManager.closeChannel not implemented")
|
|
|
|
method send*(
|
|
self: IReliableChannelManager,
|
|
channelId: ChannelId,
|
|
appPayload: seq[byte],
|
|
ephemeral: bool = false,
|
|
): Future[Result[RequestId, string]] {.async: (raises: []), base.} =
|
|
return err("Interface IReliableChannelManager.send not implemented")
|