java.nio.file.FileStore Java Examples

@Override
public Iterable<FileStore> getFileStores() {
    return MCRStoreCenter.instance().getCurrentStores(org.mycore.datamodel.ifs2.MCRFileStore.class)
        .filter(s -> s.getID().startsWith(MCRFileSystemUtils.STORE_ID_PREFIX))
        .sorted(Comparator.comparing(MCRStore::getID))
        .map(MCRStore::getID)
        .distinct()
        .map(storeId -> {
            try {
                return MCRFileStore.getInstance(storeId);
            } catch (IOException e) {
                LogManager.getLogger().error("Error while iterating FileStores.", e);
                return null;
            }
        })
        .filter(Objects::nonNull)
        .map(FileStore.class::cast)::iterator;
}
 

public void testManyPartitions() throws Exception {
  assumeFalse("windows is not supported", Constants.WINDOWS);
  Path dir = createTempDir();
  dir = FilterPath.unwrap(dir).toRealPath();
  
  // fake ssd
  FileStore root = new MockFileStore(dir.toString() + " (/dev/zzz12)", "zfs", "/dev/zzz12");
  // make a fake /dev/zzz11 for it
  Path devdir = dir.resolve("dev");
  Files.createDirectories(devdir);
  Files.createFile(devdir.resolve("zzz12"));
  // make a fake /sys/block/zzz/queue/rotational file for it
  Path sysdir = dir.resolve("sys").resolve("block").resolve("zzz").resolve("queue");
  Files.createDirectories(sysdir);
  try (OutputStream o = Files.newOutputStream(sysdir.resolve("rotational"))) {
    o.write("0\n".getBytes(StandardCharsets.US_ASCII));
  }
  Map<String,FileStore> mappings = Collections.singletonMap(dir.toString(), root);
  FileSystem mockLinux = new MockLinuxFileSystemProvider(dir.getFileSystem(), mappings, dir).getFileSystem(null);
  
  Path mockPath = mockLinux.getPath(dir.toString());
  assertFalse(IOUtils.spinsLinux(mockPath));
}
 

private void fillFromStorage ( final Map<String, Object> model )
{
    if ( this.manager != null )
    {
        final Path base = this.manager.getContext ().getBasePath ();
        try
        {
            final FileStore store = Files.getFileStore ( base );
            model.put ( "storageTotal", store.getTotalSpace () );
            model.put ( "storageFree", store.getUsableSpace () );
            model.put ( "storageUsed", store.getTotalSpace () - store.getUsableSpace () );
            model.put ( "storageName", store.name () );
        }
        catch ( final Exception e )
        {
            logger.warn ( "Failed to check storage space", e );
            // ignore
        }
    }
}
 

public void testSSD() throws Exception {
  assumeFalse("windows is not supported", Constants.WINDOWS);
  Path dir = createTempDir();
  dir = FilterPath.unwrap(dir).toRealPath();
  
  // fake ssd
  FileStore root = new MockFileStore(dir.toString() + " (/dev/zzz1)", "btrfs", "/dev/zzz1");
  // make a fake /dev/zzz1 for it
  Path devdir = dir.resolve("dev");
  Files.createDirectories(devdir);
  Files.createFile(devdir.resolve("zzz1"));
  // make a fake /sys/block/zzz/queue/rotational file for it
  Path sysdir = dir.resolve("sys").resolve("block").resolve("zzz").resolve("queue");
  Files.createDirectories(sysdir);
  try (OutputStream o = Files.newOutputStream(sysdir.resolve("rotational"))) {
    o.write("0\n".getBytes(StandardCharsets.US_ASCII));
  }
  Map<String,FileStore> mappings = Collections.singletonMap(dir.toString(), root);
  FileSystem mockLinux = new MockLinuxFileSystemProvider(dir.getFileSystem(), mappings, dir).getFileSystem(null);
  
  Path mockPath = mockLinux.getPath(dir.toString());
  assertFalse(IOUtils.spinsLinux(mockPath));
}
 

