internal static CacheItem[] GetCacheItems(
object[] keys,
object[] values,
RegionConfig regionConfig,
string regionPrefix,
string regionKey,
TimeSpan?itemExpiration,
bool useSlidingExpiration,
string connectionString)
{
CacheItem[] items = new CacheItem[values.Length];
for (int i = 0; i < values.Length; i++)
{
items[i] = GetCacheItem(
keys[i],
values[i],
regionConfig,
regionPrefix,
regionKey,
itemExpiration,
useSlidingExpiration,
connectionString);
}
return(items);
}
public NCacheClient(
CacheHandle cacheHandle,
string regionPrefix,
RegionConfig regionConfig,
IDictionary <string, string> properties)
: base(cacheHandle, regionPrefix, regionConfig, properties)
{
}
private static RegionConfig BuildRegionConfiguration(
string regionName,
string regionPrefix)
{
var regionConfig = new RegionConfig();
regionConfig.RegionName = regionName;
return(regionConfig);
}
internal static AsyncCircuitBreakerPolicy GetAsyncCircuitBreakerPolicy(
RegionConfig regionConfig,
CacheConfig cacheConfig,
INHibernateLogger logger)
{
return(Policy
.Handle <Alachisoft.NCache.Runtime.Exceptions.CacheException>(ex =>
ex.ErrorCode ==
NCacheErrorCodes.NO_SERVER_AVAILABLE)
.CircuitBreakerAsync(
exceptionsAllowedBeforeBreaking:
regionConfig.CircuitBreakerExceptionsAllowed,
durationOfBreak:
TimeSpan.FromSeconds(
regionConfig.CircuitBreakerDurationOfBreak),
onBreak:
(ex, ts, ctx) =>
{
if (logger.IsDebugEnabled())
{
logger.Debug(
$"AsyncCircuitbreaker policy:\n" +
$"\tRegion: {ctx["region"]}" +
$"\tOperation: {ctx["operation"]}" +
$"\tCircuit broken for " +
$"{cacheConfig.CacheId}\n" +
$"\tReason:{ex.Message}");
}
},
onReset: (ctx) =>
{
if (logger.IsDebugEnabled())
{
logger.Debug(
$"AsyncCircuitbreaker policy:\n" +
$"\tRegion: {ctx["region"]}" +
$"\tCircuit reset for {cacheConfig.CacheId}");
}
},
onHalfOpen: () =>
{
if (logger.IsDebugEnabled())
{
logger.Debug(
$"AsyncCircuitbreaker policy:\n" +
$"\tCircuit half-open for" +
$" {cacheConfig.CacheId}");
}
}
));
}
internal static CacheItem GetCacheItem(
object key,
object value,
RegionConfig regionConfig,
string regionPrefix,
string regionKey,
TimeSpan?itemExpiration,
bool useSlidingExpiration,
string connectionString)
{
var cacheItem = new CacheItem(value)
{
Tags = new Tag[] { new Tag(regionKey) }
};
Expiration expiration;
if (itemExpiration.HasValue &&
itemExpiration.Value.TotalMilliseconds > 0.0d)
{
if (useSlidingExpiration)
{
expiration = new Expiration(ExpirationType.Sliding,
itemExpiration.Value);
}
else
{
expiration = new Expiration(ExpirationType.Absolute,
itemExpiration.Value);
}
cacheItem.Expiration = expiration;
}
var aggregateDependency = GetDependency(
key,
value,
regionPrefix,
regionConfig,
connectionString);
if (aggregateDependency != null)
{
cacheItem.Dependency = aggregateDependency;
}
return(cacheItem);
}
private static AggregateCacheDependency GetDependency(
object key,
object value,
string regionPrefix,
RegionConfig regionConfig,
string connectionString)
{
CacheEntry cachedEntry = null;
if (value is CachedItem item)
{
if (item.Value is CacheEntry entry)
{
cachedEntry = entry;
}
else
{
return(null);
}
}
else if (value is CacheLock cacheLock)
{
return(null);
}
else
{
cachedEntry = value as CacheEntry;
if (cachedEntry == null)
{
return(null);
}
}
var id = (key as CacheKey).Key;
var entityClassFullName = cachedEntry.Subclass;
var dependencies = NCacheProvider.GetEntityDependencyConfigs(
regionPrefix,
entityClassFullName)
.ToArray();
if (dependencies.Length == 0)
{
return(null);
}
List <CacheDependency> cacheDependencies =
new List <CacheDependency>(dependencies.Length);
for (int i = 0; i < dependencies.Length; i++)
{
var cacheDependency =
dependencies[i].GetCacheDependency(
connectionString,
id);
cacheDependencies.Add(cacheDependency);
}
var aggregateDependency = new AggregateCacheDependency();
aggregateDependency.Add(cacheDependencies.ToArray());
return(aggregateDependency);
}
internal static AsyncPolicyWrap <object> GetAsyncLockFallBackPolicy(
RegionConfig regionConfig,
AsyncCircuitBreakerPolicy circuitBreaker,
INHibernateLogger logger)
{
var retryCircuitBreakerAsyncPolicyWrap =
Policy <object>
.HandleResult(x => x == null)
.WaitAndRetryAsync(
retryCount:
regionConfig.LockRetryTimes,
sleepDurationProvider:
(retryAttempt, context) =>
{
return(GetRetryWaitDuration(
retryAttempt,
context,
regionConfig.LockMinRetryDelay,
regionConfig.LockMaxRetryDelay));
},
onRetry:
(res, ts, attempt, ctx) =>
{
if (logger.IsDebugEnabled())
{
logger.Debug(
$"AsyncRetry policy:\n" +
$"\tRegion: {ctx["region"]}" +
$"\tOperation: {ctx["operation"]}\n" +
$"\tRetry attempt: {attempt},\n" +
$"\tSleepDuration:" +
$" {ts.TotalMilliseconds} ms");
}
}
)
.WrapAsync(circuitBreaker);
var timeoutRetryCircuitBreakerAsyncPolicyWrap =
Policy
.TimeoutAsync(
timeout:
regionConfig.LockAcquireTimeout,
timeoutStrategy:
TimeoutStrategy.Optimistic,
onTimeoutAsync:
(ctx, ts, task) =>
{
if (logger.IsDebugEnabled())
{
logger.Debug(
$"AsyncTimeout policy:\n" +
$"\tRegion: {ctx["region"]}" +
$"\tOperation: {ctx["operation"]}\n" +
$"\tTimeSpan: {ts.TotalMilliseconds} ms");
}
return(Task.CompletedTask);
})
.WrapAsync(retryCircuitBreakerAsyncPolicyWrap);
return(Policy <object>
.Handle <TimeoutRejectedException>()
.Or <BrokenCircuitException>()
.Or <Alachisoft.NCache.Runtime.Exceptions.CacheException>(e =>
e.ErrorCode ==
NCacheErrorCodes.NO_SERVER_AVAILABLE)
.OrResult(x => x == null)
.FallbackAsync <object>(
fallbackAction:
(ctx, ct) =>
{
return Task.FromResult((object)null);
},
onFallbackAsync:
(res, ctx) =>
{
if (logger.IsDebugEnabled())
{
logger.Debug(
$"AsyncFallback policy:\n" +
$"\tRegion: {ctx["region"]}" +
$"\tOperation: {ctx["operation"]}\n" +
$"\tFallback result: {res.Result ?? "null"}");
}
return Task.CompletedTask;
}
)
.WrapAsync(timeoutRetryCircuitBreakerAsyncPolicyWrap));
}
private static void AddCacheRegion(
XmlNode cacheRegionNode,
ApplicationConfig applicationConfig)
{
RegionConfig regionConfig =
new RegionConfig();
regionConfig.RegionName =
GetString(cacheRegionNode, "region-name", true);
if (applicationConfig.CacheRegions.ContainsKey(
regionConfig.RegionName))
{
throw new ConfigurationErrorsException(
$"Multiple cache region configurations with identical region-name " +
$"{regionConfig.RegionName} given");
}
var cacheId =
GetString(cacheRegionNode, "cache-id", false);
if (!string.IsNullOrWhiteSpace(cacheId))
{
regionConfig.CacheId = cacheId;
}
var expiration =
GetTimeSpan(cacheRegionNode, "expiration-period", true);
if (expiration.HasValue)
{
regionConfig.Expiration = expiration.Value;
}
var useSliding =
GetBoolean(cacheRegionNode, "use-sliding-expiration");
if (useSliding.HasValue)
{
regionConfig.UseSlidingExpiration = useSliding.Value;
}
var cacheKeyPrefix =
GetString(cacheRegionNode, "cache-key-prefix");
if (!string.IsNullOrWhiteSpace(cacheKeyPrefix))
{
regionConfig.CacheKeyPrefix = cacheKeyPrefix;
}
var lockKeyTimeout =
GetTimeSpan(cacheRegionNode, "lock-key-timout", true);
if (lockKeyTimeout.HasValue)
{
regionConfig.LockKeyTimeout = lockKeyTimeout.Value;
}
var lockAcquireTimeout =
GetTimeSpan(cacheRegionNode, "lock-acquire-timeout", true);
if (lockAcquireTimeout.HasValue)
{
regionConfig.LockAcquireTimeout = lockAcquireTimeout.Value;
}
var lockRetryTimes =
GetInteger(cacheRegionNode, "lock-retry-times");
if (lockRetryTimes.HasValue)
{
regionConfig.LockRetryTimes = lockRetryTimes.Value;
}
var lockMaxRetryDelay =
GetTimeSpan(cacheRegionNode, "lock-max-retry-delay");
if (lockMaxRetryDelay.HasValue)
{
regionConfig.LockMaxRetryDelay = lockMaxRetryDelay.Value;
}
var lockMinRetryDelay =
GetTimeSpan(cacheRegionNode, "lock-min-retry-delay");
if (lockMinRetryDelay.HasValue)
{
regionConfig.LockMinRetryDelay = lockMinRetryDelay.Value;
}
var circuitBreakerExceptionsAllowed =
GetInteger(
cacheRegionNode,
"circuit-breaker-exceptions-allowed");
if (circuitBreakerExceptionsAllowed.HasValue)
{
regionConfig.CircuitBreakerExceptionsAllowed =
circuitBreakerExceptionsAllowed.Value;
}
var circuitBreakerDurationOfBreak =
GetInteger(
cacheRegionNode,
"circuit-breaker-open-duration");
if (circuitBreakerDurationOfBreak.HasValue)
{
regionConfig.CircuitBreakerDurationOfBreak =
circuitBreakerDurationOfBreak.Value;
}
applicationConfig.CacheRegions.Add(
regionConfig.RegionName,
regionConfig);
}
