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

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

Introduction

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

Prototype

PosixFilePermission OWNER_READ

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

Click Source Link

Document

Read permission, owner.

Usage

From source file:org.kitodo.services.command.CommandServiceTest.java

public 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:com.streamsets.datacollector.MiniSDCTestingUtility.java

public static void setExecutePermission(Path path) throws IOException {
    Set<PosixFilePermission> set = new HashSet<PosixFilePermission>();
    set.add(PosixFilePermission.OWNER_EXECUTE);
    set.add(PosixFilePermission.OWNER_READ);
    set.add(PosixFilePermission.OWNER_WRITE);
    set.add(PosixFilePermission.OTHERS_READ);
    Files.setPosixFilePermissions(path, set);
}

From source file:uk.ac.ebi.metabolights.webservice.utils.FileUtil.java

/**
 * Create a private FTP folder for uploading big study files
 *
 * @param folder//ww  w  .ja  v  a2s  .  c  o m
 * @return a String containing created folder
 * @author jrmacias
 * @date 20151102
 */
@PostConstruct
public static Path createFtpFolder(String folder) throws IOException {

    String privateFTPRoot = PropertiesUtil.getProperty("privateFTPRoot"); // ~/ftp_private/

    // create the folder
    File ftpFolder = new File(privateFTPRoot + File.separator + folder);
    Path folderPath = ftpFolder.toPath();
    if (!ftpFolder.mkdir())
        throw new IOException();

    // set folder owner, group and access permissions
    // 'chmod 770'
    UserPrincipalLookupService lookupService = FileSystems.getDefault().getUserPrincipalLookupService();
    Set<PosixFilePermission> perms = new HashSet<PosixFilePermission>();
    // owner permissions
    perms.add(PosixFilePermission.OWNER_READ);
    perms.add(PosixFilePermission.OWNER_WRITE);
    perms.add(PosixFilePermission.OWNER_EXECUTE);
    // group permissions
    perms.add(PosixFilePermission.GROUP_READ);
    perms.add(PosixFilePermission.GROUP_WRITE);
    perms.add(PosixFilePermission.GROUP_EXECUTE);
    // apply changes
    Files.getFileAttributeView(folderPath, PosixFileAttributeView.class, LinkOption.NOFOLLOW_LINKS)
            .setPermissions(perms);

    return folderPath;
}

From source file:org.eclipse.tycho.plugins.tar.TarGzArchiverTest.java

private void setPermissionsTo700() {
    try {//w  w w . jav  a 2 s  .  c o m
        Set<PosixFilePermission> perms = new HashSet<PosixFilePermission>();
        perms.add(PosixFilePermission.OWNER_READ);
        perms.add(PosixFilePermission.OWNER_WRITE);
        perms.add(PosixFilePermission.OWNER_EXECUTE);
        Files.setPosixFilePermissions(testPermissionsFile.toPath(), perms);
    } catch (Exception e) {
        Assume.assumeNoException("skip test on filesystems that do not support POSIX file permissions", e);
    }
}

From source file:com.spectralogic.ds3client.metadata.MetadataReceivedListenerImpl_Test.java

@Test
public void testGettingMetadataFailureHandler() throws IOException, InterruptedException {
    Assume.assumeFalse(Platform.isWindows());

    try {//from   www  .  jav a2s. c o m
        final String tempPathPrefix = null;
        final Path tempDirectory = Files.createTempDirectory(Paths.get("."), tempPathPrefix);

        final String fileName = "Gracie.txt";

        final Path filePath = Files.createFile(Paths.get(tempDirectory.toString(), fileName));

        try {
            // set permissions
            if (!Platform.isWindows()) {
                final PosixFileAttributes attributes = Files.readAttributes(filePath,
                        PosixFileAttributes.class);
                final Set<PosixFilePermission> permissions = attributes.permissions();
                permissions.clear();
                permissions.add(PosixFilePermission.OWNER_READ);
                permissions.add(PosixFilePermission.OWNER_WRITE);
                Files.setPosixFilePermissions(filePath, permissions);
            }

            // get permissions
            final ImmutableMap.Builder<String, Path> fileMapper = ImmutableMap.builder();
            fileMapper.put(filePath.toString(), filePath);
            final Map<String, String> metadataFromFile = new MetadataAccessImpl(fileMapper.build())
                    .getMetadataValue(filePath.toString());

            FileUtils.deleteDirectory(tempDirectory.toFile());

            // put old permissions back
            final Metadata metadata = new MetadataImpl(new MockedHeadersReturningKeys(metadataFromFile));

            final AtomicInteger numTimesFailureHandlerCalled = new AtomicInteger(0);

            new MetadataReceivedListenerImpl(tempDirectory.toString(), new FailureEventListener() {
                @Override
                public void onFailure(final FailureEvent failureEvent) {
                    numTimesFailureHandlerCalled.incrementAndGet();
                    assertEquals(FailureEvent.FailureActivity.RestoringMetadata, failureEvent.doingWhat());
                }
            }, "localhost").metadataReceived(fileName, metadata);

            assertEquals(1, numTimesFailureHandlerCalled.get());
        } finally {
            FileUtils.deleteDirectory(tempDirectory.toFile());
        }
    } catch (final Throwable t) {
        fail("Throwing exceptions from metadata est verbotten");
    }
}

