remove duplicated codes by adding field cacheState to MojoParametersListener (#209)

Author: zrlw

src/main/java/org/apache/maven/buildcache/BuildCacheMojosExecutionStrategy.java

@@ -112,21 +112,28 @@ public void execute(
             // Forked execution should be thought as a part of originating mojo internal implementation
             // If forkedExecution is detected, it means that originating mojo is not cached so forks should rerun too
             boolean forkedExecution = lifecyclePhasesHelper.isForkedProject(project);
+            String projectName = getVersionlessProjectKey(project);
             List<MojoExecution> cleanPhase = null;
             if (source == Source.LIFECYCLE && !forkedExecution) {
-                cleanPhase = lifecyclePhasesHelper.getCleanSegment(project, mojoExecutions);
-                for (MojoExecution mojoExecution : cleanPhase) {
-                    mojoExecutionRunner.run(mojoExecution);
-                }
                 if (!cacheIsDisabled) {
                     cacheState = cacheConfig.initialize();
+                    if (cacheState == INITIALIZED) {
+                        // change mojoListener cacheState to INITIALIZED
+                        mojoListener.setCacheState(cacheState);
+                    }
+                    LOGGER.info("Cache is {} on project level for {}", cacheState, projectName);
                 } else {
-                    LOGGER.info(
-                            "Cache is explicitly disabled on project level for {}", getVersionlessProjectKey(project));
+                    LOGGER.info("Cache is explicitly disabled on project level for {}", projectName);
+                }
+                cleanPhase = lifecyclePhasesHelper.getCleanSegment(project, mojoExecutions);
+                for (MojoExecution mojoExecution : cleanPhase) {
+                    mojoExecutionRunner.run(mojoExecution);
                 }
                 if (cacheState == INITIALIZED || skipCache) {
                     result = cacheController.findCachedBuild(session, project, mojoExecutions, skipCache);
                 }
+            } else {
+                LOGGER.info("Cache is disabled on project level for {}", projectName);
             }
 
             boolean restorable = result.isSuccess() || result.isPartialSuccess();
@@ -163,9 +170,7 @@ public void execute(
 
             if (cacheConfig.isFailFast() && !result.isSuccess() && !skipCache && !forkedExecution) {
                 throw new LifecycleExecutionException(
-                        "Failed to restore project[" + getVersionlessProjectKey(project)
-                                + "] from cache, failing build.",
-                        project);
+                        "Failed to restore project[" + projectName + "] from cache, failing build.", project);
             }
         } catch (MojoExecutionException e) {
             throw new LifecycleExecutionException(e.getMessage(), e);

src/main/java/org/apache/maven/buildcache/MojoParametersListener.java

@@ -18,16 +18,13 @@
  */
 package org.apache.maven.buildcache;
 
-import javax.inject.Inject;
 import javax.inject.Named;
 import javax.inject.Singleton;
 
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
-import org.apache.maven.buildcache.checksum.MavenProjectInput;
-import org.apache.maven.buildcache.xml.CacheConfig;
 import org.apache.maven.buildcache.xml.CacheState;
 import org.apache.maven.execution.MojoExecutionEvent;
 import org.apache.maven.execution.MojoExecutionListener;
@@ -52,28 +49,18 @@ public class MojoParametersListener implements MojoExecutionListener {
     private final ConcurrentMap<MavenProject, Map<String, MojoExecutionEvent>> projectExecutions =
             new ConcurrentHashMap<>();
 
-    private final CacheConfig cacheConfig;
-
-    @Inject
-    public MojoParametersListener(CacheConfig cacheConfig) {
-        this.cacheConfig = cacheConfig;
-    }
+    private CacheState cacheState = DISABLED;
 
     @Override
     public void beforeMojoExecution(MojoExecutionEvent event) {
         final String executionKey = CacheUtils.mojoExecutionKey(event.getExecution());
         LOGGER.debug(
-                "Starting mojo execution: {}, class: {}",
+                "Starting mojo execution: {}, class: {}, cacheState: {}",
                 executionKey,
-                event.getMojo().getClass());
-        final MavenProject project = event.getProject();
-        CacheState cacheState = DISABLED;
-        boolean cacheIsDisabled = MavenProjectInput.isCacheDisabled(project);
-        if (!cacheIsDisabled) {
-            cacheState = cacheConfig.initialize();
-        }
-        LOGGER.debug("cacheState: {}", cacheState);
+                event.getMojo().getClass(),
+                cacheState);
         if (cacheState == INITIALIZED) {
+            final MavenProject project = event.getProject();
             Map<String, MojoExecutionEvent> projectEvents = projectExecutions.get(project);
             if (projectEvents == null) {
                 Map<String, MojoExecutionEvent> candidate = new ConcurrentHashMap<>();
@@ -99,4 +86,8 @@ public void afterExecutionFailure(MojoExecutionEvent event) {
     public Map<String, MojoExecutionEvent> getProjectExecutions(MavenProject project) {
         return projectExecutions.get(project);
     }
+
+    public void setCacheState(CacheState cacheState) {
+        this.cacheState = cacheState;
+    }
 }