public void TwoSubscribers()
{
using (NetMQContext context = NetMQContext.Create())
{
using (var pub = context.CreatePublisherSocket())
{
pub.Connect("pgm://224.0.0.1:5555");
using (var sub = context.CreateSubscriberSocket())
{
using (var sub2 = context.CreateSubscriberSocket())
{
sub.Bind("pgm://224.0.0.1:5555");
sub2.Bind("pgm://224.0.0.1:5555");
sub.Subscribe("");
sub2.Subscribe("");
pub.Send("Hi");
bool more;
string message = sub.ReceiveString(out more);
Assert.IsFalse(more);
Assert.AreEqual("Hi", message);
message = sub2.ReceiveString(out more);
Assert.IsFalse(more);
Assert.AreEqual("Hi", message);
}
}
}
}
}
/// <summary>
/// Subscribe To Start Auction
/// </summary>
public void subscribeToStartAuctionCmd()
{
// Bind the publisher to the address
_publisher = _context.CreatePublisherSocket();
_publisher.Bind(ConfigurationManager.AppSettings["pubAddr"]);
// Connect to address for StartAuction and subscribe to the topic - StartAuction
var startAuctionSub = _context.CreateSubscriberSocket();
var startAuctionTopic = ConfigurationManager.AppSettings["startAuctionTopic"];
startAuctionSub.Connect(ConfigurationManager.AppSettings["startAuctionAddr"]);
startAuctionSub.Subscribe(startAuctionTopic);
Console.WriteLine("SUB: " + startAuctionTopic);
while (true)
{
string startAuctionCmd = startAuctionSub.ReceiveString();
Console.WriteLine("REC: " + startAuctionCmd);
publishAcknowledgement(startAuctionCmd);
// Extract the ID and get the bidders emails
string id = MessageParser.parseMessage(startAuctionCmd, "<id>", "</id>");
IDatabase database = DatabaseFacade.GetDatabase();
string[] emails = database.getBidderEmails(id);
if (emails != null)
{
publishNotifyBiddersCommand(id, emails);
}
publishAuctionStartedEvent(id);
}
}
void CreateClient()
{
switch (_type)
{
case MQClientType.Request:
_clientSocket = _context.CreateRequestSocket();
break;
case MQClientType.Subscriber:
_clientSocket = _context.CreateSubscriberSocket();
break;
case MQClientType.Dealer:
_clientSocket = _context.CreateDealerSocket();
break;
case MQClientType.Stream:
_clientSocket = _context.CreateStreamSocket();
break;
case MQClientType.Pull:
_clientSocket = _context.CreatePullSocket();
break;
case MQClientType.XSubscriber:
_clientSocket = _context.CreateXSubscriberSocket();
break;
default:
_clientSocket = _context.CreateRequestSocket();
break;
}
_clientSocket.Connect("tcp://" + _ip + ":" + _port);
}
/// <summary>
/// Initializes a new instance of the <see cref="ForwarderDevice"/> class.
/// </summary>
/// <param name="context">The <see cref="NetMQContext"/> to use when creating the sockets.</param>
/// <param name="poller">The <see cref="Poller"/> to use.</param>
/// <param name="frontendBindAddress">The endpoint used to bind the frontend socket.</param>
/// <param name="backendBindAddress">The endpoint used to bind the backend socket.</param>
/// <param name="mode">The <see cref="DeviceMode"/> for the device.</param>
public ForwarderDevice(NetMQContext context, Poller poller, string frontendBindAddress, string backendBindAddress,
DeviceMode mode = DeviceMode.Threaded)
: base(poller, context.CreateSubscriberSocket(), context.CreatePublisherSocket(), mode)
{
FrontendSetup.Bind(frontendBindAddress);
BackendSetup.Bind(backendBindAddress);
}
public void Sending1000Messages()
{
// creating two different context and sending 1000 messages
int count = 0;
ManualResetEvent subReady = new ManualResetEvent(false);
Task subTask = Task.Factory.StartNew(() =>
{
using (NetMQContext context = NetMQContext.Create())
{
using (var sub = context.CreateSubscriberSocket())
{
sub.Bind("pgm://224.0.0.1:5555");
sub.Subscribe("");
subReady.Set();
while (count < 1000)
{
bool more;
byte[] data = sub.Receive(out more);
Assert.IsFalse(more);
int num = BitConverter.ToInt32(data, 0);
Assert.AreEqual(num, count);
count++;
}
}
}
});
subReady.WaitOne();
Task pubTask = Task.Factory.StartNew(() =>
{
using (NetMQContext context = NetMQContext.Create())
{
using (var pub = context.CreatePublisherSocket())
{
pub.Connect("pgm://224.0.0.1:5555");
for (int i = 0; i < 1000; i++)
{
pub.Send(BitConverter.GetBytes(i));
}
}
}
});
pubTask.Wait();
subTask.Wait();
Thread.MemoryBarrier();
Assert.AreEqual(1000, count);
}
public void Start()
{
if (!ServerSpecified)
{
return;
}
if (context == null)
{
context = NetMQContext.Create();
subscriber = context.CreateSubscriberSocket();
subscriber.Connect("tcp://127.0.0.1:5252");
subscriber.Subscribe(String.Empty);
sender = context.CreatePushSocket();
sender.Connect("tcp://127.0.0.1:5253");
// Start listening..
Task.Run(() =>
{
while (!tokenSource.IsCancellationRequested)
{
var message = subscriber.ReceiveString();
var eventObject = Serialization.DeserializeEnvelope <ContractMarker>(message);
eventReceivedSubject.OnNext(eventObject);
}
});
}
}
public void UseInterface()
{
var hostEntry = Dns.GetHostEntry(Dns.GetHostName());
string ip = (
from addr in hostEntry.AddressList
where addr.AddressFamily == AddressFamily.InterNetwork
select addr.ToString()
).FirstOrDefault();
using (NetMQContext context = NetMQContext.Create())
{
using (var pub = context.CreatePublisherSocket())
{
pub.Connect(string.Format("pgm://{0};224.0.0.1:5555", ip));
using (var sub = context.CreateSubscriberSocket())
{
sub.Bind(string.Format("pgm://{0};224.0.0.1:5555", ip));
sub.Subscribe("");
pub.Send("Hi");
bool more;
string message = sub.ReceiveString(out more);
Assert.IsFalse(more);
Assert.AreEqual("Hi", message);
}
}
}
}
public void MultipleSubscriptions()
{
using (NetMQContext contex = NetMQContext.Create())
{
using (var pub = contex.CreatePublisherSocket())
{
pub.Bind("tcp://127.0.0.1:5002");
using (var sub = contex.CreateSubscriberSocket())
{
sub.Connect("tcp://127.0.0.1:5002");
sub.Subscribe("C");
sub.Subscribe("B");
sub.Subscribe("A");
sub.Subscribe("D");
sub.Subscribe("E");
Thread.Sleep(500);
sub.Unsubscribe("C");
sub.Unsubscribe("B");
sub.Unsubscribe("A");
sub.Unsubscribe("D");
sub.Unsubscribe("E");
Thread.Sleep(500);
}
}
}
}
protected override void ProducerAction()
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (SubscriberSocket socket = ctx.CreateSubscriberSocket())
{
using (
var monitor = new NetMQMonitor(ctx, socket, "inproc://monitor.sub/" + Guid.NewGuid(),
SocketEvent.Connected | SocketEvent.Disconnected))
{
monitor.Connected += monitor_Connected;
monitor.Disconnected += monitor_Disconnected;
monitor.Timeout = TimeSpan.FromMilliseconds(100);
Task.Factory.StartNew(monitor.Start);
socket.Connect(Address);
socket.Subscribe(string.Empty);
while (true)
{
_commandProcessor.ExecuteAll(socket);
NetMQMessage message = socket.ReceiveMessage();
if (message != null && !IsEmpty)
{
Queue.Add(message);
}
}
}
}
}
}
public void SimplePubSub()
{
using (NetMQContext contex = NetMQContext.Create())
{
using (var pub = contex.CreatePublisherSocket())
{
pub.Bind("tcp://127.0.0.1:5002");
using (var sub = contex.CreateSubscriberSocket())
{
sub.Connect("tcp://127.0.0.1:5002");
sub.Subscribe("");
// let the subscrbier connect to the publisher before sending a message
Thread.Sleep(500);
pub.Send("Hello");
bool more;
string m = sub.ReceiveString(out more);
Assert.AreEqual("Hello", m);
Assert.False(more);
}
}
}
}
public void WelcomeMessage()
{
using (NetMQContext contex = NetMQContext.Create())
{
using (var pub = contex.CreateXPublisherSocket())
{
pub.Bind("inproc://welcome");
pub.SetWelcomeMessage("W");
using (var sub = contex.CreateSubscriberSocket())
{
sub.Subscribe("W");
sub.Connect("inproc://welcome");
var subscription = pub.Receive();
Assert.AreEqual(subscription[1], (byte)'W');
var welcomeMessage = sub.ReceiveString();
Assert.AreEqual("W", welcomeMessage);
}
}
}
}
/// <summary>
/// Start polling for messages.
/// </summary>
private void StartPolling()
{
Task.Run(() =>
{
using (var subSocket = context.CreateSubscriberSocket())
{
byte[] buffer = null;
subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect(SubscriberAddress);
subSocket.Subscribe(String.Empty);
subSocket.ReceiveReady += (s, a) =>
{
buffer = subSocket.Receive();
if (MessageRecieved != null)
{
MessageRecieved.Report(buffer.ToObject <Taurus.FeedMux>());
}
};
// Poll.
poller = new Poller();
poller.AddSocket(subSocket);
poller.PollTillCancelled();
token.ThrowIfCancellationRequested();
}
}, token).ContinueWith(ant =>
{
pollerCancelled.Set();
}, TaskContinuationOptions.OnlyOnCanceled);
}
public void LargeMessage()
{
using (NetMQContext context = NetMQContext.Create())
{
using (var pubSocket = context.CreatePublisherSocket())
{
pubSocket.Bind("tcp://127.0.0.1:5556");
using (var subSocket = context.CreateSubscriberSocket())
{
subSocket.Connect("tcp://127.0.0.1:5556");
subSocket.Subscribe("");
Thread.Sleep(100);
byte[] msg = new byte[300];
pubSocket.Send(msg);
byte[] msg2 = subSocket.Receive();
Assert.AreEqual(300, msg2.Length);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ForwarderDevice"/> class.
/// </summary>
/// <param name="context">The <see cref="NetMQContext"/> to use when creating the sockets.</param>
/// <param name="poller">The <see cref="Poller"/> to use.</param>
/// <param name="frontendBindAddress">The endpoint used to bind the frontend socket.</param>
/// <param name="backendBindAddress">The endpoint used to bind the backend socket.</param>
/// <param name="mode">The <see cref="DeviceMode"/> for the device.</param>
public ForwarderDevice(NetMQContext context, Poller poller, string frontendBindAddress, string backendBindAddress,
DeviceMode mode = DeviceMode.Threaded)
: base(poller, context.CreateSubscriberSocket(), context.CreatePublisherSocket(), mode)
{
FrontendSetup.Bind(frontendBindAddress);
BackendSetup.Bind(backendBindAddress);
}
void t_Elapsed()
{
NetMQContext ctx = NetMQContext.Create();
NetMQSocket socket = ctx.CreateSubscriberSocket();
// TODO: change socket connection ip, port
socket.Connect("tcp://172.16.12.188:5555");
socket.Subscribe(_tagID.ToString("000"));
socket.ReceiveReady += (s, a) =>
{
string topic = socket.ReceiveString();
string message = socket.ReceiveString();
msg m = JsonConvert.DeserializeObject <msg>(message);
WriteText(m);
//Application.DoEvents();
};
Poller poller = new Poller();
poller.AddSocket(socket);
poller.Start();
}
private NetMQSocket GetInboundSocket(NetMQContext context)
{
NetMQSocket socket;
switch (Connection.Pattern)
{
case MessagePattern.FireAndForget:
socket = context.CreatePullSocket();
socket.Bind(Connection.Address);
break;
case MessagePattern.RequestResponse:
socket = context.CreateResponseSocket();
socket.Bind(Connection.Address);
break;
case MessagePattern.PublishSubscribe:
var subSocket = context.CreateSubscriberSocket();
subSocket.SubscribeToAnyTopic();
subSocket.Connect(Connection.Address);
socket = subSocket;
break;
default:
throw new Exception($"Cannot create an inbound socket for pattern {Connection.Pattern}");
}
return(socket);
}
public ZmqClient()
{
context = NetMQContext.Create();
subSocket = context.CreateSubscriberSocket();
subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect(MarketDataSettings.RealTimeUpdateServerAddress);
}
private void createRSocket()
{
clientR = context.CreateSubscriberSocket();
string[] addrs = cfg.ServerS.Split(',');
foreach (string addr in addrs)
{
clientR.Connect(addr);
}
clientR.Subscribe(Global.DC_CTRL_HB); //接收心跳数据包
clientR.Subscribe(Global.Encoding.GetBytes(string.Concat(Global.DC_HEAD_AS_RPLY, Global.ENVELOPE_SPLITTER, this.guidStr))); //接收Act操作的回复数据包
}
public void Connect(string givenAddress)
{
if (IsConnected)
{
return;
}
subSocket = context.CreateSubscriberSocket();
subSocket.Connect(givenAddress);
subSocket.Subscribe("EasyErgsocket");
IsConnected = true;
}
private void Subscribe(object state)
{
_running = true;
foreach (string subscriberAddress in _configuration.SubscriberAddresses)
{
SubscriberSocket subscriberSocket = _context.CreateSubscriberSocket();
subscriberSocket.Connect(subscriberAddress);
subscriberSocket.Subscribe("");
_subscriberSockets.Add(subscriberSocket);
Task.Factory.StartNew(() => WaitForMessages(subscriberSocket));
}
}
public void MultipleSubscribers()
{
using (NetMQContext contex = NetMQContext.Create())
{
using (var pub = contex.CreatePublisherSocket())
{
pub.Bind("tcp://127.0.0.1:5002");
using (var sub = contex.CreateSubscriberSocket())
using (var sub2 = contex.CreateSubscriberSocket())
{
sub.Connect("tcp://127.0.0.1:5002");
sub.Subscribe("A");
sub.Subscribe("AB");
sub.Subscribe("B");
sub.Subscribe("C");
sub2.Connect("tcp://127.0.0.1:5002");
sub2.Subscribe("A");
sub2.Subscribe("AB");
sub2.Subscribe("C");
Thread.Sleep(500);
pub.SendMore("AB");
pub.Send("1");
string message = sub.ReceiveStringMessages().First();
Assert.AreEqual("AB", message, "First subscriber is expected to receive the message");
message = sub2.ReceiveStringMessages().First();
Assert.AreEqual("AB", message, "Second subscriber is expected to receive the message");
}
}
}
}
public void Start(string serverAddress, int serverPublishPort, int clientId, Action <ServerToClientMessage> messageHandler)
{
this.messageHandler = messageHandler;
ctx = NetMQContext.Create();
subscribeSocket = ctx.CreateSubscriberSocket();
subscribeSocket.Connect(string.Format("tcp://{0}:{1}", serverAddress, serverPublishPort));
subscribeSocket.Subscribe(clientId.ToString());
subscribeSocket.Subscribe("a");
isRunning = true;
receiveThread = new Thread(Run);
receiveThread.Name = "ClientMessageListenThread";
receiveThread.Start();
logger.Info("Server message subscriber started");
}
// initialized sprites
void Start()
{
AsyncIO.ForceDotNet.Force();
calImages = new Sprite[10];
calImages[0] = Resources.Load <Sprite>("notargets");
calImages[1] = Resources.Load <Sprite>("targetTL");
calImages[2] = Resources.Load <Sprite>("targetTM");
calImages[3] = Resources.Load <Sprite>("targetTR");
calImages[4] = Resources.Load <Sprite>("targetML");
calImages[5] = Resources.Load <Sprite>("targetMM");
calImages[6] = Resources.Load <Sprite>("targetMR");
calImages[7] = Resources.Load <Sprite>("targetBL");
calImages[8] = Resources.Load <Sprite>("targetBM");
calImages[9] = Resources.Load <Sprite>("targetBR");
calCount = 0;
curCount = 0;
gameObject.GetComponent <Image> ().sprite = calImages [calCount];
//max coords 1180*564
transX = 0;
transY = 0;
targetPrefab = GameObject.FindGameObjectWithTag("RaycastTarget");
targetPrefab.SetActive(false);
targetPrefab.layer = 2; //ignore raycast layer
isVisible = false;
AsyncIO.ForceDotNet.Force();
//setup sockets
//hangs????
//http://forum.unity3d.com/threads/netmq-basic.298104/
//must compile myself
//https://github.com/zeromq/netmq/issues/98
context = NetMQContext.Create();
server = context.CreatePublisherSocket();
server.Bind("tcp://127.0.0.1:5556");
client = context.CreateSubscriberSocket();
client.Connect("tcp://127.0.0.1:5556");
client.Subscribe("coord");
Debug.Log(System.Environment.Version);
/*server.SendMore("coord").Send ("200 200");
* string top = client.ReceiveString ();
* string message = client.ReceiveString ();
* Debug.Log (message);
* string[] coord = message.Split ();
* transX = int.Parse (coord [0]);
* transY = int.Parse (coord [1]);*/
}
protected override void StartMethod()
{
_zmqContext = NetMQContext.Create();
_zmqSocket = _zmqContext.CreateSubscriberSocket();
if (string.IsNullOrEmpty(_subsPrefix))
{
_zmqSocket.Subscribe(string.Empty);
}
else
{
_zmqSocket.Subscribe(Encoding.UTF8.GetBytes(_subsPrefix));
}
_zmqSocket.Connect(_endPoint);
}
private void start(CancellationToken token, string address, TaskCompletionSource <bool> ready)
{
using (var socket = _context.CreateSubscriberSocket())
{
socket.Subscribe(Encoding.ASCII.GetBytes(_topic));
socket.Connect(address);
ready.SetResult(true);
while (token.IsCancellationRequested == false)
{
socket.Receive(); //ignore topic
var messageBytes = socket.Receive();
var message = Encoding.ASCII.GetString(messageBytes);
Console.WriteLine("[{0}] Received - {1}", _id, message);
}
}
}
private void Connect()
{
// getting the snapshot
using (RequestSocket requestSocket = context.CreateRequestSocket())
{
requestSocket.Connect(string.Format("tcp://{0}:{1}", address, SnapshotProtocol.Port));
requestSocket.Send(SnapshotProtocol.GetTradessCommand);
string json;
requestSocket.Options.ReceiveTimeout = SnapshotProtocol.RequestTimeout;
try
{
json = requestSocket.ReceiveString();
}
catch (AgainException ex)
{
// Fail to receive trades, we call on error and don't try to do anything with subscriber
// calling on error from poller thread block the application
Task.Run(() => subject.OnError(new Exception("No response from server")));
return;
}
while (json != SnapshotProtocol.EndOfTickers)
{
PublishTicker(json);
json = requestSocket.ReceiveString();
}
}
subscriberSocket = context.CreateSubscriberSocket();
subscriberSocket.Subscribe(StreamingProtocol.TradesTopic);
subscriberSocket.Subscribe(StreamingProtocol.HeartbeatTopic);
subscriberSocket.Connect(string.Format("tcp://{0}:{1}", address, StreamingProtocol.Port));
subscriberSocket.ReceiveReady += OnSubscriberReady;
poller.AddSocket(subscriberSocket);
// reset timeout timer
timeoutTimer.Enable = false;
timeoutTimer.Enable = true;
}
public void init(string address, int port)
{
this.address = address;
this.port = port;
//create context
context = NetMQContext.Create();
//create client
client = context.CreateSubscriberSocket();
//subscribe (must be before Connect!)
client.Subscribe("");
//connect client
client.Connect("tcp://" + address + ":" + port);
//add "getData" as callback
client.ReceiveReady += getData;
}
/// <summary>
/// Subscribe
/// </summary>
private void subscribe()
{
// Create a subscriber and connect to the same address and port as the publisher
SubscriberSocket subscriber = _context.CreateSubscriberSocket();
subscriber.Connect("tcp://127.0.0.1:9999");
// Set the topic
subscriber.Subscribe("Test");
string message = String.Empty;
// Receive the message and perform the assertion
while (message == String.Empty)
{
message = subscriber.ReceiveString();
}
Console.WriteLine(message);
Assert.AreEqual("Test", message);
}
private void Connect()
{
subscriberSocket = context.CreateSubscriberSocket();
subscriberSocket.Subscribe(StreamingProtocol.HeartbeatTopic);
subscriberSocket.Connect(string.Format("tcp://{0}:{1}", address, StreamingProtocol.Port));
subject.OnNext(new ConnectionInfo(ConnectionStatus.Connecting, this.address));
subscriberSocket.ReceiveReady += OnSubscriberReady;
poller.AddSocket(subscriberSocket);
// reset timeout timer
timeoutTimer.Enable = false;
timeoutTimer.Enable = true;
}
void Start()
{
trackManager = GetComponent <TrackManager>();
statDisplayManager = GetComponent <StatDisplayManager>();
cameraManager = GetComponent <CameraManager>();
//if there is no otherBoatType set just use the playerBoatType... if this isn't set either we're screwed anyways...
if (otherBoatType == null)
{
otherBoatType = playerBoatType;
}
initLanes();
Debug.Log("Starting up NetMQ interface on " + address);
context = NetMQContext.Create();
subSocket = context.CreateSubscriberSocket();
subSocket.Connect(address);
subSocket.Subscribe("EasyErgsocket");
}
private static void ListeningQueue()
{
using (NetMQContext context = NetMQContext.Create())
{
using (var subscriber = context.CreateSubscriberSocket())
{
subscriber.Connect("tcp://127.0.0.1:5555");
subscriber.Subscribe("");
while (true)
{
bool more;
var bytes = subscriber.Receive(out more);
System.Console.WriteLine("0x{0:X}", bytes[0]);
}
}
}
}
