113 lines
5.3 KiB
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 nil, 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)
|
|
}
|