public void TestAsyncSubHandlerAPI()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
int received = 0;
EventHandler<MsgHandlerEventArgs> h = (sender, args) =>
{
Interlocked.Increment(ref received);
};
using (IAsyncSubscription s = c.SubscribeAsync("foo", h))
{
c.Publish("foo", null);
c.Flush();
Thread.Sleep(500);
}
using (IAsyncSubscription s = c.SubscribeAsync("foo", "bar", h))
{
c.Publish("foo", null);
c.Flush();
Thread.Sleep(500);
}
if (received != 2)
{
Assert.Fail("Received ({0}) != 2", received);
}
}
}
public void TestClosedConnections()
{
IConnection c = new ConnectionFactory().CreateConnection();
ISyncSubscription s = c.SubscribeSync("foo");
c.Close();
// While we can annotate all the exceptions in the test framework,
// just do it manually.
UnitTestUtilities.testExpectedException(
() => { c.Publish("foo", null); },
typeof(NATSConnectionClosedException));
UnitTestUtilities.testExpectedException(
() => { c.Publish(new Msg("foo")); },
typeof(NATSConnectionClosedException));
UnitTestUtilities.testExpectedException(
() => { c.SubscribeAsync("foo"); },
typeof(NATSConnectionClosedException));
UnitTestUtilities.testExpectedException(
() => { c.SubscribeSync("foo"); },
typeof(NATSConnectionClosedException));
UnitTestUtilities.testExpectedException(
() => { c.SubscribeAsync("foo", "bar"); },
typeof(NATSConnectionClosedException));
UnitTestUtilities.testExpectedException(
() => { c.SubscribeSync("foo", "bar"); },
typeof(NATSConnectionClosedException));
UnitTestUtilities.testExpectedException(
() => { c.Request("foo", null); },
typeof(NATSConnectionClosedException));
UnitTestUtilities.testExpectedException(
() => { s.NextMessage(); },
typeof(NATSConnectionClosedException));
UnitTestUtilities.testExpectedException(
() => { s.NextMessage(100); },
typeof(NATSConnectionClosedException));
UnitTestUtilities.testExpectedException(
() => { s.Unsubscribe(); },
typeof(NATSConnectionClosedException));
UnitTestUtilities.testExpectedException(
() => { s.AutoUnsubscribe(1); },
typeof(NATSConnectionClosedException));
}
public void TestBasicReconnectFunctionality()
{
Options opts = utils.DefaultTestOptions;
opts.Url = "nats://localhost:22222";
opts.MaxReconnect = 2;
opts.ReconnectWait = 1000;
Object testLock = new Object();
Object msgLock = new Object();
opts.DisconnectedEventHandler = (sender, args) =>
{
lock (testLock)
{
Monitor.Pulse(testLock);
}
};
opts.ReconnectedEventHandler = (sender, args) =>
{
// NOOP
};
NATSServer ns = utils.CreateServerOnPort(22222);
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
IAsyncSubscription s = c.SubscribeAsync("foo");
s.MessageHandler += (sender, args) =>
{
lock (msgLock)
{
Monitor.Pulse(msgLock);
}
};
s.Start();
c.Flush();
lock (testLock)
{
ns.Shutdown();
Assert.True(Monitor.Wait(testLock, 100000));
}
c.Publish("foo", Encoding.UTF8.GetBytes("Hello"));
// restart the server.
using (ns = utils.CreateServerOnPort(22222))
{
lock (msgLock)
{
c.Flush(50000);
Assert.True(Monitor.Wait(msgLock, 10000));
}
Assert.True(c.Stats.Reconnects == 1);
}
}
}
public void TestCustomObjectSerialization()
{
using (IEncodedConnection c = new ConnectionFactory().CreateEncodedConnection())
{
Object mu = new Object();
SerializationTestObj origObj = new SerializationTestObj();
EventHandler<EncodedMessageEventArgs> eh = (sender, args) =>
{
// Ensure we blow up in the cast
SerializationTestObj so = (SerializationTestObj)args.ReceivedObject;
Assert.IsTrue(so.Equals(origObj));
lock (mu)
{
Monitor.Pulse(mu);
}
};
using (IAsyncSubscription s = c.SubscribeAsync("foo", eh))
{
lock (mu)
{
c.Publish("foo", new SerializationTestObj());
c.Flush();
Monitor.Wait(mu, 1000);
}
}
}
}
public void TestServerAutoUnsub()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
long received = 0;
int max = 10;
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
s.MessageHandler += (sender, arg) =>
{
System.Console.WriteLine("Received msg.");
received++;
};
s.AutoUnsubscribe(max);
s.Start();
for (int i = 0; i < (max * 2); i++)
{
c.Publish("foo", Encoding.UTF8.GetBytes("hello"));
}
c.Flush();
Thread.Sleep(500);
if (received != max)
{
Assert.Fail("Recieved ({0}) != max ({1})",
received, max);
}
Assert.IsFalse(s.IsValid);
}
}
}
private static void NatsSubscribeMethod()
{
using (var c = new NC.ConnectionFactory().CreateEncodedConnection($"http://{Config.DOCKER_MACHINE_IP}:4222"))
{
c.OnDeserialize = Serializer.ProtobufDeserializer <User>;
EventHandler <NC.EncodedMessageEventArgs> eh = (sender, args) =>
{
var user = (User)args.ReceivedObject;
var redisUser = GetUserFromRedis(user.Id.ToString());
Console.WriteLine(new string('*', 10));
Console.WriteLine($"User from NATS: {user}");
Console.WriteLine($"User from REDIS: {redisUser}");
Console.WriteLine($"Are users equal: {user.Equals(redisUser)}");
};
using (var s = c.SubscribeAsync("users", eh))
{
Console.WriteLine("Waiting for a message..");
Console.WriteLine();
while (!string.IsNullOrEmpty(Console.ReadLine()))
{
Thread.Sleep(100);
}
}
}
}
public void TestReplyArg()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
s.MessageHandler += ExpectedReplyHandler;
s.Start();
lock(mu)
{
received = false;
c.Publish("foo", "bar", null);
Monitor.Wait(mu, 5000);
}
}
}
if (!received)
Assert.Fail("Message not received.");
}
public void TestQueueSubsOnReconnect()
{
AutoResetEvent reconnectEvent = new AutoResetEvent(false);
Options opts = reconnectOptions;
IConnection c;
string subj = "foo.bar";
string qgroup = "workers";
opts.ReconnectedEventHandler += (sender, args) =>
{
reconnectEvent.Set();
};
using(NATSServer ns = utils.CreateServerOnPort(22222))
{
c = new ConnectionFactory().CreateConnection(opts);
EventHandler<MsgHandlerEventArgs> eh = (sender, args) =>
{
int seq = Convert.ToInt32(Encoding.UTF8.GetString(args.Message.Data));
lock (results)
{
if (results.ContainsKey(seq) == false)
results.Add(seq, true);
}
};
// Create Queue Subscribers
c.SubscribeAsync(subj, qgroup, eh);
c.SubscribeAsync(subj, qgroup, eh);
c.Flush();
sendAndCheckMsgs(c, subj, 10);
}
// server should stop...
// give the OS time to shut it down.
Thread.Sleep(1000);
// start back up
using (NATSServer ns = utils.CreateServerOnPort(22222))
{
// wait for reconnect
Assert.True(reconnectEvent.WaitOne(6000));
sendAndCheckMsgs(c, subj, 10);
}
}
public void TestLargeMessage()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
int msgSize = 51200;
byte[] msg = new byte[msgSize];
for (int i = 0; i < msgSize; i++)
msg[i] = (byte)'A';
msg[msgSize-1] = (byte)'Z';
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
Object testLock = new Object();
s.MessageHandler += (sender, args) =>
{
lock(testLock)
{
Monitor.Pulse(testLock);
}
Assert.IsTrue(compare(msg, args.Message.Data));
};
s.Start();
c.Publish("foo", msg);
c.Flush(1000);
lock(testLock)
{
Monitor.Wait(testLock, 2000);
}
}
}
}
public void TestLargeSubjectAndReply()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
String subject = "";
for (int i = 0; i < 1024; i++)
{
subject += "A";
}
String reply = "";
for (int i = 0; i < 1024; i++)
{
reply += "A";
}
using (IAsyncSubscription s = c.SubscribeAsync(subject))
{
Object testLock = new Object();
s.MessageHandler += (sender, args) =>
{
if (!subject.Equals(args.Message.Subject))
Assert.Fail("Invalid subject received.");
if (!reply.Equals(args.Message.Reply))
Assert.Fail("Invalid subject received.");
lock (testLock)
{
Monitor.Pulse(testLock);
}
};
s.Start();
c.Publish(subject, reply, null);
c.Flush();
lock (testLock)
{
Assert.IsTrue(Monitor.Wait(testLock, 1000));
}
}
}
}
public void TestSubDelTaskCountBasic()
{
var opts = utils.DefaultTestOptions;
Assert.Throws<ArgumentOutOfRangeException>(
() => { opts.SubscriberDeliveryTaskCount = -1; });
opts.SubscriberDeliveryTaskCount = 2;
using (new NATSServer())
{
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
int s1Count = 0;
int s2Count = 0;
int COUNT = 10;
AutoResetEvent ev1 = new AutoResetEvent(false);
AutoResetEvent ev2 = new AutoResetEvent(false);
IAsyncSubscription s1 = c.SubscribeAsync("foo", (obj, args) =>
{
s1Count++;
if (s1Count == COUNT)
{
ev1.Set();
}
});
IAsyncSubscription s2 = c.SubscribeAsync("bar", (obj, args) =>
{
s2Count++;
if (s2Count >= COUNT)
{
ev2.Set();
}
});
for (int i = 0; i < 10; i++)
{
c.Publish("foo", null);
c.Publish("bar", null);
}
c.Flush();
Assert.True(ev1.WaitOne(10000));
Assert.True(ev2.WaitOne(10000));
s1.Unsubscribe();
Assert.True(s1Count == COUNT);
Assert.True(s2Count == COUNT);
ev2.Reset();
c.Publish("bar", null);
c.Flush();
Assert.True(ev2.WaitOne(10000));
Assert.True(s2Count == COUNT + 1);
s2.Unsubscribe();
}
}
}
public void TestSlowAsyncSubscriber()
{
AutoResetEvent ev = new AutoResetEvent(false);
Options opts = utils.DefaultTestOptions;
opts.SubChannelLength = 100;
using (new NATSServer())
{
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
Object mu = new Object();
s.MessageHandler += (sender, args) =>
{
// block to back us up.
ev.WaitOne(2000);
};
s.Start();
Assert.True(s.PendingByteLimit == Defaults.SubPendingBytesLimit);
Assert.True(s.PendingMessageLimit == Defaults.SubPendingMsgsLimit);
long pml = 100;
long pbl = 1024 * 1024;
s.SetPendingLimits(pml, pbl);
Assert.True(s.PendingByteLimit == pbl);
Assert.True(s.PendingMessageLimit == pml);
for (int i = 0; i < (pml + 100); i++)
{
c.Publish("foo", null);
}
int flushTimeout = 5000;
Stopwatch sw = new Stopwatch();
sw.Start();
c.Flush(flushTimeout);
sw.Stop();
ev.Set();
Assert.False(sw.ElapsedMilliseconds >= flushTimeout,
string.Format("elapsed ({0}) > timeout ({1})",
sw.ElapsedMilliseconds, flushTimeout));
}
}
}
}
public void TestEncodedSerizationOverrides()
{
using (IEncodedConnection c = new ConnectionFactory().CreateEncodedConnection())
{
c.OnDeserialize = deserializeFromXML;
c.OnSerialize = serializeToXML;
Object mu = new Object();
SerializationTestObj origObj = new SerializationTestObj();
origObj.a = 99;
EventHandler<EncodedMessageEventArgs> eh = (sender, args) =>
{
SerializationTestObj so = (SerializationTestObj)args.ReceivedObject;
Assert.IsTrue(so.Equals(origObj));
lock (mu)
{
Monitor.Pulse(mu);
}
};
using (IAsyncSubscription s = c.SubscribeAsync("foo", eh))
{
lock (mu)
{
c.Publish("foo", origObj);
c.Flush();
Monitor.Wait(mu, 1000);
}
}
}
}
public void TestStats()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
byte[] data = Encoding.UTF8.GetBytes("The quick brown fox jumped over the lazy dog");
int iter = 10;
for (int i = 0; i < iter; i++)
{
c.Publish("foo", data);
}
c.Flush(1000);
IStatistics stats = c.Stats;
Assert.AreEqual(iter, stats.OutMsgs);
Assert.AreEqual(iter * data.Length, stats.OutBytes);
c.ResetStats();
// Test both sync and async versions of subscribe.
IAsyncSubscription s1 = c.SubscribeAsync("foo");
s1.MessageHandler += (sender, arg) => { };
s1.Start();
ISyncSubscription s2 = c.SubscribeSync("foo");
for (int i = 0; i < iter; i++)
{
c.Publish("foo", data);
}
c.Flush(1000);
stats = c.Stats;
Assert.AreEqual(2 * iter, stats.InMsgs);
Assert.AreEqual(2 * iter * data.Length, stats.InBytes);
}
}
public void TestEncodedObjectRequestReply()
{
using (IEncodedConnection c = new ConnectionFactory().CreateEncodedConnection())
{
Object mu = new Object();
SerializationTestObj origObj = new SerializationTestObj();
EventHandler<EncodedMessageEventArgs> eh = (sender, args) =>
{
SerializationTestObj so = (SerializationTestObj)args.ReceivedObject;
Assert.IsTrue(so.Equals(origObj));
String str = "Received";
c.Publish(args.Reply, str);
c.Flush();
lock (mu)
{
Monitor.Pulse(mu);
}
};
using (IAsyncSubscription s = c.SubscribeAsync("foo", eh))
{
Assert.IsTrue("Received".Equals(c.Request("foo", origObj, 1000)));
Assert.IsTrue("Received".Equals(c.Request("foo", origObj)));
}
}
}
public void TestEncodedObjectSerization()
{
using (IEncodedConnection c = new ConnectionFactory().CreateEncodedConnection())
{
String myStr = "value";
Object mu = new Object();
EventHandler<EncodedMessageEventArgs> eh = (sender, args) =>
{
Assert.IsTrue(args.ReceivedObject.Equals(myStr));
lock (mu)
{
Monitor.Pulse(mu);
}
};
using (IAsyncSubscription s = c.SubscribeAsync("foo", eh))
{
lock (mu)
{
for (int i = 0; i < 10; i++)
c.Publish("foo", myStr);
c.Flush();
Monitor.Wait(mu, 1000);
}
}
using (IAsyncSubscription s = c.SubscribeAsync("foo", eh))
{
lock (mu)
{
c.Publish("foo", "bar", myStr);
c.Flush();
Monitor.Wait(mu, 1000);
}
}
}
}
public void TestSubDelTaskCountSlowConsumer()
{
AutoResetEvent errorEv = new AutoResetEvent(false);
var opts = utils.DefaultTestOptions;
opts.SubscriberDeliveryTaskCount = 1;
opts.SubChannelLength = 10;
opts.AsyncErrorEventHandler = (obj, args) => { errorEv.Set(); };
using (new NATSServer())
{
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
AutoResetEvent cbEv = new AutoResetEvent(false);
using (var s = c.SubscribeAsync("foo", (obj, args) =>
{
cbEv.WaitOne();
}))
{
for (int i = 0; i < opts.SubChannelLength * 2; i++)
{
c.Publish("foo", null);
}
c.Flush();
// make sure we hit the error.
Assert.True(errorEv.WaitOne(10000));
// unblock the callback.
cbEv.Set();
}
}
}
}
public void TestSubDelTaskCountScaling()
{
int COUNT = 20000;
var opts = utils.DefaultTestOptions;
opts.SubscriberDeliveryTaskCount = 20;
using (new NATSServer())
{
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
long recvCount = 0;
var subs = new List<IAsyncSubscription>();
EventHandler<MsgHandlerEventArgs> eh = (obj, args) =>
{
Interlocked.Increment(ref recvCount);
};
for (int i = 0; i < COUNT; i++)
{
subs.Add(c.SubscribeAsync("foo", eh));
}
c.Publish("foo", null);
c.Flush();
while (Interlocked.Read(ref recvCount) != (COUNT))
{
Thread.Sleep(100);
}
// ensure we are not creating a thread per subscriber.
Assert.True(Process.GetCurrentProcess().Threads.Count < 500);
subs.ForEach((s) => { s.Unsubscribe(); });
}
}
}
public void TestSubDelTaskCountReconnect()
{
bool disconnected = false;
AutoResetEvent reconnectEv = new AutoResetEvent(false);
var opts = utils.DefaultTestOptions;
opts.SubscriberDeliveryTaskCount = 2;
opts.DisconnectedEventHandler = (obj, args) => { disconnected = true;};
opts.ReconnectedEventHandler = (obj, args) => { reconnectEv.Set(); };
using (var server = new NATSServer())
{
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
long received = 0;
int max = 10;
AutoResetEvent ev = new AutoResetEvent(false);
using (var s = c.SubscribeAsync("foo", (obj, args) =>
{
received++;
if (received == max)
ev.Set();
}))
{
for (int i = 0; i < max / 2; i++)
{
c.Publish("foo", null);
}
c.Flush();
// bounce the server, we should reconnect, then
// be able to receive messages.
server.Bounce(100);
Assert.True(reconnectEv.WaitOne(20000));
Assert.True(disconnected);
for (int i = 0; i < max / 2; i++)
{
c.Publish("foo", null);
}
c.Flush();
Assert.True(ev.WaitOne(10000));
Assert.True(received == max);
}
}
}
}
public void TestRequestNoBody()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
byte[] response = Encoding.UTF8.GetBytes("I will help you.");
s.MessageHandler += (sender, args) =>
{
c.Publish(args.Message.Reply, response);
};
s.Start();
Msg m = c.Request("foo", null, 50000);
if (!compare(m.Data, response))
{
Assert.Fail("Response isn't valid");
}
}
}
}
public void TestAsyncSubscribe()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
asyncSub = s;
s.MessageHandler += CheckReceivedAndValidHandler;
s.Start();
lock (mu)
{
received = false;
c.Publish("foo", omsg);
c.Flush();
Monitor.Wait(mu, 30000);
}
if (!received)
Assert.Fail("Did not receive message.");
}
}
}
public void TestSendAndRecv()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
int received = 0;
int count = 1000;
s.MessageHandler += (sender, args) =>
{
Interlocked.Increment(ref received);
};
s.Start();
for (int i = 0; i < count; i++)
{
c.Publish("foo", null);
}
c.Flush();
Thread.Sleep(500);
if (received != count)
{
Assert.Fail("Received ({0}) != count ({1})", received, count);
}
}
}
}
public void TestAsyncErrHandler()
{
Object subLock = new Object();
object testLock = new Object();
IAsyncSubscription s;
Options opts = ConnectionFactory.GetDefaultOptions();
opts.SubChannelLength = 10;
bool handledError = false;
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
using (s = c.SubscribeAsync("foo"))
{
opts.AsyncErrorEventHandler = (sender, args) =>
{
lock (subLock)
{
if (handledError)
return;
handledError = true;
Assert.IsTrue(args.Subscription == s);
System.Console.WriteLine("Expected Error: " + args.Error);
Assert.IsTrue(args.Error.Contains("Slow"));
// release the subscriber
Monitor.Pulse(subLock);
}
// release the test
lock (testLock) { Monitor.Pulse(testLock); }
};
bool blockedOnSubscriber = false;
s.MessageHandler += (sender, args) =>
{
lock (subLock)
{
if (blockedOnSubscriber)
return;
Console.WriteLine("Subscriber Waiting....");
Assert.IsTrue(Monitor.Wait(subLock, 10000));
Console.WriteLine("Subscriber done.");
blockedOnSubscriber = true;
}
};
s.Start();
lock(testLock)
{
for (int i = 0; i < (opts.SubChannelLength + 100); i++)
{
c.Publish("foo", null);
}
c.Flush(1000);
Assert.IsTrue(Monitor.Wait(testLock, 1000));
}
}
}
}
public void TestUnsubscribe()
{
int count = 0;
int max = 20;
using (IConnection c = new ConnectionFactory().CreateConnection())
{
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
Boolean unsubscribed = false;
asyncSub = s;
//s.MessageHandler += UnsubscribeAfterCount;
s.MessageHandler += (sender, args) =>
{
count++;
System.Console.WriteLine("Count = {0}", count);
if (count == max)
{
asyncSub.Unsubscribe();
lock (mu)
{
unsubscribed = true;
Monitor.Pulse(mu);
}
}
};
s.Start();
max = 20;
for (int i = 0; i < max; i++)
{
c.Publish("foo", null, null);
}
Thread.Sleep(100);
c.Flush();
lock (mu)
{
if (!unsubscribed)
{
Monitor.Wait(mu, 5000);
}
}
}
if (count != max)
Assert.Fail("Received wrong # of messages after unsubscribe: {0} vs {1}", count, max);
}
}
public void TestSubDelTaskCountAutoUnsub()
{
var opts = utils.DefaultTestOptions;
opts.SubscriberDeliveryTaskCount = 2;
using (new NATSServer())
{
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
long received = 0;
int max = 10;
AutoResetEvent ev = new AutoResetEvent(false);
using (var s = c.SubscribeAsync("foo", (obj, args) =>
{
received++;
if (received > max)
ev.Set();
}))
{
s.AutoUnsubscribe(max);
for (int i = 0; i < max * 2; i++)
{
c.Publish("foo", null);
}
c.Flush();
// event should never fire.
Assert.False(ev.WaitOne(500));
// double check
Assert.True(received == max);
Assert.False(s.IsValid);
}
}
}
}
public void TestSlowAsyncSubscriber()
{
Options opts = ConnectionFactory.GetDefaultOptions();
opts.SubChannelLength = 10;
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
Object mu = new Object();
s.MessageHandler += (sender, args) =>
{
lock (mu)
{
Console.WriteLine("Subscriber Waiting....");
Assert.IsTrue(Monitor.Wait(mu, 20000));
Console.WriteLine("Subscriber done.");
}
};
s.Start();
for (int i = 0; i < (opts.SubChannelLength + 100); i++)
{
c.Publish("foo", null);
}
int flushTimeout = 1000;
Stopwatch sw = new Stopwatch();
sw.Start();
bool flushFailed = false;
try
{
c.Flush(flushTimeout);
}
catch (Exception)
{
flushFailed = true;
}
sw.Stop();
lock (mu)
{
Monitor.Pulse(mu);
}
if (sw.ElapsedMilliseconds < flushTimeout)
{
Assert.Fail("elapsed ({0}) < timeout ({1})",
sw.ElapsedMilliseconds, flushTimeout);
}
Assert.IsTrue(flushFailed);
}
}
}
public void TestFlushInHandler()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
byte[] response = Encoding.UTF8.GetBytes("I will help you.");
s.MessageHandler += (sender, args) =>
{
try
{
c.Flush();
System.Console.WriteLine("Success.");
}
catch (Exception e)
{
Assert.Fail("Unexpected exception: " + e);
}
lock (mu)
{
Monitor.Pulse(mu);
}
};
s.Start();
lock (mu)
{
c.Publish("foo", Encoding.UTF8.GetBytes("Hello"));
Monitor.Wait(mu);
}
}
}
}
public void TestAsyncSubscriberStarvation()
{
Object waitCond = new Object();
using (IConnection c = new ConnectionFactory().CreateConnection())
{
using (IAsyncSubscription helper = c.SubscribeAsync("helper"),
start = c.SubscribeAsync("start"))
{
helper.MessageHandler += (sender, arg) =>
{
System.Console.WriteLine("Helper");
c.Publish(arg.Message.Reply,
Encoding.UTF8.GetBytes("Hello"));
};
helper.Start();
start.MessageHandler += (sender, arg) =>
{
System.Console.WriteLine("Responsder");
string responseIB = c.NewInbox();
IAsyncSubscription ia = c.SubscribeAsync(responseIB);
ia.MessageHandler += (iSender, iArgs) =>
{
System.Console.WriteLine("Internal subscriber.");
lock (waitCond) { Monitor.Pulse(waitCond); }
};
ia.Start();
c.Publish("helper", responseIB,
Encoding.UTF8.GetBytes("Help me!"));
};
start.Start();
c.Publish("start", Encoding.UTF8.GetBytes("Begin"));
c.Flush();
lock (waitCond)
{
Assert.IsTrue(Monitor.Wait(waitCond, 2000));
}
}
}
}
public void TestAsyncErrHandler()
{
object subLock = new object();
object testLock = new object();
IAsyncSubscription s;
Options opts = utils.DefaultTestOptions;
opts.SubChannelLength = 10;
bool handledError = false;
using (new NATSServer())
{
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
using (s = c.SubscribeAsync("foo"))
{
c.Opts.AsyncErrorEventHandler = (sender, args) =>
{
lock (subLock)
{
if (handledError)
return;
handledError = true;
Assert.True(args.Subscription == s);
Assert.True(args.Error.Contains("Slow"));
// release the subscriber
Monitor.Pulse(subLock);
}
// release the test
lock (testLock) { Monitor.Pulse(testLock); }
};
bool blockedOnSubscriber = false;
s.MessageHandler += (sender, args) =>
{
lock (subLock)
{
if (blockedOnSubscriber)
return;
Assert.True(Monitor.Wait(subLock, 500));
blockedOnSubscriber = true;
}
};
s.Start();
lock (testLock)
{
for (int i = 0; i < (opts.SubChannelLength + 100); i++)
{
c.Publish("foo", null);
}
try
{
c.Flush(1000);
}
catch (Exception)
{
// ignore - we're testing the error handler, not flush.
}
Assert.True(Monitor.Wait(testLock, 1000));
}
}
}
}
}
public void TestAsyncSubscribersOnClose()
{
/// basically tests if the subscriber sub channel gets
/// cleared on a close.
Object waitCond = new Object();
int callbacks = 0;
using (IConnection c = new ConnectionFactory().CreateConnection())
{
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
s.MessageHandler += (sender, args) =>
{
callbacks++;
lock (waitCond)
{
Monitor.Wait(waitCond);
}
};
s.Start();
for (int i = 0; i < 10; i++)
{
c.Publish("foo", null);
}
c.Flush();
Thread.Sleep(500);
c.Close();
lock (waitCond)
{
Monitor.Pulse(waitCond);
}
Thread.Sleep(500);
Assert.IsTrue(callbacks == 1);
}
}
}
public void TestEncodedInvalidObjectSerialization()
{
using (IEncodedConnection c = new ConnectionFactory().CreateEncodedConnection())
{
String myStr = "value";
Object mu = new Object();
bool hitException = false;
EventHandler<EncodedMessageEventArgs> eh = (sender, args) =>
{
// Ensure we blow up in the cast
try
{
Exception invalid = (Exception)args.ReceivedObject;
}
catch (Exception e)
{
hitException = true;
System.Console.WriteLine("Expected exception: " + e.Message);
}
Assert.IsTrue(hitException);
lock (mu)
{
Monitor.Pulse(mu);
}
};
using (IAsyncSubscription s = c.SubscribeAsync("foo", eh))
{
lock (mu)
{
c.Publish("foo", myStr);
c.Flush();
Monitor.Wait(mu, 1000);
}
}
}
}
