Example usage for java.nio.file.attribute PosixFilePermission OTHERS_READ

List of usage examples for java.nio.file.attribute PosixFilePermission OTHERS_READ

  1. HOME
  2. Java
  3. java
  4. java.nio.file.attribute.*
  5. PosixFilePermission
  6. OTHERS_READ

Introduction

In this page you can find the example usage for java.nio.file.attribute PosixFilePermission OTHERS_READ.

Prototype

PosixFilePermission OTHERS_READ

To view the source code for java.nio.file.attribute PosixFilePermission OTHERS_READ.

Click Source Link

Document

Read permission, others.

Usage

From source file:org.kitodo.command.CommandTest.java

private static void setFileExecuteable(File file) throws IOException {
    Set<PosixFilePermission> perms = new HashSet<>();

    perms.add(PosixFilePermission.OWNER_READ);
    perms.add(PosixFilePermission.OWNER_WRITE);
    perms.add(PosixFilePermission.OWNER_EXECUTE);

    perms.add(PosixFilePermission.OTHERS_READ);
    perms.add(PosixFilePermission.OTHERS_WRITE);
    perms.add(PosixFilePermission.OTHERS_EXECUTE);

    perms.add(PosixFilePermission.GROUP_READ);
    perms.add(PosixFilePermission.GROUP_WRITE);
    perms.add(PosixFilePermission.GROUP_EXECUTE);

    Files.setPosixFilePermissions(file.toPath(), perms);
}

From source file:org.assertj.examples.PathAssertionsExamples.java

@Test
public void path_rwx_assertion() throws Exception {
    assumeTrue(SystemUtils.IS_OS_UNIX);//from   w  w w . j a  va2s  . co m

    // Create a file and set permissions to be readable by all.
    write(rwxFile, "rwx file".getBytes());

    // using PosixFilePermission to set file permissions 777
    Set<PosixFilePermission> perms = new HashSet<PosixFilePermission>();
    // add owners permission
    perms.add(PosixFilePermission.OWNER_READ);
    perms.add(PosixFilePermission.OWNER_WRITE);
    perms.add(PosixFilePermission.OWNER_EXECUTE);
    // add group permissions
    perms.add(PosixFilePermission.GROUP_READ);
    perms.add(PosixFilePermission.GROUP_WRITE);
    perms.add(PosixFilePermission.GROUP_EXECUTE);
    // add others permissions
    perms.add(PosixFilePermission.OTHERS_READ);
    perms.add(PosixFilePermission.OTHERS_WRITE);
    perms.add(PosixFilePermission.OTHERS_EXECUTE);

    Files.setPosixFilePermissions(rwxFile, perms);

    final Path symlinkToRwxFile = FileSystems.getDefault().getPath("symlink-to-rwxFile");
    if (!Files.exists(symlinkToRwxFile)) {
        createSymbolicLink(symlinkToRwxFile, rwxFile);
    }

    // The following assertions succeed:
    assertThat(rwxFile).isReadable().isWritable().isExecutable();

    assertThat(symlinkToRwxFile).isReadable().isWritable().isExecutable();
}

From source file:org.roda.core.plugins.InternalPluginsTest.java

@BeforeClass
public void setUp() throws Exception {
    basePath = TestsHelper.createBaseTempDir(getClass(), true,
            PosixFilePermissions.asFileAttribute(new HashSet<>(Arrays.asList(PosixFilePermission.OWNER_READ,
                    PosixFilePermission.OWNER_WRITE, PosixFilePermission.OWNER_EXECUTE,
                    PosixFilePermission.OTHERS_READ, PosixFilePermission.OTHERS_EXECUTE))));

    boolean deploySolr = true;
    boolean deployLdap = true;
    boolean deployFolderMonitor = true;
    boolean deployOrchestrator = true;
    boolean deployPluginManager = true;
    boolean deployDefaultResources = false;
    RodaCoreFactory.instantiateTest(deploySolr, deployLdap, deployFolderMonitor, deployOrchestrator,
            deployPluginManager, deployDefaultResources);
    model = RodaCoreFactory.getModelService();
    index = RodaCoreFactory.getIndexService();

    LOGGER.info("Running internal plugins tests under storage {}", basePath);
}

From source file:org.everit.osgi.dev.maven.util.FileManager.java

private static void setPermissionsOnFileInNonPosixSystem(final File file,
        final Set<PosixFilePermission> perms) {

    if (perms.contains(PosixFilePermission.OWNER_EXECUTE)) {
        file.setExecutable(true, !perms.contains(PosixFilePermission.OTHERS_EXECUTE));
    }/*from ww w .  j  a  v  a 2 s  .c  om*/

    if (perms.contains(PosixFilePermission.OWNER_READ)) {
        file.setReadable(true, !perms.contains(PosixFilePermission.OTHERS_READ));
    }

    if (perms.contains(PosixFilePermission.OWNER_WRITE)) {
        file.setWritable(true, !perms.contains(PosixFilePermission.OTHERS_WRITE));
    }

}

