0
0
package compose
import (
"fmt"
"io/fs"
"strings"
"sigs.k8s.io/yaml"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/deploy"
)
const (
OptionMapPath = "apps/option-map.yaml"
MapToOptions = "options"
MapToProfile = "profile"
MapToState = "state"
MapToListener = "listener"
MapToRemoved = "removed"
MapToSpec = "spec."
MapToNetwork = "network."
MapToContract = "contract."
MapToCLI = "cli"
LegacyRemoval = "legacy-transport"
maxOptionValue = 4096
)
type OptionMap struct {
Apps []AppOptions `json:"apps"`
}
type AppOptions struct {
App string `json:"app"`
Entry string `json:"entry"`
Options []OptionMapping `json:"options"`
}
type OptionMapping struct {
Name string `json:"name"`
To string `json:"to"`
Reason string `json:"reason,omitempty"`
}
func LoadOptionMap() (OptionMap, error) {
b, err := fs.ReadFile(deploy.FS, OptionMapPath)
if err != nil {
return OptionMap{}, fmt.Errorf("compose: %w", err)
}
var m OptionMap
if err := yaml.UnmarshalStrict(b, &m); err != nil {
return OptionMap{}, fmt.Errorf("compose: %s: %w", OptionMapPath, err)
}
for _, a := range m.Apps {
for _, o := range a.Options {
switch {
case o.To == MapToOptions, o.To == MapToProfile, o.To == MapToState, o.To == MapToListener, o.To == MapToCLI,
strings.HasPrefix(o.To, MapToSpec), strings.HasPrefix(o.To, MapToNetwork), strings.HasPrefix(o.To, MapToContract):
case o.To == MapToRemoved:
if o.Reason != LegacyRemoval {
return OptionMap{}, fmt.Errorf("compose: %s: %s --%s is removed for %q; the only accepted removal is %s",
OptionMapPath, a.App, o.Name, o.Reason, LegacyRemoval)
}
default:
return OptionMap{}, fmt.Errorf("compose: %s: %s --%s maps to %q", OptionMapPath, a.App, o.Name, o.To)
}
}
}
return m, nil
}
func (m OptionMap) app(name string) (AppOptions, bool) {
for _, a := range m.Apps {
if a.App == name {
return a, true
}
}
return AppOptions{}, false
}
func AppOptionMappings(app string) ([]OptionMapping, error) {
m, err := LoadOptionMap()
if err != nil {
return nil, err
}
a, ok := m.app(app)
if !ok {
return nil, fmt.Errorf("compose: %s names no app %s", OptionMapPath, app)
}
return a.Options, nil
}
func OptionArgs(app string, opts []v1alpha1.ApplicationOption) ([]string, error) {
if len(opts) == 0 {
return nil, nil
}
var out []string
for _, o := range opts {
if len(o.Value) > maxOptionValue {
return nil, fmt.Errorf("compose: --%s of %s is longer than %d bytes", o.Name, app, maxOptionValue)
}
switch o.Value {
case "true":
out = append(out, "--"+o.Name)
case "false":
default:
out = append(out, "--"+o.Name, o.Value)
}
}
return out, nil
}
type AppArg struct {
Name string
Value string
To string
Mapped bool
}
func ParseAppArgs(app string, args []string) ([]AppArg, error) {
if len(args) == 0 {
return nil, nil
}
mapped, err := LoadOptionMap()
if err != nil {
return nil, err
}
known := map[string]OptionMapping{}
if a, ok := mapped.app(app); ok {
for _, o := range a.Options {
known[o.Name] = o
}
}
var out []AppArg
for i := 0; i < len(args); i++ {
arg := args[i]
if !strings.HasPrefix(arg, "--") || arg == "--" {
return nil, fmt.Errorf("compose: %q is no option of %s; pass --name value or --name=value", arg, app)
}
name, value, hasValue := strings.Cut(strings.TrimPrefix(arg, "--"), "=")
if name == "" {
return nil, fmt.Errorf("compose: %s has an option with no name", app)
}
if !hasValue {
value = "true"
if i+1 < len(args) && !strings.HasPrefix(args[i+1], "--") {
i++
value = args[i]
}
}
if len(value) > maxOptionValue {
return nil, fmt.Errorf("compose: --%s of %s is longer than %d bytes", name, app, maxOptionValue)
}
to := MapToOptions
mapping, mapped := known[name]
if mapped {
to = mapping.To
}
if to == MapToRemoved {
return nil, fmt.Errorf("compose: --%s of %s is removed: %s", name, app, known[name].Reason)
}
out = append(out, AppArg{Name: name, Value: value, To: to, Mapped: mapped})
}
return out, nil
}