java.nio.file.ProviderNotFoundException Java Examples

The following examples show how to use java.nio.file.ProviderNotFoundException. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
Source Project: update4j   Author: update4j   File: Archive.java    License: Apache License 2.0 8 votes vote down vote up
public FileSystem openConnection() throws IOException {
    if (Files.notExists(getLocation())) {
        // I can't use Map.of("create", "true") since the overload taking a path was only added in JDK 13
        // and using URI overload doesn't support nested zip files
        try (OutputStream out = Files.newOutputStream(getLocation(), StandardOpenOption.CREATE_NEW)) {
            // End of Central Directory Record (EOCD)
            out.write(new byte[] { 0x50, 0x4b, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 });
        }
    }

    try {
        return FileSystems.newFileSystem(getLocation(), (ClassLoader) null);
    } catch (ProviderNotFoundException e) {
        ModuleFinder.ofSystem()
                        .find("jdk.zipfs")
                        .orElseThrow(() -> new ProviderNotFoundException(
                                        "Accessing the archive depends on the jdk.zipfs module which is missing from the JRE image"));

        throw e;
    }
}
 
Example #2
Source Project: openjdk-jdk9   Author: AdoptOpenJDK   File: JarSourceProviderTest.java    License: GNU General Public License v2.0 6 votes vote down vote up
@Test
public void itShouldReturnNullIfNotValidJarProvider() {
    fileSupport = new FakeFileSupport(set(), set()) {

        @Override
        public Path getJarFileSystemRoot(Path jarFile) {
            super.getJarFileSystemRoot(jarFile);
            throw new ProviderNotFoundException();
        }
    };
    fileSupport.setJarFileSystemRoot(null);
    target = new JarSourceProvider(fileSupport);

    ClassSource result = target.findSource("foobar", new FakeSearchPath("foo/bar"));

    Assert.assertEquals(set("foo/bar"), fileSupport.getCheckedJarFileSystemRoots());
    Assert.assertNull(result);
}
 
Example #3
Source Project: openjdk-jdk9   Author: AdoptOpenJDK   File: JavacFileManager.java    License: GNU General Public License v2.0 6 votes vote down vote up
public ArchiveContainer(Path archivePath) throws IOException, ProviderNotFoundException, SecurityException {
    this.archivePath = archivePath;
    if (multiReleaseValue != null && archivePath.toString().endsWith(".jar")) {
        Map<String,String> env = Collections.singletonMap("multi-release", multiReleaseValue);
        FileSystemProvider jarFSProvider = fsInfo.getJarFSProvider();
        Assert.checkNonNull(jarFSProvider, "should have been caught before!");
        this.fileSystem = jarFSProvider.newFileSystem(archivePath, env);
    } else {
        this.fileSystem = FileSystems.newFileSystem(archivePath, null);
    }
    packages = new HashMap<>();
    for (Path root : fileSystem.getRootDirectories()) {
        Files.walkFileTree(root, EnumSet.noneOf(FileVisitOption.class), Integer.MAX_VALUE,
                new SimpleFileVisitor<Path>() {
                    @Override
                    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
                        if (isValid(dir.getFileName())) {
                            packages.put(new RelativeDirectory(root.relativize(dir).toString()), dir);
                            return FileVisitResult.CONTINUE;
                        } else {
                            return FileVisitResult.SKIP_SUBTREE;
                        }
                    }
                });
    }
}
 
Example #4
Source Project: capsule   Author: puniverse   File: PathClassLoader.java    License: Eclipse Public License 1.0 6 votes vote down vote up
private static Object[] process(Path[] paths) throws IOException {
    try {
        final Object[] os = new Object[paths.length];
        for (int i = 0; i < paths.length; i++) {
            final Path p = paths[i];
            final Object o;
            if (Files.isRegularFile(p))
                o = FileSystems.newFileSystem(p, null);
            else
                o = p;
            os[i] = o;
        }
        return os;
    } catch (ProviderNotFoundException e) {
        throw new RuntimeException(e);
    }
}
 
