64e0fdc · skrepka · git.iko.soy

git.iko.soy/skrepka

Simplify code and improve type safety: declare handler result sum types, replace -1 sentinel with Maybe, combine double case match, move dedup inside guard

64e0fdciko6 months ago

server.knot+35−29

compare with master

unifiedsplit

@@ -70,6 +70,11 @@ type ForwardEntry = {messageId: MessageIdHex, toServer: ServerName, createdAt: T

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

71type AuthResult = Authorized {pubkey: PubkeyHex} | Unauthorized {}

72type PruneResult = {expiredLocal: [PresenceEntry], peerServers: [Text]}

73+type PollResult = PollUnauthorized {} | PollAuthorized {events: [PollEvent], cursor: Timestamp}

74+type VerifyResult = VerifyFailed {} | VerifyOk {peerServers: [Text]}

75+type SendResult = SendUnauthorized {} | SendRejected {} | SendDone {status: Text, remoteServers: [Text], fromKey: PubkeyHex}

76+type AckResult = AckUnauthorized {} | AckDone {pendingAcks: [AckedEntry], evictedEntries: [AckedEntry]}

77+type LookupResult = LookupUnauthorized {} | LookupDone {foundServer: Text}

75-- ============================================

80-- ============================================

@@ -412,18 +417,25 @@ boundedSmallest = \items n getKey ->

412 let newHeap = union acc.heap [a] in

417 let newHeap = union acc.heap [a] in

413 let newSize = count newHeap in

418 let newSize = count newHeap in

414 if newSize > acc.size

419 if newSize > acc.size

415− then {size: newSize, heap: newHeap, heapMax: if k > acc.heapMax then k else acc.heapMax}

420+ then {size: newSize, heap: newHeap, heapMax: case acc.heapMax of

421+ Nothing {} -> Just {value: k}

422+ Just {value: v} -> if k > v then Just {value: k} else acc.heapMax}

416 else acc

423 else acc

417− else if k < acc.heapMax

424+ else case acc.heapMax of

425+ Nothing {} -> acc

426+ Just {value: maxVal} ->

427+ if k < maxVal

418− then

428+ then

419− let removed = fold (\r x ->

429+ let removed = fold (\r x ->

420− if not r.done && getKey x == acc.heapMax

430+ if not r.done && getKey x == maxVal

421− then {done: True {}, items: r.items}

431+ then {done: True {}, items: r.items}

422− else {done: r.done, items: union r.items [x]}) {done: False {}, items: []} acc.heap in

432+ else {done: r.done, items: union r.items [x]}) {done: False {}, items: []} acc.heap in

423− let newHeap = union removed.items [a] in

433+ let newHeap = union removed.items [a] in

434+ let newMax = fold (\best x -> case best of

435+ Nothing {} -> Just {value: getKey x}

424− let newMax = fold (\best x -> if getKey x > best then getKey x else best) (-1) newHeap in

436+ Just {value: v} -> if getKey x > v then Just {value: getKey x} else best) Nothing {} newHeap in

425− {size: acc.size, heap: newHeap, heapMax: newMax}

437+ {size: acc.size, heap: newHeap, heapMax: newMax}

426− else acc) {size: 0, heap: [], heapMax: -1} items).heap

438+ else acc) {size: 0, heap: [], heapMax: Nothing {}} items).heap

427

439

428evictOldestAckedIds = \items n ->

440evictOldestAckedIds = \items n ->

429 if n <= 0 then items

441 if n <= 0 then items

@@ -774,23 +786,17 @@ serve = \req -> case req of

774 then collectPeerServers updatedPresence (\p -> p.server)

786 then collectPeerServers updatedPresence (\p -> p.server)

775 else []

787 else []

776 yield {pr: pr, verify: VerifyOk {peerServers: peerServers}}

788 yield {pr: pr, verify: VerifyOk {peerServers: peerServers}}

777− fork (do

778− let expiredLocal = case result.verify of

789+ fork (case result.verify of

779− VerifyOk _ -> do

780− p <- result.pr.expiredLocal

781− where not (p.pubkey == pubkey)

782− yield p

783− _ -> result.pr.expiredLocal

784− case result.verify of

785− VerifyOk {peerServers} ->

790+ VerifyOk {peerServers} -> do

786− when federationEnabled

791+ when federationEnabled

787− (sendToEach peerServers (\server -> do

792+ (sendToEach peerServers (\server -> do

788− _ <- fetch (federationScheme ++ server) (RecvGossip {

793+ _ <- fetch (federationScheme ++ server) (RecvGossip {

789− authorization: "Bearer " ++ federationSecret,

794+ authorization: "Bearer " ++ federationSecret,

790− events: [{eventType: "online", pubkey: pubkey, server: serverHostN, timestamp: t, ttl: onlineGossipTtl}], hopsRemaining: 2, fromServer: serverHostN})

795+ events: [{eventType: "online", pubkey: pubkey, server: serverHostN, timestamp: t, ttl: onlineGossipTtl}], hopsRemaining: 2, fromServer: serverHostN})

791− yield {}))

796+ yield {}))

792− _ -> yield {}

797+ broadcastOfflineGossip t result.pr.peerServers (do p <- result.pr.expiredLocal; where not (p.pubkey == pubkey); yield p)

798+ VerifyFailed {} ->

793− broadcastOfflineGossip t result.pr.peerServers expiredLocal)

799+ broadcastOfflineGossip t result.pr.peerServers result.pr.expiredLocal)

794 yield (case result.verify of

800 yield (case result.verify of

795 VerifyFailed _ -> respond {token: "", expiresAt: 0}

801 VerifyFailed _ -> respond {token: "", expiresAt: 0}

796 VerifyOk _ -> respond {token: token, expiresAt: expiry})

802 VerifyOk _ -> respond {token: token, expiresAt: expiry})

@@ -1089,11 +1095,11 @@ serve = \req -> case req of

1089 let originServer = normalizeServerName originServer

1095 let originServer = normalizeServerName originServer

1090 t <- now

1096 t <- now

1091 let authorized = verifyFederationAuth authorization

1097 let authorized = verifyFederationAuth authorization

1092− let dedupedIds = dedupMessageIds messageIds

1093 let validAck = authorized && originServer == serverHostN && not (fromServer == serverHostN)

1098 let validAck = authorized && originServer == serverHostN && not (fromServer == serverHostN)

1094 pruneResult <- atomic do

1099 pruneResult <- atomic do

1095 pr <- maybePrune t

1100 pr <- maybePrune t

1096 when validAck (do

1101 when validAck (do

1102+ let dedupedIds = dedupMessageIds messageIds

1097 forwards <- *forwards

1103 forwards <- *forwards

1098 set *forwards = do

1104 set *forwards = do

1099 f <- forwards

1105 f <- forwards