public void Clear_Empty_Set()
{
// http://bugs.developer.mindtouch.com/view.php?id=8739
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
set.Clear();
}
//--- Constructors ---
public Listener(string queuename, Action <AwsSqsMessage> callback, IAwsSqsClient client, TaskTimerFactory timerFactory, TimeSpan interval)
{
_queuename = queuename;
_callback = callback;
_client = client;
_cache = new ExpiringHashSet <string>(timerFactory);
_cacheTimer = ((interval.TotalSeconds * 2 < 60) ? 60 : interval.TotalSeconds * 2 + 1).Seconds();
_pollTimer = timerFactory.New(tt => Coroutine.Invoke(PollSqs, new Result()).WhenDone(r => _pollTimer.Change(interval, TaskEnv.None)), null);
_pollTimer.Change(0.Seconds(), TaskEnv.None);
}
protected override Yield Stop(Result result)
{
_expirationEntries.Dispose();
_expirationEntries.EntryExpired -= OnDelete;
_expirationEntries = null;
_path = null;
yield return(Coroutine.Invoke(base.Stop, new Result()));
result.Return();
}
public void Can_retrieve_item_checking_ttl()
{
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
var v = 42;
var ttl = TimeSpan.FromSeconds(10);
set.SetOrUpdate(v, ttl);
var entry = set[v];
Assert.AreEqual(v, entry.Value);
Assert.AreEqual(ttl, entry.TTL);
}
public void Can_retrieve_item_checking_when()
{
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
var v = 42;
var when = GlobalClock.UtcNow.AddDays(1);
set.SetOrUpdate(v, when);
var entry = set[v];
Assert.AreEqual(v, entry.Value);
Assert.AreEqual(when, entry.When);
}
public void Access_on_tasktimerfactory_ctor_set_does_not_reset_expiration()
{
var i = 42;
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
var expireTime = DateTime.UtcNow.AddSeconds(10);
set.SetExpiration(i, expireTime);
Thread.Sleep(TimeSpan.FromSeconds(2));
var entry = set[i];
AssertEx.AreEqual(ttl, entry.TTL);
Assert.AreEqual(expireTime,entry.When);
}
public void Access_on_tasktimerfactory_ctor_set_does_not_reset_expiration()
{
var i = 42;
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
var expireTime = GlobalClock.UtcNow.AddSeconds(10);
set.SetOrUpdate(i, expireTime);
Thread.Sleep(TimeSpan.FromSeconds(2));
var entry = set[i];
AssertEx.AreEqual(ttl, entry.TTL);
Assert.AreEqual(expireTime, entry.When);
}
public void Access_on_autoRefresh_set_does_reset_expiration()
{
var i = 42;
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current,true);
var expireTime = DateTime.UtcNow.AddSeconds(10);
set.SetExpiration(i, expireTime);
Thread.Sleep(TimeSpan.FromSeconds(2));
var entry = set[i];
AssertEx.AreEqual(ttl, entry.TTL);
Assert.AreNotEqual(expireTime, entry.When);
Assert.GreaterOrEqual(entry.When, expireTime);
Assert.LessOrEqual(entry.When, expireTime.AddSeconds(3));
}
public void Refresh_in_autoRefresh_only_fires_every_half_second()
{
var k = 42;
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current, true);
var expireTime = GlobalClock.UtcNow.AddSeconds(10);
set.SetOrUpdate(k, expireTime);
var when = set[k].When;
Thread.Sleep(200);
Assert.AreEqual(when, set[k].When);
Thread.Sleep(1000);
Assert.Less(when, set[k].When);
}
public void Access_on_autoRefresh_set_does_reset_expiration()
{
var i = 42;
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current, true);
var expireTime = GlobalClock.UtcNow.AddSeconds(10);
set.SetOrUpdate(i, expireTime);
Thread.Sleep(TimeSpan.FromSeconds(2));
var entry = set[i];
AssertEx.AreEqual(ttl, entry.TTL);
Assert.AreNotEqual(expireTime, entry.When);
Assert.GreaterOrEqual(entry.When, expireTime);
Assert.LessOrEqual(entry.When, expireTime.AddSeconds(3));
}
public void Clearing_set_releases_all_items()
{
var changed = false;
var ttl = 10.Seconds();
var set = new ExpiringHashSet <string>(TaskTimerFactory.Current);
set.SetOrUpdate("a", ttl);
set.SetOrUpdate("b", ttl);
set.SetOrUpdate("v", ttl);
set.CollectionChanged += (s, e) => changed = true;
Assert.AreEqual(3, set.Count());
Assert.IsFalse(changed);
set.Clear();
Assert.AreEqual(0, set.Count());
Assert.IsTrue(changed);
}
public void Set_will_fire_in_order_of_expirations()
{
var expired = new ManualResetEvent(false);
var entries = new List <int>();
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entries.Add(e.Entry.Value); expired.Set(); };
set.SetOrUpdate(3, TimeSpan.FromMilliseconds(1600));
set.SetOrUpdate(2, TimeSpan.FromMilliseconds(1500));
set.SetOrUpdate(5, TimeSpan.FromMilliseconds(3000));
set.SetOrUpdate(4, TimeSpan.FromMilliseconds(2000));
set.SetOrUpdate(1, TimeSpan.FromMilliseconds(500));
Assert.IsTrue(expired.WaitOne(1000));
Assert.AreEqual(1, entries.Count);
Assert.IsTrue(Wait.For(() => entries.Count == 5, TimeSpan.FromSeconds(5000)));
Assert.AreEqual(new[] { 1, 2, 3, 4, 5 }, entries.ToArray());
}
public void Can_dispose_set()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var i = 42;
var ttl = TimeSpan.FromSeconds(1);
ExpiringHashSet <int> .Entry entry = null;
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.SetExpiration(i, ttl);
set.Dispose();
Assert.IsTrue(changed.WaitOne(2000));
Assert.IsFalse(expired.WaitOne(2000));
}
//--- Constructors ---
/// <summary>
/// Create new client instance
/// </summary>
/// <param name="config">Client configuration.</param>
/// <param name="timerFactory">Timer factory.</param>
public AwsS3Client(AwsS3ClientConfig config, TaskTimerFactory timerFactory)
{
_config = config;
_bucketPlug = Plug.New(_config.Endpoint.S3Uri)
.WithS3Authentication(_config.PrivateKey, _config.PublicKey)
.WithTimeout(_config.Timeout)
.At(_config.Bucket);
_rootPlug = _bucketPlug;
if(!string.IsNullOrEmpty(_config.RootPath)) {
_keyRootParts = _config.RootPath.Split(new[] { config.Delimiter }, StringSplitOptions.RemoveEmptyEntries);
if(_keyRootParts.Any()) {
_rootPlug = _rootPlug.At(_keyRootParts);
}
}
_expirationEntries = new ExpiringHashSet<string>(timerFactory);
_expirationEntries.EntryExpired += OnDelete;
}
public void Can_iterate_over_items()
{
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
var n = 10;
for (var i = 1; i <= n; i++)
{
set.SetOrUpdate(i, TimeSpan.FromSeconds(i));
}
var items = from x in set select x;
Assert.AreEqual(n, items.Count());
for (var i = 1; i <= n; i++)
{
var j = i;
Assert.IsTrue((from x in set where x.Value == j && x.TTL == TimeSpan.FromSeconds(j) select x).Any());
}
}
public void New_item_with_more_recent_expiration_will_fire_at_expected_time()
{
var expired = new ManualResetEvent(false);
var entries = new List <int>();
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entries.Add(e.Entry.Value); expired.Set(); };
var n = 1000;
for (var i = 0; i < n; i++)
{
set.SetOrUpdate(i, TimeSpan.FromMinutes(10));
}
set.SetOrUpdate(100000, TimeSpan.FromSeconds(2));
Assert.IsTrue(expired.WaitOne(4000));
Assert.AreEqual(1, entries.Count);
Assert.AreEqual(n, set.Count());
}
//--- Constructors ---
/// <summary>
/// Create new client instance
/// </summary>
/// <param name="config">Client configuration.</param>
/// <param name="timerFactory">Timer factory.</param>
public AmazonS3Client(AmazonS3ClientConfig config, TaskTimerFactory timerFactory)
{
_config = config;
_bucketPlug = Plug.New(_config.S3BaseUri)
.WithS3Authentication(_config.PrivateKey, _config.PublicKey)
.WithTimeout(_config.Timeout)
.At(_config.Bucket);
_rootPlug = _bucketPlug;
if (!string.IsNullOrEmpty(_config.RootPath))
{
_keyRootParts = _config.RootPath.Split(new[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
if (_keyRootParts != null && _keyRootParts.Any())
{
_rootPlug = _rootPlug.At(_keyRootParts);
}
}
_expirationEntries = new ExpiringHashSet <string>(timerFactory);
_expirationEntries.EntryExpired += OnDelete;
}
public void Can_set_item_via_when()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var i = 42;
var when = GlobalClock.UtcNow.AddSeconds(1);
ExpiringHashSet <int> .Entry entry = null;
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.SetOrUpdate(i, when);
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
Assert.AreEqual(i, entry.Value);
Assert.AreEqual(when, entry.When);
Assert.IsNull(set[i]);
}
public void Can_set_item_via_ttl()
{
_log.Debug("running test");
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var i = 42;
var ttl = TimeSpan.FromSeconds(1);
ExpiringHashSet <int> .Entry entry = null;
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.SetOrUpdate(i, ttl);
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
Assert.AreEqual(i, entry.Value);
Assert.AreEqual(ttl, entry.TTL);
Assert.IsNull(set[i]);
}
public void Disposing_set_expires_all_items_before_dispose_returns_but_does_not_trigger_collection_changed()
{
var expired = false;
var changed = false;
var expiredEntries = new List <int>();
var ttl = TimeSpan.FromSeconds(1);
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { expiredEntries.Add(e.Entry.Value); expired = true; };
set.CollectionChanged += (s, e) => { changed = true; };
set.SetOrUpdate(12, ttl);
set.SetOrUpdate(21, ttl);
Assert.IsFalse(expired, "expired was triggered");
Assert.IsTrue(changed, "changed wasn't triggered");
changed = false;
set.Dispose();
Assert.IsFalse(changed, "changed was triggered");
Assert.IsTrue(expired, "expired wasn't triggered");
Assert.AreEqual(new[] { 12, 21 }, expiredEntries.OrderBy(x => x).ToArray());
}
public void Can_set_ttl_on_existing_item()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var i = 42;
var ttl = TimeSpan.FromSeconds(10);
ExpiringHashSet <int> .Entry entry = null;
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.SetOrUpdate(i, ttl);
Assert.IsTrue(changed.WaitOne(2000));
changed.Reset();
Assert.IsFalse(expired.WaitOne(2000));
set.SetOrUpdate(i, TimeSpan.FromSeconds(1));
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
}
public void Can_access_hashset_during_expiration_event()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var i = 42;
var ttl = TimeSpan.FromSeconds(1);
ExpiringHashSet <int> .Entry entry = null;
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => {
entry = e.Entry;
set.Delete(e.Entry.Value);
expired.Set();
};
set.CollectionChanged += (s, e) => changed.Set();
set.SetOrUpdate(i, ttl);
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
Assert.AreEqual(i, entry.Value);
Assert.AreEqual(ttl, entry.TTL);
Assert.IsNull(set[i]);
}
//--- Methods ---
protected override Yield Start(XDoc config, Result result)
{
yield return(Coroutine.Invoke(base.Start, config, new Result()));
// are we a private storage service?
_private = config["sid"].Contents == "sid://mindtouch.com/2007/07/dream/storage.private";
_log.DebugFormat("storage is {0}", _private ? "private" : "public");
// is the root blocked from access?
_privateRoot = config["private-root"].AsBool.GetValueOrDefault();
_log.DebugFormat("storage root is {0}accessible", _privateRoot ? "not " : "");
_expirationEntries = new ExpiringHashSet <string>(TimerFactory);
_expirationEntries.EntryExpired += OnDelete;
// check if folder exists
_path = Environment.ExpandEnvironmentVariables(config["folder"].Contents);
_log.DebugFormat("storage path: {0}", _path);
if (!Path.IsPathRooted(_path))
{
throw new ArgumentException(string.Format("storage path must be absolute: {0}", _path));
}
// make sure path ends with a '\' as it makes processing simpler later on
if ((_path.Length != 0) && ((_path[_path.Length - 1] != '/') || (_path[_path.Length - 1] != '\\')))
{
_path += Path.DirectorySeparatorChar;
}
if (!_private && !Directory.Exists(_path))
{
throw new ArgumentException(string.Format("storage path does not exist: {0}", _path));
}
// Fire off meta data scanning
AsyncUtil.Fork(ScanMetaData);
result.Return();
}
public void Can_reset_expiration()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var i = 42;
var ttl = TimeSpan.FromSeconds(2);
ExpiringHashSet <int> .Entry entry = null;
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.SetOrUpdate(i, ttl);
Assert.IsTrue(changed.WaitOne(500));
changed.Reset();
Thread.Sleep(500);
Assert.IsFalse(expired.WaitOne(500));
var oldExpire = set[i].When;
set.RefreshExpiration(i);
Assert.Greater(set[i].When, oldExpire);
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
}
public void Set_will_fire_in_order_of_expirations()
{
var expired = new ManualResetEvent(false);
var entries = new List<int>();
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entries.Add(e.Entry.Value); expired.Set(); };
set.SetExpiration(3, TimeSpan.FromMilliseconds(1600));
set.SetExpiration(2, TimeSpan.FromMilliseconds(1500));
set.SetExpiration(5, TimeSpan.FromMilliseconds(3000));
set.SetExpiration(4, TimeSpan.FromMilliseconds(2000));
set.SetExpiration(1, TimeSpan.FromMilliseconds(500));
Assert.IsTrue(expired.WaitOne(1000));
Assert.AreEqual(1, entries.Count);
Assert.IsTrue(Wait.For(() => entries.Count == 5, TimeSpan.FromSeconds(5000)));
Assert.AreEqual(new[] { 1, 2, 3, 4, 5 }, entries.ToArray());
}
public DreamCache(TaskTimerFactory taskTimerFactory, TimeSpan defaultExpiration)
{
_expirationTime = defaultExpiration;
_expirations = new ExpiringHashSet <CacheItem>(taskTimerFactory);
_expirations.EntryExpired += OnExpiration;
}
public void New_item_with_more_recent_expiration_will_fire_at_expected_time()
{
var expired = new ManualResetEvent(false);
var entries = new List<int>();
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entries.Add(e.Entry.Value); expired.Set(); };
var n = 1000;
for(var i = 0; i < n; i++) {
set.SetExpiration(i, TimeSpan.FromMinutes(10));
}
set.SetExpiration(100000, TimeSpan.FromSeconds(2));
Assert.IsTrue(expired.WaitOne(4000));
Assert.AreEqual(1, entries.Count);
Assert.AreEqual(n, set.Count());
}
public void Refresh_in_autoRefresh_only_fires_every_half_second()
{
var k = 42;
var ttl = TimeSpan.FromSeconds(10);
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current, true);
var expireTime = DateTime.UtcNow.AddSeconds(10);
set.SetExpiration(k, expireTime);
var when = set[k].When;
Thread.Sleep(200);
Assert.AreEqual(when, set[k].When);
Thread.Sleep(1000);
Assert.Less(when, set[k].When);
}
public void Clearing_set_releases_all_items()
{
var changed = false;
var ttl = 10.Seconds();
var set = new ExpiringHashSet<string>(TaskTimerFactory.Current);
set.SetExpiration("a", ttl);
set.SetExpiration("b", ttl);
set.SetExpiration("v", ttl);
set.CollectionChanged += (s, e) => changed = true;
Assert.AreEqual(3, set.Count());
Assert.IsFalse(changed);
set.Clear();
Assert.AreEqual(0, set.Count());
Assert.IsTrue(changed);
}
public void Clear_Empty_Set()
{
// http://bugs.developer.mindtouch.com/view.php?id=8739
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
set.Clear();
}
public void Can_set_item_via_when()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var i = 42;
var when = DateTime.UtcNow.AddSeconds(1);
ExpiringHashSet<int>.Entry entry = null;
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.SetExpiration(i, when);
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
Assert.AreEqual(i, entry.Value);
Assert.AreEqual(when, entry.When);
Assert.IsNull(set[i]);
}
public void Can_set_ttl_on_existing_item()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var i = 42;
var ttl = TimeSpan.FromSeconds(10);
ExpiringHashSet<int>.Entry entry = null;
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.SetExpiration(i, ttl);
Assert.IsTrue(changed.WaitOne(2000));
changed.Reset();
Assert.IsFalse(expired.WaitOne(2000));
set.SetExpiration(i, TimeSpan.FromSeconds(1));
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
}
//--- Constructors ---
public Listener(string queuename, Action<AwsSqsMessage> callback, IAwsSqsClient client, TaskTimerFactory timerFactory, TimeSpan interval)
{
_queuename = queuename;
_callback = callback;
_client = client;
_cache = new ExpiringHashSet<string>(timerFactory);
_cacheTimer = ((interval.TotalSeconds * 2 < 60) ? 60 : interval.TotalSeconds * 2 + 1).Seconds();
_pollTimer = timerFactory.New(tt => Coroutine.Invoke(PollSqs, new Result()).WhenDone(r => _pollTimer.Change(interval, TaskEnv.None)), null);
_pollTimer.Change(0.Seconds(), TaskEnv.None);
}
public void Can_iterate_over_items()
{
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
var n = 10;
for(var i = 1; i <= n; i++) {
set.SetExpiration(i, TimeSpan.FromSeconds(i));
}
var items = from x in set select x;
Assert.AreEqual(n, items.Count());
for(var i = 1; i <= n; i++) {
// ReSharper disable AccessToModifiedClosure
Assert.IsTrue((from x in set where x.Value == i && x.TTL == TimeSpan.FromSeconds(i) select x).Any());
// ReSharper restore AccessToModifiedClosure
}
}
public void Clear_Empty_Set()
{
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
set.Clear();
}
public void Can_reset_expiration()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var i = 42;
var ttl = TimeSpan.FromSeconds(2);
ExpiringHashSet<int>.Entry entry = null;
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.SetExpiration(i, ttl);
Assert.IsTrue(changed.WaitOne(500));
changed.Reset();
Thread.Sleep(500);
Assert.IsFalse(expired.WaitOne(500));
var oldExpire = set[i].When;
set.RefreshExpiration(i);
Assert.Greater(set[i].When, oldExpire);
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
}
public void Can_iterate_over_items()
{
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
var n = 10;
for(var i = 1; i <= n; i++) {
set.SetExpiration(i, TimeSpan.FromSeconds(i));
}
var items = from x in set select x;
Assert.AreEqual(n, items.Count());
for(var i = 1; i <= n; i++) {
var j = i;
Assert.IsTrue((from x in set where x.Value == j && x.TTL == TimeSpan.FromSeconds(j) select x).Any());
}
}
protected override Yield Stop(Result result)
{
_expirationEntries.Dispose();
_expirationEntries.EntryExpired -= OnDelete;
_expirationEntries = null;
_path = null;
yield return Coroutine.Invoke(base.Stop, new Result());
result.Return();
}
public void Disposing_set_expires_all_items_before_dispose_returns_but_does_not_trigger_collection_changed()
{
var expired = false;
var changed = false;
var expiredEntries = new List<int>();
var ttl = TimeSpan.FromSeconds(1);
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { expiredEntries.Add(e.Entry.Value); expired = true; };
set.CollectionChanged += (s, e) => { changed = true; };
set.SetExpiration(12, ttl);
set.SetExpiration(21, ttl);
Assert.IsFalse(expired, "expired was triggered");
Assert.IsTrue(changed, "changed wasn't triggered");
changed = false;
set.Dispose();
Assert.IsFalse(changed,"changed was triggered");
Assert.IsTrue(expired, "expired wasn't triggered");
Assert.AreEqual(new[] { 12, 21 },expiredEntries.OrderBy(x =>x).ToArray());
}
public void Can_access_hashset_during_expiration_event()
{
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var i = 42;
var ttl = TimeSpan.FromSeconds(1);
ExpiringHashSet<int>.Entry entry = null;
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => {
entry = e.Entry;
set.RemoveExpiration(e.Entry.Value);
expired.Set();
};
set.CollectionChanged += (s, e) => changed.Set();
set.SetExpiration(i, ttl);
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
Assert.AreEqual(i, entry.Value);
Assert.AreEqual(ttl, entry.TTL);
Assert.IsNull(set[i]);
}
public void Can_set_item_via_ttl()
{
_log.Debug("running test");
var expired = new ManualResetEvent(false);
var changed = new ManualResetEvent(false);
var i = 42;
var ttl = TimeSpan.FromSeconds(1);
ExpiringHashSet<int>.Entry entry = null;
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
set.EntryExpired += (s, e) => { entry = e.Entry; expired.Set(); };
set.CollectionChanged += (s, e) => changed.Set();
set.SetExpiration(i, ttl);
Assert.IsTrue(changed.WaitOne(5000));
Assert.IsTrue(expired.WaitOne(5000));
Assert.AreEqual(i, entry.Value);
Assert.AreEqual(ttl, entry.TTL);
Assert.IsNull(set[i]);
}
public void Can_retrieve_item_checking_ttl()
{
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
var v = 42;
var ttl = TimeSpan.FromSeconds(10);
set.SetExpiration(v, ttl);
var entry = set[v];
Assert.AreEqual(v, entry.Value);
Assert.AreEqual(ttl, entry.TTL);
}
public void Clear_Empty_Set()
{
var set = new ExpiringHashSet <int>(TaskTimerFactory.Current);
set.Clear();
}
//--- Methods ---
protected override Yield Start(XDoc config, Result result)
{
yield return Coroutine.Invoke(base.Start, config, new Result());
// are we a private storage service?
_private = config["sid"].Contents == "sid://mindtouch.com/2007/07/dream/storage.private";
_log.DebugFormat("storage is {0}", _private ? "private" : "public");
// is the root blocked from access?
_privateRoot = config["private-root"].AsBool.GetValueOrDefault();
_log.DebugFormat("storage root is {0}accessible", _privateRoot ? "not " : "");
_expirationEntries = new ExpiringHashSet<string>(TimerFactory);
_expirationEntries.EntryExpired += OnDelete;
// check if folder exists
_path = Environment.ExpandEnvironmentVariables(config["folder"].Contents);
_log.DebugFormat("storage path: {0}", _path);
if(!Path.IsPathRooted(_path)) {
throw new ArgumentException(string.Format("storage path must be absolute: {0}", _path));
}
// make sure path ends with a '\' as it makes processing simpler later on
if((_path.Length != 0) && ((_path[_path.Length - 1] != '/') || (_path[_path.Length - 1] != '\\'))) {
_path += Path.DirectorySeparatorChar;
}
if(!_private && !Directory.Exists(_path)) {
throw new ArgumentException(string.Format("storage path does not exist: {0}", _path));
}
// Fire off meta data scanning
AsyncUtil.Fork(ScanMetaData);
result.Return();
}
public void Can_retrieve_item_checking_when()
{
var set = new ExpiringHashSet<int>(TaskTimerFactory.Current);
var v = 42;
var when = DateTime.UtcNow.AddDays(1);
set.SetExpiration(v, when);
var entry = set[v];
Assert.AreEqual(v, entry.Value);
Assert.AreEqual(when, entry.When);
}
