private static void ClientThread(object UseInproc) { using (var context = ZmqContext.Create()) using (var socket = context.CreateSocket(SocketType.REQ)) { socket.Connect((bool)UseInproc ? "inproc://abc" : "tcp://localhost:9000"); foreach (int messageSize in MessageSizes) { var msg = new byte[messageSize]; var reply = new byte[messageSize]; var watch = new Stopwatch(); watch.Start(); for (int i = 0; i < RoundtripCount; i++) { SendStatus sendStatus = socket.Send(msg); Debug.Assert(sendStatus == SendStatus.Sent, "Message was not indicated as sent."); int bytesReceived = socket.Receive(reply); Debug.Assert(bytesReceived == messageSize, "Pong message did not have the expected size."); } watch.Stop(); long elapsedTime = watch.ElapsedTicks; double latency = (double)elapsedTime / RoundtripCount / 2 * 1000000 / Stopwatch.Frequency; Console.WriteLine("Roundtrips: {0}, MsgSz: {1,5}, Latency: {2,6} us", RoundtripCount, messageSize, latency.ToString("f2")); } } }
public static void Main(string[] args) { using (var context = ZmqContext.Create()) { using (ZmqSocket replyer = context.CreateSocket(SocketType.REP)) { replyer.Bind("tcp://*:5555"); bool interrupted = false; Console.CancelKeyPress += delegate { interrupted = true; }; const string replyMessage = "World"; while (!interrupted) { string message = replyer.Receive(Encoding.Unicode); Console.WriteLine("Received request: {0}", message); // Simulate work, by sleeping Thread.Sleep(1000); // Send reply back to client replyer.Send(replyMessage, Encoding.Unicode); } } } }
public static void Main(string[] args) { using (var context = ZmqContext.Create()) { using (ZmqSocket subscriber = context.CreateSocket(SocketType.SUB), syncClient = context.CreateSocket(SocketType.REQ)) { subscriber.Connect("tcp://localhost:5561"); subscriber.Subscribe(Encoding.Unicode.GetBytes(string.Empty)); syncClient.Connect("tcp://localhost:5562"); // - send a synchronization request syncClient.Send("", Encoding.Unicode); // - wait for synchronization reply syncClient.Receive(Encoding.Unicode); int receivedUpdates = 0; while (!subscriber.Receive(Encoding.Unicode).Equals("END")) { receivedUpdates++; } Console.WriteLine("Received {0} updates.", receivedUpdates); } } Console.ReadKey(); }
public Publisher(string _guid, string _host, int _port, ZmqContext _ctx) { guid = _guid; host = _host; port = _port; if (_ctx == null) { ctx = ZmqContext.Create(); } else { ctx = _ctx; } socket = ctx.CreateSocket(SocketType.PUB); var bindString = String.Empty; if (port > 0) { bindString = String.Format("tcp://*:{0}", port); } else { bindString = String.Format("inproc://{0}", guid.ToLower()); } socket.Bind(bindString); log.InfoFormat("Publisher successfuly binded on {0}", bindString); socket.SendHighWatermark = 1000000; socket.SendBufferSize = 128 * 1024; }
static void Main(string[] args) { using (var context = ZmqContext.Create()) { using (var subscriber = context.CreateSocket(ZeroMQ.SocketType.SUB)) using (var syncclient = context.CreateSocket(ZeroMQ.SocketType.REQ)) { //subscriber.Connect("tcp://172.16.73.88:3385"); subscriber.Connect("tcp://192.168.179.128:3385"); subscriber.SubscribeAll(); Thread.Sleep(1); //syncclient.Connect("tcp://172.16.73.88:4950"); syncclient.Connect("tcp://192.168.179.128:4950"); syncclient.SendFrame(new Frame(Encoding.UTF8.GetBytes("Sync me"))); var repMsg = Encoding.UTF8.GetString(syncclient.ReceiveFrame().Buffer); while (true) { var pubMsg = subscriber.ReceiveMessage(); Console.WriteLine(Encoding.UTF8.GetString(pubMsg[0].Buffer)); } } } }
static void Main(string[] args) { try { var options = new Options(); var parser = new CommandLineParser(new CommandLineParserSettings(Console.Error)); if (!parser.ParseArguments(args, options)) { Environment.Exit(1); } using (var ctx = ZmqContext.Create()) { using (var socket = ctx.CreateSocket(SocketType.PULL)) { foreach (var endPoint in options.bindEndPoints) { socket.Bind(endPoint); } while (true) { Thread.Sleep(options.delay); var msg = socket.Receive(Encoding.UTF8); Console.WriteLine("Received: " + msg); } } } } catch (Exception exp) { Console.WriteLine(exp.Message); } }
public ZmqPublisher(string endpoint) { _endpoint = endpoint; _context = ZmqContext.Create(); _socket = _context.CreateSocket(SocketType.PUB); _socket.Bind(_endpoint); }
public void Start(U startResponse) { try { using (var context = ZmqContext.Create()) { using (var socket = context.CreateSocket(SocketType.REQ)) { foreach (var connectEndpoint in _bindEndPoints) { socket.Connect(connectEndpoint); } var nextResponse = startResponse; while (true) { var responseFrame = new Frame(nextResponse.ToByteArray()); socket.SendFrame(responseFrame); var messageFrame = socket.ReceiveFrame(); var request = SerializationMethods.FromByteArray <T>(messageFrame.Buffer); var reply = _process(request); nextResponse = reply; } } } } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public static void Main(string[] args) { using (var context = ZmqContext.Create()) { using (ZmqSocket receiver = context.CreateSocket(SocketType.PULL), sender = context.CreateSocket(SocketType.PUSH)) { receiver.Connect("tcp://localhost:5557"); sender.Connect("tcp://localhost:5558"); while (true) { string task = receiver.Receive(Encoding.Unicode); // Simple progress indicator for the viewer; Console.WriteLine("{0}.", task); int sleepTime = Convert.ToInt32(task); Thread.Sleep(sleepTime); // Send 'result' to the sink sender.Send("", Encoding.Unicode); } } } }
private static void ClientTask() { using (var ctx = ZmqContext.Create()) { using (var client = ctx.CreateSocket(SocketType.REQ)) { ZHelpers.SetID(client, Encoding.Unicode); client.Connect("tcp://localhost:5555"); while (true) { // Send request, get repl client.Send("HELLO", Encoding.Unicode); string reply = client.Receive(Encoding.Unicode); if (string.IsNullOrEmpty(reply)) { break; } Console.WriteLine("Client: {0}", reply); } } } }
static void Main(string[] args) { using (ZmqContext context = ZmqContext.Create()) using (ZmqSocket server = context.CreateSocket(SocketType.SUB)) { server.SubscribeAll(); for (int i = 1; i < 255; i++) { string address = string.Format("tcp://192.168.11.{0}:9000", i); try { server.Connect(address); } catch { } } while (true) { // Wait for next request from client string message = server.Receive(Encoding.ASCII); Console.WriteLine("{0}: {1}", DateTime.Now.ToShortTimeString(), message); } } }
public void IsAConnection() { ZmqContext zmqContext = ZmqContext.Create(); Daytona.Store.Connection connection = new Daytona.Store.Connection(zmqContext); Assert.IsInstanceOfType(connection, typeof(Daytona.Store.Connection)); }
public ZmqOutboundSocket(ZmqContext context, PeerId peerId, string endPoint, IZmqSocketOptions options) { _context = context; _peerId = peerId; _options = options; EndPoint = endPoint; }
public void Start() { try { using (var context = ZmqContext.Create()) { using (var socket = context.CreateSocket(SocketType.PUSH)) { foreach (var bindEndPoint in _bindEndPoints) { socket.Connect(bindEndPoint); } while (true) { var message = _requests.Take(); var frame = new Frame(message.ToByteArray()); socket.SendFrame(frame); } } } } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public static void Main(string[] args) { using (var context = ZmqContext.Create()) { // Connect to task ventilator and weather server using (ZmqSocket receiver = context.CreateSocket(SocketType.PULL), subscriber = context.CreateSocket(SocketType.SUB)) { receiver.Connect("tcp://localhost:5557"); subscriber.Connect("tcp://localhost:5556"); subscriber.Subscribe(Encoding.Unicode.GetBytes("10001 ")); receiver.ReceiveReady += ReceiverPollInHandler; subscriber.ReceiveReady += SubscriberPollInHandler; var poller = new Poller(new List <ZmqSocket> { }); // Process messages from both sockets while (true) { poller.Poll(); } } } }
private static void ClientTask() { using (var ctx = ZmqContext.Create()) { using (var client = ctx.CreateSocket(SocketType.REQ)) { ZHelpers.SetID(client, Encoding.Unicode); client.Connect(localFeAddress); while (true) { client.Send("HELLO", Encoding.Unicode); string reply = client.Receive(Encoding.Unicode); if (string.IsNullOrEmpty(reply)) { break; } Console.WriteLine("Client: {0}", reply); Thread.Sleep(1000); } } } }
/// <summary> /// Starts the nodelet. /// </summary> /// <param name="options">The nodelet command options.</param> public void Start(Options options) { using (var context = ZmqContext.Create()) using (var subscriber = context.CreateSocket(SocketType.SUB)) { if (string.IsNullOrEmpty(options.SubscriptionChannel)) { Console.WriteLine("Subscribing to all channels."); subscriber.SubscribeAll(); } else { Console.WriteLine("Subscribing to: {0}", options.SubscriptionChannel); subscriber.Subscribe(Encoding.Unicode.GetBytes(options.SubscriptionChannel)); } var endpoint = string.Format("tcp://{0}", options.SocketConnect); Console.WriteLine("Connecting to: {0}", endpoint); subscriber.Connect(endpoint); while (true) { var message = subscriber.Receive(Encoding.Unicode); Console.WriteLine("Recieved message: {0}", message); } } }
internal ZmqMessageSender(Uri serviceUri) { context = ZmqContext.Create(); socket = context.CreateSocket(SocketType.REQ); var address = string.Format("tcp://{0}:{1}", serviceUri.Host, serviceUri.Port); socket.Connect(address); }
private static void WorkerTask() { using (var ctx = ZmqContext.Create()) { using (var worker = ctx.CreateSocket(SocketType.REQ)) { ZHelpers.SetID(worker, Encoding.Unicode); worker.Connect(localBeAddress); var msg = new ZMessage("READY"); msg.Send(worker); while (true) { var recvMsg = new ZMessage(worker); Console.WriteLine("Worker: {0}", recvMsg.BodyToString()); Thread.Sleep(1000); recvMsg.StringToBody("OK"); recvMsg.Send(worker); //var okmsg = new ZMessage("OK"); //okmsg.Send(worker); } } } }
public static void Main(string[] args) { using (var context = ZmqContext.Create()) { var randomizer = new Random(DateTime.Now.Millisecond); using (var server = context.CreateSocket(SocketType.REP)) { server.Bind("tcp://*:5555"); var cycles = 0; while (true) { var request = server.Receive(Encoding.Unicode); cycles++; if (cycles > 3 && randomizer.Next(2) == 0) { Console.WriteLine("Simulating a crash"); break; } else if (cycles < 3 && randomizer.Next(2) == 0) { Console.WriteLine("Simulating CPU overload"); Thread.Sleep(2000); } Console.WriteLine("Normal request ({0})", request); Thread.Sleep(1000); server.Send(request, Encoding.Unicode); } } } }
private static void WorkerTask() { using (var context = ZmqContext.Create()) { using (ZmqSocket worker = context.CreateSocket(SocketType.REQ)) { ZHelpers.SetID(worker, Encoding.Unicode); worker.Connect("tcp://localhost:5556"); // Tell broker we're ready for work worker.Send("READY", Encoding.Unicode); while (true) { // Read and save all frames until we get an empty frame // In this example there is only 1 but it could be more string address = worker.Receive(Encoding.Unicode); string empty = worker.Receive(Encoding.Unicode); // Get request, send reply string request = worker.Receive(Encoding.Unicode); Console.WriteLine("Worker: {0}", request); worker.SendMore(address, Encoding.Unicode); //worker.SendMore(); worker.Send("OK", Encoding.Unicode); } } } }
private static ZmqSocket GetConnectedPublishSocket(ZmqContext context) { ZmqSocket publisher = context.CreateSocket(SocketType.PUB); publisher.Connect("tcp://localhost:5556"); return(publisher); }
public static void Main(string[] args) { using (var context = ZmqContext.Create()) { using (ZmqSocket publisher = context.CreateSocket(SocketType.PUB)) { // your first potential issue lies here, if you're not // populating your addresses properly then you're not going to // bind appropriately // Test by hard coding the address publisher.Bind("tcp://127.0.0.1:5000"); int msgIndex = 0; while (true) { // your second potential issue lies here, if your logic // short circuits your send, that'll throw a wrench in the // works // Test by removing the logic and just sending a bunch of // messages var msg = "Message: " + msgIndex; // simplify Console.WriteLine("Publishing: " + msg); socket.Send(msg, Encoding.UTF8); Thread.Sleep(500); // hard code msgIndex++; if (msgIndex > 1500) { break; // hard code the break } } } } }
private static string Sender(string input) { using (var context = ZmqContext.Create()) { using (ZmqSocket pub = Helper.GetConnectedPublishSocket(context, Pipe.PublishAddressClient), syncService = context.CreateSocket(SocketType.REP)) { //syncService.Connect(Pipe.PubSubControlFrontAddressClient); //for (int i = 0; i < 1; i++) //{ // syncService.Receive(Encoding.Unicode); // syncService.Send("", Encoding.Unicode); //} for (int i = 0; i < 100000; i++) { Console.WriteLine("Enter to send message=>"); input = Console.ReadLine(); SendMessage(Pipe.ControlChannelEncoding.GetBytes(Pipe.SubscriberCountAddress), Pipe.ControlChannelEncoding.GetBytes("ADDSUBSCRIBER"), pub); if (input == "Exit") { break; } Console.WriteLine("message sent"); } Console.WriteLine("message sent enter to exit=>"); input = Console.ReadLine(); } } return(input); }
public static void Main(string[] args) { using (var context = ZmqContext.Create()) { using (ZmqSocket publisher = context.CreateSocket(SocketType.PUB)) { publisher.Bind("tcp://*:5556"); var randomizer = new Random(DateTime.Now.Millisecond); while (true) { // Get values that will fool the boss int zipcode = randomizer.Next(0, 100000); int temperature = randomizer.Next(-80, 135); int relativeHumidity = randomizer.Next(10, 60); string update = zipcode.ToString() + " " + temperature.ToString() + " " + relativeHumidity.ToString(); // Send message to 0..N subscribers via a pub socket publisher.Send(update, Encoding.Unicode); } } } }
public void Start() { try { using (var context = ZmqContext.Create()) { using (var socket = context.CreateSocket(SocketType.PULL)) { foreach (var bindEndPoint in _bindEndPoints) { socket.Bind(bindEndPoint); } while (true) { var messageFrame = socket.ReceiveFrame(); var request = SerializationMethods.FromByteArray <T>(messageFrame.Buffer); _process(request); } } } } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public Subscriber(string _guid, string _targetGuid, string _host, int _port, ZmqContext _ctx) { guid = _guid; targetGuid = _targetGuid; host = _host; port = _port; if (port > 0) connectionString = String.Format("tcp://{0}:{1}", host, port); else connectionString = String.Format("inproc://{0}", targetGuid.ToLower()); buf = new byte[1024 * 1024]; subscribeChannels = new List<string>(); if (_ctx == null) { shardedCtx = false; ctx = ZmqContext.Create(); } else { shardedCtx = true; ctx = _ctx; } socket = ctx.CreateSocket(SocketType.SUB); if (log.IsDebugEnabled) log.DebugFormat("Subscriber connecting to: `{0}`", connectionString); socket.Subscribe(Proxy.StringToByteArray(guid)); socket.Connect(connectionString); socket.ReceiveHighWatermark = 1000000; socket.ReceiveBufferSize = 128 * 1024; lastActiveTime = Proxy.Unixtimestamp(); log.InfoFormat("Connected successfuly to: `{0}` `{1}`", connectionString, targetGuid); }
public static void Main(string[] args) { using (var context = ZmqContext.Create()) { using (ZmqSocket receiver = context.CreateSocket(SocketType.PULL), controller = context.CreateSocket(SocketType.PUB)) { receiver.Bind("tcp://*:5558"); controller.Bind("tcp://*:5559"); // Wait for start of batch receiver.Receive(Encoding.Unicode); var stopwatch = new Stopwatch(); stopwatch.Start(); const int tasksToConfirm = 100; for (int taskNumber = 0; taskNumber < tasksToConfirm; taskNumber++) { string message = receiver.Receive(Encoding.Unicode); Console.WriteLine(taskNumber % 10 == 0 ? ":" : "."); } stopwatch.Stop(); Console.WriteLine("Total elapsed time: {0}", stopwatch.ElapsedMilliseconds); controller.Send("KILL", Encoding.Unicode); } } }
public void Start() { var zmqVersion = ZmqUtil.GetVersion(); _logger.InfoFormat("Loaded ZMQ v{0}", zmqVersion.ToString(3)); if (zmqVersion.Major != 4) { throw new InvalidOperationException($"Expected ZMQ v4.*, loaded ZMQ v{zmqVersion.ToString(3)}"); } _isListening = true; _outboundSockets = new ConcurrentDictionary <PeerId, ZmqOutboundSocket>(); _outboundSocketActions = new BlockingCollection <OutboundSocketAction>(); _pendingDisconnects = new BlockingCollection <PendingDisconnect>(); _context = new ZmqContext(); var startSequenceState = new InboundProcStartSequenceState(); _inboundThread = BackgroundThread.Start(InboundProc, startSequenceState); _outboundThread = BackgroundThread.Start(OutboundProc); _disconnectThread = BackgroundThread.Start(DisconnectProc); startSequenceState.Wait(); _isRunning = true; }
static void Main(string[] args) { // Prepare our context using (ZmqContext context = ZmqContext.Create()) { // Sockets to send and receive messages on using (ZmqSocket receiver = context.CreateSocket(SocketType.PULL), sender = context.CreateSocket(SocketType.PUSH)) { receiver.Connect("tcp://localhost:5557"); sender.Connect("tcp://localhost:5558"); // Process tasks forever while (true) { string message = receiver.Receive(Encoding.Unicode); // Simple progress indicator for the viewer Console.Clear(); Console.WriteLine("{0}.", message); // Do the work Thread.Sleep(Convert.ToInt32(message)); // Send results to sink sender.Send("", Encoding.Unicode); } } } }
static void Main(string[] args) { var options = new Options(); var parser = new CommandLineParser(new CommandLineParserSettings(Console.Error)); if (!parser.ParseArguments(args, options)) { Environment.Exit(1); } using (var context = ZmqContext.Create()) { using (var socket = context.CreateSocket(SocketType.REP)) { foreach (var bindEndPoint in options.bindEndPoints) { socket.Bind(bindEndPoint); } while (true) { Thread.Sleep(options.delay); var rcvdMsg = socket.Receive(Encoding.UTF8); Console.WriteLine("Received: " + rcvdMsg); var replyMsg = options.replyMessage.Replace("#msg#", rcvdMsg); Console.WriteLine("Sending : " + replyMsg + Environment.NewLine); socket.Send(replyMsg, Encoding.UTF8); } } } }
public Broker(CancellationToken token, ZmqContext ctx) { _token = token; var ready = new TaskCompletionSource <bool>(); Task.Factory.StartNew(() => start(ctx, ready)); }
public void Start() { subThread = new BackgroundWorker(); subThread.DoWork += new DoWorkEventHandler(subThread_DoWork); subThread.RunWorkerAsync(); using (var ctx = ZmqContext.Create()) { using (var socket = ctx.CreateSocket(SocketType.PUB)) { socket.Bind("tcp://127.0.0.1:5000"); while (true) { Thread.Sleep(1000); // Create a ZmqMessage containing 3 frames ZmqMessage zmqMessage = new ZmqMessage(); zmqMessage.Append(new Frame(Encoding.UTF8.GetBytes("My Frame 01"))); zmqMessage.Append(new Frame(Encoding.UTF8.GetBytes("My Frame 02"))); zmqMessage.Append(new Frame(Encoding.UTF8.GetBytes("My Frame 03"))); Console.WriteLine("PUB; publishing: "); foreach (var msg in zmqMessage) { Console.WriteLine("\t" + Encoding.UTF8.GetString(msg)); } socket.SendMessage(zmqMessage); } } } }
private static void Open(Object cancelationToken) { context = ZmqContext.Create(); frontend = context.CreateSocket(SocketType.ROUTER); backend = context.CreateSocket(SocketType.DEALER); backend.Identity = Encoding.UTF8.GetBytes("inproc://workers"); frontend.Bind("tcp://127.0.0.1:5000"); backend.Bind("inproc://workers"); workerThreads = new Thread[2]; for (int threadId = 0; threadId < workerThreads.Length; threadId++) { workerThreads[threadId] = new Thread(WorkerRoutine); workerThreads[threadId].Start(context); } frontend.ReceiveReady += new EventHandler<SocketEventArgs>(frontend_ReceiveReady); backend.ReceiveReady += new EventHandler<SocketEventArgs>(backend_ReceiveReady); Poller poller = new Poller(new[] { frontend, backend }); var token = (CancellationToken)cancelationToken; while (!token.IsCancellationRequested) { poller.Poll(TimeSpan.FromMilliseconds(100)); } }
/// <summary> /// Initializes a new instance of the <see cref="ForwarderDevice"/> class. /// </summary> /// <param name="context">The <see cref="ZmqContext"/> to use when creating the sockets.</param> /// <param name="frontendBindAddr">The address used to bind the frontend socket.</param> /// <param name="backendBindAddr">The endpoint used to bind the backend socket.</param> /// <param name="mode">The <see cref="DeviceMode"/> for the current device.</param> public XForwarderDevice(ZmqContext context, string frontendBindAddr, string backendBindAddr, DeviceMode mode) : this(context, mode) { FrontendSetup.Bind(frontendBindAddr); FrontendSetup.SubscribeAll(); BackendSetup.Bind(backendBindAddr); }
public ClientForm() { InitializeComponent(); context = ZmqContext.Create(); client = context.CreateSocket(SocketType.REQ); client.Connect("tcp://localhost:5555"); }
public MessageReceiver(ZmqContext context) { m_Context = context; m_Lock = new object(); m_MessageThread = new Thread(SubscribeAndWait); }
public Server(string id, CancellationToken token, ZmqContext ctx) { _id = id; _token = token; var ready = new TaskCompletionSource<bool>(); Task.Factory.StartNew(() => start(ctx, ready)); ready.Task.Wait(); }
public ZeroMqMessagePublisher(ZmqContext context) { Console.WriteLine("Hey there"); _pub = context.CreateSocket(SocketType.PUB); _pub.Bind("tcp://*:5555"); Console.WriteLine("Hello"); }
public ZmqInboundSocket(ZmqContext context, PeerId peerId, ZmqEndPoint originalEndpoint, IZmqSocketOptions options, string environment) { _context = context; _peerId = peerId; _originalEndpoint = originalEndpoint; _options = options; _environment = environment; }
public MessageSender(ZmqContext context) { m_Context = context; m_MessageBuffer = new ConcurrentQueue<string>(); m_MessageThread = new Thread(OnThreadStarted); m_MessageThread.Start(); }
public ZmqSubscriber(string endpoint) { _endpoint = endpoint; _context = ZmqContext.Create(); BufferSize = 1024; ConnectSocket(); }
/// <summary> /// Initializes a new instance of the <see cref="ZmqMessageServer"/> class. /// </summary> /// <param name="messageReceiver">The message receiver.</param> /// <param name="port">The port.</param> internal ZmqMessageServer(IMessageReceiver messageReceiver, int port) { tokenSource = new CancellationTokenSource(); this.port = port; this.messageReceiver = messageReceiver; context = ZmqContext.Create(); responseQueue = new ZmqResponseQueue(context, port); }
/// <summary> /// Constructor. /// </summary> public MessagingClient() { // We create the ZMQ context, and a socket to listen to messages... m_context = ZmqContext.Create(); // We start processing messages on a worker thread... m_workerThread = new Thread(processMessages); m_workerThread.Start(); }
//ORDER_CONFIRMATION_TR private NNFHandler() { // MessageBox.Show("Trying Connect to NNF "); context = ZmqContext.Create(); _ctsCancellationTokenSource = new CancellationTokenSource(); ///////// ///// }
public void Start() { _context = ZmqContext.Create(); _commandReceiver = _context.CreateSocket(SocketType.REP); _commandReceiver.Bind("tcp://*:7777"); _dequeueReceiver = _context.CreateSocket(SocketType.PUB); _dequeueReceiver.Bind("tcp://*:7778"); StartListener(); }
private Worker(string address, uint servicePort, string workerId, ZmqContext context = null) : base(context) { _frozen = false; _address = address; _resolvers = new List<MethodCallResolver>(); _requestProcessors = new List<IRequestProcessor>(); _servicePort = servicePort; _working = false; _workerId = workerId; }
public Router(uint frontendPort, uint backendPort, ZmqContext context) : base(context) { _stopCommandToken = Guid.NewGuid().ToString(); _routing = false; // stick on there address first until need for multihomed/bridging the different network _backendAddress = "*"; _frontendAddress = "*"; _frontendPort = frontendPort; _backendPort = backendPort; }
private static ZmqSocket CreateServerSocket(ZmqContext context) { Console.WriteLine("Connecting to server..."); var client = context.CreateSocket(SocketType.REQ); client.Connect(serverEndpoint); client.Linger = TimeSpan.Zero; client.ReceiveReady += PollInHandler; return client; }
public void Dispose() { if (_socket != null) { _socket.Dispose(); _socket = null; } if (_context != null) { _context.Dispose(); _context = null; } }
/// <summary> /// Create a new Host Interface server. /// </summary> /// <param name="port">Port to bind to.</param> public HostInterface(int port, INodeController controller) { log.Info("Host server interface launching..."); this.port = port; context = ZmqContext.Create(); server = context.CreateSocket(SocketType.ROUTER); server.TcpKeepalive = TcpKeepaliveBehaviour.Enable; this.controller = controller; var controllerPortal = new ControllerPortal(); controllerPortal.SetNodeID(0); controller.Initialize(controllerPortal); Instance = this; }
public JsonRpcZmqBase(ZmqContext context = null) { _ownedContext = true; _disposed = false; if (context != null) { _context = context; _ownedContext = false; } Active = false; }
public GrapevineSender(ZmqContext context, string address, IMessageSerializer serializer) { _serializer = serializer; _scheduler = new EventLoopScheduler(); _socket = context.CreateSocket(SocketType.PUB); _socket.Connect(address); _messages = new Subject<ZmqMessage>(); _messageDispatcher = _messages .SubscribeOn(_scheduler) .ObserveOn(_scheduler) .Subscribe(msg => _socket.SendMessage(msg)); }
protected override void Dispose(bool disposing) { if (disposing && socket != null) { socket.Dispose(); socket = null; } if (disposing && context != null) { context.Dispose(); context = null; } }
public ForwarderService(string frontend, string backend) { _logger.Info("Creating 0mq context."); _context = ZmqContext.Create(); _logger.Info("done."); _logger.Info("Creating 0mq forwarder device."); _forwarder = new ForwarderDevice(_context, frontend, backend, DeviceMode.Threaded); _logger.Info("done."); _logger.Info("Subscribe all on frontend."); _forwarder.FrontendSetup.SubscribeAll(); _logger.Info("done."); }
private void doStartServer(ZmqContext context) { using (var server = context.CreateSocket(SocketType.REP)) { server.Bind("tcp://127.0.0.1:87"); while (true) { var name = server.Receive(Encoding.Unicode); server.Send(DateTime.Now.ToString() + " - " + name, Encoding.Unicode); Console.WriteLine("Processed request from {0}", name); } } }
private void doStartClient(ZmqContext zmqContext, string name) { using (var client = zmqContext.CreateSocket(SocketType.REQ)) { client.Connect("tcp://127.0.0.1:87"); while (true) { client.Send(name, Encoding.Unicode); var response = client.Receive(Encoding.Unicode); Task.Delay(2000).Wait(); } } }
public void Dispose() { if (Running) StopServer(); if (_socket != null) { _socket.Dispose(); _socket = null; } if (_context != null) { _context.Dispose(); _context = null; } }
public void Dispose() { if (!_disposed) { Stop(); if (_context != null) { _context.Dispose(); _context = null; } GC.SuppressFinalize(this); _disposed = true; } }