public void Run()
{
Options opts = CreateClientOptions(clientName, tlsKey, password);
opts.ReconnectedEventHandler += (sender, args) =>
{
Console.WriteLine("Client {0} reconnected.", clientName);
Reconnected = true;
};
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
Console.WriteLine("Client {0} connected.", clientName);
EventHandler <MsgHandlerEventArgs> msgHandler = (sender, cbArgs) =>
{
//NOOP
};
using (IAsyncSubscription s = c.SubscribeAsync(subject, msgHandler))
{
// Go ahead and keep a thread up for stressing the system a bit.
while (true)
{
// always up
Thread.Sleep(250);
}
}
}
}
/// <summary>
/// 消息订阅
/// </summary>
/// <returns></returns>
public bool Subscribe(string topic)
{
bool succeed = false;
try
{
if (CheckConnect())
{
EventHandler <MsgHandlerEventArgs> h = (sender, args) =>
{
byte[] data = args.Message.Data;
string msg = Encoding.UTF8.GetString(data);
_Callback(msg);
// print the message
//Console.WriteLine(args.Message);
};
IAsyncSubscription sAsync = _conn.SubscribeAsync(topic);
sAsync.MessageHandler += h;
sAsync.Start();
sAsyncList.Add(topic, sAsync);
succeed = true;
}
}
catch (Exception ex)
{
LogHelper.Error(typeof(RemoteInfoHelper).FullName, "消息服务订阅消息异常..." + ex.Message);
}
return(succeed);
}
private NATSObservableSubscription(IAsyncSubscription subscription)
{
this.subscription = subscription ?? throw new ArgumentNullException(nameof(subscription));
this.subscription.MessageHandler += OnIncomingMessage;
this.subscription.Start();
}
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 TestAsyncSubscribe()
{
using (new NATSServer())
{
using (IConnection c = utils.DefaultTestConnection)
{
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);
}
Assert.True(received, "Did not receive message.");
}
}
}
}
/// <inheritdoc />
public Task Start(RequestDelegate requestDelegate, CancellationToken cancellationToken)
{
var connection = _connection.CreateConnection(_options.Options);
_log.LogTrace("NATS connected. Subscribing to queue {host}", _options.Server.Host);
_subscription = connection.SubscribeAsync(_options.Server.Host, async(_, args) =>
{
try
{
var context = await _converter.Parse(args, new FeatureCollection());
if (context != null)
{
await requestDelegate(context);
await _responseProcessed.ProcessResponse(args, context, connection);
}
else
{
_log.LogError("Cannot parse context");
}
}
catch (Exception e)
{
_log.LogError(e, $"Nats server not processed request {args.Message.Subject}");
}
});
_log.LogTrace("NATS server subscribed");
return(Task.CompletedTask);
}
public void TestRequest()
{
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);
c.Flush();
};
s.Start();
Msg m = c.Request("foo", Encoding.UTF8.GetBytes("help."),
5000);
if (!compare(m.Data, response))
{
Assert.Fail("Response isn't valid");
}
}
}
}
public void TestEncodedObjectRequestReply()
{
using (new NATSServer())
{
using (IEncodedConnection c = DefaultEncodedConnection)
{
c.OnDeserialize = jsonDeserializer;
c.OnSerialize = jsonSerializer;
JsonObject origObj = new JsonObject("foo");
EventHandler <EncodedMessageEventArgs> eh = (sender, args) =>
{
JsonObject so = (JsonObject)args.ReceivedObject;
Assert.True(so.Equals(origObj));
c.Publish(args.Reply, new JsonObject("Received"));
c.Flush();
};
using (IAsyncSubscription s = c.SubscribeAsync("foo", eh))
{
var jo = (JsonObject)c.Request("foo", origObj, 1000);
Assert.Equal("Received", jo.Value);
jo = (JsonObject)c.Request("foo", origObj, 1000);
Assert.Equal("Received", jo.Value);
}
}
}
}
private Task <QueryNatsAdapter> GetResponse(IEncodedConnection connection, string replySubj,
out IAsyncSubscription subscription)
{
var promise = new TaskCompletionSource <QueryNatsAdapter>();
var completed = 0;
var waitTime = 0;
ThreadPool.QueueUserWorkItem(data =>
{
while (completed == 0)
{
if (waitTime >= 60)
{
promise.SetException(new Exception("Nats connection timeout exceed"));
break;
}
Thread.Sleep(1000);
waitTime++;
}
});
subscription = connection.SubscribeAsync(replySubj,
(sender, args) =>
{
var result = (QueryNatsAdapter)args.ReceivedObject;
promise.SetResult(result);
completed++;
});
return(promise.Task);
}
public void TestEncodedSerizationOverrides()
{
using (new NATSServer())
{
using (IEncodedConnection c = DefaultEncodedConnection)
{
c.OnDeserialize = jsonDeserializer;
c.OnSerialize = jsonSerializer;
AutoResetEvent ev = new AutoResetEvent(false);
JsonObject origObj = new JsonObject("bar");
EventHandler <EncodedMessageEventArgs> eh = (sender, args) =>
{
JsonObject so = (JsonObject)args.ReceivedObject;
Assert.True(so.Equals(origObj));
ev.Set();
};
using (IAsyncSubscription s = c.SubscribeAsync("foo", eh))
{
c.Publish("foo", origObj);
c.Flush();
ev.WaitOne(1000);
}
}
}
}
public void Run()
{
_subscription = _connection.SubscribeAsync(Const.RankProcess, "rank_calculator", (sender, args) =>
{
var id = Encoding.UTF8.GetString(args.Message.Data);
var textKey = Const.TextTitleKey + id;
if (!_redisStorage.IsKeyExist(textKey))
{
_logger.LogWarning("Text key {textKey} doesn't exists", textKey);
return;
}
var text = _redisStorage.Load(textKey);
var rankKey = Const.RankTitleKey + id;
var rank = CalculateRank(text).ToString();
_redisStorage.Store(rankKey, rank);
string message = $"Event: RankCalculated, context id: {id}, rank: {rank}";
_connection.Publish(Const.BrokerRank, Encoding.UTF8.GetBytes(message));
});
_subscription.Start();
Console.WriteLine("Press Enter to exit (RankCalculator)");
Console.ReadLine();
_subscription.Unsubscribe();
_connection.Drain();
_connection.Close();
}
public void TestAsyncSubHandlerAPI()
{
using (new NATSServer())
{
using (IConnection c = utils.DefaultTestConnection)
{
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);
}
Assert.Equal(2, received);
}
}
}
public void TestAsyncSubscribe()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
asyncSub = s;
s.MessageHandler += CheckRecveivedAndValidHandler;
s.Start();
lock (mu)
{
received = false;
c.Publish("foo", omsg);
c.Flush();
Monitor.Wait(mu, 30000);
}
if (!received)
{
Assert.Fail("Did not receive message.");
}
}
}
}
void runPubSub(String testName, long testCount, long testSize)
{
Object pubSubLock = new Object();
bool finished = false;
int subCount = 0;
byte[] payload = generatePayload(testSize);
ConnectionFactory cf = new ConnectionFactory();
Options o = ConnectionFactory.GetDefaultOptions();
o.Url = url;
o.SubChannelLength = 10000000;
o.AsyncErrorEventHandler += (sender, obj) => {
System.Console.WriteLine("Error: " + obj.Error);
};
IConnection subConn = cf.CreateConnection(o);
IConnection pubConn = cf.CreateConnection(url);
IAsyncSubscription s = subConn.SubscribeAsync(subject, (sender, args) =>
{
subCount++;
if (subCount == testCount)
{
lock (pubSubLock)
{
finished = true;
Monitor.Pulse(pubSubLock);
}
}
});
s.SetPendingLimits(10000000, 1000000000);
subConn.Flush();
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < testCount; i++)
{
pubConn.Publish(subject, payload);
}
pubConn.Flush();
lock (pubSubLock)
{
if (!finished)
{
Monitor.Wait(pubSubLock);
}
}
sw.Stop();
PrintResults(testName, sw, testCount, testSize);
pubConn.Close();
subConn.Close();
}
public void TestServerAutoUnsub()
{
using (new NATSServer())
{
using (IConnection c = utils.DefaultTestConnection)
{
long received = 0;
int max = 10;
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
s.MessageHandler += (sender, arg) =>
{
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);
Assert.Equal(max, received);
Assert.False(s.IsValid);
}
}
}
}
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 TestServerAutoUnsub()
{
using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
{
using (IConnection c = Context.OpenConnection(Context.Server1.Port))
{
long received = 0;
int max = 10;
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
s.MessageHandler += (sender, arg) =>
{
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);
Assert.Equal(max, received);
Assert.False(s.IsValid);
}
}
}
}
public void TestBasicReconnectFunctionality()
{
Options opts = Context.GetTestOptions(Context.Server1.Port);
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 = NATSServer.Create(Context.Server1.Port);
using (IConnection c = Context.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 = NATSServer.Create(Context.Server1.Port))
{
lock (msgLock)
{
c.Flush(50000);
Assert.True(Monitor.Wait(msgLock, 10000));
}
Assert.True(c.Stats.Reconnects == 1);
}
}
}
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 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 TestDefaultObjectSerialization()
{
using (new NATSServer())
{
using (IEncodedConnection c = DefaultEncodedConnection)
{
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.True(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 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 async Task StartAsync(CancellationToken cancellationToken)
{
await WrapStarter(() => _connection = _connectionFactory.Get <QueryNatsAdapter>(), cancellationToken);
var queue = _queueFactory.Get();
_subscription = _connection.SubscribeAsync(queue, CreateHandler());
}
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 Subscribe(EventHandler <MsgHandlerEventArgs> handler, IEnumerable <string> listOfTopics)
{
foreach (var topic in listOfTopics)
{
_asyncSubscription = _connection.SubscribeAsync(topic);
_asyncSubscription.MessageHandler += handler;
_asyncSubscription.Start();
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="backoffPolicy">The back off policy to use.</param>
/// <param name="subscription">The suubscription to be processed</param>
/// <param name="logger">The logger to use for reporting issues</param>
protected AbstractBackoffSubscriptionProcessor(
IAsyncBackoffPolicy backoffPolicy,
IAsyncSubscription <T> subscription,
ILogger <AbstractBackoffSubscriptionProcessor <T> > logger)
{
_backoffPolicy = backoffPolicy;
_subscription = subscription;
_logger = logger;
}
public void Receive <T>(string subject, IMessageHandler <T> handler) where T : class
{
CommonConsumer <T> consumer = new CommonConsumer <T>(handler);
using (IEncodedConnection connector = _natsConnectorFactory.GetConnector(defaultNatsURL))
{
IAsyncSubscription s = connector.SubscribeAsync(subject, (sender, args) => { consumer.Process(args); });
}
}
public void Stop()
{
if (subscription != null)
{
subscription.Dispose();
subscription = null;
}
Resource.Service.With(Resource, closeCallback);
}
private static void SubscribeClear()
{
EventHandler <MsgHandlerEventArgs> handler = (sender, args) =>
{
Console.Clear();
};
IAsyncSubscription s = _connection.SubscribeAsync(
"nats.demo.clear", handler);
}
private async Task MonitorProcess()
{
while (!_token.IsCancellationRequested)
{
try
{
bool exSleep;
lock (_lock)
exSleep = _exceptionSleep;
if (exSleep)
{
OnDispose();
Core.Log.Warning("An exception has been thrown, the listener has been stoped for {0} seconds.", Config.RequestOptions.ServerReceiverOptions.SleepOnExceptionInSec);
await Task.Delay(Config.RequestOptions.ServerReceiverOptions.SleepOnExceptionInSec * 1000, _token).ConfigureAwait(false);
lock (_lock)
_exceptionSleep = false;
_connection.Close();
_receiver.Unsubscribe();
_connection = _factory.CreateConnection(Connection.Route);
_receiver = _connection.SubscribeAsync(Connection.Name, MessageHandler);
Core.Log.Warning("The listener has been resumed.");
}
if (Counters.CurrentMessages >= Config.RequestOptions.ServerReceiverOptions.MaxSimultaneousMessagesPerQueue)
{
OnDispose();
Core.Log.Warning("Maximum simultaneous messages per queue has been reached, the message needs to wait to be processed, consider increase the MaxSimultaneousMessagePerQueue value, CurrentValue={0}.", Config.RequestOptions.ServerReceiverOptions.MaxSimultaneousMessagesPerQueue);
while (!_token.IsCancellationRequested && Counters.CurrentMessages >= Config.RequestOptions.ServerReceiverOptions.MaxSimultaneousMessagesPerQueue)
{
await Task.Delay(500, _token).ConfigureAwait(false);
}
_connection.Close();
_receiver.Unsubscribe();
_connection = _factory.CreateConnection(Connection.Route);
_receiver = _connection.SubscribeAsync(Connection.Name, MessageHandler);
Core.Log.Warning("The listener has been resumed.");
}
await Task.Delay(100, _token).ConfigureAwait(false);
}
catch (TaskCanceledException) { }
catch (Exception ex)
{
Core.Log.Write(ex);
if (!_token.IsCancellationRequested)
{
await Task.Delay(2000, _token).ConfigureAwait(false);
}
}
}
}
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 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);
}
}
