public override void SignalateDiagnosticEvent(DiagnosticEventData data)
{
_curDiagnosticEventData = data;
if (data.Actived != _diagnosticActive)
{
if (_currentObserver != null)
{
_currentObserver.Dispose();
}
if (!data.Actived)
{
WithoutDiagnosticTimerObserver();
}
_diagnosticActive = data.Actived;
}
if (_seqDir != data.SequencePath)
{
_seqDir = data.SequencePath;
LoadPhotoDistance();
}
if (_curDiagnosticEventData.CurrentState == DiagnosticState.Restart)
{
_absoluteDistance = 0;
_distanceDataSource.OnNext(new DistanceData {
AbsoluteDistance = 0, ReferenceEncoderNumber = 1, AbsoluteLeftPulseCount = 0 * PulsePerMeter, AbsoluteRightPulseCount = 0 * PulsePerMeter
});
}
else if (_curDiagnosticEventData.CurrentState == DiagnosticState.Next)
{
long last = _absoluteDistance;
long distance = GetDistance(1);
if (last != 0 && distance != 0 && last / 100 != distance / 100 && distance != (distance / 100) * 100)
{
_distanceDataSource.OnNext(new DistanceData {
AbsoluteDistance = (distance / 100) * 100, ReferenceEncoderNumber = 1, AbsoluteLeftPulseCount = distance * PulsePerMeter, AbsoluteRightPulseCount = distance * PulsePerMeter
});
}
_distanceDataSource.OnNext(new DistanceData {
AbsoluteDistance = distance, ReferenceEncoderNumber = 1, AbsoluteLeftPulseCount = distance * PulsePerMeter, AbsoluteRightPulseCount = distance * PulsePerMeter
});
}
else if (_curDiagnosticEventData.CurrentState == DiagnosticState.Back)
{
long distance = GetDistance(-1);
_distanceDataSource.OnNext(new DistanceData {
AbsoluteDistance = distance, ReferenceEncoderNumber = 1, AbsoluteLeftPulseCount = distance * PulsePerMeter, AbsoluteRightPulseCount = distance * PulsePerMeter
});
}
}
public static async Task IgnoreElementsWhileConvertingTest()
{
var input = new SubjectSlim <int>();
var output = input
.IgnoreElementsWhileConverting(
async i =>
{
await Task.Delay(75).ConfigureAwait(false);
return(i * 1000);
})
.Replay();
using (output.Connect())
{
for (int i = 0; i < 10; i++)
{
input.OnNext(i);
await Task.Delay(50).ConfigureAwait(false);
}
input.OnCompleted();
Assert.That(output.ToEnumerable(), Is.EqualTo(new[] { 0, 2000, 4000, 6000, 8000 }));
}
}
public Task Initialize(Func <Task <bool> > before = null, Func <Task> after = null)
{
ValidateConfiguration();
return(MakeStateTransition(ProviderState.Created, ProviderState.Initializing, ProviderState.Initialized,
() => InitializeCore().ContinueWith(
t =>
{
_rawDataSource = CreateDataSource(t.Result);
if (_rawDataSource != null)
{
_rawDataSourceObserver = _rawDataSource.Subscribe(
data => _dataSourceProxySubject.OnNext(data),
error =>
{
_dataSourceProxySubject.OnError(error);
Log.Error().Exception(error).Write();
_providerStateSubject.OnNext(ProviderState.Failed);
});
}
return t.Result;
}, TaskContinuationOptions.OnlyOnRanToCompletion),
before, after));
}
protected void TrackDependencyOperationalState <TAgent>(bool isMandatory = true, bool canFailover = true)
where TAgent : IOperationalAgent
{
lock (_dependencies)
{
var dependency = new AgentDependency(isMandatory);
_dependencies[typeof(TAgent)] = dependency;
IObservable <Tuple <AgentInformation, OperationalAgentStates> > obs;
if (canFailover)
{
obs = AgentBroker.Instance.ObserveAnyWithAgentInfo <TAgent, OperationalAgentStates>("OperationalStateDataSource");
}
else
{
obs = AgentBroker.Instance.ObserveFirstWithAgentInfo <TAgent, OperationalAgentStates>("OperationalStateDataSource");
}
this.RegisterObserver(obs.Subscribe(
t =>
{
dependency.State = t.Item2;
_dependenciesOperationalStateSubject.OnNext(Tuple.Create(typeof(TAgent).AssemblyQualifiedName, t.Item1.AgentId, t.Item2));
ValidateAgentDependencies();
}));
}
}
public static async Task IgnoreElementsWhileConvertingTest()
{
var input = new SubjectSlim<int>();
var output = input
.IgnoreElementsWhileConverting(
async i =>
{
await Task.Delay(75).ConfigureAwait(false);
return i * 1000;
})
.Replay();
using (output.Connect())
{
for (int i = 0; i < 10; i++)
{
input.OnNext(i);
await Task.Delay(50).ConfigureAwait(false);
}
input.OnCompleted();
Assert.That(output.ToEnumerable(), Is.EqualTo(new[] { 0, 2000, 4000, 6000, 8000 }));
}
}
public static void WithPreviousTest()
{
var input = new SubjectSlim<int?>();
var output = input.WithPrevious().Replay();
using (output.Connect())
{
for (int i = 0; i < 5; i++)
input.OnNext(i);
input.OnCompleted();
Assert.That(output.ToEnumerable(), Is.EqualTo(
new[] {
Tuple.Create<int?, int?>(null, 0),
Tuple.Create<int?, int?>(0, 1),
Tuple.Create<int?, int?>(1, 2),
Tuple.Create<int?, int?>(2, 3),
Tuple.Create<int?, int?>(3, 4)
}));
}
}
public static void WithPreviousTest()
{
var input = new SubjectSlim <int?>();
var output = input.WithPrevious().Replay();
using (output.Connect())
{
for (int i = 0; i < 5; i++)
{
input.OnNext(i);
}
input.OnCompleted();
Assert.That(output.ToEnumerable(), Is.EqualTo(
new[] {
Tuple.Create <int?, int?>(null, 0),
Tuple.Create <int?, int?>(0, 1),
Tuple.Create <int?, int?>(1, 2),
Tuple.Create <int?, int?>(2, 3),
Tuple.Create <int?, int?>(3, 4)
}));
}
}
public Task <Exception> ProcessCalibrationData(bool isAccepted, CalibrationData calibrationData, Func <Task <bool> > before = null, Func <Task> after = null)
{
if (calibrationData == null)
{
throw new ArgumentNullException("calibrationData");
}
return(MakeStateTransition(
ProviderState.Started,
ProviderState.Started,
ProviderState.Started,
async() =>
{
var result = await ProcessCalibrationDataCore(isAccepted, calibrationData).ConfigureAwait(false);
if (isAccepted)
{
_calibrationSubject.OnNext(calibrationData);
}
return result;
},
before, after));
}
protected override async Task <AcquisitionActionResult> StartCore(StartAcquisitionParameter parameters, AcquisitionActionResult result)
{
result = await base.StartCore(parameters, result).ConfigureAwait(false);
if (!result.IsSuccessful)
{
return(result);
}
this.RegisterObserver(AgentBroker.Instance.ObserveAny <ILocalisationAgent, LocalisationData>("DataSource").Subscribe(data => _localisationSubject.OnNext(data)));
this.RegisterObserver(AgentBroker.Instance.ObserveAny <IDistanceAgent, DistanceData>("DataSource").Subscribe(data => _distanceSubject.OnNext(data)));
return(result);
}
public async Task <ExecutionResult> RecycleAgent(string agentId)
{
if (string.IsNullOrEmpty(agentId))
{
throw new ArgumentNullException("agentId");
}
Lazy <LocalAgentInformation> lazyLocal;
Lazy <RemoteAgentInformation> lazyRemote;
if (_localAgents.TryRemove(agentId, out lazyLocal))
{
var result = new ExecutionResult {
AgentId = agentId
};
try
{
var local = lazyLocal.Value;
local.IsRecycled = true;
local.Agent.Dispose();
local.ServiceHost.Close();
foreach (var rxService in local.RxServices.Where(s => s.Value.IsValueCreated))
{
rxService.Value.Value.Connection.Dispose();
}
var agentInfo = await GetOrRegisterLocalAgent(local.Configuration, local.IsInternal, forceRegister : true).ConfigureAwait(false);
if (this.Configuration.AutoActivateAgents)
{
await agentInfo.Agent.Activate().ConfigureAwait(false);
}
}
catch (Exception ex)
{
result.Exception = ex;
}
return(result);
}
else if (_remoteAgents.TryRemove(agentId, out lazyRemote))
{
try
{
var remote = lazyRemote.Value;
remote.IsRecycled = true;
remote.SetIsReachable(false);
remote.SetLastKnownState(AgentState.Disposed);
_agentSubject.OnNext(new SerializableAgentInformation(remote));
await remote.ServiceClientFactory.Close().ConfigureAwait(false);
var peerAgentId = GetAgentId(remote.PeerNode, PeerCommunicationAgent.Configuration.Name);
var result = await TryExecuteOnOne <IPeerCommunicationAgent, bool>(peerAgentId, a => a.RecycleAgent(remote.AgentId)).ConfigureAwait(false);
GetOrRegisterRemoteAgent(remote.PeerNode, remote.AgentId, remote.DisplayData, remote.Contracts, remote.IsInternal, forceRegister: true);
if (!result.IsSuccessful)
{
return(result);
}
else if (!result.Result)
{
return new ExecutionResult {
AgentId = agentId, Exception = new InvalidOperationException(string.Format("Recycling of remote agent '{0}' failed.", agentId))
}
}
;
else
{
return new ExecutionResult {
AgentId = agentId
}
};
}
catch (Exception ex)
{
return(new ExecutionResult {
AgentId = agentId, Exception = ex
});
}
}
else
{
return(new ExecutionResult {
AgentId = agentId, Exception = new ArgumentException(string.Format("Agent '{0}' cannot be found.", agentId), "agentId")
});
}
}
