private void TriggerFirstHeart(UniqueAddress from) { if (_state.ActiveReceivers.Contains(from) && !FailureDetector.IsMonitoring(from.Address)) { Log.Debug("Cluster Node [{0}] - Trigger extra expected heartbeat from [{1}]", _cluster.SelfAddress, from.Address); FailureDetector.Heartbeat(from.Address); } }
/// <summary> /// Constructor for outbound ProtocolStateActors /// </summary> public ProtocolStateActor(HandshakeInfo handshakeInfo, Address remoteAddress, TaskCompletionSource <AssociationHandle> statusCompletionSource, Transport transport, AkkaProtocolSettings settings, AkkaPduCodec codec, FailureDetector failureDetector, int?refuseUid = null) : this( new OutboundUnassociated(remoteAddress, statusCompletionSource, transport), handshakeInfo, settings, codec, failureDetector, refuseUid) { }
protected override void PostStop() { foreach (var receiver in _state.ActiveReceivers) { FailureDetector.Remove(receiver.Address); } _heartbeatTask.Cancel(); _cluster.Unsubscribe(Self); }
public async Task StartAsync() { await Disseminator.StartAsync(); await Transport.StartAsync(); await FailureDetector.StartAsync(); await MembershipMonitor.StartAsync(); }
/// <summary> /// Common constructor used by both the outbound and the inboud cases /// </summary> protected ProtocolStateActor(InitialProtocolStateData initialData, HandshakeInfo localHandshakeInfo, AkkaProtocolSettings settings, AkkaPduCodec codec, FailureDetector failureDetector, int?refuseUid) { _initialData = initialData; _localHandshakeInfo = localHandshakeInfo; _settings = settings; _refuseUid = refuseUid; _localAddress = _localHandshakeInfo.Origin; _codec = codec; _failureDetector = failureDetector; InitializeFSM(); }
/// <summary> /// TBD /// </summary> /// <param name="node">TBD</param> /// <returns>TBD</returns> public ClusterHeartbeatSenderState RemoveMember(UniqueAddress node) { var newState = MembershipChange(Ring - node); FailureDetector.Remove(node.Address); if (newState.OldReceiversNowUnreachable.Contains(node)) { return(newState.Copy(oldReceiversNowUnreachable: newState.OldReceiversNowUnreachable.Remove(node))); } return(newState); }
public async Task LeaveAsync() { // TODO tell others? await MembershipMonitor.StopAsync(); await FailureDetector.StopAsync(); await Transport.StopAsync(); await Disseminator.StopAsync(); }
public SwimClient(SwimHost local, SwimMeta initialMeta, SwimClientOptions options) { Local = local; Members = new MembershipList(local, initialMeta); Disseminator = new Disseminator(Members, new DisseminatorOptions()); Transport = new SwimTransport(new UdpTransport(local, new UdpTransportOptions()), Disseminator, options.MessageSerializer); FailureDetector = new FailureDetector(Transport, Members, new FailureDetectorOptions(options.Logger)); MembershipMonitor = new MembershipMonitor(Members, Transport, FailureDetector, new MembershipMonitorOptions()); Members.OnJoined += (_, args) => options.Logger.Information("Host {host} joined", args.Member.Host); Members.OnUpdated += (_, args) => options.Logger.Information("Host {host} updated", args.Member.Host); Members.OnLeft += (_, args) => options.Logger.Information("Host {host} left", args.Member.Host); }
/// <summary> /// TBD /// </summary> /// <param name="from">TBD</param> /// <returns>TBD</returns> public ClusterHeartbeatSenderState HeartbeatRsp(UniqueAddress from) { if (ActiveReceivers.Contains(from)) { FailureDetector.Heartbeat(from.Address); if (OldReceiversNowUnreachable.Contains(from)) { //back from unreachable, ok to stop heartbeating to it if (!Ring.MyReceivers.Value.Contains(from)) { FailureDetector.Remove(from.Address); } return(Copy(oldReceiversNowUnreachable: OldReceiversNowUnreachable.Remove(from))); } return(this); } return(this); }
private ClusterHeartbeatSenderState MembershipChange(HeartbeatNodeRing newRing) { var oldReceivers = Ring.MyReceivers.Value; var removedReceivers = oldReceivers.Except(newRing.MyReceivers.Value); var adjustedOldReceiversNowUnreachable = OldReceiversNowUnreachable; foreach (var r in removedReceivers) { if (FailureDetector.IsAvailable(r.Address)) { FailureDetector.Remove(r.Address); } else { adjustedOldReceiversNowUnreachable = adjustedOldReceiversNowUnreachable.Add(r); } } return(Copy(newRing, adjustedOldReceiversNowUnreachable)); }
private void DoHeartbeat() { foreach (var to in _state.ActiveReceivers) { if (FailureDetector.IsMonitoring(to.Address)) { Log.Debug("Cluster Node [{0}] - Heartbeat to [{1}]", _cluster.SelfAddress, to.Address); } else { Log.Debug("Cluster Node [{0}] - First Heartbeat to [{1}]", _cluster.SelfAddress, to.Address); // schedule the expected first heartbeat for later, which will give the // other side a chance to reply, and also trigger some resends if needed Context.System.Scheduler.ScheduleOnce(_cluster.Settings.HeartbeatExpectedResponseAfter, Self, new ExpectedFirstHeartbeat(to)); } HeartbeatReceiver(to.Address).Tell(_selfHeartbeat); } }
public static Props InboundProps(HandshakeInfo handshakeInfo, AssociationHandle wrappedHandle, IAssociationEventListener associationEventListener, AkkaProtocolSettings settings, AkkaPduCodec codec, FailureDetector failureDetector) { return (Props.Create( () => new ProtocolStateActor(handshakeInfo, wrappedHandle, associationEventListener, settings, codec, failureDetector))); }
public static Props OutboundProps(HandshakeInfo handshakeInfo, Address remoteAddress, TaskCompletionSource <AssociationHandle> statusCompletionSource, Transport transport, AkkaProtocolSettings settings, AkkaPduCodec codec, FailureDetector failureDetector, int?refuseUid = null) { return(Props.Create(() => new ProtocolStateActor(handshakeInfo, remoteAddress, statusCompletionSource, transport, settings, codec, failureDetector, refuseUid))); }
/// <summary> /// Constructor for inbound ProtocolStateActors /// </summary> public ProtocolStateActor(HandshakeInfo handshakeInfo, AssociationHandle wrappedHandle, IAssociationEventListener associationEventListener, AkkaProtocolSettings settings, AkkaPduCodec codec, FailureDetector failureDetector) : this(new InboundUnassociated(associationEventListener, wrappedHandle), handshakeInfo, settings, codec, failureDetector, refuseUid : null) { }
public MainForm() { log4net.Config.XmlConfigurator.Configure(); log.Info("MainForm.MainForm : Application opened as " + PROGRAM_NAME); InitializeComponent(); this.Text = PROGRAM_NAME; isCameraMode = false; zibReplayCam1.SetText(""); zibReplayCam2.SetText(""); Camera1Display.SetText(""); Camera2Display.SetText(""); SwitchDisplayMode(); guiSem = new Semaphore(0, 1); program_settings = new Settings(); // see how much memory is available on computer and take 80% of it float freeMem = 1000; try { System.Diagnostics.PerformanceCounter ramCounter = new System.Diagnostics.PerformanceCounter("Memory", "Available MBytes"); freeMem = ramCounter.NextValue(); } catch (Exception inner) { log.Error("MainForm.Form1_Load : Unable to retrieve amount of free memory on system, defaulting to 1GB.", inner); } if (freeMem > 2100) { freeMem = 2100; } // each queue takes 6 MB per item in it int queueSize = 50;//Convert.ToInt32(freeMem * 0.90) / 32; mainQueue = new CircularQueue <QueueElement>("MAIN", queueSize); ipQueue1 = new CircularQueue <QueueElement>("IP1", queueSize); ipQueue2 = new CircularQueue <QueueElement>("IP2", queueSize); saveQueue = new CircularQueue <QueueElement>("save_queue", queueSize); // initialize camera and processor 1 cam1 = new Camera(); cam1.AddSubscriber(ipQueue1); cam1.AddSubscriber(mainQueue); imagep1 = new FailureDetector(DEFAULT_IMAGE_PROCESSOR1_NAME, ref cam1); imagep1.SetConsumerQueue(ipQueue1); imagep1.AddSubscriber(saveQueue); imagep1.AddSubscriber(mainQueue); imagep1.EnableAutoExposure(true); imagep1.EnableAutoROI(false); // initialize camera and processor 2 cam2 = new Camera(); cam2.AddSubscriber(ipQueue2); cam2.AddSubscriber(mainQueue); imagep2 = new FailureDetector(DEFAULT_IMAGE_PROCESSOR2_NAME, ref cam2); imagep2.SetConsumerQueue(ipQueue2); imagep2.AddSubscriber(saveQueue); imagep2.AddSubscriber(mainQueue); imagep2.EnableAutoExposure(true); imagep2.EnableAutoROI(false); // sets image queue saveEngine = new ImageHistoryBuffer(); saveEngine.SetConsumerQueue(saveQueue); // add thread error handlers cam1.ThreadError += new ThreadErrorHandler(Camera0ThreadError); cam2.ThreadError += new ThreadErrorHandler(Camera1ThreadError); imagep1.ThreadError += new ThreadErrorHandler(ImageProcessor0ThreadError); imagep2.ThreadError += new ThreadErrorHandler(ImageProcessor0ThreadError); saveEngine.ThreadError += new ThreadErrorHandler(SaveQueueThreadError); // start the cameras RefreshCameras(); // initialize camera and processor periods camera1Period = 0.066; camera2Period = 0.066; process1Period = 0.2; process2Period = 0.2; // need to update comboboxes cmboCam1View.Items.Add(DISPLAY_TYPE_NORMAL); cmboCam1View.Items.Add(DISPLAY_TYPE_PROCESSED); cmboCam1View.SelectedIndex = 0; cmboCam2View.Items.Add(DISPLAY_TYPE_NORMAL); cmboCam2View.Items.Add(DISPLAY_TYPE_PROCESSED); cmboCam2View.SelectedIndex = 0; cmbo_DataType.Items.Add(DISPLAY_TYPE_NORMAL); cmbo_DataType.Items.Add(DISPLAY_TYPE_PROCESSED); cmbo_DataType.SelectedIndex = 1; cmbo_VideoType.Items.Add(VIDEO_TYPE_TEST); cmbo_VideoType.Items.Add(VIDEO_TYPE_DEBUG); cmbo_VideoType.SelectedIndex = 0; cmbo_DataType.SelectedIndexChanged += cmbo_DataType_SelectedIndexChanged; cmbo_VideoType.SelectedIndexChanged += cmbo_VideoType_SelectedIndexChanged; isReplayManagerValid = false; guiSem.Release(); // setup timer update TimerCallback tcb = new TimerCallback(DisplayImage); imageUpdateTimer = new System.Threading.Timer(tcb, imageUpdateTimer, Timeout.Infinite, Timeout.Infinite); imageUpdateTimer.Change(1, 200); // setup garbage collector TimerCallback tcb2 = new TimerCallback(GarbageCollector); garbageCollector = new System.Threading.Timer(tcb2, garbageCollector, Timeout.Infinite, Timeout.Infinite); garbageCollector.Change(1, 100); // setup replay feedback TimerCallback tcb3 = new TimerCallback(ReplayFeedbackTimer); replayFeedbackTimer = new System.Threading.Timer(tcb3, replayFeedbackTimer, Timeout.Infinite, Timeout.Infinite); }