public void Run(PairSocket shim)
{
shim.SignalOK();
while (true)
{
try
{
NetMQMessage msg = shim.ReceiveMultipartMessage();
string command = msg[0].ConvertToString();
if (command == NetMQActor.EndShimMessage)
{
break;
}
//Simulate a failure that should be sent back to Actor
throw new InvalidOperationException("Actors Shim threw an Exception");
}
//You WILL need to decide what Exceptions should be caught here, this is for
//demonstration purposes only, any unhandled fault will bubble up to caller's code
catch (InvalidOperationException e)
{
shim.Send(string.Format("Error: Exception occurred {0}", e.Message));
}
}
}
private void Run(PairSocket shim)
{
m_shim = shim;
shim.ReceiveReady += OnShimMessage;
m_timeoutTimer = new NetMQTimer(TimeOut);
m_timeoutTimer.Elapsed += OnTimeoutTimer;
m_reconnectTimer = new NetMQTimer(ReconnectTimer);
m_reconnectTimer.Elapsed += OnReconnectTimer;
m_poller = new Poller(shim);
m_poller.AddTimer(m_timeoutTimer);
m_poller.AddTimer(m_reconnectTimer);
shim.SignalOK();
Connect();
m_poller.PollTillCancelled();
if (m_subscriber != null)
{
m_subscriber.Dispose();
}
}
private void Run(PairSocket shim)
{
using (m_publisherSocket = new XPublisherSocket(m_address))
{
m_publisherSocket.SetWelcomeMessage(WelcomeMessage);
m_publisherSocket.ReceiveReady += DropPublisherSubscriptions;
m_heartbeatTimer = new NetMQTimer(HeartbeatInterval);
m_heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
shim.ReceiveReady += OnShimMessage;
// signal the actor that the shim is ready to work
shim.SignalOK();
m_poller = new NetMQPoller {
m_publisherSocket, shim
};
m_poller.Add(m_heartbeatTimer);
// Polling until poller is cancelled
m_poller.Run();
}
}
public void RunPipeline(PairSocket shim)
{
publisherSocket = context.CreatePublisherSocket();
publisherSocket.Bind("tcp://*:" + StreamingProtocol.Port);
snapshotSocket = context.CreateResponseSocket();
snapshotSocket.Bind("tcp://*:" + SnapshotProtocol.Port);
snapshotSocket.ReceiveReady += OnSnapshotReady;
shim.ReceiveReady += OnShimReady;
heartbeatTimer = new NetMQTimer(StreamingProtocol.HeartbeatInterval);
heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
shim.SignalOK();
poller = new Poller();
poller.AddSocket(shim);
poller.AddSocket(snapshotSocket);
poller.AddTimer(heartbeatTimer);
poller.Start();
publisherSocket.Dispose();
snapshotSocket.Dispose();
}
private void RunActor(PairSocket shim)
{
_shim = shim;
using (_subscriber = new SubscriberSocket())
using (_publisher = new PublisherSocket())
{
using (_beacon = new NetMQBeacon())
{
_shim.ReceiveReady += OnShimReady;
_subscriber.Subscribe(string.Empty);
_port = _subscriber.BindRandomPort("tcp://*");
_logger?.LogInformation($"{_id}: Peer bus is bound to {{BusPort}}", _port);
_subscriber.ReceiveReady += OnSubscriberReady;
_logger?.LogInformation($"{_id}: Peer is broadcasting UDP on port {{BeaconPort}}", _beaconPort);
_beacon.Configure(_beaconPort);
_beacon.Publish(_port.ToString(), _beaconInterval);
_beacon.Subscribe(string.Empty);
_beacon.ReceiveReady += OnBeaconReady;
var cleanupTimer = new NetMQTimer(_cleanupInterval);
cleanupTimer.Elapsed += Cleanup;
_poll = new NetMQPoller {
_shim, _subscriber, _beacon, cleanupTimer
};
_shim.SignalOK();
_poll.Run();
}
}
}
public void Run(PairSocket shim)
{
m_pipe = shim;
shim.SignalOK();
m_pipe.ReceiveReady += OnPipeReady;
m_pingTimer = new NetMQTimer(interval: TimeSpan.Zero);
m_pingTimer.Elapsed += PingElapsed;
m_pingTimer.Enable = false;
using (m_poller = new NetMQPoller {
m_pipe, m_pingTimer
})
{
m_poller.Run();
}
// the beacon might never been configured
#if NET35
m_udpSocket?.Close();
#else
m_udpSocket?.Dispose();
#endif
}
private void Run(PairSocket shim)
{
_shim = shim;
using (_publisherSocket = new XPublisherSocket())
{
_publisherSocket.SetWelcomeMessage(WelcomeMessage);
_publisherSocket.Bind(_address);
_publisherSocket.ReceiveReady += DropPublisherSubscriptions;
_heartbeatTimer = new NetMQTimer(_heartbeatInterval);
_heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
if (_receiveTimeout > 0)
{
_receiveTimeoutTimer = new NetMQTimer(1000);
_receiveTimeoutTimer.Enable = false;
_receiveTimeoutTimer.Elapsed += OnReceiveTimeout;;
}
shim.ReceiveReady += OnShimMessage;
// signal the actor that the shim is ready to work
shim.SignalOK();
_poller = new NetMQPoller {
_publisherSocket, shim, _heartbeatTimer, _receiveTimeoutTimer
};
// Polling until poller is cancelled
_poller.Run();
}
}
public void RequestStop()
{
lock (m_writer)
{
m_writer.SignalOK();
}
}
public void Run(PairSocket shim)
{
shim.SignalOK();
shim.ReceiveReady += OnShimReady;
m_messagesPipe = new PairSocket();
m_messagesPipe.Connect(string.Format("inproc://wsrouter-{0}", m_id));
m_messagesPipe.ReceiveReady += OnMessagePipeReady;
m_stream = new StreamSocket();
m_stream.ReceiveReady += OnStreamReady;
m_poller = new NetMQPoller();
m_poller.Add(m_messagesPipe);
m_poller.Add(shim);
m_poller.Add(m_stream);
m_messagesPipe.SignalOK();
m_poller.Run();
m_messagesPipe.Dispose();
m_stream.Dispose();
}
private void RunActor(PairSocket shim)
{
// save the shim to the class to use later
m_shim = shim;
// create all subscriber, publisher and beacon
using (m_subscriber = new SubscriberSocket())
using (m_publisher = new PublisherSocket())
using (m_beacon = new NetMQBeacon())
{
// listen to actor commands
m_shim.ReceiveReady += OnShimReady;
// subscribe to all messages
m_subscriber.Subscribe("");
// we bind to a random port, we will later publish this port
// using the beacon
m_randomPort = m_subscriber.BindRandomPort("tcp://*");
Console.WriteLine("Bus subscriber is bound to {0}", m_subscriber.Options.LastEndpoint);
// listen to incoming messages from other publishers, forward them to the shim
m_subscriber.ReceiveReady += OnSubscriberReady;
// configure the beacon to listen on the broadcast port
Console.WriteLine("Beacon is being configured to UDP port {0}", m_broadcastPort);
m_beacon.Configure(m_broadcastPort);
// publishing the random port to all other nodes
Console.WriteLine("Beacon is publishing the Bus subscriber port {0}", m_randomPort);
m_beacon.Publish(m_randomPort.ToString(), TimeSpan.FromSeconds(1));
// Subscribe to all beacon on the port
Console.WriteLine("Beacon is subscribing to all beacons on UDP port {0}", m_broadcastPort);
m_beacon.Subscribe("");
// listen to incoming beacons
m_beacon.ReceiveReady += OnBeaconReady;
// Create a timer to clear dead nodes
NetMQTimer timer = new NetMQTimer(TimeSpan.FromSeconds(1));
timer.Elapsed += ClearDeadNodes;
// Create and configure the poller with all sockets and the timer
m_poller = new NetMQPoller {
m_shim, m_subscriber, m_beacon, timer
};
// signal the actor that we finished with configuration and
// ready to work
m_shim.SignalOK();
// polling until cancelled
m_poller.Run();
}
}
public void Run(PairSocket shim)
{
this.shim = shim;
shim.ReceiveReady += OnShimReady;
shim.SignalOK();
poller = new NetMQPoller {
shim
};
poller.Run();
}
private void Run(PairSocket shim)
{
shim.ReceiveReady += OnShimReady;
m_receiveSocket.ReceiveReady += OnSocketReady;
m_poller = new NetMQPoller { m_receiveSocket, shim };
shim.SignalOK();
m_poller.Run();
m_receiveSocket.ReceiveReady -= OnSocketReady;
}
public void Run(PairSocket shim)
{
shim.SignalOK();
while (true)
{
try
{
//Message for this actor/shim handler is expected to be
//Frame[0] : Command
//Frame[2] : AccountAction as JSON
//Frame[1] : Account as JSON
//
//Result back to actor is a JSON message of the amended Account
NetMQMessage msg = shim.ReceiveMultipartMessage();
string command = msg[0].ConvertToString();
if (command == NetMQActor.EndShimMessage)
{
break;
}
if (msg[0].ConvertToString() == "AMEND ACCOUNT")
{
string accountActionJson = msg[1].ConvertToString();
var accountAction = JsonConvert.DeserializeObject <AccountAction>(accountActionJson);
string accountJson = msg[2].ConvertToString();
var account = JsonConvert.DeserializeObject <Account>(accountJson);
if (account != null && accountAction != null)
{
AmendAccount(accountAction, account);
shim.SendFrame(JsonConvert.SerializeObject(account));
}
else
{
shim.SendFrame("Error: incorrectly formatted message to actor");
}
}
else
{
shim.SendFrame("Error: invalid message to actor");
}
}
// You WILL need to decide what Exceptions should be caught here, this is for
// demonstration purposes only, any unhandled fault will bubble up to caller's code.
catch (Exception e)
{
shim.SendFrame($"Error: Exception occurred {e.Message}");
}
}
}
private void Run(PairSocket shim)
{
shim.ReceiveReady += OnShimReady;
m_receiveSocket.ReceiveReady += OnSocketReady;
m_poller = new NetMQPoller {
m_receiveSocket, shim
};
shim.SignalOK();
m_poller.Run();
m_receiveSocket.ReceiveReady -= OnSocketReady;
}
public void Run(PairSocket shim)
{
_poller = new NetMQPoller();
_ = Observable.FromEventPattern <NetMQSocketEventArgs>(e => shim.ReceiveReady += e, e => shim.ReceiveReady -= e)
.Select(e => e.EventArgs)
.Subscribe(OnShimReady);
_poller.Add(shim);
// Timer
var timeoutTimer = new NetMQTimer(TimeSpan.FromSeconds(5));
_ = Observable.FromEventPattern <NetMQTimerEventArgs>(e => timeoutTimer.Elapsed += e, e => timeoutTimer.Elapsed -= e)
.Select(e => e.EventArgs)
.ObserveOn(ThreadPoolScheduler.Instance)
.Subscribe(OnTimeoutElapsed);
_poller.Add(timeoutTimer);
_subscriberSocket = new SubscriberSocket();
_subscriberSocket.Options.Linger = TimeSpan.Zero;
_subscriberSocket.Subscribe(CoreHearbeatTopic);
_subscriberSocket.Connect($"tcp://{_address}:{_port + 1}");
_subject.OnNext(ConnectionStatus.Connecting);
_ = Observable.FromEventPattern <NetMQSocketEventArgs>(e => _subscriberSocket.ReceiveReady += e, e => _subscriberSocket.ReceiveReady -= e)
.Select(e => e.EventArgs)
.Where(e => e.Socket.ReceiveFrameString() == CoreHearbeatTopic)
.ObserveOn(ThreadPoolScheduler.Instance)
.Subscribe(e =>
{
timeoutTimer.Reset();
Thread.MemoryBarrier();
var status = _borgConnected
? (ConnectionStatus.Online | ConnectionStatus.Connected)
: (ConnectionStatus.Online | ConnectionStatus.Disconnected);
_subject.OnNext(status);
});
_poller.Add(_subscriberSocket);
timeoutTimer.Reset();
shim.SignalOK();
_poller.Run();
// Cleanup stuff after stopping
_poller.Remove(_subscriberSocket);
_poller.Remove(timeoutTimer);
_poller.Remove(shim);
_poller.Dispose();
}
void IShimHandler.Run(PairSocket pipe)
{
_pipe = pipe;
_pipe.SignalOK();
_pipe.ReceiveReady += OnPipeReady;
_zre = Zre.Create(_ctx, _name);
_zre.ReceiveReady += OnZreReady;
_poller = new Poller();
_poller.AddSocket(_zre);
_poller.AddSocket(_pipe);
_poller.PollTillCancelled();
}
private NetMQActor CreateActor()
{
return(NetMQActor.Create(shim =>
{
Shim = shim;
Shim.ReceiveReady += ShimOnReceiveReady;
Poller.Add(ListeningSocket);
Poller.Add(InitTimer);
Poller.Add(Shim);
Shim.SignalOK();
Poller.Run();
}));
}
void IShimHandler.Run(PairSocket shim)
{
_pipe = shim;
_pipe.SignalOK();
_pipe.ReceiveReady += OnPipeReady;
_timer = new NetMQTimer(TimeSpan.FromSeconds(1));
_timer.Elapsed += OnPingPeer;
_inbox = _context.CreateRouterSocket();
_inbox.ReceiveReady += OnInboxReady;
_poller = new Poller(_pipe);
_poller.AddTimer(_timer);
_poller.PollTillCancelled();
}
public void RunPipeline(PairSocket shim)
{
shim.SignalOK();
while (true)
{
try
{
//Message for this actor/shim handler is expected to be
//Frame[0] : Command
//Frame[2] : AccountAction as JSON
//Frame[1] : Account as JSON
//
//Result back to actor is a JSON message of the amended Account
NetMQMessage msg = shim.ReceiveMessage();
string command = msg[0].ConvertToString();
if (command == ActorKnownMessages.END_PIPE)
{
break;
}
if (msg[0].ConvertToString() == "AMEND ACCOUNT")
{
string accountActionJson = msg[1].ConvertToString();
AccountAction accountAction = JsonConvert.DeserializeObject <AccountAction>(accountActionJson);
string accountJson = msg[2].ConvertToString();
Account account = JsonConvert.DeserializeObject <Account>(accountJson);
AmmendAccount(accountAction, account);
shim.Send(JsonConvert.SerializeObject(account));
}
else
{
shim.Send("Error: invalid message to actor");
}
}
//You WILL need to decide what Exceptions should be caught here, this is for
//demonstration purposes only, any unhandled falut will bubble up to callers code
catch (Exception e)
{
shim.Send(string.Format("Error: Exception occurred {0}", e.Message));
}
}
}
void IShimHandler.Run(PairSocket shim)
{
Poller = new NetMQPoller();
Shim = shim;
Shim.ReceiveReady += OnShimReady;
Poller.Add(Shim);
Initialize();
Shim.SignalOK();
Poller.Run();
Cleanup();
}
private void Run(PairSocket shim)
{
using (var router = new RouterSocket())
{
router.Bind(_address);
router.ReceiveReady += SendSnapshot;
shim.ReceiveReady += OnShimMessage;
// signal the actor that the shim is ready to work
shim.SignalOK();
_poller = new NetMQPoller {
router, _actor
};
_poller.Run();
}
}
public void Run(PairSocket shim)
{
using (subscriberSocket = new SubscriberSocket())
{
subscriberSocket.Options.ReceiveHighWatermark = 1000;
subscriberSocket.ReceiveReady += ResultSubscriber_ReceiveReady;
subscriberSocket.Connect(connectionString);
subscriberSocket.Subscribe(""); //Subscribe to all messages
this.shim = shim;
shim.ReceiveReady += OnShimReady;
shim.SignalOK();
poller = new NetMQPoller {
shim, subscriberSocket
};
poller.Run();
}
}
private void Run(PairSocket shim)
{
using (_publisherSocket = new PublisherSocket(_address))
{
//_publisherSocket.Bind(_address);
//_publisherSocket.ReceiveReady += DropPublisherSubscriptions;
shim.ReceiveReady += OnShimMessage;
_heartbeatTimer = new NetMQTimer(TimeSpan.FromSeconds(10));
_heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
// signal the actor that the shim is ready to work
shim.SignalOK();
_poller = new NetMQPoller {
shim, _publisherSocket, _heartbeatTimer
};
_poller.Run();
}
}
public void RunPipeline(PairSocket shim)
{
shim.SignalOK();
while (true)
{
try
{
//Message for this actor/shim handler is expected to be
//Frame[0] : Command
//Frame[1] : Payload
//
//Result back to actor is a simple echoing of the Payload, where
//the payload is prefixed with "ECHO BACK "
NetMQMessage msg = shim.ReceiveMessage();
string command = msg[0].ConvertToString();
if (command == ActorKnownMessages.END_PIPE)
{
break;
}
if (command == "ECHO")
{
shim.Send(string.Format("ECHO BACK : {0}",
msg[1].ConvertToString()));
}
else
{
shim.Send("Error: invalid message to actor");
}
}
//You WILL need to decide what Exceptions should be caught here, this is for
//demonstration purposes only, any unhandled falut will bubble up to callers code
catch (Exception e)
{
shim.Send(string.Format("Error: Exception occurred {0}", e.Message));
}
}
}
/// <summary>
/// Execute the shimhandler's Run method, signal ok and then dispose of the shim.
/// </summary>
private void RunShim()
{
try
{
m_shimHandler.Run(m_shim);
}
catch (TerminatingException)
{}
// Do not block, if the other end of the pipe is already deleted
m_shim.Options.SendTimeout = TimeSpan.Zero;
try
{
m_shim.SignalOK();
}
catch (AgainException)
{}
m_shim.Dispose();
}
public void Run(PairSocket shim)
{
shim.SignalOK();
while (true)
{
try
{
//Message for this actor/shim handler is expected to be
//Frame[0] : Command
//Frame[1] : Payload
//
//Result back to actor is a simple echoing of the Payload, where
//the payload is prefixed with "ECHO BACK "
NetMQMessage msg = shim.ReceiveMultipartMessage();
string command = msg[0].ConvertToString();
switch (command)
{
case NetMQActor.EndShimMessage:
return;
case "ECHO":
shim.SendFrame($"ECHO BACK : {msg[1].ConvertToString()}");
break;
default:
shim.SendFrame("Error: invalid message to actor");
break;
}
}
// You WILL need to decide what Exceptions should be caught here, this is for
// demonstration purposes only, any unhandled fault will bubble up to caller's code
catch (Exception e)
{
shim.SendFrame($"Error: Exception occurred {e.Message}");
}
}
}
public void RunPipeline(PairSocket shim)
{
shim.SignalOK();
shim.ReceiveReady += OnShimReady;
m_messagesPipe = m_context.CreatePairSocket();
m_messagesPipe.Connect(string.Format("inproc://wsrouter-{0}", m_id));
m_messagesPipe.ReceiveReady += OnMessagePipeReady;
m_stream = m_context.CreateStreamSocket();
m_stream.ReceiveReady += OnStreamReady;
m_poller = new Poller(m_messagesPipe, shim, m_stream);
m_messagesPipe.SignalOK();
m_poller.Start();
m_messagesPipe.Dispose();
m_stream.Dispose();
}
public void Run(PairSocket shim)
{
string shimAdd = $"inproc://wsrouter-{Id}";
Monitor.Enter(this);
try
{
isRuning = true;
shim.SignalOK();
shim.ReceiveReady += OnShimReady;
MessagesPipe = new PairSocket();
MessagesPipe.Connect(shimAdd);
MessagesPipe.ReceiveReady += OnMessagePipeReady;
Stream = new StreamSocket();
Stream.Bind(Address);
Stream.ReceiveReady += OnStreamReady;
Poller = new NetMQPoller
{
MessagesPipe,
shim,
Stream
};
MessagesPipe.SignalOK();
Poller.Run();
shim.Dispose();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
Monitor.Exit(this);
}
}
/// <summary>
/// This method is being run asynchronously by m_actor.
/// </summary>
/// <param name="shim"></param>
private void RunActor(PairSocket shim)
{
_pipe = shim;
_pipe.ReceiveReady += OnPipeReceiveReady;
var reapTimer = new NetMQTimer(TimeSpan.FromMilliseconds(1000));
reapTimer.Elapsed += OnReapTimerElapsed;
// Start poller, but poll only the _pipe. Start() and Stop() will add/remove other items to poll
_poller = new NetMQPoller {
_pipe, reapTimer
};
// Signal the actor that we're ready to work
_pipe.SignalOK();
// polling until cancelled
_poller.Run();
Dispose();
}
private void Run(PairSocket shim)
{
_shim = shim;
shim.ReceiveReady += OnShimMessage;
_timeoutTimer = new NetMQTimer(_heartbeatTimeOut);
_timeoutTimer.Elapsed += OnTimeoutTimer;
_reconnectTimer = new NetMQTimer(_reconnectInterval);
_reconnectTimer.Elapsed += OnReconnectTimer;
_poller = new NetMQPoller {
shim, _timeoutTimer, _reconnectTimer
};
shim.SignalOK();
Connect();
_poller.Run();
_subscriber?.Dispose();
}
public void RunPipeline(PairSocket shim)
{
// we should signal before running the poller but this will block the application
shim.SignalOK();
this.poller = new Poller();
shim.ReceiveReady += OnShimReady;
poller.AddSocket(shim);
timeoutTimer = new NetMQTimer(StreamingProtocol.Timeout);
timeoutTimer.Elapsed += TimeoutElapsed;
poller.AddTimer(timeoutTimer);
Connect();
poller.Start();
if (subscriberSocket != null)
{
subscriberSocket.Dispose();
}
}
public void Run(PairSocket shim)
{
m_pipe = shim;
shim.SignalOK();
m_pipe.ReceiveReady += OnPipeReady;
m_pingTimer = new NetMQTimer(0);
m_pingTimer.Elapsed += PingElapsed;
m_pingTimer.Enable = false;
m_poller = new Poller();
m_poller.AddSocket(m_pipe);
m_poller.AddTimer(m_pingTimer);
m_poller.PollTillCancelled();
// the beacon might never been configured
if (m_udpSocket != null)
{
m_udpSocket.Close();
}
}
public void Run(PairSocket shim)
{
m_pipe = shim;
shim.SignalOK();
m_pipe.ReceiveReady += OnPipeReady;
m_pingTimer = new NetMQTimer(interval: TimeSpan.Zero);
m_pingTimer.Elapsed += PingElapsed;
m_pingTimer.Enable = false;
m_poller = new NetMQPoller {
m_pipe, m_pingTimer
};
m_poller.Run();
// the beacon might never been configured
if (m_udpSocket != null)
{
m_udpSocket.Close();
}
}
private void RunActor(PairSocket shim)
{
// save the shim to the class to use later
m_shim = shim;
// create all subscriber, publisher and beacon
using (m_subscriber = new SubscriberSocket())
using (m_publisher = new PublisherSocket())
using (m_beacon = new NetMQBeacon())
{
// listen to actor commands
m_shim.ReceiveReady += OnShimReady;
// subscribe to all messages
m_subscriber.Subscribe("");
// we bind to a random port, we will later publish this port
// using the beacon
m_randomPort = m_subscriber.BindRandomPort("tcp://*");
Console.WriteLine("Bus subscriber is bound to {0}", m_subscriber.Options.LastEndpoint);
// listen to incoming messages from other publishers, forward them to the shim
m_subscriber.ReceiveReady += OnSubscriberReady;
// configure the beacon to listen on the broadcast port
Console.WriteLine("Beacon is being configured to UDP port {0}", m_broadcastPort);
m_beacon.Configure(m_broadcastPort);
// publishing the random port to all other nodes
Console.WriteLine("Beacon is publishing the Bus subscriber port {0}", m_randomPort);
m_beacon.Publish(m_randomPort.ToString(), TimeSpan.FromSeconds(1));
// Subscribe to all beacon on the port
Console.WriteLine("Beacon is subscribing to all beacons on UDP port {0}", m_broadcastPort);
m_beacon.Subscribe("");
// listen to incoming beacons
m_beacon.ReceiveReady += OnBeaconReady;
// Create a timer to clear dead nodes
NetMQTimer timer = new NetMQTimer(TimeSpan.FromSeconds(1));
timer.Elapsed += ClearDeadNodes;
// Create and configure the poller with all sockets and the timer
m_poller = new NetMQPoller { m_shim, m_subscriber, m_beacon, timer };
// signal the actor that we finished with configuration and
// ready to work
m_shim.SignalOK();
// polling until cancelled
m_poller.Run();
}
}
public void Run(PairSocket shim)
{
m_pipe = shim;
shim.SignalOK();
m_pipe.ReceiveReady += OnPipeReady;
m_pingTimer = new NetMQTimer(interval: TimeSpan.Zero);
m_pingTimer.Elapsed += PingElapsed;
m_pingTimer.Enable = false;
m_poller = new NetMQPoller { m_pipe, m_pingTimer };
m_poller.Run();
// the beacon might never been configured
if (m_udpSocket != null)
m_udpSocket.Close();
}
public void Run(PairSocket shim)
{
m_pipe = shim;
shim.SignalOK();
m_pipe.ReceiveReady += OnPipeReady;
m_pingTimer = new NetMQTimer(0);
m_pingTimer.Elapsed += PingElapsed;
m_pingTimer.Enable = false;
m_poller = new Poller();
m_poller.AddSocket(m_pipe);
m_poller.AddTimer(m_pingTimer);
m_poller.PollTillCancelled();
// the beacon might never been configured
if (m_udpSocket != null)
{
m_udpSocket.Close();
}
}
private void Run(PairSocket shim)
{
m_shim = shim;
shim.ReceiveReady += OnShimMessage;
m_timeoutTimer = new NetMQTimer(TimeOut);
m_timeoutTimer.Elapsed += OnTimeoutTimer;
m_reconnectTimer = new NetMQTimer(ReconnectTimer);
m_reconnectTimer.Elapsed += OnReconnectTimer;
m_poller = new Poller(shim);
m_poller.AddTimer(m_timeoutTimer);
m_poller.AddTimer(m_reconnectTimer);
shim.SignalOK();
Connect();
m_poller.PollTillCancelled();
if (m_subscriber != null)
m_subscriber.Dispose();
}
public void Run(PairSocket shim)
{
m_pipe = shim;
shim.SignalOK();
m_pipe.ReceiveReady += OnPipeReady;
m_pingTimer = new NetMQTimer(interval: TimeSpan.Zero);
m_pingTimer.Elapsed += PingElapsed;
m_pingTimer.Enable = false;
using (m_poller = new NetMQPoller { m_pipe, m_pingTimer })
{
m_poller.Run();
}
// the beacon might never been configured
#if NET35
m_udpSocket?.Close();
#else
m_udpSocket?.Dispose();
#endif
}
private void Run(PairSocket shim)
{
using (m_publisherSocket = m_context.CreateXPublisherSocket())
{
m_publisherSocket.SetWelcomeMessage(WelcomeMessage);
m_publisherSocket.Bind(m_address);
m_publisherSocket.ReceiveReady += DropPublisherSubscriptions;
m_heartbeatTimer = new NetMQTimer(HeartbeatInterval);
m_heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
shim.ReceiveReady += OnShimMessage;
// signal the actor that the shim is ready to work
shim.SignalOK();
m_poller = new Poller(m_publisherSocket, shim);
m_poller.AddTimer(m_heartbeatTimer);
// Polling until poller is cancelled
m_poller.PollTillCancelled();
}
}
