rs-zero 0.2.24

Rust-first microservice framework inspired by go-zero engineering practices
Documentation
use std::sync::{
    Arc,
    atomic::{AtomicU64, Ordering},
};

const STATE_BITS: u32 = 8;
const STATE_MASK: u64 = (1 << STATE_BITS) - 1;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MqttConnectionState {
    Starting,
    Connected,
    Subscribed,
    Disconnected,
    Reconnecting,
}

impl MqttConnectionState {
    fn as_u8(self) -> u8 {
        match self {
            Self::Starting => 0,
            Self::Connected => 1,
            Self::Subscribed => 2,
            Self::Disconnected => 3,
            Self::Reconnecting => 4,
        }
    }

    fn from_u8(value: u8) -> Self {
        match value {
            1 => Self::Connected,
            2 => Self::Subscribed,
            3 => Self::Disconnected,
            4 => Self::Reconnecting,
            _ => Self::Starting,
        }
    }
}

#[derive(Debug, Clone)]
pub struct MqttReadiness {
    value: Arc<AtomicU64>,
}

impl Default for MqttReadiness {
    fn default() -> Self {
        Self::new()
    }
}

impl MqttReadiness {
    pub fn new() -> Self {
        Self {
            value: Arc::new(AtomicU64::new(pack(0, MqttConnectionState::Starting))),
        }
    }

    pub fn state(&self) -> MqttConnectionState {
        unpack_state(self.value.load(Ordering::SeqCst))
    }

    pub fn generation(&self) -> u64 {
        unpack_generation(self.value.load(Ordering::SeqCst))
    }

    pub fn set_state(&self, state: MqttConnectionState) {
        self.value
            .fetch_update(Ordering::SeqCst, Ordering::SeqCst, |value| {
                Some(pack(unpack_generation(value), state))
            })
            .expect("readiness state update cannot fail");
    }

    #[doc(hidden)]
    pub fn begin_generation(&self) -> u64 {
        let previous = self
            .value
            .fetch_update(Ordering::SeqCst, Ordering::SeqCst, |value| {
                Some(pack(
                    unpack_generation(value).saturating_add(1),
                    MqttConnectionState::Starting,
                ))
            })
            .expect("readiness generation update cannot fail");
        unpack_generation(previous).saturating_add(1)
    }

    #[doc(hidden)]
    pub fn set_state_for_generation(&self, generation: u64, state: MqttConnectionState) -> bool {
        let mut current = self.value.load(Ordering::SeqCst);
        loop {
            if unpack_generation(current) != generation {
                return false;
            }
            match self.value.compare_exchange(
                current,
                pack(generation, state),
                Ordering::SeqCst,
                Ordering::SeqCst,
            ) {
                Ok(_) => return true,
                Err(updated) => current = updated,
            }
        }
    }

    pub fn is_ready(&self) -> bool {
        self.state() == MqttConnectionState::Subscribed
    }
}

fn pack(generation: u64, state: MqttConnectionState) -> u64 {
    (generation << STATE_BITS) | u64::from(state.as_u8())
}

fn unpack_generation(value: u64) -> u64 {
    value >> STATE_BITS
}

fn unpack_state(value: u64) -> MqttConnectionState {
    MqttConnectionState::from_u8((value & STATE_MASK) as u8)
}