api

const (
	ReadsPerSecond  = 5.0
	ReadBurst       = 30.0
	WritesPerSecond = 5.0
	WriteBurst      = 60.0
)

The rates this server sets for itself, for the classes the contract does not give an interval to. They are per device and per second.

Writes are generous on purpose: the intervals in discovery govern a client that is connected, and a client that has been offline for a session drains its whole queue the moment it reconnects. Refusing that drain would be refusing the case the offline queue exists for.

const (
	GlobalReadsPerSecond  = 500.0
	GlobalWritesPerSecond = 200.0
	GlobalLivePerSecond   = 500.0
	GlobalFieldPerSecond  = 100.0
	GlobalOtherPerSecond  = 50.0
)

The ceilings over every device at once, per second and in burst. They are what stops a flood spread across many tokens, which a per-device bucket cannot see.

const (
	MaxNameLen   = 200
	MaxShortLen  = 64
	MaxSectors   = 64
	MaxLapNumber = 100_000
	MaxLapMs     = 3_600_000 // one hour, the same bound the trace codec puts on t
	MaxSpeedKmh  = 1_000
	MaxIncidents = 100_000
	// MaxCornersPerLap bounds a lap's corner analysis. No circuit has sixty-four
	// corners, and the client's own widest setting reports ninety-nine, so this
	// is wider than any real lap and narrow enough that the column cannot be
	// used as storage.
	MaxCornersPerLap = 64
	// MaxSetupValues bounds the named values of a setup sheet, and
	// MaxSetupTextLen the length of one setting's group, name, text or unit. A
	// real iRacing sheet is sixty to ninety lines of a few words each.
	MaxSetupValues  = 256
	MaxSetupTextLen = 200
	// MaxSetupUpdateCount bounds the simulator's own revision counter for the
	// sheet. A driver who changed their setup a million times in one sitting
	// did not.
	MaxSetupUpdateCount = 1_000_000
	// MaxSetupKpa, MaxSetupTempC and the tread percentage bound the normalised
	// core. Each is far outside what a tyre does and inside what the column can
	// mean.
	MaxSetupKpa   = 1_000
	MaxSetupTempC = 1_000
)

The bounds this server puts on the fields the contract leaves open. Each is far wider than any honest value and narrow enough that a column cannot be used as storage: a text field is a name, not a place to keep a document.

const DefaultScope = wire.ScopeClass

DefaultScope is what GET /reference uses when the client names none. It is the widest, because an unqualified request means "the best lap you can give me" and the fallback below narrows it to whatever this server actually holds.

const DeviceLabelMax = 80

DeviceLabelMax is how much of a client's User-Agent is kept as the label a driver sees against a paired machine. It is the only thing the pairing flow learns about a machine, and the contract sends nothing else.

const DiscoveryMaxAge = 5 * 60

DiscoveryMaxAge is how long a client may keep the discovery document. Five minutes is what the contract says, and it is the right answer: the document changes when an operator changes a setting, and a driver who is mid-session when that happens should not be re-fetching it every lap to find out.

const FieldMaxCars = 200

FieldMaxCars caps one report. A full grid is forty-odd cars; this is well above any of them and is here so that a body inside the size limit cannot still be a hundred thousand entries.

const FieldMaxSessions = 256

FieldMaxSessions caps how many sessions are relayed at once, for the same reason LiveMaxStints does.

const FieldQuietPeriod = 3

FieldQuietPeriod is how long an armed relay may go silent before another client may take over. Three times the published interval: long enough that a dropped packet does not change who is authoritative, short enough that a driver who quits mid-session does not hold the relay for the rest of it.

const IdempotencyHeader = "Idempotency-Key"

IdempotencyHeader is the header every authenticated write carries. It is what makes the client's offline queue safe: because a retry is free, a lap upload that failed for any reason can simply be sent again.

const IdempotencyKeyMax = 200

IdempotencyKeyMax is the longest key this server stores. A UUID is 36 characters and the contract does not say what a key looks like beyond being unique per request, so the cap is generous and exists only to keep a table row bounded.

const IntervalBurst = 4.0

IntervalBurst is the slack on the three classes whose rate comes from discovery. A client that sends at exactly the published interval must never be refused, so the bucket has to absorb the jitter of a timer and a network; four calls is that and no more.

const LiveMaxStints = 1024

LiveMaxStints caps how many stints are held at once, so a flood of identifiers cannot grow the map without bound. It is far above any team's concurrent drivers; the oldest entry is dropped when it is reached.

const LiveTTL = 30 * time.Second

LiveTTL is how long a live sample is worth anything. Past it the entry is swept: a driver whose client stopped sending is not on track, and showing their last known position for the rest of the afternoon would be a lie.

const MinClient = "1.0.0"

MinClient is the oldest client version this build accepts, compared against the X-Client-Version header and published as wire.Discovery.MinClient. A client older than it is told wire.CodeClientTooOld and stops uploading.

const PairBurst = 10.0

PairBurst is how many pairing calls one address may make at once. It covers a client that starts a pairing and polls immediately, several times over, and it is small enough that walking the user-code space is not worth beginning.

const PairIntervalS = 2

PairIntervalS is the floor a client must not poll faster than, published as wire.PairStart.IntervalS and enforced by the limiter, so the number a client is given and the number it is held to are the same number.

const Prefix = config.APIBase

Prefix is where version 1 is mounted. It is the value discovery publishes as wire.Discovery.API, taken from one constant so the document and the routes cannot disagree.

const SweepInterval = time.Hour

SweepInterval is how often the two tables that hold short-lived rows are cleared out. Neither expiry is enforced by the sweep — the lookups check the clock — so this is housekeeping, and an hour is often enough that a week away does not leave a table full of last week.