You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by as...@apache.org on 2021/06/16 12:05:01 UTC
[camel-k] 01/20: feat(cmd/run): resource option refactoring
This is an automated email from the ASF dual-hosted git repository.
astefanutti pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-k.git
commit 890b4df49c71b08040373a74fc2f8b70d6ebedff
Author: Pasquale Congiusti <pa...@gmail.com>
AuthorDate: Tue Jun 1 10:41:48 2021 +0200
feat(cmd/run): resource option refactoring
* Provide support for configmap, secret or local file
* Refactoring the structure of mount points to distinguish clearly between config and resource options
Ref #2003
---
pkg/apis/camel/v1/common_types.go | 11 ++--
pkg/apis/camel/v1/integration_types_support.go | 9 ++++
pkg/cmd/run.go | 46 +++-------------
pkg/cmd/run_help.go | 55 +++++++++++++++++---
pkg/cmd/run_test.go | 8 +--
pkg/trait/environment.go | 4 +-
pkg/trait/jvm.go | 1 -
pkg/trait/jvm_test.go | 8 +--
pkg/trait/trait_test.go | 24 +++++----
pkg/trait/trait_types.go | 72 +++++++++++++++++++-------
pkg/trait/util.go | 28 ++++++++++
11 files changed, 175 insertions(+), 91 deletions(-)
diff --git a/pkg/apis/camel/v1/common_types.go b/pkg/apis/camel/v1/common_types.go
index aeedb75..6b2cda8 100644
--- a/pkg/apis/camel/v1/common_types.go
+++ b/pkg/apis/camel/v1/common_types.go
@@ -26,8 +26,9 @@ const TraitAnnotationPrefix = "trait.camel.apache.org/"
// ConfigurationSpec --
type ConfigurationSpec struct {
- Type string `json:"type"`
- Value string `json:"value"`
+ Type string `json:"type"`
+ Value string `json:"value"`
+ ResourceType string `json:"resourceType,omitempty"`
}
// Artifact --
@@ -196,9 +197,11 @@ type ResourceSpec struct {
}
const (
- // ResourceTypeData --
+ // ResourceTypeData represents a generic data resource
ResourceTypeData ResourceType = "data"
- // ResourceTypeOpenAPI --
+ // ResourceTypeConfig represents a config resource known to runtime
+ ResourceTypeConfig ResourceType = "config"
+ // ResourceTypeOpenAPI represents an OpenAPI config resource
ResourceTypeOpenAPI ResourceType = "openapi"
)
diff --git a/pkg/apis/camel/v1/integration_types_support.go b/pkg/apis/camel/v1/integration_types_support.go
index 1ba06f5..acf3bd6 100644
--- a/pkg/apis/camel/v1/integration_types_support.go
+++ b/pkg/apis/camel/v1/integration_types_support.go
@@ -109,6 +109,15 @@ func (in *IntegrationSpec) AddConfiguration(confType string, confValue string) {
})
}
+// AddConfigurationAsResourceType will set a configuration specified with a resource type
+func (in *IntegrationSpec) AddConfigurationAsResourceType(confType string, confValue string, resourceType string) {
+ in.Configuration = append(in.Configuration, ConfigurationSpec{
+ Type: confType,
+ Value: confValue,
+ ResourceType: resourceType,
+ })
+}
+
// AddDependency --
func (in *IntegrationSpec) AddDependency(dependency string) {
if in.Dependencies == nil {
diff --git a/pkg/cmd/run.go b/pkg/cmd/run.go
index 403a799..69fcfe8 100644
--- a/pkg/cmd/run.go
+++ b/pkg/cmd/run.go
@@ -82,6 +82,7 @@ func newCmdRun(rootCmdOptions *RootCmdOptions) (*cobra.Command, *runCmdOptions)
cmd.Flags().StringArrayP("property", "p", nil, "Add a runtime property or properties file (syntax: [my-key=my-value|file:/path/to/my-conf.properties])")
cmd.Flags().StringArray("build-property", nil, "Add a build time property or properties file (syntax: [my-key=my-value|file:/path/to/my-conf.properties])")
cmd.Flags().StringArray("config", nil, "Add runtime configuration from a Configmap, a Secret or a file (syntax: [configmap|secret|file]:name)")
+ cmd.Flags().StringArray("resource", nil, "Add runtime resource from a Configmap, a Secret or a file (syntax: [configmap|secret|file]:name)")
cmd.Flags().StringArray("configmap", nil, "[Deprecated] Add a ConfigMap")
cmd.Flags().StringArray("secret", nil, "[Deprecated] Add a Secret")
cmd.Flags().StringArray("maven-repository", nil, "Add a maven repository")
@@ -93,7 +94,6 @@ func newCmdRun(rootCmdOptions *RootCmdOptions) (*cobra.Command, *runCmdOptions)
cmd.Flags().StringArrayP("trait", "t", nil, "Configure a trait. E.g. \"-t service.enabled=false\"")
cmd.Flags().StringP("output", "o", "", "Output format. One of: json|yaml")
cmd.Flags().Bool("compression", false, "Enable storage of sources and resources as a compressed binary blobs")
- cmd.Flags().StringArray("resource", nil, "Add a resource")
cmd.Flags().StringArray("open-api", nil, "Add an OpenAPI v2 spec")
cmd.Flags().StringArrayP("volume", "v", nil, "Mount a volume into the integration container. E.g \"-v pvcname:/container/path\"")
cmd.Flags().StringArrayP("env", "e", nil, "Set an environment variable in the integration container. E.g \"-e MY_VAR=my-value\"")
@@ -544,16 +544,13 @@ func (o *runCmdOptions) updateIntegrationCode(c client.Client, sources []string,
}
for _, resource := range o.Resources {
- rawData, contentType, err := loadRawContent(resource)
- if err != nil {
- return nil, err
- }
-
- resourceSpec, err := binaryOrTextResource(path.Base(resource), rawData, contentType, o.Compression)
- if err != nil {
- return nil, err
+ if config, parseErr := ParseConfigOption(resource); parseErr == nil {
+ if applyResourceOptionErr := ApplyResourceOption(config, &integration.Spec, c, namespace, o.Compression); applyResourceOptionErr != nil {
+ return nil, applyResourceOptionErr
+ }
+ } else {
+ return nil, parseErr
}
- integration.Spec.AddResources(resourceSpec)
}
for _, resource := range o.OpenAPIs {
@@ -718,35 +715,6 @@ func keyValueProps(value string) (*properties.Properties, error) {
return properties.Load([]byte(value), properties.UTF8)
}
-func binaryOrTextResource(fileName string, data []byte, contentType string, base64Compression bool) (v1.ResourceSpec, error) {
- resourceSpec := v1.ResourceSpec{
- DataSpec: v1.DataSpec{
- Name: fileName,
- ContentKey: fileName,
- ContentType: contentType,
- Compression: false,
- },
- Type: v1.ResourceTypeData,
- }
-
- if !base64Compression && isBinary(contentType) {
- resourceSpec.RawContent = data
- return resourceSpec, nil
- }
- // either is a text resource or base64 compression is enabled
- if base64Compression {
- content, err := compressToString(data)
- if err != nil {
- return resourceSpec, err
- }
- resourceSpec.Content = content
- resourceSpec.Compression = true
- } else {
- resourceSpec.Content = string(data)
- }
- return resourceSpec, nil
-}
-
func (o *runCmdOptions) GetIntegrationName(sources []string) string {
name := ""
if o.IntegrationName != "" {
diff --git a/pkg/cmd/run_help.go b/pkg/cmd/run_help.go
index 2f78b79..927d7b8 100644
--- a/pkg/cmd/run_help.go
+++ b/pkg/cmd/run_help.go
@@ -76,43 +76,82 @@ func ParseConfigOption(item string) (*RunConfigOption, error) {
return newRunConfigOption(cot, groups[2]), nil
}
-// ApplyConfigOption will set the proper option behavior to the IntegrationSpec
-func ApplyConfigOption(config *RunConfigOption, integrationSpec *v1.IntegrationSpec, c client.Client, namespace string, enableCompression bool) error {
+func applyOption(config *RunConfigOption, integrationSpec *v1.IntegrationSpec,
+ c client.Client, namespace string, enableCompression bool, resourceType v1.ResourceType) error {
switch config.ConfigType {
case ConfigOptionTypeConfigmap:
cm := kubernetes.LookupConfigmap(context.Background(), c, namespace, config.Value)
if cm == nil {
fmt.Printf("Warn: %s Configmap not found in %s namespace, make sure to provide it before the Integration can run\n",
config.Value, namespace)
- } else if cm.BinaryData != nil {
+ } else if resourceType != v1.ResourceTypeData && cm.BinaryData != nil {
return fmt.Errorf("you cannot provide a binary config, use a text file instead")
}
- integrationSpec.AddConfiguration(string(config.ConfigType), config.Value)
+ integrationSpec.AddConfigurationAsResourceType(string(config.ConfigType), config.Value, string(resourceType))
case ConfigOptionTypeSecret:
secret := kubernetes.LookupSecret(context.Background(), c, namespace, config.Value)
if secret == nil {
fmt.Printf("Warn: %s Secret not found in %s namespace, make sure to provide it before the Integration can run\n",
config.Value, namespace)
}
- integrationSpec.AddConfiguration(string(config.ConfigType), config.Value)
+ integrationSpec.AddConfigurationAsResourceType(string(config.ConfigType), config.Value, string(resourceType))
case ConfigOptionTypeFile:
// Don't allow a binary non compressed resource
rawData, contentType, err := loadRawContent(config.Value)
if err != nil {
return err
}
- if !enableCompression && isBinary(contentType) {
+ if resourceType != v1.ResourceTypeData && !enableCompression && isBinary(contentType) {
return fmt.Errorf("you cannot provide a binary config, use a text file or check --resource flag instead")
}
- resourceSpec, err := binaryOrTextResource(path.Base(config.Value), rawData, contentType, enableCompression)
+ resourceSpec, err := binaryOrTextResource(path.Base(config.Value), rawData, contentType, enableCompression, resourceType)
if err != nil {
return err
}
integrationSpec.AddResources(resourceSpec)
default:
// Should never reach this
- return fmt.Errorf("invalid config option type %s", config.ConfigType)
+ return fmt.Errorf("invalid option type %s", config.ConfigType)
}
return nil
}
+
+// ApplyConfigOption will set the proper --config option behavior to the IntegrationSpec
+func ApplyConfigOption(config *RunConfigOption, integrationSpec *v1.IntegrationSpec, c client.Client, namespace string, enableCompression bool) error {
+ return applyOption(config, integrationSpec, c, namespace, enableCompression, v1.ResourceTypeConfig)
+}
+
+// ApplyResourceOption will set the proper --resource option behavior to the IntegrationSpec
+func ApplyResourceOption(config *RunConfigOption, integrationSpec *v1.IntegrationSpec, c client.Client, namespace string, enableCompression bool) error {
+ return applyOption(config, integrationSpec, c, namespace, enableCompression, v1.ResourceTypeData)
+}
+
+func binaryOrTextResource(fileName string, data []byte, contentType string, base64Compression bool, resourceType v1.ResourceType) (v1.ResourceSpec, error) {
+ resourceSpec := v1.ResourceSpec{
+ DataSpec: v1.DataSpec{
+ Name: fileName,
+ ContentKey: fileName,
+ ContentType: contentType,
+ Compression: false,
+ },
+ Type: resourceType,
+ }
+
+ if !base64Compression && isBinary(contentType) {
+ resourceSpec.RawContent = data
+ return resourceSpec, nil
+ }
+ // either is a text resource or base64 compression is enabled
+ if base64Compression {
+ content, err := compressToString(data)
+ if err != nil {
+ return resourceSpec, err
+ }
+ resourceSpec.Content = content
+ resourceSpec.Compression = true
+ } else {
+ resourceSpec.Content = string(data)
+ }
+ return resourceSpec, nil
+}
diff --git a/pkg/cmd/run_test.go b/pkg/cmd/run_test.go
index e15354d..7d1f8cd 100644
--- a/pkg/cmd/run_test.go
+++ b/pkg/cmd/run_test.go
@@ -487,7 +487,7 @@ func TestRunWithSavedValues(t *testing.T) {
}*/
func TestRunBinaryResource(t *testing.T) {
- binaryResourceSpec, err := binaryOrTextResource("file.ext", []byte{1, 2, 3, 4}, "application/octet-stream", false)
+ binaryResourceSpec, err := binaryOrTextResource("file.ext", []byte{1, 2, 3, 4}, "application/octet-stream", false, v1.ResourceTypeData)
assert.Nil(t, err)
assert.Equal(t, "", binaryResourceSpec.Content)
assert.NotNil(t, binaryResourceSpec.RawContent)
@@ -499,7 +499,7 @@ func TestRunBinaryResource(t *testing.T) {
func TestRunBinaryCompressedResource(t *testing.T) {
data := []byte{1, 2, 3, 4}
base64Compressed, _ := compressToString(data)
- binaryResourceSpec, err := binaryOrTextResource("file.ext", data, "application/octet-stream", true)
+ binaryResourceSpec, err := binaryOrTextResource("file.ext", data, "application/octet-stream", true, v1.ResourceTypeData)
assert.Nil(t, err)
assert.Equal(t, base64Compressed, binaryResourceSpec.Content)
assert.Nil(t, binaryResourceSpec.RawContent)
@@ -509,7 +509,7 @@ func TestRunBinaryCompressedResource(t *testing.T) {
}
func TestRunTextResource(t *testing.T) {
- textResourceSpec, err := binaryOrTextResource("file.ext", []byte("hello world"), "text/plain", false)
+ textResourceSpec, err := binaryOrTextResource("file.ext", []byte("hello world"), "text/plain", false, v1.ResourceTypeData)
assert.Nil(t, err)
assert.Equal(t, "hello world", textResourceSpec.Content)
assert.Nil(t, textResourceSpec.RawContent)
@@ -521,7 +521,7 @@ func TestRunTextResource(t *testing.T) {
func TestRunTextCompressedResource(t *testing.T) {
data := []byte("hello horld")
base64Compressed, _ := compressToString(data)
- textResourceSpec, err := binaryOrTextResource("file.ext", []byte("hello horld"), "text/plain", true)
+ textResourceSpec, err := binaryOrTextResource("file.ext", []byte("hello horld"), "text/plain", true, v1.ResourceTypeData)
assert.Nil(t, err)
assert.Equal(t, base64Compressed, textResourceSpec.Content)
assert.Nil(t, textResourceSpec.RawContent)
diff --git a/pkg/trait/environment.go b/pkg/trait/environment.go
index 30b396e..bfc8cae 100644
--- a/pkg/trait/environment.go
+++ b/pkg/trait/environment.go
@@ -72,8 +72,8 @@ func (t *environmentTrait) Apply(e *Environment) error {
envvar.SetVal(&e.EnvVars, envVarCamelKIntegration, e.Integration.Name)
}
envvar.SetVal(&e.EnvVars, envVarCamelKRuntimeVersion, e.RuntimeVersion)
- envvar.SetVal(&e.EnvVars, envVarMountPathConfigMaps, configMapsMountPath)
- envvar.SetVal(&e.EnvVars, envVarMountPathSecrets, secretsMountPath)
+ envvar.SetVal(&e.EnvVars, envVarMountPathConfigMaps, configConfigmapsMountPath)
+ envvar.SetVal(&e.EnvVars, envVarMountPathSecrets, configSecretsMountPath)
if util.IsNilOrTrue(t.ContainerMeta) {
envvar.SetValFrom(&e.EnvVars, envVarNamespace, "metadata.namespace")
diff --git a/pkg/trait/jvm.go b/pkg/trait/jvm.go
index 2d722e2..725f84c 100644
--- a/pkg/trait/jvm.go
+++ b/pkg/trait/jvm.go
@@ -95,7 +95,6 @@ func (t *jvmTrait) Apply(e *Environment) error {
classpath := strset.New()
- classpath.Add(resourcesMountPath)
classpath.Add("./resources")
for _, artifact := range kit.Status.Artifacts {
diff --git a/pkg/trait/jvm_test.go b/pkg/trait/jvm_test.go
index 2572dc1..cfa925c 100644
--- a/pkg/trait/jvm_test.go
+++ b/pkg/trait/jvm_test.go
@@ -103,12 +103,12 @@ func TestApplyJvmTraitWithDeploymentResource(t *testing.T) {
assert.Nil(t, err)
- cp := strset.New("/etc/camel/resources", "./resources", "/mount/path").List()
+ cp := strset.New("./resources", "/mount/path").List()
sort.Strings(cp)
assert.Equal(t, []string{
"-cp",
- "./resources:/etc/camel/resources:/mount/path",
+ "./resources:/mount/path",
"io.quarkus.bootstrap.runner.QuarkusEntryPoint",
}, d.Spec.Template.Spec.Containers[0].Args)
}
@@ -135,12 +135,12 @@ func TestApplyJvmTraitWithKNativeResource(t *testing.T) {
assert.Nil(t, err)
- cp := strset.New("/etc/camel/resources", "./resources", "/mount/path").List()
+ cp := strset.New("./resources", "/mount/path").List()
sort.Strings(cp)
assert.Equal(t, []string{
"-cp",
- "./resources:/etc/camel/resources:/mount/path",
+ "./resources:/mount/path",
"io.quarkus.bootstrap.runner.QuarkusEntryPoint",
}, s.Spec.Template.Spec.Containers[0].Args)
}
diff --git a/pkg/trait/trait_test.go b/pkg/trait/trait_test.go
index e1bea3b..f49a5b0 100644
--- a/pkg/trait/trait_test.go
+++ b/pkg/trait/trait_test.go
@@ -253,12 +253,14 @@ func TestConfigureVolumesAndMountsTextResourcesAndProperties(t *testing.T) {
Value: "a=b",
},
{
- Type: "configmap",
- Value: "test-configmap",
+ Type: "configmap",
+ Value: "test-configmap",
+ ResourceType: "config",
},
{
- Type: "secret",
- Value: "test-secret",
+ Type: "secret",
+ Value: "test-secret",
+ ResourceType: "config",
},
{
Type: "volume",
@@ -313,7 +315,7 @@ func TestConfigureVolumesAndMountsTextResourcesAndProperties(t *testing.T) {
m = findVVolumeMount(mnts, func(m corev1.VolumeMount) bool { return m.Name == "i-resource-001" })
assert.NotNil(t, m)
- assert.Equal(t, "/etc/camel/resources/res2.txt", m.MountPath)
+ assert.Equal(t, "/etc/camel/data/resources/res2.txt", m.MountPath)
v = findVolume(vols, func(v corev1.Volume) bool { return v.ConfigMap.Name == TestDeploymentName+"-resource-002" })
assert.NotNil(t, v)
@@ -324,7 +326,7 @@ func TestConfigureVolumesAndMountsTextResourcesAndProperties(t *testing.T) {
m = findVVolumeMount(mnts, func(m corev1.VolumeMount) bool { return m.Name == "i-resource-002" })
assert.NotNil(t, m)
- assert.Equal(t, "/etc/camel/resources/res3.txt", m.MountPath)
+ assert.Equal(t, "/etc/camel/data/resources/res3.txt", m.MountPath)
v = findVolume(vols, func(v corev1.Volume) bool { return v.ConfigMap.Name == TestDeploymentName+"-resource-003" })
assert.NotNil(t, v)
@@ -335,7 +337,7 @@ func TestConfigureVolumesAndMountsTextResourcesAndProperties(t *testing.T) {
m = findVVolumeMount(mnts, func(m corev1.VolumeMount) bool { return m.Name == "i-resource-003" })
assert.NotNil(t, m)
- assert.Equal(t, "/etc/camel/resources/res4.txt", m.MountPath)
+ assert.Equal(t, "/etc/camel/data/resources/res4.txt", m.MountPath)
v = findVolume(vols, func(v corev1.Volume) bool { return v.ConfigMap.Name == "test-configmap" })
assert.NotNil(t, v)
@@ -345,7 +347,7 @@ func TestConfigureVolumesAndMountsTextResourcesAndProperties(t *testing.T) {
m = findVVolumeMount(mnts, func(m corev1.VolumeMount) bool { return m.Name == "test-configmap" })
assert.NotNil(t, m)
- assert.Equal(t, path.Join(configMapsMountPath, "test-configmap"), m.MountPath)
+ assert.Equal(t, path.Join(configConfigmapsMountPath, "test-configmap"), m.MountPath)
v = findVolume(vols, func(v corev1.Volume) bool { return v.Name == "test-secret" })
assert.NotNil(t, v)
@@ -354,7 +356,7 @@ func TestConfigureVolumesAndMountsTextResourcesAndProperties(t *testing.T) {
m = findVVolumeMount(mnts, func(m corev1.VolumeMount) bool { return m.Name == "test-secret" })
assert.NotNil(t, m)
- assert.Equal(t, path.Join(secretsMountPath, "test-secret"), m.MountPath)
+ assert.Equal(t, path.Join(configSecretsMountPath, "test-secret"), m.MountPath)
v = findVolume(vols, func(v corev1.Volume) bool { return v.Name == "testvolume-data" })
assert.NotNil(t, v)
@@ -478,7 +480,7 @@ func TestConfigureVolumesAndMountsBinaryAndTextResources(t *testing.T) {
m := findVVolumeMount(mnts, func(m corev1.VolumeMount) bool { return m.Name == v.Name })
assert.NotNil(t, m)
- assert.Equal(t, "/etc/camel/resources/res1.bin", m.MountPath)
+ assert.Equal(t, "/etc/camel/data/resources/res1.bin", m.MountPath)
v = findVolume(vols, func(v corev1.Volume) bool { return v.ConfigMap.Name == "my-cm2" })
assert.NotNil(t, v)
@@ -489,7 +491,7 @@ func TestConfigureVolumesAndMountsBinaryAndTextResources(t *testing.T) {
m = findVVolumeMount(mnts, func(m corev1.VolumeMount) bool { return m.Name == v.Name })
assert.NotNil(t, m)
- assert.Equal(t, "/etc/camel/resources/res2.txt", m.MountPath)
+ assert.Equal(t, "/etc/camel/data/resources/res2.txt", m.MountPath)
}
func TestOnlySomeTraitsInfluenceBuild(t *testing.T) {
diff --git a/pkg/trait/trait_types.go b/pkg/trait/trait_types.go
index 6e7426c..2786f25 100644
--- a/pkg/trait/trait_types.go
+++ b/pkg/trait/trait_types.go
@@ -48,13 +48,17 @@ import (
const True = "true"
var (
- basePath = "/etc/camel"
- confDPath = path.Join(basePath, "conf.d")
- sourcesMountPath = path.Join(basePath, "sources")
- resourcesMountPath = path.Join(basePath, "resources")
- configMapsMountPath = path.Join(confDPath, "_configmaps")
- secretsMountPath = path.Join(confDPath, "_secrets")
- serviceBindingsMountPath = path.Join(confDPath, "_servicebindings")
+ basePath = "/etc/camel"
+ confDPath = path.Join(basePath, "conf.d")
+ sourcesMountPath = path.Join(basePath, "sources")
+ dataDefaultMountPath = path.Join(basePath, "data")
+ dataResourcesMountPath = path.Join(dataDefaultMountPath, "resources")
+ dataConfigmapsMountPath = path.Join(dataDefaultMountPath, "configmaps")
+ dataSecretsMountPath = path.Join(dataDefaultMountPath, "secrets")
+ configResourcesMountPath = path.Join(confDPath, "_resources")
+ configConfigmapsMountPath = path.Join(confDPath, "_configmaps")
+ configSecretsMountPath = path.Join(confDPath, "_secrets")
+ serviceBindingsMountPath = path.Join(confDPath, "_servicebindings")
)
// Identifiable represent an identifiable type
@@ -463,7 +467,7 @@ func (e *Environment) computeConfigMaps() []ctrl.Object {
}
for i, r := range e.Integration.Spec.Resources {
- if r.Type != v1.ResourceTypeData {
+ if r.Type == v1.ResourceTypeOpenAPI {
continue
}
if r.ContentRef != "" {
@@ -601,7 +605,7 @@ func (e *Environment) configureVolumesAndMounts(vols *[]corev1.Volume, mnts *[]c
}
for i, r := range e.Integration.Resources() {
- if r.Type != v1.ResourceTypeData {
+ if r.Type == v1.ResourceTypeOpenAPI {
continue
}
@@ -609,7 +613,8 @@ func (e *Environment) configureVolumesAndMounts(vols *[]corev1.Volume, mnts *[]c
refName := fmt.Sprintf("i-resource-%03d", i)
resName := strings.TrimPrefix(r.Name, "/")
cmKey := "content"
- resPath := path.Join(resourcesMountPath, resName)
+ resourceMountPoint := getResourceMountPoint(r.Type)
+ resPath := path.Join(resourceMountPoint, resName)
if r.ContentRef != "" {
cmName = r.ContentRef
@@ -690,15 +695,15 @@ func (e *Environment) configureVolumesAndMounts(vols *[]corev1.Volume, mnts *[]c
//
// Volumes :: Additional ConfigMaps
//
- for _, cmName := range e.collectConfigurationValues("configmap") {
- refName := kubernetes.SanitizeLabel(cmName)
+ for _, configmaps := range e.collectConfigurations("configmap") {
+ refName := kubernetes.SanitizeLabel(configmaps["value"])
*vols = append(*vols, corev1.Volume{
Name: refName,
VolumeSource: corev1.VolumeSource{
ConfigMap: &corev1.ConfigMapVolumeSource{
LocalObjectReference: corev1.LocalObjectReference{
- Name: cmName,
+ Name: configmaps["value"],
},
},
},
@@ -706,7 +711,7 @@ func (e *Environment) configureVolumesAndMounts(vols *[]corev1.Volume, mnts *[]c
*mnts = append(*mnts, corev1.VolumeMount{
Name: refName,
- MountPath: path.Join(configMapsMountPath, strings.ToLower(cmName)),
+ MountPath: path.Join(getConfigmapMountPoint(configmaps["resourceType"]), strings.ToLower(configmaps["value"])),
ReadOnly: true,
})
}
@@ -732,21 +737,21 @@ func (e *Environment) configureVolumesAndMounts(vols *[]corev1.Volume, mnts *[]c
MountPath: path.Join(serviceBindingsMountPath, strings.ToLower(sb)),
})
}
- for _, secretName := range e.collectConfigurationValues("secret") {
- refName := kubernetes.SanitizeLabel(secretName)
+ for _, secret := range e.collectConfigurations("secret") {
+ refName := kubernetes.SanitizeLabel(secret["value"])
*vols = append(*vols, corev1.Volume{
Name: refName,
VolumeSource: corev1.VolumeSource{
Secret: &corev1.SecretVolumeSource{
- SecretName: secretName,
+ SecretName: secret["value"],
},
},
})
*mnts = append(*mnts, corev1.VolumeMount{
Name: refName,
- MountPath: path.Join(secretsMountPath, strings.ToLower(secretName)),
+ MountPath: path.Join(getSecretMountPoint(secret["resourceType"]), strings.ToLower(secret["value"])),
ReadOnly: true,
})
}
@@ -781,6 +786,33 @@ func (e *Environment) configureVolumesAndMounts(vols *[]corev1.Volume, mnts *[]c
}
}
+func getResourceMountPoint(resourceType v1.ResourceType) string {
+ switch resourceType {
+ case v1.ResourceTypeData:
+ return dataResourcesMountPath
+ }
+ // Default, config type
+ return configResourcesMountPath
+}
+
+func getConfigmapMountPoint(resourceType string) string {
+ switch resourceType {
+ case "data":
+ return dataConfigmapsMountPath
+ }
+ // Default, config type
+ return configConfigmapsMountPath
+}
+
+func getSecretMountPoint(resourceType string) string {
+ switch resourceType {
+ case "data":
+ return dataSecretsMountPath
+ }
+ // Default, config type
+ return configSecretsMountPath
+}
+
func (e *Environment) collectConfigurationValues(configurationType string) []string {
return collectConfigurationValues(configurationType, e.Platform, e.IntegrationKit, e.Integration)
}
@@ -793,6 +825,10 @@ func (e *Environment) collectConfigurationPairs(configurationType string) []vari
return collectConfigurationPairs(configurationType, e.Platform, e.IntegrationKit, e.Integration)
}
+func (e *Environment) collectConfigurations(configurationType string) []map[string]string {
+ return collectConfigurations(configurationType, e.Platform, e.IntegrationKit, e.Integration)
+}
+
func (e *Environment) getIntegrationContainer() *corev1.Container {
containerName := defaultContainerName
dt := e.Catalog.GetTrait(containerTraitID)
diff --git a/pkg/trait/util.go b/pkg/trait/util.go
index 366d594..4a2dc5d 100644
--- a/pkg/trait/util.go
+++ b/pkg/trait/util.go
@@ -77,6 +77,34 @@ func collectConfigurationValues(configurationType string, configurable ...v1.Con
return s
}
+func collectConfigurations(configurationType string, configurable ...v1.Configurable) []map[string]string {
+ var result []map[string]string
+
+ for _, c := range configurable {
+ c := c
+
+ if c == nil || reflect.ValueOf(c).IsNil() {
+ continue
+ }
+
+ entries := c.Configurations()
+ if entries == nil {
+ continue
+ }
+
+ for _, entry := range entries {
+ if entry.Type == configurationType {
+ var item = make(map[string]string)
+ item["value"] = entry.Value
+ item["resourceType"] = entry.ResourceType
+ result = append(result, item)
+ }
+ }
+ }
+
+ return result
+}
+
func collectConfigurationPairs(configurationType string, configurable ...v1.Configurable) []variable {
result := make([]variable, 0)