| package org.apache.continuum.buildagent.taskqueue.execution; |
| |
| /* |
| * 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. |
| */ |
| |
| import org.apache.continuum.buildagent.buildcontext.BuildContext; |
| import org.apache.continuum.buildagent.configuration.BuildAgentConfigurationService; |
| import org.apache.continuum.buildagent.manager.BuildAgentManager; |
| import org.apache.continuum.buildagent.taskqueue.PrepareBuildProjectsTask; |
| import org.apache.continuum.buildagent.utils.BuildContextToBuildDefinition; |
| import org.apache.continuum.buildagent.utils.BuildContextToProject; |
| import org.apache.continuum.buildagent.utils.ContinuumBuildAgentUtil; |
| import org.apache.maven.continuum.ContinuumException; |
| import org.apache.maven.continuum.model.project.BuildDefinition; |
| import org.apache.maven.continuum.model.project.Project; |
| import org.apache.maven.continuum.model.scm.ChangeSet; |
| import org.apache.maven.continuum.model.scm.ScmResult; |
| import org.apache.maven.continuum.project.ContinuumProjectState; |
| import org.codehaus.plexus.action.ActionManager; |
| import org.codehaus.plexus.action.ActionNotFoundException; |
| import org.codehaus.plexus.taskqueue.Task; |
| import org.codehaus.plexus.taskqueue.execution.TaskExecutionException; |
| import org.codehaus.plexus.taskqueue.execution.TaskExecutor; |
| import org.codehaus.plexus.util.StringUtils; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * @plexus.component role="org.codehaus.plexus.taskqueue.execution.TaskExecutor" |
| * role-hint="prepare-build-agent" |
| */ |
| public class PrepareBuildProjectsTaskExecutor |
| implements TaskExecutor |
| { |
| private static final Logger log = LoggerFactory.getLogger( PrepareBuildProjectsTaskExecutor.class ); |
| |
| /** |
| * @plexus.requirement |
| */ |
| private ActionManager actionManager; |
| |
| /** |
| * @plexus.requirement |
| */ |
| private BuildAgentConfigurationService buildAgentConfigurationService; |
| |
| /** |
| * @plexus.requirement |
| */ |
| private BuildAgentManager buildAgentManager; |
| |
| public void executeTask( Task task ) |
| throws TaskExecutionException |
| { |
| List<BuildContext> buildContexts = ( (PrepareBuildProjectsTask) task ).getBuildContexts(); |
| |
| Map<String, Object> context = null; |
| |
| try |
| { |
| if ( buildContexts != null && buildContexts.size() > 0 ) |
| { |
| try |
| { |
| for ( BuildContext buildContext : buildContexts ) |
| { |
| BuildDefinition buildDef = BuildContextToBuildDefinition.getBuildDefinition( buildContext ); |
| |
| log.debug( "Check scm root state of project group '{}'", buildContext.getProjectGroupName() ); |
| if ( !checkProjectScmRoot( context ) ) |
| { |
| break; |
| } |
| |
| log.info( "Starting prepare build of project group '{}'", buildContext.getProjectGroupName() ); |
| startPrepareBuild( buildContext ); |
| |
| log.info( "Initializing prepare build" ); |
| initializeActionContext( buildContext ); |
| |
| try |
| { |
| if ( buildDef.isBuildFresh() ) |
| { |
| log.info( "Clean up working directory of project '{}'", buildContext.getProjectName() ); |
| cleanWorkingDirectory( buildContext ); |
| } |
| |
| log.info( "Updating working directory of project '{}'", buildContext.getProjectName() ); |
| updateWorkingDirectory( buildContext ); |
| |
| //CONTINUUM-1393 |
| if ( !buildDef.isBuildFresh() ) |
| { |
| log.info( "Merging SCM results of project '{}'", buildContext.getProjectName() ); |
| mergeScmResults( buildContext ); |
| } |
| } |
| finally |
| { |
| endProjectPrepareBuild( buildContext ); |
| context = buildContext.getActionContext(); |
| } |
| } |
| } |
| finally |
| { |
| endPrepareBuild( context ); |
| } |
| |
| if ( checkProjectScmRoot( context ) ) |
| { |
| log.debug( "Successful prepare build. Creating build task" ); |
| buildProjects( buildContexts ); |
| } |
| } |
| else |
| { |
| throw new TaskExecutionException( "No project build context" ); |
| } |
| } |
| catch ( TaskExecutionException e ) |
| { |
| log.error( "Error while preparing build of project: {}", e.getMessage() ); |
| } |
| } |
| |
| private void startPrepareBuild( BuildContext buildContext ) |
| throws TaskExecutionException |
| { |
| Map<String, Object> actionContext = buildContext.getActionContext(); |
| |
| if ( actionContext == null || !( ContinuumBuildAgentUtil.getScmRootState( actionContext ) == |
| ContinuumProjectState.UPDATING ) ) |
| { |
| Map<String, Object> map = new HashMap<String, Object>(); |
| map.put( ContinuumBuildAgentUtil.KEY_PROJECT_GROUP_ID, buildContext.getProjectGroupId() ); |
| map.put( ContinuumBuildAgentUtil.KEY_SCM_ROOT_ADDRESS, buildContext.getScmRootAddress() ); |
| map.put( ContinuumBuildAgentUtil.KEY_BUILD_AGENT_URL, buildContext.getBuildAgentUrl() ); |
| |
| try |
| { |
| buildAgentManager.startPrepareBuild( map ); |
| } |
| catch ( ContinuumException e ) |
| { |
| throw new TaskExecutionException( e.getMessage(), e ); |
| } |
| } |
| } |
| |
| private void initializeActionContext( BuildContext buildContext ) |
| { |
| Map<String, Object> actionContext = new HashMap<String, Object>(); |
| |
| actionContext.put( ContinuumBuildAgentUtil.KEY_PROJECT_ID, buildContext.getProjectId() ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_PROJECT, BuildContextToProject.getProject( buildContext ) ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_BUILD_DEFINITION, |
| BuildContextToBuildDefinition.getBuildDefinition( buildContext ) ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_SCM_ROOT_STATE, ContinuumProjectState.UPDATING ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_PROJECT_GROUP_ID, buildContext.getProjectGroupId() ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_SCM_ROOT_ADDRESS, buildContext.getScmRootAddress() ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_OLD_SCM_RESULT, buildContext.getOldScmResult() ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_LATEST_UPDATE_DATE, buildContext.getLatestUpdateDate() ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_TRIGGER, buildContext.getTrigger() ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_USERNAME, buildContext.getUsername() ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_SCM_USERNAME, buildContext.getScmUsername() ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_SCM_PASSWORD, buildContext.getScmPassword() ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_BUILD_AGENT_URL, buildContext.getBuildAgentUrl() ); |
| |
| buildContext.setActionContext( actionContext ); |
| } |
| |
| private boolean checkProjectScmRoot( Map<String, Object> context ) |
| { |
| return !( context != null && ContinuumBuildAgentUtil.getScmRootState( context ) == |
| ContinuumProjectState.ERROR ); |
| |
| } |
| |
| private void cleanWorkingDirectory( BuildContext buildContext ) |
| throws TaskExecutionException |
| { |
| performAction( "clean-agent-working-directory", buildContext ); |
| } |
| |
| private void updateWorkingDirectory( BuildContext buildContext ) |
| throws TaskExecutionException |
| { |
| Map<String, Object> actionContext = buildContext.getActionContext(); |
| |
| performAction( "check-agent-working-directory", buildContext ); |
| |
| boolean workingDirectoryExists = ContinuumBuildAgentUtil.getBoolean( actionContext, |
| ContinuumBuildAgentUtil.KEY_WORKING_DIRECTORY_EXISTS ); |
| |
| ScmResult scmResult; |
| |
| Date date; |
| |
| if ( workingDirectoryExists ) |
| { |
| performAction( "update-agent-working-directory", buildContext ); |
| |
| scmResult = ContinuumBuildAgentUtil.getUpdateScmResult( actionContext, null ); |
| |
| date = ContinuumBuildAgentUtil.getLatestUpdateDate( actionContext ); |
| } |
| else |
| { |
| Project project = ContinuumBuildAgentUtil.getProject( actionContext ); |
| |
| actionContext.put( ContinuumBuildAgentUtil.KEY_WORKING_DIRECTORY, |
| buildAgentConfigurationService.getWorkingDirectory( |
| project.getId() ).getAbsolutePath() ); |
| |
| performAction( "checkout-agent-project", buildContext ); |
| |
| scmResult = ContinuumBuildAgentUtil.getCheckoutScmResult( actionContext, null ); |
| |
| performAction( "changelog-agent-project", buildContext ); |
| |
| date = ContinuumBuildAgentUtil.getLatestUpdateDate( actionContext ); |
| } |
| |
| buildContext.setScmResult( scmResult ); |
| buildContext.setLatestUpdateDate( date ); |
| actionContext.put( ContinuumBuildAgentUtil.KEY_SCM_RESULT, scmResult ); |
| } |
| |
| private void endProjectPrepareBuild( BuildContext buildContext ) |
| throws TaskExecutionException |
| { |
| Map<String, Object> context = buildContext.getActionContext(); |
| |
| ScmResult scmResult = ContinuumBuildAgentUtil.getScmResult( context, null ); |
| |
| log.debug( "End prepare build of project '{}'", buildContext.getProjectName() ); |
| |
| if ( scmResult == null || !scmResult.isSuccess() ) |
| { |
| context.put( ContinuumBuildAgentUtil.KEY_SCM_ROOT_STATE, ContinuumProjectState.ERROR ); |
| } |
| else |
| { |
| buildContext.setScmResult( scmResult ); |
| } |
| } |
| |
| private void endPrepareBuild( Map<String, Object> context ) |
| throws TaskExecutionException |
| { |
| if ( context != null ) |
| { |
| Map<String, Object> result = new HashMap<String, Object>(); |
| result.put( ContinuumBuildAgentUtil.KEY_PROJECT_GROUP_ID, ContinuumBuildAgentUtil.getProjectGroupId( |
| context ) ); |
| result.put( ContinuumBuildAgentUtil.KEY_SCM_ROOT_ADDRESS, ContinuumBuildAgentUtil.getScmRootAddress( |
| context ) ); |
| result.put( ContinuumBuildAgentUtil.KEY_SCM_ROOT_STATE, ContinuumBuildAgentUtil.getScmRootState( |
| context ) ); |
| result.put( ContinuumBuildAgentUtil.KEY_BUILD_AGENT_URL, ContinuumBuildAgentUtil.getBuildAgentUrl( |
| context ) ); |
| |
| if ( ContinuumBuildAgentUtil.getScmRootState( context ) == ContinuumProjectState.ERROR ) |
| { |
| String error = convertScmResultToError( ContinuumBuildAgentUtil.getScmResult( context, null ) ); |
| |
| if ( StringUtils.isEmpty( error ) ) |
| { |
| result.put( ContinuumBuildAgentUtil.KEY_SCM_ERROR, "" ); |
| } |
| else |
| { |
| result.put( ContinuumBuildAgentUtil.KEY_SCM_ERROR, error ); |
| } |
| } |
| else |
| { |
| result.put( ContinuumBuildAgentUtil.KEY_SCM_ERROR, "" ); |
| } |
| |
| try |
| { |
| log.debug( "End prepare build of project group '{}'", ContinuumBuildAgentUtil.getProjectGroupId( |
| context ) ); |
| buildAgentManager.endPrepareBuild( result ); |
| } |
| catch ( ContinuumException e ) |
| { |
| throw new TaskExecutionException( e.getMessage(), e ); |
| } |
| } |
| else |
| { |
| throw new TaskExecutionException( "No project build context" ); |
| } |
| } |
| |
| private String convertScmResultToError( ScmResult result ) |
| { |
| String error = ""; |
| |
| if ( result == null ) |
| { |
| error = "Scm result is null."; |
| } |
| else |
| { |
| if ( result.getCommandLine() != null ) |
| { |
| error = "Command line: " + StringUtils.clean( result.getCommandLine() ) + |
| System.getProperty( "line.separator" ); |
| } |
| |
| if ( result.getProviderMessage() != null ) |
| { |
| error = "Provider message: " + StringUtils.clean( result.getProviderMessage() ) + |
| System.getProperty( "line.separator" ); |
| } |
| |
| if ( result.getCommandOutput() != null ) |
| { |
| error += "Command output: " + System.getProperty( "line.separator" ); |
| error += "-------------------------------------------------------------------------------" + |
| System.getProperty( "line.separator" ); |
| error += StringUtils.clean( result.getCommandOutput() ) + System.getProperty( "line.separator" ); |
| error += "-------------------------------------------------------------------------------" + |
| System.getProperty( "line.separator" ); |
| } |
| |
| if ( result.getException() != null ) |
| { |
| error += "Exception:" + System.getProperty( "line.separator" ); |
| error += result.getException(); |
| } |
| } |
| |
| return error; |
| } |
| |
| private void performAction( String actionName, BuildContext buildContext ) |
| throws TaskExecutionException |
| { |
| TaskExecutionException exception; |
| |
| try |
| { |
| log.info( "Performing action " + actionName ); |
| actionManager.lookup( actionName ).execute( buildContext.getActionContext() ); |
| return; |
| } |
| catch ( ActionNotFoundException e ) |
| { |
| exception = new TaskExecutionException( "Error looking up action '" + actionName + "'", e ); |
| } |
| catch ( Exception e ) |
| { |
| exception = new TaskExecutionException( "Error executing action '" + actionName + "'", e ); |
| } |
| |
| ScmResult result = new ScmResult(); |
| |
| result.setSuccess( false ); |
| |
| result.setException( ContinuumBuildAgentUtil.throwableToString( exception ) ); |
| |
| buildContext.setScmResult( result ); |
| buildContext.getActionContext().put( ContinuumBuildAgentUtil.KEY_UPDATE_SCM_RESULT, result ); |
| |
| throw exception; |
| } |
| |
| private void mergeScmResults( BuildContext buildContext ) |
| { |
| Map<String, Object> context = buildContext.getActionContext(); |
| ScmResult oldScmResult = ContinuumBuildAgentUtil.getOldScmResult( context, null ); |
| ScmResult newScmResult = ContinuumBuildAgentUtil.getScmResult( context, null ); |
| |
| if ( oldScmResult != null ) |
| { |
| if ( newScmResult == null ) |
| { |
| context.put( ContinuumBuildAgentUtil.KEY_SCM_RESULT, oldScmResult ); |
| } |
| else |
| { |
| List<ChangeSet> oldChanges = oldScmResult.getChanges(); |
| |
| List<ChangeSet> newChanges = newScmResult.getChanges(); |
| |
| for ( ChangeSet change : newChanges ) |
| { |
| if ( !oldChanges.contains( change ) ) |
| { |
| oldChanges.add( change ); |
| } |
| } |
| |
| newScmResult.setChanges( oldChanges ); |
| } |
| } |
| } |
| |
| private void buildProjects( List<BuildContext> buildContexts ) |
| throws TaskExecutionException |
| { |
| Map<String, Object> map = new HashMap<String, Object>(); |
| map.put( ContinuumBuildAgentUtil.KEY_BUILD_CONTEXTS, buildContexts ); |
| |
| BuildContext context = new BuildContext(); |
| context.setActionContext( map ); |
| |
| performAction( "create-agent-build-project-task", context ); |
| } |
| } |
