public void TestClientAutoUnsub() { using (IConnection c = new ConnectionFactory().CreateConnection()) { long received = 0; int max = 10; using (ISyncSubscription s = c.SubscribeSync("foo")) { s.AutoUnsubscribe(max); for (int i = 0; i < max * 2; i++) { c.Publish("foo", null); } c.Flush(); Thread.Sleep(100); try { while (true) { s.NextMessage(0); received++; } } catch (NATSBadSubscriptionException) { /* ignore */ } Assert.IsTrue(received == max); Assert.IsFalse(s.IsValid); } } }
public void TestReconnectDisallowedFlags() { Options opts = ConnectionFactory.GetDefaultOptions(); opts.Url = "nats://localhost:22222"; opts.AllowReconnect = false; Object testLock = new Object(); opts.ClosedEventHandler = (sender, args) => { lock(testLock) { Monitor.Pulse(testLock); } }; using (NATSServer ns = utils.CreateServerOnPort(22222)) { using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { lock (testLock) { ns.Shutdown(); Assert.IsTrue(Monitor.Wait(testLock, 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); } } }
public void TestServersOption() { IConnection c = null; ConnectionFactory cf = new ConnectionFactory(); Options o = ConnectionFactory.GetDefaultOptions(); o.NoRandomize = true; UnitTestUtilities.testExpectedException( () => { cf.CreateConnection(); }, typeof(NATSNoServersException)); o.Servers = testServers; UnitTestUtilities.testExpectedException( () => { cf.CreateConnection(o); }, typeof(NATSNoServersException)); // Make sure we can connect to first server if running using (NATSServer ns = utils.CreateServerOnPort(1222)) { c = cf.CreateConnection(o); Assert.IsTrue(testServers[0].Equals(c.ConnectedUrl)); c.Close(); } // make sure we can connect to a non-first server. using (NATSServer ns = utils.CreateServerOnPort(1227)) { c = cf.CreateConnection(o); Assert.IsTrue(testServers[5].Equals(c.ConnectedUrl)); c.Close(); } }
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); } } }
void IReqRepImpl.SetupConnection(ClientContextBase ctx) { Original.Options opts = ConnectionUtils.GetDefaultOptions(); var cf = new Original.ConnectionFactory(); ctx.Connection = cf.CreateConnection(opts); }
public void TestConnectionStatus() { IConnection c = new ConnectionFactory().CreateConnection(); Assert.AreEqual(ConnState.CONNECTED, c.State); c.Close(); Assert.AreEqual(ConnState.CLOSED, c.State); }
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 TestSimplePublish() { using (IConnection c = new ConnectionFactory().CreateConnection()) { c.Publish("foo", Encoding.UTF8.GetBytes("Hello World!")); } }
public void Run(string[] args) { Stopwatch sw = null; parseArgs(args); banner(); Options opts = ConnectionFactory.GetDefaultOptions(); opts.Url = url; using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { sw = Stopwatch.StartNew(); for (int i = 0; i < count; i++) { c.Request(subject, payload); } c.Flush(); sw.Stop(); System.Console.Write("Completed {0} requests in {1} seconds ", count, sw.Elapsed.TotalSeconds); System.Console.WriteLine("({0} requests/second).", (int)(count / sw.Elapsed.TotalSeconds)); printStats(c); } }
public void Run(string[] args) { parseArgs(args); banner(); Options opts = ConnectionFactory.GetDefaultOptions(); opts.Url = url; using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { TimeSpan elapsed; if (sync) { elapsed = receiveSyncSubscriber(c); } else { elapsed = receiveAsyncSubscriber(c); } System.Console.Write("Received {0} msgs in {1} seconds ", count, elapsed.TotalSeconds); System.Console.WriteLine("({0} msgs/second).", (int)(count / elapsed.TotalSeconds)); printStats(c); } }
private void connectAndFail(String url) { try { System.Console.WriteLine("Trying: " + url); hitDisconnect = 0; Options opts = ConnectionFactory.GetDefaultOptions(); opts.Url = url; opts.DisconnectedEventHandler += handleDisconnect; IConnection c = new ConnectionFactory().CreateConnection(url); Assert.Fail("Expected a failure; did not receive one"); c.Close(); } catch (Exception e) { if (e.Message.Contains("Authorization")) { System.Console.WriteLine("Success with expected failure: " + e.Message); } else { Assert.Fail("Unexpected exception thrown: " + e); } } finally { if (hitDisconnect > 0) Assert.Fail("The disconnect event handler was incorrectly invoked."); } }
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 Run(string[] args) { parseArgs(args); banner(); Options opts = ConnectionFactory.GetDefaultOptions(); opts.Url = url; replyMsg.Data = Encoding.UTF8.GetBytes("reply"); using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { TimeSpan elapsed; if (sync) { elapsed = receiveSyncSubscriber(c); } else { elapsed = receiveAsyncSubscriber(c); } System.Console.Write("Replied to {0} msgs in {1} seconds ", received, elapsed.TotalSeconds); System.Console.WriteLine("({0} replies/second).", (int)(received / elapsed.TotalSeconds)); printStats(c); } }
public void TestAuthServers() { string[] plainServers = new string[] { "nats://*****:*****@localhost:1224"}; opts.Servers = authServers; using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { Assert.Equal(authServers[1], c.ConnectedUrl); } } }
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 TestCloseDisconnectedHandler() { bool disconnected = false; Object mu = new Object(); Options o = ConnectionFactory.GetDefaultOptions(); o.AllowReconnect = false; o.DisconnectedEventHandler += (sender, args) => { lock (mu) { disconnected = true; Monitor.Pulse(mu); } }; IConnection c = new ConnectionFactory().CreateConnection(o); lock (mu) { c.Close(); Monitor.Wait(mu, 20000); } Assert.IsTrue(disconnected); // now test using. disconnected = false; lock (mu) { using (c = new ConnectionFactory().CreateConnection(o)) { }; Monitor.Wait(mu); } Assert.IsTrue(disconnected); }
public FlowmakerConnection(string natsServerUrl = null) { var factorty = new NC.ConnectionFactory(); _natsOptions = NC.ConnectionFactory.GetDefaultOptions(); _natsOptions.Url = natsServerUrl == null ? "demo.nats.io:4222" : natsServerUrl; _connection = factorty.CreateConnection(_natsOptions); }
public void TestAuthSuccess() { using (NATSServer s = util.CreateServerWithConfig(TestContext, "auth_1222.conf")) { IConnection c = new ConnectionFactory().CreateConnection("nats://*****:*****@localhost:1222"); c.Close(); } }
private static void NatsPublishMethod(User user) { using (var c = new NC.ConnectionFactory().CreateEncodedConnection($"http://{Config.DOCKER_MACHINE_IP}:4222")) { c.OnSerialize = PCTestCommon.Serializer.ProtobufSerializer; c.Publish("users", user); } }
private void ProducingWorker(object state) { var ctx = (MyWorkerContext)state; Original.Options opts = ConnectionUtils.GetDefaultOptions(); var cf = new Original.ConnectionFactory(); using (Original.IConnection conn = cf.CreateConnection(opts)) { Workers.RunPublisher(conn, ctx); } }
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)); }
private bool isNatsServerRunning() { try { IConnection c = new NATS.Client.ConnectionFactory().CreateConnection(); c.Close(); return(true); } catch (Exception) { return(false); } }
private void ConsumingWorker(object state) { var ctx = (MyWorkerContext)state; Original.Options opts = ConnectionUtils.GetDefaultOptions(); var cf = new Original.ConnectionFactory(); using (Original.IConnection conn = cf.CreateConnection(opts)) { Workers.RunParallelPassiveConsumer(conn, ctx, ConsumingAgentCount); //Workers.RunParallelReactiveConsumer(conn, ctx, ConsumingAgentCount); } }
public void TestMultipleClose() { IConnection c = new ConnectionFactory().CreateConnection(); Task[] tasks = new Task[10]; for (int i = 0; i < 10; i++) { tasks[i] = new Task(() => { c.Close(); }); tasks[i].Start(); } Task.WaitAll(tasks); }
public void TestCloseHandler() { bool closed = false; Options o = ConnectionFactory.GetDefaultOptions(); o.ClosedEventHandler += (sender, args) => { closed = true; }; IConnection c = new ConnectionFactory().CreateConnection(o); c.Close(); Assert.IsTrue(closed); // now test using. closed = false; using (c = new ConnectionFactory().CreateConnection(o)) { }; Assert.IsTrue(closed); }
public void TestConnectedServer() { IConnection c = new ConnectionFactory().CreateConnection(); string u = c.ConnectedUrl; if (string.IsNullOrWhiteSpace(u)) Assert.Fail("Invalid connected url {0}.", u); if (!Defaults.Url.Equals(u)) Assert.Fail("Invalid connected url {0}.", u); c.Close(); u = c.ConnectedUrl; if (u != null) Assert.Fail("Url is not null after connection is closed."); }
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); } } } }
public NATSServer(bool verify) { createProcessStartInfo(); p = Process.Start(psInfo); if (verify) { for (int i = 0; i < 10; i++) { try { var c = new ConnectionFactory().CreateConnection(); c.Close(); break; } catch { Thread.Sleep(i * 250); } } } }
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 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 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 = 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 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); } } }
// TODO [TestMethod] public void TestSlowSubscriber() { Options opts = ConnectionFactory.GetDefaultOptions(); opts.SubChannelLength = 10; using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { using (ISyncSubscription s = c.SubscribeSync("foo")) { for (int i =0; i < (opts.SubChannelLength+100); i++) { c.Publish("foo", null); } try { c.Flush(); } catch (Exception ex) { System.Console.WriteLine(ex); if (ex.InnerException != null) System.Console.WriteLine(ex.InnerException); throw ex; } try { s.NextMessage(); } catch (NATSSlowConsumerException) { return; } Assert.Fail("Did not receive an exception."); } } }
public void TestValidSubscriber() { using (IConnection c = new ConnectionFactory().CreateConnection()) { using (ISyncSubscription s = c.SubscribeSync("foo")) { Assert.IsTrue(s.IsValid); try { s.NextMessage(100); } catch (NATSTimeoutException) { } Assert.IsTrue(s.IsValid); s.Unsubscribe(); Assert.IsFalse(s.IsValid); try { s.NextMessage(100); } catch (NATSBadSubscriptionException) { } } } }
public void TestCloseSubRelease() { using (IConnection c = new ConnectionFactory().CreateConnection()) { using (ISyncSubscription s = c.SubscribeSync("foo")) { Stopwatch sw = new Stopwatch(); sw.Start(); try { new Task(() => { Thread.Sleep(100); c.Close(); }).Start(); s.NextMessage(10000); } catch (Exception) { /* ignore */ } sw.Stop(); Assert.IsTrue(sw.ElapsedMilliseconds < 10000); } } }