private EaseHelper() { EMChatConfigs configs = new EMChatConfigs(System.Environment.GetFolderPath(Environment.SpecialFolder.Personal) + "\\Changliao", /*System.Environment.GetFolderPath(Environment.SpecialFolder.Personal)+ "\\Changliao"*/ System.Environment.CurrentDirectory, AppSettingHelper.getAppConfig("hxKey"), 0); client = EMClient.create(configs); queue = new BackgroundQueue(); ChangLiaoConnection = new EMConnectionListener(); ChangLiaoConnection.onConntect = onConnect; ChangLiaoConnection.onDisconnect = onDisconnect; ChangLiaoConnection.onPong = onPong; client.addConnectionListener(ChangLiaoConnection); ChangLiaoChatManager = new EMChatManagerListener(); ChangLiaoChatManager.onReceiveMessages = onReciveMessage; ChangLiaoChatManager.onReceiveCmdMessages = onReciveCmdMessage; ContactListener = new EMContactListener(); ContactListener.onContactAdded = onContactAdded; ContactListener.onContactDeleted = onContactDeleted; ContactListener.onContactInvited = onContactInvited; client.getChatManager().addListener(ChangLiaoChatManager); client.getContactManager().registerContactListener(ContactListener); GroupManagerListener = new EMGroupManagerListener(); GroupManagerListener.onLeaveGroup = onLeaveGroup; GroupManagerListener.onReceiveJoinGroupApplication = onReceiveJoinGroupApplication; GroupManagerListener.onMemberLeftGroup = onMemberLeaveGroup; GroupManagerListener.onMemberJoinedGroup = onMemberJoinedGroup; GroupManagerListener.onAutoAcceptInvitationFromGroup = onAutoAcceptInvitationFromGroup; GroupManagerListener.onUpdateMyGroupList = onUpdateMyGroupList; client.getGroupManager().addListener(GroupManagerListener); relogin = false; }
public async Task ServiceShouldRunMaxConcurrentCountTaskWhenExistInQueue() { CancellationTokenSource tokenSource = new CancellationTokenSource(); BackgroundQueue queue = new BackgroundQueue((ex) => { throw ex; }, 10, 10);; BackgroundQueueService queueService = new BackgroundQueueService(queue); int highwaterMark = 0; for (int i = 0; i < 20; i++) { queue.Enqueue(async(ct) => { highwaterMark = Math.Max(queue.ConcurrentCount, highwaterMark); await Task.Delay(5); }); } var runningService = Task.Run(async() => await queueService.StartAsync(tokenSource.Token)); while (queue.Count > 0) { await Task.Delay(20); } highwaterMark.Should().BeGreaterThan(1); }
private static void HandleExpiration <T>(HttpCacheShim that , CacheAddParameters <T> parameters , string cacheKey , CacheItemUpdateReason reason , out object expensiveObject , out CacheDependency dependency , out DateTime absoluteExpiration , out TimeSpan slidingExpiration) where T : class { Log("Expired", () => "(" + reason + ") " + cacheKey); expensiveObject = null; dependency = null; absoluteExpiration = Cache.NoAbsoluteExpiration; slidingExpiration = Cache.NoSlidingExpiration; // if we were not shutting down, might want to handle the reuse/refresh if (reason == CacheItemUpdateReason.Expired && !AppDomain.CurrentDomain.IsFinalizingForUnload()) { if (parameters.ShouldScheduleRefresh && HttpCacheShim.DisableBackfill == false && !BackgroundQueue.IsBacklogged()) { // we need queue a request to the underlying store to get more current data into the cache so it stays primed. BackgroundQueue.Enqueue(parameters); } } }
public async Task ContinueRunningAfterFailedTask() { // Arrange var generated = new List <int>(); var expected = new List <int> { 1, 3 }; // Act await HostedService.StartAsync(CancellationToken.None); BackgroundQueue.Enqueue(token => { generated.Add(1); return(Task.CompletedTask); }); BackgroundQueue.Enqueue(token => throw new Exception("Other tasks should execute properly")); BackgroundQueue.Enqueue(token => { generated.Add(3); return(Task.CompletedTask); }); await Delay(1000, new CancellationTokenSource()); await HostedService.StopAsync(CancellationToken.None); // Assert tasks execute when another task fails generated.Should().Equal(expected); }
public async Task QueueTasksWhileRunning() { // Arrange var generated = new List <int>(); var expected = new List <int>(); for (var i = 0; i < 100; i++) { expected.Add(i); } // Act await HostedService.StartAsync(CancellationToken.None); for (var i = 0; i < 100; i++) { var count = i; BackgroundQueue.Enqueue(token => { generated.Add(count); return(Task.CompletedTask); }); } await Delay(1000, new CancellationTokenSource()); await HostedService.StopAsync(CancellationToken.None); // Assert all tasks are executed in correct order generated.Should().Equal(expected); }
public RecognizerService(DiscordClient client, Settings settings, ILogger <RecognizerService> logger, OsuEmoji emoji, OsuUtils utils, ShedulerService sheduler) { this.client = client; this.logger = logger; this.utils = utils; this.sheduler = sheduler; this.emoji = emoji; recognizer = new Recognizer(); webClient = new WebClient(); ignoreList = new Dictionary <int, DateTime>(); api = new BanchoApi(settings.ClientId, settings.Secret); gapi = new GatariApi(); queue = new BackgroundQueue(); logger.LogInformation("Osu service started"); ConfigureFilesInterceptor(client); }
public async Task StopAsync_GivenTask_ThenTaskCanceled() { var options = new BackgroundQueueOptions(); var queue = new BackgroundQueue(options); var tcs = new TaskCompletionSource <int>(); var delay = TimeSpan.FromMilliseconds(100); var stopwatch = Stopwatch.StartNew(); var delayTask = queue.Enqueue(async token => { tcs.SetResult(0); await Task.Delay(delay, token).ConfigureAwait(false); return(stopwatch.Elapsed); }); // make sure the delay task has started await tcs.Task.ConfigureAwait(false); var stopTask = queue.StopAsync(); await Assert.ThrowsAsync <TaskCanceledException>(async() => await Task.WhenAll(delayTask, stopTask).ConfigureAwait(false) ).ConfigureAwait(false); // the stop task should have ran to completion await stopTask.ConfigureAwait(false); }
public MovieUpdateUnitTest() { movieUpdateRepositoryMock = new Mock <IMovieUpdateRepository>(); eventbusMock = new Mock <IEventBus>(); backgroundQueueMock = new BackgroundQueue((e) => { }, 1, 1000); mapperMock = new Mock <IMapper>(); movieUpdateCommandHandler = new MovieUpdateCommandHandler(movieUpdateRepositoryMock.Object, mapperMock.Object, backgroundQueueMock, eventbusMock.Object); }
public RepositoryController( BuildAssetRegistryContext context, BackgroundQueue queue, Func <ActorId, IPullRequestActor> pullRequestActorFactory) { Context = context; Queue = queue; PullRequestActorFactory = pullRequestActorFactory; }
public SubscriptionsController( BuildAssetRegistryContext context, BackgroundQueue queue, Func <ActorId, ISubscriptionActor> subscriptionActorFactory) { _context = context; _queue = queue; _subscriptionActorFactory = subscriptionActorFactory; }
public AddAdminUnitTest() { adminRepositoryMock = new Mock <IAddAdminRepository>(); adminDecrypteEventHandlerMock = new Mock <IAdminDecrypteEventHandler>(); backgroundQueueMock = new BackgroundQueue((e) => { }, 1, 1000); eventStoreRepositoryMock = new Mock <IEventStoreRepository>(); addAdminCommandHandler = new AddAdminCommandHandler(adminRepositoryMock.Object, adminDecrypteEventHandlerMock.Object, backgroundQueueMock, eventStoreRepositoryMock.Object); }
public async Task Enqueue_GivenStop_ThenDisposed() { var options = new BackgroundQueueOptions(); var queue = new BackgroundQueue(options); await queue.StopAsync().ConfigureAwait(false); await Assert.ThrowsAsync <InvalidOperationException>(async() => await queue.Enqueue(token => Task.FromResult(1)).ConfigureAwait(false) ).ConfigureAwait(false); }
public SongUploadService( BackgroundQueue backgroundQueue, ICdnManagerService cdnManagerService, IDocumentStore db, ILogger <SongUploadService> logger) { this.backgroundQueue = backgroundQueue; this.cdnManagerService = cdnManagerService; this.logger = logger; this.db = db; }
public SubscriptionsController( BuildAssetRegistryContext context, BackgroundQueue queue, IDependencyUpdater dependencyUpdater, IActorProxyFactory <ISubscriptionActor> subscriptionActorFactory) : base(context, queue, dependencyUpdater, subscriptionActorFactory) { _context = context; _queue = queue; _dependencyUpdater = dependencyUpdater; }
private DBHelper() { DbConnection sqliteCon = SQLiteProviderFactory.Instance.CreateConnection(); sqliteCon.ConnectionString = "data source=" + System.Environment.GetFolderPath(Environment.SpecialFolder.Personal) + "\\Changliao\\app\\" + SettingMenager.shard.idCard + "\\db\\cl.db;foreign keys=true"; db = new CLDBContext(sqliteCon); var objectContext = ((IObjectContextAdapter)db).ObjectContext; var mappingCollection = (StorageMappingItemCollection)objectContext.MetadataWorkspace.GetItemCollection(DataSpace.CSSpace); mappingCollection.GenerateViews(new List <EdmSchemaError>()); queue = new BackgroundQueue(); }
public AddAdminCommandHandler( IAddAdminRepository addAdminRepository, IAdminDecrypteEventHandler adminDecrypteEventHandler, BackgroundQueue backgroundQueue, IEventStoreRepository eventStoreRepository ) { this.addAdminRepository = addAdminRepository; this.adminDecrypteEventHandler = adminDecrypteEventHandler; this.backgroundQueue = backgroundQueue; this.eventStoreRepository = eventStoreRepository; }
public async Task NormalAsync() { var queue = new BackgroundQueue <IWebHookWorkItem>(); var service = new BackgroundSender(queue); var count = 0; await service.SendAsync(new WebHookWorkItem(new WebHookNotification(), new WebHook()), CancellationToken.None); await queue.DequeueAsync(CancellationToken.None).ContinueWith(t => count++); Assert.Equal(1, count); }
public async Task DefaultWebHookServiceAsync() { var queue = new BackgroundQueue <IWebHookNotification>(); var service = new DefaultWebHookService(queue); var count = 0; await service.NotifyAsync(new WebHookNotification()); await queue.DequeueAsync(CancellationToken.None).ContinueWith(t => count++); Assert.Equal(1, count); }
public async Task Enqueue_GivenResult_ThenIsValid() { var options = new BackgroundQueueOptions(); var queue = new BackgroundQueue(options); var result = await queue.Enqueue(token => Task.FromResult(1)).ConfigureAwait(false); Assert.Equal(1, result); // cleanup await queue.StopAsync().ConfigureAwait(false); }
public MovieUpdateCommandHandler( IMovieUpdateRepository movieUpdateRepository, IMapper mapper, BackgroundQueue backgroundQueue, IEventBus eventBus ) { this.movieUpdateRepository = movieUpdateRepository; this.mapper = mapper; this.backgroundQueue = backgroundQueue; this.eventBus = eventBus; }
public async Task StopAsync_GivenNoTasks_ThenStopsImmediately() { var options = new BackgroundQueueOptions(); var queue = new BackgroundQueue(options); var stopwatch = Stopwatch.StartNew(); await queue.StopAsync().ConfigureAwait(false); var elapsed = stopwatch.Elapsed; Assert.InRange(elapsed.TotalMilliseconds, 0, 25); }
public async Task Enqueue_GivenException_ThenException() { var options = new BackgroundQueueOptions(); var queue = new BackgroundQueue(options); await Assert.ThrowsAsync <ApplicationException>(async() => await queue.Enqueue <int>(token => throw new ApplicationException()).ConfigureAwait(false) ).ConfigureAwait(false); // cleanup await queue.StopAsync().ConfigureAwait(false); }
public BuildsController(BuildAssetRegistryContext context, IRemoteFactory factory, IServiceScopeFactory serviceScopeFactory, BackgroundQueue queue, ILogger <BuildsController> logger) : base(context) { RemoteFactory = factory; ServiceScopeFactory = serviceScopeFactory; Queue = queue; Logger = logger; }
public SyncController( BackgroundQueue backgroundQueue, ISyncMpContactsToHubSpotService syncService, IJobRepository jobRepository, IConfigurationService configurationService, ILogger <SyncController> logger) { _backgroundQueue = backgroundQueue ?? throw new ArgumentNullException(nameof(backgroundQueue)); _syncService = syncService ?? throw new ArgumentNullException(nameof(syncService)); _jobRepository = jobRepository ?? throw new ArgumentNullException(nameof(jobRepository)); _configurationService = configurationService ?? throw new ArgumentNullException(nameof(configurationService)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); }
public SendGridEmailService( BackgroundQueue queue, IDocumentStore db, IOptionsMonitor <EmailSettings> emailOptions, ILogger <SendGridEmailService> logger, IWebHostEnvironment host) { this.logger = logger ?? throw new ArgumentNullException(nameof(logger)); this.db = db ?? throw new ArgumentNullException(nameof(db)); backgroundWorker = queue ?? throw new ArgumentNullException(nameof(queue)); this.host = host ?? throw new ArgumentNullException(nameof(host)); this.emailOptions = emailOptions.CurrentValue; }
public ShedulerService(ILogger <ShedulerService> logger) { sheduledTasks = new List <SheduledTask>(); queue = new BackgroundQueue(); this.logger = logger; timer = new Timer(1000); timer.Elapsed += Timer_Elapsed; logger.LogInformation("ShedulerService started"); StartSheduler(); }
public PushNotificationSender( BackgroundQueue backgroundQueue, IOptionsMonitor <AppSettings> appOptions, IOptionsMonitor <EmailSettings> emailOptions, IDocumentStore db, ILogger <PushNotificationSender> logger) { _backgroundQueue = backgroundQueue ?? throw new ArgumentNullException(nameof(backgroundQueue)); _db = db ?? throw new ArgumentNullException(nameof(db)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _appOptions = appOptions.CurrentValue; _emailOptions = emailOptions.CurrentValue; }
public async Task StopAsync_GivenCancelledToken_ThenTaskCanceled() { var options = new BackgroundQueueOptions(); var queue = new BackgroundQueue(options); var tcs = new TaskCompletionSource <int>(); var delay = queue.Enqueue(token => tcs.Task); var cancellationToken = new CancellationToken(true); await Assert.ThrowsAsync <TaskCanceledException>(async() => await queue.StopAsync(cancellationToken).ConfigureAwait(false) ).ConfigureAwait(false); tcs.SetResult(0); await delay.ConfigureAwait(false); }
public TransportplanungKomponenteBusinessLogic(TransportplanRepository tp_REPO, ITransactionServices transactionService, IAuftragServicesFürTransportplanung auftragServices, IUnterbeauftragungServicesFürTransportplanung unterbeauftragungServices, ITransportnetzServicesFürTransportplanung transportnetzServices, ITimeServices timeServices) { Check.Argument(tp_REPO != null, "tp_REPO != null"); Check.Argument(transactionService != null, "transactionService != null"); Check.Argument(auftragServices != null, "auftragServices != null"); Check.Argument(unterbeauftragungServices != null, "unterbeauftragungsServices != null"); Check.Argument(transportnetzServices != null, "transportnetzServices != null"); Check.Argument(timeServices != null, "timeServices != null"); this.tp_REPO = tp_REPO; this.transactionService = transactionService; this.auftragServices = auftragServices; this.unterbeauftragungServices = unterbeauftragungServices; this.transportnetzServices = transportnetzServices; this.timeServices = timeServices; this.planungsQueue = new BackgroundQueue(); }
public async Task Enqueue_GivenDelay_ThenIsValid() { var options = new BackgroundQueueOptions(); var queue = new BackgroundQueue(options); var delay = TimeSpan.FromMilliseconds(100); var stopwatch = Stopwatch.StartNew(); var elapsed = await queue.Enqueue(async token => { await Task.Delay(delay, token).ConfigureAwait(false); return(stopwatch.Elapsed); }).ConfigureAwait(false); var delta = elapsed - delay; Assert.InRange(delta.TotalMilliseconds, 0, 25); // cleanup await queue.StopAsync().ConfigureAwait(false); }
public async Task StopAsync_GivenShutdownTimeout_ThenTaskCanceled() { var options = new BackgroundQueueOptions { ShutdownTimeout = TimeSpan.FromMilliseconds(50) }; var queue = new BackgroundQueue(options); var tcs = new TaskCompletionSource <int>(); var delay = queue.Enqueue(token => tcs.Task); var stopwatch = Stopwatch.StartNew(); await Assert.ThrowsAsync <TaskCanceledException>(async() => await queue.StopAsync(CancellationToken.None).ConfigureAwait(false) ).ConfigureAwait(false); var elapsed = stopwatch.Elapsed; Assert.InRange(elapsed.TotalMilliseconds, 50, 100); tcs.SetResult(0); await delay.ConfigureAwait(false); }
private bool disposedValue = false; // To detect redundant calls protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { if (_markerProvider != null) { _markerProvider.Dispose(); } if (_packageInstallerEvents != null) { _packageInstallerEvents.PackageReferenceAdded -= InstallerEvents_PackageReferenceAdded; _packageInstallerEvents.PackageReferenceRemoved -= InstallerEvents_PackageReferenceRemoved; } if (_documentEvents != null) { _documentEvents.DocumentOpened -= OnDocumentOpened; _documentEvents.DocumentClosing -= OnDocumentClosing; } if (_selectionEvents != null) { _selectionEvents.SolutionOpened -= SelectionEvents_SolutionOpened; _selectionEvents.Dispose(); } if (_taskProvider != null) { _taskProvider.Dispose(); } if (_backgroundQueue != null) { _backgroundQueue.Dispose(); } _auditResults.Clear(); } // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below. // TODO: set large fields to null. //_packageReferenceMarkerClients = null; _markerProvider = null; _packageInstallerEvents = null; _documentEvents = null; _selectionEvents = null; _dte = null; _taskProvider = null; _backgroundQueue = null; _auditResults = null; disposedValue = true; } }
public IncomingMessageManager() { _incomingMessageQueue = new BackgroundQueue<IIncomingMessage>(ProcessIncomingMessage); _knownMessageProcessors = new ConcurrentDictionary<IMessageDestination, IProcessAnyMessage>(); _incomingMessageQueue.Start(); }