public void RegisterWorkflow(IWorkflow workflow)
{
if (_registry.Any(x => x.Item1 == workflow.Id && x.Item2 == workflow.Version))
{
throw new InvalidOperationException($"Workflow {workflow.Id} version {workflow.Version} is already registered");
}
var builder = _serviceProvider.GetService <IWorkflowBuilder>().UseData <object>();
workflow.Build(builder);
var def = builder.Build(workflow.Id, workflow.Version);
_registry.Add(Tuple.Create(workflow.Id, workflow.Version, def));
}
private void QueueUpdateManual(IArkUpdateableContext context, string type, string key)
{
if (_updateQueue.Any(x => x.Item1 == context))
{
return;
}
if (_currentContext == context)
{
_currentCts?.Cancel();
}
_progress.Report($"{type} ({key}): Update queued manually ({DateTime.Now:HH:mm:ss.ffff})");
_updateQueue.Add(new Tuple <IArkUpdateableContext, bool>(context, true));
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
if (_disposed)
{
return;
}
lock (_disposingContext)
{
if (_disposed)
{
return;
}
_disposed = true;
}
_dmaOperations.CompleteAdding();
var timeout = Task.Delay(Timeout * 10);
while (_dmaOperations.Any())
{
var iteration = Task.Delay(100);
var completedTask = Task.WhenAny(timeout, iteration).Result;
if (completedTask == timeout)
{
throw new Exception("Cannot dispose");
}
}
_dmaOperations.Dispose();
}
public static void Clear <T>(this BlockingCollection <T> collection)
{
while (collection.Any())
{
collection.TryTake(out _);
}
}
public T Map <T>(DbDataReader reader, T entity)
{
if (reader is null)
{
throw new ArgumentNullException(nameof(reader));
}
if (entity is null)
{
throw new ArgumentNullException(nameof(entity));
}
Type entityType = typeof(T);
if (SqlTypeMap.Types.ContainsKey(entityType))
{
return((T)reader[0]);
}
if (cachedSchemas.Any(schema => schema.EntityType == entityType))
{
return(MapFromCache(reader, entity));
}
cachedSchemas.Add(CreateSchema(entityType));
return(MapFromCache(reader, entity));
}
public bool IsPrimeParallel_StorePrimes(int i)
{
if (i == 1)
{
return(false);
}
if (i == 2 || i == 3)
{
return(true);
}
if (_primeBlockingCollection.Any(p => i % p == 0))
{
return(true);
}
int limit = (int)Math.Sqrt(i) + 1;
bool isPrime = false;
Parallel.For(5, limit, (j, loopState) =>
{
if (i % j == 0)
{
loopState.Stop();
isPrime = true;
}
});
if (isPrime)
{
_primeBlockingCollection.Add(i);
}
return(isPrime);
}
/// <summary>
/// Takes the next item from the queue. If no item is queued, the Thread blocks until a item is available
/// </summary>
/// <returns></returns>
public T Take()
{
lock (takeItemLock)
{
while (true)
{
if (highPriorityItems.Any())
{
lock(countLock)
return highPriorityItems.Take();
}
else if (normalPriorityItems.Any())
{
lock (countLock)
return normalPriorityItems.Take();
}
else if (lowPriorityItems.Any())
{
lock (countLock)
return lowPriorityItems.Take();
}
else
{
itemWaitHandle.WaitOne();
}
}
}
}
/// <summary>
/// Сохраняет в БД результаты парсинга
/// </summary>
/// <param name="resourceItemsBc">resourceItemsBc</param>
/// <param name="releasesBc">releasesBc</param>
private void SaveResults(BlockingCollection <ResourceItemEntity> resourceItemsBc,
BlockingCollection <AlbumInfoRelease> releasesBc)
{
if (!resourceItemsBc.Any() && !releasesBc.Any())
{
throw new AlbumInfoReleaseException(Helper.EmptyReleaseException);
}
var resourceItems = resourceItemsBc.ToList();
foreach (var resourceItem in resourceItems)
{
//находим соответствующий релиз
var release = releasesBc.FirstOrDefault(r => r.ResourceInternalId == resourceItem.ResourceInternalId);
if (release != null)
{
var music = MapAlbumInfoReleaseToMusic(release);
var musicId = SaveRelease(music);
resourceItem.MusicId = musicId;
SaveMusicTrack(release.TrackList, musicId);
SaveResourceItem(resourceItem);
}
else
{
throw new AlbumInfoReleaseException(
string.Format(Helper.ParsReleaseException, resourceItem.ResourceInternalId));
}
}
}
private void EnqueueIfNotExists(string partitionKey)
{
if (!_enqueuedKeys.Any(partitionKey.Equals))
{
// if the key is not already in the queue, add it. No need to add it if it's already there, as
// when the partition is processed, it will already try to send all events.
_enqueuedKeys.Add(partitionKey);
}
}
public void Add(T tm, Func <T, T, bool> compare)
{
var isActiveItemOk = (typeof(T).IsValueType ? default(T).Equals(_activeItem) : _activeItem == null) || !compare(tm, _activeItem);
if (!LoadRatesQueue.Any(t => compare(t, tm)) && isActiveItemOk)
{
AddCore(tm);
}
}
public void ProcessQueue_Performs_Operation_On_All_Elements_From_InQueue_To_OutQueue()
{
new ZippingPool(_inQueue, _outQueue, _nullifyingProcess)
.ProcessQueue(Config.ThreadsCount);
var hasNonEmptyChunks = _outQueue.Any(c => c.Content.Length > 0);
Assert.False(hasNonEmptyChunks);
}
void EnqueueEvent(IEvent e)
{
if (uncommittedEvents.Any(item => item.GetType() == e.GetType()))
{
throw new ArgumentException($"无法重复添加类型相同的事件。 [AggregateRootType = {GetType()}, AggregateRootId = {Id}, EventType = {e.GetType()}]", nameof(e));
}
uncommittedEvents.TryAdd(e);
}
private static void WriteThread()
{
for (; ;)
{
var task = _WriteQueue.Take();
var flush = !_WriteQueue.Any();
DoWrite(task.S, flush);
task.Done.Set();
}
}
public static async Task GetRandomFights([NotNull] Player player, [NotNull] Player opp, [NotNull] RefreshBB refresh, int builds = 100, int positions = 200, int cores = 8)
{
if (Running == true)
{
return;
}
Running = true;
_refreshBB = refresh;
_refreshBB.Bplayer = player.GetString();
_refreshBB.Bopp = opp.GetString();
source = new CancellationTokenSource();
token = source.Token;
_empty = new ManualResetEvent(false);
CORES = cores;
MaxValue = 0;
BUILDS = builds;
POSITIONS = positions;
_refreshBB.TOTAL_DONE = 0;
_refreshBB.TOTAL = positions;
START = DateTime.UtcNow;
END = DateTime.MinValue;
_jobs_random = new BlockingCollection <int>();
for (int i = 0; i < 40000; i++)
{
_jobs_random.Add(i);
}
for (int i = 0; i < 8; i++)
{
Thread thread = new Thread(OnHandlerStartRandom)
{
IsBackground = true
}; //Mark 'false' if you want to prevent program exit until jobs finish
thread.Start();
}
while (!_empty.WaitOne(1000))
{
Console.WriteLine(_jobs_random.Count());
_refreshBB.Update = !_refreshBB.Update;
if (!_jobs_random.Any())
{
break;
}
}
END = DateTime.UtcNow;
Running = false;
_refreshBB.Update = !_refreshBB.Update;
}
/// <summary>
/// Waits until the given event is handled, if it is already queued.
/// </summary>
/// <param name="e"></param>
private void WaitUntilHandled(IEventExecutor e)
{
// if the event is queued, wait until it is handled
if (event_queue.Any(evt => e.Equals(evt)))
{
lock (evt_locks[e])
{
Monitor.Wait(evt_locks[e]);
}
}
}
public Job Dequeue(CancellationToken token)
{
if (_tasks.Any())
{
return(_tasks.Take(token));
}
else
{
return(null);
}
}
public void PollNow()
{
if (!_isStarted)
{
return;
}
if (!_commandList.Any(c => c.Command == QueueCommands.Poll))
{
_commandList.Add(CommandData.Poll());
}
}
private void DrainActivities <T>(ConcurrentQueue <T> currentActivites, BlockingCollection <T> activitiesToProcess)
{
currentActivites.Clear();
if (activitiesToProcess.Any())
{
while (activitiesToProcess.TryTake(out T item))
{
currentActivites.Enqueue(item);
}
}
}
public Task StopAsync()
{
StopPublishing();
StopMaintainingConnection();
while (_messageQueue.Any())
{
_messageQueue.Take();
}
return(Task.FromResult(0));
}
public Task StopAsync()
{
_connectionCancellationToken?.Cancel(false);
_connectionCancellationToken = null;
while (_messageQueue.Any())
{
_messageQueue.Take();
}
return(Task.FromResult(0));
}
private Task StartRoleTask(CancellationToken token,
OnChangeActions onChangeActions,
BlockingCollection <ClientEvent> clientEvents)
{
return(Task.Run(async() =>
{
while (!token.IsCancellationRequested && !clientEvents.IsAddingCompleted)
{
try
{
// take the most recent event, if multiple are queued up then we only need the latest
ClientEvent clientEvent = null;
while (clientEvents.Any())
{
try
{
clientEvent = clientEvents.Take(token);
}
catch (OperationCanceledException) { }
}
// if there was an event then call the appropriate role beahvaiour
if (clientEvent != null)
{
if (clientEvent.EventType == EventType.Coordinator)
{
//await this.coordinator.ExecuteCoordinatorRoleAsync(this.clientId,
// clientEvent,
// onChangeActions,
// token);
}
else
{
//await this.follower.ExecuteFollowerRoleAsync(this.clientId,
// clientEvent,
// onChangeActions,
// token);
}
}
else
{
await WaitFor(TimeSpan.FromSeconds(1), token);
}
}
catch (Exception ex)
{
this.logger.Error(ex);
await WaitFor(TimeSpan.FromSeconds(1), token);
}
}
}));
}
public IEnumerable <JournalRecord> GetRecords(long fromRecord = 0)
{
using (var queue = new BlockingCollection <JournalRecord>())
{
async Task MessageReceived(IStreamSubscription subscription, StreamMessage message,
CancellationToken cancellationToken)
{
var json = await message.GetJsonData(cancellationToken);
var command = (Command)_serializer.FromString(json);
var journalRecord = new JournalRecord(message.StreamVersion, message.CreatedUtc, command);
queue.Add(journalRecord);
}
// pass null to subscribe from the beginning
//or the version of the previous record
int?version = null;
if (fromRecord > 0)
{
version = (int)fromRecord - 1;
}
var caughtUp = false;
using (
var sub = _streamStore.SubscribeToStream(
_streamId,
version,
MessageReceived,
SubscriptionDropped,
hasCaughtUp => caughtUp = hasCaughtUp))
{
sub.MaxCountPerRead = 100;
while (!caughtUp || queue.Any())
{
if (queue.TryTake(out var journalRecord))
{
yield return(journalRecord);
}
else if (!caughtUp)
{
Thread.Sleep(100);
}
}
}
}
}
public void Run()
{
while (_exception == null && _sheduled.Any(x => !x.Value))
{
_sheduled.Where(x => !x.Value && _ready(x.Key)).ForEach(x => Enqueue(x.Key));
_wake.WaitOne();
}
while (_exception == null && _tasks.Any())
{
_wake.WaitOne();
}
Cancel();
}
public void Dispose()
{
_source?.Cancel();
if (_queue != null)
{
_queue.CompleteAdding();
while (_queue.Any())
{
_queue.TryTake(out _);
}
_queue.Dispose();
}
}
private void GenerateChunk(CancellationToken token)
{
var chunkGenerator = _chunkGeneratorFactory.Invoke();
while (!token.IsCancellationRequested || _generateQueue.Any())
{
if (!_generateQueue.TryTake(out var chunkSize, 1000))
{
continue;
}
var chunk = chunkGenerator.GenerateNext(chunkSize);
_writeQueue.Add(chunk);
}
}
private void ProcessTasks()
{
Status = WorkflowStatus.Running;
ProduceQueue();
var sleepTime = 1;
while (Status != WorkflowStatus.Completed && Status != WorkflowStatus.Error)
{
bool threadStart;
int threadCount;
lock (_lockThreadCounter)
{
threadCount = _threadCount;
threadStart = _threadCount < MaxThreads && _queue.Any();
if (threadStart)
{
_threadCount++;
}
}
if (threadStart)
{
Task.Factory.StartNew(() =>
{
var task = _queue.GetConsumingEnumerable().First();
task.Run(_state);
while (task.Status != WorkflowStatus.Completed && task.Status != WorkflowStatus.Error)
{
Thread.Sleep(50);
}
lock (_lockThreadCounter)
_threadCount--;
});
}
if (_tasks.All(t => t.Status == WorkflowStatus.Completed))
{
Status = WorkflowStatus.Completed;
}
lock (_lockThreadCounter)
sleepTime = threadCount == _threadCount ? sleepTime + 1 : 1;
Thread.Sleep(sleepTime);
}
}
static void Main(string[] args)
{
Console.Title = "Statistics";
var producerCts = new CancellationTokenSource();
var oneSecondGroupMessages = new BlockingCollection <DecodedMessage>();
var oneSecondProducer = new Producer();
oneSecondProducer.StartProducing(producerCts.Token, TimeSpan.FromSeconds(1), "one-second-stats", oneSecondGroupMessages);
var thirtySecondGroupMessages = new BlockingCollection <DecodedMessage>();
var thirtySecondProducer = new Producer();
thirtySecondProducer.StartProducing(producerCts.Token, TimeSpan.FromSeconds(30), "thirty-second-stats", thirtySecondGroupMessages);
var consumerCts = new CancellationTokenSource();
var oneSecondConsumer = new Consumer();
oneSecondConsumer.StartConsuming(consumerCts.Token, "one-second-group", oneSecondGroupMessages);
var thirtySecondConsumer = new Consumer();
thirtySecondConsumer.StartConsuming(consumerCts.Token, "thirty-second-group", thirtySecondGroupMessages);
Console.WriteLine("Press any key to shutdown");
Console.ReadKey();
consumerCts.Cancel();
// perform a shutdown, allowing for 30 seconds to process current items
// this is just an example, it could end with message loss
var sw = new Stopwatch();
sw.Start();
while (oneSecondGroupMessages.Any())
{
if (sw.ElapsedMilliseconds > 60000)
{
producerCts.Cancel(); // force close (could lose messages)
}
else
{
Thread.Sleep(100);
}
}
}
public void Stop()
{
if (_messagesWaitingForPersistence.Any())
{
_logger.WarnFormat("Stopping PersistenceTransport with messages waiting for persistence to come back online!");
}
_innerTransport.Stop();
_pendingReceives.CompleteAdding();
if (_receptionThread != null && !_receptionThread.Join(30.Second()))
{
_logger.WarnFormat("Unable to stop reception thread");
}
SetInitialPhase();
}
private void WriteToFile(CancellationToken token)
{
var fileName = _fileNameProvider.GetPath();
Logger.Info("File name is {fileName}", fileName);
using var writer = _fileWriterFactory.Invoke(fileName);
while (!token.IsCancellationRequested || _writeQueue.Any())
{
if (!_writeQueue.TryTake(out var nextChunk, 1000))
{
continue;
}
writer.Write(nextChunk);
}
}
public static BlockingCollection <T> Move <T>(this BlockingCollection <T> values, int sourceIndex, int targetIndex)
{
if (values == null || !values.Any())
{
return(values);
}
var list = values.ToList();
list.Move(sourceIndex, targetIndex);
while (values.TryTake(out _))
{
}
list.ForEach(values.Add);
return(values);
}
public static async Task LoadImageNames(ObservableCollection<string> resultCollection)
{
var buffer = new BlockingCollection<string>();
buffer.Add("turtles");
foreach (var image in buffer.GetConsumingEnumerable())
{
var nextBatch = await LoadNextImages(resultCollection, image);
foreach (var nextImage in nextBatch)
{
buffer.Add(nextImage);
}
if (!buffer.Any())
{
buffer.CompleteAdding();
}
}
//await LoadNextImages(resultCollection, new[] { "turtles" });
}
private bool UpdatePackageInCommandAlreadyQueued(Command command, BlockingCollection<Command> commandQueue)
{
return commandQueue.Any(a => a.PackageName == command.PackageName);
}
