iframe-proxy | Sunbelt Computer Software

History

220 lines (199 loc) · 7.61 KB

Raw

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

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

using System.Collections.Concurrent;

using NpgsqlRest;

using StackExchange.Redis;

namespace NpgsqlRestClient

{

public class RedisCache : IRoutineCache, IDisposable

{

private readonly ConnectionMultiplexer _redis;

private readonly IDatabase _db;

private readonly ILogger? _logger;

private readonly CacheOptions _cacheOptions;

// In-process in-flight factory invocations (single-instance coalescing). Cross-process

// coalescing across NpgsqlRest instances is intentionally out of scope; this only collapses

// a burst hitting THIS instance into one execution. See memory RoutineCache for the pattern.

private readonly ConcurrentDictionary<string, Lazy<Task<object?>>> _inflight = new(StringComparer.Ordinal);

private bool _disposed;

public RedisCache(string configuration, ILogger? logger = null, CacheOptions? cacheOptions = null)

{

_logger = logger;

_cacheOptions = cacheOptions ?? new CacheOptions();

ConnectionMultiplexer? redis = null;

try

{

_logger?.LogDebug("Connecting to Redis with configuration: {RedisConfiguration}", configuration);

redis = ConnectionMultiplexer.Connect(configuration);

_db = redis.GetDatabase();

// Test the connection

_db.Ping();

_redis = redis; // Only assign after successful initialization

_logger?.LogInformation("Successfully connected to Redis cache");

}

catch (Exception ex)

{

// Dispose the connection if initialization failed

redis?.Dispose();

_disposed = true;

_logger?.LogError(ex, "Failed to initialize Redis connection");

throw new InvalidOperationException("Failed to initialize Redis cache", ex);

}

private string GetEffectiveKey(string key)

{

return CacheKeyHasher.GetEffectiveKey(key, _cacheOptions);

}

public bool Get(RoutineEndpoint endpoint, string key, out object? result)

{

result = null;

if (_disposed)

{

_logger?.LogWarning("Attempted to get from disposed Redis cache");

return false;

}

try

{

var effectiveKey = GetEffectiveKey(key);

var redisValue = _db.StringGet(effectiveKey);

if (redisValue.HasValue)

{

result = redisValue.ToString();

_logger?.LogTrace("Cache hit for key: {Key}", key);

return true;

}

_logger?.LogTrace("Cache miss for key: {Key}", key);

return false;

}

catch (RedisException ex)

{

_logger?.LogError(ex, "Redis error while getting key: {Key}", key);

return false;

}

catch (Exception ex)

{

_logger?.LogError(ex, "Unexpected error while getting key from Redis: {Key}", key);

return false;

}

public void AddOrUpdate(RoutineEndpoint endpoint, string key, object? value, TimeSpan? overrideExpiration = null)

{

if (_disposed)

{

_logger?.LogWarning("Attempted to set on disposed Redis cache");

return;

}

try

{

var effectiveKey = GetEffectiveKey(key);

var stringValue = value?.ToString();

var expiry = overrideExpiration ?? endpoint.CacheExpiresIn;

_db.StringSet(effectiveKey, stringValue, expiry.HasValue ? new Expiration(expiry.Value) : default);

_logger?.LogTrace("Cached value for key: {Key} with expiry: {Expiry}", key, expiry);

}

catch (RedisException ex)

{

_logger?.LogError(ex, "Redis error while setting key: {Key}", key);

}

catch (Exception ex)

{

_logger?.LogError(ex, "Unexpected error while setting key in Redis: {Key}", key);

}

public async ValueTask<object?> GetOrCreateAsync(

RoutineEndpoint endpoint,

string key,

Func<CancellationToken, ValueTask<object?>> factory,

TimeSpan? overrideExpiration = null,

CancellationToken cancellationToken = default)

{

var effectiveKey = GetEffectiveKey(key);

while (true)

{

cancellationToken.ThrowIfCancellationRequested();

if (Get(endpoint, key, out var cached))

{

return cached;

}

var lazy = _inflight.GetOrAdd(

effectiveKey,

_ => new Lazy<Task<object?>>(() => RunFactoryAsync(endpoint, key, effectiveKey, factory, overrideExpiration, cancellationToken)));

try

{

return await lazy.Value.WaitAsync(cancellationToken);

}

catch (OperationCanceledException)

{

if (cancellationToken.IsCancellationRequested)

{

throw;

}

// Lead caller cancelled before this waiter; retry (value may be cached now, or this

// caller becomes the new lead with its own live resources).

}

private async Task<object?> RunFactoryAsync(

RoutineEndpoint endpoint,

string key,

string effectiveKey,

Func<CancellationToken, ValueTask<object?>> factory,

TimeSpan? overrideExpiration,

CancellationToken cancellationToken)

{

try

{

var result = await factory(cancellationToken).ConfigureAwait(false);

AddOrUpdate(endpoint, key, result, overrideExpiration);

return result;

}

finally

{

_inflight.TryRemove(effectiveKey, out _);

}

public bool Remove(string key)

{

if (_disposed)

{

_logger?.LogWarning("Attempted to remove from disposed Redis cache");

return false;

}

try

{

var effectiveKey = GetEffectiveKey(key);

var result = _db.KeyDelete(effectiveKey);

_logger?.LogTrace("Removed cache key: {Key}, success: {Result}", key, result);

return result;

}

catch (RedisException ex)

{

_logger?.LogError(ex, "Redis error while removing key: {Key}", key);

return false;

}

catch (Exception ex)

{

_logger?.LogError(ex, "Unexpected error while removing key from Redis: {Key}", key);

return false;

}

public void Dispose()

{

if (_disposed)

{

return;

}

try

{

_redis.Dispose();

_logger?.LogInformation("Redis cache connection disposed");

}

catch (Exception ex)

{

_logger?.LogError(ex, "Error while disposing Redis cache connection");

}

finally

{

_disposed = true;

}

Sunbelt Computer Software

PL/B Language Development and Support

Navigation Menu

Uh oh!

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

Uh oh!

FilesExpand file tree

RedisCache.cs

Latest commit

History

RedisCache.cs

File metadata and controls