Struct DashboardConfig 

pub struct DashboardConfig {
    pub bind_address: String,
    pub port: u16,
    pub database_url: String,
    pub pool_size: u32,
    pub static_dir: PathBuf,
    pub auth: AuthConfig,
    pub websocket: WebSocketConfig,
    pub enable_cors: bool,
    pub allowed_origins: Vec<String>,
}

Main configuration for the web dashboard.

This struct contains all configuration options for the Hammerwork web dashboard, including server settings, database connection, authentication, and WebSocket options.

Examples

use hammerwork_web::config::DashboardConfig;
use std::path::PathBuf;

// Create with defaults
let config = DashboardConfig::default();
assert_eq!(config.bind_address, "127.0.0.1");
assert_eq!(config.port, 8080);

// Use builder pattern
let config = DashboardConfig::new()
    .with_bind_address("0.0.0.0", 9090)
    .with_database_url("postgresql://localhost/hammerwork")
    .with_cors(true);

assert_eq!(config.bind_addr(), "0.0.0.0:9090");
assert!(config.enable_cors);

Debug shows database_url with its password replaced by ***.

Fields

bind_address: String

Server bind address

port: u16

Server port

database_url: String

Database connection URL

pool_size: u32

Database connection pool size

static_dir: PathBuf

Directory containing static assets (HTML, CSS, JS)

auth: AuthConfig

Authentication configuration

websocket: WebSocketConfig

WebSocket configuration

enable_cors: bool

Enable CORS for cross-origin requests from allowed_origins.

CORS is only ever granted to the listed origins, never to any origin, so enabling it requires at least one entry there.

allowed_origins: Vec<String>

Origins other than the dashboard’s own (scheme://host[:port]) that may send state-changing requests and WebSocket connections, and, with enable_cors, read API responses. Browsers on any other origin are refused (see crate::security).

Implementations

impl DashboardConfig

pub fn new() -> Self

Create a new configuration with defaults.

Examples

use hammerwork_web::config::DashboardConfig;

let config = DashboardConfig::new();
assert_eq!(config.bind_address, "127.0.0.1");
assert_eq!(config.port, 8080);
assert_eq!(config.database_url, "postgresql://localhost/hammerwork");

pub fn with_bind_address(self, address: &str, port: u16) -> Self

Set the server bind address and port.

Examples

use hammerwork_web::config::DashboardConfig;

let config = DashboardConfig::new()
    .with_bind_address("0.0.0.0", 9090);

assert_eq!(config.bind_address, "0.0.0.0");
assert_eq!(config.port, 9090);
assert_eq!(config.bind_addr(), "0.0.0.0:9090");

pub fn with_database_url(self, url: &str) -> Self

Set the database URL.

Supports both PostgreSQL and MySQL database URLs.

Examples

use hammerwork_web::config::DashboardConfig;

// PostgreSQL
let pg_config = DashboardConfig::new()
    .with_database_url("postgresql://user:pass@localhost/hammerwork");
assert_eq!(pg_config.database_url, "postgresql://user:pass@localhost/hammerwork");

// MySQL
let mysql_config = DashboardConfig::new()
    .with_database_url("mysql://root:password@localhost/hammerwork");
assert_eq!(mysql_config.database_url, "mysql://root:password@localhost/hammerwork");

pub fn with_static_dir(self, dir: PathBuf) -> Self

Set the static assets directory.

Examples

use hammerwork_web::config::DashboardConfig;
use std::path::PathBuf;

let config = DashboardConfig::new()
    .with_static_dir(PathBuf::from("/var/www/dashboard"));

assert_eq!(config.static_dir, PathBuf::from("/var/www/dashboard"));

pub fn with_auth(self, username: &str, password_hash: &str) -> Self

Enable authentication with username and password hash.

The password should be a bcrypt hash for security. When authentication is enabled, all API endpoints and WebSocket connections will require basic authentication.

Examples

use hammerwork_web::config::DashboardConfig;

let config = DashboardConfig::new()
    .with_auth("admin", "$2b$12$hash...");

assert!(config.auth.enabled);
assert_eq!(config.auth.username, "admin");
assert_eq!(config.auth.password_hash, "$2b$12$hash...");

pub fn with_cors(self, enabled: bool) -> Self

Enable or disable CORS support.

When enabled, browsers on the origins in allowed_origins may call the API; validate requires at least one of them.

Examples

use hammerwork_web::config::DashboardConfig;

let config = DashboardConfig::new()
    .with_cors(true)
    .with_allowed_origin("https://ops.example.com");

assert!(config.enable_cors);
assert_eq!(config.allowed_origins, ["https://ops.example.com"]);

let config = DashboardConfig::new()
    .with_cors(false);

assert!(!config.enable_cors);

pub fn with_allowed_origin(self, origin: &str) -> Self

Allow requests from another origin (scheme://host[:port]); see allowed_origins.

pub fn from_file(path: &str) -> Result<Self>

Load configuration from a TOML file

pub fn validate(&self) -> Result<()>

Check settings that would make the server unsafe or make it fail at runtime:

• authentication enabled in a build without the auth feature, which cannot verify bcrypt password hashes;
• an entry of allowed_origins that is not an origin, or enable_cors without any;
• a zero websocket.ping_interval (tokio::time::interval panics on a zero period), websocket.message_buffer_size or websocket.max_message_size;
• a zero websocket.live_update_max_jobs while live updates are enabled.

pub fn save_to_file(&self, path: &str) -> Result<()>

Save configuration to a TOML file

pub fn bind_addr(&self) -> String

Get the full bind address (address:port)

Trait Implementations

impl Clone for DashboardConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DashboardConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DashboardConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DashboardConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DashboardConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.