@axpecter/lync 2.3.2 → 3.0.0

package/runtime/Handles.luau

@@ -0,0 +1,114 @@
+--!strict
+--!optimize 2
+-- What a handle is bound to, and what it was asked to do before there was anything to bind it to.
+
+local Types = require (script.Parent.Parent.Types)
+
+local Handles = {}
+
+-- Types ---------------------------------------------------------------
+
+-- What a handle knows about where it ended up, which is nothing until it is told.
+export type Live = {
+    space: string?,
+    name: string?,
+    id: number?,
+    def: any,
+    session: any,
+    isServer: boolean,
+    waiting: { (any) -> () },
+}
+
+-- An attachment made before there was anything to attach to.
+export type Waiting = {
+    connected: boolean,
+    held: Types.Connection?,
+}
+
+-- Private -------------------------------------------------------------
+
+--[[
+    A connection to something that does not exist yet, ended the same way as one that does.
+
+    A metatable rather than a closure per attachment, because a handle may be listened to as often
+    as a caller likes and the pair of fields is the whole of what one of these is.
+]]
+local Attached = {}
+Attached.__index = Attached
+
+function Attached.disconnect (self: Waiting)
+    self.connected = false
+
+    local held = self.held
+    if held ~= nil then held:disconnect () end
+end
+
+-- Public --------------------------------------------------------------
+
+--[[
+    A fresh binding, which every handle is made holding one of.
+
+    Made by the handle rather than here, and typed here, because what fills it is the calls below
+    and nothing a caller can reach.
+]]
+function Handles.live (): Live
+    return {
+        space = nil,
+        name = nil,
+        id = nil,
+        def = nil,
+        session = nil,
+        isServer = false,
+        waiting = {},
+    }
+end
+
+--[[
+    Something to do to this handle once there is a session to do it with.
+
+    Run now where there is one and held where there is not, so a caller who attaches before a
+    namespace opens and one who attaches after are asking for the same thing and get it.
+]]
+function Handles.waiting (of: Live, run: (any) -> ())
+    local session = of.session
+    if session ~= nil then
+        run (session)
+        return
+    end
+
+    table.insert (of.waiting, run)
+end
+
+-- A listener attached whenever the caller liked, and the connection that ends it either way.
+function Handles.later (of: Live, bind: (any) -> Types.Connection): Types.Connection
+    local session = of.session
+    if session ~= nil then return bind (session) end
+
+    local held: Waiting = setmetatable ({ connected = true, held = nil }, Attached) :: any
+    table.insert (of.waiting, function (opened: any)
+        if not held.connected then return end
+        held.held = bind (opened)
+    end)
+
+    return (held :: any) :: Types.Connection
+end
+
+--[[
+    A handle, bound to what its namespace compiled it into, and everything it was owed since.
+
+    The binding is written before anything waiting runs, because what waits is listeners and
+    responders and both of them reach back through the handle for the id they attach under.
+]]
+function Handles.opened (of: Live, def: any, session: any, isServer: boolean)
+    of.id = def.id
+    of.def = def
+    of.session = session
+    of.isServer = isServer
+
+    for _, run in of.waiting do
+        run (session)
+    end
+    table.clear (of.waiting)
+end
+
+return table.freeze (Handles)

package/runtime/Handshake.luau

