2022-11-04 09:52:27 +00:00
|
|
|
when (NimMajor, NimMinor) < (1, 4):
|
|
|
|
{.push raises: [Defect].}
|
|
|
|
else:
|
|
|
|
{.push raises: [].}
|
2022-07-25 11:01:37 +00:00
|
|
|
|
2022-11-09 17:50:18 +00:00
|
|
|
import
|
|
|
|
std/[options, sequtils],
|
|
|
|
stew/results
|
2022-07-25 11:01:37 +00:00
|
|
|
import
|
2022-09-28 11:36:05 +00:00
|
|
|
../../utils/time,
|
2022-11-04 09:52:08 +00:00
|
|
|
../waku_message,
|
2022-11-09 17:50:18 +00:00
|
|
|
./common
|
|
|
|
|
|
|
|
|
|
|
|
## Wire protocol
|
|
|
|
|
|
|
|
type PagingIndexRPC* = object
|
|
|
|
## This type contains the description of an Index used in the pagination of WakuMessages
|
|
|
|
pubsubTopic*: PubsubTopic
|
|
|
|
senderTime*: Timestamp # the time at which the message is generated
|
|
|
|
receiverTime*: Timestamp
|
|
|
|
digest*: MessageDigest # calculated over payload and content topic
|
|
|
|
|
|
|
|
proc `==`*(x, y: PagingIndexRPC): bool =
|
|
|
|
## receiverTime plays no role in index equality
|
|
|
|
(x.senderTime == y.senderTime) and
|
|
|
|
(x.digest == y.digest) and
|
|
|
|
(x.pubsubTopic == y.pubsubTopic)
|
|
|
|
|
|
|
|
proc compute*(T: type PagingIndexRPC, msg: WakuMessage, receivedTime: Timestamp, pubsubTopic: PubsubTopic): T =
|
|
|
|
## Takes a WakuMessage with received timestamp and returns its Index.
|
|
|
|
let
|
|
|
|
digest = computeDigest(msg)
|
|
|
|
senderTime = msg.timestamp
|
|
|
|
|
|
|
|
PagingIndexRPC(
|
|
|
|
pubsubTopic: pubsubTopic,
|
|
|
|
senderTime: senderTime,
|
|
|
|
receiverTime: receivedTime,
|
|
|
|
digest: digest
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
|
type
|
|
|
|
PagingDirectionRPC* {.pure.} = enum
|
|
|
|
## PagingDirection determines the direction of pagination
|
|
|
|
BACKWARD = uint32(0)
|
|
|
|
FORWARD = uint32(1)
|
|
|
|
|
|
|
|
PagingInfoRPC* = object
|
|
|
|
## This type holds the information needed for the pagination
|
2022-11-17 19:40:08 +00:00
|
|
|
pageSize*: Option[uint64]
|
|
|
|
cursor*: Option[PagingIndexRPC]
|
|
|
|
direction*: Option[PagingDirectionRPC]
|
2022-07-25 11:01:37 +00:00
|
|
|
|
|
|
|
|
|
|
|
type
|
2022-11-09 17:50:18 +00:00
|
|
|
HistoryContentFilterRPC* = object
|
2022-07-25 11:01:37 +00:00
|
|
|
contentTopic*: ContentTopic
|
|
|
|
|
2022-11-09 17:50:18 +00:00
|
|
|
HistoryQueryRPC* = object
|
|
|
|
contentFilters*: seq[HistoryContentFilterRPC]
|
2022-11-17 19:40:08 +00:00
|
|
|
pubsubTopic*: Option[PubsubTopic]
|
|
|
|
pagingInfo*: Option[PagingInfoRPC]
|
|
|
|
startTime*: Option[int64]
|
|
|
|
endTime*: Option[int64]
|
2022-07-25 11:01:37 +00:00
|
|
|
|
2022-11-09 17:50:18 +00:00
|
|
|
HistoryResponseErrorRPC* {.pure.} = enum
|
|
|
|
## HistoryResponseErrorRPC contains error message to inform the querying node about
|
|
|
|
## the state of its request
|
2022-07-25 11:01:37 +00:00
|
|
|
NONE = uint32(0)
|
|
|
|
INVALID_CURSOR = uint32(1)
|
2022-09-20 09:39:52 +00:00
|
|
|
SERVICE_UNAVAILABLE = uint32(503)
|
2022-07-25 11:01:37 +00:00
|
|
|
|
2022-11-09 17:50:18 +00:00
|
|
|
HistoryResponseRPC* = object
|
2022-07-25 11:01:37 +00:00
|
|
|
messages*: seq[WakuMessage]
|
2022-11-17 19:40:08 +00:00
|
|
|
pagingInfo*: Option[PagingInfoRPC]
|
2022-11-09 17:50:18 +00:00
|
|
|
error*: HistoryResponseErrorRPC
|
2022-07-25 11:01:37 +00:00
|
|
|
|
|
|
|
HistoryRPC* = object
|
|
|
|
requestId*: string
|
2022-11-17 19:40:08 +00:00
|
|
|
query*: Option[HistoryQueryRPC]
|
|
|
|
response*: Option[HistoryResponseRPC]
|
2022-11-09 17:50:18 +00:00
|
|
|
|
|
|
|
|
|
|
|
proc parse*(T: type HistoryResponseErrorRPC, kind: uint32): T =
|
|
|
|
case kind:
|
|
|
|
of 0, 1, 503:
|
|
|
|
HistoryResponseErrorRPC(kind)
|
|
|
|
else:
|
|
|
|
# TODO: Improve error variants/move to satus codes
|
|
|
|
HistoryResponseErrorRPC.INVALID_CURSOR
|
|
|
|
|
|
|
|
|
|
|
|
## Wire protocol type mappings
|
|
|
|
|
|
|
|
proc toRPC*(cursor: HistoryCursor): PagingIndexRPC {.gcsafe.}=
|
|
|
|
PagingIndexRPC(
|
|
|
|
pubsubTopic: cursor.pubsubTopic,
|
|
|
|
senderTime: cursor.senderTime,
|
|
|
|
receiverTime: cursor.storeTime,
|
|
|
|
digest: cursor.digest
|
|
|
|
)
|
|
|
|
|
|
|
|
proc toAPI*(rpc: PagingIndexRPC): HistoryCursor =
|
|
|
|
HistoryCursor(
|
|
|
|
pubsubTopic: rpc.pubsubTopic,
|
|
|
|
senderTime: rpc.senderTime,
|
|
|
|
storeTime: rpc.receiverTime,
|
|
|
|
digest: rpc.digest
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
|
proc toRPC*(query: HistoryQuery): HistoryQueryRPC =
|
2022-11-17 19:40:08 +00:00
|
|
|
var rpc = HistoryQueryRPC()
|
|
|
|
|
|
|
|
rpc.contentFilters = query.contentTopics.mapIt(HistoryContentFilterRPC(contentTopic: it))
|
|
|
|
|
|
|
|
rpc.pubsubTopic = query.pubsubTopic
|
|
|
|
|
|
|
|
rpc.pagingInfo = block:
|
|
|
|
if query.cursor.isNone() and
|
|
|
|
query.pageSize == default(type query.pageSize) and
|
|
|
|
query.ascending == default(type query.ascending):
|
|
|
|
none(PagingInfoRPC)
|
|
|
|
else:
|
|
|
|
let
|
|
|
|
pageSize = some(query.pageSize)
|
|
|
|
cursor = query.cursor.map(toRPC)
|
|
|
|
direction = if query.ascending: some(PagingDirectionRPC.FORWARD)
|
|
|
|
else: some(PagingDirectionRPC.BACKWARD)
|
|
|
|
some(PagingInfoRPC(
|
|
|
|
pageSize: pageSize,
|
|
|
|
cursor: cursor,
|
|
|
|
direction: direction
|
|
|
|
))
|
|
|
|
|
|
|
|
rpc.startTime = query.startTime
|
|
|
|
rpc.endTime = query.endTime
|
|
|
|
|
|
|
|
rpc
|
2022-11-09 17:50:18 +00:00
|
|
|
|
|
|
|
|
|
|
|
proc toAPI*(rpc: HistoryQueryRPC): HistoryQuery =
|
|
|
|
let
|
2022-11-17 19:40:08 +00:00
|
|
|
pubsubTopic = rpc.pubsubTopic
|
2022-11-09 17:50:18 +00:00
|
|
|
|
|
|
|
contentTopics = rpc.contentFilters.mapIt(it.contentTopic)
|
|
|
|
|
2022-11-17 19:40:08 +00:00
|
|
|
cursor = if rpc.pagingInfo.isNone() or rpc.pagingInfo.get().cursor.isNone(): none(HistoryCursor)
|
|
|
|
else: rpc.pagingInfo.get().cursor.map(toAPI)
|
2022-11-09 17:50:18 +00:00
|
|
|
|
2022-11-17 19:40:08 +00:00
|
|
|
startTime = rpc.startTime
|
2022-11-09 17:50:18 +00:00
|
|
|
|
2022-11-17 19:40:08 +00:00
|
|
|
endTime = rpc.endTime
|
2022-11-09 17:50:18 +00:00
|
|
|
|
2022-11-17 19:40:08 +00:00
|
|
|
pageSize = if rpc.pagingInfo.isNone() or rpc.pagingInfo.get().pageSize.isNone(): 0'u64
|
|
|
|
else: rpc.pagingInfo.get().pageSize.get()
|
2022-11-09 17:50:18 +00:00
|
|
|
|
2022-11-17 19:40:08 +00:00
|
|
|
ascending = if rpc.pagingInfo.isNone() or rpc.pagingInfo.get().direction.isNone(): true
|
|
|
|
else: rpc.pagingInfo.get().direction.get() == PagingDirectionRPC.FORWARD
|
2022-11-09 17:50:18 +00:00
|
|
|
|
|
|
|
HistoryQuery(
|
|
|
|
pubsubTopic: pubsubTopic,
|
|
|
|
contentTopics: contentTopics,
|
|
|
|
cursor: cursor,
|
|
|
|
startTime: startTime,
|
|
|
|
endTime: endTime,
|
|
|
|
pageSize: pageSize,
|
|
|
|
ascending: ascending
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
|
proc toRPC*(err: HistoryError): HistoryResponseErrorRPC =
|
|
|
|
# TODO: Better error mappings/move to error codes
|
|
|
|
case err.kind:
|
|
|
|
of HistoryErrorKind.BAD_REQUEST:
|
|
|
|
# TODO: Respond aksi with the reason
|
|
|
|
HistoryResponseErrorRPC.INVALID_CURSOR
|
|
|
|
of HistoryErrorKind.SERVICE_UNAVAILABLE:
|
|
|
|
HistoryResponseErrorRPC.SERVICE_UNAVAILABLE
|
|
|
|
else:
|
2022-11-17 19:40:08 +00:00
|
|
|
HistoryResponseErrorRPC.INVALID_CURSOR
|
2022-11-09 17:50:18 +00:00
|
|
|
|
|
|
|
proc toAPI*(err: HistoryResponseErrorRPC): HistoryError =
|
|
|
|
# TODO: Better error mappings/move to error codes
|
|
|
|
case err:
|
|
|
|
of HistoryResponseErrorRPC.INVALID_CURSOR:
|
|
|
|
HistoryError(kind: HistoryErrorKind.BAD_REQUEST, cause: "invalid cursor")
|
|
|
|
of HistoryResponseErrorRPC.SERVICE_UNAVAILABLE:
|
|
|
|
HistoryError(kind: HistoryErrorKind.SERVICE_UNAVAILABLE)
|
|
|
|
else:
|
|
|
|
HistoryError(kind: HistoryErrorKind.UNKNOWN)
|
|
|
|
|
|
|
|
|
|
|
|
proc toRPC*(res: HistoryResult): HistoryResponseRPC =
|
|
|
|
if res.isErr():
|
|
|
|
let error = res.error.toRPC()
|
|
|
|
|
|
|
|
HistoryResponseRPC(error: error)
|
|
|
|
else:
|
|
|
|
let resp = res.get()
|
|
|
|
|
|
|
|
let
|
|
|
|
messages = resp.messages
|
|
|
|
|
|
|
|
pagingInfo = block:
|
|
|
|
if resp.cursor.isNone():
|
2022-11-17 19:40:08 +00:00
|
|
|
none(PagingInfoRPC)
|
2022-11-09 17:50:18 +00:00
|
|
|
else:
|
|
|
|
let
|
2022-11-17 19:40:08 +00:00
|
|
|
pageSize = some(resp.pageSize)
|
|
|
|
cursor = resp.cursor.map(toRPC)
|
|
|
|
direction = if resp.ascending: some(PagingDirectionRPC.FORWARD)
|
|
|
|
else: some(PagingDirectionRPC.BACKWARD)
|
|
|
|
some(PagingInfoRPC(
|
2022-11-09 17:50:18 +00:00
|
|
|
pageSize: pageSize,
|
|
|
|
cursor: cursor,
|
|
|
|
direction: direction
|
2022-11-17 19:40:08 +00:00
|
|
|
))
|
2022-11-09 17:50:18 +00:00
|
|
|
|
|
|
|
error = HistoryResponseErrorRPC.NONE
|
|
|
|
|
|
|
|
HistoryResponseRPC(
|
|
|
|
messages: messages,
|
|
|
|
pagingInfo: pagingInfo,
|
|
|
|
error: error
|
|
|
|
)
|
|
|
|
|
|
|
|
proc toAPI*(rpc: HistoryResponseRPC): HistoryResult =
|
|
|
|
if rpc.error != HistoryResponseErrorRPC.NONE:
|
|
|
|
err(rpc.error.toAPI())
|
|
|
|
else:
|
|
|
|
let
|
|
|
|
messages = rpc.messages
|
|
|
|
|
2022-11-17 19:40:08 +00:00
|
|
|
pageSize = if rpc.pagingInfo.isNone(): 0'u64
|
|
|
|
else: rpc.pagingInfo.get().pageSize.get(0'u64)
|
2022-11-09 17:50:18 +00:00
|
|
|
|
2022-11-17 19:40:08 +00:00
|
|
|
ascending = if rpc.pagingInfo.isNone(): true
|
|
|
|
else: rpc.pagingInfo.get().direction.get(PagingDirectionRPC.FORWARD) == PagingDirectionRPC.FORWARD
|
2022-11-09 17:50:18 +00:00
|
|
|
|
2022-11-17 19:40:08 +00:00
|
|
|
cursor = if rpc.pagingInfo.isNone(): none(HistoryCursor)
|
|
|
|
else: rpc.pagingInfo.get().cursor.map(toAPI)
|
2022-11-09 17:50:18 +00:00
|
|
|
|
|
|
|
ok(HistoryResponse(
|
|
|
|
messages: messages,
|
|
|
|
pageSize: pageSize,
|
|
|
|
ascending: ascending,
|
|
|
|
cursor: cursor
|
|
|
|
))
|