1 package org.eclipse.aether;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.util.Collection;
23 import java.util.Collections;
24 import java.util.HashMap;
25 import java.util.Map;
26
27 import org.eclipse.aether.artifact.Artifact;
28 import org.eclipse.aether.artifact.ArtifactType;
29 import org.eclipse.aether.artifact.ArtifactTypeRegistry;
30 import org.eclipse.aether.collection.DependencyGraphTransformer;
31 import org.eclipse.aether.collection.DependencyManager;
32 import org.eclipse.aether.collection.DependencySelector;
33 import org.eclipse.aether.collection.DependencyTraverser;
34 import org.eclipse.aether.collection.VersionFilter;
35 import org.eclipse.aether.repository.Authentication;
36 import org.eclipse.aether.repository.AuthenticationSelector;
37 import org.eclipse.aether.repository.LocalRepository;
38 import org.eclipse.aether.repository.LocalRepositoryManager;
39 import org.eclipse.aether.repository.MirrorSelector;
40 import org.eclipse.aether.repository.Proxy;
41 import org.eclipse.aether.repository.ProxySelector;
42 import org.eclipse.aether.repository.RemoteRepository;
43 import org.eclipse.aether.repository.RepositoryPolicy;
44 import org.eclipse.aether.repository.WorkspaceReader;
45 import org.eclipse.aether.resolution.ArtifactDescriptorPolicy;
46 import org.eclipse.aether.resolution.ResolutionErrorPolicy;
47 import org.eclipse.aether.transfer.TransferListener;
48 import org.eclipse.aether.transform.FileTransformer;
49 import org.eclipse.aether.transform.FileTransformerManager;
50
51 import static java.util.Objects.requireNonNull;
52
53
54
55
56
57
58
59
60
61 public final class DefaultRepositorySystemSession
62 implements RepositorySystemSession
63 {
64
65 private boolean readOnly;
66
67 private boolean offline;
68
69 private boolean ignoreArtifactDescriptorRepositories;
70
71 private ResolutionErrorPolicy resolutionErrorPolicy;
72
73 private ArtifactDescriptorPolicy artifactDescriptorPolicy;
74
75 private String checksumPolicy;
76
77 private String updatePolicy;
78
79 private LocalRepositoryManager localRepositoryManager;
80
81 private FileTransformerManager fileTransformerManager;
82
83 private WorkspaceReader workspaceReader;
84
85 private RepositoryListener repositoryListener;
86
87 private TransferListener transferListener;
88
89 private Map<String, String> systemProperties;
90
91 private Map<String, String> systemPropertiesView;
92
93 private Map<String, String> userProperties;
94
95 private Map<String, String> userPropertiesView;
96
97 private Map<String, Object> configProperties;
98
99 private Map<String, Object> configPropertiesView;
100
101 private MirrorSelector mirrorSelector;
102
103 private ProxySelector proxySelector;
104
105 private AuthenticationSelector authenticationSelector;
106
107 private ArtifactTypeRegistry artifactTypeRegistry;
108
109 private DependencyTraverser dependencyTraverser;
110
111 private DependencyManager dependencyManager;
112
113 private DependencySelector dependencySelector;
114
115 private VersionFilter versionFilter;
116
117 private DependencyGraphTransformer dependencyGraphTransformer;
118
119 private SessionData data;
120
121 private RepositoryCache cache;
122
123
124
125
126
127
128 public DefaultRepositorySystemSession()
129 {
130 systemProperties = new HashMap<>();
131 systemPropertiesView = Collections.unmodifiableMap( systemProperties );
132 userProperties = new HashMap<>();
133 userPropertiesView = Collections.unmodifiableMap( userProperties );
134 configProperties = new HashMap<>();
135 configPropertiesView = Collections.unmodifiableMap( configProperties );
136 mirrorSelector = NullMirrorSelector.INSTANCE;
137 proxySelector = NullProxySelector.INSTANCE;
138 authenticationSelector = NullAuthenticationSelector.INSTANCE;
139 artifactTypeRegistry = NullArtifactTypeRegistry.INSTANCE;
140 fileTransformerManager = NullFileTransformerManager.INSTANCE;
141 data = new DefaultSessionData();
142 }
143
144
145
146
147
148
149
150
151
152 public DefaultRepositorySystemSession( RepositorySystemSession session )
153 {
154 requireNonNull( session, "repository system session cannot be null" );
155
156 setOffline( session.isOffline() );
157 setIgnoreArtifactDescriptorRepositories( session.isIgnoreArtifactDescriptorRepositories() );
158 setResolutionErrorPolicy( session.getResolutionErrorPolicy() );
159 setArtifactDescriptorPolicy( session.getArtifactDescriptorPolicy() );
160 setChecksumPolicy( session.getChecksumPolicy() );
161 setUpdatePolicy( session.getUpdatePolicy() );
162 setLocalRepositoryManager( session.getLocalRepositoryManager() );
163 setWorkspaceReader( session.getWorkspaceReader() );
164 setRepositoryListener( session.getRepositoryListener() );
165 setTransferListener( session.getTransferListener() );
166 setSystemProperties( session.getSystemProperties() );
167 setUserProperties( session.getUserProperties() );
168 setConfigProperties( session.getConfigProperties() );
169 setMirrorSelector( session.getMirrorSelector() );
170 setProxySelector( session.getProxySelector() );
171 setAuthenticationSelector( session.getAuthenticationSelector() );
172 setArtifactTypeRegistry( session.getArtifactTypeRegistry() );
173 setDependencyTraverser( session.getDependencyTraverser() );
174 setDependencyManager( session.getDependencyManager() );
175 setDependencySelector( session.getDependencySelector() );
176 setVersionFilter( session.getVersionFilter() );
177 setDependencyGraphTransformer( session.getDependencyGraphTransformer() );
178 setFileTransformerManager( session.getFileTransformerManager() );
179 setData( session.getData() );
180 setCache( session.getCache() );
181 }
182
183 @Override
184 public boolean isOffline()
185 {
186 return offline;
187 }
188
189
190
191
192
193
194
195
196 public DefaultRepositorySystemSession setOffline( boolean offline )
197 {
198 verifyStateForMutation();
199 this.offline = offline;
200 return this;
201 }
202
203 @Override
204 public boolean isIgnoreArtifactDescriptorRepositories()
205 {
206 return ignoreArtifactDescriptorRepositories;
207 }
208
209
210
211
212
213
214
215
216
217
218 public DefaultRepositorySystemSession setIgnoreArtifactDescriptorRepositories(
219 boolean ignoreArtifactDescriptorRepositories )
220 {
221 verifyStateForMutation();
222 this.ignoreArtifactDescriptorRepositories = ignoreArtifactDescriptorRepositories;
223 return this;
224 }
225
226 @Override
227 public ResolutionErrorPolicy getResolutionErrorPolicy()
228 {
229 return resolutionErrorPolicy;
230 }
231
232
233
234
235
236
237
238
239 public DefaultRepositorySystemSession setResolutionErrorPolicy( ResolutionErrorPolicy resolutionErrorPolicy )
240 {
241 verifyStateForMutation();
242 this.resolutionErrorPolicy = resolutionErrorPolicy;
243 return this;
244 }
245
246 @Override
247 public ArtifactDescriptorPolicy getArtifactDescriptorPolicy()
248 {
249 return artifactDescriptorPolicy;
250 }
251
252
253
254
255
256
257
258
259 public DefaultRepositorySystemSession setArtifactDescriptorPolicy(
260 ArtifactDescriptorPolicy artifactDescriptorPolicy )
261 {
262 verifyStateForMutation();
263 this.artifactDescriptorPolicy = artifactDescriptorPolicy;
264 return this;
265 }
266
267 @Override
268 public String getChecksumPolicy()
269 {
270 return checksumPolicy;
271 }
272
273
274
275
276
277
278
279
280
281
282
283 public DefaultRepositorySystemSession setChecksumPolicy( String checksumPolicy )
284 {
285 verifyStateForMutation();
286 this.checksumPolicy = checksumPolicy;
287 return this;
288 }
289
290 @Override
291 public String getUpdatePolicy()
292 {
293 return updatePolicy;
294 }
295
296
297
298
299
300
301
302
303
304
305
306 public DefaultRepositorySystemSession setUpdatePolicy( String updatePolicy )
307 {
308 verifyStateForMutation();
309 this.updatePolicy = updatePolicy;
310 return this;
311 }
312
313 @Override
314 public LocalRepository getLocalRepository()
315 {
316 LocalRepositoryManager lrm = getLocalRepositoryManager();
317 return ( lrm != null ) ? lrm.getRepository() : null;
318 }
319
320 public LocalRepositoryManager getLocalRepositoryManager()
321 {
322 return localRepositoryManager;
323 }
324
325
326
327
328
329
330
331
332 public DefaultRepositorySystemSession setLocalRepositoryManager( LocalRepositoryManager localRepositoryManager )
333 {
334 verifyStateForMutation();
335 this.localRepositoryManager = localRepositoryManager;
336 return this;
337 }
338
339 @Override
340 public FileTransformerManager getFileTransformerManager()
341 {
342 return fileTransformerManager;
343 }
344
345 public DefaultRepositorySystemSession setFileTransformerManager( FileTransformerManager fileTransformerManager )
346 {
347 verifyStateForMutation();
348 this.fileTransformerManager = fileTransformerManager;
349 if ( this.fileTransformerManager == null )
350 {
351 this.fileTransformerManager = NullFileTransformerManager.INSTANCE;
352 }
353 return this;
354 }
355
356 @Override
357 public WorkspaceReader getWorkspaceReader()
358 {
359 return workspaceReader;
360 }
361
362
363
364
365
366
367
368
369 public DefaultRepositorySystemSession setWorkspaceReader( WorkspaceReader workspaceReader )
370 {
371 verifyStateForMutation();
372 this.workspaceReader = workspaceReader;
373 return this;
374 }
375
376 @Override
377 public RepositoryListener getRepositoryListener()
378 {
379 return repositoryListener;
380 }
381
382
383
384
385
386
387
388 public DefaultRepositorySystemSession setRepositoryListener( RepositoryListener repositoryListener )
389 {
390 verifyStateForMutation();
391 this.repositoryListener = repositoryListener;
392 return this;
393 }
394
395 @Override
396 public TransferListener getTransferListener()
397 {
398 return transferListener;
399 }
400
401
402
403
404
405
406
407 public DefaultRepositorySystemSession setTransferListener( TransferListener transferListener )
408 {
409 verifyStateForMutation();
410 this.transferListener = transferListener;
411 return this;
412 }
413
414 @SuppressWarnings( "checkstyle:magicnumber" )
415 private <T> Map<String, T> copySafe( Map<?, ?> table, Class<T> valueType )
416 {
417 Map<String, T> map;
418 if ( table == null || table.isEmpty() )
419 {
420 map = new HashMap<>();
421 }
422 else
423 {
424 map = new HashMap<>( (int) ( table.size() / 0.75f ) + 1 );
425 for ( Map.Entry<?, ?> entry : table.entrySet() )
426 {
427 Object key = entry.getKey();
428 if ( key instanceof String )
429 {
430 Object value = entry.getValue();
431 if ( valueType.isInstance( value ) )
432 {
433 map.put( key.toString(), valueType.cast( value ) );
434 }
435 }
436 }
437 }
438 return map;
439 }
440
441 @Override
442 public Map<String, String> getSystemProperties()
443 {
444 return systemPropertiesView;
445 }
446
447
448
449
450
451
452
453
454
455
456
457 public DefaultRepositorySystemSession setSystemProperties( Map<?, ?> systemProperties )
458 {
459 verifyStateForMutation();
460 this.systemProperties = copySafe( systemProperties, String.class );
461 systemPropertiesView = Collections.unmodifiableMap( this.systemProperties );
462 return this;
463 }
464
465
466
467
468
469
470
471
472 public DefaultRepositorySystemSession setSystemProperty( String key, String value )
473 {
474 verifyStateForMutation();
475 if ( value != null )
476 {
477 systemProperties.put( key, value );
478 }
479 else
480 {
481 systemProperties.remove( key );
482 }
483 return this;
484 }
485
486 @Override
487 public Map<String, String> getUserProperties()
488 {
489 return userPropertiesView;
490 }
491
492
493
494
495
496
497
498
499
500
501
502
503 public DefaultRepositorySystemSession setUserProperties( Map<?, ?> userProperties )
504 {
505 verifyStateForMutation();
506 this.userProperties = copySafe( userProperties, String.class );
507 userPropertiesView = Collections.unmodifiableMap( this.userProperties );
508 return this;
509 }
510
511
512
513
514
515
516
517
518 public DefaultRepositorySystemSession setUserProperty( String key, String value )
519 {
520 verifyStateForMutation();
521 if ( value != null )
522 {
523 userProperties.put( key, value );
524 }
525 else
526 {
527 userProperties.remove( key );
528 }
529 return this;
530 }
531
532 @Override
533 public Map<String, Object> getConfigProperties()
534 {
535 return configPropertiesView;
536 }
537
538
539
540
541
542
543
544
545
546
547
548 public DefaultRepositorySystemSession setConfigProperties( Map<?, ?> configProperties )
549 {
550 verifyStateForMutation();
551 this.configProperties = copySafe( configProperties, Object.class );
552 configPropertiesView = Collections.unmodifiableMap( this.configProperties );
553 return this;
554 }
555
556
557
558
559
560
561
562
563 public DefaultRepositorySystemSession setConfigProperty( String key, Object value )
564 {
565 verifyStateForMutation();
566 if ( value != null )
567 {
568 configProperties.put( key, value );
569 }
570 else
571 {
572 configProperties.remove( key );
573 }
574 return this;
575 }
576
577 @Override
578 public MirrorSelector getMirrorSelector()
579 {
580 return mirrorSelector;
581 }
582
583
584
585
586
587
588
589
590
591 public DefaultRepositorySystemSession setMirrorSelector( MirrorSelector mirrorSelector )
592 {
593 verifyStateForMutation();
594 this.mirrorSelector = mirrorSelector;
595 if ( this.mirrorSelector == null )
596 {
597 this.mirrorSelector = NullMirrorSelector.INSTANCE;
598 }
599 return this;
600 }
601
602 @Override
603 public ProxySelector getProxySelector()
604 {
605 return proxySelector;
606 }
607
608
609
610
611
612
613
614
615
616
617 public DefaultRepositorySystemSession setProxySelector( ProxySelector proxySelector )
618 {
619 verifyStateForMutation();
620 this.proxySelector = proxySelector;
621 if ( this.proxySelector == null )
622 {
623 this.proxySelector = NullProxySelector.INSTANCE;
624 }
625 return this;
626 }
627
628 @Override
629 public AuthenticationSelector getAuthenticationSelector()
630 {
631 return authenticationSelector;
632 }
633
634
635
636
637
638
639
640
641
642
643 public DefaultRepositorySystemSession setAuthenticationSelector( AuthenticationSelector authenticationSelector )
644 {
645 verifyStateForMutation();
646 this.authenticationSelector = authenticationSelector;
647 if ( this.authenticationSelector == null )
648 {
649 this.authenticationSelector = NullAuthenticationSelector.INSTANCE;
650 }
651 return this;
652 }
653
654 @Override
655 public ArtifactTypeRegistry getArtifactTypeRegistry()
656 {
657 return artifactTypeRegistry;
658 }
659
660
661
662
663
664
665
666 public DefaultRepositorySystemSession setArtifactTypeRegistry( ArtifactTypeRegistry artifactTypeRegistry )
667 {
668 verifyStateForMutation();
669 this.artifactTypeRegistry = artifactTypeRegistry;
670 if ( this.artifactTypeRegistry == null )
671 {
672 this.artifactTypeRegistry = NullArtifactTypeRegistry.INSTANCE;
673 }
674 return this;
675 }
676
677 @Override
678 public DependencyTraverser getDependencyTraverser()
679 {
680 return dependencyTraverser;
681 }
682
683
684
685
686
687
688
689 public DefaultRepositorySystemSession setDependencyTraverser( DependencyTraverser dependencyTraverser )
690 {
691 verifyStateForMutation();
692 this.dependencyTraverser = dependencyTraverser;
693 return this;
694 }
695
696 @Override
697 public DependencyManager getDependencyManager()
698 {
699 return dependencyManager;
700 }
701
702
703
704
705
706
707
708 public DefaultRepositorySystemSession setDependencyManager( DependencyManager dependencyManager )
709 {
710 verifyStateForMutation();
711 this.dependencyManager = dependencyManager;
712 return this;
713 }
714
715 @Override
716 public DependencySelector getDependencySelector()
717 {
718 return dependencySelector;
719 }
720
721
722
723
724
725
726
727 public DefaultRepositorySystemSession setDependencySelector( DependencySelector dependencySelector )
728 {
729 verifyStateForMutation();
730 this.dependencySelector = dependencySelector;
731 return this;
732 }
733
734 @Override
735 public VersionFilter getVersionFilter()
736 {
737 return versionFilter;
738 }
739
740
741
742
743
744
745
746
747 public DefaultRepositorySystemSession setVersionFilter( VersionFilter versionFilter )
748 {
749 verifyStateForMutation();
750 this.versionFilter = versionFilter;
751 return this;
752 }
753
754 @Override
755 public DependencyGraphTransformer getDependencyGraphTransformer()
756 {
757 return dependencyGraphTransformer;
758 }
759
760
761
762
763
764
765
766
767 public DefaultRepositorySystemSession setDependencyGraphTransformer(
768 DependencyGraphTransformer dependencyGraphTransformer )
769 {
770 verifyStateForMutation();
771 this.dependencyGraphTransformer = dependencyGraphTransformer;
772 return this;
773 }
774
775 @Override
776 public SessionData getData()
777 {
778 return data;
779 }
780
781
782
783
784
785
786
787 public DefaultRepositorySystemSession setData( SessionData data )
788 {
789 verifyStateForMutation();
790 this.data = data;
791 if ( this.data == null )
792 {
793 this.data = new DefaultSessionData();
794 }
795 return this;
796 }
797
798 @Override
799 public RepositoryCache getCache()
800 {
801 return cache;
802 }
803
804
805
806
807
808
809
810 public DefaultRepositorySystemSession setCache( RepositoryCache cache )
811 {
812 verifyStateForMutation();
813 this.cache = cache;
814 return this;
815 }
816
817
818
819
820
821
822 public void setReadOnly()
823 {
824 readOnly = true;
825 }
826
827
828
829
830 private void verifyStateForMutation()
831 {
832 if ( readOnly )
833 {
834 throw new IllegalStateException( "repository system session is read-only" );
835 }
836 }
837
838 static class NullProxySelector
839 implements ProxySelector
840 {
841
842 public static final ProxySelector INSTANCE = new NullProxySelector();
843
844 public Proxy getProxy( RemoteRepository repository )
845 {
846 requireNonNull( repository, "repository cannot be null" );
847 return repository.getProxy();
848 }
849
850 }
851
852 static class NullMirrorSelector
853 implements MirrorSelector
854 {
855
856 public static final MirrorSelector INSTANCE = new NullMirrorSelector();
857
858 public RemoteRepository getMirror( RemoteRepository repository )
859 {
860 requireNonNull( repository, "repository cannot be null" );
861 return null;
862 }
863
864 }
865
866 static class NullAuthenticationSelector
867 implements AuthenticationSelector
868 {
869
870 public static final AuthenticationSelector INSTANCE = new NullAuthenticationSelector();
871
872 public Authentication getAuthentication( RemoteRepository repository )
873 {
874 requireNonNull( repository, "repository cannot be null" );
875 return repository.getAuthentication();
876 }
877
878 }
879
880 static final class NullArtifactTypeRegistry
881 implements ArtifactTypeRegistry
882 {
883
884 public static final ArtifactTypeRegistry INSTANCE = new NullArtifactTypeRegistry();
885
886 public ArtifactType get( String typeId )
887 {
888 return null;
889 }
890
891 }
892
893 static final class NullFileTransformerManager implements FileTransformerManager
894 {
895 public static final FileTransformerManager INSTANCE = new NullFileTransformerManager();
896
897 @Override
898 public Collection<FileTransformer> getTransformersForArtifact( Artifact artifact )
899 {
900 return Collections.emptyList();
901 }
902 }
903 }