public HealthMonitor(
ILogFactory logFactory,
IHealthProvider healthProvider,
TimeSpan monitoringPeriod)
{
_healthProvider = healthProvider;
_timer = new TimerTrigger(nameof(HealthMonitor), monitoringPeriod, logFactory);
_timer.Triggered += HandleMonitoringTimer;
}
public OperationsPeriodicalHandler(
IOperationOrchestratorService operationOrchestratorService,
TimeSpan idlePeriod,
ILogFactory logFactory)
{
_operationOrchestratorService = operationOrchestratorService;
_timerTrigger = new TimerTrigger(nameof(OperationsPeriodicalHandler), idlePeriod, logFactory);
_timerTrigger.Triggered += Execute;
}
public MyPeriodicalHandler(ILogFactory logFactory, IFxGeteRestClient fxGeteRestClient, ITickPricePublisher pricePublisher, TimeSpan interval)
{
_fxGeteRestClient = fxGeteRestClient;
_pricePublisher = pricePublisher;
_timerTrigger = new TimerTrigger(nameof(MyPeriodicalHandler), interval, logFactory);
_timerTrigger.Triggered += Execute;
_nextForcePush = DateTime.UtcNow;
}
public static VTrigger CreateElapsedTimerTrigger(float time, TriggerCondition condition, TriggerAction action)
{
TimerTrigger timerTrigger = (TimerTrigger)TriggerManager.CreateTrigger(TriggerType.TimerTrigger);
TriggerManager.TriggerRegisterElapsedTimer(timerTrigger, time);
TriggerManager.TriggerAddCondition(timerTrigger, condition);
TriggerManager.TriggerAddAction(timerTrigger, action);
return(timerTrigger);
}
public CompletedCampaignsManager(
ICampaignsService campaignsService,
TimeSpan idlePeriod,
ILogFactory logFactory)
{
_campaignsService = campaignsService;
_timerTrigger = new TimerTrigger(nameof(CompletedCampaignsManager), idlePeriod, logFactory);
_timerTrigger.Triggered += Execute;
}
public void TimerTrigger_WithValidLoggerProvided_LogsMessageSuccessfully()
{
var logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
TimerTrigger.Run(null, logger);
var msg = logger.Logs[0];
Assert.Contains("C# Timer trigger function executed at", msg);
}
public MarketDataCacheService(
MarketDataService.MarketDataServiceClient marketDataServiceClient,
ILog log
)
{
_marketDataServiceClient = marketDataServiceClient;
_timerTrigger = new TimerTrigger(nameof(MarketDataCacheService), TimeSpan.FromSeconds(1), log);
_timerTrigger.Triggered += Execute;
}
public ExpiredVouchersManager(
IVouchersService vouchersService,
TimeSpan idlePeriod,
ILogFactory logFactory)
{
_vouchersService = vouchersService;
_timerTrigger = new TimerTrigger(nameof(ExpiredVouchersManager), idlePeriod, logFactory);
_timerTrigger.Triggered += Execute;
}
public ArbitrageDetectorService(ISettingsService settingsService, IOrderBooksService orderBooksService, ILogFactory logFactory)
{
_settingsService = settingsService;
_orderBooksService = orderBooksService;
_log = logFactory.CreateLog(this);
var executionInterval = GetSettings().ExecutionInterval;
_trigger = new TimerTrigger(nameof(ArbitrageDetectorService), executionInterval, logFactory, Execute);
}
public UpdateHealStatusPeriodicalHandler(TimeSpan timerPeriod,
ILogFactory logFactory,
IServiceScopeFactory serviceScopeFactory)
{
_serviceScopeFactory = serviceScopeFactory;
_log = logFactory.CreateLog(this);
_timerTrigger = new TimerTrigger(nameof(UpdateHealStatusPeriodicalHandler), timerPeriod, logFactory);
_timerTrigger.Triggered += (trigger, args, token) => Execute();
}
private static void TriggerRegisterElapsedTimer(TimerTrigger trigger, float time)
{
if (trigger != null)
{
trigger.trigger_event = 20;
trigger.trigger_type = 3;
trigger.start_time = Singleton <VTimer> .Instance.CurTime + time;
TriggerManager.AddTimerTrigger(trigger);
}
}
public MatrixHistoryService(IArbitrageDetectorService arbitrageDetectorService, ISettingsService settingsService, IMatrixHistoryRepository matrixHistoryRepository, ILogFactory logFactory)
{
_arbitrageDetectorService = arbitrageDetectorService;
_settingsService = settingsService;
_matrixHistoryRepository = matrixHistoryRepository;
_log = logFactory.CreateLog(this);
var settings = settingsService.GetAsync().GetAwaiter().GetResult();
_trigger = new TimerTrigger(nameof(MatrixHistoryService), settings.MatrixHistoryInterval, logFactory, Execute);
}
public CashinGrabber(
IMongoDatabase mongoDatabase,
IQueueExt queueExt,
ILogFactory logFactory)
{
_mongoDatabase = mongoDatabase;
_queueExt = queueExt;
_log = logFactory.CreateLog(this);
_timerTrigger = new TimerTrigger(nameof(CashinGrabber), TimeSpan.FromSeconds(10), logFactory);
_timerTrigger.Triggered += Execute;
}
public LykkeArbitrageDetectorService(IOrderBooksService orderBooksService, ISettingsService settingsService, ILogFactory logFactory)
{
_arbitrages = new List <LykkeArbitrageRow>();
_orderBooksService = orderBooksService;
_log = logFactory.CreateLog(this);
var settings = settingsService.GetAsync().GetAwaiter().GetResult();
var executionInterval = settings.LykkeArbitragesExecutionInterval;
_trigger = new TimerTrigger(nameof(LykkeArbitrageDetectorService), executionInterval, logFactory, Execute);
}
public BlockchainIndexingManager(
IBlockchainIndexingService blockchainIndexingService,
ILogFactory logFactory)
{
_timerTrigger = new TimerTrigger(nameof(BlockchainIndexingManager), TimeSpan.FromSeconds(5), logFactory);
_timerTrigger.Triggered += async(timer, args, token) =>
{
while (await blockchainIndexingService.IndexNonIndexedBlocksAsync())
{
}
};
}
public ExpiredRequestsManager(
IPaymentsService paymentsService,
TimeSpan idlePeriod,
TimeSpan paymentsExpirationPeriod,
ILogFactory logFactory)
{
_paymentsService = paymentsService;
_paymentsExpirationPeriod = paymentsExpirationPeriod;
_log = logFactory.CreateLog(this);
_timerTrigger = new TimerTrigger(nameof(ExpiredRequestsManager), idlePeriod, logFactory);
_timerTrigger.Triggered += Execute;
}
public void TimerShouldLogMessage()
{
//Arrange
var logger = new ListLogger();
//Act
TimerTrigger.Run(null, logger);
//Assert
Assert.Single(logger.Logs, $"C# Timer trigger function executed at: {_now}");
}
private static void TriggerRegisterPeriodTimer(TimerTrigger trigger, float start_time, float interval, float duration)
{
if (trigger != null)
{
trigger.trigger_event = 21;
trigger.trigger_type = 3;
trigger.start_time = Singleton <VTimer> .Instance.CurTime + start_time;
trigger.interval_time = interval;
trigger.duration_time = duration;
TriggerManager.AddTimerTrigger(trigger);
}
}
public ArbitrageDetectorService(ISettingsService settingsService, IOrderBooksService orderBooksService, ILogFactory logFactory)
{
_synthOrderBooks = new ConcurrentDictionary <AssetPairSource, SynthOrderBook>();
_arbitrages = new ConcurrentDictionary <string, Arbitrage>();
_arbitrageHistory = new ConcurrentDictionary <string, Arbitrage>();
_settingsService = settingsService;
_orderBooksService = orderBooksService;
_log = logFactory.CreateLog(this);
_trigger = new TimerTrigger(nameof(ArbitrageDetectorService), DefaultInterval, logFactory, Execute);
}
public RemoveOldSpentOutputsPeriodicalHandler(
ILogFactory logFactory,
TimeSpan timerPeriod,
TimeSpan expiration,
ISpentOutputRepository spentOutputRepository)
{
_expiration = expiration;
_spentOutputRepository = spentOutputRepository;
_log = logFactory.CreateLog(this);
_timerTrigger = new TimerTrigger(nameof(RemoveOldSpentOutputsPeriodicalHandler), timerPeriod, logFactory);
_timerTrigger.Triggered += (trigger, args, token) => Execute();
}
public TransactionInputDecodingManager(
int batchSize,
ITransactionInputDecodingService transactionInputDecodingService,
ILogFactory logFactory)
{
_timerTrigger = new TimerTrigger(nameof(TransactionLogDecodingManager), TimeSpan.FromSeconds(5), logFactory);
_timerTrigger.Triggered += async(timer, args, token) =>
{
while (await transactionInputDecodingService.DecodeNonDecodedInputsAsync(batchSize))
{
}
};
}
public ReservedVouchersTimeoutManager(
IVouchersService vouchersService,
TimeSpan idlePeriod,
TimeSpan generatePaymentTimeout,
TimeSpan finishPaymentTimeout,
ILogFactory logFactory)
{
_vouchersService = vouchersService;
_generatePaymentTimeout = generatePaymentTimeout;
_finishPaymentTimeout = finishPaymentTimeout;
_timerTrigger = new TimerTrigger(nameof(ReservedVouchersTimeoutManager), idlePeriod, logFactory);
_timerTrigger.Triggered += Execute;
}
public CleanupHandler(
ILykkeMarketProfile marketProfileClient,
IDatabase database,
TimeSpan marketDataInterval,
ILogFactory logFactory
)
{
_marketProfileClient = marketProfileClient;
_database = database;
_marketDataInterval = marketDataInterval;
_timerTrigger = new TimerTrigger(nameof(CleanupHandler), TimeSpan.FromMinutes(10), logFactory);
_timerTrigger.Triggered += Execute;
}
public EthNodeClientBase(Func <Task <string[]> > connStringListGetter, ILogFactory log, TimeSpan?webSocketConnectionTimeout)
{
_connStringListGetter = connStringListGetter;
_log = log.CreateLog(this);
_nethereumLog = log.CreateNethereumLog(this);
UpdateConnectionList(connStringListGetter.Invoke().Result);
SetActiveConnectionPool();
_timer = new TimerTrigger(GetType().Name, TimeSpan.FromSeconds(300), log, TimerHandler);
_timer.Start();
// setting up timeout for websocket connections
ClientBase.ConnectionTimeout = webSocketConnectionTimeout ?? TimeSpan.FromSeconds(DefaultWebSocketConnectionTimeoutInSeconds);
}
public StreamService(ILogFactory logFactory, bool needPing = false)
{
if (needPing)
{
_checkTimer = new TimerTrigger(nameof(StreamService <T>), TimeSpan.FromSeconds(10), logFactory);
_checkTimer.Triggered += CheckStreams;
_checkTimer.Start();
_pingTimer = new TimerTrigger(nameof(StreamService <T>), TimeSpan.FromMinutes(1), logFactory);
_pingTimer.Triggered += Ping;
_pingTimer.Start();
}
}
public LimitReachedHandler(
ILimitsService limitsService,
IClientAccountClient clientAccountClient,
IPersonalDataService personalDataService,
ILogFactory logFactory
)
{
_limitsService = limitsService;
_clientAccountClient = clientAccountClient;
_personalDataService = personalDataService;
_log = logFactory.CreateLog(this);
_timerTrigger = new TimerTrigger(nameof(LimitReachedHandler), TimeSpan.FromMinutes(10), logFactory);
_timerTrigger.Triggered += Execute;
}
public async Task TimerTrigger_can_be_run_without_event_handler()
{
// Arrange
var timer = new TimerTrigger("TestTimer", TimeSpan.FromMilliseconds(100), new LogToConsole());
// Act
timer.Start();
await Task.Delay(500);
timer.Stop();
// Assert
}
public UpdateBalancesPeriodicalHandler(
ILogFactory logFactory,
TimeSpan timerPeriod,
IWalletBalanceService walletBalanceService,
IObservableWalletRepository observableWalletRepository)
{
_walletBalanceService = walletBalanceService;
_observableWalletRepository = observableWalletRepository;
_log = logFactory.CreateLog(this);
_timerTrigger = new TimerTrigger(nameof(UpdateBalancesPeriodicalHandler), timerPeriod, logFactory);
_timerTrigger.Triggered += (trigger, args, token) => Execute();
}
public StreamServiceBase(ILogFactory logFactory, bool needPing = false)
{
_log = logFactory.CreateLog(this);
_checkTimer = new TimerTrigger($"StreamService<{nameof(T)}>", TimeSpan.FromSeconds(10), logFactory);
_checkTimer.Triggered += CheckStreams;
_checkTimer.Start();
if (needPing)
{
_pingTimer = new TimerTrigger($"StreamService<{nameof(T)}>", TimeSpan.FromSeconds(30), logFactory);
_pingTimer.Triggered += Ping;
_pingTimer.Start();
}
}
public BaseTimeEventHandler(
ILogFactory logFactory,
int executionTimeSec,
IRabbitPublisher<TimeEvent> timePublisher)
{
_timePublisher = timePublisher ??
throw new ArgumentNullException(nameof(timePublisher));
_log = logFactory.CreateLog(this);
_timerTrigger =
new TimerTrigger(nameof(BaseTimeEventHandler), TimeSpan.FromSeconds(executionTimeSec), logFactory);
_timerTrigger.Triggered += Execute;
}
public void asyncWorker_asAsyncAction_should_return_an_executable_asyncAction_with_support_for_triggers()
{
var wa = new ManualResetEvent( false );
var asyncAction = AsyncWorker.Using( 5 )
.OnExecute( e =>
{
Thread.Sleep( e.Argument );
} );
var timerTrigger = new TimerTrigger( 5, TimerTriggerMode.Once );
asyncAction.AddTrigger( timerTrigger );
timerTrigger.Start();
asyncAction.Completed += ( s, e ) => wa.Set();
var actual = wa.WaitOne( 500 );
// var actual = asyncAction.AsyncWaitHandle.WaitOne( 15 );
actual.Should().Be.True();
}
