1 /*
2 * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.internal.module;
27
28 import java.io.File;
29 import java.io.IOError;
30 import java.io.IOException;
31 import java.io.InputStream;
32 import java.io.UncheckedIOException;
33 import java.lang.module.ModuleReader;
34 import java.lang.module.ModuleReference;
35 import java.net.URI;
36 import java.nio.ByteBuffer;
37 import java.nio.file.Files;
38 import java.nio.file.Path;
39 import java.util.List;
40 import java.util.Objects;
41 import java.util.Optional;
42 import java.util.concurrent.locks.Lock;
43 import java.util.concurrent.locks.ReadWriteLock;
44 import java.util.concurrent.locks.ReentrantReadWriteLock;
45 import java.util.function.Supplier;
46 import java.util.jar.JarEntry;
47 import java.util.jar.JarFile;
48 import java.util.stream.Collectors;
49 import java.util.stream.Stream;
50 import java.util.zip.ZipFile;
51
52 import jdk.internal.jmod.JmodFile;
53 import jdk.internal.module.ModuleHashes.HashSupplier;
54 import sun.net.www.ParseUtil;
55
56
57 /**
58 * A factory for creating ModuleReference implementations where the modules are
59 * packaged as modular JAR file, JMOD files or where the modules are exploded
60 * on the file system.
61 */
62
63 class ModuleReferences {
64 private ModuleReferences() { }
65
66 /**
67 * Creates a ModuleReference to a possibly-patched module
68 */
69 private static ModuleReference newModule(ModuleInfo.Attributes attrs,
70 URI uri,
71 Supplier<ModuleReader> supplier,
72 ModulePatcher patcher,
73 HashSupplier hasher) {
74 ModuleReference mref = new ModuleReferenceImpl(attrs.descriptor(),
75 uri,
76 supplier,
77 null,
78 attrs.target(),
79 attrs.recordedHashes(),
80 hasher,
81 attrs.moduleResolution());
82 if (patcher != null)
83 mref = patcher.patchIfNeeded(mref);
84
85 return mref;
86 }
87
88 /**
89 * Creates a ModuleReference to a possibly-patched module in a modular JAR.
90 */
91 static ModuleReference newJarModule(ModuleInfo.Attributes attrs,
92 ModulePatcher patcher,
93 Path file) {
94 URI uri = file.toUri();
95 Supplier<ModuleReader> supplier = () -> new JarModuleReader(file, uri);
96 HashSupplier hasher = (a) -> ModuleHashes.computeHash(file, a);
97 return newModule(attrs, uri, supplier, patcher, hasher);
98 }
99
100 /**
101 * Creates a ModuleReference to a module in a JMOD file.
102 */
103 static ModuleReference newJModModule(ModuleInfo.Attributes attrs, Path file) {
104 URI uri = file.toUri();
105 Supplier<ModuleReader> supplier = () -> new JModModuleReader(file, uri);
106 HashSupplier hasher = (a) -> ModuleHashes.computeHash(file, a);
107 return newModule(attrs, uri, supplier, null, hasher);
108 }
109
110 /**
111 * Creates a ModuleReference to a possibly-patched exploded module.
112 */
113 static ModuleReference newExplodedModule(ModuleInfo.Attributes attrs,
114 ModulePatcher patcher,
115 Path dir) {
116 Supplier<ModuleReader> supplier = () -> new ExplodedModuleReader(dir);
117 return newModule(attrs, dir.toUri(), supplier, patcher, null);
118 }
119
120
121 /**
122 * A base module reader that encapsulates machinery required to close the
123 * module reader safely.
124 */
125 static abstract class SafeCloseModuleReader implements ModuleReader {
126
127 // RW lock to support safe close
128 private final ReadWriteLock lock = new ReentrantReadWriteLock();
129 private final Lock readLock = lock.readLock();
130 private final Lock writeLock = lock.writeLock();
131 private boolean closed;
132
133 SafeCloseModuleReader() { }
134
135 /**
136 * Returns a URL to resource. This method is invoked by the find
137 * method to do the actual work of finding the resource.
138 */
139 abstract Optional<URI> implFind(String name) throws IOException;
140
141 /**
142 * Returns an input stream for reading a resource. This method is
143 * invoked by the open method to do the actual work of opening
144 * an input stream to the resource.
145 */
146 abstract Optional<InputStream> implOpen(String name) throws IOException;
147
148 /**
149 * Returns a stream of the names of resources in the module. This
150 * method is invoked by the list method to do the actual work of
151 * creating the stream.
152 */
153 abstract Stream<String> implList() throws IOException;
154
155 /**
156 * Closes the module reader. This method is invoked by close to do the
157 * actual work of closing the module reader.
158 */
159 abstract void implClose() throws IOException;
160
161 @Override
162 public final Optional<URI> find(String name) throws IOException {
163 readLock.lock();
164 try {
165 if (!closed) {
166 return implFind(name);
167 } else {
168 throw new IOException("ModuleReader is closed");
169 }
170 } finally {
171 readLock.unlock();
172 }
173 }
174
175
176 @Override
177 public final Optional<InputStream> open(String name) throws IOException {
178 readLock.lock();
179 try {
180 if (!closed) {
181 return implOpen(name);
182 } else {
183 throw new IOException("ModuleReader is closed");
184 }
185 } finally {
186 readLock.unlock();
187 }
188 }
189
190 @Override
191 public final Stream<String> list() throws IOException {
192 readLock.lock();
193 try {
194 if (!closed) {
195 return implList();
196 } else {
197 throw new IOException("ModuleReader is closed");
198 }
199 } finally {
200 readLock.unlock();
201 }
202 }
203
204 @Override
205 public final void close() throws IOException {
206 writeLock.lock();
207 try {
208 if (!closed) {
209 closed = true;
210 implClose();
211 }
212 } finally {
213 writeLock.unlock();
214 }
215 }
216 }
217
218
219 /**
220 * A ModuleReader for a modular JAR file.
221 */
222 static class JarModuleReader extends SafeCloseModuleReader {
223 private final JarFile jf;
224 private final URI uri;
225
226 static JarFile newJarFile(Path path) {
227 try {
228 return new JarFile(new File(path.toString()),
229 true, // verify
230 ZipFile.OPEN_READ,
231 JarFile.runtimeVersion());
232 } catch (IOException ioe) {
233 throw new UncheckedIOException(ioe);
234 }
235 }
236
237 JarModuleReader(Path path, URI uri) {
238 this.jf = newJarFile(path);
239 this.uri = uri;
240 }
241
242 private JarEntry getEntry(String name) {
243 return jf.getJarEntry(Objects.requireNonNull(name));
244 }
245
246 @Override
247 Optional<URI> implFind(String name) throws IOException {
248 JarEntry je = getEntry(name);
249 if (je != null) {
250 if (jf.isMultiRelease())
251 name = je.getRealName();
252 if (je.isDirectory() && !name.endsWith("/"))
253 name += "/";
254 String encodedPath = ParseUtil.encodePath(name, false);
255 String uris = "jar:" + uri + "!/" + encodedPath;
256 return Optional.of(URI.create(uris));
257 } else {
258 return Optional.empty();
259 }
260 }
261
262 @Override
263 Optional<InputStream> implOpen(String name) throws IOException {
264 JarEntry je = getEntry(name);
265 if (je != null) {
266 return Optional.of(jf.getInputStream(je));
267 } else {
268 return Optional.empty();
269 }
270 }
271
272 @Override
273 Stream<String> implList() throws IOException {
274 // take snapshot to avoid async close
275 List<String> names = jf.versionedStream()
276 .map(JarEntry::getName)
277 .collect(Collectors.toList());
278 return names.stream();
279 }
280
281 @Override
282 void implClose() throws IOException {
283 jf.close();
284 }
285 }
286
287
288 /**
289 * A ModuleReader for a JMOD file.
290 */
291 static class JModModuleReader extends SafeCloseModuleReader {
292 private final JmodFile jf;
293 private final URI uri;
294
295 static JmodFile newJmodFile(Path path) {
296 try {
297 return new JmodFile(path);
298 } catch (IOException ioe) {
299 throw new UncheckedIOException(ioe);
300 }
301 }
302
303 JModModuleReader(Path path, URI uri) {
304 this.jf = newJmodFile(path);
305 this.uri = uri;
306 }
307
308 private JmodFile.Entry getEntry(String name) {
309 Objects.requireNonNull(name);
310 return jf.getEntry(JmodFile.Section.CLASSES, name);
311 }
312
313 @Override
314 Optional<URI> implFind(String name) {
315 JmodFile.Entry je = getEntry(name);
316 if (je != null) {
317 if (je.isDirectory() && !name.endsWith("/"))
318 name += "/";
319 String encodedPath = ParseUtil.encodePath(name, false);
320 String uris = "jmod:" + uri + "!/" + encodedPath;
321 return Optional.of(URI.create(uris));
322 } else {
323 return Optional.empty();
324 }
325 }
326
327 @Override
328 Optional<InputStream> implOpen(String name) throws IOException {
329 JmodFile.Entry je = getEntry(name);
330 if (je != null) {
331 return Optional.of(jf.getInputStream(je));
332 } else {
333 return Optional.empty();
334 }
335 }
336
337 @Override
338 Stream<String> implList() throws IOException {
339 // take snapshot to avoid async close
340 List<String> names = jf.stream()
341 .filter(e -> e.section() == JmodFile.Section.CLASSES)
342 .map(JmodFile.Entry::name)
343 .collect(Collectors.toList());
344 return names.stream();
345 }
346
347 @Override
348 void implClose() throws IOException {
349 jf.close();
350 }
351 }
352
353
354 /**
355 * A ModuleReader for an exploded module.
356 */
357 static class ExplodedModuleReader implements ModuleReader {
358 private final Path dir;
359 private volatile boolean closed;
360
361 ExplodedModuleReader(Path dir) {
362 this.dir = dir;
363
364 // when running with a security manager then check that the caller
365 // has access to the directory.
366 SecurityManager sm = System.getSecurityManager();
367 if (sm != null) {
368 boolean unused = Files.isDirectory(dir);
369 }
370 }
371
372 /**
373 * Throws IOException if the module reader is closed;
374 */
375 private void ensureOpen() throws IOException {
376 if (closed) throw new IOException("ModuleReader is closed");
377 }
378
379 @Override
380 public Optional<URI> find(String name) throws IOException {
381 ensureOpen();
382 Path path = Resources.toFilePath(dir, name);
383 if (path != null) {
384 try {
385 return Optional.of(path.toUri());
386 } catch (IOError e) {
387 throw (IOException) e.getCause();
388 }
389 } else {
390 return Optional.empty();
391 }
392 }
393
394 @Override
395 public Optional<InputStream> open(String name) throws IOException {
396 ensureOpen();
397 Path path = Resources.toFilePath(dir, name);
398 if (path != null) {
399 return Optional.of(Files.newInputStream(path));
400 } else {
401 return Optional.empty();
402 }
403 }
404
405 @Override
406 public Optional<ByteBuffer> read(String name) throws IOException {
407 ensureOpen();
408 Path path = Resources.toFilePath(dir, name);
409 if (path != null) {
410 return Optional.of(ByteBuffer.wrap(Files.readAllBytes(path)));
411 } else {
412 return Optional.empty();
413 }
414 }
415
416 @Override
417 public Stream<String> list() throws IOException {
418 ensureOpen();
419 return Files.walk(dir, Integer.MAX_VALUE)
420 .map(f -> Resources.toResourceName(dir, f))
421 .filter(s -> s.length() > 0);
422 }
423
424 @Override
425 public void close() {
426 closed = true;
427 }
428 }
429
430 }