setup

type Detected struct {
	Files      []FileSource
	Journald   bool
	Containers []string
	Lokis      []Loki
}

type FileSource struct {
	Name  string
	Paths []string
}

type Loki struct {
	Container, Service, Project string
	Networks                    []string
}

type LokiSource struct {
	URL, User, CACert string
	// Credentials is "ask" or "vault" (with VaultPath).
	Credentials, VaultPath string
	// Selector is "label=value"; empty writes the profile commented out
	// (a Loki source needs at least one label matcher).
	Selector string
	// Network is the Compose network the console joins.
	Network string
}

type Options struct {
	// Root is the project directory (absolute): .locklog/ is created in it.
	Root string
	// Home is the user's home directory, never a project ("" unknown).
	Home string
	// Facts are the host's.
	Facts hostfacts.Facts
	// Production is --production; ProductionSet says it was given.
	Production, ProductionSet bool
	// Ask asks, on In, what the options did not give (the interactive
	// form): whether the profile is production, and the proxy of a
	// detected Compose Loki. Without it nothing is asked.
	Ask bool
	// Only limits detection to the log files under these directories: no
	// journal, no container (scripted runs that know their logs).
	Only []string
	// Profile is the main profile's name ("" : prod or staging).
	Profile string
	// LokiProxy is the Compose Loki service (or container) to put behind
	// the authenticating proxy (interactive only: its token is shown on
	// TTY); "" asks when one is detected (with Ask).
	LokiProxy string
	// LokiSelector is the Loki source's "label=value" matcher.
	LokiSelector string
	// ProxyBase is the directory, outside the project, that holds the
	// proxies' directories (created 0700).
	ProxyBase string
	// Credentials is the proxied Loki source's: "ask" (the console asks at
	// start) or "vault" (with VaultPath; the console asks the Vault token
	// at start).
	Credentials, VaultPath string
	// In holds the answers; Out is what the run prints (a human's text).
	// TTY is the human's terminal, the only place the proxy's token is
	// shown (nil: no terminal, and no proxy is generated).
	In  io.Reader
	Out io.Writer
	TTY io.Writer
}

type Plan struct {
	// Profile is the main profile's name; the containers go to
	// Profile-docker (a docker source needs a console of its own), a
	// proxied Loki to Profile-loki (a console on the Compose network).
	Profile    string
	Production bool
	Detected   Detected
	// LokiProxy, when set, is the proxied Loki's source.
	LokiProxy *LokiSource
}

type Result struct {
	Profile    string
	Production bool
	// Config is the config file written (created, or the profiles
	// appended to it).
	Config string
	// Created: the config file did not exist before.
	Created bool
	// Profiles are the profiles written: Profile, and its side profiles
	// (Profile-docker for the containers, Profile-loki for a proxied
	// Loki).
	Profiles []string
	// Credentials is the proxied Loki's ("ask" or "vault"); empty when no
	// profile written has a secret.
	Credentials string
	// Proxy is the generated proxy (its Token is shown on TTY only).
	Proxy *authproxy.Result
}