sessiondir

type ClaimOptions struct {
	RuntimeRoot  string
	StateRoot    string
	Name         string
	Command      []string
	ForceCommand []string
}

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

type Record struct {
	Name     string `json:"name"`
	LaunchID string `json:"launch_id"`
	// AdminSocket is where the session's admin socket is bound, under the
	// runtime root it claimed its name with. A reader under another runtime
	// root — a login shell asking about a cron job's session — shares only
	// the record with it, and a path rebuilt under the reader's own root
	// names a socket nothing answers at. Forced on every publish, like Name
	// and LaunchID, so no caller can leave it out.
	AdminSocket string `json:"admin_socket,omitempty"`
	// AttachSocket is where the session's local terminal door is bound, beside
	// the admin socket and under the same runtime root, for the same reason
	// AdminSocket is recorded: `upterm attach` from a shell under a different
	// XDG_RUNTIME_DIR must dial the socket that exists, not one rebuilt under
	// its own root. Forced on every publish.
	AttachSocket string `json:"attach_socket,omitempty"`
	// HostKeys is the public half of the key the attach door presents, in
	// authorized_keys form. One entry: the session host key the daemon
	// generated for this run. `upterm attach` pins it: the socket's
	// permissions are what keep another process from binding that path, and
	// this is what catches one that managed to. A slice because the record's
	// shape predates the single key and older attach clients read it.
	// Unlike AdminSocket and AttachSocket it is not forced on every publish —
	// Dir has no key of its own — so the daemon supplies it once it has one.
	HostKeys     []string  `json:"host_keys,omitempty"`
	SessionID    string    `json:"session_id,omitempty"`
	Command      []string  `json:"command,omitempty"`
	ForceCommand []string  `json:"force_command,omitempty"`
	StartedAt    time.Time `json:"started_at"`
	UpdatedAt    time.Time `json:"updated_at"`
	// omitzero, not omitempty: omitempty does nothing for a struct, so a
	// record that has not finished carried finished_at: "0001-01-01T00:00:00Z"
	// — a date, and one a reader could easily take for a real one.
	FinishedAt time.Time `json:"finished_at,omitzero"`
	// FirstGuestJoinedAt is when a guest first joined this session, or the
	// zero time when none ever has. It latches: the first join writes it and
	// no later join moves it.
	//
	// Published because "has anyone ever joined?" cannot be answered from
	// connected_clients, which is a current list. A reader that polls it
	// misses a guest who joins and leaves between two ticks -- the bug
	// action-upterm has today, latching in a local variable of its own
	// poller. One sticky fact with one owner replaces every consumer's
	// private latch.
	//
	// Guests only: the host's own attached terminal is a client of its own
	// session, so counting clients would make every foreground session look
	// joined from the moment it starts.
	//
	// omitzero for the reason FinishedAt is: omitempty does nothing for a
	// struct, and a zero time serialises to a date a reader could take for a
	// real one.
	FirstGuestJoinedAt time.Time `json:"first_guest_joined_at,omitzero"`
	Status             string    `json:"status"`
	Reason             string    `json:"reason"`
	ExitCode           *int      `json:"exit_code,omitempty"`
	Signal             string    `json:"signal,omitempty"`
	SignalNumber       *int      `json:"signal_number,omitempty"`
	// Pid is the process that claimed the name. Set by Claim and never by a
	// caller: the claimer is the owner by definition, and a reader who finds
	// the name held but its socket silent needs a process to name.
	Pid int `json:"pid,omitempty"`
	// LogPath is where the session's process writes its log, published by
	// the process that knows, for the reason AdminSocket is: the reader's
	// state root need not be the daemon's.
	LogPath string `json:"log_path,omitempty"`
}