update docker deps and CLI

zonblade · zonblade · commit df1fb9d27c8d · 2025-05-26T01:38:14.000+09:00
diff --git a/build-docker/alpine/Dockerfile b/build-docker/alpine/Dockerfile
@@ -10,12 +10,13 @@ RUN apk add --no-cache \
     perl \
     perl-utils \
     perl-dev \
+    sqlite-dev \
     openssl-dev
 
 COPY . .
+RUN cargo build -p router-cli --release
 RUN cargo build -p router-core --release
 RUN cargo build -p router-api --release
-RUN cargo build -p router-cli --release
 
 # Runtime image stage
 FROM alpine:latest
@@ -24,7 +25,8 @@ WORKDIR /app
 # Install minimal runtime dependencies
 RUN apk add --no-cache \
     ca-certificates \
-    bash
+    bash \
+    sqlite-libs
 
 # Copy binaries from builder
 COPY --from=builder /app/target/release/router-core /usr/local/bin/router-core
diff --git a/router-cli/Cargo.toml b/router-cli/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2021"
 mini-config     = { workspace = true }
 crossterm       = { workspace = true }
 clap            = { version = "4.5.35", features = ["derive"] }
-reqwest         = { version = "0.12.4", features = ["json", "blocking"] }
+ureq            = { version = "2.9.6", features = ["json"] }
 serde           = { version = "1.0.196", features = ["derive"] }
 tokio           = { version = "1.35.1", features = ["full"] }
 serde_json      = "1.0.113"
@@ -16,5 +16,4 @@ anyhow          = "1.0.79"
 thiserror       = "1.0.56"
 log             = "0.4.20"
 env_logger      = "0.11.1"
-dirs            = "5.0.1"
-openssl         = "0.10.72"
+dirs            = "5.0.1"
diff --git a/router-cli/src/main.rs b/router-cli/src/main.rs
@@ -1,18 +1,17 @@
 use anyhow::{Context, Result};
-use clap::Parser;
+use clap::{Parser, Subcommand};
 use log::{debug, error, info};
-use reqwest::{blocking::Client, header};
 use serde::{Deserialize, Serialize};
