feat: Move create table logic to frontend (#455)

* refactor: dependency, from frontend depends on datanode to datanode depends on frontend

* wip: start frontend in datanode

* wip: migrate create database to frontend

* wip: impl alter table

* fix: CR comments

* feat: add table id and region ids field to CreateExpr

* chore: rebase develop

* refactor: frontend catalog should set from datanode

* feat: gRPC AddColumn request support add multi columns

* wip: move create table and create-on-insertion to frontend

* wip: error handling

* fix: some unit tests

* fix: all unit tests

* chore: merge develop

* feat: add create/alter-on-insertion to dist_insert/sql_dist_insert

* fix: add region number/catalog/schema to InsertExpr

* feat: add handle_create_table/handle_create_database...

* fix: remove catalog from insert expr

* fix: CR comments

* fix: when running in standalone mode, mysql opts and postgres opts should pass to frontend so that auctually running service can change the port to listen on

* refactor: add a standalone subcommand, move frontend start stuff to cmd package

* chore: optimize create table failure logs

* docs: change readme

* docs: update readme

src/cmd/src/bin/greptime.rs

@@ -1,10 +1,10 @@
 use std::fmt;
 
 use clap::Parser;
-use cmd::datanode;
 use cmd::error::Result;
 use cmd::frontend;
 use cmd::metasrv;
+use cmd::{datanode, standalone};
 use common_telemetry::logging::error;
 use common_telemetry::logging::info;
 
@@ -33,6 +33,8 @@ enum SubCommand {
     Frontend(frontend::Command),
     #[clap(name = "metasrv")]
     Metasrv(metasrv::Command),
+    #[clap(name = "standalone")]
+    Standalone(standalone::Command),
 }
 
 impl SubCommand {
@@ -41,6 +43,7 @@ impl SubCommand {
             SubCommand::Datanode(cmd) => cmd.run().await,
             SubCommand::Frontend(cmd) => cmd.run().await,
             SubCommand::Metasrv(cmd) => cmd.run().await,
+            SubCommand::Standalone(cmd) => cmd.run().await,
         }
     }
 }
@@ -51,6 +54,7 @@ impl fmt::Display for SubCommand {
             SubCommand::Datanode(..) => write!(f, "greptime-datanode"),
             SubCommand::Frontend(..) => write!(f, "greptime-frontend"),
             SubCommand::Metasrv(..) => write!(f, "greptime-metasrv"),
+            SubCommand::Standalone(..) => write!(f, "greptime-standalone"),
         }
     }
 }

src/cmd/src/error.rs

@@ -11,6 +11,12 @@ pub enum Error {
         source: datanode::error::Error,
     },
 