@Override
public boolean isStorageAvailable() {
  try {
    FileStore fileStore = Files.getFileStore(contentDir);
    long usableSpace = fileStore.getUsableSpace();
    boolean readOnly = fileStore.isReadOnly();
    boolean result = !readOnly && usableSpace > 0;
    if (!result) {
      log.warn("File blob store '{}' is not writable. Read only: {}. Usable space: {}",
          getBlobStoreConfiguration().getName(), readOnly, usableSpace);
    }
    return result;
  }
  catch (IOException e) {
    log.warn("File blob store '{}' is not writable.", getBlobStoreConfiguration().getName(), e);
    return false;
  }
}
 

public MockLinuxFileSystemProvider(FileSystem delegateInstance, final Map<String,FileStore> filesToStore, Path root) {
  super("mocklinux://", delegateInstance);
  if (mockedPath(root)) {
    throw new AssumptionViolatedException("can't mock /sys and /dev inside of /sys or /dev!");
  }
  final Collection<FileStore> allStores = new HashSet<>(filesToStore.values());
  this.fileSystem = new FilterFileSystem(this, delegateInstance) {
    @Override
    public Iterable<FileStore> getFileStores() {
      return allStores;
    }

    @Override
    public Path getPath(String first, String... more) {
      return new MockLinuxPath(delegateInstance.getPath(first, more), this);
    }
  };
  this.filesToStore = filesToStore;
  this.root = new MockLinuxPath(root, this.fileSystem);
}
 

/**
 * Get the location of the DVD, or null if no DVD can be found.
 * <p>
 * @return the DVD location.
 */
private String getLocation() {
    FileSystem fs = FileSystems.getDefault();
    for(Path rootPath : fs.getRootDirectories()) {
        try {
            FileStore store = Files.getFileStore(rootPath);
            if(store.type().toLowerCase().contains("udf")) {
                if(store.getTotalSpace()>10000000000L) { //Blu-ray
                    return "bluray:///" + rootPath.toString();
                }
                else {
                    return "dvdsimple:///" + rootPath.toString(); //DVD
                }
            }
        }
        catch(IOException ex) {
            //Never mind
        }
    }
    return null;
}
 

@Test
public void testFileStore() throws URISyntaxException, IOException {
  URI uri = clusterUri.resolve("/tmp/testFileStore");
  Path path = Paths.get(uri);
  if (Files.exists(path))
    Files.delete(path);
  assertFalse(Files.exists(path));
  Files.createFile(path);
  assertTrue(Files.exists(path));
  FileStore st = Files.getFileStore(path);
  assertNotNull(st);
  Assert.assertNotNull(st.name());
  Assert.assertNotNull(st.type());

  Assert.assertFalse(st.isReadOnly());

  Assert.assertNotEquals(0, st.getTotalSpace());
  Assert.assertNotEquals(0, st.getUnallocatedSpace());
  Assert.assertNotEquals(0, st.getUsableSpace());

  Assert
      .assertTrue(st.supportsFileAttributeView(BasicFileAttributeView.class));
  Assert.assertTrue(st.supportsFileAttributeView("basic"));

  st.getAttribute("test");
}
 

@Override
public Iterable<FileStore> getFileStores() {
  final Iterable<FileStore> fileStores = delegate.getFileStores();
  return () -> {
    final Iterator<FileStore> iterator = fileStores.iterator();
    return new Iterator<FileStore>() {
      @Override
      public boolean hasNext() {
        return iterator.hasNext();
      }

      @Override
      public FileStore next() {
        return new FilterFileStore(iterator.next(), parent.getScheme()) {};
      }
      
      @Override
      public void remove() {
        iterator.remove();
      }
    };
  };
}
 