Example #5
Source Project: lua-for-android   Author: qtiuto   File: JavacFileManager.java    License: BSD 3-Clause "New" or "Revised" License 5 votes vote down vote up
public ArchiveContainer(File archivePath) throws IOException, ProviderNotFoundException, SecurityException {
    this.archivePath = archivePath;

    this.orderedZipFile = new OrderedZipFile(archivePath.getPath());

    packages = new HashMap<>();
    for (OrderedZipFile.EntryFile f:orderedZipFile.getEntries()){
        if(f.isDirectory()&&isValid(f.getEntryName())){
            packages.put(new RelativeDirectory(f.getEntryName()), f);
        }
    }
}
 
Example #6
Source Project: ocr-neuralnet   Author: vinsfortunato   File: NativeUtils.java    License: GNU General Public License v3.0 5 votes vote down vote up
private static boolean isPosixCompliant() {
    try {
        return FileSystems.getDefault()
                .supportedFileAttributeViews()
                .contains("posix");
    } catch (FileSystemNotFoundException
            | ProviderNotFoundException
            | SecurityException e) {
        return false;
    }
}
 
Example #7
Source Project: openjdk-jdk9   Author: AdoptOpenJDK   File: JarSourceProvider.java    License: GNU General Public License v2.0 5 votes vote down vote up
private ClassSource createSource(Path jarFile) {
    try {
        Path jarRootPath = fileSupport.getJarFileSystemRoot(jarFile);
        if (jarRootPath == null) {
            return null;
        }
        ClassLoader classLoader = fileSupport.createClassLoader(jarFile);
        return new JarFileSource(jarFile, jarRootPath, classLoader);
    } catch (ProviderNotFoundException | MalformedURLException e) {
    }
    return null;
}
 
Example #8
Source Project: openjdk-jdk9   Author: AdoptOpenJDK   File: JRTIndex.java    License: GNU General Public License v2.0 5 votes vote down vote up
public static boolean isAvailable() {
    try {
        FileSystems.getFileSystem(URI.create("jrt:/"));
        return true;
    } catch (ProviderNotFoundException | FileSystemNotFoundException e) {
        return false;
    }
}
 
Example #9
Source Project: openjdk-jdk9   Author: AdoptOpenJDK   File: Basic.java    License: GNU General Public License v2.0 5 votes vote down vote up
static void checkNoUOE() throws IOException, URISyntaxException {
    String dir = System.getProperty("test.dir", ".");
    String fileName = dir + File.separator + "foo.bar";
    Path path = Paths.get(fileName);
    Path file = Files.createFile(path);
    try {
        URI uri = new URI("jar", file.toUri().toString(), null);
        System.out.println(uri);
        FileSystem fs = FileSystems.newFileSystem(uri, new HashMap());
        fs.close();
    } catch (ProviderNotFoundException pnfe) {
        System.out.println("Expected ProviderNotFoundException caught: "
            + "\"" + pnfe.getMessage() + "\"");
    }
}
 
Example #10
Source Project: WarpPI   Author: Cavallium   File: NativeUtils.java    License: Apache License 2.0 5 votes vote down vote up
private static boolean isPosixCompliant() {
	try {
		if (FileSystems.getDefault().supportedFileAttributeViews().contains("posix"))
			return true;
		return false;
	} catch (FileSystemNotFoundException | ProviderNotFoundException | SecurityException e) {
		return false;
	}
}
 
Example #11
Source Project: native-utils   Author: adamheinrich   File: NativeUtils.java    License: MIT License 5 votes vote down vote up
private static boolean isPosixCompliant() {
    try {
        return FileSystems.getDefault()
                .supportedFileAttributeViews()
                .contains("posix");
    } catch (FileSystemNotFoundException
            | ProviderNotFoundException
            | SecurityException e) {
        return false;
    }
}
 
