changes to libsqlx

Author: MarinPostma

Cargo.lock

@@ -9,7 +9,11 @@ edition = "2021"
 axum = "0.6.18"
 clap = { version = "4.3.11", features = ["derive"] }
 color-eyre = "0.6.2"
+futures = "0.3.28"
 hyper = { version = "0.14.27", features = ["h2"] }
+libsqlx = { version = "0.1.0", path = "../libsqlx" }
+serde = { version = "1.0.166", features = ["derive"] }
 tokio = { version = "1.29.1", features = ["full"] }
 tracing = "0.1.37"
 tracing-subscriber = "0.3.17"
+uuid = { version = "1.4.0", features = ["v4"] }

libsqlx-server/Cargo.toml

@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 
-use libsqlx::Database;
 use tokio::{sync::{mpsc, oneshot}, task::{JoinSet, block_in_place}};
 
 pub mod config;
@@ -26,9 +25,17 @@ enum AllocationMessage {
     }
 }
 
+enum Database {}
+
+impl Database {
+    fn connect(&self) -> Box<dyn libsqlx::Connection + Send> {
+        todo!();
+    }
+}
+
 pub struct Allocation {
     inbox: mpsc::Receiver<AllocationMessage>,
-    database: Box<dyn Database>,
+    database: Database,
     /// senders to the spawned connections
     connections: HashMap<u32, mpsc::Sender<ExecFn>>,
     /// spawned connection futures, returning their connection id on completion.
@@ -69,7 +76,7 @@ impl Allocation {
 
     async fn new_conn_exec(&mut self, exec: ExecFn) -> ConnectionId {
         let id = self.next_conn_id();
-        let conn = block_in_place(|| self.database.connect()).unwrap();
+        let conn = block_in_place(|| self.database.connect());
         let (close_sender, exit) = mpsc::channel(1);
         let (exec_sender, exec_receiver) = mpsc::channel(1);
         let conn = Connection {
@@ -103,7 +110,7 @@ impl Allocation {
 
 struct Connection {
     id: u32,
-    conn: Box<dyn libsqlx::Connection>,
+    conn: Box<dyn libsqlx::Connection + Send>,
     exit: mpsc::Receiver<()>,
     exec: mpsc::Receiver<ExecFn>,
 }

libsqlx-server/src/allocation/mod.rs

@@ -1,21 +1,53 @@
 use std::sync::Arc;
 
-use axum::Router;
+use axum::{extract::State, routing::post, Json, Router};
 use color_eyre::eyre::Result;
 use hyper::server::accept::Accept;
+use serde::{Deserialize, Serialize};
 use tokio::io::{AsyncRead, AsyncWrite};
 
-pub struct AdminServerConfig { }
+use crate::{meta::MetaStore, allocation::config::AllocConfig};
 
-struct AdminServerState { }
+pub struct AdminServerConfig {}
+
+struct AdminServerState {
+    meta_store: Arc<MetaStore>,
+}
 
 pub async fn run_admin_server<I>(_config: AdminServerConfig, listener: I) -> Result<()>
-where I: Accept<Error = std::io::Error>,
-      I::Conn: AsyncRead + AsyncWrite + Send + Unpin + 'static,
+where
+    I: Accept<Error = std::io::Error>,
+    I::Conn: AsyncRead + AsyncWrite + Send + Unpin + 'static,
 {
-    let state = AdminServerState { };
-    let app = Router::new().with_state(Arc::new(state));
-    axum::Server::builder(listener).serve(app.into_make_service()).await?;
+    let state = AdminServerState {
+        meta_store: todo!(),
+    };
+    let app = Router::new()
+        .route("/manage/allocation/create", post(allocate))
+        .with_state(Arc::new(state));
+    axum::Server::builder(listener)
+        .serve(app.into_make_service())
+        .await?;
 
     Ok(())
 }
+
+#[derive(Serialize, Debug)]
+struct ErrorResponse {}
+
+#[derive(Serialize, Debug)]
+struct AllocateResp { }
+
+#[derive(Deserialize, Debug)]
+struct AllocateReq {
+    alloc_id: String,
+    config: AllocConfig,
+}
+
+async fn allocate(
+    State(state): State<Arc<AdminServerState>>,
+    Json(req): Json<AllocateReq>,
+) -> Result<Json<AllocateResp>, Json<ErrorResponse>> {
+    state.meta_store.allocate(&req.alloc_id, &req.config).await;
+    todo!();
+}

libsqlx-server/src/http/admin.rs

@@ -2,7 +2,10 @@ use color_eyre::eyre::Result;
 use tracing::metadata::LevelFilter;
 use tracing_subscriber::prelude::*;
 
+mod allocation;
+mod databases;
 mod http;
+mod meta;
 
 #[tokio::main]
 async fn main() -> Result<()> {

libsqlx-server/src/main.rs

@@ -22,12 +22,26 @@ pub struct DescribeCol {
 
 pub trait Connection {
     /// Executes a query program
-    fn execute_program<B: ResultBuilder>(
+    fn execute_program(
         &mut self,
         pgm: Program,
-        result_builder: B,
-    ) -> crate::Result<B>;
+        result_builder: &mut dyn ResultBuilder,
+    ) -> crate::Result<()>;
 
     /// Parse the SQL statement and return information about it.
     fn describe(&self, sql: String) -> crate::Result<DescribeResponse>;
 }
+
+impl Connection for Box<dyn Connection> {
+    fn execute_program(
+        &mut self,
+        pgm: Program,
+        result_builder: &mut dyn ResultBuilder,
+    ) -> crate::Result<()> {
+        self.as_mut().execute_program(pgm, result_builder)
+    }
+
+    fn describe(&self, sql: String) -> crate::Result<DescribeResponse> {
+        self.as_ref().describe(sql)
+    }
+}