java.nio.file.attribute.DosFileAttributes Java Examples

private static byte[] getWindowsFileAttributes(Path file) {
  byte[] fileAttributes = new byte[4];

  try {
    DosFileAttributeView dosFileAttributeView = Files.getFileAttributeView(file, DosFileAttributeView.class,
        LinkOption.NOFOLLOW_LINKS);
    DosFileAttributes dosFileAttributes = dosFileAttributeView.readAttributes();

    byte windowsAttribute = 0;

    windowsAttribute = setBitIfApplicable(dosFileAttributes.isReadOnly(), windowsAttribute, 0);
    windowsAttribute = setBitIfApplicable(dosFileAttributes.isHidden(), windowsAttribute, 1);
    windowsAttribute = setBitIfApplicable(dosFileAttributes.isSystem(), windowsAttribute, 2);
    windowsAttribute = setBitIfApplicable(dosFileAttributes.isArchive(), windowsAttribute, 5);
    fileAttributes[0] = windowsAttribute;
  } catch (IOException e) {
    // ignore
  }

  return fileAttributes;
}
 

@Test
public void testGetFileAttributesReturnsAttributesAsDefined() throws IOException {
  File file = mock(File.class);
  Path path = mock(Path.class);
  when(file.toPath()).thenReturn(path);
  when(file.exists()).thenReturn(true);
  DosFileAttributes dosFileAttributes = mock(DosFileAttributes.class);
  DosFileAttributeView dosFileAttributeView = mockDosFileAttributeView(path, true, dosFileAttributes);
  when(dosFileAttributeView.readAttributes()).thenReturn(dosFileAttributes);
  when(dosFileAttributes.isReadOnly()).thenReturn(true);
  when(dosFileAttributes.isHidden()).thenReturn(true);
  when(dosFileAttributes.isSystem()).thenReturn(true);
  when(dosFileAttributes.isArchive()).thenReturn(true);

  byte[] attributes = FileUtils.getFileAttributes(file);

  assertThat(isBitSet(attributes[0], 0)).isTrue();
  assertThat(isBitSet(attributes[0], 1)).isTrue();
  assertThat(isBitSet(attributes[0], 2)).isTrue();
  assertThat(isBitSet(attributes[0], 5)).isTrue();
}
 

private DosFileAttributeView mockDosFileAttributeView(Path path, boolean fileExists, DosFileAttributes dosFileAttributes) throws IOException {
  FileSystemProvider fileSystemProvider = mock(FileSystemProvider.class);
  FileSystem fileSystem = mock(FileSystem.class);
  DosFileAttributeView dosFileAttributeView = mock(DosFileAttributeView.class);

  when(fileSystemProvider.readAttributes(path, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS)).thenReturn(dosFileAttributes);
  when(path.getFileSystem()).thenReturn(fileSystem);
  when(fileSystemProvider.getFileAttributeView(path, DosFileAttributeView.class, LinkOption.NOFOLLOW_LINKS))
      .thenReturn(dosFileAttributeView);
  when(path.getFileSystem().provider()).thenReturn(fileSystemProvider);

  if (!fileExists) {
    doThrow(new IOException()).when(fileSystemProvider).checkAccess(path);
  }

  return dosFileAttributeView;
}
 

@Override
public boolean isHidden(Path path) throws IOException {
  // TODO(cgdecker): This should probably be configurable, but this seems fine for now
  /*
   * If the DOS view is supported, use the Windows isHidden method (check the dos:hidden
   * attribute). Otherwise, use the Unix isHidden method (just check if the file name starts with
   * ".").
   */
  JimfsPath checkedPath = checkPath(path);
  FileSystemView view = getDefaultView(checkedPath);
  if (getFileStore(path).supportsFileAttributeView("dos")) {
    return view.readAttributes(checkedPath, DosFileAttributes.class, Options.NOFOLLOW_LINKS)
        .isHidden();
  }
  return path.getNameCount() > 0 && path.getFileName().toString().startsWith(".");
}
 

