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