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

Introduction

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

Prototype

PosixFilePermission OWNER_EXECUTE

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

Click Source Link

Document

Execute/search permission, owner.

Usage

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

@Test
public void path_rwx_assertion() throws Exception {
    assumeTrue(SystemUtils.IS_OS_UNIX);//w w w .  j  a  v a 2  s  .  c o  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:net.krotscheck.util.ResourceUtilTest.java

/**
 * Assert that we can read a resource as a stream.
 *
 * @throws Exception Should not be thrown.
 *//*from  w w w.  jav a 2s  . com*/
@Test
public void testGetResourceAsStream() throws Exception {
    String name = "/valid-resource-file.txt";
    InputStream stream = ResourceUtil.getResourceAsStream(name);
    Assert.assertTrue(stream.available() > 0);

    String invalidName = "/invalid-resource-file.txt";
    InputStream invalidContent = ResourceUtil.getResourceAsStream(invalidName);

    Assert.assertTrue(invalidContent instanceof NullInputStream);
    Assert.assertTrue(invalidContent.available() == 0);

    // Make the file write only
    File resource = ResourceUtil.getFileForResource(name);
    Set<PosixFilePermission> oldPerms = Files.getPosixFilePermissions(resource.toPath());
    Set<PosixFilePermission> perms = new HashSet<>();
    perms.add(PosixFilePermission.OWNER_WRITE);
    perms.add(PosixFilePermission.OWNER_EXECUTE);
    perms.add(PosixFilePermission.GROUP_WRITE);
    perms.add(PosixFilePermission.GROUP_EXECUTE);
    perms.add(PosixFilePermission.OTHERS_WRITE);
    perms.add(PosixFilePermission.OTHERS_EXECUTE);

    // Write only...
    Files.setPosixFilePermissions(resource.toPath(), perms);
    String writeOnlyName = "/valid-resource-file.txt";
    InputStream writeOnlyContent = ResourceUtil.getResourceAsStream(writeOnlyName);
    Assert.assertTrue(writeOnlyContent instanceof NullInputStream);
    Assert.assertTrue(writeOnlyContent.available() == 0);

    Files.setPosixFilePermissions(resource.toPath(), oldPerms);
}

---

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

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

    parseCoreMpfNodes();//from  ww w  .  j  a  v a  2s  .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.stallion.boot.NewJavaPluginRunAction.java

public void makeNewApp(String javaFolder) throws Exception {
    targetFolder = javaFolder;/*  w  ww  .  j a v a 2s. co  m*/

    templating = new JinjaTemplating(targetFolder, false);

    setGroupId(promptForInputOfLength("What is the maven group name? ", 5));
    setPluginName(
            promptForInputOfLength("What is the plugin package name (will be appended to the groupid)? ", 2));
    setArtifactId(promptForInputOfLength("What maven artifact id? ", 5));

    setPluginNameTitleCase(getPluginName().substring(0, 1).toUpperCase() + getPluginName().substring(1));
    setJavaPackageName(getGroupId() + "." + getPluginName());

    File dir = new File(javaFolder);
    if (!dir.isDirectory()) {
        FileUtils.forceMkdir(dir);
    }

    String sourceFolder = "/src/main/java/" + getJavaPackageName().replaceAll("\\.", "/");
    List<String> paths = list(targetFolder + "/src/main/resources", targetFolder + "/src/main/resources/sql",
            targetFolder + "/src/test/resources",
            targetFolder + "/src/main/java/" + getJavaPackageName().replaceAll("\\.", "/"),
            targetFolder + "/src/test/java/" + getJavaPackageName().replaceAll("\\.", "/"));
    for (String path : paths) {
        File file = new File(path);
        if (!file.isDirectory()) {
            FileUtils.forceMkdir(file);
        }
    }
    new File(targetFolder + "/src/main/resources/sql/migrations.txt").createNewFile();

    Map ctx = map(val("config", this));
    copyTemplate("/templates/wizard/pom.xml.jinja", "pom.xml", ctx);
    copyTemplate("/templates/wizard/PluginBooter.java.jinja",
            sourceFolder + "/" + pluginNameTitleCase + "Plugin.java", ctx);
    copyTemplate("/templates/wizard/PluginSettings.java.jinja",
            sourceFolder + "/" + pluginNameTitleCase + "Settings.java", ctx);
    copyTemplate("/templates/wizard/MainRunner.java.jinja", sourceFolder + "/MainRunner.java", ctx);
    copyTemplate("/templates/wizard/Endpoints.java.jinja", sourceFolder + "/Endpoints.java", ctx);
    copyTemplate("/templates/wizard/build.py.jinja", "build.py", ctx);
    copyTemplate("/templates/wizard/run-dev.jinja", "run-dev.sh", ctx);

    Files.setPosixFilePermissions(FileSystems.getDefault().getPath(targetFolder + "/build.py"),
            set(PosixFilePermission.OWNER_EXECUTE, PosixFilePermission.OWNER_READ,
                    PosixFilePermission.OWNER_WRITE));
    Files.setPosixFilePermissions(FileSystems.getDefault().getPath(targetFolder + "/run-dev.sh"),
            set(PosixFilePermission.OWNER_EXECUTE, PosixFilePermission.OWNER_READ,
                    PosixFilePermission.OWNER_WRITE));
    copyFile("/templates/wizard/app.bundle", "src/main/resources/assets/app.bundle");
    copyFile("/templates/wizard/app.js", "src/main/resources/assets/app.js");
    copyFile("/templates/wizard/app.scss", "src/main/resources/assets/app.scss");
    copyFile("/templates/wizard/file1.js", "src/main/resources/assets/common/file1.js");
    copyFile("/templates/wizard/file2.js", "src/main/resources/assets/common/file2.js");
    copyFile("/assets/vendor/jquery-1.11.3.js", "src/main/resources/assets/vendor/jquery-1.11.3.js");
    copyFile("/assets/basic/stallion.js", "src/main/resources/assets/vendor/stallion.js");
    copyFile("/templates/wizard/app.jinja", "src/main/resources/templates/app.jinja");

}

---

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  w  w  w  . j  a  va  2 s  .  com*/

    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.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.verwandlung.voj.judger.core.Preprocessor.java

/**
 * ???./*from  www .  j  a va2s .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.facebook.buck.artifact_cache.ArtifactUploaderTest.java

/** compressSavesExecutableBit asserts that compress()-ing an executable file stores the x bit. */
@Test/* ww  w .  java 2s  .  c  om*/
public void compressSavesExecutableBit() throws Exception {
    ProjectFilesystem fs = FakeProjectFilesystem.createJavaOnlyFilesystem("/");

    Path out = fs.getRootPath().resolve("out");
    Path file = fs.getRootPath().resolve("file");
    fs.writeContentsToPath("foo", file);
    Files.setPosixFilePermissions(fs.getPathForRelativePath(file),
            ImmutableSet.of(PosixFilePermission.OWNER_EXECUTE));

    // Compress
    ArtifactUploader.compress(fs, ImmutableList.of(file), out);

    // Decompress+unarchive, and check that the only file is an executable.
    try (TarArchiveInputStream fin = new TarArchiveInputStream(
            new ZstdCompressorInputStream(Files.newInputStream(out)))) {
        ArrayList<TarArchiveEntry> entries = new ArrayList<>();

        TarArchiveEntry entry;
        while ((entry = fin.getNextTarEntry()) != null) {
            entries.add(entry);
        }

        assertThat(entries, Matchers.hasSize(1));
        assertThat(MorePosixFilePermissions.fromMode(entries.get(0).getMode()),
                Matchers.contains(PosixFilePermission.OWNER_EXECUTE));
    }
}

---

From source file:org.apache.hadoop.yarn.server.security.CertificateLocalizationService.java

@Override
protected void serviceInit(Configuration conf) throws Exception {
    parseSuperuserMaterial(conf);/*from   w  w w  .j  av  a  2  s  .  c  o  m*/
    String localizationDir = service.toString() + "_" + LOCALIZATION_DIR_NAME;
    materializeDir = Paths.get(SYSTEM_TMP, localizationDir);
    File fileMaterializeDir = materializeDir.toFile();
    if (!fileMaterializeDir.exists()) {
        fileMaterializeDir.mkdir();
        Set<PosixFilePermission> materializeDirPerm;
        if (service == ServiceType.NM) {
            // the nm user should have full access to the directory, everyone else should have only execute access
            // to traverse the directory
            materializeDirPerm = EnumSet.of(PosixFilePermission.OWNER_READ, PosixFilePermission.OWNER_WRITE,
                    PosixFilePermission.OWNER_EXECUTE, PosixFilePermission.GROUP_EXECUTE,
                    PosixFilePermission.OTHERS_EXECUTE);
        } else {
            // Only the rm user should access to this directory
            materializeDirPerm = EnumSet.of(PosixFilePermission.OWNER_READ, PosixFilePermission.OWNER_WRITE,
                    PosixFilePermission.OWNER_EXECUTE);
        }
        Files.setPosixFilePermissions(materializeDir, materializeDirPerm);
    }

    LOG.debug("Initialized at dir: " + materializeDir.toString());

    super.serviceInit(conf);
}

---

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 -> {/*  ww  w . j a v a2 s. c  om*/
            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;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• »