From source file:org.kitodo.command.CommandTest.java

private static void setFileNotExecuteable(File file) throws IOException {
    Set<PosixFilePermission> perms = new HashSet<>();

    perms.add(PosixFilePermission.OWNER_READ);
    perms.add(PosixFilePermission.OWNER_WRITE);

    perms.add(PosixFilePermission.OTHERS_READ);
    perms.add(PosixFilePermission.OTHERS_WRITE);

    perms.add(PosixFilePermission.GROUP_READ);
    perms.add(PosixFilePermission.GROUP_WRITE);

    Files.setPosixFilePermissions(file.toPath(), perms);
}

From source file:org.verwandlung.voj.judger.core.Preprocessor.java

/**
 * ???.//  ww w . ja v  a2 s . c  o m
 * Linux, ?UID=1536?, ?Others???.
 * @param workDirectory 
 */
private void setWorkDirectoryPermission(File workDirectory) throws IOException {
    if (!System.getProperty("os.name").contains("Windows")) {
        Set<PosixFilePermission> permissions = new HashSet<>();

        permissions.add(PosixFilePermission.OWNER_READ);
        permissions.add(PosixFilePermission.OWNER_WRITE);
        permissions.add(PosixFilePermission.OWNER_EXECUTE);

        permissions.add(PosixFilePermission.GROUP_READ);
        permissions.add(PosixFilePermission.GROUP_WRITE);
        permissions.add(PosixFilePermission.GROUP_EXECUTE);

        permissions.add(PosixFilePermission.OTHERS_READ);
        permissions.add(PosixFilePermission.OTHERS_WRITE);
        permissions.add(PosixFilePermission.OTHERS_EXECUTE);
        Files.setPosixFilePermissions(workDirectory.toPath(), permissions);
    }
}

From source file:com.streamsets.datacollector.el.TestRuntimeEL.java

@Test
public void testLoadResource() throws Exception {
    Path fooFile = Paths.get(resourcesDir.getPath(), "foo.txt");
    try {/*from   ww  w  .ja v  a2  s . co  m*/
        Files.write(fooFile, "Hello".getBytes(StandardCharsets.UTF_8));
        RuntimeEL.loadRuntimeConfiguration(runtimeInfo);
        Assert.assertNull(RuntimeEL.loadResource("bar.txt", false));
        Assert.assertNull(RuntimeEL.loadResource("bar.txt", true));
        Assert.assertEquals("Hello", RuntimeEL.loadResource("foo.txt", false));
        try {
            RuntimeEL.loadResource("foo.txt", true);
            Assert.fail();
        } catch (IllegalArgumentException ex) {
            //nop
        } catch (Exception ex) {
            Assert.fail();
        }
        Files.setPosixFilePermissions(fooFile,
                ImmutableSet.of(PosixFilePermission.OWNER_READ, PosixFilePermission.OWNER_WRITE));
        Assert.assertEquals("Hello", RuntimeEL.loadResource("foo.txt", true));

        try {
            Files.setPosixFilePermissions(fooFile, ImmutableSet.of(PosixFilePermission.OTHERS_READ));
            Assert.assertEquals("Hello", RuntimeEL.loadResource("foo.txt", true));
            Assert.fail();
        } catch (IllegalArgumentException ex) {
            //NOP
        }

        try {
            Files.setPosixFilePermissions(fooFile, ImmutableSet.of(PosixFilePermission.OTHERS_WRITE));
            Assert.assertEquals("Hello", RuntimeEL.loadResource("foo.txt", true));
            Assert.fail();
        } catch (IllegalArgumentException ex) {
            //NOP
        }
    } finally {
        Files.setPosixFilePermissions(fooFile,
                ImmutableSet.of(PosixFilePermission.OWNER_READ, PosixFilePermission.OWNER_WRITE));
    }
}

From source file:org.ng200.openolympus.cerberus.executors.JavaExecutor.java