Example #12
Source Project: Hadoop-BAM   Author: HadoopGenomics   File: BAMInputFormat.java    License: MIT License 5 votes vote down vote up
public List<InputSplit> getSplits(
		List<InputSplit> splits, Configuration cfg)
	throws IOException
{

	final List<InputSplit> origSplits = removeIndexFiles(splits);

	// Align the splits so that they don't cross blocks.

	// addIndexedSplits() requires the given splits to be sorted by file
	// path, so do so. Although FileInputFormat.getSplits() does, at the time
	// of writing this, generate them in that order, we shouldn't rely on it.
	Collections.sort(origSplits, new Comparator<InputSplit>() {
		public int compare(InputSplit a, InputSplit b) {
			FileSplit fa = (FileSplit)a, fb = (FileSplit)b;
			return fa.getPath().compareTo(fb.getPath());
		}
	});

	final List<InputSplit> newSplits =
		new ArrayList<InputSplit>(origSplits.size());

	for (int i = 0; i < origSplits.size();) {
		try {
			i = addIndexedSplits                        (origSplits, i, newSplits, cfg);
		} catch (IOException | ProviderNotFoundException e) {
			if (cfg.getBoolean(ENABLE_BAI_SPLIT_CALCULATOR, false)) {
				try {
					i = addBAISplits            (origSplits, i, newSplits, cfg);
				} catch (IOException | ProviderNotFoundException e2) {
					i = addProbabilisticSplits  (origSplits, i, newSplits, cfg);
				}
			} else {
				i = addProbabilisticSplits          (origSplits, i, newSplits, cfg);
			}
		}
	}
	return filterByInterval(newSplits, cfg);
}
 
Example #13
Source Project: bazel   Author: bazelbuild   File: SimpleJavaLibraryBuilder.java    License: Apache License 2.0 5 votes vote down vote up
private FileSystem getJarFileSystem(Path sourceJar) throws IOException {
  FileSystem fs = filesystems.get(sourceJar);
  if (fs == null) {
    try {
      fs = FileSystems.newFileSystem(sourceJar, null);
    } catch (ProviderNotFoundException e) {
      throw new IOException(String.format("unable to open %s as a jar file", sourceJar), e);
    }
    filesystems.put(sourceJar, fs);
  }
  return fs;
}
 
Example #14
Source Project: takari-lifecycle   Author: takari   File: JavaInstallation.java    License: Eclipse Public License 1.0 5 votes vote down vote up
public static synchronized JavaInstallation getDefault() throws IOException {
  if (instance == null) {
    List<Path> cp;
    try {
      cp = getJrtFs();
    } catch (ProviderNotFoundException e) {
      cp = getJava8();
    }
    instance = new JavaInstallation(cp);
  }
  return instance;
}
 
Example #15
Source Project: jimfs   Author: google   File: Jimfs.java    License: Apache License 2.0 5 votes vote down vote up
@VisibleForTesting
static FileSystem newFileSystem(URI uri, Configuration config) {
  checkArgument(
      URI_SCHEME.equals(uri.getScheme()), "uri (%s) must have scheme %s", uri, URI_SCHEME);

  try {
    // Create the FileSystem. It uses JimfsFileSystemProvider as its provider, as that is
    // the provider that actually implements the operations needed for Files methods to work.
    JimfsFileSystem fileSystem =
        JimfsFileSystems.newFileSystem(JimfsFileSystemProvider.instance(), uri, config);

    /*
     * Now, call FileSystems.newFileSystem, passing it the FileSystem we just created. This
     * allows the system-loaded SystemJimfsFileSystemProvider instance to cache the FileSystem
     * so that methods like Paths.get(URI) work.
     * We do it in this awkward way to avoid issues when the classes in the API (this class
     * and Configuration, for example) are loaded by a different classloader than the one that
     * loads SystemJimfsFileSystemProvider using ServiceLoader. See
     * https://github.com/google/jimfs/issues/18 for gory details.
     */
    try {
      ImmutableMap<String, ?> env = ImmutableMap.of(FILE_SYSTEM_KEY, fileSystem);
      FileSystems.newFileSystem(uri, env, SystemJimfsFileSystemProvider.class.getClassLoader());
    } catch (ProviderNotFoundException | ServiceConfigurationError ignore) {
      // See the similar catch block below for why we ignore this.
      // We log there rather than here so that there's only typically one such message per VM.
    }

    return fileSystem;
  } catch (IOException e) {
    throw new AssertionError(e);
  }
}
 
