change mgmt json format; add cli flags

proxy/Cargo.toml

@@ -16,5 +16,6 @@ serde = "1"
 serde_json = "1"
 tokio = "1.7.1"
 tokio-postgres = "0.7.2"
+clap = "2.33.0"
 
 zenith_utils = { path = "../zenith_utils" }

proxy/src/cplane_api.rs

@@ -1,22 +1,41 @@
 use anyhow::{bail, Result};
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, net::SocketAddr};
+use std::{
+    collections::HashMap,
+    net::{IpAddr, SocketAddr},
+};
 
 pub struct CPlaneApi {
-    address: SocketAddr,
+    // address: SocketAddr,
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct DatabaseInfo {
-    pub addr: SocketAddr,
-    pub connstr: String,
+    pub host: IpAddr, // TODO: allow host name here too
+    pub port: u16,
+    pub dbname: String,
+    pub user: String,
+    pub password: String,
+}
+
+impl DatabaseInfo {
+    pub fn socket_addr(&self) -> SocketAddr {
+        SocketAddr::new(self.host, self.port)
+    }
+
+    pub fn conn_string(&self) -> String {
+        format!(
+            "dbname={} user={} password={}",
+            self.dbname, self.user, self.password
+        )
+    }
 }
 
 // mock cplane api
 impl CPlaneApi {
-    pub fn new(address: &SocketAddr) -> CPlaneApi {
+    pub fn new(_address: &SocketAddr) -> CPlaneApi {
         CPlaneApi {
-            address: address.clone(),
+            // address: address.clone(),
         }
     }
 
@@ -53,15 +72,21 @@ impl CPlaneApi {
 
     pub fn get_database_uri(&self, _user: &String, _database: &String) -> Result<DatabaseInfo> {
         Ok(DatabaseInfo {
-            addr: "127.0.0.1:5432".parse()?,
-            connstr: "user=stas dbname=stas".into(),
+            host: "127.0.0.1".parse()?,
+            port: 5432,
+            dbname: "stas".to_string(),
+            user: "stas".to_string(),
+            password: "mypass".to_string(),
         })
     }
 
-    pub fn create_database(&self, _user: &String, _database: &String) -> Result<DatabaseInfo> {
-        Ok(DatabaseInfo {
-            addr: "127.0.0.1:5432".parse()?,
-            connstr: "user=stas dbname=stas".into(),
-        })
-    }
+    // pub fn create_database(&self, _user: &String, _database: &String) -> Result<DatabaseInfo> {
+    //     Ok(DatabaseInfo {
+    //         host: "127.0.0.1".parse()?,
+    //         port: 5432,
+    //         dbname: "stas".to_string(),
+    //         user: "stas".to_string(),
+    //         password: "mypass".to_string(),
+    //     })
+    // }
 }

proxy/src/main.rs

@@ -12,6 +12,8 @@ use std::{
     thread,
 };
 
+use clap::{App, Arg};
+
 use cplane_api::DatabaseInfo;
 
 mod cplane_api;
@@ -26,7 +28,7 @@ pub struct ProxyConf {
     /// will notify us here, so that we can 'unfreeze' user session.
     pub mgmt_address: SocketAddr,
 
-    /// control plane address where we check auth and create clusters.
+    /// control plane address where we would check auth.
     pub cplane_address: SocketAddr,
 }
 
@@ -36,9 +38,28 @@ pub struct ProxyState {
 }
 
 fn main() -> anyhow::Result<()> {
+    let arg_matches = App::new("Zenith proxy/router")
+        .arg(
+            Arg::with_name("proxy")
+                .short("p")
+                .long("proxy")
+                .takes_value(true)
+                .help("listen for incoming client connections on ip:port")
+                .default_value("127.0.0.1:4432"),
+        )
+        .arg(
+            Arg::with_name("mgmt")
+                .short("m")
+                .long("mgmt")
+                .takes_value(true)
+                .help("listen for management callback connection on ip:port")
+                .default_value("127.0.0.1:7000"),
+        )
+        .get_matches();
+
     let conf = ProxyConf {
-        proxy_address: "0.0.0.0:4000".parse()?,
-        mgmt_address: "0.0.0.0:8080".parse()?,
+        proxy_address: arg_matches.value_of("proxy").unwrap().parse()?,
+        mgmt_address: arg_matches.value_of("mgmt").unwrap().parse()?,
         cplane_address: "127.0.0.1:3000".parse()?,
     };
     let state = ProxyState {

proxy/src/mgmt.rs

@@ -46,8 +46,11 @@ struct MgmtHandler {
 //     "session_id": "71d6d03e6d93d99a",
 //     "result": {
 //         "Success": {
-//             "addr": "127.0.0.1:5432",
-//             "connstr": "user=stas dbname=stas"
+//             "host": "127.0.0.1",
+//             "port": 5432,
+//             "dbname": "stas",
+//             "user": "stas"
+//             "password": "mypass"
 //         }
 //     }
 // }

proxy/src/proxy.rs

@@ -227,8 +227,8 @@ databases without opening the browser.
 }
 
 async fn proxy_pass(pgb: PostgresBackend, db_info: DatabaseInfo) -> anyhow::Result<()> {
-    let mut socket = tokio::net::TcpStream::connect(db_info.addr).await?;
-    let config = db_info.connstr.parse::<tokio_postgres::Config>()?;
+    let mut socket = tokio::net::TcpStream::connect(db_info.socket_addr()).await?;
+    let config = db_info.conn_string().parse::<tokio_postgres::Config>()?;
     let _ = config.connect_raw(&mut socket, NoTls).await?;
 
     println!("Connected to pg, proxying");