@Override
public ExecutionResult execute(final Path program) throws IOException {

    final Path chrootRoot = this.storage.getPath().resolve("chroot");

    final Path chrootedProgram = chrootRoot.resolve(program.getFileName().toString());

    FileAccess.createDirectories(chrootedProgram);
    FileAccess.copyDirectory(program, chrootedProgram, StandardCopyOption.REPLACE_EXISTING,
            StandardCopyOption.COPY_ATTRIBUTES);

    final Path outOfMemoryFile = chrootRoot.resolve("outOfMemory");

    final Path policyFile = this.storage.getPath().resolve("olymp.policy");

    try (Stream<Path> paths = FileAccess.walkPaths(storage.getPath())) {
        paths.forEach(path -> {//from   w  w  w  .  j  a  v  a  2s  . co  m
            try {
                Files.setPosixFilePermissions(path,
                        new HashSet<PosixFilePermission>(
                                Lists.from(PosixFilePermission.OWNER_EXECUTE, PosixFilePermission.OWNER_READ,
                                        PosixFilePermission.OWNER_WRITE, PosixFilePermission.GROUP_EXECUTE,
                                        PosixFilePermission.GROUP_READ, PosixFilePermission.GROUP_WRITE,
                                        PosixFilePermission.OTHERS_EXECUTE, PosixFilePermission.OTHERS_READ)));
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
    }

    this.buildPolicy(chrootRoot, policyFile);

    final CommandLine commandLine = new CommandLine("sudo");
    commandLine.addArgument("olympus_watchdog");

    this.setUpOlrunnerLimits(commandLine);

    commandLine.addArgument("--security=0");
    commandLine.addArgument("--jail=/");

    commandLine.addArgument("--");

    commandLine.addArgument("/usr/bin/java");

    commandLine.addArgument("-classpath");
    commandLine.addArgument(chrootedProgram.toAbsolutePath().toString());
    commandLine.addArgument("-Djava.security.manager");
    commandLine.addArgument("-Djava.security.policy=" + policyFile.toAbsolutePath().toString());

    commandLine.addArgument("-Xmx" + this.getMemoryLimit());
    commandLine.addArgument("-Xms" + this.getMemoryLimit());

    commandLine.addArgument(MessageFormat.format("-XX:OnOutOfMemoryError=touch {0}; echo \"\" > {0}",
            outOfMemoryFile.toAbsolutePath().toString()), false);

    commandLine.addArgument("Main");

    final DefaultExecutor executor = new DefaultExecutor();

    executor.setWatchdog(new ExecuteWatchdog(20000)); // 20 seconds for the
    // sandbox to
    // complete
    executor.setWorkingDirectory(chrootRoot.toFile());

    executor.setStreamHandler(new PumpStreamHandler(this.outputStream, this.errorStream, this.inputStream));
    try {
        executor.execute(commandLine);
    } catch (final IOException e) {
        if (!e.getMessage().toLowerCase().equals("stream closed")) {
            throw e;
        }
    }
    final ExecutionResult readOlrunnerVerdict = this.readOlrunnerVerdict(chrootRoot.resolve("verdict.txt"));

    if (FileAccess.exists(outOfMemoryFile)) {
        readOlrunnerVerdict.setResultType(ExecutionResultType.MEMORY_LIMIT);
    }

    readOlrunnerVerdict.setMemoryPeak(this.getMemoryLimit());

    return readOlrunnerVerdict;
}

From source file:org.mitre.mpf.wfm.util.PropertiesUtil.java

@PostConstruct
private void init() throws IOException, WfmProcessingException {

    parseCoreMpfNodes();//from  www. j  a  v a2s . c  o m

    mpfPropertiesConfig = mpfPropertiesConfigBuilder.getCompleteConfiguration();

    if (!mediaTypesFile.exists()) {
        copyResource(mediaTypesFile, getMediaTypesTemplate());
    }

    Set<PosixFilePermission> permissions = new HashSet<>();
    permissions.add(PosixFilePermission.OWNER_READ);
    permissions.add(PosixFilePermission.OWNER_WRITE);
    permissions.add(PosixFilePermission.OWNER_EXECUTE);

    Path share = Paths.get(getSharePath()).toAbsolutePath();
    if (!Files.exists(share)) {
        share = Files.createDirectories(share, PosixFilePermissions.asFileAttribute(permissions));
    }

    if (!Files.exists(share) || !Files.isDirectory(share)) {
        throw new WfmProcessingException(
                String.format("Failed to create the path '%s'. It does not exist or it is not a directory.",
                        share.toString()));
    }

    artifactsDirectory = createOrFail(share, "artifacts", permissions);
    markupDirectory = createOrFail(share, "markup", permissions);
    outputObjectsDirectory = createOrFail(share, "output-objects", permissions);
    remoteMediaCacheDirectory = createOrFail(share, "remote-media", permissions);
    uploadedComponentsDirectory = createOrFail(share, getComponentUploadDirName(), permissions);
    createOrFail(getPluginDeploymentPath().toPath(), "",
            EnumSet.of(PosixFilePermission.OWNER_READ, PosixFilePermission.OWNER_WRITE,
                    PosixFilePermission.OWNER_EXECUTE, PosixFilePermission.GROUP_READ,
                    PosixFilePermission.GROUP_EXECUTE, PosixFilePermission.OTHERS_READ,
                    PosixFilePermission.OTHERS_EXECUTE));

    // create the default models directory, although the user may have set "detection.models.dir.path" to something else
    createOrFail(share, "models", permissions);

    log.info("All file resources are stored within the shared directory '{}'.", share);
    log.debug("Artifacts Directory = {}", artifactsDirectory);
    log.debug("Markup Directory = {}", markupDirectory);
    log.debug("Output Objects Directory = {}", outputObjectsDirectory);
    log.debug("Remote Media Cache Directory = {}", remoteMediaCacheDirectory);
    log.debug("Uploaded Components Directory = {}", uploadedComponentsDirectory);
}

From source file:io.hops.hopsworks.common.security.CertificatesMgmService.java

@PostConstruct
public void init() {
    masterPasswordFile = new File(settings.getHopsworksMasterEncPasswordFile());
    if (!masterPasswordFile.exists()) {
        throw new IllegalStateException("Master encryption file does not exist");
    }//  ww  w  . ja  va2 s.c o m

    try {
        PosixFileAttributeView fileView = Files.getFileAttributeView(masterPasswordFile.toPath(),
                PosixFileAttributeView.class, LinkOption.NOFOLLOW_LINKS);
        Set<PosixFilePermission> filePermissions = fileView.readAttributes().permissions();
        boolean ownerRead = filePermissions.contains(PosixFilePermission.OWNER_READ);
        boolean ownerWrite = filePermissions.contains(PosixFilePermission.OWNER_WRITE);
        boolean ownerExecute = filePermissions.contains(PosixFilePermission.OWNER_EXECUTE);

        boolean groupRead = filePermissions.contains(PosixFilePermission.GROUP_READ);
        boolean groupWrite = filePermissions.contains(PosixFilePermission.GROUP_WRITE);
        boolean groupExecute = filePermissions.contains(PosixFilePermission.GROUP_EXECUTE);

        boolean othersRead = filePermissions.contains(PosixFilePermission.OTHERS_READ);
        boolean othersWrite = filePermissions.contains(PosixFilePermission.OTHERS_WRITE);
        boolean othersExecute = filePermissions.contains(PosixFilePermission.OTHERS_EXECUTE);

        // Permissions should be 700
        if ((ownerRead && ownerWrite && ownerExecute) && (!groupRead && !groupWrite && !groupExecute)
                && (!othersRead && !othersWrite && !othersExecute)) {
            String owner = fileView.readAttributes().owner().getName();
            String group = fileView.readAttributes().group().getName();
            String permStr = PosixFilePermissions.toString(filePermissions);
            LOG.log(Level.INFO, "Passed permissions check for file " + masterPasswordFile.getAbsolutePath()
                    + ". Owner: " + owner + " Group: " + group + " Permissions: " + permStr);
        } else {
            throw new IllegalStateException("Wrong permissions for file " + masterPasswordFile.getAbsolutePath()
                    + ", it should be 700");
        }

    } catch (UnsupportedOperationException ex) {
        LOG.log(Level.WARNING,
                "Associated filesystem is not POSIX compliant. "
                        + "Continue without checking the permissions of " + masterPasswordFile.getAbsolutePath()
                        + " This might be a security problem.");
    } catch (IOException ex) {
        throw new IllegalStateException(
                "Error while getting POSIX permissions of " + masterPasswordFile.getAbsolutePath());
    }

    // Register handlers when master encryption password changes
    MasterPasswordChangeHandler<CertsFacade> psUserCertsHandler = new PSUserCertsMasterPasswordHandler(
            userFacade);
    psUserCertsHandler.setFacade(certsFacade);
    registerMasterPasswordChangeHandler(UserCerts.class, psUserCertsHandler);

    MasterPasswordChangeHandler<CertsFacade> pgUserCertsHandler = new PGUserCertsMasterPasswordHandler(
            projectFacade);
    pgUserCertsHandler.setFacade(certsFacade);
    registerMasterPasswordChangeHandler(ProjectGenericUserCerts.class, pgUserCertsHandler);

    MasterPasswordChangeHandler<ClusterCertificateFacade> delaClusterCertsHandler = new DelaCertsMasterPasswordHandler(
            settings);
    delaClusterCertsHandler.setFacade(clusterCertificateFacade);
    registerMasterPasswordChangeHandler(ClusterCertificate.class, delaClusterCertsHandler);
}