@Override public Set<String> supportedFileAttributeViews() { return delegate.supportedFileAttributeViews(); }
private static boolean isPosixComplantFs() { return FileSystems.getDefault().supportedFileAttributeViews().contains(POSIX_FILE_VIEW); }
/** * Creates a new temporary directory. */ public static File createTempDir() throws IOException { // The previously used approach of creating a temporary file, deleting // it, and making a new directory having the same name in its place is // potentially problematic: // https://stackoverflow.com/questions/617414/how-to-create-a-temporary-directory-folder-in-java // We can use the Java 7 Files.createTempDirectory() API, but note that // by default, the permissions of the created directory are 0700&(~umask) // whereas the old approach created a temporary directory with permissions // 0777&(~umask). // To avoid permissions problems like https://issues.jenkins-ci.org/browse/JENKINS-48407 // we can pass POSIX file permissions as an attribute (see, for example, // https://github.com/jenkinsci/jenkins/pull/3161 ) final Path tempPath; final String tempDirNamePrefix = "jenkins"; if (FileSystems.getDefault().supportedFileAttributeViews().contains("posix")) { tempPath = Files.createTempDirectory(tempDirNamePrefix, PosixFilePermissions.asFileAttribute(EnumSet.allOf(PosixFilePermission.class))); } else { tempPath = Files.createTempDirectory(tempDirNamePrefix); } return tempPath.toFile(); }
@Override public String invoke(File dir, VirtualChannel channel) throws IOException { Path tempPath; final boolean isPosix = FileSystems.getDefault().supportedFileAttributeViews().contains("posix"); if (isPosix) { tempPath = Files.createTempDirectory(Util.fileToPath(dir), name, PosixFilePermissions.asFileAttribute(EnumSet.allOf(PosixFilePermission.class))); } else { tempPath = Files.createTempDirectory(Util.fileToPath(dir), name, new FileAttribute<?>[] {}); } if (tempPath.toFile() == null) { throw new IOException("Failed to obtain file from path " + dir + " on " + remote); } return tempPath.toFile().getName(); } }
private void setExecutableIfAvailable(final String targetFileName) throws IOException { final Path targetPath = this.basePath.resolve(targetFileName); final FileSystem fileSystem = targetPath.getFileSystem(); if (fileSystem.supportedFileAttributeViews().contains("posix")) { // NTFS does not support PosixFilePermissions, for example. final Set<PosixFilePermission> permissions = new HashSet<PosixFilePermission>(Files.getPosixFilePermissions(targetPath)); permissions.add(PosixFilePermission.OWNER_EXECUTE); permissions.add(PosixFilePermission.GROUP_EXECUTE); permissions.add(PosixFilePermission.OTHERS_EXECUTE); Files.setPosixFilePermissions(targetPath, permissions); } }
private void setExecutableIfAvailable(final String targetFileName) throws IOException { final Path targetPath = this.pluginBasePath.resolve(targetFileName); final FileSystem fileSystem = targetPath.getFileSystem(); if (fileSystem.supportedFileAttributeViews().contains("posix")) { // NTFS does not support PosixFilePermissions, for example. final Set<PosixFilePermission> permissions = new HashSet<PosixFilePermission>(Files.getPosixFilePermissions(targetPath)); permissions.add(PosixFilePermission.OWNER_EXECUTE); permissions.add(PosixFilePermission.GROUP_EXECUTE); permissions.add(PosixFilePermission.OTHERS_EXECUTE); Files.setPosixFilePermissions(targetPath, permissions); } }
private Path createSensitiveKeyFile(File confDir) { Path sensitiveKeyFile = Paths.get(confDir+"/sensitive.key"); final boolean isPosixSupported = FileSystems.getDefault().supportedFileAttributeViews().contains("posix"); try { if (isPosixSupported) { // Initially create file with the empty permission set (so nobody can get a file descriptor on it): Set<PosixFilePermission> perms = new HashSet<PosixFilePermission>(); FileAttribute<Set<PosixFilePermission>> attr = PosixFilePermissions.asFileAttribute(perms); sensitiveKeyFile = Files.createFile(sensitiveKeyFile, attr); // Then, once created, add owner-only rights: perms.add(PosixFilePermission.OWNER_WRITE); perms.add(PosixFilePermission.OWNER_READ); attr = PosixFilePermissions.asFileAttribute(perms); Files.setPosixFilePermissions(sensitiveKeyFile, perms); } else { // If Posix is not supported (e.g. Windows) then create the key file without permission settings. cmdLogger.info("Current file system does not support Posix, using default permission settings."); sensitiveKeyFile = Files.createFile(sensitiveKeyFile); } } catch (final FileAlreadyExistsException faee) { cmdLogger.error("The sensitive.key file {} already exists. That shouldn't have been. Aborting.", sensitiveKeyFile); System.exit(1); } catch (final Exception e) { cmdLogger.error("Other failure relating to setting permissions on {}. " + "(so that only the owner can read it). " + "This is fatal to the bootstrap process for security reasons. Exception was: {}", sensitiveKeyFile, e); System.exit(1); } return sensitiveKeyFile; }
final FileSystem jarPathJavaFileSystem = jarPathJava.getFileSystem(); final FileSystem jarPathTempFileSystem = jarPathTemp.getFileSystem(); if (jarPathJavaFileSystem.supportedFileAttributeViews().contains("posix") && jarPathTempFileSystem.supportedFileAttributeViews().contains("posix")) {
@Test public void testWithInaccessibleDir() throws IOException { // Some systems don't support POSIX (Windows) and will fail if run. Should ignore the test in that event if (!FileSystems.getDefault().supportedFileAttributeViews().contains("posix")) { return; } File inaccessibleDir = new File("target/inaccessible"); inaccessibleDir.deleteOnExit(); inaccessibleDir.mkdir(); Set<PosixFilePermission> posixFilePermissions = new HashSet<>(); Files.setPosixFilePermissions(inaccessibleDir.toPath(), posixFilePermissions); final TestRunner runner = TestRunners.newTestRunner(new GetFile()); runner.setProperty(GetFile.DIRECTORY, inaccessibleDir.getAbsolutePath()); try { runner.run(); fail(); } catch (AssertionError e) { assertTrue(e.getCause().getMessage() .endsWith("does not have sufficient permissions (i.e., not writable and readable)")); } }
@Test public void testWithUnwritableDir() throws IOException { // Some systems don't support POSIX (Windows) and will fail if run. Should ignore the test in that event if (!FileSystems.getDefault().supportedFileAttributeViews().contains("posix")) { return; } File unwritableDir = new File("target/unwritable"); unwritableDir.deleteOnExit(); unwritableDir.mkdir(); Set<PosixFilePermission> posixFilePermissions = new HashSet<>(); posixFilePermissions.add(PosixFilePermission.GROUP_EXECUTE); posixFilePermissions.add(PosixFilePermission.GROUP_READ); posixFilePermissions.add(PosixFilePermission.OTHERS_EXECUTE); posixFilePermissions.add(PosixFilePermission.OTHERS_READ); posixFilePermissions.add(PosixFilePermission.OWNER_EXECUTE); posixFilePermissions.add(PosixFilePermission.OWNER_READ); Files.setPosixFilePermissions(unwritableDir.toPath(), posixFilePermissions); final TestRunner runner = TestRunners.newTestRunner(new GetFile()); runner.setProperty(GetFile.DIRECTORY, unwritableDir.getAbsolutePath()); try { runner.run(); fail(); } catch (AssertionError e) { assertTrue(e.getCause().getMessage() .endsWith("does not have sufficient permissions (i.e., not writable and readable)")); } }
@Test public void testWithUnreadableDir() throws IOException { // Some systems don't support POSIX (Windows) and will fail if run. Should ignore the test in that event if (!FileSystems.getDefault().supportedFileAttributeViews().contains("posix")) { return; } File unreadableDir = new File("target/unreadable"); unreadableDir.deleteOnExit(); unreadableDir.mkdir(); Set<PosixFilePermission> posixFilePermissions = new HashSet<>(); posixFilePermissions.add(PosixFilePermission.GROUP_EXECUTE); posixFilePermissions.add(PosixFilePermission.GROUP_WRITE); posixFilePermissions.add(PosixFilePermission.OTHERS_EXECUTE); posixFilePermissions.add(PosixFilePermission.OTHERS_WRITE); posixFilePermissions.add(PosixFilePermission.OWNER_EXECUTE); posixFilePermissions.add(PosixFilePermission.OWNER_WRITE); Files.setPosixFilePermissions(unreadableDir.toPath(), posixFilePermissions); final TestRunner runner = TestRunners.newTestRunner(new GetFile()); runner.setProperty(GetFile.DIRECTORY, unreadableDir.getAbsolutePath()); try { runner.run(); fail(); } catch (AssertionError e) { Throwable ex = e.getCause(); assertTrue(e.getCause().getMessage() .endsWith("does not have sufficient permissions (i.e., not writable and readable)")); } }
@Test public void testGetters() throws IOException { try (FileSystem fs = CloudStorageFileSystem.forBucket("bucket")) { assertThat(fs.isOpen()).isTrue(); assertThat(fs.isReadOnly()).isFalse(); assertThat(fs.getRootDirectories()).containsExactly(fs.getPath("/")); assertThat(fs.getFileStores()).isEmpty(); assertThat(fs.getSeparator()).isEqualTo("/"); assertThat(fs.supportedFileAttributeViews()).containsExactly("basic", "gcs"); } }
public static boolean filePermSupported() { FileSystem system = FileSystems.getDefault(); for (String name : system.supportedFileAttributeViews()) { // see javadoc for PosixFileAttributeView. if ("posix".equals(name)) { return true; } } return false; } }
UploaderFileAttributes getFileAttributes(Path file) { Set<String> supportedViews = FileSystems.getDefault().supportedFileAttributeViews(); LOG.trace("Supported attribute views are {}", supportedViews); if (supportedViews.contains("user")) { try { UserDefinedFileAttributeView view = Files.getFileAttributeView(file, UserDefinedFileAttributeView.class); List<String> attributes = view.list(); LOG.debug("Found file attributes {} for file {}", attributes, file); Optional<Long> maybeStartTime = readFileAttributeAsLong(file, LOG_START_TIME_ATTR, view, attributes); Optional<Long> maybeEndTime = readFileAttributeAsLong(file, LOG_END_TIME_ATTR, view, attributes); return new UploaderFileAttributes(maybeStartTime, maybeEndTime); } catch (Exception e) { LOG.error("Could not get extra file metadata for {}", file, e); } } return new UploaderFileAttributes(Optional.absent(), Optional.absent()); }
/** * Test case for https://github.com/dadoonet/fscrawler/issues/362 * @throws Exception In case something is wrong */ @Test public void test_non_readable_file() throws Exception { // We change the attributes of the file logger.info(" ---> Changing attributes for file roottxtfile.txt"); boolean isPosix = FileSystems.getDefault().supportedFileAttributeViews().contains("posix"); assumeTrue("This test can only run on Posix systems", isPosix); Files.getFileAttributeView(currentTestResourceDir.resolve("roottxtfile.txt"), PosixFileAttributeView.class) .setPermissions(EnumSet.noneOf(PosixFilePermission.class)); Fs fs = startCrawlerDefinition() .setIndexContent(false) .build(); startCrawler(getCrawlerName(), fs, endCrawlerDefinition(getCrawlerName()), null); // We should have one doc first countTestHelper(new ESSearchRequest().withIndex(getCrawlerName()), 1L, currentTestResourceDir); } }
public static boolean filePermSupported() { FileSystem system = FileSystems.getDefault(); for (String name : system.supportedFileAttributeViews()) { // see javadoc for PosixFileAttributeView. if ("posix".equals(name)) { return true; } } return false; } }
private static boolean isPosix() { return FileSystems .getDefault() .supportedFileAttributeViews() .contains("posix"); }
/** * Check if posix file attribute view is supported on the default FileSystem. * * @return true if posix file attribute view supported, false otherwise */ public static boolean isFilePosixAttributeViewSupported() { return FileSystems.getDefault().supportedFileAttributeViews().contains("posix"); } }
private static Set<Class<? extends FileAttributeView>> supportedAttributeViews(Path source, Path target, boolean sameFileSystem) { Set<String> viewNames = source.getFileSystem().supportedFileAttributeViews(); if (!sameFileSystem) { viewNames = new HashSet<>(viewNames); // can be unmodifyable viewNames.retainAll(target.getFileSystem().supportedFileAttributeViews()); } Set<Class<? extends FileAttributeView>> supportedAttribueViews = new HashSet<>(viewNames.size()); for (String string : viewNames) { supportedAttribueViews.add(FileAttributeViews.mapAttributeViewName(string)); } return supportedAttribueViews; }
public void setPermission(final Permission permission) throws AccessDeniedException { if(FileSystems.getDefault().supportedFileAttributeViews().contains("posix")) { try { Files.setPosixFilePermissions(Paths.get(path), PosixFilePermissions.fromString(permission.getSymbol())); } catch(IllegalArgumentException | IOException e) { throw new LocalAccessDeniedException(String.format("Cannot change permissions of %s", path), e); } } }