Files
scriptorium/internal/adapter/cli/selection.go

113 lines
5.3 KiB
Go

package cli
import (
"context"
"errors"
"strconv"
appconfig "gitea.maximumdirect.net/eric/scriptorium/internal/config"
"go.maximumdirect.net/ckconfig"
"go.maximumdirect.net/commandkit"
"go.maximumdirect.net/configkit"
"go.maximumdirect.net/promptkit"
)
// applicationInput holds only application-owned selectors. Supplied retains the
// distinction between omission and a caller's empty or zero value.
type applicationInput struct {
Addr commandkit.Supplied[string]
ArtifactRoot commandkit.Supplied[string]
MaxRequestBytes commandkit.Supplied[int64]
MaxArtifactBytes commandkit.Supplied[int64]
MaxResponseBytes commandkit.Supplied[int64]
}
func configurationSelectors[I any](target func(*I) *ckconfig.Selection) []commandkit.Flag[I] {
return []commandkit.Flag[I]{
commandkit.ValueFlag(commandkit.FlagMeta{Name: "config", Usage: "Select the application configuration file.", Completion: commandkit.CompleteFiles()}, (*string)(nil), parseString,
func(input *I, value commandkit.Supplied[string]) { target(input).Config = value }),
commandkit.ValueFlag(commandkit.FlagMeta{Name: "overlay", Usage: "Select an application overlay by name."}, (*string)(nil), parseString,
func(input *I, value commandkit.Supplied[string]) { target(input).Overlay = value }),
}
}
func serverSelectors[I any](target func(*I) *applicationInput) []commandkit.Flag[I] {
stringFlag := func(name, usage string, completion commandkit.CompletionHint, field func(*applicationInput) *commandkit.Supplied[string]) commandkit.Flag[I] {
return commandkit.ValueFlag(commandkit.FlagMeta{Name: name, Usage: usage, Completion: completion}, (*string)(nil), parseString,
func(input *I, value commandkit.Supplied[string]) { *field(target(input)) = value })
}
limitFlag := func(name, usage string, field func(*applicationInput) *commandkit.Supplied[int64]) commandkit.Flag[I] {
return commandkit.ValueFlag(commandkit.FlagMeta{Name: name, Usage: usage}, (*int64)(nil), func(raw string) (int64, error) { return strconv.ParseInt(raw, 10, 64) },
func(input *I, value commandkit.Supplied[int64]) { *field(target(input)) = value })
}
return []commandkit.Flag[I]{
stringFlag("addr", "HTTP listen address.", commandkit.NoCompletion(), func(input *applicationInput) *commandkit.Supplied[string] { return &input.Addr }),
stringFlag("artifact-root", "HTTP artifact root.", commandkit.CompleteDirectories(), func(input *applicationInput) *commandkit.Supplied[string] { return &input.ArtifactRoot }),
limitFlag("max-request-bytes", "HTTP request byte limit (zero is unlimited).", func(input *applicationInput) *commandkit.Supplied[int64] { return &input.MaxRequestBytes }),
limitFlag("max-artifact-bytes", "HTTP artifact byte limit (zero is unlimited).", func(input *applicationInput) *commandkit.Supplied[int64] { return &input.MaxArtifactBytes }),
limitFlag("max-response-bytes", "HTTP response byte limit (zero is unlimited).", func(input *applicationInput) *commandkit.Supplied[int64] { return &input.MaxResponseBytes }),
}
}
func parseString(raw string) (string, error) { return raw, nil }
func namedApplicationOverrides(input applicationInput) []configkit.Override {
var records []configkit.Override
appendString := func(path configkit.Path, flag string, value commandkit.Supplied[string]) {
if value.Set {
records = append(records, configkit.Override{Path: path, Value: value.Value, Flag: flag})
}
}
appendLimit := func(key, flag string, value commandkit.Supplied[int64]) {
if value.Set {
records = append(records, configkit.Override{Path: configkit.Keys("server", key), Value: value.Value, Flag: flag})
}
}
appendString(configkit.Keys("server", "addr"), "--addr", input.Addr)
appendString(configkit.Keys("server", "artifact_root"), "--artifact-root", input.ArtifactRoot)
appendLimit("max_request_bytes", "--max-request-bytes", input.MaxRequestBytes)
appendLimit("max_artifact_bytes", "--max-artifact-bytes", input.MaxArtifactBytes)
appendLimit("max_response_bytes", "--max-response-bytes", input.MaxResponseBytes)
return records
}
func loadApplication(ctx context.Context, selection ckconfig.Selection, input applicationInput, _ struct{}) (*configkit.Result[appconfig.Document], error) {
if err := ctx.Err(); err != nil {
return nil, err
}
result, err := appconfig.Load(appconfig.LoadOptions{
Path: selection.Config.Value, Explicit: selection.Config.Set, Overlay: selection.Overlay.Value,
Overrides: append(namedApplicationOverrides(input), selection.Overrides...),
})
if err != nil {
return nil, err
}
if err := ctx.Err(); err != nil {
return result, err
}
return result, nil
}
func loadEngine(ctx context.Context, selection ckconfig.Selection, input applicationInput, state *acquisitionState) (*promptkit.Engine, error) {
result, err := loadApplication(ctx, selection, input, struct{}{})
if state != nil {
evidence := applicationAcquisition{err: err}
if result != nil {
evidence.sources, evidence.records = result.Sources(), result.Diagnostics()
}
var native *configkit.LoadError
if errors.As(err, &native) && native != nil {
evidence.sources, evidence.records = native.Sources(), native.Diagnostics()
}
state.applications = append(state.applications, evidence)
if err != nil {
return nil, errApplicationAcquisition
}
}
if err != nil {
return nil, err
}
settings := appconfig.Settings(result.Config)
return newEngine(settings)
}