This is an automated email from the ASF dual-hosted git repository.
astefanutti pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel-k.git
commit daf9c0fa003a80f69bbae3724fee8e642f2a20e4
Author: lburgazzoli <lburgazz...@gmail.com>
AuthorDate: Tue Jul 2 16:52:47 2019 +0200
Move waiting for platform to controller #797
---
pkg/apis/camel/v1alpha1/build_types.go | 8 ++-
pkg/apis/camel/v1alpha1/common_types_support.go | 14 +++-
pkg/apis/camel/v1alpha1/integration_types.go | 6 +-
pkg/apis/camel/v1alpha1/integrationkit_types.go | 6 +-
pkg/controller/build/build_controller.go | 61 +++++++++++-----
pkg/controller/build/{initialize.go => error.go} | 22 +++---
pkg/controller/build/initialize.go | 2 +-
pkg/controller/build/recovery.go | 10 +--
pkg/controller/integration/deploy.go | 3 +-
.../integration/{monitor.go => error.go} | 21 +++---
pkg/controller/integration/initialize.go | 34 +--------
.../integration/integration_controller.go | 82 ++++++++++++++--------
pkg/controller/integration/monitor.go | 5 +-
.../integrationkit/{monitor.go => error.go} | 20 +++---
pkg/controller/integrationkit/initialize.go | 12 +---
.../integrationkit/integrationkit_controller.go | 73 ++++++++++++-------
pkg/controller/integrationkit/monitor.go | 4 +-
pkg/trait/builder_test.go | 2 +-
pkg/trait/gc.go | 2 +-
pkg/trait/probes.go | 4 +-
pkg/trait/probes_test.go | 2 +-
21 files changed, 218 insertions(+), 175 deletions(-)
diff --git a/pkg/apis/camel/v1alpha1/build_types.go
b/pkg/apis/camel/v1alpha1/build_types.go
index 1c51661..b70ffd0 100644
--- a/pkg/apis/camel/v1alpha1/build_types.go
+++ b/pkg/apis/camel/v1alpha1/build_types.go
@@ -64,8 +64,12 @@ const (
// BuildKind --
BuildKind string = "Build"
- // BuildPhaseInitial --
- BuildPhaseInitial BuildPhase = ""
+ // BuildPhaseNone --
+ BuildPhaseNone BuildPhase = ""
+ // BuildPhaseInitialization --
+ BuildPhaseInitialization BuildPhase = "initialization"
+ // BuildPhaseWaitingForPlatform --
+ BuildPhaseWaitingForPlatform BuildPhase = "Waiting For Platform"
// BuildPhaseScheduling --
BuildPhaseScheduling BuildPhase = "Scheduling"
// BuildPhasePending --
diff --git a/pkg/apis/camel/v1alpha1/common_types_support.go
b/pkg/apis/camel/v1alpha1/common_types_support.go
index 09cf835..b09ee3f 100644
--- a/pkg/apis/camel/v1alpha1/common_types_support.go
+++ b/pkg/apis/camel/v1alpha1/common_types_support.go
@@ -19,12 +19,22 @@ package v1alpha1
import (
"fmt"
+
+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func (in *Artifact) String() string {
return in.ID
}
-func (spec ConfigurationSpec) String() string {
- return fmt.Sprintf("%s=%s", spec.Type, spec.Value)
+func (in *ConfigurationSpec) String() string {
+ return fmt.Sprintf("%s=%s", in.Type, in.Value)
+}
+
+// NewErrorFailure --
+func NewErrorFailure(err error) *Failure {
+ return &Failure{
+ Reason: err.Error(),
+ Time: metav1.Now(),
+ }
}
diff --git a/pkg/apis/camel/v1alpha1/integration_types.go
b/pkg/apis/camel/v1alpha1/integration_types.go
index 9127432..86ab6f3 100644
--- a/pkg/apis/camel/v1alpha1/integration_types.go
+++ b/pkg/apis/camel/v1alpha1/integration_types.go
@@ -142,8 +142,10 @@ const (
// IntegrationKind --
IntegrationKind string = "Integration"
- // IntegrationPhaseInitial --
- IntegrationPhaseInitial IntegrationPhase = ""
+ // IntegrationPhaseNone --
+ IntegrationPhaseNone IntegrationPhase = ""
+ // IntegrationPhaseInitialization --
+ IntegrationPhaseInitialization IntegrationPhase = "initialization"
// IntegrationPhaseWaitingForPlatform --
IntegrationPhaseWaitingForPlatform IntegrationPhase = "Waiting For
Platform"
// IntegrationPhaseBuildingKit --
diff --git a/pkg/apis/camel/v1alpha1/integrationkit_types.go
b/pkg/apis/camel/v1alpha1/integrationkit_types.go
index 2d199ae..a00cc86 100644
--- a/pkg/apis/camel/v1alpha1/integrationkit_types.go
+++ b/pkg/apis/camel/v1alpha1/integrationkit_types.go
@@ -82,8 +82,10 @@ const (
// IntegrationKitTypeExternal --
IntegrationKitTypeExternal = "external"
- // IntegrationKitPhaseInitial --
- IntegrationKitPhaseInitial IntegrationKitPhase = ""
+ // IntegrationKitPhaseNone --
+ IntegrationKitPhaseNone IntegrationKitPhase = ""
+ // IntegrationKitPhaseInitialization --
+ IntegrationKitPhaseInitialization IntegrationKitPhase = "initialization"
// IntegrationKitPhaseWaitingForPlatform --
IntegrationKitPhaseWaitingForPlatform IntegrationKitPhase = "Waiting
For Platform"
// IntegrationKitPhaseBuildSubmitted --
diff --git a/pkg/controller/build/build_controller.go
b/pkg/controller/build/build_controller.go
index fd85160..b88d0cb 100644
--- a/pkg/controller/build/build_controller.go
+++ b/pkg/controller/build/build_controller.go
@@ -21,6 +21,7 @@ import (
"sync"
"time"
+ "github.com/apache/camel-k/pkg/platform"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/errors"
k8serrors "k8s.io/apimachinery/pkg/api/errors"
@@ -161,6 +162,34 @@ func (r *ReconcileBuild) Reconcile(request
reconcile.Request) (reconcile.Result,
return reconcile.Result{}, err
}
+ target := instance.DeepCopy()
+ targetLog := rlog.ForBuild(target)
+
+ if target.Status.Phase == v1alpha1.BuildPhaseNone ||
target.Status.Phase == v1alpha1.BuildPhaseWaitingForPlatform {
+ pl, err := platform.GetCurrentPlatform(ctx, r.client,
target.Namespace)
+ switch {
+ case err != nil:
+ target.Status.Phase = v1alpha1.BuildPhaseError
+ target.Status.Failure = v1alpha1.NewErrorFailure(err)
+ case pl.Status.Phase != v1alpha1.IntegrationPlatformPhaseReady:
+ target.Status.Phase =
v1alpha1.BuildPhaseWaitingForPlatform
+ default:
+ target.Status.Phase = v1alpha1.BuildPhaseInitialization
+ }
+
+ if instance.Status.Phase != target.Status.Phase {
+ err = r.update(ctx, target)
+ if err != nil {
+ if k8serrors.IsConflict(err) {
+ targetLog.Error(err, "conflict")
+ err = nil
+ }
+ }
+ }
+
+ return reconcile.Result{}, err
+ }
+
actions := []Action{
NewInitializeAction(),
NewScheduleRoutineAction(r.reader, r.builder, &r.routines),
@@ -168,14 +197,9 @@ func (r *ReconcileBuild) Reconcile(request
reconcile.Request) (reconcile.Result,
NewMonitorRoutineAction(&r.routines),
NewMonitorPodAction(),
NewErrorRecoveryAction(),
+ NewErrorAction(),
}
- var err error
-
- target := instance.DeepCopy()
- targetPhase := target.Status.Phase
- targetLog := rlog.ForBuild(target)
-
for _, a := range actions {
a.InjectClient(r.client)
a.InjectLogger(targetLog)
@@ -183,15 +207,13 @@ func (r *ReconcileBuild) Reconcile(request
reconcile.Request) (reconcile.Result,
if a.CanHandle(target) {
targetLog.Infof("Invoking action %s", a.Name())
- phaseFrom := target.Status.Phase
-
- target, err = a.Handle(ctx, target)
+ newTarget, err := a.Handle(ctx, target)
if err != nil {
return reconcile.Result{}, err
}
- if target != nil {
- if err := r.client.Status().Update(ctx,
target); err != nil {
+ if newTarget != nil {
+ if err := r.update(ctx, newTarget); err != nil {
if k8serrors.IsConflict(err) {
targetLog.Error(err, "conflict")
return reconcile.Result{
@@ -202,15 +224,15 @@ func (r *ReconcileBuild) Reconcile(request
reconcile.Request) (reconcile.Result,
return reconcile.Result{}, err
}
- targetPhase = target.Status.Phase
-
- if targetPhase != phaseFrom {
+ if newTarget.Status.Phase !=
target.Status.Phase {
targetLog.Info(
"state transition",
- "phase-from", phaseFrom,
- "phase-to", target.Status.Phase,
+ "phase-from",
target.Status.Phase,
+ "phase-to",
newTarget.Status.Phase,
)
}
+
+ target = newTarget
}
// handle one action at time so the resource
@@ -220,7 +242,7 @@ func (r *ReconcileBuild) Reconcile(request
reconcile.Request) (reconcile.Result,
}
// Requeue scheduling build so that it re-enters the build working queue
- if targetPhase == v1alpha1.BuildPhaseScheduling || targetPhase ==
v1alpha1.BuildPhaseFailed {
+ if target.Status.Phase == v1alpha1.BuildPhaseScheduling ||
target.Status.Phase == v1alpha1.BuildPhaseFailed {
return reconcile.Result{
RequeueAfter: 5 * time.Second,
}, nil
@@ -228,3 +250,8 @@ func (r *ReconcileBuild) Reconcile(request
reconcile.Request) (reconcile.Result,
return reconcile.Result{}, nil
}
+
+// Update --
+func (r *ReconcileBuild) update(ctx context.Context, target *v1alpha1.Build)
error {
+ return r.client.Status().Update(ctx, target)
+}
diff --git a/pkg/controller/build/initialize.go b/pkg/controller/build/error.go
similarity index 65%
copy from pkg/controller/build/initialize.go
copy to pkg/controller/build/error.go
index a6fba9c..62d42b8 100644
--- a/pkg/controller/build/initialize.go
+++ b/pkg/controller/build/error.go
@@ -23,28 +23,26 @@ import (
"github.com/apache/camel-k/pkg/apis/camel/v1alpha1"
)
-// NewInitializeAction creates a new initialize action
-func NewInitializeAction() Action {
- return &initializeAction{}
+// NewErrorAction creates a new error action for scheduled routine
+func NewErrorAction() Action {
+ return &errorAction{}
}
-type initializeAction struct {
+type errorAction struct {
baseAction
}
// Name returns a common name of the action
-func (action *initializeAction) Name() string {
- return "initialize"
+func (action *errorAction) Name() string {
+ return "error"
}
// CanHandle tells whether this action can handle the build
-func (action *initializeAction) CanHandle(build *v1alpha1.Build) bool {
- return build.Status.Phase == v1alpha1.BuildPhaseInitial
+func (action *errorAction) CanHandle(build *v1alpha1.Build) bool {
+ return build.Status.Phase == v1alpha1.BuildPhaseError
}
// Handle handles the builds
-func (action *initializeAction) Handle(ctx context.Context, build
*v1alpha1.Build) (*v1alpha1.Build, error) {
- build.Status.Phase = v1alpha1.BuildPhaseScheduling
-
- return build, nil
+func (action *errorAction) Handle(ctx context.Context, build *v1alpha1.Build)
(*v1alpha1.Build, error) {
+ return nil, nil
}
diff --git a/pkg/controller/build/initialize.go
b/pkg/controller/build/initialize.go
index a6fba9c..a3c0674 100644
--- a/pkg/controller/build/initialize.go
+++ b/pkg/controller/build/initialize.go
@@ -39,7 +39,7 @@ func (action *initializeAction) Name() string {
// CanHandle tells whether this action can handle the build
func (action *initializeAction) CanHandle(build *v1alpha1.Build) bool {
- return build.Status.Phase == v1alpha1.BuildPhaseInitial
+ return build.Status.Phase == v1alpha1.BuildPhaseInitialization
}
// Handle handles the builds
diff --git a/pkg/controller/build/recovery.go b/pkg/controller/build/recovery.go
index 4492c87..f7abc97 100644
--- a/pkg/controller/build/recovery.go
+++ b/pkg/controller/build/recovery.go
@@ -24,8 +24,6 @@ import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"github.com/apache/camel-k/pkg/apis/camel/v1alpha1"
- "github.com/apache/camel-k/pkg/platform"
-
"github.com/jpillora/backoff"
)
@@ -56,12 +54,6 @@ func (action *errorRecoveryAction) CanHandle(build
*v1alpha1.Build) bool {
}
func (action *errorRecoveryAction) Handle(ctx context.Context, build
*v1alpha1.Build) (*v1alpha1.Build, error) {
- // The integration platform must be initialized before handling the
error recovery
- if _, err := platform.GetCurrentPlatform(ctx, action.client,
build.Namespace); err != nil {
- action.L.Info("Waiting for an integration platform to be
initialized")
- return nil, nil
- }
-
if build.Status.Failure == nil {
build.Status.Failure = &v1alpha1.Failure{
Reason: build.Status.Error,
@@ -96,7 +88,7 @@ func (action *errorRecoveryAction) Handle(ctx
context.Context, build *v1alpha1.B
}
build.Status = v1alpha1.BuildStatus{}
- build.Status.Phase = v1alpha1.BuildPhaseInitial
+ build.Status.Phase = v1alpha1.BuildPhaseInitialization
build.Status.Failure.Recovery.Attempt++
build.Status.Failure.Recovery.AttemptTime = metav1.Now()
diff --git a/pkg/controller/integration/deploy.go
b/pkg/controller/integration/deploy.go
index 36c43ec..d61e5ec 100644
--- a/pkg/controller/integration/deploy.go
+++ b/pkg/controller/integration/deploy.go
@@ -57,8 +57,7 @@ func (action *deployAction) Handle(ctx context.Context,
integration *v1alpha1.In
return nil, err
}
- target := integration.DeepCopy()
- target.Status.Phase = v1alpha1.IntegrationPhaseRunning
+ integration.Status.Phase = v1alpha1.IntegrationPhaseRunning
return integration, nil
}
diff --git a/pkg/controller/integration/monitor.go
b/pkg/controller/integration/error.go
similarity index 67%
copy from pkg/controller/integration/monitor.go
copy to pkg/controller/integration/error.go
index b5c99cb..262e866 100644
--- a/pkg/controller/integration/monitor.go
+++ b/pkg/controller/integration/error.go
@@ -24,25 +24,24 @@ import (
"github.com/apache/camel-k/pkg/util/digest"
)
-// NewMonitorAction creates a new monitoring action for an integration
-func NewMonitorAction() Action {
- return &monitorAction{}
+// NewErrorAction creates a new error action for an integration
+func NewErrorAction() Action {
+ return &errorAction{}
}
-type monitorAction struct {
+type errorAction struct {
baseAction
}
-func (action *monitorAction) Name() string {
- return "monitor"
+func (action *errorAction) Name() string {
+ return "error"
}
-func (action *monitorAction) CanHandle(integration *v1alpha1.Integration) bool
{
- return integration.Status.Phase == v1alpha1.IntegrationPhaseRunning ||
- integration.Status.Phase == v1alpha1.IntegrationPhaseError
+func (action *errorAction) CanHandle(integration *v1alpha1.Integration) bool {
+ return integration.Status.Phase == v1alpha1.IntegrationPhaseError
}
-func (action *monitorAction) Handle(ctx context.Context, integration
*v1alpha1.Integration) (*v1alpha1.Integration, error) {
+func (action *errorAction) Handle(ctx context.Context, integration
*v1alpha1.Integration) (*v1alpha1.Integration, error) {
hash, err := digest.ComputeForIntegration(integration)
if err != nil {
return nil, err
@@ -52,7 +51,7 @@ func (action *monitorAction) Handle(ctx context.Context,
integration *v1alpha1.I
action.L.Info("Integration needs a rebuild")
integration.Status.Digest = hash
- integration.Status.Phase = ""
+ integration.Status.Phase =
v1alpha1.IntegrationPhaseInitialization
return integration, nil
}
diff --git a/pkg/controller/integration/initialize.go
b/pkg/controller/integration/initialize.go
index 8fed1e8..53be34d 100644
--- a/pkg/controller/integration/initialize.go
+++ b/pkg/controller/integration/initialize.go
@@ -21,7 +21,6 @@ import (
"context"
"github.com/apache/camel-k/pkg/apis/camel/v1alpha1"
- "github.com/apache/camel-k/pkg/platform"
"github.com/apache/camel-k/pkg/trait"
)
@@ -41,42 +40,11 @@ func (action *initializeAction) Name() string {
// CanHandle tells whether this action can handle the integration
func (action *initializeAction) CanHandle(integration *v1alpha1.Integration)
bool {
- return integration.Status.Phase == v1alpha1.IntegrationPhaseInitial ||
integration.Status.Phase == v1alpha1.IntegrationPhaseWaitingForPlatform
+ return integration.Status.Phase ==
v1alpha1.IntegrationPhaseInitialization
}
// Handle handles the integrations
func (action *initializeAction) Handle(ctx context.Context, integration
*v1alpha1.Integration) (*v1alpha1.Integration, error) {
- pl, err := platform.GetCurrentPlatform(ctx, action.client,
integration.Namespace)
- if err != nil {
- return nil, err
- }
-
- // The integration platform needs to be ready before starting to create
integrations
- if pl.Status.Phase != v1alpha1.IntegrationPlatformPhaseReady {
- action.L.Info("Waiting for the integration platform to be
initialized")
-
- if integration.Status.Phase !=
v1alpha1.IntegrationPhaseWaitingForPlatform {
- integration.Status.Phase =
v1alpha1.IntegrationPhaseWaitingForPlatform
- return integration, nil
- }
-
- return nil, nil
- }
-
- //
- // restore phase to initial phase as traits are not aware of
- // WaitingForPlatform phase
- //
- if integration.Status.Phase ==
v1alpha1.IntegrationPhaseWaitingForPlatform {
- integration.Status.Phase = v1alpha1.IntegrationPhaseInitial
-
- return integration, nil
- }
-
- // better not changing the spec section of the target because it may be
used for comparison by a
- // higher level controller (e.g. Knative source controller)
-
- // execute custom initialization
if _, err := trait.Apply(ctx, action.client, integration, nil); err !=
nil {
return nil, err
}
diff --git a/pkg/controller/integration/integration_controller.go
b/pkg/controller/integration/integration_controller.go
index e604252..2bdfb96 100644
--- a/pkg/controller/integration/integration_controller.go
+++ b/pkg/controller/integration/integration_controller.go
@@ -19,6 +19,8 @@ package integration
import (
"context"
+ "github.com/apache/camel-k/pkg/platform"
+
"github.com/apache/camel-k/pkg/util/digest"
"k8s.io/apimachinery/pkg/api/errors"
@@ -224,25 +226,48 @@ func (r *ReconcileIntegration) Reconcile(request
reconcile.Request) (reconcile.R
return reconcile.Result{}, err
}
- actions := []Action{
- NewInitializeAction(),
- NewBuildKitAction(),
- NewDeployAction(),
- NewMonitorAction(),
- NewDeleteAction(),
- }
-
// Delete phase
if instance.GetDeletionTimestamp() != nil {
instance.Status.Phase = v1alpha1.IntegrationPhaseDeleting
}
- var targetPhase v1alpha1.IntegrationPhase
- var err error
-
target := instance.DeepCopy()
targetLog := rlog.ForIntegration(target)
+ if target.Status.Phase == v1alpha1.IntegrationPhaseNone ||
target.Status.Phase == v1alpha1.IntegrationPhaseWaitingForPlatform {
+ pl, err := platform.GetCurrentPlatform(ctx, r.client,
target.Namespace)
+ switch {
+ case err != nil:
+ target.Status.Phase = v1alpha1.IntegrationPhaseError
+ target.Status.Failure = v1alpha1.NewErrorFailure(err)
+ case pl.Status.Phase != v1alpha1.IntegrationPlatformPhaseReady:
+ target.Status.Phase =
v1alpha1.IntegrationPhaseWaitingForPlatform
+ default:
+ target.Status.Phase =
v1alpha1.IntegrationPhaseInitialization
+ }
+
+ if instance.Status.Phase != target.Status.Phase {
+ err = r.update(ctx, target)
+ if err != nil {
+ if k8serrors.IsConflict(err) {
+ targetLog.Error(err, "conflict")
+ err = nil
+ }
+ }
+ }
+
+ return reconcile.Result{}, err
+ }
+
+ actions := []Action{
+ NewInitializeAction(),
+ NewBuildKitAction(),
+ NewDeployAction(),
+ NewMonitorAction(),
+ NewErrorAction(),
+ NewDeleteAction(),
+ }
+
for _, a := range actions {
a.InjectClient(r.client)
a.InjectLogger(targetLog)
@@ -250,22 +275,13 @@ func (r *ReconcileIntegration) Reconcile(request
reconcile.Request) (reconcile.R
if a.CanHandle(target) {
targetLog.Infof("Invoking action %s", a.Name())
- phaseFrom := target.Status.Phase
-
- target, err = a.Handle(ctx, target)
+ newTarget, err := a.Handle(ctx, target)
if err != nil {
return reconcile.Result{}, err
}
- if target != nil {
- dgst, err :=
digest.ComputeForIntegration(target)
- if err != nil {
- return reconcile.Result{}, err
- }
-
- target.Status.Digest = dgst
-
- if err := r.client.Status().Update(ctx,
target); err != nil {
+ if newTarget != nil {
+ if err := r.update(ctx, newTarget); err != nil {
if k8serrors.IsConflict(err) {
targetLog.Error(err, "conflict")
return reconcile.Result{
@@ -276,13 +292,11 @@ func (r *ReconcileIntegration) Reconcile(request
reconcile.Request) (reconcile.R
return reconcile.Result{}, err
}
- targetPhase = target.Status.Phase
-
- if targetPhase != phaseFrom {
+ if newTarget.Status.Phase !=
target.Status.Phase {
targetLog.Info(
"state transition",
- "phase-from", phaseFrom,
- "phase-to", target.Status.Phase,
+ "phase-from",
target.Status.Phase,
+ "phase-to",
newTarget.Status.Phase,
)
}
}
@@ -295,3 +309,15 @@ func (r *ReconcileIntegration) Reconcile(request
reconcile.Request) (reconcile.R
return reconcile.Result{}, nil
}
+
+// Update --
+func (r *ReconcileIntegration) update(ctx context.Context, target
*v1alpha1.Integration) error {
+ dgst, err := digest.ComputeForIntegration(target)
+ if err != nil {
+ return err
+ }
+
+ target.Status.Digest = dgst
+
+ return r.client.Status().Update(ctx, target)
+}
diff --git a/pkg/controller/integration/monitor.go
b/pkg/controller/integration/monitor.go
index b5c99cb..f4ff480 100644
--- a/pkg/controller/integration/monitor.go
+++ b/pkg/controller/integration/monitor.go
@@ -38,8 +38,7 @@ func (action *monitorAction) Name() string {
}
func (action *monitorAction) CanHandle(integration *v1alpha1.Integration) bool
{
- return integration.Status.Phase == v1alpha1.IntegrationPhaseRunning ||
- integration.Status.Phase == v1alpha1.IntegrationPhaseError
+ return integration.Status.Phase == v1alpha1.IntegrationPhaseRunning
}
func (action *monitorAction) Handle(ctx context.Context, integration
*v1alpha1.Integration) (*v1alpha1.Integration, error) {
@@ -52,7 +51,7 @@ func (action *monitorAction) Handle(ctx context.Context,
integration *v1alpha1.I
action.L.Info("Integration needs a rebuild")
integration.Status.Digest = hash
- integration.Status.Phase = ""
+ integration.Status.Phase =
v1alpha1.IntegrationPhaseInitialization
return integration, nil
}
diff --git a/pkg/controller/integrationkit/monitor.go
b/pkg/controller/integrationkit/error.go
similarity index 65%
copy from pkg/controller/integrationkit/monitor.go
copy to pkg/controller/integrationkit/error.go
index a3910b1..ac63e46 100644
--- a/pkg/controller/integrationkit/monitor.go
+++ b/pkg/controller/integrationkit/error.go
@@ -24,24 +24,24 @@ import (
"github.com/apache/camel-k/pkg/util/digest"
)
-// NewMonitorAction creates a new monitoring handling action for the kit
-func NewMonitorAction() Action {
- return &monitorAction{}
+// NewErrorAction creates a new error handling action for the kit
+func NewErrorAction() Action {
+ return &errorAction{}
}
-type monitorAction struct {
+type errorAction struct {
baseAction
}
-func (action *monitorAction) Name() string {
- return "monitor"
+func (action *errorAction) Name() string {
+ return "error"
}
-func (action *monitorAction) CanHandle(kit *v1alpha1.IntegrationKit) bool {
- return kit.Status.Phase == v1alpha1.IntegrationKitPhaseReady ||
kit.Status.Phase == v1alpha1.IntegrationKitPhaseError
+func (action *errorAction) CanHandle(kit *v1alpha1.IntegrationKit) bool {
+ return kit.Status.Phase == v1alpha1.IntegrationKitPhaseError
}
-func (action *monitorAction) Handle(ctx context.Context, kit
*v1alpha1.IntegrationKit) (*v1alpha1.IntegrationKit, error) {
+func (action *errorAction) Handle(ctx context.Context, kit
*v1alpha1.IntegrationKit) (*v1alpha1.IntegrationKit, error) {
hash, err := digest.ComputeForIntegrationKit(kit)
if err != nil {
return nil, err
@@ -50,7 +50,7 @@ func (action *monitorAction) Handle(ctx context.Context, kit
*v1alpha1.Integrati
action.L.Info("IntegrationKit needs a rebuild")
kit.Status.Digest = hash
- kit.Status.Phase = v1alpha1.IntegrationKitPhaseBuildSubmitted
+ kit.Status.Phase = v1alpha1.IntegrationKitPhaseInitialization
return kit, nil
}
diff --git a/pkg/controller/integrationkit/initialize.go
b/pkg/controller/integrationkit/initialize.go
index 405797f..cfdb138 100644
--- a/pkg/controller/integrationkit/initialize.go
+++ b/pkg/controller/integrationkit/initialize.go
@@ -21,7 +21,6 @@ import (
"context"
"github.com/apache/camel-k/pkg/apis/camel/v1alpha1"
- "github.com/apache/camel-k/pkg/platform"
"github.com/apache/camel-k/pkg/trait"
)
@@ -39,18 +38,11 @@ func (action *initializeAction) Name() string {
}
func (action *initializeAction) CanHandle(kit *v1alpha1.IntegrationKit) bool {
- return kit.Status.Phase == v1alpha1.IntegrationKitPhaseInitial ||
kit.Status.Phase == v1alpha1.IntegrationKitPhaseWaitingForPlatform
+ return kit.Status.Phase == v1alpha1.IntegrationKitPhaseInitialization
}
func (action *initializeAction) Handle(ctx context.Context, kit
*v1alpha1.IntegrationKit) (*v1alpha1.IntegrationKit, error) {
- // The integration platform needs to be initialized before starting to
create kits
- _, err := platform.GetCurrentPlatform(ctx, action.client, kit.Namespace)
- if err != nil {
- action.L.Info("Waiting for the integration platform to be
initialized")
- return nil, nil
- }
-
- _, err = trait.Apply(ctx, action.client, nil, kit)
+ _, err := trait.Apply(ctx, action.client, nil, kit)
if err != nil {
return nil, err
}
diff --git a/pkg/controller/integrationkit/integrationkit_controller.go
b/pkg/controller/integrationkit/integrationkit_controller.go
index bca22e2..ff401d5 100644
--- a/pkg/controller/integrationkit/integrationkit_controller.go
+++ b/pkg/controller/integrationkit/integrationkit_controller.go
@@ -19,6 +19,8 @@ package integrationkit
import (
"context"
+ "github.com/apache/camel-k/pkg/platform"
+
"github.com/apache/camel-k/pkg/util/digest"
"k8s.io/apimachinery/pkg/api/errors"
@@ -141,18 +143,41 @@ func (r *ReconcileIntegrationKit) Reconcile(request
reconcile.Request) (reconcil
return reconcile.Result{}, err
}
+ target := instance.DeepCopy()
+ targetLog := rlog.ForIntegrationKit(target)
+
+ if target.Status.Phase == v1alpha1.IntegrationKitPhaseNone ||
target.Status.Phase == v1alpha1.IntegrationKitPhaseWaitingForPlatform {
+ pl, err := platform.GetCurrentPlatform(ctx, r.client,
target.Namespace)
+ switch {
+ case err != nil:
+ target.Status.Phase = v1alpha1.IntegrationKitPhaseError
+ target.Status.Failure = v1alpha1.NewErrorFailure(err)
+ case pl.Status.Phase != v1alpha1.IntegrationPlatformPhaseReady:
+ target.Status.Phase =
v1alpha1.IntegrationKitPhaseWaitingForPlatform
+ default:
+ target.Status.Phase =
v1alpha1.IntegrationKitPhaseInitialization
+ }
+
+ if instance.Status.Phase != target.Status.Phase {
+ err = r.update(ctx, target)
+ if err != nil {
+ if k8serrors.IsConflict(err) {
+ targetLog.Error(err, "conflict")
+ err = nil
+ }
+ }
+ }
+
+ return reconcile.Result{}, err
+ }
+
actions := []Action{
NewInitializeAction(),
NewBuildAction(),
NewMonitorAction(),
+ NewErrorAction(),
}
- var targetPhase v1alpha1.IntegrationKitPhase
- var err error
-
- target := instance.DeepCopy()
- targetLog := rlog.ForIntegrationKit(target)
-
for _, a := range actions {
a.InjectClient(r.client)
a.InjectLogger(targetLog)
@@ -160,23 +185,13 @@ func (r *ReconcileIntegrationKit) Reconcile(request
reconcile.Request) (reconcil
if a.CanHandle(target) {
targetLog.Infof("Invoking action %s", a.Name())
- phaseFrom := target.Status.Phase
-
- target, err = a.Handle(ctx, target)
+ newTarget, err := a.Handle(ctx, target)
if err != nil {
return reconcile.Result{}, err
}
- if target != nil {
- dgst, err :=
digest.ComputeForIntegrationKit(target)
- if err != nil {
- return reconcile.Result{}, err
- }
-
- target.Status.Digest = dgst
-
- err = r.client.Status().Update(ctx, target)
- if err != nil {
+ if newTarget != nil {
+ if err := r.update(ctx, newTarget); err != nil {
if k8serrors.IsConflict(err) {
targetLog.Error(err, "conflict")
return reconcile.Result{
@@ -187,13 +202,11 @@ func (r *ReconcileIntegrationKit) Reconcile(request
reconcile.Request) (reconcil
return reconcile.Result{}, err
}
- targetPhase = target.Status.Phase
-
- if targetPhase != phaseFrom {
+ if newTarget.Status.Phase !=
target.Status.Phase {
targetLog.Info(
"state transition",
- "phase-from", phaseFrom,
- "phase-to", target.Status.Phase,
+ "phase-from",
target.Status.Phase,
+ "phase-to",
newTarget.Status.Phase,
)
}
}
@@ -206,3 +219,15 @@ func (r *ReconcileIntegrationKit) Reconcile(request
reconcile.Request) (reconcil
return reconcile.Result{}, nil
}
+
+// Update --
+func (r *ReconcileIntegrationKit) update(ctx context.Context, target
*v1alpha1.IntegrationKit) error {
+ dgst, err := digest.ComputeForIntegrationKit(target)
+ if err != nil {
+ return err
+ }
+
+ target.Status.Digest = dgst
+
+ return r.client.Status().Update(ctx, target)
+}
diff --git a/pkg/controller/integrationkit/monitor.go
b/pkg/controller/integrationkit/monitor.go
index a3910b1..fdcfcbc 100644
--- a/pkg/controller/integrationkit/monitor.go
+++ b/pkg/controller/integrationkit/monitor.go
@@ -38,7 +38,7 @@ func (action *monitorAction) Name() string {
}
func (action *monitorAction) CanHandle(kit *v1alpha1.IntegrationKit) bool {
- return kit.Status.Phase == v1alpha1.IntegrationKitPhaseReady ||
kit.Status.Phase == v1alpha1.IntegrationKitPhaseError
+ return kit.Status.Phase == v1alpha1.IntegrationKitPhaseReady
}
func (action *monitorAction) Handle(ctx context.Context, kit
*v1alpha1.IntegrationKit) (*v1alpha1.IntegrationKit, error) {
@@ -50,7 +50,7 @@ func (action *monitorAction) Handle(ctx context.Context, kit
*v1alpha1.Integrati
action.L.Info("IntegrationKit needs a rebuild")
kit.Status.Digest = hash
- kit.Status.Phase = v1alpha1.IntegrationKitPhaseBuildSubmitted
+ kit.Status.Phase = v1alpha1.IntegrationKitPhaseInitialization
return kit, nil
}
diff --git a/pkg/trait/builder_test.go b/pkg/trait/builder_test.go
index a921cc8..f1153d3 100644
--- a/pkg/trait/builder_test.go
+++ b/pkg/trait/builder_test.go
@@ -66,7 +66,7 @@ func TestBuilderTraitNotAppliedBecauseOfNilPhase(t
*testing.T) {
for _, e := range environments {
e := e // pin
- e.IntegrationKit.Status.Phase = ""
+ e.IntegrationKit.Status.Phase =
v1alpha1.IntegrationKitPhaseInitialization
t.Run(string(e.Platform.Spec.Cluster), func(t *testing.T) {
err := NewBuilderTestCatalog().apply(e)
diff --git a/pkg/trait/gc.go b/pkg/trait/gc.go
index 68da326..d104db1 100644
--- a/pkg/trait/gc.go
+++ b/pkg/trait/gc.go
@@ -46,7 +46,7 @@ func (t *garbageCollectorTrait) Configure(e *Environment)
(bool, error) {
return false, nil
}
- return e.IntegrationInPhase(v1alpha1.IntegrationPhaseInitial) ||
+ return e.IntegrationInPhase(v1alpha1.IntegrationPhaseInitialization) ||
e.IntegrationInPhase(v1alpha1.IntegrationPhaseDeploying), nil
}
diff --git a/pkg/trait/probes.go b/pkg/trait/probes.go
index 7d76132..1cfb46a 100644
--- a/pkg/trait/probes.go
+++ b/pkg/trait/probes.go
@@ -58,14 +58,14 @@ func newProbesTrait() *probesTrait {
func (t *probesTrait) Configure(e *Environment) (bool, error) {
if t.Enabled != nil && *t.Enabled {
- return e.IntegrationInPhase(v1alpha1.IntegrationPhaseInitial)
|| e.IntegrationInPhase(v1alpha1.IntegrationPhaseDeploying), nil
+ return
e.IntegrationInPhase(v1alpha1.IntegrationPhaseInitialization) ||
e.IntegrationInPhase(v1alpha1.IntegrationPhaseDeploying), nil
}
return false, nil
}
func (t *probesTrait) Apply(e *Environment) error {
- if e.IntegrationInPhase(v1alpha1.IntegrationPhaseInitial) {
+ if e.IntegrationInPhase(v1alpha1.IntegrationPhaseInitialization) {
util.StringSliceUniqueAdd(&e.Integration.Status.Dependencies,
"runtime:health")
// sort the dependencies to get always the same list if they
don't change
diff --git a/pkg/trait/probes_test.go b/pkg/trait/probes_test.go
index 82c95cf..90b6b56 100644
--- a/pkg/trait/probes_test.go
+++ b/pkg/trait/probes_test.go
@@ -34,7 +34,7 @@ func TestProbesDeps(t *testing.T) {
e := Environment{
Integration: &v1alpha1.Integration{
Status: v1alpha1.IntegrationStatus{
- Phase: v1alpha1.IntegrationPhaseInitial,
+ Phase: v1alpha1.IntegrationPhaseInitialization,
},
},
}
