@trioforge/crucible 0.1.0 → 0.2.0

package/out/internal/data/scheduler.d.ts

@@ -0,0 +1 @@
+export {};

package/out/internal/data/scheduler.luau

@@ -0,0 +1,507 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local bootClock = TS.import(script, script.Parent.Parent, "boot").bootClock
+local _limits = TS.import(script, script.Parent, "limits")
+local BUDGET_RECHECK_SECONDS = _limits.BUDGET_RECHECK_SECONDS
+local BUDGET_RESERVE_FRACTION = _limits.BUDGET_RESERVE_FRACTION
+local BUDGET_RESERVE_MIN = _limits.BUDGET_RESERVE_MIN
+local KEY_READ_BYTES_PER_MINUTE = _limits.KEY_READ_BYTES_PER_MINUTE
+local KEY_WRITE_BYTES_PER_MINUTE = _limits.KEY_WRITE_BYTES_PER_MINUTE
+local LEASE_CRITICAL_SECONDS = _limits.LEASE_CRITICAL_SECONDS
+local MAX_IN_FLIGHT = _limits.MAX_IN_FLIGHT
+local MAX_PENDING_OPERATIONS = _limits.MAX_PENDING_OPERATIONS
+local MAX_PENDING_PER_KEY = _limits.MAX_PENDING_PER_KEY
+local ORDINARY_AGING_SECONDS = _limits.ORDINARY_AGING_SECONDS
+local ORDINARY_MAX_IN_FLIGHT = _limits.ORDINARY_MAX_IN_FLIGHT
+local RESERVED_SESSION_SLOTS = _limits.RESERVED_SESSION_SLOTS
+local RETRY_BASE_SECONDS = _limits.RETRY_BASE_SECONDS
+local RETRY_CAP_SECONDS = _limits.RETRY_CAP_SECONDS
+local Waiters = TS.import(script, script.Parent, "waiters").Waiters
+--* @internal Dispatch order, most urgent first (rule 34). 
+--* @internal 
+--* @internal 
+--* @internal 
+local Ticket
+do
+	Ticket = setmetatable({}, {
+		__tostring = function()
+			return "Ticket"
+		end,
+	})
+	Ticket.__index = Ticket
+	function Ticket.new(...)
+		local self = setmetatable({}, Ticket)
+		return self:constructor(...) or self
+	end
+	function Ticket:constructor(port)
+		self.dispatched = false
+		self.inFlight = false
+		self.ambiguous = false
+		self.listeners = {}
+		self.waiters = Waiters.new(port)
+	end
+	function Ticket:onSettled(listener)
+		if self.settled ~= nil then
+			listener(self.settled)
+		else
+			local _listeners = self.listeners
+			local _listener = listener
+			table.insert(_listeners, _listener)
+		end
+	end
+	function Ticket:wait(deadline)
+		local _condition = deadline
+		if _condition == nil then
+			_condition = math.huge
+		end
+		local limit = _condition
+		while self.settled == nil and bootClock() < limit do
+			self.waiters:park(deadline)
+		end
+		return self.settled
+	end
+	function Ticket:settle(settled)
+		if self.settled ~= nil then
+			return nil
+		end
+		self.settled = settled
+		for _, listener in self.listeners do
+			listener(settled)
+		end
+		table.clear(self.listeners)
+		self.waiters:wake()
+	end
+end
+local function slotOf(priority)
+	if priority == 4 then
+		return 1
+	end
+	if priority == 5 then
+		return 2
+	end
+	return 0
+end
+--* @internal The one keyed scheduler per server (rules 32 to 36). Every time is bootClock() (rule 25). 
+local KeyedScheduler
+do
+	KeyedScheduler = setmetatable({}, {
+		__tostring = function()
+			return "KeyedScheduler"
+		end,
+	})
+	KeyedScheduler.__index = KeyedScheduler
+	function KeyedScheduler.new(...)
+		local self = setmetatable({}, KeyedScheduler)
+		return self:constructor(...) or self
+	end
+	function KeyedScheduler:constructor(port, diagnose)
+		self.port = port
+		self.diagnose = diagnose
+		self.queue = {}
+		self.lanes = {}
+		self.traffic = {}
+		self.pendingPerKey = {}
+		self.pending = 0
+		self.inFlight = 0
+		self.shared = 0
+		self.ordinary = 0
+		self.sequence = 0
+		self.pumping = false
+		self.again = false
+		self.timerAt = math.huge
+	end
+	function KeyedScheduler:reserve()
+		return math.max(BUDGET_RESERVE_MIN, math.floor(BUDGET_RESERVE_FRACTION * (60 + 40 * self.port.players.count())))
+	end
+	function KeyedScheduler:setDispatchCutoff(at)
+		self.cutoff = at
+		self:pump()
+	end
+	function KeyedScheduler:submit(request)
+		local ticket = Ticket.new(self.port)
+		local now = bootClock()
+		if self.cutoff ~= nil and now >= self.cutoff then
+			ticket:settle({
+				kind = "closing",
+			})
+			return ticket
+		end
+		local lane = `{request.store}\0{request.key}`
+		local counted = slotOf(request.priority) ~= 0
+		if counted then
+			local _condition = self.pendingPerKey[lane]
+			if _condition == nil then
+				_condition = 0
+			end
+			local perKey = _condition
+			if self.pending >= MAX_PENDING_OPERATIONS or perKey >= MAX_PENDING_PER_KEY then
+				ticket:settle({
+					kind = "overloaded",
+				})
+				return ticket
+			end
+			self.pending += 1
+			local _pendingPerKey = self.pendingPerKey
+			local _arg1 = perKey + 1
+			_pendingPerKey[lane] = _arg1
+		end
+		local _queue = self.queue
+		local _object = {
+			request = request,
+			ticket = ticket,
+			lane = lane,
+		}
+		local _left = "sequence"
+		self.sequence += 1
+		_object[_left] = self.sequence
+		_object.enqueuedAt = now
+		_object.counted = counted
+		_object.readyAt = now
+		_object.retries = 0
+		table.insert(_queue, _object)
+		self:pump()
+		return ticket
+	end
+	function KeyedScheduler:rank(entry, now)
+		local request = entry.request
+		local _condition = request.priority == 3 and request.renewal == true
+		if _condition then
+			local _condition_1 = request.safeUntil
+			if _condition_1 == nil then
+				_condition_1 = math.huge
+			end
+			_condition = _condition_1 - now < LEASE_CRITICAL_SECONDS
+		end
+		if _condition then
+			return 0
+		end
+		if request.priority == 5 and now - entry.enqueuedAt >= ORDINARY_AGING_SECONDS then
+			return 2 + 0.5
+		end
+		return request.priority
+	end
+	function KeyedScheduler:before(a, b, now)
+		local ra = self:rank(a, now)
+		local rb = self:rank(b, now)
+		if ra ~= rb then
+			return ra < rb
+		end
+		if ra == 0 or ra == 1 or ra == 3 then
+			local _condition = a.request.safeUntil
+			if _condition == nil then
+				_condition = math.huge
+			end
+			local sa = _condition
+			local _condition_1 = b.request.safeUntil
+			if _condition_1 == nil then
+				_condition_1 = math.huge
+			end
+			local sb = _condition_1
+			if sa ~= sb then
+				return sa < sb
+			end
+		end
+		return a.sequence < b.sequence
+	end
+	function KeyedScheduler:hasSlot(entry)
+		if self.inFlight >= MAX_IN_FLIGHT then
+			return false
+		end
+		local slot = slotOf(entry.request.priority)
+		if slot == 0 then
+			return true
+		end
+		if self.shared >= MAX_IN_FLIGHT - RESERVED_SESSION_SLOTS then
+			return false
+		end
+		return slot == 1 or self.ordinary < ORDINARY_MAX_IN_FLIGHT
+	end
+	function KeyedScheduler:hasBudget(entry)
+		local update = entry.request.kind == "update"
+		if entry.request.priority ~= 5 then
+			return self.port.budget(entry.request.kind) >= 1
+		end
+		local reserve = self:reserve()
+		if self.port.budget("read") <= reserve then
+			return false
+		end
+		return not update or self.port.budget("update") > reserve
+	end
+	function KeyedScheduler:recent(lane, now)
+		local _traffic = self.traffic
+		local _lane = lane
+		local _condition = _traffic[_lane]
+		if _condition == nil then
+			_condition = {}
+		end
+		-- ▼ ReadonlyArray.filter ▼
+		local _newValue = {}
+		local _callback = function(t)
+			return now - t.at < 60
+		end
+		local _length = 0
+		for _k, _v in _condition do
+			if _callback(_v, _k - 1, _condition) == true then
+				_length += 1
+				_newValue[_length] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filter ▲
+		local kept = _newValue
+		if #kept == 0 then
+			local _traffic_1 = self.traffic
+			local _lane_1 = lane
+			_traffic_1[_lane_1] = nil
+		else
+			local _traffic_1 = self.traffic
+			local _lane_1 = lane
+			_traffic_1[_lane_1] = kept
+		end
+		return kept
+	end
+	function KeyedScheduler:paced(entry, now)
+		local update = entry.request.kind == "update"
+		local bytes = entry.request.bytes
+		for _, t in self:recent(entry.lane, now) do
+			if t.update == update then
+				bytes += t.bytes
+			end
+		end
+		return bytes <= (if update then KEY_WRITE_BYTES_PER_MINUTE else KEY_READ_BYTES_PER_MINUTE)
+	end
+	function KeyedScheduler:settle(entry, settled)
+		local _queue = self.queue
+		local _entry = entry
+		local index = (table.find(_queue, _entry) or 0) - 1
+		if index ~= -1 then
+			table.remove(self.queue, index + 1)
+		end
+		local _lanes = self.lanes
+		local _lane = entry.lane
+		if _lanes[_lane] == entry then
+			local _lanes_1 = self.lanes
+			local _lane_1 = entry.lane
+			_lanes_1[_lane_1] = nil
+		end
+		if entry.counted then
+			self.pending -= 1
+			local _pendingPerKey = self.pendingPerKey
+			local _lane_1 = entry.lane
+			local _condition = _pendingPerKey[_lane_1]
+			if _condition == nil then
+				_condition = 1
+			end
+			local perKey = _condition - 1
+			if perKey <= 0 then
+				local _pendingPerKey_1 = self.pendingPerKey
+				local _lane_2 = entry.lane
+				_pendingPerKey_1[_lane_2] = nil
+			else
+				local _pendingPerKey_1 = self.pendingPerKey
+				local _lane_2 = entry.lane
+				_pendingPerKey_1[_lane_2] = perKey
+			end
+		end
+		entry.ticket:settle(settled)
+	end
+	function KeyedScheduler:givenUp(entry)
+		return if entry.ticket.ambiguous then {
+			kind = "uncertain",
+		} else {
+			kind = "timeout",
+		}
+	end
+	function KeyedScheduler:finish(entry, outcome)
+		local _result = entry.request.onResult
+		if _result ~= nil then
+			_result(outcome)
+		end
+		if outcome.kind == "ok" or not outcome.retryable then
+			if outcome.kind == "error" then
+				self.diagnose(`storage:{entry.request.store}:{outcome.code}`, `{entry.request.store} storage error {outcome.code} on key {entry.request.key}`)
+			end
+			self:settle(entry, {
+				kind = "done",
+				outcome = outcome,
+			})
+			return nil
+		end
+		if outcome.ambiguous then
+			entry.ticket.ambiguous = true
+		end
+		local now = bootClock()
+		local span = math.min(RETRY_CAP_SECONDS, RETRY_BASE_SECONDS * 2 ^ entry.retries)
+		entry.retries += 1
+		entry.readyAt = now + self.port.random() * span
+		local _exp = entry.request.dispatchDeadline
+		local _condition = self.cutoff
+		if _condition == nil then
+			_condition = math.huge
+		end
+		local limit = math.min(_exp, _condition)
+		if entry.readyAt >= limit then
+			self:settle(entry, self:givenUp(entry))
+		else
+			local _queue = self.queue
+			local _entry = entry
+			table.insert(_queue, _entry)
+		end
+	end
+	function KeyedScheduler:dispatch(entry, now)
+		local _queue = self.queue
+		local _queue_1 = self.queue
+		local _entry = entry
+		local _arg0 = (table.find(_queue_1, _entry) or 0) - 1
+		table.remove(_queue, _arg0 + 1)
+		local _lanes = self.lanes
+		local _lane = entry.lane
+		local _entry_1 = entry
+		_lanes[_lane] = _entry_1
+		local slot = slotOf(entry.request.priority)
+		self.inFlight += 1
+		if slot ~= 0 then
+			self.shared += 1
+		end
+		if slot == 2 then
+			self.ordinary += 1
+		end
+		entry.ticket.dispatched = true
+		entry.ticket.inFlight = true
+		local request = entry.request
+		local update = request.kind == "update"
+		local traffic = self:recent(entry.lane, now)
+		local _arg0_1 = {
+			at = now,
+			bytes = request.bytes,
+			update = update,
+		}
+		table.insert(traffic, _arg0_1)
+		local _traffic = self.traffic
+		local _lane_1 = entry.lane
+		_traffic[_lane_1] = traffic
+		local transform = if update then request.transform() else nil
+		local _result = request.onDispatch
+		if _result ~= nil then
+			_result(now)
+		end
+		self.port.spawn(function()
+			local ok, result = pcall(function()
+				return if update then self.port.update(request.store, request.key, transform) else self.port.read(request.store, request.key)
+			end)
+			self.inFlight -= 1
+			if slot ~= 0 then
+				self.shared -= 1
+			end
+			if slot == 2 then
+				self.ordinary -= 1
+			end
+			entry.ticket.inFlight = false
+			local outcome = if ok then result else {
+				kind = "error",
+				code = 0,
+				retryable = true,
+				ambiguous = true,
+			}
+			local handled, err = pcall(function()
+				return self:finish(entry, outcome)
+			end)
+			if not handled then
+				self:settle(entry, {
+					kind = "done",
+					outcome = {
+						kind = "error",
+						code = 0,
+						retryable = false,
+						ambiguous = true,
+					},
+				})
+				self.diagnose(`finish:{request.store}`, `{request.store} request handling failed: {err}`)
+			end
+			self:pump()
+		end)
+	end
+	function KeyedScheduler:pump()
+		if self.pumping then
+			self.again = true
+			return nil
+		end
+		self.pumping = true
+		repeat
+			do
+				self.again = false
+				self:step()
+			end
+		until not self.again
+		self.pumping = false
+	end
+	function KeyedScheduler:step()
+		local now = bootClock()
+		local wake = math.huge
+		local blocked = false
+		local _array = {}
+		local _length = #_array
+		local _array_1 = self.queue
+		table.move(_array_1, 1, #_array_1, _length + 1, _array)
+		for _, entry in _array do
+			local _exp = entry.request.dispatchDeadline
+			local _condition = self.cutoff
+			if _condition == nil then
+				_condition = math.huge
+			end
+			local limit = math.min(_exp, _condition)
+			if now >= limit then
+				self:settle(entry, self:givenUp(entry))
+			else
+				wake = math.min(wake, limit)
+			end
+		end
+		while true do
+			local best
+			for _, entry in self.queue do
+				if entry.readyAt > now then
+					wake = math.min(wake, entry.readyAt)
+					continue
+				end
+				local _lanes = self.lanes
+				local _lane = entry.lane
+				local holder = _lanes[_lane]
+				if (holder ~= nil and holder ~= entry) or not self:hasSlot(entry) then
+					continue
+				end
+				if not self:hasBudget(entry) or not self:paced(entry, now) then
+					blocked = true
+					continue
+				end
+				if best == nil or self:before(entry, best, now) then
+					best = entry
+				end
+			end
+			if best == nil then
+				break
+			end
+			self:dispatch(best, now)
+		end
+		if blocked then
+			wake = math.min(wake, now + BUDGET_RECHECK_SECONDS)
+		end
+		self:arm(wake, now)
+	end
+	function KeyedScheduler:arm(at, now)
+		if at == math.huge or at >= self.timerAt then
+			return nil
+		end
+		if self.timer ~= nil then
+			self.port.cancel(self.timer)
+		end
+		self.timerAt = at
+		self.timer = self.port.delay(math.max(at - now, 0), function()
+			self.timer = nil
+			self.timerAt = math.huge
+			self:pump()
+		end)
+	end
+end
+return {
+	Ticket = Ticket,
+	KeyedScheduler = KeyedScheduler,
+}

package/out/internal/data/session.d.ts

@@ -0,0 +1 @@
+export {};