pib-client-cached 0.28.0

API client for pib-service - caching data storage
Documentation
// SPDX-FileCopyrightText: Politik im Blick developers
// SPDX-FileCopyrightText: Wolfgang Silbermayr <wolfgang@silbermayr.at>
//
// SPDX-License-Identifier: AGPL-3.0-or-later OR EUPL-1.2

use std::{
    hash::{DefaultHasher, Hasher as _},
    marker::PhantomData,
};

use cachekit::builder::{CacheBuilder, DynCache};
use pib_client::PibClient;
use pib_service_core_types::{DataItem, Entity};

use crate::{
    CACHE_POLICY, CACHE_SIZE, ClearableCache, ItemCache,
    item::{AliasGetableItem, AliasUpdatableItem, GetableItem},
};

#[derive(Debug)]
pub(super) struct AliasCache<
    PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    ALIAS: std::fmt::Debug + std::hash::Hash,
    ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
> {
    aliases: DynCache<(PARENTID, u128), ID>,
    _phantom: PhantomData<ALIAS>,
}

impl<
    PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    ALIAS: std::fmt::Debug + std::hash::Hash,
    ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
> AliasCache<PARENTID, ALIAS, ID>
{
    pub fn new() -> Self {
        let aliases = CacheBuilder::new(CACHE_SIZE).build(CACHE_POLICY);

        Self {
            aliases,
            _phantom: PhantomData,
        }
    }

    pub fn clear(&mut self) {
        self.aliases.clear()
    }
}

fn calculate_alias_hash<ALIAS: std::hash::Hash>(alias: &ALIAS) -> u128 {
    let hash_1 = {
        let mut hasher = DefaultHasher::new();
        alias.hash(&mut hasher);
        hasher.finish()
    };

    // reduce collision risk by hashing with a different seed
    let hash_2 = {
        let mut hasher = DefaultHasher::new();
        hasher.write_u64(0x8d82_ff44_919d_67e2);
        alias.hash(&mut hasher);
        hasher.finish()
    };

    (u128::from(hash_1) << 64) | u128::from(hash_2)
}

impl<
    PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    ALIAS: std::fmt::Debug + std::hash::Hash,
    ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
> AliasCache<PARENTID, ALIAS, ID>
{
    pub async fn get_by_alias<
        C: PibClient,
        T: AliasGetableItem<PARENTID, ID, T, ALIAS>
            + Entity<PARENTID, ID>
            + GetableItem<PARENTID, ID, T>
            + std::fmt::Debug
            + Clone,
    >(
        &mut self,
        client: &C,
        parent_id: PARENTID,
        alias: ALIAS,
        item_cache: &mut ItemCache<PARENTID, ID, T>,
    ) -> Result<DataItem<PARENTID, ID, T>, C::ClientError> {
        let alias_hash = calculate_alias_hash(&alias);
        let item = if let Some(id) = self.aliases.get(&(parent_id, alias_hash)) {
            item_cache.get(client, parent_id, *id).await?
        } else {
            let item = T::get_by_alias(client, parent_id, alias).await?;
            item_cache.insert(item.clone());
            item
        };

        self.insert(&item);
        Ok(item)
    }

    pub async fn update_by_alias<
        C: PibClient,
        T: AliasUpdatableItem<PARENTID, ID, T, UPDATE, ALIAS>
            + AliasGetableItem<PARENTID, ID, T, ALIAS>
            + Entity<PARENTID, ID>
            + GetableItem<PARENTID, ID, T>
            + std::fmt::Debug
            + Clone,
        UPDATE,
    >(
        &mut self,
        client: &C,
        parent_id: PARENTID,
        alias: ALIAS,
        update_item: UPDATE,
        item_cache: &mut ItemCache<PARENTID, ID, T>,
    ) -> Result<DataItem<PARENTID, ID, T>, C::ClientError> {
        let item = T::update_by_alias(client, parent_id, alias, update_item).await?;

        item_cache.insert(item.clone());
        self.aliases.clear();
        self.insert(&item);

        Ok(item)
    }

    pub fn insert<
        T: AliasGetableItem<PARENTID, ID, T, ALIAS>
            + Entity<PARENTID, ID>
            + GetableItem<PARENTID, ID, T>
            + std::fmt::Debug
            + Clone,
    >(
        &mut self,
        item: &DataItem<PARENTID, ID, T>,
    ) {
        for alias in <T as AliasGetableItem<PARENTID, ID, T, ALIAS>>::get_aliases(item) {
            let alias_hash = calculate_alias_hash(&alias);
            self.aliases.insert((item.parent_id, alias_hash), item.id);
        }
    }
}

impl<
    PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
    ALIAS: std::fmt::Debug + std::hash::Hash,
    ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
> ClearableCache for AliasCache<PARENTID, ALIAS, ID>
{
    fn clear_cache(&mut self) {
        self.clear();
    }
}