private static Long getUsableSpace(String dir) {
  try {
    File file = new File(dir);
    if (!file.exists()) {
      file = file.getParentFile();
      if (!file.exists()) {//this is not a disk directory . so just pretend that there is enough space
        return Long.MAX_VALUE;
      }
    }
    FileStore fileStore = Files.getFileStore(file.toPath());
    return fileStore.getUsableSpace();
  } catch (IOException e) {
    throw new SolrException(ErrorCode.SERVER_ERROR, "Could not free disk space", e);
  }
}
 

@Override
public Iterable<FileStore> getFileStores() {
    FileStore store;
    try {
        store = Files.getFileStore(root);
    } catch (IOException ioe) {
        store = null;
    }
    return SoleIterable(store);
}
 

private static boolean supportsFileOwnerAttributeView(Path path, Class<? extends FileOwnerAttributeView> view) {
    FileStore store;
    try {
        store = Files.getFileStore(path);
    } catch (IOException e) {
        return false;
    }
    return store.supportsFileAttributeView(view);
}
 

private static String getMountPointLinux(final FileStore store) {
    String desc = store.toString();
    int index = desc.lastIndexOf(" (");
    if (index != -1) {
        return desc.substring(0, index);
    } else {
        return desc;
    }
}
 

public void testNVME() throws Exception {
  assumeFalse("windows is not supported", Constants.WINDOWS);
  Path dir = createTempDir();
  dir = FilterPath.unwrap(dir).toRealPath();
  
  // fake ssd
  FileStore root = new MockFileStore(dir.toString() + " (/dev/nvme0n1p1)", "btrfs", "/dev/nvme0n1p1");
  // make a fake /dev/nvme0n1p1 for it
  Path devdir = dir.resolve("dev");
  Files.createDirectories(devdir);
  Files.createFile(devdir.resolve("nvme0n1p1"));
  // make a fake /sys/block/nvme0n1/queue/rotational file for it
  Path sysdir = dir.resolve("sys").resolve("block").resolve("nvme0n1").resolve("queue");
  Files.createDirectories(sysdir);
  try (OutputStream o = Files.newOutputStream(sysdir.resolve("rotational"))) {
    o.write("0\n".getBytes(StandardCharsets.US_ASCII));
  }
  // As test for the longest path match, add some other devices (that have no queue/rotational), too:
  Files.createFile(dir.resolve("sys").resolve("block").resolve("nvme0"));
  Files.createFile(dir.resolve("sys").resolve("block").resolve("dummy"));
  Files.createFile(dir.resolve("sys").resolve("block").resolve("nvm"));
  Map<String,FileStore> mappings = Collections.singletonMap(dir.toString(), root);
  FileSystem mockLinux = new MockLinuxFileSystemProvider(dir.getFileSystem(), mappings, dir).getFileSystem(null);
  
  Path mockPath = mockLinux.getPath(dir.toString());
  assertFalse(IOUtils.spinsLinux(mockPath));
}
 

