oxcache 0.1.4

A high-performance multi-level cache library for Rust with L1 (memory) and L2 (Redis) caching.
Documentation 
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

#![allow(deprecated)]
// Copyright (c) 2025-2026, Kirky.X
//
// MIT License
//
// 生命周期管理集成测试

use oxcache::backend::l1::L1Backend;
use oxcache::backend::l2::L2Backend;
use oxcache::client::two_level::TwoLevelClient;
use oxcache::config::{L1Config, L2Config, TwoLevelConfig};
use oxcache::serialization::SerializerEnum;
use std::sync::Arc;
use std::time::Duration;

use crate::common;

use common::cleanup_service;

#[tokio::test]
async fn test_client_lifecycle_shutdown() {
    common::setup_logging();

    if !common::is_redis_available().await {
        println!("Skipping test_client_lifecycle_shutdown because Redis is not available");
        return;
    }

    let service_name = common::generate_unique_service_name("lifecycle");

    let l1_config = L1Config {
        max_capacity: 1000,
        ..Default::default()
    };
    let l1 = Arc::new(L1Backend::new(l1_config.max_capacity));
    let l2_config = L2Config {
        connection_string: std::env::var("REDIS_URL")
            .unwrap_or_else(|_| "redis://127.0.0.1:6379".to_string())
            .into(),
        ..Default::default()
    };
    let l2 = Arc::new(L2Backend::new(&l2_config).await.unwrap());

    let config = TwoLevelConfig {
        promote_on_hit: true,
        enable_batch_write: true,
        batch_size: 10,
        batch_interval_ms: 50,
        invalidation_channel: None,
        bloom_filter: None,
        warmup: None,
        max_key_length: Some(1024),
        max_value_size: Some(1024 * 1024),
    };

    {
        let client = TwoLevelClient::new(
            service_name.clone(),
            config,
            l1.clone(),
            l2.clone(),
            SerializerEnum::Json(oxcache::serialization::json::JsonSerializer::new()),
        )
        .await
        .expect("Failed to create client");

        // Use the client
        let _ = client.set("key", &"value", None).await;

        // When client goes out of scope, we expect background tasks to stop.
        // Currently we can't easily verify this programmatically without internal hooks,
        // but we can ensure that dropping doesn't panic and resources are ostensibly released.
    }

    // Wait a bit to ensure no crashes occur after drop
    tokio::time::sleep(Duration::from_millis(200)).await;

    cleanup_service(&service_name).await;
}

#[tokio::test]
async fn test_two_level_client_shutdown() {
    common::setup_logging();

    if !common::is_redis_available().await {
        println!("Skipping test_two_level_client_shutdown because Redis is not available");
        return;
    }

    let service_name = common::generate_unique_service_name("shutdown_test");

    let l1 = Arc::new(L1Backend::new(1000));
    let l2_config = L2Config {
        connection_string: std::env::var("REDIS_URL")
            .unwrap_or_else(|_| "redis://127.0.0.1:6379".to_string())
            .into(),
        ..Default::default()
    };
    let l2 = Arc::new(L2Backend::new(&l2_config).await.unwrap());

    let config = TwoLevelConfig {
        promote_on_hit: true,
        enable_batch_write: true,
        batch_size: 10,
        batch_interval_ms: 50,
        invalidation_channel: None,
        bloom_filter: None,
        warmup: None,
        max_key_length: Some(1024),
        max_value_size: Some(1024 * 1024),
    };

    let client = TwoLevelClient::new(
        service_name.clone(),
        config,
        l1.clone(),
        l2.clone(),
        SerializerEnum::Json(oxcache::serialization::json::JsonSerializer::new()),
    )
    .await
    .expect("Failed to create client");

    // 使用客户端进行一些操作
    client
        .set("test_key", &"test_value", Some(60))
        .await
        .unwrap();

    // 验证数据写入成功
    let value: String = client.get("test_key").await.unwrap().unwrap();
    assert_eq!(value, "test_value");

    // 执行优雅关闭
    client.shutdown().await.expect("Failed to shutdown client");

    // 等待一段时间确保所有后台任务都已停止
    tokio::time::sleep(Duration::from_millis(500)).await;

    // 验证关闭后客户端状态（这里主要验证不panic）
    // 注意：由于客户端已关闭，某些操作可能会失败，这是预期的行为
}