| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.maven.buildcache; |
| |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.nio.charset.StandardCharsets; |
| import java.nio.file.FileVisitResult; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.nio.file.SimpleFileVisitor; |
| import java.nio.file.attribute.BasicFileAttributes; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.Optional; |
| import java.util.Set; |
| import java.util.TreeSet; |
| import java.util.UUID; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.concurrent.ConcurrentMap; |
| import java.util.concurrent.Future; |
| import java.util.concurrent.FutureTask; |
| import java.util.regex.Pattern; |
| import javax.annotation.Nonnull; |
| import javax.inject.Inject; |
| import javax.inject.Named; |
| import org.apache.commons.io.FileUtils; |
| import org.apache.commons.io.FilenameUtils; |
| import org.apache.commons.lang3.StringUtils; |
| import org.apache.commons.lang3.mutable.MutableBoolean; |
| import org.apache.maven.SessionScoped; |
| import org.apache.maven.artifact.handler.ArtifactHandler; |
| import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager; |
| import org.apache.maven.buildcache.artifact.RestoredArtifact; |
| import org.apache.maven.buildcache.hash.HashAlgorithm; |
| import org.apache.maven.buildcache.hash.HashFactory; |
| import org.apache.maven.buildcache.xml.Build; |
| import org.apache.maven.buildcache.xml.CacheConfig; |
| import org.apache.maven.buildcache.xml.CacheSource; |
| import org.apache.maven.buildcache.xml.DtoUtils; |
| import org.apache.maven.buildcache.xml.XmlService; |
| import org.apache.maven.buildcache.xml.build.Artifact; |
| import org.apache.maven.buildcache.xml.build.CompletedExecution; |
| import org.apache.maven.buildcache.xml.build.DigestItem; |
| import org.apache.maven.buildcache.xml.build.ProjectsInputInfo; |
| import org.apache.maven.buildcache.xml.build.Scm; |
| import org.apache.maven.buildcache.xml.config.PropertyName; |
| import org.apache.maven.buildcache.xml.config.TrackedProperty; |
| import org.apache.maven.buildcache.xml.diff.Diff; |
| import org.apache.maven.buildcache.xml.report.CacheReport; |
| import org.apache.maven.buildcache.xml.report.ProjectReport; |
| import org.apache.maven.execution.MavenSession; |
| import org.apache.maven.execution.MojoExecutionEvent; |
| import org.apache.maven.plugin.Mojo; |
| import org.apache.maven.plugin.MojoExecution; |
| import org.apache.maven.plugin.descriptor.Parameter; |
| import org.apache.maven.project.MavenProject; |
| import org.apache.maven.project.MavenProjectHelper; |
| import org.apache.maven.repository.RepositorySystem; |
| import org.codehaus.plexus.util.ReflectionUtils; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import static java.nio.file.StandardOpenOption.CREATE; |
| import static java.nio.file.StandardOpenOption.TRUNCATE_EXISTING; |
| import static org.apache.commons.lang3.StringUtils.isNotBlank; |
| import static org.apache.commons.lang3.StringUtils.replace; |
| import static org.apache.commons.lang3.StringUtils.split; |
| import static org.apache.maven.buildcache.CacheResult.empty; |
| import static org.apache.maven.buildcache.CacheResult.failure; |
| import static org.apache.maven.buildcache.CacheResult.partialSuccess; |
| import static org.apache.maven.buildcache.CacheResult.rebuilded; |
| import static org.apache.maven.buildcache.CacheResult.success; |
| import static org.apache.maven.buildcache.HttpCacheRepositoryImpl.BUILDINFO_XML; |
| import static org.apache.maven.buildcache.checksum.KeyUtils.getVersionlessProjectKey; |
| import static org.apache.maven.buildcache.checksum.MavenProjectInput.CACHE_IMPLEMENTATION_VERSION; |
| |
| /** |
| * CacheControllerImpl |
| */ |
| @SessionScoped |
| @Named |
| @SuppressWarnings( "unused" ) |
| public class CacheControllerImpl implements CacheController |
| { |
| |
| public static final String FILE_SEPARATOR_SUBST = "_"; |
| |
| /** |
| * Prefix for generated sources stored as a separate artifact in cache |
| */ |
| private static final String BUILD_PREFIX = "build" + FILE_SEPARATOR_SUBST; |
| |
| private static final Logger LOGGER = LoggerFactory.getLogger( CacheControllerImpl.class ); |
| |
| private final MavenProjectHelper projectHelper; |
| |
| private final ArtifactHandlerManager artifactHandlerManager; |
| |
| private final XmlService xmlService; |
| |
| private final CacheConfig cacheConfig; |
| |
| private final LocalCacheRepository localCache; |
| |
| private final RemoteCacheRepository remoteCache; |
| |
| private final ConcurrentMap<String, CacheResult> cacheResults = new ConcurrentHashMap<>(); |
| |
| private final LifecyclePhasesHelper lifecyclePhasesHelper; |
| |
| private volatile Map<String, MavenProject> projectIndex; |
| |
| private final ProjectInputCalculator projectInputCalculator; |
| |
| private final RestoredArtifactHandler restoreArtifactHandler; |
| |
| private volatile Scm scm; |
| |
| @Inject |
| @SuppressWarnings( "checkstyle:ParameterNumber" ) |
| public CacheControllerImpl( |
| MavenProjectHelper projectHelper, |
| RepositorySystem repoSystem, |
| ArtifactHandlerManager artifactHandlerManager, |
| XmlService xmlService, |
| LocalCacheRepository localCache, |
| RemoteCacheRepository remoteCache, |
| CacheConfig cacheConfig, |
| ProjectInputCalculator projectInputCalculator, |
| RestoredArtifactHandler restoreArtifactHandler, |
| LifecyclePhasesHelper lifecyclePhasesHelper, |
| MavenSession session ) |
| { |
| this.projectHelper = projectHelper; |
| this.localCache = localCache; |
| this.remoteCache = remoteCache; |
| this.cacheConfig = cacheConfig; |
| this.artifactHandlerManager = artifactHandlerManager; |
| this.xmlService = xmlService; |
| this.lifecyclePhasesHelper = lifecyclePhasesHelper; |
| this.projectInputCalculator = projectInputCalculator; |
| this.restoreArtifactHandler = restoreArtifactHandler; |
| } |
| |
| @Override |
| @Nonnull |
| public CacheResult findCachedBuild( MavenSession session, MavenProject project, |
| List<MojoExecution> mojoExecutions ) |
| { |
| final String highestRequestPhase = CacheUtils.getLast( mojoExecutions ).getLifecyclePhase(); |
| if ( !lifecyclePhasesHelper.isLaterPhaseThanClean( highestRequestPhase ) ) |
| { |
| return empty(); |
| } |
| |
| LOGGER.info( "Attempting to restore project from build cache" ); |
| |
| ProjectsInputInfo inputInfo = projectInputCalculator.calculateInput( project ); |
| |
| final CacheContext context = new CacheContext( project, inputInfo, session ); |
| // remote build first |
| CacheResult result = findCachedBuild( mojoExecutions, context ); |
| |
| if ( !result.isSuccess() && result.getContext() != null ) |
| { |
| LOGGER.debug( "Remote cache is incomplete or missing, trying local build" ); |
| |
| CacheResult localBuild = findLocalBuild( mojoExecutions, context ); |
| |
| if ( localBuild.isSuccess() || ( localBuild.isPartialSuccess() && !result.isPartialSuccess() ) ) |
| { |
| result = localBuild; |
| } |
| else |
| { |
| LOGGER.info( "Local build was not found by checksum " + inputInfo.getChecksum() ); |
| } |
| } |
| cacheResults.put( getVersionlessProjectKey( project ), result ); |
| |
| return result; |
| } |
| |
| private CacheResult findCachedBuild( List<MojoExecution> mojoExecutions, CacheContext context ) |
| { |
| Optional<Build> cachedBuild = Optional.empty(); |
| try |
| { |
| cachedBuild = localCache.findBuild( context ); |
| if ( cachedBuild.isPresent() ) |
| { |
| return analyzeResult( context, mojoExecutions, cachedBuild.get() ); |
| } |
| } |
| catch ( Exception e ) |
| { |
| LOGGER.error( "Cannot read cached remote build", e ); |
| } |
| return cachedBuild.map( build -> failure( build, context ) ) |
| .orElseGet( () -> empty( context ) ); |
| } |
| |
| private CacheResult findLocalBuild( List<MojoExecution> mojoExecutions, CacheContext context ) |
| { |
| Optional<Build> localBuild = Optional.empty(); |
| try |
| { |
| localBuild = localCache.findLocalBuild( context ); |
| if ( localBuild.isPresent() ) |
| { |
| return analyzeResult( context, mojoExecutions, localBuild.get() ); |
| } |
| } |
| catch ( Exception e ) |
| { |
| LOGGER.error( "Cannot read local build", e ); |
| } |
| return localBuild.map( build -> failure( build, context ) ) |
| .orElseGet( () -> empty( context ) ); |
| } |
| |
| private CacheResult analyzeResult( CacheContext context, List<MojoExecution> mojoExecutions, Build build ) |
| { |
| try |
| { |
| final ProjectsInputInfo inputInfo = context.getInputInfo(); |
| |
| LOGGER.info( "Found cached build, restoring from cache {}", inputInfo.getChecksum() ); |
| LOGGER.debug( "Cached build details: {}", build ); |
| |
| final String cacheImplementationVersion = build.getCacheImplementationVersion(); |
| if ( !CACHE_IMPLEMENTATION_VERSION.equals( cacheImplementationVersion ) ) |
| { |
| LOGGER.warn( |
| "Maven and cached build implementations mismatch, caching might not work correctly. " |
| + "Implementation version: " + CACHE_IMPLEMENTATION_VERSION |
| + ", cached build: {}", |
| build.getCacheImplementationVersion() ); |
| } |
| |
| List<MojoExecution> cachedSegment = lifecyclePhasesHelper.getCachedSegment( mojoExecutions, build ); |
| List<MojoExecution> missingMojos = build.getMissingExecutions( cachedSegment ); |
| if ( !missingMojos.isEmpty() ) |
| { |
| LOGGER.warn( "Cached build doesn't contains all requested plugin executions " |
| + "(missing: {}), cannot restore", missingMojos ); |
| return failure( build, context ); |
| } |
| |
| if ( !isCachedSegmentPropertiesPresent( context.getProject(), build, cachedSegment ) ) |
| { |
| LOGGER.info( "Cached build violates cache rules, cannot restore" ); |
| return failure( build, context ); |
| } |
| |
| final String highestRequestPhase = CacheUtils.getLast( mojoExecutions ).getLifecyclePhase(); |
| if ( lifecyclePhasesHelper.isLaterPhaseThanBuild( highestRequestPhase, build ) |
| && !canIgnoreMissingSegment( build, mojoExecutions ) ) |
| { |
| LOGGER.info( "Project restored partially. Highest cached goal: {}, requested: {}", |
| build.getHighestCompletedGoal(), highestRequestPhase ); |
| return partialSuccess( build, context ); |
| } |
| |
| return success( build, context ); |
| |
| } |
| catch ( Exception e ) |
| { |
| LOGGER.error( "Failed to restore project", e ); |
| localCache.clearCache( context ); |
| return failure( build, context ); |
| } |
| } |
| |
| private boolean canIgnoreMissingSegment( Build info, List<MojoExecution> mojoExecutions ) |
| { |
| final List<MojoExecution> postCachedSegment = lifecyclePhasesHelper.getPostCachedSegment( mojoExecutions, |
| info ); |
| for ( MojoExecution mojoExecution : postCachedSegment ) |
| { |
| if ( !cacheConfig.canIgnore( mojoExecution ) ) |
| { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean restoreProjectArtifacts( CacheResult cacheResult ) |
| { |
| final Build build = cacheResult.getBuildInfo(); |
| final CacheContext context = cacheResult.getContext(); |
| final MavenProject project = context.getProject(); |
| |
| try |
| { |
| RestoredArtifact restoredProjectArtifact = null; |
| List<RestoredArtifact> restoredAttachedArtifacts = new ArrayList<>(); |
| |
| if ( build.getArtifact() != null && isNotBlank( build.getArtifact().getFileName() ) ) |
| { |
| final Artifact artifactInfo = build.getArtifact(); |
| String originalVersion = artifactInfo.getVersion(); |
| artifactInfo.setVersion( project.getVersion() ); |
| // TODO if remote is forced, probably need to refresh or reconcile all files |
| final Future<File> downloadTask = createDownloadTask( |
| cacheResult, |
| context, |
| project, |
| artifactInfo, |
| originalVersion ); |
| restoredProjectArtifact = restoredArtifact( project.getArtifact(), artifactInfo.getType(), |
| artifactInfo.getClassifier(), |
| downloadTask ); |
| } |
| |
| for ( Artifact attachedArtifactInfo : build.getAttachedArtifacts() ) |
| { |
| String originalVersion = attachedArtifactInfo.getVersion(); |
| attachedArtifactInfo.setVersion( project.getVersion() ); |
| if ( isNotBlank( attachedArtifactInfo.getFileName() ) ) |
| { |
| if ( StringUtils.startsWith( attachedArtifactInfo.getClassifier(), BUILD_PREFIX ) ) |
| { |
| // restoring generated sources might be unnecessary in CI, could be disabled for |
| // performance reasons |
| if ( cacheConfig.isRestoreGeneratedSources() ) |
| { |
| // generated sources artifact |
| final Path attachedArtifactFile = localCache.getArtifactFile( context, |
| cacheResult.getSource(), attachedArtifactInfo ); |
| restoreGeneratedSources( attachedArtifactInfo, attachedArtifactFile, project ); |
| } |
| } |
| else |
| { |
| Future<File> downloadTask = createDownloadTask( |
| cacheResult, |
| context, |
| project, |
| attachedArtifactInfo, |
| originalVersion ); |
| final RestoredArtifact restoredAttachedArtifact = restoredArtifact( |
| restoredProjectArtifact == null ? project.getArtifact() |
| : restoredProjectArtifact, |
| attachedArtifactInfo.getType(), |
| attachedArtifactInfo.getClassifier(), |
| downloadTask ); |
| restoredAttachedArtifacts.add( restoredAttachedArtifact ); |
| } |
| } |
| } |
| // Actually modify project at the end in case something went wrong during restoration, |
| // in which case, the project is unmodified and we continue with normal build. |
| if ( restoredProjectArtifact != null ) |
| { |
| project.setArtifact( restoredProjectArtifact ); |
| } |
| restoredAttachedArtifacts.forEach( project::addAttachedArtifact ); |
| return true; |
| } |
| catch ( Exception e ) |
| { |
| LOGGER.debug( "Cannot restore cache, continuing with normal build.", e ); |
| return false; |
| } |
| } |
| |
| /** |
| * Helper method similar to {@link org.apache.maven.project.MavenProjectHelper#attachArtifact} to work specifically |
| * with restored from cache artifacts |
| */ |
| private RestoredArtifact restoredArtifact( org.apache.maven.artifact.Artifact parent, String artifactType, |
| String artifactClassifier, |
| Future<File> artifactFile ) |
| { |
| ArtifactHandler handler = null; |
| |
| if ( artifactType != null ) |
| { |
| handler = artifactHandlerManager.getArtifactHandler( artifactType ); |
| } |
| |
| if ( handler == null ) |
| { |
| handler = artifactHandlerManager.getArtifactHandler( "jar" ); |
| } |
| |
| // todo: probably need update download url to cache |
| RestoredArtifact artifact = new RestoredArtifact( parent, artifactFile, artifactType, artifactClassifier, |
| handler ); |
| artifact.setResolved( true ); |
| |
| return artifact; |
| } |
| |
| private Future<File> createDownloadTask( CacheResult cacheResult, CacheContext context, MavenProject project, |
| Artifact artifact, String originalVersion ) |
| { |
| final FutureTask<File> downloadTask = new FutureTask<>( () -> |
| { |
| LOGGER.debug( "Downloading artifact {}", artifact.getArtifactId() ); |
| final Path artifactFile = localCache.getArtifactFile( context, cacheResult.getSource(), |
| artifact ); |
| if ( !Files.exists( artifactFile ) ) |
| { |
| throw new FileNotFoundException( |
| "Missing file for cached build, cannot restore. File: " + artifactFile ); |
| } |
| LOGGER.debug( "Downloaded artifact " + artifact.getArtifactId() + " to: " + artifactFile ); |
| return restoreArtifactHandler.adjustArchiveArtifactVersion( |
| project, |
| originalVersion, |
| artifactFile ).toFile(); |
| } ); |
| if ( !cacheConfig.isLazyRestore() ) |
| { |
| downloadTask.run(); |
| } |
| return downloadTask; |
| } |
| |
| @Override |
| public void save( CacheResult cacheResult, List<MojoExecution> mojoExecutions, |
| Map<String, MojoExecutionEvent> executionEvents ) |
| { |
| CacheContext context = cacheResult.getContext(); |
| |
| if ( context == null || context.getInputInfo() == null ) |
| { |
| LOGGER.info( "Cannot save project in cache, skipping" ); |
| return; |
| } |
| |
| final MavenProject project = context.getProject(); |
| final MavenSession session = context.getSession(); |
| try |
| { |
| final HashFactory hashFactory = cacheConfig.getHashFactory(); |
| final org.apache.maven.artifact.Artifact projectArtifact = project.getArtifact(); |
| final List<org.apache.maven.artifact.Artifact> attachedArtifacts; |
| final List<Artifact> attachedArtifactDtos; |
| final Artifact projectArtifactDto; |
| if ( project.hasLifecyclePhase( "package" ) ) |
| { |
| final HashAlgorithm algorithm = hashFactory.createAlgorithm(); |
| attachGeneratedSources( project ); |
| attachOutputs( project ); |
| attachedArtifacts = project.getAttachedArtifacts() != null |
| ? project.getAttachedArtifacts() : Collections.emptyList(); |
| attachedArtifactDtos = artifactDtos( attachedArtifacts, algorithm ); |
| projectArtifactDto = artifactDto( project.getArtifact(), algorithm ); |
| } |
| else |
| { |
| attachedArtifacts = Collections.emptyList(); |
| attachedArtifactDtos = new ArrayList<>(); |
| projectArtifactDto = null; |
| } |
| |
| List<CompletedExecution> completedExecution = buildExecutionInfo( mojoExecutions, executionEvents ); |
| |
| final Build build = new Build( session.getGoals(), projectArtifactDto, attachedArtifactDtos, |
| context.getInputInfo(), completedExecution, hashFactory.getAlgorithm() ); |
| populateGitInfo( build, session ); |
| build.getDto().set_final( cacheConfig.isSaveFinal() ); |
| cacheResults.put( getVersionlessProjectKey( project ), rebuilded( cacheResult, build ) ); |
| |
| // if package phase presence means new artifacts were packaged |
| if ( project.hasLifecyclePhase( "package" ) ) |
| { |
| localCache.beforeSave( context ); |
| localCache.saveBuildInfo( cacheResult, build ); |
| if ( projectArtifact.getFile() != null ) |
| { |
| localCache.saveArtifactFile( cacheResult, projectArtifact ); |
| } |
| for ( org.apache.maven.artifact.Artifact attachedArtifact : attachedArtifacts ) |
| { |
| if ( attachedArtifact.getFile() != null && isOutputArtifact( |
| attachedArtifact.getFile().getName() ) ) |
| { |
| localCache.saveArtifactFile( cacheResult, attachedArtifact ); |
| } |
| } |
| } |
| else |
| { |
| localCache.saveBuildInfo( cacheResult, build ); |
| } |
| |
| if ( cacheConfig.isBaselineDiffEnabled() ) |
| { |
| produceDiffReport( cacheResult, build ); |
| } |
| |
| } |
| catch ( Exception e ) |
| { |
| LOGGER.error( "Failed to save project, cleaning cache. Project: {}", project, e ); |
| try |
| { |
| localCache.clearCache( context ); |
| } |
| catch ( Exception ex ) |
| { |
| LOGGER.error( "Failed to clean cache due to unexpected error:", ex ); |
| } |
| } |
| } |
| |
| public void produceDiffReport( CacheResult cacheResult, Build build ) |
| { |
| MavenProject project = cacheResult.getContext().getProject(); |
| Optional<Build> baselineHolder = remoteCache.findBaselineBuild( project ); |
| if ( baselineHolder.isPresent() ) |
| { |
| Build baseline = baselineHolder.get(); |
| String outputDirectory = project.getBuild().getDirectory(); |
| Path reportOutputDir = Paths.get( outputDirectory, "incremental-maven" ); |
| LOGGER.info( "Saving cache builds diff to: {}", reportOutputDir ); |
| Diff diff = new CacheDiff( build.getDto(), baseline.getDto(), cacheConfig ).compare(); |
| try |
| { |
| Files.createDirectories( reportOutputDir ); |
| final ProjectsInputInfo baselineInputs = baseline.getDto().getProjectsInputInfo(); |
| final String checksum = baselineInputs.getChecksum(); |
| Files.write( reportOutputDir.resolve( "buildinfo-baseline-" + checksum + ".xml" ), |
| xmlService.toBytes( baseline.getDto() ), TRUNCATE_EXISTING, CREATE ); |
| Files.write( reportOutputDir.resolve( "buildinfo-" + checksum + ".xml" ), |
| xmlService.toBytes( build.getDto() ), TRUNCATE_EXISTING, CREATE ); |
| Files.write( reportOutputDir.resolve( "buildsdiff-" + checksum + ".xml" ), |
| xmlService.toBytes( diff ), TRUNCATE_EXISTING, CREATE ); |
| final Optional<DigestItem> pom = CacheDiff.findPom( build.getDto().getProjectsInputInfo() ); |
| if ( pom.isPresent() ) |
| { |
| Files.write( reportOutputDir.resolve( "effective-pom-" + checksum + ".xml" ), |
| pom.get().getValue().getBytes( StandardCharsets.UTF_8 ), |
| TRUNCATE_EXISTING, CREATE ); |
| } |
| final Optional<DigestItem> baselinePom = CacheDiff.findPom( baselineInputs ); |
| if ( baselinePom.isPresent() ) |
| { |
| Files.write( reportOutputDir.resolve( |
| "effective-pom-baseline-" + baselineInputs.getChecksum() + ".xml" ), |
| baselinePom.get().getValue().getBytes( StandardCharsets.UTF_8 ), |
| TRUNCATE_EXISTING, CREATE ); |
| } |
| } |
| catch ( IOException e ) |
| { |
| LOGGER.error( "Cannot produce build diff for project", e ); |
| } |
| } |
| else |
| { |
| LOGGER.info( "Cannot find project in baseline build, skipping diff" ); |
| } |
| } |
| |
| private List<Artifact> artifactDtos( List<org.apache.maven.artifact.Artifact> attachedArtifacts, |
| HashAlgorithm digest ) throws IOException |
| { |
| List<Artifact> result = new ArrayList<>(); |
| for ( org.apache.maven.artifact.Artifact attachedArtifact : attachedArtifacts ) |
| { |
| if ( attachedArtifact.getFile() != null && isOutputArtifact( attachedArtifact.getFile().getName() ) ) |
| { |
| result.add( artifactDto( attachedArtifact, digest ) ); |
| } |
| } |
| return result; |
| } |
| |
| private Artifact artifactDto( org.apache.maven.artifact.Artifact projectArtifact, |
| HashAlgorithm algorithm ) throws IOException |
| { |
| final Artifact dto = DtoUtils.createDto( projectArtifact ); |
| if ( projectArtifact.getFile() != null && projectArtifact.getFile().isFile() ) |
| { |
| final Path file = projectArtifact.getFile().toPath(); |
| dto.setFileHash( algorithm.hash( file ) ); |
| dto.setFileSize( Files.size( file ) ); |
| } |
| return dto; |
| } |
| |
| private List<CompletedExecution> buildExecutionInfo( List<MojoExecution> mojoExecutions, |
| Map<String, MojoExecutionEvent> executionEvents ) |
| { |
| List<CompletedExecution> list = new ArrayList<>(); |
| for ( MojoExecution mojoExecution : mojoExecutions ) |
| { |
| final String executionKey = CacheUtils.mojoExecutionKey( mojoExecution ); |
| final MojoExecutionEvent executionEvent = executionEvents != null ? executionEvents.get( executionKey ) |
| : null; |
| CompletedExecution executionInfo = new CompletedExecution(); |
| executionInfo.setExecutionKey( executionKey ); |
| executionInfo.setMojoClassName( mojoExecution.getMojoDescriptor().getImplementation() ); |
| if ( executionEvent != null ) |
| { |
| recordMojoProperties( executionInfo, executionEvent ); |
| } |
| list.add( executionInfo ); |
| } |
| return list; |
| } |
| |
| private void recordMojoProperties( CompletedExecution execution, MojoExecutionEvent executionEvent ) |
| { |
| final MojoExecution mojoExecution = executionEvent.getExecution(); |
| |
| final boolean logAll = cacheConfig.isLogAllProperties( mojoExecution ); |
| List<TrackedProperty> trackedProperties = cacheConfig.getTrackedProperties( mojoExecution ); |
| List<PropertyName> noLogProperties = cacheConfig.getNologProperties( mojoExecution ); |
| List<PropertyName> forceLogProperties = cacheConfig.getLoggedProperties( mojoExecution ); |
| final Mojo mojo = executionEvent.getMojo(); |
| |
| final File baseDir = executionEvent.getProject().getBasedir(); |
| final String baseDirPath = FilenameUtils.normalizeNoEndSeparator( baseDir.getAbsolutePath() ) + File.separator; |
| |
| final List<Parameter> parameters = mojoExecution.getMojoDescriptor().getParameters(); |
| for ( Parameter parameter : parameters ) |
| { |
| // editable parameters could be configured by user |
| if ( !parameter.isEditable() ) |
| { |
| continue; |
| } |
| |
| final String propertyName = parameter.getName(); |
| final boolean tracked = isTracked( propertyName, trackedProperties ); |
| if ( !tracked && isExcluded( propertyName, logAll, noLogProperties, forceLogProperties ) ) |
| { |
| continue; |
| } |
| |
| try |
| { |
| final Object value = ReflectionUtils.getValueIncludingSuperclasses( propertyName, mojo ); |
| DtoUtils.addProperty( execution, propertyName, value, baseDirPath, tracked ); |
| } |
| catch ( IllegalAccessException e ) |
| { |
| LOGGER.info( "Cannot get property {} value from {}: {}", propertyName, mojo, e.getMessage() ); |
| if ( tracked ) |
| { |
| throw new IllegalArgumentException( "Property configured in cache introspection config " |
| + "for " + mojo + " is not accessible: " + propertyName ); |
| } |
| } |
| } |
| } |
| |
| private boolean isExcluded( String propertyName, boolean logAll, List<PropertyName> excludedProperties, |
| List<PropertyName> forceLogProperties ) |
| { |
| if ( !forceLogProperties.isEmpty() ) |
| { |
| for ( PropertyName logProperty : forceLogProperties ) |
| { |
| if ( StringUtils.equals( propertyName, logProperty.getPropertyName() ) ) |
| { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| if ( !excludedProperties.isEmpty() ) |
| { |
| for ( PropertyName excludedProperty : excludedProperties ) |
| { |
| if ( StringUtils.equals( propertyName, excludedProperty.getPropertyName() ) ) |
| { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| return !logAll; |
| } |
| |
| private boolean isTracked( String propertyName, List<TrackedProperty> trackedProperties ) |
| { |
| for ( TrackedProperty trackedProperty : trackedProperties ) |
| { |
| if ( StringUtils.equals( propertyName, trackedProperty.getPropertyName() ) ) |
| { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean isCachedSegmentPropertiesPresent( MavenProject project, Build build, |
| List<MojoExecution> mojoExecutions ) |
| { |
| for ( MojoExecution mojoExecution : mojoExecutions ) |
| { |
| // completion of all mojos checked above, so we expect tp have execution info here |
| final List<TrackedProperty> trackedProperties = cacheConfig.getTrackedProperties( mojoExecution ); |
| final CompletedExecution cachedExecution = build.findMojoExecutionInfo( mojoExecution ); |
| |
| if ( cachedExecution == null ) |
| { |
| LOGGER.info( "Execution is not cached. Plugin: {}, goal {}", |
| mojoExecution.getExecutionId(), mojoExecution.getGoal() ); |
| return false; |
| } |
| |
| if ( !DtoUtils.containsAllProperties( cachedExecution, trackedProperties ) ) |
| { |
| LOGGER.info( "Build info doesn't match rules. Plugin: {}", |
| mojoExecution.getExecutionId() ); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean isForcedExecution( MavenProject project, MojoExecution execution ) |
| { |
| if ( cacheConfig.isForcedExecution( execution ) ) |
| { |
| return true; |
| } |
| |
| if ( StringUtils.isNotBlank( cacheConfig.getAlwaysRunPlugins() ) ) |
| { |
| String[] alwaysRunPluginsList = split( cacheConfig.getAlwaysRunPlugins(), "," ); |
| for ( String pluginAndGoal : alwaysRunPluginsList ) |
| { |
| String[] tokens = pluginAndGoal.split( ":" ); |
| String alwaysRunPlugin = tokens[0]; |
| String alwaysRunGoal = tokens.length == 1 ? "*" : tokens[1]; |
| if ( Objects.equals( execution.getPlugin().getArtifactId(), alwaysRunPlugin ) |
| && ( "*".equals( alwaysRunGoal ) |
| || Objects.equals( execution.getGoal(), alwaysRunGoal ) ) ) |
| { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| @Override |
| public void saveCacheReport( MavenSession session ) |
| { |
| try |
| { |
| CacheReport cacheReport = new CacheReport(); |
| for ( CacheResult result : cacheResults.values() ) |
| { |
| ProjectReport projectReport = new ProjectReport(); |
| CacheContext context = result.getContext(); |
| MavenProject project = context.getProject(); |
| projectReport.setGroupId( project.getGroupId() ); |
| projectReport.setArtifactId( project.getArtifactId() ); |
| projectReport.setChecksum( context.getInputInfo().getChecksum() ); |
| boolean checksumMatched = result.getStatus() != RestoreStatus.EMPTY; |
| projectReport.setChecksumMatched( checksumMatched ); |
| projectReport.setLifecycleMatched( checksumMatched && result.isSuccess() ); |
| projectReport.setSource( String.valueOf( result.getSource() ) ); |
| if ( result.getSource() == CacheSource.REMOTE ) |
| { |
| projectReport.setUrl( remoteCache.getResourceUrl( context, BUILDINFO_XML ) ); |
| } |
| else if ( result.getSource() == CacheSource.BUILD && cacheConfig.isSaveToRemote() ) |
| { |
| projectReport.setSharedToRemote( true ); |
| projectReport.setUrl( remoteCache.getResourceUrl( context, BUILDINFO_XML ) ); |
| } |
| cacheReport.addProject( projectReport ); |
| } |
| |
| String buildId = UUID.randomUUID().toString(); |
| localCache.saveCacheReport( buildId, session, cacheReport ); |
| } |
| catch ( Exception e ) |
| { |
| LOGGER.error( "Cannot save incremental build aggregated report", e ); |
| } |
| } |
| |
| private void populateGitInfo( Build build, MavenSession session ) |
| { |
| if ( scm == null ) |
| { |
| synchronized ( this ) |
| { |
| if ( scm == null ) |
| { |
| try |
| { |
| scm = CacheUtils.readGitInfo( session ); |
| } |
| catch ( IOException e ) |
| { |
| scm = new Scm(); |
| LOGGER.error( "Cannot populate git info", e ); |
| } |
| } |
| } |
| } |
| build.getDto().setScm( scm ); |
| } |
| |
| private void zipAndAttachArtifact( MavenProject project, Path dir, String classifier ) throws IOException |
| { |
| Path temp = Files.createTempFile( "maven-incremental", project.getArtifactId() ); |
| temp.toFile().deleteOnExit(); |
| CacheUtils.zip( dir, temp ); |
| projectHelper.attachArtifact( project, "zip", classifier, temp.toFile() ); |
| } |
| |
| private String pathToClassifier( Path relative ) |
| { |
| final int nameCount = relative.getNameCount(); |
| List<String> segments = new ArrayList<>( nameCount + 1 ); |
| for ( int i = 0; i < nameCount; i++ ) |
| { |
| segments.add( relative.getName( i ).toFile().getName() ); |
| } |
| // todo handle _ in file names |
| return BUILD_PREFIX + StringUtils.join( segments.iterator(), FILE_SEPARATOR_SUBST ); |
| } |
| |
| private Path classifierToPath( Path outputDir, String classifier ) |
| { |
| classifier = StringUtils.removeStart( classifier, BUILD_PREFIX ); |
| final String relPath = replace( classifier, FILE_SEPARATOR_SUBST, File.separator ); |
| return outputDir.resolve( relPath ); |
| } |
| |
| private void restoreGeneratedSources( Artifact artifact, Path artifactFilePath, MavenProject project ) |
| throws IOException |
| { |
| final Path targetDir = Paths.get( project.getBuild().getDirectory() ); |
| final Path outputDir = classifierToPath( targetDir, artifact.getClassifier() ); |
| if ( Files.exists( outputDir ) ) |
| { |
| FileUtils.cleanDirectory( outputDir.toFile() ); |
| } |
| else |
| { |
| Files.createDirectories( outputDir ); |
| } |
| CacheUtils.unzip( artifactFilePath, outputDir ); |
| } |
| |
| // TODO: move to config |
| public void attachGeneratedSources( MavenProject project ) throws IOException |
| { |
| final Path targetDir = Paths.get( project.getBuild().getDirectory() ); |
| |
| final Path generatedSourcesDir = targetDir.resolve( "generated-sources" ); |
| attachDirIfNotEmpty( generatedSourcesDir, targetDir, project ); |
| |
| final Path generatedTestSourcesDir = targetDir.resolve( "generated-test-sources" ); |
| attachDirIfNotEmpty( generatedTestSourcesDir, targetDir, project ); |
| |
| Set<String> sourceRoots = new TreeSet<>(); |
| if ( project.getCompileSourceRoots() != null ) |
| { |
| sourceRoots.addAll( project.getCompileSourceRoots() ); |
| } |
| if ( project.getTestCompileSourceRoots() != null ) |
| { |
| sourceRoots.addAll( project.getTestCompileSourceRoots() ); |
| } |
| |
| for ( String sourceRoot : sourceRoots ) |
| { |
| final Path sourceRootPath = Paths.get( sourceRoot ); |
| if ( Files.isDirectory( sourceRootPath ) |
| && sourceRootPath.startsWith( targetDir ) |
| && !( sourceRootPath.startsWith( generatedSourcesDir ) |
| || sourceRootPath.startsWith( generatedTestSourcesDir ) ) ) |
| { // dir within target |
| attachDirIfNotEmpty( sourceRootPath, targetDir, project ); |
| } |
| } |
| } |
| |
| private void attachOutputs( MavenProject project ) throws IOException |
| { |
| final List<String> attachedDirs = cacheConfig.getAttachedOutputs(); |
| for ( String dir : attachedDirs ) |
| { |
| final Path targetDir = Paths.get( project.getBuild().getDirectory() ); |
| final Path outputDir = targetDir.resolve( dir ); |
| attachDirIfNotEmpty( outputDir, targetDir, project ); |
| } |
| } |
| |
| private void attachDirIfNotEmpty( Path candidateSubDir, Path parentDir, MavenProject project ) throws IOException |
| { |
| if ( Files.isDirectory( candidateSubDir ) && hasFiles( candidateSubDir ) ) |
| { |
| final Path relativePath = parentDir.relativize( candidateSubDir ); |
| final String classifier = pathToClassifier( relativePath ); |
| zipAndAttachArtifact( project, candidateSubDir, classifier ); |
| LOGGER.debug( "Attached directory: {}", candidateSubDir ); |
| } |
| } |
| |
| private boolean hasFiles( Path candidateSubDir ) throws IOException |
| { |
| final MutableBoolean hasFiles = new MutableBoolean(); |
| Files.walkFileTree( candidateSubDir, new SimpleFileVisitor<Path>() |
| { |
| |
| @Override |
| public FileVisitResult visitFile( Path path, BasicFileAttributes basicFileAttributes ) |
| { |
| hasFiles.setTrue(); |
| return FileVisitResult.TERMINATE; |
| } |
| } ); |
| return hasFiles.booleanValue(); |
| } |
| |
| private boolean isOutputArtifact( String name ) |
| { |
| List<Pattern> excludePatterns = cacheConfig.getExcludePatterns(); |
| for ( Pattern pattern : excludePatterns ) |
| { |
| if ( pattern.matcher( name ).matches() ) |
| { |
| return false; |
| } |
| } |
| return true; |
| } |
| } |
