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

use super::request::*;
use crate::base::*;
use cyfs_base::BuckyResult;

use http_types::{Method, Request, StatusCode, Url};
use std::sync::Arc;


pub struct SyncRequestor {
    requestor: HttpRequestorRef,
    service_url: Url,
}

impl Default for SyncRequestor {
    fn default() -> Self {
        let service_addr = format!("127.0.0.1:{}", cyfs_base::NON_STACK_HTTP_PORT);

        Self::new_tcp(&service_addr)
    }
}

impl SyncRequestor {
    pub fn new_tcp(service_addr: &str) -> Self {
        let tcp_requestor = TcpHttpRequestor::new(service_addr);
        Self::new(Arc::new(Box::new(tcp_requestor)))
    }

    pub fn new(requestor: HttpRequestorRef) -> Self {
        let addr = requestor.remote_addr();

        let url = format!("http://{}/sync/", addr);
        let url = Url::parse(&url).unwrap();

        Self {
            requestor,
            service_url: url,
        }
    }

    pub async fn sync_status(&self, flush: bool) -> BuckyResult<DeviceSyncStatus> {
        let url = self.service_url.join("status").unwrap();

        let http_req = match flush {
            true => Request::new(Method::Post, url),
            false => Request::new(Method::Get, url),
        };

        debug!("will get device sync status: flush={}", flush);

        let mut resp = self.requestor.request_timeout(http_req, std::time::Duration::from_secs(30)).await?;

        match resp.status() {
            StatusCode::Ok => {
                let ret = RequestorHelper::decode_json_body(&mut resp).await?;

                info!(
                    "get device sync status success: flush={}, status={:?}",
                    flush, ret
                );
                Ok(ret)
            }
            code @ _ => {
                let e = RequestorHelper::error_from_resp(&mut resp).await;

                error!("get device sync status failed: code={}, err={}", code, e);
                Err(e)
            }
        }
    }
}