osvm 0.8.3

OpenSVM CLI tool for managing SVM nodes and deployments
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use {
    crate::utils::ssh_deploy::{
        client::SshClient,
        dependencies::install_dependencies,
        errors::DeploymentError,
        types::{DeploymentConfig, NetworkType, ServerConfig},
        validators::validate_system_requirements,
    },
    std::error::Error,
};

/// Deploy a node to a remote server
///
/// # Arguments
/// * `host` - Host to deploy to
/// * `svm_name` - SVM name
/// * `node_type` - Node type (validator or RPC)
/// * `network` - Network type
///
/// # Returns
/// * `Result<String, Box<dyn Error>>` - Node ID or error
pub fn deploy_node(
    host: &str,
    svm_name: &str,
    node_type: &str,
    network: NetworkType,
) -> Result<String, Box<dyn Error>> {
    // This is a simplified implementation that returns a node ID
    let node_id = format!("{}-{}-{}-{}", svm_name, node_type, network, host);
    Ok(node_id)
}

/// Deploy a new SVM node to a remote server
///
/// # Arguments
/// * `server_config` - Server configuration
/// * `deployment_config` - Deployment configuration
/// * `progress_callback` - Callback function for progress updates
///
/// # Returns
/// * `Result<(), Box<dyn Error>>` - Success/failure
pub async fn deploy_svm_node(
    server_config: ServerConfig,
    deployment_config: DeploymentConfig,
    progress_callback: Option<crate::prelude::ProgressCallback>,
) -> Result<(), Box<dyn Error>> {
    // Create SSH client and connect
    let mut client = SshClient::new(server_config.clone())?;
    client.connect()?;

    // Send initial progress update
    if let Some(callback) = &progress_callback {
        callback(0, "Connected to server");
    }

    // Get system information
    let system_info = client.get_system_info()?;

    // Send progress update
    if let Some(callback) = &progress_callback {
        callback(5, "Retrieved system information");
    }

    // Check system requirements based on the SVM type and node type
    validate_system_requirements(&system_info, &deployment_config)?;

    // Send progress update
    if let Some(callback) = &progress_callback {
        callback(10, "Validated system requirements");
    }

    // Install dependencies
    install_dependencies(&mut client, &deployment_config)?;

    // Send progress update
    if let Some(callback) = &progress_callback {
        callback(30, "Installed dependencies");
    }

    // Create installation directory
    client.create_directory(&server_config.install_dir)?;

    // Deploy based on SVM type
    match deployment_config.svm_type.as_str() {
        "solana" => {
            crate::utils::ssh_deploy::deployments::solana::deploy_solana(
                &mut client,
                &server_config,
                &deployment_config,
                progress_callback.as_ref(),
            )
            .await?;
        }
        "sonic" => {
            crate::utils::ssh_deploy::deployments::sonic::deploy_sonic(
                &mut client,
                &server_config,
                &deployment_config,
                progress_callback.as_ref(),
            )
            .await?;
        }
        "eclipse" => {
            crate::utils::ssh_deploy::deployments::eclipse::deploy_eclipse(
                &mut client,
                &server_config,
                &deployment_config,
                progress_callback.as_ref(),
            )
            .await?;
        }
        "s00n" => {
            crate::utils::ssh_deploy::deployments::s00n::deploy_s00n(
                &mut client,
                &server_config,
                &deployment_config,
                progress_callback.as_ref(),
            )
            .await?;
        }
        _ => {
            return Err(Box::new(DeploymentError::ValidationError(format!(
                "Unsupported SVM type: {}",
                deployment_config.svm_type
            ))));
        }
    }

    // Send final progress update
    if let Some(callback) = &progress_callback {
        callback(100, "Deployment completed successfully");
    }

    // Close SSH connection
    client.close();

    Ok(())
}