@Test
public void testAttributes() {
  DosFileAttributes attrs = provider.readAttributes(file);
  assertThat(attrs.isHidden()).isFalse();
  assertThat(attrs.isArchive()).isFalse();
  assertThat(attrs.isReadOnly()).isFalse();
  assertThat(attrs.isSystem()).isFalse();

  file.setAttribute("dos", "hidden", true);

  attrs = provider.readAttributes(file);
  assertThat(attrs.isHidden()).isTrue();
  assertThat(attrs.isArchive()).isFalse();
  assertThat(attrs.isReadOnly()).isFalse();
  assertThat(attrs.isSystem()).isFalse();
}
 

@Test
public void testGetFileAttributesWhenFileDoesNotExistReturnsEmptyBytes() throws IOException {
  File file = mock(File.class);
  Path path = mock(Path.class);
  when(file.toPath()).thenReturn(path);
  when(file.exists()).thenReturn(false);
  DosFileAttributes dosFileAttributes = mock(DosFileAttributes.class);
  mockDosFileAttributeView(path, true, dosFileAttributes);

  byte[] attributes = FileUtils.getFileAttributes(file);

  assertThat(attributes).contains(0, 0, 0, 0);
}
 

protected PathAttributes convert(final java.nio.file.Path file) throws IOException {
    final boolean isPosix = session.isPosixFilesystem();
    final PathAttributes attributes = new PathAttributes();
    final Class<? extends BasicFileAttributes> provider = isPosix ? PosixFileAttributes.class : DosFileAttributes.class;
    final BasicFileAttributes a = Files.readAttributes(file, provider, LinkOption.NOFOLLOW_LINKS);
    if(a.isRegularFile()) {
        attributes.setSize(a.size());
    }
    attributes.setModificationDate(a.lastModifiedTime().toMillis());
    attributes.setCreationDate(a.creationTime().toMillis());
    attributes.setAccessedDate(a.lastAccessTime().toMillis());
    if(isPosix) {
        attributes.setOwner(((PosixFileAttributes) a).owner().getName());
        attributes.setGroup(((PosixFileAttributes) a).group().getName());
        attributes.setPermission(new Permission(PosixFilePermissions.toString(((PosixFileAttributes) a).permissions())));
    }
    else {
        Permission.Action actions = Permission.Action.none;
        if(Files.isReadable(file)) {
            actions = actions.or(Permission.Action.read);
        }
        if(Files.isWritable(file)) {
            actions = actions.or(Permission.Action.write);
        }
        if(Files.isExecutable(file)) {
            actions = actions.or(Permission.Action.execute);
        }
        attributes.setPermission(new Permission(
            actions, Permission.Action.none, Permission.Action.none
        ));
    }
    return attributes;
}
 

/**
 * 
 * @param fileLoc
 * @return 
 */
public static Map<String, String> getFileMetadata(Path fileLoc) {
    Map<String, String> linkedHashMap = new LinkedHashMap<>();

    try {
        DosFileAttributes dosFileAttr = Files.readAttributes(fileLoc, DosFileAttributes.class);

        linkedHashMap.put("File Name", fileLoc.getFileName().toString());
        linkedHashMap.put("File Location", fileLoc.toString());
        linkedHashMap.put("File Size", readableFileSize(dosFileAttr.size()));
        linkedHashMap.put("Creation Time", getDateTime(dosFileAttr.creationTime()));
        linkedHashMap.put("Last Accessed Time", getDateTime(dosFileAttr.lastAccessTime()));
        linkedHashMap.put("Last Modified Time", getDateTime(dosFileAttr.lastModifiedTime()));
        linkedHashMap.put("Is Directory?", dosFileAttr.isDirectory() ? "True" : "False");
        linkedHashMap.put("Is Regular File?", dosFileAttr.isRegularFile() ? "True" : "False");
        linkedHashMap.put("Is Symbolic Link?", dosFileAttr.isSymbolicLink() ? "True" : "False");
        linkedHashMap.put("Is Archive?", dosFileAttr.isArchive() ? "True" : "False");
        linkedHashMap.put("Is Hidden File?", dosFileAttr.isHidden() ? "True" : "False");
        linkedHashMap.put("Is ReadOnly?", dosFileAttr.isReadOnly() ? "True" : "False");
        linkedHashMap.put("Is System File?", dosFileAttr.isSystem() ? "True" : "False");

        if (getOsName().equals("Linux")) {
            PosixFileAttributes attr = Files.readAttributes(fileLoc, PosixFileAttributes.class);
            String posixPerm = String.format("%s %s %s%n", attr.owner().getName(), attr.group().getName(),
                    PosixFilePermissions.toString(attr.permissions()));

            linkedHashMap.put("Posix", posixPerm);
        }

    } catch (UnsupportedOperationException | IOException ex) {
        System.err.println(ex.getMessage());
    }

    return linkedHashMap;
}
 

