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);
}
