coedit

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 Departure struct {
	SID       string
	StorageID int64
	Path      string
	App       string
	Member    model.CoEditMember
	// Reason: "left" (it said so), "timeout" (its page went away), "closed"
	// (the session ended).
	Reason string
}

type Entry struct {
	Seq    uint64 `json:"seq"`
	Kind   Kind   `json:"kind"`
	Client string `json:"client"`
	// At is the relay's clock when the entry landed, Unix milliseconds - the
	// same for every member, where a Document Server would use its own.
	At int64 `json:"at"`
	// Ctr is the writer's counter, bound into the sealed entry.
	Ctr uint64 `json:"ctr,omitempty"`
	// CT is a member's sealed payload (base64 on the wire).
	CT []byte `json:"ct,omitempty"`
	// Member is who joined (KindJoin).
	Member *Member `json:"member,omitempty"`
	// Through is the last entry a save holds (KindSaved).
	Through uint64 `json:"through,omitempty"`
}

type Eph struct {
	Client string `json:"client"`
	Ctr    uint64 `json:"ctr"`
	CT     []byte `json:"ct"`
	// At is when the relay took it (Unix ms) - for the sockets of other
	// processes, which read the latest cursors from the database
	// (cursors.go).
	At int64 `json:"-"`
}

type Hello struct {
	SID string
	// Created: this member started the session and must store the base
	// document (and, KeyFolder, the sealed key) before anybody else joins.
	Created      bool
	Me           Member
	Head         uint64
	ChangesHead  uint64
	SavedThrough uint64
	KeyMode      string
	// Key is the raw session key (KeyServer).
	Key []byte
	// SealedKey is the sealed session key (KeyFolder), "" until set.
	SealedKey string
}

type Identity struct {
	User int64
	// Person is the person's presence identity (the account, and the end
	// user a shared proxy token names): two of them behind one proxy token
	// are two people. Empty = the account alone.
	Person  string
	Name    string
	CanEdit bool
	// TokenHash is hex SHA-256 of the token the member is handed: the
	// requests that name the member carry it (MemberToken checks it).
	TokenHash string
}

type KeyBox interface {
	Enabled() bool
	SealFor(plaintext, aad string) (string, error)
	OpenFor(stored, aad string) (string, error)
}

type Kind string

type LeaseOp string

type Member struct {
	Client string `json:"client"`
	// User is an opaque id of the person in THIS session (the same for each
	// of their connections in it), never an account id.
	User string `json:"user"`
	Name string `json:"name"`
	// IndexUser is the editor's per-session user index: given once, never
	// twice in a session, not even after its member left.
	IndexUser int  `json:"index_user"`
	CanEdit   bool `json:"can_edit"`
}

type OpenRequest struct {
	// Doc is the file's key (DocKey: a digest of the storage and the path).
	Doc       string
	StorageID int64
	Path      string
	// App and Build: the app and the build its members run. Members of one
	// session run one build: another build may write entries this one cannot
	// read.
	App   string
	Build string
	// FileSig is the file as the opener's server read it (size:mtime, etag).
	// 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
	// KeyMode is KeyServer (an ordinary folder) or KeyFolder (an encrypted
	// one).
	KeyMode string
}

type Options struct {
	Store Store
	// BlobDir is where the sealed blobs are kept, one folder per session
	// (<data_dir>/coedit). Several processes on one database must share it,
	// as they share the upload staging directory.
	BlobDir string
	// Keys seals the keys of KeyServer sessions. nil or not enabled: an
	// ordinary folder is not edited together (ErrNoServerKey).
	Keys KeyBox
	// LeaseTTL is how long the changes lease lasts without a renewal (the
	// Document Server's save lock expires after 60 s).
	LeaseTTL time.Duration
	// MemberTTL is how long a member whose page gives no sign of life stays.
	MemberTTL time.Duration
	// MaxEntryBytes caps one sealed payload.
	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 together.
	MaxBlobBytes int64
	// MaxMembers caps the members of one session.
	MaxMembers 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 the next person to open the file to see and save them.
	UnsavedRetention time.Duration
	// NotReadyTTL is how long a session may wait for its key and its base.
	NotReadyTTL time.Duration
	// PollEvery is how often a member's socket reads the log without a
	// notice from this process (another process wrote the entry).
	PollEvery time.Duration
	// OnDeparture is told about every member that left, after it is recorded.
	OnDeparture func(ctx context.Context, d Departure)
	// Now is the clock (tests).
	Now func() time.Time
}

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

type Store interface {
	WithTx(ctx context.Context, fn func(ctx context.Context) error) error
	db.CoEditStore
}

type Watcher struct {
	SID    string
	Client string
	// Notify gets a signal (never more than one waiting) when an entry lands
	// in this process: read the log from where the socket is.
	Notify chan struct{}
	// Eph gets the other members' cursors. A full buffer drops them: a
	// cursor is worth nothing late.
	Eph chan Eph
	// Ended gets why the membership ended ("left", "timeout", "closed").
	Ended chan string
	// contains filtered or unexported fields
}