✨ Add compute-config rig-ops command to dry-run plugin configuration

cmd/rig-ops/cmd/plugins/computeConfig.go

@@ -0,0 +1,82 @@
+package plugins
+
+import (
+	"context"
+	"os"
+
+	"connectrpc.com/connect"
+	"github.com/rigdev/rig-go-api/operator/api/v1/pipeline"
+	"github.com/rigdev/rig/cmd/common"
+	"github.com/rigdev/rig/cmd/rig-ops/cmd/base"
+	"github.com/rigdev/rig/pkg/api/v1alpha2"
+	"github.com/rigdev/rig/pkg/obj"
+	"github.com/spf13/cobra"
+	"gopkg.in/yaml.v3"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+func (c *Cmd) computeConfig(ctx context.Context, _ *cobra.Command, args []string) error {
+	cfg, err := base.GetOperatorConfig(ctx, c.OperatorClient, c.Scheme)
+	if err != nil {
+		return err
+	}
+
+	var spec string
+	var capsule v1alpha2.Capsule
+	if len(args) > 0 {
+		if err := c.K8s.Get(ctx, client.ObjectKey{
+			Namespace: args[0],
+			Name:      args[1],
+		}, &capsule); err != nil {
+			return err
+		}
+	} else if specPath != "" {
+		bytes, err := os.ReadFile(specPath)
+		if err != nil {
+			return err
+		}
+		spec = string(bytes)
+		if err := obj.Decode([]byte(spec), &capsule); err != nil {
+			return err
+		}
+	} else {
+		capsuleList := v1alpha2.CapsuleList{}
+		if err := c.K8s.List(ctx, &capsuleList); err != nil {
+			return err
+		}
+		var choices [][]string
+		for _, c := range capsuleList.Items {
+			choices = append(choices, []string{c.Namespace, c.Name})
+		}
+		idx, err := c.Prompter.TableSelect(
+			"Choose a capsule", choices, []string{"Namespace", "Capsule"}, common.SelectEnableFilterOpt,
+		)
+		if err != nil {
+			return err
+		}
+		choice := choices[idx]
+		if err := c.K8s.Get(ctx, client.ObjectKey{
+			Namespace: choice[0],
+			Name:      choice[1],
+		}, &capsule); err != nil {
+			return err
+		}
+	}
+
+	cfgBytes, err := yaml.Marshal(cfg)
+	if err != nil {
+		return err
+	}
+
+	resp, err := c.OperatorClient.Pipeline.DryRunPluginConfig(ctx, connect.NewRequest(&pipeline.DryRunPluginConfigRequest{
+		Namespace:      capsule.Namespace,
+		Capsule:        capsule.Name,
+		OperatorConfig: string(cfgBytes),
+		CapsuleSpec:    spec,
+	}))
+	if err != nil {
+		return err
+	}
+
+	return common.FormatPrint(resp.Msg.GetSteps(), common.OutputTypeYAML)
+}

cmd/rig-ops/cmd/plugins/setup.go

@@ -120,5 +120,21 @@ The dry run will be executed with the resulting list of plugins.`,
 	}
 	pluginsCmd.AddCommand(list)
 
+	computeConfig := &cobra.Command{
+		Use: "compute-config",
+		//nolint:lll
+		Short: "Given an operator config and a capsule spec, computes the configuration generated for each plugin.",
+		Args: func(_ *cobra.Command, args []string) error {
+			if len(args) != 0 && len(args) != 2 {
+				return errors.New("takes exactly 0 or 2 arguments")
+			}
+			return nil
+		},
+		RunE: cli.CtxWrap(cmd.computeConfig),
+	}
+	//nolint:lll
+	computeConfig.Flags().StringVar(&specPath, "spec", "", "If given, will read the capsule spec at the path instead of using the capsule spec of an existing capsule from the platform")
+	pluginsCmd.AddCommand(computeConfig)
+
 	parent.AddCommand(pluginsCmd)
 }

pkg/controller/plugin/external_plugin.go

@@ -186,6 +186,12 @@ func (p *pluginExecutor) WatchObjectStatus(
 	return p.pluginClient.WatchObjectStatus(ctx, namespace, capsule, callback, p.id)
 }
 
+func (p *pluginExecutor) ComputeConfig(ctx context.Context, req pipeline.CapsuleRequest) (string, error) {
+	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
+	defer cancel()
+	return p.pluginClient.ComputeConfig(ctx, req)
+}
+
 type rigOperatorPlugin struct {
 	plugin.NetRPCUnsupportedPlugin
 	logger hclog.Logger
@@ -239,23 +245,10 @@ func (m *pluginClient) Initialize(ctx context.Context, pluginConfig, tag string,
 }
 
 func (m *pluginClient) Run(ctx context.Context, req pipeline.CapsuleRequest, opts pipeline.Options) error {
-	reqServer := &requestServer{req: req}
-	capsuleBytes, err := obj.Encode(req.Capsule(), req.Scheme())
+	s, brokerID, err := m.setupGRPCServer(req)
 	if err != nil {
 		return err
 	}
-
-	c := make(chan *grpc.Server)
-	serverFunc := func(opts []grpc.ServerOption) *grpc.Server {
-		s := grpc.NewServer(opts...)
-		apiplugin.RegisterRequestServiceServer(s, reqServer)
-		c <- s
-		return s
-	}
-
-	brokerID := m.broker.NextId()
-	go m.broker.AcceptAndServe(brokerID, serverFunc)
-	s := <-c
 	defer s.Stop()
 
 	var additionalObjects [][]byte
@@ -267,6 +260,10 @@ func (m *pluginClient) Run(ctx context.Context, req pipeline.CapsuleRequest, opt
 		additionalObjects = append(additionalObjects, bs)
 	}
 
+	capsuleBytes, err := obj.Encode(req.Capsule(), req.Scheme())
+	if err != nil {
+		return err
+	}
 	_, err = m.client.RunCapsule(ctx, &apiplugin.RunCapsuleRequest{
 		RunServer:         brokerID,
 		CapsuleObject:     capsuleBytes,
@@ -276,6 +273,21 @@ func (m *pluginClient) Run(ctx context.Context, req pipeline.CapsuleRequest, opt
 	return err
 }
 
+func (m *pluginClient) setupGRPCServer(req pipeline.CapsuleRequest) (*grpc.Server, uint32, error) {
+	reqServer := &requestServer{req: req}
+	c := make(chan *grpc.Server)
+	serverFunc := func(opts []grpc.ServerOption) *grpc.Server {
+		s := grpc.NewServer(opts...)
+		apiplugin.RegisterRequestServiceServer(s, reqServer)
+		c <- s
+		return s
+	}
+	brokerID := m.broker.NextId()
+	go m.broker.AcceptAndServe(brokerID, serverFunc)
+	s := <-c
+	return s, brokerID, nil
+}
+
 func (m *pluginClient) WatchObjectStatus(
 	ctx context.Context,
 	namespace string,
@@ -301,6 +313,26 @@ func (m *pluginClient) WatchObjectStatus(
 	}
 }
 
+func (m *pluginClient) ComputeConfig(ctx context.Context, req pipeline.CapsuleRequest) (string, error) {
+	s, brokerID, err := m.setupGRPCServer(req)
+	if err != nil {
+		return "", err
+	}
+	defer s.Stop()
+
+	capsuleBytes, err := obj.Encode(req.Capsule(), req.Scheme())
+	if err != nil {
+		return "", err
+	}
+
+	resp, err := m.client.ComputeConfig(ctx, &apiplugin.ComputeConfigRequest{
+		RunServer:     brokerID,
+		CapsuleObject: capsuleBytes,
+	})
+
+	return resp.GetConfig(), err
+}
+
 type requestServer struct {
 	apiplugin.UnimplementedRequestServiceServer
 

pkg/controller/plugin/helpers.go

@@ -2,14 +2,16 @@ package plugin
 
 import (
 	"bytes"
+	"encoding/json"
 	"html/template"
 
 	"github.com/mitchellh/mapstructure"
 	"github.com/rigdev/rig/pkg/obj"
 	"github.com/rigdev/rig/pkg/pipeline"
+	"sigs.k8s.io/yaml"
 )
 
-type ParseStep[T any] func(config T, req pipeline.CapsuleRequest) (string, any, error)
+type ParseStep[T any] func(config T, req pipeline.CapsuleRequest) (map[string]any, error)
 
 // ParseCapsuleTemplatedConfig parses the given data as a Go template with
 // the capsule as a templating context under '.capsule'
@@ -21,25 +23,30 @@ func ParseCapsuleTemplatedConfig[T any](data []byte, req pipeline.CapsuleRequest
 // Using this, we parse the config at every execution of the plugin.
 // If we get performance issues due to that we can try and optimize that.
 func ParseTemplatedConfig[T any](data []byte, req pipeline.CapsuleRequest, steps ...ParseStep[T]) (T, error) {
+	if len(data) == 0 {
+		data = []byte("{}")
+	}
 	var config, empty T
 
 	values := map[string]any{}
 	for _, step := range steps {
-		name, obj, err := step(config, req)
+		m, err := step(config, req)
 		if err != nil {
 			return empty, err
 		}
 
-		result := map[string]interface{}{}
-		d, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{TagName: "json", Result: &result})
-		if err != nil {
-			return empty, err
+		for k, v := range m {
+			result := map[string]interface{}{}
+			d, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{TagName: "json", Result: &result})
+			if err != nil {
+				return empty, err
+			}
+			if err := d.Decode(v); err != nil {
+				return empty, err
+			}
+			values[k] = result
 		}
 
-		if err := d.Decode(obj); err != nil {
-			return empty, err
-		}
-		values[name] = result
 		t, err := template.New("config").Parse(string(data))
 		if err != nil {
 			return empty, err
@@ -56,10 +63,32 @@ func ParseTemplatedConfig[T any](data []byte, req pipeline.CapsuleRequest, steps
 	return config, nil
 }
 
-func CapsuleStep[T any](_ T, req pipeline.CapsuleRequest) (string, any, error) {
-	return "capsule", req.Capsule(), nil
+func CapsuleStep[T any](_ T, req pipeline.CapsuleRequest) (map[string]any, error) {
+	c := req.Capsule()
+	extensions := map[string]any{}
+	for k, v := range c.Spec.Extensions {
+		vv := map[string]any{}
+		if err := json.Unmarshal(v, &vv); err != nil {
+			return nil, err
+		}
+		extensions[k] = vv
+	}
+	c.Spec.Extensions = nil
+	return map[string]any{
+		"capsule":           c,
+		"capsuleExtensions": extensions,
+	}, nil
 }
 
 func LoadYAMLConfig(data []byte, out any) error {
 	return obj.Decode(data, out)
 }
+
+func ParseCapsuleTemplatedConfigToString[T any](data []byte, req pipeline.CapsuleRequest) (string, error) {
+	obj, err := ParseCapsuleTemplatedConfig[T](data, req)
+	if err != nil {
+		return "", err
+	}
+	bs, err := yaml.Marshal(obj)
+	return string(bs), err
+}

pkg/controller/plugin/helpers_test.go

@@ -0,0 +1,57 @@
+package plugin
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+
+	"github.com/go-logr/logr"
+	"github.com/rigdev/rig/pkg/api/v1alpha2"
+	"github.com/rigdev/rig/pkg/pipeline"
+	"github.com/rigdev/rig/pkg/scheme"
+	"github.com/stretchr/testify/require"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func Test_ParseCapsuleTemplatedConfig(t *testing.T) {
+	name, namespace := "name", "namespace"
+	vm := scheme.NewVersionMapperFromScheme(scheme.New())
+	p := pipeline.NewCapsulePipeline(nil, scheme.New(), vm, logr.FromContextOrDiscard(context.Background()))
+
+	req := pipeline.NewCapsuleRequest(p, &v1alpha2.Capsule{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      name,
+			Namespace: namespace,
+		},
+		Spec: v1alpha2.CapsuleSpec{
+			Extensions: map[string]json.RawMessage{
+				"ext": json.RawMessage(`{"field": "value"}`),
+			},
+			Scale: v1alpha2.CapsuleScale{
+				Horizontal: v1alpha2.HorizontalScale{
+					Instances: v1alpha2.Instances{
+						Min: 69,
+					},
+				},
+			},
+		},
+	}, nil)
+
+	s := `hej: asdf
+hej2: {{ .capsuleExtensions.ext.field  }}
+hej3: {{ .capsule.spec.scale.horizontal.instances.min }}`
+	conf, err := ParseCapsuleTemplatedConfig[config]([]byte(s), req)
+	require.NoError(t, err)
+
+	require.Equal(t, config{
+		Hej:  "asdf",
+		Hej2: "value",
+		Hej3: 69,
+	}, conf)
+}
+
+type config struct {
+	Hej  string `json:"hej"`
+	Hej2 string `json:"hej2"`
+	Hej3 int    `json:"hej3"`
+}

pkg/controller/plugin/manager.go

@@ -234,7 +234,9 @@ func (m *Manager) GetPlugins() []Info {
 	return plugins
 }
 
-func (m *Manager) NewStep(execCtx ExecutionContext, step v1alpha1.Step, logger logr.Logger) (*Step, error) {
+func (m *Manager) NewStep(
+	execCtx ExecutionContext, step v1alpha1.Step, logger logr.Logger, name string,
+) (*Step, error) {
 	var err error
 	var ps []*pluginExecutor
 	defer func() {
@@ -274,6 +276,7 @@ func (m *Manager) NewStep(execCtx ExecutionContext, step v1alpha1.Step, logger l
 		logger:  logger,
 		plugins: ps,
 		matcher: matcher,
+		name:    name,
 	}, nil
 }