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/01/07 13:48:12 UTC
[camel-k] 06/24: feat(cmd/run): config content type
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 <pa...@gmail.com>
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())