public void TimeSpan_MaxValue_Should_Never_Expire()
{
var e = Expiration.From(TimeSpan.MaxValue);
Assert.Equal(0u, e.Value);
Assert.True(e.IsAbsolute);
Assert.True(e.IsNever);
}
public void TimeSpan_Less_Than_One_Month_Should_Become_Valid_Relative_Expiration()
{
var e = Expiration.From(TimeSpan.FromSeconds(100));
Assert.Equal(100u, e.Value);
Assert.False(e.IsAbsolute);
Assert.False(e.IsNever);
}
public void DateTime_Value_Should_Become_Valid_Absolute_Expiration()
{
var e = Expiration.From(new DateTime(2012, 01, 31, 23, 0, 0, DateTimeKind.Utc));
Assert.Equal(1328050800u, e.Value);
Assert.True(e.IsAbsolute);
Assert.False(e.IsNever);
}
public void DateTime_MinValue_Should_Never_Expire()
{
var e = Expiration.From(DateTime.MaxValue);
Assert.Equal(0u, e.Value);
Assert.True(e.IsAbsolute);
Assert.True(e.IsNever);
}
public void Different_Instances_From_Same_DateTime_Must_Be_Equal()
{
var a = Expiration.From(new DateTime(2012, 01, 31, 23, 0, 0, DateTimeKind.Utc));
var b = (Expiration)(new DateTime(2012, 01, 31, 23, 0, 0, DateTimeKind.Utc));
Assert.True(a.Equals(a), "a = a");
Assert.True(b.Equals(b), "b = b");
Assert.True(a.Equals(b), "a = b");
Assert.True(b.Equals(a), "b = a");
}
public void Different_Relative_Instances_From_Same_TimeSpan_Must_Be_Equal()
{
var a = Expiration.From(TimeSpan.FromSeconds(100));
var b = (Expiration)(TimeSpan.FromSeconds(100));
Assert.True(a.Equals(a), "a = a");
Assert.True(b.Equals(b), "b = b");
Assert.True(a.Equals(b), "a = b");
Assert.True(b.Equals(a), "b = a");
}
private Operations.TouchOperation PerformTouch(string key, ulong cas, Expiration expiration)
{
var retval = new Operations.TouchOperation(allocator, key, keyFormatter)
{
Cas = cas,
Expiration = expiration
};
retval.Initialize();
return(retval);
}
private async Task <bool> PerformFlushAll(Expiration when)
{
try
{
var tasks = cluster.Broadcast((_, state) => new Operations.FlushOperation(state.allocator)
{
When = state.when
}, (allocator, when));
await Task.WhenAll(tasks).ConfigureAwait(false);
return(true);
}
catch (IOException) { return(false); }
}
public async Task <OperationResult> TouchWithResultAsync(string key, Expiration expiration = default)
{
try
{
var op = PerformTouch(key, cas: 0, expiration);
await cluster.Execute(op).ConfigureAwait(false);
return(new OperationResult((OperationStatus)op.StatusCode, op.Cas));
}
catch (IOException e)
{
return(new OperationResult(e));
}
}
public async Task <ulong> MutateAsync(MutationMode mode, string key, Expiration expiration, ulong delta, ulong defaultValue)
{
try
{
var result = await PerformMutate(mode, key, expiration, delta, defaultValue, 0).ConfigureAwait(false);
return(result.Value);
}
catch (Exception e)
{
LogTo.Error(e);
return(0);
}
}
public async Task <bool> TouchAsync(string key, Expiration expiration = default)
{
try
{
var op = PerformTouch(key, cas: 0, expiration);
await cluster.Execute(op).ConfigureAwait(false);
return(op.StatusCode == Protocol.Status.Success);
}
catch (IOException)
{
return(false);
}
}
private Operations.MutateOperation PerformMutate(
MutationMode mode, string key,
ulong delta, ulong defaultValue,
ulong cas, Expiration expiration, bool silent)
{
var retval = new Operations.MutateOperation(allocator, key, keyFormatter, mode, delta, defaultValue)
{
Cas = cas,
Expiration = expiration,
Silent = silent
};
retval.Initialize();
return(retval);
}
private Operations.StoreOperation PerformStore(
StoreMode mode, string key,
uint flags, SequenceBuilder value,
ulong cas, Expiration expiration, bool silent)
{
var retval = new Operations.StoreOperation(allocator, key, keyFormatter, mode, flags, value)
{
Expiration = expiration,
Cas = cas,
Silent = silent
};
retval.Initialize();
return(retval);
}
public void Negative_TimeSpan_Should_Become_Valid_Absolute_Expiration()
{
var old = SystemTime.Now;
SystemTime.Set(() => new DateTime(2011, 12, 31, 23, 0, 0, DateTimeKind.Utc));
try
{
var e = Expiration.From(TimeSpan.FromSeconds(-10));
Assert.Equal(1325372390u, e.Value);
Assert.True(e.IsAbsolute);
Assert.False(e.IsNever);
}
finally
{
SystemTime.Set(old);
}
}
public void TimeSpan_Greater_Than_One_Month_Should_Become_Valid_Absolute_Expiration()
{
var old = SystemTime.Now;
SystemTime.Set(() => new DateTime(2011, 12, 31, 23, 0, 0, DateTimeKind.Utc));
try
{
var e = Expiration.From(TimeSpan.FromDays(31));
Assert.Equal(1328050800u, e.Value);
Assert.True(e.IsAbsolute);
Assert.False(e.IsNever);
}
finally
{
SystemTime.Set(old);
}
}
public void Different_Absolute_Instances_From_Same_TimeSpan_Must_Be_Equal()
{
var old = SystemTime.Now;
SystemTime.Set(() => new DateTime(2011, 12, 31, 23, 0, 0, DateTimeKind.Utc));
try
{
var a = Expiration.From(TimeSpan.FromDays(60));
var b = (Expiration)(TimeSpan.FromDays(60));
Assert.True(a.Equals(a), "a = a");
Assert.True(b.Equals(b), "b = b");
Assert.True(a.Equals(b), "a = b");
Assert.True(b.Equals(a), "b = a");
}
finally
{
SystemTime.Set(old);
}
}
public static ulong Increment(this ISimpleMemcachedClient self, string key, Expiration expiration, ulong delta = Protocol.MUTATE_DEFAULT_DELTA, ulong defaultValue = Protocol.MUTATE_DEFAULT_VALUE)
{
return(self.Mutate(MutationMode.Increment, key, expiration, delta, defaultValue));
}
public static Task<bool> AddAsync(this ISimpleMemcachedClient self, string key, object value, Expiration expiration)
{
return self.StoreAsync(StoreMode.Add, key, value, expiration);
}
public async Task <bool> StoreAsync(StoreMode mode, string key, object value, Expiration expiration = default)
{
try
{
using var sb = new SequenceBuilder(allocator);
var flags = itemFormatter.Serialize(sb, value);
var op = PerformStore(mode, key, flags, sb, 0, expiration, silent: true);
await cluster.Execute(op).ConfigureAwait(false);
return(op.StatusCode == Protocol.Status.Success);
}
catch (IOException)
{
return(false);
}
}
public static bool Store(this ISimpleMemcachedClient self, StoreMode mode, string key, object value, Expiration expiration)
{
return self.StoreAsync(mode, key, value, expiration).RunAndUnwrap();
}
public Task <IOperationResult> StoreAsync(StoreMode mode, string key, object value, Expiration expiration, ulong cas)
{
return(PerformStoreAsync(mode, key, value, expiration, cas));
}
public async Task <IGetOperationResult <T> > GetAndTouchAsync <T>(string key, Expiration expiration, ulong cas)
{
var result = await PerformGetAndTouchCore(key, expiration, cas).ConfigureAwait(false);
var converted = ConvertToResult <T>(result);
return(converted);
}
public static bool Replace(this ISimpleMemcachedClient self, string key, object value, Expiration expiration)
{
return(self.Store(StoreMode.Replace, key, value, expiration));
}
public static Task<IOperationResult> StoreAsync(this IMemcachedClient self, StoreMode mode, string key, object value, Expiration expiration)
{
return self.StoreAsync(mode, key, value, expiration, Protocol.NO_CAS);
}
protected async Task <IOperationResult> PerformStoreAsync(StoreMode mode, string key, object value, Expiration expiration, ulong cas)
{
try
{
using (var ci = transcoder.Serialize(value))
using (var kb = keyTransformer.Transform(key))
{
var op = opFactory.Store(mode, kb, ci, expiration.Value, cas);
await cluster.Execute(op).ConfigureAwait(false);
return(op.Result);
}
}
catch (IOException e)
{
return(new BinaryOperationResult().FailWith(e));
}
}
protected async Task <IMutateOperationResult> PerformMutate(MutationMode mode, string key, Expiration expiration, ulong delta, ulong defaultValue, ulong cas)
{
try
{
using (var kb = keyTransformer.Transform(key))
{
var op = opFactory.Mutate(mode, kb, expiration.Value, delta, defaultValue, cas);
await cluster.Execute(op).ConfigureAwait(false);
return(op.Result);
}
}
catch (IOException e)
{
return(new MutateOperationResult().FailWith(e));
}
}
public static IOperationResult Replace(this IMemcachedClient self, string key, object value, Expiration expiration, ulong cas = Protocol.NO_CAS)
{
return self.Store(StoreMode.Replace, key, value, expiration, cas);
}
public static Task<IOperationResult> AddAsync(this IMemcachedClient self, string key, object value, Expiration expiration, ulong cas = Protocol.NO_CAS)
{
return self.StoreAsync(StoreMode.Add, key, value, expiration, cas);
}
public static bool Add(this ISimpleMemcachedClient self, string key, object value, Expiration expiration)
{
return self.Store(StoreMode.Add, key, value, expiration);
}
public static ulong Mutate(this ISimpleMemcachedClient self, MutationMode mode, string key, Expiration expiration, ulong delta = Protocol.MUTATE_DEFAULT_DELTA, ulong defaultValue = Protocol.MUTATE_DEFAULT_VALUE)
{
return self.MutateAsync(mode, key, expiration, delta, defaultValue).RunAndUnwrap();
}
public static bool Touch(this ISimpleMemcachedClient self, string key, Expiration expiration)
{
return self.TouchAsync(key, expiration).RunAndUnwrap();
}
public static IMutateOperationResult Decrement(this IMemcachedClient self, string key, Expiration expiration, ulong delta = Protocol.MUTATE_DEFAULT_DELTA, ulong defaultValue = Protocol.MUTATE_DEFAULT_VALUE, ulong cas = Protocol.NO_CAS)
{
return(self.Mutate(MutationMode.Decrement, key, expiration, delta, defaultValue, cas));
}
public static IOperationResult Touch(this IMemcachedClient self, string key, Expiration expiration, ulong cas = Protocol.NO_CAS)
{
return self.TouchAsync(key, expiration, cas).RunAndUnwrap();
}
protected virtual async Task <IGetOperationResult> PerformGetAndTouchCore(string key, Expiration expiration, ulong cas)
{
try
{
using (var kb = keyTransformer.Transform(key))
{
var op = opFactory.GetAndTouch(kb, expiration.Value, cas);
await cluster.Execute(op).ConfigureAwait(false);
return(op.Result);
}
}
catch (IOException e)
{
return(new GetOperationResult().FailWith(e));
}
}
public static IMutateOperationResult Increment(this IMemcachedClient self, string key, Expiration expiration, ulong delta = Protocol.MUTATE_DEFAULT_DELTA, ulong defaultValue = Protocol.MUTATE_DEFAULT_VALUE, ulong cas = Protocol.NO_CAS)
{
return self.Mutate(MutationMode.Increment, key, expiration, delta, defaultValue, cas);
}
public static IOperationResult Store(this IMemcachedClient self, StoreMode mode, string key, object value, Expiration expiration, ulong cas = Protocol.NO_CAS)
{
return self.StoreAsync(mode, key, value, expiration, cas).RunAndUnwrap();
}
public static Task<IOperationResult> TouchAsync(this IMemcachedClient self, string key, Expiration expiration)
{
return self.TouchAsync(key, expiration, Protocol.NO_CAS);
}
public async Task <OperationResult> StoreWithResultAsync(StoreMode mode, string key, object value, ulong cas = 0, Expiration expiration = default)
{
try
{
using var sb = new SequenceBuilder(allocator);
var flags = itemFormatter.Serialize(sb, value);
var op = PerformStore(mode, key, flags, sb, cas, expiration, silent: false);
await cluster.Execute(op).ConfigureAwait(false);
return(new OperationResult((OperationStatus)op.StatusCode, op.Cas));
}
catch (IOException e)
{
return(new OperationResult(e));
}
}
public static IMutateOperationResult Mutate(this IMemcachedClient self, MutationMode mode, string key, Expiration expiration, ulong delta = Protocol.MUTATE_DEFAULT_DELTA, ulong defaultValue = Protocol.MUTATE_DEFAULT_VALUE, ulong cas = Protocol.NO_CAS)
{
return self.MutateAsync(mode, key, expiration, delta, defaultValue, cas).RunAndUnwrap();
}
public static IOperationResult Add(this IMemcachedClient self, string key, object value, Expiration expiration, ulong cas = Protocol.NO_CAS)
{
return(self.Store(StoreMode.Add, key, value, expiration, cas));
}
public static Task <IOperationResult> SetAsync(this IMemcachedClient self, string key, object value, Expiration expiration, ulong cas = Protocol.NO_CAS)
{
return(self.StoreAsync(StoreMode.Set, key, value, expiration, cas));
}
public Task <IOperationResult> TouchAsync(string key, Expiration expiration, ulong cas)
{
return(PerformTouch(key, expiration, cas));
}
public static ulong Decrement(this ISimpleMemcachedClient self, string key, Expiration expiration, ulong delta = Protocol.MUTATE_DEFAULT_DELTA, ulong defaultValue = Protocol.MUTATE_DEFAULT_VALUE)
{
return self.Mutate(MutationMode.Decrement, key, expiration, delta, defaultValue);
}
public Task <IMutateOperationResult> MutateAsync(MutationMode mode, string key, Expiration expiration, ulong delta, ulong defaultValue, ulong cas)
{
return(PerformMutate(mode, key, expiration, delta, defaultValue, cas));
}
public static Task<ulong> MutateAsync(this ISimpleMemcachedClient self, MutationMode mode, string key, Expiration expiration)
{
return self.MutateAsync(mode, key, expiration, Protocol.MUTATE_DEFAULT_DELTA, Protocol.MUTATE_DEFAULT_VALUE);
}