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