Examples with PosixFilePermission java.nio.file.attribute.PosixFilePermission used on opensource projects

Example 76 with PosixFilePermission

use of java.nio.file.attribute.PosixFilePermission in project nifi by apache.

the class RunNiFi method savePidProperties.

private synchronized void savePidProperties(final Properties pidProperties, final Logger logger) throws IOException {
    final String pid = pidProperties.getProperty(PID_KEY);
    if (!StringUtils.isBlank(pid)) {
        writePidFile(pid, logger);
    }
    final File statusFile = getStatusFile(logger);
    if (statusFile.exists() && !statusFile.delete()) {
        logger.warn("Failed to delete {}", statusFile);
    }
    if (!statusFile.createNewFile()) {
        throw new IOException("Failed to create file " + statusFile);
    }
    try {
        final Set<PosixFilePermission> perms = new HashSet<>();
        perms.add(PosixFilePermission.OWNER_READ);
        perms.add(PosixFilePermission.OWNER_WRITE);
        Files.setPosixFilePermissions(statusFile.toPath(), perms);
    } catch (final Exception e) {
        logger.warn("Failed to set permissions so that only the owner can read status file {}; " + "this may allows others to have access to the key needed to communicate with NiFi. " + "Permissions should be changed so that only the owner can read this file", statusFile);
    }
    try (final FileOutputStream fos = new FileOutputStream(statusFile)) {
        pidProperties.store(fos, null);
        fos.getFD().sync();
    }
    logger.debug("Saved Properties {} to {}", new Object[] { pidProperties, statusFile });
}

Example 77 with PosixFilePermission

use of java.nio.file.attribute.PosixFilePermission in project nifi by apache.

the class RunNiFi method writePidFile.

private synchronized void writePidFile(final String pid, final Logger logger) throws IOException {
    final File pidFile = getPidFile(logger);
    if (pidFile.exists() && !pidFile.delete()) {
        logger.warn("Failed to delete {}", pidFile);
    }
    if (!pidFile.createNewFile()) {
        throw new IOException("Failed to create file " + pidFile);
    }
    try {
        final Set<PosixFilePermission> perms = new HashSet<>();
        perms.add(PosixFilePermission.OWNER_WRITE);
        perms.add(PosixFilePermission.OWNER_READ);
        perms.add(PosixFilePermission.GROUP_READ);
        perms.add(PosixFilePermission.OTHERS_READ);
        Files.setPosixFilePermissions(pidFile.toPath(), perms);
    } catch (final Exception e) {
        logger.warn("Failed to set permissions so that only the owner can read pid file {}; " + "this may allows others to have access to the key needed to communicate with NiFi. " + "Permissions should be changed so that only the owner can read this file", pidFile);
    }
    try (final FileOutputStream fos = new FileOutputStream(pidFile)) {
        fos.write(pid.getBytes(StandardCharsets.UTF_8));
        fos.getFD().sync();
    }
    logger.debug("Saved Pid {} to {}", new Object[] { pid, pidFile });
}

Example 78 with PosixFilePermission

use of java.nio.file.attribute.PosixFilePermission in project nifi by apache.

the class TestGetFile method testWithInaccessibleDir.

@Test
public void testWithInaccessibleDir() throws IOException {
    // Some systems don't support POSIX (Windows) and will fail if run. Should ignore the test in that event
    if (!FileSystems.getDefault().supportedFileAttributeViews().contains("posix")) {
        return;
    }
    File inaccessibleDir = new File("target/inaccessible");
    inaccessibleDir.deleteOnExit();
    inaccessibleDir.mkdir();
    Set<PosixFilePermission> posixFilePermissions = new HashSet<>();
    Files.setPosixFilePermissions(inaccessibleDir.toPath(), posixFilePermissions);
    final TestRunner runner = TestRunners.newTestRunner(new GetFile());
    runner.setProperty(GetFile.DIRECTORY, inaccessibleDir.getAbsolutePath());
    try {
        runner.run();
        fail();
    } catch (AssertionError e) {
        assertTrue(e.getCause().getMessage().endsWith("does not have sufficient permissions (i.e., not writable and readable)"));
    }
}

Example 79 with PosixFilePermission

use of java.nio.file.attribute.PosixFilePermission in project nifi by apache.

