emissary/internal/command/api/agent/spec/update.go

186 lines
4.1 KiB
Go
Raw Normal View History

package spec
import (
"encoding/json"
"os"
"forge.cadoles.com/Cadoles/emissary/internal/client"
2023-03-10 11:28:37 +01:00
agentFlag "forge.cadoles.com/Cadoles/emissary/internal/command/api/agent/flag"
"forge.cadoles.com/Cadoles/emissary/internal/command/api/apierr"
clientFlag "forge.cadoles.com/Cadoles/emissary/internal/command/api/flag"
"forge.cadoles.com/Cadoles/emissary/internal/format"
"forge.cadoles.com/Cadoles/emissary/internal/spec"
jsonpatch "github.com/evanphx/json-patch/v5"
"github.com/pkg/errors"
"github.com/urfave/cli/v2"
)
func UpdateCommand() *cli.Command {
return &cli.Command{
Name: "update",
Usage: "Update agent specification",
Flags: agentFlag.WithAgentFlags(
&cli.StringFlag{
Name: "spec-name",
2023-03-13 10:44:58 +01:00
Usage: "use `NAME` as specification's name",
},
&cli.StringFlag{
Name: "spec-data",
2023-03-13 10:44:58 +01:00
Usage: "use `DATA` as specification's data, '-' to read from STDIN",
},
&cli.BoolFlag{
Name: "no-patch",
Usage: "Dont use spec-data as a patch to existing specification",
},
&cli.IntFlag{
Name: "revision",
Usage: "Use `REVISION` as specification revision number",
},
),
Action: func(ctx *cli.Context) error {
baseFlags := clientFlag.GetBaseFlags(ctx)
agentID, err := agentFlag.AssertAgentID(ctx)
if err != nil {
return errors.WithStack(err)
}
specName, err := assertSpecName(ctx)
if err != nil {
return errors.WithStack(err)
}
specData, err := assertSpecData(ctx)
if err != nil {
return errors.WithStack(err)
}
noPatch := ctx.Bool("no-patch")
token, err := clientFlag.GetToken(baseFlags)
if err != nil {
return errors.WithStack(apierr.Wrap(err))
}
client := client.New(baseFlags.ServerURL, client.WithToken(token))
specs, err := client.GetAgentSpecs(ctx.Context, agentID)
if err != nil {
return errors.WithStack(apierr.Wrap(err))
}
var existingSpec spec.Spec
for _, s := range specs {
if s.SpecName() != specName {
continue
}
existingSpec = s
break
}
revision := 0
if existingSpec != nil {
originSpecData := existingSpec.SpecData()
if !noPatch {
specData, err = applyPatch(originSpecData, specData)
if err != nil {
return errors.WithStack(err)
}
}
revision = existingSpec.SpecRevision()
}
if specificRevision := ctx.Int("revision"); specificRevision != 0 {
revision = specificRevision
}
rawSpec := &spec.RawSpec{
Name: specName,
Revision: revision,
Data: specData,
}
if err := spec.Validate(ctx.Context, rawSpec); err != nil {
return errors.WithStack(apierr.Wrap(err))
}
spec, err := client.UpdateAgentSpec(ctx.Context, agentID, rawSpec)
if err != nil {
return errors.WithStack(apierr.Wrap(err))
}
hints := format.Hints{
OutputMode: baseFlags.OutputMode,
}
if err := format.Write(baseFlags.Format, os.Stdout, hints, spec); err != nil {
return errors.WithStack(err)
}
return nil
},
}
}
func assertSpecName(ctx *cli.Context) (spec.Name, error) {
specName := ctx.String("spec-name")
if specName == "" {
return "", errors.New("flag 'spec-name' is required")
}
return spec.Name(specName), nil
}
func assertSpecData(ctx *cli.Context) (map[string]any, error) {
rawSpecData := ctx.String("spec-data")
if rawSpecData == "" {
return nil, errors.New("flag 'spec-data' is required")
}
var specData map[string]any
if rawSpecData == "-" {
decoder := json.NewDecoder(os.Stdin)
if err := decoder.Decode(&specData); err != nil {
return nil, errors.WithStack(err)
}
} else {
if err := json.Unmarshal([]byte(rawSpecData), &specData); err != nil {
return nil, errors.WithStack(err)
}
}
return specData, nil
}
func applyPatch(origin any, patch any) (map[string]any, error) {
originJSON, err := json.Marshal(origin)
if err != nil {
return nil, errors.WithStack(err)
}
patchJSON, err := json.Marshal(patch)
if err != nil {
return nil, errors.WithStack(err)
}
result, err := jsonpatch.MergePatch(originJSON, patchJSON)
if err != nil {
return nil, errors.WithStack(err)
}
var specData map[string]any
if err := json.Unmarshal(result, &specData); err != nil {
}
return specData, nil
}