107 lines
3.7 KiB
Rust
107 lines
3.7 KiB
Rust
use detee_shared::app_proto::brain_app_cli_client::BrainAppCliClient;
|
|
use detee_shared::app_proto::{
|
|
AppContract, AppNodeFilters, AppNodeListResp, DelAppReq, ListAppContractsReq, NewAppReq,
|
|
NewAppRes,
|
|
};
|
|
use detee_shared::sgx::types::brain::AppDeployConfig;
|
|
use tokio_stream::StreamExt;
|
|
|
|
use crate::config::Config;
|
|
use crate::sgx::utils::calculate_nanolp_for_app;
|
|
use crate::utils::{self, sign_request};
|
|
|
|
#[derive(thiserror::Error, Debug)]
|
|
pub enum Error {
|
|
#[error("Failed to connect to the brain: {0}")]
|
|
BrainConnection(#[from] tonic::transport::Error),
|
|
#[error("Received error from brain: {}", _0.message())]
|
|
ResponseStatus(#[from] tonic::Status),
|
|
#[error(transparent)]
|
|
InternalError(#[from] utils::Error),
|
|
#[error(transparent)]
|
|
ConfigError(#[from] crate::config::Error),
|
|
}
|
|
|
|
type Result<T> = std::result::Result<T, Error>;
|
|
|
|
pub async fn new_app(app_deploy_config: AppDeployConfig) -> Result<NewAppRes> {
|
|
let resource = app_deploy_config.clone().resource;
|
|
let mut req: NewAppReq = app_deploy_config.clone().into();
|
|
|
|
let locked_nano = calculate_nanolp_for_app(
|
|
resource.vcpu,
|
|
resource.memory_mb,
|
|
resource.disk_mb,
|
|
app_deploy_config.hours,
|
|
req.price_per_unit,
|
|
);
|
|
|
|
req.uuid = "".to_string();
|
|
req.locked_nano = locked_nano;
|
|
req.admin_pubkey = Config::get_detee_wallet()?;
|
|
req.hratls_pubkey = Config::get_hratls_pubkey_hex()?;
|
|
|
|
let mut daemon_serivce = BrainAppCliClient::connect(Config::get_brain_url()).await?;
|
|
let res = daemon_serivce.deploy_app(sign_request(req)?).await?;
|
|
Ok(res.into_inner())
|
|
}
|
|
|
|
pub async fn delete_app(app_uuid: String) -> Result<()> {
|
|
let admin_pubkey = Config::get_detee_wallet()?;
|
|
let delete_req = DelAppReq { uuid: app_uuid, admin_pubkey };
|
|
let mut daemon_serivce = BrainAppCliClient::connect(Config::get_brain_url()).await?;
|
|
let _ = daemon_serivce.delete_app(sign_request(delete_req)?).await?;
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn list_apps() -> Result<Vec<AppContract>> {
|
|
let admin_pubkey = Config::get_detee_wallet().unwrap();
|
|
let list_req = ListAppContractsReq { admin_pubkey };
|
|
let mut daemon_serivce = BrainAppCliClient::connect(Config::get_brain_url()).await?;
|
|
let mut res_stream =
|
|
daemon_serivce.list_app_contracts(sign_request(list_req)?).await?.into_inner();
|
|
|
|
let mut app_contracts = vec![];
|
|
|
|
while let Some(stream_update) = res_stream.next().await {
|
|
match stream_update {
|
|
Ok(contract) => {
|
|
app_contracts.push(contract);
|
|
}
|
|
Err(e) => {
|
|
println!("Brain disconnected from register_node: {e}");
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(app_contracts)
|
|
}
|
|
|
|
pub async fn get_one_app_node(req: AppNodeFilters) -> Result<AppNodeListResp> {
|
|
let mut daemon_serivce = BrainAppCliClient::connect(Config::get_brain_url()).await?;
|
|
let res = daemon_serivce.get_one_app_node(sign_request(req)?).await?;
|
|
|
|
Ok(res.into_inner())
|
|
}
|
|
|
|
pub async fn get_app_node_list(req: AppNodeFilters) -> Result<Vec<AppNodeListResp>> {
|
|
log::debug!("Getting app nodes from brain...");
|
|
let mut daemon_serivce = BrainAppCliClient::connect(Config::get_brain_url()).await?;
|
|
let mut nodes = Vec::new();
|
|
let mut grpc_stream = daemon_serivce.list_app_nodes(sign_request(req)?).await?.into_inner();
|
|
|
|
while let Some(stream_update) = grpc_stream.next().await {
|
|
match stream_update {
|
|
Ok(node) => {
|
|
log::debug!("Received node from brain: {node:?}");
|
|
nodes.push(node);
|
|
}
|
|
Err(e) => {
|
|
log::warn!("Received error instead of node list: {e:?}");
|
|
}
|
|
}
|
|
}
|
|
log::debug!("Brain terminated list_nodes stream.");
|
|
Ok(nodes)
|
|
}
|