jb_alvarado
Lieutenant
- Registriert
- Sep. 2015
- Beiträge
- 576
Hallo Allerseits,
ich lerne gerade Rust und nebenbei versuche ich ein Programm, welches ich in python geschrieben hatte, in Rust nach zubauen.
Hier ist es so, dass ich gerne den Inhalt eines Ordners (mit mp4 Videos) abspielen möchte und gleichzeitig soll der Ordner überwacht werden ob Dateien sich ändern. Wenn es eine Änderung gibt, soll sich das direkt auf die Liste der abzuspielenden Dateien auswirken.
Für die Dateiliste dachte ich, könnte ich ein
Zum überwachen des Ordner nehme ich notify:
Und in einer weiteren Funktion würde ich nun den Ordner einlesen und verarbeiten:
Hierbei habe ich jetzt allerdings zwei Probleme:
1.
2. Bei Rust ist es ja so, dass man keine Varibale weiter verarbeiten darf, wenn sie schon ausgeliehen ist. Also wenn ich den Vector mit den Dateien drinnen an die watch_folder Function übergeben würde, könnte ich ihn nicht danach im loop auslesen. Was gibt es hier für Möglichkeiten?
ich lerne gerade Rust und nebenbei versuche ich ein Programm, welches ich in python geschrieben hatte, in Rust nach zubauen.
Hier ist es so, dass ich gerne den Inhalt eines Ordners (mit mp4 Videos) abspielen möchte und gleichzeitig soll der Ordner überwacht werden ob Dateien sich ändern. Wenn es eine Änderung gibt, soll sich das direkt auf die Liste der abzuspielenden Dateien auswirken.
Für die Dateiliste dachte ich, könnte ich ein
struct nehmen:
Rust:
struct Source {
files: Vec<String>
}
impl Source {
fn new() -> Self {
Self {
files: vec![]
}
}
fn push(&mut self, file: String) {
self.files.push(file)
}
fn rm(&mut self, file: String) {
self.files.retain(|x| x != &file);
}
fn mv(&mut self, old_file: String, new_file: String) {
let i = self.files
.iter()
.position(|x| *x == old_file)
.unwrap();
self.files[i] = new_file;
}
}Zum überwachen des Ordner nehme ich notify:
Rust:
fn watch_folder(path: &String, source: &mut Source) {
// let mut source = Source::new();
let (sender, receiver) = channel();
let mut watcher = watcher(sender, Duration::from_secs(2)).unwrap();
watcher.watch(path, RecursiveMode::Recursive).unwrap();
println!("watch path: '{}'", path);
loop {
match receiver.recv() {
Ok(event) => match event {
Create(new_path) => {
println!("Create new file: {:?}", new_path);
source.push(new_path.display().to_string());
}
Remove(old_path) => {
println!("Remove file: {:?}", old_path);
source.rm(old_path.display().to_string());
}
Rename(old_path, new_path) => {
println!("Rename file: {:?} to {:?}", old_path, new_path);
source.mv(old_path.display().to_string(),
new_path.display().to_string());
}
_ => (),
},
Err(e) => println!("watch error: {:?}", e),
}
}Und in einer weiteren Funktion würde ich nun den Ordner einlesen und verarbeiten:
Rust:
pub fn walk(path: &String) {
let mut source = Source::new();
let mut index: usize = 0;
for entry in WalkDir::new(path).into_iter().filter_map(|e| e.ok()) {
if entry.path().is_file() {
source.push(entry.path().display().to_string());
}
}
watch_folder(&path, &mut source);
loop {
while index < source.files.len() {
println!("Play file {}: {:?}", index, source.files[index]);
index += 1;
thread::sleep(time::Duration::from_secs(10)); // simulate playing
}
index = 0
}
}Hierbei habe ich jetzt allerdings zwei Probleme:
1.
watch_folder() muss im Hintergrund ausgeführt werden. Was wäre hier die beste Methode? async, mit Threads oder mit dieses tokio? Mein erster async versuch (mit block_on()) ist gescheitet, watch_folder() hatte es erst gestartet als der loop fertig war.2. Bei Rust ist es ja so, dass man keine Varibale weiter verarbeiten darf, wenn sie schon ausgeliehen ist. Also wenn ich den Vector mit den Dateien drinnen an die watch_folder Function übergeben würde, könnte ich ihn nicht danach im loop auslesen. Was gibt es hier für Möglichkeiten?
Zuletzt bearbeitet:
