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
|
/*
* Copyright (c) 2023 Vaughn Nugent
*
* Library: VNLib
* Package: ObjectCacheServer
* File: CacheStore.cs
*
* CacheStore.cs is part of ObjectCacheServer which is part of the larger
* VNLib collection of libraries and utilities.
*
* ObjectCacheServer is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* ObjectCacheServer is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see https://www.gnu.org/licenses/.
*/
using System;
using System.Threading;
using System.Threading.Tasks;
using VNLib.Utils.Logging;
using VNLib.Net.Messaging.FBM;
using VNLib.Plugins;
using VNLib.Plugins.Extensions.Loading;
namespace VNLib.Data.Caching.ObjectCache.Server.Cache
{
/*
* Implements the blob cache store, which is an abstraction around the blob cache listener.
* This allows for publishing local events (say from other nodes) to keep caches in sync.
*/
[ConfigurationName("cache")]
internal sealed class CacheStore : ICacheStore, IDisposable
{
/// <summary>
/// Gets the underlying cache listener
/// </summary>
public BlobCacheListener<IPeerEventQueue> Listener { get; }
public CacheStore(PluginBase plugin, IConfigScope config)
{
//Init cache
Listener = InitializeCache((ObjectCacheServerEntry)plugin, config);
}
///<inheritdoc/>
ValueTask ICacheStore.AddOrUpdateBlobAsync<T>(string objectId, string? alternateId, ObjectDataReader<T> bodyData, T state, CancellationToken token)
{
return Listener.Cache.AddOrUpdateObjectAsync(objectId, alternateId, bodyData, state, default, token);
}
///<inheritdoc/>
void ICacheStore.Clear()
{
throw new NotImplementedException();
}
///<inheritdoc/>
ValueTask<bool> ICacheStore.DeleteItemAsync(string id, CancellationToken token)
{
return Listener.Cache.DeleteObjectAsync(id, token);
}
private static BlobCacheListener<IPeerEventQueue> InitializeCache(ObjectCacheServerEntry plugin, IConfigScope config)
{
const string CacheConfigTemplate =
@"
Cache Configuration:
Max memory: {max} Mb
Buckets: {bc}
Entries per-bucket: {mc}
";
//Deserialize the cache config
CacheConfiguration cacheConf = config.Deserialze<CacheConfiguration>();
if (cacheConf.MaxCacheEntries < 2)
{
throw new ArgumentException("You must configure a 'max_cache' size larger than 1 item");
}
//Suggestion
if (cacheConf.MaxCacheEntries < 200)
{
plugin.Log.Information("Suggestion: You may want a larger cache size, you have less than 200 items in cache");
}
//calculate the max memory usage
ulong maxByteSize = cacheConf.MaxCacheEntries * (ulong)cacheConf.BucketCount * (ulong)cacheConf.MaxMessageSize;
//Log the cache config
plugin.Log.Information(CacheConfigTemplate,
maxByteSize / (1024 * 1000),
cacheConf.BucketCount,
cacheConf.MaxCacheEntries
);
//Get the event listener
ICacheListenerEventQueue<IPeerEventQueue> queue = plugin.GetOrCreateSingleton<CacheListenerPubQueue>();
//Get the memory manager
ICacheMemoryManagerFactory manager = plugin.GetOrCreateSingleton<BucketLocalManagerFactory>();
//Load the blob cache table system
IBlobCacheTable bc = plugin.LoadMemoryCacheSystem(config, manager, cacheConf);
FallbackFBMMemoryManager fbmMemManager = new(plugin.ListenerHeap);
//Endpoint only allows for a single reader
return new(bc, queue, plugin.Log, fbmMemManager);
}
/*
* Cleaned up by the plugin on exit
*/
public void Dispose()
{
Listener.Dispose();
}
}
}
|
