use crate::rpc_proto;
use base64::encode;
use prometheus_client::encoding::text::Encode;
use prost::Message;
use sha2::{Digest, Sha256};
use std::fmt;
pub trait Hasher {
fn hash(topic_string: String) -> TopicHash;
}
#[derive(Debug, Clone)]
pub struct IdentityHash {}
impl Hasher for IdentityHash {
fn hash(topic_string: String) -> TopicHash {
TopicHash { hash: topic_string }
}
}
#[derive(Debug, Clone)]
pub struct Sha256Hash {}
impl Hasher for Sha256Hash {
fn hash(topic_string: String) -> TopicHash {
let topic_descripter = rpc_proto::TopicDescriptor {
name: Some(topic_string),
auth: None,
enc: None,
};
let mut bytes = Vec::with_capacity(topic_descripter.encoded_len());
topic_descripter
.encode(&mut bytes)
.expect("buffer is large enough");
let hash = encode(Sha256::digest(&bytes).as_slice());
TopicHash { hash }
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Encode)]
pub struct TopicHash {
hash: String,
}
impl TopicHash {
pub fn from_raw(hash: impl Into<String>) -> TopicHash {
TopicHash { hash: hash.into() }
}
pub fn into_string(self) -> String {
self.hash
}
pub fn as_str(&self) -> &str {
&self.hash
}
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct Topic<H: Hasher> {
topic: String,
phantom_data: std::marker::PhantomData<H>,
}
impl<H: Hasher> From<Topic<H>> for TopicHash {
fn from(topic: Topic<H>) -> TopicHash {
topic.hash()
}
}
impl<H: Hasher> Topic<H> {
pub fn new(topic: impl Into<String>) -> Self {
Topic {
topic: topic.into(),
phantom_data: std::marker::PhantomData,
}
}
pub fn hash(&self) -> TopicHash {
H::hash(self.topic.clone())
}
}
impl<H: Hasher> fmt::Display for Topic<H> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.topic)
}
}
impl fmt::Display for TopicHash {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.hash)
}
}