wse 3.2.0

WebSocket engine for reactive user interfaces: topics with message recovery, presence, clustering without a broker, JWT, end-to-end encryption and signed messages.
Documentation
//! Joining the cluster mesh, cluster TLS reload and the peer list.

use pyo3::exceptions::{PyRuntimeError, PyTypeError};
use pyo3::prelude::*;
use pyo3::types::{PyDict, PyList};

use super::RustWSEServer;
use super::messaging::py_error;
use crate::server::cluster_link;
use crate::server::{ClusterSettings, ClusterTls};

impl RustWSEServer {
    pub(super) fn connect_cluster_inner(
        &self,
        peers: Vec<String>,
        tls: (Option<String>, Option<String>, Option<String>),
        listen: (Option<u16>, Option<String>, bool),
        discovery: (Option<Vec<String>>, Option<String>),
        secret: Option<&Bound<'_, PyAny>>,
    ) -> PyResult<()> {
        let (tls_cert, tls_key, tls_ca) = tls;
        let (cluster_port, cluster_host, single_port) = listen;
        let (seeds, cluster_addr) = discovery;

        // The secret as bytes: a str is taken as its UTF-8.
        let secret =
            match secret {
                None => None,
                Some(value) if value.is_none() => None,
                Some(value) => match value.extract::<String>() {
                    Ok(text) => Some(text.into_bytes()),
                    Err(_) => Some(value.extract::<Vec<u8>>().map_err(|_| {
                        PyTypeError::new_err("cluster_secret must be str or bytes")
                    })?),
                },
            };
        let tls = match (tls_cert, tls_key, tls_ca) {
            (Some(cert), Some(key), Some(ca)) => Some(ClusterTls::new(cert, key, ca)),
            (None, None, None) => None,
            _ => {
                return Err(PyRuntimeError::new_err(
                    "Partial TLS config: provide all of tls_cert, tls_key, tls_ca or none",
                ));
            }
        };
        // The environment fills in what the call leaves out.
        let (secret, tls) = match (secret, tls) {
            (None, None) => {
                let tls = match (
                    std::env::var("WSE_CLUSTER_TLS_CERT").ok(),
                    std::env::var("WSE_CLUSTER_TLS_KEY").ok(),
                    std::env::var("WSE_CLUSTER_TLS_CA").ok(),
                ) {
                    (Some(cert), Some(key), Some(ca)) => Some(ClusterTls::new(cert, key, ca)),
                    (None, None, None) => None,
                    _ => {
                        return Err(PyRuntimeError::new_err(
                            "Partial TLS env vars: set all of WSE_CLUSTER_TLS_CERT, \
                             WSE_CLUSTER_TLS_KEY, WSE_CLUSTER_TLS_CA or none",
                        ));
                    }
                };
                let secret = std::env::var("WSE_CLUSTER_SECRET")
                    .ok()
                    .map(String::into_bytes);
                (secret, tls)
            }
            given => given,
        };
        let settings = ClusterSettings {
            peers,
            seeds,
            cluster_addr,
            port: cluster_port,
            host: cluster_host,
            single_port,
            secret,
            tls,
        };
        // On the server's runtime; a stopped server is refused by the engine.
        let runtime = self.runtime();
        let _runtime = runtime.as_ref().map(tokio::runtime::Handle::enter);
        cluster_link::connect(&self.shared, settings).map_err(py_error)
    }

    pub(super) fn reload_cluster_tls_impl(
        &self,
        cert_path: String,
        key_path: String,
        ca_path: String,
    ) -> PyResult<()> {
        self.engine()
            .reload_cluster_tls(&ClusterTls::new(cert_path, key_path, ca_path))
            .map_err(py_error)
    }

    pub(super) fn cluster_info_impl(&self, py: Python<'_>) -> PyResult<Py<PyList>> {
        // Copied out first: no map shard lock is held while Python allocates.
        let peers = self.engine().cluster_peers();
        let list = PyList::empty(py);
        for peer in &peers {
            let d = PyDict::new(py);
            d.set_item("address", &peer.address)?;
            d.set_item("instance_id", &peer.instance_id)?;
            d.set_item("capabilities", peer.capabilities)?;
            d.set_item("connected_at", peer.connected_at)?;
            list.append(d)?;
        }
        Ok(list.unbind())
    }
}