private void PublishBeacon(int port)
{
var transmit = BeaconMessage(port);
if (_interval == TimeSpan.Zero)
{
// Use default
_beacon.Publish(transmit);
}
else
{
_beacon.Publish(transmit, _interval);
}
}
private void RunActor(PairSocket shim)
{
_shim = shim;
using (_subscriber = new SubscriberSocket())
using (_publisher = new PublisherSocket())
{
using (_beacon = new NetMQBeacon())
{
_shim.ReceiveReady += OnShimReady;
_subscriber.Subscribe(string.Empty);
_port = _subscriber.BindRandomPort("tcp://*");
_logger?.LogInformation($"{_id}: Peer bus is bound to {{BusPort}}", _port);
_subscriber.ReceiveReady += OnSubscriberReady;
_logger?.LogInformation($"{_id}: Peer is broadcasting UDP on port {{BeaconPort}}", _beaconPort);
_beacon.Configure(_beaconPort);
_beacon.Publish(_port.ToString(), _beaconInterval);
_beacon.Subscribe(string.Empty);
_beacon.ReceiveReady += OnBeaconReady;
var cleanupTimer = new NetMQTimer(_cleanupInterval);
cleanupTimer.Elapsed += Cleanup;
_poll = new NetMQPoller {
_shim, _subscriber, _beacon, cleanupTimer
};
_shim.SignalOK();
_poll.Run();
}
}
}
public void Polling()
{
using (var speaker = new NetMQBeacon())
using (var listener = new NetMQBeacon())
{
speaker.Configure(9999);
speaker.Publish("Hello", s_publishInterval);
var manualResetEvent = new ManualResetEvent(false);
listener.Configure(9999);
listener.Subscribe("H");
string message = "";
listener.ReceiveReady += (sender, args) =>
{
message = listener.Receive().String;
manualResetEvent.Set();
};
using (var poller = new NetMQPoller {
listener
})
{
poller.RunAsync();
manualResetEvent.WaitOne();
Assert.AreEqual("Hello", message);
}
}
}
public void SimplePublishSubscribe()
{
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQBeacon speaker = new NetMQBeacon(context))
{
speaker.Configure(9999);
Console.WriteLine(speaker.Hostname);
speaker.Publish("Hello");
using (NetMQBeacon listener = new NetMQBeacon(context))
{
listener.Configure(9999);
listener.Subscribe("H");
string peerName;
string message = listener.ReceiveString(out peerName);
Console.WriteLine(peerName);
Assert.AreEqual("Hello", message);
}
}
}
}
public void Unsubscribe()
{
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQBeacon speaker = new NetMQBeacon(context))
{
speaker.Configure(9999);
using (NetMQBeacon listener = new NetMQBeacon(context))
{
listener.Configure(9999);
listener.Subscribe("H");
// this should send one broadcast message and stop
speaker.Publish("Hello");
string peerName;
string message = listener.ReceiveString(out peerName);
listener.Unsubscribe();
Assert.AreEqual("Hello", message);
ISocketPollable socket = listener;
socket.Socket.Options.ReceiveTimeout = TimeSpan.FromSeconds(2);
Assert.Throws <AgainException>(() =>
{
message = listener.ReceiveString(out peerName);
});
}
}
}
}
private void RunActor(PairSocket shim)
{
// save the shim to the class to use later
m_shim = shim;
// create all subscriber, publisher and beacon
using (m_subscriber = new SubscriberSocket())
using (m_publisher = new PublisherSocket())
using (m_beacon = new NetMQBeacon())
{
// listen to actor commands
m_shim.ReceiveReady += OnShimReady;
// subscribe to all messages
m_subscriber.Subscribe("");
// we bind to a random port, we will later publish this port
// using the beacon
m_randomPort = m_subscriber.BindRandomPort("tcp://*");
Console.WriteLine("Bus subscriber is bound to {0}", m_subscriber.Options.LastEndpoint);
// listen to incoming messages from other publishers, forward them to the shim
m_subscriber.ReceiveReady += OnSubscriberReady;
// configure the beacon to listen on the broadcast port
Console.WriteLine("Beacon is being configured to UDP port {0}", m_broadcastPort);
m_beacon.Configure(m_broadcastPort);
// publishing the random port to all other nodes
Console.WriteLine("Beacon is publishing the Bus subscriber port {0}", m_randomPort);
m_beacon.Publish(m_randomPort.ToString(), TimeSpan.FromSeconds(1));
// Subscribe to all beacon on the port
Console.WriteLine("Beacon is subscribing to all beacons on UDP port {0}", m_broadcastPort);
m_beacon.Subscribe("");
// listen to incoming beacons
m_beacon.ReceiveReady += OnBeaconReady;
// Create a timer to clear dead nodes
NetMQTimer timer = new NetMQTimer(TimeSpan.FromSeconds(1));
timer.Elapsed += ClearDeadNodes;
// Create and configure the poller with all sockets and the timer
m_poller = new NetMQPoller {
m_shim, m_subscriber, m_beacon, timer
};
// signal the actor that we finished with configuration and
// ready to work
m_shim.SignalOK();
// polling until cancelled
m_poller.Run();
}
}
public void Start()
{
Initialize();
if (IsRunning)
{
return;
}
_beacon.Subscribe("");
_beacon.Publish(_selfNode.Serialize(), TimeSpan.FromSeconds(1));
timer = new NetMQTimer(TimeSpan.FromSeconds(1));
timer.Elapsed += ClearDeadNodes;
_poller = new NetMQPoller {
_beacon, timer
};
_poller.RunAsync();
}
public void SubscribeToDifferentTopic()
{
using (var speaker = new NetMQBeacon())
using (var listener = new NetMQBeacon())
{
speaker.Configure(9999);
listener.Configure(9999);
listener.Subscribe("B");
// this should send one broadcast message and stop
speaker.Publish("Hello", s_publishInterval);
Assert.IsFalse(listener.TryReceive(TimeSpan.FromMilliseconds(300), out BeaconMessage message));
}
}
public void BothSpeakerAndListenerOverLoopback()
{
using (var beacon1 = new NetMQBeacon())
using (var beacon2 = new NetMQBeacon())
{
beacon1.Configure(9998, "loopback");
beacon1.Publish("H1", s_publishInterval);
beacon1.Subscribe("H");
beacon2.Configure(9998, "loopback");
beacon2.Publish("H2", s_publishInterval);
beacon2.Subscribe("H");
Assert.AreEqual("H2", beacon1.Receive().String);
Assert.AreEqual("H1", beacon2.Receive().String);
}
}
public void SimplePublishSubscribe()
{
using (var speaker = new NetMQBeacon())
using (var listener = new NetMQBeacon())
{
speaker.Configure(9999);
speaker.Publish("Hello", s_publishInterval);
listener.Configure(9999);
listener.Subscribe("H");
var message = listener.Receive();
Assert.AreEqual("Hello", message.String);
}
}
public void BothSpeakerAndListenerOverLoopback()
{
using (var beacon1 = new NetMQBeacon())
using (var beacon2 = new NetMQBeacon())
{
beacon1.Configure(9998, "loopback");
beacon1.Publish("H1", s_publishInterval);
beacon1.Subscribe("H");
beacon2.Configure(9998, "loopback");
beacon2.Publish("H2", s_publishInterval);
beacon2.Subscribe("H");
Assert.AreEqual("H2", beacon1.Receive().String);
Assert.AreEqual("H1", beacon2.Receive().String);
}
}
public void ConfigureTwice()
{
using (var speaker = new NetMQBeacon())
using (var listener = new NetMQBeacon())
{
speaker.Configure(5555);
speaker.Configure(9999);
speaker.Publish("Hello", s_publishInterval);
listener.Configure(9999);
listener.Subscribe("H");
string message = listener.Receive().String;
Assert.AreEqual("Hello", message);
}
}
public void ConfigureTwice()
{
using (var speaker = new NetMQBeacon())
using (var listener = new NetMQBeacon())
{
speaker.Configure(5555);
speaker.Configure(9999);
speaker.Publish("Hello", s_publishInterval);
listener.Configure(9999);
listener.Subscribe("H");
string message = listener.Receive().String;
Assert.AreEqual("Hello", message);
}
}
public void SubscribeToDifferentTopic()
{
using (var context = NetMQContext.Create())
using (var speaker = new NetMQBeacon(context))
using (var listener = new NetMQBeacon(context))
{
speaker.Configure(9999);
listener.Configure(9999);
listener.Subscribe("B");
// this should send one broadcast message and stop
speaker.Publish("Hello", s_publishInterval);
string peerName;
string message;
Assert.IsFalse(listener.TryReceiveString(TimeSpan.FromMilliseconds(300), out peerName, out message));
}
}
public void SimplePublishSubscribe()
{
using (var speaker = new NetMQBeacon())
using (var listener = new NetMQBeacon())
{
speaker.Configure(9999);
speaker.Publish("Hello", s_publishInterval);
listener.Configure(9999);
listener.Subscribe("H");
var message = listener.Receive();
Console.WriteLine(message.PeerAddress);
Assert.AreEqual("Hello", message.String);
}
}
public void Polling()
{
using (var context = NetMQContext.Create())
using (var speaker = new NetMQBeacon(context))
using (var listener = new NetMQBeacon(context))
{
speaker.Configure(9999);
Console.WriteLine(speaker.Hostname);
speaker.Publish("Hello", s_publishInterval);
var manualResetEvent = new ManualResetEvent(false);
listener.Configure(9999);
listener.Subscribe("H");
string peerName = "";
string message = "";
listener.ReceiveReady += (sender, args) =>
{
message = listener.ReceiveString(out peerName);
manualResetEvent.Set();
};
using (var poller = new Poller(listener)
{
PollTimeout = 10
})
{
poller.PollTillCancelledNonBlocking();
manualResetEvent.WaitOne();
Console.WriteLine(peerName);
Assert.AreEqual("Hello", message);
poller.CancelAndJoin();
}
}
}
public void Polling()
{
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQBeacon speaker = new NetMQBeacon(context))
{
speaker.Configure(9999);
Console.WriteLine(speaker.Hostname);
speaker.Publish("Hello");
using (NetMQBeacon listener = new NetMQBeacon(context))
{
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
listener.Configure(9999);
listener.Subscribe("H");
string peerName = "";
string message = "";
listener.ReceiveReady += (sender, args) =>
{
message = listener.ReceiveString(out peerName);
manualResetEvent.Set();
};
Poller poller = new Poller(listener);
Task t = Task.Factory.StartNew(poller.Start);
manualResetEvent.WaitOne();
Console.WriteLine(peerName);
Assert.AreEqual("Hello", message);
poller.Stop(true);
}
}
}
}
public void Unsubscribe()
{
using (var speaker = new NetMQBeacon())
using (var listener = new NetMQBeacon())
{
speaker.Configure(9999);
listener.Configure(9999);
listener.Subscribe("H");
// this should send one broadcast message and stop
speaker.Publish("Hello", s_publishInterval);
Thread.Sleep(10);
listener.Unsubscribe();
Assert.AreEqual("Hello", listener.Receive().String);
Assert.IsFalse(listener.TryReceive(TimeSpan.FromMilliseconds(300), out BeaconMessage message));
}
}
public void Unsubscribe()
{
using (var speaker = new NetMQBeacon())
using (var listener = new NetMQBeacon())
{
speaker.Configure(9999);
listener.Configure(9999);
listener.Subscribe("H");
// this should send one broadcast message and stop
speaker.Publish("Hello", s_publishInterval);
Thread.Sleep(10);
listener.Unsubscribe();
Assert.AreEqual("Hello", listener.Receive().String);
BeaconMessage message;
Assert.IsFalse(listener.TryReceive(TimeSpan.FromMilliseconds(300), out message));
}
}
public void SimplePublishSubscribe()
{
using (var speaker = new NetMQBeacon())
using (var listener = new NetMQBeacon())
{
speaker.Configure(9999);
Console.WriteLine(speaker.Hostname);
speaker.Publish("Hello", s_publishInterval);
listener.Configure(9999);
listener.Subscribe("H");
string peerName;
string message = listener.ReceiveString(out peerName);
Console.WriteLine(peerName);
Assert.AreEqual("Hello", message);
}
}
public void SimplePublishSubscribe()
{
using (var speaker = new NetMQBeacon())
using (var listener = new NetMQBeacon())
{
speaker.Configure(9999);
Console.WriteLine(speaker.Hostname);
speaker.Publish("Hello", s_publishInterval);
listener.Configure(9999);
listener.Subscribe("H");
string peerName;
string message = listener.ReceiveString(out peerName);
Console.WriteLine(peerName);
Assert.AreEqual("Hello", message);
}
}
public void Polling()
{
using (var context = NetMQContext.Create())
using (var speaker = new NetMQBeacon(context))
using (var listener = new NetMQBeacon(context))
{
speaker.Configure(9999);
Console.WriteLine(speaker.Hostname);
speaker.Publish("Hello");
var manualResetEvent = new ManualResetEvent(false);
listener.Configure(9999);
listener.Subscribe("H");
string peerName = "";
string message = "";
listener.ReceiveReady += (sender, args) =>
{
message = listener.ReceiveString(out peerName);
manualResetEvent.Set();
};
using (var poller = new Poller(listener) { PollTimeout = 10})
{
poller.PollTillCancelledNonBlocking();
manualResetEvent.WaitOne();
Console.WriteLine(peerName);
Assert.AreEqual("Hello", message);
poller.CancelAndJoin();
}
}
}
public void ConfigureTwice()
{
using (var context = NetMQContext.Create())
using (var speaker = new NetMQBeacon(context))
using (var listener = new NetMQBeacon(context))
{
speaker.Configure(5555);
speaker.Configure(9999);
Console.WriteLine(speaker.Hostname);
speaker.Publish("Hello");
listener.Configure(9999);
listener.Subscribe("H");
string peerName;
string message = listener.ReceiveString(out peerName);
Console.WriteLine(peerName);
Assert.AreEqual("Hello", message);
}
}
public void Silence()
{
using (var context = NetMQContext.Create())
using (var speaker = new NetMQBeacon(context))
using (var listener = new NetMQBeacon(context))
{
speaker.Configure(9999);
listener.Configure(9999);
listener.Subscribe("H");
// this should send one broadcast message and stop
speaker.Publish("Hello", s_publishInterval);
Thread.Sleep(10);
speaker.Silence();
string peerName;
Assert.AreEqual("Hello", listener.ReceiveString(out peerName));
string message;
Assert.IsFalse(listener.TryReceiveString(TimeSpan.FromMilliseconds(300), out peerName, out message));
}
}
public void BothSpeakerAndListenerOverLoopback()
{
using (var beacon1 = new NetMQBeacon())
using (var beacon2 = new NetMQBeacon())
{
beacon1.Configure("loopback", 9998);
beacon1.Publish("H1", s_publishInterval);
beacon1.Subscribe("H");
beacon2.Configure("loopback", 9998);
beacon2.Publish("H2", s_publishInterval);
beacon2.Subscribe("H");
string peerName;
string message = beacon1.ReceiveString(out peerName);
Assert.AreEqual("H2", message);
message = beacon2.ReceiveString(out peerName);
Assert.AreEqual("H1", message);
}
}
public void BothSpeakerAndListener()
{
using (NetMQContext context = NetMQContext.Create())
using (NetMQBeacon beacon1 = new NetMQBeacon(context))
using (NetMQBeacon beacon2 = new NetMQBeacon(context))
{
beacon1.Configure(9999);
beacon1.Publish("H1");
beacon1.Subscribe("H");
beacon2.Configure(9999);
beacon2.Publish("H2");
beacon2.Subscribe("H");
string peerName;
string message = beacon1.ReceiveString(out peerName);
Assert.AreEqual("H2", message);
message = beacon2.ReceiveString(out peerName);
Assert.AreEqual("H1", message);
}
}
public void BothSpeakerAndListener()
{
using (var context = NetMQContext.Create())
using (var beacon1 = new NetMQBeacon(context))
using (var beacon2 = new NetMQBeacon(context))
{
beacon1.Configure(9999);
beacon1.Publish("H1", s_publishInterval);
beacon1.Subscribe("H");
beacon2.Configure(9999);
beacon2.Publish("H2", s_publishInterval);
beacon2.Subscribe("H");
string peerName;
string message = beacon1.ReceiveString(out peerName);
Assert.AreEqual("H2", message);
message = beacon2.ReceiveString(out peerName);
Assert.AreEqual("H1", message);
}
}
public void Unsubscribe()
{
using (var context = NetMQContext.Create())
using (var speaker = new NetMQBeacon(context))
using (var listener = new NetMQBeacon(context))
{
speaker.Configure(9999);
listener.Configure(9999);
listener.Subscribe("H");
// this should send one broadcast message and stop
speaker.Publish("Hello");
string peerName;
string message = listener.ReceiveString(out peerName);
listener.Unsubscribe();
Assert.AreEqual("Hello", message);
ISocketPollable socket = listener;
socket.Socket.Options.ReceiveTimeout = TimeSpan.FromSeconds(2);
Assert.Throws<AgainException>(() => { message = listener.ReceiveString(out peerName); });
}
}
public void Silence()
{
using (var context = NetMQContext.Create())
using (var speaker = new NetMQBeacon(context))
using (var listener = new NetMQBeacon(context))
{
speaker.Configure(9999);
listener.Configure(9999);
listener.Subscribe("H");
// this should send one broadcast message and stop
speaker.Publish("Hello", s_publishInterval);
Thread.Sleep(10);
speaker.Silence();
string peerName;
Assert.AreEqual("Hello", listener.ReceiveString(out peerName));
string message;
Assert.IsFalse(listener.TryReceiveString(TimeSpan.FromMilliseconds(300), out peerName, out message));
}
}
public void BothSpeakerAndListenerOverLoopback()
{
using (var beacon1 = new NetMQBeacon())
using (var beacon2 = new NetMQBeacon())
{
beacon1.Configure("loopback", 9998);
beacon1.Publish("H1", s_publishInterval);
beacon1.Subscribe("H");
beacon2.Configure("loopback", 9998);
beacon2.Publish("H2", s_publishInterval);
beacon2.Subscribe("H");
string peerName;
string message = beacon1.ReceiveString(out peerName);
Assert.AreEqual("H2", message);
message = beacon2.ReceiveString(out peerName);
Assert.AreEqual("H1", message);
}
}
public void SubscribeToDifferentTopic()
{
using (var speaker = new NetMQBeacon())
using (var listener = new NetMQBeacon())
{
speaker.Configure(9999);
listener.Configure(9999);
listener.Subscribe("B");
// this should send one broadcast message and stop
speaker.Publish("Hello", s_publishInterval);
BeaconMessage message;
Assert.IsFalse(listener.TryReceive(TimeSpan.FromMilliseconds(300), out message));
}
}
public void Polling()
{
using (var speaker = new NetMQBeacon())
using (var listener = new NetMQBeacon())
{
speaker.Configure(9999);
speaker.Publish("Hello", s_publishInterval);
var manualResetEvent = new ManualResetEvent(false);
listener.Configure(9999);
listener.Subscribe("H");
string message = "";
listener.ReceiveReady += (sender, args) =>
{
message = listener.Receive().String;
manualResetEvent.Set();
};
using (var poller = new NetMQPoller { listener })
{
poller.RunAsync();
manualResetEvent.WaitOne();
Assert.AreEqual("Hello", message);
}
}
}
