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