e2eoffice

type AppendRequest struct {
	Kind Kind
	// Base is the head the writer has seen; the entry lands at Base+1 or not
	// at all.
	Base uint64
	Ctr  uint64
	CT   []byte
}

type ConflictError struct {
	Head uint64
}

type Entry struct {
	Seq    uint64 `json:"seq"`
	Kind   Kind   `json:"kind"`
	Client string `json:"client"`
	User   int64  `json:"user"`
	// At is the relay's clock when the entry landed, in Unix milliseconds.
	// Every bridge uses it where the Document Server would use its own clock
	// (a lock's time), so all of them derive the same state.
	At int64 `json:"at"`
	// Ctr is the writer's counter, bound into the sealed entry; the relay
	// only checks that it grows.
	Ctr uint64 `json:"ctr,omitempty"`
	// CT is the sealed payload of a member's entry.
	CT []byte `json:"ct,omitempty"`
	// Member is who joined (KindJoin).
	Member *Member `json:"member,omitempty"`
	// Through and Sig describe a save (KindSaved): the last entry the saved
	// file holds and the file's new signature.
	Through uint64 `json:"through,omitempty"`
	Sig     string `json:"sig,omitempty"`
}

type Eph struct {
	Client string `json:"client"`
	CT     []byte `json:"ct"`
}

type Frame struct {
	Entry *Entry
	Eph   *Eph
}

type Hello struct {
	Client       string
	IndexUser    int
	Head         uint64
	ChangesHead  uint64
	SavedThrough uint64
	Key          []byte
}

type Identity struct {
	User    int64
	Name    string
	CanEdit bool
}

type Kind string

type LeaseOp string

type Member struct {
	Client string `json:"client"`
	User   int64  `json:"user"`
	Name   string `json:"name"`
	// IndexUser is the editor's per-session user index. The editor builds its
	// user id from it and its object ids from the user id, so two members
	// must never share one, not even one that left: it only grows.
	IndexUser int  `json:"index_user"`
	CanEdit   bool `json:"can_edit"`
}

type OpenRequest struct {
	// Doc is the caller's key for the file (tenant, storage and path). The
	// relay only compares it.
	Doc string
	// Build is the editor build the opener runs. Members of one session run
	// one build: another build may write changes this one cannot read.
	Build string
	// FileSig is the file as the opener read it (size:mtime). A session goes
	// on from the file it started from or from its last save; a file that
	// changed outside it is not the document its log applies to.
	FileSig string
}

type OpenResult struct {
	SID string
	// Created: this opener started the session and must set its key and
	// store its base before anybody can join.
	Created bool
	// Key is the sealed session key, nil until the creator set it.
	Key []byte
}

type Options struct {
	// LeaseTTL is how long the changes lease lasts without a renewal (the
	// Document Server's save lock expires after 60 s).
	LeaseTTL time.Duration
	// MaxEntryBytes caps one sealed payload. The editor cuts its changes at
	// 1.5 MB per message (websocketMaxPayloadSize); the rest is sealing.
	MaxEntryBytes int
	// MaxLogBytes caps a session's log. Past it a member has to save and the
	// next opening starts a new session.
	MaxLogBytes int64
	// MaxBlobBytes caps a session's blobs (the base document and its images).
	MaxBlobBytes int64
	// SubscriberBuffer is how many frames a subscriber may fall behind before
	// it is cut off (and has to subscribe again from the last entry it has).
	SubscriberBuffer int
	// SavedIdle is how long an empty session whose log is all saved is kept.
	SavedIdle time.Duration
	// UnsavedRetention is how long an empty session with unsaved changes is
	// kept for somebody to open and save it.
	UnsavedRetention time.Duration
	// NotReadyTTL is how long a session may wait for its key and its base.
	NotReadyTTL time.Duration
	// Now is the clock (tests).
	Now func() time.Time
	// Who answers, for a caller joining the session of doc, who they are and
	// whether they may write - from the server's own records: the account
	// signed in on ctx and filex's rules for the file (an editor role and
	// files.modify), never from anything the caller sent. nil lets nobody
	// join (ErrNoIdentity); an error from it refuses the join.
	Who func(ctx context.Context, doc string) (Identity, error)
}

type Relay struct {
	// contains filtered or unexported fields
}

type State struct {
	SID          string
	Doc          string
	Head         uint64
	ChangesHead  uint64
	SavedThrough uint64
	Members      int
	// Dirty: the log holds changes no save has (the explorer can say "unsaved
	// changes from a co-editing session").
	Dirty      bool
	LastActive time.Time
}