continuum-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From c...@apache.org
Subject svn commit: r775693 [2/5] - in /continuum/branches/continuum-1.3.x: continuum-api/src/main/java/org/apache/continuum/builder/distributed/ continuum-api/src/main/java/org/apache/continuum/builder/distributed/manager/ continuum-api/src/main/java/org/apac...
Date Sun, 17 May 2009 16:14:24 GMT
Added: continuum/branches/continuum-1.3.x/continuum-core/src/main/java/org/apache/continuum/builder/distributed/DefaultDistributedBuildService.java
URL: http://svn.apache.org/viewvc/continuum/branches/continuum-1.3.x/continuum-core/src/main/java/org/apache/continuum/builder/distributed/DefaultDistributedBuildService.java?rev=775693&view=auto
==============================================================================
--- continuum/branches/continuum-1.3.x/continuum-core/src/main/java/org/apache/continuum/builder/distributed/DefaultDistributedBuildService.java
(added)
+++ continuum/branches/continuum-1.3.x/continuum-core/src/main/java/org/apache/continuum/builder/distributed/DefaultDistributedBuildService.java
Sun May 17 16:14:22 2009
@@ -0,0 +1,725 @@
+package org.apache.continuum.builder.distributed;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.continuum.builder.distributed.util.DistributedBuildUtil;
+import org.apache.continuum.builder.utils.ContinuumBuildConstant;
+import org.apache.continuum.dao.BuildDefinitionDao;
+import org.apache.continuum.dao.BuildResultDao;
+import org.apache.continuum.dao.ProjectDao;
+import org.apache.continuum.dao.ProjectScmRootDao;
+import org.apache.continuum.model.project.ProjectScmRoot;
+import org.apache.maven.continuum.ContinuumException;
+import org.apache.maven.continuum.configuration.ConfigurationException;
+import org.apache.maven.continuum.configuration.ConfigurationService;
+import org.apache.maven.continuum.execution.ContinuumBuildExecutorConstants;
+import org.apache.maven.continuum.installation.InstallationService;
+import org.apache.maven.continuum.model.project.BuildDefinition;
+import org.apache.maven.continuum.model.project.BuildResult;
+import org.apache.maven.continuum.model.project.Project;
+import org.apache.maven.continuum.model.project.ProjectDependency;
+import org.apache.maven.continuum.model.project.ProjectDeveloper;
+import org.apache.maven.continuum.model.project.ProjectNotifier;
+import org.apache.maven.continuum.model.scm.ChangeFile;
+import org.apache.maven.continuum.model.scm.ChangeSet;
+import org.apache.maven.continuum.model.system.Installation;
+import org.apache.maven.continuum.model.system.Profile;
+import org.apache.maven.continuum.notification.ContinuumNotificationDispatcher;
+import org.apache.maven.continuum.project.ContinuumProjectState;
+import org.apache.maven.continuum.store.ContinuumStoreException;
+import org.codehaus.plexus.util.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * @plexus.component role="org.apache.continuum.builder.distributed.DistributedBuildService"
+ */
+public class DefaultDistributedBuildService
+    implements DistributedBuildService
+{
+    private static final Logger log = LoggerFactory.getLogger( DefaultDistributedBuildService.class
);
+
+    /**
+     * @plexus.requirement
+     */
+    private ProjectDao projectDao;
+
+    /**
+     * @plexus.requirement
+     */
+    private BuildDefinitionDao buildDefinitionDao;
+
+    /**
+     * @plexus.requirement
+     */
+    private BuildResultDao buildResultDao;
+
+    /**
+     * @plexus.requirement
+     */
+    private ProjectScmRootDao projectScmRootDao;
+
+    /**
+     * @plexus.requirement
+     */
+    private ConfigurationService configurationService;
+
+    /**
+     * @plexus.requirement
+     */
+    private InstallationService installationService;
+
+    /**
+     * @plexus.requirement
+     */
+    private ContinuumNotificationDispatcher notifierDispatcher;
+
+    /**
+     * @plexus.requirement
+     */
+    private DistributedBuildUtil distributedBuildUtil;
+
+    public void updateBuildResult( Map<String, Object> context )
+        throws ContinuumException
+    {
+        try
+        {
+            int projectId = ContinuumBuildConstant.getProjectId( context );
+            int buildDefinitionId = ContinuumBuildConstant.getBuildDefinitionId( context
);
+    
+            log.info( "update build result of project '" + projectId + "'" );
+    
+            Project project = projectDao.getProjectWithAllDetails( projectId );
+            BuildDefinition buildDefinition = buildDefinitionDao.getBuildDefinition( buildDefinitionId
);
+    
+            BuildResult oldBuildResult =
+                buildResultDao.getLatestBuildResultForBuildDefinition( projectId, buildDefinitionId
);
+    
+            int buildNumber;
+    
+            if ( ContinuumBuildConstant.getBuildState( context ) == ContinuumProjectState.OK
)
+            {
+                buildNumber = project.getBuildNumber() + 1;
+            }
+            else
+            {
+                buildNumber = project.getBuildNumber();
+            }
+    
+            // ----------------------------------------------------------------------
+            // Make the buildResult
+            // ----------------------------------------------------------------------
+    
+            BuildResult buildResult = distributedBuildUtil.convertMapToBuildResult( context
);
+    
+            if ( buildResult.getState() != ContinuumProjectState.CANCELLED )
+            {
+                buildResult.setBuildDefinition( buildDefinition );
+                buildResult.setBuildNumber( buildNumber );
+                buildResult.setModifiedDependencies( distributedBuildUtil.getModifiedDependencies(
oldBuildResult, context ) );
+                buildResult.setScmResult( distributedBuildUtil.getScmResult( context ) );
+    
+                Date date = ContinuumBuildConstant.getLatestUpdateDate( context );
+                if ( date != null )
+                {
+                    buildResult.setLastChangedDate( date.getTime() );
+                }
+                else if ( oldBuildResult != null )
+                {
+                    buildResult.setLastChangedDate( oldBuildResult.getLastChangedDate() );
+                }
+    
+                buildResultDao.addBuildResult( project, buildResult );
+    
+                project.setOldState( project.getState() );
+                project.setState( ContinuumBuildConstant.getBuildState( context ) );
+                project.setBuildNumber( buildNumber );
+                project.setLatestBuildId( buildResult.getId() );
+            }
+            else
+            {
+                project.setState( project.getOldState() );
+                project.setOldState( 0 );
+            }
+    
+            projectDao.updateProject( project );
+    
+            File buildOutputFile = configurationService.getBuildOutputFile( buildResult.getId(),
project.getId() );
+    
+            FileWriter fstream = new FileWriter( buildOutputFile );
+            BufferedWriter out = new BufferedWriter( fstream );
+            out.write( ContinuumBuildConstant.getBuildOutput( context ) == null ? ""
+                : ContinuumBuildConstant.getBuildOutput( context ) );
+            out.close();
+    
+            if ( buildResult.getState() != ContinuumProjectState.CANCELLED )
+            {
+                notifierDispatcher.buildComplete( project, buildDefinition, buildResult );
+            }
+        }
+        catch ( ContinuumStoreException e )
+        {
+            throw new ContinuumException( "Error while updating build result for project",
e );
+        }
+        catch ( ConfigurationException e )
+        {
+            throw new ContinuumException( "Error retrieving build output file", e );
+        }
+        catch ( IOException e )
+        {
+            throw new ContinuumException( "Error while writing build output to file", e );
+        }
+    }
+    
+    public void prepareBuildFinished( Map<String, Object> context )
+        throws ContinuumException
+    {
+        int projectGroupId = ContinuumBuildConstant.getProjectGroupId( context );
+        String scmRootAddress = ContinuumBuildConstant.getScmRootAddress( context );
+    
+        try
+        {
+            ProjectScmRoot scmRoot =
+                projectScmRootDao.getProjectScmRootByProjectGroupAndScmRootAddress( projectGroupId,
scmRootAddress );
+    
+            String error = ContinuumBuildConstant.getScmError( context );
+    
+            if ( StringUtils.isEmpty( error ) )
+            {
+                scmRoot.setState( ContinuumProjectState.UPDATED );
+            }
+            else
+            {
+                scmRoot.setState( ContinuumProjectState.ERROR );
+                scmRoot.setError( error );
+            }
+    
+            projectScmRootDao.updateProjectScmRoot( scmRoot );
+    
+            notifierDispatcher.prepareBuildComplete( scmRoot );
+        }
+        catch ( ContinuumStoreException e )
+        {
+            throw new ContinuumException( "Error while updating project scm root '" + scmRootAddress
+ "'", e );
+        }
+    }
+    
+    public void startProjectBuild( int projectId )
+        throws ContinuumException
+    {
+        try
+        {
+            Project project = projectDao.getProject( projectId );
+            project.setState( ContinuumProjectState.BUILDING );
+            projectDao.updateProject( project );
+        }
+        catch ( ContinuumStoreException e )
+        {
+            log.error( "Error while updating project's state", e );
+            throw new ContinuumException( "Error while updating project's state", e );
+        }
+    }
+    
+    public void startPrepareBuild( Map<String, Object> context )
+        throws ContinuumException
+    {
+        try
+        {
+            int projectGroupId = ContinuumBuildConstant.getProjectGroupId( context );
+            String scmRootAddress = ContinuumBuildConstant.getScmRootAddress( context );
+    
+            ProjectScmRoot scmRoot =
+                projectScmRootDao.getProjectScmRootByProjectGroupAndScmRootAddress( projectGroupId,
scmRootAddress );
+            scmRoot.setOldState( scmRoot.getState() );
+            scmRoot.setState( ContinuumProjectState.UPDATING );
+            projectScmRootDao.updateProjectScmRoot( scmRoot );
+        }
+        catch ( ContinuumStoreException e )
+        {
+            log.error( "Error while updating project scm root's state", e );
+            throw new ContinuumException( "Error while updating project scm root's state",
e );
+        }
+    }
+    
+    public Map<String, String> getEnvironments( int buildDefinitionId, String installationType
)
+        throws ContinuumException
+    {
+        BuildDefinition buildDefinition;
+    
+        try
+        {
+            buildDefinition = buildDefinitionDao.getBuildDefinition( buildDefinitionId );
+        }
+        catch ( ContinuumStoreException e )
+        {
+            throw new ContinuumException( "Failed to retrieve build definition: " + buildDefinitionId,
e );
+        }
+    
+        Profile profile = buildDefinition.getProfile();
+        if ( profile == null )
+        {
+            return Collections.EMPTY_MAP;
+        }
+        Map<String, String> envVars = new HashMap<String, String>();
+        String javaHome = getJavaHomeValue( buildDefinition );
+        if ( !StringUtils.isEmpty( javaHome ) )
+        {
+            envVars.put( installationService.getEnvVar( InstallationService.JDK_TYPE ), javaHome
);
+        }
+        Installation builder = profile.getBuilder();
+        if ( builder != null )
+        {
+            envVars.put( installationService.getEnvVar( installationType ), builder.getVarValue()
);
+        }
+        envVars.putAll( getEnvironmentVariables( buildDefinition ) );
+        return envVars;
+    }
+    
+    public void updateProject( Map<String, Object> context )
+        throws ContinuumException
+    {
+        try
+        {
+            Project project = projectDao.getProject( ContinuumBuildConstant.getProjectId(
context ) );
+    
+            if ( StringUtils.isNotBlank( ContinuumBuildConstant.getGroupId( context ) ) )
+            {
+                project.setGroupId( ContinuumBuildConstant.getGroupId( context ) );
+            }
+            if ( StringUtils.isNotBlank( ContinuumBuildConstant.getArtifactId( context )
) )
+            {
+                project.setArtifactId( ContinuumBuildConstant.getArtifactId( context ) );
+            }
+            if ( StringUtils.isNotBlank( ContinuumBuildConstant.getVersion( context ) ) )
+            {
+                project.setVersion( ContinuumBuildConstant.getVersion( context ) );
+            }
+            if ( StringUtils.isNotBlank( ContinuumBuildConstant.getProjectName( context )
) )
+            {
+                project.setName( ContinuumBuildConstant.getProjectName( context ) );
+            }
+            if ( StringUtils.isNotBlank( ContinuumBuildConstant.getProjectDescription( context
) ) )
+            {
+                project.setDescription( ContinuumBuildConstant.getProjectDescription( context
) );
+            }
+            if ( StringUtils.isNotBlank( ContinuumBuildConstant.getProjectUrl( context )
) )
+            {
+                project.setUrl( ContinuumBuildConstant.getProjectUrl( context ) );
+            }
+            if ( StringUtils.isNotBlank( ContinuumBuildConstant.getScmUrl( context ) ) )
+            {
+                project.setScmUrl( ContinuumBuildConstant.getScmUrl( context ) );
+            }
+            if ( StringUtils.isNotBlank( ContinuumBuildConstant.getScmTag( context ) ) )
+            {
+                project.setScmTag( ContinuumBuildConstant.getScmTag( context ) );
+            }
+            project.setParent( getProjectParent( context ) );
+            project.setDependencies( getProjectDependencies( context ) );
+            project.setDevelopers( getProjectDevelopers( context ) );
+            project.setNotifiers( getProjectNotifiers( context ) );
+    
+            projectDao.updateProject( project );
+        }
+        catch ( ContinuumStoreException e )
+        {
+            throw new ContinuumException( "Unable to update project from working copy", e
);
+        }
+    }
+
+    public boolean shouldBuild( Map<String, Object> context )
+    {
+        try
+        {
+            int projectId = ContinuumBuildConstant.getProjectId( context );
+    
+            int buildDefinitionId = ContinuumBuildConstant.getBuildDefinitionId( context
);
+    
+            int trigger = ContinuumBuildConstant.getTrigger( context );
+    
+            Project project = projectDao.getProjectWithAllDetails( projectId );
+    
+            BuildDefinition buildDefinition = buildDefinitionDao.getBuildDefinition( buildDefinitionId
);
+    
+            BuildResult oldBuildResult =
+                buildResultDao.getLatestBuildResultForBuildDefinition( projectId, buildDefinitionId
);
+    
+            List<ProjectDependency> modifiedDependencies = distributedBuildUtil.getModifiedDependencies(
oldBuildResult, context );
+    
+            List<ChangeSet> changes = distributedBuildUtil.getScmChanges( context );
+    
+            if ( buildDefinition.isBuildFresh() )
+            {
+                log.info( "FreshBuild configured, building" );
+                return true;
+            }
+            if ( buildDefinition.isAlwaysBuild() )
+            {
+                log.info( "AlwaysBuild configured, building" );
+                return true;
+            }
+            if ( oldBuildResult == null )
+            {
+                log.info( "The project was never be built with the current build definition,
building" );
+                return true;
+            }
+    
+            //CONTINUUM-1428
+            if ( project.getOldState() == ContinuumProjectState.ERROR ||
+                oldBuildResult.getState() == ContinuumProjectState.ERROR )
+            {
+                log.info( "Latest state was 'ERROR', building" );
+                return true;
+            }
+    
+            if ( trigger == ContinuumProjectState.TRIGGER_FORCED )
+            {
+                log.info( "The project build is forced, building" );
+                return true;
+            }
+    
+            Date date = ContinuumBuildConstant.getLatestUpdateDate( context );
+            if ( date != null && oldBuildResult.getLastChangedDate() >= date.getTime()
)
+            {
+                log.info( "No changes found,not building" );
+                return false;
+            }
+            else if ( date != null && changes.isEmpty() )
+            {
+                // fresh checkout from build agent that's why changes is empty
+                log.info( "Changes found in the current project, building" );
+                return true;
+            }
+    
+            boolean shouldBuild = false;
+    
+            boolean allChangesUnknown = true;
+    
+            if ( project.getOldState() != ContinuumProjectState.NEW &&
+                project.getOldState() != ContinuumProjectState.CHECKEDOUT &&
+                project.getState() != ContinuumProjectState.NEW &&
+                project.getState() != ContinuumProjectState.CHECKEDOUT )
+            {
+                // Check SCM changes
+                allChangesUnknown = checkAllChangesUnknown( changes );
+    
+                if ( allChangesUnknown )
+                {
+                    if ( !changes.isEmpty() )
+                    {
+                        log.info(
+                            "The project was not built because all changes are unknown (maybe
local modifications or ignored files not defined in your SCM tool." );
+                    }
+                    else
+                    {
+                        log.info(
+                            "The project was not built because no changes were detected in
sources since the last build." );
+                    }
+                }
+    
+                // Check dependencies changes
+                if ( modifiedDependencies != null && !modifiedDependencies.isEmpty()
)
+                {
+                    log.info( "Found dependencies changes, building" );
+                    shouldBuild = true;
+                }
+            }
+    
+            // Check changes
+            if ( !shouldBuild && ( ( !allChangesUnknown && !changes.isEmpty()
) ||
+                project.getExecutorId().equals( ContinuumBuildExecutorConstants.MAVEN_TWO_BUILD_EXECUTOR
) ) )
+            {
+                shouldBuild = shouldBuild( changes, buildDefinition, project, getMavenProjectVersion(
context ),
+                                           getMavenProjectModules( context ) );
+            }
+    
+            if ( shouldBuild )
+            {
+                log.info( "Changes found in the current project, building" );
+            }
+            else
+            {
+                log.info( "No changes in the current project, not building" );
+            }
+    
+            return shouldBuild;
+        }
+        catch ( ContinuumStoreException e )
+        {
+            log.error( "Failed to determine if project should build", e );
+        }
+        catch ( ContinuumException e )
+        {
+            log.error( "Failed to determine if project should build", e );
+        }
+    
+        return false;
+    }
+    
+    private boolean shouldBuild( List<ChangeSet> changes, BuildDefinition buildDefinition,
Project project,
+                                 String mavenProjectVersion, List<String> mavenProjectModules
)
+    {
+        //Check if it's a recursive build
+        boolean isRecursive = false;
+        if ( StringUtils.isNotEmpty( buildDefinition.getArguments() ) )
+        {
+            isRecursive = buildDefinition.getArguments().indexOf( "-N" ) < 0 &&
+                buildDefinition.getArguments().indexOf( "--non-recursive" ) < 0;
+        }
+    
+        if ( isRecursive && changes != null && !changes.isEmpty() )
+        {
+            if ( log.isInfoEnabled() )
+            {
+                log.info( "recursive build and changes found --> building" );
+            }
+            return true;
+        }
+    
+        if ( !project.getVersion().equals( mavenProjectVersion ) )
+        {
+            log.info( "Found changes in project's version ( maybe project was recently released
), building" );
+            return true;
+        }
+    
+        if ( changes == null || changes.isEmpty() )
+        {
+            if ( log.isInfoEnabled() )
+            {
+                log.info( "Found no changes, not building" );
+            }
+            return false;
+        }
+    
+        //check if changes are only in sub-modules or not
+        List<ChangeFile> files = new ArrayList<ChangeFile>();
+        for ( ChangeSet changeSet : changes )
+        {
+            files.addAll( changeSet.getFiles() );
+        }
+    
+        int i = 0;
+        while ( i <= files.size() - 1 )
+        {
+            ChangeFile file = files.get( i );
+            if ( log.isDebugEnabled() )
+            {
+                log.debug( "changeFile.name " + file.getName() );
+                log.debug( "check in modules " + mavenProjectModules );
+            }
+            boolean found = false;
+            if ( mavenProjectModules != null )
+            {
+                for ( String module : mavenProjectModules )
+                {
+                    if ( file.getName().indexOf( module ) >= 0 )
+                    {
+                        if ( log.isDebugEnabled() )
+                        {
+                            log.debug( "changeFile.name " + file.getName() + " removed because
in a module" );
+                        }
+                        files.remove( file );
+                        found = true;
+                        break;
+                    }
+                    if ( log.isDebugEnabled() )
+                    {
+                        log.debug( "not removing file " + file.getName() + " not in module
" + module );
+                    }
+                }
+            }
+            if ( !found )
+            {
+                i++;
+            }
+        }
+    
+        boolean shouldBuild = !files.isEmpty();
+    
+        if ( !shouldBuild )
+        {
+            log.info( "Changes are only in sub-modules." );
+        }
+    
+        if ( log.isDebugEnabled() )
+        {
+            log.debug( "shoulbuild = " + shouldBuild );
+        }
+    
+        return shouldBuild;
+    }
+    
+    private boolean checkAllChangesUnknown( List<ChangeSet> changes )
+    {
+        for ( ChangeSet changeSet : changes )
+        {
+            List<ChangeFile> changeFiles = changeSet.getFiles();
+    
+            for ( ChangeFile changeFile : changeFiles )
+            {
+                if ( !"unknown".equalsIgnoreCase( changeFile.getStatus() ) )
+                {
+                    return false;
+                }
+            }
+        }
+    
+        return true;
+    }
+    
+
+    private String getJavaHomeValue( BuildDefinition buildDefinition )
+    {
+        Profile profile = buildDefinition.getProfile();
+        if ( profile == null )
+        {
+            return null;
+        }
+        Installation jdk = profile.getJdk();
+        if ( jdk == null )
+        {
+            return null;
+        }
+        return jdk.getVarValue();
+    }
+    
+    private Map<String, String> getEnvironmentVariables( BuildDefinition buildDefinition
)
+    {
+        Profile profile = buildDefinition.getProfile();
+        Map<String, String> envVars = new HashMap<String, String>();
+        if ( profile == null )
+        {
+            return envVars;
+        }
+        List<Installation> environmentVariables = profile.getEnvironmentVariables();
+        if ( environmentVariables.isEmpty() )
+        {
+            return envVars;
+        }
+        for ( Installation installation : environmentVariables )
+        {
+            envVars.put( installation.getVarName(), installation.getVarValue() );
+        }
+        return envVars;
+    }
+
+    private ProjectDependency getProjectParent( Map<String, Object> context )
+    {
+        Map<String, Object> map = ContinuumBuildConstant.getProjectParent( context
);
+    
+        if ( map != null && map.size() > 0 )
+        {
+            ProjectDependency parent = new ProjectDependency();
+            parent.setGroupId( ContinuumBuildConstant.getGroupId( map ) );
+            parent.setArtifactId( ContinuumBuildConstant.getArtifactId( map ) );
+            parent.setVersion( ContinuumBuildConstant.getVersion( map ) );
+    
+            return parent;
+        }
+    
+        return null;
+    }
+    
+    private List<ProjectDependency> getProjectDependencies( Map<String, Object>
context )
+    {
+        List<ProjectDependency> projectDependencies = new ArrayList<ProjectDependency>();
+    
+        List<Map<String, Object>> dependencies = ContinuumBuildConstant.getProjectDependencies(
context );
+    
+        if ( dependencies != null )
+        {
+            for ( Map<String, Object> map : dependencies )
+            {
+                ProjectDependency dependency = new ProjectDependency();
+                dependency.setGroupId( ContinuumBuildConstant.getGroupId( map ) );
+                dependency.setArtifactId( ContinuumBuildConstant.getArtifactId( map ) );
+                dependency.setVersion( ContinuumBuildConstant.getVersion( map ) );
+    
+                projectDependencies.add( dependency );
+            }
+        }
+        return projectDependencies;
+    }
+    
+    private List<ProjectDeveloper> getProjectDevelopers( Map<String, Object>
context )
+    {
+        List<ProjectDeveloper> projectDevelopers = new ArrayList<ProjectDeveloper>();
+    
+        List<Map<String, Object>> developers = ContinuumBuildConstant.getProjectDevelopers(
context );
+    
+        if ( developers != null )
+        {
+            for ( Map<String, Object> map : developers )
+            {
+                ProjectDeveloper developer = new ProjectDeveloper();
+                developer.setName( ContinuumBuildConstant.getDeveloperName( map ) );
+                developer.setEmail( ContinuumBuildConstant.getDeveloperEmail( map ) );
+                developer.setScmId( ContinuumBuildConstant.getDeveloperScmId( map ) );
+    
+                projectDevelopers.add( developer );
+            }
+        }
+        return projectDevelopers;
+    }
+    
+    private List<ProjectNotifier> getProjectNotifiers( Map<String, Object> context
)
+    {
+        List<ProjectNotifier> projectNotifiers = new ArrayList<ProjectNotifier>();
+    
+        List<Map<String, Object>> notifiers = ContinuumBuildConstant.getProjectNotifiers(
context );
+    
+        if ( notifiers != null )
+        {
+            for ( Map<String, Object> map : notifiers )
+            {
+                ProjectNotifier notifier = new ProjectNotifier();
+                notifier.setConfiguration( ContinuumBuildConstant.getNotifierConfiguration(
map ) );
+                notifier.setEnabled( ContinuumBuildConstant.isNotifierEnabled( map ) );
+                notifier.setFrom( ContinuumBuildConstant.getNotifierFrom( map ) );
+                notifier.setRecipientType( ContinuumBuildConstant.getNotifierRecipientType(
map ) );
+                notifier.setSendOnError( ContinuumBuildConstant.isNotifierSendOnError( map
) );
+                notifier.setSendOnFailure( ContinuumBuildConstant.isNotifierSendOnFailure(
map ) );
+                notifier.setSendOnScmFailure( ContinuumBuildConstant.isNotifierSendOnScmFailure(
map ) );
+                notifier.setSendOnSuccess( ContinuumBuildConstant.isNotifierSendOnSuccess(
map ) );
+                notifier.setSendOnWarning( ContinuumBuildConstant.isNotifierSendOnWarning(
map ) );
+                notifier.setType( ContinuumBuildConstant.getNotifierType( map ) );
+    
+                projectNotifiers.add( notifier );
+            }
+        }
+        return projectNotifiers;
+    }
+
+    private String getMavenProjectVersion( Map<String, Object> context )
+    {
+        Map<String, Object> map = ContinuumBuildConstant.getMavenProject( context );
+    
+        if ( !map.isEmpty() )
+        {
+            return ContinuumBuildConstant.getVersion( map );
+        }
+    
+        return null;
+    }
+    
+    private List<String> getMavenProjectModules( Map<String, Object> context
)
+    {
+        Map<String, Object> map = ContinuumBuildConstant.getMavenProject( context );
+    
+        if ( !map.isEmpty() )
+        {
+            return ContinuumBuildConstant.getProjectModules( map );
+        }
+    
+        return null;
+    }
+}

Propchange: continuum/branches/continuum-1.3.x/continuum-core/src/main/java/org/apache/continuum/builder/distributed/DefaultDistributedBuildService.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: continuum/branches/continuum-1.3.x/continuum-core/src/main/java/org/apache/continuum/builder/distributed/DefaultDistributedBuildService.java
------------------------------------------------------------------------------
    svn:keywords = Author Date Id Revision



Mime
View raw message