package org.apache.continuum.buildagent;
/*
* 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.commons.io.FileUtils;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.continuum.buildagent.buildcontext.BuildContext;
import org.apache.continuum.buildagent.buildcontext.manager.BuildContextManager;
import org.apache.continuum.buildagent.configuration.BuildAgentConfigurationService;
import org.apache.continuum.buildagent.manager.BuildAgentManager;
import org.apache.continuum.buildagent.manager.BuildAgentPurgeManager;
import org.apache.continuum.buildagent.manager.BuildAgentReleaseManager;
import org.apache.continuum.buildagent.model.Installation;
import org.apache.continuum.buildagent.taskqueue.PrepareBuildProjectsTask;
import org.apache.continuum.buildagent.taskqueue.manager.BuildAgentTaskQueueManager;
import org.apache.continuum.buildagent.utils.ContinuumBuildAgentUtil;
import org.apache.continuum.buildagent.utils.WorkingCopyContentGenerator;
import org.apache.continuum.taskqueue.BuildProjectTask;
import org.apache.continuum.taskqueue.manager.TaskQueueManagerException;
import org.apache.continuum.utils.build.BuildTrigger;
import org.apache.continuum.utils.release.ReleaseUtil;
import org.apache.maven.continuum.ContinuumException;
import org.apache.maven.continuum.model.project.BuildResult;
import org.apache.maven.continuum.model.scm.ChangeFile;
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.apache.maven.continuum.release.ContinuumReleaseException;
import org.apache.maven.shared.release.ReleaseResult;
import org.codehaus.plexus.taskqueue.TaskQueueException;
import org.codehaus.plexus.util.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.activation.MimetypesFileTypeMap;
/**
* @plexus.component role="org.apache.continuum.buildagent.ContinuumBuildAgentService"
*/
public class ContinuumBuildAgentServiceImpl
implements ContinuumBuildAgentService
{
private static final Logger log = LoggerFactory.getLogger( ContinuumBuildAgentServiceImpl.class );
private static final String FILE_SEPARATOR = System.getProperty( "file.separator" );
/**
* @plexus.requirement
*/
private BuildAgentConfigurationService buildAgentConfigurationService;
/**
* @plexus.requirement
*/
private BuildAgentTaskQueueManager buildAgentTaskQueueManager;
/**
* @plexus.requirement
*/
private BuildContextManager buildContextManager;
/**
* @plexus.requirement
*/
private WorkingCopyContentGenerator generator;
/**
* @plexus.requirement
*/
private BuildAgentReleaseManager buildAgentReleaseManager;
/**
* @plexus.requirement
*/
private BuildAgentManager buildAgentManager;
/**
* @plexus.requirement
*/
private BuildAgentPurgeManager purgeManager;
public void buildProjects( List<Map<String, Object>> projectsBuildContext )
throws ContinuumBuildAgentException
{
List<BuildContext> buildContextList = initializeBuildContext( projectsBuildContext );
PrepareBuildProjectsTask task = createPrepareBuildProjectsTask( buildContextList );
if ( task == null )
{
return;
}
try
{
log.info( "Adding project group {} to prepare build queue", task.getProjectGroupId() );
buildAgentTaskQueueManager.getPrepareBuildQueue().put( task );
}
catch ( TaskQueueException e )
{
throw new ContinuumBuildAgentException( "Error while enqueuing projects", e );
}
}
public List<Map<String, String>> getAvailableInstallations()
throws ContinuumBuildAgentException
{
List<Map<String, String>> installationsList = new ArrayList<Map<String, String>>();
List<Installation> installations = buildAgentConfigurationService.getAvailableInstallations();
for ( Installation installation : installations )
{
Map<String, String> map = new HashMap<String, String>();
if ( StringUtils.isBlank( installation.getName() ) )
{
map.put( ContinuumBuildAgentUtil.KEY_INSTALLATION_NAME, "" );
}
else
{
map.put( ContinuumBuildAgentUtil.KEY_INSTALLATION_NAME, installation.getName() );
}
if ( StringUtils.isBlank( installation.getType() ) )
{
map.put( ContinuumBuildAgentUtil.KEY_INSTALLATION_TYPE, "" );
}
else
{
map.put( ContinuumBuildAgentUtil.KEY_INSTALLATION_TYPE, installation.getType() );
}
if ( StringUtils.isBlank( installation.getVarName() ) )
{
map.put( ContinuumBuildAgentUtil.KEY_INSTALLATION_VAR_NAME, "" );
}
else
{
map.put( ContinuumBuildAgentUtil.KEY_INSTALLATION_VAR_VALUE, installation.getVarValue() );
}
if ( StringUtils.isBlank( installation.getVarValue() ) )
{
map.put( ContinuumBuildAgentUtil.KEY_INSTALLATION_VAR_VALUE, "" );
}
else
{
map.put( ContinuumBuildAgentUtil.KEY_INSTALLATION_VAR_VALUE, installation.getVarValue() );
}
installationsList.add( map );
}
return installationsList;
}
public Map<String, Object> getBuildResult( int projectId )
throws ContinuumBuildAgentException
{
log.debug( "Get build result of project {}", projectId );
Map<String, Object> result = new HashMap<String, Object>();
int currentBuildId = 0;
try
{
log.debug( "Get current build project" );
currentBuildId = buildAgentTaskQueueManager.getIdOfProjectCurrentlyBuilding();
}
catch ( TaskQueueManagerException e )
{
throw new ContinuumBuildAgentException( e.getMessage(), e );
}
log.debug( "Check if project {} is the one currently building in the agent", projectId );
if ( projectId == currentBuildId )
{
BuildContext buildContext = buildContextManager.getBuildContext( projectId );
result.put( ContinuumBuildAgentUtil.KEY_PROJECT_ID, buildContext.getProjectId() );
result.put( ContinuumBuildAgentUtil.KEY_BUILD_DEFINITION_ID, buildContext.getBuildDefinitionId() );
result.put( ContinuumBuildAgentUtil.KEY_TRIGGER, buildContext.getTrigger() );
result.put( ContinuumBuildAgentUtil.KEY_USERNAME, buildContext.getUsername() );
BuildResult buildResult = buildContext.getBuildResult();
if ( buildResult != null )
{
if ( buildResult.getStartTime() <= 0 )
{
result.put( ContinuumBuildAgentUtil.KEY_START_TIME, Long.toString(
buildContext.getBuildStartTime() ) );
}
else
{
result.put( ContinuumBuildAgentUtil.KEY_START_TIME, Long.toString( buildResult.getStartTime() ) );
}
if ( buildResult.getError() == null )
{
result.put( ContinuumBuildAgentUtil.KEY_BUILD_ERROR, "" );
}
else
{
result.put( ContinuumBuildAgentUtil.KEY_BUILD_ERROR, buildResult.getError() );
}
result.put( ContinuumBuildAgentUtil.KEY_BUILD_STATE, buildResult.getState() );
result.put( ContinuumBuildAgentUtil.KEY_END_TIME, Long.toString( buildResult.getEndTime() ) );
result.put( ContinuumBuildAgentUtil.KEY_BUILD_EXIT_CODE, buildResult.getExitCode() );
}
else
{
result.put( ContinuumBuildAgentUtil.KEY_START_TIME, Long.toString( buildContext.getBuildStartTime() ) );
result.put( ContinuumBuildAgentUtil.KEY_END_TIME, Long.toString( 0 ) );
result.put( ContinuumBuildAgentUtil.KEY_BUILD_STATE, ContinuumProjectState.BUILDING );
result.put( ContinuumBuildAgentUtil.KEY_BUILD_ERROR, "" );
result.put( ContinuumBuildAgentUtil.KEY_BUILD_EXIT_CODE, 0 );
}
String buildOutput = getBuildOutputText( projectId );
if ( buildOutput == null )
{
result.put( ContinuumBuildAgentUtil.KEY_BUILD_OUTPUT, "" );
}
else
{
result.put( ContinuumBuildAgentUtil.KEY_BUILD_OUTPUT, buildOutput );
}
result.put( ContinuumBuildAgentUtil.KEY_SCM_RESULT, ContinuumBuildAgentUtil.createScmResult(
buildContext ) );
}
else
{
log.debug( "Unable to get build result because project {} is not currently building in the agent",
projectId );
}
return result;
}
public void cancelBuild()
throws ContinuumBuildAgentException
{
try
{
log.debug( "Cancelling current build" );
buildAgentTaskQueueManager.cancelBuild();
}
catch ( TaskQueueManagerException e )
{
throw new ContinuumBuildAgentException( e.getMessage(), e );
}
}
public String generateWorkingCopyContent( int projectId, String userDirectory, String baseUrl,
String imagesBaseUrl )
throws ContinuumBuildAgentException
{
File workingDirectory = buildAgentConfigurationService.getWorkingDirectory( projectId );
try
{
List<File> files = ContinuumBuildAgentUtil.getFiles( userDirectory, workingDirectory );
return generator.generate( files, baseUrl, imagesBaseUrl, workingDirectory );
}
catch ( ContinuumException e )
{
log.error( "Failed to generate working copy content", e );
}
return "";
}
public Map<String, Object> getProjectFile( int projectId, String directory, String filename )
throws ContinuumBuildAgentException
{
Map<String, Object> projectFile = new HashMap<String, Object>();
String relativePath = "\\.\\./"; // prevent users from using relative paths.
Pattern pattern = Pattern.compile( relativePath );
Matcher matcher = pattern.matcher( directory );
String filteredDirectory = matcher.replaceAll( "" );
matcher = pattern.matcher( filename );
String filteredFilename = matcher.replaceAll( "" );
File workingDirectory = buildAgentConfigurationService.getWorkingDirectory( projectId );
File fileDirectory = new File( workingDirectory, filteredDirectory );
File userFile = new File( fileDirectory, filteredFilename );
byte[] downloadFile;
try
{
downloadFile = FileUtils.readFileToByteArray( userFile );
}
catch ( IOException e )
{
throw new ContinuumBuildAgentException( "Can't read file: " + filename );
}
MimetypesFileTypeMap mimeTypesMap = new MimetypesFileTypeMap();
mimeTypesMap.addMimeTypes( "application/java-archive jar war ear" );
mimeTypesMap.addMimeTypes( "application/java-class class" );
mimeTypesMap.addMimeTypes( "image/png png" );
String mimeType = mimeTypesMap.getContentType( userFile );
String fileContent;
boolean isStream = false;
if ( ( mimeType.indexOf( "image" ) >= 0 ) || ( mimeType.indexOf( "java-archive" ) >= 0 ) ||
( mimeType.indexOf( "java-class" ) >= 0 ) || ( userFile.length() > 100000 ) )
{
fileContent = "";
isStream = true;
}
else
{
try
{
fileContent = FileUtils.readFileToString( userFile );
}
catch ( IOException e )
{
throw new ContinuumBuildAgentException( "Can't read file " + filename, e );
}
}
projectFile.put( "downloadFileName", userFile.getName() );
projectFile.put( "downloadFileLength", Long.toString( userFile.length() ) );
projectFile.put( "downloadFile", downloadFile );
projectFile.put( "mimeType", mimeType );
projectFile.put( "fileContent", fileContent );
projectFile.put( "isStream", isStream );
return projectFile;
}
public Map<String, Object> getReleasePluginParameters( int projectId, String pomFilename )
throws ContinuumBuildAgentException
{
String workingDirectory = buildAgentConfigurationService.getWorkingDirectory( projectId ).getPath();
try
{
log.debug( "Getting release plugin parameters of project {}", projectId );
return ReleaseUtil.getReleasePluginParameters( workingDirectory, pomFilename );
}
catch ( Exception e )
{
throw new ContinuumBuildAgentException( "Error getting release plugin parameters from pom file", e );
}
}
public List<Map<String, String>> processProject( int projectId, String pomFilename, boolean autoVersionSubmodules )
throws ContinuumBuildAgentException
{
List<Map<String, String>> projects = new ArrayList<Map<String, String>>();
String workingDirectory = buildAgentConfigurationService.getWorkingDirectory( projectId ).getPath();
try
{
ReleaseUtil.processProject( workingDirectory, pomFilename, autoVersionSubmodules, projects );
}
catch ( Exception e )
{
throw new ContinuumBuildAgentException( "Unable to process project " + projectId, e );
}
return projects;
}
public String releasePrepare( Map project, Properties properties, Map releaseVersion, Map developmentVersion,
Map<String, String> environments, String username )
throws ContinuumBuildAgentException
{
try
{
log.debug( "Preparing release" );
return buildAgentReleaseManager.releasePrepare( project, properties, releaseVersion, developmentVersion,
environments, username );
}
catch ( ContinuumReleaseException e )
{
throw new ContinuumBuildAgentException( "Unable to prepare release", e );
}
}
public Map<String, Object> getReleaseResult( String releaseId )
throws ContinuumBuildAgentException
{
log.debug( "Getting release result of release {}", releaseId );
ReleaseResult result = buildAgentReleaseManager.getReleaseResult( releaseId );
Map<String, Object> map = new HashMap<String, Object>();
map.put( ContinuumBuildAgentUtil.KEY_START_TIME, Long.toString( result.getStartTime() ) );
map.put( ContinuumBuildAgentUtil.KEY_END_TIME, Long.toString( result.getEndTime() ) );
map.put( ContinuumBuildAgentUtil.KEY_RELEASE_RESULT_CODE, result.getResultCode() );
map.put( ContinuumBuildAgentUtil.KEY_RELEASE_OUTPUT, result.getOutput() );
return map;
}
public Map<String, Object> getListener( String releaseId )
throws ContinuumBuildAgentException
{
return buildAgentReleaseManager.getListener( releaseId );
}
public void removeListener( String releaseId )
{
buildAgentReleaseManager.removeListener( releaseId );
}
public String getPreparedReleaseName( String releaseId )
{
return buildAgentReleaseManager.getPreparedReleaseName( releaseId );
}
public void releasePerform( String releaseId, String goals, String arguments, boolean useReleaseProfile,
Map repository, String username )
throws ContinuumBuildAgentException
{
try
{
log.debug( "Performing release" );
buildAgentReleaseManager.releasePerform( releaseId, goals, arguments, useReleaseProfile, repository,
username );
}
catch ( ContinuumReleaseException e )
{
throw new ContinuumBuildAgentException( "Unable to perform release " + releaseId, e );
}
}
public String releasePerformFromScm( String goals, String arguments, boolean useReleaseProfile, Map repository,
String scmUrl, String scmUsername, String scmPassword, String scmTag,
String scmTagBase, Map<String, String> environments, String username )
throws ContinuumBuildAgentException
{
try
{
log.debug( "Performing release from scm" );
return buildAgentReleaseManager.releasePerformFromScm( goals, arguments, useReleaseProfile, repository,
scmUrl, scmUsername, scmPassword, scmTag, scmTagBase,
environments, username );
}
catch ( ContinuumReleaseException e )
{
throw new ContinuumBuildAgentException( "Unable to perform release from scm", e );
}
}
public String releaseCleanup( String releaseId )
throws ContinuumBuildAgentException
{
log.debug( "Cleanup release {}", releaseId );
return buildAgentReleaseManager.releaseCleanup( releaseId );
}
public void releaseRollback( String releaseId, int projectId )
throws ContinuumBuildAgentException
{
try
{
log.debug( "Release rollback release {} with project {}", releaseId, projectId );
buildAgentReleaseManager.releaseRollback( releaseId, projectId );
}
catch ( ContinuumReleaseException e )
{
throw new ContinuumBuildAgentException( e );
}
}
public int getBuildSizeOfAgent()
{
int size = 0;
try
{
log.debug( "Getting number of projects in any queue" );
if ( buildAgentTaskQueueManager.getCurrentProjectInBuilding() != null )
{
size++;
}
PrepareBuildProjectsTask currentPrepareBuild = buildAgentTaskQueueManager.getCurrentProjectInPrepareBuild();
if ( currentPrepareBuild != null )
{
// need to get actual number of projects.
size = size + currentPrepareBuild.getBuildContexts().size();
}
size = size + buildAgentTaskQueueManager.getProjectsInBuildQueue().size();
for ( PrepareBuildProjectsTask prepareBuildTask : buildAgentTaskQueueManager.getProjectsInPrepareBuildQueue() )
{
if ( prepareBuildTask != null )
{
size = size + prepareBuildTask.getBuildContexts().size();
}
}
}
catch ( TaskQueueManagerException e )
{
log.error( "Error occurred while getting build size of agent" );
}
return size;
}
public List<Map<String, Object>> getProjectsInPrepareBuildQueue()
throws ContinuumBuildAgentException
{
try
{
log.debug( "Getting projects in prepare build queue" );
List<Map<String, Object>> projects = new ArrayList<Map<String, Object>>();
for ( PrepareBuildProjectsTask task : buildAgentTaskQueueManager.getProjectsInPrepareBuildQueue() )
{
Map<String, Object> map = new HashMap<String, Object>();
map.put( ContinuumBuildAgentUtil.KEY_PROJECT_GROUP_ID, new Integer( task.getProjectGroupId() ) );
map.put( ContinuumBuildAgentUtil.KEY_SCM_ROOT_ID, new Integer( task.getScmRootId() ) );
map.put( ContinuumBuildAgentUtil.KEY_SCM_ROOT_ADDRESS, task.getScmRootAddress() );
map.put( ContinuumBuildAgentUtil.KEY_TRIGGER, task.getBuildTrigger().getTrigger() );
map.put( ContinuumBuildAgentUtil.KEY_USERNAME, task.getBuildTrigger().getTriggeredBy() );
projects.add( map );
}
return projects;
}
catch ( TaskQueueManagerException e )
{
log.error( "Error occurred while retrieving projects in prepare build queue", e );
throw new ContinuumBuildAgentException( "Error occurred while retrieving projects in prepare build queue",
e );
}
}
public List<Map<String, Object>> getProjectsAndBuildDefinitionsInPrepareBuildQueue()
throws ContinuumBuildAgentException
{
try
{
log.debug( "Getting projects in prepare build queue" );
List<Map<String, Object>> projects = new ArrayList<Map<String, Object>>();
for ( PrepareBuildProjectsTask task : buildAgentTaskQueueManager.getProjectsInPrepareBuildQueue() )
{
for ( BuildContext context : task.getBuildContexts() )
{
Map<String, Object> map = new HashMap<String, Object>();
map.put( ContinuumBuildAgentUtil.KEY_PROJECT_ID, context.getProjectId() );
map.put( ContinuumBuildAgentUtil.KEY_BUILD_DEFINITION_ID, context.getBuildDefinitionId() );
projects.add( map );
}
}
return projects;
}
catch ( TaskQueueManagerException e )
{
log.error( "Error occurred while retrieving projects in prepare build queue", e );
throw new ContinuumBuildAgentException( "Error occurred while retrieving projects in prepare build queue",
e );
}
}
public List<Map<String, Object>> getProjectsInBuildQueue()
throws ContinuumBuildAgentException
{
try
{
log.debug( "Getting projects in build queue" );
List<Map<String, Object>> projects = new ArrayList<Map<String, Object>>();
for ( BuildProjectTask task : buildAgentTaskQueueManager.getProjectsInBuildQueue() )
{
Map<String, Object> map = new HashMap<String, Object>();
map.put( ContinuumBuildAgentUtil.KEY_PROJECT_ID, new Integer( task.getProjectId() ) );
map.put( ContinuumBuildAgentUtil.KEY_BUILD_DEFINITION_ID, new Integer( task.getBuildDefinitionId() ) );
map.put( ContinuumBuildAgentUtil.KEY_TRIGGER, task.getBuildTrigger().getTrigger() );
map.put( ContinuumBuildAgentUtil.KEY_USERNAME, task.getBuildTrigger().getTriggeredBy() );
map.put( ContinuumBuildAgentUtil.KEY_PROJECT_GROUP_ID, new Integer( task.getProjectGroupId() ) );
map.put( ContinuumBuildAgentUtil.KEY_BUILD_DEFINITION_LABEL, task.getBuildDefinitionLabel() );
projects.add( map );
}
return projects;
}
catch ( TaskQueueManagerException e )
{
log.error( "Error occurred while retrieving projects in build queue", e );
throw new ContinuumBuildAgentException( "Error occurred while retrieving projects in build queue", e );
}
}
public Map<String, Object> getProjectCurrentlyPreparingBuild()
throws ContinuumBuildAgentException
{
try
{
log.debug( "Get project currently preparing build" );
Map<String, Object> project = new HashMap<String, Object>();
PrepareBuildProjectsTask task = buildAgentTaskQueueManager.getCurrentProjectInPrepareBuild();
if ( task != null )
{
project.put( ContinuumBuildAgentUtil.KEY_PROJECT_GROUP_ID, new Integer( task.getProjectGroupId() ) );
project.put( ContinuumBuildAgentUtil.KEY_SCM_ROOT_ID, new Integer( task.getScmRootId() ) );
project.put( ContinuumBuildAgentUtil.KEY_SCM_ROOT_ADDRESS, task.getScmRootAddress() );
project.put( ContinuumBuildAgentUtil.KEY_TRIGGER, task.getBuildTrigger().getTrigger() );
project.put( ContinuumBuildAgentUtil.KEY_USERNAME, task.getBuildTrigger().getTriggeredBy() );
}
return project;
}
catch ( TaskQueueManagerException e )
{
log.error( "Error occurred while retrieving current project in prepare build", e );
throw new ContinuumBuildAgentException( "Error occurred while retrieving current project in prepare build",
e );
}
}
public List<Map<String, Object>> getProjectsAndBuildDefinitionsCurrentlyPreparingBuild()
throws ContinuumBuildAgentException
{
try
{
log.debug( "Getting projects currently preparing build" );
List<Map<String, Object>> projects = new ArrayList<Map<String, Object>>();
PrepareBuildProjectsTask task = buildAgentTaskQueueManager.getCurrentProjectInPrepareBuild();
if ( task != null )
{
for ( BuildContext context : task.getBuildContexts() )
{
Map<String, Object> map = new HashMap<String, Object>();
map.put( ContinuumBuildAgentUtil.KEY_PROJECT_ID, context.getProjectId() );
map.put( ContinuumBuildAgentUtil.KEY_BUILD_DEFINITION_ID, context.getBuildDefinitionId() );
projects.add( map );
}
}
return projects;
}
catch ( TaskQueueManagerException e )
{
log.error( "Error occurred while retrieving current projects in prepare build", e );
throw new ContinuumBuildAgentException( "Error occurred while retrieving current projects in prepare build",
e );
}
}
public Map<String, Object> getProjectCurrentlyBuilding()
throws ContinuumBuildAgentException
{
try
{
log.debug( "Getting currently building project" );
Map<String, Object> project = new HashMap<String, Object>();
BuildProjectTask task = buildAgentTaskQueueManager.getCurrentProjectInBuilding();
if ( task != null )
{
project.put( ContinuumBuildAgentUtil.KEY_PROJECT_ID, new Integer( task.getProjectId() ) );
project.put( ContinuumBuildAgentUtil.KEY_BUILD_DEFINITION_ID, new Integer(
task.getBuildDefinitionId() ) );
project.put( ContinuumBuildAgentUtil.KEY_TRIGGER, task.getBuildTrigger().getTrigger() );
project.put( ContinuumBuildAgentUtil.KEY_USERNAME, task.getBuildTrigger().getTriggeredBy() );
project.put( ContinuumBuildAgentUtil.KEY_PROJECT_GROUP_ID, new Integer( task.getProjectGroupId() ) );
project.put( ContinuumBuildAgentUtil.KEY_BUILD_DEFINITION_LABEL, task.getBuildDefinitionLabel() );
}
return project;
}
catch ( TaskQueueManagerException e )
{
log.error( "Error occurred while retrieving current project in building", e );
throw new ContinuumBuildAgentException( "Error occurred while retrieving current project in building", e );
}
}
public boolean isProjectGroupInQueue( int projectGroupId )
{
try
{
log.debug( "Checking if project group is in any queue", projectGroupId );
for ( PrepareBuildProjectsTask task : buildAgentTaskQueueManager.getProjectsInPrepareBuildQueue() )
{
if ( task.getProjectGroupId() == projectGroupId )
{
log.debug( "projectGroup {} is in prepare build queue", projectGroupId );
return true;
}
}
PrepareBuildProjectsTask currentPrepareBuildTask =
buildAgentTaskQueueManager.getCurrentProjectInPrepareBuild();
if ( currentPrepareBuildTask != null && currentPrepareBuildTask.getProjectGroupId() == projectGroupId )
{
log.debug( "projectGroup {} is currently preparing build", projectGroupId );
return true;
}
for ( BuildProjectTask task : buildAgentTaskQueueManager.getProjectsInBuildQueue() )
{
if ( task.getProjectGroupId() == projectGroupId )
{
log.debug( "projectGroup {} is in build queue", projectGroupId );
return true;
}
}
BuildProjectTask currentBuildTask = buildAgentTaskQueueManager.getCurrentProjectInBuilding();
if ( currentBuildTask != null && currentBuildTask.getProjectGroupId() == projectGroupId )
{
log.debug( "projectGroup {} is currently building", projectGroupId );
return true;
}
}
catch ( TaskQueueManagerException e )
{
log.error( "Error while checking if project group " + projectGroupId + " is queued in agent", e );
}
return false;
}
public boolean isProjectScmRootInQueue( int projectScmRootId, List<Integer> projectIds )
{
try
{
log.debug( "Checking if projects {} is in any queue", projectIds );
PrepareBuildProjectsTask currentPrepareBuildTask =
buildAgentTaskQueueManager.getCurrentProjectInPrepareBuild();
if ( currentPrepareBuildTask != null && currentPrepareBuildTask.getScmRootId() == projectScmRootId )
{
return true;
}
BuildProjectTask currentBuildTask = buildAgentTaskQueueManager.getCurrentProjectInBuilding();
if ( currentBuildTask != null )
{
int projectId = currentBuildTask.getProjectId();
for ( Integer pid : projectIds )
{
if ( pid == projectId )
{
return true;
}
}
}
for ( PrepareBuildProjectsTask task : buildAgentTaskQueueManager.getProjectsInPrepareBuildQueue() )
{
if ( task.getScmRootId() == projectScmRootId )
{
return true;
}
}
for ( BuildProjectTask task : buildAgentTaskQueueManager.getProjectsInBuildQueue() )
{
int projectId = task.getProjectId();
for ( Integer pid : projectIds )
{
if ( pid == projectId )
{
return true;
}
}
}
}
catch ( TaskQueueManagerException e )
{
log.error( "Error while checking if project scm root " + projectScmRootId + " is queued in agent", e );
}
return false;
}
public boolean isProjectGroupInPrepareBuildQueue( int projectGroupId )
{
try
{
log.debug( "Checking if project group {} is in prepare build queue", projectGroupId );
for ( PrepareBuildProjectsTask task : buildAgentTaskQueueManager.getProjectsInPrepareBuildQueue() )
{
if ( task.getProjectGroupId() == projectGroupId )
{
return true;
}
}
}
catch ( TaskQueueManagerException e )
{
log.error(
"Error while checking if project group " + projectGroupId + " is in prepare build queue in agent", e );
}
return false;
}
public boolean isProjectInPrepareBuildQueue( int projectId, int buildDefinitionId )
{
try
{
log.debug( "Checking if projectId={}, buildDefinitionId={} is in prepare build queue", projectId,
buildDefinitionId );
for ( PrepareBuildProjectsTask task : buildAgentTaskQueueManager.getProjectsInPrepareBuildQueue() )
{
if ( task != null )
{
for ( BuildContext context : task.getBuildContexts() )
{
if ( context.getProjectId() == projectId &&
( buildDefinitionId == -1 || context.getBuildDefinitionId() == buildDefinitionId ) )
{
log.debug( "projectId={}, buildDefinitionId={} is in prepare build queue" );
return true;
}
}
}
}
}
catch ( TaskQueueManagerException e )
{
log.error( "Error while checking if projectId=" + projectId + ", buildDefinitionId=" + buildDefinitionId +
" is in prepare build queue in agent", e );
}
return false;
}
public boolean isProjectGroupCurrentlyPreparingBuild( int projectGroupId )
{
try
{
log.debug( "Checking if project group {} currently preparing build", projectGroupId );
PrepareBuildProjectsTask currentPrepareBuildTask =
buildAgentTaskQueueManager.getCurrentProjectInPrepareBuild();
if ( currentPrepareBuildTask != null && currentPrepareBuildTask.getProjectGroupId() == projectGroupId )
{
return true;
}
}
catch ( TaskQueueManagerException e )
{
log.error(
"Error while checking if project group " + projectGroupId + " is currently preparing build in agent",
e );
}
return false;
}
public boolean isProjectCurrentlyPreparingBuild( int projectId, int buildDefinitionId )
{
try
{
log.debug( "Checking if projectId={}, buildDefinitionId={} currently preparing build", projectId,
buildDefinitionId );
PrepareBuildProjectsTask currentPrepareBuildTask =
buildAgentTaskQueueManager.getCurrentProjectInPrepareBuild();
if ( currentPrepareBuildTask != null )
{
for ( BuildContext context : currentPrepareBuildTask.getBuildContexts() )
{
if ( context.getProjectId() == projectId &&
( buildDefinitionId == -1 || context.getBuildDefinitionId() == buildDefinitionId ) )
{
log.debug( "projectId={}, buildDefinitionId={} is currently preparing build" );
return true;
}
}
}
}
catch ( TaskQueueManagerException e )
{
log.error( "Error while checking if projectId=" + projectId + ", buildDefinitionId=" + buildDefinitionId +
" is currently preparing build in agent", e );
}
return false;
}
public boolean isProjectCurrentlyBuilding( int projectId, int buildDefinitionId )
{
try
{
log.debug( "Checking if projectId={}, buildDefinitionId={} is currently building", projectId,
buildDefinitionId );
BuildProjectTask currentBuildTask = buildAgentTaskQueueManager.getCurrentProjectInBuilding();
if ( currentBuildTask != null && currentBuildTask.getProjectId() == projectId &&
( buildDefinitionId == -1 || currentBuildTask.getBuildDefinitionId() == buildDefinitionId ) )
{
log.debug( "projectId={}, buildDefinitionId={} is currently building" );
return true;
}
}
catch ( TaskQueueManagerException e )
{
log.error(
"Error occurred while checking if projectId=" + projectId + ", buildDefinitionId=" + buildDefinitionId +
" is currently building in agent", e );
}
return false;
}
public boolean isProjectInBuildQueue( int projectId, int buildDefinitionId )
{
try
{
log.debug( "Checking if projectId={}, buildDefinitionId={} is in build queue", projectId,
buildDefinitionId );
List<BuildProjectTask> buildTasks = buildAgentTaskQueueManager.getProjectsInBuildQueue();
if ( buildTasks != null )
{
for ( BuildProjectTask task : buildTasks )
{
if ( task.getProjectId() == projectId &&
( buildDefinitionId == -1 || task.getBuildDefinitionId() == buildDefinitionId ) )
{
log.debug( "projectId={}, buildDefinitionId={} is in build queue" );
return true;
}
}
}
}
catch ( TaskQueueManagerException e )
{
log.error(
"Error occurred while checking if projectId=" + projectId + ", buildDefinitionId=" + buildDefinitionId +
" is in build queue of agent", e );
}
return false;
}
public boolean removeFromPrepareBuildQueue( int projectGroupId, int scmRootId )
throws ContinuumBuildAgentException
{
try
{
log.info( "Removing project group {} from prepare build queue", projectGroupId );
return buildAgentTaskQueueManager.removeFromPrepareBuildQueue( projectGroupId, scmRootId );
}
catch ( TaskQueueManagerException e )
{
log.error( "Error occurred while removing projects from prepare build queue", e );
throw new ContinuumBuildAgentException( "Error occurred while removing projects from prepare build queue",
e );
}
}
public void removeFromPrepareBuildQueue( List<String> hashCodes )
throws ContinuumBuildAgentException
{
try
{
log.info( "Removing project groups {} from prepare build queue", hashCodes );
buildAgentTaskQueueManager.removeFromPrepareBuildQueue( listToIntArray( hashCodes ) );
}
catch ( TaskQueueManagerException e )
{
log.error( "Error occurred while removing projects from prepare build queue", e );
throw new ContinuumBuildAgentException( "Error occurred while removing projects from prepare build queue",
e );
}
}
public boolean removeFromBuildQueue( int projectId, int buildDefinitionId )
throws ContinuumBuildAgentException
{
try
{
log.info( "Removing project {} with buildDefinition {} from build queue", projectId, buildDefinitionId );
return buildAgentTaskQueueManager.removeFromBuildQueue( projectId, buildDefinitionId );
}
catch ( TaskQueueManagerException e )
{
log.error( "Error occurred while removing project from build queue", e );
throw new ContinuumBuildAgentException( "Error occurred while removing project from build queue ", e );
}
}
public void removeFromBuildQueue( List<String> hashCodes )
throws ContinuumBuildAgentException
{
try
{
log.info( "Removing projects {} from build queue", hashCodes );
buildAgentTaskQueueManager.removeFromBuildQueue( listToIntArray( hashCodes ) );
}
catch ( TaskQueueManagerException e )
{
log.error( "Error occurred while removing projects from build queue", e );
throw new ContinuumBuildAgentException( "Error occurred while removing project from build queue ", e );
}
}
public boolean ping()
throws ContinuumBuildAgentException
{
try
{
// check first if it can ping the master
return buildAgentManager.pingMaster();
}
catch ( ContinuumException e )
{
throw new ContinuumBuildAgentException( e.getMessage() );
}
}
public String getBuildAgentPlatform()
throws ContinuumBuildAgentException
{
try
{
log.debug( "Getting build agent platform" );
return System.getProperty( "os.name" );
}
catch ( Exception e )
{
log.error( "Error in when trying to get build agent's platform", e );
throw new ContinuumBuildAgentException( "Error in when trying to get build agent's platform", e );
}
}
public boolean isExecutingBuild()
{
return getBuildSizeOfAgent() > 0;
}
public boolean isExecutingRelease()
throws ContinuumBuildAgentException
{
try
{
return buildAgentReleaseManager.getReleaseManager().isExecutingRelease();
}
catch ( Exception e )
{
throw new ContinuumBuildAgentException( e.getMessage(), e );
}
}
public void executeDirectoryPurge( String directoryType, int daysOlder, int retentionCount, boolean deleteAll )
throws ContinuumBuildAgentException
{
String logMsgFormat =
"Directory purge [directoryType={0}, daysOlder={1}, retentionCount={2}, deleteAll={3}] not possible; {4}";
if ( isExecutingBuild() )
{
log.info( MessageFormat.format( logMsgFormat, directoryType, daysOlder, retentionCount, deleteAll,
"Build Agent busy" ) );
return;
}
try
{
if ( isExecutingRelease() )
{
log.info( MessageFormat.format( logMsgFormat, directoryType, daysOlder, retentionCount, deleteAll,
"Build Agent is executing a release." ) );
return;
}
}
catch ( ContinuumBuildAgentException e )
{
if ( isExecutingRelease() )
{
log.info( MessageFormat.format( logMsgFormat, directoryType, daysOlder, retentionCount, deleteAll,
"Unable to determine if Build Agent is executing a release." ) );
return;
}
}
try
{
purgeManager.executeDirectoryPurge( directoryType, daysOlder, retentionCount, deleteAll );
}
catch ( Exception e )
{
throw new ContinuumBuildAgentException( e.getMessage(), e );
}
}
private List<BuildContext> initializeBuildContext( List<Map<String, Object>> projectsBuildContext )
{
List<BuildContext> buildContext = new ArrayList<BuildContext>();
for ( Map<String, Object> map : projectsBuildContext )
{
BuildContext context = new BuildContext();
context.setProjectId( ContinuumBuildAgentUtil.getProjectId( map ) );
context.setProjectVersion( ContinuumBuildAgentUtil.getProjectVersion( map ) );
context.setBuildDefinitionId( ContinuumBuildAgentUtil.getBuildDefinitionId( map ) );
context.setBuildFile( ContinuumBuildAgentUtil.getBuildFile( map ) );
context.setExecutorId( ContinuumBuildAgentUtil.getExecutorId( map ) );
context.setGoals( ContinuumBuildAgentUtil.getGoals( map ) );
context.setArguments( ContinuumBuildAgentUtil.getArguments( map ) );
context.setScmUrl( ContinuumBuildAgentUtil.getScmUrl( map ) );
context.setScmUsername( ContinuumBuildAgentUtil.getScmUsername( map ) );
context.setScmPassword( ContinuumBuildAgentUtil.getScmPassword( map ) );
context.setBuildFresh( ContinuumBuildAgentUtil.isBuildFresh( map ) );
context.setProjectGroupId( ContinuumBuildAgentUtil.getProjectGroupId( map ) );
context.setProjectGroupName( ContinuumBuildAgentUtil.getProjectGroupName( map ) );
context.setScmRootAddress( ContinuumBuildAgentUtil.getScmRootAddress( map ) );
context.setScmRootId( ContinuumBuildAgentUtil.getScmRootId( map ) );
context.setProjectName( ContinuumBuildAgentUtil.getProjectName( map ) );
context.setProjectState( ContinuumBuildAgentUtil.getProjectState( map ) );
context.setTrigger( ContinuumBuildAgentUtil.getTrigger( map ) );
context.setUsername( ContinuumBuildAgentUtil.getUsername( map ) );
context.setLocalRepository( ContinuumBuildAgentUtil.getLocalRepository( map ) );
context.setBuildNumber( ContinuumBuildAgentUtil.getBuildNumber( map ) );
context.setOldScmResult( getScmResult( ContinuumBuildAgentUtil.getOldScmChanges( map ) ) );
context.setLatestUpdateDate( ContinuumBuildAgentUtil.getLatestUpdateDate( map ) );
context.setBuildAgentUrl( ContinuumBuildAgentUtil.getBuildAgentUrl( map ) );
context.setMaxExecutionTime( ContinuumBuildAgentUtil.getMaxExecutionTime( map ) );
context.setBuildDefinitionLabel( ContinuumBuildAgentUtil.getBuildDefinitionLabel( map ) );
context.setScmTag( ContinuumBuildAgentUtil.getScmTag( map ) );
buildContext.add( context );
}
buildContextManager.addBuildContexts( buildContext );
return buildContext;
}
private String getBuildOutputText( int projectId )
{
try
{
File buildOutputFile = buildAgentConfigurationService.getBuildOutputFile( projectId );
if ( buildOutputFile.exists() )
{
return StringEscapeUtils.escapeHtml( FileUtils.readFileToString( buildOutputFile ) );
}
}
catch ( Exception e )
{
// do not throw exception, just log it
log.error( "Error retrieving build output file", e );
}
return null;
}
private ScmResult getScmResult( List<Map<String, Object>> scmChanges )
{
ScmResult scmResult = null;
if ( scmChanges != null && scmChanges.size() > 0 )
{
scmResult = new ScmResult();
for ( Map<String, Object> map : scmChanges )
{
ChangeSet changeSet = new ChangeSet();
changeSet.setAuthor( ContinuumBuildAgentUtil.getChangeSetAuthor( map ) );
changeSet.setComment( ContinuumBuildAgentUtil.getChangeSetComment( map ) );
changeSet.setDate( ContinuumBuildAgentUtil.getChangeSetDate( map ) );
setChangeFiles( changeSet, map );
scmResult.addChange( changeSet );
}
}
return scmResult;
}
private void setChangeFiles( ChangeSet changeSet, Map<String, Object> context )
{
List<Map<String, Object>> files = ContinuumBuildAgentUtil.getChangeSetFiles( context );
if ( files != null )
{
for ( Map<String, Object> map : files )
{
ChangeFile changeFile = new ChangeFile();
changeFile.setName( ContinuumBuildAgentUtil.getChangeFileName( map ) );
changeFile.setRevision( ContinuumBuildAgentUtil.getChangeFileRevision( map ) );
changeFile.setStatus( ContinuumBuildAgentUtil.getChangeFileStatus( map ) );
changeSet.addFile( changeFile );
}
}
}
private PrepareBuildProjectsTask createPrepareBuildProjectsTask( List<BuildContext> buildContexts )
throws ContinuumBuildAgentException
{
if ( buildContexts != null && buildContexts.size() > 0 )
{
BuildContext context = buildContexts.get( 0 );
return new PrepareBuildProjectsTask( buildContexts, new BuildTrigger( context.getTrigger(),
context.getUsername() ),
context.getProjectGroupId(), context.getScmRootAddress(),
context.getScmRootId() );
}
else
{
log.info( "Nothing to build" );
return null;
}
}
private int[] listToIntArray( List<String> strings )
{
if ( strings == null || strings.isEmpty() )
{
return new int[0];
}
int[] array = new int[0];
for ( String intString : strings )
{
array = ArrayUtils.add( array, Integer.parseInt( intString ) );
}
return array;
}
}