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

use crate::get_device_from_file;
use cyfs_base::*;
use std::fs;
use std::path::PathBuf;

#[derive(Clone)]
pub struct TestContext {
    meta_endpoint: String,
    test_dir: PathBuf,
    owner_device_desc_path: PathBuf,
    owner_device_id: DeviceId,
    owowner_device: Device,
    owner_private_key: PrivateKey,
    devices: Vec<(Device, PrivateKey)>,
}

impl TestContext {
    pub fn new(
        meta_endpoint: String,
        test_dir: PathBuf,
        peer_desc_path: PathBuf,
        peer_desc: Device,
        peer_secret: PrivateKey,
    ) -> BuckyResult<Self> {
        let peer_id = peer_desc.desc().device_id();

        Ok(TestContext {
            meta_endpoint,
            test_dir,
            owner_device_desc_path: peer_desc_path,
            owner_device_id: peer_id,
            owowner_device: peer_desc,
            owner_private_key: peer_secret,
            devices: Vec::new(),
        })
    }

    pub fn owner_device(&self) -> &Device {
        &self.owowner_device
    }

    pub fn owner_device_desc_path(&self) -> PathBuf {
        self.owner_device_desc_path.clone()
    }

    pub fn owner_device_id(&self) -> DeviceId {
        self.owner_device_id.clone()
    }

    pub fn owner_public_key(&self) -> &PublicKey {
        self.owowner_device.desc().public_key()
    }

    pub fn owner_private_key(&self) -> &PrivateKey {
        &self.owner_private_key
    }

    pub fn test_dir(&self) -> PathBuf {
        self.test_dir.clone()
    }

    pub fn devices(&self) -> &Vec<(Device, PrivateKey)> {
        &self.devices
    }

    pub fn meta_endpoint(&self) -> String {
        self.meta_endpoint.clone()
    }

    pub fn load_devices(&mut self) -> BuckyResult<()> {
        let peer_desc_dir = self.test_dir.join("device_secs");
        info!(
            "load peers info from peer desc dir:{}",
            peer_desc_dir.to_string_lossy()
        );
        for entry in fs::read_dir(&peer_desc_dir)? {
            let entry = entry?;
            let peer_path = entry.path();

            let peer_desc_path = peer_path.join("device");

            info!(
                "load peer desc from peer desc file:{}",
                peer_desc_path.to_string_lossy()
            );
            let (device_desc, secret) = get_device_from_file(
                &peer_desc_path.with_extension("desc"),
                &peer_desc_path.with_extension("sec"),
            )?;

            self.devices.push((device_desc, secret));
        }
        Ok(())
    }
}