asyncgit 0.2.1

allow using git2 in a asynchronous context
Documentation 
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use crate::{hash, sync, AsyncNotification, StatusItem, CWD};
use crossbeam_channel::Sender;
use log::trace;
use std::{
    hash::Hash,
    sync::{
        atomic::{AtomicUsize, Ordering},
        Arc, Mutex,
    },
};
use sync::status::StatusType;

#[derive(Default, Hash, Clone)]
pub struct Status {
    pub work_dir: Vec<StatusItem>,
    pub stage: Vec<StatusItem>,
}

struct Request<R, A>(R, Option<A>);

///
pub struct AsyncStatus {
    current: Arc<Mutex<Request<u64, Status>>>,
    last: Arc<Mutex<Status>>,
    sender: Sender<AsyncNotification>,
    pending: Arc<AtomicUsize>,
}

impl AsyncStatus {
    ///
    pub fn new(sender: Sender<AsyncNotification>) -> Self {
        Self {
            current: Arc::new(Mutex::new(Request(0, None))),
            last: Arc::new(Mutex::new(Status::default())),
            sender,
            pending: Arc::new(AtomicUsize::new(0)),
        }
    }

    ///
    pub fn last(&mut self) -> Status {
        let last = self.last.lock().unwrap();
        last.clone()
    }

    ///
    pub fn is_pending(&self) -> bool {
        self.pending.load(Ordering::Relaxed) > 0
    }

    ///
    pub fn fetch(&mut self, request: u64) -> Option<Status> {
        let hash_request = hash(&request);

        trace!("request: {} [hash: {}]", request, hash_request);

        {
            let mut current = self.current.lock().unwrap();

            if current.0 == hash_request {
                return current.1.clone();
            }

            current.0 = hash_request;
            current.1 = None;
        }

        let arc_current = Arc::clone(&self.current);
        let arc_last = Arc::clone(&self.last);
        let sender = self.sender.clone();
        let arc_pending = Arc::clone(&self.pending);
        rayon_core::spawn(move || {
            arc_pending.fetch_add(1, Ordering::Relaxed);

            let res = Self::get_status();
            trace!("status fetched: {}", hash(&res));

            {
                let mut current = arc_current.lock().unwrap();
                if current.0 == hash_request {
                    current.1 = Some(res.clone());
                }
            }

            {
                let mut last = arc_last.lock().unwrap();
                *last = res;
            }

            arc_pending.fetch_sub(1, Ordering::Relaxed);

            sender
                .send(AsyncNotification::Status)
                .expect("error sending status");
        });

        None
    }

    fn get_status() -> Status {
        let work_dir =
            sync::status::get_status(CWD, StatusType::WorkingDir);
        let stage = sync::status::get_status(CWD, StatusType::Stage);

        Status { stage, work_dir }
    }
}