@@ -0,0 +1,90 @@
+--!strict
+--!optimize 2
+-- The two messages the handshake lane carries, and the judgement each one earns.
+
+local Catalog = require (script.Parent.Parent.kernel.Catalog)
+local Log = require (script.Parent.Parent.kernel.Log)
+local Protocol = require (script.Parent.Parent.wire.Protocol)
+local Wide = require (script.Parent.Parent.kernel.Wide)
+
+local Handshake = {}
+
+-- Constants -----------------------------------------------------------
+
+-- What each message weighs, which is the whole of what tells the two apart, and where a field sits.
+const HELLO = Protocol.HELLO_BYTES
+const VERDICT = Protocol.VERDICT_BYTES
+const FIELD = Protocol.VERDICT_FIELD
+
+-- Private -------------------------------------------------------------
+
+--[[
+    One code for both sides. A hello reaching a client and a verdict reaching a server are one event
+    told from two ends, and neither end has anything to say about the bytes past that.
+]]
+local function unspoken ()
+    local facts: Log.Facts = { code = Catalog.HELLO }
+    Log.warn (Log.line (Catalog.HELLO, facts), facts)
+end
+
+-- Two builds that cannot speak to one another, as the one sentence both machines read it as.
+local function mismatch (ours: Wide.Word, theirs: Wide.Word): (string, Log.Facts)
+    local facts: Log.Facts =
+        { code = Catalog.MISMATCH, ours = Wide.text (ours), theirs = Wide.text (theirs) }
+    return Log.line (Catalog.MISMATCH, facts), facts
+end
+
+-- Public --------------------------------------------------------------
+
+function Handshake.hello (ours: Wide.Word): buffer
+    local out = buffer.create (HELLO)
+    Wide.write (out, 0, ours)
+    return out
+end
+
+-- The verdict a hello has earned, and whether the machine that sent it may be spoken to.
+function Handshake.verdict (ours: Wide.Word, epoch: number, bytes: buffer): (buffer?, boolean)
+    if buffer.len (bytes) ~= HELLO then
+        unspoken ()
+        return nil, false
+    end
+
+    local theirs = Wide.read (bytes, 0)
+    local out = buffer.create (VERDICT)
+
+    if Wide.same (theirs, ours) then
+        buffer.writeu8 (out, 0, Protocol.VERDICT_ACCEPT)
+        buffer.writef64 (out, FIELD, epoch)
+        return out, true
+    end
+
+    Log.warn (mismatch (ours, theirs))
+
+    buffer.writeu8 (out, 0, Protocol.VERDICT_REJECT)
+    Wide.write (out, FIELD, ours)
+    return out, false
+end
+
+--[[
+    The namespace epoch, or nothing where the lane carried no verdict yet. A refusal is the third
+    way out and never comes back: two builds that disagree cannot be made to agree at run time, so
+    it raises where a message nobody can read only warns.
+]]
+function Handshake.judged (ours: Wide.Word, bytes: buffer): number?
+    if buffer.len (bytes) ~= VERDICT then
+        unspoken ()
+        return nil
+    end
+
+    local said = buffer.readu8 (bytes, 0)
+    if said == Protocol.VERDICT_ACCEPT then return buffer.readf64 (bytes, FIELD) end
+
+    if said ~= Protocol.VERDICT_REJECT then
+        unspoken ()
+        return nil
+    end
+
+    return Log.error (mismatch (ours, Wide.read (bytes, FIELD)))
+end
+
+return table.freeze (Handshake)

package/runtime/Pending.luau

@@ -0,0 +1,196 @@
+--!strict
+--!optimize 2
+-- Requests in flight: the id each waits under, the deadline it waits to, and every way out.
+
+local Heap = require (script.Parent.Parent.kernel.Heap)
+local Log = require (script.Parent.Parent.kernel.Log)
+local Protocol = require (script.Parent.Parent.wire.Protocol)
+local Types = require (script.Parent.Parent.Types)
+
+local Pending = {}
+Pending.__index = Pending
+
+-- Constants -----------------------------------------------------------
+
+-- Twice the live ceiling, so the walk for a free id always has somewhere to go and cannot fail.
+const SPACE = Protocol.QUERY_CAP * 2
+
+-- Types ---------------------------------------------------------------
+
+--[[
+    One request nobody has answered. Its deadline is here as well as in the heap, since a heap entry
+    outlives its request: an id comes round a lap later and the entry popping then belongs to the
+    one before it.
+]]
+type Entry = {
+    read definition: string,
+    read player: Player?,
+    read opened: number,
+    read at: number,
+    read complete: Types.Outcome<any>,
+}
+
+export type Pending = {
+    read open: (
+        self: Pending,
+        now: number,
+        definition: string,
+        player: Player?,
+        timeout: number?,
+        complete: Types.Outcome<any>
+    ) -> number,
+    read answer: (self: Pending, id: number, value: any) -> boolean,
+    read fail: (self: Pending, id: number, code: Types.OutcomeCode, now: number) -> boolean,
+    read sweep: (self: Pending, now: number) -> (),
+    read rejectFor: (self: Pending, player: Player, now: number) -> (),
+    read rejectAll: (self: Pending, now: number) -> (),
+}
+
+type Self = {
+    namespace: string,
+    live: { [number]: Entry },
+    count: number,
+    next: number,
+    deadlines: Heap.Heap,
+}
+
+-- Private -------------------------------------------------------------
+
+-- A request lifted out of the live set. Every way out goes through here, so one resolves once.
+local function taken (self: Self, id: number): Entry?
+    local entry = self.live[id]
+    if entry == nil then return nil end
+
+    self.live[id] = nil
+    self.count -= 1
+    return entry
+end
+
+-- Public --------------------------------------------------------------
+
+function Pending.new (namespace: string): Pending
+    local self: Self = {
+        namespace = namespace,
+        live = {},
+        count = 0,
+        next = 0,
+        deadlines = Heap.new (),
+    }
+    return (setmetatable (self, Pending) :: any) :: Pending
+end
+
+-- A request, under the first id nothing is waiting on.
+function Pending.open (
+    self: Self,
+    now: number,
+    definition: string,
+    player: Player?,
+    timeout: number?,
+    complete: Types.Outcome<any>
+): number
+    if self.count == Protocol.QUERY_CAP then
+        Log.refuse (
+            `{self.namespace} has {Protocol.QUERY_CAP} requests in flight, which is the ceiling`
+        )
+    end
+
+    local id = self.next
+    while self.live[id] ~= nil do
+        id = (id + 1) % SPACE
+    end
+    self.next = (id + 1) % SPACE
+
+    local at = now + (timeout or Protocol.QUERY_TIMEOUT)
+    self.live[id] = {
+        definition = definition,
+        player = player,
+        opened = now,
+        at = at,
+        complete = complete,
+    }
+    self.count += 1
+
+    Heap.push (self.deadlines, at, id)
+    return id
+end
+
+--[[
+    The reply arrived. Answers whether anybody was waiting, an id nobody waits on being a reply to a
+    request that already ended or a frame nobody here sent for.
+]]
+function Pending.answer (self: Self, id: number, value: any): boolean
+    local entry = taken (self, id)
+    if entry == nil then return false end
+
+    entry.complete (true, value, nil)
+    return true
+end
+
+--[[
+    The request ended as one of the four outcomes. The elapsed time rides on all of them, a caller
+    reading how long a leave took being owed the same number as one reading a timeout.
+]]
+function Pending.fail (self: Self, id: number, code: Types.OutcomeCode, now: number): boolean
+    local entry = taken (self, id)
+    if entry == nil then return false end
+
+    entry.complete (
+        false,
+        code,
+        table.freeze ({ definition = entry.definition, elapsed = now - entry.opened })
+    )
+    return true
+end
+
+-- Every deadline that has passed, and only the requests still waiting on one of them.
+function Pending.sweep (self: Self, now: number)
+    local heap = self.deadlines
+
+    while true do
+        local at, id = Heap.peek (heap)
+        if at == nil or at > now then return end
+        Heap.pop (heap)
+
+        local entry = self.live[id :: number]
+        if entry ~= nil and entry.at <= now then
+            Pending.fail (self, id :: number, "timeout", now)
+        end
+    end
+end
+
+--[[
+    Everything owed by somebody who has gone, named for what happened: a caller branching on a leave
+    knows not to retry, where one told it timed out would.
+]]
+function Pending.rejectFor (self: Self, player: Player, now: number)
+    local taking: { number } = {}
+    for id, entry in self.live do
+        if entry.player == player then table.insert (taking, id) end
+    end
+
+    for _, id in taking do
+        Pending.fail (self, id, "leave", now)
+    end
+end
+
+--[[
+    Everything at once, which is a namespace closing. The live set is replaced before anything is
+    answered, so a completion opening a request of its own lands in the new one and nothing in the
+    old can be answered twice.
+]]
+function Pending.rejectAll (self: Self, now: number)
+    local live = self.live
+
+    self.live = {}
+    self.count = 0
+
+    for _, entry in live do
+        entry.complete (
+            false,
+            "shutdown",
+            table.freeze ({ definition = entry.definition, elapsed = now - entry.opened })
+        )
+    end
+end
+
+return table.freeze (Pending)