feat: frontend instance (#238)

* feat: frontend instance

* no need to carry column length in `Column` proto

* add more tests

* rebase develop

* create a new variant with already provisioned RecordBatches in Output

* resolve code review comments

* new frontend instance does not connect datanode grpc

* add more tests

* add more tests

* rebase develop

Co-authored-by: luofucong <luofucong@greptime.com>

src/cmd/Cargo.toml

@@ -12,6 +12,8 @@ clap = { version = "3.1", features = ["derive"] }
 common-error = { path = "../common/error" }
 common-telemetry = { path = "../common/telemetry", features = ["deadlock_detection"]}
 datanode = { path = "../datanode" }
+frontend = { path = "../frontend" }
+futures = "0.3"
 snafu = { version = "0.7", features = ["backtraces"] }
 tokio = { version = "1.18", features = ["full"] }
 toml = "0.5"

src/cmd/src/bin/greptime.rs

@@ -3,6 +3,7 @@ use std::fmt;
 use clap::Parser;
 use cmd::datanode;
 use cmd::error::Result;
+use cmd::frontend;
 use common_telemetry::{self, logging::error, logging::info};
 
 #[derive(Parser)]
@@ -26,12 +27,15 @@ impl Command {
 enum SubCommand {
     #[clap(name = "datanode")]
     Datanode(datanode::Command),
+    #[clap(name = "frontend")]
+    Frontend(frontend::Command),
 }
 
 impl SubCommand {
     async fn run(self) -> Result<()> {
         match self {
             SubCommand::Datanode(cmd) => cmd.run().await,
+            SubCommand::Frontend(cmd) => cmd.run().await,
         }
     }
 }
@@ -40,6 +44,7 @@ impl fmt::Display for SubCommand {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             SubCommand::Datanode(..) => write!(f, "greptime-datanode"),
+            SubCommand::Frontend(..) => write!(f, "greptime-frontend"),
         }
     }
 }

src/cmd/src/error.rs

@@ -11,6 +11,12 @@ pub enum Error {
         source: datanode::error::Error,
     },
 
+    #[snafu(display("Failed to start frontend, source: {}", source))]
+    StartFrontend {
+        #[snafu(backtrace)]
+        source: frontend::error::Error,
+    },
+
     #[snafu(display("Failed to read config file: {}, source: {}", path, source))]
     ReadConfig {
         source: std::io::Error,
@@ -27,6 +33,7 @@ impl ErrorExt for Error {
     fn status_code(&self) -> StatusCode {
         match self {
             Error::StartDatanode { source } => source.status_code(),
+            Error::StartFrontend { source } => source.status_code(),
             Error::ReadConfig { .. } | Error::ParseConfig { .. } => StatusCode::InvalidArguments,
         }
     }

src/cmd/src/frontend.rs

@@ -0,0 +1,97 @@
+use clap::Parser;
+use frontend::frontend::{Frontend, FrontendOptions};
+use snafu::ResultExt;
+
+use crate::error::{self, Result};
+use crate::toml_loader;
+
+#[derive(Parser)]
+pub struct Command {
+    #[clap(subcommand)]
+    subcmd: SubCommand,
+}
+
+impl Command {
+    pub async fn run(self) -> Result<()> {
+        self.subcmd.run().await
+    }
+}
+
+#[derive(Parser)]
+enum SubCommand {
+    Start(StartCommand),
+}
+
+impl SubCommand {
+    async fn run(self) -> Result<()> {
+        match self {
+            SubCommand::Start(cmd) => cmd.run().await,
+        }
+    }
+}
+
+#[derive(Debug, Parser)]
+struct StartCommand {
+    #[clap(long)]
+    http_addr: Option<String>,
+    #[clap(long)]
+    grpc_addr: Option<String>,
+    #[clap(long)]
+    mysql_addr: Option<String>,
+    #[clap(short, long)]
+    config_file: Option<String>,
+}
+
+impl StartCommand {
+    async fn run(self) -> Result<()> {
+        let opts = self.try_into()?;
+        let mut frontend = Frontend::new(opts);
+        frontend.start().await.context(error::StartFrontendSnafu)
+    }
+}
+
+impl TryFrom<StartCommand> for FrontendOptions {
+    type Error = error::Error;
+
+    fn try_from(cmd: StartCommand) -> Result<Self> {
+        let mut opts: FrontendOptions = if let Some(path) = cmd.config_file {
+            toml_loader::from_file!(&path)?
+        } else {
+            FrontendOptions::default()
+        };
+
+        if let Some(addr) = cmd.http_addr {
+            opts.http_addr = Some(addr);
+        }
+        if let Some(addr) = cmd.grpc_addr {
+            opts.grpc_addr = Some(addr);
+        }
+        if let Some(addr) = cmd.mysql_addr {
+            opts.mysql_addr = Some(addr);
+        }
+        Ok(opts)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_try_from_start_command() {
+        let command = StartCommand {
+            http_addr: Some("127.0.0.1:1234".to_string()),
+            grpc_addr: None,
+            mysql_addr: Some("127.0.0.1:5678".to_string()),
+            config_file: None,
+        };
+
+        let opts: FrontendOptions = command.try_into().unwrap();
+        assert_eq!(opts.http_addr, Some("127.0.0.1:1234".to_string()));
+        assert_eq!(opts.mysql_addr, Some("127.0.0.1:5678".to_string()));
+
+        let default_opts = FrontendOptions::default();
+        assert_eq!(opts.grpc_addr, default_opts.grpc_addr);
+        assert_eq!(opts.mysql_runtime_size, default_opts.mysql_runtime_size);
+    }
+}

src/cmd/src/lib.rs

@@ -1,3 +1,4 @@
 pub mod datanode;
 pub mod error;
+pub mod frontend;
 mod toml_loader;