private void StreamHealthCheckMsgHandler(StreamHealthCheckMsg msg)
{
if (_resource == null || msg.Resource == null || msg.Resource.Id != _resource.Id)
{
return;
}
try
{
_resource.Content.Sequence = msg.Resource.Content.Sequence;
_resource.Content.MatchStatus = msg.Resource.Content.MatchStatus;
_logger.Debug(
$"Listener state for {msg.Resource} has " +
$"sequence={msg.Resource.Content.Sequence} " +
$"processedSequence={msg.CurrentSequence} " +
(msg.Resource.Content.Sequence > msg.CurrentSequence
? $"missedSequence={msg.Resource.Content.Sequence - msg.CurrentSequence} "
: "") +
$"State={msg.StreamingState} " +
$"isMatchOver={msg.Resource.IsMatchOver}");
var streamIsValid =
_streamHealthCheckValidation.ValidateStream(msg.Resource, msg.StreamingState, msg.CurrentSequence);
var connectToStreamServer =
_streamHealthCheckValidation.CanConnectToStreamServer(msg.Resource, msg.StreamingState);
if (!streamIsValid)
{
_logger.Warn($"Detected invalid stream for {msg.Resource}");
if (_streamInvalidDetected)
{
Context.Parent.Tell(new StopStreamingMsg());
}
else
{
_streamInvalidDetected = true;
Context.Parent.Tell(new SuspendAndReprocessSnapshotMsg());
}
}
else
{
_streamInvalidDetected = false;
}
if (connectToStreamServer)
{
Context.Parent.Tell(new ConnectToStreamServerMsg());
}
}
catch (Exception ex)
{
_logger.Error($"Error occured on Stream Health Check for {_resource} - exception - {ex}");
throw;
}
}
private void StreamHealthCheckMsgHandler(StreamHealthCheckMsg msg)
{
if (_resource == null || msg.Resource == null || msg.Resource.Id != _resource.Id)
{
return;
}
_resource.Content.Sequence = msg.Resource.Content.Sequence;
_resource.Content.MatchStatus = msg.Resource.Content.MatchStatus;
LogState(msg);
if (StopStreamingDueToMatchOver(msg))
{
return;
}
if (!ValidateTime())
{
return;
}
try
{
var isSequenceValid = _streamHealthCheckValidation.IsSequenceValid(msg.Resource, msg.StreamingState, msg.CurrentSequence);
var SequenceUpdated = msg.CurrentSequence > lastProcessedSequence && lastProcessedSequence > 0;
var isInErroredState = msg.StreamingState == StreamListenerState.Errored;
_erroredStateCount = isInErroredState ? _erroredStateCount + 1 : 0;
var isNeedStopErroredState = isInErroredState && _erroredStateCount >= _settings.MaxInErroredState - 1;
//var streamIsValid
if (!isSequenceValid && !SequenceUpdated || isNeedStopErroredState)
{
_logger.Warn($"StreamHealthCheckMsgHandler: Detected {(_streamInvalidDetected ? "invalid" : "suspicious")} stream {msg.Resource}, isNeedStopErroredState={isNeedStopErroredState}, " +
$"isSequenceValid={isSequenceValid}, SequenceUpdated={SequenceUpdated}");
if (_streamInvalidDetected)
{
Context.Parent.Tell(new StopStreamingMsg());
}
else
{
_streamInvalidDetected = true;
Context.Parent.Tell(new SuspendMessage(SuspensionReason.HEALTH_CHECK_FALURE));
}
}
else
{
_streamInvalidDetected = false;
}
if (_streamHealthCheckValidation.CanConnectToStreamServer(msg.Resource, msg.StreamingState))
{
Context.Parent.Tell(new ConnectToStreamServerMsg());
}
}
catch (Exception ex)
{
_logger.Error($"Error occured on Stream Health Check for {_resource} - exception - {ex}");
throw;
}
lastExecute = DateTime.UtcNow;
lastProcessedSequence = msg.CurrentSequence;
}
private void Initialize()
{
_logger.Info($"Initializing stream listener for {_resource}");
try
{
State = StreamListenerState.Initializing;
Receive <StreamConnectedMsg>(a => Become(Streaming));
Receive <StreamDisconnectedMsg>(a => StreamDisconnectedMsgHandler(a));
Receive <StreamUpdateMsg>(a => Stash.Stash());
Receive <RetrieveAndProcessSnapshotMsg>(a => RetrieveAndProcessSnapshot(false, true));
Receive <ClearFixtureStateMsg>(a => ClearState(true));
Receive <GetStreamListenerActorStateMsg>(a => Sender.Tell(State));
var fixtureStateActor = Context.System.ActorSelection(FixtureStateActor.Path);
var fixtureState =
fixtureStateActor
.Ask <FixtureState>(
new GetFixtureStateMsg {
FixtureId = _fixtureId
},
TimeSpan.FromSeconds(10))
.Result;
_currentEpoch = fixtureState?.Epoch ?? -1;
_currentSequence = _resource.Content.Sequence;
_lastSequenceProcessedInSnapshot = -1;
_fixtureIsSuspended = false;
if (!string.IsNullOrEmpty(_resource.Content?.StartTime))
{
_fixtureStartTime = DateTime.Parse(_resource.Content.StartTime);
}
if (_resource.IsMatchOver)
{
if (fixtureState != null && fixtureState.MatchStatus != MatchStatus.MatchOver)
{
ProcessMatchOver();
}
_logger.Warn($"Stopping actor for {_resource} as the resource is marked as ended");
Context.Parent.Tell(
new StreamListenerCreationCancelledMsg
{
FixtureId = _resource.Id,
FixtureStatus = _resource.MatchStatus.ToString(),
Reason = "Match is over"
});
Become(Stopped);
}
else
{
//either connect to stream server and go to Streaming State, or go to Initialized State
if (_streamHealthCheckValidation.CanConnectToStreamServer(_resource, State))
{
ConnectToStreamServer();
}
else
{
Become(Initialized);
}
}
}
catch (Exception ex)
{
_logger.Error($"Error on Initialize resource {_resource} - exception - {ex}");
_erroredException = ex;
Become(Errored);
}
}