Add network driver options for client

Cargo.toml

@@ -34,6 +34,7 @@ tokio = { version = "1.0", features = ["rt-multi-thread", "macros"] }
 tonic = "0.12.3"
 rustyline = "16.0.0"
 colored = "3.0.0"
+clap = { version = "4.5.4", features = ["derive"] }
 
 [dev-dependencies]
 serial_test = "2.0.0"

src/client.rs

@@ -1,18 +1,38 @@
 use std::io::{stdout, Write};
 use std::path::{Path, PathBuf};
 
+use clap::Parser;
 use colored::Colorize;
 
 use rustyline::{error::ReadlineError, DefaultEditor};
 
 use simpledb_rs::{
     driver::{
-        embedded::EmbeddedDriver, ConnectionControl, Driver, DriverControl, MetadataControl,
-        ResultSetControl, Statement, StatementControl,
+        embedded::EmbeddedDriver, network::driver::NetworkDriver, ConnectionControl, Driver,
+        DriverControl, MetadataControl, ResultSetControl, Statement, StatementControl,
     },
     record::field::Type,
 };
 
+#[derive(Parser)]
+#[command(name = "client")]
+struct Args {
+    /// Enable verbose output
+    #[arg(long)]
+    verbose: bool,
+
+    /// Network server host. If omitted, use embedded driver
+    #[arg(long)]
+    host: Option<String>,
+
+    /// Network server port
+    #[arg(long, default_value_t = 50051)]
+    port: u16,
+
+    /// Database URL
+    db_url: Option<String>,
+}
+
 trait ClientEditor {
     fn readline(&mut self, prompt: &str) -> Result<String, ReadlineError>;
     fn load_history<P: AsRef<Path> + ?Sized>(&mut self, path: &P) -> rustyline::Result<()>;
@@ -316,23 +336,19 @@ fn run_client<W: Write, E: ClientEditor>(
 }
 
 fn main() -> Result<(), anyhow::Error> {
+    let args = Args::parse();
+
     let mut editor = DefaultEditor::new()?;
-    let mut db_url = None;
-    let mut verbose = false;
-    for arg in std::env::args().skip(1) {
-        if arg == "--verbose" {
-            verbose = true;
-        } else {
-            db_url = Some(arg);
-        }
-    }
-    simpledb_rs::config::set_verbose(verbose);
-    run_client(
-        Driver::Embedded(EmbeddedDriver::new()),
-        &mut editor,
-        &mut stdout(),
-        db_url.as_deref(),
-    )
+
+    simpledb_rs::config::set_verbose(args.verbose);
+
+    let driver = if let Some(h) = args.host {
+        Driver::Network(NetworkDriver::new(&h, args.port))
+    } else {
+        Driver::Embedded(EmbeddedDriver::new())
+    };
+
+    run_client(driver, &mut editor, &mut stdout(), args.db_url.as_deref())
 }
 
 #[cfg(test)]

src/driver/network/connection.rs

@@ -82,10 +82,7 @@ impl ConnectionService for RemoteConnection {
             .expect(&format!("Unknown connection_id: {}", connection_id));
         connection.close().unwrap();
 
-        self.embedded_connection_dict
-            .lock()
-            .unwrap()
-            .remove(&connection_id);
+        lock.remove(&connection_id);
         Ok(Response::new(ConnectionCloseResponse {}))
     }
 

src/driver/network/driver.rs

@@ -73,44 +73,44 @@ impl DriverService for RemoteDriver {
 
 pub struct NetworkDriver {
     runtime: Arc<Runtime>,
+    host: String,
+    port: u16,
 }
 
 impl NetworkDriver {
-    pub fn new() -> Self {
+    pub fn new(host: &str, port: u16) -> Self {
         let runtime = Builder::new_current_thread().enable_all().build().unwrap();
         let runtime = Arc::new(runtime);
-        NetworkDriver { runtime }
+        NetworkDriver {
+            runtime,
+            host: host.to_string(),
+            port,
+        }
     }
 }
 
 impl DriverControl for NetworkDriver {
-    fn connect(&self, db_url: &str) -> Result<(String, Connection), anyhow::Error> {
-        if let Some(idx) = db_url.find("//") {
-            let db_url = db_url[idx + 2..].trim();
-            let url = format!("http://{}:50051", db_url);
-            dbg!(&url);
-            let endpoint = Endpoint::from_shared(url)?;
-            let channel = self.runtime.block_on(endpoint.connect())?;
-            let mut client = DriverServiceClient::new(channel.clone());
-            let response = self
-                .runtime
-                .block_on(client.create_connection(DriverCreateConnectionRequest {
-                    url: db_url.to_string(),
-                }))?
-                .into_inner();
-            let connection_id = response.connection_id;
-
-            return Ok((
-                "".to_string(),
-                Connection::Network(NetworkConnection::new(
-                    self.runtime.clone(),
-                    channel,
-                    connection_id,
-                )?),
-            ));
-        } else {
-            panic!("Invalid URL");
-        }
+    fn connect(&self, db_name: &str) -> Result<(String, Connection), anyhow::Error> {
+        let url = format!("http://{}:{}", self.host, self.port);
+        let endpoint = Endpoint::from_shared(url)?;
+        let channel = self.runtime.block_on(endpoint.connect())?;
+        let mut client = DriverServiceClient::new(channel.clone());
+        let response = self
+            .runtime
+            .block_on(client.create_connection(DriverCreateConnectionRequest {
+                url: db_name.to_string(),
+            }))?
+            .into_inner();
+        let connection_id = response.connection_id;
+
+        Ok((
+            "".to_string(),
+            Connection::Network(NetworkConnection::new(
+                self.runtime.clone(),
+                channel,
+                connection_id,
+            )?),
+        ))
     }
 }
 
@@ -168,8 +168,8 @@ mod tests {
         // give the server a moment to start
         thread::sleep(Duration::from_millis(100));
 
-        let driver = NetworkDriver::new();
-        let (_db_name, connection) = driver.connect("jdbc:simpledb://127.0.0.1")?;
+        let driver = NetworkDriver::new("127.0.0.1", 50051);
+        let (_db_name, connection) = driver.connect("sample")?;
 
         let mut statement = connection.create_statement()?;
         statement.execute_update("create table test (A I32, B VARCHAR(20))")?;

src/server.rs

@@ -8,7 +8,7 @@ use tonic::transport::Server;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let addr = "[::1]:50051".parse()?;
+    let addr = "127.0.0.1:50051".parse()?;
 
     let remote_driver = RemoteDriver::new();
     let remote_connection = remote_driver.create_remote_connection();