Struct Server 

pub struct Server {

    pub host: HostName,
    pub port: Port,
    pub name: ServerName,
    pub username: Option<String>,
    pub password: Option<String>,
    pub max_connections: MaxConnections,
    pub use_tls: bool,
    pub tls_verify_cert: bool,
    pub tls_cert_path: Option<String>,
    pub connection_keepalive: Option<Duration>,
    pub health_check_max_per_cycle: usize,
    pub health_check_pool_timeout: Duration,
    pub tier: u8,
}

Configuration for a single backend server

Fields

host: HostName

port: Port

name: ServerName

username: Option<String>

password: Option<String>

max_connections: MaxConnections

Maximum number of concurrent connections to this server

use_tls: bool

Enable TLS/SSL for this backend connection

tls_verify_cert: bool

Verify TLS certificates (recommended for production)

tls_cert_path: Option<String>

Optional path to custom CA certificate

connection_keepalive: Option<Duration>

Interval to send keep-alive commands (DATE) on idle connections None disables keep-alive (default)

health_check_max_per_cycle: usize

Maximum number of connections to check per health check cycle Lower values reduce pool contention but may take longer to detect all stale connections

health_check_pool_timeout: Duration

Timeout when acquiring a connection for health checking Short timeout prevents blocking if pool is busy

tier: u8

Server tier for prioritization (lower = higher priority, default: 0) Servers with lower tier numbers are tried first; higher tiers only when lower exhausted

Implementations

impl Server

pub fn builder(host: impl Into<String>, port: Port) -> ServerBuilder

Create a builder for configuring a backend server

Example

use nntp_proxy::config::Server;
use nntp_proxy::types::{Port, MaxConnections};

let config = Server::builder("news.example.com", Port::try_new(119).unwrap())
    .name("Example Server")
    .max_connections(MaxConnections::try_new(15).unwrap())
    .build()
    .unwrap();

Trait Implementations

impl Clone for Server

fn clone(&self) -> Server

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Server

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Server

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Server

fn eq(&self, other: &Server) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Server

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Server