scatter_net/legacy/net/config/methods/
populate_lake_config.rs

1use std::{
2    env,
3    fs::{self, File},
4    path::PathBuf,
5    process,
6};
7
8use anyhow::Result;
9use ps_datalake::lake::config::ConfigStoreEntry;
10
11use crate::NetConfig;
12
13impl NetConfig {
14    pub fn populate_lake_config(&mut self) -> Result<()> {
15        // Check if there's already a writable store
16        let has_writable = self.lake.stores.iter().any(|entry| !entry.readonly);
17
18        if !has_writable {
19            // Create default writable store in user's home directory
20            let home = env::var("HOME")
21                .or_else(|_| env::var("USERPROFILE"))
22                .unwrap_or_else(|_| ".".to_string());
23
24            let pid = process::id();
25            let lake_path = PathBuf::from(home)
26                .join("scatter-net")
27                .join(format!("{pid}.lake"));
28
29            if let Some(lake_directory) = lake_path.parent() {
30                // Create directories if they don't exist
31                fs::create_dir_all(lake_directory).unwrap_or_else(|err| {
32                    eprintln!("Failed to create lake directory: {err}");
33                });
34
35                if !fs::exists(&lake_path)? {
36                    // Create the lake file
37                    let lake_file = File::create(&lake_path).map_err(|err| {
38                        eprintln!("Failed to create lake file: {err}");
39                        err
40                    })?;
41
42                    // Truncate to 1 GiB
43                    lake_file.set_len(1024 * 1024 * 1024).map_err(|err| {
44                        eprintln!("Failed to set file size: {err}");
45                        err
46                    })?;
47                }
48
49                // Add the new store to the configuration
50                self.lake.stores.push(ConfigStoreEntry {
51                    filename: lake_path.to_string_lossy().into_owned(),
52                    readonly: false,
53                });
54
55                // Add all existing entries in the directory as readonly
56                if let Ok(entries) = fs::read_dir(lake_directory) {
57                    for entry in entries.flatten() {
58                        let path = entry.path();
59                        if path != lake_path && path.extension().is_some_and(|ext| ext == "lake") {
60                            self.lake.stores.push(ConfigStoreEntry {
61                                filename: path.to_string_lossy().into_owned(),
62                                readonly: true,
63                            });
64                        }
65                    }
66                }
67            }
68        }
69
70        Ok(())
71    }
72}