the class TestGetFile method testAttributes.

@Test
public void testAttributes() throws IOException {
    final File directory = new File("target/test/data/in/");
    deleteDirectory(directory);
    assertTrue("Unable to create test data directory " + directory.getAbsolutePath(), directory.exists() || directory.mkdirs());
    final File inFile = new File("src/test/resources/hello.txt");
    final Path inPath = inFile.toPath();
    final File destFile = new File(directory, inFile.getName());
    final Path targetPath = destFile.toPath();
    Files.copy(inPath, targetPath);
    boolean verifyLastModified = false;
    try {
        destFile.setLastModified(1000000000);
        verifyLastModified = true;
    } catch (Exception doNothing) {
    }
    boolean verifyPermissions = false;
    try {
        /* If you mount an NTFS partition in Linux, you are unable to change the permissions of the files,
            * because every file has the same permissions, controlled by the 'fmask' and 'dmask' mount options.
            * Executing a chmod command will not fail, but it does not change the file's permissions.
            * From Java perspective the NTFS mount point, as a FileStore supports the 'unix' and 'posix' file
            * attribute views, but the setPosixFilePermissions() has no effect.
            *
            * If you set verifyPermissions to true without the following extra check, the test case will fail
            * on a file system, where Nifi source is located on a NTFS mount point in Linux.
            * The purpose of the extra check is to ensure, that setPosixFilePermissions() changes the file's
            * permissions, and set verifyPermissions, after we are convinced.
            */
        Set<PosixFilePermission> perms = PosixFilePermissions.fromString("r--r-----");
        Files.setPosixFilePermissions(targetPath, perms);
        Set<PosixFilePermission> permsAfterSet = Files.getPosixFilePermissions(targetPath);
        if (perms.equals(permsAfterSet)) {
            verifyPermissions = true;
        }
    } catch (Exception doNothing) {
    }
    final TestRunner runner = TestRunners.newTestRunner(new GetFile());
    runner.setProperty(GetFile.DIRECTORY, "target/test/data/in");
    runner.run();
    runner.assertAllFlowFilesTransferred(GetFile.REL_SUCCESS, 1);
    final List<MockFlowFile> successFiles = runner.getFlowFilesForRelationship(GetFile.REL_SUCCESS);
    if (verifyLastModified) {
        try {
            final DateFormat formatter = new SimpleDateFormat(GetFile.FILE_MODIFY_DATE_ATTR_FORMAT, Locale.US);
            final Date fileModifyTime = formatter.parse(successFiles.get(0).getAttribute("file.lastModifiedTime"));
            assertEquals(new Date(1000000000), fileModifyTime);
        } catch (ParseException e) {
            fail();
        }
    }
    if (verifyPermissions) {
        successFiles.get(0).assertAttributeEquals("file.permissions", "r--r-----");
    }
}

Example 80 with PosixFilePermission

use of java.nio.file.attribute.PosixFilePermission in project felix by apache.

the class Posix method ls.

