Java捕获Linux挂载/卸载文件夹

Question

I have a java project which one of its components is to monitor a specific folder which is mounted to my machine.
My linux version is OpenSUSE 42.1

For monitoring the folder I'm using java's Watch Service .
Attached is the main code for folder monitoring we found online and modified to our on need.
(sorry for the lack of copy rights, can't find where it was taken from) .
Constructor:

/**
 * Creates a WatchService and registers the given directory
 */
public WatchDir(Path dir, Kind<?>... dirWatchKinds) throws IOException {
    this.watcher = FileSystems.getDefault().newWatchService();
    this.keys = new HashMap<WatchKey,Path>();

    register(dir, dirWatchKinds);
    Runtime.getRuntime().addShutdownHook(new Thread() {
        public void run() {
            try {
                watcher.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    });
}

Run method (implemented as runnable):

/**
 * Process all events for keys queued to the watcher
 */
public void run() {
    while (shouldRun) {

        // wait for key to be signalled
        WatchKey key;
        try {               
            key = watcher.take();
        } catch (Exception x) {             
            return;
        }

        Path dir = keys.get(key);
        if (dir == null) {
            log.error("WatchKey not recognized!!");
            continue;
        }

        for (WatchEvent<?> event: key.pollEvents()) {
            WatchEvent.Kind<?> kind = event.kind();

            if (kind == OVERFLOW) {
                continue;
            }

            // Context for directory entry event is the file name of entry
            WatchEvent<Path> ev = cast(event);
            Path name = ev.context();
            Path child = dir.resolve(name);

           handleDirEvent(child, ev.kind());

        }

        // reset key and remove from set if directory no longer accessible
        boolean valid = key.reset();
        if (!valid) {
            // Check that dir path still exists. If not, notify user and whoever run the thread
            if (Files.notExists(dir)){
                //log.error(String.format("Directory ", arg1));
                fireFileChangedEvent(dir.getFileName().toString(), FileState.Deleted);
            }

            keys.remove(key);

            // all directories are inaccessible
            if (keys.isEmpty()) {
                break;
            }
        }
    }
}

Now for my problem.
The mounted folder is prone to disconnections which probably will be handled out side of my program scope (from terminal I guess).
Currently when it happens, the watcher.take() is getting notified, without any events to handle,
and on the boolean valid = key.reset() it gets value false which then results in thread termination eventually.
From that point I don't really know when the folder will be mounted again - for re-running the monitor thread.

What is the best way to monitor mount / unmount of the folder?
Please note : the monitored endpoint folder not necessarily is the mounting point, it (the mounted folder) could be one of its ancestors.

Any help would be appreciated!

Answer 1

Your could look at the /proc/mounts file to see if the mount still exist or not.

Not sure about OpenSUSE but I assume they work the same as Redhat style linux. https://www.centos.org/docs/5/html/5.2/Deployment_Guide/s2-proc-mounts.html

Answer 2

Following @StefanE answer, I found the following good example for using java native for reading this file.
Taken from this answer ,
it parses nicely the /etc/mtab file, and in my specific usage I'll check this file each time interval to see if the folder is mounted again.

    mntent mntEnt;
    Pointer stream = CLib.INSTANCE.setmntent("/etc/mtab", "r");
    while ((mntEnt = CLib.INSTANCE.getmntent(stream)) != null) {
        if (mntEnt.mnt_type.equalsIgnoreCase("cifs")){
            System.out.println("Mounted from: " + mntEnt.mnt_fsname);
            System.out.println("Mounted on: " + mntEnt.mnt_dir);
            System.out.println("File system type: " + mntEnt.mnt_type);
            System.out.println("-------------------------------");  
        }
    }

    CLib.INSTANCE.endmntent(stream);

for my specific usage it results with

Mounted from: //192.168.163.129/storage1/rawData
Mounted on: /mntMS/StorageServer1/rawData
File system type: cifs

Mounted from: //192.168.163.129/storage2/output
Mounted on: /mntMS/StorageServer2/output
File system type: cifs

Mounted from: //192.168.163.129/storage2/rawData
Mounted on: /mntMS/StorageServer2/rawData
File system type: cifs

Mounted from: //127.0.0.1/storage1/output
Mounted on: /mntMS/StorageServer1/output
File system type: cifs