adc8b7f · skrepka · git.iko.soy

57-- Types

58-- ============================================

59

60−type PollEvent = {id: MessageIdHex, eventType: Text, payload: {encryptedBlob: BlobHex, fromKey: PubkeyHex, timestamp: Timestamp, toKey: PubkeyHex}}

60+type PollEvent = {id: MessageIdHex, eventType: Text, payload: {encryptedBlob: BlobHex, timestamp: Timestamp, toKey: PubkeyHex}}

61

62data GossipEventType = GossipOnline {} | GossipOffline {} | GossipUnknown {}

63

108

109type Challenge = {pubkey: PubkeyHex, challenge: Text, expiresAt: Timestamp}

110type Session = {token: Text, pubkey: PubkeyHex, expiresAt: Timestamp}

111−type Message = {messageId: MessageIdHex, toKey: PubkeyHex, fromKey: PubkeyHex, encryptedBlob: BlobHex, timestamp: Timestamp, originServer: Text, receivedAt: Timestamp}

111+type Message = {messageId: MessageIdHex, toKey: PubkeyHex, encryptedBlob: BlobHex, timestamp: Timestamp, originServer: Text, receivedAt: Timestamp}

112type PresenceEntry = {pubkey: PubkeyHex, server: AnyServerName, expiresAt: Timestamp, timestamp: Timestamp}

113−type ForwardEntry = {messageId: MessageIdHex, toServer: ServerName, createdAt: Timestamp, toKey: PubkeyHex, fromKey: PubkeyHex, encryptedBlob: BlobHex, timestamp: Timestamp}

113+type ForwardEntry = {messageId: MessageIdHex, toServer: ServerName, createdAt: Timestamp, toKey: PubkeyHex, encryptedBlob: BlobHex, timestamp: Timestamp}

114type AckedEntry = {messageId: MessageIdHex, toKey: PubkeyHex, ackedAt: Timestamp, originServer: ServerName}

115data AuthResult = Authorized {pubkey: PubkeyHex} | Unauthorized {}

116−data SendResult = SendFailed {status: MessageStatus} | SendDone {delivery: DeliveryStatus, remoteServers: [ServerName], forwardServers: [ServerName], fromKey: PubkeyHex}

116+data SendResult = SendFailed {status: MessageStatus} | SendDone {delivery: DeliveryStatus, remoteServers: [ServerName], forwardServers: [ServerName]}

117data VerifyResult = VerifyFailed {} | VerifyOk {peerServers: [ServerName]}

118data AckResult = AckUnauthorized {} | AckDone {pendingAcks: [AckedEntry], evictedEntries: [AckedEntry]}

119data PollResult = PollUnauthorized {} | PollOk {events: [PollEvent], cursor: Timestamp}

174 POST {events: [GossipEvent], hopsRemaining: Int, fromServer: ServerName} /gossip headers {authorization: Text}

175 -> {ok: Bool}

176 = RecvGossip

177− POST {toKey: PubkeyHex, fromKey: PubkeyHex, encryptedBlob: BlobHex, timestamp: Timestamp, originServer: ServerName, messageId: MessageIdHex} /forward headers {authorization: Text}

177+ POST {toKey: PubkeyHex, encryptedBlob: BlobHex, timestamp: Timestamp, originServer: ServerName, messageId: MessageIdHex} /forward headers {authorization: Text}

178 -> {ok: Bool}

179 = ForwardMessage

180 POST {messageIds: [MessageIdHex], originServer: ServerName, fromServer: ServerName} /ack headers {authorization: Text}

724 Just {value: f} -> do

725 let rest = do x <- entries; where x.messageId != f.messageId; yield x

726 result <- fetch (federationUrl f.toServer) (ForwardMessage {

727− toKey: f.toKey, fromKey: f.fromKey, encryptedBlob: f.encryptedBlob,

727+ toKey: f.toKey, encryptedBlob: f.encryptedBlob,

728 timestamp: f.timestamp, originServer: serverHostN, messageId: f.messageId,

729 authorization: federationAuth})

730 whenOk result (removeForward f.messageId f.toServer)

750 where m.toKey == target.pubkey

751 where none forwards (\f -> f.messageId == m.messageId && f.toServer == target.server)

