1 package org.eclipse.aether.internal.impl.filter;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import javax.inject.Inject;
23 import javax.inject.Named;
24 import javax.inject.Singleton;
25
26 import java.util.Collections;
27 import java.util.HashMap;
28 import java.util.Map;
29 import java.util.stream.Collectors;
30
31 import org.eclipse.aether.RepositorySystemSession;
32 import org.eclipse.aether.artifact.Artifact;
33 import org.eclipse.aether.impl.RemoteRepositoryFilterManager;
34 import org.eclipse.aether.metadata.Metadata;
35 import org.eclipse.aether.repository.RemoteRepository;
36 import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilter;
37 import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
38
39 import static java.util.Objects.requireNonNull;
40
41
42
43
44
45
46
47
48
49 @Singleton
50 @Named
51 public final class DefaultRemoteRepositoryFilterManager
52 implements RemoteRepositoryFilterManager
53 {
54 private static final String INSTANCE_KEY = DefaultRemoteRepositoryFilterManager.class.getName() + ".instance";
55
56 private final Map<String, RemoteRepositoryFilterSource> sources;
57
58
59
60
61
62
63 @Deprecated
64 public DefaultRemoteRepositoryFilterManager()
65 {
66 this.sources = new HashMap<>();
67 }
68
69 @Inject
70 public DefaultRemoteRepositoryFilterManager( Map<String, RemoteRepositoryFilterSource> sources )
71 {
72 this.sources = requireNonNull( sources );
73 }
74
75 @Override
76 public RemoteRepositoryFilter getRemoteRepositoryFilter( RepositorySystemSession session )
77 {
78 return (RemoteRepositoryFilter) session.getData().computeIfAbsent( INSTANCE_KEY, () ->
79 {
80 HashMap<String, RemoteRepositoryFilter> filters = new HashMap<>();
81 for ( Map.Entry<String, RemoteRepositoryFilterSource> entry : sources.entrySet() )
82 {
83 RemoteRepositoryFilter filter = entry.getValue().getRemoteRepositoryFilter( session );
84 if ( filter != null )
85 {
86 filters.put( entry.getKey(), filter );
87 }
88 }
89 if ( !filters.isEmpty() )
90 {
91 return new Participants( filters );
92 }
93 else
94 {
95 return null;
96 }
97 }
98 );
99 }
100
101
102
103
104
105 private static class Participants implements RemoteRepositoryFilter
106 {
107 private final Map<String, RemoteRepositoryFilter> participants;
108
109 private Participants( Map<String, RemoteRepositoryFilter> participants )
110 {
111 this.participants = Collections.unmodifiableMap( participants );
112 }
113
114 @Override
115 public RemoteRepositoryFilter.Result acceptArtifact( RemoteRepository remoteRepository, Artifact artifact )
116 {
117 return new Consensus( participants.entrySet().stream()
118 .collect( Collectors.toMap(
119 Map.Entry::getKey,
120 e -> e.getValue().acceptArtifact( remoteRepository, artifact ) ) ) );
121 }
122
123 @Override
124 public RemoteRepositoryFilter.Result acceptMetadata( RemoteRepository remoteRepository, Metadata metadata )
125 {
126 return new Consensus( participants.entrySet().stream()
127 .collect( Collectors.toMap(
128 Map.Entry::getKey,
129 e -> e.getValue().acceptMetadata( remoteRepository, metadata ) ) ) );
130 }
131 }
132
133
134
135
136
137 private static class Consensus implements RemoteRepositoryFilter.Result
138 {
139 private final boolean accepted;
140
141 private final String reasoning;
142
143 Consensus( Map<String, RemoteRepositoryFilter.Result> results )
144 {
145 this.accepted = results.values().stream().allMatch( RemoteRepositoryFilter.Result::isAccepted );
146 this.reasoning = results.values().stream().filter( r -> !r.isAccepted() ).map(
147 RemoteRepositoryFilter.Result::reasoning ).collect(
148 Collectors.joining( "; " ) );
149 }
150
151 @Override
152 public boolean isAccepted()
153 {
154 return accepted;
155 }
156
157 @Override
158 public String reasoning()
159 {
160 return reasoning;
161 }
162 }
163 }