private void Run(PairSocket shim)
{
_shim = shim;
using (_publisherSocket = new XPublisherSocket())
{
_publisherSocket.SetWelcomeMessage(WelcomeMessage);
_publisherSocket.Bind(_address);
_publisherSocket.ReceiveReady += DropPublisherSubscriptions;
_heartbeatTimer = new NetMQTimer(_heartbeatInterval);
_heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
if (_receiveTimeout > 0)
{
_receiveTimeoutTimer = new NetMQTimer(1000);
_receiveTimeoutTimer.Enable = false;
_receiveTimeoutTimer.Elapsed += OnReceiveTimeout;;
}
shim.ReceiveReady += OnShimMessage;
// signal the actor that the shim is ready to work
shim.SignalOK();
_poller = new NetMQPoller {
_publisherSocket, shim, _heartbeatTimer, _receiveTimeoutTimer
};
// Polling until poller is cancelled
_poller.Run();
}
}
public static void Run()
{
using (var publisherSocket = new XPublisherSocket())
{
publisherSocket.SetWelcomeMessage("WM");
publisherSocket.Bind("tcp://*:6669");
// we just drop subscriptions
publisherSocket.ReceiveReady += (sender, eventArgs) => publisherSocket.SkipMultipartMessage();
var poller = new NetMQPoller {
publisherSocket
};
// send a message every second
var sendMessageTimer = new NetMQTimer(1000);
poller.Add(sendMessageTimer);
sendMessageTimer.Elapsed +=
(sender, eventArgs) =>
publisherSocket.SendMoreFrame("A").SendFrame(new Random().Next().ToString());
// send heartbeat every two seconds
var heartbeatTimer = new NetMQTimer(2000);
poller.Add(heartbeatTimer);
heartbeatTimer.Elapsed += (sender, eventArgs) => publisherSocket.SendFrame("HB");
poller.Stop();
}
}
public void Start()
{
ManualResetEvent mre = new ManualResetEvent(false);
// NetMQ.Bind to Publish and Subscribe addresses
Task.Factory.StartNew(() =>
{
using (_toSocket = new XPublisherSocket())
using (_fromSocket = new XSubscriberSocket())
{
_toSocket.Bind(_toAddress);
_fromSocket.Bind(_fromAddress);
_proxy = new Proxy(_fromSocket, _toSocket);
mre.Set();
// This method is blocking, so important to set the ManualResetEvent before this.
_proxy.Start();
}
});
// Wait until the message host is actually started before returning
mre.WaitOne(-1);
}
private void ProxyThread()
{
if (_disposeCount != 0)
{
_traces.Debug("IpcEventProxy: disposed before start.");
return;
}
XSubscriberSocket xsub = null;
XPublisherSocket xpub = null;
try
{
xsub = _context.CreateXSubscriberSocket();
xpub = _context.CreateXPublisherSocket();
xsub.Bind(_xSubscriberAddress);
xpub.Bind(_xPublisherAddress);
var xproxy = new Proxy(xpub, xsub, null);
_traces.Debug("IpcEventProxy: started (pub->xsub {0} <=> {1} xpub<-sub)", _xSubscriberAddress, _xPublisherAddress);
xproxy.Start();
_traces.Debug("IpcEventProxy: stopped.");
}
catch (NetMQException ex)
{
if (_disposeCount == 0 && !(ex is TerminatingException))
{
_isFaultedState = true;
_traces.Error(ex, "Error while IpcEventProxy starting or during operation.");
var handler = FaultedState;
if (handler != null)
{
try
{
handler(this, EventArgs.Empty);
}
catch (Exception ex2)
{
_traces.Error(ex2);
}
}
}
}
finally
{
if (xsub != null)
{
_traces.CaptureMqExceptions(xsub.Dispose);
}
if (xpub != null)
{
_traces.CaptureMqExceptions(xpub.Dispose);
}
}
}
protected override Task ExecuteAsync(CancellationToken stoppingToken)
{
xpubSocket.Bind(BusOption.SubscriberAddress);
xsubSocket.Bind(BusOption.PublisherAddress);
this.logger.LogInformation("MQBusService started");
var proxy = new Proxy(xsubSocket, xpubSocket);
return(Task.Run(proxy.Start));
}
private void Work()
{
using (var subscriberSocket = new XSubscriberSocket())
{
subscriberSocket.Bind(_toPublisherEndpoint);
using (var publisherSocket = new XPublisherSocket())
{
publisherSocket.Bind(_toSubscriberEndpoint);
_proxy = new Proxy(subscriberSocket, publisherSocket);
_proxy.Start();
}
}
}
private void Work()
{
using (var subscriberSocket = new SubscriberSocket())
{
subscriberSocket.Options.ReceiveHighWatermark = 1000;
subscriberSocket.SubscribeToAnyTopic();
subscriberSocket.Connect(_toPublisherEndpoint);
using (var publisherSocket = new XPublisherSocket())
{
publisherSocket.Options.XPubVerbose = true;
publisherSocket.Bind(_toSubscribersEndpoint);
using (_poller = new NetMQPoller {
new NetMQTimer(TimeSpan.FromMilliseconds(1)), subscriberSocket, publisherSocket
})
{
subscriberSocket.ReceiveReady += (s, e) =>
{
var message = e.Socket.ReceiveMultipartBytes();
var topic = Encoding.UTF8.GetString(message[0]);
var payload = message[1];
_cache[topic] = payload;
publisherSocket.SendMultipartBytes(message);
};
publisherSocket.ReceiveReady += (s, e) =>
{
var message = e.Socket.ReceiveFrameBytes();
var isSub = message[0] == 1;
var topic = Encoding.UTF8.GetString(message.Skip(1).ToArray());
if (_cache.ContainsKey(topic))
{
publisherSocket.SendMoreFrame(Encoding.UTF8.GetBytes(topic)).SendFrame(_cache[topic]);
}
};
_poller.Run();
}
}
}
}
public void WelcomeMessage()
{
using (var pub = new XPublisherSocket())
using (var sub = new SubscriberSocket())
{
pub.Bind("inproc://welcome");
pub.SetWelcomeMessage("W");
sub.Subscribe("W");
sub.Connect("inproc://welcome");
var subscription = pub.ReceiveFrameBytes();
Assert.AreEqual(subscription[1], (byte)'W');
Assert.AreEqual("W", sub.ReceiveFrameString());
}
}
/// <summary>
/// Starts the external to local message transfering.
/// </summary>
/// <param name="portForSubscribers">The port for local subscribers.</param>
/// <param name="discoveryEndpoints">The endpoints to perform other brokers discovery.</param>
private void StartExternalToLocalTransfer(int portForSubscribers, EndpointsRange discoveryEndpoints)
{
Task.Run(() =>
{
using (var xsubSocket = new XSubscriberSocket())
using (var xpubSocket = new XPublisherSocket())
{
xpubSocket.Bind($"tcp://localhost:{portForSubscribers}");
var dynamicSubscriber = new DynamicSubscriber(xsubSocket, discoveryEndpoints);
dynamicSubscriber.StartDiscovering();
_externalToLocalProxy = new NetMQ.Proxy(xpubSocket, xsubSocket);
_externalToLocalProxy.Start();
}
});
}
public void BroadcastEnabled()
{
using (var pub = new XPublisherSocket())
using (var sub1 = new XSubscriberSocket())
using (var sub2 = new XSubscriberSocket())
{
pub.Bind("inproc://manual");
pub.Options.XPubBroadcast = true;
sub1.Connect("inproc://manual");
sub2.Connect("inproc://manual");
sub1.SendFrame(new byte[] { 1, (byte)'A' });
sub2.SendFrame(new byte[] { 1, (byte)'A' });
var payload = new[] { (byte)42 };
var msg = new Msg();
msg.InitEmpty();
// add prefix 2 to the topic, this indicates a broadcast message and it will not be sent to sub1
sub1.SendFrame(new byte[] { 2, (byte)'A' }, true);
sub1.SendFrame(new byte[] { (byte)42 });
var subscription = pub.ReceiveFrameBytes();
var topic = pub.ReceiveFrameBytes();
var message = pub.ReceiveFrameBytes();
Assert.AreEqual(2, topic[0]);
// we must skip the first byte if we have detected a broadcast message
// the sender of this message is already marked for exclusion
// but the match logic in Send should work with normal topic.
topic = topic.Skip(1).ToArray();
pub.SendFrame(topic, true);
pub.SendFrame(message);
var broadcast2 = sub2.ReceiveFrameBytes();
Assert.IsTrue(broadcast2[0] == 65);
broadcast2 = sub2.ReceiveFrameBytes();
Assert.IsTrue(broadcast2.SequenceEqual(payload));
// this message SHOULD NOT be resent to sub1
var received = sub1.TryReceive(ref msg, System.TimeSpan.FromMilliseconds(500));
Assert.IsFalse(received);
}
}
public void BroadcastDisabled()
{
using (var pub = new XPublisherSocket())
using (var sub1 = new XSubscriberSocket())
using (var sub2 = new XSubscriberSocket())
{
pub.Bind("inproc://manual");
pub.Options.XPubBroadcast = false;
sub1.Connect("inproc://manual");
sub2.Connect("inproc://manual");
Thread.Sleep(50);
sub1.SendFrame(new byte[] { 1, (byte)'A' });
sub2.SendFrame(new byte[] { 1, (byte)'A' });
var payload = new[] { (byte)42 };
var msg = new Msg();
msg.InitEmpty();
sub1.SendFrame(new byte[] { (byte)'A' }, true);
sub1.SendFrame(new byte[] { (byte)42 });
var subscription = pub.ReceiveFrameBytes();
var topic = pub.ReceiveFrameBytes();
var message = pub.ReceiveFrameBytes();
pub.SendFrame(topic, true);
pub.SendFrame(message);
var broadcast2 = sub2.ReceiveFrameBytes();
Assert.IsTrue(broadcast2[0] == 65);
broadcast2 = sub2.ReceiveFrameBytes();
Assert.IsTrue(broadcast2.SequenceEqual(payload));
// sub1 should receive a message normally
var broadcast1 = sub1.ReceiveFrameBytes();
Assert.IsTrue(broadcast1[0] == 65);
broadcast1 = sub1.ReceiveFrameBytes();
Assert.IsTrue(broadcast1.SequenceEqual(payload));
}
}
public void Manual()
{
using (var pub = new XPublisherSocket())
using (var sub = new XSubscriberSocket())
{
pub.Bind("inproc://manual");
pub.Options.ManualPublisher = true;
sub.Connect("inproc://manual");
sub.SendFrame(new byte[] { 1, (byte)'A' });
var subscription = pub.ReceiveFrameBytes();
Assert.AreEqual(subscription[1], (byte)'A');
pub.Subscribe("B");
pub.SendFrame("A");
pub.SendFrame("B");
Assert.AreEqual("B", sub.ReceiveFrameString());
}
}
private void Run(PairSocket shim)
{
using (m_publisherSocket = m_context.CreateXPublisherSocket())
{
m_publisherSocket.SetWelcomeMessage(WelcomeMessage);
m_publisherSocket.Bind(m_address);
m_publisherSocket.ReceiveReady += DropPublisherSubscriptions;
m_heartbeatTimer = new NetMQTimer(HeartbeatInterval);
m_heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
shim.ReceiveReady += OnShimMessage;
// signal the actor that the shim is ready to work
shim.SignalOK();
m_poller = new Poller(m_publisherSocket, shim);
m_poller.AddTimer(m_heartbeatTimer);
// Polling until poller is cancelled
m_poller.PollTillCancelled();
}
}
public void CouldTrackSubscriberIdentityInXPubSocket()
{
using (var pub = new XPublisherSocket())
using (var sub1 = new XSubscriberSocket())
using (var sub2 = new XSubscriberSocket()) {
pub.Bind("inproc://manual");
pub.Options.ManualPublisher = true;
sub1.Connect("inproc://manual");
sub2.Connect("inproc://manual");
Thread.Sleep(50);
sub1.SendFrame(new byte[] { 1, (byte)'A' });
var identity1 = new byte[] { 1 };
var identity2 = new byte[] { 2 };
sub1.SendFrame(new byte[] { (byte)'A' }, true);
sub1.SendFrame(new byte[] { (byte)42 });
var subscription = pub.ReceiveFrameBytes();
// NB Identity must be set before pub.Subscribe/Unsubscribe/Send, because these operations clear a private field with last subscriber
// set identity to sub1
pub.Options.Identity = identity1;
Assert.IsTrue(identity1.SequenceEqual(pub.Options.Identity), "Cannot read identity that was just set");
pub.Subscribe(subscription);
Assert.IsTrue(identity1.SequenceEqual(pub.Options.Identity), "Identity must be kept after Subscribe/Unsubscribe/Send operations (which clear m_lastPipe)");
var topic = pub.ReceiveFrameBytes();
var message = pub.ReceiveFrameBytes();
sub2.SendFrame(new byte[] { 1, (byte)'A' });
sub2.SendFrame(new byte[] { (byte)'A' }, true);
sub2.SendFrame(new byte[] { (byte)43 });
subscription = pub.ReceiveFrameBytes();
// Id of sub2 is not set yet
Assert.IsNull(pub.Options.Identity);
pub.Options.Identity = identity2;
Assert.IsTrue(identity2.SequenceEqual(pub.Options.Identity), "Cannot read identity that was just set");
pub.Subscribe(subscription);
Assert.IsTrue(identity2.SequenceEqual(pub.Options.Identity), "Identity must be kept after Subscribe/Unsubscribe/Send operations (which clear m_lastPipe)");
topic = pub.ReceiveFrameBytes();
message = pub.ReceiveFrameBytes();
sub1.SendFrame(new byte[] { (byte)'A' }, true);
sub1.SendFrame(new byte[] { (byte)44 });
topic = pub.ReceiveFrameBytes();
message = pub.ReceiveFrameBytes();
Assert.IsTrue(identity1.SequenceEqual(pub.Options.Identity), "Identity option must be set to the identity of sub1 here");
sub2.SendFrame(new byte[] { (byte)'A' }, true);
sub2.SendFrame(new byte[] { (byte)45 });
topic = pub.ReceiveFrameBytes();
message = pub.ReceiveFrameBytes();
Assert.IsTrue(identity2.SequenceEqual(pub.Options.Identity), "Identity option must be set to the identity of sub2 here");
}
}
private void Run(PairSocket shim)
{
using (m_publisherSocket = m_context.CreateXPublisherSocket())
{
m_publisherSocket.SetWelcomeMessage(WelcomeMessage);
m_publisherSocket.Bind(m_address);
m_publisherSocket.ReceiveReady += DropPublisherSubscriptions;
m_heartbeatTimer = new NetMQTimer(HeartbeatInterval);
m_heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
shim.ReceiveReady += OnShimMessage;
// signal the actor that the shim is ready to work
shim.SignalOK();
m_poller = new Poller(m_publisherSocket, shim);
m_poller.AddTimer(m_heartbeatTimer);
// Polling until poller is cancelled
m_poller.PollTillCancelled();
}
}