public void testGetFileStore() throws Exception {
  Path dir = createTempDir();
  dir = FilterPath.unwrap(dir).toRealPath();
  
  // now we can create some fake mount points:
  FileStore root = new MockFileStore(dir.toString() + " (/dev/sda1)", "ntfs", "/dev/sda1");
  FileStore usr = new MockFileStore(dir.resolve("usr").toString() + " (/dev/sda2)", "xfs", "/dev/sda2");

  // associate some preset files to these
  Map<String,FileStore> mappings = new HashMap<>();
  mappings.put(dir.toString(), root);
  mappings.put(dir.resolve("foo.txt").toString(), root);
  mappings.put(dir.resolve("usr").toString(), usr);
  mappings.put(dir.resolve("usr/bar.txt").toString(), usr);
  
  FileSystem mockLinux = new MockLinuxFileSystemProvider(dir.getFileSystem(), mappings, dir).getFileSystem(null);
  Path mockPath = mockLinux.getPath(dir.toString());
  
  // sanity check our mock:
  assertSame(usr, Files.getFileStore(mockPath.resolve("usr")));
  assertSame(usr, Files.getFileStore(mockPath.resolve("usr/bar.txt")));
  // for root filesystem we get a crappy one
  assertNotSame(root, Files.getFileStore(mockPath));
  assertNotSame(usr, Files.getFileStore(mockPath));
  assertNotSame(root, Files.getFileStore(mockPath.resolve("foo.txt")));
  assertNotSame(usr, Files.getFileStore(mockPath.resolve("foo.txt")));
  
  // now test our method:
  assertSame(usr, IOUtils.getFileStore(mockPath.resolve("usr")));
  assertSame(usr, IOUtils.getFileStore(mockPath.resolve("usr/bar.txt")));
  assertSame(root, IOUtils.getFileStore(mockPath));
  assertSame(root, IOUtils.getFileStore(mockPath.resolve("foo.txt")));
}
 

@Override
public FileStore getFileStore(Path path) throws IOException {
  FileStore ret = filesToStore.get(path.toString());
  if (ret == null) {
    throw new IllegalArgumentException("this mock doesnt know wtf to do with: " + path);
  }
  // act like the linux fs provider here, return a crazy rootfs one
  if (ret.toString().startsWith(root + " (")) {
    return new MockFileStore(root + " (rootfs)", "rootfs", "rootfs");
  }

  return ret;
}
 

@Override
public void bindTo(MeterRegistry registry) {
  for (FileStore fileStore : FileSystems.getDefault().getFileStores()) {
    LOG.debug(
        "Add gauge metric for {}, isReadOnly {}, type {}",
        fileStore.name(),
        fileStore.isReadOnly(),
        fileStore.type());
    Iterable<Tag> tagsWithPath = Tags.concat(Tags.empty(), "path", fileStore.toString());

    Gauge.builder("disk.free", fileStore, exceptionToNonWrapper(FileStore::getUnallocatedSpace))
        .tags(tagsWithPath)
        .description("Unallocated space for file storage")
        .baseUnit("bytes")
        .strongReference(true)
        .register(registry);
    Gauge.builder("disk.total", fileStore, exceptionToNonWrapper(FileStore::getTotalSpace))
        .tags(tagsWithPath)
        .description("Total space for file storage")
        .baseUnit("bytes")
        .strongReference(true)
        .register(registry);
    Gauge.builder("disk.usable", fileStore, exceptionToNonWrapper(FileStore::getUsableSpace))
        .tags(tagsWithPath)
        .description("Usable space for file storage")
        .baseUnit("bytes")
        .strongReference(true)
        .register(registry);
  }
}
 

@Override
public Iterable<FileStore> getFileStores() {
    FileStore store;
    try {
        store = Files.getFileStore(root);
    } catch (IOException ioe) {
        store = null;
    }
    return SoleIterable(store);
}
 

@Override
public Iterable<FileStore> getFileStores() {
    return MCRContentStoreFactory
        .getAvailableStores()
        .keySet()
        .stream()
        .map(MCRIFSFileSystem::getFileStore)::iterator;
}
 

public long unallocatedBytes() throws IOException {
    Iterable<FileStore> fileStores = localFileSystem.getFileStores();
    long totalUsableSpace = 0l;
    for(FileStore fs:fileStores){
        totalUsableSpace+=fs.getUnallocatedSpace();
    }
    return totalUsableSpace;
}
 

