more changes, working on subdomain router

Author: benbot

Cargo.lock

@@ -1,6 +1,5 @@
-use std::{collections::HashMap, ptr::null};
+use std::collections::HashMap;
 
-use uuid::uuid;
 use wasmtime::*;
 
 #[derive(Clone, Copy, Debug)]
@@ -99,7 +98,7 @@ impl Runtime {
 
     pub fn add_module(&mut self, name: &str, bytes: &[u8]) -> wasmtime::Result<()> {
         let module = Module::from_binary(self.get_engine(), bytes).unwrap();
-        let result = self.modules.insert(name.to_string(), module.clone());
+        self.modules.insert(name.to_string(), module.clone());
 
         let nuuid = uuid::Uuid::new_v4().to_string();
         println!("nuuid: {}", nuuid);
@@ -110,7 +109,6 @@ impl Runtime {
         match result {
             Some(_) => Err(wasmtime::Error::msg("asdf")),
             None => Ok(()),
-            _ => unreachable!(),
         }
     }
 

orb-runtime/src/lib.rs

@@ -11,5 +11,5 @@ maud = "0.25.0"
 reqwest = { version = "0.11.18", features = ["multipart"] }
 tokio = { version = "1.29.1", features = ["macros", "rt-multi-thread", "net", "sync"] }
 orb-runtime = { path = "../orb-runtime" }
-diesel = { version = "2.1.0", features = [ "sqlite" ] }
 uuid = { version = "1.4.1", features = ["fast-rng", "v4"] }
+tower = "0.4.13"

orb-server/Cargo.toml

@@ -0,0 +1,73 @@
+use std::{convert::Infallible, task::Poll};
+
+use axum::{http::Request, body::{HttpBody, Body}, response::Response, routing::future::RouteFuture, Router};
+use tower::{Service, Layer};
+
+use crate::RuntimeDb;
+
+#[derive(Clone)]
+pub struct Subrouter<S> {
+    inner: S,
+    runtime_db: RuntimeDb,
+}
+
+impl<S> Subrouter<S> {
+    fn new(inner: S, runtime_db: RuntimeDb) -> Self {
+        Self {
+            inner,
+            runtime_db,
+        }
+    }
+}
+
+async fn route_subdomain(subdomain: String) -> Result<(), Infallible> {
+    todo!()
+    // match subdomain {
+    //     crate::config::HOSTNAME => self.inner.call_with_state(req, self.runtime_db.clone()),
+    //     _ => {
+    //         let runtime_db = rt.block_on((*self.runtime_db).lock());
+    //         let orb = runtime_db.get(subdomain).unwrap();
+    //         orb.router.call(req)
+    //     },
+    // }
+}
+
+impl<S, B> Service<Request<B>> for Subrouter<S>
+    where S: Service<Request<B>>,
+          S::Future: Into<RouteFuture<Response, Infallible>>,
+{
+
+    type Response = Response;
+
+    type Error = Infallible;
+
+    type Future = RouteFuture<Response, Self::Error>;
+
+    fn poll_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: Request<B>) -> Self::Future {
+        self.inner.call(req).into()
+    }
+}
+
+
+#[derive(Clone)]
+pub struct SubrouterLayer {
+    runtime_db: RuntimeDb
+}
+
+impl SubrouterLayer {
+    pub fn new(runtime_db: RuntimeDb) -> Self {
+        Self { runtime_db }
+    }
+}
+
+impl<S> Layer<S> for SubrouterLayer {
+    type Service = Subrouter<S>;
+
+    fn layer(&self, inner: S) -> Self::Service {
+        Subrouter::new(inner, self.runtime_db.clone())
+    }
+}

orb-server/src/app_subrouter.rs

@@ -0,0 +1 @@
+pub const HOSTNAME: &'static str = "darch";

orb-server/src/config.rs

@@ -0,0 +1,17 @@
+pub async fn save_wasm(app_name: &String, endpoint: &String, data: Vec<u8>) -> Result<(), reqwest::Error> {
+    let client = reqwest::Client::new();
+
+    let route = format!("/orb/endpoint/{}/{}", app_name, endpoint);
+
+    let res = client
+        .post("http://localhost:5001/api/v0/files/write")
+        .query(&[("arg", route), ("create", "true".to_string()), ("parents", "true".to_string())])
+        .multipart(reqwest::multipart::Form::new().part("file", reqwest::multipart::Part::bytes(data)))
+        .send()
+        .await?;
+
+    println!("Response: {:?}", res);
+    println!("Status: {:?}", String::from_utf8(res.bytes().await?.to_vec()));
+
+    Ok(())
+}