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 2024/04/23 11:27:56 UTC
(camel-k) branch main updated (a5c2ce757 -> 57149cfdb)
This is an automated email from the ASF dual-hosted git repository.
pcongiusti pushed a change to branch main
in repository https://gitbox.apache.org/repos/asf/camel-k.git
from a5c2ce757 fix(trait): synthetic Kit
new bea48df57 fix(trait): don't report runtime version...
new 57149cfdb chore(trait): disable traits requiring catalog when missing
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
addons/keda/keda.go | 4 +++-
addons/master/master.go | 3 +++
addons/resume/resume.go | 3 +++
addons/telemetry/telemetry.go | 4 +++-
addons/tracing/tracing.go | 42 +++++++++++++++++---------------------
pkg/trait/builder.go | 4 +++-
pkg/trait/camel.go | 31 ++++++++++++++++------------
pkg/trait/camel_test.go | 33 ++++++++++++++++++++++++++++++
pkg/trait/container.go | 1 -
pkg/trait/cron.go | 8 ++++++--
pkg/trait/dependencies.go | 4 +++-
pkg/trait/dependencies_test.go | 8 ++++++--
pkg/trait/error_handler.go | 4 +++-
pkg/trait/error_handler_test.go | 14 +++++++++----
pkg/trait/health.go | 3 +++
pkg/trait/jvm.go | 7 +++++--
pkg/trait/kamelets.go | 3 +++
pkg/trait/knative.go | 3 +++
pkg/trait/knative_service.go | 4 ++--
pkg/trait/logging.go | 4 +++-
pkg/trait/openapi.go | 4 +++-
pkg/trait/quarkus.go | 3 +++
pkg/trait/service.go | 6 ++++--
pkg/trait/service_binding.go | 3 +++
pkg/trait/trait_condition_types.go | 17 ++++++++++++++-
25 files changed, 161 insertions(+), 59 deletions(-)
(camel-k) 01/02: fix(trait): don't report runtime version...
Posted by pc...@apache.org.
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 bea48df579362ac2125ea96d8fc17b21a4c000de
Author: Pasquale Congiusti <pa...@gmail.com>
AuthorDate: Wed Apr 17 16:20:37 2024 +0200
fix(trait): don't report runtime version...
... for external kit or syntetic Integrations.
As a side effect, we had to introduce a further check to avoid leveraging a Camel catalog which was taken as default.
Closes #5309
---
pkg/trait/camel.go | 15 ++++++++-------
pkg/trait/camel_test.go | 29 +++++++++++++++++++++++++++++
pkg/trait/cron.go | 3 +++
pkg/trait/jvm.go | 3 +++
pkg/trait/logging.go | 4 +++-
5 files changed, 46 insertions(+), 8 deletions(-)
diff --git a/pkg/trait/camel.go b/pkg/trait/camel.go
index d774cfca2..9f573c503 100644
--- a/pkg/trait/camel.go
+++ b/pkg/trait/camel.go
@@ -63,6 +63,13 @@ func (t *camelTrait) Matches(trait Trait) bool {
}
func (t *camelTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
+ if e.IntegrationKit != nil && e.IntegrationKit.IsExternal() {
+ return false, newIntegrationConditionPlatformDisabledWithMessage("Camel", "integration kit was not created via Camel K operator"), nil
+ }
+ if e.Integration != nil && e.Integration.IsSynthetic() {
+ return false, newIntegrationConditionPlatformDisabledWithMessage("Camel", "syntetic integration"), nil
+ }
+
if t.RuntimeVersion == "" {
if runtimeVersion, err := determineRuntimeVersion(e); err != nil {
return false, nil, err
@@ -71,21 +78,15 @@ func (t *camelTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
}
}
- // Don't run this trait for a synthetic Integration
- return e.Integration == nil || !e.Integration.IsSynthetic(), nil, nil
+ return true, nil, nil
}
func (t *camelTrait) Apply(e *Environment) error {
- if t.RuntimeVersion == "" {
- return errors.New("unable to determine runtime version")
- }
-
if e.CamelCatalog == nil {
if err := t.loadOrCreateCatalog(e, t.RuntimeVersion); err != nil {
return err
}
}
-
e.RuntimeVersion = e.CamelCatalog.Runtime.Version
if e.Integration != nil {
diff --git a/pkg/trait/camel_test.go b/pkg/trait/camel_test.go
index 5d5a13a4f..2ca58645e 100644
--- a/pkg/trait/camel_test.go
+++ b/pkg/trait/camel_test.go
@@ -246,3 +246,32 @@ func TestCamelCatalogSemver(t *testing.T) {
// 2.x will translate with 2.16.0 as it is already existing
assert.Equal(t, environment.CamelCatalog.CamelCatalogSpec.Runtime.Version, environment.RuntimeVersion)
}
+
+func TestCamelTraitExternalKit(t *testing.T) {
+ trait, environment := createNominalCamelTest(true)
+ environment.Integration.Status = v1.IntegrationStatus{}
+ environment.IntegrationKit.Labels[v1.IntegrationKitTypeLabel] = v1.IntegrationKitTypeExternal
+
+ configured, condition, err := trait.Configure(environment)
+ require.NoError(t, err)
+ assert.Equal(t, "explicitly disabled by the platform: integration kit was not created via Camel K operator", condition.message)
+ assert.False(t, configured)
+
+ assert.Equal(t, v1.RuntimeProvider(""), environment.Integration.Status.RuntimeProvider)
+ assert.Equal(t, "", environment.Integration.Status.RuntimeVersion)
+}
+
+func TestCamelTraitSyntheticIntegration(t *testing.T) {
+ trait, environment := createNominalCamelTest(true)
+ environment.Integration.Status = v1.IntegrationStatus{}
+ environment.Integration.Annotations = make(map[string]string)
+ environment.Integration.Annotations[v1.IntegrationSyntheticLabel] = "true"
+
+ configured, condition, err := trait.Configure(environment)
+ require.NoError(t, err)
+ assert.Equal(t, "explicitly disabled by the platform: syntetic integration", condition.message)
+ assert.False(t, configured)
+
+ assert.Equal(t, v1.RuntimeProvider(""), environment.Integration.Status.RuntimeProvider)
+ assert.Equal(t, "", environment.Integration.Status.RuntimeVersion)
+}
diff --git a/pkg/trait/cron.go b/pkg/trait/cron.go
index adf04f0c3..3e81c8ea2 100644
--- a/pkg/trait/cron.go
+++ b/pkg/trait/cron.go
@@ -83,6 +83,9 @@ func (t *cronTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
if !e.IntegrationInPhase(v1.IntegrationPhaseInitialization) && !e.IntegrationInRunningPhases() {
return false, nil, nil
}
+ if e.CamelCatalog == nil {
+ return false, newIntegrationConditionPlatformDisabledWithMessage("Cron", "no camel catalog available for this Integration"), nil
+ }
if _, ok := e.CamelCatalog.Runtime.Capabilities[v1.CapabilityCron]; !ok {
return false, NewIntegrationCondition(
diff --git a/pkg/trait/jvm.go b/pkg/trait/jvm.go
index 858ac33e4..a47e59f6f 100644
--- a/pkg/trait/jvm.go
+++ b/pkg/trait/jvm.go
@@ -74,6 +74,9 @@ func (t *jvmTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
return false, newIntegrationConditionPlatformDisabledWithMessage("JVM", "integration kit was not created via Camel K operator"), nil
}
+ if e.CamelCatalog == nil {
+ return false, newIntegrationConditionPlatformDisabledWithMessage("JVM", "no camel catalog available for this Integration"), nil
+ }
return true, nil, nil
}
diff --git a/pkg/trait/logging.go b/pkg/trait/logging.go
index 00d26369c..1063e21e7 100644
--- a/pkg/trait/logging.go
+++ b/pkg/trait/logging.go
@@ -52,10 +52,12 @@ func (l loggingTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
if e.Integration == nil {
return false, nil, nil
}
-
if !pointer.BoolDeref(l.Enabled, true) {
return false, NewIntegrationConditionUserDisabled("Logging"), nil
}
+ if e.CamelCatalog == nil {
+ return false, newIntegrationConditionPlatformDisabledWithMessage("Logging", "no camel catalog available for this Integration"), nil
+ }
return e.IntegrationInRunningPhases(), nil, nil
}
(camel-k) 02/02: chore(trait): disable traits requiring catalog when missing
Posted by pc...@apache.org.
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 57149cfdbf9db836363e411350857f97e47984af
Author: Pasquale Congiusti <pa...@gmail.com>
AuthorDate: Thu Apr 18 15:37:40 2024 +0200
chore(trait): disable traits requiring catalog when missing
We must explicitly define which are the traits that can be executed and which can't because missing catalog.
The catalog has sense only for the "managed" Integrations.
---
addons/keda/keda.go | 4 +++-
addons/master/master.go | 3 +++
addons/resume/resume.go | 3 +++
addons/telemetry/telemetry.go | 4 +++-
addons/tracing/tracing.go | 42 +++++++++++++++++---------------------
pkg/trait/builder.go | 4 +++-
pkg/trait/camel.go | 26 +++++++++++++----------
pkg/trait/camel_test.go | 34 ++++++++++++++++--------------
pkg/trait/container.go | 1 -
pkg/trait/cron.go | 7 ++++---
pkg/trait/dependencies.go | 4 +++-
pkg/trait/dependencies_test.go | 8 ++++++--
pkg/trait/error_handler.go | 4 +++-
pkg/trait/error_handler_test.go | 14 +++++++++----
pkg/trait/health.go | 3 +++
pkg/trait/jvm.go | 6 +++---
pkg/trait/kamelets.go | 3 +++
pkg/trait/knative.go | 3 +++
pkg/trait/knative_service.go | 4 ++--
pkg/trait/logging.go | 2 +-
pkg/trait/openapi.go | 4 +++-
pkg/trait/quarkus.go | 3 +++
pkg/trait/service.go | 6 ++++--
pkg/trait/service_binding.go | 3 +++
pkg/trait/trait_condition_types.go | 17 ++++++++++++++-
25 files changed, 138 insertions(+), 74 deletions(-)
diff --git a/addons/keda/keda.go b/addons/keda/keda.go
index ce4b56ab9..184dbdb90 100644
--- a/addons/keda/keda.go
+++ b/addons/keda/keda.go
@@ -120,10 +120,12 @@ func (t *kedaTrait) Configure(e *trait.Environment) (bool, *trait.TraitCondition
if e.Integration == nil || !pointer.BoolDeref(t.Enabled, false) {
return false, nil, nil
}
+ if e.CamelCatalog == nil {
+ return false, trait.NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
if !e.IntegrationInPhase(camelv1.IntegrationPhaseInitialization) && !e.IntegrationInRunningPhases() {
return false, nil, nil
}
-
if t.Auto == nil || *t.Auto {
if err := t.populateTriggersFromKamelets(e); err != nil {
return false, nil, err
diff --git a/addons/master/master.go b/addons/master/master.go
index 692bfb2c4..deec026f1 100644
--- a/addons/master/master.go
+++ b/addons/master/master.go
@@ -92,6 +92,9 @@ func (t *masterTrait) Configure(e *trait.Environment) (bool, *trait.TraitConditi
if !pointer.BoolDeref(t.Enabled, true) {
return false, trait.NewIntegrationConditionUserDisabled(masterComponent), nil
}
+ if e.CamelCatalog == nil {
+ return false, trait.NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
if !e.IntegrationInPhase(v1.IntegrationPhaseInitialization, v1.IntegrationPhaseBuildingKit) && !e.IntegrationInRunningPhases() {
return false, nil, nil
}
diff --git a/addons/resume/resume.go b/addons/resume/resume.go
index 221ae0364..2f44d1701 100644
--- a/addons/resume/resume.go
+++ b/addons/resume/resume.go
@@ -79,6 +79,9 @@ func (r *resumeTrait) Configure(environment *trait.Environment) (bool, *trait.Tr
if !pointer.BoolDeref(r.Enabled, false) {
return false, nil, nil
}
+ if environment.CamelCatalog == nil {
+ return false, trait.NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
if !environment.IntegrationInPhase(v1.IntegrationPhaseInitialization) && !environment.IntegrationInRunningPhases() {
return false, nil, nil
}
diff --git a/addons/telemetry/telemetry.go b/addons/telemetry/telemetry.go
index ec7f7c858..d6363a868 100644
--- a/addons/telemetry/telemetry.go
+++ b/addons/telemetry/telemetry.go
@@ -93,7 +93,9 @@ func (t *telemetryTrait) Configure(e *trait.Environment) (bool, *trait.TraitCond
if e.Integration == nil || !pointer.BoolDeref(t.Enabled, false) {
return false, nil, nil
}
-
+ if e.CamelCatalog == nil {
+ return false, trait.NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
var condition *trait.TraitCondition
if pointer.BoolDeref(t.Auto, true) {
if t.Endpoint == "" {
diff --git a/addons/tracing/tracing.go b/addons/tracing/tracing.go
index 0cf3852e0..52cb6684c 100644
--- a/addons/tracing/tracing.go
+++ b/addons/tracing/tracing.go
@@ -90,6 +90,9 @@ func (t *tracingTrait) Configure(e *trait.Environment) (bool, *trait.TraitCondit
if e.Integration == nil || !pointer.BoolDeref(t.Enabled, false) {
return false, nil, nil
}
+ if e.CamelCatalog == nil {
+ return false, trait.NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
if pointer.BoolDeref(t.Auto, true) {
if t.Endpoint == "" {
@@ -125,30 +128,23 @@ func (t *tracingTrait) Configure(e *trait.Environment) (bool, *trait.TraitCondit
func (t *tracingTrait) Apply(e *trait.Environment) error {
util.StringSliceUniqueAdd(&e.Integration.Status.Capabilities, v1.CapabilityTracing)
- if e.CamelCatalog != nil {
- provider := e.CamelCatalog.CamelCatalogSpec.Runtime.Provider
- properties := tracingProperties[provider]
-
- if appPropEnabled := properties[propEnabled]; appPropEnabled != "" {
- e.ApplicationProperties[appPropEnabled] = "true"
- }
-
- if appPropEndpoint := properties[propEndpoint]; appPropEndpoint != "" && t.Endpoint != "" {
- e.ApplicationProperties[appPropEndpoint] = t.Endpoint
- }
-
- if appPropServiceName := properties[propServiceName]; appPropServiceName != "" && t.ServiceName != "" {
- e.ApplicationProperties[appPropServiceName] = t.ServiceName
- }
-
- if appPropSamplerType := properties[propSamplerType]; appPropSamplerType != "" && t.SamplerType != nil {
- e.ApplicationProperties[appPropSamplerType] = *t.SamplerType
- }
-
- if appPropSamplerParam := properties[propSamplerParam]; appPropSamplerParam != "" && t.SamplerParam != nil {
- e.ApplicationProperties[appPropSamplerParam] = *t.SamplerParam
- }
+ provider := e.CamelCatalog.CamelCatalogSpec.Runtime.Provider
+ properties := tracingProperties[provider]
+ if appPropEnabled := properties[propEnabled]; appPropEnabled != "" {
+ e.ApplicationProperties[appPropEnabled] = "true"
+ }
+ if appPropEndpoint := properties[propEndpoint]; appPropEndpoint != "" && t.Endpoint != "" {
+ e.ApplicationProperties[appPropEndpoint] = t.Endpoint
+ }
+ if appPropServiceName := properties[propServiceName]; appPropServiceName != "" && t.ServiceName != "" {
+ e.ApplicationProperties[appPropServiceName] = t.ServiceName
+ }
+ if appPropSamplerType := properties[propSamplerType]; appPropSamplerType != "" && t.SamplerType != nil {
+ e.ApplicationProperties[appPropSamplerType] = *t.SamplerType
+ }
+ if appPropSamplerParam := properties[propSamplerParam]; appPropSamplerParam != "" && t.SamplerParam != nil {
+ e.ApplicationProperties[appPropSamplerParam] = *t.SamplerParam
}
return nil
diff --git a/pkg/trait/builder.go b/pkg/trait/builder.go
index 115ea6d66..afbc66688 100644
--- a/pkg/trait/builder.go
+++ b/pkg/trait/builder.go
@@ -90,7 +90,9 @@ func (t *builderTrait) Configure(e *Environment) (bool, *TraitCondition, error)
if e.IntegrationKit == nil {
return false, nil, nil
}
-
+ if e.CamelCatalog == nil {
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
condition := t.adaptDeprecatedFields()
if e.Platform.Status.Build.PublishStrategy == v1.IntegrationPlatformBuildPublishStrategySpectrum {
condition = newOrAppend(condition, "Spectrum publishing strategy is deprecated and may be removed in future releases. Make sure to use any supported publishing strategy instead.")
diff --git a/pkg/trait/camel.go b/pkg/trait/camel.go
index 9f573c503..46a7ef2d3 100644
--- a/pkg/trait/camel.go
+++ b/pkg/trait/camel.go
@@ -63,11 +63,8 @@ func (t *camelTrait) Matches(trait Trait) bool {
}
func (t *camelTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
- if e.IntegrationKit != nil && e.IntegrationKit.IsExternal() {
- return false, newIntegrationConditionPlatformDisabledWithMessage("Camel", "integration kit was not created via Camel K operator"), nil
- }
if e.Integration != nil && e.Integration.IsSynthetic() {
- return false, newIntegrationConditionPlatformDisabledWithMessage("Camel", "syntetic integration"), nil
+ return false, NewIntegrationConditionPlatformDisabledWithMessage("Camel", "synthetic integration"), nil
}
if t.RuntimeVersion == "" {
@@ -82,13 +79,26 @@ func (t *camelTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
}
func (t *camelTrait) Apply(e *Environment) error {
+ if e.IntegrationKitInPhase(v1.IntegrationKitPhaseReady) && e.IntegrationInRunningPhases() {
+ // Get all resources
+ maps := t.computeConfigMaps(e)
+ e.Resources.AddAll(maps)
+ }
+ if e.IntegrationKit != nil && e.IntegrationKit.IsSynthetic() {
+ // This is required as during init phase, the trait set by default these values
+ // which are widely used in the platform for different purposese.
+ if e.Integration != nil {
+ e.Integration.Status.RuntimeVersion = ""
+ e.Integration.Status.RuntimeProvider = ""
+ }
+ return nil
+ }
if e.CamelCatalog == nil {
if err := t.loadOrCreateCatalog(e, t.RuntimeVersion); err != nil {
return err
}
}
e.RuntimeVersion = e.CamelCatalog.Runtime.Version
-
if e.Integration != nil {
e.Integration.Status.RuntimeVersion = e.CamelCatalog.Runtime.Version
e.Integration.Status.RuntimeProvider = e.CamelCatalog.Runtime.Provider
@@ -98,12 +108,6 @@ func (t *camelTrait) Apply(e *Environment) error {
e.IntegrationKit.Status.RuntimeProvider = e.CamelCatalog.Runtime.Provider
}
- if e.IntegrationKitInPhase(v1.IntegrationKitPhaseReady) && e.IntegrationInRunningPhases() {
- // Get all resources
- maps := t.computeConfigMaps(e)
- e.Resources.AddAll(maps)
- }
-
return nil
}
diff --git a/pkg/trait/camel_test.go b/pkg/trait/camel_test.go
index 2ca58645e..175f154c3 100644
--- a/pkg/trait/camel_test.go
+++ b/pkg/trait/camel_test.go
@@ -45,6 +45,7 @@ func TestConfigureEnabledCamelTraitSucceeds(t *testing.T) {
func TestApplyCamelTraitSucceeds(t *testing.T) {
trait, environment := createNominalCamelTest(false)
+ environment.Integration.Status.Phase = v1.IntegrationPhaseBuildingKit
configured, condition, err := trait.Configure(environment)
require.NoError(t, err)
@@ -63,6 +64,22 @@ func TestApplyCamelTraitSucceeds(t *testing.T) {
assert.False(t, exactVersionRegexp.MatchString("wroong"))
}
+func TestApplyCamelTraitExternalKit(t *testing.T) {
+ trait, environment := createNominalCamelTest(false)
+ environment.IntegrationKit.Labels[v1.IntegrationKitTypeLabel] = v1.IntegrationKitTypeSynthetic
+
+ configured, condition, err := trait.Configure(environment)
+ require.NoError(t, err)
+ assert.Nil(t, condition)
+ assert.True(t, configured)
+ err = trait.Apply(environment)
+ require.NoError(t, err)
+ assert.Equal(t, "", environment.Integration.Status.RuntimeVersion)
+ assert.Equal(t, v1.RuntimeProvider(""), environment.Integration.Status.RuntimeProvider)
+ assert.Equal(t, "", environment.IntegrationKit.Status.RuntimeVersion)
+ assert.Equal(t, v1.RuntimeProvider(""), environment.Integration.Status.RuntimeProvider)
+}
+
func TestApplyCamelTraitWithoutEnvironmentCatalogAndUnmatchableVersionFails(t *testing.T) {
trait, environment := createNominalCamelTest(false)
environment.CamelCatalog = nil
@@ -233,6 +250,7 @@ func TestCamelMatches(t *testing.T) {
func TestCamelCatalogSemver(t *testing.T) {
trait, environment := createNominalCamelTest(true)
+ environment.Integration.Status.Phase = v1.IntegrationPhaseBuildingKit
trait.RuntimeVersion = "2.x"
environment.CamelCatalog.CamelCatalogSpec.Runtime.Version = "2.16.0"
@@ -247,20 +265,6 @@ func TestCamelCatalogSemver(t *testing.T) {
assert.Equal(t, environment.CamelCatalog.CamelCatalogSpec.Runtime.Version, environment.RuntimeVersion)
}
-func TestCamelTraitExternalKit(t *testing.T) {
- trait, environment := createNominalCamelTest(true)
- environment.Integration.Status = v1.IntegrationStatus{}
- environment.IntegrationKit.Labels[v1.IntegrationKitTypeLabel] = v1.IntegrationKitTypeExternal
-
- configured, condition, err := trait.Configure(environment)
- require.NoError(t, err)
- assert.Equal(t, "explicitly disabled by the platform: integration kit was not created via Camel K operator", condition.message)
- assert.False(t, configured)
-
- assert.Equal(t, v1.RuntimeProvider(""), environment.Integration.Status.RuntimeProvider)
- assert.Equal(t, "", environment.Integration.Status.RuntimeVersion)
-}
-
func TestCamelTraitSyntheticIntegration(t *testing.T) {
trait, environment := createNominalCamelTest(true)
environment.Integration.Status = v1.IntegrationStatus{}
@@ -269,7 +273,7 @@ func TestCamelTraitSyntheticIntegration(t *testing.T) {
configured, condition, err := trait.Configure(environment)
require.NoError(t, err)
- assert.Equal(t, "explicitly disabled by the platform: syntetic integration", condition.message)
+ assert.Equal(t, "explicitly disabled by the platform: synthetic integration", condition.message)
assert.False(t, configured)
assert.Equal(t, v1.RuntimeProvider(""), environment.Integration.Status.RuntimeProvider)
diff --git a/pkg/trait/container.go b/pkg/trait/container.go
index ecb5d160f..19ab28ee5 100644
--- a/pkg/trait/container.go
+++ b/pkg/trait/container.go
@@ -168,7 +168,6 @@ func (t *containerTrait) configureImageIntegrationKit(e *Environment) error {
kit.SetOperatorID(operatorID)
}
- t.L.Infof("image %s", kit.Spec.Image)
e.Resources.Add(kit)
e.Integration.SetIntegrationKit(kit)
}
diff --git a/pkg/trait/cron.go b/pkg/trait/cron.go
index 3e81c8ea2..67bbd7efb 100644
--- a/pkg/trait/cron.go
+++ b/pkg/trait/cron.go
@@ -84,9 +84,8 @@ func (t *cronTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
return false, nil, nil
}
if e.CamelCatalog == nil {
- return false, newIntegrationConditionPlatformDisabledWithMessage("Cron", "no camel catalog available for this Integration"), nil
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
}
-
if _, ok := e.CamelCatalog.Runtime.Capabilities[v1.CapabilityCron]; !ok {
return false, NewIntegrationCondition(
"Cron",
@@ -96,7 +95,6 @@ func (t *cronTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
"the runtime provider %s does not declare 'cron' capability",
), nil
}
-
if pointer.BoolDeref(t.Auto, true) {
globalCron, err := t.getGlobalCron(e)
if err != nil {
@@ -309,6 +307,9 @@ func (c *cronInfo) withSchedule(schedule string) *cronInfo {
}
func (t *cronTrait) getGlobalCron(e *Environment) (*cronInfo, error) {
+ if e.CamelCatalog == nil {
+ return nil, nil
+ }
fromURIs, err := t.getSourcesFromURIs(e)
if err != nil {
return nil, err
diff --git a/pkg/trait/dependencies.go b/pkg/trait/dependencies.go
index e8d6e5d0f..b2dc4b7f9 100644
--- a/pkg/trait/dependencies.go
+++ b/pkg/trait/dependencies.go
@@ -42,7 +42,9 @@ func (t *dependenciesTrait) Configure(e *Environment) (bool, *TraitCondition, er
if e.Integration == nil {
return false, nil, nil
}
-
+ if e.CamelCatalog == nil {
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
return e.IntegrationInPhase(v1.IntegrationPhaseInitialization), nil, nil
}
diff --git a/pkg/trait/dependencies_test.go b/pkg/trait/dependencies_test.go
index bda3b785d..e3d4aeeba 100644
--- a/pkg/trait/dependencies_test.go
+++ b/pkg/trait/dependencies_test.go
@@ -28,9 +28,13 @@ import (
)
func TestDependenciesTraitApplicability(t *testing.T) {
+ catalog, err := camel.DefaultCatalog()
+ require.NoError(t, err)
+
e := &Environment{
- Catalog: NewEnvironmentTestCatalog(),
- Integration: &v1.Integration{},
+ CamelCatalog: catalog,
+ Catalog: NewEnvironmentTestCatalog(),
+ Integration: &v1.Integration{},
}
trait := newDependenciesTrait()
diff --git a/pkg/trait/error_handler.go b/pkg/trait/error_handler.go
index c37388e69..829304073 100644
--- a/pkg/trait/error_handler.go
+++ b/pkg/trait/error_handler.go
@@ -44,11 +44,13 @@ func (t *errorHandlerTrait) Configure(e *Environment) (bool, *TraitCondition, er
if e.Integration == nil {
return false, nil, nil
}
+ if e.CamelCatalog == nil {
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
if !e.IntegrationInPhase(v1.IntegrationPhaseInitialization) && !e.IntegrationInRunningPhases() {
return false, nil, nil
}
-
if t.ErrorHandlerRef == "" {
t.ErrorHandlerRef = e.Integration.Spec.GetConfigurationProperty(v1.ErrorHandlerRefName)
}
diff --git a/pkg/trait/error_handler_test.go b/pkg/trait/error_handler_test.go
index d5579aa95..4f6ed6168 100644
--- a/pkg/trait/error_handler_test.go
+++ b/pkg/trait/error_handler_test.go
@@ -29,9 +29,12 @@ import (
)
func TestErrorHandlerConfigureFromIntegrationProperty(t *testing.T) {
+ catalog, err := camel.DefaultCatalog()
+ require.NoError(t, err)
e := &Environment{
- Catalog: NewEnvironmentTestCatalog(),
- Integration: &v1.Integration{},
+ CamelCatalog: catalog,
+ Catalog: NewEnvironmentTestCatalog(),
+ Integration: &v1.Integration{},
}
e.Integration.Spec.AddConfigurationProperty(fmt.Sprintf("%v = %s", v1.ErrorHandlerRefName, "defaultErrorHandler"))
@@ -56,9 +59,12 @@ func TestErrorHandlerConfigureFromIntegrationProperty(t *testing.T) {
}
func TestErrorHandlerApplySource(t *testing.T) {
+ catalog, err := camel.DefaultCatalog()
+ require.NoError(t, err)
e := &Environment{
- Catalog: NewEnvironmentTestCatalog(),
- Integration: &v1.Integration{},
+ CamelCatalog: catalog,
+ Catalog: NewEnvironmentTestCatalog(),
+ Integration: &v1.Integration{},
}
e.Integration.Spec.AddConfiguration("property", fmt.Sprintf("%v = %s", v1.ErrorHandlerRefName, "defaultErrorHandler"))
e.Integration.Status.Phase = v1.IntegrationPhaseInitialization
diff --git a/pkg/trait/health.go b/pkg/trait/health.go
index c01c5cb31..a214b7144 100644
--- a/pkg/trait/health.go
+++ b/pkg/trait/health.go
@@ -53,6 +53,9 @@ func newHealthTrait() Trait {
}
func (t *healthTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
+ if e.CamelCatalog == nil {
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
if e.Integration == nil ||
!e.IntegrationInPhase(v1.IntegrationPhaseInitialization) && !e.IntegrationInRunningPhases() {
return false, nil, nil
diff --git a/pkg/trait/jvm.go b/pkg/trait/jvm.go
index a47e59f6f..57a59081a 100644
--- a/pkg/trait/jvm.go
+++ b/pkg/trait/jvm.go
@@ -66,16 +66,16 @@ func (t *jvmTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
// The JVM trait must be disabled in case the current IntegrationKit corresponds to a native build
if qt := e.Catalog.GetTrait(quarkusTraitID); qt != nil {
if quarkus, ok := qt.(*quarkusTrait); ok && quarkus.isNativeIntegration(e) {
- return false, newIntegrationConditionPlatformDisabledWithMessage("JVM", "quarkus native build"), nil
+ return false, NewIntegrationConditionPlatformDisabledWithMessage("JVM", "quarkus native build"), nil
}
}
if e.IntegrationKit != nil && e.IntegrationKit.IsSynthetic() {
- return false, newIntegrationConditionPlatformDisabledWithMessage("JVM", "integration kit was not created via Camel K operator"), nil
+ return false, NewIntegrationConditionPlatformDisabledWithMessage("JVM", "integration kit was not created via Camel K operator"), nil
}
if e.CamelCatalog == nil {
- return false, newIntegrationConditionPlatformDisabledWithMessage("JVM", "no camel catalog available for this Integration"), nil
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
}
return true, nil, nil
}
diff --git a/pkg/trait/kamelets.go b/pkg/trait/kamelets.go
index 280501848..77df3baf2 100644
--- a/pkg/trait/kamelets.go
+++ b/pkg/trait/kamelets.go
@@ -79,6 +79,9 @@ func (t *kameletsTrait) Configure(e *Environment) (bool, *TraitCondition, error)
if !pointer.BoolDeref(t.Enabled, true) {
return false, NewIntegrationConditionUserDisabled("Kamelets"), nil
}
+ if e.CamelCatalog == nil {
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
if !e.IntegrationInPhase(v1.IntegrationPhaseInitialization) && !e.IntegrationInRunningPhases() {
return false, nil, nil
}
diff --git a/pkg/trait/knative.go b/pkg/trait/knative.go
index 30063f98a..3328ec650 100644
--- a/pkg/trait/knative.go
+++ b/pkg/trait/knative.go
@@ -73,6 +73,9 @@ func (t *knativeTrait) Configure(e *Environment) (bool, *TraitCondition, error)
if !pointer.BoolDeref(t.Enabled, true) {
return false, NewIntegrationConditionUserDisabled("Knative"), nil
}
+ if e.CamelCatalog == nil {
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
if !e.IntegrationInPhase(v1.IntegrationPhaseInitialization) && !e.IntegrationInRunningPhases() {
return false, nil, nil
}
diff --git a/pkg/trait/knative_service.go b/pkg/trait/knative_service.go
index e8baaf7d6..a8e53a779 100644
--- a/pkg/trait/knative_service.go
+++ b/pkg/trait/knative_service.go
@@ -144,8 +144,8 @@ func (t *knativeServiceTrait) Apply(e *Environment) error {
}
func (t *knativeServiceTrait) SelectControllerStrategy(e *Environment) (*ControllerStrategy, error) {
- if !pointer.BoolDeref(t.Enabled, true) {
- // explicitly disabled
+ if !pointer.BoolDeref(t.Enabled, true) || e.CamelCatalog == nil {
+ // explicitly disabled or sourceless Integration (missing catalog)
return nil, nil
}
diff --git a/pkg/trait/logging.go b/pkg/trait/logging.go
index 1063e21e7..aaea69eee 100644
--- a/pkg/trait/logging.go
+++ b/pkg/trait/logging.go
@@ -56,7 +56,7 @@ func (l loggingTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
return false, NewIntegrationConditionUserDisabled("Logging"), nil
}
if e.CamelCatalog == nil {
- return false, newIntegrationConditionPlatformDisabledWithMessage("Logging", "no camel catalog available for this Integration"), nil
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
}
return e.IntegrationInRunningPhases(), nil, nil
diff --git a/pkg/trait/openapi.go b/pkg/trait/openapi.go
index 1cbc5fe96..1157b80a6 100644
--- a/pkg/trait/openapi.go
+++ b/pkg/trait/openapi.go
@@ -59,7 +59,9 @@ func (t *openAPITrait) Configure(e *Environment) (bool, *TraitCondition, error)
if !e.IntegrationInPhase(v1.IntegrationPhaseInitialization) {
return false, nil, nil
}
-
+ if e.CamelCatalog == nil {
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
// check if the runtime provides 'rest' capabilities
if _, ok := e.CamelCatalog.Runtime.Capabilities[v1.CapabilityRest]; !ok {
return false, nil, fmt.Errorf("the runtime provider %s does not declare 'rest' capability", e.CamelCatalog.Runtime.Provider)
diff --git a/pkg/trait/quarkus.go b/pkg/trait/quarkus.go
index 1140029be..28b44a382 100644
--- a/pkg/trait/quarkus.go
+++ b/pkg/trait/quarkus.go
@@ -140,6 +140,9 @@ func (t *quarkusTrait) Matches(trait Trait) bool {
}
func (t *quarkusTrait) Configure(e *Environment) (bool, *TraitCondition, error) {
+ if e.CamelCatalog == nil {
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
condition := t.adaptDeprecatedFields()
return e.IntegrationInPhase(v1.IntegrationPhaseBuildingKit) ||
diff --git a/pkg/trait/service.go b/pkg/trait/service.go
index b2e081ab2..515133658 100644
--- a/pkg/trait/service.go
+++ b/pkg/trait/service.go
@@ -56,13 +56,15 @@ func (t *serviceTrait) Configure(e *Environment) (bool, *TraitCondition, error)
"explicitly disabled",
), nil
}
-
+ if e.CamelCatalog == nil {
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
// in case the knative-service and service trait are enabled, the knative-service has priority
// then this service is disabled
if e.GetTrait(knativeServiceTraitID) != nil {
knativeServiceTrait, _ := e.GetTrait(knativeServiceTraitID).(*knativeServiceTrait)
if pointer.BoolDeref(knativeServiceTrait.Enabled, true) {
- return false, newIntegrationConditionPlatformDisabledWithMessage("Service", "knative-service trait has priority over this trait"), nil
+ return false, NewIntegrationConditionPlatformDisabledWithMessage("Service", "knative-service trait has priority over this trait"), nil
}
}
diff --git a/pkg/trait/service_binding.go b/pkg/trait/service_binding.go
index 867c8b4c2..2ed176670 100644
--- a/pkg/trait/service_binding.go
+++ b/pkg/trait/service_binding.go
@@ -70,6 +70,9 @@ func (t *serviceBindingTrait) Configure(e *Environment) (bool, *TraitCondition,
if !pointer.BoolDeref(t.Enabled, true) {
return false, NewIntegrationConditionUserDisabled("ServiceBinding"), nil
}
+ if e.CamelCatalog == nil {
+ return false, NewIntegrationConditionPlatformDisabledCatalogMissing(), nil
+ }
if len(t.Services) == 0 {
return false, nil, nil
}
diff --git a/pkg/trait/trait_condition_types.go b/pkg/trait/trait_condition_types.go
index 216993a27..86abc5ea2 100644
--- a/pkg/trait/trait_condition_types.go
+++ b/pkg/trait/trait_condition_types.go
@@ -56,10 +56,25 @@ func NewIntegrationConditionUserDisabled(traitID string) *TraitCondition {
return NewIntegrationCondition(traitID, v1.IntegrationConditionTraitInfo, corev1.ConditionTrue, traitConfigurationReason, userDisabledMessage)
}
-func newIntegrationConditionPlatformDisabledWithMessage(traitID string, message string) *TraitCondition {
+func NewIntegrationConditionUserEnabledWithMessage(traitID string, message string) *TraitCondition {
+ return NewIntegrationCondition(traitID, v1.IntegrationConditionTraitInfo, corev1.ConditionTrue, traitConfigurationReason, fmt.Sprintf("%s: %s", userEnabledMessage, message))
+}
+
+func NewIntegrationConditionPlatformDisabledWithMessage(traitID string, message string) *TraitCondition {
return NewIntegrationCondition(traitID, v1.IntegrationConditionTraitInfo, corev1.ConditionTrue, traitConfigurationReason, fmt.Sprintf("%s: %s", platformDisabledMessage, message))
}
+// This one is reused among different traits in order to avoid polluting the conditions with the same message.
+func NewIntegrationConditionPlatformDisabledCatalogMissing() *TraitCondition {
+ return NewIntegrationCondition(
+ "Generic",
+ v1.IntegrationConditionTraitInfo,
+ corev1.ConditionTrue,
+ traitConfigurationReason,
+ "no camel catalog available for this Integration. Several traits have not been executed for this reason. Check applied trait condition to know more.",
+ )
+}
+
func (tc *TraitCondition) integrationCondition() (v1.IntegrationConditionType, corev1.ConditionStatus, string, string) {
return v1.IntegrationConditionType(fmt.Sprintf("%s%s", tc.traitID, tc.integrationConditionType)),
tc.conditionStatus,