1 package org.codehaus.plexus.languages.java.jpms;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import javax.inject.Named;
23 import javax.inject.Singleton;
24
25 import java.io.File;
26 import java.io.IOException;
27 import java.nio.file.Files;
28 import java.nio.file.Path;
29 import java.nio.file.Paths;
30 import java.util.Collections;
31 import java.util.HashMap;
32 import java.util.HashSet;
33 import java.util.LinkedHashMap;
34 import java.util.Map;
35 import java.util.Map.Entry;
36 import java.util.Set;
37
38 import org.codehaus.plexus.languages.java.jpms.JavaModuleDescriptor.JavaProvides;
39 import org.codehaus.plexus.languages.java.version.JavaVersion;
40
41
42
43
44
45
46
47 @Named
48 @Singleton
49 public class LocationManager {
50 private SourceModuleInfoParser sourceParser;
51
52 private ManifestModuleNameExtractor manifestModuleNameExtractor;
53
54 public LocationManager() {
55 this.sourceParser = new SourceModuleInfoParser();
56 this.manifestModuleNameExtractor = new ManifestModuleNameExtractor();
57 }
58
59 LocationManager(SourceModuleInfoParser sourceParser) {
60 this.sourceParser = sourceParser;
61 this.manifestModuleNameExtractor = new ManifestModuleNameExtractor();
62 }
63
64
65
66
67
68
69 public ResolvePathResult parseModuleDescriptor(Path descriptorPath) throws IOException {
70 JavaModuleDescriptor moduleDescriptor;
71 if (descriptorPath.endsWith("module-info.java")) {
72 moduleDescriptor = sourceParser.fromSourcePath(descriptorPath);
73 } else {
74 throw new IOException("Invalid path to module descriptor: " + descriptorPath);
75 }
76 return new ResolvePathResult()
77 .setModuleDescriptor(moduleDescriptor)
78 .setModuleNameSource(ModuleNameSource.MODULEDESCRIPTOR);
79 }
80
81
82
83
84
85
86 public ResolvePathResult parseModuleDescriptor(File descriptorPath) throws IOException {
87 return parseModuleDescriptor(descriptorPath.toPath());
88 }
89
90
91
92
93
94
95 public ResolvePathResult parseModuleDescriptor(String descriptorPath) throws IOException {
96 return parseModuleDescriptor(Paths.get(descriptorPath));
97 }
98
99
100
101
102
103
104
105
106 public <T> ResolvePathResult resolvePath(final ResolvePathRequest<T> request) throws IOException {
107 ModuleNameExtractor filenameExtractor = new ModuleNameExtractor() {
108 MainClassModuleNameExtractor extractor = new MainClassModuleNameExtractor(request.getJdkHome());
109
110 @Override
111 public String extract(Path file) throws IOException {
112 if (request.getJdkHome() != null) {
113 return extractor
114 .extract(Collections.singletonMap(file, file))
115 .get(file);
116 } else {
117 return CmdModuleNameExtractor.getModuleName(file);
118 }
119 }
120 };
121
122 return resolvePath(
123 request.toPath(request.getPathElement()),
124 filenameExtractor,
125 getBinaryModuleInfoParser(request.getJdkHome()),
126 request.getTargetRelease());
127 }
128
129
130
131
132
133
134
135
136
137 public <T> ResolvePathsResult<T> resolvePaths(final ResolvePathsRequest<T> request) throws IOException {
138 final ResolvePathsResult<T> result = request.createResult();
139
140 Map<T, JavaModuleDescriptor> pathElements =
141 new LinkedHashMap<>(request.getPathElements().size());
142
143 final ModuleInfoParser binaryParser = getBinaryModuleInfoParser(request.getJdkHome());
144
145 JavaModuleDescriptor mainModuleDescriptor = getMainModuleDescriptor(request, binaryParser);
146
147 result.setMainModuleDescriptor(mainModuleDescriptor);
148
149
150 Map<String, Set<String>> availableProviders = new HashMap<>();
151
152 if (mainModuleDescriptor != null && request.isIncludeAllProviders()) {
153 collectProviders(mainModuleDescriptor, availableProviders);
154 }
155
156 Map<String, JavaModuleDescriptor> availableNamedModules = new HashMap<>();
157
158 Map<String, ModuleNameSource> moduleNameSources = new HashMap<>();
159
160 final Map<T, Path> filenameAutoModules = new HashMap<>();
161
162
163 for (final T t : request.getPathElements()) {
164 JavaModuleDescriptor moduleDescriptor;
165 ModuleNameSource source;
166
167 ModuleNameExtractor nameExtractor = path -> {
168 if (request.getJdkHome() != null) {
169 filenameAutoModules.put(t, path);
170 } else {
171 return CmdModuleNameExtractor.getModuleName(path);
172 }
173 return null;
174 };
175
176 try {
177 ResolvePathResult resolvedPath =
178 resolvePath(request.toPath(t), nameExtractor, binaryParser, request.getTargetRelease());
179
180 moduleDescriptor = resolvedPath.getModuleDescriptor();
181
182 source = resolvedPath.getModuleNameSource();
183 } catch (Exception e) {
184 result.getPathExceptions().put(t, e);
185
186 pathElements.put(t, null);
187
188 continue;
189 }
190
191
192 if (moduleDescriptor != null && moduleNameSources.putIfAbsent(moduleDescriptor.name(), source) == null) {
193 availableNamedModules.put(moduleDescriptor.name(), moduleDescriptor);
194
195 if (request.isIncludeAllProviders()) {
196 collectProviders(moduleDescriptor, availableProviders);
197 }
198 }
199
200 pathElements.put(t, moduleDescriptor);
201 }
202 result.setPathElements(pathElements);
203
204 if (!filenameAutoModules.isEmpty()) {
205 MainClassModuleNameExtractor extractor = new MainClassModuleNameExtractor(request.getJdkHome());
206
207 Map<T, String> automodules = extractor.extract(filenameAutoModules);
208
209 for (Map.Entry<T, String> entry : automodules.entrySet()) {
210 String moduleName = entry.getValue();
211
212 if (moduleName != null) {
213 JavaModuleDescriptor moduleDescriptor =
214 JavaModuleDescriptor.newAutomaticModule(moduleName).build();
215
216 moduleNameSources.put(moduleDescriptor.name(), ModuleNameSource.FILENAME);
217
218 availableNamedModules.put(moduleDescriptor.name(), moduleDescriptor);
219
220 pathElements.put(entry.getKey(), moduleDescriptor);
221 }
222 }
223 }
224
225 Set<String> requiredNamedModules = new HashSet<>();
226
227 if (mainModuleDescriptor != null) {
228 requiredNamedModules.add(mainModuleDescriptor.name());
229
230 selectRequires(
231 mainModuleDescriptor,
232 Collections.unmodifiableMap(availableNamedModules),
233 Collections.unmodifiableMap(availableProviders),
234 requiredNamedModules,
235 true,
236 true,
237 request.isIncludeStatic());
238 }
239
240 for (String additionalModule : request.getAdditionalModules()) {
241 selectModule(
242 additionalModule,
243 Collections.unmodifiableMap(availableNamedModules),
244 Collections.unmodifiableMap(availableProviders),
245 requiredNamedModules,
246 true,
247 true,
248 request.isIncludeStatic());
249 }
250
251 Set<String> collectedModules = new HashSet<>(requiredNamedModules.size());
252
253 for (Entry<T, JavaModuleDescriptor> entry : pathElements.entrySet()) {
254 if (entry.getValue() != null
255 && requiredNamedModules.contains(entry.getValue().name())) {
256
257
258
259
260 if (collectedModules.add(entry.getValue().name())) {
261 result.getModulepathElements()
262 .put(
263 entry.getKey(),
264 moduleNameSources.get(entry.getValue().name()));
265 } else {
266 result.getPathExceptions()
267 .put(
268 entry.getKey(),
269 new IllegalStateException(
270 "Module '" + entry.getValue().name() + "' is already on the module path!"));
271 }
272 } else {
273 result.getClasspathElements().add(entry.getKey());
274 }
275 }
276
277 return result;
278 }
279
280
281
282
283
284
285
286
287
288
289 ModuleInfoParser getBinaryModuleInfoParser(final Path jdkHome) {
290 final ModuleInfoParser binaryParser;
291 if (jdkHome == null) {
292 binaryParser = new BinaryModuleInfoParser();
293 } else {
294 binaryParser = new ModuleInfoClassParser();
295 }
296 return binaryParser;
297 }
298
299 private <T> JavaModuleDescriptor getMainModuleDescriptor(
300 final ResolvePathsRequest<T> request, ModuleInfoParser binaryParser) throws IOException {
301 JavaModuleDescriptor mainModuleDescriptor;
302
303 Path descriptorPath = request.getMainModuleDescriptor();
304
305 if (descriptorPath != null) {
306 if (descriptorPath.endsWith("module-info.java")) {
307 mainModuleDescriptor = sourceParser.fromSourcePath(descriptorPath);
308 } else if (descriptorPath.endsWith("module-info.class")) {
309 mainModuleDescriptor =
310 binaryParser.getModuleDescriptor(descriptorPath.getParent(), request.getTargetRelease());
311 } else {
312 throw new IOException("Invalid path to module descriptor: " + descriptorPath);
313 }
314 } else {
315 mainModuleDescriptor = request.getModuleDescriptor();
316 }
317 return mainModuleDescriptor;
318 }
319
320 private ResolvePathResult resolvePath(
321 Path path,
322 ModuleNameExtractor fileModulenameExtractor,
323 ModuleInfoParser binaryParser,
324 JavaVersion targetRelease)
325 throws IOException {
326 ResolvePathResult result = new ResolvePathResult();
327
328 JavaModuleDescriptor moduleDescriptor = null;
329
330
331 if (Files.isRegularFile(path) && !path.getFileName().toString().endsWith(".jar")) {
332 throw new IllegalArgumentException(
333 "'" + path + "' not allowed on the path, only outputDirectories and jars are accepted");
334 }
335
336 if (Files.isRegularFile(path)
337 || Files.exists(path.resolve("module-info.class"))
338 || AbstractBinaryModuleInfoParser.findVersionedModuleInfo(path, targetRelease) != null) {
339 moduleDescriptor = binaryParser.getModuleDescriptor(path, targetRelease);
340 }
341
342 if (moduleDescriptor != null) {
343 result.setModuleNameSource(ModuleNameSource.MODULEDESCRIPTOR);
344 } else {
345 String moduleName = manifestModuleNameExtractor.extract(path);
346
347 if (moduleName != null) {
348 result.setModuleNameSource(ModuleNameSource.MANIFEST);
349 } else {
350 moduleName = fileModulenameExtractor.extract(path);
351
352 if (moduleName != null) {
353 result.setModuleNameSource(ModuleNameSource.FILENAME);
354 }
355 }
356
357 if (moduleName != null) {
358 moduleDescriptor =
359 JavaModuleDescriptor.newAutomaticModule(moduleName).build();
360 }
361 }
362 result.setModuleDescriptor(moduleDescriptor);
363
364 return result;
365 }
366
367 private void selectRequires(
368 JavaModuleDescriptor module,
369 Map<String, JavaModuleDescriptor> availableModules,
370 Map<String, Set<String>> availableProviders,
371 Set<String> namedModules,
372 boolean isRootModule,
373 boolean includeAsTransitive,
374 boolean includeStatic) {
375 for (JavaModuleDescriptor.JavaRequires requires : module.requires()) {
376
377 if (isRootModule
378 || includeStatic
379 || includeAsTransitive
380 || !requires.modifiers().contains(JavaModuleDescriptor.JavaRequires.JavaModifier.STATIC)
381 || requires.modifiers().contains(JavaModuleDescriptor.JavaRequires.JavaModifier.TRANSITIVE)) {
382 selectModule(
383 requires.name(),
384 availableModules,
385 availableProviders,
386 namedModules,
387 false,
388 includeStatic,
389 includeStatic);
390 }
391 }
392
393 for (String uses : module.uses()) {
394 if (availableProviders.containsKey(uses)) {
395 for (String providerModule : availableProviders.get(uses)) {
396 JavaModuleDescriptor requiredModule = availableModules.get(providerModule);
397
398 if (requiredModule != null && namedModules.add(providerModule)) {
399 selectRequires(
400 requiredModule,
401 availableModules,
402 availableProviders,
403 namedModules,
404 false,
405 includeAsTransitive,
406 includeStatic);
407 }
408 }
409 }
410 }
411 }
412
413 private void selectModule(
414 String module,
415 Map<String, JavaModuleDescriptor> availableModules,
416 Map<String, Set<String>> availableProviders,
417 Set<String> namedModules,
418 boolean isRootModule,
419 boolean includeTransitive,
420 boolean includeStatic) {
421 JavaModuleDescriptor requiredModule = availableModules.get(module);
422
423 if (requiredModule != null && namedModules.add(module)) {
424 selectRequires(
425 requiredModule,
426 availableModules,
427 availableProviders,
428 namedModules,
429 false,
430 includeTransitive,
431 includeStatic);
432 }
433 }
434
435 private void collectProviders(JavaModuleDescriptor moduleDescriptor, Map<String, Set<String>> availableProviders) {
436 for (JavaProvides provides : moduleDescriptor.provides()) {
437
438 final String serviceClassName = provides.service().replace('$', '.');
439
440 Set<String> providingModules = availableProviders.computeIfAbsent(serviceClassName, k -> new HashSet<>());
441
442 providingModules.add(moduleDescriptor.name());
443 }
444 }
445 }