Example #16
Source Project: openjdk-jdk9   Author: AdoptOpenJDK   File: Locations.java    License: GNU General Public License v2.0 4 votes vote down vote up
public void addFile(Path file, boolean warn) {
    if (contains(file)) {
        // discard duplicates
        return;
    }

    if (!fsInfo.exists(file)) {
        /* No such file or directory exists */
        if (warn) {
            log.warning(Lint.LintCategory.PATH,
                    "path.element.not.found", file);
        }
        super.add(file);
        return;
    }

    Path canonFile = fsInfo.getCanonicalFile(file);
    if (canonicalValues.contains(canonFile)) {
        /* Discard duplicates and avoid infinite recursion */
        return;
    }

    if (fsInfo.isFile(file)) {
        /* File is an ordinary file. */
        if (   !file.getFileName().toString().endsWith(".jmod")
            && !file.endsWith("modules")) {
            if (!isArchive(file)) {
                /* Not a recognized extension; open it to see if
                 it looks like a valid zip file. */
                try {
                    FileSystems.newFileSystem(file, null).close();
                    if (warn) {
                        log.warning(Lint.LintCategory.PATH,
                                "unexpected.archive.file", file);
                    }
                } catch (IOException | ProviderNotFoundException e) {
                    // FIXME: include e.getLocalizedMessage in warning
                    if (warn) {
                        log.warning(Lint.LintCategory.PATH,
                                "invalid.archive.file", file);
                    }
                    return;
                }
            } else {
                if (fsInfo.getJarFSProvider() == null) {
                    log.error(Errors.NoZipfsForArchive(file));
                    return ;
                }
            }
        }
    }

    /* Now what we have left is either a directory or a file name
     conforming to archive naming convention */
    super.add(file);
    canonicalValues.add(canonFile);

    if (expandJarClassPaths && fsInfo.isFile(file) && !file.endsWith("modules")) {
        addJarClassPath(file, warn);
    }
}
 
Example #17
Source Project: openjdk-jdk9   Author: AdoptOpenJDK   File: Locations.java    License: GNU General Public License v2.0 4 votes vote down vote up
private void initSystemModules() throws IOException {
    if (moduleTable != null)
        return;

    if (systemJavaHome == null) {
        moduleTable = new ModuleTable();
        return;
    }

    if (modules == null) {
        try {
            URI jrtURI = URI.create("jrt:/");
            FileSystem jrtfs;

            if (isCurrentPlatform(systemJavaHome)) {
                jrtfs = FileSystems.getFileSystem(jrtURI);
            } else {
                try {
                    Map<String, String> attrMap =
                            Collections.singletonMap("java.home", systemJavaHome.toString());
                    jrtfs = FileSystems.newFileSystem(jrtURI, attrMap);
                } catch (ProviderNotFoundException ex) {
                    URL javaHomeURL = systemJavaHome.resolve("jrt-fs.jar").toUri().toURL();
                    ClassLoader currentLoader = Locations.class.getClassLoader();
                    URLClassLoader fsLoader =
                            new URLClassLoader(new URL[] {javaHomeURL}, currentLoader);

                    jrtfs = FileSystems.newFileSystem(jrtURI, Collections.emptyMap(), fsLoader);

                    closeables.add(fsLoader);
                }

                closeables.add(jrtfs);
            }

            modules = jrtfs.getPath("/modules");
        } catch (FileSystemNotFoundException | ProviderNotFoundException e) {
            modules = systemJavaHome.resolve("modules");
            if (!Files.exists(modules))
                throw new IOException("can't find system classes", e);
        }
    }

    moduleTable = new ModuleTable();
    try (DirectoryStream<Path> stream = Files.newDirectoryStream(modules, Files::isDirectory)) {
        for (Path entry : stream) {
            String moduleName = entry.getFileName().toString();
            String name = location.getName() + "[" + moduleName + "]";
            ModuleLocationHandler h = new ModuleLocationHandler(this,
                    name, moduleName, Collections.singletonList(entry), false);
            moduleTable.add(h);
        }
    }
}
 
Example #18
Source Project: openjdk-jdk9   Author: AdoptOpenJDK   File: Task.java    License: GNU General Public License v2.0 4 votes vote down vote up
static List<Class<?>> getClasses(int count) throws Exception {
    List<Class<?>> classes = new ArrayList<>();
    FileSystem fs = null;

    try {
        fs = FileSystems.getFileSystem(URI.create("jrt:/"));
    } catch (ProviderNotFoundException | FileSystemNotFoundException e) {
        throw new RuntimeException("FAIL - JRT Filesystem not found");
    }

    List<String> fileNames;
    Path modules = fs.getPath("/modules");

    Predicate<String> startsWithJavaBase          = path -> path.toString().startsWith("java.base/java");
    Predicate<String> startsWithJavaDesktop       = path -> path.toString().startsWith("java.desktop/java");
    Predicate<String> startsWithJavaDataTransfer  = path -> path.toString().startsWith("java.datatransfer/java");
    Predicate<String> startsWithJavaRMI           = path -> path.toString().startsWith("java.rmi/java");
    Predicate<String> startsWithJavaSmartCardIO   = path -> path.toString().startsWith("java.smartcardio/java");
    Predicate<String> startsWithJavaManagement    = path -> path.toString().startsWith("java.management/java");
    Predicate<String> startsWithJavaXML           = path -> path.toString().startsWith("java.xml/java");
    Predicate<String> startsWithJavaXMLBind       = path -> path.toString().startsWith("java.xml.bind/java");
    Predicate<String> startsWithJavaScripting     = path -> path.toString().startsWith("java.scripting/java");
    Predicate<String> startsWithJavaNaming        = path -> path.toString().startsWith("java.naming/java");
    Predicate<String> startsWithJavaSQL           = path -> path.toString().startsWith("java.sql/java");
    Predicate<String> startsWithJavaActivation    = path -> path.toString().startsWith("java.activation/java");
    Predicate<String> startsWithJavaCompiler      = path -> path.toString().startsWith("java.compiler/java");
    Predicate<String> startsWithJavaAnnotations   = path -> path.toString().startsWith("java.annotations/java");
    Predicate<String> startsWithJavaTransaction   = path -> path.toString().startsWith("java.transaction/java");
    Predicate<String> startsWithJavaLogging       = path -> path.toString().startsWith("java.logging/java");
    Predicate<String> startsWithJavaCorba         = path -> path.toString().startsWith("java.corba/java");
    Predicate<String> startsWithJavaPrefs         = path -> path.toString().startsWith("java.prefs/java");

    fileNames = Files.walk(modules)
            .map(Path::toString)
            .filter(path -> path.toString().contains("java"))
            .map(s -> s.substring(9))  // remove /modules/ from beginning
            .filter(startsWithJavaBase
                .or(startsWithJavaDesktop)
                .or(startsWithJavaDataTransfer)
                .or(startsWithJavaRMI)
                .or(startsWithJavaSmartCardIO)
                .or(startsWithJavaManagement)
                .or(startsWithJavaXML)
                .or(startsWithJavaXMLBind)
                .or(startsWithJavaScripting)
                .or(startsWithJavaNaming)
                .or(startsWithJavaSQL)
                .or(startsWithJavaActivation)
                .or(startsWithJavaCompiler)
                .or(startsWithJavaAnnotations)
                .or(startsWithJavaTransaction)
                .or(startsWithJavaLogging)
                .or(startsWithJavaCorba)
                .or(startsWithJavaPrefs))
            .map(s -> s.replace('/', '.'))
            .filter(path -> path.toString().endsWith(".class"))
            .map(s -> s.substring(0, s.length() - 6))  // drop .class
            .map(s -> s.substring(s.indexOf(".")))
            .filter(path -> path.toString().contains("java"))
            .map(s -> s.substring(s.indexOf("java")))
            .collect(Collectors.toList());

    for (String name : fileNames) {
        classes.add(Class.forName(name));
        if (count == classes.size()) {
            break;
        }
    }

    return classes;
}
 
