public HeartbeatServiceTests()
{
_validateApplicationTokenService = A.Fake <IValidateApplicationTokenService>();
_dataStore = A.Fake <IDataStore>();
_compassEnvironment = A.Fake <ICompassEnvironment>();
_sut = new HeartbeatService(_validateApplicationTokenService, _dataStore, _compassEnvironment);
}
public Initialisor(IBus bus, IBus eventProcessingBus)
{
if (bus == null)
{
throw new ArgumentNullException("bus");
}
_bus = bus;
_eventProcessingBus = eventProcessingBus;
_membershipService = new MembershipService(_bus);
_s3Config = AwsConfigFactory.GetS3Config();
var awsClientFactory = new AwsClientFactory();
_fileStore = new S3FileStore(awsClientFactory);
var dynamoDbConfig = AwsConfigFactory.GetDynamoDbConfig();
var mediaRepository = new MediaRepository(dynamoDbConfig, awsClientFactory);
var uniquNameRepository = new UniqueNameRepository(dynamoDbConfig, awsClientFactory);
_mediaService = new MediaService(_bus, mediaRepository, uniquNameRepository, _fileStore);
_heartbeatService = new HeartbeatService(_bus, ServerSettings.ServerName);
_heartbeatService.Start();
AutoMapperConfiguration.Configure();
}
public DynDns53ConsoleClient(IConfigHandler configHandler, IAmazonRoute53 route53Client, IHeartbeatService heartbeatService, ILog logger)
{
this.configHandler = configHandler;
this.route53Client = route53Client;
this.heartbeatService = heartbeatService;
this.logger = logger;
}
public KinesisShardReaderBase(IAmazonKinesis client,
ICheckpointRepository checkpointRepository,
IHeartbeatService heartbeatService)
{
_client = client;
CheckpointRepository = checkpointRepository;
HeartbeatService = heartbeatService;
}
/// <summary>
/// Initialises the object. This is called within a lock, do not call Initialise from
/// within this.
/// </summary>
protected virtual void DoInitialise()
{
_Clock = Factory.Singleton.Resolve <IClock>();
_PrivateHeartbeat = Factory.Singleton.Resolve <IHeartbeatService>();
_PrivateHeartbeat.FastTick += Heartbeat_FastTimerTicked;
_PrivateHeartbeat.SlowTick += Heartbeat_SlowTimerTicked;
_PrivateHeartbeat.Start();
}
public HeartbeatJob(IHeartbeatService hearbeat)
{
if (hearbeat == null)
{
throw new ArgumentNullException("hearbeat");
}
_hearbeat = hearbeat;
}
/// <summary>
/// Creates a new object.
/// </summary>
/// <param name="expireMilliseconds"></param>
/// <param name="millisecondsBetweenChecks"></param>
public ExpiringCollection(int expireMilliseconds, int millisecondsBetweenChecks)
{
ExpireMilliseconds = expireMilliseconds;
MillisecondsBetweenChecks = millisecondsBetweenChecks;
_Clock = Factory.Singleton.Resolve <IClock>();
_HeartbeatService = Factory.Singleton.ResolveSingleton <IHeartbeatService>();
}
public HeartbeatJob(IHeartbeatService hearbeat, IActionContext actionContext, AuthenticatorService authenticatorService)
: base(actionContext, authenticatorService)
{
if (hearbeat == null)
{
throw new ArgumentNullException(nameof(hearbeat));
}
_hearbeat = hearbeat;
}
public ServiceHeartBeatJob(IHeartbeatService hearbeat, IHRAMServicesService iHRAMServicesService)
{
if (hearbeat == null)
{
throw new ArgumentNullException(nameof(hearbeat));
}
_hearbeat = hearbeat;
this._IHRAMServicesService = iHRAMServicesService;
}
public ServerStatusCheckerJob(IHeartbeatService hearbeat, IStoreServerService iStoreServerService)
{
if (hearbeat == null)
{
throw new ArgumentNullException(nameof(hearbeat));
}
_hearbeat = hearbeat;
this._IStoreServerService = iStoreServerService;
}
public ProcessedMeasurementsKinesisShardReader(IAmazonKinesis client,
ICheckpointRepository checkpointRepository,
IHeartbeatService heartbeatService,
IBus bus,
ILogger logger)
: base(client, checkpointRepository, heartbeatService)
{
_bus = bus;
_logger = logger;
}
public ProcessedMeasurementsShardReaderFactory(ICheckpointRepository checkpointRepository,
IHeartbeatService heartbeatService,
IBus bus,
ILogger logger)
{
_checkpointRepository = checkpointRepository;
_heartbeatService = heartbeatService;
_bus = bus;
_logger = logger;
}
public AwsKinesisFactory(IAwsClientFactory clientFactory,
IOptions <AwsSettings> awsOptions,
IHeartbeatService heartbeatService,
ILogger logger)
{
_clientFactory = clientFactory;
_heartbeatService = heartbeatService;
_logger = logger;
_awsSettings = awsOptions.Value;
}
/// <summary>
/// See base docs.
/// </summary>
/// <param name="view"></param>
public override void Initialise(IBackgroundThreadQueuesView view)
{
base.Initialise(view);
var heartbeatService = Factory.Singleton.ResolveSingleton <IHeartbeatService>();
heartbeatService.FastTick += HeartbeatService_FastTick;
_HeartbeatService = heartbeatService;
ShowQueues();
}
/// <summary>
/// Creates a new object.
/// </summary>
public NetworkConnector() : base()
{
UseKeepAlive = true;
IdleTimeout = DefaultIdleTimeout;
_LastIdleCheck = DateTime.UtcNow;
_LastEstablishedCheck = _LastIdleCheck;
_TcpConnectionService = Factory.Singleton.Resolve <ITcpConnectionStateService>();
_HeartbeatService = Factory.Singleton.Resolve <IHeartbeatService>().Singleton;
_HeartbeatService.FastTick += HeartbeatService_FastTick;
}
public RawMeasurementsKinesisShardReader(IAmazonKinesis client,
ICheckpointRepository checkpointRepository,
IHeartbeatService heartbeatService,
IProcessedMeasurementStreamWriter processedMeasurementStreamWriter,
IRecordProcessor recordProcessor,
ILogger logger)
: base(client, checkpointRepository, heartbeatService)
{
_processedMeasurementStreamWriter = processedMeasurementStreamWriter;
_recordProcessor = recordProcessor;
_logger = logger;
}
public Processor(LoggerFactory loggerFactory, ISettings settings, IImageProcessor imageProcessor, IWittyPiService wittyPiService,
INtpService ntpService, IStopCheckService stopCheckService, IAirQualityProcessor airQualityProcessor, IHeartbeatService heartbeatService)
{
this.logger = loggerFactory(nameof(Processor));
this.settings = settings;
this.imageProcessor = imageProcessor;
this.wittyPiService = wittyPiService;
this.ntpService = ntpService;
this.stopCheckService = stopCheckService;
this.airQualityProcessor = airQualityProcessor;
this.heartbeatService = heartbeatService;
}
/// <summary>
/// See base docs.
/// </summary>
/// <param name="disposing"></param>
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
{
if (_HeartbeatService != null)
{
_HeartbeatService.FastTick -= HeartbeatService_FastTick;
}
_HeartbeatService = null;
}
}
public RawMeasurementsShardReaderFactory(IRecordProcessorFactory recordProcessorFactory,
IProcessedMeasurementStreamWriter processedMeasurementStreamWriter,
ICheckpointRepository checkpointRepository,
IHeartbeatService heartbeatService,
ILogger logger)
{
_recordProcessorFactory = recordProcessorFactory;
_processedMeasurementStreamWriter = processedMeasurementStreamWriter;
_checkpointRepository = checkpointRepository;
_heartbeatService = heartbeatService;
_logger = logger;
}
/// <summary>
/// See interface docs.
/// </summary>
public void Initialise()
{
lock (_SyncLock) {
if (_HeartbeatService == null)
{
_NextSnapshot = DateTime.UtcNow.AddSeconds(SnapshotInterval);
FullPath = Path.Combine(Factory.ResolveSingleton <IConfigurationStorage>().Folder, FileName);
_HeartbeatService = Factory.ResolveSingleton <IHeartbeatService>();
_HeartbeatService.SlowTick += HeartbeatService_SlowTick;
}
}
}
//TODO: Handle Resume:
///<summary>
///See <a href="https://discordapp.com/developers/docs/topics/voice-connections#resuming-voice-connection">Discord API Documentation</a>
///</summary>
///
private void OnHello(HelloEventData e)
{
var payload = new GatewayPayload
{
OpCode = GatewayOpCode.Voice_Identify,
Data = new VoiceIdentifyRequest
{
server_id = guildId,
user_id = userId,
session_id = sessionId,
token = token
}
};
voiceGateway.Send(payload);
heartbeatService = new VoiceHeartbeatService(voiceGateway, e.heartbeat_interval);
}
public SubmitHandInViewModel(ILastSaveViewModel lastSaveViewModel, IExamTimeLeftViewModel examTimeLeftViewModel, ILanguageService languageService, IHandInFieldValueStorageService handInFieldValueStorageService, IHandInFileSelectorViewModel handInFileSelectorViewModel, IMessenger messenger, IHandInFileService handInFileService, IBoardingPassStorageService boardingPassStorageService, IHandInFieldIdStorageService handInFieldIdStorageService, IHeartbeatService heartbeatService)
{
this._languageService = languageService;
this._handInFieldValueStorageService = handInFieldValueStorageService;
this._messenger = messenger;
this._handInFileService = handInFileService;
this._boardingPassStorageService = boardingPassStorageService;
this._handInFieldIdStorageService = handInFieldIdStorageService;
this._heartbeatService = heartbeatService;
this.LastSaveViewModel = lastSaveViewModel;
this.ExamTimeLeftViewModel = examTimeLeftViewModel;
this.HandInFileSelectorViewModel = handInFileSelectorViewModel;
this._messenger.Register <OnInitiateSubmitHandIn>((object)this, new Action <OnInitiateSubmitHandIn>(this.OnInitiateSubmitHandIn));
this.PreviousViewCommand = (ICommand) new RelayCommand((Action <object>)(c => this.PreviousViewClick()), (Predicate <object>)null);
this.NextViewCommand = (ICommand) new RelayCommand((Action <object>)(c => this.NextViewClick()), (Predicate <object>)null);
this._messenger.Register <OnHandInFieldsLoaded>((object)this, new Action <OnHandInFieldsLoaded>(this.OnHandInFieldsLoaded));
this._messenger.Register <OnHandInFieldInputLostFocus>((object)this, new Action <OnHandInFieldInputLostFocus>(this.OnHandInFieldInputLostFocus));
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="parameters"></param>
public void Startup(PluginStartupParameters parameters)
{
Singleton = this;
lock (_SyncLock) {
var optionsStorage = new OptionsStorage();
_Options = optionsStorage.Load();
_Database = Factory.Singleton.Resolve <IAutoConfigBaseStationDatabase>().Singleton.Database;
_Database.FileNameChanging += BaseStationDatabase_FileNameChanging;
_Database.FileNameChanged += BaseStationDatabase_FileNameChanged;
_StandingDataManager = Factory.Singleton.Resolve <IStandingDataManager>().Singleton;
_StandingDataManager.LoadCompleted += StandingDataManager_LoadCompleted;
var feedManager = Factory.Singleton.Resolve <IFeedManager>().Singleton;
feedManager.FeedsChanged += FeedManager_FeedsChanged;
_OnlineLookupCache = Provider.CreateOnlineLookupCache();
_OnlineLookupCache.Database = _Database;
_OnlineLookupCache.RefreshOutOfDateAircraft = _Options.RefreshOutOfDateAircraft;
_OnlineLookupCache.EnabledChanged += OnlineLookupCache_EnabledChanged;
StartSession();
var onlineLookupManager = Factory.Singleton.Resolve <IAircraftOnlineLookupManager>().Singleton;
onlineLookupManager.RegisterCache(_OnlineLookupCache, 100, letManagerControlLifetime: false);
// If we process messages on the same thread as the listener raises the message received event on then we
// will be running on the same thread as the aircraft list. Our processing can take some time, particularly if many
// database writes have to happen simultaneously on startup, so to avoid blocking the update of the aircraft list
// we create a background thread and process the messages on that.
_BackgroundThreadMessageQueue = new BackgroundThreadQueue <BaseStationMessageEventArgs>("BaseStationDatabaseWriterMessageQueue", 200000);
_BackgroundThreadMessageQueue.StartBackgroundThread(MessageQueue_MessageReceived, MessageQueue_ExceptionCaught);
HookFeed();
_HeartbeatService = Factory.Singleton.Resolve <IHeartbeatService>();
_HeartbeatService.SlowTick += Heartbeat_SlowTick;
_HeartbeatService.Start();
}
}
public void Dispose()
{
foreach (var disposable in _handlers)
{
if (disposable != null)
{
disposable.Dispose();
}
}
_handlers.Clear();
if (_heartbeatService != null)
{
_heartbeatService.Stop();
_heartbeatService.Dispose();
_heartbeatService = null;
}
_bus = null;
_eventProcessingBus = null;
}
/// <summary>
/// See interface docs.
/// </summary>
public void Start()
{
if (!_Started)
{
_Started = true;
_Clock = Factory.Singleton.Resolve <IClock>();
Downloader = Factory.Singleton.Resolve <IAirPressureDownloader>();
Lookup = Factory.Singleton.Resolve <IAirPressureLookup>();
_SharedConfiguration = Factory.Singleton.ResolveSingleton <ISharedConfiguration>();
Enabled = _SharedConfiguration.Get().BaseStationSettings.DownloadGlobalAirPressureReadings;
_SharedConfiguration.ConfigurationChanged += SharedConfiguration_ConfigurationChanged;
if (_BackgroundWorker == null)
{
_BackgroundWorker = Factory.Singleton.Resolve <IBackgroundWorker>();
_BackgroundWorker.DoWork += BackgroundWorker_DoWork;
}
_HeartbeatService = Factory.Singleton.ResolveSingleton <IHeartbeatService>();
_HeartbeatService.SlowTick += HeartbeatService_SlowTick;
}
}
public LoginViewModel(IMessenger messenger, IBoardingPassValidator boardingPassValidator, ILanguageService languageService, IConfigurationService configurationService, ITimerService loginAttemptsTimer, IBoardingPassStorageService boardingPassStorageService, IFlexClient flexClient, IHeartbeatService heartbeatService, IStorageCleanerService storageCleanerService)
{
this._messenger = messenger;
this._boardingPassValidator = boardingPassValidator;
this._languageService = languageService;
this._configurationService = configurationService;
this._loginAttemptsTimer = loginAttemptsTimer;
this._boardingPassStorageService = boardingPassStorageService;
this._flexClient = flexClient;
this._heartbeatService = heartbeatService;
this._storageCleanerService = storageCleanerService;
this._messenger.Register <OnSuccessfulHealthCheck>((object)this, new Action <OnSuccessfulHealthCheck>(this.OnSuccessfulHealthCheck));
this.UpdateText((OnLanguageChanged)null);
this._messenger.Register <OnLanguageChanged>((object)this, new Action <OnLanguageChanged>(this.UpdateText));
this._messenger.Register <OnLoginErrorPopupClosed>((object)this, new Action <OnLoginErrorPopupClosed>(this.OnLoginErrorPopupClosed));
this.LoginCommand = (ICommand) new RelayCommand((Action <object>)(c => this.LoginClick()), (Predicate <object>)null);
this._loginAttemptsTimer.AutoReset = false;
this._loginAttemptsTimer.Interval = (double)(configurationService.BoardingPassLoginLockDurationInSeconds * 1000);
this._loginAttemptsTimer.Elapsed += (ElapsedEventHandler)((s, e) =>
{
DispatcherHelper.CheckBeginInvokeOnUI((Action)(() => this.CanLogin = true));
this.LoginAttemptsCounter = 0;
});
}
private void OnHello(HelloEventData e)
{
heartbeatService = new HeartbeatService(gateway, e.heartbeat_interval);
heartbeatService.Start();
}
public HeartbeatJob(IHeartbeatService heartbeat)
{
_heartbeat = heartbeat ?? throw new ArgumentNullException(nameof(heartbeat));
}
public HeartbeatController(
IHeartbeatService heartbeatService
)
{
_heartbeatService = heartbeatService;
}
public HeartbeatHttp(IHeartbeatService heartbeatService)
{
this.heartbeatService = heartbeatService;
}
/// <summary>
/// Creates a new object.
/// </summary>
public RawMessageTranslator()
{
Provider = new DefaultProvider();
_StandingDataManager = Factory.Singleton.Resolve<IStandingDataManager>().Singleton;
_Statistics = Factory.Singleton.Resolve<IStatistics>().Singleton;
GlobalDecodeAirborneThresholdMilliseconds = 10000;
GlobalDecodeFastSurfaceThresholdMilliseconds = 25000;
GlobalDecodeSlowSurfaceThresholdMilliseconds = 50000;
LocalDecodeMaxSpeedAirborne = 15.0;
LocalDecodeMaxSpeedTransition = 5.0;
LocalDecodeMaxSpeedSurface = 3.0;
ReceiverRangeKilometres = 650;
TrackingTimeoutSeconds = 600;
AcceptIcaoInPI0Count = 1;
AcceptIcaoInPI0Milliseconds = 1000;
_CompactPositionReporting = Factory.Singleton.Resolve<ICompactPositionReporting>();
_HeartbeatService = Factory.Singleton.Resolve<IHeartbeatService>().Singleton;
_HeartbeatService.SlowTick += Heartbeat_SlowTick;
}
/// <summary>
/// Disposes of or finalises the object.
/// </summary>
/// <param name="disposing"></param>
private void Dispose(bool disposing)
{
if(disposing) {
_Disposed = true;
if(_HeartbeatService != null) {
_HeartbeatService.SlowTick -= Heartbeat_SlowTick;
_HeartbeatService = null;
}
}
}
public HeartbeatJob(IHeartbeatService hearbeat)
{
if (hearbeat == null) throw new ArgumentNullException("hearbeat");
_hearbeat = hearbeat;
}