From source file:org.kitodo.services.command.CommandServiceTest.java

public 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:com.ibm.ecm.extension.aspera.AsperaPlugin.java

private Path makeFileExecutable(final Path file) throws AsperaPluginException {
    final Set<PosixFilePermission> perms = new HashSet<>();
    perms.add(PosixFilePermission.OWNER_READ);
    perms.add(PosixFilePermission.OWNER_WRITE);
    perms.add(PosixFilePermission.OWNER_EXECUTE);
    perms.add(PosixFilePermission.GROUP_READ);
    perms.add(PosixFilePermission.GROUP_EXECUTE);
    try {//  w w w .  ja  va2  s  . com
        Files.setPosixFilePermissions(file, perms);
    } catch (final IOException e) {
        throw new AsperaPluginException("Failed to make the file executable: " + file, e);
    }

    return file;
}

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

@PostConstruct
public void init() {
    File tmpDir = new File(settings.getHopsworksTmpCertDir());
    if (!tmpDir.exists()) {
        throw new IllegalStateException(
                "Transient certificates directory <" + tmpDir.getAbsolutePath() + "> does NOT exist!");
    }//  w  w w.j  av  a 2 s. com

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

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

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

        // Permissions should be 750
        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(permissions);
            LOG.log(Level.INFO, "Passed permissions check for " + tmpDir.getAbsolutePath() + ". Owner: " + owner
                    + " Group: " + group + " permissions: " + permStr);
        } else {
            throw new IllegalStateException(
                    "Wrong permissions for " + tmpDir.getAbsolutePath() + ", it should be 0750");
        }
    } catch (UnsupportedOperationException ex) {
        LOG.log(Level.WARNING,
                "Associated filesystem is not POSIX compliant. "
                        + "Continue without checking the permissions of " + tmpDir.getAbsolutePath()
                        + " This might be a security problem.");
    } catch (IOException ex) {
        throw new IllegalStateException(
                "Error while getting filesystem " + "permissions of " + tmpDir.getAbsolutePath(), ex);
    }

    try {
        FileUtils.cleanDirectory(tmpDir);
    } catch (IOException ex) {
        LOG.log(Level.WARNING, "Could not clean directory " + tmpDir.getAbsolutePath()
                + " during startup, there might be stale " + "certificates", ex);
    }
    transientDir = tmpDir.getAbsolutePath();
    String delayRaw = settings.getCertificateMaterializerDelay();
    DELAY_VALUE = settings.getConfTimeValue(delayRaw);
    DELAY_TIMEUNIT = settings.getConfTimeTimeUnit(delayRaw);

    try {
        String hostAddress = InetAddress.getLocalHost().getHostAddress();
        long threadId = Thread.currentThread().getId();
        String lock_identifier = hostAddress + "_" + threadId;
        lock_id = lock_identifier.length() <= 30 ? lock_identifier : lock_identifier.substring(0, 30);
    } catch (UnknownHostException ex) {
        throw new IllegalStateException(ex);
    }
}

From source file:org.esa.s2tbx.dataio.gdal.GDALInstaller.java

private static void setExecutablePermissions(Path executablePathName) {
    if (IS_OS_UNIX) {
        Set<PosixFilePermission> permissions = new HashSet<>(Arrays.asList(PosixFilePermission.OWNER_READ,
                PosixFilePermission.OWNER_WRITE, PosixFilePermission.OWNER_EXECUTE,
                PosixFilePermission.GROUP_READ, PosixFilePermission.GROUP_EXECUTE,
                PosixFilePermission.OTHERS_READ, PosixFilePermission.OTHERS_EXECUTE));
        try {//from  ww  w .  jav a 2  s . c  om
            Files.setPosixFilePermissions(executablePathName, permissions);
        } catch (IOException e) {
            // can't set the permissions for this file, eg. the file was installed as root
            // send a warning message, user will have to do that by hand.
            logger.log(Level.SEVERE,
                    "Can't set execution permissions for executable " + executablePathName.toString()
                            + ". If required, please ask an authorised user to make the file executable.",
                    e);
        }
    }
}

From source file:android.databinding.compilationTest.BaseCompilationTest.java

private void setExecutable() throws IOException {
    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);
    //add others permissions
    perms.add(PosixFilePermission.OTHERS_READ);
    Files.setPosixFilePermissions(Paths.get(new File(testFolder, "gradlew").getAbsolutePath()), perms);
}