类java.nio.file.attribute.PosixFilePermission源码实例Demo

下面列出了怎么用java.nio.file.attribute.PosixFilePermission的API类实例代码及写法,或者点击链接到github查看源代码。

源代码1 项目: datacollector   文件: TestDataStore.java
@Test
public void testExistingPermission() throws IOException {
  File file = new File(createTestDir(), "x");
  Set<PosixFilePermission> perms = ImmutableSet.of(
      PosixFilePermission.OWNER_READ,
      PosixFilePermission.OWNER_WRITE,
      PosixFilePermission.GROUP_READ
  );
  FileAttribute attribute = PosixFilePermissions.asFileAttribute(perms);
  Files.createFile(file.toPath(), attribute);

  DataStore ds = new DataStore(file);
  try {
    OutputStream outputStream = ds.getOutputStream();
    ds.commit(outputStream);
    ds.release();
  } finally {
    ds.close();
  }
  Set<PosixFilePermission> gotPerms = Files.getPosixFilePermissions(file.toPath());
  Assert.assertEquals(perms, gotPerms);
}
 
源代码2 项目: jimfs   文件: JimfsUnixLikeFileSystemTest.java
@Test
public void testCreateSymbolicLink_withInitialAttributes() throws IOException {
  FileAttribute<Set<PosixFilePermission>> permissions =
      PosixFilePermissions.asFileAttribute(PosixFilePermissions.fromString("rwxrwxrwx"));

  Files.createSymbolicLink(path("/foo"), path("bar"), permissions);

  assertThatPath("/foo", NOFOLLOW_LINKS)
      .isSymbolicLink()
      .and()
      .attribute("posix:permissions")
      .is(permissions.value());

  Files.createSymbolicLink(path("/normal"), path("bar"));

  assertThatPath("/normal", NOFOLLOW_LINKS)
      .isSymbolicLink()
      .and()
      .attribute("posix:permissions")
      .isNot(permissions.value());
}
 
