use std::collections::HashMap;
use std::net::SocketAddr;
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::Instant;
use parking_lot::Mutex;
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ClientId(u64);
impl ClientId {
#[must_use]
pub fn as_u64(self) -> u64 {
self.0
}
}
impl std::fmt::Display for ClientId {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.0.fmt(f)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ClientState {
Negotiating,
Authenticating,
Idle,
InTransaction,
Waiting,
}
impl ClientState {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
ClientState::Negotiating => "negotiating",
ClientState::Authenticating => "authenticating",
ClientState::Idle => "idle",
ClientState::InTransaction => "in_transaction",
ClientState::Waiting => "waiting",
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum WaitRole {
Primary,
Replica,
}
impl WaitRole {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
WaitRole::Primary => "primary",
WaitRole::Replica => "replica",
}
}
}
#[derive(Clone, Debug)]
pub struct WaitTarget {
pub database: String,
pub user: String,
pub role: WaitRole,
}
#[derive(Clone, Debug)]
pub struct ClientEntry {
pub id: ClientId,
pub remote: SocketAddr,
pub state: ClientState,
pub accepted_at: Instant,
pub state_since: Instant,
pub database: Option<String>,
pub user: Option<String>,
pub waiting_for: Option<WaitTarget>,
}
pub struct ClientRegistry {
next_id: AtomicU64,
entries: Mutex<HashMap<ClientId, ClientEntry>>,
}
impl ClientRegistry {
#[must_use]
pub fn new() -> Self {
Self {
next_id: AtomicU64::new(1),
entries: Mutex::new(HashMap::new()),
}
}
pub fn register(self: &Arc<Self>, remote: SocketAddr) -> ClientGuard {
let id = ClientId(self.next_id.fetch_add(1, Ordering::Relaxed));
let now = Instant::now();
let entry = ClientEntry {
id,
remote,
state: ClientState::Negotiating,
accepted_at: now,
state_since: now,
database: None,
user: None,
waiting_for: None,
};
{
let mut entries = self.entries.lock();
entries.insert(id, entry);
}
ClientGuard {
id,
registry: Arc::clone(self),
}
}
#[must_use]
pub fn snapshot(&self) -> Vec<ClientEntry> {
let entries = self.entries.lock();
entries.values().cloned().collect()
}
#[must_use]
pub fn count(&self) -> usize {
self.entries.lock().len()
}
#[must_use]
pub fn counts_by_state(&self) -> [(ClientState, u64); 5] {
let entries = self.entries.lock();
let mut negotiating = 0u64;
let mut authenticating = 0u64;
let mut idle = 0u64;
let mut in_transaction = 0u64;
let mut waiting = 0u64;
for entry in entries.values() {
match entry.state {
ClientState::Negotiating => negotiating += 1,
ClientState::Authenticating => authenticating += 1,
ClientState::Idle => idle += 1,
ClientState::InTransaction => in_transaction += 1,
ClientState::Waiting => waiting += 1,
}
}
[
(ClientState::Negotiating, negotiating),
(ClientState::Authenticating, authenticating),
(ClientState::Idle, idle),
(ClientState::InTransaction, in_transaction),
(ClientState::Waiting, waiting),
]
}
}
impl Default for ClientRegistry {
fn default() -> Self {
Self::new()
}
}
pub struct ClientGuard {
id: ClientId,
registry: Arc<ClientRegistry>,
}
impl ClientGuard {
#[must_use]
pub fn id(&self) -> ClientId {
self.id
}
pub fn set_state(&self, state: ClientState) {
let mut entries = self.registry.entries.lock();
if let Some(entry) = entries.get_mut(&self.id)
&& entry.state != state
{
entry.state = state;
entry.state_since = Instant::now();
}
}
pub fn set_database_and_user(&self, database: &str, user: &str) {
let mut entries = self.registry.entries.lock();
if let Some(entry) = entries.get_mut(&self.id) {
entry.database = Some(database.to_owned());
entry.user = Some(user.to_owned());
}
}
pub fn set_waiting_for(&self, target: Option<WaitTarget>) {
let mut entries = self.registry.entries.lock();
if let Some(entry) = entries.get_mut(&self.id) {
entry.waiting_for = target;
}
}
}
impl Drop for ClientGuard {
fn drop(&mut self) {
let mut entries = self.registry.entries.lock();
entries.remove(&self.id);
}
}