public static void Main(string[] args)
{
const int MegaBit = 1024;
const int MegaByte = 1024;
using (var pub = new PublisherSocket())
using (var sub1 = new SubscriberSocket())
using (var sub2 = new SubscriberSocket())
{
pub.Options.MulticastHops = 2;
pub.Options.MulticastRate = 40 * MegaBit; // 40 megabit
pub.Options.MulticastRecoveryInterval = TimeSpan.FromMinutes(10);
pub.Options.SendBuffer = MegaByte * 10; // 10 megabyte
pub.Connect("pgm://224.0.0.1:5555");
sub1.Options.ReceiveBuffer = MegaByte * 10;
sub1.Bind("pgm://224.0.0.1:5555");
sub1.Subscribe("");
sub2.Bind("pgm://224.0.0.1:5555");
sub2.Options.ReceiveBuffer = MegaByte * 10;
sub2.Subscribe("");
Console.WriteLine("Server sending 'Hi'");
pub.SendFrame("Hi", false);
bool more;
Console.WriteLine("sub1 received = '{0}'", sub1.ReceiveFrameString(out more));
Console.WriteLine("sub2 received = '{0}'", sub2.ReceiveFrameString(out more));
}
}
public async Task <XtResult <TMessage> > PublishAsync <TMessage>(TMessage message)
where TMessage : class, new()
{
PublisherSocket publisherSocket = null;
try
{
publisherSocket = new PublisherSocket();
publisherSocket.Connect(_configuration.Address());
return(await Task.Run(() =>
{
try
{
var msg = new PubSubMessage <TMessage>(_configuration, message);
publisherSocket.SendMultipartMessage(msg);
}
catch (System.Exception ex)
{
return XtResult <TMessage> .Failed(ex, "publish");
}
return XtResult <TMessage> .Success(message, "publish");
}));
}
catch (System.Exception ex)
{
return(XtResult <TMessage> .Failed(ex, "publish"));
}
finally
{
publisherSocket?.Dispose();
}
}
public void Start()
{
_messageHost?.Start();
lock (_publishSocketLocker)
{
_publishSocket = new PublisherSocket();
_publishSocket.Connect(_publishAddress);
}
_subscribeThreadCancellation = new CancellationTokenSource();
_pingThreadCancellation = new CancellationTokenSource();
_subscribeThread = new Thread(SubscribeThread)
{
IsBackground = true
};
_subscribeThread.Start();
_pingThread = new Thread(PingThread)
{
IsBackground = true
};
_pingThread.Start();
// Wait until the subscribe thread has actually subscribed before continuing.
// For some reason a "reset event" doesn't work here.
while (!_subscribeThreadRunning)
{
Thread.Sleep(50);
}
}
public ActorPublisher()
{
actor_id = random_string(5);
var context = NetMQContext.Create();
pub = context.CreatePublisherSocket();
pub.Connect("tcp://localhost:5012");
}
private void TaskDataPub(CancellationToken cancelToken, BlockingCollection <object> queue, string address)
{
using (var pubSocket = new PublisherSocket())
{
//pubSocket.Options.SendHighWatermark = 1;
pubSocket.Connect(address);
while (!cancelToken.IsCancellationRequested)
{
if (queue.TryTake(out object data, 500))
{
switch (data.GetType().Name)
{
case "ClientHeartbeat":
pubSocket.Serialise <ClientHeartbeat>(data);
break;
case "ClientPositionUpdate":
pubSocket.Serialise <ClientPositionUpdate>(data);
break;
case "ClientFrequencyUpdate":
pubSocket.Serialise <ClientFrequencyUpdate>(data);
break;
}
}
}
}
taskDataPub = null;
}
public void SetPgmSettings()
{
const int MegaBit = 1024;
const int MegaByte = 1024;
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
pub.Options.MulticastHops = 2;
pub.Options.MulticastRate = 40 * MegaBit; // 40 megabit
pub.Options.MulticastRecoveryInterval = TimeSpan.FromMinutes(10);
pub.Options.SendBuffer = MegaByte * 10; // 10 megabyte
pub.Connect("pgm://224.0.0.1:5555");
sub.Options.ReceiveBuffer = MegaByte * 10;
sub.Bind("pgm://224.0.0.1:5555");
sub.Subscribe("");
pub.SendFrame("Hi");
bool more;
Assert.AreEqual("Hi", sub.ReceiveFrameString(out more));
Assert.IsFalse(more);
Assert.AreEqual(2, pub.Options.MulticastHops);
Assert.AreEqual(40 * MegaBit, pub.Options.MulticastRate);
Assert.AreEqual(TimeSpan.FromMinutes(10), pub.Options.MulticastRecoveryInterval);
Assert.AreEqual(MegaByte * 10, pub.Options.SendBuffer);
Assert.AreEqual(MegaByte * 10, sub.Options.ReceiveBuffer);
}
}
// Client thread which does not block Update()
void NetMQClient()
{
AsyncIO.ForceDotNet.Force();
NetMQConfig.ManualTerminationTakeOver();
NetMQConfig.ContextCreate(true);
//string msg;
var timeout = new System.TimeSpan(0, 0, 1); //1sec
Debug.Log("Connect to the server.");
pubSocket = new PublisherSocket();
pubSocket.Options.ReceiveHighWatermark = 0;
pubSocket.Connect("tcp://192.168.1.122:55556");
bool is_connected = true;
while (is_connected && stop_thread_ == false)
{
pubSocket.TrySendFrame(timeout, final);
}
pubSocket.Close();
Debug.Log("ContextTerminate.");
NetMQConfig.ContextTerminate();
NetMQConfig.Cleanup();
}
private void OnBeaconReady(object sender, NetMQBeaconEventArgs e)
{
var readyTime = DateTimeOffset.Now;
var message = _beacon.Receive();
int.TryParse(message.String, out var port);
var peer = new PeerInfo(message.PeerHost, port);
if (!_info.ContainsKey(peer))
{
_info.Add(peer, readyTime);
_publisher.Connect(peer.Address);
_shim.SendMoreFrame("A").SendFrame(peer.Address);
_logger?.LogInformation($"{_id}: Added new peer from '{{PeerAddress}}'", peer.Address);
_hub?.Clients.All.SendAsync("ReceiveMessage", "success", $"Adding new peer from '{peer.Address}'");
}
else
{
_logger?.LogDebug($"{_id}: Updating keep-alive for peer '{{PeerAddress}}'", peer.Address);
_info[peer] = readyTime;
}
}
public void UseInterface()
{
#if NETCOREAPP1_0
var hostEntry = Dns.GetHostEntryAsync(Dns.GetHostName()).Result;
#else
var hostEntry = Dns.GetHostEntry(Dns.GetHostName());
#endif
string ip = hostEntry.AddressList
.Where(addr => addr.AddressFamily == AddressFamily.InterNetwork)
.Select(addr => addr.ToString())
.FirstOrDefault();
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
pub.Connect($"pgm://{ip};224.0.0.1:5555");
sub.Bind($"pgm://{ip};224.0.0.1:5555");
sub.Subscribe("");
pub.SendFrame("Hi");
bool more;
Assert.AreEqual("Hi", sub.ReceiveFrameString(out more));
Assert.IsFalse(more);
}
}
public void TwoPublishers()
{
using (var pub = new PublisherSocket())
using (var pub2 = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
pub.Connect("pgm://224.0.0.1:5555");
pub2.Connect("pgm://224.0.0.1:5555");
sub.Bind("pgm://224.0.0.1:5555");
sub.Subscribe("");
pub.SendFrame("Hi");
bool more;
Assert.AreEqual("Hi", sub.ReceiveFrameString(out more));
Assert.IsFalse(more);
pub2.SendFrame("Hi2");
Assert.AreEqual("Hi2", sub.ReceiveFrameString(out more));
Assert.IsFalse(more);
}
}
public virtual NetMQSocket Rent()
{
if (_pool.TryDequeue(out var _sender))
{
Interlocked.Decrement(ref _count);
Debug.Assert(_count >= 0);
return(_sender);
}
try
{
switch (_options.Pattern)
{
case NetMQPattern.PushPull:
_sender = new PushSocket();
break;
case NetMQPattern.PubSub:
_sender = new PublisherSocket();
break;
default:
break;
}
_sender.Connect(HostAddress);
}
catch (Exception e)
{
_logger.LogError(e, "ZeroMQ channel model create failed!");
throw;
}
return(_sender);
}
private void mq_test()
{
mq_end = true;
time_cnt = 0;
try
{
using (var publisher = new PublisherSocket())
{
publisher.Connect("tcp://127.0.0.1:5550");
while (mq_end)
{
int x = (int)(100 * Math.Sin(time_cnt));
int y = 0;//(int)obj1;
this.chkPx.Location = new System.Drawing.Point(x + 150, 257 + y);
byte[][] bytes = { Encoding.ASCII.GetBytes("foo"), Encoding.ASCII.GetBytes($"{x}") };
publisher.SendMultipartBytes(bytes);
time_cnt += 0.05;
Thread.Sleep(10);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, this.Text, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public void LargeMessage()
{
using (var pub = new PublisherSocket())
using (var sub = new SubscriberSocket())
{
pub.Connect("pgm://224.0.0.1:5555");
sub.Bind("pgm://224.0.0.1:5555");
sub.Subscribe("");
var data = new byte[3200]; // this should be at least 3 packets
for (Int16 i = 0; i < 1600; i++)
{
Array.Copy(BitConverter.GetBytes(i), 0, data, i * 2, 2);
}
pub.SendFrame(data);
byte[] message = sub.ReceiveFrameBytes();
Assert.AreEqual(3200, message.Length);
for (Int16 i = 0; i < 1600; i++)
{
Assert.AreEqual(i, BitConverter.ToInt16(message, i * 2));
}
}
}
private void OnBeaconReady(object sender, NetMQBeaconEventArgs e)
{
// we got another beacon
// let's check if we already know about the beacon
var message = m_beacon.Receive();
int port;
int.TryParse(message.String, out port);
NodeKey node = new NodeKey(message.PeerHost, port);
// check if node already exist
if (!m_nodes.ContainsKey(node))
{
// we have a new node, let's add it and connect to subscriber
m_nodes.Add(node, DateTime.Now);
m_publisher.Connect(node.Address);
m_shim.SendMoreFrame(AddedNodeCommand).SendFrame(node.Address);
}
else
{
//Console.WriteLine("Node {0} is not a new beacon.", node);
m_nodes[node] = DateTime.Now;
}
}
/// <summary>
/// <para>Constructs a publisher socket.</para>
/// </summary>
/// <param name="address">Address to which to connect (for example: tcp://localhost:9001).</param>
/// <param name="context">ZMQ Context.</param>
/// <param name="verboseLog">Enable tracing of each event published.</param>
/// <param name="traceWriter">Traces</param>
internal Publisher(string address, NetMQContext context, bool verboseLog, ITraceWriter traceWriter)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (string.IsNullOrEmpty(address))
{
throw new ArgumentNullException("address");
}
if (traceWriter == null)
{
throw new ArgumentNullException("traceWriter");
}
_traces = traceWriter;
_verboseLog = verboseLog;
_instanceHashCode = this.GetHashCode();
_socket = context.CreatePublisherSocket();
_socket.Options.SendHighWatermark = 100000;
try
{
_socket.Connect(address);
_traces.Debug("Publisher({0:x}) created ({1}).", _instanceHashCode, address);
}
catch (Exception ex)
{
_traces.Error(ex);
_socket.Dispose();
throw;
}
}
private void OnBeaconReady(object sender, NetMQBeaconEventArgs e)
{
// we got another beacon
// let's check if we already know about the beacon
string nodeName;
int port = Convert.ToInt32(m_beacon.ReceiveString(out nodeName));
// remove the port from the peer name
nodeName = nodeName.Replace(":" + m_broadcastPort, "");
NodeKey node = new NodeKey(nodeName, port);
// check if node already exist
if (!m_nodes.ContainsKey(node))
{
// we have a new node, let's add it and connect to subscriber
m_nodes.Add(node, DateTime.Now);
m_publisher.Connect(node.Address);
m_shim.SendMoreFrame(AddedNodeCommand).SendFrame(node.Address);
}
else
{
//Console.WriteLine("Node {0} is not a new beacon.", node);
m_nodes[node] = DateTime.Now;
}
}
protected override void Run()
{
AsyncIO.ForceDotNet.Force(); // this line is needed to prevent unity freeze after one use, not sure why yet
using (SUB = new SubscriberSocket())
using (PUB = new PublisherSocket())
using (REQ = new RequestSocket()) {
SUB.Connect("tcp://localhost:5555");
SUB.Subscribe("");
PUB.Connect("tcp://localhost:5556");
REQ.Connect("tcp://localhost:5557");
Debug.Log("Connected: Receiving Messages");
while (Running)
{
/*Receive continuos Slicer data*/
string msg = SUB.ReceiveFrameString();
/*Send continuos Unity data*/
var bytes = new byte[dataPackage.t.Length * 4];
System.Buffer.BlockCopy(dataPackage.t, 0, bytes, 0, bytes.Length);
PUB.SendFrame(bytes);
/*Request volume data once*/
if (reqestData)
{
REQ.SendFrame("volume");
string msg2 = REQ.ReceiveFrameString();
Debug.Log(msg2);
byte[] file = System.IO.File.ReadAllBytes(msg2);
Debug.Log(file.Length);
int d1 = System.BitConverter.ToInt32(file, 0);
int d2 = System.BitConverter.ToInt32(file, 4);
int d3 = System.BitConverter.ToInt32(file, 8);
float[] volume = new float[d1 * d2 * d3];
System.Buffer.BlockCopy(file, 12, volume, 0, volume.Length * sizeof(float));
string s = d1 + " " + d2 + " " + d3 + " : ";
//for (int i = 0; i < volume.Length; ++i) s += volume[i] + " ";
Debug.Log(s);
reqestData = false;
}
/*60fps*/
System.Threading.Thread.Sleep(16);
}
SUB.Close();
PUB.Close();
REQ.Close();
}
NetMQConfig.Cleanup();
}
protected override Task RunInternal()
{
_publisherSocket = new PublisherSocket();
_publisherSocket.Connect(_configuration.BrokerEndpoint);
_heartbeatProc = Task.Run(HandleHeartbeat, _cancel.Token);
return Task.CompletedTask;
}
private void createSSocket()
{
clientS = context.CreatePublisherSocket();
string[] srAddrs = cfg.ServerR.Split(',');
foreach (string addr in srAddrs)
{
clientS.Connect(addr);
}
}
protected override Task RunInternal()
{
_heartbeatProc = Task.Run(HandleHeartbeat, _cancel.Token).ConfigureAwait(false);
_publisherSocket = new PublisherSocket();
_publisherSocket.Connect(_configuration.RouterEndpoint);
return(Task.CompletedTask);
}
/// <summary>
/// Default ctor.
/// </summary>
public FeedMuxMessageBroker()
{
context = NetMQContext.Create();
pubSocket = context.CreatePublisherSocket();
pubSocket.Connect(PublisherAddress);
pollerCancelled = new ManualResetEvent(false);
source = new CancellationTokenSource();
token = source.Token;
StartPolling();
}
/// <summary>
/// Starts the publisher, connecting it to specified subscrubers.
/// </summary>
/// <param name="subscribers">The subscribers to connect.</param>
/// <param name="selfIdentity">The self identity.</param>
public void Start(List <IPEndPoint> subscribers, PeerIdentity selfIdentity)
{
_selfIdentity = selfIdentity;
_socket = new PublisherSocket();
foreach (var subscriber in subscribers)
{
_socket.Connect($"tcp://{subscriber.Address}:{subscriber.Port}");
}
}
public void Sending1000Messages()
{
// creating two different context and sending 1000 messages
int count = 0;
var subReady = new ManualResetEvent(false);
Task subTask = Task.Factory.StartNew(() =>
{
using (var sub = new SubscriberSocket())
{
sub.Bind("pgm://224.0.0.1:5555");
sub.Subscribe("");
subReady.Set();
while (count < 1000)
{
bool more;
Assert.AreEqual(count, BitConverter.ToInt32(sub.ReceiveFrameBytes(out more), 0));
Assert.IsFalse(more);
count++;
}
}
});
subReady.WaitOne();
Task pubTask = Task.Factory.StartNew(() =>
{
using (var pub = new PublisherSocket())
{
pub.Connect("pgm://224.0.0.1:5555");
for (int i = 0; i < 1000; i++)
{
pub.SendFrame(BitConverter.GetBytes(i));
}
// if we close the socket before the subscriber receives all messages subscriber
// might miss messages, lets wait another second
Thread.Sleep(1000);
}
});
pubTask.Wait();
subTask.Wait();
Thread.MemoryBarrier();
Assert.AreEqual(1000, count);
}
public void Connect(string givenAddress)
{
if (IsConnected)
{
return;
}
pubSocket = context.CreatePublisherSocket();
pubSocket.Connect(givenAddress);
IsConnected = true;
}
static void Main(string[] args)
{
//using (var server = new ResponseSocket("@tcp://localhost:5556")) // bind
//using (var client = new RequestSocket(">tcp://localhost:5556")) // connect
//{
// // Send a message from the client socket
// client.SendFrame("Hello");
// // Receive the message from the server socket
// string m1 = server.ReceiveFrameString();
// Console.WriteLine("From Client: {0}", m1);
// // Send a response back from the server
// server.SendFrame("Hi Back");
// // Receive the response from the client socket
// string m2 = client.ReceiveFrameString();
// Console.WriteLine("From Server: {0}", m2);
//}
const int MegaBit = 1024;
const int MegaByte = 1024;
using (var pub = new PublisherSocket())
using (var sub1 = new SubscriberSocket())
using (var sub2 = new SubscriberSocket())
{
pub.Options.MulticastHops = 2;
pub.Options.MulticastRate = 40 * MegaBit; // 40 megabit
pub.Options.MulticastRecoveryInterval = TimeSpan.FromMinutes(10);
pub.Options.SendBuffer = MegaByte * 10; // 10 megabyte
pub.Connect("pgm://224.0.0.1:5555");
sub1.Options.ReceiveBuffer = MegaByte * 10;
sub1.Bind("pgm://224.0.0.1:5555");
sub1.Subscribe("");
sub2.Bind("pgm://224.0.0.1:5555");
sub2.Options.ReceiveBuffer = MegaByte * 10;
sub2.Subscribe("");
Console.WriteLine("Server sending 'Hi'");
pub.Send("Hi");
bool more;
Console.WriteLine("sub1 received = '{0}'", sub1.ReceiveString(out more));
Console.WriteLine("sub2 received = '{0}'", sub2.ReceiveString(out more));
}
Console.ReadLine();
}
public void ThroughXPubXSubWithReconnectingPublisher()
{
using (var xpub = new XPublisherSocket())
using (var xsub = new XSubscriberSocket())
using (var poller = new NetMQPoller {
xsub, xpub
})
{
var xPubPort = (ushort)xpub.BindRandomPort("tcp://*");
var xSubPort = (ushort)xsub.BindRandomPort("tcp://*");
var proxy = new Proxy(xsub, xpub, poller: poller);
proxy.Start();
poller.RunAsync();
// long running subscriber
using (var sub = new SubscriberSocket())
{
sub.Connect(string.Format("tcp://localhost:{0}", xPubPort));
sub.Subscribe("A");
// publisher 1
using (var pub = new PublisherSocket())
{
pub.Connect(string.Format("tcp://localhost:{0}", xSubPort));
// give the publisher a chance to learn of the subscription
Thread.Sleep(100);
pub.SendMoreFrame("A").SendFrame("1");
}
// publisher 2
using (var pub = new PublisherSocket())
{
pub.Connect(string.Format("tcp://localhost:{0}", xSubPort));
// give the publisher a chance to learn of the subscription
Thread.Sleep(100);
pub.SendMoreFrame("A").SendFrame("2");
}
var frames = new List <string>();
Assert.True(sub.TryReceiveMultipartStrings(TimeSpan.FromSeconds(1), ref frames));
CollectionAssert.AreEqual(new[] { "A", "1" }, frames);
Assert.True(sub.TryReceiveMultipartStrings(TimeSpan.FromSeconds(1), ref frames));
CollectionAssert.AreEqual(new[] { "A", "2" }, frames);
}
}
}
public async Task ShouldHandleStateOfTheWorldRequest()
{
using (var publisher = new PublisherSocket())
{
publisher.Connect(ToPublishersEndpoint);
var command1 = new ChangeCcyPairState("EUR/USD", "TEST2", CcyPairState.Passive);
var command2 = new ChangeCcyPairState("EUR/USD", "TEST2", CcyPairState.Active);
var message1 = _eventSerializer.ToProducerMessage(command1);
var message2 = _eventSerializer.ToProducerMessage(command2);
await Task.Delay(200);
publisher.SendMoreFrame(message1.Subject)
.SendFrame(_eventSerializer.Serializer.Serialize(message1));
await Task.Delay(200);
publisher.SendMoreFrame(message2.Subject)
.SendFrame(_eventSerializer.Serializer.Serialize(message2));
await Task.Delay(200);
var cacheItems = await _eventCache.GetAllStreams();
Assert.AreEqual(2, cacheItems.Count());
using (var dealer = new DealerSocket())
{
var request = new StateRequest()
{
Subject = "EUR/USD"
};
var requestBytes = _eventSerializer.Serializer.Serialize(request);
dealer.Connect(StateOfTheWorldEndpoint);
dealer.SendFrame(requestBytes);
var hasResponse = dealer.TryReceiveFrameBytes(TimeSpan.FromMilliseconds(1000), out var responseBytes);
var response = _eventSerializer.Serializer.Deserialize <StateReply>(responseBytes);
Assert.AreEqual(2, response.Events.Count());
}
}
}
private void Publish()
{
publishing = true;
publisherSocket.Connect(@"tcp://127.0.0.1:17233");
while (publishing)
{
if (teleprinter.CachedDataAvailableEvent.WaitOne(TimeSpan.FromMilliseconds(200)))
{
if (!publisherSocket.TrySendFrame(teleprinter.GetCachedOutput()))
{
Log.Debug("Failed to send frame.");
}
}
}
}
private void Work()
{
using (var publisherSocket = new PublisherSocket())
{
publisherSocket.Connect(_brokerEndpoint);
while (!_cancel.IsCancellationRequested)
{
var price = Next();
publisherSocket
.SendMoreFrame(Topic)
.SendFrame(price.Serialize());
Thread.Sleep(50);
}
}
}
/// <summary>
/// Creates a new instance of the <see cref="DualSocketBusPublisher"/> type.
/// </summary>
/// <param name="messageBusEndpoint"> The subscribed message bus' endpoint. </param>
/// <param name="dispatcher"> The dispatcher that is used for outgoing messages from the subscibed bus. </param>
public DualSocketBusPublisher(
IDualSocketEndpoint messageBusEndpoint,
ISocketDispatcherThread dispatcher)
{
Dispatcher = dispatcher;
MessageBusEndpoint = messageBusEndpoint;
OutgoingMessages = new Lazy <PublisherSocket>(() =>
{
var socket = new PublisherSocket();
socket.Connect(MessageBusEndpoint.Incoming);
return(socket);
}, true);
OutgoingMessageQueue = new Lazy <NetMQQueue <NetMQMessage> >(() =>
{
var queue = new NetMQQueue <NetMQMessage>();
queue.ReceiveReady += OnMessageQueued;
return(queue);
}, true);
}
public async Task Start()
{
_publishMarketUpdates = new PublisherSocket();
foreach (var broker in _configuration.BrokerDescriptors)
{
_publishMarketUpdates.Connect(broker.PublishUpdateEndpoint);
}
_disconnected = IsConnected
.Buffer(2, 1)
.Where(buffer => buffer.Count > 1 && buffer[0] && !buffer[1])
.Subscribe(async _ =>
{
await DoStart();
});
await DoStart();
}
private void SenderWorker()
{
_mqContext = NetMQContext.Create();
_publisherSocket = _mqContext.CreatePublisherSocket();
if (Protocol == "tcp")
_publisherSocket.Connect(_address);
if (Protocol == "pgm") //Multicast
{
_publisherSocket.Options.MulticastHops = 4;
_publisherSocket.Options.MulticastRate = 40 * 1024; // 40 megabit
_publisherSocket.Options.MulticastRecoveryInterval = TimeSpan.FromMinutes(10);
_publisherSocket.Options.SendBuffer = 1024 * 10; // 10 megabyte
_publisherSocket.Bind(_address);
}
_publisherSocket.SendReady += (s, a) => { };
}