public void TestExpiredEventsAreDeliveredWhenIncludeExpiredIsTrue()
{
var cache = Client.GetOrCreateCache <int, int>(TestUtils.TestName)
.WithExpiryPolicy(new ExpiryPolicy(TimeSpan.FromMilliseconds(100), null, null));
var events = new ConcurrentQueue <ICacheEntryEvent <int, int> >();
var qry = new ContinuousQueryClient <int, int>(new DelegateListener <int, int>(events.Enqueue))
{
IncludeExpired = true
};
using (cache.QueryContinuous(qry))
{
cache[1] = 2;
TestUtils.WaitForTrueCondition(() => events.Count == 2, 5000);
}
Assert.AreEqual(2, events.Count);
Assert.AreEqual(CacheEntryEventType.Created, events.First().EventType);
Assert.AreEqual(CacheEntryEventType.Expired, events.Last().EventType);
Assert.IsTrue(events.Last().HasValue);
Assert.IsTrue(events.Last().HasOldValue);
Assert.AreEqual(2, events.Last().Value);
Assert.AreEqual(2, events.Last().OldValue);
Assert.AreEqual(1, events.Last().Key);
}
/// <summary>
/// Tests batching behavior.
/// </summary>
private void TestBatches(int keyCount, int bufferSize, TimeSpan interval,
Action <List <int>, ConcurrentQueue <List <int> > > assert)
{
var res = new ConcurrentQueue <List <int> >();
var qry = new ContinuousQueryClient <int, int>
{
Listener = new DelegateBatchListener <int, int>(evts =>
res.Enqueue(evts.Select(e => e.Key).ToList())),
BufferSize = bufferSize,
TimeInterval = interval
};
var cache = Client.GetOrCreateCache <int, int>(TestUtils.TestName);
var server = Ignition.GetIgnite("1");
var serverCache = server.GetCache <int, int>(cache.Name);
// Use primary keys for "remote" node to ensure batching.
// Client is connected to another server node, so it will receive batches as expected.
var keys = TestUtils.GetPrimaryKeys(server, cache.Name).Take(keyCount).ToList();
using (cache.QueryContinuous(qry))
{
keys.ForEach(k => serverCache.Put(k, k));
assert(keys, res);
}
}
public void TestExceptionInFilterIsLoggedAndFilterIsIgnored()
{
var cache = Client.GetOrCreateCache <int, int>(TestUtils.TestName);
var evts = new ConcurrentBag <int>();
var qry = new ContinuousQueryClient <int, int>(new DelegateListener <int, int>(e => evts.Add(e.Key)))
{
Filter = new ExceptionalFilter()
};
using (cache.QueryContinuous(qry))
{
cache[1] = 1;
}
Assert.AreEqual(1, cache[1]);
// Assert: error is logged.
var error = GetLoggers()
.SelectMany(x => x.Entries)
.Where(e => e.Level >= LogLevel.Warn)
.Select(e => e.Message)
.LastOrDefault();
Assert.AreEqual(
"CacheEntryEventFilter failed: javax.cache.event.CacheEntryListenerException: " +
ExceptionalFilter.Error,
error);
// Assert: continuous query event is delivered.
Assert.AreEqual(new[] { 1 }, evts);
}
/// <summary>
/// Writes the continuous query.
/// </summary>
/// <param name="ctx">Request context.</param>
/// <param name="continuousQuery">Query.</param>
private void WriteContinuousQuery(ClientRequestContext ctx, ContinuousQueryClient <TK, TV> continuousQuery)
{
var w = ctx.Writer;
w.WriteInt(continuousQuery.BufferSize);
w.WriteLong((long)continuousQuery.TimeInterval.TotalMilliseconds);
w.WriteBoolean(false); // Include expired.
if (continuousQuery.Filter == null)
{
w.WriteObject <object>(null);
}
else
{
var javaFilter = continuousQuery.Filter as PlatformJavaObjectFactoryProxy;
if (javaFilter != null)
{
w.WriteObject(javaFilter.GetRawProxy());
w.WriteByte(FilterPlatformJava);
}
else
{
var filterHolder = new ContinuousQueryFilterHolder(continuousQuery.Filter, _keepBinary);
w.WriteObject(filterHolder);
w.WriteByte(FilterPlatformDotnet);
}
}
ctx.Socket.ExpectNotifications();
}
public void TestDefaultSettings()
{
var qry = new ContinuousQueryClient <int, int>();
Assert.AreEqual(ContinuousQueryClient.DefaultBufferSize, qry.BufferSize);
Assert.AreEqual(TimeSpan.Zero, qry.TimeInterval);
}
public void TestClientDisconnectRaisesDisconnectedEventOnQueryHandle()
{
ICacheEntryEvent <int, int> lastEvt = null;
var qry = new ContinuousQueryClient <int, int>(
new DelegateListener <int, int>(e => lastEvt = e));
var client = GetClient();
var cache = client.GetOrCreateCache <int, int>(TestUtils.TestName);
var handle = cache.QueryContinuous(qry);
ContinuousQueryClientDisconnectedEventArgs disconnectedEventArgs = null;
handle.Disconnected += (sender, args) =>
{
disconnectedEventArgs = args;
// ReSharper disable once AccessToDisposedClosure (disposed state does not matter)
Assert.AreEqual(handle, sender);
};
cache[1] = 1;
TestUtils.WaitForTrueCondition(() => lastEvt != null);
client.Dispose();
// Assert: disconnected event has been raised.
TestUtils.WaitForTrueCondition(() => disconnectedEventArgs != null);
Assert.IsNotNull(disconnectedEventArgs.Exception);
StringAssert.StartsWith("Cannot access a disposed object", disconnectedEventArgs.Exception.Message);
// Multiple dispose is allowed.
handle.Dispose();
handle.Dispose();
}
public void TestContinuousQueryWithKeepBinaryPassesBinaryObjectsToListenerAndFilter()
{
var cache = Client.GetOrCreateCache <int, Person>(TestUtils.TestName);
var binCache = cache.WithKeepBinary <int, IBinaryObject>();
var evts = new ConcurrentBag <IBinaryObject>();
var qry = new ContinuousQueryClient <int, IBinaryObject>
{
Listener = new DelegateListener <int, IBinaryObject>(e => evts.Add(e.Value)),
Filter = new EvenIdBinaryFilter()
};
using (binCache.QueryContinuous(qry))
{
cache[2] = new Person(2);
cache[3] = new Person(3);
TestUtils.WaitForTrueCondition(() => !evts.IsEmpty);
}
// Listener should receive one event with an even id.
var binObj = evts.Single();
Assert.IsNotNull(binObj);
Assert.AreEqual(2, binObj.GetField <int>("Id"));
Assert.AreEqual("Person 2", binObj.GetField <string>("Name"));
// Filter has received both events, last one was filtered out.
binObj = EvenIdBinaryFilter.LastValue;
Assert.IsNotNull(binObj);
Assert.AreEqual(3, binObj.GetField <int>("Id"));
Assert.AreEqual("Person 3", binObj.GetField <string>("Name"));
}
public void TestContinuousQueryWithCustomObjects()
{
var cache = Client.GetOrCreateCache <int, Person>(TestUtils.TestName);
var evts = new ConcurrentBag <Person>();
var qry = new ContinuousQueryClient <int, Person>
{
Listener = new DelegateListener <int, Person>(e => evts.Add(e.Value)),
Filter = new EvenIdFilter()
};
using (cache.QueryContinuous(qry))
{
cache[2] = new Person(2);
cache[3] = new Person(3);
TestUtils.WaitForTrueCondition(() => !evts.IsEmpty);
}
// Listener should receive one event with an even id.
var obj = evts.Single();
Assert.IsNotNull(obj);
Assert.AreEqual(2, obj.Id);
Assert.AreEqual("Person 2", obj.Name);
// Filter has received both events, last one was filtered out.
obj = EvenIdFilter.LastValue;
Assert.IsNotNull(obj);
Assert.AreEqual(3, obj.Id);
Assert.AreEqual("Person 3", obj.Name);
}
/** <inheritDoc /> */
public IContinuousQueryHandleClient QueryContinuous(ContinuousQueryClient <TK, TV> continuousQuery)
{
IgniteArgumentCheck.NotNull(continuousQuery, "continuousQuery");
IgniteArgumentCheck.NotNull(continuousQuery.Listener, "continuousQuery.Listener");
return(QueryContinuousInternal(continuousQuery));
}
public void TestContinuousQueryWithFilterReceivesOnlyMatchingEvents()
{
var cache = Client.GetOrCreateCache <int, int>(TestUtils.TestName);
ICacheEntryEvent <int, int> lastEvt = null;
var listener = new DelegateListener <int, int>(e => lastEvt = e);
var qry = new ContinuousQueryClient <int, int>(listener)
{
Filter = new OddKeyFilter()
};
using (cache.QueryContinuous(qry))
{
cache.Put(0, 0);
TestUtils.WaitForTrueCondition(() => OddKeyFilter.LastKey == 0);
Assert.IsNull(lastEvt);
cache.Put(5, 5);
TestUtils.WaitForTrueCondition(() => OddKeyFilter.LastKey == 5);
TestUtils.WaitForTrueCondition(() => lastEvt != null);
Assert.IsNotNull(lastEvt);
Assert.AreEqual(5, lastEvt.Key);
cache.Put(8, 8);
TestUtils.WaitForTrueCondition(() => OddKeyFilter.LastKey == 8);
Assert.AreEqual(5, lastEvt.Key);
}
}
public void TestComputeWorksWhenContinuousQueryIsActive()
{
var cache = Client.GetOrCreateCache <int, int>(TestUtils.TestName);
var receivedKeysAll = new ConcurrentBag <int>();
var receivedKeysOdd = new ConcurrentBag <int>();
var qry1 = new ContinuousQueryClient <int, int>
{
Listener = new DelegateListener <int, int>(e => receivedKeysOdd.Add(e.Key)),
Filter = new OddKeyFilter()
};
var qry2 = new ContinuousQueryClient <int, int>
{
Listener = new DelegateListener <int, int>(e => receivedKeysAll.Add(e.Key)),
};
var cts = new CancellationTokenSource();
var computeRunnerTask = Task.Factory.StartNew(() =>
{
while (!cts.IsCancellationRequested)
{
var res = Client.GetCompute().ExecuteJavaTask <int>(
ComputeApiTest.EchoTask, ComputeApiTest.EchoTypeInt);
Assert.AreEqual(1, res);
}
}, cts.Token);
var keys = Enumerable.Range(1, 10000).ToArray();
using (cache.QueryContinuous(qry1))
using (cache.QueryContinuous(qry2))
{
foreach (var key in keys)
{
cache[key] = key;
}
}
cts.Cancel();
computeRunnerTask.Wait();
TestUtils.WaitForTrueCondition(() => receivedKeysAll.Count == keys.Length);
Assert.AreEqual(keys.Length / 2, receivedKeysOdd.Count);
CollectionAssert.AreEquivalent(keys, receivedKeysAll);
CollectionAssert.AreEquivalent(keys.Where(k => k % 2 == 1), receivedKeysOdd);
}
public void TestContinuousQueryCountIsLimitedByMaxCursors()
{
var cache = Client.GetOrCreateCache <int, int>(TestUtils.TestName);
var qry = new ContinuousQueryClient <int, int>(new DelegateListener <int, int>());
var queries = Enumerable.Range(1, MaxCursors).Select(_ => cache.QueryContinuous(qry)).ToList();
var ex = Assert.Throws <IgniteClientException>(() => cache.QueryContinuous(qry));
queries.ForEach(q => q.Dispose());
StringAssert.StartsWith("Too many open cursors", ex.Message);
Assert.AreEqual(ClientStatusCode.TooManyCursors, ex.StatusCode);
}
public void TestContinuousQueryCallsLocalListenerWithCorrectEvent()
{
var cache = Client.GetOrCreateCache <int, int>(TestUtils.TestName);
var events = new List <ICacheEntryEvent <int, int> >();
var qry = new ContinuousQueryClient <int, int>(new DelegateListener <int, int>(events.Add));
using (cache.QueryContinuous(qry))
{
// Create.
cache.Put(1, 1);
TestUtils.WaitForTrueCondition(() => events.Count == 1);
var evt = events.Single();
Assert.AreEqual(CacheEntryEventType.Created, evt.EventType);
Assert.IsFalse(evt.HasOldValue);
Assert.IsTrue(evt.HasValue);
Assert.AreEqual(1, evt.Key);
Assert.AreEqual(1, evt.Value);
// Update.
cache.Put(1, 2);
TestUtils.WaitForTrueCondition(() => events.Count == 2);
evt = events.Last();
Assert.AreEqual(CacheEntryEventType.Updated, evt.EventType);
Assert.IsTrue(evt.HasOldValue);
Assert.IsTrue(evt.HasValue);
Assert.AreEqual(1, evt.Key);
Assert.AreEqual(2, evt.Value);
Assert.AreEqual(1, evt.OldValue);
// Remove.
cache.Remove(1);
TestUtils.WaitForTrueCondition(() => events.Count == 3);
evt = events.Last();
Assert.AreEqual(CacheEntryEventType.Removed, evt.EventType);
Assert.IsTrue(evt.HasOldValue);
Assert.IsTrue(evt.HasValue);
Assert.AreEqual(1, evt.Key);
Assert.AreEqual(2, evt.Value);
Assert.AreEqual(2, evt.OldValue);
}
}
public void TestClientDisconnectDoesNotRaiseDisconnectedEventOnDisposedQueryHandle()
{
var qry = new ContinuousQueryClient <int, int>(new DelegateListener <int, int>());
var client = GetClient();
var cache = client.GetOrCreateCache <int, int>(TestUtils.TestName);
ContinuousQueryClientDisconnectedEventArgs disconnectedEventArgs = null;
using (var handle = cache.QueryContinuous(qry))
{
handle.Disconnected += (sender, args) => disconnectedEventArgs = args;
}
client.Dispose();
// Assert: disconnected event has NOT been raised.
Assert.IsNull(disconnectedEventArgs);
}
public void TestMultipleQueriesMultithreaded()
{
var cache = Ignition.GetIgnite().GetOrCreateCache <int, int>(TestUtils.TestName);
cache.Put(1, 0);
var cts = new CancellationTokenSource();
var updaterThread = Task.Factory.StartNew(() =>
{
for (long i = 0; i < long.MaxValue && !cts.IsCancellationRequested; i++)
{
cache.Put(1, (int)i);
}
});
var clientCache = Client.GetCache <int, int>(cache.Name);
TestUtils.RunMultiThreaded(() =>
{
var evt = new ManualResetEventSlim();
var qry = new ContinuousQueryClient <int, int>
{
Listener = new DelegateListener <int, int>(e =>
{
Assert.AreEqual(1, e.Key);
Assert.AreEqual(CacheEntryEventType.Updated, e.EventType);
evt.Set();
})
};
for (var i = 0; i < 200; i++)
{
evt.Reset();
using (clientCache.QueryContinuous(qry))
{
evt.Wait();
}
}
}, 16);
cts.Cancel();
updaterThread.Wait();
}
public static void Main()
{
using (IIgniteClient ignite = Ignition.StartClient(Utils.GetThinClientConfiguration()))
{
Console.WriteLine();
Console.WriteLine(">>> Cache continuous query example started.");
var cache = ignite.GetOrCreateCache <int, string>(CacheName);
// Clean up caches on all nodes before run.
cache.Clear();
const int keyCnt = 20;
for (int i = 0; i < keyCnt; i++)
{
cache.Put(i, i.ToString());
}
var qry = new ContinuousQueryClient <int, string>
{
Listener = new Listener <string>(),
Filter = new ContinuousQueryFilter(15)
};
// Create new continuous query.
using (cache.QueryContinuous(qry))
{
// Add a few more keys and watch more query notifications.
for (var i = keyCnt; i < keyCnt + 5; i++)
{
cache.Put(i, i.ToString());
}
// Wait for a while while callback is notified about remaining puts.
Thread.Sleep(2000);
}
}
Console.WriteLine();
Console.WriteLine(">>> Example finished, press any key to exit ...");
Console.ReadKey();
}
public void TestContinuousQueryWithJavaFilterReceivesOnlyMatchingEvents()
{
var cache = Client.GetOrCreateCache <int, int>(TestUtils.TestName);
var evts = new ConcurrentBag <int>();
var listener = new DelegateListener <int, int>(e => evts.Add(e.Key));
var qry = new ContinuousQueryClient <int, int>(listener)
{
Filter = new JavaObject("org.apache.ignite.platform.PlatformCacheEntryEvenKeyEventFilter", null)
.ToCacheEntryEventFilter <int, int>()
};
using (cache.QueryContinuous(qry))
{
cache.PutAll(Enumerable.Range(1, 5).ToDictionary(x => x, x => x));
}
TestUtils.WaitForTrueCondition(() => evts.Count == 2);
CollectionAssert.AreEquivalent(new[] { 2, 4 }, evts);
}
public void TestIncludeExpiredIsFalseByDefaultAndExpiredEventsAreSkipped()
{
var cache = Client.GetOrCreateCache <int, int>(TestUtils.TestName)
.WithExpiryPolicy(new ExpiryPolicy(TimeSpan.FromMilliseconds(100), null, null));
var events = new ConcurrentQueue <ICacheEntryEvent <int, int> >();
var qry = new ContinuousQueryClient <int, int>(new DelegateListener <int, int>(events.Enqueue));
Assert.IsFalse(qry.IncludeExpired);
using (cache.QueryContinuous(qry))
{
cache[1] = 2;
TestUtils.WaitForTrueCondition(() => !cache.ContainsKey(1), 5000);
cache[2] = 3;
}
Assert.AreEqual(2, events.Count);
Assert.AreEqual(CacheEntryEventType.Created, events.First().EventType);
Assert.AreEqual(CacheEntryEventType.Created, events.Last().EventType);
}
/// <summary>
/// Starts the continuous query.
/// </summary>
private ClientContinuousQueryHandle QueryContinuousInternal(
ContinuousQueryClient <TK, TV> continuousQuery)
{
Debug.Assert(continuousQuery != null);
Debug.Assert(continuousQuery.Listener != null);
var listener = continuousQuery.Listener;
return(DoOutInOp(
ClientOp.QueryContinuous,
ctx => WriteContinuousQuery(ctx, continuousQuery),
ctx =>
{
var queryId = ctx.Stream.ReadLong();
var qryHandle = new ClientContinuousQueryHandle(ctx.Socket, queryId);
ctx.Socket.AddNotificationHandler(queryId,
(stream, err) => HandleContinuousQueryEvents(stream, err, listener, qryHandle));
return qryHandle;
}));
}
public IContinuousQueryHandleClient QueryContinuous(ContinuousQueryClient <TK, TV> continuousQuery)
{
throw new NotImplementedException();
}
