Setting up a poll watcher using notify example - rust

Question

The notify documentation is great for raw and debounced events. There is mention of a poll watcher implementation but I cannot seem to set this up. Would anyone be able to point me or provide some sample code? Either for a raw or debounced method?
I have a mount drive I am trying to watch through Linux and the inotify instance is picking up no events so my only option is to try to poll.
Heres my current code for the debounced
extern crate notify;
extern crate weighted_rs;
use notify::{Watcher, RecursiveMode, watcher};
use std::sync::mpsc::channel;
use std::time::Duration;
use std::path::Path;
use std::fs;
use weighted_rs::{SmoothWeight, Weight};
fn main() {
// Create a channel to receive the events.
let (tx, rx) = channel();
// Create a watcher object, delivering debounced events.
// The notification back-end is selected based on the platform.
let mut watcher = watcher(tx, Duration::from_secs(5)).unwrap();
// Add a path to be watched. All files and directories at that path
and
// below will be monitored for changes.
//watcher.watch("/mnt/jobs_testwatch/",
RecursiveMode::NonRecursive).unwrap();
watcher.watch("/mnt/jobs/", RecursiveMode::NonRecursive).unwrap();
let mut sw: SmoothWeight<&str> = SmoothWeight::new();
sw.add("w1", 1);
sw.add("w2", 1);
sw.add("w3", 1);
loop {
match rx.recv() {
Err(e) => println!("watch error: {:?}", e),
Ok(event) => {
println!("{:?}", event);
match event{
notify::DebouncedEvent::NoticeWrite(_) => {}
notify::DebouncedEvent::NoticeRemove(_) => {}
notify::DebouncedEvent::Write(_) => {},
notify::DebouncedEvent::Chmod(_) => {},
notify::DebouncedEvent::Remove(_) => {}
notify::DebouncedEvent::Rename(_, _) => {}
notify::DebouncedEvent::Rescan => {}
notify::DebouncedEvent::Error(_, _) => {},
notify::DebouncedEvent::Create(x) => {
println!("{:?}", x);
let path_gen = Path::new(&x);
let file_stem = path_gen.file_stem().unwrap();
let extension = path_gen.extension();
//println!("filestem = {:?}, extension = {:?}",
file_stem, extension);
if extension != None {
//println!("event = {:?} -- Path = {:?}", op, path);
//println!("filename =>{:?}, extension =>{:?}",
file_stem, extension.unwrap());
//println!("");
//let xml_string = OsStr::new("xml");
match extension.unwrap().to_str(){
Some("xml")=>{
println!("found {:?}.", extension.unwrap());
let s = sw.next().unwrap();
println!("moving to /{} ...", s);
let movepath = format!
("/mnt/jobs/lbalancewatchers/{}/{}.xml",s,
file_stem.to_str().unwrap());
let foo = fs::read_to_string(&x);
match foo{
Ok(_) => {
let a = fs::rename(&x, &movepath);
if let Err(e) = a {
println!("error moving file -->
{}", e)
}
println!("moved {:?} to {:?}",
&file_stem, &movepath)},
//println!("{:#?}", foo.unwrap())},
Err(_) => println!("")
}
//println!("{:#?}", foo)
}
_ => {println!("{:?} is NOT an xml" ,
extension)}
}
};
},
}
}
}
}
}