@Test(expected = UnsupportedOperationException.class)
public void getFileAttributeViewUnsupportedOperationException()
    throws IOException {
  Path rootPath = Paths.get(clusterUri);
  Path path = Files.createTempFile(rootPath, "test", "tmp");
  Files.readAttributes(path, DosFileAttributes.class);
}
 

@Test
public void testView() throws IOException {
  DosFileAttributeView view =
      provider.view(
          fileLookup(),
          ImmutableMap.<String, FileAttributeView>of(
              "basic", new BasicAttributeProvider().view(fileLookup(), NO_INHERITED_VIEWS)));
  assertNotNull(view);

  assertThat(view.name()).isEqualTo("dos");

  DosFileAttributes attrs = view.readAttributes();
  assertThat(attrs.isHidden()).isFalse();
  assertThat(attrs.isArchive()).isFalse();
  assertThat(attrs.isReadOnly()).isFalse();
  assertThat(attrs.isSystem()).isFalse();

  view.setArchive(true);
  view.setReadOnly(true);
  view.setHidden(true);
  view.setSystem(false);

  assertThat(attrs.isHidden()).isFalse();
  assertThat(attrs.isArchive()).isFalse();
  assertThat(attrs.isReadOnly()).isFalse();

  attrs = view.readAttributes();
  assertThat(attrs.isHidden()).isTrue();
  assertThat(attrs.isArchive()).isTrue();
  assertThat(attrs.isReadOnly()).isTrue();
  assertThat(attrs.isSystem()).isFalse();

  view.setTimes(FileTime.fromMillis(0L), null, null);
  assertThat(view.readAttributes().lastModifiedTime()).isEqualTo(FileTime.fromMillis(0L));
}
 

private Stat statPath(Path p, long inodeNumber) throws IOException {

        Class<? extends  BasicFileAttributeView> attributeClass =
                IS_UNIX ? PosixFileAttributeView.class : DosFileAttributeView.class;

        BasicFileAttributes attrs = Files.getFileAttributeView(p, attributeClass, NOFOLLOW_LINKS).readAttributes();

        Stat stat = new Stat();

        stat.setATime(attrs.lastAccessTime().toMillis());
        stat.setCTime(attrs.creationTime().toMillis());
        stat.setMTime(attrs.lastModifiedTime().toMillis());

        if (IS_UNIX) {
            stat.setGid((Integer) Files.getAttribute(p, "unix:gid", NOFOLLOW_LINKS));
            stat.setUid((Integer) Files.getAttribute(p, "unix:uid", NOFOLLOW_LINKS));
            stat.setMode((Integer) Files.getAttribute(p, "unix:mode", NOFOLLOW_LINKS));
            stat.setNlink((Integer) Files.getAttribute(p, "unix:nlink", NOFOLLOW_LINKS));
        } else {
            DosFileAttributes dosAttrs = (DosFileAttributes)attrs;
            stat.setGid(0);
            stat.setUid(0);
            int type = dosAttrs.isSymbolicLink() ? Stat.S_IFLNK : dosAttrs.isDirectory() ? Stat.S_IFDIR : Stat.S_IFREG;
            stat.setMode( type |(dosAttrs.isReadOnly()? 0400 : 0600));
            stat.setNlink(1);
        }

        stat.setDev(17);
        stat.setIno((int) inodeNumber);
        stat.setRdev(17);
        stat.setSize(attrs.size());
        stat.setFileid((int) inodeNumber);
        stat.setGeneration(attrs.lastModifiedTime().toMillis());

        return stat;
    }
 