+    #[snafu(display("Failed to build frontend, source: {}", source))]
+    BuildFrontend {
+        #[snafu(backtrace)]
+        source: frontend::error::Error,
+    },
+
     #[snafu(display("Failed to start frontend, source: {}", source))]
     StartFrontend {
         #[snafu(backtrace)]
@@ -38,6 +44,9 @@ pub enum Error {
 
     #[snafu(display("Missing config, msg: {}", msg))]
     MissingConfig { msg: String, backtrace: Backtrace },
+
+    #[snafu(display("Illegal config: {}", msg))]
+    IllegalConfig { msg: String, backtrace: Backtrace },
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -51,6 +60,8 @@ impl ErrorExt for Error {
             Error::ReadConfig { .. } | Error::ParseConfig { .. } | Error::MissingConfig { .. } => {
                 StatusCode::InvalidArguments
             }
+            Error::IllegalConfig { .. } => StatusCode::InvalidArguments,
+            Error::BuildFrontend { source, .. } => source.status_code(),
         }
     }
 

src/cmd/src/lib.rs

@@ -2,4 +2,5 @@ pub mod datanode;
 pub mod error;
 pub mod frontend;
 pub mod metasrv;
+pub mod standalone;
 mod toml_loader;

src/cmd/src/standalone.rs

@@ -0,0 +1,192 @@
+use clap::Parser;
+use common_telemetry::info;
+use datanode::datanode::{Datanode, DatanodeOptions};
+use datanode::instance::InstanceRef;
+use frontend::frontend::{Frontend, FrontendOptions, Mode};
+use frontend::grpc::GrpcOptions;
+use frontend::influxdb::InfluxdbOptions;
+use frontend::instance::Instance as FeInstance;
+use frontend::mysql::MysqlOptions;
+use frontend::opentsdb::OpentsdbOptions;
+use frontend::postgres::PostgresOptions;
+use snafu::ResultExt;
+use tokio::try_join;
+
+use crate::error::{
+    BuildFrontendSnafu, Error, IllegalConfigSnafu, Result, StartDatanodeSnafu, StartFrontendSnafu,
+};
+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)]
+    rpc_addr: Option<String>,
+    #[clap(long)]
+    mysql_addr: Option<String>,
+    #[clap(long)]
+    postgres_addr: Option<String>,
+    #[clap(long)]
+    opentsdb_addr: Option<String>,
+    #[clap(short, long)]
+    influxdb_enable: bool,
+    #[clap(short, long)]
+    config_file: Option<String>,
+}
+
+impl StartCommand {
+    async fn run(self) -> Result<()> {
+        let fe_opts = FrontendOptions::try_from(self)?;
+        let dn_opts = DatanodeOptions::default();
+
+        let mut datanode = Datanode::new(dn_opts.clone())
+            .await
+            .context(StartDatanodeSnafu)?;
+        let mut frontend = build_frontend(fe_opts, &dn_opts, datanode.get_instance()).await?;
+
+        try_join!(
+            async { datanode.start().await.context(StartDatanodeSnafu) },
+            async { frontend.start().await.context(StartFrontendSnafu) }
+        )?;
+
+        Ok(())
+    }
+}
+
+/// Build frontend instance in standalone mode
+async fn build_frontend(
+    fe_opts: FrontendOptions,
+    dn_opts: &DatanodeOptions,
+    datanode_instance: InstanceRef,
+) -> Result<Frontend<FeInstance>> {
+    let grpc_server_addr = &dn_opts.rpc_addr;
+    info!(
+        "Build frontend with datanode gRPC addr: {}",
+        grpc_server_addr
+    );
+    let mut frontend_instance = FeInstance::try_new(&fe_opts)
+        .await
+        .context(BuildFrontendSnafu)?;
+    frontend_instance.set_catalog_manager(datanode_instance.catalog_manager().clone());
+    Ok(Frontend::new(fe_opts, frontend_instance))
+}
+
+impl TryFrom<StartCommand> for FrontendOptions {
+    type Error = Error;
+
+    fn try_from(cmd: StartCommand) -> std::result::Result<Self, Self::Error> {
+        let mut opts: FrontendOptions = if let Some(path) = cmd.config_file {
+            toml_loader::from_file!(&path)?
+        } else {
+            FrontendOptions::default()
+        };
+
+        opts.mode = Mode::Standalone;
+
+        if let Some(addr) = cmd.http_addr {
+            opts.http_addr = Some(addr);
+        }
+        if let Some(addr) = cmd.rpc_addr {
+            // frontend grpc addr conflict with datanode default grpc addr
+            let datanode_grpc_addr = DatanodeOptions::default().rpc_addr;
+            if addr == datanode_grpc_addr {
+                return IllegalConfigSnafu {
+                    msg: format!(
+                        "gRPC listen address conflicts with datanode reserved gRPC addr: {}",
+                        datanode_grpc_addr
+                    ),
+                }
+                .fail();
+            }
+            opts.grpc_options = Some(GrpcOptions {
+                addr,
+                ..Default::default()
+            });
+        }
+
+        if let Some(addr) = cmd.mysql_addr {
+            opts.mysql_options = Some(MysqlOptions {
+                addr,
+                ..Default::default()
+            })
+        }
+        if let Some(addr) = cmd.postgres_addr {
+            opts.postgres_options = Some(PostgresOptions {
+                addr,
+                ..Default::default()
+            })
+        }
+
+        if let Some(addr) = cmd.opentsdb_addr {
+            opts.opentsdb_options = Some(OpentsdbOptions {
+                addr,
+                ..Default::default()
+            });
+        }
+
+        if cmd.influxdb_enable {
+            opts.influxdb_options = Some(InfluxdbOptions { enable: true });
+        }
+
+        Ok(opts)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_read_config_file() {
+        let cmd = StartCommand {
+            http_addr: None,
+            rpc_addr: None,
+            mysql_addr: None,
+            postgres_addr: None,
+            opentsdb_addr: None,
+            config_file: Some(format!(
+                "{}/../../config/standalone.example.toml",
+                std::env::current_dir().unwrap().as_path().to_str().unwrap()
+            )),
+            influxdb_enable: false,
+        };
+
+        let fe_opts = FrontendOptions::try_from(cmd).unwrap();
+        assert_eq!(Mode::Standalone, fe_opts.mode);
+        assert_eq!("127.0.0.1:3001".to_string(), fe_opts.datanode_rpc_addr);
+        assert_eq!(Some("0.0.0.0:4000".to_string()), fe_opts.http_addr);
+        assert_eq!(
+            "0.0.0.0:4001".to_string(),
+            fe_opts.grpc_options.unwrap().addr
+        );
+        assert_eq!("0.0.0.0:4003", fe_opts.mysql_options.as_ref().unwrap().addr);
+        assert_eq!(4, fe_opts.mysql_options.as_ref().unwrap().runtime_size);
+        assert!(fe_opts.influxdb_options.as_ref().unwrap().enable);
+    }
+}