/// <summary>
/// Reads the value from the cache for a specific key
/// </summary>
/// <typeparam name="TExpected">Expected type of the value</typeparam>
/// <param name="keyName">Name of the key</param>
/// <returns>Value for the key</returns>
public Maybe <TExpected> Read <TExpected>(ICacheKey key)
{
try
{
// Retrieve the default db
IDatabase defaultDb = GetDefaultRedisDb(readOnly: true);
// Read the value
RedisValue redisValue = defaultDb.StringGet(key.Name);
if (redisValue.IsNull)
{
return(new Maybe <TExpected>());
}
// Parse to the expected type
TExpected value = RedisConverter.ConvertTo <TExpected>(redisValue);
return(new Maybe <TExpected>(value));
}
catch (Exception ex)
{
string exceptionMessage = string.Format("Something went wrong while reading the key '{0}' from the cache.", key.Name);
var cacheException = new CacheException(exceptionMessage, ex);
return(new Maybe <TExpected>());
}
}
public void MessageIsSet()
{
var cacheException = new CacheException("special message");
Assert.AreEqual(cacheException.Message, "special message");
Assert.AreEqual(cacheException.InnerException, null);
}
/// <summary>
/// Makes a key and data package form the keys and values of hashtable, for bulk operations
/// </summary>
/// <param name="dic">Hashtable containing the keys and values to be packaged</param>
/// <param name="keys">Contains packaged keys after execution</param>
/// <param name="data">Contains packaged data after execution</param>
internal static void PackageKeysExceptions(Hashtable dic, Alachisoft.NCache.Common.Protobuf.KeyExceptionPackageResponse keyExceptionPackage)
{
int errorCode = -1;
if (dic != null && dic.Count > 0)
{
IDictionaryEnumerator enu = dic.GetEnumerator();
while (enu.MoveNext())
{
CacheException cacheException = enu.Value as CacheException;
if (cacheException != null)
{
errorCode = cacheException.ErrorCode;
}
Exception ex = enu.Value as Exception;
if (ex != null)
{
keyExceptionPackage.keys.Add((string)enu.Key);
Alachisoft.NCache.Common.Protobuf.Exception exc = new Alachisoft.NCache.Common.Protobuf.Exception();
exc.message = ex.Message;
exc.exception = ex.ToString();
exc.type = Alachisoft.NCache.Common.Protobuf.Exception.Type.GENERALFAILURE;
exc.errorCode = errorCode;
keyExceptionPackage.exceptions.Add(exc);
}
}
}
}
public void MessageExceptionConstructor()
{
var exception = new CacheException(Message, _innerException);
exception.Message.Should().Be(Message);
exception.InnerException.Should().Be(_innerException);
}
public void ExceptionFormatConstructor()
{
var exception = new CacheException(_innerException, Format, Arg);
exception.InnerException.Should().Be(_innerException);
exception.Message.Should().Be(Formatted);
}
internal static Exception CacheEntityNotHaveKeyAttribute(string type)
{
CacheException exception = new CacheException(CacheErrorCodes.EntityNotHaveKeyAttribute);
exception.Data["Type"] = type;
return(exception);
}
internal static Exception CacheSlidingTimeBiggerThanMaxAlive(string type)
{
CacheException exception = new CacheException(CacheErrorCodes.SlidingTimeBiggerThanMaxAlive);
exception.Data["Type"] = type;
return(exception);
}
public void InnerExceptionAndMessageIsSet()
{
var inner = new Exception("inner");
var cacheException = new CacheException("special message", inner);
Assert.AreEqual(cacheException.Message, "special message");
Assert.AreEqual(cacheException.InnerException, inner);
}
internal static Exception SmsCacheError(string cause, CacheException ex)
{
SmsException exception = new SmsException(AliyunErrorCodes.SmsCacheError, ex);
exception.Data["Cause"] = cause;
return(exception);
}
public void ConstructorInner()
{
Exception e = new Exception();
CacheException exception = new CacheException("Message", e);
Assert.AreEqual("Message", exception.Message);
Assert.AreEqual(e, exception.InnerException);
}
internal static Exception ConvertError(string key, Exception innerException)
{
CacheException exception = new CacheException(CacheErrorCodes.ConvertError, innerException);
exception.Data["Key"] = key;
return(exception);
}
internal static Exception Unkown(object key, object?value, Exception innerException)
{
CacheException exception = new CacheException(CacheErrorCodes.Unkown, innerException);
exception.Data["Key"] = key;
exception.Data["Value"] = value;
return(exception);
}
/// <summary>
/// Removes the specified keys.
/// </summary>
/// <param name="keys">list of keys</param>
/// <returns>The number of keys that were removed</returns>
public long Remove(System.Collections.Generic.List <ICacheKey> keys)
{
try
{
return(RemoveKeys(keys));
}
catch (Exception ex)
{
string exceptionMessage = "Something went wrong while deleting the list of keys from the cache.";
var cacheException = new CacheException(exceptionMessage, ex);
return(0);
}
}
public void ConstructorDeserialize()
{
CacheException exception = new CacheException("Message");
BinaryFormatter formatter = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.All));
byte[] buffer = null;
using (MemoryStream ms = new MemoryStream()) {
formatter.Serialize(ms, exception);
buffer = ms.ToArray();
}
CacheException deserializeException = null;
using (MemoryStream ms = new MemoryStream(buffer)) {
deserializeException = (CacheException)formatter.Deserialize(ms);
}
Assert.AreEqual("Message", deserializeException.Message);
}
/// <summary>
/// Removes a key from the cache
/// </summary>
/// <param name="keyName">Name of the key</param>
/// <returns>Indication whether or not the operation succeeded</returns>
public bool Remove(ICacheKey key)
{
try
{
// Remove using the existing functionality
long operationResult = RemoveKeys(new List <ICacheKey>()
{
key
});
return(operationResult == 1);
}
catch (Exception ex)
{
string exceptionMessage = string.Format("Something went wrong while deleting the key '{0}' from the cache.", key.Name);
var cacheException = new CacheException(exceptionMessage, ex);
return(false);
}
}
/// <summary>
/// Gets the cache client response.
/// </summary>
/// <typeparam name="T">Return value type.</typeparam>
/// <param name="key">The key.</param>
/// <returns>A task that represents the asynchronous operation.
/// Returns the cache client response.</returns>
private async Task <CacheClientResponse> GetCacheClientResponse <T>(string key)
{
CacheException exception = null;
object result = null;
GetOperationResult <string> valueResult = await this.client.GetAsync <string>(key) as GetOperationResult <string>;
if (valueResult.Success)
{
result = typeof(T) == typeof(string)
? valueResult.Value
: (object)this.cacheSerializer.Deserialize <T>(valueResult.Value);
}
else
{
exception = new CacheException(valueResult.Message, valueResult.Exception);
}
return(new CacheClientResponse(result, exception));
}
private ConnectionMultiplexer ConnectToRedisCache(string configurationString)
{
try
{
// Assign options for the connection
var configOptions = ConfigurationOptions.Parse(configurationString);
configOptions.ClientName = "Codit Cache Client";
// Connect to the cache
ConnectionMultiplexer connection = ConnectionMultiplexer.Connect(configOptions);
return(connection);
}
catch (Exception ex)
{
string exceptionMessage = string.Format("Failed to connect to the Redis cache with configuration string '{0}'.", configurationString);
var cacheConnectionEx = new CacheException(exceptionMessage, ex);
throw cacheConnectionEx;
}
}
/// <summary>
/// Writes a value to a specific key
/// </summary>
/// <typeparam name="TValue">Type of the value</typeparam>
/// <param name="keyName">Name of the key</param>
/// <param name="value">New value of the key</param>
/// <param name="expiration">Duration that the key will live in the cache</param>
/// <returns>Indication whether or not the operation succeeded</returns>
public bool Write <TValue>(ICacheKey key, TValue value, TimeSpan expiration)
{
try
{
// Retrieve the default db
IDatabase defaultDb = GetDefaultRedisDb(readOnly: false);
// Convert the value to native redis value
RedisValue nativeValue = RedisConverter.ConvertFrom <TValue>(value);
// Write the value to the key
bool operationResult = defaultDb.StringSet(key.Name, nativeValue, expiration, When.Always);
return(operationResult);
}
catch (Exception ex)
{
string exceptionMessage = string.Format("Something went wrong while writing the key '{0}' to the cache.", key.Name);
var cacheException = new CacheException(exceptionMessage, ex);
return(false);
}
}
/// <summary>
/// Desirializes the given type.
/// </summary>
/// <param name="serializedObject">The serialized object. A <see cref="T:System.Byte[]"/> Object.</param>
/// <returns>A <see cref="T:T"/> Object.</returns>
//[System.Diagnostics.DebuggerStepThrough]
public static T BinaryDeSerialize <T>(byte[] serializedObject)
{
#region Access Log
#if TRACE
{
Handler.LogHandler.Tracking("Access Method: " + typeof(Serialization).FullName + "->" + ((object)MethodBase.GetCurrentMethod()).ToString() + " ;");
}
#endif
#endregion Access Log
try
{
MemoryStream ms = new MemoryStream();
ms.Write(serializedObject, 0, serializedObject.Length);
ms.Seek(0, 0);
BinaryFormatter b = new BinaryFormatter();
Object obj = b.Deserialize(ms);
ms.Close();
return((T)obj);
}
catch (Exception ex)
{
MemoryStream ms = new MemoryStream();
ms.Write(serializedObject, 0, serializedObject.Length);
ms.Seek(0, 0);
BinaryFormatter b = new BinaryFormatter();
Object obj = b.Deserialize(ms);
ms.Close();
CacheException cex = (CacheException)obj;
if (cex != null)
{
// TODO: Shared Cache Exception
Handler.LogHandler.Error(cex.StackTrace, ex);
}
return((T)obj);
}
}
public void ConstructorMessage()
{
CacheException exception = new CacheException("Message");
Assert.AreEqual("Message", exception.Message);
}
public void FormatConstructor()
{
var exception = new CacheException(Format, Arg);
exception.Message.Should().Be(Formatted);
}
public void MessageConstructor()
{
var exception = new CacheException(Message);
exception.Message.Should().Be(Message);
}
public CacheClientResponse(object value, CacheException exception)
{
this.Value = value;
this.Exception = exception;
}
public void ConstructorDefault()
{
CacheException exception = new CacheException();
}
