public static List<Builder> LoadBuildersWithTasks(int numberOfBuilders)
{
BlockingCollection<Builder> buildersToLoad = new BlockingCollection<Builder>();
BlockingCollection<Builder> loadedBuilders = new BlockingCollection<Builder>();
for (int i = 0; i < numberOfBuilders; i++)
{
buildersToLoad.Add(new Builder { Name = "Builder" + i, Status = "Status" + i });
}
buildersToLoad.CompleteAdding();
Task loader1 = Task.Factory.StartNew(() =>
{
foreach (Builder item in buildersToLoad.GetConsumingEnumerable())
{
Thread.Sleep(1000);
loadedBuilders.Add(item);
}
}, TaskCreationOptions.LongRunning);
Task loader2 = Task.Factory.StartNew(() =>
{
foreach (Builder item in buildersToLoad.GetConsumingEnumerable())
{
Thread.Sleep(1000);
loadedBuilders.Add(item);
}
}, TaskCreationOptions.LongRunning);
Task.WaitAll(loader1, loader2);
return loadedBuilders.ToList();
}
// Demonstrates:
// BlockingCollection<T>.Add()
// BlockingCollection<T>.Take()
// BlockingCollection<T>.CompleteAdding()
public static void BC_AddTakeCompleteAdding()
{
using (BlockingCollection<int> bc = new BlockingCollection<int>()) {
// Spin up a Task to populate the BlockingCollection
using (Task t1 = Task.Factory.StartNew(() => {
bc.Add(1);
bc.Add(2);
bc.Add(3);
bc.CompleteAdding();
})) {
// Spin up a Task to consume the BlockingCollection
using (Task t2 = Task.Factory.StartNew(() => {
try {
// Consume the BlockingCollection
while (true) Console.WriteLine(bc.Take());
}
catch (InvalidOperationException) {
// An InvalidOperationException means that Take() was called on a completed collection
Console.WriteLine("That's All!");
}
}))
Task.WaitAll(t1, t2);
}
}
}
public void when_consuming_enumerable_then_succeeds()
{
var bytes = new BlockingCollection<byte>();
var incoming = bytes.GetConsumingEnumerable().ToObservable(TaskPoolScheduler.Default);
var messages = from header in incoming.Buffer(4)
let length = BitConverter.ToInt32(header.ToArray(), 0)
let body = incoming.Take(length)
select Encoding.UTF8.GetString(body.ToEnumerable().ToArray());
messages.Subscribe(s => Console.Write(s));
var message = "hello";
BitConverter.GetBytes(message.Length).Concat(Encoding.UTF8.GetBytes(message)).ToList().ForEach(b => bytes.Add(b));
message = "world";
BitConverter.GetBytes(message.Length).Concat(Encoding.UTF8.GetBytes(message)).ToList().ForEach(b => bytes.Add(b));
Thread.Sleep(2000);
Console.WriteLine(bytes.Count);
}
public void NotifyBlock(string poolId, long blockHeight)
{
queue?.Add(new QueuedNotification
{
Category = NotificationCategory.Block,
PoolId = poolId,
Subject = "Block Notification",
Msg = $"Pool {poolId} found block candidate {blockHeight}"
});
}
/// <param name="autoLoadHeadDeploymentIntervalMs">AutoLoad is disabled if set to Timeout.Infinite</param>
public Host(IHostContext context, int autoLoadHeadDeploymentIntervalMs = 30000)
{
_hostContext = context;
_cells = new Dictionary<string, Cell>();
_commandQueue = new BlockingCollection<IHostCommand>();
_autoLoadHeadDeploymentIntervalMs = autoLoadHeadDeploymentIntervalMs;
_autoLoadHeadDeploymentTimer = new Timer(o => _commandQueue.Add(new LoadCurrentHeadDeploymentCommand()), null, Timeout.Infinite, _autoLoadHeadDeploymentIntervalMs);
_watchdogTimer = new Timer(o => _commandQueue.Add(new EnsureAllCellsAreRunningUnlessCancelledCommand()), null, Timeout.Infinite, _watchdogIntervalMs);
}
public void NotifyPaymentSuccess(string poolId, decimal amount, int recpientsCount, string txInfo, decimal?txFee)
{
queue?.Add(new QueuedNotification
{
Category = NotificationCategory.PaymentSuccess,
PoolId = poolId,
Subject = "Payout Success Notification",
Msg = $"Paid {FormatAmount(amount, poolId)} from pool {poolId} to {recpientsCount} recipients in Transaction(s) {txInfo}."
});
}
public TerminalTester(TimeSpan globalTimeout, string prompt = @"/ # ")
{
timeoutSync = new object();
eventCollection = new BlockingCollection<Event>(new ConcurrentQueue<Event>());
reportCollection = new ConcurrentQueue<Event>();
reportEndingLock = new object();
reportCollection.Enqueue(new ReportSeparator());
terminal = new PromptTerminal(x => eventCollection.Add(new Line { Content = x }), () => eventCollection.Add( new Prompt() ), prompt);
defaultPrompt = prompt;
this.globalTimeout = globalTimeout;
}
static void FileReader(BlockingCollection<int> input, BlockingCollection<string> output)
{
StreamReader file = new StreamReader("input.txt"); // TODO: check exceptions
string line;
while ((line = file.ReadLine()) != null)
{
output.Add(line);
}
output.Add(null); // EOF
Console.WriteLine("line count: " + input.Take());
}
/// <summary>
/// Process domain MX query, start new tasks for each of received MX entry
/// </summary>
/// <param name="domainMx"></param>
/// <returns></returns>
private async Task ProcessDomainAsync(DomainMx domainMx)
{
if (_lookup == null)
{
return;
}
int mxCount = 0;
var wasException = false;
try
{
var result = await _lookup.QueryAsync(domainMx.Domain, QueryType.MX, QueryClass.IN, _cancellation.Token);
domainMx.Error = result.HasError ? result.ErrorMessage : null;
// result.Answers.Count may be different than real MX records count in the case of redirection
var mxs = result.Answers.MxRecords();
mxCount = mxs.Count();
if (mxCount != result.Answers.Count)
{
domainMx.Error =
$@"Bad number ({mxCount}\{result.Answers.Count}) of received MX records. Probably redirects occurred.";
}
domainMx.mxCount = mxCount;
domainMx.MxArray = new DomainMx.MxEntry[mxCount];
if (Settings.Sort)
{
mxs = mxs.OrderBy(mx => mx.Preference);
}
var i = 0;
foreach (var mx in mxs)
{
var entry = new DomainMx.MxEntry(domainMx, mx.Exchange, mx.Preference);
ProcessExchange(entry);
domainMx.MxArray[i++] = entry;
}
}
catch (Exception e)
{
domainMx.Error = e.Message;
wasException = true;
}
finally
{
// log info about Domain even without MX (for reporting purposes)
if (mxCount == 0 || wasException)
{
_dataStorage?.Add(domainMx);
}
}
}
public static IEnumerable<CycleCompletedArgs> GetCycles(this RemoteViewClient client, Action<RemoteViewClient> attachAction)
{
using (var resultQueue = new BlockingCollection<object>(new ConcurrentQueue<object>()))
using (var otherQueue = new BlockingCollection<object>(new ConcurrentQueue<object>()))
{
var resultListener = new EventViewResultListener();
resultListener.CycleCompleted += (sender, e) => resultQueue.Add(e);
resultListener.CycleExecutionFailed += (s, e) => otherQueue.Add(e);
resultListener.ProcessTerminated += (s, e) => otherQueue.Add(e);
resultListener.ViewDefinitionCompilationFailed += (s, e) => otherQueue.Add(e);
client.SetResultListener(resultListener);
attachAction(client);
TimeSpan timeout = TimeSpan.FromMinutes(1);
try
{
while (true)
{
object next;
var index = BlockingCollection<object>.TryTakeFromAny(new[] { resultQueue, otherQueue }, out next, timeout);
if (index == 0)
{
yield return (CycleCompletedArgs)next;
}
else
{
var detailMessage = string.Format("for {0} after {1}\n state {2} is completed {3}", client.GetViewDefinition().Name, timeout, client.GetState(), client.IsCompleted);
switch (index)
{
case 0:
throw new ArgumentException("index");
case 1:
throw new Exception(string.Format("Error occured whilst getting results {0}\n{1}", next, detailMessage));
default:
throw new TimeoutException("No results received " + detailMessage);
}
}
}
}
finally
{
client.RemoveResultListener();
}
}
}
private void MsgWindow_ClipboardContentChanged(object sender, EventArgs e)
{
string text = WinClipboard.ReadText();
if (text == null)
{
return;
}
ISLogger.Write("INPUTMANAGER->OnClipboardCopied");
inputQueue?.Add(new Win32Msg {
wParam = INPUTSHARE_CLIPBOARDTEXTCOPY, cbText = text
});
}
public static void Main ()
{
int gcCount = 0;
int joinCount = 0;
targetTime = DateTime.UtcNow.AddSeconds(30);
Thread gcThread = new Thread (() => {
while (!finished()) {
GC.Collect ();
gcCount++;
Thread.Sleep (1);
}
});
gcThread.Start ();
// Create threads then join them for 30 seconds nonstop while GCs occur once per ms
while (!finished()) {
BlockingCollection<Thread> threads = new BlockingCollection<Thread> (new ConcurrentQueue<Thread> (), 128);
Thread joinThread = new Thread (() => {
for (int i = 0; ; ++i) {
Thread t = threads.Take ();
if (t == null)
break;
t.Join ();
// Uncomment this and run with MONO_LOG_LEVEL=info MONO_LOG_MASK=gc
// to see GC/join balance in real time
//Console.Write ("*");
}
});
joinThread.Start ();
const int makeThreads = 10*1000;
for (int i = 0; i < makeThreads; ++i) {
Thread t = new Thread (() => { Thread.Yield (); });
t.Start ();
threads.Add (t);
}
threads.Add (null);
joinThread.Join ();
joinCount += makeThreads;
Console.WriteLine("Performed {0} GCs, created {1} threads. Finished? {2}", gcCount, joinCount, finished());
}
gcThread.Join ();
}
public void DetachedParentChild()
{
//Arrange
var sequence = new BlockingCollection<int>();
var child1 = new Action(() => { sequence.Add(2); Thread.Sleep(5000); sequence.Add(4); });
var parent = new Action(() => { sequence.Add(1); Task.Factory.StartNew(child1); Thread.Sleep(2500); sequence.Add(3); });
//Act
var parent_task = Task.Factory.StartNew(parent);
parent_task.Wait();
//Assert
Assert.IsTrue(Enumerable.SequenceEqual(new int[] { 1, 2, 3 }, sequence), sequence.Aggregate(new StringBuilder(), (whole, next) => whole.AppendFormat("{0}|", next)).ToString());
CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, sequence.ToList());
}
public void TestCollectionContainsElement2()
{
string item = "abc";
BlockingCollection<string> collection = new BlockingCollection<string>();
collection.Add("cat");
collection.Add(item);
collection.Add("dog");
Assert.Equal(item, collection.Take(item));
// Remove remaining items, check that item is not there
Assert.NotEqual(item, collection.Take());
Assert.NotEqual(item, collection.Take());
Assert.Equal(0, collection.Count);
}
public void Send(IrcMessage payload)
{
if (!_runCts.IsCancellationRequested)
{
_sendQueue?.Add(payload);
}
}
public void TestStreamingTransportServer()
{
BlockingCollection<string> queue = new BlockingCollection<string>();
List<string> events = new List<string>();
IStreamingCodec<string> stringCodec = _injector.GetInstance<StringStreamingCodec>();
IPEndPoint endpoint = new IPEndPoint(IPAddress.Any, 0);
var remoteHandler = Observer.Create<TransportEvent<string>>(tEvent => queue.Add(tEvent.Data));
using (var server = new StreamingTransportServer<string>(endpoint.Address, remoteHandler, _tcpPortProvider, stringCodec))
{
server.Run();
IPEndPoint remoteEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), server.LocalEndpoint.Port);
using (var client = new StreamingTransportClient<string>(remoteEndpoint, stringCodec))
{
client.Send("Hello");
client.Send(", ");
client.Send("World!");
events.Add(queue.Take());
events.Add(queue.Take());
events.Add(queue.Take());
}
}
Assert.Equal(3, events.Count);
Assert.Equal(events[0], "Hello");
Assert.Equal(events[1], ", ");
Assert.Equal(events[2], "World!");
}
static void Main(string[] args)
{
Console.WriteLine("=== In Line Execution ===");
Task<string>[] tasks = GetTasks();
string[] all = Task.WhenAll(tasks).Result;
Console.WriteLine(string.Join("", all));
Console.WriteLine("=== Standard Live Execution ===");
tasks = GetTasks();
BlockingCollection<string> results = new BlockingCollection<string>();
Task.WaitAll(tasks.Select(async t =>
{
results.Add(await t);
Console.WriteLine("[{0:hh:mm:ss.fff}] Current result: [{1}]", DateTime.Now, string.Join("", results));
}).ToArray());
Console.WriteLine("=== Pragmateek Live Execution ===");
results = new BlockingCollection<string>();
tasks = GetTasks();
Task.WaitAll(tasks.Select(t => t.ContinueWith(p =>
{
results.Add(p.Result);
Console.WriteLine("[{0:hh:mm:ss.fff}] Current result: [{1}]", DateTime.Now, string.Join("", results));
})).ToArray());
}
public void Run()
{
BlockingCollection<string> col = new BlockingCollection<string>();
Task read = Task.Run(() =>
{
foreach (string v in col.GetConsumingEnumerable())
Console.WriteLine(v);
Console.WriteLine("End of read task.");
});
Task write = Task.Run(() =>
{
while (true)
{
string s = Console.ReadLine();
if (string.IsNullOrWhiteSpace(s))
{
col.CompleteAdding();
break;
}
col.Add(s);
}
});
write.Wait();
Thread.Sleep(1000);
}
public void Publish_Where_Channel_Publication_Fails_Results_In_A_Non_Completed_Publication_Task_Which_Is_Placed_Back_On_The_Publication_Queue()
{
var _connection = Substitute.For<IConnection>();
var _channel = Substitute.For<IModel>();
var _publicationQueue = new BlockingCollection<Publication>();
_connection.CreateModel().Returns(_channel);
_channel
.When(channel => channel.BasicPublish(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IBasicProperties>(), Arg.Any<byte[]>()))
.Do(callInfo => { throw new ApplicationException("Bang !"); });
var _messageDelivery = new MessageDelivery("EXCHANGE", typeof(MyEvent).Name, MessageDeliveryMode.Persistent, message => "ARoutingKey");
var _myEvent = new MyEvent(Guid.NewGuid(), "CorrlationId_1", "Detail", 1);
var _taskCompletionSource = new TaskCompletionSource<PublicationResult>();
var _publication = new Publication(_messageDelivery, _myEvent, _taskCompletionSource);
var _SUT = new Publisher(_connection, _publicationQueue, CancellationToken.None);
var _publisherTask = _SUT.Start();
_publicationQueue.Add(_publication);
try { _publisherTask.Wait(); } catch { }
Assert.IsFalse(_publication.ResultTask.IsCompleted);
Assert.AreSame(_publication, _publicationQueue.First());
}
internal void SendEvent(Event e)
{
if (Connected && !(_sendQueue?.IsAddingCompleted ?? true))
{
_sendQueue?.Add(e);
}
}
public static void InternalCancellation_WakingUp()
{
for (int test = 0; test < 2; test++)
{
BlockingCollection<int> coll1 = new BlockingCollection<int>(1);
coll1.Add(1); //fills the collection.
Assert.False(coll1.IsAddingCompleted,
"InternalCancellation_WakingUp: At this point CompleteAdding should not have occurred.");
// This is racy on what we want to test, in that it's possible this queued work could execute
// so quickly that CompleteAdding happens before the tested method gets invoked, but the test
// should still pass in such cases, we're just testing something other than we'd planned.
Task t = Task.Run(() => coll1.CompleteAdding());
// Try different methods that should wake up once CompleteAdding has been called
int item = coll1.Take(); // remove the existing item in the collection
switch (test)
{
case 0:
Assert.Throws<InvalidOperationException>(() => coll1.Take());
break;
case 1:
Assert.False(coll1.TryTake(out item));
break;
}
t.Wait();
Assert.True(coll1.IsAddingCompleted,
"InternalCancellation_WakingUp: At this point CompleteAdding should have occurred.");
}
}
public static void Main(string[] args)
{
Console.WriteLine("Hello World!");
BlockingCollection<String> col = new BlockingCollection<string>();
Task read = Task.Run(() =>
{
foreach (String v in col.GetConsumingEnumerable())
Console.WriteLine(v);
});
Task write = Task.Run(() =>
{
while (true)
{
String s = Console.ReadLine();
if (String.IsNullOrWhiteSpace(s)) break;
col.Add(s);
}
});
write.Wait();
Console.Write("Press any key to continue . . . ");
Console.ReadKey(true);
}
private SubstManager()
{
FindAvailableDrives();
_freeDriveQ = new BlockingCollection<char>(_driveSet.Length);
foreach (char drive in _driveSet)
_freeDriveQ.Add(drive);
}
public void Send(RpcPayload payload)
{
if (!_runCts.IsCancellationRequested)
{
_sendQueue?.Add(payload);
}
}
public static void Run()
{
int size = 10;
BlockingCollection<int> col = new BlockingCollection<int>(size/3);
Task read = Task.Run(() =>
{
foreach(var item in col.GetConsumingEnumerable())
{
Console.WriteLine("Read " + item);
}
});
Task write = Task.Run(() =>
{
foreach(int i in Enumerable.Range(1, size))
{
Console.WriteLine("adding " + i);
col.Add(i);
}
col.CompleteAdding();
});
write.Wait();
read.Wait();
}
public override IEnumerable<Row> Execute(IEnumerable<Row> rows) {
var blockingCollection = new BlockingCollection<Row>();
var count = _operations.Count;
if (count == 0) {
yield break;
}
Debug("Creating tasks for {0} operations.", count);
var tasks = _operations.Select(currentOp =>
Task.Factory.StartNew(() => {
try {
foreach (var row in currentOp.Execute(null)) {
blockingCollection.Add(row);
}
}
finally {
if (Interlocked.Decrement(ref count) == 0) {
blockingCollection.CompleteAdding();
}
}
})).ToArray();
foreach (var row in blockingCollection.GetConsumingEnumerable()) {
yield return row;
}
Task.WaitAll(tasks); // raise any exception that were raised during execution
}
public void AddTryTake(int producerThreads, int consumerThreads)
{
var stack = new BlockingCollection<int>();
var startEvent = new ManualResetEventSlim(false);
var finished = 0;
var stop = false;
var producerTasks = Enumerable.Range(0, producerThreads).Select(i => Task.Factory.StartNew(() =>
{
var count = iterations/producerThreads;
startEvent.Wait();
for (var j = 0; j < count; j++)
stack.Add(0);
Interlocked.Increment(ref finished);
if (finished >= producerThreads) stop = true;
}, TaskCreationOptions.LongRunning)).ToArray();
var consumerTasks = Enumerable.Range(0, consumerThreads).Select(i => Task.Factory.StartNew(() =>
{
int num;
startEvent.Wait();
while (!stop) stack.TryTake(out num);
}, TaskCreationOptions.LongRunning)).ToArray();
var stopwatch = Stopwatch.StartNew();
startEvent.Set();
stop = true;
Task.WaitAll(producerTasks);
Task.WaitAll(consumerTasks);
stopwatch.StopAndLog(iterations);
}
static void Main(string[] args)
{
BlockingCollection<String> col = new BlockingCollection<string>();
Task read = Task.Run(() =>
{
while (true)
{
Console.WriteLine(col.Take());
}
});
Task write = Task.Run(() =>
{
while (true)
{
string s = Console.ReadLine();
if (string.IsNullOrWhiteSpace(s))
{
break;
}
col.Add(s);
}
});
write.Wait();
}
private static void Decrypt(IHashAlgorithm algo)
{
// IProducerConsumerCollection
using (var producerConsumerCollection = new BlockingCollection<string>(50000))
{
// Consumer.
var tasks = new List<Task>();
for (int workingThread = 0; workingThread < Environment.ProcessorCount; workingThread++)
{
tasks.Add(Task.Factory.StartNew(() => HashThread(algo, producerConsumerCollection)));
}
// Producer.
while (true)
{
var line = Console.ReadLine();
if (line == null)
{
producerConsumerCollection.CompleteAdding();
break;
}
producerConsumerCollection.Add(line);
}
// Wait until processing is done.
foreach (Task task in tasks)
{
task.Wait();
}
}
}
public static void Main(string[] args)
{
BlockingCollection<string> collection = new BlockingCollection<string>();
Task read = Task.Run(() =>
{
foreach (string v in collection.GetConsumingEnumerable())
{
Console.WriteLine(v);
}
});
Task write = Task.Run(() =>
{
while (true)
{
string s = Console.ReadLine();
if (string.IsNullOrWhiteSpace(s))
{
collection.CompleteAdding();
break;
}
collection.Add(s);
}
});
write.Wait();
}
public Manifest Build(string path, IPackageMetaData packageMetaData)
{
var files = this.artefactProcessor.RetrieveFiles(path);
var manifest = new Manifest
{
Author = packageMetaData.Author,
Id = Guid.NewGuid(),
Name = packageMetaData.Name,
Path = path,
Tokens = packageMetaData.Tokens,
Version = packageMetaData.Version,
};
int progress = 0;
var fileCount = files.Count();
var manifestFiles = new BlockingCollection<ManifestFile>();
Parallel.ForEach(
files,
file =>
{
manifestFiles.Add(new ManifestFile { File = StripParentPath(path, file) });
this.progressNotifier.UpdateProgress(ProgressStage.BuildManifest, fileCount, progress);
progress++;
});
manifest.Files.AddRange(manifestFiles);
return manifest;
}
/// <summary>
/// <para>관리되는 대상 목록의 조건에 만족하는 타입을 반환합니다. </para>
/// <para>.NET Framework 4.0 빌드는 병렬적으로 작업을 처리합니다.</para>
/// </summary>
/// <returns>
/// 조건에 만족하는 타입 목록입니다.
/// </returns>
public override IEnumerable<Type> GetMatchingTypes()
{
#if NET40
BlockingCollection<Type> blockedTypeCollection = new BlockingCollection<Type>();
Parallel.ForEach( this.types, (type, loop) =>
{
if( type.IsDependencyAttribute() )
blockedTypeCollection.Add(type);
});
return blockedTypeCollection.AsEnumerable();
#else
foreach (var type in this.types)
{
if (type.IsDependencyAttribute())
{
yield return type;
}
else if ( type.IsDynamicAttribute() )
{
yield return type;
}
}
#endif
}
public void TestWritableTransportServer()
{
BlockingCollection<WritableString> queue = new BlockingCollection<WritableString>();
List<string> events = new List<string>();
IPEndPoint endpoint = new IPEndPoint(IPAddress.Any, 0);
var remoteHandler = Observer.Create<TransportEvent<WritableString>>(tEvent => queue.Add(tEvent.Data));
using (var server = new WritableTransportServer<WritableString>(endpoint, remoteHandler, _tcpPortProvider, _injector))
{
server.Run();
IPEndPoint remoteEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), server.LocalEndpoint.Port);
using (var client = new WritableTransportClient<WritableString>(remoteEndpoint, _injector))
{
client.Send(new WritableString("Hello"));
client.Send(new WritableString(", "));
client.Send(new WritableString("World!"));
events.Add(queue.Take().Data);
events.Add(queue.Take().Data);
events.Add(queue.Take().Data);
}
}
Assert.AreEqual(3, events.Count);
Assert.AreEqual(events[0], "Hello");
Assert.AreEqual(events[1], ", ");
Assert.AreEqual(events[2], "World!");
}
public object Read(Newtonsoft.Json.JsonReader reader)
{
if (reader.TokenType != Newtonsoft.Json.JsonToken.StartObject)
throw new Exception();
int w = ReadIntProperty(reader, "Width");
int h = ReadIntProperty(reader, "Height");
int d = ReadIntProperty(reader, "Depth");
var grid = new TileData[d, h, w];
reader.Read();
if (reader.TokenType != Newtonsoft.Json.JsonToken.PropertyName || (string)reader.Value != "TileData")
throw new Exception();
ReadAndValidate(reader, Newtonsoft.Json.JsonToken.StartArray);
var queue = new BlockingCollection<Tuple<int, byte[]>>();
var readerTask = Task.Factory.StartNew(() =>
{
for (int i = 0; i < d; ++i)
{
reader.Read();
int z = (int)(long)reader.Value;
byte[] buf = reader.ReadAsBytes();
queue.Add(new Tuple<int, byte[]>(z, buf));
}
queue.CompleteAdding();
});
Parallel.For(0, d, i =>
{
var tuple = queue.Take();
int z = tuple.Item1;
byte[] arr = tuple.Item2;
using (var memStream = new MemoryStream(arr))
{
using (var decompressStream = new DeflateStream(memStream, CompressionMode.Decompress))
using (var streamReader = new BinaryReader(decompressStream))
{
for (int y = 0; y < h; ++y)
for (int x = 0; x < w; ++x)
grid[z, y, x].Raw = streamReader.ReadUInt64();
}
}
});
readerTask.Wait();
ReadAndValidate(reader, Newtonsoft.Json.JsonToken.EndArray);
ReadAndValidate(reader, Newtonsoft.Json.JsonToken.EndObject);
return grid;
}
public async Task CopyContainer(CloudBlobContainer sourceContainer, string destination)
{
var uri = new Uri(sourceContainer.Uri.AbsoluteUri.TrimEnd('/') + '/');
destination = Path.Combine(destination, sourceContainer.Name);
BlobContinuationToken continuationToken = null;
do
{
var segments = await sourceContainer.ListBlobsSegmentedAsync(prefix: null, useFlatBlobListing: true,
blobListingDetails: BlobListingDetails.Metadata, maxResults: MaxParallelDownloads,
currentToken: continuationToken, options: null, operationContext: null);
var tasks = new BlockingCollection<Task>(MaxParallelDownloads);
Parallel.ForEach(segments.Results.Cast<CloudBlockBlob>(), srcFile =>
{
var relativePath = uri.MakeRelativeUri(srcFile.Uri);
var destLocation = Path.Combine(destination, relativePath.OriginalString);
if (File.Exists(destLocation) && File.GetLastWriteTimeUtc(destLocation) == srcFile.Properties.LastModified)
{
// If the file looks unchanged, skip it.
return;
}
Directory.CreateDirectory(Path.GetDirectoryName(destLocation));
tasks.Add(srcFile.DownloadToFileAsync(destLocation, FileMode.Create));
});
await Task.WhenAll(tasks);
continuationToken = segments.ContinuationToken;
} while (continuationToken != null);
}
static void Main(string[] args)
{
// create a blocking collection
BlockingCollection<int> blockingCollection
= new BlockingCollection<int>();
// create and start a producer
Task.Factory.StartNew(() => {
// put the producer to sleep
System.Threading.Thread.Sleep(500);
for (int i = 0; i < 100; i++) {
// add the item to the collection
blockingCollection.Add(i);
}
// mark the collection as finished
blockingCollection.CompleteAdding();
});
// create and start a consumer
Task consumer = Task.Factory.StartNew(() => {
// use a foreach loop to consume the blocking collection
foreach (int i in blockingCollection) {
Console.WriteLine("Item {0}", i);
}
Console.WriteLine("Collection is fully consumed");
});
// wait for the consumer to finish
consumer.Wait();
// wait for input before exiting
Console.WriteLine("Press enter to finish");
Console.ReadLine();
}
public void Write(byte[] data)
{
try {
_writeQueue?.Add(data);
} catch (InvalidOperationException) {
Log.To.Sync.I(Tag, "Attempt to write after closing socket, ignore...");
}
}
/// <summary>
/// Process customer's order request.
/// </summary>
/// <param name="orderRequest">Order request quantum</param>
/// <returns></returns>
public void ExecuteOrder(EffectProcessorsContainer effectsContainer)
{
RequestQuantum orderRequestQuantum = (RequestQuantum)effectsContainer.Envelope.Message;
var orderRequest = (OrderRequest)orderRequestQuantum.RequestEnvelope.Message;
var updates = new OrderMatcher(orderRequest, effectsContainer).Match();
awaitedUpdates?.Add(updates);
}
/// <inheritdoc />
public void Dispose()
{
if (_disposed)
{
return;
}
Flush();
if (!_synchronous)
{
_flushTimer?.Dispose();
_requests?.Add(new ShutdownRequest());
_writerTask?.Wait();
_requests?.Dispose();
_requests = null;
}
_disposed = true;
}
public void AddTask(T task)
{
try
{
_blockingCollection?.Add(task);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public Job(int id, Process process, JobCallbackInfo callback = null)
{
logger.Info("Spawning new job id {0}; will call {1}", id, process.StartInfo.FileName);
jobId = id;
this.process = process;
// if a progress port was specified in callback info, prepare for streaming
if (callback != null && callback.ProgressPort > 0)
{
var streamEp = new IPEndPoint(callback.Address, callback.ProgressPort);
CreateProgressStream(streamEp);
streamingCollection = new BlockingCollection <string>();
process.OutputDataReceived += (s, a) => streamingCollection.Add(a.Data);
process.ErrorDataReceived += (s, a) => streamingCollection.Add(a.Data);
streamingLoopTask = Task.Factory.StartNew(StreamingLoopHandler);
}
else
{
output = new HelperFunctions.ThreadSafeStringBuilder();
process.OutputDataReceived += (s, a) => output.AppendLine(a.Data);
process.ErrorDataReceived += (s, a) => output.AppendLine(a.Data);
}
// always log output
process.OutputDataReceived += (s, a) => logger.Debug($"Job {this.jobId} std output: {a.Data}");
process.ErrorDataReceived += (s, a) => logger.Debug($"Job {this.jobId} std error: {a.Data}");
// add a logging message when a job finishes and ensure that streaming task stops if needed
process.EnableRaisingEvents = true;
process.Exited += (o, e) => logger.Info($"Job {id} finished executing.");
process.Exited += (o, e) => streamingCollection?.Add(null);
if (callback != null)
{
logger.Info("Registering job {0:d} for callbacks", id);
// if callbacks are specified, we need to register for process events, and setup a handler
callbackInfo = callback;
// fire the callback handler in another thread (otherwise the callback might take a while and block other events waiting on exit)
process.Exited += (o, e) => Task.Factory.StartNew(FireCompletionCallback);
}
process.Start();
process.BeginErrorReadLine();
process.BeginOutputReadLine();
}
private void Log(Guid CorrelationId, string Message, LogLevel LogLevel, bool SendToConsole)
{
if (LogLevel <= _settings.TraceLogLevel)
{
var message = _settings.MaxTraceLogSize.HasValue ? Message.Truncate(_settings.MaxTraceLogSize.Value) : Message;
var traceLog = new TraceLog(CorrelationId, message, LogLevel);
FormatMessage(traceLog);
_traceQueue?.Add(traceLog);
if (SendToConsole)
{
Console.WriteLine(traceLog.Message);
}
}
}
/// <summary>
/// Queue the job for processing.
/// </summary>
/// <returns><c>true</c>, if job was queued, <c>false</c> otherwise.</returns>
/// <param name="job">The job</param>
/// </param>
public bool Enqueue(object o)
{
if (!m_isRunning)
{
return(false);
}
m_jobQueue?.Add(o);
lock (m_mainLock)
{
if (m_numberThreads < m_concurrency && m_numberThreads < m_jobQueue.Count)
{
Util.FireAndForget(ProcessRequests, null, m_name, false);
++m_numberThreads;
}
}
return(true);
}
public NotificationService(
ClusterConfig clusterConfig,
JsonSerializerSettings serializerSettings,
IMessageBus messageBus)
{
Contract.RequiresNonNull(clusterConfig, nameof(clusterConfig));
Contract.RequiresNonNull(messageBus, nameof(messageBus));
this.clusterConfig = clusterConfig;
this.serializerSettings = serializerSettings;
poolConfigs = clusterConfig.Pools.ToDictionary(x => x.Id, x => x);
adminEmail = clusterConfig.Notifications?.Admin?.EmailAddress;
//adminPhone = null;
if (clusterConfig.Notifications?.Enabled == true)
{
queue = new BlockingCollection <QueuedNotification>();
queueSub = queue.GetConsumingEnumerable()
.ToObservable(TaskPoolScheduler.Default)
.Select(notification => Observable.FromAsync(() => SendNotificationAsync(notification)))
.Concat()
.Subscribe();
messageBus.Listen <BlockNotification>()
.Subscribe(x =>
{
queue?.Add(new QueuedNotification
{
Category = NotificationCategory.Block,
PoolId = x.PoolId,
Subject = "Block Notification",
Msg = $"Pool {x.PoolId} found block candidate {x.BlockHeight}"
});
});
}
}
/// <summary> Starts capturing and processing video frames. </summary>
/// <param name="frameGrabDelay"> The frame grab delay. </param>
/// <param name="timestampFn"> Function to generate the timestamp for each frame. This
/// function will get called once per frame. </param>
protected void StartProcessing(TimeSpan frameGrabDelay, Func <DateTime> timestampFn)
{
OnProcessingStarting();
ResetTrigger = true;
FrameGrabTimer.Reset();
AnalysisTaskQueue = new BlockingCollection <Task <NewResultEventArgs> >();
var timerIterations = 0;
// Create a background thread that will grab frames in a loop.
ProducerTask = Task.Factory.StartNew(async() =>
{
var frameCount = 0;
while (!Stopping)
{
LogMessage("Producer: waiting for timer to trigger frame-grab");
// Wait to get released by the timer.
FrameGrabTimer.WaitOne();
LogMessage("Producer: grabbing frame...");
DateTime startTime;
// Grab single frame.
var timestamp = timestampFn();
var image = new Mat();
var success = Reader.Read(image);
LogMessage("Producer: frame-grab took {0} ms", (DateTime.Now - startTime).Milliseconds);
if (!success)
{
// If we've reached the end of the video, stop here.
if (Reader.CaptureType == CaptureType.File)
{
LogMessage("Producer: null frame from video file, stop!");
// This will call StopProcessing on a new thread.
await StopProcessingAsync();
// Break out of the loop to make sure we don't try grabbing more
// frames.
break;
}
// If failed on live camera, try again.
LogMessage("Producer: null frame from live camera, continue!");
continue;
}
// Package the image for submission.
VideoFrameMetadata meta;
meta.Index = frameCount;
meta.Timestamp = timestamp;
var vframe = new VideoFrame(image, meta);
// Raise the new frame event
LogMessage("Producer: new frame provided, should analyze? Frame num: {0}", meta.Index);
OnNewFrameProvided(vframe);
if (AnalysisPredicate(vframe))
{
LogMessage("Producer: analyzing frame");
// Call the analysis function on a threadpool thread
var analysisTask = DoAnalyzeFrame(vframe);
LogMessage("Producer: adding analysis task to queue {0}", analysisTask.Id);
// Push the frame onto the queue
AnalysisTaskQueue.Add(analysisTask);
}
else
{
LogMessage("Producer: not analyzing frame");
}
LogMessage("Producer: iteration took {0} ms", (DateTime.Now - startTime).Milliseconds);
++frameCount;
}
LogMessage("Producer: stopping, destroy reader and timer");
AnalysisTaskQueue.CompleteAdding();
// We reach this point by breaking out of the while loop. So we must be stopping.
Reader.Dispose();
Reader = null;
// Make sure the timer stops, then get rid of it.
var h = new ManualResetEvent(false);
Timer.Dispose(h);
h.WaitOne();
Timer = null;
LogMessage("Producer: stopped");
}, TaskCreationOptions.LongRunning);
ConsumerTask = Task.Factory.StartNew(async() =>
{
while (!AnalysisTaskQueue.IsCompleted)
{
LogMessage("Consumer: waiting for task to get added");
// Get the next processing task.
Task <NewResultEventArgs> nextTask = null;
// Blocks if m_analysisTaskQueue.Count == 0
// IOE means that Take() was called on a completed collection.
// Some other thread can call CompleteAdding after we pass the
// IsCompleted check but before we call Take.
// In this example, we can simply catch the exception since the
// loop will break on the next iteration.
// See https://msdn.microsoft.com/en-us/library/dd997371(v=vs.110).aspx
try
{
nextTask = AnalysisTaskQueue.Take();
}
catch (InvalidOperationException) { }
if (nextTask == null)
{
continue;
}
// Block until the result becomes available.
LogMessage("Consumer: waiting for next result to arrive for task {0}", nextTask.Id);
var result = await nextTask;
// Raise the new result event.
LogMessage("Consumer: got result for frame {0}. {1} tasks in queue", result.Frame.Metadata.Index, AnalysisTaskQueue.Count);
OnNewResultAvailable(result);
}
LogMessage("Consumer: stopped");
}, TaskCreationOptions.LongRunning);
// Set up a timer object that will trigger the frame-grab at a regular interval.
Timer = new Timer(async s /* state */ =>
{
await TimerMutex.WaitAsync();
try
{
// If the handle was not reset by the producer, then the frame-grab was missed.
bool missed = FrameGrabTimer.WaitOne(0);
FrameGrabTimer.Set();
if (missed)
{
LogMessage("Timer: missed frame-grab {0}", timerIterations - 1);
}
LogMessage("Timer: grab frame num {0}", timerIterations);
++timerIterations;
}
finally
{
TimerMutex.Release();
}
}, null, TimeSpan.Zero, frameGrabDelay);
OnProcessingStarted();
}
public override void OnNext(byte value)
{
_fifo.Add(value);
}
public void ReadAll(Func <int, Release, bool> processor)
{
TaskCreationOptions taskOptions = TaskCreationOptions.LongRunning;
Task[] consumers = new Task[this.ThreadCount];
for (int i = 0; i < consumers.Length; ++i)
{
consumers[i] = Task.Factory.StartNew(delegate(object state)
{
int threadNumber = (int)state;
int count = 0;
try
{
string[] stringBatch;
while (true)
{
BlockingCollection <string[]> .TakeFromAny(stringCollection, out stringBatch, cancellationToken);
foreach (string releaseStringOriginal in stringBatch)
{
// Remove <releases>...</releases>
string releaseString = Utility.TrimString(releaseStringOriginal, "<releases>");
releaseString = Utility.TrimString(releaseString, "</releases>");
var fixedText = Utility.FixXmlText(releaseString);
XDocument doc = XDocument.Parse(fixedText);
var release = DataReader.ReadRelease(doc.Root);
++count;
if (!processor(threadNumber, release))
{
cancellationSource.Cancel();
throw new OperationCanceledException();
}
}
}
}
catch (OperationCanceledException)
{
}
catch (InvalidOperationException)
{
}
catch (ArgumentException)
{
}
}, i, taskOptions);
}
Task stringProducer = Task.Factory.StartNew(delegate
{
try
{
string[] stringBatch;
while (ReadBatch(BatchSize, out stringBatch))
{
BlockingCollection <string[]> .AddToAny(stringCollection, stringBatch, cancellationToken);
}
}
catch (OperationCanceledException)
{
}
catch (InvalidOperationException)
{
}
finally
{
foreach (var coll in stringCollection)
{
coll.CompleteAdding();
}
}
}, taskOptions);
Task dataReader = Task.Factory.StartNew(delegate
{
try
{
int read = 0;
char[] NewBuffer = new char[BufferSize];
while ((read = reader.ReadBlock(NewBuffer, 0, BufferSize)) > 0)
{
bufferCollection.Add(new CharBuffer(NewBuffer, read), cancellationToken);
NewBuffer = new char[BufferSize];
}
}
catch (OperationCanceledException)
{
}
finally
{
bufferCollection.CompleteAdding();
}
}, taskOptions);
Task.WaitAll(consumers);
stringProducer.Wait();
dataReader.Wait();
}
public NotificationService(
ClusterConfig clusterConfig,
JsonSerializerSettings serializerSettings,
IMessageBus messageBus)
{
Contract.RequiresNonNull(clusterConfig, nameof(clusterConfig));
Contract.RequiresNonNull(messageBus, nameof(messageBus));
this.clusterConfig = clusterConfig;
this.serializerSettings = serializerSettings;
poolConfigs = clusterConfig.Pools.ToDictionary(x => x.Id, x => x);
adminEmail = clusterConfig.Notifications?.Admin?.EmailAddress;
//adminPhone = null;
if (clusterConfig.Notifications?.Enabled == true)
{
queue = new BlockingCollection <QueuedNotification>();
queueSub = queue.GetConsumingEnumerable()
.ToObservable(TaskPoolScheduler.Default)
.Select(notification => Observable.FromAsync(() => SendNotificationAsync(notification)))
.Concat()
.Subscribe();
messageBus.Listen <AdminNotification>()
.Subscribe(x =>
{
queue?.Add(new QueuedNotification
{
Category = NotificationCategory.Admin,
Subject = x.Subject,
Msg = x.Message
});
});
messageBus.Listen <BlockNotification>()
.Subscribe(x =>
{
queue?.Add(new QueuedNotification
{
Category = NotificationCategory.Block,
PoolId = x.PoolId,
Subject = "Block Notification",
Msg = $"Pool {x.PoolId} found block candidate {x.BlockHeight}"
});
});
messageBus.Listen <PaymentNotification>()
.Subscribe(x =>
{
if (string.IsNullOrEmpty(x.Error))
{
queue?.Add(new QueuedNotification
{
Category = NotificationCategory.PaymentSuccess,
PoolId = x.PoolId,
Subject = "Payout Success Notification",
Msg = $"Paid {FormatAmount(x.Amount, x.PoolId)} from pool {x.PoolId} to {x.RecpientsCount} recipients in Transaction(s) {x.TxInfo}."
});
}
else
{
queue?.Add(new QueuedNotification
{
Category = NotificationCategory.PaymentFailure,
PoolId = x.PoolId,
Subject = "Payout Failure Notification",
Msg = $"Failed to pay out {x.Amount} {poolConfigs[x.PoolId].Coin.Type} from pool {x.PoolId}: {x.Error}"
});
}
});
}
}
void CalculateIntoGroup()
{
List <Guid> leftRecords = new List <Guid>();
HashSet <Guid> filesProcessed = new HashSet <Guid>();
groupedFiles = new Dictionary <int, Dictionary <Guid, List <Guid> > >();
Dictionary <Guid, List <Guid> > disconnectedFiles = null;
if (IncludesDisconnected)
{
disconnectedFiles = new Dictionary <Guid, List <Guid> >();
foreach (var record in allRecords)
{
if (record.Value.IgnoredMode == IgnoredMode.HiddenAndDisconnected)
{
if (!disconnectedFiles.TryGetValue(record.Value.File1Id, out var list))
{
list = new List <Guid>();
disconnectedFiles.Add(record.Value.File1Id, list);
}
list.Add(record.Key);
if (!disconnectedFiles.TryGetValue(record.Value.File2Id, out list))
{
list = new List <Guid>();
disconnectedFiles.Add(record.Value.File2Id, list);
}
list.Add(record.Key);
}
else
{
leftRecords.Add(record.Key);
}
}
}
else
{
foreach (var record in allRecords)
{
if (record.Value.IgnoredMode != IgnoredMode.HiddenAndDisconnected)
{
leftRecords.Add(record.Key);
}
}
}
if (leftRecords.Count != 0)
{
//FileId, SimilarRecordID
var unsortedGroup = new List <Dictionary <Guid, List <Guid> > >();
BlockingCollection <Guid> needToPrepareThumbprints = null;
Thread preparingFileThumbprints = null;
needToPrepareThumbprints = new BlockingCollection <Guid>();
preparingFileThumbprints = new Thread(PreparingFileThumbprints);
preparingFileThumbprints.Start(needToPrepareThumbprints);
while (leftRecords.Count > 0)
{
var firstRecord = allRecords[leftRecords[0]];
leftRecords.RemoveAt(0);
Dictionary <Guid, List <Guid> > currentFilesGroup = new Dictionary <Guid, List <Guid> >();
unsortedGroup.Add(currentFilesGroup);
Queue <Guid> filesToProcess = new Queue <Guid>();
if (!filesProcessed.Contains(firstRecord.File1Id))
{
filesToProcess.Enqueue(firstRecord.File1Id);
}
if (!filesProcessed.Contains(firstRecord.File1Id))
{
filesToProcess.Enqueue(firstRecord.File2Id);
}
currentFilesGroup.Add(firstRecord.File1Id, new List <Guid>()
{
firstRecord.Id
});
needToPrepareThumbprints?.Add(firstRecord.File1Id);
currentFilesGroup.Add(firstRecord.File2Id, new List <Guid>()
{
firstRecord.Id
});
needToPrepareThumbprints?.Add(firstRecord.File2Id);
while (filesToProcess.Count > 0)
{
var fileToProcess = filesToProcess.Dequeue();
filesProcessed.Add(fileToProcess);
var records = fileToRecords[fileToProcess];
foreach (var recordId in records)
{
if (leftRecords.Remove(recordId))
{
var record = allRecords[recordId];
if (!filesProcessed.Contains(record.File1Id))
{
filesToProcess.Enqueue(record.File1Id);
}
if (!filesProcessed.Contains(record.File2Id))
{
filesToProcess.Enqueue(record.File2Id);
}
if (!currentFilesGroup.TryGetValue(record.File1Id, out var list))
{
list = new List <Guid>();
currentFilesGroup.Add(record.File1Id, list);
needToPrepareThumbprints?.Add(record.File1Id);
}
list.Add(record.Id);
if (!currentFilesGroup.TryGetValue(record.File2Id, out list))
{
list = new List <Guid>();
currentFilesGroup.Add(record.File2Id, list);
needToPrepareThumbprints?.Add(record.File2Id);
}
list.Add(record.Id);
}
}
}
}
var sortedGroup = unsortedGroup.OrderByDescending(i => i.Values.Sum(j => j.Count(k => allRecords[k].IgnoredMode == IgnoredMode.Effective))); //order by descending: total effective records in group.
var groupIndex = 0;
foreach (var item in sortedGroup)
{
groupedFiles.Add(groupIndex++, item);
}
needToPrepareThumbprints.CompleteAdding();
preparingFileThumbprints.Join();
needToPrepareThumbprints.Dispose();
}
if (disconnectedFiles?.Count > 0)
{
groupedFiles.Add(-1, disconnectedFiles);
}
}
void EnumerateGPOAdmin(string DomainName, BlockingCollection <LocalAdminInfo> output)
{
string targetsid = "S-1-5-32-544__Members";
Console.WriteLine("Starting GPO Correlation");
DirectorySearcher gposearcher = helpers.GetDomainSearcher(DomainName);
gposearcher.Filter = "(&(objectCategory=groupPolicyContainer)(name=*)(gpcfilesyspath=*))";
gposearcher.PropertiesToLoad.AddRange(new string[] { "displayname", "name", "gpcfilesyspath" });
ConcurrentQueue <string> INIResults = new ConcurrentQueue <string>();
Parallel.ForEach(gposearcher.FindAll().Cast <SearchResult>().ToArray(), (result) =>
{
string display = result.GetProp("displayname");
string name = result.GetProp("name");
string path = result.GetProp("gpcfilesyspath");
if (display == null || name == null || path == null)
{
return;
}
string template = String.Format("{0}\\{1}", path, "MACHINE\\Microsoft\\Windows NT\\SecEdit\\GptTmpl.inf");
using (StreamReader sr = new StreamReader(template))
{
string line = String.Empty;
string currsection = String.Empty;
while ((line = sr.ReadLine()) != null)
{
Match section = Regex.Match(line, @"^\[(.+)\]");
if (section.Success)
{
currsection = section.Captures[0].Value.Trim();
}
if (!currsection.Equals("[Group Membership]"))
{
continue;
}
Match key = Regex.Match(line, @"(.+?)\s*=(.*)");
if (key.Success)
{
string n = key.Groups[1].Value;
string v = key.Groups[2].Value;
if (n.Contains(targetsid))
{
v = v.Trim();
List <String> members = v.Split(',').ToList();
List <DBObject> resolved = new List <DBObject>();
for (int i = 0; i < members.Count; i++)
{
string m = members[i];
m = m.Trim('*');
string sid;
if (!m.StartsWith("S-1-", StringComparison.CurrentCulture))
{
try
{
sid = new NTAccount(DomainName, m).Translate(typeof(SecurityIdentifier)).Value;
}
catch
{
sid = null;
}
}
else
{
sid = m;
}
if (sid == null)
{
continue;
}
string user = null;
if (manager.FindBySID(sid, CurrentDomain, out DBObject obj))
{
user = obj.BloodHoundDisplayName;
}
else
{
try
{
DirectoryEntry entry = new DirectoryEntry($"LDAP://<SID={sid}");
obj = entry.ConvertToDB();
manager.InsertRecord(obj);
}
catch
{
obj = null;
}
}
if (obj != null)
{
resolved.Add(obj);
}
}
DirectorySearcher OUSearch = helpers.GetDomainSearcher(DomainName);
OUSearch.Filter = $"(&(objectCategory=organizationalUnit)(name=*)(gplink=*{name}*))";
foreach (SearchResult r in OUSearch.FindAll())
{
DirectorySearcher compsearcher = helpers.GetDomainSearcher(DomainName, ADSPath: r.GetProp("adspath"));
foreach (SearchResult ra in compsearcher.FindAll())
{
string sat = ra.GetProp("samaccounttype");
if (sat == null)
{
continue;
}
DBObject resultdb = ra.ConvertToDB();
if (sat.Equals("805306369"))
{
foreach (DBObject obj in resolved)
{
output.Add(new LocalAdminInfo
{
ObjectName = obj.BloodHoundDisplayName,
ObjectType = obj.Type,
Server = resultdb.BloodHoundDisplayName
});
}
}
}
compsearcher.Dispose();
}
OUSearch.Dispose();
}
}
}
}
});
gposearcher.Dispose();
output.CompleteAdding();
Console.WriteLine("Done GPO Correlation");
}
protected override void QueueTask(Task task)
{
mainThreadQueue.Add(task);
}
public static void Log(string data, LogLevel level)
{
LogQueue.Add(new LogItem(data, level));
}
public void StartEnumeration()
{
Console.WriteLine("\nStarting Local Admin Enumeration");
List <string> Domains = helpers.GetDomainList();
Stopwatch watch = Stopwatch.StartNew();
Stopwatch overwatch = Stopwatch.StartNew();
foreach (string DomainName in Domains)
{
Console.WriteLine($"Started local admin enumeration for {DomainName}");
CurrentDomain = DomainName;
if (options.Stealth)
{
BlockingCollection <LocalAdminInfo> coll = new BlockingCollection <LocalAdminInfo>();
Task gpowriter = StartWriter(coll, Task.Factory);
EnumerateGPOAdmin(DomainName, coll);
gpowriter.Wait();
continue;
}
BlockingCollection <Computer> input = new BlockingCollection <Computer>();
BlockingCollection <LocalAdminInfo> output = new BlockingCollection <LocalAdminInfo>();
LimitedConcurrencyLevelTaskScheduler scheduler = new LimitedConcurrencyLevelTaskScheduler(options.Threads);
TaskFactory factory = new TaskFactory(scheduler);
Task writer = StartWriter(output, factory);
List <Task> taskhandles = new List <Task>();
for (int i = 0; i < options.Threads; i++)
{
taskhandles.Add(StartConsumer(input, output, factory));
}
System.Timers.Timer t = new System.Timers.Timer();
if (options.NoDB)
{
total = -1;
DirectorySearcher searcher = helpers.GetDomainSearcher(DomainName);
searcher.Filter = "(&(sAMAccountType=805306369)(!(UserAccountControl:1.2.840.113556.1.4.803:=2)))";
searcher.PropertiesToLoad.AddRange(new string[] { "dnshostname", "samaccounttype", "distinguishedname", "primarygroupid", "samaccountname", "objectsid" });
t.Elapsed += Timer_Tick;
t.Interval = options.Interval;
t.Enabled = true;
PrintStatus();
foreach (SearchResult r in searcher.FindAll())
{
input.Add(r.ConvertToDB() as Computer);
}
searcher.Dispose();
}
else
{
var computers =
manager.GetComputers().Find(x => x.Domain.Equals(DomainName));
total = computers.Count();
t.Elapsed += Timer_Tick;
t.Interval = options.Interval;
t.Enabled = true;
PrintStatus();
foreach (Computer c in computers)
{
input.Add(c);
}
}
input.CompleteAdding();
options.WriteVerbose("Waiting for enumeration threads to finish...");
Task.WaitAll(taskhandles.ToArray());
output.CompleteAdding();
options.WriteVerbose("Waiting for writer thread to finish...");
writer.Wait();
PrintStatus();
t.Dispose();
Console.WriteLine($"Enumeration for {CurrentDomain} done in {watch.Elapsed}");
watch.Reset();
}
Console.WriteLine($"Local Admin Enumeration done in {overwatch.Elapsed}\n");
watch.Stop();
overwatch.Stop();
}
/// <summary>
/// Enumerates GCRoots of a given object. Similar to !gcroot.
/// </summary>
/// <param name="target">The target object to search for GC rooting.</param>
/// <param name="returnOnlyFullyUniquePaths">Whether to only return fully unique paths.</param>
/// <param name="maxDegreeOfParallelism">The number of threads this class is allowed to use to calculate the result.
/// Setting this to 1 will cause the algorithm to run on the current thread.</param>
/// <param name="roots">The roots to consider. You can pass ClrMD.</param>
/// <param name="cancellationToken">A cancellation token to stop enumeration.</param>
/// <returns>An enumeration of all GC roots found for target.</returns>
public IEnumerable <GCRootPath> EnumerateGCRoots(ulong target, bool returnOnlyFullyUniquePaths, int maxDegreeOfParallelism, IEnumerable <IClrRoot> roots, CancellationToken cancellationToken = default)
{
if (roots is null)
{
throw new ArgumentNullException(nameof(roots));
}
bool parallel = Heap.Runtime.IsThreadSafe && maxDegreeOfParallelism > 1;
Dictionary <ulong, LinkedListNode <ClrObject> > knownEndPoints = new Dictionary <ulong, LinkedListNode <ClrObject> >()
{
{ target, new LinkedListNode <ClrObject>(Heap.GetObject(target)) }
};
if (!parallel)
{
int count = 0;
ObjectSet processedObjects = new ObjectSet(Heap);
foreach (IClrRoot root in roots)
{
LinkedList <ClrObject> path = PathsTo(processedObjects, knownEndPoints, root.Object, target, returnOnlyFullyUniquePaths, cancellationToken).FirstOrDefault();
if (path != null)
{
yield return(new GCRootPath(root, path.ToImmutableArray()));
}
if (count != processedObjects.Count)
{
count = processedObjects.Count;
ProgressUpdated?.Invoke(this, count);
}
}
}
else
{
ParallelObjectSet processedObjects = new ParallelObjectSet(Heap);
ConcurrentQueue <GCRootPath> results = new ConcurrentQueue <GCRootPath>();
using BlockingCollection <IClrRoot?> queue = new BlockingCollection <IClrRoot?>();
Thread[] threads = new Thread[Math.Min(maxDegreeOfParallelism, Environment.ProcessorCount)];
for (int i = 0; i < threads.Length; i++)
{
threads[i] = new Thread(() => WorkerThread(queue, results, processedObjects, knownEndPoints, target, all: true, returnOnlyFullyUniquePaths, cancellationToken))
{
Name = "GCRoot Worker Thread"
};
threads[i].Start();
}
foreach (IClrRoot root in roots)
{
queue.Add(root);
}
// Add one sentinal value for every thread
for (int i = 0; i < threads.Length; i++)
{
queue.Add(null);
}
int count = 0;
// Worker threads end when they have run out of roots to process. While we are waiting for them to exit, yield return
// any results they've found. We'll use a 100 msec timeout because processing roots is slooooow and finding a root is
// rare. There's no reason to check these results super quickly and starve worker threads.
for (int i = 0; i < threads.Length; i++)
{
while (!threads[i].Join(100))
{
while (results.TryDequeue(out GCRootPath result))
{
yield return(result);
}
}
if (count != processedObjects.Count)
{
count = processedObjects.Count;
ProgressUpdated?.Invoke(this, count);
}
}
// We could have raced to put an object in the results queue while joining the last thread, so we need to drain the
// results queue one last time.
while (results.TryDequeue(out GCRootPath result))
{
yield return(result);
}
if (count != processedObjects.Count)
{
count = processedObjects.Count;
ProgressUpdated?.Invoke(this, count);
}
}
}
public Task StartAsync(CancellationToken ct)
{
queue = new BlockingCollection <QueuedNotification>();
queueSub = queue.GetConsumingEnumerable()
.ToObservable(TaskPoolScheduler.Default)
.Select(notification => Observable.FromAsync(() => SendNotificationAsync(notification)))
.Concat()
.Subscribe();
messageBus.Listen <AdminNotification>()
.Subscribe(x =>
{
queue?.Add(new QueuedNotification
{
Category = NotificationCategory.Admin,
Subject = x.Subject,
Msg = x.Message
});
});
messageBus.Listen <BlockFoundNotification>()
.Subscribe(x =>
{
queue?.Add(new QueuedNotification
{
Category = NotificationCategory.Block,
PoolId = x.PoolId,
Subject = "Block Notification",
Msg = $"Pool {x.PoolId} found block candidate {x.BlockHeight}"
});
});
messageBus.Listen <PaymentNotification>()
.Subscribe(x =>
{
if (string.IsNullOrEmpty(x.Error))
{
var coin = poolConfigs[x.PoolId].Template;
// prepare tx links
string[] txLinks = null;
if (!string.IsNullOrEmpty(coin.ExplorerTxLink))
{
txLinks = x.TxIds.Select(txHash => string.Format(coin.ExplorerTxLink, txHash)).ToArray();
}
queue?.Add(new QueuedNotification
{
Category = NotificationCategory.PaymentSuccess,
PoolId = x.PoolId,
Subject = "Payout Success Notification",
Msg = $"Paid {FormatAmount(x.Amount, x.PoolId)} from pool {x.PoolId} to {x.RecpientsCount} recipients in Transaction(s) {txLinks}."
});
}
else
{
queue?.Add(new QueuedNotification
{
Category = NotificationCategory.PaymentFailure,
PoolId = x.PoolId,
Subject = "Payout Failure Notification",
Msg = $"Failed to pay out {x.Amount} {poolConfigs[x.PoolId].Template.Symbol} from pool {x.PoolId}: {x.Error}"
});
}
});
logger.Info(() => "Online");
return(Task.CompletedTask);
}
public static void SendAsync(HarmonyPacket p)
{
_toSend?.Add(p);
}
public void AsyncAdd(Action action)
{
lock (SyncRoot)
queue?.Add(new Tuple <Action, ManualResetEvent>(action, null));
}
public void LogPerformance(Guid CorrelationId, string OperationName, TimeSpan OperationDuration) => _performanceQueue?.Add(new PerformanceLog(CorrelationId, OperationName, OperationDuration));
private void LogMetric(Guid CorrelationId, string ItemId, string MetricName, DateTime?DateTimeValue, int?IntValue, string TextValue) => _metricQueue?.Add(new MetricLog(CorrelationId, ItemId, MetricName, DateTimeValue, IntValue, TextValue));
public static void Main()
{
BlockingCollection<string> col = new BlockingCollection<string>();
Task read = Task.Run(() =>
{
while (true)
{
//Console.WriteLine("Taking");
col.Add("Removing");
}
});
Task write = Task.Run(() =>
{
while (true)
{
string s = Console.ReadLine();
if (string.IsNullOrWhiteSpace(s)) break;
Console.WriteLine("Adding");
col.Add(s);
col.CompleteAdding();
}
});
write.Wait();
}