static FileStore getFileStore(Path path) throws IOException {
  FileStore store = Files.getFileStore(path);
  String mount = getMountPoint(store);

  // find the "matching" FileStore from system list, it's the one we want, but only return
  // that if it's unambiguous (only one matching):
  FileStore sameMountPoint = null;
  for (FileStore fs : path.getFileSystem().getFileStores()) {
    if (mount.equals(getMountPoint(fs))) {
      if (sameMountPoint == null) {
        sameMountPoint = fs;
      } else {
        // more than one filesystem has the same mount point; something is wrong!
        // fall back to crappy one we got from Files.getFileStore
        return store;
      }
    }
  }

  if (sameMountPoint != null) {
    // ok, we found only one, use it:
    return sameMountPoint;
  } else {
    // fall back to crappy one we got from Files.getFileStore
    return store;    
  }
}
 

public Path toPhysicalPath() throws IOException {
    if (isAbsolute()) {
        for (FileStore fs : getFileSystem().getFileStores()) {
            if (fs instanceof MCRAbstractFileStore) {
                Path physicalPath = ((MCRAbstractFileStore) fs).getPhysicalPath(this);
                if (physicalPath != null) {
                    return physicalPath;
                }
            }
        }
        return null;
    }
    throw new IOException("Cannot get real path from relative path.");
}
 

private static FileStore getFileStore(String id) {
    try {
        return MCRFileStore.getInstance(id);
    } catch (IOException e) {
        throw new MCRException(e);
    }
}
 

@Override
public Iterable<FileStore> getFileStores() {
    FileStore store;
    try {
        store = Files.getFileStore(root);
    } catch (IOException ioe) {
        store = null;
    }
    return SoleIterable(store);
}
 

@Test
public void testFileStore() throws URISyntaxException, IOException {
  URI uri = clusterUri.resolve("/tmp/testFileStore");
  Path path = Paths.get(uri);
  if (Files.exists(path))
    Files.delete(path);
  assertFalse(Files.exists(path));
  Files.createFile(path);
  assertTrue(Files.exists(path));
  FileStore st = Files.getFileStore(path);
  assertNotNull(st);
}
 

public static boolean isReadOnlyExecutable(Path path) throws IOException {
  FileStore fileStore = Files.getFileStore(path);
  if (fileStore.supportsFileAttributeView("posix")) {
    Set<PosixFilePermission> perms = Files.getPosixFilePermissions(path);
    if (perms.contains(PosixFilePermission.OWNER_EXECUTE)
        && !perms.contains(PosixFilePermission.GROUP_EXECUTE)
        && !perms.contains(PosixFilePermission.OTHERS_EXECUTE)) {
      setReadOnlyPerms(path, true);
    }
    return perms.contains(PosixFilePermission.OWNER_EXECUTE);
  } else {
    return Files.isExecutable(path);
  }
}
 

private boolean hasEnoughDiskSpace(Path path)
{
    try {
        FileStore fileStore = getFileStore(path);
        return fileStore.getUsableSpace() > fileStore.getTotalSpace() * (1.0 - maxUsedSpaceThreshold);
    }
    catch (IOException e) {
        throw new PrestoException(OUT_OF_SPILL_SPACE, "Cannot determine free space for spill", e);
    }
}
 

@Override
public FsStat getFsStat() throws IOException {
    FileStore store = Files.getFileStore(_root);
    long total = store.getTotalSpace();
    long free = store.getUsableSpace();
    return new FsStat(total, Long.MAX_VALUE, total-free, pathToInode.size());
}
 

public long freeDiskBytes() throws IOException {
    Iterable<FileStore> fileStores = localFileSystem.getFileStores();
    long totalUsableSpace = 0l;
    for(FileStore fs:fileStores){
        totalUsableSpace+=fs.getUsableSpace();
    }
    return totalUsableSpace;
}
 

static void checkFileStores(FileSystem fs) throws IOException {
    // sanity check method
    if (FileUtils.areFileSystemsAccessible()) {
        System.out.println("\n--- Begin FileStores ---");
        for (FileStore store: fs.getFileStores()) {
            System.out.println(store);
        }
        System.out.println("--- EndFileStores ---\n");
    } else {
        System.err.println
            ("Skipping FileStore check due to file system access failure");
    }
}