257a697 · skrepka · git.iko.soy

git.iko.soy/skrepka

Simplify server.knot: drop getKey dedup from forEach/mapEach, remove unused correlationId from federation handlers, misc cleanups

257a697iko5 months ago

server.knot+31−36

compare with master

unifiedsplit

@@ -440,7 +440,6 @@ route Api = AuthApi | ClientApi | FederationApi | FederationVerifyApi | Federati

440-- Generic helpers

441-- ============================================

442

443−id = \x -> x

444filter = \xs pred -> do x <- xs; where pred x; yield x

443filter = \xs pred -> do x <- xs; where pred x; yield x

445removeWhere = \xs pred -> filter xs (\x -> not (pred x))

444removeWhere = \xs pred -> filter xs (\x -> not (pred x))

446pluck = \xs f -> do x <- xs; yield (f x)

445pluck = \xs f -> do x <- xs; yield (f x)

@@ -533,19 +532,17 @@ isSendSuccess = \s -> case s of

533 MsDuplicate {} -> True {}

532 MsDuplicate {} -> True {}

534 _ -> False {}

533 _ -> False {}

535

534

536−-- Sequence an IO action over each unique item (dedup by getKey).

535+-- Sequence an IO action over each item, in order.

537−forEach = \items getKey action -> case headOf items of

536+forEach = \items action -> case headOf items of

538 Nothing {} -> yield {}

537 Nothing {} -> yield {}

539− Just {value: x} -> do

538+ Just {value: x} -> do action x; forEach (drop 1 items) action

540− action x

541− forEach (filter items (\y -> getKey y != getKey x)) getKey action

542

539

543-- Like forEach, but collects each action's result into a list.

540-- Like forEach, but collects each action's result into a list.

544−mapEach = \items getKey action -> case headOf items of

541+mapEach = \items action -> case headOf items of

545 Nothing {} -> yield []

542 Nothing {} -> yield []

546 Just {value: x} -> do

543 Just {value: x} -> do

547 r <- action x

544 r <- action x

548− rest <- mapEach (filter items (\y -> getKey y != getKey x)) getKey action

545+ rest <- mapEach (drop 1 items) action

549 yield (union [r] rest)

546 yield (union [r] rest)

550

547

551-- Hex tokens: one random hex char per recursive call.

548-- Hex tokens: one random hex char per recursive call.

@@ -890,7 +887,7 @@ cancelOne = \mid to ownerPred t -> atomic do

890 when owns (do _ <- applyCancel msgs matches to mid t; yield {})

887 when owns (do _ <- applyCancel msgs matches to mid t; yield {})

891 yield owns

888 yield owns

892

889