752 yield {messageId: m.messageId, toServer: target.server, createdAt: t,

753− toKey: m.toKey, fromKey: m.fromKey, encryptedBlob: m.encryptedBlob, timestamp: m.timestamp}

753+ toKey: m.toKey, encryptedBlob: m.encryptedBlob, timestamp: m.timestamp}

754 let capped = takeN candidates (maxForwardsEntries - count forwards)

755 let updatedForwards = union forwards capped

756 set *forwards = updatedForwards

842 let evts = do

843 m <- limitedMsgs

844 yield {id: m.messageId, eventType: "message",

845− payload: {toKey: m.toKey, fromKey: m.fromKey,

845+ payload: {toKey: m.toKey,

846 encryptedBlob: m.encryptedBlob,

847 timestamp: m.timestamp}}

848 in let lastReceivedAt = fold (\acc m -> max acc m.receivedAt) clampedCursor limitedMsgs

936 pr <- maybePrune t

937 withSessionAuth authorization t

938 (yield {pr: pr, send: SendFailed {status: MsUnauthorized {}}})

939− (\fromKey -> do

939+ (\_ -> do

940 messages <- *messages

941 if countMessagesFor messages to t >= maxMessagesPerRecipient

942 then yield {pr: pr, send: SendFailed {status: MsRejected {}}}

946 let seqTs = nextSeqTs t seqCounter

947 set *seqCounter = seqTs

948 let updatedMessages = union messages

949− [{messageId: msgId, toKey: to, fromKey: fromKey,

949+ [{messageId: msgId, toKey: to,

950 encryptedBlob: encryptedBlob, timestamp: clampedTs, originServer: "", receivedAt: seqTs}]

951 set *messages = updatedMessages

952 let toPresence = do p <- presence; where p.pubkey == to && p.expiresAt > t; yield p

959 else if shouldForward then DsFederated {}

960 else DsQueued {}

961 let updatedForwards = if shouldForward

962− then union forwards (do s <- forwardServers; yield {messageId: msgId, toServer: s, createdAt: t, toKey: to, fromKey: fromKey, encryptedBlob: encryptedBlob, timestamp: clampedTs})

962+ then union forwards (do s <- forwardServers; yield {messageId: msgId, toServer: s, createdAt: t, toKey: to, encryptedBlob: encryptedBlob, timestamp: clampedTs})

963 else forwards

964 set *forwards = updatedForwards

965− yield {pr: pr, send: SendDone {delivery: delivery, remoteServers: remoteServers, forwardServers: forwardServers, fromKey: fromKey}})

965+ yield {pr: pr, send: SendDone {delivery: delivery, remoteServers: remoteServers, forwardServers: forwardServers}})

966 case result.send of

967− SendDone {delivery, remoteServers, forwardServers, fromKey} ->

967+ SendDone {delivery, remoteServers, forwardServers} ->

968 fork (do

969 when (count remoteServers > 0 && federationEnabled) (do

970 sendToEach remoteServers (\server -> do

971 fwdResult <- fetch (federationUrl server) (ForwardMessage {

972− toKey: to, fromKey: fromKey, encryptedBlob: encryptedBlob,

972+ toKey: to, encryptedBlob: encryptedBlob,

973 timestamp: clampedTs, originServer: serverHostN, messageId: msgId,

974 authorization: federationAuth})

975 when (any forwardServers (\s -> s == server))

1075 (forwardQueuedMessages newlyOnlineRemote t))

1076 yield (respond {ok: True {}}))

1077

1078− ForwardMessage {toKey, fromKey, encryptedBlob, timestamp, originServer, messageId, authorization, respond} -> do

1078+ ForwardMessage {toKey, encryptedBlob, timestamp, originServer, messageId, authorization, respond} -> do

1079 t <- now

1080 withFederationAuth authorization t respond (not (isLocalServer originServer)) (do

1081 let clampedTs = clampTimestamp timestamp t

1092 let seqTs = nextSeqTs t seqCounter

1093 set *seqCounter = seqTs

1094 let updatedMessages = union messages

1095− [{messageId: messageId, toKey: toKey, fromKey: fromKey,

1095+ [{messageId: messageId, toKey: toKey,

1096 encryptedBlob: encryptedBlob, timestamp: clampedTs, originServer: originServer, receivedAt: seqTs}]

1097 set *messages = updatedMessages

1098 yield {pr: pr, forward: ForwardStored {}}