private NetMQSocket InitSocket(ZmqSocketType socketType, string endPoint, bool isBind, string identity)
{
NetMQSocket socket = GetSocket(socketType);
if (identity != null && identity != "")
{
socket.Options.Identity = Encoding.UTF8.GetBytes(identity);
}
socket.Options.SendHighWatermark = 10000;
socket.Options.ReceiveHighWatermark = 10000;
socket.Options.Linger = TimeSpan.Zero;
socket.Options.TcpKeepalive = true;
socket.Options.TcpKeepaliveIdle = TimeSpan.FromMinutes(1);
socket.Options.TcpKeepaliveInterval = TimeSpan.FromSeconds(10);
if (isBind)
{
socket.Bind(endPoint);
}
else
{
socket.Connect(endPoint);
}
SetReceive(socketType, socket);
return(socket);
}
/// <summary>
/// Performs initialization actions, bindings and connections on the socket.
/// </summary>
internal void Configure()
{
if (m_isConfigured)
{
return;
}
if (m_bindings.Count == 0 && m_connections.Count == 0)
{
throw new InvalidOperationException("Device sockets must bind or connect to at least one endpoint.");
}
foreach (var initializer in m_socketInitializers)
{
initializer.Invoke(m_socket);
}
foreach (var endpoint in m_bindings)
{
m_socket.Bind(endpoint);
}
foreach (string endpoint in m_connections)
{
m_socket.Connect(endpoint);
}
m_isConfigured = true;
}
private static void Main(string[] args)
{
using (var ctx = NetMQContext.Create())
{
using (NetMQSocket frontend = ctx.CreateRouterSocket(), backend = ctx.CreateDealerSocket())
{
frontend.Bind(FRONTEND_ENDPOINT);
backend.Bind(BACKEND_ENDPOINT);
//Handler for messages coming in to the frontend
frontend.ReceiveReady += (sender, e) =>
{
var msg = frontend.ReceiveMessage();
backend.SendMessage(msg); //Relay this message to the backend
};
//Handler for messages coming in to the backend
backend.ReceiveReady += (sender, e) =>
{
var msg = backend.ReceiveMessage();
frontend.SendMessage(msg); //Relay this message to the frontend
};
using (var poller = new Poller())
{
poller.AddSocket(backend);
poller.AddSocket(frontend);
//Listen out for events on both sockets and raise events when messages come in
poller.Start();
}
}
}
}
public void BindToLocal()
{
var validAliasesForLocalHost = new[] { "127.0.0.1", "localhost", System.Net.Dns.GetHostName() };
foreach (var alias in validAliasesForLocalHost)
{
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQSocket localDealer = context.CreateDealerSocket())
{
localDealer.Bind("tcp://*:5002");
using (NetMQSocket connectingDealer = context.CreateDealerSocket())
{
connectingDealer.Connect("tcp://" + alias + ":5002");
localDealer.Send("test");
Assert.AreEqual("test", connectingDealer.ReceiveString());
Console.WriteLine(alias + " connected ");
}
}
}
}
}
//public int timeLimit = 120;
//Add option to modify this in AppOptions
protected override void Run()
{
ForceDotNet.Force();
//socket = new RequestSocket();
//socket.Connect("tcp://localhost:5555");
Debug.Log("Communication started");
if (option == CommunicatorOption.RECEIVE_DATA)
{
socket = new RequestSocket();
socket.Connect(address);
//Debug.Log("Communication started");
dataList = new List <float[]>();
ReceiveOnePointData();
}
else if (option == CommunicatorOption.SEND_DATA)
{
socket = new ResponseSocket();
socket.Bind(address);
//Debug.Log("Communication started");
CreateByteData();
SendOnePointData();
}
//byte_dataList
}
public static void Main(string[] args)
{
NetMQContext context = NetMQContext.Create();
NetMQSocket server = context.CreateRequestSocket();
server.Bind("tcp://*:5555");
NetMQMessage message = new NetMQMessage();
NetMQMessage getmass = new NetMQMessage();
message.Append("Hallo ");
message.Append(40);
Client client = new Client();
Thread t = new Thread(new ThreadStart(client.runClient));
t.Start();
while (true)
{
server.SendMessage(message, false);
getmass = server.ReceiveMessage(false);
System.Console.WriteLine(getmass.Pop().ConvertToString());
System.Console.WriteLine(getmass.Pop().ConvertToInt32());
}
}
private void SetupPublisher()
{
Open(0);
_publisherSocket = _context.CreatePublisherSocket();
_publisherSocket.Bind(_configuration.PublisherAddress);
}
public FeedZmQPublisher(string address, ILog log)
{
_log = log;
_context = NetMQContext.Create();
_socket = _context.CreatePushSocket();
_socket.Bind(address);
}
/// <summary>
///
/// </summary>
public void Start()
{
m_server = new RouterSocket();
m_server.Bind("tcp://*:" + ListnenPort);
m_server.ReceiveReady += Server_ReceiveReady;
m_server.SendReady += Server_SendReady;
m_started = true;
new Thread(() =>
{
long nextSend = 0, nextHeartBeat = 0;
while (m_started)
{
var tmp = TimeSpan.FromMilliseconds(1);
m_server.Poll(tmp);
if (nextSend <= 0)
{
SendQueue();
nextSend = SendInterval;
}
if (nextHeartBeat <= 0)
{
Heartbeat();
nextHeartBeat = PingInterval;
}
nextSend -= 10;
nextHeartBeat -= 10;
Thread.Sleep(10);
}
})
{
IsBackground = true
}.Start();
}
public Server(ISerializer serializer, string serverUri)
{
_serializer = serializer;
_rsa = Rsa.Create();
_sessionCache = new SessionCache();
_socket = new ResponseSocket();
_socket.Bind(serverUri);
while (true)
{
var messageBytes = _socket.ReceiveFrameBytes();
var message = _serializer.Deserialize <SecurityLayerMessage>(messageBytes);
switch (message.Type)
{
case SecurityMessageType.ClientHello:
HandleClientHello(message.Data);
break;
case SecurityMessageType.ClientKeyExchange:
HandleClientKeyExchange(message.Data);
break;
case SecurityMessageType.ApplicationData:
HandleApplicationData(message.Data);
break;
}
}
}
public async Task Start ()
{
ThrowIfDisposed ();
var ct = cancellationTokenSource.Token;
nmqPoller = new Poller ();
nmqScheduler = new NetMQScheduler (nmqContext, nmqPoller);
nmqServer = nmqContext.CreateResponseSocket ();
nmqServer.Bind (Address.AbsoluteUri.TrimEnd ('/'));
serverTask = Task.Factory.StartNew (() => {
ct.ThrowIfCancellationRequested ();
while (true) {
if (ct.IsCancellationRequested) {
// clean up here
ct.ThrowIfCancellationRequested ();
}
var msg = nmqServer.Receive ();
var request = Request.Deserialize (msg);
var result = Handle (request);
byte[] output_buffer = result.Serialize ();
nmqServer.Send (output_buffer);
}
}, ct);
await serverTask;
}
/// <summary>
/// Initializes a new instance of the <see cref="NmqResponseQueue"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="port">The port.</param>
internal NmqResponseQueue(NetMQContext context, int port)
{
socket = context.CreateResponseSocket();
var address = string.Format("tcp://127.0.0.1:{0}", port);
socket.Bind(address);
}
public void HasOutTest()
{
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQSocket server = context.CreateDealerSocket())
{
server.Bind("tcp://*:5557");
// no client is connected so we don't have out
Assert.IsFalse(server.HasOut);
using (NetMQSocket client = context.CreateDealerSocket())
{
Assert.IsFalse(client.HasOut);
client.Connect("tcp://localhost:5557");
Thread.Sleep(100);
// client is connected so server should have out now, client as well
Assert.IsTrue(server.HasOut);
Assert.IsTrue(client.HasOut);
}
Thread.Sleep(100);
// client is disposed,server shouldn't have out now
Assert.IsFalse(server.HasOut);
}
}
}
void CreateServer()
{
switch (_type)
{
case ServerType.Response:
_serverSocket = _context.CreateResponseSocket(); break;
case ServerType.Pub:
_serverSocket = _context.CreatePushSocket(); break;
case ServerType.Router:
_serverSocket = _context.CreateRouterSocket(); break;
case ServerType.Stream:
_serverSocket = _context.CreateStreamSocket(); break;
case ServerType.Push:
_serverSocket = _context.CreatePushSocket(); break;
case ServerType.XPub:
_serverSocket = _context.CreateXPublisherSocket(); break;
default:
_serverSocket = _context.CreateResponseSocket(); break;
}
_serverSocket.Bind("tcp://*:" + _port);
Task.Factory.StartNew(() =>
AsyncRead(_serverSocket), TaskCreationOptions.LongRunning);
}
protected void CreateServer()
{
switch (_type)
{
case MQServerType.Response:
_serverSocket = _context.CreateResponseSocket(); break;
case MQServerType.Publisher:
_serverSocket = _context.CreatePublisherSocket(); break;
case MQServerType.Router:
_serverSocket = _context.CreateRouterSocket(); break;
case MQServerType.Stream:
_serverSocket = _context.CreateStreamSocket(); break;
case MQServerType.Push:
_serverSocket = _context.CreatePushSocket(); break;
case MQServerType.XPublisher:
_serverSocket = _context.CreateXPublisherSocket(); break;
default:
_serverSocket = _context.CreateResponseSocket(); break;
}
_serverSocket.Bind("tcp://*:" + _port);
}
private void SetupPublisher()
{
Open(0);
_publisherSocket = _context.CreatePublisherSocket();
_publisherSocket.Bind(_configuration.PublisherAddress);
}
public void Start()
{
_context = NetMQContext.Create();
_frontend = _context.CreateRouterSocket();
_backend = _context.CreateRouterSocket();
_frontend.Bind("tcp://localhost:5555"); // For Clients
_backend.Bind("tcp://localhost:5556"); // For Workers
_frontend.ReceiveReady += _frontEnd_ReceiveReady;
_backend.ReceiveReady += _backEnd_ReceiveReady;
var heartbeatTimer = new NetMQTimer(Paranoid.HEARTBEAT_INTERVAL_MS);
heartbeatTimer.Elapsed += heartbeatTimer_Elapsed;
_poller = new Poller();
_poller.AddSocket(_frontend);
_poller.AddSocket(_backend);
_poller.AddTimer(heartbeatTimer);
_nextHeartbeatAt = DateTime.Now.AddMilliseconds(Paranoid.HEARTBEAT_INTERVAL_MS);
Task.Factory.StartNew(t => Run(t), _tokenSource.Token, TaskCreationOptions.LongRunning);
Task.Factory.StartNew(_poller.Start, TaskCreationOptions.LongRunning);
}
/// <summary>
/// Initializes a new instance of the Server class
/// </summary>
/// <param name="connectionString">How the server should be set up, to listen on TCP port 7954 to all incoming connections: "tcp://*:7954"</param>
public Server(string connectionString)
{
serverConnectionString = connectionString;
NetMQContext context = NetMQContext.Create();
netMqSocket = context.CreateRouterSocket();
netMqSocket.Bind(serverConnectionString);
}
/// <summary>
/// Bind the extended <see cref="NetMQSocket"/> to the specified <paramref name="endpoint"/>.
/// </summary>
/// <param name="socket"> The socket that should be bound to the specified <paramref name="endpoint"/>. </param>
/// <param name="endpoint"> The endpoint that should be bound to the <paramref name="socket"/>. </param>
public static void Bind(this NetMQSocket socket, ISocketEndpoint endpoint)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
socket.Bind(endpoint.AsString());
}
public Task StartAsync(HostingApplication hostingApplication, CancellationToken cancellationToken)
{
_routerSocket = new RouterSocket();
_routerSocket.Bind($"tcp://{_hostingOptions.Host}");
_routerSocket.ReceiveReady += RouterSocket_ReceiveReady;
_dealerSocket = new DealerSocket();
_dealerSocket.Bind(INPROC_SERVER_URL);
_dealerSocket.ReceiveReady += DealerSocket_ReceiveReady;
_poller = new NetMQPoller {
_routerSocket, _dealerSocket
};
_poller.RunAsync();
_workerPoller = new NetMQPoller();
async void OnReceiveReady(object sender, NetMQSocketEventArgs args)
{
NetMQMessage receiveMessage = args.Socket.ReceiveMultipartMessage();
string address = receiveMessage.Pop().ConvertToString();
string content = receiveMessage.Last().ConvertToString(Encoding.UTF8);
OwinContext owinContext = null;
long startTimestamp = Stopwatch.GetTimestamp();
_logger.LogInformation($"Request starting tcp://{_hostingOptions.Host} {content}");
owinContext = hostingApplication.CreateContext(content);
try
{
await hostingApplication.ProcessRequestAsync(owinContext);
}
catch (Exception ex)
{
owinContext.Response.Error(ex.Message);
throw;
}
finally
{
string sendContent = _serializer.Serialize(owinContext.Response);
_logger.LogInformation($"Request finished in {new TimeSpan((long)(TimestampToTicks * (Stopwatch.GetTimestamp() - startTimestamp))).TotalMilliseconds}ms {sendContent}");
NetMQMessage sendMessage = new NetMQMessage();
sendMessage.Append(address);
sendMessage.AppendEmptyFrame();
sendMessage.Append(sendContent, Encoding.UTF8);
args.Socket.SendMultipartMessage(sendMessage);
hostingApplication.DisponseContext(owinContext);
}
}
foreach (var item in Enumerable.Range(0, _hostingOptions.ProcessCount))
{
NetMQSocket process = new DealerSocket();
process.Connect(INPROC_SERVER_URL);
process.ReceiveReady += OnReceiveReady;
_workerPoller.Add(process);
}
_workerPoller.RunAsync();
return(Task.CompletedTask);
}
protected override NetMQSocket CreateListener()
{
NetMQSocket listener = this.Context.CreatePullSocket();
string bindTo = CreateAddress("tcp", Host, Port);
listener.Bind(bindTo);
return(listener);
}
public void DisposeImmediatly()
{
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQSocket server = context.CreateDealerSocket())
{
server.Bind("tcp://*:5557");
}
}
}
private void InitZmq()
{
if (_ctx == null)
{
_ctx = NetMQContext.Create();
_socket = _ctx.CreatePublisherSocket();
var address = string.Format("{0}:{1}", _host, _port);
_socket.Bind(address);
}
}
public RequestHandlerSocket(NetMQContext context,
string address,
Func <byte[], TRequest> requestUnmarshaller,
Func <TReply, byte[]> replyMarshaller)
{
_requestUnmarshaller = requestUnmarshaller;
_replyMarshaller = replyMarshaller;
_timeout = TimeSpan.FromMilliseconds(100);
_socket = context.CreateSocket(ZmqSocketType.Rep);
_socket.Bind(address);
Task.Factory.StartNew(Run, TaskCreationOptions.LongRunning);
}
public void Start()
{
SignalService.Logger.Info("Bind zeroMQ socket to address: {0}", Address);
router = zeroMQContext.CreateSocket(ZmqSocketType.Router);
router.Bind(Address);
router.ReceiveReady += RouterOnReceiveReady;
//poller = new Poller();
//poller.AddSocket(router);
//new Thread(() => poller.Start()).Start(); // TODO stop thread
new Thread(PollerThread).Start();
}
public ZeroMQService(ILogger <ZeroMQService> logger, IOptions <ZMQOption> option)
{
_logger = logger;
this.xsubSocket = new XSubscriberSocket();
this.xpubSocket = new XPublisherSocket();
this.xsubSocket = new PullSocket();
this.xpubSocket = new PushSocket();
_option = option.Value;
xpubSocket.Bind(_option?.SendAddress ?? "tcp://127.0.0.1:5556");
xsubSocket.Bind(_option?.ReceiveAddress ?? "tcp://127.0.0.1:5557");
_proxy = new Proxy(xsubSocket, xpubSocket);
}
void Start()
{
AsyncIO.ForceDotNet.Force();
response = new ResponseSocket();
response.Bind("tcp://127.0.0.1:5555");
sender = new DealerSocket();
sender.Bind("tcp://127.0.0.1:5557");
receiver = new DealerSocket();
receiver.Bind("tcp://127.0.0.1:5558");
}
public NetMQScheduler(NetMQContext context, Poller poller = null)
{
m_context = context;
if (poller == null)
{
m_ownPoller = true;
m_poller = new Poller();
}
else
{
m_ownPoller = false;
m_poller = poller;
}
m_clientSockets = new ConcurrentBag<NetMQSocket>();
m_schedulerId = Interlocked.Increment(ref s_schedulerCounter);
m_address = string.Format("{0}://scheduler-{1}", NetMQ.zmq.Address.InProcProtocol, m_schedulerId);
m_serverSocket = context.CreatePullSocket();
m_serverSocket.Options.Linger = TimeSpan.Zero;
m_serverSocket.Bind(m_address);
m_currentMessageHandler = OnMessageFirstTime;
m_serverSocket.ReceiveReady += m_currentMessageHandler;
m_poller.AddSocket(m_serverSocket);
m_clientSocket = new ThreadLocal<NetMQSocket>(() =>
{
var socket = m_context.CreatePushSocket();
socket.Connect(m_address);
m_clientSockets.Add(socket);
return socket;
});
m_schedulerThread = new ThreadLocal<bool>(() => false);
if (m_ownPoller)
{
Task.Factory.StartNew(m_poller.Start, TaskCreationOptions.LongRunning);
}
}
public void Bind()
{
context = NetMQContext.Create();
if (socket != null)
{
throw new NetMQException("Attempt to set socket that was already defined. This would prevent successful dispose of the context later on (since we can no longer close all sockets).");
}
socket = context.CreateResponseSocket();
socket.Options.Linger = new TimeSpan(0, 0, 0, 1);
Trace.Assert(Protocol.ToLower().Equals("tcp"), "Only TCP is supported for now");
socket.Bind("tcp://" + Host + ":" + Port);
}
public Task StartAsync(HostingApplication hostingApplication, CancellationToken cancellationToken)
{
_routerSocket = new RouterSocket();
_routerSocket.Bind($"tcp://{_hostingOptions.Host}");
_routerSocket.ReceiveReady += RouterSocket_ReceiveReady;
_dealerSocket = new DealerSocket();
_dealerSocket.Bind(INPROC_SERVER_URL);
_dealerSocket.ReceiveReady += DealerSocket_ReceiveReady;
_poller = new NetMQPoller {
_routerSocket, _dealerSocket
};
_poller.RunAsync();
return(Task.CompletedTask);
}
static void Main(string[] args)
{
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQSocket response = context.CreateResponseSocket())
{
string address = GetComputerLanIP();
if (PORT_NUMBER > 0)
{
if (!string.IsNullOrEmpty(address))
{
Console.WriteLine("Binding tcp://{0}:{1}", address, PORT_NUMBER);
response.Bind(string.Format("tcp://{0}:{1}", address, PORT_NUMBER));
while (true)
{
bool hasMore = true;
string msg = response.ReceiveString(out hasMore);
if (string.IsNullOrEmpty(msg))
{
Console.WriteLine("No msg received.");
break;
}
Console.WriteLine("Msg received! {0}", msg);
response.Send(msg, false, hasMore);
Thread.Sleep(1000);
}
response.Options.Linger = TimeSpan.Zero;
}
else
{
Console.WriteLine("Wrong IP address");
}
}
else
{
Console.WriteLine("The port number should be greater than 0");
}
Console.WriteLine("Press ENTER to exit...");
Console.ReadLine();
}
}
}
public void Start(string configFile)
{
config = ServiceConfig.FromXml(configFile);
log.DebugFormat("Start from {0}", configFile);
if (config.PushPull != null)
{
log.InfoFormat("Starting listening for Pull: {0}", config.PushPull.ListenAddress);
NetMQContext ctx1 = NetMQContext.Create();
InitLinks(ctx1, _push_links, config.PushPull, ZmqSocketType.Push);
puller = ctx1.CreatePullSocket();
puller.ReceiveReady += this.PullerReceiveReady;
puller.Bind(config.PushPull.ListenAddress);
this.source_pp = new CancellationTokenSource();
this.token_pp = this.source_pp.Token;
Task newTask = Task.Factory.StartNew(this.OnPull, this.token_pp);
this.tasks.Add(newTask);
}
if (config.PubSub != null)
{
log.InfoFormat("Starting listening for subscriber: {0}", config.PubSub.ListenAddress);
NetMQContext ctx2 = NetMQContext.Create();
InitLinks(ctx2, _sub_links, config.PubSub, ZmqSocketType.Sub);
foreach (var link in _sub_links)
{
link.Value.socket.ReceiveReady += SubOnReceiveReady;
}
publisher = ctx2.CreatePublisherSocket();
publisher.Bind(config.PubSub.ListenAddress);
this.source_ps = new CancellationTokenSource();
this.token_ps = this.source_ps.Token;
Task newTask = Task.Factory.StartNew(this.OnSubscribe, this.token_ps);
this.tasks.Add(newTask);
}
if (config.ReqRep != null)
{
log.InfoFormat("Starting listening for Request: {0}", config.ReqRep.ListenAddress);
NetMQContext ctx3 = NetMQContext.Create();
//InitLinks(ctx3, _req_links, config.ReqRep, ZmqSocketType.Req); delete by xsw 2014-09-17
responser = ctx3.CreateResponseSocket();
responser.ReceiveReady += this.RepReceiveReady;
responser.Bind(config.ReqRep.ListenAddress);
this.source_rr = new CancellationTokenSource();
this.token_rr = this.source_rr.Token;
Task newTask = Task.Factory.StartNew(this.OnResponse, this.token_rr);
this.tasks.Add(newTask);
}
}
// 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]);*/
}
internal static void Start(this NetMQSocket socket, string address, SocketType socketType)
{
switch (socketType)
{
case SocketType.Client:
socket.Connect(address);
break;
case SocketType.Server:
socket.Bind(address);
break;
default:
throw new ArgumentException(string.Format("Unknown SocketType {0}", socketType), "socketType");
}
}
public void Initialize()
{
LoggingExtensions.Logging.Log.InitializeWith <LoggingExtensions.log4net.Log4NetLog>();
//context = NetMQContext.Create();
frontend = new ResponseSocket(); // context.CreateResponseSocket();
backend = new PublisherSocket(); // context.CreatePublisherSocket();
var frontAdress = ConfigurationManager.AppSettings["ctrl_frontendBindAddress"];
var bakdendAdress = ConfigurationManager.AppSettings["ctrl_backendBindAddress"];
frontend.Bind(frontAdress);
backend.Bind(bakdendAdress);
this.Log().Info("初始化ZeroMq完成");
}
// 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]);*/
}
public void Start()
{
using (m_serverSocket = m_context.CreateResponseSocket())
{
foreach (var address in m_addresses)
{
m_log.InfoFormat("Listening on {0}", address);
m_serverSocket.Bind(address);
}
m_serverSocket.ReceiveReady += OnMessage;
m_poller = new Poller();
m_poller.AddSocket(m_serverSocket);
m_poller.Start();
}
}
//? swtich to ctor with Socket and Sender? move setup to factory?
public SendSocket(NetMQContext context,
string address,
Func <T, byte[]> marshaller,
ZmqSocketType type = ZmqSocketType.Pub,
bool bind = true)
{
_msgSender = marshaller;
_socket = context.CreateSocket(type);
if (bind)
{
_socket.Bind(address);
}
else
{
_socket.Connect(address);
}
}
/// <summary>
/// Create a new instance of a Proxy (NetMQ.Proxy)
/// with the given sockets to serve as a front-end, a back-end, and a control socket.
/// </summary>
/// <param name="publisherAddress">the address that messages will be forwarded from</param>
/// <param name="subscriberAddress">the address that messages should be sent to</param>
/// <param name="heartbeat">the timespan at which to send HEARTBEAT messages (in milliseconds) - you can set this to zero if not needed</param>
/// <param name="control">this socket will have messages also sent to it - you can set this to null if not needed</param>
public ZeroMqHub(string publisherAddress, string subscriberAddress, int heartbeat = 0, NetMQSocket control = null)
{
_subscriberAddress = subscriberAddress;
_publisherAddress = publisherAddress;
var context = NetMQContext.Create();
_subscriber = context.CreateXSubscriberSocket();
_publisher = context.CreateXPublisherSocket();
_control = control;
if (heartbeat > 0)
{
_heartbeat = new NetMQTimer(heartbeat);
_heartbeat.Elapsed += (s, a) => _publisher.Send("HEARTBEAT");
}
Name = "XPub-XSub";
PSJobTypeName = typeof(ZeroMqHub).Name;
_subscriber.Bind(subscriberAddress);
_publisher.Bind(publisherAddress);
}
/// <summary>
/// Create a new NetMQScheduler object within the given context, and optionally using the given poller.
/// </summary>
/// <param name="context">the NetMQContext to create this NetMQScheduler within</param>
/// <param name="poller">(optional)the Poller for this Net to use</param>
public NetMQScheduler([NotNull] NetMQContext context, [CanBeNull] Poller poller = null)
{
if (poller == null)
{
m_ownPoller = true;
m_poller = new Poller();
}
else
{
m_ownPoller = false;
m_poller = poller;
}
m_tasksQueue = new ConcurrentQueue<Task>();
m_syncObject = new object();
var schedulerId = Interlocked.Increment(ref s_schedulerCounter);
var address = string.Format("{0}://scheduler-{1}", Address.InProcProtocol, schedulerId);
m_serverSocket = context.CreatePullSocket();
m_serverSocket.Options.Linger = TimeSpan.Zero;
m_serverSocket.Bind(address);
m_currentMessageHandler = OnMessageFirstTime;
m_serverSocket.ReceiveReady += m_currentMessageHandler;
m_poller.AddSocket(m_serverSocket);
m_clientSocket = context.CreatePushSocket();
m_clientSocket.Connect(address);
m_schedulerThread = new ThreadLocal<bool>(() => false);
if (m_ownPoller)
{
m_poller.PollTillCancelledNonBlocking();
}
}
protected void CreateServer()
{
switch (_type)
{
case MQServerType.Response:
_serverSocket = _context.CreateResponseSocket(); break;
case MQServerType.Publisher:
_serverSocket = _context.CreatePublisherSocket(); break;
case MQServerType.Router:
_serverSocket = _context.CreateRouterSocket(); break;
case MQServerType.Stream:
_serverSocket = _context.CreateStreamSocket(); break;
case MQServerType.Push:
_serverSocket = _context.CreatePushSocket(); break;
case MQServerType.XPublisher:
_serverSocket = _context.CreateXPublisherSocket(); break;
default:
_serverSocket = _context.CreateResponseSocket(); break;
}
_serverSocket.Bind("tcp://*:" + _port);
}
private NetMQScheduler(Poller poller, PushSocket pushSocket, PullSocket pullSocket)
{
if (poller == null)
{
m_ownPoller = true;
m_poller = new Poller();
}
else
{
m_ownPoller = false;
m_poller = poller;
}
var address = string.Format("{0}://scheduler-{1}",
Address.InProcProtocol,
Interlocked.Increment(ref s_schedulerCounter));
m_serverSocket = pullSocket;
m_serverSocket.Options.Linger = TimeSpan.Zero;
m_serverSocket.Bind(address);
m_currentMessageHandler = OnMessageFirstTime;
m_serverSocket.ReceiveReady += m_currentMessageHandler;
m_poller.AddSocket(m_serverSocket);
m_clientSocket = pushSocket;
m_clientSocket.Connect(address);
m_isSchedulerThread = new ThreadLocal<bool>(() => false);
if (m_ownPoller)
{
m_poller.PollTillCancelledNonBlocking();
}
}
private void InitZmq(string host, int port)
{
if (_ctx == null)
{
_ctx = NetMQContext.Create();
_socket = _ctx.CreateResponseSocket();
var address = string.Format("{0}:{1}", host, port);
_socket.Bind(address);
Log.InfoFormat(@"Context server running at: {0}", address);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NmqResponseQueue"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="port">The port.</param>
internal NmqResponseQueue(NetMQContext context, int port)
{
socket = context.CreateResponseSocket();
var address = string.Format("tcp://127.0.0.1:{0}", port);
socket.Bind(address);
}
/// <summary>
/// Starts the publishing and request servers.
/// </summary>
public void StartServer()
{
if (!ServerRunning)
{
_context = NetMQContext.Create();
//the publisher socket
_pubSocket = _context.CreatePublisherSocket();
_pubSocket.Bind("tcp://*:" + PublisherPort);
//the request socket
_reqSocket = _context.CreateSocket(ZmqSocketType.Rep);
_reqSocket.Bind("tcp://*:" + RequestPort);
_reqSocket.ReceiveReady += _reqSocket_ReceiveReady;
_poller = new Poller(new[] { _reqSocket });
Task.Factory.StartNew(_poller.Start, TaskCreationOptions.LongRunning);
}
ServerRunning = true;
}
/// <summary>
/// Starts the server.
/// </summary>
public void StartServer()
{
if (_runServer) return;
_runServer = true;
_context = NetMQContext.Create();
_socket = _context.CreateSocket(NetMQ.zmq.ZmqSocketType.Rep);
_socket.Bind("tcp://*:" + _socketPort);
_socket.ReceiveReady += _socket_ReceiveReady;
_poller = new Poller(new[] { _socket });
Task.Factory.StartNew(_poller.Start, TaskCreationOptions.LongRunning);
}
public void Start(NetMQContext context)
{
this.SetUpMonitorChannel(context);
this.SetUpAddSubscriberCountChannel(context);
//this should work but the forwarder device appears to be broken - it does not use XSUb and XPUB sockets
//forwarderDevice = new ForwarderDevice(context, PublishAddressServer, SubscribeAddressServer, DeviceMode.Threaded);
//forwarderDevice.FrontendSetup.Subscribe(string.Empty);
//forwarderDevice.Start();
//while (!forwarderDevice.IsRunning)
//{ }
QueueDevce = new QueueDevice(context, PubSubControlBackAddressServer, PubSubControlFrontAddressServer, DeviceMode.Threaded);
QueueDevce.Start();
//while (!QueueDevce.IsRunning)
//{
//}
this.Writeline("Control channel started");
long count = 0;
this.cancellationTokenSource = new CancellationTokenSource();
var token = this.cancellationTokenSource.Token;
Task.Run(() =>
{
using (frontend = context.CreateXSubscriberSocket())
{
using (backend = context.CreateXPublisherSocket())
{
frontend.Bind(Pipe.PublishAddressServer); ////"tcp://*:5550");
backend.Bind(Pipe.SubscribeAddressServer); ////"tcp://*:5553");
// frontend.ReceiveReady += frontend_ReceiveReady;
frontend.ReceiveReady += new EventHandler<NetMQSocketEventArgs>(FrontendReceiveReady);
backend.ReceiveReady += new EventHandler<NetMQSocketEventArgs>(BackendReceiveReady);
// this.AddSubscriberCountChannel.ReceiveReady += new EventHandler<NetMQSocketEventArgs>(AddSubscriberCountChannelReceiveReady);
using (this.poller = new Poller(new NetMQSocket[] { frontend, backend, this.AddSubscriberCountChannel }))
{
Writeline("About to start polling");
while (true)
{
poller.Start(); // .PollOnce(); .Poll(new TimeSpan(0,0,0,0,5));
Writeline("polling" + count);
count++;
if (token.IsCancellationRequested)
{
Writeline("break");
break;
}
}
}
Writeline("stopped polling and exiting");
}
}
},
token);
}
public void ConnectOrBindAddress(NetMQSocket socket)
{
var address = $"{Uri.Scheme}://{Uri.Host}:{Uri.Port}";
socket.Bind(address);
}
public Broadcaster()
{
ctx = NetMQContext.Create();
server = ctx.CreatePublisherSocket();
server.Bind("tcp://127.0.0.1:5003");
}
/// <summary>
/// Start the server.
/// </summary>
public void StartServer()
{
//check that it's not already running
if (ServerRunning) return;
_context = NetMQContext.Create();
_routerSocket = _context.CreateSocket(NetMQ.zmq.ZmqSocketType.Router);
_routerSocket.Bind("tcp://*:" + _listenPort);
_routerSocket.ReceiveReady += socket_ReceiveReady;
_poller = new Poller(new[] { _routerSocket });
Task.Factory.StartNew(_poller.Start, TaskCreationOptions.LongRunning);
ServerRunning = true;
}
