runar_cli 0.1.0

Runar CLI for node initialization and management
Documentation 
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

//! Configuration management for Runar CLI
//!
//! This module handles loading, saving, and managing node configuration files.

use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::path::Path;
use uuid::Uuid;

/// Node configuration stored in the config file
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NodeConfig {
    /// Unique identifier for this node
    pub node_id: String,

    /// Default network ID this node belongs to
    pub default_network_id: String,

    /// Additional network IDs this node participates in
    pub network_ids: Vec<String>,

    /// Keys name for OS key store (format: runar_{uuid})
    pub keys_name: String,

    /// Node public key (for reference)
    pub node_public_key: String,

    /// Setup server configuration
    pub setup_server: SetupServerConfig,

    /// Request timeout in milliseconds
    pub request_timeout_ms: u64,
}

/// Setup server configuration for QR code generation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SetupServerConfig {
    /// IP address for setup server
    pub ip: String,

    /// Port for setup server
    pub port: u16,
}

impl Default for SetupServerConfig {
    fn default() -> Self {
        Self {
            ip: "127.0.0.1".to_string(),
            port: 8080,
        }
    }
}

impl NodeConfig {
    /// Create a new node configuration
    pub fn new(
        node_id: String,
        default_network_id: String,
        node_public_key: String,
        setup_server: SetupServerConfig,
    ) -> Self {
        let keys_name = format!("runar_{}", Uuid::new_v4());

        Self {
            node_id,
            default_network_id,
            network_ids: Vec::new(),
            keys_name,
            node_public_key,
            setup_server,
            request_timeout_ms: 30000, // 30 seconds
        }
    }

    /// Load configuration from file
    pub fn load(config_dir: &Path) -> Result<Self> {
        let config_file = config_dir.join("config.json");

        if !config_file.exists() {
            return Err(anyhow::anyhow!(
                "Configuration file not found: {:?}",
                config_file
            ));
        }

        let config_content = std::fs::read_to_string(&config_file)
            .with_context(|| format!("Failed to read config file: {config_file:?}"))?;

        let config: NodeConfig = serde_json::from_str(&config_content)
            .with_context(|| format!("Failed to parse config file: {config_file:?}"))?;

        Ok(config)
    }

    /// Save configuration to file
    pub fn save(&self, config_dir: &Path) -> Result<()> {
        let config_file = config_dir.join("config.json");

        let config_content =
            serde_json::to_string_pretty(self).context("Failed to serialize config")?;

        std::fs::write(&config_file, config_content)
            .with_context(|| format!("Failed to write config file: {config_file:?}"))?;

        Ok(())
    }

    /// Check if configuration exists
    pub fn exists(config_dir: &Path) -> bool {
        config_dir.join("config.json").exists()
    }
}