@Override
public void setFileHiddenAttribute(
        String sourceFile,
        boolean hidden ) {

    sourceFile = IoUtils.normalizeFilePath(sourceFile, osType);
    checkFileExistence(new File(sourceFile));

    final String errMsg = "Could not " + (hidden
                                          ? "set"
                                          : "unset")
                          + " the hidden attribute of file '" + sourceFile + "'";
    if (OperatingSystemType.getCurrentOsType().isWindows()) {
        try {
            Path path = Paths.get(sourceFile);
            DosFileAttributes attr;
            attr = Files.readAttributes(path, DosFileAttributes.class, LinkOption.NOFOLLOW_LINKS);

            boolean goHidden = attr.isHidden();
            if (!hidden && goHidden) {
                Files.setAttribute(path, "dos:hidden", false, LinkOption.NOFOLLOW_LINKS);
            } else if (hidden && !goHidden) {
                Files.setAttribute(path, "dos:hidden", true, LinkOption.NOFOLLOW_LINKS);
            }
        } catch (IOException e) {
            throw new FileSystemOperationException(errMsg, e);
        }
    } else if (OperatingSystemType.getCurrentOsType().isUnix()) {
        // a '.' prefix makes the file hidden
        String filePath = IoUtils.getFilePath(sourceFile);
        String fileName = IoUtils.getFileName(sourceFile);
        if (hidden) {
            if (fileName.startsWith(".")) {
                log.warn("File '" + sourceFile + "' is already hidden. No changes are made!");
                return;
            } else {
                fileName = "." + fileName;
            }
        } else {
            if (!fileName.startsWith(".")) {
                log.warn("File '" + sourceFile + "' is already NOT hidden. No changes are made!");
                return;
            } else {
                fileName = fileName.substring(1);
            }
        }
        renameFile(sourceFile, filePath + fileName, false);
    } else {
        throw new FileSystemOperationException(errMsg + ": Unknown OS type");
    }
}
 

@Override
protected FileStatus stat(Path path, boolean followSymlinks) throws IOException {
  File file = getIoFile(path);
  final DosFileAttributes attributes;
  try {
    attributes = getAttribs(file, followSymlinks);
  } catch (IOException e) {
    throw new FileNotFoundException(path + ERR_NO_SUCH_FILE_OR_DIR);
  }

  final boolean isSymbolicLink = !followSymlinks && fileIsSymbolicLink(file);
  FileStatus status =
      new FileStatus() {
        @Override
        public boolean isFile() {
          return !isSymbolicLink && (attributes.isRegularFile() || isSpecialFile());
        }

        @Override
        public boolean isSpecialFile() {
          // attributes.isOther() returns false for symlinks but returns true for junctions.
          // Bazel treats junctions like symlinks. So let's return false here for junctions.
          // This fixes https://github.com/bazelbuild/bazel/issues/9176
          return !isSymbolicLink && attributes.isOther();
        }

        @Override
        public boolean isDirectory() {
          return !isSymbolicLink && attributes.isDirectory();
        }

        @Override
        public boolean isSymbolicLink() {
          return isSymbolicLink;
        }

        @Override
        public long getSize() throws IOException {
          return attributes.size();
        }

        @Override
        public long getLastModifiedTime() throws IOException {
          return attributes.lastModifiedTime().toMillis();
        }

        @Override
        public long getLastChangeTime() {
          // This is the best we can do with Java NIO...
          return attributes.lastModifiedTime().toMillis();
        }

        @Override
        public long getNodeId() {
          // TODO(bazel-team): Consider making use of attributes.fileKey().
          return -1;
        }
      };

  return status;
}
 

private static DosFileAttributes getAttribs(File file, boolean followSymlinks)
    throws IOException {
  return Files.readAttributes(
      file.toPath(), DosFileAttributes.class, symlinkOpts(followSymlinks));
}
 

@Override
public Class<DosFileAttributes> attributesType() {
  return DosFileAttributes.class;
}
 

@Override
public DosFileAttributes readAttributes(File file) {
  return new Attributes(file);
}
 

@Override
public DosFileAttributes readAttributes() throws IOException {
  return new Attributes(lookupFile());
}