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 cdfcc91d98089a2331832a41378e576116c7bc07 Author: Pasquale Congiusti <[email protected]> AuthorDate: Mon Nov 29 17:22:04 2021 +0100 feat(cmd/run): config content type With this new field we know if a Config option is used as a resource or a configuration to be parsed --- pkg/cmd/run_help.go | 6 ++--- pkg/util/resource/config.go | 51 ++++++++++++++++++++++++++-------------- pkg/util/resource/config_test.go | 30 +++++++++++------------ 3 files changed, 52 insertions(+), 35 deletions(-) diff --git a/pkg/cmd/run_help.go b/pkg/cmd/run_help.go index 186eecb..c87df46 100644 --- a/pkg/cmd/run_help.go +++ b/pkg/cmd/run_help.go @@ -65,7 +65,7 @@ func ApplyResourceOption(ctx context.Context, config *resource.Config, integrati func applyOption(ctx context.Context, config *resource.Config, integration *v1.Integration, c client.Client, namespace string, enableCompression bool, resourceType v1.ResourceType) (*corev1.ConfigMap, error) { var maybeGenCm *corev1.ConfigMap - switch config.Type() { + switch config.StorageType() { case resource.StorageTypeConfigmap: cm := kubernetes.LookupConfigmap(ctx, c, namespace, config.Name()) if cm == nil { @@ -99,10 +99,10 @@ func applyOption(ctx context.Context, config *resource.Config, integration *v1.I } default: // Should never reach this - return maybeGenCm, fmt.Errorf("invalid option type %s", config.Type()) + return maybeGenCm, fmt.Errorf("invalid option type %s", config.StorageType()) } - integration.Spec.AddConfigurationAsResource(string(config.Type()), config.Name(), string(resourceType), config.DestinationPath(), config.Key()) + integration.Spec.AddConfigurationAsResource(string(config.StorageType()), config.Name(), string(resourceType), config.DestinationPath(), config.Key()) return maybeGenCm, nil } diff --git a/pkg/util/resource/config.go b/pkg/util/resource/config.go index f5ff97d..a09f372 100644 --- a/pkg/util/resource/config.go +++ b/pkg/util/resource/config.go @@ -37,7 +37,8 @@ var invalidPaths = []string{"/etc/camel", "/deployments/dependencies"} // Config represents a config option. type Config struct { - configType StorageType + storageType StorageType + contentType ContentType resourceName string resourceKey string destinationPath string @@ -48,9 +49,14 @@ func (config *Config) DestinationPath() string { return config.destinationPath } -// Type is the type, converted as string. -func (config *Config) Type() StorageType { - return config.configType +// StorageType is the type of storage used for the configuration. +func (config *Config) StorageType() StorageType { + return config.storageType +} + +// ContentType is the type of content used for the configuration. +func (config *Config) ContentType() ContentType { + return config.contentType } // Name is the name of the resource. @@ -90,24 +96,35 @@ const ( StorageTypeFile StorageType = "file" ) +// ContentType represent what kind of a content is, either data or purely text configuration. +type ContentType string + +const ( + // ContentTypeData can contain binary content, won't be parsed to look for user properties. + ContentTypeData ContentType = "data" + // ContentTypeText can't contain binary content, will be parsed to look for user properties. + ContentTypeText ContentType = "text" +) + var ( validConfigSecretRegexp = regexp.MustCompile(`^(configmap|secret)\:([\w\.\-\_\:\/@]+)$`) validFileRegexp = regexp.MustCompile(`^file\:([\w\.\-\_\:\/@" ]+)$`) validResourceRegexp = regexp.MustCompile(`^([\w\.\-\_\:]+)(\/([\w\.\-\_\:]+))?(\@([\w\.\-\_\:\/]+))?$`) ) -func newConfig(configType StorageType, value string) *Config { - rn, mk, mp := parseResourceValue(configType, value) +func newConfig(storageType StorageType, contentType ContentType, value string) *Config { + rn, mk, mp := parseResourceValue(storageType, value) return &Config{ - configType: configType, + storageType: storageType, + contentType: contentType, resourceName: rn, resourceKey: mk, destinationPath: mp, } } -func parseResourceValue(configType StorageType, value string) (resource string, maybeKey string, maybeDestinationPath string) { - if configType == StorageTypeFile { +func parseResourceValue(storageType StorageType, value string) (resource string, maybeKey string, maybeDestinationPath string) { + if storageType == StorageTypeFile { resource, maybeDestinationPath = ParseFileValue(value) return resource, "", maybeDestinationPath } @@ -139,25 +156,25 @@ func parseCMOrSecretValue(value string) (resource string, maybeKey string, maybe // ParseResource will parse and return a Config. func ParseResource(item string) (*Config, error) { // Deprecated: ensure backward compatibility with `--resource filename` format until version 1.5.x - // then replace with parseOption() func directly - option, err := parse(item) + // then replace with parse() func directly + resource, err := parse(item, ContentTypeData) if err != nil { if strings.HasPrefix(err.Error(), "could not match config, secret or file configuration") { fmt.Printf("Warn: --resource %s has been deprecated. You should use --resource file:%s instead.\n", item, item) - return parse("file:" + item) + return parse("file:"+item, ContentTypeData) } return nil, err } - return option, nil + return resource, nil } // ParseConfig will parse and return a Config. func ParseConfig(item string) (*Config, error) { - return parse(item) + return parse(item, ContentTypeText) } -func parse(item string) (*Config, error) { +func parse(item string, contentType ContentType) (*Config, error) { var cot StorageType var value string switch { @@ -180,7 +197,7 @@ func parse(item string) (*Config, error) { return nil, fmt.Errorf("could not match config, secret or file configuration as %s", item) } - configurationOption := newConfig(cot, value) + configurationOption := newConfig(cot, contentType, value) if err := configurationOption.Validate(); err != nil { return nil, err } @@ -216,7 +233,7 @@ func ConvertFileToConfigmap(ctx context.Context, c client.Client, resourceSpec v return cm, err } } - config.configType = StorageTypeConfigmap + config.storageType = StorageTypeConfigmap config.resourceName = cm.Name return cm, nil diff --git a/pkg/util/resource/config_test.go b/pkg/util/resource/config_test.go index 44173f9..5d7fb24 100644 --- a/pkg/util/resource/config_test.go +++ b/pkg/util/resource/config_test.go @@ -32,21 +32,21 @@ func TestParseConfigOption(t *testing.T) { configmap, err := ParseConfig(validConfigMap) assert.Nil(t, err) - assert.Equal(t, StorageTypeConfigmap, configmap.configType) + assert.Equal(t, StorageTypeConfigmap, configmap.storageType) assert.Equal(t, "my-config_map", configmap.Name()) secret, err := ParseConfig(validSecret) assert.Nil(t, err) - assert.Equal(t, StorageTypeSecret, secret.configType) + assert.Equal(t, StorageTypeSecret, secret.storageType) assert.Equal(t, "my-secret", secret.Name()) file, err := ParseConfig(validFile) assert.Nil(t, err) - assert.Equal(t, StorageTypeFile, file.configType) + assert.Equal(t, StorageTypeFile, file.storageType) assert.Equal(t, "/tmp/my-file.txt", file.Name()) _, err = ParseConfig(notValid) assert.NotNil(t, err) location, err := ParseConfig(validLocation) assert.Nil(t, err) - assert.Equal(t, StorageTypeFile, location.configType) + assert.Equal(t, StorageTypeFile, location.storageType) assert.Equal(t, "my-file.txt", location.Name()) assert.Equal(t, "/tmp/another-name.xml", location.DestinationPath()) } @@ -66,77 +66,77 @@ func TestParseConfigOptionAllParams(t *testing.T) { parsedCm1, err := ParseConfig(cm1) assert.Nil(t, err) - assert.Equal(t, StorageTypeConfigmap, parsedCm1.Type()) + assert.Equal(t, StorageTypeConfigmap, parsedCm1.StorageType()) assert.Equal(t, "my-config_map", parsedCm1.Name()) assert.Equal(t, "key", parsedCm1.Key()) assert.Equal(t, "/tmp/my", parsedCm1.DestinationPath()) parsedCm2, err := ParseConfig(cm2) assert.Nil(t, err) - assert.Equal(t, StorageTypeConfigmap, parsedCm2.Type()) + assert.Equal(t, StorageTypeConfigmap, parsedCm2.StorageType()) assert.Equal(t, "my-config_map", parsedCm2.Name()) assert.Equal(t, "key", parsedCm2.Key()) assert.Equal(t, "", parsedCm2.DestinationPath()) parsedCm3, err := ParseConfig(cm3) assert.Nil(t, err) - assert.Equal(t, StorageTypeConfigmap, parsedCm3.Type()) + assert.Equal(t, StorageTypeConfigmap, parsedCm3.StorageType()) assert.Equal(t, "my-config_map", parsedCm3.Name()) assert.Equal(t, "", parsedCm3.Key()) assert.Equal(t, "/tmp/my", parsedCm3.DestinationPath()) parsedCm4, err := ParseConfig(cm4) assert.Nil(t, err) - assert.Equal(t, StorageTypeConfigmap, parsedCm4.Type()) + assert.Equal(t, StorageTypeConfigmap, parsedCm4.StorageType()) assert.Equal(t, "my-config_map", parsedCm4.Name()) assert.Equal(t, "", parsedCm4.Key()) assert.Equal(t, "", parsedCm4.DestinationPath()) parsedSec1, err := ParseConfig(sec1) assert.Nil(t, err) - assert.Equal(t, StorageTypeSecret, parsedSec1.Type()) + assert.Equal(t, StorageTypeSecret, parsedSec1.StorageType()) assert.Equal(t, "sec", parsedSec1.Name()) assert.Equal(t, "key", parsedSec1.Key()) assert.Equal(t, "/tmp/sec", parsedSec1.DestinationPath()) parsedSec2, err := ParseConfig(sec2) assert.Nil(t, err) - assert.Equal(t, StorageTypeSecret, parsedSec2.Type()) + assert.Equal(t, StorageTypeSecret, parsedSec2.StorageType()) assert.Equal(t, "sec", parsedSec2.Name()) assert.Equal(t, "key", parsedSec2.Key()) assert.Equal(t, "", parsedSec2.DestinationPath()) parsedSec3, err := ParseConfig(sec3) assert.Nil(t, err) - assert.Equal(t, StorageTypeSecret, parsedSec3.Type()) + assert.Equal(t, StorageTypeSecret, parsedSec3.StorageType()) assert.Equal(t, "sec", parsedSec3.Name()) assert.Equal(t, "", parsedSec3.Key()) assert.Equal(t, "/tmp/sec", parsedSec3.DestinationPath()) parsedSec4, err := ParseConfig(sec4) assert.Nil(t, err) - assert.Equal(t, StorageTypeSecret, parsedSec4.Type()) + assert.Equal(t, StorageTypeSecret, parsedSec4.StorageType()) assert.Equal(t, "sec", parsedSec4.Name()) assert.Equal(t, "", parsedSec4.Key()) assert.Equal(t, "", parsedSec4.DestinationPath()) parsedFile1, err := ParseConfig(file1) assert.Nil(t, err) - assert.Equal(t, StorageTypeFile, parsedFile1.Type()) + assert.Equal(t, StorageTypeFile, parsedFile1.StorageType()) assert.Equal(t, "/path/to/my-file.txt", parsedFile1.Name()) assert.Equal(t, "", parsedFile1.Key()) assert.Equal(t, "/tmp/file.txt", parsedFile1.DestinationPath()) parsedFile2, err := ParseConfig(file2) assert.Nil(t, err) - assert.Equal(t, StorageTypeFile, parsedFile2.Type()) + assert.Equal(t, StorageTypeFile, parsedFile2.StorageType()) assert.Equal(t, "/path/to/my-file.txt", parsedFile2.Name()) assert.Equal(t, "", parsedFile2.Key()) assert.Equal(t, "", parsedFile2.DestinationPath()) parsedFile3, err := ParseConfig(file3) assert.Nil(t, err) - assert.Equal(t, StorageTypeFile, parsedFile3.Type()) + assert.Equal(t, StorageTypeFile, parsedFile3.StorageType()) assert.Equal(t, "/path to/my-file.txt", parsedFile3.Name()) assert.Equal(t, "", parsedFile3.Key()) assert.Equal(t, "", parsedFile3.DestinationPath())
