refactor: (WIP) returning errorOnApply and errorOnAudit

dieppa · dieppa · commit 51043f7b29c7 · 2025-10-03T16:47:12.000+08:00
diff --git a/core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/error/FlamingockException.java b/core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/error/FlamingockException.java
@@ -22,10 +22,6 @@
 public class FlamingockException extends RuntimeException {
 
 
-  public FlamingockException() {
-    super();
-  }
-
   public FlamingockException(Throwable cause) {
     super(cause);
   }
@@ -38,12 +34,4 @@ public FlamingockException(String formattedMessage, Object... args) {
     super(String.format(formattedMessage, args));
   }
 
-  public FlamingockException(Throwable cause, String formattedMessage, Object... args) {
-    this(String.format(formattedMessage, args), cause);
-  }
-
-  public FlamingockException(Throwable cause, String message) {
-    super(message, cause);
-  }
-
 }
diff --git a/core/flamingock-core/src/main/java/io/flamingock/internal/core/pipeline/execution/StageExecutionException.java b/core/flamingock-core/src/main/java/io/flamingock/internal/core/pipeline/execution/StageExecutionException.java
@@ -19,16 +19,17 @@
 
 public class StageExecutionException extends FlamingockException {
 
-    private final StageSummary summary;
-
-
-    public StageExecutionException(StageSummary summary) {
-        super("\n\n" + summary.getPretty() + "\n");
-        this.summary = summary;
+    public static StageExecutionException fromExisting(Throwable exception, StageSummary summary) {
+        Throwable cause = exception.getCause();
+        return (exception instanceof FlamingockException) && cause != null
+                ? new StageExecutionException(cause, summary)
+                : new StageExecutionException(exception, summary);
     }
 
-    public StageExecutionException(Throwable throwable, StageSummary summary) {
-        super(throwable);
+    private final StageSummary summary;
+
+    private StageExecutionException(Throwable cause, StageSummary summary) {
+        super(cause);
         this.summary = summary;
     }
 
diff --git a/core/flamingock-core/src/main/java/io/flamingock/internal/core/pipeline/execution/StageExecutor.java b/core/flamingock-core/src/main/java/io/flamingock/internal/core/pipeline/execution/StageExecutor.java
@@ -23,6 +23,7 @@
 import io.flamingock.internal.core.store.lock.Lock;
 import io.flamingock.internal.core.targets.TargetSystemManager;
 import io.flamingock.internal.core.task.executable.ExecutableTask;
+import io.flamingock.internal.core.task.navigation.FailedChangeProcessResult;
 import io.flamingock.internal.core.task.navigation.navigator.ChangeProcessResult;
 import io.flamingock.internal.core.task.navigation.navigator.ChangeProcessStrategy;
 import io.flamingock.internal.core.task.navigation.navigator.ChangeProcessStrategyFactory;
@@ -91,27 +92,25 @@ public Output executeStage(ExecutableStage executableStage,
                     })
                     .filter(ChangeProcessResult::isFailed)
                     .findFirst()
+                    .map(processResult -> (FailedChangeProcessResult)processResult)
                     .ifPresent(failedResult -> {
                         Duration stageDuration = Duration.between(stageStart, LocalDateTime.now());
                         logger.debug("Stage execution failed [stage={} duration={} failed_change={}]",
                                    stageName, formatDuration(stageDuration), failedResult.getChangeId());
-                        throw new StageExecutionException(summary);
+                        throw StageExecutionException.fromExisting(failedResult.getException(), summary);
                     });
 
             Duration stageDuration = Duration.between(stageStart, LocalDateTime.now());
             logger.info("Stage execution completed successfully [stage={} duration={} tasks={}]", 
                        stageName, formatDuration(stageDuration), taskCount);
 
         } catch (StageExecutionException stageExecutionException) {
-            Duration stageDuration = Duration.between(stageStart, LocalDateTime.now());
-            logger.debug("Stage execution failed [stage={} duration={}]",
-                       stageName, formatDuration(stageDuration));
             throw stageExecutionException;
         } catch (Throwable throwable) {
             Duration stageDuration = Duration.between(stageStart, LocalDateTime.now());
             logger.debug("Stage execution failed with unexpected error [stage={} duration={} error={}]",
                        stageName, formatDuration(stageDuration), throwable.getMessage(), throwable);
-            throw new StageExecutionException(throwable, summary);
+            throw StageExecutionException.fromExisting(throwable, summary);
         }
 
         return new Output(summary);
diff --git a/core/flamingock-core/src/main/java/io/flamingock/internal/core/runner/PipelineExecutionException.java b/core/flamingock-core/src/main/java/io/flamingock/internal/core/runner/PipelineExecutionException.java
@@ -19,15 +19,17 @@
 
 public class PipelineExecutionException extends FlamingockException {
 
-    private final PipelineSummary summary;
+    public static PipelineExecutionException fromExisting(Throwable exception, PipelineSummary summary) {
+        Throwable cause = exception.getCause();
+        return (exception instanceof FlamingockException) && cause != null
+                ? new PipelineExecutionException(cause, summary)
+                : new PipelineExecutionException(exception, summary);
+    }
 
+    private final PipelineSummary summary;
 
-    public PipelineExecutionException(PipelineSummary summary) {
-        super("\n\n" + summary.getPretty() + "\n");
-        this.summary = summary;
-    }
 
-    public PipelineExecutionException(Throwable throwable, PipelineSummary summary) {
+    private PipelineExecutionException(Throwable throwable, PipelineSummary summary) {
         super(throwable);
         this.summary = summary;
     }
diff --git a/core/flamingock-core/src/main/java/io/flamingock/internal/core/runner/PipelineRunner.java b/core/flamingock-core/src/main/java/io/flamingock/internal/core/runner/PipelineRunner.java
@@ -15,12 +15,7 @@
  */
 package io.flamingock.internal.core.runner;
 
-import io.flamingock.internal.util.id.RunnerId;
 import io.flamingock.internal.common.core.error.FlamingockException;
-import io.flamingock.internal.core.plan.ExecutionPlan;
-import io.flamingock.internal.core.plan.ExecutionPlanner;
-import io.flamingock.internal.core.store.lock.Lock;
-import io.flamingock.internal.core.store.lock.LockException;
 import io.flamingock.internal.core.event.EventPublisher;
 import io.flamingock.internal.core.event.model.impl.PipelineCompletedEvent;
 import io.flamingock.internal.core.event.model.impl.PipelineFailedEvent;
@@ -29,13 +24,18 @@
 import io.flamingock.internal.core.event.model.impl.StageFailedEvent;
 import io.flamingock.internal.core.event.model.impl.StageStartedEvent;
 import io.flamingock.internal.core.pipeline.execution.ExecutableStage;
-import io.flamingock.internal.core.pipeline.loaded.stage.AbstractLoadedStage;
-import io.flamingock.internal.core.pipeline.loaded.LoadedPipeline;
 import io.flamingock.internal.core.pipeline.execution.ExecutionContext;
 import io.flamingock.internal.core.pipeline.execution.OrphanExecutionContext;
 import io.flamingock.internal.core.pipeline.execution.StageExecutionException;
 import io.flamingock.internal.core.pipeline.execution.StageExecutor;
 import io.flamingock.internal.core.pipeline.execution.StageSummary;
+import io.flamingock.internal.core.pipeline.loaded.LoadedPipeline;
+import io.flamingock.internal.core.pipeline.loaded.stage.AbstractLoadedStage;
+import io.flamingock.internal.core.plan.ExecutionPlan;
+import io.flamingock.internal.core.plan.ExecutionPlanner;
+import io.flamingock.internal.core.store.lock.Lock;
+import io.flamingock.internal.core.store.lock.LockException;
+import io.flamingock.internal.util.id.RunnerId;
 import io.flamingock.internal.util.log.FlamingockLoggerFactory;
 import org.slf4j.Logger;
 
@@ -82,6 +82,15 @@ public PipelineRunner(RunnerId runnerId,
         this.finalizer = finalizer;
     }
 
+    private static List<AbstractLoadedStage> validateAndGetExecutableStages(LoadedPipeline pipeline) {
+        pipeline.validate();
+        List<AbstractLoadedStage> stages = new ArrayList<>();
+        if (pipeline.getSystemStage().isPresent()) {
+            stages.add(pipeline.getSystemStage().get());
+        }
+        stages.addAll(pipeline.getStages());
+        return stages;
+    }
 
     private void run(LoadedPipeline pipeline) throws FlamingockException {
 
@@ -93,7 +102,7 @@ private void run(LoadedPipeline pipeline) throws FlamingockException {
                 // Validate execution plan for manual intervention requirements
                 // This centralized validation ensures both community and cloud paths are validated
                 execution.validate();
-                
+
                 if (pipelineSummary == null) {
                     pipelineSummary = new PipelineSummary(execution.getPipeline());
                 }
@@ -121,7 +130,7 @@ private void run(LoadedPipeline pipeline) throws FlamingockException {
                 //if it's a StageExecutionException, we can safely assume the stage started its
                 //execution, therefor the pipelinesSummary is initialised
                 requireNonNull(pipelineSummary).merge(e.getSummary());
-                throw new PipelineExecutionException(pipelineSummary);
+                throw PipelineExecutionException.fromExisting(e.getCause(), pipelineSummary);
             }
         } while (true);
 
@@ -131,17 +140,6 @@ private void run(LoadedPipeline pipeline) throws FlamingockException {
         eventPublisher.publish(new PipelineCompletedEvent());
     }
 
-    private static List<AbstractLoadedStage> validateAndGetExecutableStages(LoadedPipeline pipeline) {
-        pipeline.validate();
-        List<AbstractLoadedStage> stages = new ArrayList<>();
-        if(pipeline.getSystemStage().isPresent()) {
-            stages.add(pipeline.getSystemStage().get());
-        }
-        stages.addAll(pipeline.getStages());
-        return stages;
-    }
-
-
     private StageSummary runStage(String executionId, Lock lock, ExecutableStage executableStage) {
         try {
             return startStage(executionId, lock, executableStage);
@@ -164,12 +162,24 @@ private StageSummary startStage(String executionId, Lock lock, ExecutableStage e
         return executionOutput.getSummary();
     }
 
-    private FlamingockException processAndGetFlamingockException(Throwable generalException) throws FlamingockException {
-        FlamingockException exception = generalException instanceof FlamingockException ? (FlamingockException) generalException : new FlamingockException(generalException);
+    private FlamingockException processAndGetFlamingockException(Throwable exception) throws FlamingockException {
+        FlamingockException flamingockException;
+        if (exception instanceof PipelineExecutionException) {
+            PipelineExecutionException pipelineException = (PipelineExecutionException) exception;
+            if (pipelineException.getCause() instanceof FlamingockException) {
+                flamingockException = (FlamingockException) pipelineException.getCause();
+            } else {
+                flamingockException = (PipelineExecutionException) exception;
+            }
+        } else if (exception instanceof FlamingockException) {
+            flamingockException = (FlamingockException) exception;
+        } else {
+            flamingockException = new FlamingockException(exception);
+        }
         logger.debug("Error executing the process. ABORTED OPERATION", exception);
-        eventPublisher.publish(new StageFailedEvent(exception));
-        eventPublisher.publish(new PipelineFailedEvent(exception));
-        return exception;
+        eventPublisher.publish(new StageFailedEvent(flamingockException));
+        eventPublisher.publish(new PipelineFailedEvent(flamingockException));
+        return flamingockException;
     }
 
     @Override
diff --git a/core/flamingock-core/src/main/java/io/flamingock/internal/core/runtime/MissingInjectedParameterException.java b/core/flamingock-core/src/main/java/io/flamingock/internal/core/runtime/MissingInjectedParameterException.java
@@ -24,7 +24,7 @@ public class MissingInjectedParameterException extends FlamingockException {
   private final String name;
 
   public MissingInjectedParameterException(Class<?> wrongParameter, String name) {
-    super();
+    super(buildMessage(wrongParameter, name));
     this.wrongParameter = wrongParameter;
     this.name = name;
   }
@@ -37,12 +37,11 @@ public String getName() {
     return name;
   }
 
-  @Override
-  public String getMessage() {
+  private static String buildMessage(Class<?> wrongParameter, String name) {
 
 
     StringBuilder sb = new StringBuilder("Wrong parameter[")
-        .append(getWrongParameter().getSimpleName())
+        .append(wrongParameter.getSimpleName())
         .append("]");
     if (name != null) {
       sb.append(" with name: ")
diff --git a/core/flamingock-core/src/main/java/io/flamingock/internal/core/store/lock/LockException.java b/core/flamingock-core/src/main/java/io/flamingock/internal/core/store/lock/LockException.java
@@ -26,7 +26,4 @@ public LockException(String s) {
     super(s);
   }
 
-  public LockException() {
-    super();
-  }
 }
diff --git a/core/flamingock-core/src/main/java/io/flamingock/internal/core/task/executable/ChangeExecutionException.java b/core/flamingock-core/src/main/java/io/flamingock/internal/core/task/executable/ChangeExecutionException.java
@@ -0,0 +1,17 @@
+package io.flamingock.internal.core.task.executable;
+
+import io.flamingock.internal.common.core.error.FlamingockException;
+
+public class ChangeExecutionException extends FlamingockException {
+    public ChangeExecutionException(String changeId,
+                                    Throwable cause) {
+        super(buildMessage(changeId, cause));
+    }
+
+    private static String buildMessage(String changeId, Throwable cause) {
+        return String.format(
+                "error trying to apply change with id[%s]: %s",
+                changeId,
+                cause.getMessage());
+    }
+}
diff --git a/core/flamingock-core/src/main/java/io/flamingock/internal/core/task/executable/ReflectionExecutableTask.java b/core/flamingock-core/src/main/java/io/flamingock/internal/core/task/executable/ReflectionExecutableTask.java
@@ -16,6 +16,7 @@
 package io.flamingock.internal.core.task.executable;
 
 import io.flamingock.internal.core.runtime.ExecutionRuntime;
+import io.flamingock.internal.core.runtime.MissingInjectedParameterException;
 import io.flamingock.internal.core.task.loaded.AbstractReflectionLoadedTask;
 import io.flamingock.internal.common.core.recovery.action.ChangeAction;
 
@@ -75,7 +76,11 @@ public void execute(ExecutionRuntime executionRuntime) {
 
     protected void executeInternal(ExecutionRuntime executionRuntime, Method method ) {
         Object instance = executionRuntime.getInstance(descriptor.getConstructor());
-        executionRuntime.executeMethodWithInjectedDependencies(instance, method);
+        try {
+            executionRuntime.executeMethodWithInjectedDependencies(instance, method);
+        } catch (Throwable ex) {
+            throw new ChangeExecutionException(this.getId(), ex);
+        }
     }
 
     @Override
diff --git a/core/flamingock-core/src/main/java/io/flamingock/internal/core/task/executable/TemplateExecutableTask.java b/core/flamingock-core/src/main/java/io/flamingock/internal/core/task/executable/TemplateExecutableTask.java
@@ -39,15 +39,19 @@ public TemplateExecutableTask(String stageName,
 
     @Override
     protected void executeInternal(ExecutionRuntime executionRuntime, Method method ) {
-        logger.debug("Starting execution of change[{}] with template: {}", descriptor.getId(), descriptor.getTemplateClass());
-        logger.debug("change[{}] transactional: {}", descriptor.getId(), descriptor.isTransactional());
-        Object instance = executionRuntime.getInstance(descriptor.getConstructor());
-        ChangeTemplate<?,?,?> changeTemplateInstance = (ChangeTemplate<?,?,?>) instance;
-        changeTemplateInstance.setTransactional(descriptor.isTransactional());
-        setExecutionData(executionRuntime, changeTemplateInstance, "Configuration");
-        setExecutionData(executionRuntime, changeTemplateInstance, "ApplyPayload");
-        setExecutionData(executionRuntime, changeTemplateInstance, "RollbackPayload");
-        executionRuntime.executeMethodWithInjectedDependencies(instance, method);
+        try {
+            logger.debug("Starting execution of change[{}] with template: {}", descriptor.getId(), descriptor.getTemplateClass());
+            logger.debug("change[{}] transactional: {}", descriptor.getId(), descriptor.isTransactional());
+            Object instance = executionRuntime.getInstance(descriptor.getConstructor());
+            ChangeTemplate<?,?,?> changeTemplateInstance = (ChangeTemplate<?,?,?>) instance;
+            changeTemplateInstance.setTransactional(descriptor.isTransactional());
+            setExecutionData(executionRuntime, changeTemplateInstance, "Configuration");
+            setExecutionData(executionRuntime, changeTemplateInstance, "ApplyPayload");
+            setExecutionData(executionRuntime, changeTemplateInstance, "RollbackPayload");
+            executionRuntime.executeMethodWithInjectedDependencies(instance, method);
+        } catch (Throwable ex) {
+            throw new ChangeExecutionException(this.getId(), ex);
+        }
     }
 
 
diff --git a/core/flamingock-core/src/main/java/io/flamingock/internal/core/task/navigation/navigator/ChangeProcessLogger.java b/core/flamingock-core/src/main/java/io/flamingock/internal/core/task/navigation/navigator/ChangeProcessLogger.java
@@ -36,38 +36,38 @@ public class ChangeProcessLogger {
     private static final String AUTO_ROLLBACK_DESC = "auto-rollback";
 
     public void logChangeExecutionStart(String changeId) {
-        logger.info("Starting change execution [change={}]", changeId);
+        logger.info("Starting change execution [change= {}]", changeId);
     }
     
     public void logTargetSystemResolved(String changeId, TargetSystemDescriptor targetSystem) {
         String targetSystemId = targetSystem != null ? targetSystem.getId() : null;
-        logger.debug("Target system resolved [change={}, targetSystem={}]", changeId, targetSystemId);
+        logger.debug("Target system resolved [change= {}, targetSystem= {}]", changeId, targetSystemId);
     }
     
     public void logStrategyApplication(String changeId, String targetSystemId, String strategyType) {
-        logger.info("Applying change [change={}, target={}, strategy={}]", changeId, targetSystemId, strategyType);
+        logger.info("Applying change [change= {}, target= {}, strategy= {}]", changeId, targetSystemId, strategyType);
     }
 
     public void logSkippedExecution(String changeId) {
-        logger.info("SKIPPED [change={}, reason=already applied]", changeId);
+        logger.info("SKIPPED [change= {}, reason=already applied]", changeId);
     }
 
     public void logExecutionResult(ExecutionStep executionStep) {
         String taskId = executionStep.getTask().getId();
         String duration = formatDuration(executionStep.getDuration());
         
         if (executionStep instanceof SuccessApplyStep) {
-            logger.info("APPLIED [change={}, duration={}]", taskId, duration);
+            logger.info("APPLIED [change= {}, duration= {}]", taskId, duration);
         } else if (executionStep instanceof FailedExecutionStep) {
             FailedExecutionStep failed = (FailedExecutionStep) executionStep;
-            logger.error("FAILED [change={}, duration={}, error={}]",
+            logger.error("FAILED [change= {}, duration= {}] : {}",
                         taskId, duration, failed.getMainError().getMessage());
         }
     }
 
     public void logAutoRollback(ExecutableTask executableChange, long duration) {
         String formattedDuration = formatDuration(duration);
-        logger.info("ROLLED_BACK [change={}, duration={}]", executableChange.getId(), formattedDuration);
+        logger.info("ROLLED_BACK [change= {}, duration= {}]", executableChange.getId(), formattedDuration);
     }
 
     public void logManualRollbackResult(ManualRolledBackStep rolledBack) {
@@ -76,19 +76,19 @@ public void logManualRollbackResult(ManualRolledBackStep rolledBack) {
         
         if (rolledBack instanceof FailedManualRolledBackStep) {
             FailedManualRolledBackStep failed = (FailedManualRolledBackStep) rolledBack;
-            logger.error("ROLLBACK_FAILED [change={}, duration={}, error={}]", 
+            logger.error("ROLLBACK_FAILED [change= {}, duration= {}] : {}",
                         taskId, duration, failed.getMainError().getMessage());
         } else {
-            logger.info("ROLLED_BACK [change={}, duration={}]", taskId, duration);
+            logger.info("ROLLED_BACK [change= {}, duration= {}]", taskId, duration);
         }
     }
 
     public void logAuditResult(Result auditResult, String id, String description) {
         if (auditResult instanceof Result.Error) {
-            logger.error("Audit operation failed [change={}, operation={}, error={}]", 
+            logger.error("Audit operation failed [change= {}, operation= {}] : {}",
                         id, description, ((Result.Error) auditResult).getError().getMessage());
         } else {
-            logger.debug("Audit operation completed successfully [change={}, operation={}]", id, description);
+            logger.debug("Audit operation completed successfully [change= {}, operation= {}]", id, description);
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,4 @@ public LockException(String s) {`
`26`	`26`	`super(s);`
`27`	`27`	`}`
`28`	`28`
`29`		`- public LockException() {`
`30`		`- super();`
`31`		`- }`
`32`	`29`	`}`