taubyte_sdk/storage/
capacity.rs

1use super::{imports, Storage};
2use crate::errno::Error;
3
4// TODO confirm i64 is correct, using int in go-sdk
5impl Storage {
6    fn used_size_unsafe(&self, size: *mut usize) -> Error {
7        #[allow(unused_unsafe)]
8        unsafe {
9            imports::storageUsedSize(self.id, size)
10        }
11    }
12
13    fn used_unsafe(&self, used: *mut u8) -> Error {
14        #[allow(unused_unsafe)]
15        unsafe {
16            imports::storageUsed(self.id, used)
17        }
18    }
19
20    pub fn used(&self) -> Result<i64, Box<dyn std::error::Error>> {
21        let mut size: usize = 0;
22        let err = self.used_size_unsafe(&mut size);
23        if err.is_err() {
24            Err(format!("Getting storage used size failed with: {}", err).into())
25        } else {
26            let mut used = vec![0; size];
27            let err = self.used_unsafe(used.as_mut_ptr());
28            if err.is_err() {
29                Err(format!("Getting storage used failed with: {}", err).into())
30            } else {
31                let used = String::from_utf8(used)?;
32                let used = used.parse::<i64>()?;
33                Ok(used)
34            }
35        }
36    }
37
38    fn capacity_size_unsafe(&self, size: *mut usize) -> Error {
39        #[allow(unused_unsafe)]
40        unsafe {
41            imports::storageCapacitySize(self.id, size)
42        }
43    }
44
45    fn capacity_unsafe(&self, capacity: *mut u8) -> Error {
46        #[allow(unused_unsafe)]
47        unsafe {
48            imports::storageCapacity(self.id, capacity)
49        }
50    }
51
52    pub fn capacity(&self) -> Result<i64, Box<dyn std::error::Error>> {
53        let mut size: usize = 0;
54        let err = self.capacity_size_unsafe(&mut size);
55        if err.is_err() {
56            Err(format!("Getting storage capacity size failed with: {}", err).into())
57        } else {
58            let mut capacity = vec![0; size];
59            let err = self.capacity_unsafe(capacity.as_mut_ptr());
60            if err.is_err() {
61                Err(format!("Getting storage capacity failed with: {}", err).into())
62            } else {
63                let capacity = String::from_utf8(capacity)?;
64                let capacity = capacity.parse::<i64>()?;
65                Ok(capacity)
66            }
67        }
68    }
69
70    pub fn remaining_capacity(&self) -> Result<i64, Box<dyn std::error::Error>> {
71        let used = self.used()?;
72        let capacity = self.capacity()?;
73        Ok(capacity - used)
74    }
75}
76
77#[cfg(test)]
78pub mod test {
79    use crate::storage::Storage;
80
81    use crate::storage::new::test as new_test;
82    pub static STORAGE_USED: &str = "500";
83    pub static STORAGE_CAPACITY: &str = "1000";
84
85    #[test]
86    fn test_capacity() {
87        let storage = Storage::new(new_test::STORAGE_NAME).unwrap_or_else(|err| {
88            panic!("{}", err);
89        });
90
91        let used = storage.used().unwrap_or_else(|err| {
92            panic!("{}", err);
93        });
94        assert_eq!(used, STORAGE_USED.parse::<i64>().unwrap());
95
96        let capacity = storage.capacity().unwrap_or_else(|err| {
97            panic!("{}", err);
98        });
99        assert_eq!(capacity, STORAGE_CAPACITY.parse::<i64>().unwrap());
100
101        let remaining_capacity = storage.remaining_capacity().unwrap_or_else(|err| {
102            panic!("{}", err);
103        });
104        assert_eq!(remaining_capacity, 500);
105    }
106}
107
108#[cfg(test)]
109#[allow(non_snake_case)]
110pub mod mock {
111    use crate::{
112        errno::{Errno, Error},
113        storage::new::test as new_test,
114        utils::test as utils,
115    };
116
117    pub fn storageUsedSize(id: u32, size: *mut usize) -> Error {
118        use super::test;
119
120        if id != new_test::STORAGE_ID {
121            Errno::ErrorCap.error()
122        } else {
123            utils::write_usize(size, test::STORAGE_USED.len());
124            Errno::ErrorNone.error()
125        }
126    }
127
128    pub fn storageUsed(id: u32, used: *mut u8) -> Error {
129        use super::test;
130
131        if id != new_test::STORAGE_ID {
132            Errno::ErrorCap.error()
133        } else {
134            utils::write_string(used, test::STORAGE_USED);
135            Errno::ErrorNone.error()
136        }
137    }
138
139    pub fn storageCapacitySize(id: u32, size: *mut usize) -> Error {
140        use super::test;
141
142        if id != new_test::STORAGE_ID {
143            Errno::ErrorCap.error()
144        } else {
145            utils::write_usize(size, test::STORAGE_CAPACITY.len());
146            Errno::ErrorNone.error()
147        }
148    }
149
150    pub fn storageCapacity(id: u32, capacity: *mut u8) -> Error {
151        use super::test;
152
153        if id != new_test::STORAGE_ID {
154            Errno::ErrorCap.error()
155        } else {
156            utils::write_string(capacity, test::STORAGE_CAPACITY);
157            Errno::ErrorNone.error()
158        }
159    }
160}
taubyte_sdk/storage/capacity.rs

taubyte_sdk/storage/
capacity.rs
