View Javadoc
1   package org.codehaus.plexus.languages.java.jpms;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
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   * Maps artifacts to modules and analyzes the type of required modules
43   *
44   * @author Robert Scholte
45   * @since 1.0.0
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       * @param descriptorPath never {@code null}
66       * @return the parsed module descriptor
67       * @throws IOException when descriptorPath could not be read
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       * @param descriptorPath never {@code null}
83       * @return the parsed module descriptor
84       * @throws IOException when descriptorPath could not be read
85       */
86      public ResolvePathResult parseModuleDescriptor(File descriptorPath) throws IOException {
87          return parseModuleDescriptor(descriptorPath.toPath());
88      }
89  
90      /**
91       * @param descriptorPath never {@code null}
92       * @return the parsed module descriptor
93       * @throws IOException when descriptorPath could not be read
94       */
95      public ResolvePathResult parseModuleDescriptor(String descriptorPath) throws IOException {
96          return parseModuleDescriptor(Paths.get(descriptorPath));
97      }
98  
99      /**
100      * Resolve a single jar
101      *
102      * @param request the request
103      * @return the {@link ResolvePathResult}, containing the name and optional module descriptor
104      * @throws IOException if any occurs
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      * Decide for every {@code request.getPathElements()} if it belongs to the modulePath or classPath, based on the
131      * {@code request.getMainModuleDescriptor()}.
132      *
133      * @param request the paths to resolve
134      * @return the result of the resolution
135      * @throws IOException if a critical IOException occurs
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         // key = service, value = names of modules that provide this service
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         // collect all modules from path
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             // in case of identical module names, first one wins
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                 // Consider strategies how to handle duplicate modules by name
257                 // For now only add first on modulePath, just ignore others,
258                 //   This has effectively the same result as putting it on the modulePath, but might better help
259                 // analyzing issues.
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      * If the jdkHome is specified, its version it considered higher than the runtime java version.
282      * In that case the version-agnostic {@link ModuleInfoClassParser} must be used to read the module
283      * descriptor, since the runtime's own {@code java.lang.module.ModuleDescriptor} cannot be trusted
284      * to read a module-info.class produced by a newer JDK than the one it runs on.
285      *
286      * @param jdkHome
287      * @return
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         // either jar or outputDirectory
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             // includeTransitive is one level deeper compared to includeStatic
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             // module-info.class uses FQN, i.e. $-separator for subclasses
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 }