dsc 0.1.3

dsc is a cli tool for finding and removing duplicate files on one or multiple file systems, while respecting your gitignore rules. 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use std::thread;
use std::thread::JoinHandle;

use anyhow::Context;
use crossbeam::channel::{Receiver, Sender};

use crate::candidate_selection::hashing::{FileHasher, HashInstructions};
use crate::candidate_selection::messages::WorkerMessage::{HashComputed, NotHashable};
use crate::candidate_selection::messages::{
    CoordinatorMessage, FileWithDescriptor, HashComputedResult, WorkerMessage,
};

pub struct Worker {
    work_in: Receiver<CoordinatorMessage>,
    work_out: Sender<WorkerMessage>,
    file_hasher: FileHasher,
}

impl Worker {
    // response message should change into an actual message (split offs needs to be respected)
    pub fn new(
        work_in: Receiver<CoordinatorMessage>,
        work_out: Sender<WorkerMessage>,
        buffer_size: usize,
    ) -> Self {
        let file_hasher = FileHasher::new(buffer_size);

        Worker {
            work_in,
            work_out,
            file_hasher,
        }
    }

    pub fn work(mut self) -> JoinHandle<::anyhow::Result<Worker>> {
        thread::spawn(move || {
            self.work_internal()?;
            Ok(self)
        })
    }

    // We are allowed to open up to 512 file handles here
    fn work_internal(&mut self) -> ::anyhow::Result<()> {
        while let Ok(CoordinatorMessage::HashCommand(file_with_handle, instructions)) =
            self.work_in.recv()
        {
            self.hash(file_with_handle, instructions)?;
        }
        Ok(())
    }

    fn hash(
        &mut self,
        file_with_handle: FileWithDescriptor,
        instructions: HashInstructions,
    ) -> ::anyhow::Result<()> {
        let mut file_with_handle = file_with_handle;

        match self
            .file_hasher
            .hash(&mut file_with_handle.file, &instructions)
        {
            Ok(hash) => {
                let result = HashComputedResult { instructions, hash };

                self.work_out
                    .send(HashComputed(file_with_handle, result))
                    .context("Worker failed to send hash result")
            }
            Err(_) => self
                .work_out
                .send(NotHashable(file_with_handle))
                .context("Worker failed to send not hashable message"),
        }?;

        Ok(())
    }
}