java.nio.file.ProviderNotFoundException Java Examples

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;
    }
}
 

@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);
}
 

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;
                        }
                    }
                });
    }
}
 

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);
    }
}
 

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);
        }
    }
}
 

private static boolean isPosixCompliant() {
    try {
        return FileSystems.getDefault()
                .supportedFileAttributeViews()
                .contains("posix");
    } catch (FileSystemNotFoundException
            | ProviderNotFoundException
            | SecurityException e) {
        return false;
    }
}
 

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;
}
 

public static boolean isAvailable() {
    try {
        FileSystems.getFileSystem(URI.create("jrt:/"));
        return true;
    } catch (ProviderNotFoundException | FileSystemNotFoundException e) {
        return false;
    }
}
 

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() + "\"");
    }
}
 

private static boolean isPosixCompliant() {
	try {
		if (FileSystems.getDefault().supportedFileAttributeViews().contains("posix"))
			return true;
		return false;
	} catch (FileSystemNotFoundException | ProviderNotFoundException | SecurityException e) {
		return false;
	}
}
 

private static boolean isPosixCompliant() {
    try {
        return FileSystems.getDefault()
                .supportedFileAttributeViews()
                .contains("posix");
    } catch (FileSystemNotFoundException
            | ProviderNotFoundException
            | SecurityException e) {
        return false;
    }
}
 

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);
}
 

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;
}
 

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;
}
 

@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);
  }
}
 

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);
    }
}
 

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);
        }
    }
}
 

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;
}
 

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();
}
 

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"));
}