feat: Implement virtual hosting for multi-domain Gemini server

- Add hostname-based request routing for multiple capsules per server
- Parse virtual host configs from TOML sections ([hostname])
- Implement per-host certificate and content isolation
- Add comprehensive virtual host testing and validation
- Update docs and examples for multi-host deployments

This enables Pollux to serve multiple Gemini domains from one instance,
providing the foundation for multi-tenant Gemini hosting.
This commit is contained in:
Jeena 2026-01-22 02:38:09 +00:00
parent c193d831ed
commit 0459cb6220
22 changed files with 2296 additions and 406 deletions

View file

@ -0,0 +1,306 @@
mod common;
#[test]
fn test_single_host_config() {
let temp_dir = tempfile::TempDir::new().unwrap();
let config_path = temp_dir.path().join("config.toml");
let port = 1967 + (std::process::id() % 1000) as u16;
// Create content directory and certificates
let content_dir = temp_dir.path().join("content");
std::fs::create_dir(&content_dir).unwrap();
// Generate test certificates
use std::process::Command;
let cert_path = temp_dir.path().join("cert.pem");
let key_path = temp_dir.path().join("key.pem");
let cert_result = Command::new("openssl")
.args(&[
"req", "-x509", "-newkey", "rsa:2048",
"-keyout", &key_path.to_string_lossy(),
"-out", &cert_path.to_string_lossy(),
"-days", "1",
"-nodes",
"-subj", "/CN=example.com"
])
.output();
if cert_result.is_err() {
panic!("Failed to generate test certificates for config test");
}
let config_content = format!(r#"
bind_host = "127.0.0.1"
port = {}
["example.com"]
root = "{}"
cert = "{}"
key = "{}"
"#, port, content_dir.display(), cert_path.display(), key_path.display());
std::fs::write(&config_path, config_content).unwrap();
let mut server_process = std::process::Command::new(env!("CARGO_BIN_EXE_pollux"))
.arg("--config")
.arg(&config_path)
.spawn()
.unwrap();
std::thread::sleep(std::time::Duration::from_millis(500));
assert!(server_process.try_wait().unwrap().is_none(), "Server should start with valid single host config");
server_process.kill().unwrap();
}
#[test]
fn test_multiple_hosts_config() {
let temp_dir = common::setup_test_environment();
let config_path = temp_dir.path().join("config.toml");
let config_content = format!(r#"
[site1.com]
root = "{}"
cert = "{}"
key = "{}"
[site2.org]
root = "{}"
cert = "{}"
key = "{}"
bind_host = "127.0.0.1"
port = 1965
"#, temp_dir.path().join("site1").display(),
temp_dir.path().join("site1_cert.pem").display(),
temp_dir.path().join("site1_key.pem").display(),
temp_dir.path().join("site2").display(),
temp_dir.path().join("site2_cert.pem").display(),
temp_dir.path().join("site2_key.pem").display());
std::fs::write(&config_path, config_content).unwrap();
// Create additional directories and generate certificates
std::fs::create_dir(temp_dir.path().join("site1")).unwrap();
std::fs::create_dir(temp_dir.path().join("site2")).unwrap();
// Generate certificates for each host
use std::process::Command;
// Site 1 certificate
let cert_result1 = Command::new("openssl")
.args(&[
"req", "-x509", "-newkey", "rsa:2048",
"-keyout", &temp_dir.path().join("site1_key.pem").to_string_lossy(),
"-out", &temp_dir.path().join("site1_cert.pem").to_string_lossy(),
"-days", "1",
"-nodes",
"-subj", "/CN=site1.com"
])
.output();
// Site 2 certificate
let cert_result2 = Command::new("openssl")
.args(&[
"req", "-x509", "-newkey", "rsa:2048",
"-keyout", &temp_dir.path().join("site2_key.pem").to_string_lossy(),
"-out", &temp_dir.path().join("site2_cert.pem").to_string_lossy(),
"-days", "1",
"-nodes",
"-subj", "/CN=site2.org"
])
.output();
if cert_result1.is_err() || cert_result2.is_err() {
panic!("Failed to generate test certificates for multiple hosts test");
}
// Test server starts successfully with multiple host config
let port = 1968 + (std::process::id() % 1000) as u16;
let config_content = format!(r#"
bind_host = "127.0.0.1"
port = {}
["site1.com"]
root = "{}"
cert = "{}"
key = "{}"
["site2.org"]
root = "{}"
cert = "{}"
key = "{}"
"#,
port,
temp_dir.path().join("site1").display(),
temp_dir.path().join("site1_cert.pem").display(),
temp_dir.path().join("site1_key.pem").display(),
temp_dir.path().join("site2").display(),
temp_dir.path().join("site2_cert.pem").display(),
temp_dir.path().join("site2_key.pem").display());
std::fs::write(&config_path, config_content).unwrap();
let mut server_process = std::process::Command::new(env!("CARGO_BIN_EXE_pollux"))
.arg("--config")
.arg(&config_path)
.spawn()
.unwrap();
std::thread::sleep(std::time::Duration::from_millis(500));
assert!(server_process.try_wait().unwrap().is_none(), "Server should start with valid multiple host config");
server_process.kill().unwrap();
}
#[test]
fn test_missing_required_fields_in_host_config() {
let temp_dir = common::setup_test_environment();
let config_path = temp_dir.path().join("config.toml");
let config_content = r#"
bind_host = "127.0.0.1"
port = 1965
["example.com"]
root = "/tmp/content"
# missing cert and key
"#;
std::fs::write(&config_path, config_content).unwrap();
let output = std::process::Command::new(env!("CARGO_BIN_EXE_pollux"))
.arg("--config")
.arg(&config_path)
.output()
.unwrap();
assert!(!output.status.success());
let stderr = String::from_utf8(output.stderr).unwrap();
assert!(stderr.contains("Missing required field") || stderr.contains("missing field"));
}
#[test]
fn test_invalid_hostname_config() {
let temp_dir = common::setup_test_environment();
let config_path = temp_dir.path().join("config.toml");
let config_content = format!(r#"
["invalid"]
root = "{}"
cert = "{}"
key = "{}"
"#, temp_dir.path().join("content").display(),
temp_dir.path().join("cert.pem").display(),
temp_dir.path().join("key.pem").display());
std::fs::write(&config_path, config_content).unwrap();
let output = std::process::Command::new(env!("CARGO_BIN_EXE_pollux"))
.arg("--config")
.arg(&config_path)
.output()
.unwrap();
assert!(!output.status.success());
let stderr = String::from_utf8(output.stderr).unwrap();
assert!(stderr.contains("Invalid hostname"));
}
#[test]
fn test_no_hosts_config() {
let temp_dir = common::setup_test_environment();
let config_path = temp_dir.path().join("config.toml");
let config_content = r#"
bind_host = "127.0.0.1"
port = 1965
# No host sections
"#;
std::fs::write(&config_path, config_content).unwrap();
let output = std::process::Command::new(env!("CARGO_BIN_EXE_pollux"))
.arg("--config")
.arg(&config_path)
.output()
.unwrap();
assert!(!output.status.success());
let stderr = String::from_utf8(output.stderr).unwrap();
assert!(stderr.contains("No host configurations found"));
}
#[test]
fn test_duplicate_hostname_config() {
let temp_dir = common::setup_test_environment();
let config_path = temp_dir.path().join("config.toml");
let config_content = format!(r#"
[example.com]
root = "{}"
cert = "{}"
key = "{}"
[example.com]
root = "{}"
cert = "{}"
key = "{}"
"#, temp_dir.path().join("path1").display(),
temp_dir.path().join("cert1.pem").display(),
temp_dir.path().join("key1.pem").display(),
temp_dir.path().join("path2").display(),
temp_dir.path().join("cert2.pem").display(),
temp_dir.path().join("key2.pem").display());
std::fs::write(&config_path, config_content).unwrap();
// Create the directories and certs
std::fs::create_dir(temp_dir.path().join("path1")).unwrap();
std::fs::create_dir(temp_dir.path().join("path2")).unwrap();
std::fs::write(temp_dir.path().join("cert1.pem"), "cert1").unwrap();
std::fs::write(temp_dir.path().join("key1.pem"), "key1").unwrap();
std::fs::write(temp_dir.path().join("cert2.pem"), "cert2").unwrap();
std::fs::write(temp_dir.path().join("key2.pem"), "key2").unwrap();
let output = std::process::Command::new(env!("CARGO_BIN_EXE_pollux"))
.arg("--config")
.arg(&config_path)
.output()
.unwrap();
// Duplicate table headers are not allowed in TOML, so this should fail
assert!(!output.status.success());
}
#[test]
fn test_host_with_port_override() {
let temp_dir = common::setup_test_environment();
let config_path = temp_dir.path().join("config.toml");
// Test server starts successfully
let port = 1969 + (std::process::id() % 1000) as u16;
let config_content = format!(r#"
bind_host = "127.0.0.1"
port = {}
["example.com"]
root = "{}"
cert = "{}"
key = "{}"
port = 1970 # Override global port
"#, port,
temp_dir.path().join("content").display(),
temp_dir.path().join("cert.pem").display(),
temp_dir.path().join("key.pem").display());
std::fs::write(&config_path, config_content).unwrap();
let mut server_process = std::process::Command::new(env!("CARGO_BIN_EXE_pollux"))
.arg("--config")
.arg(&config_path)
.spawn()
.unwrap();
std::thread::sleep(std::time::Duration::from_millis(500));
assert!(server_process.try_wait().unwrap().is_none(), "Server should start with host port override");
server_process.kill().unwrap();
}
#[test]
fn test_config_file_not_found() {
let output = std::process::Command::new(env!("CARGO_BIN_EXE_pollux"))
.arg("--config")
.arg("nonexistent.toml")
.output()
.unwrap();
assert!(!output.status.success());
let stderr = String::from_utf8(output.stderr).unwrap();
assert!(stderr.contains("Config file 'nonexistent.toml' not found"));
}