Refine search
protected Map<String, String> getAttributesFromFile(final Path file) { Map<String, String> attributes = new HashMap<>(); try { FileStore store = Files.getFileStore(file); if (store.supportsFileAttributeView("basic")) { try { final DateFormat formatter = new SimpleDateFormat(FILE_MODIFY_DATE_ATTR_FORMAT, Locale.US); BasicFileAttributeView view = Files.getFileAttributeView(file, BasicFileAttributeView.class); BasicFileAttributes attrs = view.readAttributes(); attributes.put(FILE_LAST_MODIFY_TIME_ATTRIBUTE, formatter.format(new Date(attrs.lastModifiedTime().toMillis()))); attributes.put(FILE_CREATION_TIME_ATTRIBUTE, formatter.format(new Date(attrs.creationTime().toMillis()))); attributes.put(FILE_LAST_ACCESS_TIME_ATTRIBUTE, formatter.format(new Date(attrs.lastAccessTime().toMillis()))); } catch (Exception ignore) { FileOwnerAttributeView view = Files.getFileAttributeView(file, FileOwnerAttributeView.class); attributes.put(FILE_OWNER_ATTRIBUTE, view.getOwner().getName()); } catch (Exception ignore) {
/** {@inheritDoc} */ @Override public void setTimes(IgfsPath path, long modificationTime, long accessTime) throws IgniteException { Path p = fileForPath(path).toPath(); if (!Files.exists(p)) throw new IgfsPathNotFoundException("Failed to set times (path not found): " + path); try { Files.getFileAttributeView(p, BasicFileAttributeView.class) .setTimes( (modificationTime >= 0) ? FileTime.from(modificationTime, TimeUnit.MILLISECONDS) : null, (accessTime >= 0) ? FileTime.from(accessTime, TimeUnit.MILLISECONDS) : null, null); } catch (IOException e) { throw new IgniteException("Failed to set times for path: " + path, e); } }
private static void unzip(final ZipFile zip, final Path targetDir) throws IOException { final Enumeration<? extends ZipEntry> entries = zip.entries(); while (entries.hasMoreElements()) { final ZipEntry entry = entries.nextElement(); final String name = entry.getName(); final Path current = resolveSecurely(targetDir, name); if (entry.isDirectory()) { if (!Files.exists(current)) { Files.createDirectories(current); } } else { if (Files.notExists(current.getParent())) { Files.createDirectories(current.getParent()); } try (final InputStream eis = zip.getInputStream(entry)) { Files.copy(eis, current); } } try { Files.getFileAttributeView(current, BasicFileAttributeView.class).setTimes(entry.getLastModifiedTime(), entry.getLastAccessTime(), entry.getCreationTime()); } catch (IOException e) { //ignore, if we cannot set it, world will not end } } }
@Override public void mknod( final FsEntryName name, final Type type, final BitField<FsOutputOption> options, final @CheckForNull Entry template) throws IOException { final Path file = target.resolve(name.getPath()); switch (type) { case FILE: if (options.get(EXCLUSIVE)) createFile(file); else newOutputStream(file).close(); break; case DIRECTORY: createDirectory(file); break; default: throw new IOException(file + " (entry type not supported: " + type + ")"); } if (null != template) { getBasicFileAttributeView(file) .setTimes( toFileTime(template.getTime(WRITE)), toFileTime(template.getTime(READ)), toFileTime(template.getTime(CREATE))); } }
@Override ClassFile getClassFile(String name, String suffix) throws IOException { // Class files are in here under names like this: // /modules/java.base/java/lang/Object.class (jdk9 b74) // so within a modules top level qualifier and then the java.base module String fileName = name.replace('.', '/') + suffix; Path p = fileMap.get(fileName); if (p == null) { return null; } byte[] bs = Files.readAllBytes(p); BasicFileAttributeView bfav = Files.getFileAttributeView(p, BasicFileAttributeView.class); BasicFileAttributes bfas = bfav.readAttributes(); long time = bfas.lastModifiedTime().toMillis(); long size = bfas.size(); ClassFile cf = new ByteBasedClassFile(bs, "jimage",fileName,time,size); return cf; } }
if( Files.isDirectory( path ) ) { throw new FileSystemException( path.toString() + " is a directory" ); if ( !creating && !Files.isWritable( path )) { throw new AccessDeniedException( "file not writable" ); Files.getFileAttributeView( childGetParent( path ), BasicFileAttributeView.class ).setTimes( now, now, null );
/** * @param fs * @param file * @return non null attributes object */ static Attributes getFileAttributesBasic(FS fs, File file) { try { Path nioPath = toPath(file); BasicFileAttributes readAttributes = nioPath .getFileSystem() .provider() .getFileAttributeView(nioPath, BasicFileAttributeView.class, LinkOption.NOFOLLOW_LINKS).readAttributes(); Attributes attributes = new Attributes(fs, file, true, readAttributes.isDirectory(), fs.supportsExecute() ? file.canExecute() : false, readAttributes.isSymbolicLink(), readAttributes.isRegularFile(), // readAttributes.creationTime().toMillis(), // readAttributes.lastModifiedTime().toMillis(), readAttributes.isSymbolicLink() ? Constants .encode(readSymLink(file)).length : readAttributes.size()); return attributes; } catch (IOException e) { return new Attributes(file, fs); } }
@Override public void createDirectory( @Nullable Path dirArg, @Nullable FileAttribute<?>... attrs ) throws IOException { EightyFS eighty = checkProviderAndGet80( dirArg ); EightyPath dir = toRealPathEx( (EightyPath) _n0( dirArg ), NOFOLLOW_LINKS ); if( existsEx( dir, NOFOLLOW_LINKS ) ) { throw new FileAlreadyExistsException( dir.toString() ); } // an absolute path (toRealPath) that does not exist has a parent EightyPath parent = childGetParent( dir ); if( !Files.isDirectory( parent ) ) { throw new NoSuchFileException( parent.toString() ); } throwIfPathIsNotAccessible( dir ); eighty.createDirectory( dir, _nargs( attrs ) ); FileTime now = FileTime.from( Clock.systemUTC().instant() ); Files.getFileAttributeView( parent, BasicFileAttributeView.class ).setTimes( now, now, null ); parent._getFileSystem().signal( dir, StandardWatchEventKinds.ENTRY_CREATE ); }
Files.createDirectory(folder); Files.createFile(file); Files.getFileAttributeView(folder, BasicFileAttributeView.class) .setTimes(null, null, someTimeAgo); Files.getFileAttributeView(file, BasicFileAttributeView.class) .setTimes(null, null, someTimeAgo); Files.getFileAttributeView(root, BasicFileAttributeView.class) .setTimes(null, null, someTimeAgo);
@Override public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { try { if (copyOptionsSet.contains(COPY_ATTRIBUTES)) { /* * Copy file times. Inspired by * java.nio.file.CopyMoveHelper.copyToForeignTarget() */ BasicFileAttributes attrs = readAttributes(dir, BasicFileAttributes.class, linkOptions); BasicFileAttributeView view = getFileAttributeView( toDestination(dir), BasicFileAttributeView.class, linkOptions); view.setTimes(attrs.lastModifiedTime(), attrs.lastAccessTime(), attrs.creationTime()); } return CONTINUE; } catch (IOException ex) { return visitFileFailed(dir, ex); } }
/** {@inheritDoc} */ @Override public T2<Long, Long> times(String path) throws IOException { BasicFileAttributes attrs = Files.getFileAttributeView(path(path), BasicFileAttributeView.class) .readAttributes(); return new T2<>(attrs.lastModifiedTime().toMillis(), attrs.lastAccessTime().toMillis()); }
/** Returns whether or not the file with the given name in the given dir is a directory. */ private static boolean isDirectory( SecureDirectoryStream<Path> dir, Path name, LinkOption... options) throws IOException { return dir.getFileAttributeView(name, BasicFileAttributeView.class, options) .readAttributes() .isDirectory(); }
public static LocalDateTime getModificationTime(File file) { LocalDateTime time; try { Path path = Paths.get(file.getAbsolutePath()); BasicFileAttributes fileattr = Files .getFileAttributeView(path, BasicFileAttributeView.class) .readAttributes(); time = LocalDateTime.ofInstant(fileattr.lastModifiedTime().toInstant(), ZoneId.systemDefault()); } catch (Exception e) { time = null; } return time; }
import java.io.IOException; import java.nio.file.*; import java.nio.file.attribute.*; public class TestFA { static void getAttributes(String pathStr) throws IOException { Path p = Paths.get(pathStr); BasicFileAttributes view = Files.getFileAttributeView(p, BasicFileAttributeView.class) .readAttributes(); System.out.println(view.creationTime()+" is the same as "+view.lastModifiedTime()); } public static void main(String[] args) throws IOException { for (String s : args) { getAttributes(s); } } }
BasicFileAttributeView from_attributes_view = Files.getFileAttributeView( from_file.toPath(), BasicFileAttributeView.class); BasicFileAttributes from_attributes = from_attributes_view.readAttributes(); from_last_modified = from_attributes.lastModifiedTime(); from_last_access = from_attributes.lastAccessTime(); from_created = from_attributes.creationTime(); BasicFileAttributeView to_attributes_view = Files.getFileAttributeView( to_file.toPath(), BasicFileAttributeView.class); BasicFileAttributes to_attributes = to_attributes_view.readAttributes(); FileTime to_last_modified = to_attributes.lastModifiedTime(); to_attributes_view.setTimes( from_last_modified, from_last_access, from_created );
File attribFile = new File("/tmp/file.txt"); Path attribPath = attribFile.toPath(); BasicFileAttributeView basicView = attribPath.getFileAttributeView(BasicFileAttributeView.class); BasicFileAttributes basicAttribs = basicView.readAttributes(); System.out.println("Created: " + basicAttribs.creationTime()); System.out.println("Accessed: " + basicAttribs.lastAccessTime()); System.out.println("Modified: " + basicAttribs.lastModifiedTime());
/** * Sets the {@link Path}'s last modified time and last access time to * the given valid times. * * @param mtime the modification time to set (only if no less than zero). * @param atime the access time to set (only if no less than zero). * @throws IOException if setting the times fails. */ @Override public void setTimes(Path p, long mtime, long atime) throws IOException { try { BasicFileAttributeView view = Files.getFileAttributeView( pathToFile(p).toPath(), BasicFileAttributeView.class); FileTime fmtime = (mtime >= 0) ? FileTime.fromMillis(mtime) : null; FileTime fatime = (atime >= 0) ? FileTime.fromMillis(atime) : null; view.setTimes(fmtime, fatime, null); } catch (NoSuchFileException e) { throw new FileNotFoundException("File " + p + " does not exist"); } }
@Test @Category( Attributes.class ) public void testGetLastModifiedAllMethodsDeliverSame() throws IOException { Path path = getFile(); FileTime last0 = Files.getLastModifiedTime( path ); FileTime last1 = FS.provider().readAttributes( path, BasicFileAttributes.class ).lastModifiedTime(); FileTime last2 = (FileTime) FS.provider().readAttributes( path, "basic:lastModifiedTime" ).get( "lastModifiedTime" ); FileTime last3 = FS.provider().getFileAttributeView( path, BasicFileAttributeView.class ).readAttributes().lastModifiedTime(); assertThat( last0 ).isEqualTo( last1 ); assertThat( last1 ).isEqualTo( last2 ); assertThat( last2 ).isEqualTo( last3 ); assertThat( last3 ).isEqualTo( last0 ); }
public static LocalDateTime getCreationTime(File file) { LocalDateTime time; try { Path path = Paths.get(file.getAbsolutePath()); BasicFileAttributes fileattr = Files .getFileAttributeView(path, BasicFileAttributeView.class) .readAttributes(); time = LocalDateTime.ofInstant(fileattr.creationTime().toInstant(), ZoneId.systemDefault()); } catch (Exception e) { time = null; } return time; }
@Test @Category( { Attributes.class, Writable.class, Attributes.class, CreationTime.class } ) public void testSetCreationTimeViaView() throws IOException { FileTime past = FileTime.fromMillis( System.currentTimeMillis() - 100000 ); final Path file = fileTA(); FS.provider().getFileAttributeView( file, BasicFileAttributeView.class ).setTimes( null, null, past ); assertThat( Files.readAttributes( file, BasicFileAttributes.class ).creationTime() ). usingComparator( FileTimeComparator::roughlyComparableTo ).isEqualTo( past ); }