std mpsc sender channel closed when used in closure

I'm trying to create a thread watching for file changes in rust. I'm using the notify crate to get file change events.

The following code shows what is run in the watch thread:

use std::{path::PathBuf, thread};

use log::{error, info};
use notify::Watcher;

fn main() {
    env_logger::init();

    let (tx, rx) = std::sync::mpsc::channel();

    thread::spawn({
        let config_path = PathBuf::from("config.toml");

        move || {
            let mut watcher =
                notify::recommended_watcher(move |res: Result<notify::Event, notify::Error>| {
                    match res {
                        Ok(event) => match event.kind {
                            notify::event::EventKind::Modify(notify::event::ModifyKind::Data(
                                notify::event::DataChange::Any,
                            )) => {
                                info!("Reloading config file");
                                tx.send(true).ok();
                            }
                            _ => (),
                        },
                        Err(e) => {
                            error!("Notify Error: {}", e);
                        }
                    }
                })
                .unwrap();
            watcher.watch(&config_path, notify::RecursiveMode::NonRecursive)
        }
    });

    loop {
        match rx.recv() {
            Ok(_) => {
                // reload config
            }
            Err(e) => {
                error!("Error while watching config file: {}", e);
                break;
            }
        }
    }
}

# Cargo.toml

[dependencies]
env_logger = "0.10.0"
log = "0.4.19"
notify = "6.0.1"

The problem is that I get the output Error while watching config file: receiving on a closed channel when trying to receive from the channel.

I expected that the sender tx is moved into the closure without the channel being closed. But somehow it gets closed.

I already looked through known problems of the notify crate, but I think nothing relates to my problem.

watch() is non-blocking. From the documentation (emphasis mine):

> Begin watching a new path.

So it is fire-and-forget. You don't need to spawn a new thread for it. And in fact, when you do, the thread terminates immediately after the watch, the watcher is dropped and the channel is closed.

Here's what you should do:

fn main() {
    let (tx, rx) = std::sync::mpsc::channel();

    let config_path = PathBuf::from("config.toml");

    let mut watcher =
        notify::recommended_watcher(move |res: Result<notify::Event, notify::Error>| match res {
            Ok(event) => match event.kind {
                notify::event::EventKind::Modify(notify::event::ModifyKind::Data(
                    notify::event::DataChange::Any,
                )) => {
                    info!("Reloading config file");
                    tx.send(true).ok();
                }
                _ => (),
            },
            Err(e) => {
                error!("Notify Error: {}", e);
            }
        })
        .unwrap();
    watcher.watch(&config_path, notify::RecursiveMode::NonRecursive);

    loop {
        match rx.recv() {
            Ok(_) => {
                // reload config
            }
            Err(e) => {
                error!("Error while watching config file: {}", e);
                break;
            }
        }
    }
}