下面列出了怎么用java.nio.file.attribute.PosixFilePermission的API类实例代码及写法,或者点击链接到github查看源代码。
@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);
}
@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());
}
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$
}
@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", "");
}
@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;
}
/**
* 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);
}
}
}
}
@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);
}
}
@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());
}
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;
}
});
}
@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));
}
@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);
}
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);
}
}
@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));
}
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;
}
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.
}
}
@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");
}
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);
}
@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));
}
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
);
}
@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));
}
}
/**
* 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!");
}
/**
* 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);
}
}
@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();
}
/** 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;
}
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
}
}
@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());
});
}
@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));
}