893−sendBatchedGossip = \peers events hops -> forEach peers id (\server -> do

890+sendBatchedGossip = \peers events hops -> forEach peers (\server -> do

894 t <- now

891 t <- now

895 failures <- *forwardFailures

892 failures <- *forwardFailures

896 when (shouldRetryServer server t failures) (do

893 when (shouldRetryServer server t failures) (do

@@ -917,8 +914,8 @@ retryPendingForwards = do

917 fwds <- *forwards

914 fwds <- *forwards

918 failures <- *forwardFailures

915 failures <- *forwardFailures

919 blocked <- *blockedPeers

916 blocked <- *blockedPeers

920− forEach (filter (collectPeers fwds (\f -> f.toServer)) (\s -> shouldRetryServer s t failures && not (elem blocked s))) id (\server ->

917+ forEach (filter (collectPeers fwds (\f -> f.toServer)) (\s -> shouldRetryServer s t failures && not (elem blocked s))) (\server ->

921− forEach (takeRelation maxBatchSize (filter fwds (\f -> f.toServer == server))) (\f -> f.messageId) (\f -> do

918+ forEach (takeRelation maxBatchSize (filter fwds (\f -> f.toServer == server))) (\f -> do

922 t2 <- now

919 t2 <- now

923 auth <- generateFederationAuth ("forward:" ++ f.messageId) t2

920 auth <- generateFederationAuth ("forward:" ++ f.messageId) t2

924 result <- fetch (federationUrl server) (ForwardMessage {

921 result <- fetch (federationUrl server) (ForwardMessage {

@@ -940,7 +937,7 @@ retryPendingForwards = do

940 else x)))

937 else x)))

941

938

942sendAcksAndClean = \pendingAcks ->

939sendAcksAndClean = \pendingAcks ->

943− forEach (collectPeers pendingAcks (\a -> a.originServer)) id (\server -> do

940+ forEach (collectPeers pendingAcks (\a -> a.originServer)) (\server -> do

944 let mids = mapWhere pendingAcks (\a -> a.originServer == server) (\a -> a.messageId)

941 let mids = mapWhere pendingAcks (\a -> a.originServer == server) (\a -> a.messageId)

945 t <- now

942 t <- now

946 auth <- generateFederationAuth "ack" t

943 auth <- generateFederationAuth "ack" t

@@ -979,7 +976,6 @@ pruneAndRetry = \t -> do

979 when (t - lastRefresh >= presenceRefreshInterval) (do

976 when (t - lastRefresh >= presenceRefreshInterval) (do

980 atomic do set *lastPresenceRefresh = t

977 atomic do set *lastPresenceRefresh = t

981 refreshLocalPresence t))

978 refreshLocalPresence t))

982− yield {}

983

979

984refreshLocalPresence = \t -> do

980refreshLocalPresence = \t -> do

985 refreshState <- atomic do

981 refreshState <- atomic do

@@ -1213,7 +1209,7 @@ sendMessageCore = \senderKey to encryptedBlob clampedTs effMsgId expiresInMs msg

1213 yield {status: if any toPresence (\p -> isLocalServer p.server) then MsDelivered {} else if forwardsEnqueued then MsFederated {} else MsQueued {}, remoteServers: remoteServers}

1209 yield {status: if any toPresence (\p -> isLocalServer p.server) then MsDelivered {} else if forwardsEnqueued then MsFederated {} else MsQueued {}, remoteServers: remoteServers}

1214

1210

1215forkForwardsTo = \effMsgId to encryptedBlob clampedTs servers ->

1211forkForwardsTo = \effMsgId to encryptedBlob clampedTs servers ->

1216− forEach servers id (\server -> do

1212+ forEach servers (\server -> do

1217 fwds <- *forwards

1213 fwds <- *forwards

1218 let same = \x -> x.messageId == effMsgId && x.toServer == server

1214 let same = \x -> x.messageId == effMsgId && x.toServer == server

1219 case findFirst fwds same of

1215 case findFirst fwds same of

@@ -1329,7 +1325,7 @@ handleCancelMessage = \messageId to authorization clientIp respond -> do

1329 yield (respond {ok: True {}, authorized: True {}, cancelled: result.cancelled, error: ""}))

1325 yield (respond {ok: True {}, authorized: True {}, cancelled: result.cancelled, error: ""}))

1330

1326

1331sendCancelToEach = \messageId to servers ->

1327sendCancelToEach = \messageId to servers ->

1332− forEach servers id (\server -> do

1328+ forEach servers (\server -> do

1333 t <- now

1329 t <- now

1334 auth <- generateFederationAuth ("cancel:" ++ messageId) t

1330 auth <- generateFederationAuth ("cancel:" ++ messageId) t

1335 result <- fetch (federationUrl server) (FederationCancel {

1331 result <- fetch (federationUrl server) (FederationCancel {

@@ -1344,7 +1340,7 @@ handleCancelBatch = \cancels authorization clientIp respond -> do

1344 let mkErr = \e -> {results: [], authorized: False {}, error: if e == "draining" then "" else e}

1340 let mkErr = \e -> {results: [], authorized: False {}, error: if e == "draining" then "" else e}

1345 gateClientWrite authorization clientIp t respond mkErr

1341 gateClientWrite authorization clientIp t respond mkErr

1346 {results: [], authorized: True {}, error: "rate_limited"} (\senderKey -> do

1342 {results: [], authorized: True {}, error: "rate_limited"} (\senderKey -> do

1347− results <- mapEach (takeRelation maxBatchSize cancels) (\e -> e.messageId) (\e -> do

1343+ results <- mapEach (takeRelation maxBatchSize cancels) (\e -> do

1348 r <- cancelOne e.messageId e.to (\m -> m.originServer == "" && m.senderKey == senderKey) t

1344 r <- cancelOne e.messageId e.to (\m -> m.originServer == "" && m.senderKey == senderKey) t

1349 yield {messageId: e.messageId, cancelled: r})

1345 yield {messageId: e.messageId, cancelled: r})

1350 yield (respond {results: results, authorized: True {}, error: ""}))

1346 yield (respond {results: results, authorized: True {}, error: ""}))

@@ -1353,7 +1349,7 @@ handleSendBatch = \messages authorization clientIp respond -> do

1353 t <- now

1349 t <- now

1354 let mkErr = \_ -> {results: [], authorized: False {}, retryAfterMs: 0}

1350 let mkErr = \_ -> {results: [], authorized: False {}, retryAfterMs: 0}

1355 gateAuth (True {}) authorization clientIp t respond mkErr (\senderKey -> do

1351 gateAuth (True {}) authorization clientIp t respond mkErr (\senderKey -> do

1356− results <- mapEach (takeRelation maxBatchSize messages) id (\m -> do

1352+ results <- mapEach (takeRelation maxBatchSize messages) (\m -> do

1357 effMsgId <- resolveMessageId m.messageId

1353 effMsgId <- resolveMessageId m.messageId

1358 let clampedTs = clampTimestamp m.timestamp t

1354 let clampedTs = clampTimestamp m.timestamp t

1359 r <- if t - m.timestamp > messageMaxAge

1355 r <- if t - m.timestamp > messageMaxAge

@@ -1385,7 +1381,7 @@ handleVerifyToken = \token scope clientIp respond -> do

1385handleFederationPubkey = \respond -> do

1381handleFederationPubkey = \respond -> do

1386 yield (respond {pubkey: serverFederationPublicKeyHex, ok: serverFederationPublicKeyHex != ""})

1382 yield (respond {pubkey: serverFederationPublicKeyHex, ok: serverFederationPublicKeyHex != ""})

1387

1383

1388−handleRecvGossip = \events hopsRemaining fromServer requestTimestamp correlationId authorization respond -> do

1384+handleRecvGossip = \events hopsRemaining fromServer requestTimestamp authorization respond -> do

1389 t <- now

1385 t <- now

1390 withFederationAuth authorization t respond fromServer "gossip" requestTimestamp (clamp 0 maxGossipHops hopsRemaining >= 1 && not (isLocalServer fromServer) && count events <= maxGossipEvents) (do

1386 withFederationAuth authorization t respond fromServer "gossip" requestTimestamp (clamp 0 maxGossipHops hopsRemaining >= 1 && not (isLocalServer fromServer) && count events <= maxGossipEvents) (do

1391 newlyOnline <- atomic do

1387 newlyOnline <- atomic do

@@ -1402,7 +1398,7 @@ handleRecvGossip = \events hopsRemaining fromServer requestTimestamp correlation

1402 let offline = mapWhere validEvents isOffline (\v -> {pubkey: v.pubkey, server: v.server, timestamp: v.timestamp})

1398 let offline = mapWhere validEvents isOffline (\v -> {pubkey: v.pubkey, server: v.server, timestamp: v.timestamp})

1403 set *presence = capList (mergePresence (filter pres (\p -> none offline (\o -> o.pubkey == p.pubkey && o.server == p.server && o.timestamp > p.timestamp))) online) maxPresenceEntries (\p -> p.expiresAt)

1399 set *presence = capList (mergePresence (filter pres (\p -> none offline (\o -> o.pubkey == p.pubkey && o.server == p.server && o.timestamp > p.timestamp))) online) maxPresenceEntries (\p -> p.expiresAt)

1404 yield (mapWhere online (\e -> none pres (\p -> p.pubkey == e.pubkey && p.server == e.server && p.expiresAt >= e.expiresAt)) (\e -> {pubkey: e.pubkey, server: e.server}))

1400 yield (mapWhere online (\e -> none pres (\p -> p.pubkey == e.pubkey && p.server == e.server && p.expiresAt >= e.expiresAt)) (\e -> {pubkey: e.pubkey, server: e.server}))

1405− fork (forEach newlyOnline (\tgt -> tgt.pubkey ++ "|" ++ tgt.server) (\tgt -> forwardQueuedToServer tgt.pubkey tgt.server t))

1401+ fork (forEach newlyOnline (\tgt -> forwardQueuedToServer tgt.pubkey tgt.server t))

1406 yield (respond {ok: True {}, error: "", retryAfterMs: 0}))

1402 yield (respond {ok: True {}, error: "", retryAfterMs: 0}))

1407

1403

1408-- Store a federated/forwarded message into the local mailbox. Caller wraps in `atomic`.

1404-- Store a federated/forwarded message into the local mailbox. Caller wraps in `atomic`.

@@ -1429,7 +1425,7 @@ storeFederated = \toKey encryptedBlob timestamp originServer messageId expiresAt

1429 set *pollWakeup = seqTs

1425 set *pollWakeup = seqTs

1430 yield ""

1426 yield ""

1431

1427

1432−handleForwardMessage = \toKey encryptedBlob timestamp originServer messageId fromServer requestTimestamp correlationId expiresAt priority authorization respond -> do

1428+handleForwardMessage = \toKey encryptedBlob timestamp originServer messageId fromServer requestTimestamp expiresAt priority authorization respond -> do

1433 t <- now

1429 t <- now

1434 withFederationAuth authorization t respond fromServer ("forward:" ++ messageId) requestTimestamp (not (isLocalServer originServer) && not (isLocalServer fromServer)) (do

1430 withFederationAuth authorization t respond fromServer ("forward:" ++ messageId) requestTimestamp (not (isLocalServer originServer) && not (isLocalServer fromServer)) (do

1435 if t - timestamp > messageMaxAge

1431 if t - timestamp > messageMaxAge

@@ -1438,7 +1434,7 @@ handleForwardMessage = \toKey encryptedBlob timestamp originServer messageId fro

1438 result <- atomic (storeFederated toKey encryptedBlob timestamp originServer messageId expiresAt priority (True {}) t)

1434 result <- atomic (storeFederated toKey encryptedBlob timestamp originServer messageId expiresAt priority (True {}) t)

1439 yield (respond {ok: result == "", error: result, retryAfterMs: 0}))

1435 yield (respond {ok: result == "", error: result, retryAfterMs: 0}))

1440

1436

1441−handleFederationAck = \messageIds originServer fromServer requestTimestamp correlationId authorization respond -> do

1437+handleFederationAck = \messageIds originServer fromServer requestTimestamp authorization respond -> do

1442 t <- now

1438 t <- now

1443 let ackRespond = \r -> respond {ok: r.ok, error: r.error, ackedCount: 0, results: [], retryAfterMs: r.retryAfterMs}

1439 let ackRespond = \r -> respond {ok: r.ok, error: r.error, ackedCount: 0, results: [], retryAfterMs: r.retryAfterMs}

1444 withFederationAuth authorization t ackRespond fromServer "ack" requestTimestamp (isLocalServer originServer && not (isLocalServer fromServer)) (do

1440 withFederationAuth authorization t ackRespond fromServer "ack" requestTimestamp (isLocalServer originServer && not (isLocalServer fromServer)) (do

@@ -1461,27 +1457,27 @@ handleFederationAck = \messageIds originServer fromServer requestTimestamp corre

1461 yield {ackedCount: count removed, results: pluck dedupedIds (\mid -> {messageId: mid, found: any removed (\f -> f.messageId == mid)})}

1457 yield {ackedCount: count removed, results: pluck dedupedIds (\mid -> {messageId: mid, found: any removed (\f -> f.messageId == mid)})}

1462 yield (respond {ok: True {}, error: "", ackedCount: result.ackedCount, results: result.results, retryAfterMs: 0}))

1458 yield (respond {ok: True {}, error: "", ackedCount: result.ackedCount, results: result.results, retryAfterMs: 0}))

1463

1459

1464−handleFederationCancel = \messageId toKey fromServer requestTimestamp correlationId authorization respond -> do

1460+handleFederationCancel = \messageId toKey fromServer requestTimestamp authorization respond -> do

1465 t <- now

1461 t <- now

1466 let cancelRespond = \r -> respond {ok: r.ok, error: r.error, cancelled: False {}, retryAfterMs: r.retryAfterMs}

1462 let cancelRespond = \r -> respond {ok: r.ok, error: r.error, cancelled: False {}, retryAfterMs: r.retryAfterMs}

1467 withFederationAuth authorization t cancelRespond fromServer ("cancel:" ++ messageId) requestTimestamp (not (isLocalServer fromServer)) (do

1463 withFederationAuth authorization t cancelRespond fromServer ("cancel:" ++ messageId) requestTimestamp (not (isLocalServer fromServer)) (do

1468 cancelled <- cancelOne messageId toKey (\m -> m.originServer == fromServer) t

1464 cancelled <- cancelOne messageId toKey (\m -> m.originServer == fromServer) t

1469 yield (respond {ok: True {}, error: "", cancelled: cancelled, retryAfterMs: 0}))

1465 yield (respond {ok: True {}, error: "", cancelled: cancelled, retryAfterMs: 0}))

1470

1466

1471−handleFederationBatchCancel = \cancels fromServer requestTimestamp correlationId authorization respond -> do

1467+handleFederationBatchCancel = \cancels fromServer requestTimestamp authorization respond -> do

1472 t <- now

1468 t <- now

1473 let batchRespond = \r -> respond {ok: r.ok, error: r.error, results: [], retryAfterMs: r.retryAfterMs}

1469 let batchRespond = \r -> respond {ok: r.ok, error: r.error, results: [], retryAfterMs: r.retryAfterMs}

1474 withFederationAuth authorization t batchRespond fromServer "cancel-batch" requestTimestamp (not (isLocalServer fromServer) && count cancels <= maxBatchSize) (do

1470 withFederationAuth authorization t batchRespond fromServer "cancel-batch" requestTimestamp (not (isLocalServer fromServer) && count cancels <= maxBatchSize) (do

1475− results <- mapEach (takeRelation maxBatchSize cancels) (\e -> e.messageId) (\e -> do

1471+ results <- mapEach (takeRelation maxBatchSize cancels) (\e -> do

1476 cancelled <- cancelOne e.messageId e.toKey (\m -> m.originServer == fromServer) t

1472 cancelled <- cancelOne e.messageId e.toKey (\m -> m.originServer == fromServer) t

1477 yield {messageId: e.messageId, cancelled: cancelled})

1473 yield {messageId: e.messageId, cancelled: cancelled})

1478 yield (respond {ok: True {}, error: "", results: results, retryAfterMs: 0}))

1474 yield (respond {ok: True {}, error: "", results: results, retryAfterMs: 0}))

1479

1475

1480−handleFederationBatchForward = \forwards fromServer requestTimestamp correlationId authorization respond -> do

1476+handleFederationBatchForward = \forwards fromServer requestTimestamp authorization respond -> do

1481 t <- now

1477 t <- now

1482 let batchRespond = \r -> respond {ok: r.ok, error: r.error, results: [], retryAfterMs: r.retryAfterMs}

1478 let batchRespond = \r -> respond {ok: r.ok, error: r.error, results: [], retryAfterMs: r.retryAfterMs}

1483 withFederationAuth authorization t batchRespond fromServer "forward-batch" requestTimestamp (not (isLocalServer fromServer) && count forwards <= maxBatchSize) (do

1479 withFederationAuth authorization t batchRespond fromServer "forward-batch" requestTimestamp (not (isLocalServer fromServer) && count forwards <= maxBatchSize) (do

1484− results <- mapEach (takeRelation maxBatchSize forwards) (\e -> e.messageId) (\e -> do

1480+ results <- mapEach (takeRelation maxBatchSize forwards) (\e -> do

1485 ok <- if isLocalServer e.originServer || t - e.timestamp > messageMaxAge then yield False

1481 ok <- if isLocalServer e.originServer || t - e.timestamp > messageMaxAge then yield False

1486 else do

1482 else do

1487 result <- atomic (storeFederated e.toKey e.encryptedBlob e.timestamp e.originServer e.messageId e.expiresAt e.priority (False {}) t)

1483 result <- atomic (storeFederated e.toKey e.encryptedBlob e.timestamp e.originServer e.messageId e.expiresAt e.priority (False {}) t)

@@ -1489,7 +1485,7 @@ handleFederationBatchForward = \forwards fromServer requestTimestamp correlation

1489 yield {messageId: e.messageId, ok: ok})

1485 yield {messageId: e.messageId, ok: ok})

1490 yield (respond {ok: True {}, error: "", results: results, retryAfterMs: 0}))

1486 yield (respond {ok: True {}, error: "", results: results, retryAfterMs: 0}))

1491

1487

1492−handleFederationDeliveryReceipt = \messageIds toKeys fromServer requestTimestamp correlationId authorization respond -> do

1488+handleFederationDeliveryReceipt = \messageIds toKeys fromServer requestTimestamp authorization respond -> do

1493 t <- now

1489 t <- now

1494 let receiptRespond = \r -> respond {ok: r.ok, error: r.error, receivedCount: 0, retryAfterMs: r.retryAfterMs}

1490 let receiptRespond = \r -> respond {ok: r.ok, error: r.error, receivedCount: 0, retryAfterMs: r.retryAfterMs}

1495 withFederationAuth authorization t receiptRespond fromServer "delivery-receipt" requestTimestamp (not (isLocalServer fromServer) && count messageIds <= maxMessageIds) (do

1491 withFederationAuth authorization t receiptRespond fromServer "delivery-receipt" requestTimestamp (not (isLocalServer fromServer) && count messageIds <= maxMessageIds) (do

@@ -1648,8 +1644,7 @@ handleAdminRevokeIp = \ip authorization respond -> withMaintAuth authorization

1648 let same = \s -> s.ip == ip

1644 let same = \s -> s.ip == ip

1649 set *sessions = removeWhere ses same

1645 set *sessions = removeWhere ses same

1650 yield (mapWhere ses same (\s -> s.pubkey))

1646 yield (mapWhere ses same (\s -> s.pubkey))

1651− let uniqueKeys = unique keys

1652− yield (respond {ok: ip != "", revokedCount: count keys, affectedKeys: count uniqueKeys}))

1647+ yield (respond {ok: ip != "", revokedCount: count keys, affectedKeys: count (unique keys)}))

1653

1648

1654handleAdminListAllSessions = \limit authorization respond -> withMaintAuth authorization

1649handleAdminListAllSessions = \limit authorization respond -> withMaintAuth authorization

1655 (yield (respond {sessions: [], ok: False {}, total: 0}))

1650 (yield (respond {sessions: [], ok: False {}, total: 0}))

@@ -1816,13 +1811,13 @@ serve = \req -> case req of

1816 CancelBatch {cancels, authorization, clientIp, respond} -> handleCancelBatch cancels authorization clientIp respond

1811 CancelBatch {cancels, authorization, clientIp, respond} -> handleCancelBatch cancels authorization clientIp respond

1817 LookupPresence {pubkey, authorization, clientIp, respond} -> handleLookupPresence pubkey authorization clientIp respond

1812 LookupPresence {pubkey, authorization, clientIp, respond} -> handleLookupPresence pubkey authorization clientIp respond

1818 BatchLookupPresence {pubkeys, authorization, clientIp, respond} -> handleBatchLookupPresence pubkeys authorization clientIp respond

1813 BatchLookupPresence {pubkeys, authorization, clientIp, respond} -> handleBatchLookupPresence pubkeys authorization clientIp respond

1819− RecvGossip {events, hopsRemaining, fromServer, requestTimestamp, correlationId, protocolVersion, authorization, respond} -> handleRecvGossip events hopsRemaining fromServer requestTimestamp correlationId authorization respond

1814+ RecvGossip {events, hopsRemaining, fromServer, requestTimestamp, authorization, respond} -> handleRecvGossip events hopsRemaining fromServer requestTimestamp authorization respond

1820− ForwardMessage {toKey, encryptedBlob, timestamp, originServer, messageId, fromServer, requestTimestamp, correlationId, expiresAt, priority, protocolVersion, authorization, respond} -> handleForwardMessage toKey encryptedBlob timestamp originServer messageId fromServer requestTimestamp correlationId expiresAt priority authorization respond

1815+ ForwardMessage {toKey, encryptedBlob, timestamp, originServer, messageId, fromServer, requestTimestamp, expiresAt, priority, authorization, respond} -> handleForwardMessage toKey encryptedBlob timestamp originServer messageId fromServer requestTimestamp expiresAt priority authorization respond

1821− FederationAck {messageIds, originServer, fromServer, requestTimestamp, correlationId, protocolVersion, authorization, respond} -> handleFederationAck messageIds originServer fromServer requestTimestamp correlationId authorization respond

1816+ FederationAck {messageIds, originServer, fromServer, requestTimestamp, authorization, respond} -> handleFederationAck messageIds originServer fromServer requestTimestamp authorization respond

1822− FederationCancel {messageId, toKey, fromServer, requestTimestamp, correlationId, protocolVersion, authorization, respond} -> handleFederationCancel messageId toKey fromServer requestTimestamp correlationId authorization respond

1817+ FederationCancel {messageId, toKey, fromServer, requestTimestamp, authorization, respond} -> handleFederationCancel messageId toKey fromServer requestTimestamp authorization respond

1823− FederationBatchCancel {cancels, fromServer, requestTimestamp, correlationId, protocolVersion, authorization, respond} -> handleFederationBatchCancel cancels fromServer requestTimestamp correlationId authorization respond

1818+ FederationBatchCancel {cancels, fromServer, requestTimestamp, authorization, respond} -> handleFederationBatchCancel cancels fromServer requestTimestamp authorization respond

1824− FederationBatchForward {forwards, fromServer, requestTimestamp, correlationId, protocolVersion, authorization, respond} -> handleFederationBatchForward forwards fromServer requestTimestamp correlationId authorization respond

1819+ FederationBatchForward {forwards, fromServer, requestTimestamp, authorization, respond} -> handleFederationBatchForward forwards fromServer requestTimestamp authorization respond

1825− FederationDeliveryReceipt {messageIds, toKeys, fromServer, requestTimestamp, correlationId, protocolVersion, authorization, respond} -> handleFederationDeliveryReceipt messageIds toKeys fromServer requestTimestamp correlationId authorization respond

1820+ FederationDeliveryReceipt {messageIds, toKeys, fromServer, requestTimestamp, authorization, respond} -> handleFederationDeliveryReceipt messageIds toKeys fromServer requestTimestamp authorization respond

1826 VerifyToken {token, scope, clientIp, respond} -> handleVerifyToken token scope clientIp respond

1821 VerifyToken {token, scope, clientIp, respond} -> handleVerifyToken token scope clientIp respond

1827 FederationPubkey {respond} -> handleFederationPubkey respond

1822 FederationPubkey {respond} -> handleFederationPubkey respond

1828 Prune {authorization, respond} -> handlePrune authorization respond

1823 Prune {authorization, respond} -> handlePrune authorization respond