protected void ls(CommandSession session, Process process, String[] argv) throws Exception {
    final String[] usage = { "ls - list files", "Usage: ls [OPTIONS] [PATTERNS...]", "  -? --help                show help", "  -1                       list one entry per line", "  -C                       multi-column output", "     --color=WHEN          colorize the output, may be `always', `never' or `auto'", "  -a                       list entries starting with .", "  -F                       append file type indicators", "  -m                       comma separated", "  -l                       long listing", "  -S                       sort by size", "  -f                       output is not sorted", "  -r                       reverse sort order", "  -t                       sort by modification time", "  -x                       sort horizontally", "  -L                       list referenced file for links", "  -h                       print sizes in human readable form" };
    Options opt = parseOptions(session, usage, argv);
    String color = opt.isSet("color") ? opt.get("color") : "auto";
    boolean colored;
    switch(color) {
        case "always":
        case "yes":
        case "force":
            colored = true;
            break;
        case "never":
        case "no":
        case "none":
            colored = false;
            break;
        case "auto":
        case "tty":
        case "if-tty":
            colored = process.isTty(1);
            break;
        default:
            throw new IllegalArgumentException("invalid argument ‘" + color + "’ for ‘--color’");
    }
    Map<String, String> colors = colored ? getLsColorMap(session) : Collections.emptyMap();
    class PathEntry implements Comparable<PathEntry> {

        final Path abs;

        final Path path;

        final Map<String, Object> attributes;

        public PathEntry(Path abs, Path root) {
            this.abs = abs;
            this.path = abs.startsWith(root) ? root.relativize(abs) : abs;
            this.attributes = readAttributes(abs);
        }

        @Override
        public int compareTo(PathEntry o) {
            int c = doCompare(o);
            return opt.isSet("r") ? -c : c;
        }

        private int doCompare(PathEntry o) {
            if (opt.isSet("f")) {
                return -1;
            }
            if (opt.isSet("S")) {
                long s0 = attributes.get("size") != null ? ((Number) attributes.get("size")).longValue() : 0L;
                long s1 = o.attributes.get("size") != null ? ((Number) o.attributes.get("size")).longValue() : 0L;
                return s0 > s1 ? -1 : s0 < s1 ? 1 : path.toString().compareTo(o.path.toString());
            }
            if (opt.isSet("t")) {
                long t0 = attributes.get("lastModifiedTime") != null ? ((FileTime) attributes.get("lastModifiedTime")).toMillis() : 0L;
                long t1 = o.attributes.get("lastModifiedTime") != null ? ((FileTime) o.attributes.get("lastModifiedTime")).toMillis() : 0L;
                return t0 > t1 ? -1 : t0 < t1 ? 1 : path.toString().compareTo(o.path.toString());
            }
            return path.toString().compareTo(o.path.toString());
        }

        boolean isNotDirectory() {
            return is("isRegularFile") || is("isSymbolicLink") || is("isOther");
        }

        boolean isDirectory() {
            return is("isDirectory");
        }

        private boolean is(String attr) {
            Object d = attributes.get(attr);
            return d instanceof Boolean && (Boolean) d;
        }

        String display() {
            String type;
            String suffix;
            String link = "";
            if (is("isSymbolicLink")) {
                type = "sl";
                suffix = "@";
                try {
                    Path l = Files.readSymbolicLink(abs);
                    link = " -> " + l.toString();
                } catch (IOException e) {
                // ignore
                }
            } else if (is("isDirectory")) {
                type = "dr";
                suffix = "/";
            } else if (is("isExecutable")) {
                type = "ex";
                suffix = "*";
            } else if (is("isOther")) {
                type = "ot";
                suffix = "";
            } else {
                type = "";
                suffix = "";
            }
            String col = colors.get(type);
            boolean addSuffix = opt.isSet("F");
            if (col != null && !col.isEmpty()) {
                return "\033[" + col + "m" + path.toString() + "\033[m" + (addSuffix ? suffix : "") + link;
            } else {
                return path.toString() + (addSuffix ? suffix : "") + link;
            }
        }

        String longDisplay() {
            String username;
            if (attributes.containsKey("owner")) {
                username = Objects.toString(attributes.get("owner"), null);
            } else {
                username = "owner";
            }
            if (username.length() > 8) {
                username = username.substring(0, 8);
            } else {
                for (int i = username.length(); i < 8; i++) {
                    username = username + " ";
                }
            }
            String group;
            if (attributes.containsKey("group")) {
                group = Objects.toString(attributes.get("group"), null);
            } else {
                group = "group";
            }
            if (group.length() > 8) {
                group = group.substring(0, 8);
            } else {
                for (int i = group.length(); i < 8; i++) {
                    group = group + " ";
                }
            }
            Number length = (Number) attributes.get("size");
            if (length == null) {
                length = 0L;
            }
            String lengthString;
            if (opt.isSet("h")) {
                double l = length.longValue();
                String unit = "B";
                if (l >= 1000) {
                    l /= 1024;
                    unit = "K";
                    if (l >= 1000) {
                        l /= 1024;
                        unit = "M";
                        if (l >= 1000) {
                            l /= 1024;
                            unit = "T";
                        }
                    }
                }
                if (l < 10 && length.longValue() > 1000) {
                    lengthString = String.format("%.1f", l) + unit;
                } else {
                    lengthString = String.format("%3.0f", l) + unit;
                }
            } else {
                lengthString = String.format("%1$8s", length);
            }
            @SuppressWarnings("unchecked") Set<PosixFilePermission> perms = (Set<PosixFilePermission>) attributes.get("permissions");
            if (perms == null) {
                perms = EnumSet.noneOf(PosixFilePermission.class);
            }
            // TODO: all fields should be padded to align
            return (is("isDirectory") ? "d" : (is("isSymbolicLink") ? "l" : (is("isOther") ? "o" : "-"))) + PosixFilePermissions.toString(perms) + " " + String.format("%3s", (attributes.containsKey("nlink") ? attributes.get("nlink").toString() : "1")) + " " + username + " " + group + " " + lengthString + " " + toString((FileTime) attributes.get("lastModifiedTime")) + " " + display();
        }

        protected String toString(FileTime time) {
            long millis = (time != null) ? time.toMillis() : -1L;
            if (millis < 0L) {
                return "------------";
            }
            ZonedDateTime dt = Instant.ofEpochMilli(millis).atZone(ZoneId.systemDefault());
            // Less than six months
            if (System.currentTimeMillis() - millis < 183L * 24L * 60L * 60L * 1000L) {
                return DateTimeFormatter.ofPattern("MMM ppd HH:mm").format(dt);
            } else // Older than six months
            {
                return DateTimeFormatter.ofPattern("MMM ppd  yyyy").format(dt);
            }
        }

        protected Map<String, Object> readAttributes(Path path) {
            Map<String, Object> attrs = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
            for (String view : path.getFileSystem().supportedFileAttributeViews()) {
                try {
                    Map<String, Object> ta = Files.readAttributes(path, view + ":*", getLinkOptions(opt.isSet("L")));
                    ta.entrySet().forEach(e -> attrs.putIfAbsent(e.getKey(), e.getValue()));
                } catch (IOException e) {
                // Ignore
                }
            }
            attrs.computeIfAbsent("isExecutable", s -> Files.isExecutable(path));
            attrs.computeIfAbsent("permissions", s -> getPermissionsFromFile(path.toFile()));
            return attrs;
        }
    }
    Path currentDir = session.currentDir();
    // Listing
    List<Path> expanded = new ArrayList<>();
    if (opt.args().isEmpty()) {
        expanded.add(currentDir);
    } else {
        opt.args().forEach(s -> expanded.add(currentDir.resolve(s)));
    }
    boolean listAll = opt.isSet("a");
    Predicate<Path> filter = p -> listAll || !p.getFileName().toString().startsWith(".");
    List<PathEntry> all = expanded.stream().filter(filter).map(p -> new PathEntry(p, currentDir)).sorted().collect(Collectors.toList());
    // Print files first
    List<PathEntry> files = all.stream().filter(PathEntry::isNotDirectory).collect(Collectors.toList());
    PrintStream out = process.out();
    Consumer<Stream<PathEntry>> display = s -> {
        boolean optLine = opt.isSet("1");
        boolean optComma = opt.isSet("m");
        boolean optLong = opt.isSet("l");
        boolean optCol = opt.isSet("C");
        if (!optLine && !optComma && !optLong && !optCol) {
            if (process.isTty(1)) {
                optCol = true;
            } else {
                optLine = true;
            }
        }
        // One entry per line
        if (optLine) {
            s.map(PathEntry::display).forEach(out::println);
        } else // Comma separated list
        if (optComma) {
            out.println(s.map(PathEntry::display).collect(Collectors.joining(", ")));
        } else // Long listing
        if (optLong) {
            s.map(PathEntry::longDisplay).forEach(out::println);
        } else // Column listing
        if (optCol) {
            toColumn(session, process, out, s.map(PathEntry::display), opt.isSet("x"));
        }
    };
    boolean space = false;
    if (!files.isEmpty()) {
        display.accept(files.stream());
        space = true;
    }
    // Print directories
    List<PathEntry> directories = all.stream().filter(PathEntry::isDirectory).collect(Collectors.toList());
    for (PathEntry entry : directories) {
        if (space) {
            out.println();
        }
        space = true;
        Path path = currentDir.resolve(entry.path);
        if (expanded.size() > 1) {
            out.println(currentDir.relativize(path).toString() + ":");
        }
        display.accept(Stream.concat(Arrays.asList(".", "..").stream().map(path::resolve), Files.list(path)).filter(filter).map(p -> new PathEntry(p, path)).sorted());
    }
}