View Javadoc
1   package org.apache.maven.execution;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import java.io.File;
23  import java.util.ArrayList;
24  import java.util.Date;
25  import java.util.List;
26  import java.util.Properties;
27  
28  import org.apache.maven.artifact.repository.ArtifactRepository;
29  import org.apache.maven.model.Profile;
30  import org.apache.maven.project.DefaultProjectBuildingRequest;
31  import org.apache.maven.project.ProjectBuildingRequest;
32  import org.apache.maven.settings.Mirror;
33  import org.apache.maven.settings.Proxy;
34  import org.apache.maven.settings.Server;
35  import org.eclipse.aether.DefaultRepositoryCache;
36  import org.eclipse.aether.RepositoryCache;
37  import org.eclipse.aether.repository.WorkspaceReader;
38  import org.eclipse.aether.transfer.TransferListener;
39  
40  /**
41   * @author Jason van Zyl
42   */
43  public class DefaultMavenExecutionRequest
44      implements MavenExecutionRequest
45  {
46  
47      private RepositoryCache repositoryCache = new DefaultRepositoryCache();
48  
49      private WorkspaceReader workspaceReader;
50  
51      private ArtifactRepository localRepository;
52  
53      private File localRepositoryPath;
54  
55      private boolean offline = false;
56  
57      private boolean interactiveMode = true;
58  
59      private boolean cacheTransferError;
60  
61      private boolean cacheNotFound;
62  
63      private List<Proxy> proxies;
64  
65      private List<Server> servers;
66  
67      private List<Mirror> mirrors;
68  
69      private List<Profile> profiles;
70  
71      private List<String> pluginGroups;
72  
73      private boolean isProjectPresent = true;
74  
75      // ----------------------------------------------------------------------------
76      // We need to allow per execution user and global settings as the embedder
77      // might be running in a mode where its executing many threads with totally
78      // different settings.
79      // ----------------------------------------------------------------------------
80  
81      private File userSettingsFile;
82  
83      private File globalSettingsFile;
84  
85      private File userToolchainsFile;
86  
87      // ----------------------------------------------------------------------------
88      // Request
89      // ----------------------------------------------------------------------------
90  
91      private File basedir;
92  
93      private List<String> goals;
94  
95      private boolean useReactor = false;
96  
97      private boolean recursive = true;
98  
99      private File pom;
100 
101     private String reactorFailureBehavior = REACTOR_FAIL_FAST;
102 
103     private List<String> selectedProjects;
104 
105     private List<String> excludedProjects;
106 
107     private String resumeFrom;
108 
109     private String makeBehavior;
110 
111     private Properties systemProperties;
112 
113     private Properties userProperties;
114 
115     private Date startTime;
116 
117     private boolean showErrors = false;
118 
119     private List<String> activeProfiles;
120 
121     private List<String> inactiveProfiles;
122 
123     private TransferListener transferListener;
124 
125     private int loggingLevel = LOGGING_LEVEL_INFO;
126 
127     private String globalChecksumPolicy;
128 
129     private boolean updateSnapshots = false;
130 
131     private List<ArtifactRepository> remoteRepositories;
132 
133     private List<ArtifactRepository> pluginArtifactRepositories;
134 
135     private ExecutionListener executionListener;
136 
137     private int degreeOfConcurrency = 1;
138 
139     private String builderId = "singlethreaded";
140 
141     /**
142      * Suppress SNAPSHOT updates.
143      * 
144      * @issue MNG-2681
145      */
146     private boolean noSnapshotUpdates;
147 
148     private boolean useSimpleLocalRepositoryManager = false;
149 
150     public DefaultMavenExecutionRequest()
151     {
152     }
153 
154     public static MavenExecutionRequest copy( MavenExecutionRequest original )
155     {
156         DefaultMavenExecutionRequest copy = new DefaultMavenExecutionRequest();
157         copy.setLocalRepository( original.getLocalRepository() );
158         copy.setLocalRepositoryPath( original.getLocalRepositoryPath() );
159         copy.setOffline( original.isOffline() );
160         copy.setInteractiveMode( original.isInteractiveMode() );
161         copy.setCacheNotFound( original.isCacheNotFound() );
162         copy.setCacheTransferError( original.isCacheTransferError() );
163         copy.setProxies( original.getProxies() );
164         copy.setServers( original.getServers() );
165         copy.setMirrors( original.getMirrors() );
166         copy.setProfiles( original.getProfiles() );
167         copy.setPluginGroups( original.getPluginGroups() );
168         copy.setProjectPresent( original.isProjectPresent() );
169         copy.setUserSettingsFile( original.getUserSettingsFile() );
170         copy.setGlobalSettingsFile( original.getGlobalSettingsFile() );
171         copy.setUserToolchainsFile( original.getUserToolchainsFile() );
172         copy.setBaseDirectory( ( original.getBaseDirectory() != null ) ? new File( original.getBaseDirectory() ) : null );
173         copy.setGoals( original.getGoals() );
174         copy.setRecursive( original.isRecursive() );
175         copy.setPom( original.getPom() );
176         copy.setSystemProperties( original.getSystemProperties() );
177         copy.setUserProperties( original.getUserProperties() );
178         copy.setShowErrors( original.isShowErrors() );
179         copy.setActiveProfiles( original.getActiveProfiles() );
180         copy.setInactiveProfiles( original.getInactiveProfiles() );
181         copy.setTransferListener( original.getTransferListener() );
182         copy.setLoggingLevel( original.getLoggingLevel() );
183         copy.setGlobalChecksumPolicy( original.getGlobalChecksumPolicy() );
184         copy.setUpdateSnapshots( original.isUpdateSnapshots() );
185         copy.setRemoteRepositories( original.getRemoteRepositories() );
186         copy.setPluginArtifactRepositories( original.getPluginArtifactRepositories() );
187         copy.setRepositoryCache( original.getRepositoryCache() );
188         copy.setWorkspaceReader( original.getWorkspaceReader() );
189         copy.setNoSnapshotUpdates( original.isNoSnapshotUpdates() );
190         copy.setExecutionListener( original.getExecutionListener() );
191         return copy;
192     }
193 
194     public String getBaseDirectory()
195     {
196         if ( basedir == null )
197         {
198             return null;
199         }
200 
201         return basedir.getAbsolutePath();
202     }
203 
204     public ArtifactRepository getLocalRepository()
205     {
206         return localRepository;
207     }
208 
209     public File getLocalRepositoryPath()
210     {
211         return localRepositoryPath;
212     }
213 
214     public List<String> getGoals()
215     {
216         if ( goals == null )
217         {
218             goals = new ArrayList<String>();
219         }
220         return goals;
221     }
222 
223     public Properties getSystemProperties()
224     {
225         if ( systemProperties == null )
226         {
227             systemProperties = new Properties();
228         }
229 
230         return systemProperties;
231     }
232 
233     public Properties getUserProperties()
234     {
235         if ( userProperties == null )
236         {
237             userProperties = new Properties();
238         }
239 
240         return userProperties;
241     }
242 
243     public File getPom()
244     {
245         return pom;
246     }
247 
248     public String getReactorFailureBehavior()
249     {
250         return reactorFailureBehavior;
251     }
252 
253     public List<String> getSelectedProjects()
254     {
255         if ( selectedProjects == null )
256         {
257             selectedProjects = new ArrayList<String>();
258         }
259 
260         return selectedProjects;
261     }
262 
263     public List<String> getExcludedProjects()
264     {
265         if ( excludedProjects == null )
266         {
267             excludedProjects = new ArrayList<String>();
268         }
269 
270         return excludedProjects;
271     }
272 
273     public String getResumeFrom()
274     {
275         return resumeFrom;
276     }
277 
278     public String getMakeBehavior()
279     {
280         return makeBehavior;
281     }
282 
283     public Date getStartTime()
284     {
285         return startTime;
286     }
287 
288     public boolean isShowErrors()
289     {
290         return showErrors;
291     }
292 
293     public boolean isInteractiveMode()
294     {
295         return interactiveMode;
296     }
297 
298     public MavenExecutionRequest setActiveProfiles( List<String> activeProfiles )
299     {
300         if ( activeProfiles != null )
301         {
302             this.activeProfiles = new ArrayList<String>( activeProfiles );
303         }
304         else
305         {
306             this.activeProfiles = null;
307         }
308 
309         return this;
310     }
311 
312     public MavenExecutionRequest setInactiveProfiles( List<String> inactiveProfiles )
313     {
314         if ( inactiveProfiles != null )
315         {
316             this.inactiveProfiles = new ArrayList<String>( inactiveProfiles );
317         }
318         else
319         {
320             this.inactiveProfiles = null;
321         }
322 
323         return this;
324     }
325 
326     public MavenExecutionRequest setRemoteRepositories( List<ArtifactRepository> remoteRepositories )
327     {
328         if ( remoteRepositories != null )
329         {
330             this.remoteRepositories = new ArrayList<ArtifactRepository>( remoteRepositories );
331         }
332         else
333         {
334             this.remoteRepositories = null;
335         }
336 
337         return this;
338     }
339 
340     public MavenExecutionRequest setPluginArtifactRepositories( List<ArtifactRepository> pluginArtifactRepositories )
341     {
342         if ( pluginArtifactRepositories != null )
343         {
344             this.pluginArtifactRepositories = new ArrayList<ArtifactRepository>( pluginArtifactRepositories );
345         }
346         else
347         {
348             this.pluginArtifactRepositories = null;
349         }
350 
351         return this;
352     }
353 
354     public void setProjectBuildingConfiguration( ProjectBuildingRequest projectBuildingConfiguration )
355     {
356         this.projectBuildingRequest = projectBuildingConfiguration;
357     }
358 
359     public List<String> getActiveProfiles()
360     {
361         if ( activeProfiles == null )
362         {
363             activeProfiles = new ArrayList<String>();
364         }
365         return activeProfiles;
366     }
367 
368     public List<String> getInactiveProfiles()
369     {
370         if ( inactiveProfiles == null )
371         {
372             inactiveProfiles = new ArrayList<String>();
373         }
374         return inactiveProfiles;
375     }
376 
377     public TransferListener getTransferListener()
378     {
379         return transferListener;
380     }
381 
382     public int getLoggingLevel()
383     {
384         return loggingLevel;
385     }
386 
387     public boolean isOffline()
388     {
389         return offline;
390     }
391 
392     public boolean isUpdateSnapshots()
393     {
394         return updateSnapshots;
395     }
396 
397     public boolean isNoSnapshotUpdates()
398     {
399         return noSnapshotUpdates;
400     }
401 
402     public String getGlobalChecksumPolicy()
403     {
404         return globalChecksumPolicy;
405     }
406 
407     public boolean isRecursive()
408     {
409         return recursive;
410     }
411 
412     // ----------------------------------------------------------------------
413     //
414     // ----------------------------------------------------------------------
415 
416     public MavenExecutionRequest setBaseDirectory( File basedir )
417     {
418         this.basedir = basedir;
419 
420         return this;
421     }
422 
423     public MavenExecutionRequest setStartTime( Date startTime )
424     {
425         this.startTime = startTime;
426 
427         return this;
428     }
429 
430     public MavenExecutionRequest setShowErrors( boolean showErrors )
431     {
432         this.showErrors = showErrors;
433 
434         return this;
435     }
436 
437     public MavenExecutionRequest setGoals( List<String> goals )
438     {
439         if ( goals != null )
440         {
441             this.goals = new ArrayList<String>( goals );
442         }
443         else
444         {
445             this.goals = null;
446         }
447 
448         return this;
449     }
450 
451     public MavenExecutionRequest setLocalRepository( ArtifactRepository localRepository )
452     {
453         this.localRepository = localRepository;
454 
455         if ( localRepository != null )
456         {
457             setLocalRepositoryPath( new File( localRepository.getBasedir() ).getAbsoluteFile() );
458         }
459 
460         return this;
461     }
462 
463     public MavenExecutionRequest setLocalRepositoryPath( File localRepository )
464     {
465         localRepositoryPath = localRepository;
466 
467         return this;
468     }
469 
470     public MavenExecutionRequest setLocalRepositoryPath( String localRepository )
471     {
472         localRepositoryPath = ( localRepository != null ) ? new File( localRepository ) : null;
473 
474         return this;
475     }
476 
477     public MavenExecutionRequest setSystemProperties( Properties properties )
478     {
479         if ( properties != null )
480         {
481             this.systemProperties = new Properties();
482             this.systemProperties.putAll( properties );
483         }
484         else
485         {
486             this.systemProperties = null;
487         }
488 
489         return this;
490     }
491 
492     public MavenExecutionRequest setUserProperties( Properties userProperties )
493     {
494         if ( userProperties != null )
495         {
496             this.userProperties = new Properties();
497             this.userProperties.putAll( userProperties );
498         }
499         else
500         {
501             this.userProperties = null;
502         }
503 
504         return this;
505     }
506 
507     public MavenExecutionRequest setReactorFailureBehavior( String failureBehavior )
508     {
509         reactorFailureBehavior = failureBehavior;
510 
511         return this;
512     }
513 
514     public MavenExecutionRequest setSelectedProjects( List<String> selectedProjects )
515     {
516         if ( selectedProjects != null )
517         {
518             this.selectedProjects = new ArrayList<String>( selectedProjects );
519         }
520         else
521         {
522             this.selectedProjects = null;
523         }
524 
525         return this;
526     }
527 
528     public MavenExecutionRequest setExcludedProjects( List<String> excludedProjects )
529     {
530         if ( excludedProjects != null )
531         {
532             this.excludedProjects = new ArrayList<String>( excludedProjects );
533         }
534         else
535         {
536             this.excludedProjects = null;
537         }
538 
539         return this;
540     }
541 
542     public MavenExecutionRequest setResumeFrom( String project )
543     {
544         this.resumeFrom = project;
545 
546         return this;
547     }
548 
549     public MavenExecutionRequest setMakeBehavior( String makeBehavior )
550     {
551         this.makeBehavior = makeBehavior;
552 
553         return this;
554     }
555 
556     public MavenExecutionRequest addActiveProfile( String profile )
557     {
558         if ( !getActiveProfiles().contains( profile ) )
559         {
560             getActiveProfiles().add( profile );
561         }
562 
563         return this;
564     }
565 
566     public MavenExecutionRequest addInactiveProfile( String profile )
567     {
568         if ( !getInactiveProfiles().contains( profile ) )
569         {
570             getInactiveProfiles().add( profile );
571         }
572 
573         return this;
574     }
575 
576     public MavenExecutionRequest addActiveProfiles( List<String> profiles )
577     {
578         for ( String profile : profiles )
579         {
580             addActiveProfile( profile );
581         }
582 
583         return this;
584     }
585 
586     public MavenExecutionRequest addInactiveProfiles( List<String> profiles )
587     {
588         for ( String profile : profiles )
589         {
590             addInactiveProfile( profile );
591         }
592 
593         return this;
594     }
595 
596     public MavenExecutionRequest setUseReactor( boolean reactorActive )
597     {
598         useReactor = reactorActive;
599 
600         return this;
601     }
602 
603     public boolean useReactor()
604     {
605         return useReactor;
606     }
607 
608     /** @deprecated use {@link #setPom(File)} */
609     public MavenExecutionRequest setPomFile( String pomFilename )
610     {
611         if ( pomFilename != null )
612         {
613             pom = new File( pomFilename );
614         }
615 
616         return this;
617     }
618 
619     public MavenExecutionRequest setPom( File pom )
620     {
621         this.pom = pom;
622 
623         return this;
624     }
625 
626     public MavenExecutionRequest setInteractiveMode( boolean interactive )
627     {
628         interactiveMode = interactive;
629 
630         return this;
631     }
632 
633     public MavenExecutionRequest setTransferListener( TransferListener transferListener )
634     {
635         this.transferListener = transferListener;
636 
637         return this;
638     }
639 
640     public MavenExecutionRequest setLoggingLevel( int loggingLevel )
641     {
642         this.loggingLevel = loggingLevel;
643 
644         return this;
645     }
646 
647     public MavenExecutionRequest setOffline( boolean offline )
648     {
649         this.offline = offline;
650 
651         return this;
652     }
653 
654     public MavenExecutionRequest setUpdateSnapshots( boolean updateSnapshots )
655     {
656         this.updateSnapshots = updateSnapshots;
657 
658         return this;
659     }
660 
661     public MavenExecutionRequest setNoSnapshotUpdates( boolean noSnapshotUpdates )
662     {
663         this.noSnapshotUpdates = noSnapshotUpdates;
664 
665         return this;
666     }
667 
668     public MavenExecutionRequest setGlobalChecksumPolicy( String globalChecksumPolicy )
669     {
670         this.globalChecksumPolicy = globalChecksumPolicy;
671 
672         return this;
673     }
674 
675     // ----------------------------------------------------------------------------
676     // Settings equivalents
677     // ----------------------------------------------------------------------------
678 
679     public List<Proxy> getProxies()
680     {
681         if ( proxies == null )
682         {
683             proxies = new ArrayList<Proxy>();
684         }
685         return proxies;
686     }
687 
688     public MavenExecutionRequest setProxies( List<Proxy> proxies )
689     {
690         if ( proxies != null )
691         {
692             this.proxies = new ArrayList<Proxy>( proxies );
693         }
694         else
695         {
696             this.proxies = null;
697         }
698 
699         return this;
700     }
701 
702     public MavenExecutionRequest addProxy( Proxy proxy )
703     {
704         if ( proxy == null )
705         {
706             throw new IllegalArgumentException( "proxy missing" );
707         }
708 
709         for ( Proxy p : getProxies() )
710         {
711             if ( p.getId() != null && p.getId().equals( proxy.getId() ) )
712             {
713                 return this;
714             }
715         }
716 
717         getProxies().add( proxy );
718 
719         return this;
720     }
721 
722     public List<Server> getServers()
723     {
724         if ( servers == null )
725         {
726             servers = new ArrayList<Server>();
727         }
728         return servers;
729     }
730 
731     public MavenExecutionRequest setServers( List<Server> servers )
732     {
733         if ( servers != null )
734         {
735             this.servers = new ArrayList<Server>( servers );
736         }
737         else
738         {
739             this.servers = null;
740         }
741 
742         return this;
743     }
744 
745     public MavenExecutionRequest addServer( Server server )
746     {
747         if ( server == null )
748         {
749             throw new IllegalArgumentException( "server missing" );
750         }
751 
752         for ( Server p : getServers() )
753         {
754             if ( p.getId() != null && p.getId().equals( server.getId() ) )
755             {
756                 return this;
757             }
758         }
759 
760         getServers().add( server );
761 
762         return this;
763     }
764 
765     public List<Mirror> getMirrors()
766     {
767         if ( mirrors == null )
768         {
769             mirrors = new ArrayList<Mirror>();
770         }
771         return mirrors;
772     }
773 
774     public MavenExecutionRequest setMirrors( List<Mirror> mirrors )
775     {
776         if ( mirrors != null )
777         {
778             this.mirrors = new ArrayList<Mirror>( mirrors );
779         }
780         else
781         {
782             this.mirrors = null;
783         }
784 
785         return this;
786     }
787 
788     public MavenExecutionRequest addMirror( Mirror mirror )
789     {
790         if ( mirror == null )
791         {
792             throw new IllegalArgumentException( "mirror missing" );
793         }
794 
795         for ( Mirror p : getMirrors() )
796         {
797             if ( p.getId() != null && p.getId().equals( mirror.getId() ) )
798             {
799                 return this;
800             }
801         }
802 
803         getMirrors().add( mirror );
804 
805         return this;
806     }
807 
808     public List<Profile> getProfiles()
809     {
810         if ( profiles == null )
811         {
812             profiles = new ArrayList<Profile>();
813         }
814         return profiles;
815     }
816 
817     public MavenExecutionRequest setProfiles( List<Profile> profiles )
818     {
819         if ( profiles != null )
820         {
821             this.profiles = new ArrayList<Profile>( profiles );
822         }
823         else
824         {
825             this.profiles = null;
826         }
827 
828         return this;
829     }
830 
831     public List<String> getPluginGroups()
832     {
833         if ( pluginGroups == null )
834         {
835             pluginGroups = new ArrayList<String>();
836         }
837 
838         return pluginGroups;
839     }
840 
841     public MavenExecutionRequest setPluginGroups( List<String> pluginGroups )
842     {
843         if ( pluginGroups != null )
844         {
845             this.pluginGroups = new ArrayList<String>( pluginGroups );
846         }
847         else
848         {
849             this.pluginGroups = null;
850         }
851 
852         return this;
853     }
854 
855     public MavenExecutionRequest addPluginGroup( String pluginGroup )
856     {
857         if ( !getPluginGroups().contains( pluginGroup ) )
858         {
859             getPluginGroups().add( pluginGroup );
860         }
861 
862         return this;
863     }
864 
865     public MavenExecutionRequest addPluginGroups( List<String> pluginGroups )
866     {
867         for ( String pluginGroup : pluginGroups )
868         {
869             addPluginGroup( pluginGroup );
870         }
871 
872         return this;
873     }
874 
875     public MavenExecutionRequest setRecursive( boolean recursive )
876     {
877         this.recursive = recursive;
878 
879         return this;
880     }
881 
882     // calculated from request attributes.
883     private ProjectBuildingRequest projectBuildingRequest;
884 
885     public boolean isProjectPresent()
886     {
887         return isProjectPresent;
888     }
889 
890     public MavenExecutionRequest setProjectPresent( boolean projectPresent )
891     {
892         isProjectPresent = projectPresent;
893 
894         return this;
895     }
896 
897     // Settings files
898 
899     public File getUserSettingsFile()
900     {
901         return userSettingsFile;
902     }
903 
904     public MavenExecutionRequest setUserSettingsFile( File userSettingsFile )
905     {
906         this.userSettingsFile = userSettingsFile;
907 
908         return this;
909     }
910 
911     public File getGlobalSettingsFile()
912     {
913         return globalSettingsFile;
914     }
915 
916     public MavenExecutionRequest setGlobalSettingsFile( File globalSettingsFile )
917     {
918         this.globalSettingsFile = globalSettingsFile;
919 
920         return this;
921     }
922 
923     public File getUserToolchainsFile()
924     {
925         return userToolchainsFile;
926     }
927 
928     public MavenExecutionRequest setUserToolchainsFile( File userToolchainsFile )
929     {
930         this.userToolchainsFile = userToolchainsFile;
931 
932         return this;
933     }
934 
935     public MavenExecutionRequest addRemoteRepository( ArtifactRepository repository )
936     {
937         for ( ArtifactRepository repo : getRemoteRepositories() )
938         {
939             if ( repo.getId() != null && repo.getId().equals( repository.getId() ) )
940             {
941                 return this;
942             }
943         }
944 
945         getRemoteRepositories().add( repository );
946 
947         return this;
948     }
949 
950     public List<ArtifactRepository> getRemoteRepositories()
951     {
952         if ( remoteRepositories == null )
953         {
954             remoteRepositories = new ArrayList<ArtifactRepository>();
955         }
956         return remoteRepositories;
957     }
958 
959     public MavenExecutionRequest addPluginArtifactRepository( ArtifactRepository repository )
960     {
961         for ( ArtifactRepository repo : getPluginArtifactRepositories() )
962         {
963             if ( repo.getId() != null && repo.getId().equals( repository.getId() ) )
964             {
965                 return this;
966             }
967         }
968 
969         getPluginArtifactRepositories().add( repository );
970 
971         return this;
972     }
973 
974     public List<ArtifactRepository> getPluginArtifactRepositories()
975     {
976         if ( pluginArtifactRepositories == null )
977         {
978             pluginArtifactRepositories = new ArrayList<ArtifactRepository>();
979         }
980         return pluginArtifactRepositories;
981     }
982 
983     // TODO: this does not belong here.
984     public ProjectBuildingRequest getProjectBuildingRequest()
985     {
986         if ( projectBuildingRequest == null )
987         {
988             projectBuildingRequest = new DefaultProjectBuildingRequest();
989             projectBuildingRequest.setLocalRepository( getLocalRepository() );
990             projectBuildingRequest.setSystemProperties( getSystemProperties() );
991             projectBuildingRequest.setUserProperties( getUserProperties() );
992             projectBuildingRequest.setRemoteRepositories( getRemoteRepositories() );
993             projectBuildingRequest.setPluginArtifactRepositories( getPluginArtifactRepositories() );
994             projectBuildingRequest.setActiveProfileIds( getActiveProfiles() );
995             projectBuildingRequest.setInactiveProfileIds( getInactiveProfiles() );
996             projectBuildingRequest.setProfiles( getProfiles() );
997             projectBuildingRequest.setProcessPlugins( true );
998             projectBuildingRequest.setBuildStartTime( getStartTime() );
999         }
1000 
1001         return projectBuildingRequest;
1002     }
1003 
1004     public MavenExecutionRequest addProfile( Profile profile )
1005     {
1006         if ( profile == null )
1007         {
1008             throw new IllegalArgumentException( "profile missing" );
1009         }
1010 
1011         for ( Profile p : getProfiles() )
1012         {
1013             if ( p.getId() != null && p.getId().equals( profile.getId() ) )
1014             {
1015                 return this;
1016             }
1017         }
1018 
1019         getProfiles().add( profile );
1020 
1021         return this;
1022     }
1023 
1024     public RepositoryCache getRepositoryCache()
1025     {
1026         return repositoryCache;
1027     }
1028 
1029     public MavenExecutionRequest setRepositoryCache( RepositoryCache repositoryCache )
1030     {
1031         this.repositoryCache = repositoryCache;
1032 
1033         return this;
1034     }
1035 
1036     public ExecutionListener getExecutionListener()
1037     {
1038         return executionListener;
1039     }
1040 
1041     public MavenExecutionRequest setExecutionListener( ExecutionListener executionListener )
1042     {
1043         this.executionListener = executionListener;
1044 
1045         return this;
1046     }
1047 
1048     public void setDegreeOfConcurrency( final int degreeOfConcurrency )
1049     {
1050         this.degreeOfConcurrency = degreeOfConcurrency;
1051     }
1052 
1053     public int getDegreeOfConcurrency()
1054     {
1055         return degreeOfConcurrency;
1056     }
1057 
1058     public WorkspaceReader getWorkspaceReader()
1059     {
1060         return workspaceReader;
1061     }
1062 
1063     public MavenExecutionRequest setWorkspaceReader( WorkspaceReader workspaceReader )
1064     {
1065         this.workspaceReader = workspaceReader;
1066         return this;
1067     }
1068 
1069     public boolean isCacheTransferError()
1070     {
1071         return cacheTransferError;
1072     }
1073 
1074     public MavenExecutionRequest setCacheTransferError( boolean cacheTransferError )
1075     {
1076         this.cacheTransferError = cacheTransferError;
1077         return this;
1078     }
1079 
1080     public boolean isCacheNotFound()
1081     {
1082         return cacheNotFound;
1083     }
1084 
1085     public MavenExecutionRequest setCacheNotFound( boolean cacheNotFound )
1086     {
1087         this.cacheNotFound = cacheNotFound;
1088         return this;
1089     }
1090 
1091     public boolean isUseLegacyLocalRepository()
1092     {
1093         return this.useSimpleLocalRepositoryManager;
1094     }
1095 
1096     public MavenExecutionRequest setUseLegacyLocalRepository( boolean useSimpleLocalRepositoryManager )
1097     {
1098         this.useSimpleLocalRepositoryManager = useSimpleLocalRepositoryManager;
1099         return this;
1100     }
1101 
1102     public MavenExecutionRequest setBuilderId( String builderId )
1103     {
1104         this.builderId = builderId;
1105         return this;
1106     }
1107 
1108     public String getBuilderId()
1109     {
1110         return builderId;
1111     }
1112 }