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