/// <summary>
/// Unsubscribe subject.
/// </summary>
/// <exception cref="NotImplementedException"></exception>
public void UnSubscribe()
{
if (_connection.State == ConnState.CONNECTED)
{
_subscription.Unsubscribe();
}
}
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();
}
protected override void OnDispose()
{
if (_receiver == null)
{
return;
}
try
{
_receiver.Unsubscribe();
_connection.Close();
}
catch
{
// ignored
}
_receiver = null;
}
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 TestUnsubscribe()
{
int count = 0;
int max = 20;
using (new NATSServer())
{
using (IConnection c = utils.DefaultTestConnection)
{
using (IAsyncSubscription s = c.SubscribeAsync("foo"))
{
Boolean unsubscribed = false;
asyncSub = s;
//s.MessageHandler += UnsubscribeAfterCount;
s.MessageHandler += (sender, args) =>
{
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);
}
}
}
Assert.Equal(max, count);
}
}
}
public static IObservable <MsgHandlerEventArgs> ToObservable(this IAsyncSubscription sub)
{
return(Observable.Create <MsgHandlerEventArgs>(
observer =>
{
EventHandler <MsgHandlerEventArgs> handler = (sender, args) => observer.OnNext(args);
sub.MessageHandler += handler;
sub.Start();
return Disposable.Create(() =>
{
sub.MessageHandler -= handler;
sub.Unsubscribe();
});
}));
}
public void Stop()
{
_heartbeat.Stop();
_molDiscoverySubscription.Unsubscribe();
_molInfoSubscription.Unsubscribe();
_molTargetedInfoSubscription.Unsubscribe();
_molRequestSubscription.Unsubscribe();
_molResponseSubscription.Unsubscribe();
foreach (IAsyncSubscription subscription in _molRequestServiceSubscriptions)
{
subscription.Unsubscribe();
}
_conn.Close();
_logger.LogInformation("NATS Transporter stoped");
}
public bool FlushAndUnsubscribe()
{
try
{
_asyncSubscription?.Unsubscribe();
_connection?.Drain();
_connection?.Close();
return(true);
}
catch (Exception ex)
{
Log.Error($"An error occured when closing connection. Error: {ex}");
return(false);
}
}
public void Dispose()
{
try
{
messageReceived?.Unsubscribe();
messageDisconnect?.Unsubscribe();
// Draining and closing a connection
c?.Drain();
// Closing a connection
c?.Close();
c = null;
}
catch
{
}
}
public Task <bool> ReceiveMessageAsync()
{
Console.WriteLine("======================================================");
Console.WriteLine("Press ENTER key to exit after receiving all the messages of NATS.");
Console.WriteLine("======================================================");
// Create a new connection factory to create
// a connection.
ConnectionFactory cf = new ConnectionFactory();
// Creates a live connection to the default
// NATS Server running locally
_client = cf.CreateConnection(_connectionString);
// Setup an event handler to process incoming messages.
// An anonymous delegate function is used for brevity.
EventHandler <MsgHandlerEventArgs> h = (sender, args) =>
{
// print the message
//Console.WriteLine(args.Message);
var messageBody = Encoding.UTF8.GetString(args.Message.Data);
_saveData.ExecuteQuery(messageBody);
// Here are some of the accessible properties from
// the message:
// args.Message.Data;
// args.Message.Reply;
// args.Message.Subject;
// args.Message.ArrivalSubcription.Subject;
// args.Message.ArrivalSubcription.QueuedMessageCount;
// args.Message.ArrivalSubcription.Queue;
// Unsubscribing from within the delegate function is supported.
// args.Message.ArrivalSubcription.Unsubscribe();
};
// The simple way to create an asynchronous subscriber
// is to simply pass the event in. Messages will start
// arriving immediately.
IAsyncSubscription s = _client.SubscribeAsync(_queueName, h);
Console.ReadLine();
s.Unsubscribe();
return(Task.FromResult(true));
}
public void Run()
{
_subscription = _connection.SubscribeAsync(Const.BrokerRank, (sender, args) =>
{
string message = Encoding.UTF8.GetString(args.Message.Data);
_logger.LogDebug(message);
});
_subscription = _connection.SubscribeAsync(Const.BrokerSimilarity, (sender, args) =>
{
string message = Encoding.UTF8.GetString(args.Message.Data);
_logger.LogDebug(message);
});
_subscription.Start();
Console.WriteLine("Press Enter to exit (EventsLogger)");
Console.ReadLine();
_subscription.Unsubscribe();
_connection.Drain();
_connection.Close();
}
public void TestExtendedReconnectFunctionality()
{
Options opts = reconnectOptions;
Object msgLock = new Object();
AutoResetEvent disconnectedEvent = new AutoResetEvent(false);
AutoResetEvent reconnectedEvent = new AutoResetEvent(false);
opts.DisconnectedEventHandler = (sender, args) =>
{
disconnectedEvent.Set();
};
opts.ReconnectedEventHandler = (sender, args) =>
{
reconnectedEvent.Set();
};
byte[] payload = Encoding.UTF8.GetBytes("bar");
NATSServer ns = utils.CreateServerOnPort(22222);
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
IAsyncSubscription s1 = c.SubscribeAsync("foo");
IAsyncSubscription s2 = c.SubscribeAsync("foobar");
s1.MessageHandler += incrReceivedMessageHandler;
s2.MessageHandler += incrReceivedMessageHandler;
s1.Start();
s2.Start();
received = 0;
c.Publish("foo", payload);
c.Flush();
ns.Shutdown();
// server is stopped here.
Assert.True(disconnectedEvent.WaitOne(20000));
// subscribe to bar while connected.
IAsyncSubscription s3 = c.SubscribeAsync("bar");
s3.MessageHandler += incrReceivedMessageHandler;
s3.Start();
// Unsub foobar while disconnected
s2.Unsubscribe();
c.Publish("foo", payload);
c.Publish("bar", payload);
// server is restarted here...
using (NATSServer ts = utils.CreateServerOnPort(22222))
{
// wait for reconnect
Assert.True(reconnectedEvent.WaitOne(60000));
c.Publish("foobar", payload);
c.Publish("foo", payload);
using (IAsyncSubscription s4 = c.SubscribeAsync("done"))
{
AutoResetEvent doneEvent = new AutoResetEvent(false);
s4.MessageHandler += (sender, args) =>
{
doneEvent.Set();
};
s4.Start();
c.Publish("done", payload);
Assert.True(doneEvent.WaitOne(4000));
}
} // NATSServer
Assert.Equal(4, received);
}
}
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 TestExtendedReconnectFunctionality()
{
Options opts = reconnectOptions;
Object disconnectedLock = new Object();
Object msgLock = new Object();
Object reconnectedLock = new Object();
opts.DisconnectedEventHandler = (sender, args) =>
{
System.Console.WriteLine("Disconnected.");
lock (disconnectedLock)
{
Monitor.Pulse(disconnectedLock);
}
};
opts.ReconnectedEventHandler = (sender, args) =>
{
System.Console.WriteLine("Reconnected.");
lock (reconnectedLock)
{
Monitor.Pulse(reconnectedLock);
}
};
byte[] payload = Encoding.UTF8.GetBytes("bar");
NATSServer ns = utils.CreateServerOnPort(22222);
using (IConnection c = new ConnectionFactory().CreateConnection(opts))
{
IAsyncSubscription s1 = c.SubscribeAsync("foo");
IAsyncSubscription s2 = c.SubscribeAsync("foobar");
s1.MessageHandler += incrReceivedMessageHandler;
s2.MessageHandler += incrReceivedMessageHandler;
s1.Start();
s2.Start();
received = 0;
c.Publish("foo", payload);
c.Flush();
lock (disconnectedLock)
{
ns.Shutdown();
// server is stopped here.
Assert.IsTrue(Monitor.Wait(disconnectedLock, 20000));
}
// subscribe to bar while connected.
IAsyncSubscription s3 = c.SubscribeAsync("bar");
s3.MessageHandler += incrReceivedMessageHandler;
s3.Start();
// Unsub foobar while disconnected
s2.Unsubscribe();
c.Publish("foo", payload);
c.Publish("bar", payload);
// server is restarted here...
using (NATSServer ts = utils.CreateServerOnPort(22222))
{
// wait for reconnect
lock (reconnectedLock)
{
Assert.IsTrue(Monitor.Wait(reconnectedLock, 60000));
}
c.Publish("foobar", payload);
c.Publish("foo", payload);
using (IAsyncSubscription s4 = c.SubscribeAsync("done"))
{
Object doneLock = new Object();
s4.MessageHandler += (sender, args) =>
{
System.Console.WriteLine("Recieved done message.");
lock (doneLock)
{
Monitor.Pulse(doneLock);
}
};
s4.Start();
lock (doneLock)
{
c.Publish("done", payload);
Assert.IsTrue(Monitor.Wait(doneLock, 2000));
}
}
} // NATSServer
if (received != 4)
{
Assert.Fail("Expected 4, received {0}.", received);
}
}
}
/// <inheritdoc />
public void Dispose()
{
_subscription?.Unsubscribe();
_subscription?.Dispose();
_connection?.Dispose();
}
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 Task StopAsync(CancellationToken cancellationToken)
{
subscription.Unsubscribe();
connection.Close();
return(Task.CompletedTask);
}
// it looks like this is the only way to unsubcribe from specific subscription
// this method might be redundant but keeping it just to have all functionalities
public void Unsubscribe(IAsyncSubscription subscription)
{
subscription.Unsubscribe();
}