What happens to watched directories when they are renamed?

[devurandom]

I am watching a directory (recursively) and also its parent (non-recursively). When I detect a Rename(old, new) event, I tried to unwatch() the old path, but that produced an error (old path is not being watched). The same happened when I tried to unwatch() the new path. Now my question is: How come? What happens to watched directories when they are renamed?

[passcod]

What platform is this?

[passcod]

But generally:

• The old path will not be watched any more
• The new path might be watched depending where it ends up (e.g. within the purview of an existing recursive watch), but nothing special is done. Notably, notify will not be watching the new path automatically. { Edit: see clarification: What happens to watched directories when they are renamed? #165 (comment) }

[devurandom]

This would be Linux 4.18.

I assumed notify still holds an fd to the directory and would thus keep watching it even if it moves.

So generally I can assume that when a directory is being watched and then moved, it is not longer being watched and I do not need to undertake any measures to prevent it from being watched? The only thing I do need to do is to watch out for directories that are being moved into locations that I would like to watch?

[passcod]

So, on Linux, inotify only takes paths as inputs. The kernel does the holding and monitoring, we don't keep FDs ourselves. Other kernel APIs take FDs (like fanotify), but are impractical (such as requiring root and not supporting all events) and also not implemented here.

[passcod]

So generally I can assume that when a directory is being watched and then moved, it is not longer being watched and I do not need to undertake any measures to prevent it from being watched?

If it's moved out of all watched subtrees, yes. If it's moved between watched subtrees, we watch for that and would add a watch on the "new" path.

The only thing I do need to do is to watch out for directories that are being moved into locations that I would like to watch?

Correct, but also you might not get to know where a directory moved to, because if it moves outside the inotify-watched subtrees, the destination event won't get emitted.

[devurandom]

When a directory is moved back into it's original place, it will not automatically be watched by inotify again? (i.e. moving a directory I placed a watch() on to a different location is an implicit unwatch()?)

[passcod]

By inotify, no. But we catch directory creation within the events we get and add watches for them. (Said events will only give us paths within the subtrees we watch, so it doesn't "escape" the watch root, so to speak.)

[passcod]

See this: https://github.com/passcod/notify/blob/master/src/inotify.rs#L232-L270

[passcod]

And I mispoke when I said "Notably, notify will not be watching the new path automatically.". I should have added the caveat "if it's out of our purview". Notify does add watches for directories moved or created into our purview.

[devurandom]

I think there might be a misunderstanding. What I mean is:

let (tx, rx) = channel();
let mut watcher = watcher(tx, Duration::from_secs(2)).unwrap();
watcher.watch(".", RecursiveMode::NonRecursive); // Watch the main directory for new folders we would like to watch
watcher.watch("templates", RecursiveMode::Recursive);
loop {
        match rx.recv() {
            Ok(event) => {
                match &event {
                    Create(path) |
                    Write(path) |
                    Rename(old_path, new_path) => {
                        // First situation:
                        // 1. "templates" directory is renamed to "foo.bar"
                        // 2. I receive the event here, but what is the state of `watcher` afterwards?
                        //
                        // Second situation:
                        // 1. "foo.bar" directory is renamed to "templates"
                        // 2. I receive the event here, but what is the state of `watcher` afterwards? Will it automatically watch "templates" recursively again?
                    }}}}

---

From https://github.com/passcod/notify/blob/master/src/inotify.rs#L232-L270 I gather that for all directories, including those I called watch() on, they will automatically be unwatched by Rust notify, when they are moved out of their original location (i.e. MOVED_FROM). Correct?

[passcod]

when they are moved out of their original location (i.e. MOVED_FROM), directories will automatically be unwatched by Rust notify, correct?

Yes. The caveats and confusion above is because of the two different watch contexts. In all-recursive contexts, the watches would be re-added and everything would work "as expected". Here, the top context is non-recursive, and rename events are only tracked "from above", so notify doesn't re-add watches. This is possibly a missing feature but I'll have to think more about it.

In more detail:

Because you're watching both from without and within, if the move event is from the watch on ., it will be a MOVED_*, and if the move event is from the watch on template, it will be a MOVE_SELF. As you're watching both, both events will be received, but the contexts of the events are different.

The sequence goes like this:

0. State here is one non-recursive watch on . and one recursive watch on templates (and subfolders).
1. Filesystem: rename(templates → foo.bar)
2. Inotify: sends a tracked MOVED_FROM: .../templates for the watch on ..
   • Notify receives it and issues an internal remove_watch event on .../templates.
3. Inotify: sends a tracked MOVED_TO: .../foo.bar for the watch on ..
   • Notify receives it. It's in the context of the watch on ., which is not recursive, so it doesn't issue an internal add_watch event on .../foo.bar.
4. Inotify: sends an untracked MOVE_SELF: .../templates for the watch on templates.
   • Notify receives it and issues an untracked RENAME: .../templates event.
5. Notify: Internal events are settled and external events are emitted.
6. Notify: The debounce layer resolves the tracked MOVED_* events to a single Rename(old, new).
7. State here is one non-recursive watch on .
8. Filesystem: rename(foo.bar → templates)
9. Inotify: sends a tracked MOVED_FROM: .../foo.bar for the watch on ..
   • Notify receives it, but there's no watch on foo.bar so it doesn't do anything special.
10. Inotify: sends a tracked MOVED_TO: .../templates for the watch on ..
    • Notify receives it. It's in the context of the watch on ., which is not recursive, so it doesn't issue an internal add_watch event on .../templates.
11. Notify: internal events settle, external events emit, debounce resolves the rename.
12. State hasn't changed. It's still one non-recursive watch on .

[devurandom]

Thank you very much for the detailed explanation!

I am in the process of writing an opportunistic watcher, which would be able to watch() directories that do not (yet) exist, by watching their parent directory non-recursively and issuing a recursive watch on the target directory, as soon as it comes into existence.

[devurandom]

Would the OpportunisticWatcher from devurandom/gutenberg@c8975c5 be of interest to Notify? Maybe it could be improved upon, generalised added as an optional addon layered on top of the existing Watchers?

[passcod]

Current version is feature-frozen ("maintained, not developed") and the next version will have significantly different architecture, so not directly, but I'll keep it in mind!