use std::sync::Arc;
use algo_ops::AlgoOps;
use anyhow::{Result, anyhow};
use ed25519_dalek::SigningKey;
use rustls::ClientConfig;
use sw_identity_tls::client::{IdentityServerVerifier, client_config};
use sw_identity_tls::{
EndpointRecord, EndpointResolver, MembershipAuthority, Role, StaticMembership, bit_decoder,
default_provider, generate,
};
#[derive(Debug, Clone)]
pub struct DiscoveryConfig {
pub app_id: u64,
pub allow_key: String,
pub node_bit: u8,
pub endpoint_key: String,
pub cache_lifetime_secs: Option<u64>,
}
impl DiscoveryConfig {
pub fn bingle(app_id: u64) -> Self {
Self {
app_id,
allow_key: "allow_static".to_string(),
node_bit: 2,
endpoint_key: "rsvd_l_b1".to_string(),
cache_lifetime_secs: None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DiscoveredNode {
pub identity: String,
pub endpoint: EndpointRecord,
}
impl DiscoveredNode {
pub fn base_url(&self) -> Option<String> {
self.endpoint
.socket_addrs()
.first()
.map(|addr| format!("https://{addr}"))
}
}
pub fn resolve_nodes(algo: &AlgoOps, cfg: &DiscoveryConfig) -> Result<Vec<DiscoveredNode>> {
let resolver = EndpointResolver::new(
algo.clone(),
cfg.app_id,
cfg.cache_lifetime_secs,
cfg.endpoint_key.clone(),
bit_decoder(cfg.allow_key.clone(), cfg.node_bit),
);
Ok(resolver
.resolve()?
.into_iter()
.map(|(identity, endpoint)| DiscoveredNode { identity, endpoint })
.collect())
}
pub fn pinned_client_config(own: &SigningKey, node_identity: &str) -> Result<ClientConfig> {
let provider = default_provider();
let authority: Arc<dyn MembershipAuthority> =
Arc::new(StaticMembership::new().with(node_identity, Role::ClusterNode));
let verifier = Arc::new(IdentityServerVerifier::new_for_role(
authority,
provider,
Role::ClusterNode,
));
let cert = generate(own).map_err(|e| anyhow!("mint client identity certificate: {e}"))?;
client_config(cert, verifier).map_err(|e| anyhow!("build client mutual-TLS config: {e}"))
}
pub(crate) fn identity_key(algo: &AlgoOps) -> Result<SigningKey> {
let seed = algo.private_key_bytes()?;
let seed: [u8; 32] = seed
.try_into()
.map_err(|_| anyhow!("account seed must be 32 bytes for a TLS identity"))?;
Ok(SigningKey::from_bytes(&seed))
}