1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
#![deny(missing_docs)] //! # Actix Sled Cache //! _A caching system built on top of Sled and Actix_ //! //! This project is designed to allow easy caching in actix-based systems. Specifically, it was //! developed to hold image files and metadata in a media cache for a simple web application. //! //! ### Example: //! ```rust //! use actix::{Actor, System}; //! use actix_sled_cache::bincode::Cache; //! use sled_extensions::Config; //! //! # fn main() -> Result<(), Box<dyn std::error::Error>> { //! let sys = System::new("cache-example"); //! let db = Config::default().temporary(true).open()?; //! //! let mut cache_builder = Cache::builder(db, "simple-cache"); //! cache_builder //! .as_mut() //! .extend_on_update() //! .extend_on_fetch() //! .expiration_length(chrono::Duration::seconds(1)); //! //! let cache: Cache<usize> = cache_builder //! .frequency(std::time::Duration::from_secs(1)) //! .build()?; //! //! // Clone the tree out of the cache before starting the cache actor //! let tree = cache.tree(); //! //! cache.start(); //! //! // If un-accessed, this record will be deleted after one second //! tree.insert("some-key", 5)?; //! //! // Commented to prevent a never-ending test //! // sys.run()?; //! # Ok(()) //! # } //! ``` //! //! The cache created here has a frequency of one second, which means every second it will check //! for expired records. In many cases, the frequency can be much less often. This cache also has //! an expiration_length of one second, which means after one second has passed since the last //! interaction with the record, it is eligible for deletion. use actix::{Message, Recipient}; use std::sync::Arc; mod cache; mod error; pub use self::{ cache::{Cache, CacheBuilder}, error::Error, }; /// A bincode-backed cache for structured data pub mod bincode { use sled_extensions::bincode::BincodeEncoding; use crate::cache; /// A cache that stores structured data encoded as bincode pub type Cache<V> = cache::Cache<V, BincodeEncoding, BincodeEncoding>; /// A builder for the cache that stores structured data encoded as bincode pub type CacheBuilder<V> = cache::CacheBuilder<V, BincodeEncoding, BincodeEncoding>; } /// A pure bytes-backed cache for binary data pub mod bin { use sled_extensions::{bincode::BincodeEncoding, expiring::plain::PlainEncoding, IVec}; use crate::cache; /// A cache that stores unstructured data encoded as bytes pub type Cache = cache::Cache<IVec, BincodeEncoding, PlainEncoding>; /// A builder for thate cache that stores unstructured data encoded as bytes pub type CacheBuilder = cache::CacheBuilder<IVec, BincodeEncoding, PlainEncoding>; } #[derive(Message)] /// A message containing the key ov an item that has been deleted from a cache /// /// This message will be sent to all subscribers upon deletion pub struct Deleted(pub Arc<[u8]>); #[derive(Message)] /// A message that registers an actor's interest in cache expiry pub struct Subscribe(pub Recipient<Deleted>);