1#![recursion_limit = "256"]
16
17#[cfg(test)]
29mod data_usage_snapshot_tests;
30mod ecstore_test_compat;
31
32use std::path::PathBuf;
33use std::sync::{Arc, Once};
34
35#[cfg(feature = "put-object-commit-barrier")]
36use ecstore_test_compat::fixture::ecstore_set_disk;
37use ecstore_test_compat::fixture::{
38 BucketOperations as _, BucketOptions, ECStore, Endpoint, EndpointServerPools, Endpoints, MakeBucketOptions, ObjectIO as _,
39 PoolEndpoints, PutObjReader, SelectObjectSnapshot, init_bucket_metadata_sys, init_local_disks,
40};
41use tokio_util::sync::CancellationToken;
42
43static INIT_TRACING: Once = Once::new();
44
45#[cfg(feature = "put-object-commit-barrier")]
46pub struct PutObjectCommitBarrier(ecstore_set_disk::test_util::PutObjectCommitBarrier);
47
48#[cfg(feature = "put-object-commit-barrier")]
49impl PutObjectCommitBarrier {
50 pub fn before_namespace(bucket: &str, object: &str) -> Self {
51 Self(ecstore_set_disk::test_util::PutObjectCommitBarrier::install(
52 bucket,
53 object,
54 ecstore_set_disk::test_util::PutObjectCommitPause::BeforeNamespace,
55 ))
56 }
57
58 pub async fn wait_until_paused(&self) {
59 self.0.wait_until_paused().await;
60 }
61
62 pub async fn release_and_wait_until_namespace_pending(&self) {
63 self.0.release_and_wait_until_namespace_pending().await;
64 }
65}
66
67pub fn init_tracing() {
70 INIT_TRACING.call_once(|| {
71 let _ = tracing_subscriber::fmt()
72 .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
73 .with_timer(tracing_subscriber::fmt::time::UtcTime::rfc_3339())
74 .with_thread_names(true)
75 .try_init();
76 });
77}
78
79pub struct TestECStoreEnv {
89 pub temp_root: PathBuf,
91 pub disk_paths: Vec<PathBuf>,
93 pub ecstore: Arc<ECStore>,
97 pub endpoint_pools: EndpointServerPools,
104}
105
106impl TestECStoreEnv {
107 pub fn builder() -> TestECStoreEnvBuilder {
108 TestECStoreEnvBuilder::default()
109 }
110
111 pub async fn make_bucket(&self, bucket: &str, versioned: bool) {
115 self.ecstore
116 .make_bucket(
117 bucket,
118 &MakeBucketOptions {
119 versioning_enabled: versioned,
120 ..Default::default()
121 },
122 )
123 .await
124 .unwrap_or_else(|e| panic!("failed to create test bucket {bucket}: {e:?}"));
125 }
126
127 pub async fn put_object_bytes(&self, bucket: &str, object: &str, bytes: Vec<u8>) {
129 let mut reader = PutObjReader::from_vec(bytes);
130 self.ecstore
131 .put_object(bucket, object, &mut reader, &Default::default())
132 .await
133 .unwrap_or_else(|e| panic!("failed to write test object {bucket}/{object}: {e:?}"));
134 }
135
136 pub async fn prepare_select_object_snapshot(&self, bucket: &str, object: &str) -> Arc<SelectObjectSnapshot> {
142 Arc::new(
143 self.ecstore
144 .prepare_select_object_snapshot(bucket, object, &Default::default(), &Default::default())
145 .await
146 .unwrap_or_else(|e| panic!("failed to prepare test object snapshot {bucket}/{object}: {e:?}")),
147 )
148 }
149}
150
151pub struct TestECStoreEnvBuilder {
154 disk_count: usize,
155 prefix: String,
156 base_dir: Option<PathBuf>,
157 init_bucket_metadata: bool,
158}
159
160impl Default for TestECStoreEnvBuilder {
161 fn default() -> Self {
162 Self {
163 disk_count: 4,
164 prefix: "rustfs_test_utils".to_string(),
165 base_dir: None,
166 init_bucket_metadata: true,
167 }
168 }
169}
170
171impl TestECStoreEnvBuilder {
172 pub fn disk_count(mut self, n: usize) -> Self {
174 self.disk_count = n;
175 self
176 }
177
178 pub fn prefix(mut self, prefix: &str) -> Self {
181 self.prefix = prefix.to_string();
182 self
183 }
184
185 pub fn base_dir(mut self, dir: impl Into<PathBuf>) -> Self {
188 self.base_dir = Some(dir.into());
189 self
190 }
191
192 pub fn init_bucket_metadata(mut self, yes: bool) -> Self {
195 self.init_bucket_metadata = yes;
196 self
197 }
198
199 pub async fn build(self) -> TestECStoreEnv {
202 init_tracing();
203
204 let temp_root = match &self.base_dir {
205 Some(dir) => dir.clone(),
206 None => {
207 let root = PathBuf::from(format!("/tmp/{}_{}", self.prefix, uuid::Uuid::new_v4()));
208 if root.exists() {
209 tokio::fs::remove_dir_all(&root).await.ok();
210 }
211 root
212 }
213 };
214 tokio::fs::create_dir_all(&temp_root).await.expect("create test temp root");
215
216 let disk_paths: Vec<PathBuf> = (1..=self.disk_count).map(|i| temp_root.join(format!("disk{i}"))).collect();
217 for disk_path in &disk_paths {
218 tokio::fs::create_dir_all(disk_path).await.expect("create test disk dir");
219 }
220
221 let mut endpoints = Vec::new();
222 for (i, disk_path) in disk_paths.iter().enumerate() {
223 let mut endpoint = Endpoint::try_from(disk_path.to_str().expect("utf-8 disk path")).expect("parse disk endpoint");
224 endpoint.set_pool_index(0);
225 endpoint.set_set_index(0);
226 endpoint.set_disk_index(i);
227 endpoints.push(endpoint);
228 }
229
230 let pool_endpoints = PoolEndpoints {
231 legacy: false,
232 set_count: 1,
233 drives_per_set: self.disk_count,
234 endpoints: Endpoints::from(endpoints),
235 cmd_line: "test".to_string(),
236 platform: format!("OS: {} | Arch: {}", std::env::consts::OS, std::env::consts::ARCH),
237 };
238 let endpoint_pools = EndpointServerPools::from(vec![pool_endpoints]);
239
240 init_local_disks(endpoint_pools.clone()).await.expect("init local disks");
241
242 let server_addr: std::net::SocketAddr = "127.0.0.1:0".parse().expect("parse test addr");
245 let ecstore = ECStore::new(server_addr, endpoint_pools.clone(), CancellationToken::new())
246 .await
247 .expect("build test ECStore");
248
249 let mut pool_meta = ecstore.pool_meta.read().await.clone();
255 pool_meta.dont_save = false;
256 pool_meta
257 .save(ecstore.pools.clone())
258 .await
259 .expect("persist test pool metadata");
260
261 if self.init_bucket_metadata {
262 let buckets_list = ecstore
263 .list_bucket(&BucketOptions {
264 no_metadata: true,
265 ..Default::default()
266 })
267 .await
268 .expect("list buckets for metadata init");
269 let buckets = buckets_list.into_iter().map(|v| v.name).collect();
270 init_bucket_metadata_sys(ecstore.clone(), buckets).await;
271 }
272
273 TestECStoreEnv {
274 temp_root,
275 disk_paths,
276 ecstore,
277 endpoint_pools,
278 }
279 }
280}