sn_testnet_deploy/
deploy.rs

1// Copyright (c) 2023, MaidSafe.
2// All rights reserved.
3//
4// This SAFE Network Software is licensed under the BSD-3-Clause license.
5// Please see the LICENSE file for more details.
6
7use crate::{
8    ansible::provisioning::{PrivateNodeProvisionInventory, ProvisionOptions},
9    error::Result,
10    funding::get_address_from_sk,
11    get_anvil_node_data, get_bootstrap_cache_url, get_genesis_multiaddr, write_environment_details,
12    BinaryOption, DeploymentInventory, DeploymentType, EnvironmentDetails, EnvironmentType,
13    EvmDetails, EvmNetwork, InfraRunOptions, LogFormat, NodeType, TestnetDeployer,
14};
15use alloy::{hex::ToHexExt, primitives::U256};
16use colored::Colorize;
17use log::error;
18use serde::{Deserialize, Serialize};
19use std::{path::PathBuf, time::Duration};
20
21#[derive(Clone, Serialize, Deserialize)]
22pub struct DeployOptions {
23    pub binary_option: BinaryOption,
24    pub chunk_size: Option<u64>,
25    pub client_env_variables: Option<Vec<(String, String)>>,
26    pub client_vm_count: Option<u16>,
27    pub client_vm_size: Option<String>,
28    pub current_inventory: DeploymentInventory,
29    pub enable_download_verifier: bool,
30    pub enable_performance_verifier: bool,
31    pub enable_random_verifier: bool,
32    pub enable_telegraf: bool,
33    pub environment_type: EnvironmentType,
34    pub evm_data_payments_address: Option<String>,
35    pub evm_network: EvmNetwork,
36    pub evm_node_vm_size: Option<String>,
37    pub evm_payment_token_address: Option<String>,
38    pub evm_rpc_url: Option<String>,
39    pub full_cone_nat_gateway_vm_size: Option<String>,
40    pub full_cone_private_node_count: u16,
41    pub full_cone_private_node_vm_count: Option<u16>,
42    pub full_cone_private_node_volume_size: Option<u16>,
43    pub funding_wallet_secret_key: Option<String>,
44    pub genesis_node_volume_size: Option<u16>,
45    pub initial_gas: Option<U256>,
46    pub initial_tokens: Option<U256>,
47    pub interval: Duration,
48    pub log_format: Option<LogFormat>,
49    pub max_archived_log_files: u16,
50    pub max_log_files: u16,
51    pub name: String,
52    pub network_id: u8,
53    pub network_dashboard_branch: Option<String>,
54    pub node_count: u16,
55    pub node_env_variables: Option<Vec<(String, String)>>,
56    pub node_vm_count: Option<u16>,
57    pub node_vm_size: Option<String>,
58    pub node_volume_size: Option<u16>,
59    pub output_inventory_dir_path: PathBuf,
60    pub peer_cache_node_count: u16,
61    pub peer_cache_node_vm_count: Option<u16>,
62    pub peer_cache_node_vm_size: Option<String>,
63    pub peer_cache_node_volume_size: Option<u16>,
64    pub symmetric_nat_gateway_vm_size: Option<String>,
65    pub symmetric_private_node_count: u16,
66    pub symmetric_private_node_vm_count: Option<u16>,
67    pub symmetric_private_node_volume_size: Option<u16>,
68    pub public_rpc: bool,
69    pub region: String,
70    pub rewards_address: String,
71    pub uploaders_count: u16,
72    pub upload_interval: u16,
73}
74
75impl TestnetDeployer {
76    pub async fn deploy_to_genesis(
77        &self,
78        options: &DeployOptions,
79    ) -> Result<(ProvisionOptions, (String, String))> {
80        let build_custom_binaries = {
81            match &options.binary_option {
82                BinaryOption::BuildFromSource { .. } => true,
83                BinaryOption::Versioned { .. } => false,
84            }
85        };
86
87        self.create_or_update_infra(&InfraRunOptions {
88            client_image_id: None,
89            client_vm_count: options.client_vm_count,
90            client_vm_size: options.client_vm_size.clone(),
91            enable_build_vm: build_custom_binaries,
92            evm_node_count: match options.evm_network {
93                EvmNetwork::Anvil => Some(1),
94                EvmNetwork::ArbitrumOne => Some(0),
95                EvmNetwork::ArbitrumSepoliaTest => Some(0),
96                EvmNetwork::Custom => Some(0),
97            },
98            evm_node_vm_size: options.evm_node_vm_size.clone(),
99            evm_node_image_id: None,
100            full_cone_nat_gateway_vm_size: options.full_cone_nat_gateway_vm_size.clone(),
101            full_cone_private_node_vm_count: options.full_cone_private_node_vm_count,
102            full_cone_private_node_volume_size: options.full_cone_private_node_volume_size,
103            genesis_vm_count: Some(1),
104            genesis_node_volume_size: options.genesis_node_volume_size,
105            name: options.name.clone(),
106            nat_gateway_image_id: None,
107            node_image_id: None,
108            node_vm_count: options.node_vm_count,
109            node_vm_size: options.node_vm_size.clone(),
110            node_volume_size: options.node_volume_size,
111            peer_cache_image_id: None,
112            peer_cache_node_vm_count: options.peer_cache_node_vm_count,
113            peer_cache_node_vm_size: options.peer_cache_node_vm_size.clone(),
114            peer_cache_node_volume_size: options.peer_cache_node_volume_size,
115            region: options.region.clone(),
116            symmetric_nat_gateway_vm_size: options.symmetric_nat_gateway_vm_size.clone(),
117            symmetric_private_node_vm_count: options.symmetric_private_node_vm_count,
118            symmetric_private_node_volume_size: options.symmetric_private_node_volume_size,
119            tfvars_filenames: Some(
120                options
121                    .environment_type
122                    .get_tfvars_filenames(&options.name, &options.region),
123            ),
124        })
125        .map_err(|err| {
126            println!("Failed to create infra {err:?}");
127            err
128        })?;
129
130        write_environment_details(
131            &self.s3_repository,
132            &options.name,
133            &EnvironmentDetails {
134                deployment_type: DeploymentType::New,
135                environment_type: options.environment_type.clone(),
136                evm_details: EvmDetails {
137                    network: options.evm_network.clone(),
138                    data_payments_address: options.evm_data_payments_address.clone(),
139                    payment_token_address: options.evm_payment_token_address.clone(),
140                    rpc_url: options.evm_rpc_url.clone(),
141                },
142                funding_wallet_address: None,
143                network_id: Some(options.network_id),
144                region: options.region.clone(),
145                rewards_address: Some(options.rewards_address.clone()),
146            },
147        )
148        .await?;
149
150        let mut provision_options = ProvisionOptions::from(options.clone());
151        let anvil_node_data = if options.evm_network == EvmNetwork::Anvil {
152            self.ansible_provisioner
153                .print_ansible_run_banner("Provision Anvil Node");
154            self.ansible_provisioner
155                .provision_evm_nodes(&provision_options)
156                .map_err(|err| {
157                    println!("Failed to provision evm node {err:?}");
158                    err
159                })?;
160
161            Some(
162                get_anvil_node_data(&self.ansible_provisioner.ansible_runner, &self.ssh_client)
163                    .map_err(|err| {
164                        println!("Failed to get evm testnet data {err:?}");
165                        err
166                    })?,
167            )
168        } else {
169            None
170        };
171
172        let funding_wallet_address = if let Some(secret_key) = &options.funding_wallet_secret_key {
173            let address = get_address_from_sk(secret_key)?;
174            Some(address.encode_hex())
175        } else if let Some(emv_data) = &anvil_node_data {
176            let address = get_address_from_sk(&emv_data.deployer_wallet_private_key)?;
177            Some(address.encode_hex())
178        } else {
179            error!("Funding wallet address not provided");
180            None
181        };
182
183        if let Some(custom_evm) = anvil_node_data {
184            provision_options.evm_data_payments_address =
185                Some(custom_evm.data_payments_address.clone());
186            provision_options.evm_payment_token_address =
187                Some(custom_evm.payment_token_address.clone());
188            provision_options.evm_rpc_url = Some(custom_evm.rpc_url.clone());
189            provision_options.funding_wallet_secret_key =
190                Some(custom_evm.deployer_wallet_private_key.clone());
191        };
192
193        write_environment_details(
194            &self.s3_repository,
195            &options.name,
196            &EnvironmentDetails {
197                deployment_type: DeploymentType::New,
198                environment_type: options.environment_type.clone(),
199                evm_details: EvmDetails {
200                    network: options.evm_network.clone(),
201                    data_payments_address: provision_options.evm_data_payments_address.clone(),
202                    payment_token_address: provision_options.evm_payment_token_address.clone(),
203                    rpc_url: provision_options.evm_rpc_url.clone(),
204                },
205                funding_wallet_address,
206                network_id: Some(options.network_id),
207                region: options.region.clone(),
208                rewards_address: Some(options.rewards_address.clone()),
209            },
210        )
211        .await?;
212
213        if build_custom_binaries {
214            self.ansible_provisioner
215                .print_ansible_run_banner("Build Custom Binaries");
216            self.ansible_provisioner
217                .build_safe_network_binaries(&provision_options, None)
218                .map_err(|err| {
219                    println!("Failed to build safe network binaries {err:?}");
220                    err
221                })?;
222        }
223
224        self.ansible_provisioner
225            .print_ansible_run_banner("Provision Genesis Node");
226        self.ansible_provisioner
227            .provision_genesis_node(&provision_options)
228            .map_err(|err| {
229                println!("Failed to provision genesis node {err:?}");
230                err
231            })?;
232
233        let (genesis_multiaddr, genesis_ip) =
234            get_genesis_multiaddr(&self.ansible_provisioner.ansible_runner, &self.ssh_client)
235                .map_err(|err| {
236                    println!("Failed to get genesis multiaddr {err:?}");
237                    err
238                })?;
239
240        Ok((
241            provision_options,
242            (genesis_multiaddr, get_bootstrap_cache_url(&genesis_ip)),
243        ))
244    }
245
246    pub async fn deploy(&self, options: &DeployOptions) -> Result<()> {
247        let (mut provision_options, (genesis_multiaddr, genesis_network_contacts)) =
248            self.deploy_to_genesis(options).await?;
249
250        println!("Obtained multiaddr for genesis node: {genesis_multiaddr}, network contact: {genesis_network_contacts}");
251
252        let mut node_provision_failed = false;
253        self.ansible_provisioner
254            .print_ansible_run_banner("Provision Peer Cache Nodes");
255        match self.ansible_provisioner.provision_nodes(
256            &provision_options,
257            Some(genesis_multiaddr.clone()),
258            Some(genesis_network_contacts.clone()),
259            NodeType::PeerCache,
260        ) {
261            Ok(()) => {
262                println!("Provisioned Peer Cache nodes");
263            }
264            Err(err) => {
265                error!("Failed to provision Peer Cache nodes: {err}");
266                node_provision_failed = true;
267            }
268        }
269
270        self.ansible_provisioner
271            .print_ansible_run_banner("Provision Normal Nodes");
272        match self.ansible_provisioner.provision_nodes(
273            &provision_options,
274            Some(genesis_multiaddr.clone()),
275            Some(genesis_network_contacts.clone()),
276            NodeType::Generic,
277        ) {
278            Ok(()) => {
279                println!("Provisioned normal nodes");
280            }
281            Err(err) => {
282                error!("Failed to provision normal nodes: {err}");
283                node_provision_failed = true;
284            }
285        }
286
287        let private_node_inventory = PrivateNodeProvisionInventory::new(
288            &self.ansible_provisioner,
289            options.full_cone_private_node_vm_count,
290            options.symmetric_private_node_vm_count,
291        )?;
292
293        if private_node_inventory.should_provision_full_cone_private_nodes() {
294            match self.ansible_provisioner.provision_full_cone(
295                &provision_options,
296                Some(genesis_multiaddr.clone()),
297                Some(genesis_network_contacts.clone()),
298                private_node_inventory.clone(),
299                None,
300            ) {
301                Ok(()) => {
302                    println!("Provisioned Full Cone nodes and Gateway");
303                }
304                Err(err) => {
305                    error!("Failed to provision Full Cone nodes and Gateway: {err}");
306                    node_provision_failed = true;
307                }
308            }
309        }
310
311        if private_node_inventory.should_provision_symmetric_private_nodes() {
312            self.ansible_provisioner
313                .print_ansible_run_banner("Provision Symmetric NAT Gateway");
314            self.ansible_provisioner
315                .provision_symmetric_nat_gateway(&provision_options, &private_node_inventory)
316                .map_err(|err| {
317                    println!("Failed to provision Symmetric NAT gateway {err:?}");
318                    err
319                })?;
320
321            self.ansible_provisioner
322                .print_ansible_run_banner("Provision Symmetric Private Nodes");
323            match self.ansible_provisioner.provision_symmetric_private_nodes(
324                &mut provision_options,
325                Some(genesis_multiaddr.clone()),
326                Some(genesis_network_contacts.clone()),
327                &private_node_inventory,
328            ) {
329                Ok(()) => {
330                    println!("Provisioned Symmetric private nodes");
331                }
332                Err(err) => {
333                    error!("Failed to provision Symmetric Private nodes: {err}");
334                    node_provision_failed = true;
335                }
336            }
337        }
338
339        self.ansible_provisioner
340            .print_ansible_run_banner("Provision Clients");
341        self.ansible_provisioner
342            .provision_clients(
343                &provision_options,
344                Some(genesis_multiaddr.clone()),
345                Some(genesis_network_contacts.clone()),
346            )
347            .await
348            .map_err(|err| {
349                println!("Failed to provision Clients {err:?}");
350                err
351            })?;
352        self.ansible_provisioner
353            .print_ansible_run_banner("Provision Downloaders");
354        self.ansible_provisioner
355            .provision_downloaders(
356                &provision_options,
357                Some(genesis_multiaddr.clone()),
358                Some(genesis_network_contacts.clone()),
359            )
360            .await
361            .map_err(|err| {
362                println!("Failed to provision downloaders {err:?}");
363                err
364            })?;
365
366        if node_provision_failed {
367            println!();
368            println!("{}", "WARNING!".yellow());
369            println!("Some nodes failed to provision without error.");
370            println!("This usually means a small number of nodes failed to start on a few VMs.");
371            println!("However, most of the time the deployment will still be usable.");
372            println!("See the output from Ansible to determine which VMs had failures.");
373        }
374
375        Ok(())
376    }
377}
sn_testnet_deploy/deploy.rs

sn_testnet_deploy/
deploy.rs