源代码3 项目: aCute   文件: DebuggersRegistry.java
public static DebuggerInfo getDefaultDebugger() {
	URL netcoredbgUrl = FileLocator.find(AcutePlugin.getDefault().getBundle(), new Path("netcoredbg")); //$NON-NLS-1$
	if (netcoredbgUrl != null) {
		try {
			netcoredbgUrl = FileLocator.toFileURL(netcoredbgUrl);
			File dbgDir = new File(netcoredbgUrl.toURI().normalize()).getAbsoluteFile();
			if (!dbgDir.canExecute() && dbgDir.canExecute()) {
				Files.setPosixFilePermissions(dbgDir.toPath(), Collections.singleton(PosixFilePermission.OWNER_EXECUTE));
			}
			return new DebuggerInfo(new File(dbgDir,Platform.OS_WIN32.equals(Platform.getOS()) ? "netcoredbg.exe" : "netcoredbg"), Collections.singletonList("--interpreter=vscode")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		} catch (IOException | URISyntaxException ex) {
			AcutePlugin.logError(ex);
		}
	}
	return new DebuggerInfo(new File("/home/mistria/apps/netcoredbg-linux-master/netcoredbg/netcoredbg"), Collections.singletonList("--interpreter=vscode")); //$NON-NLS-1$ //$NON-NLS-2$
}
 
源代码4 项目: copybara   文件: HgOriginTest.java
@Test
public void testHgOriginWithHook() throws Exception {
  Files.write(remotePath.resolve("foo.txt"), "hello".getBytes(UTF_8));
  Files.write(remotePath.resolve("bar.txt"), "hello".getBytes(UTF_8));

  repository.hg(remotePath, "add", "foo.txt");
  repository.hg(remotePath, "add", "bar.txt");
  repository.hg(remotePath, "commit", "-m", "foo");

  Path hook = Files.createTempFile("script", "script");
  Files.write(hook, "touch hook.txt".getBytes(UTF_8));

  Files.setPosixFilePermissions(
      hook,
      ImmutableSet.<PosixFilePermission>builder()
          .addAll(Files.getPosixFilePermissions(hook))
          .add(PosixFilePermission.OWNER_EXECUTE)
          .build());

  options.hgOrigin.originCheckoutHook = hook.toString();
  origin = origin();

  Path checkoutDir = Files.createTempDirectory("checkout");
  newReader().checkout(origin.resolve("tip"), checkoutDir);
  assertThatPath(checkoutDir).containsFile("hook.txt", "");
}
 
源代码5 项目: consulo   文件: FileSystemUtil.java
@Override
public boolean clonePermissions(@Nonnull String source, @Nonnull String target, boolean execOnly) throws IOException {
  if (!SystemInfo.isUnix) return false;

  Path sourcePath = Paths.get(source), targetPath = Paths.get(target);
  Set<PosixFilePermission> sourcePermissions = Files.readAttributes(sourcePath, PosixFileAttributes.class).permissions();
  Set<PosixFilePermission> targetPermissions = Files.readAttributes(targetPath, PosixFileAttributes.class).permissions();
  Set<PosixFilePermission> newPermissions;
  if (execOnly) {
    newPermissions = EnumSet.copyOf(targetPermissions);
    for (PosixFilePermission permission : myExecPermissions) {
      if (sourcePermissions.contains(permission)) {
        newPermissions.add(permission);
      }
      else {
        newPermissions.remove(permission);
      }
    }
  }
  else {
    newPermissions = sourcePermissions;
  }
  Files.setAttribute(targetPath, "posix:permissions", newPermissions);
  return true;
}
 
源代码6 项目: copybara   文件: FileUtil.java
/**
 * Tries to add the Posix permissions if the file belongs to a Posix filesystem. This is an
 * addition, which means that no permissions are removed.
 *
 * <p>For Windows type filesystems, it uses setReadable/setWritable/setExecutable, which is only
 * supported for the owner, and ignores the rest of permissions.
 */
public static void addPermissions(Path path, Set<PosixFilePermission> permissionsToAdd)
    throws IOException {
  if (path.getFileSystem().supportedFileAttributeViews().contains("posix")) {
    Set<PosixFilePermission> permissions = Files.getPosixFilePermissions(path);
    permissions.addAll(permissionsToAdd);
    Files.setPosixFilePermissions(path, permissions);
  } else {
    File file = path.toFile();
    if (permissionsToAdd.contains(PosixFilePermission.OWNER_READ)) {
      if (!file.setReadable(true)) {
        throw new IOException("Could not set 'readable' permission for file: " + path);
      }
    }
    if (permissionsToAdd.contains(PosixFilePermission.OWNER_WRITE)) {
      if (!file.setWritable(true)) {
        throw new IOException("Could not set 'writable' permission for file: " + path);
      }
    }
    if (permissionsToAdd.contains(PosixFilePermission.OWNER_EXECUTE)) {
      if (!file.setExecutable(true)) {
        throw new IOException("Could not set 'executable' permission for file: " + path);
      }
    }
  }
}
 
源代码7 项目: datacollector   文件: TestRuntimeEL.java
@Test
public void testLoadResourceRestrictedSuccess() throws Exception {
  Path fooFile = Paths.get(resourcesDir.getPath(), "foo.txt");
  Files.write(fooFile, "Hello\n".getBytes(StandardCharsets.UTF_8));
  Files.setPosixFilePermissions(fooFile, ImmutableSet.of(
      PosixFilePermission.OWNER_READ,
      PosixFilePermission.OWNER_WRITE)
  );

  RuntimeEL.loadRuntimeConfiguration(runtimeInfo);

  try {
    RuntimeEL.loadResourceRaw("foo.txt", true);
  } finally {
    Files.deleteIfExists(fooFile);
  }
}
 
源代码8 项目: jimfs   文件: JimfsUnixLikeFileSystemTest.java
@Test
public void testCreateDirectory_withInitialAttributes() throws IOException {
  FileAttribute<Set<PosixFilePermission>> permissions =
      PosixFilePermissions.asFileAttribute(PosixFilePermissions.fromString("rwxrwxrwx"));

  Files.createDirectory(path("/foo"), permissions);

  assertThatPath("/foo")
      .isDirectory()
      .and()
      .attribute("posix:permissions")
      .is(permissions.value());

  Files.createDirectory(path("/normal"));

  assertThatPath("/normal")
      .isDirectory()
      .and()
      .attribute("posix:permissions")
      .isNot(permissions.value());
}
 
源代码9 项目: zeppelin   文件: FileSystemStorage.java
public void writeFile(final String content, final Path file, boolean writeTempFileFirst, Set<PosixFilePermission> permissions)
    throws IOException {
  FsPermission fsPermission;
  if (permissions == null || permissions.isEmpty()) {
    fsPermission = FsPermission.getFileDefault();
  } else {
    // FsPermission expects a 10-character string because of the leading
    // directory indicator, i.e. "drwx------". The JDK toString method returns
    // a 9-character string, so prepend a leading character.
    fsPermission = FsPermission.valueOf("-" + PosixFilePermissions.toString(permissions));
  }
  callHdfsOperation(new HdfsOperation<Void>() {
    @Override
    public Void call() throws IOException {
      InputStream in = new ByteArrayInputStream(content.getBytes(
          zConf.getString(ZeppelinConfiguration.ConfVars.ZEPPELIN_ENCODING)));
      Path tmpFile = new Path(file.toString() + ".tmp");
      IOUtils.copyBytes(in, fs.create(tmpFile), hadoopConf);
      fs.setPermission(tmpFile, fsPermission);
      fs.delete(file, true);
      fs.rename(tmpFile, file);
      return null;
    }
  });
}
 
源代码10 项目: appengine-plugins-core   文件: FileUtilTest.java
@Test
public void testCopyDirectory_posixPermissions() throws IOException {
  assumeTrue(!System.getProperty("os.name").startsWith("Windows"));

  Set<PosixFilePermission> permission = Sets.newHashSet();
  permission.add(PosixFilePermission.OWNER_READ);
  permission.add(PosixFilePermission.GROUP_READ);
  permission.add(PosixFilePermission.OTHERS_READ);
  permission.add(PosixFilePermission.OTHERS_EXECUTE);
  permission.add(PosixFilePermission.OTHERS_WRITE);

  Path src = testDir.newFolder("src").toPath();
  Path dest = testDir.newFolder("dest").toPath();

  Path rootFile = Files.createFile(src.resolve("root1.file"));
  Assert.assertNotEquals(
      "This test is useless - modified permissions are default permissions",
      Files.getPosixFilePermissions(rootFile),
      permission);
  Files.setPosixFilePermissions(rootFile, permission);

  FileUtil.copyDirectory(src, dest);

  Assert.assertEquals(
      permission, Files.getPosixFilePermissions(dest.resolve(src.relativize(rootFile))));
}
 
private static void testKafkaKeytabHelper(String keytabDirStr) throws Exception {
  assertThat(keytabDirStr, not(equalTo(INVALID_KEYTAB_DIR)));
  final Path keytabDir = Paths.get(keytabDirStr);
  assertTrue(Files.exists(keytabDir));
  assertTrue(Files.isDirectory(keytabDir));

  // kafka-keytabs dir should be globally writeable at this point
  final Path kafkaKeytabsDir = keytabDir.resolve(StandaloneAndClusterPipelineManager.KAFKA_KEYTAB_DIR);
  assertTrue(Files.exists(kafkaKeytabsDir));
  assertTrue(Files.isDirectory(kafkaKeytabsDir));
  final Set<PosixFilePermission> topLevelPerms = Files.getPosixFilePermissions(kafkaKeytabsDir);
  assertThat(topLevelPerms, equalTo(StandaloneAndClusterPipelineManager.GLOBAL_ALL_PERM));

  // current user level subdirectory should be restricted to user only
  final Path userLevelDir = kafkaKeytabsDir.resolve(System.getProperty("user.name"));
  assertTrue(Files.exists(userLevelDir));
  assertTrue(Files.isDirectory(userLevelDir));
  final Set<PosixFilePermission> userLevelPerms = Files.getPosixFilePermissions(userLevelDir);
  assertThat(userLevelPerms, equalTo(StandaloneAndClusterPipelineManager.USER_ONLY_PERM));

}
 
源代码12 项目: celos   文件: TestTaskTest.java
@Test
public void testTempDirIsWorldReadable() throws IOException {
    File tempDir = TestTask.getTempDir();
    Set<PosixFilePermission> perms = Files.getPosixFilePermissions(tempDir.toPath());
    Assert.assertTrue(perms.contains(PosixFilePermission.OTHERS_READ));
    Assert.assertTrue(perms.contains(PosixFilePermission.OTHERS_EXECUTE));
    Assert.assertTrue(perms.contains(PosixFilePermission.OWNER_READ));
    Assert.assertTrue(perms.contains(PosixFilePermission.OWNER_EXECUTE));
    Assert.assertTrue(perms.contains(PosixFilePermission.OWNER_WRITE));
    tempDir.delete();
}
 
@Test
public void testDistributesSpillOverPathsBadDisk()
        throws Exception
{
    List<Type> types = ImmutableList.of(BIGINT);
    List<Path> spillPaths = ImmutableList.of(spillPath1.toPath(), spillPath2.toPath());
    FileSingleStreamSpillerFactory spillerFactory = new FileSingleStreamSpillerFactory(
            executor, // executor won't be closed, because we don't call destroy() on the spiller factory
            blockEncodingSerde,
            new SpillerStats(),
            spillPaths,
            1.0,
            false,
            false);

    assertEquals(listFiles(spillPath1.toPath()).size(), 0);
    assertEquals(listFiles(spillPath2.toPath()).size(), 0);

    // Set first spiller path to read-only after initialization to emulate a disk failing during runtime
    setPosixFilePermissions(spillPath1.toPath(), ImmutableSet.of(PosixFilePermission.OWNER_READ));

    Page page = buildPage();
    List<SingleStreamSpiller> spillers = new ArrayList<>();
    int numberOfSpills = 10;
    for (int i = 0; i < numberOfSpills; ++i) {
        SingleStreamSpiller singleStreamSpiller = spillerFactory.create(types, bytes -> {}, newSimpleAggregatedMemoryContext().newLocalMemoryContext("test"));
        getUnchecked(singleStreamSpiller.spill(page));
        spillers.add(singleStreamSpiller);
    }

    // bad disk should receive no spills, with the good disk taking the remainder
    assertEquals(listFiles(spillPath1.toPath()).size(), 0);
    assertEquals(listFiles(spillPath2.toPath()).size(), numberOfSpills);

    spillers.forEach(SingleStreamSpiller::close);
    assertEquals(listFiles(spillPath1.toPath()).size(), 0);
    assertEquals(listFiles(spillPath2.toPath()).size(), 0);
}
 
源代码14 项目: Flink-CEPplus   文件: JarDeleteHandlerTest.java
private void makeJarDirReadOnly() {
	try {
		Files.setPosixFilePermissions(jarDir, new HashSet<>(Arrays.asList(
			PosixFilePermission.OTHERS_READ,
			PosixFilePermission.GROUP_READ,
			PosixFilePermission.OWNER_READ,
			PosixFilePermission.OTHERS_EXECUTE,
			PosixFilePermission.GROUP_EXECUTE,
			PosixFilePermission.OWNER_EXECUTE)));
	} catch (final Exception e) {
		Assume.assumeNoException(e);
	}
}
 
源代码15 项目: ParallelGit   文件: PosixFileAttributesTest.java
@Test
public void getPermissionOfFile_shouldContainOwnerWrite() throws IOException {
  writeToCache("/file.txt");
  commitToMaster();
  initGitFileSystem();

  PosixFileAttributes attributes = readPosixAttributes("/file.txt");
  Collection permissions = (Collection) attributes.permissions();
  assertTrue(permissions.contains(PosixFilePermission.OWNER_WRITE));
}
 
源代码16 项目: hadoop   文件: LocalJavaKeyStoreProvider.java
private static Set<PosixFilePermission> modeToPosixFilePermission(
    int mode) {
  Set<PosixFilePermission> perms = EnumSet.noneOf(PosixFilePermission.class);
  if ((mode & 0001) != 0) {
    perms.add(PosixFilePermission.OTHERS_EXECUTE);
  }
  if ((mode & 0002) != 0) {
    perms.add(PosixFilePermission.OTHERS_WRITE);
  }
  if ((mode & 0004) != 0) {
    perms.add(PosixFilePermission.OTHERS_READ);
  }
  if ((mode & 0010) != 0) {
    perms.add(PosixFilePermission.GROUP_EXECUTE);
  }
  if ((mode & 0020) != 0) {
    perms.add(PosixFilePermission.GROUP_WRITE);
  }
  if ((mode & 0040) != 0) {
    perms.add(PosixFilePermission.GROUP_READ);
  }
  if ((mode & 0100) != 0) {
    perms.add(PosixFilePermission.OWNER_EXECUTE);
  }
  if ((mode & 0200) != 0) {
    perms.add(PosixFilePermission.OWNER_WRITE);
  }
  if ((mode & 0400) != 0) {
    perms.add(PosixFilePermission.OWNER_READ);
  }
  return perms;
}
 
源代码17 项目: dragonwell8_jdk   文件: DflCache.java
private static void makeMine(Path p) throws IOException {
    // chmod to owner-rw only, otherwise MIT krb5 rejects
    try {
        Set<PosixFilePermission> attrs = new HashSet<>();
        attrs.add(PosixFilePermission.OWNER_READ);
        attrs.add(PosixFilePermission.OWNER_WRITE);
        Files.setPosixFilePermissions(p, attrs);
    } catch (UnsupportedOperationException uoe) {
        // No POSIX permission. That's OK.
    }
}
 
源代码18 项目: jimfs   文件: PosixAttributeProvider.java
@SuppressWarnings("unchecked")
protected Attributes(File file) {
  super(file);
  this.owner = (UserPrincipal) file.getAttribute("owner", "owner");
  this.group = (GroupPrincipal) file.getAttribute("posix", "group");
  this.permissions =
      (ImmutableSet<PosixFilePermission>) file.getAttribute("posix", "permissions");
}
 
源代码19 项目: pnc   文件: IoUtil.java
private static void setUnixPermissions(Path path) throws IOException {
    Set<PosixFilePermission> perms = new HashSet<>();
    perms.add(PosixFilePermission.OWNER_READ);
    perms.add(PosixFilePermission.OWNER_WRITE);
    if (isDirectory(path)) {
        perms.add(PosixFilePermission.OWNER_EXECUTE);
    }
    Files.setPosixFilePermissions(path, perms);
}
 
源代码20 项目: ParallelGit   文件: PosixFileAttributeViewTest.java
@Test
public void getPermissionOfFile_shouldContainOwnerWrite() throws IOException {
  writeToCache("/file.txt");
  commitToMaster();
  initGitFileSystem();

  GfsFileAttributeView.Posix view = provider.getFileAttributeView(gfs.getPath("/file.txt"), GfsFileAttributeView.Posix.class);
  assertNotNull(view);
  Collection permissions = (Collection) readAttribute(view, GfsFileAttributeView.Posix.PERMISSIONS_NAME);
  assertNotNull(permissions);
  assertTrue(permissions.contains(PosixFilePermission.OWNER_WRITE));
}
 
源代码21 项目: zip4j   文件: FileUtilsTestLinuxAndMac.java
private void verifyAllPermissionSet(Set<PosixFilePermission> permissions) {
  assertThat(permissions).contains(
      PosixFilePermission.OWNER_READ,
      PosixFilePermission.OWNER_WRITE,
      PosixFilePermission.OWNER_EXECUTE,
      PosixFilePermission.GROUP_READ,
      PosixFilePermission.GROUP_WRITE,
      PosixFilePermission.GROUP_EXECUTE,
      PosixFilePermission.OTHERS_READ,
      PosixFilePermission.OTHERS_WRITE,
      PosixFilePermission.OTHERS_EXECUTE
  );
}
 
源代码22 项目: vespa   文件: ProcessFactoryImplTest.java
@Test
public void testSpawnWithPersistentOutputFile() {

    class TemporaryFile implements AutoCloseable {
        private final Path path;
        private TemporaryFile() {
            String outputFileName = ProcessFactoryImplTest.class.getSimpleName() + "-temporary-test-file.out";
            FileAttribute<Set<PosixFilePermission>> fileAttribute = PosixFilePermissions.asFileAttribute(
                    PosixFilePermissions.fromString("rw-------"));
            path = uncheck(() -> Files.createTempFile(outputFileName, ".out", fileAttribute));
        }
        @Override public void close() { uncheck(() -> Files.deleteIfExists(path)); }
    }

    try (TemporaryFile outputPath = new TemporaryFile()) {
        CommandLine commandLine = mock(CommandLine.class);
        when(commandLine.getArguments()).thenReturn(List.of("program"));
        when(commandLine.programName()).thenReturn("program");
        when(commandLine.getOutputFile()).thenReturn(Optional.of(outputPath.path));
        try (ChildProcess2Impl child = processFactory.spawn(commandLine)) {
            assertEquals(outputPath.path, child.getOutputPath());
            assertTrue(Files.exists(outputPath.path));
            assertEquals("rw-------", new UnixPath(outputPath.path).getPermissions());
        }

        assertTrue(Files.exists(outputPath.path));
    }

}
 
源代码23 项目: openjdk-jdk8u   文件: ZipFSPermissionsTest.java
/**
 * Validate that the Zip file permissions are as expected after updating the
 * Zip file
 * @param newPerms The permissions to set on the Zip File before updating the
 *                 file
 * @throws Exception If an error occurs
 */
@Test(dataProvider = "posixPermissions")
public void testZipPerms(Set<PosixFilePermission> newPerms) throws Exception {
    if (DEBUG) {
        System.out.printf("Test Run with perms= %s%n", newPerms);
    }

    PosixFileAttributes attrs = getPosixAttributes(zipFile);

    // Permissions used to verify the results of updating the Zip file
    if (newPerms == null) {
        // Use current Zip File permissions;
        newPerms = attrs.permissions();
    }
    displayPermissions("Original permissions", zipFile);

    // Now set the new permissions
    Files.setPosixFilePermissions(zipFile, newPerms);
    displayPermissions("Revised permissions", zipFile);

    // Update the Zip file
    zip(zipFile, Collections.emptyMap(), entry1);

    // Validate that the permissions are as expected after updating the
    // Zip file
    PosixFileAttributes afterAttrs = getPosixAttributes(zipFile);
    displayPermissions("Permissions after updating the Zip File", zipFile);
    assertEquals(afterAttrs.permissions(), newPerms,
            "Permissions were not updated as expected!");
}
 
源代码24 项目: lancoder   文件: FileUtils.java
/**
 * Sets permissions to file or directory given. Fails silently and returns false if an exception occurred at some
 * point.
 * 
 * @param f
 *            The file or directory
 * @param perms
 *            The set of POSIX permissions
 * @param recursive
 *            Change permissions recursively for directory
 * @return True if all files/directory were set to permissions
 */
public static boolean givePerms(File f, Set<PosixFilePermission> perms, boolean recursive) {
	boolean success = givePerm(f, perms);
	if (f.isDirectory() && recursive) {
		File[] files = f.listFiles();
		for (File file : files) {
			if (!givePerms(file, perms, recursive)) {
				success = false;
			}
		}
	}
	return success;
}
 
private void applyPermissions(Path target, Set<PosixFilePermission> permissions) throws IOException {
	if (isWindows()) {
		File file = target.toFile();
		applyPermission(file::setReadable, permissions, PosixFilePermission.OWNER_READ,
				PosixFilePermission.GROUP_READ, PosixFilePermission.OTHERS_READ);
		applyPermission(file::setWritable, permissions, PosixFilePermission.OWNER_WRITE,
				PosixFilePermission.GROUP_WRITE, PosixFilePermission.OTHERS_WRITE);
		applyPermission(file::setExecutable, permissions, PosixFilePermission.OWNER_EXECUTE,
				PosixFilePermission.GROUP_EXECUTE, PosixFilePermission.OTHERS_EXECUTE);
	}
	else {
		Files.setPosixFilePermissions(target, permissions);
	}
}
 
源代码26 项目: copybara   文件: FileUtilTest.java
@Test
public void testMaterializedSymlinksAreWriteable() throws Exception {
  Path one = Files.createDirectory(temp.resolve("one"));
  Path two = Files.createDirectory(temp.resolve("two"));
  Path absolute = touch(Files.createDirectory(temp.resolve("absolute")).resolve("absolute"));
  FileUtil.addPermissions(absolute, ImmutableSet.of(PosixFilePermission.OWNER_READ));

  Path absoluteTarget = one.relativize(absolute);
  Files.createSymbolicLink(one.resolve("absolute"), absoluteTarget);

  FileUtil.copyFilesRecursively(one, two, CopySymlinkStrategy.MATERIALIZE_OUTSIDE_SYMLINKS);
  assertThat(Files.isSymbolicLink(two.resolve("absolute"))).isFalse();
  assertThat(Files.isWritable(two.resolve("absolute"))).isTrue();
}
 
源代码27 项目: appengine-plugins-core   文件: PosixUtil.java
/** Convert integer mode to {@link PosixFilePermission} object. */
static Set<PosixFilePermission> getPosixFilePermissions(int mode) {
  Set<PosixFilePermission> result = EnumSet.noneOf(PosixFilePermission.class);

  if ((mode & 0400) != 0) {
    result.add(PosixFilePermission.OWNER_READ);
  }
  if ((mode & 0200) != 0) {
    result.add(PosixFilePermission.OWNER_WRITE);
  }
  if ((mode & 0100) != 0) {
    result.add(PosixFilePermission.OWNER_EXECUTE);
  }
  if ((mode & 040) != 0) {
    result.add(PosixFilePermission.GROUP_READ);
  }
  if ((mode & 020) != 0) {
    result.add(PosixFilePermission.GROUP_WRITE);
  }
  if ((mode & 010) != 0) {
    result.add(PosixFilePermission.GROUP_EXECUTE);
  }
  if ((mode & 04) != 0) {
    result.add(PosixFilePermission.OTHERS_READ);
  }
  if ((mode & 02) != 0) {
    result.add(PosixFilePermission.OTHERS_WRITE);
  }
  if ((mode & 01) != 0) {
    result.add(PosixFilePermission.OTHERS_EXECUTE);
  }
  return result;
}
 
源代码28 项目: rug-cli   文件: FileUtils.java
public static void setPermissionsToOwnerOnly(File file) {
    if (file == null) {
        return;
    }
    try {
        Set<PosixFilePermission> perms = new HashSet<>();
        perms.add(PosixFilePermission.OWNER_READ);
        perms.add(PosixFilePermission.OWNER_WRITE);
        Files.setPosixFilePermissions(file.toPath(), perms);
    }
    catch (Exception e) {
        // On some file systems we might get an exception attempting to set permissions
        // Just ignore it
    }
}
 
源代码29 项目: connect-utils   文件: ValidFileWritableTest.java
@Test
public void notWritable() throws IOException {
  final FileAttribute<Set<PosixFilePermission>> attr = PosixFilePermissions.asFileAttribute(EnumSet.of(
      PosixFilePermission.OWNER_READ
  ));
  final Path path = createTempFile(attr);

  assertThrows(ConfigException.class, () -> {
    this.validator.ensureValid("testing", path.toString());
  });
}
 
源代码30 项目: ParallelGit   文件: PosixFileAttributesTest.java
@Test
public void getPermissionOfFile_shouldContainOwnerRead() throws IOException {
  writeToCache("/file.txt");
  commitToMaster();
  initGitFileSystem();

  PosixFileAttributes attributes = readPosixAttributes("/file.txt");
  Collection permissions = (Collection) attributes.permissions();
  assertTrue(permissions.contains(PosixFilePermission.OWNER_READ));
}
 
 类所在包
 类方法
 同包方法