vm deployment working

there still are bugs on how it manages tables in the DB

interim_tables.surql

@@ -33,7 +33,6 @@ DEFINE FIELD dtrfs_url ON TABLE new_vm_req TYPE string;
 DEFINE FIELD kernel_sha ON TABLE new_vm_req TYPE string;
 DEFINE FIELD kernel_url ON TABLE new_vm_req TYPE string;
 DEFINE FIELD created_at ON TABLE new_vm_req TYPE datetime;
-DEFINE FIELD updated_at ON TABLE new_vm_req TYPE datetime;
 DEFINE FIELD price_per_unit ON TABLE new_vm_req TYPE int;
 DEFINE FIELD locked_nano ON TABLE new_vm_req TYPE int;
 DEFINE FIELD error ON TABLE new_vm_req TYPE string;

scripts/deploy.sh

@@ -10,12 +10,12 @@ server="$1"
 }
 
 [[ "$server" == "testnet" ]] && server="164.92.249.180"
-[[ "$server" == "staging" ]] && server="registry.detee.ltd"
+[[ "$server" == "staging" ]] && server="149.36.48.100"
 
-cargo build --release
+cargo build --release --bin brain
-ssh $server systemctl stop detee-brain-mock.service
+ssh $server systemctl stop detee-brain.service
-scp target/release/brain-mock $server:/usr/local/bin/brain-mock
+scp target/release/brain $server:/usr/local/bin/detee-brain
-ssh $server mkdir -p /etc/detee/brain-mock/
+ssh $server mkdir -p /etc/detee/brain/
-scp scripts/detee-brain-mock.service $server:/etc/systemd/system/detee-brain-mock.service
+scp scripts/detee-brain.service $server:/etc/systemd/system/detee-brain.service
 ssh $server systemctl daemon-reload
-ssh $server systemctl start detee-brain-mock.service
+ssh $server systemctl start detee-brain.service

scripts/detee-brain.service

@@ -1,10 +1,10 @@
 [Unit]
-Description=DeTEE Brain Mock
+Description=DeTEE Brain
 After=network.target
 
 [Service]
 Type=simple
-ExecStart=/usr/local/bin/brain-mock
+ExecStart=/usr/local/bin/detee-brain
 Restart=always
 
 [Install]

src/bin/brain.rs

@@ -1,8 +1,10 @@
 use detee_shared::general_proto::brain_general_cli_server::BrainGeneralCliServer;
 use detee_shared::vm_proto::brain_vm_cli_server::BrainVmCliServer;
+use detee_shared::vm_proto::brain_vm_daemon_server::BrainVmDaemonServer;
+use surreal_brain::db;
 use surreal_brain::grpc::BrainGeneralCliForReal;
 use surreal_brain::grpc::BrainVmCliForReal;
-use surreal_brain::db;
+use surreal_brain::grpc::BrainVmDaemonForReal;
 use tonic::transport::{Identity, Server, ServerTlsConfig};
 
 #[tokio::main]
