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