You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by pc...@apache.org on 2022/03/07 08:40:00 UTC
[camel-k] 01/02: feat(cmd/bind): --trait option
This is an automated email from the ASF dual-hosted git repository.
pcongiusti pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-k.git
commit 3683ab0e1fc4f02251b61e79bd50c9b367ee21c4
Author: Pasquale Congiusti <pa...@gmail.com>
AuthorDate: Mon Jan 24 17:05:01 2022 +0100
feat(cmd/bind): --trait option
* Add the possibility to use -t/--trait feature directly on bind
* Code refactorying to reduce duplicates in cmd/run
* Provided a cleaner output for run command
Closes #2596
---
pkg/cmd/bind.go | 42 ++++++-----
pkg/cmd/bind_test.go | 30 ++++++++
pkg/cmd/run.go | 165 +++++++-----------------------------------
pkg/cmd/run_test.go | 196 ++++++++++++++++++++++++++++++++++++--------------
pkg/cmd/trait_help.go | 107 +++++++++++++++++++++++++++
5 files changed, 329 insertions(+), 211 deletions(-)
diff --git a/pkg/cmd/bind.go b/pkg/cmd/bind.go
index 4e581ce..e8c59e2 100644
--- a/pkg/cmd/bind.go
+++ b/pkg/cmd/bind.go
@@ -25,6 +25,7 @@ import (
v1 "github.com/apache/camel-k/pkg/apis/camel/v1"
"github.com/apache/camel-k/pkg/apis/camel/v1alpha1"
+ "github.com/apache/camel-k/pkg/trait"
"github.com/apache/camel-k/pkg/util/kubernetes"
"github.com/apache/camel-k/pkg/util/reference"
"github.com/apache/camel-k/pkg/util/uri"
@@ -64,6 +65,7 @@ func newCmdBind(rootCmdOptions *RootCmdOptions) (*cobra.Command, *bindCmdOptions
cmd.Flags().StringArrayP("property", "p", nil, `Add a binding property in the form of "source.<key>=<value>", "sink.<key>=<value>", "error-handler.<key>=<value>" or "step-<n>.<key>=<value>"`)
cmd.Flags().Bool("skip-checks", false, "Do not verify the binding for compliance with Kamelets and other Kubernetes resources")
cmd.Flags().StringArray("step", nil, `Add binding steps as Kubernetes resources. Endpoints are expected in the format "[[apigroup/]version:]kind:[namespace/]name", plain Camel URIs or Kamelet name.`)
+ cmd.Flags().StringArrayP("trait", "t", nil, `Add a trait to the corresponding Integration.`)
return &cmd, &options
}
@@ -84,6 +86,7 @@ type bindCmdOptions struct {
Properties []string `mapstructure:"properties" yaml:",omitempty"`
SkipChecks bool `mapstructure:"skip-checks" yaml:",omitempty"`
Steps []string `mapstructure:"steps" yaml:",omitempty"`
+ Traits []string `mapstructure:"traits" yaml:",omitempty"`
}
func (o *bindCmdOptions) validate(cmd *cobra.Command, args []string) error {
@@ -128,10 +131,22 @@ func (o *bindCmdOptions) validate(cmd *cobra.Command, args []string) error {
}
}
- return nil
+ client, err := o.GetCmdClient()
+ if err != nil {
+ return err
+ }
+ catalog := trait.NewCatalog(client)
+
+ return validateTraits(catalog, o.Traits)
}
func (o *bindCmdOptions) run(cmd *cobra.Command, args []string) error {
+ client, err := o.GetCmdClient()
+ if err != nil {
+ return err
+ }
+ catalog := trait.NewCatalog(client)
+
source, err := o.decode(args[0], sourceKey)
if err != nil {
return err
@@ -174,28 +189,19 @@ func (o *bindCmdOptions) run(cmd *cobra.Command, args []string) error {
binding.Spec.Steps = append(binding.Spec.Steps, step)
}
}
+ for _, item := range o.Connects {
+ o.Traits = append(o.Traits, fmt.Sprintf("service-binding.services=%s", item))
+ }
- if len(o.Connects) > 0 {
- trait := make(map[string]interface{})
- trait["serviceBindings"] = o.Connects
- specs := make(map[string]v1.TraitSpec)
- data, err := json.Marshal(trait)
- if err != nil {
- return err
+ if len(o.Traits) > 0 {
+ if binding.Spec.Integration == nil {
+ binding.Spec.Integration = &v1.IntegrationSpec{}
}
- var spec v1.TraitSpec
- err = json.Unmarshal(data, &spec.Configuration)
+ traits, err := configureTraits(o.Traits, catalog)
if err != nil {
return err
}
- specs["service-binding"] = spec
- binding.Spec.Integration = &v1.IntegrationSpec{}
- binding.Spec.Integration.Traits = specs
- }
-
- client, err := o.GetCmdClient()
- if err != nil {
- return err
+ binding.Spec.Integration.Traits = traits
}
if o.OutputFormat != "" {
diff --git a/pkg/cmd/bind_test.go b/pkg/cmd/bind_test.go
index 34736d1..d1c396a 100644
--- a/pkg/cmd/bind_test.go
+++ b/pkg/cmd/bind_test.go
@@ -161,3 +161,33 @@ spec:
status: {}
`, output)
}
+
+func TestBindTraits(t *testing.T) {
+ buildCmdOptions, bindCmd, _ := initializeBindCmdOptions(t)
+ output, err := test.ExecuteCommand(bindCmd, cmdBind, "my:src", "my:dst", "-o", "yaml", "-t", "mount.configs=configmap:my-cm", "-c", "my-service-binding")
+ assert.Equal(t, "yaml", buildCmdOptions.OutputFormat)
+
+ assert.Nil(t, err)
+ assert.Equal(t, `apiVersion: camel.apache.org/v1alpha1
+kind: KameletBinding
+metadata:
+ creationTimestamp: null
+ name: my-to-my
+spec:
+ integration:
+ traits:
+ mount:
+ configuration:
+ configs:
+ - configmap:my-cm
+ service-binding:
+ configuration:
+ services:
+ - my-service-binding
+ sink:
+ uri: my:dst
+ source:
+ uri: my:src
+status: {}
+`, output)
+}
diff --git a/pkg/cmd/run.go b/pkg/cmd/run.go
index 3d0aa32..4c74065 100644
--- a/pkg/cmd/run.go
+++ b/pkg/cmd/run.go
@@ -29,7 +29,6 @@ import (
"syscall"
"github.com/magiconair/properties"
- "github.com/mitchellh/mapstructure"
"github.com/pkg/errors"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
@@ -37,7 +36,9 @@ import (
corev1 "k8s.io/api/core/v1"
k8serrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ "k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/util/yaml"
+ "k8s.io/cli-runtime/pkg/printers"
ctrl "sigs.k8s.io/controller-runtime/pkg/client"
@@ -245,7 +246,13 @@ func (o *runCmdOptions) validate() error {
}
}
- return nil
+ client, err := o.GetCmdClient()
+ if err != nil {
+ return err
+ }
+ catalog := trait.NewCatalog(client)
+
+ return validateTraits(catalog, o.Traits)
}
func filterBuildPropertyFiles(maybePropertyFiles []string) []string {
@@ -266,18 +273,6 @@ func (o *runCmdOptions) run(cmd *cobra.Command, args []string) error {
}
catalog := trait.NewCatalog(c)
- tp := catalog.ComputeTraitsProperties()
- for _, t := range o.Traits {
- kv := strings.SplitN(t, "=", 2)
- prefix := kv[0]
- if strings.Contains(prefix, "[") {
- prefix = prefix[0:strings.Index(prefix, "[")]
- }
- if !util.StringSliceExists(tp, prefix) {
- return fmt.Errorf("%s is not a valid trait property", t)
- }
- }
-
integration, err := o.createOrUpdateIntegration(cmd, c, args, catalog)
if err != nil {
return err
@@ -603,32 +598,19 @@ func (o *runCmdOptions) createOrUpdateIntegration(cmd *cobra.Command, c client.C
for _, item := range o.EnvVars {
o.Traits = append(o.Traits, fmt.Sprintf("environment.vars=%s", item))
}
-
- if err := o.configureTraits(integration, o.Traits, catalog); err != nil {
- return nil, err
+ for _, item := range o.Connects {
+ o.Traits = append(o.Traits, fmt.Sprintf("service-binding.services=%s", item))
}
-
- switch o.OutputFormat {
- case "":
- // continue..
- case "yaml":
- data, err := kubernetes.ToYAML(integration)
- if err != nil {
- return nil, err
- }
- fmt.Fprint(cmd.OutOrStdout(), string(data))
- return nil, nil
-
- case "json":
- data, err := kubernetes.ToJSON(integration)
+ if len(o.Traits) > 0 {
+ traits, err := configureTraits(o.Traits, catalog)
if err != nil {
return nil, err
}
- fmt.Fprint(cmd.OutOrStdout(), string(data))
- return nil, nil
+ integration.Spec.Traits = traits
+ }
- default:
- return nil, fmt.Errorf("invalid output format option '%s', should be one of: yaml|json", o.OutputFormat)
+ if o.OutputFormat != "" {
+ return nil, showIntegrationOutput(cmd, integration, o.OutputFormat, c.GetScheme())
}
if existing == nil {
@@ -646,6 +628,14 @@ func (o *runCmdOptions) createOrUpdateIntegration(cmd *cobra.Command, c client.C
return integration, nil
}
+func showIntegrationOutput(cmd *cobra.Command, integration *v1.Integration, outputFormat string, scheme runtime.ObjectTyper) error {
+ printer := printers.NewTypeSetter(scheme)
+ printer.Delegate = &kubernetes.CLIPrinter{
+ Format: outputFormat,
+ }
+ return printer.PrintObj(integration, cmd.OutOrStdout())
+}
+
func (o *runCmdOptions) parseAndConvertToTrait(
c client.Client, integration *v1.Integration, params []string,
parse func(string) (*resource.Config, error),
@@ -703,22 +693,6 @@ func (o *runCmdOptions) GetIntegrationName(sources []string) string {
return name
}
-func (o *runCmdOptions) configureTraits(integration *v1.Integration, options []string, catalog trait.Finder) error {
- // configure ServiceBinding trait
- for _, sb := range o.Connects {
- bindings := fmt.Sprintf("service-binding.services=%s", sb)
- options = append(options, bindings)
- }
- traits, err := configureTraits(options, catalog)
- if err != nil {
- return err
- }
-
- integration.Spec.Traits = traits
-
- return nil
-}
-
func loadPropertyFile(fileName string) (*properties.Properties, error) {
file, err := util.ReadFile(fileName)
if err != nil {
@@ -761,92 +735,3 @@ func resolvePodTemplate(ctx context.Context, templateSrc string, spec *v1.Integr
}
return err
}
-
-func configureTraits(options []string, catalog trait.Finder) (map[string]v1.TraitSpec, error) {
- traits := make(map[string]map[string]interface{})
-
- for _, option := range options {
- parts := traitConfigRegexp.FindStringSubmatch(option)
- if len(parts) < 4 {
- return nil, errors.New("unrecognized config format (expected \"<trait>.<prop>=<value>\"): " + option)
- }
- id := parts[1]
- fullProp := parts[2][1:]
- value := parts[3]
- if _, ok := traits[id]; !ok {
- traits[id] = make(map[string]interface{})
- }
-
- propParts := util.ConfigTreePropertySplit(fullProp)
- var current = traits[id]
- if len(propParts) > 1 {
- c, err := util.NavigateConfigTree(current, propParts[0:len(propParts)-1])
- if err != nil {
- return nil, err
- }
- if cc, ok := c.(map[string]interface{}); ok {
- current = cc
- } else {
- return nil, errors.New("trait configuration cannot end with a slice")
- }
- }
-
- prop := propParts[len(propParts)-1]
- switch v := current[prop].(type) {
- case []string:
- current[prop] = append(v, value)
- case string:
- // Aggregate multiple occurrences of the same option into a string array, to emulate POSIX conventions.
- // This enables executing:
- // $ kamel run -t <trait>.<property>=<value_1> ... -t <trait>.<property>=<value_N>
- // Or:
- // $ kamel run --trait <trait>.<property>=<value_1>,...,<trait>.<property>=<value_N>
- current[prop] = []string{v, value}
- case nil:
- current[prop] = value
- }
- }
-
- specs := make(map[string]v1.TraitSpec)
- for id, config := range traits {
- t := catalog.GetTrait(id)
- if t != nil {
- // let's take a clone to prevent default values set at runtime from being serialized
- zero := reflect.New(reflect.TypeOf(t)).Interface()
- err := configureTrait(config, zero)
- if err != nil {
- return nil, err
- }
- data, err := json.Marshal(zero)
- if err != nil {
- return nil, err
- }
- var spec v1.TraitSpec
- err = json.Unmarshal(data, &spec.Configuration)
- if err != nil {
- return nil, err
- }
- specs[id] = spec
- }
- }
-
- return specs, nil
-}
-
-func configureTrait(config map[string]interface{}, trait interface{}) error {
- md := mapstructure.Metadata{}
-
- decoder, err := mapstructure.NewDecoder(
- &mapstructure.DecoderConfig{
- Metadata: &md,
- WeaklyTypedInput: true,
- TagName: "property",
- Result: &trait,
- },
- )
- if err != nil {
- return err
- }
-
- return decoder.Decode(config)
-}
diff --git a/pkg/cmd/run_test.go b/pkg/cmd/run_test.go
index 98740d6..7f277ed 100644
--- a/pkg/cmd/run_test.go
+++ b/pkg/cmd/run_test.go
@@ -19,8 +19,10 @@ package cmd
import (
"context"
+ "fmt"
"io/ioutil"
"os"
+ "path/filepath"
"testing"
v1 "github.com/apache/camel-k/pkg/apis/camel/v1"
@@ -46,6 +48,17 @@ func initializeRunCmdOptions(t *testing.T) (*runCmdOptions, *cobra.Command, Root
return runCmdOptions, rootCmd, *options
}
+// nolint: unparam
+func initializeRunCmdOptionsWithOutput(t *testing.T) (*runCmdOptions, *cobra.Command, RootCmdOptions) {
+ t.Helper()
+
+ options, rootCmd := kamelTestPreAddCommandInit()
+ runCmdOptions := addTestRunCmdWithOutput(*options, rootCmd)
+ kamelTestPostAddCommandInit(t, rootCmd)
+
+ return runCmdOptions, rootCmd, *options
+}
+
func addTestRunCmd(options RootCmdOptions, rootCmd *cobra.Command) *runCmdOptions {
// add a testing version of run Command
runCmd, runOptions := newCmdRun(&options)
@@ -60,6 +73,17 @@ func addTestRunCmd(options RootCmdOptions, rootCmd *cobra.Command) *runCmdOption
return runOptions
}
+func addTestRunCmdWithOutput(options RootCmdOptions, rootCmd *cobra.Command) *runCmdOptions {
+ // add a testing version of run Command with output
+ runCmd, runOptions := newCmdRun(&options)
+ runCmd.PersistentPreRunE = func(c *cobra.Command, args []string) error {
+ return nil
+ }
+ runCmd.Args = test.ArbitraryArgs
+ rootCmd.AddCommand(runCmd)
+ return runOptions
+}
+
func TestRunNoFlag(t *testing.T) {
runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
_, err := test.ExecuteCommand(rootCmd, cmdRun, integrationSource)
@@ -294,16 +318,27 @@ func TestRunSyncFlag(t *testing.T) {
assert.Equal(t, true, runCmdOptions.Sync)
}
-func TestRunTraitFlag(t *testing.T) {
+func TestRunExistingTraitFlag(t *testing.T) {
runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
_, err := test.ExecuteCommand(rootCmd, cmdRun,
- "--trait", "trait1",
- "--trait", "trait2",
+ "--trait", "jvm.enabled",
+ "--trait", "logging.enabled",
integrationSource)
assert.Nil(t, err)
assert.Len(t, runCmdOptions.Traits, 2)
- assert.Equal(t, "trait1", runCmdOptions.Traits[0])
- assert.Equal(t, "trait2", runCmdOptions.Traits[1])
+ assert.Equal(t, "jvm.enabled", runCmdOptions.Traits[0])
+ assert.Equal(t, "logging.enabled", runCmdOptions.Traits[1])
+}
+
+func TestRunMissingTraitFlag(t *testing.T) {
+ runCmdOptions, rootCmd, _ := initializeRunCmdOptions(t)
+ _, err := test.ExecuteCommand(rootCmd, cmdRun,
+ "--trait", "bogus.missing",
+ integrationSource)
+ assert.NotNil(t, err)
+ assert.Equal(t, "bogus.missing is not a valid trait property", err.Error())
+ assert.Len(t, runCmdOptions.Traits, 1)
+ assert.Equal(t, "bogus.missing", runCmdOptions.Traits[0])
}
func TestConfigureTraits(t *testing.T) {
@@ -373,9 +408,9 @@ func TestTraitsNestedConfig(t *testing.T) {
"--trait", "custom.slice-of-map[3].f=h",
"--trait", "custom.slice-of-map[2].f=i",
"example.js")
- if err != nil {
- t.Error(err)
- }
+ // We will have an error because those traits are not existing
+ // however we want to test how those properties are mapped in the configuration
+ assert.NotNil(t, err)
catalog := &customTraitFinder{}
traits, err := configureTraits(runCmdOptions.Traits, catalog)
@@ -448,51 +483,6 @@ func TestRunValidateArgs(t *testing.T) {
assert.Equal(t, "One of the provided sources is not reachable: missing file or unsupported scheme in missing_file", err.Error())
}
-//
-// This test does work when running as single test but fails
-// otherwise as we are using a global viper instance
-//
-
-/*
-const TestKamelConfigContent = `
-kamel:
- install:
- olm: false
- run:
- integration:
- route:
- sources:
- - examples/dns.js
- - examples/Sample.java
-`
-
-func TestRunWithSavedValues(t *testing.T) {
- dir, err := ioutil.TempDir("", "run-")
- assert.Nil(t, err)
-
- defer func() {
- _ = os.RemoveAll(dir)
- }()
-
- assert.Nil(t, os.Setenv("KAMEL_CONFIG_PATH", dir))
- defer func() {
- _ = os.Unsetenv("KAMEL_CONFIG_PATH")
- }()
-
- assert.Nil(t, ioutil.WriteFile(path.Join(dir, "kamel-config.yaml"), []byte(TestKamelConfigContent), 0644))
-
- options, rootCmd := kamelTestPreAddCommandInit()
-
- runCmdOptions := addTestRunCmd(options, rootCmd)
-
- kamelTestPostAddCommandInit(t, rootCmd)
-
- _, err = test.ExecuteCommand(rootCmd, "run", "route.java")
-
- assert.Nil(t, err)
- assert.Len(t, runCmdOptions.Sources, 2)
-}*/
-
func TestRunBinaryResource(t *testing.T) {
binaryResourceSpec, err := binaryOrTextResource("file.ext", []byte{1, 2, 3, 4}, "application/octet-stream", false, v1.ResourceTypeData, "")
assert.Nil(t, err)
@@ -579,3 +569,103 @@ func TestFilterBuildPropertyFiles(t *testing.T) {
assert.Equal(t, len(outputValues), 1)
assert.Equal(t, outputValues[0], "/tmp/test")
}
+
+const TestSrcContent = `
+import org.apache.camel.builder.RouteBuilder;
+
+public class Sample extends RouteBuilder {
+ @Override
+ public void configure() throws Exception {
+ from("timer:tick")
+ .log("Hello Camel K!");
+ }
+}
+`
+
+func TestOutputYaml(t *testing.T) {
+ var tmpFile *os.File
+ var err error
+ if tmpFile, err = ioutil.TempFile("", "camel-k-"); err != nil {
+ t.Error(err)
+ }
+
+ assert.Nil(t, tmpFile.Close())
+ assert.Nil(t, ioutil.WriteFile(tmpFile.Name(), []byte(TestSrcContent), 0o400))
+ fileName := filepath.Base(tmpFile.Name())
+
+ buildCmdOptions, runCmd, _ := initializeRunCmdOptionsWithOutput(t)
+ output, err := test.ExecuteCommand(runCmd, cmdRun, tmpFile.Name(), "-o", "yaml")
+ assert.Equal(t, "yaml", buildCmdOptions.OutputFormat)
+
+ assert.Nil(t, err)
+ assert.Equal(t, fmt.Sprintf(`apiVersion: camel.apache.org/v1
+kind: Integration
+metadata:
+ creationTimestamp: null
+ name: %s
+spec:
+ sources:
+ - content: "\nimport org.apache.camel.builder.RouteBuilder;\n\npublic class Sample
+ extends RouteBuilder {\n @Override\n public void configure() throws Exception
+ {\n\t from(\"timer:tick\")\n .log(\"Hello Camel K!\");\n }\n}\n"
+ name: %s
+status: {}
+`, fileName, fileName), output)
+}
+
+func TestTrait(t *testing.T) {
+ var tmpFile *os.File
+ var err error
+ if tmpFile, err = ioutil.TempFile("", "camel-k-"); err != nil {
+ t.Error(err)
+ }
+
+ assert.Nil(t, tmpFile.Close())
+ assert.Nil(t, ioutil.WriteFile(tmpFile.Name(), []byte(TestSrcContent), 0o400))
+ fileName := filepath.Base(tmpFile.Name())
+
+ buildCmdOptions, runCmd, _ := initializeRunCmdOptionsWithOutput(t)
+ output, err := test.ExecuteCommand(runCmd, cmdRun, tmpFile.Name(), "-o", "yaml", "-t", "mount.configs=configmap:my-cm", "--connect", "my-service-binding")
+ assert.Equal(t, "yaml", buildCmdOptions.OutputFormat)
+
+ assert.Nil(t, err)
+ assert.Equal(t, fmt.Sprintf(`apiVersion: camel.apache.org/v1
+kind: Integration
+metadata:
+ creationTimestamp: null
+ name: %s
+spec:
+ sources:
+ - content: "\nimport org.apache.camel.builder.RouteBuilder;\n\npublic class Sample
+ extends RouteBuilder {\n @Override\n public void configure() throws Exception
+ {\n\t from(\"timer:tick\")\n .log(\"Hello Camel K!\");\n }\n}\n"
+ name: %s
+ traits:
+ mount:
+ configuration:
+ configs:
+ - configmap:my-cm
+ service-binding:
+ configuration:
+ services:
+ - my-service-binding
+status: {}
+`, fileName, fileName), output)
+}
+
+func TestMissingTrait(t *testing.T) {
+ var tmpFile *os.File
+ var err error
+ if tmpFile, err = ioutil.TempFile("", "camel-k-"); err != nil {
+ t.Error(err)
+ }
+
+ assert.Nil(t, tmpFile.Close())
+ assert.Nil(t, ioutil.WriteFile(tmpFile.Name(), []byte(TestSrcContent), 0o400))
+
+ buildCmdOptions, runCmd, _ := initializeRunCmdOptionsWithOutput(t)
+ output, err := test.ExecuteCommand(runCmd, cmdRun, tmpFile.Name(), "-o", "yaml", "-t", "bogus.fail=i-must-fail")
+ assert.Equal(t, "yaml", buildCmdOptions.OutputFormat)
+ assert.Equal(t, "Error: bogus.fail=i-must-fail is not a valid trait property\n", output)
+ assert.NotNil(t, err)
+}
diff --git a/pkg/cmd/trait_help.go b/pkg/cmd/trait_help.go
index 0ef7bc9..b56e8c6 100644
--- a/pkg/cmd/trait_help.go
+++ b/pkg/cmd/trait_help.go
@@ -26,12 +26,14 @@ import (
"strings"
"github.com/fatih/structs"
+ "github.com/mitchellh/mapstructure"
"github.com/spf13/cobra"
"gopkg.in/yaml.v2"
v1 "github.com/apache/camel-k/pkg/apis/camel/v1"
"github.com/apache/camel-k/pkg/resources"
"github.com/apache/camel-k/pkg/trait"
+ "github.com/apache/camel-k/pkg/util"
"github.com/apache/camel-k/pkg/util/indentedwriter"
)
@@ -261,3 +263,108 @@ func outputTraits(descriptions []*traitDescription) (string, error) {
return nil
})
}
+
+func validateTraits(catalog *trait.Catalog, traits []string) error {
+ tp := catalog.ComputeTraitsProperties()
+ for _, t := range traits {
+ kv := strings.SplitN(t, "=", 2)
+ prefix := kv[0]
+ if strings.Contains(prefix, "[") {
+ prefix = prefix[0:strings.Index(prefix, "[")]
+ }
+ if !util.StringSliceExists(tp, prefix) {
+ return fmt.Errorf("%s is not a valid trait property", t)
+ }
+ }
+
+ return nil
+}
+
+func configureTraits(options []string, catalog trait.Finder) (map[string]v1.TraitSpec, error) {
+ traits := make(map[string]map[string]interface{})
+
+ for _, option := range options {
+ parts := traitConfigRegexp.FindStringSubmatch(option)
+ if len(parts) < 4 {
+ return nil, errors.New("unrecognized config format (expected \"<trait>.<prop>=<value>\"): " + option)
+ }
+ id := parts[1]
+ fullProp := parts[2][1:]
+ value := parts[3]
+ if _, ok := traits[id]; !ok {
+ traits[id] = make(map[string]interface{})
+ }
+
+ propParts := util.ConfigTreePropertySplit(fullProp)
+ var current = traits[id]
+ if len(propParts) > 1 {
+ c, err := util.NavigateConfigTree(current, propParts[0:len(propParts)-1])
+ if err != nil {
+ return nil, err
+ }
+ if cc, ok := c.(map[string]interface{}); ok {
+ current = cc
+ } else {
+ return nil, errors.New("trait configuration cannot end with a slice")
+ }
+ }
+
+ prop := propParts[len(propParts)-1]
+ switch v := current[prop].(type) {
+ case []string:
+ current[prop] = append(v, value)
+ case string:
+ // Aggregate multiple occurrences of the same option into a string array, to emulate POSIX conventions.
+ // This enables executing:
+ // $ kamel run -t <trait>.<property>=<value_1> ... -t <trait>.<property>=<value_N>
+ // Or:
+ // $ kamel run --trait <trait>.<property>=<value_1>,...,<trait>.<property>=<value_N>
+ current[prop] = []string{v, value}
+ case nil:
+ current[prop] = value
+ }
+ }
+
+ specs := make(map[string]v1.TraitSpec)
+ for id, config := range traits {
+ t := catalog.GetTrait(id)
+ if t != nil {
+ // let's take a clone to prevent default values set at runtime from being serialized
+ zero := reflect.New(reflect.TypeOf(t)).Interface()
+ err := configureTrait(config, zero)
+ if err != nil {
+ return nil, err
+ }
+ data, err := json.Marshal(zero)
+ if err != nil {
+ return nil, err
+ }
+ var spec v1.TraitSpec
+ err = json.Unmarshal(data, &spec.Configuration)
+ if err != nil {
+ return nil, err
+ }
+ specs[id] = spec
+ }
+ }
+
+ return specs, nil
+}
+
+func configureTrait(config map[string]interface{}, trait interface{}) error {
+ md := mapstructure.Metadata{}
+
+ decoder, err := mapstructure.NewDecoder(
+ &mapstructure.DecoderConfig{
+ Metadata: &md,
+ WeaklyTypedInput: true,
+ TagName: "property",
+ Result: &trait,
+ },
+ )
+ if err != nil {
+ return err
+ }
+
+ return decoder.Decode(config)
+}