/// <summary>
/// Dispose the current stream listener
/// </summary>
public void Dispose()
{
try
{
_logger.InfoFormat("Disposing listener for {0}", _resource);
IsDisposing = true;
Stop();
// this is for not sending twice the suspension command
if (!IsFixtureDeleted && !IsFixtureEnded && ShouldSuspendOnDisconnection())
{
SuspendFixture(SuspensionReason.FIXTURE_DISPOSING);
}
// free the resource instantiated by the SDK
_resource = null;
}
finally
{
IsConnecting = false;
IsStreaming = false;
IsDisconnected = true;
_logger.Info("Listener disposed");
}
}
public virtual void CreateStreamListener(IResourceFacade resource, IAdapterPlugin platformConnector)
{
bool creationWasLocked = false;
try
{
_logger.InfoFormat("Attempting to create a Listener for sport={0} and {1}", resource.Sport, resource);
if (_listeners.ContainsKey(resource.Id))
{
_logger.InfoFormat("Stream listener already exists for {0}, skipping creation", resource);
return;
}
// this is king of lock that prevent to create 2 listener for the same resource.Id
if (LockCreatingListener(resource))
{
return;
}
creationWasLocked = true;
var listener = CreateStreamListenerObject(resource, platformConnector, EventState, StateManager);
var isStarted = listener.Start();
if (!isStarted)
{
_logger.WarnFormat("Couldn't start stream listener for {0}", resource);
listener.Dispose();
DisposedStreamListener(listener);
return;
}
var added = _listeners.TryAdd(resource.Id, listener);
if (!added)
{
_logger.WarnFormat("Failed to add stream listener - most likely it has been already added {0} - this will be disposed now", resource);
listener.Dispose();
DisposedStreamListener(listener);
return;
}
OnStreamCreated(resource.Id);
(listener as StreamListener).OnDisconnected += OnStreamDisconnected;
_logger.InfoFormat("Listener created for {0}", resource);
}
finally
{
if (creationWasLocked)
{
ReleaseCreatingListener(resource);
}
ReleaseProcessing(resource.Id);
_logger.DebugFormat("Finished processing fixture {0}", resource);
_logger.DebugFormat("Saving event state after processing fixture {0}", resource);
SaveEventState();
}
}
private bool RemoveStreamListenerIfFinishedProcessing(IResourceFacade resource)
{
var listener = _listeners[resource.Id];
if (listener.IsFixtureEnded || resource.IsMatchOver)
{
_logger.DebugFormat("{0} is marked as ended - checking for stopping streaming", resource);
var currentState = EventState.GetFixtureState(resource.Id);
if (currentState != null && currentState.MatchStatus != MatchStatus.MatchOver)
{
_logger.DebugFormat("{0} is over but the MatchOver update has not been processed yet", resource);
return(false);
}
_logger.InfoFormat("{0} is over. Listener will be removed", resource);
if (RemoveStreamListener(resource.Id))
{
EventState.RemoveFixture(resource.Id);
}
else
{
_logger.WarnFormat("Couldn't remove listener for matchOver fixture {0}", resource);
}
return(true);
}
return(false);
}
private static int CompareByStartDate(IResourceFacade x, IResourceFacade y)
{
if (string.IsNullOrWhiteSpace(x.Content.StartTime))
{
return(1);
}
if (string.IsNullOrWhiteSpace(y.Content.StartTime))
{
return(-1);
}
var xD = DateTime.Parse(x.Content.StartTime);
var yD = DateTime.Parse(y.Content.StartTime);
var date = DateTime.Now;
if (xD.Date == date.Date && yD.Date != date.Date)
{
return(-1);
}
if (xD.Date != date.Date && yD.Date == date.Date)
{
return(1);
}
return(xD.CompareTo(yD));
}
/// <summary>
/// This method checks whether we need to retrieve and process a new snapshot (when current resource sequence is different than te stored sequence).
/// </summary>
/// <param name="resourceFacade"></param>
/// <param name="state"></param>
/// <returns></returns>
public bool IsSnapshotNeeded(IResourceFacade resourceFacade, FixtureState state)
{
_logger.Debug(
$"{resourceFacade} has stored sequence={state?.Sequence}; resource sequence={resourceFacade?.Content?.Sequence}");
return(state == null ||
resourceFacade?.Content != null && resourceFacade.Content.Sequence != state.Sequence);
}
/// <summary>
/// This method determines whether we can connect to the streaming server
/// by checking current streaming state and match status
/// </summary>
/// <param name="resource"></param>
/// <param name="state"></param>
/// <returns></returns>
public bool CanConnectToStreamServer(IResourceFacade resource, StreamListenerState state)
{
var isFixtureInSetup = resource.Content.MatchStatus == (int)MatchStatus.Setup;
return
(state != StreamListenerState.Streaming &&
(!isFixtureInSetup || _settings.AllowFixtureStreamingInSetupMode));
}
public bool ShouldProcessResource(IResourceFacade resource)
{
if (HasStreamListener(resource.Id))
{
_logger.DebugFormat("Listener already exists for {0}", resource);
IListener listener = _listeners[resource.Id];
var shouldAdapterProcessResource = false;
if (listener.IsFixtureDeleted)
{
_logger.DebugFormat("{0} was deleted and republished. Listener wil be removed", resource);
RemoveStreamListener(resource.Id);
}
else if (listener.IsIgnored)
{
_logger.DebugFormat("{0} is marked as ignored. Listener wil be removed", resource);
RemoveStreamListener(resource.Id);
}
//Disconnected from the stream - this fixture should be reconnected ASAP
else if (listener.IsDisconnected && (resource.MatchStatus == MatchStatus.Prematch || resource.MatchStatus == MatchStatus.InRunning))
{
_logger.WarnFormat("{0} was disconnected from stream {1}", resource, resource.MatchStatus);
RemoveStreamListener(resource.Id);
shouldAdapterProcessResource = true;
}
else
{
if (!RemoveStreamListenerIfFinishedProcessing(resource))
{
_listeners[resource.Id].UpdateResourceState(resource);
}
}
return(shouldAdapterProcessResource);
}
else
{
// Check fixture is not yet over, ignore if over
var fixtureState = EventState.GetFixtureState(resource.Id);
if (resource.IsMatchOver && (fixtureState == null || fixtureState.MatchStatus == resource.MatchStatus))
{
_logger.InfoFormat("{0} is over. Adapter will not process the resource", resource);
return(false);
}
if (_createListener.ContainsKey(resource.Id))
{
_logger.DebugFormat("Listener for {0} is not created yet. It is creating right now.", resource);
return(false);
}
_logger.DebugFormat("Listener for {0} is not created yet. Adapter will add resource to the creation queue", resource);
//the resource will added to the queue
return(true);
}
}
private void ValidateCache(IResourceFacade resource)
{
//this ensures that cached object is not already used in stream listener
if (_cachedResources.ContainsKey(resource.Id) && _cachedResources[resource.Id] == resource)
{
IResourceFacade ignore = null;
_cachedResources.TryRemove(resource.Id, out ignore);
}
}
private void ValidateCache(IResourceFacade resource)
{
//this ensures that cached object is not already used in stream listener - if we got a newer version is best to replace it
if (_cachedResources.ContainsKey(resource.Id))
{
IResourceFacade ignore = null;
_cachedResources.TryRemove(resource.Id, out ignore);
}
}
public StreamListener(IResourceFacade resource, IAdapterPlugin platformConnector, IEventState eventState, IStateManager stateManager, ISettings settings)
{
if (resource == null)
{
throw new ArgumentException("Resource information cannot be null");
}
if (resource.Content == null)
{
throw new Exception("Resource does not contain any content");
}
_logger.DebugFormat("Instantiating listener for {0} with sequence={1}", resource, resource.Content.Sequence);
_lockTimeout = settings.ProcessingLockTimeOutInSecs;
_resource = resource;
_platformConnector = platformConnector;
_eventState = eventState;
_stateManager = stateManager;
_settings = settings;
_currentSequence = resource.Content.Sequence;
_lastSequenceProcessedInSnapshot = -1;
_hasRecoveredFromError = true;
_isFirstSnapshotProcessed = false;
_isProcessingFirstSnapshot = false;
_performingDelayedStop = false;
_marketsRuleManager = stateManager.CreateNewMarketRuleManager(resource.Id);
FixtureId = resource.Id;
Sport = resource.Sport;
SequenceOnStreamingAvailable = _currentSequence;
IsStreaming = false;
IsConnecting = false;
IsDisposing = false;
IsErrored = false;
IsIgnored = false;
IsStopping = false;
var fixtureState = _eventState.GetFixtureState(resource.Id);
IsFixtureEnded = fixtureState != null ? fixtureState.MatchStatus == MatchStatus.MatchOver : _resource.IsMatchOver;
IsFixtureSetup = (_resource.MatchStatus == MatchStatus.Setup || _resource.MatchStatus == MatchStatus.Ready);
IsFixtureDeleted = false;
IsInPlay = fixtureState != null ? fixtureState.MatchStatus == MatchStatus.InRunning : _resource.MatchStatus == MatchStatus.InRunning;
_currentEpoch = fixtureState != null ? fixtureState.Epoch : -1;
_Stats = StatsManager.Instance[string.Concat("adapter.core.sport.", resource.Sport)].GetHandle();
SetupListener();
_logger.DebugFormat("Listener instantiated for {0}", resource);
}
private void ValidateCache(IResourceFacade resource)
{
//this ensures that cached object is not already used in stream listener
if (_cachedResources.ContainsKey(resource.Id) && _cachedResources[resource.Id] == resource)
{
IResourceFacade ignore = null;
_cachedResources.TryRemove(resource.Id, out ignore);
}
}
private void MarkResourceAsProcessable(IResourceFacade resource)
{
lock (_sync)
{
if (_currentlyProcessedFixtures.Contains(resource.Id))
{
_currentlyProcessedFixtures.Remove(resource.Id);
}
}
}
private bool LockCreatingListener(IResourceFacade resource)
{
var process = _createListener.TryAdd(resource.Id, true);
if (!process)
{
_logger.InfoFormat("Another creation of listener processing right now for {0}, skipping creation", resource);
return(true);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="streamListenerActor"></param>
/// <param name="resource"></param>
public ResourceActor(IActorRef streamListenerActor, IResourceFacade resource)
{
_streamListenerActor = streamListenerActor ?? throw new ArgumentNullException(nameof(streamListenerActor));
_resource = resource ?? throw new ArgumentNullException(nameof(resource));
_fixtureId = _resource.Id;
Receive <StartStreamingMsg>(o => StartStreamingMsgHandler(o));
Receive <StopStreamingMsg>(o => StopStreamingMsgHandler(o));
Initialize();
}
public StreamListener(IResourceFacade resource, IAdapterPlugin platformConnector, IEventState eventState, IStateManager stateManager,ISettings settings)
{
if (resource == null)
throw new ArgumentException("Resource information cannot be null");
if (resource.Content == null)
throw new Exception("Resource does not contain any content");
_logger.DebugFormat("Instantiating listener for {0} with sequence={1}", resource, resource.Content.Sequence);
_lockTimeout = settings.ProcessingLockTimeOutInSecs;
_resource = resource;
_platformConnector = platformConnector;
_eventState = eventState;
_stateManager = stateManager;
_settings = settings;
_currentSequence = resource.Content.Sequence;
_lastSequenceProcessedInSnapshot = -1;
_hasRecoveredFromError = true;
_isFirstSnapshotProcessed = false;
_isProcessingFirstSnapshot = false;
_performingDelayedStop = false;
_marketsRuleManager = stateManager.CreateNewMarketRuleManager(resource.Id);
FixtureId = resource.Id;
Sport = resource.Sport;
SequenceOnStreamingAvailable = _currentSequence;
IsStreaming = false;
IsConnecting = false;
IsDisposing = false;
IsErrored = false;
IsIgnored = false;
IsStopping = false;
var fixtureState = _eventState.GetFixtureState(resource.Id);
IsFixtureEnded = fixtureState != null ? fixtureState.MatchStatus == MatchStatus.MatchOver : _resource.IsMatchOver;
IsFixtureSetup = (_resource.MatchStatus == MatchStatus.Setup || _resource.MatchStatus == MatchStatus.Ready);
IsFixtureDeleted = false;
IsInPlay = fixtureState != null ? fixtureState.MatchStatus == MatchStatus.InRunning : _resource.MatchStatus == MatchStatus.InRunning;
_currentEpoch = fixtureState != null ? fixtureState.Epoch : -1;
_Stats = StatsManager.Instance[string.Concat("adapter.core.sport.", resource.Sport)].GetHandle();
SetupListener();
_logger.DebugFormat("Listener instantiated for {0}", resource);
}
public override void CreateStreamListener(IResourceFacade resource, IAdapterPlugin platformConnector)
{
base.CreateStreamListener(resource, platformConnector);
var listener = GetStreamListenerObject(resource.Id);
UpdateStateFromStreamListener(listener);
var fixtureOverview = GetFixtureOverview(listener.FixtureId) as FixtureOverview;
PublishDelta(fixtureOverview);
_logger.DebugFormat("Created new StreamListener for {0}", resource);
}
/// <summary>
///
/// </summary>
/// <param name="resource"></param>
/// <param name="settings"></param>
/// <param name="streamHealthCheckValidation"></param>
public StreamHealthCheckActor(
IResourceFacade resource,
ISettings settings,
IStreamHealthCheckValidation streamHealthCheckValidation)
{
_resource = resource ?? throw new ArgumentNullException(nameof(resource));
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
_streamHealthCheckValidation = streamHealthCheckValidation ?? throw new ArgumentNullException(nameof(streamHealthCheckValidation));
Receive <ConnectToStreamServerMsg>(a => ConnectToStreamServerMsgHandler(a));
Receive <StreamConnectedMsg>(a => StreamConnectedMsgHandler(a));
Receive <StartStreamingNotRespondingMsg>(a => StartStreamingNotRespondingMsgHandler(a));
Receive <StreamHealthCheckMsg>(a => StreamHealthCheckMsgHandler(a));
}
/// <summary>
/// This method validates the streaming conditions
/// check for resource sequence, match status, streaming state
/// </summary>
/// <param name="resource"></param>
/// <param name="state"></param>
/// <param name="sequence"></param>
/// <returns></returns>
public bool ValidateStream(IResourceFacade resource, StreamListenerState state, int sequence)
{
if (resource.Content.Sequence - sequence < _settings.StreamSafetyThreshold)
{
return(true);
}
if (ShouldIgnoreUnprocessedSequence(resource, state))
{
return(true);
}
return(false);
}
private void BuildStreamListenerActorInstance(object msg, IResourceFacade resource)
{
var streamListenerActorName = StreamListenerActor.GetName(resource.Id);
if (_streamListenerManagerActorContext.Child(streamListenerActorName).IsNobody())
{
if (_creationInProgressFixtureIdSet.Count + 1 > _settings.FixtureCreationConcurrency)
{
_logger.Warn(
$"BuildStreamListenerActorInstance - {resource}" +
$" - {msg.GetType().Name}" +
$" - fixture creation concurrency limit of {_settings.FixtureCreationConcurrency} has been reached" +
$" - Moving to Busy State" +
$" - _creationInProgressFixtureIdSetCount={_creationInProgressFixtureIdSet.Count} items");
Become(Busy);
Self.Tell(msg);
}
else
{
_logger.Debug(
$"BuildStreamListenerActorInstance - {resource} with MatchStatus={resource.MatchStatus}" +
$" - {msg.GetType().Name}" +
$" - _creationInProgressFixtureIdSetCount={_creationInProgressFixtureIdSet.Count} items" +
$" - Going to create the Stream Listener Actor Instance");
_streamListenerManagerActorContext.ActorOf(Props.Create(() =>
new StreamListenerActor(
_settings,
_adapterPlugin,
resource,
_stateManager,
_suspensionManager,
_streamHealthCheckValidation,
_fixtureValidation)),
streamListenerActorName);
if (!_creationInProgressFixtureIdSet.Contains(resource.Id))
{
_creationInProgressFixtureIdSet.Add(resource.Id);
}
}
}
else
{
_logger.Debug(
$"BuildStreamListenerActorInstance - {resource}" +
$" - {msg.GetType().Name}" +
$" - StreamListenerActor instance not created as existing instance has been found");
}
}
private bool ShouldIgnoreUnprocessedSequence(IResourceFacade resource, StreamListenerState state)
{
if (state != StreamListenerState.Streaming)
{
_logger.Debug($"ValidateStream skipped for {resource} Reason=\"Not Streaming\"");
return(true);
}
if (resource.Content.MatchStatus == (int)MatchStatus.Setup && !_settings.AllowFixtureStreamingInSetupMode)
{
_logger.Debug($"ValidateStream skipped for {resource} Reason=\"Fixture is in setup state\"");
return(true);
}
return(false);
}
public virtual void CreateStreamListener(IResourceFacade resource, IAdapterPlugin platformConnector)
{
try
{
_logger.InfoFormat("Attempting to create a Listener for sport={0} and {1}", resource.Sport, resource);
if (_listeners.ContainsKey(resource.Id))
{
_logger.InfoFormat("Stream listener already exists for {0}, skipping creation", resource);
return;
}
var listener = CreateStreamListenerObject(resource, platformConnector, EventState, StateManager);
var isStarted = listener.Start();
if (!isStarted)
{
_logger.WarnFormat("Couldn't start stream listener for {0}", resource);
listener.Dispose();
DisposedStreamListener(listener);
return;
}
var added = _listeners.TryAdd(resource.Id, listener);
if (!added)
{
_logger.WarnFormat("Failed to add stream listener - most likely it has been already added {0} - this will be disposed now", resource);
listener.Dispose();
DisposedStreamListener(listener);
return;
}
OnStreamCreated(resource.Id);
(listener as StreamListener).OnDisconnected += OnStreamDisconnected;
_logger.InfoFormat("Listener created for {0}", resource);
}
finally
{
MarkResourceAsProcessable(resource);
SaveEventState();
_logger.DebugFormat("Finished processing fixture {0}", resource);
}
}
/// <summary>
///
/// </summary>
/// <param name="settings"></param>
/// <param name="platformConnector"></param>
/// <param name="resource"></param>
/// <param name="stateManager"></param>
/// <param name="suspensionManager"></param>
/// <param name="streamHealthCheckValidation"></param>
/// <param name="fixtureValidation"></param>
public StreamListenerActor(
ISettings settings,
IAdapterPlugin platformConnector,
IResourceFacade resource,
IStateManager stateManager,
ISuspensionManager suspensionManager,
IStreamHealthCheckValidation streamHealthCheckValidation,
IFixtureValidation fixtureValidation)
{
try
{
_isInitializing = true;
_settings = settings ?? throw new ArgumentNullException(nameof(settings));
_platformConnector = platformConnector ?? throw new ArgumentNullException(nameof(platformConnector));
_resource = resource ?? throw new ArgumentNullException(nameof(resource));
_stateManager = stateManager ?? throw new ArgumentNullException(nameof(stateManager));
_suspensionManager = suspensionManager ?? throw new ArgumentNullException(nameof(suspensionManager));
_marketsRuleManager = _stateManager.CreateNewMarketRuleManager(resource.Id);
_streamHealthCheckValidation = streamHealthCheckValidation ?? throw new ArgumentNullException(nameof(streamHealthCheckValidation));
_fixtureValidation = fixtureValidation ?? throw new ArgumentNullException(nameof(fixtureValidation));
_fixtureId = _resource.Id;
_resourceActor = Context.ActorOf(
Props.Create(() => new ResourceActor(Self, _resource)),
ResourceActor.ActorName);
_streamHealthCheckActor = Context.ActorOf(
Props.Create(() => new StreamHealthCheckActor(_resource, _settings, _streamHealthCheckValidation)),
StreamHealthCheckActor.ActorName);
_streamStatsActor = Context.ActorOf(
Props.Create(() => new StreamStatsActor()),
StreamStatsActor.ActorName);
Context.Parent.Tell(new NewStreamListenerActorMsg {
FixtureId = _resource.Id, Sport = _resource.Sport
});
Initialize();
}
catch (Exception ex)
{
_logger.Error(
$"Stream Listener instantiation failed for {_resource} - exception - {ex}");
_erroredException = ex;
Become(Errored);
}
}
/// <summary>
/// Allows to inform this object that a resource
/// may have changed its status.
///
/// If the resource is now in a state were
/// streaming is allowed, this object will
/// try to connect to the streaming server.
/// </summary>
/// <param name="resource"></param>
public void UpdateResourceState(IResourceFacade resource)
{
// this is the case when the StreamListener
// has been already stopped
if (_resource == null)
{
return;
}
IsFixtureSetup = (resource.MatchStatus == MatchStatus.Setup ||
resource.MatchStatus == MatchStatus.Ready);
SequenceOnStreamingAvailable = resource.Content.Sequence;
_logger.DebugFormat("Listener state for {4} has sequence={0} processedSequence={1} isDisconnected={2} isStreaming={3}", SequenceOnStreamingAvailable, _currentSequence, IsDisconnected, IsStreaming, resource);
StartStreaming();
}
public IResourceFacade GetResource(string featureName, string resourceName)
{
if (_service == null)
{
return(null);
}
IResourceFacade resource = null;
var feature = _service.GetFeature(featureName);
var udapiResource = feature?.GetResource(resourceName);
if (udapiResource != null)
{
resource = new UdapiResourceFacade(udapiResource, featureName, _reconnectStrategy, _settings.EchoDelay, _settings.EchoInterval);
}
return(resource);
}
private void ProcessResource(string sport, IResourceFacade resource)
{
_logger.DebugFormat("Attempt to process {0} for sport={1}", resource, sport);
_cachedResources.AddOrUpdate(resource.Id, resource, (k, v) => v);
// make sure that the resource is not already being processed by some other thread
if (!_streamManager.TryLockProcessing(resource.Id))
{
return;
}
bool addedToQueue = false;
try
{
_logger.InfoFormat("Processing {0}", resource);
if (_streamManager.ShouldProcessResource(resource))
{
if (_resourceCreationQueue.All(x => x.Id != resource.Id))
{
_logger.DebugFormat("Adding {0} to the creation queue ", resource);
_resourceCreationQueue.Add(resource);
addedToQueue = true;
_logger.DebugFormat("Added {0} to the creation queue", resource);
}
else
{
_logger.DebugFormat("{0} is already added to the creation queue ", resource);
}
}
}
finally
{
if (!addedToQueue)
{
_streamManager.ReleaseProcessing(resource.Id);
}
}
}
private void ProcessResource(string sport, IResourceFacade resource)
{
_logger.DebugFormat("Attempt to process {0} for sport={1}", resource, sport);
_cachedResources.AddOrUpdate(resource.Id, resource, (k, v) => v);
// make sure that the resource is not already being processed by some other thread
if (!_streamManager.CanBeProcessed(resource.Id))
{
return;
}
_logger.InfoFormat("Processing {0}", resource);
if (_streamManager.ShouldProcessResource(resource))
{
_logger.DebugFormat("Adding {0} to the creation queue ", resource);
_resourceCreationQueue.Add(resource);
_logger.DebugFormat("Added {0} to the creation queue", resource);
}
}
public static int CompareToByStatusAndDate(this IResourceFacade x, IResourceFacade y)
{
if (x.Content == null)
{
return(1);
}
if (y.Content == null)
{
return(-1);
}
if (x.Content.MatchStatus == y.Content.MatchStatus)
{
return(CompareByStartDate(x, y));
}
if (x.Content.MatchStatus == 40)
{
return(-1);
}
if (y.Content.MatchStatus == 40)
{
return(1);
}
if (x.Content.MatchStatus == 30)
{
return(-1);
}
if (y.Content.MatchStatus == 30)
{
return(1);
}
return((int)x.Content.MatchStatus.CompareTo((int)y.Content.MatchStatus));
}
private FixtureState GetFixtureState(IResourceFacade resource)
{
var fixtureStateActor = Context.System.ActorSelection(FixtureStateActor.Path);
FixtureState state = null;
try
{
state = fixtureStateActor
.Ask <FixtureState>(
new GetFixtureStateMsg {
FixtureId = resource.Id
},
TimeSpan.FromSeconds(10))
.Result;
}
catch (Exception e)
{
_logger.Warn($"GetFixtureState failed for {resource} {e}");
}
return(state);
}
protected override IListener CreateStreamListenerObject(IResourceFacade resource, IAdapterPlugin platformConnector, IEventState eventState,
IStateManager stateManager)
{
var streamListener = base.CreateStreamListenerObject(resource, platformConnector, eventState, stateManager);
var streamListenerObject = streamListener as StreamListener;
if (streamListenerObject != null)
{
streamListenerObject.OnConnected += StreamListenerConnected;
streamListenerObject.OnDisconnected += StreamListenerDisconnected;
streamListenerObject.OnError += StreamListenerErrored;
streamListenerObject.OnFlagsChanged += StreamListenerFlagsChanged;
streamListenerObject.OnBeginSnapshotProcessing += StreamListenerSnapshot;
streamListenerObject.OnFinishedSnapshotProcessing += StreamListenerFinishedProcessingUpdate;
streamListenerObject.OnBeginStreamUpdateProcessing += StreamListenerBeginStreamUpdate;
streamListenerObject.OnFinishedStreamUpdateProcessing += StreamListenerFinishedProcessingUpdate;
streamListenerObject.OnSuspend += StreamListenerSuspended;
streamListenerObject.OnStop += StreamListenerStop;
}
return(streamListener);
}
public virtual void CreateStreamListener(IResourceFacade resource, IAdapterPlugin platformConnector)
{
try
{
_logger.InfoFormat("Attempting to create a Listener for sport={0} and {1}", resource.Sport, resource);
if (_listeners.ContainsKey(resource.Id))
{
_logger.InfoFormat("Stream listener already exists for {0}, skipping creation",resource);
return;
}
var listener = CreateStreamListenerObject(resource, platformConnector, EventState, StateManager);
var isStarted = listener.Start();
if (!isStarted)
{
_logger.WarnFormat("Couldn't start stream listener for {0}", resource);
listener.Dispose();
DisposedStreamListener(listener);
return;
}
var added = _listeners.TryAdd(resource.Id, listener);
if (!added)
{
_logger.WarnFormat("Failed to add stream listener - most likely it has been already added {0} - this will be disposed now",resource);
listener.Dispose();
DisposedStreamListener(listener);
return;
}
OnStreamCreated(resource.Id);
(listener as StreamListener).OnDisconnected += OnStreamDisconnected;
_logger.InfoFormat("Listener created for {0}", resource);
}
finally
{
MarkResourceAsProcessable(resource);
SaveEventState();
_logger.DebugFormat("Finished processing fixture {0}", resource);
}
}
private bool RemoveStreamListenerIfFinishedProcessing(IResourceFacade resource)
{
var listener = _listeners[resource.Id];
if (listener.IsFixtureEnded || resource.IsMatchOver)
{
_logger.DebugFormat("{0} is marked as ended - checking for stopping streaming", resource);
var currentState = EventState.GetFixtureState(resource.Id);
if (currentState != null && currentState.MatchStatus != MatchStatus.MatchOver)
{
_logger.DebugFormat("{0} is over but the MatchOver update has not been processed yet", resource);
return false;
}
_logger.InfoFormat("{0} is over. Listener will be removed", resource);
if (RemoveStreamListener(resource.Id))
{
EventState.RemoveFixture(resource.Id);
}
else
{
_logger.WarnFormat("Couldn't remove listener for matchOver fixture {0}", resource);
}
return true;
}
return false;
}
private void MarkResourceAsProcessable(IResourceFacade resource)
{
lock (_sync)
{
if (_currentlyProcessedFixtures.Contains(resource.Id))
_currentlyProcessedFixtures.Remove(resource.Id);
}
}
public bool ShouldProcessResource(IResourceFacade resource)
{
if (HasStreamListener(resource.Id))
{
_logger.DebugFormat("Listener already exists for {0}", resource);
IListener listener = _listeners[resource.Id];
var shouldAdapterProcessResource = false;
if (listener.IsFixtureDeleted)
{
_logger.DebugFormat("{0} was deleted and republished. Listener wil be removed", resource);
RemoveStreamListener(resource.Id);
}
else if (listener.IsIgnored)
{
_logger.DebugFormat("{0} is marked as ignored. Listener wil be removed", resource);
RemoveStreamListener(resource.Id);
}
//Disconnected from the stream - this fixture should be reconnected ASAP
else if (listener.IsDisconnected && (resource.MatchStatus == MatchStatus.Prematch || resource.MatchStatus == MatchStatus.InRunning))
{
_logger.WarnFormat("{0} was disconnected from stream {1}", resource, resource.MatchStatus);
RemoveStreamListener(resource.Id);
shouldAdapterProcessResource = true;
}
else
{
if (!RemoveStreamListenerIfFinishedProcessing(resource))
{
_listeners[resource.Id].UpdateResourceState(resource);
}
}
MarkResourceAsProcessable(resource);
return shouldAdapterProcessResource;
}
else
{
// Check fixture is not yet over, ignore if over
var fixtureState = EventState.GetFixtureState(resource.Id);
if (resource.IsMatchOver && (fixtureState == null || fixtureState.MatchStatus == resource.MatchStatus))
{
_logger.InfoFormat("{0} is over. Adapter will not process the resource", resource);
MarkResourceAsProcessable(resource);
return false;
}
//the resource will be processed
return true;
}
}
public override void CreateStreamListener(IResourceFacade resource, IAdapterPlugin platformConnector)
{
base.CreateStreamListener(resource, platformConnector);
var listener = GetStreamListenerObject(resource.Id);
UpdateStateFromStreamListener(listener);
var fixtureOverview = GetFixtureOverview(listener.FixtureId) as FixtureOverview;
PublishDelta(fixtureOverview);
_logger.DebugFormat("Created new StreamListener for {0}", resource);
}
protected override IListener CreateStreamListenerObject(IResourceFacade resource, IAdapterPlugin platformConnector, IEventState eventState,
IStateManager stateManager)
{
var streamListener = base.CreateStreamListenerObject(resource, platformConnector, eventState, stateManager);
var streamListenerObject = streamListener as StreamListener;
if (streamListenerObject != null)
{
streamListenerObject.OnConnected += StreamListenerConnected;
streamListenerObject.OnDisconnected += StreamListenerDisconnected;
streamListenerObject.OnError += StreamListenerErrored;
streamListenerObject.OnFlagsChanged += StreamListenerFlagsChanged;
streamListenerObject.OnBeginSnapshotProcessing += StreamListenerSnapshot;
streamListenerObject.OnFinishedSnapshotProcessing += StreamListenerFinishedProcessingUpdate;
streamListenerObject.OnBeginStreamUpdateProcessing += StreamListenerBeginStreamUpdate;
streamListenerObject.OnFinishedStreamUpdateProcessing += StreamListenerFinishedProcessingUpdate;
streamListenerObject.OnSuspend += StreamListenerSuspended;
streamListenerObject.OnStop += StreamListenerStop;
}
return streamListener;
}
private void ProcessResource(string sport, IResourceFacade resource)
{
_logger.DebugFormat("Attempt to process {0} for sport={1}", resource, sport);
_cachedResources.AddOrUpdate(resource.Id, resource, (k, v) => v);
// make sure that the resource is not already being processed by some other thread
if (!_streamManager.CanBeProcessed(resource.Id))
return;
_logger.InfoFormat("Processing {0}", resource);
if (_streamManager.ShouldProcessResource(resource))
{
_logger.DebugFormat("Adding {0} to the creation queue ", resource);
_resourceCreationQueue.Add(resource);
_logger.DebugFormat("Added {0} to the creation queue", resource);
}
}
/// <summary>
/// This method validates the streaming conditions
/// check for resource sequence, match status, streaming state
/// </summary>
/// <param name="resource"></param>
/// <param name="state"></param>
/// <param name="sequence"></param>
/// <returns></returns>
public bool IsSequenceValid(IResourceFacade resource, StreamListenerState state, int sequence)
{
return(resource.Content.Sequence <= sequence || ShouldIgnoreUnprocessedSequence(resource, state));
}
/// <summary>
/// Allows to inform this object that a resource
/// may have changed its status.
///
/// If the resource is now in a state were
/// streaming is allowed, this object will
/// try to connect to the streaming server.
/// </summary>
/// <param name="resource"></param>
public void UpdateResourceState(IResourceFacade resource)
{
// this is the case when the StreamListener
// has been already stopped
if (_resource == null)
return;
IsFixtureSetup = (resource.MatchStatus == MatchStatus.Setup ||
resource.MatchStatus == MatchStatus.Ready);
SequenceOnStreamingAvailable = resource.Content.Sequence;
_logger.DebugFormat("Listener state for {4} has sequence={0} processedSequence={1} isDisconnected={2} isStreaming={3}", SequenceOnStreamingAvailable, _currentSequence, IsDisconnected, IsStreaming, resource);
StartStreaming();
}
/// <summary>
/// Dispose the current stream listener
/// </summary>
public void Dispose()
{
try
{
_logger.InfoFormat("Disposing listener for {0}", _resource);
IsDisposing = true;
Stop();
// this is for not sending twice the suspension command
if (!IsFixtureDeleted && !IsFixtureEnded && ShouldSuspendOnDisconnection())
SuspendFixture(SuspensionReason.FIXTURE_DISPOSING);
// free the resource instantiated by the SDK
_resource = null;
}
finally
{
IsConnecting = false;
IsStreaming = false;
IsDisconnected = true;
_logger.Info("Listener disposed");
}
}
protected virtual IListener CreateStreamListenerObject(IResourceFacade resource, IAdapterPlugin platformConnector, IEventState eventState, IStateManager stateManager)
{
return new StreamListener(resource, platformConnector, eventState, stateManager,_settings);
}
private void ReleaseCreatingListener(IResourceFacade resource)
{
bool v;
_createListener.TryRemove(resource.Id, out v);
}
protected virtual IListener CreateStreamListenerObject(IResourceFacade resource, IAdapterPlugin platformConnector, IEventState eventState, IStateManager stateManager)
{
return(new StreamListener(resource, platformConnector, eventState, stateManager, _settings));
}