Example #19
Source Project: openjdk-jdk9   Author: AdoptOpenJDK   File: JImageTest.java    License: GNU General Public License v2.0 4 votes vote down vote up
public static void main(String[] args) throws Exception {
    List<String> bootClasses = new ArrayList<>();

    FileSystem fs;
    try {
        fs = FileSystems.getFileSystem(URI.create("jrt:/"));
    } catch (ProviderNotFoundException | FileSystemNotFoundException e) {
        System.out.println("Not an image build, test skipped.");
        return;
    }

    // Build the set of locations expected in the Image
    Consumer<Path> c = (p) -> {
           // take only the .class resources.
           if (Files.isRegularFile(p) && p.toString().endsWith(".class")
                   && !p.toString().endsWith("module-info.class")) {
               String loc = p.toString().substring("/modules".length());
               bootClasses.add(loc);
           }
       };

    Path javabase = fs.getPath("/modules/java.base");
    Path mgtbase = fs.getPath("/modules/java.management");
    try (Stream<Path> stream = Files.walk(javabase)) {
        stream.forEach(c);
    }
    try (Stream<Path> stream = Files.walk(mgtbase)) {
        stream.forEach(c);
    }

    if (bootClasses.isEmpty()) {
        throw new RuntimeException("No boot class to check against");
    }

    File jdkHome = new File(System.getProperty("test.jdk"));
    // JPRT not yet ready for jmods
    Helper helper = Helper.newHelper();
    if (helper == null) {
        System.err.println("Test not run, NO jmods directory");
        return;
    }

    // Generate the sample image
    String module = "mod1";
    String[] classes = {module + ".Main"};
    helper.generateDefaultJModule(module, Arrays.asList(classes), "java.management");

    Path image = helper.generateDefaultImage(module).assertSuccess();
    Path extractedDir = JImageGenerator.getJImageTask()
            .dir(helper.createNewExtractedDir("modules"))
            .image(image.resolve("lib").resolve("modules"))
            .extract().assertSuccess();
}
 
Example #20
Source Project: openjdk-jdk9   Author: AdoptOpenJDK   File: CompressorPluginTest.java    License: GNU General Public License v2.0 4 votes vote down vote up
public void test() throws Exception {
    FileSystem fs;
    try {
        fs = FileSystems.getFileSystem(URI.create("jrt:/"));
    } catch (ProviderNotFoundException | FileSystemNotFoundException e) {
        System.err.println("Not an image build, test skipped.");
        return;
    }
    Path javabase = fs.getPath("/modules/java.base");

    checkCompress(gatherResources(javabase), new ZipPlugin(), null,
            new ResourceDecompressorFactory[]{
                new ZipDecompressorFactory()
            });

    ResourcePool classes = gatherClasses(javabase);
    // compress = String sharing
    checkCompress(classes, new StringSharingPlugin(), null,
            new ResourceDecompressorFactory[]{
                new StringSharingDecompressorFactory()});

    // compress level 0 == no compression
    Properties options0 = new Properties();
    options0.setProperty(DefaultCompressPlugin.NAME,
            "0");
    checkCompress(classes, new DefaultCompressPlugin(),
            options0,
            new ResourceDecompressorFactory[]{
            });

    // compress level 1 == String sharing
    Properties options1 = new Properties();
    options1.setProperty(DefaultCompressPlugin.NAME, "1");
    checkCompress(classes, new DefaultCompressPlugin(),
            options1,
            new ResourceDecompressorFactory[]{
                new StringSharingDecompressorFactory()
            });

    // compress level 1 == String sharing + filter
    options1.setProperty(DefaultCompressPlugin.FILTER,
            "**Exception.class");
    options1.setProperty(DefaultCompressPlugin.NAME, "1");
    checkCompress(classes, new DefaultCompressPlugin(),
            options1,
            new ResourceDecompressorFactory[]{
                new StringSharingDecompressorFactory()
            }, Collections.singletonList(".*Exception.class"));

    // compress level 2 == ZIP
    Properties options2 = new Properties();
    options2.setProperty(DefaultCompressPlugin.FILTER,
            "**Exception.class");
    options2.setProperty(DefaultCompressPlugin.NAME, "2");
    checkCompress(classes, new DefaultCompressPlugin(),
            options2,
            new ResourceDecompressorFactory[]{
                new ZipDecompressorFactory()
            }, Collections.singletonList(".*Exception.class"));

    // compress level 2 == ZIP + filter
    options2.setProperty(DefaultCompressPlugin.FILTER,
            "**Exception.class");
    options2.setProperty(DefaultCompressPlugin.NAME, "2");
    checkCompress(classes, new DefaultCompressPlugin(),
            options2,
            new ResourceDecompressorFactory[]{
                new ZipDecompressorFactory(),
            }, Collections.singletonList(".*Exception.class"));
}