@@ -11,17 +13,19 @@ async fn main() {
     db::init().await.unwrap();
     let addr = "0.0.0.0:31337".parse().unwrap();
 
+    let snp_daemon_server = BrainVmDaemonServer::new(BrainVmDaemonForReal {});
     let snp_cli_server = BrainVmCliServer::new(BrainVmCliForReal {});
     let general_service_server = BrainGeneralCliServer::new(BrainGeneralCliForReal {});
 
-    let cert = std::fs::read_to_string("./tmp/brain-crt.pem").unwrap();
+    let cert = std::fs::read_to_string("/etc/detee/brain/brain-crt.pem").unwrap();
-    let key = std::fs::read_to_string("./tmp/brain-key.pem").unwrap();
+    let key = std::fs::read_to_string("/etc/detee/brain/brain-key.pem").unwrap();
 
     let identity = Identity::from_pem(cert, key);
 
     Server::builder()
         .tls_config(ServerTlsConfig::new().identity(identity))
         .unwrap()
+        .add_service(snp_daemon_server)
         .add_service(snp_cli_server)
         .add_service(general_service_server)
         .serve(addr)

src/db.rs

@@ -206,16 +206,16 @@ impl VmNodeWithReports {
             filters.storage_gb
         );
         if !filters.city.is_empty() {
-            query += &format!(r#"&& city = "{}"\n"#, filters.city);
+            query += &format!("&& city = '{}' ", filters.city);
         }
         if !filters.region.is_empty() {
-            query += &format!(r#"&& region = "{}"\n"#, filters.region);
+            query += &format!("&& region = '{}' ", filters.region);
         }
         if !filters.country.is_empty() {
-            query += &format!(r#"&& country = "{}"\n"#, filters.country);
+            query += &format!("&& country = '{}' ", filters.country);
         }
         if !filters.ip.is_empty() {
-            query += &format!(r#"&& ip = "{}"\n"#, filters.ip);
+            query += &format!("&& ip = '{}' ", filters.ip);
         }
         query += ";";
         let mut result =
@@ -284,7 +284,7 @@ impl NewVmReq {
     }
 
     pub async fn submit(self) -> Result<(), Error> {
-        let _: Option<Self> = DB.create(self.id.clone()).content(self).await?;
+        let _: Vec<Self> = DB.insert(NEW_VM_REQ).relation(self).await?;
         Ok(())
     }
 }
@@ -305,13 +305,14 @@ impl NewVmResp {
                 "live select * from measurement_args where id = measurement_args:{vm_id};"
             ))
             .await?;
-        let mut live_stream1 = resp.stream::<Notification<NewVmReq>>(0)?;
+        let mut new_vm_stream = resp.stream::<Notification<NewVmReq>>(0)?;
-        let mut live_stream2 =
+        let mut args_stream =
             resp.stream::<Notification<detee_shared::snp::pb::vm_proto::MeasurementArgs>>(1)?;
 
         loop {
             tokio::select! {
-                new_vm_req_notif = live_stream1.next() => {
+                new_vm_req_notif = new_vm_stream.next() => {
+                    log::debug!("Got stream 1...");
                     if let Some(new_vm_req_notif) = new_vm_req_notif {
                         match new_vm_req_notif {
                             Ok(new_vm_req_notif) => {
@@ -328,7 +329,7 @@ impl NewVmResp {
                         }
                     }
                 }
-                args_notif = live_stream2.next() => {
+                args_notif = args_stream.next() => {
                     if let Some(args_notif) = args_notif {
                         match args_notif {
                             Ok(args_notif) => {

src/grpc.rs

@@ -35,9 +35,9 @@ impl From<NewVmReq> for db::NewVmReq {
     fn from(new_vm_req: NewVmReq) -> Self {
         Self {
             id: RecordId::from((db::NEW_VM_REQ, nanoid!(40, &db::ID_ALPHABET))),
-            hostname: new_vm_req.hostname,
             admin: RecordId::from((db::ACCOUNT, new_vm_req.admin_pubkey)),
             vm_node: RecordId::from((db::VM_NODE, new_vm_req.node_pubkey)),
+            hostname: new_vm_req.hostname,
             extra_ports: new_vm_req.extra_ports,
             public_ipv4: new_vm_req.public_ipv4,
             public_ipv6: new_vm_req.public_ipv6,
@@ -235,7 +235,7 @@ impl From<VmNodeResources> for db::VmNodeResources {
     }
 }
 
-struct BrainVmDaemonForReal {}
+pub struct BrainVmDaemonForReal {}
 
 #[tonic::async_trait]
 impl BrainVmDaemon for BrainVmDaemonForReal {
@@ -676,13 +676,12 @@ impl BrainVmCli for BrainVmCliForReal {
     ) -> Result<Response<VmNodeListResp>, Status> {
         let req = check_sig_from_req(req)?;
         info!("Unknown CLI requested ListVmNodesStream: {req:?}");
-        todo!();
+        // TODO: optimize this query so that it gets only one node
-        // match self.data.get_one_node_by_filters(&req) {
+        let nodes = db::VmNodeWithReports::find_by_filters(req).await?;
-        //     Some(node) => Ok(Response::new(node.into())),
+        if let Some(node) = nodes.into_iter().next() {
-        //     None => Err(Status::not_found(
+            return Ok(Response::new(node.into()));
-        //         "Could not find any node based on your search criteria",
+        }
-        //     )),
+        Err(Status::not_found("Could not find any node based on your search criteria"))
-        // }
     }
 }