-use std::{env, fs::File, io::Read, path::PathBuf};
+use std::{env, fs::File, io::{Read, Write}, path::PathBuf};
 
 /// Mini-Gateway Router CLI Tool
 #[derive(Parser)]
 #[command(name = "gwrs")]
 #[command(about = "CLI tool for Mini-Gateway Router API", long_about = None)]
 struct Cli {
     /// Path to the configuration file
-    #[arg(long, required = true)]
-    config: PathBuf,
+    #[arg(long)]
+    config: Option<PathBuf>,
 
     /// Use credentials from OS environment variables (GWRS_USER, GWRS_PASS)
     #[arg(long, global = true)]
@@ -29,6 +28,24 @@ struct Cli {
     /// API base URL (default: http://localhost:24042)
     #[arg(long, global = true, default_value = "http://localhost:24042")]
     url: String,
+
+    #[command(subcommand)]
+    command: Option<Commands>,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Initialize a new configuration file
+    Init {
+        /// Location to create the configuration file (default: current directory)
+        #[arg(value_name = "LOCATION")]
+        location: Option<PathBuf>,
+    },
+    /// Upload configuration to the router
+    Config {
+        /// Path to the configuration file
+        config: PathBuf,
+    },
 }
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -66,26 +83,64 @@ fn main() -> Result<()> {
     env_logger::init();
     let cli = Cli::parse();
 
-    // Get credentials
-    let (username, password) = get_credentials(&cli)?;
-
-    debug!("Using API URL: {}", cli.url);
-    debug!("Using username: {}", username);
-
-    // Create HTTP client
-    let client = Client::new();
-
-    // Authenticate and get token
-    let token = authenticate(&client, &cli.url, &username, &password)?;
-    debug!("Authentication successful, token received");
-
-    // Upload config
-    upload_config(&client, &cli.url, &token, &cli.config)?;
+    match cli.command {
+        Some(Commands::Init { location }) => {
+            init_config(&location.unwrap_or_else(|| PathBuf::from(".")))?;
+        }
+        Some(Commands::Config { config }) => {
+            // Get credentials
+            let (username, password) = get_credentials(&Credentials { 
+                osenv: cli.osenv, 
+                user: cli.user, 
+                pass: cli.pass 
+            })?;
+
+            debug!("Using API URL: {}", cli.url);
+            debug!("Using username: {}", username);
+
+            // Authenticate and get token
+            let token = authenticate(&cli.url, &username, &password)?;
+            debug!("Authentication successful, token received");
+
+            // Upload config
+            upload_config(&cli.url, &token, &config)?;
+        }
+        None => {
+            if let Some(config) = cli.config {
+                // Get credentials
+                let (username, password) = get_credentials(&Credentials { 
+                    osenv: cli.osenv, 
+                    user: cli.user, 
+                    pass: cli.pass 
+                })?;
+
+                debug!("Using API URL: {}", cli.url);
+                debug!("Using username: {}", username);
+
+                // Authenticate and get token
+                let token = authenticate(&cli.url, &username, &password)?;
+                debug!("Authentication successful, token received");
+
+                // Upload config
+                upload_config(&cli.url, &token, &config)?;
+            } else {
+                error!("No configuration file specified. Use --config or the config subcommand");
+                anyhow::bail!("No configuration file specified. Use --config or the config subcommand");
+            }
+        }
+    }
 
     Ok(())
 }
 
-fn get_credentials(cli: &Cli) -> Result<(String, String)> {
+#[derive(Debug)]
+struct Credentials {
+    osenv: bool,
+    user: Option<String>,
+    pass: Option<String>,
+}
+
+fn get_credentials(cli: &Credentials) -> Result<(String, String)> {
     if cli.osenv {
         debug!("Getting credentials from environment variables");
         let username = env::var("GWRS_USER").context("GWRS_USER environment variable not set")?;
@@ -100,7 +155,77 @@ fn get_credentials(cli: &Cli) -> Result<(String, String)> {
     }
 }
 
-fn authenticate(client: &Client, base_url: &str, username: &str, password: &str) -> Result<String> {
+fn init_config(location: &PathBuf) -> Result<()> {
+    info!("Initializing configuration file in: {}", location.display());
+
+    let config_path = location.join("router-config.yaml");
+    let config_content = r#"# Mini-Gateway Router Configuration
+# This file contains the configuration for your router setup
+
+proxy:
+  - name: "proxy1"
+    listen: "127.0.0.1:8080"
+    domains:
+      - domain: "example.com"
+        tls: false
+        tls_cert: |
+          -----BEGIN CERTIFICATE-----
+          cert
+          -----END CERTIFICATE-----
+        tls_key: |
+          -----BEGIN PRIVATE KEY-----
+          key
+          -----END PRIVATE KEY-----
+    highspeed:
+      enabled: true
+      target: "gateway1"
+    gateway:
+      - name: "gateway1"
+        domain: "example.com"
+        target: "127.0.0.1:8080"
+        path:
+          - priority: 1
+            pattern: "^(.*)$"
+            target: "/$1"
+"#;
+
+    let mut file = File::create(&config_path)
+        .context("Failed to create configuration file")?;
+    
+    file.write_all(config_content.as_bytes())
+        .context("Failed to write configuration file")?;
+
+    info!("Configuration file created at: {}", config_path.display());
+    println!("Configuration file created at: {}", config_path.display());
+    println!("\nConfiguration file structure explanation:");
+    println!("1. proxy: Define your proxy servers with their settings");
+    println!("   - name: Unique identifier for the proxy");
+    println!("   - listen: Address and port to listen on");
+    println!("   - domains: List of domains this proxy handles");
+    println!("     - domain: Domain name");
+    println!("     - tls: Enable/disable TLS");
+    println!("     - tls_cert: TLS certificate (if tls is true)");
+    println!("     - tls_key: TLS private key (if tls is true)");
+    println!("   - highspeed: High-speed routing settings");
+    println!("     - enabled: Enable/disable high-speed routing");
+    println!("     - target: Target gateway for high-speed routing");
+    println!("   - gateway: List of gateways for this proxy");
+    println!("     - name: Gateway name");
+    println!("     - domain: Domain for this gateway");
+    println!("     - target: Target address and port");
+    println!("     - path: URL path routing rules");
+    println!("       - priority: Rule priority (lower numbers = higher priority)");
+    println!("       - pattern: Regex pattern to match");
+    println!("       - target: Target path pattern");
+    println!("\nTo use this configuration:");
+    println!("1. Edit the file to match your setup");
+    println!("2. Use 'gwrs config router-config.yaml' to upload it");
+    println!("3. Add authentication with --user/--pass or --osenv");
+
+    Ok(())
+}
+
+fn authenticate(base_url: &str, username: &str, password: &str) -> Result<String> {
     info!("Authenticating with username: {}", username);
 
     let login_url = format!("{}/api/v1/users/login", base_url);
@@ -109,14 +234,12 @@ fn authenticate(client: &Client, base_url: &str, username: &str, password: &str)
         password: password.to_string(),
     };
 
-    let response = client
-        .post(&login_url)
-        .json(&login_request)
-        .send()
+    let response = ureq::post(&login_url)
+        .send_json(ureq::json!(login_request))
         .context("Failed to send login request")?;
 
     let login_response = response
-        .json::<LoginResponse>()
+        .into_json::<LoginResponse>()
         .context("Failed to parse login response")?;
 
     if !login_response.success {
@@ -134,7 +257,6 @@ fn authenticate(client: &Client, base_url: &str, username: &str, password: &str)
 }
 
 fn upload_config(
-    client: &Client,
     base_url: &str,
     token: &str,
     config_path: &PathBuf,
@@ -155,36 +277,26 @@ fn upload_config(
 
     // Prepare request
     let upload_url = format!("{}/api/v1/settings/auto-config", base_url);
-    let mut headers = header::HeaderMap::new();
-    headers.insert(
-        header::AUTHORIZATION,
-        header::HeaderValue::from_str(&format!("Bearer {}", token))?,
-    );
-    headers.insert(
-        header::CONTENT_TYPE,
-        header::HeaderValue::from_static("application/yaml"),
-    );
 
     // Send request
-    let response = client
-        .post(&upload_url)
-        .headers(headers)
-        .body(contents)
-        .send()
+    let response = ureq::post(&upload_url)
+        .set("Authorization", &format!("Bearer {}", token))
+        .set("Content-Type", "application/yaml")
+        .send_string(&contents)
         .context("Failed to send configuration upload request")?;
 
     // Check status
     let status = response.status();
-    if !status.is_success() {
+    if status >= 400 {
         let error_text = response
-            .text()
+            .into_string()
             .unwrap_or_else(|_| "Unknown error".to_string());
         error!("Upload failed with status {}: {}", status, error_text);
         anyhow::bail!("Upload failed with status {}: {}", status, error_text);
     }
 
     let upload_response = response
-        .json::<ConfigUploadResponse>()
+        .into_json::<ConfigUploadResponse>()
         .context("Failed to parse upload response")?;
 
     if let Some(error) = upload_response.error {
