public override void Init(ConcentratorDataContext context)
{
base.Init(context);
var query = String.Format(@"SELECT Prod_ID as ProdID, [path] as Path, BV.BrandID, ConcentratorID
FROM {0}
LEFT JOIN BrandVendor BV ON BV.VendorBrandCode = CAST(Supplier_id as nvarchar(10))",
ProductIndexBulk.ProductIndexTableName);
var toProcess = context.ExecuteStoreQuery <ProductProcessResult>(query).Count();
var _productsToProcess = context.ExecuteStoreQuery <ProductProcessResult>(query);
int processed = 0;
int progressReportIdx = toProcess / 20;
context.ExecuteStoreCommand(_productSpecTableCreate);
context.ExecuteStoreCommand(_productDescTableCreate);
context.ExecuteStoreCommand(_barcodeTableCreate);
context.ExecuteStoreCommand(_relatedTableCreate);
context.ExecuteStoreCommand(_imageTableCreate);
var options = new ParallelOptions
{
MaxDegreeOfParallelism = 8
};
Log.InfoFormat("About to download {0} individual product files", toProcess);
try
{
// Processes all products
Parallel.ForEach(_productsToProcess, options, (p, ls, idx) =>
{
XElement root;
using (var file = new MemoryStream())
{
try
{
//var req = (HttpWebRequest)WebRequest.Create(new Uri(base.BaseURI, p.Path));
//req.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
//req.Credentials = base.Credentials;
//var t = req.DownloadDataAsync();
////.ContinueWith<byte[]>(data =>
////{
//// return data.Result;
////});
//t.Start(Task.Factory.Scheduler);
//t.Wait();
//if (t.IsCompleted && !t.IsFaulted)
//{
// file.Write(t.Result, 0, t.Result.Length);
//}
//else
// return;
DownloadFile(p.Path, file);
file.Position = 0;
using (XmlTextReader reader = new XmlTextReader(file))
{
root = XDocument.Load(reader).Element("ICECAT-interface").Element("Product");
}
}
catch (Exception ex)
{
Log.Error(String.Format("Failed to download {0} from: {1}", p.ProdID, p.Path), ex);
return;
}
}
#region Parse xml
var baseSpec = new
{
HighPic = root.Attribute("HighPic").Value,
ICECatID = (int)root.Attribute("ID"),
Name = root.Attribute("Name").Value,
ManufacturerID = root.Attribute("Prod_id").Value,
Quality = root.Attribute("Quality").Value,
ReleaseDate = root.Attribute("ReleaseDate").Value,
ThumbPic = root.Attribute("ThumbPic").Value,
ICECatCategory = (int)root.Element("Category").Attribute("ID"),
SupplierID = (int)root.Element("Supplier").Attribute("ID")
};
var descriptions = from d in root.Elements("ProductDescription")
let l = d.Attribute("langid")
where l != null
let lang = (int)l
where DataImport.Languages.ContainsKey(lang)
select new
{
IceCatID = (int)d.Attribute("ID"),
LongDesc = d.Attribute("LongDesc").Value,
ManualPDFUrl = d.Attribute("ManualPDFURL").Value,
PDFSize = (int)d.Attribute("ManualPDFSize"),
ShortDesc = d.Attribute("ShortDesc").Value,
WarrantyInfo = d.Attribute("WarrantyInfo").Value,
ICECatLang = lang,
URL = d.Attribute("URL").Value
};
var barcodes = from b in root.Elements("EANCode")
let eanNode = b.Attribute("EAN")
where eanNode != null
select eanNode.Value.Trim();
var images = from i in root.Element("ProductGallery").Elements("ProductPicture")
select i.Attribute("Pic").Value;
var specs = from f in root.Elements("ProductFeature")
where !f.IsEmpty
let signs = f.Try(e => e.Element("Feature").Element("Measure").Element("Signs"), null)
select new
{
CatFeatureID = (int)f.Attribute("CategoryFeature_ID"),
CatFeatureGroupID = (int)f.Attribute("CategoryFeatureGroup_ID"),
SpecID = (int)f.Element("Feature").Attribute("ID"),
ValID = (long)f.Attribute("ID"),
RawValue = f.Attribute("Value").Value,
PresentationValue = f.Attribute("Presentation_Value").Value,
Signs = signs.Try(s => from si in s.Elements("Sign")
let langID = (int)si.Attribute("langid")
where IceCat.DataImport.Languages.ContainsKey(langID)
select new
{
LangID = langID,
Value = si.Value
}, null)
};
var related = from r in root.Elements("ProductRelated")
where !r.IsEmpty
let prod = r.Element("Product")
where !prod.IsEmpty
let supplier = prod.Element("Supplier")
where supplier != null
select new
{
ProdID = prod.Attribute("Prod_id").Value,
SupplierID = (int)supplier.Attribute("ID"),
Preferred = (bool)r.Attribute("Preferred"),
Reversed = (bool)r.Attribute("Reversed")
};
#endregion Parse xml
using (var ctx = new ConcentratorDataContext())
{
using (var connection = new SqlConnection(Environments.Current.Connection))
{
connection.Open();
var com = connection.CreateCommand();
// Insert spec values in staging table
com.CommandText = "INSERT INTO " + ProductSpecTable + " ([ProdID], [SupplierID], [LangID], [Value], [ICAttributeID], [CatFeatureID], [CatFeatureGroupID], [ConcentratorProductID]) VALUES(@ProdID, @SupplierID, @LangID, @Value, @AttributeID, @CatFeatureID, @CatFeatureGroupID, @ConProductID);";
foreach (var spec in specs)
{
foreach (var lang in DataImport.Languages)
{
com.Parameters.AddWithValue("ProdID", baseSpec.ManufacturerID);
com.Parameters.AddWithValue("SupplierID", baseSpec.SupplierID);
com.Parameters.AddWithValue("LangID", lang.Value);
com.Parameters.AddWithValue("Value", spec.RawValue.Cap(3000));
com.Parameters.AddWithValue("AttributeID", spec.SpecID);
com.Parameters.AddWithValue("ConProductID", p.ConcentratorID);
com.Parameters.AddWithValue("CatFeatureID", spec.CatFeatureID);
com.Parameters.AddWithValue("CatFeatureGroupID", spec.CatFeatureGroupID);
com.ExecuteNonQuery();
com.Parameters.Clear();
}
}
com = connection.CreateCommand();
// Insert descriptions in staging table
com.CommandText = "INSERT INTO " + ProductDescriptionTable + " ([LongDesc], [ShortDesc], [PDFUrl], [Warranty], [Quality], [LangID], [ConcentratorProductID], PDFSize, [URL]) VALUES(@LongDesc, @ShortDesc, @PDFUrl, @Warranty, @Quality, @LangID, @ConcentratorProductID, @PDFSize, @URL);";
foreach (var desc in descriptions)
{
com.Parameters.AddWithValue("LongDesc", desc.LongDesc.Cap(2500));
com.Parameters.AddWithValue("ShortDesc", desc.ShortDesc.Cap(1000));
com.Parameters.AddWithValue("PDFUrl", desc.ManualPDFUrl);
com.Parameters.AddWithValue("Warranty", desc.WarrantyInfo.Cap(2500));
com.Parameters.AddWithValue("LangID", desc.ICECatLang);
com.Parameters.AddWithValue("Quality", baseSpec.Quality);
com.Parameters.AddWithValue("ConcentratorProductID", p.ConcentratorID);
com.Parameters.AddWithValue("PDFSize", desc.PDFSize);
com.Parameters.AddWithValue("URL", desc.URL);
com.ExecuteNonQuery();
com.Parameters.Clear();
}
com = connection.CreateCommand();
// Insert barcodes in staging table
com.CommandText = "INSERT INTO " + BarcodeTable + " (Barcode, ProductID) VALUES(@Barcode, @ProductID)";
foreach (var barcode in barcodes)
{
com.Parameters.AddWithValue("Barcode", barcode);
com.Parameters.AddWithValue("ProductID", p.ConcentratorID);
com.ExecuteNonQuery();
com.Parameters.Clear();
}
// Insert related products in staging table
com.CommandText = "INSERT INTO " + RelatedTable + " (LeftProdID, RightICProdID, SupplierID, Reversed, Preferred) VALUES(@LeftProdID, @RightICProdID, @SupplierID, @Reversed, @Preferred)";
foreach (var rel in related)
{
com.Parameters.AddWithValue("LeftProdID", p.ConcentratorID);
com.Parameters.AddWithValue("RightICProdID", rel.ProdID);
com.Parameters.AddWithValue("SupplierID", rel.SupplierID);
com.Parameters.AddWithValue("Reversed", rel.Reversed);
com.Parameters.AddWithValue("Preferred", rel.Preferred);
com.ExecuteNonQuery();
com.Parameters.Clear();
}
// Insert images in staging table
com.CommandText = "INSERT INTO " + ImageTable + " (ProductID, Sequence, URL) VALUES(@ProductID, @Seq, @Url)";
var imgs = images.ToList();
for (int i = 0; i < imgs.Count; i++)
{
var img = imgs[i];
com.Parameters.AddWithValue("ProductID", p.ConcentratorID);
com.Parameters.AddWithValue("Seq", i + 1);
com.Parameters.AddWithValue("Url", img);
com.ExecuteNonQuery();
com.Parameters.Clear();
}
}
}
Interlocked.Increment(ref processed);
if (processed % (progressReportIdx <= 0 ? 1 : progressReportIdx) == 0)
{
Log.InfoFormat("{0} Files downloaded and imported", processed);
}
});
}
catch (AggregateException ex)
{
foreach (var inEx in ex.InnerExceptions)
{
Log.Fatal("Exception from ProductBulk loop: ", ex);
}
throw ex;
}
}
/// <summary>
/// Compute SVM output with support vector sharing.
/// </summary>
///
private int computeParallel(int classA, int classB, double[] input, out double output, Cache cache)
{
// Get the machine for this problem
KernelSupportVectorMachine machine = machines[classA - 1][classB];
// Get the vectors shared among all machines
int[] vectors = cache.Vectors[classA - 1][classB];
double[] values = cache.Products;
double sum = machine.Threshold;
if (machine.IsCompact)
{
// For linear machines, computation is simpler
for (int i = 0; i < machine.Weights.Length; i++)
{
sum += machine.Weights[i] * input[i];
}
}
else
{
#region Backward compatibility
for (int i = 0; i < vectors.Length; i++)
{
double value;
// Check if it is a shared vector
int j = vectors[i];
if (j >= 0)
{
// This is a shared vector. Check
// if it has already been computed
if (!Double.IsNaN(values[j]))
{
// Yes, it has. Retrieve the value from the cache
value = values[j];
}
else
{
// No, it has not. Compute and store the computed value in the cache
value = values[j] = machine.Kernel.Function(machine.SupportVectors[i], input);
Interlocked.Increment(ref cache.Evaluations);
}
}
else
{
// This vector is not shared by any other machine. No need to cache
value = machine.Kernel.Function(machine.SupportVectors[i], input);
Interlocked.Increment(ref cache.Evaluations);
}
sum += machine.Weights[i] * value;
}
#endregion
}
// Produce probabilities if required
if (machine.IsProbabilistic)
{
output = machine.Link.Inverse(sum);
return(output >= 0.5 ? +1 : -1);
}
else
{
output = sum;
return(output >= 0 ? +1 : -1);
}
}
public void Target <U>()
{
//dummy line to avoid warnings
Test.Eval(typeof(U) != null);
Interlocked.Increment(ref Test.Xcounter);
}
/// <summary>
/// Allocate a unique identifier for a resource.
/// </summary>
/// <remarks>
/// Internal resources are given even numbers while resources
/// allocated by extensions get odd numbers to minimize the communication
/// between internal and external resource managers.
/// </remarks>
/// <returns>The unique identifier of an internal resource (even number starting from 2).</returns>
static int RegisterInternalInstance()
{
// Even numbers are reserved for internal use (odd for externals)
return Interlocked.Increment(ref ResourceIdCounter) * 2;
}
public async Task update_concurrent_conflict_test()
{
var aggregateId = ObjectId.GenerateNewStringId();
var command = new CreateTestAggregateCommand
{
AggregateRootId = aggregateId,
Title = "Sample Note"
};
//执行创建聚合根的命令
var commandResult = await _commandService.ExecuteAsync(command, CommandReturnType.EventHandled);
Assert.NotNull(commandResult);
Assert.Equal(CommandStatus.Success, commandResult.Status);
var note = await _memoryCache.GetAsync <TestAggregate>(aggregateId);
Assert.NotNull(note);
Assert.Equal("Sample Note", note.Title);
Assert.Equal(1, ((IAggregateRoot)note).Version);
//往EventStore直接插入事件，用于模拟并发冲突的情况
var eventStream = new DomainEventStream(
ObjectId.GenerateNewStringId(),
aggregateId,
typeof(TestAggregate).FullName,
DateTime.Now,
new IDomainEvent[] { new TestAggregateTitleChanged("Changed Title")
{
AggregateRootId = aggregateId, Version = 2
} },
null);
var result = await _eventStore.BatchAppendAsync(new DomainEventStream[] { eventStream });
Assert.NotNull(result);
Assert.Equal(aggregateId, result.SuccessAggregateRootIdList[0]);
await _publishedVersionStore.UpdatePublishedVersionAsync("DefaultEventProcessor", typeof(TestAggregate).FullName, aggregateId, 2);
var commandList = new List <ICommand>();
for (var i = 0; i < 50; i++)
{
commandList.Add(new ChangeTestAggregateTitleCommand
{
AggregateRootId = aggregateId,
Title = "Changed Note2"
});
}
var waitHandle = new ManualResetEvent(false);
var count = 0L;
foreach (var updateCommand in commandList)
{
await _commandService.ExecuteAsync(updateCommand).ContinueWith(t =>
{
Assert.NotNull(t.Result);
var currentCommandResult = t.Result;
Assert.NotNull(currentCommandResult);
Assert.Equal(CommandStatus.Success, currentCommandResult.Status);
var totalCount = Interlocked.Increment(ref count);
if (totalCount == commandList.Count)
{
waitHandle.Set();
}
});
}
waitHandle.WaitOne();
note = await _memoryCache.GetAsync <TestAggregate>(aggregateId);
Assert.NotNull(note);
Assert.Equal(2 + commandList.Count, ((IAggregateRoot)note).Version);
Assert.Equal("Changed Note2", note.Title);
}
internal void TallyError(Exception e)
{
Interlocked.Increment(ref _errorCount);
}
public override Int32 Create(
String FileName,
UInt32 CreateOptions,
UInt32 GrantedAccess,
UInt32 FileAttributes,
Byte[] SecurityDescriptor,
UInt64 AllocationSize,
out Object FileNode0,
out Object FileDesc,
out FileInfo FileInfo,
out String NormalizedName)
{
FileNode0 = default(Object);
FileDesc = default(Object);
FileInfo = default(FileInfo);
NormalizedName = default(String);
FileNode FileNode;
FileNode ParentNode;
Int32 Result = STATUS_SUCCESS;
FileNode = FileNodeMap.Get(FileName);
if (null != FileNode)
{
return(STATUS_OBJECT_NAME_COLLISION);
}
ParentNode = FileNodeMap.GetParent(FileName, ref Result);
if (null == ParentNode)
{
return(Result);
}
if (0 != (CreateOptions & FILE_DIRECTORY_FILE))
{
AllocationSize = 0;
}
if (FileNodeMap.Count() >= MaxFileNodes)
{
return(STATUS_CANNOT_MAKE);
}
if (AllocationSize > MaxFileSize)
{
return(STATUS_DISK_FULL);
}
if ("\\" != ParentNode.FileName)
{
/* normalize name */
FileName = ParentNode.FileName + "\\" + Path.GetFileName(FileName);
}
FileNode = new FileNode(FileName);
FileNode.MainFileNode = FileNodeMap.GetMain(FileName);
FileNode.FileInfo.FileAttributes = 0 != (FileAttributes & (UInt32)System.IO.FileAttributes.Directory) ?
FileAttributes : FileAttributes | (UInt32)System.IO.FileAttributes.Archive;
FileNode.FileSecurity = SecurityDescriptor;
if (0 != AllocationSize)
{
Result = SetFileSizeInternal(FileNode, AllocationSize, true);
if (0 > Result)
{
return(Result);
}
}
FileNodeMap.Insert(FileNode);
Interlocked.Increment(ref FileNode.OpenCount);
FileNode0 = FileNode;
FileInfo = FileNode.GetFileInfo();
NormalizedName = FileNode.FileName;
return(STATUS_SUCCESS);
}
public async Task ExplicitPublishMode()
{
using (var mx = Create(channelPrefix: "foo:"))
{
var pub = mx.GetSubscriber();
int a = 0, b = 0, c = 0, d = 0;
pub.Subscribe(new RedisChannel("*bcd", RedisChannel.PatternMode.Literal), (x, y) => Interlocked.Increment(ref a));
pub.Subscribe(new RedisChannel("a*cd", RedisChannel.PatternMode.Pattern), (x, y) => Interlocked.Increment(ref b));
pub.Subscribe(new RedisChannel("ab*d", RedisChannel.PatternMode.Auto), (x, y) => Interlocked.Increment(ref c));
pub.Subscribe("abc*", (x, y) => Interlocked.Increment(ref d));
await Task.Delay(1000).ForAwait();
pub.Publish("abcd", "efg");
await UntilCondition(TimeSpan.FromSeconds(10),
() => Thread.VolatileRead(ref b) == 1 &&
Thread.VolatileRead(ref c) == 1 &&
Thread.VolatileRead(ref d) == 1);
Assert.Equal(0, Thread.VolatileRead(ref a));
Assert.Equal(1, Thread.VolatileRead(ref b));
Assert.Equal(1, Thread.VolatileRead(ref c));
Assert.Equal(1, Thread.VolatileRead(ref d));
pub.Publish("*bcd", "efg");
await UntilCondition(TimeSpan.FromSeconds(10), () => Thread.VolatileRead(ref a) == 1);
Assert.Equal(1, Thread.VolatileRead(ref a));
}
}
public async Task TestBasicPubSub(string channelPrefix, bool wildCard, string breaker)
{
using (var muxer = Create(channelPrefix: channelPrefix))
{
var pub = GetAnyMaster(muxer);
var sub = muxer.GetSubscriber();
await PingAsync(muxer, pub, sub).ForAwait();
HashSet <string> received = new HashSet <string>();
int secondHandler = 0;
string subChannel = (wildCard ? "a*c" : "abc") + breaker;
string pubChannel = "abc" + breaker;
Action <RedisChannel, RedisValue> handler1 = (channel, payload) =>
{
lock (received)
{
if (channel == pubChannel)
{
received.Add(payload);
}
else
{
Log(channel);
}
}
}
, handler2 = (_, __) => Interlocked.Increment(ref secondHandler);
sub.Subscribe(subChannel, handler1);
sub.Subscribe(subChannel, handler2);
lock (received)
{
Assert.Empty(received);
}
Assert.Equal(0, Thread.VolatileRead(ref secondHandler));
var count = sub.Publish(pubChannel, "def");
await PingAsync(muxer, pub, sub, 3).ForAwait();
lock (received)
{
Assert.Single(received);
}
Assert.Equal(1, Thread.VolatileRead(ref secondHandler));
// unsubscribe from first; should still see second
sub.Unsubscribe(subChannel, handler1);
count = sub.Publish(pubChannel, "ghi");
await PingAsync(muxer, pub, sub).ForAwait();
lock (received)
{
Assert.Single(received);
}
Assert.Equal(2, Thread.VolatileRead(ref secondHandler));
Assert.Equal(1, count);
// unsubscribe from second; should see nothing this time
sub.Unsubscribe(subChannel, handler2);
count = sub.Publish(pubChannel, "ghi");
await PingAsync(muxer, pub, sub).ForAwait();
lock (received)
{
Assert.Single(received);
}
Assert.Equal(2, Thread.VolatileRead(ref secondHandler));
Assert.Equal(0, count);
}
}
public static void ParalellGetPutRemove(int workers, int tables, int putCount, int durationSec)
{
var start = DateTime.UtcNow;
using (var cache = MakeCache())
{
var tasks = new Task[workers];
var totalGet = 0;
var totalPut = 0;
var totalRem = 0;
var getFound = 0;
var putInsert = 0;
var removed = 0;
for (var i = 0; i < workers; i++)
{
tasks[i] =
Task.Factory.StartNew(
() =>
{
while (true)
{
var now = DateTime.UtcNow;
if ((now - start).TotalSeconds >= durationSec)
{
return;
}
var t = NFX.ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, tables);
var tbl = cache.GetOrCreateTable <string>("tbl_" + t);
var get = NFX.ExternalRandomGenerator.Instance.NextScaledRandomInteger(putCount * 2, putCount * 4);
var put = NFX.ExternalRandomGenerator.Instance.NextScaledRandomInteger(putCount / 2, putCount);
var remove = NFX.ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, putCount);
Interlocked.Add(ref totalGet, get);
Interlocked.Add(ref totalPut, put);
Interlocked.Add(ref totalRem, remove);
for (var j = 0; j < get; j++)
{
if (null != tbl.Get(NFX.ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, 1000000).ToString()))
{
Interlocked.Increment(ref getFound);
}
}
for (var j = 0; j < put; j++)
{
if (PutResult.Inserted == tbl.Put(
NFX.ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, 1000000).ToString(),
NFX.Parsing.NaturalTextGenerator.Generate()
))
{
Interlocked.Increment(ref putInsert);
}
}
for (var j = 0; j < remove; j++)
{
if (tbl.Remove(
NFX.ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, 1000000).ToString()
))
{
Interlocked.Increment(ref removed);
}
}
}
}
, TaskCreationOptions.LongRunning);
}
Task.WaitAll(tasks);
Console.WriteLine("{0} workers, {1} tables, {2} put, {3} sec duration", workers, tables, putCount, durationSec);
Console.WriteLine("-----------------------------------------------------------");
Console.WriteLine("Total Gets: {0:n0}, found {1:n0}", totalGet, getFound);
Console.WriteLine("Total Puts: {0:n0}, inserted {1:n0}", totalPut, putInsert);
Console.WriteLine("Total Removes: {0:n0}, removed {1:n0}", totalRem, removed);
Console.WriteLine("Pile utilized bytes: {0:n0}", cache.Pile.UtilizedBytes);
Console.WriteLine("Pile object count: {0:n0}", cache.Pile.ObjectCount);
cache.PurgeAll();
Assert.AreEqual(0, cache.Count);
Assert.AreEqual(0, cache.Pile.UtilizedBytes);
Assert.AreEqual(0, cache.Pile.ObjectCount);
Console.WriteLine();
}
}
/// <summary>
/// An internal constructor used by the factory methods on task and its descendent(s).
/// This variant does not capture the ExecutionContext; it is up to the caller to do that.
/// </summary>
/// <param name="action">An action to execute.</param>
/// <param name="state">Optional state to pass to the action.</param>
/// <param name="parent">Parent of Task.</param>
/// <param name="cancellationToken">A CancellationToken for the task.</param>
/// <param name="scheduler">A task scheduler under which the task will run.</param>
/// <param name="creationOptions">Options to control its execution.</param>
/// <param name="internalOptions">Internal options to control its execution</param>
internal Task(Delegate action, object state, Task parent, CancellationToken cancellationToken, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler)
{
if (action == null)
{
#pragma warning disable IDE0016
throw new ArgumentNullException(nameof(action));
#pragma warning restore IDE0016
}
if (scheduler == null)
{
#pragma warning disable IDE0016
throw new ArgumentNullException(nameof(scheduler));
#pragma warning restore IDE0016
}
Contract.EndContractBlock();
// This is readonly, and so must be set in the constructor
// Keep a link to your parent if: (A) You are attached, or (B) you are self-replicating.
if
(
(creationOptions & TaskCreationOptions.AttachedToParent) != 0 ||
(internalOptions & InternalTaskOptions.SelfReplicating) != 0
)
{
_parent = parent;
}
Id = Interlocked.Increment(ref _lastId) - 1;
_status = (int)TaskStatus.Created;
if
(
_parent != null &&
(creationOptions & TaskCreationOptions.AttachedToParent) != 0 &&
(_parent.CreationOptions & TaskCreationOptions.DenyChildAttach) == 0
)
{
_parent.AddNewChild();
}
ExecutingTaskScheduler = scheduler;
Action = action;
State = state;
_waitHandle = new ManualResetEventSlim(false);
if ((creationOptions &
~(TaskCreationOptions.AttachedToParent |
TaskCreationOptions.LongRunning |
TaskCreationOptions.DenyChildAttach |
TaskCreationOptions.HideScheduler |
TaskCreationOptions.PreferFairness |
TaskCreationOptions.RunContinuationsAsynchronously)) != 0)
{
throw new ArgumentOutOfRangeException(nameof(creationOptions));
}
// Throw exception if the user specifies both LongRunning and SelfReplicating
if ((creationOptions & TaskCreationOptions.LongRunning) != 0 &&
(internalOptions & InternalTaskOptions.SelfReplicating) != 0)
{
throw new InvalidOperationException("An attempt was made to create a LongRunning SelfReplicating task.");
}
if ((internalOptions & InternalTaskOptions.ContinuationTask) != 0)
{
// For continuation tasks or TaskCompletionSource.Tasks, begin life in the
// WaitingForActivation state rather than the Created state.
_status = (int)TaskStatus.WaitingForActivation;
}
CreationOptions = creationOptions;
_internalOptions = internalOptions;
// if we have a non-null cancellationToken, allocate the contingent properties to save it
// we need to do this as the very last thing in the construction path, because the CT registration could modify m_stateFlags
if (cancellationToken.CanBeCanceled)
{
AssignCancellationToken(cancellationToken, null, null);
}
}
public static void FID_PutGetCorrectness(int cnt, int tbls)
{
var sw = new System.Diagnostics.Stopwatch();
var dicts = new ConcurrentDictionary <FID, string> [tbls];
for (var i = 0; i < dicts.Length; i++)
{
dicts[i] = new ConcurrentDictionary <FID, string>();
}
var notInserted = 0;
using (var cache = MakeCache())
{
sw.Start();
Parallel.For(0, cnt, (i) =>
{
var t = i % tbls;
var tbl = cache.GetOrCreateTable <FID>(t.ToString());
var key = FID.Generate();
var data = NFX.Parsing.NaturalTextGenerator.Generate(0);
var pr = tbl.Put(key, data);
dicts[t].TryAdd(key, data);
if (pr != PutResult.Inserted)
{
Interlocked.Increment(ref notInserted);
}
});
var elapsed = sw.ElapsedMilliseconds;
var inserted = cnt - notInserted;
Console.WriteLine("Population of {0:n0} in {1:n0} msec at {2:n0}ops/sec", cnt, elapsed, cnt / (elapsed / 1000d));
Console.WriteLine(" inserted: {0:n0} ({1:n0}%)", inserted, (int)(100 * (inserted / (double)cnt)));
Console.WriteLine(" not-inserted: {0:n0} ({1:n0}%)", notInserted, (int)(100 * (notInserted) / (double)cnt));
sw.Restart();
var found = 0;
var notfound = 0;
for (var i = 0; i < tbls; i++)
{
var tbl = cache.GetOrCreateTable <FID>(i.ToString());
var dict = dicts[i];
Parallel.ForEach(dict, (kvp) =>
{
var data = tbl.Get(kvp.Key);
if (data != null)
{
Assert.AreEqual(data, kvp.Value);
Interlocked.Increment(ref found);
}
else
{
Interlocked.Increment(ref notfound);
}
});
}
elapsed = sw.ElapsedMilliseconds;
var totalGot = found + notfound;
Console.WriteLine("Got of {0:n0} in {1:n0} msec at {2:n0}ops/sec", totalGot, elapsed, totalGot / (elapsed / 1000d));
Console.WriteLine(" found: {0:n0} ({1:n0}%)", found, (int)(100 * (found / (double)totalGot)));
Console.WriteLine(" not-found: {0:n0} ({1:n0}%)", notfound, (int)(100 * (notfound) / (double)totalGot));
Assert.IsTrue((found / (double)inserted) > 0.9d);
}//using cache
}
public ResourceResolverRequest(string path)
{
Id = Interlocked.Increment(ref _lastId);
Path = path;
_waitHandle = new ManualResetEvent(false);
}
/// <summary>
/// Generates a TraceId.
/// </summary>
/// <returns></returns>
public string TraceIdentifier()
{
return(_id ??= GenerateRequestId(Interlocked.Increment(ref _requestId)));
}
public async Task Test()
{
await using var pairTracker = await PoolManager.GetServerClient();
var server = pairTracker.Pair.Server;
var eventCount = 0;
await server.WaitAssertion(() =>
{
var ticker = IoCManager.Resolve <IEntitySystemManager>().GetEntitySystem <GameTicker>();
ticker.RestartRound();
var config = IoCManager.Resolve <IConfigurationManager>();
config.SetCVar(CCVars.GameLobbyEnabled, true);
var roundEndSystem = IoCManager.Resolve <IEntitySystemManager>().GetEntitySystem <RoundEndSystem>();
roundEndSystem.DefaultCooldownDuration = TimeSpan.FromMilliseconds(250);
roundEndSystem.DefaultCountdownDuration = TimeSpan.FromMilliseconds(500);
roundEndSystem.DefaultRestartRoundDuration = TimeSpan.FromMilliseconds(250);
});
await server.WaitAssertion(() =>
{
var bus = IoCManager.Resolve <IEntityManager>().EventBus;
bus.SubscribeEvent <RoundEndSystemChangedEvent>(EventSource.Local, this, _ => {
Interlocked.Increment(ref eventCount);
});
var roundEndSystem = IoCManager.Resolve <IEntitySystemManager>().GetEntitySystem <RoundEndSystem>();
// Press the shuttle call button
roundEndSystem.RequestRoundEnd();
Assert.That(roundEndSystem.ExpectedCountdownEnd, Is.Not.Null, "Shuttle was called, but countdown time was not set");
Assert.That(roundEndSystem.CanCall(), Is.False, "Started the shuttle, but didn't have to wait cooldown to press cancel button");
// Check that we can't recall the shuttle yet
roundEndSystem.CancelRoundEndCountdown();
Assert.That(roundEndSystem.ExpectedCountdownEnd, Is.Not.Null, "Shuttle was cancelled, even though the button was on cooldown");
});
await WaitForEvent(); // Wait for Cooldown
await server.WaitAssertion(() =>
{
var roundEndSystem = IoCManager.Resolve <IEntitySystemManager>().GetEntitySystem <RoundEndSystem>();
Assert.That(roundEndSystem.CanCall(), Is.True, "We waited a while, but the cooldown is not expired");
Assert.That(roundEndSystem.ExpectedCountdownEnd, Is.Not.Null, "We were waiting for the cooldown, but the round also ended");
// Recall the shuttle, which should trigger the cooldown again
roundEndSystem.CancelRoundEndCountdown();
Assert.That(roundEndSystem.ExpectedCountdownEnd, Is.Null, "Recalled shuttle, but countdown has not ended");
Assert.That(roundEndSystem.CanCall(), Is.False, "Recalled shuttle, but cooldown has not been enabled");
});
await WaitForEvent(); // Wait for Cooldown
await server.WaitAssertion(() =>
{
var roundEndSystem = IoCManager.Resolve <IEntitySystemManager>().GetEntitySystem <RoundEndSystem>();
Assert.That(roundEndSystem.CanCall(), Is.True, "We waited a while, but the cooldown is not expired");
// Press the shuttle call button
roundEndSystem.RequestRoundEnd();
});
await WaitForEvent(); // Wait for Cooldown
await server.WaitAssertion(() =>
{
var roundEndSystem = IoCManager.Resolve <IEntitySystemManager>().GetEntitySystem <RoundEndSystem>();
Assert.That(roundEndSystem.CanCall(), Is.True, "We waited a while, but the cooldown is not expired");
Assert.That(roundEndSystem.ExpectedCountdownEnd, Is.Not.Null, "The countdown ended, but we just wanted the cooldown to end");
});
await WaitForEvent(); // Wait for countdown to end round
await CheckRunLevel(GameRunLevel.PostRound);
await WaitForEvent(); // Wait for Restart
await CheckRunLevel(GameRunLevel.PreRoundLobby);
Task CheckRunLevel(GameRunLevel level)
{
return(server.WaitAssertion(() =>
{
var ticker = IoCManager.Resolve <IEntitySystemManager>().GetEntitySystem <GameTicker>();
Assert.That(ticker.RunLevel, Is.EqualTo(level));
}));
}
async Task WaitForEvent()
{
var timeout = Task.Delay(TimeSpan.FromSeconds(10));
var currentCount = Thread.VolatileRead(ref eventCount);
while (currentCount == Thread.VolatileRead(ref eventCount) && !timeout.IsCompleted)
{
await PoolManager.RunTicksSync(pairTracker.Pair, 5);
}
if (timeout.IsCompleted)
{
throw new TimeoutException("Event took too long to trigger");
}
}
await pairTracker.CleanReturnAsync();
}
public async Task TestPartialSubscriberGetMessage()
{
using (var muxerA = Create())
using (var muxerB = Create())
using (var conn = Create())
{
int gotA = 0, gotB = 0;
var listenA = muxerA.GetSubscriber();
var listenB = muxerB.GetSubscriber();
var pub = conn.GetSubscriber();
var prefix = Me();
var tA = listenA.SubscribeAsync(prefix + "channel", (s, msg) => { if (s == prefix + "channel" && msg == "message")
{
Interlocked.Increment(ref gotA);
}
});
var tB = listenB.SubscribeAsync(prefix + "chann*", (s, msg) => { if (s == prefix + "channel" && msg == "message")
{
Interlocked.Increment(ref gotB);
}
});
await Task.WhenAll(tA, tB).ForAwait();
Assert.Equal(2, pub.Publish(prefix + "channel", "message"));
await AllowReasonableTimeToPublishAndProcess().ForAwait();
Assert.Equal(1, Interlocked.CompareExchange(ref gotA, 0, 0));
Assert.Equal(1, Interlocked.CompareExchange(ref gotB, 0, 0));
// and unsubscibe...
tB = listenB.UnsubscribeAsync(prefix + "chann*", null);
await tB;
Assert.Equal(1, pub.Publish(prefix + "channel", "message"));
await AllowReasonableTimeToPublishAndProcess().ForAwait();
Assert.Equal(2, Interlocked.CompareExchange(ref gotA, 0, 0));
Assert.Equal(1, Interlocked.CompareExchange(ref gotB, 0, 0));
}
}
public void SetNewSessionId()
{
SessionId2 = (uint)Interlocked.Increment(ref _sid);
}
internal string GenerateMessageId()
{
var id = Interlocked.Increment(ref lastMessageId);
return(DebugName + id);
}
private int NextId()
{
int id = Interlocked.Increment(ref _nextId);
return(id);
}
public void BufferingTargetWrapperSyncWithTimedFlushTest()
{
var myTarget = new MyTarget();
var targetWrapper = new BufferingTargetWrapper
{
WrappedTarget = myTarget,
BufferSize = 10,
FlushTimeout = 1000,
};
InitializeTargets(myTarget, targetWrapper);
const int totalEvents = 100;
var continuationHit = new bool[totalEvents];
var lastException = new Exception[totalEvents];
var continuationThread = new Thread[totalEvents];
var hitCount = 0;
CreateContinuationFunc createAsyncContinuation =
eventNumber =>
ex =>
{
lastException[eventNumber] = ex;
continuationThread[eventNumber] = Thread.CurrentThread;
continuationHit[eventNumber] = true;
Interlocked.Increment(ref hitCount);
};
// write 9 events - they will all be buffered and no final continuation will be reached
var eventCounter = 0;
for (var i = 0; i < 9; ++i)
{
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
}
Assert.AreEqual(0, hitCount);
Assert.AreEqual(0, myTarget.WriteCount);
// sleep 2 seconds, this will trigger the timer and flush all events
Thread.Sleep(4000);
Assert.AreEqual(9, hitCount);
Assert.AreEqual(1, myTarget.BufferedWriteCount);
Assert.AreEqual(9, myTarget.BufferedTotalEvents);
Assert.AreEqual(9, myTarget.WriteCount);
for (var i = 0; i < hitCount; ++i)
{
Assert.AreNotSame(Thread.CurrentThread, continuationThread[i]);
Assert.IsNull(lastException[i]);
}
// write 11 more events, 10 will be hit immediately because the buffer will fill up
// 1 will be pending
for (var i = 0; i < 11; ++i)
{
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
}
Assert.AreEqual(19, hitCount);
Assert.AreEqual(2, myTarget.BufferedWriteCount);
Assert.AreEqual(19, myTarget.BufferedTotalEvents);
Assert.AreEqual(19, myTarget.WriteCount);
// sleep 2 seonds and the last remaining one will be flushed
Thread.Sleep(2000);
Assert.AreEqual(20, hitCount);
Assert.AreEqual(3, myTarget.BufferedWriteCount);
Assert.AreEqual(20, myTarget.BufferedTotalEvents);
Assert.AreEqual(20, myTarget.WriteCount);
}
private static async void RunOneSection(SectionAddress addr, string logMsg, bool hideProgress)
{
if (Engine.WorkingLock == 0)
{
Interlocked.Increment(ref Engine.WorkingLock);
Logger logger = null;
SettingViewModel setting = null;
MainViewModel mainModel = null;
Application.Current.Dispatcher.Invoke(() =>
{
MainWindow w = Application.Current.MainWindow as MainWindow;
logger = w.Logger;
mainModel = w.Model;
setting = w.Setting;
// Populate BuildTree
if (!hideProgress)
{
w.Model.BuildTree.Children.Clear();
w.PopulateOneTreeView(addr.Plugin, w.Model.BuildTree, w.Model.BuildTree);
w.CurBuildTree = null;
}
});
mainModel.WorkInProgress = true;
EngineState s = new EngineState(addr.Plugin.Project, logger, mainModel, addr.Plugin, addr.Section.SectionName);
s.SetOption(setting);
s.DisableLogger = setting.Log_DisableInInterface;
Engine.WorkingEngine = new Engine(s);
// Build Start, Switch to Build View
if (!hideProgress)
{
mainModel.SwitchNormalBuildInterface = false;
}
// Run
long buildId = await Engine.WorkingEngine.Run(logMsg);
// Build Ended, Switch to Normal View
if (!hideProgress)
{
mainModel.SwitchNormalBuildInterface = true;
}
// Turn off ProgressRing
mainModel.WorkInProgress = false;
Engine.WorkingEngine = null;
Interlocked.Decrement(ref Engine.WorkingLock);
if (!hideProgress)
{
Application.Current.Dispatcher.Invoke(() =>
{
MainWindow w = Application.Current.MainWindow as MainWindow;
w.DrawPlugin(w.CurMainTree.Plugin);
});
}
}
}
public void BufferingTargetWrapperSyncTest1()
{
var myTarget = new MyTarget();
var targetWrapper = new BufferingTargetWrapper
{
WrappedTarget = myTarget,
BufferSize = 10,
};
InitializeTargets(myTarget, targetWrapper);
const int totalEvents = 100;
var continuationHit = new bool[totalEvents];
var lastException = new Exception[totalEvents];
var continuationThread = new Thread[totalEvents];
var hitCount = 0;
CreateContinuationFunc createAsyncContinuation =
eventNumber =>
ex =>
{
lastException[eventNumber] = ex;
continuationThread[eventNumber] = Thread.CurrentThread;
continuationHit[eventNumber] = true;
Interlocked.Increment(ref hitCount);
};
// write 9 events - they will all be buffered and no final continuation will be reached
var eventCounter = 0;
for (var i = 0; i < 9; ++i)
{
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
}
Assert.AreEqual(0, hitCount);
Assert.AreEqual(0, myTarget.WriteCount);
// write one more event - everything will be flushed
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
Assert.AreEqual(10, hitCount);
Assert.AreEqual(1, myTarget.BufferedWriteCount);
Assert.AreEqual(10, myTarget.BufferedTotalEvents);
Assert.AreEqual(10, myTarget.WriteCount);
for (var i = 0; i < hitCount; ++i)
{
Assert.AreSame(Thread.CurrentThread, continuationThread[i]);
Assert.IsNull(lastException[i]);
}
// write 9 more events - they will all be buffered and no final continuation will be reached
for (var i = 0; i < 9; ++i)
{
targetWrapper.WriteAsyncLogEvent(new LogEventInfo().WithContinuation(createAsyncContinuation(eventCounter++)));
}
// no change
Assert.AreEqual(10, hitCount);
Assert.AreEqual(1, myTarget.BufferedWriteCount);
Assert.AreEqual(10, myTarget.BufferedTotalEvents);
Assert.AreEqual(10, myTarget.WriteCount);
Exception flushException = null;
var flushHit = new ManualResetEvent(false);
targetWrapper.Flush(
ex =>
{
flushException = ex;
flushHit.Set();
});
Thread.Sleep(1000);
flushHit.WaitOne();
Assert.IsNull(flushException);
// make sure remaining events were written
Assert.AreEqual(19, hitCount);
Assert.AreEqual(2, myTarget.BufferedWriteCount);
Assert.AreEqual(19, myTarget.BufferedTotalEvents);
Assert.AreEqual(19, myTarget.WriteCount);
Assert.AreEqual(1, myTarget.FlushCount);
// flushes happen on the same thread
for (var i = 10; i < hitCount; ++i)
{
Assert.IsNotNull(continuationThread[i]);
Assert.AreSame(Thread.CurrentThread, continuationThread[i], "Invalid thread #" + i);
Assert.IsNull(lastException[i]);
}
// flush again - should just invoke Flush() on the wrapped target
flushHit.Reset();
targetWrapper.Flush(
ex =>
{
flushException = ex;
flushHit.Set();
});
flushHit.WaitOne();
Assert.AreEqual(19, hitCount);
Assert.AreEqual(2, myTarget.BufferedWriteCount);
Assert.AreEqual(19, myTarget.BufferedTotalEvents);
Assert.AreEqual(19, myTarget.WriteCount);
Assert.AreEqual(2, myTarget.FlushCount);
targetWrapper.Close();
myTarget.Close();
}
private void Drain()
{
if (Interlocked.Increment(ref _trampoline) != 1)
{
return;
}
for (; ;)
{
if (Volatile.Read(ref _isDisposed))
{
while (_stack.Count != 0)
{
var enumerator = _stack.Pop();
enumerator.Dispose();
}
Disposable.TryDispose(ref _currentSubscription);
}
else
{
if (_stack.Count != 0)
{
var currentEnumerator = _stack.Peek();
var currentObservable = default(IObservable <TSource>);
try
{
if (currentEnumerator.MoveNext())
{
currentObservable = currentEnumerator.Current;
}
}
catch (Exception ex)
{
currentEnumerator.Dispose();
ForwardOnError(ex);
Volatile.Write(ref _isDisposed, true);
continue;
}
IObservable <TSource> next;
try
{
next = Helpers.Unpack(currentObservable);
}
catch (Exception ex)
{
if (!Fail(ex))
{
Volatile.Write(ref _isDisposed, true);
}
continue;
}
if (next != null)
{
var nextSeq = Extract(next);
if (nextSeq != null)
{
if (TryGetEnumerator(nextSeq, out var nextEnumerator))
{
_stack.Push(nextEnumerator);
continue;
}
Volatile.Write(ref _isDisposed, true);
continue;
}
// we need an unique indicator for this as
// Subscribe could return a Disposable.Empty or
// a BooleanDisposable
var sad = ReadyToken.Ready;
// Swap in the Ready indicator so we know the sequence hasn't been disposed
if (Disposable.TrySetSingle(ref _currentSubscription, sad) == TrySetSingleResult.Success)
{
// subscribe to the source
var d = next.SubscribeSafe(this);
// Try to swap in the returned disposable in place of the Ready indicator
// Since this drain loop is the only one to use Ready, this should
// be unambiguous
var u = Interlocked.CompareExchange(ref _currentSubscription, d, sad);
// sequence disposed or completed synchronously
if (u != sad)
{
d.Dispose();
if (u == BooleanDisposable.True)
{
continue;
}
}
}
else
{
continue;
}
}
else
{
_stack.Pop();
currentEnumerator.Dispose();
continue;
}
}
else
{
Volatile.Write(ref _isDisposed, true);
Done();
}
}
if (Interlocked.Decrement(ref _trampoline) == 0)
{
break;
}
}
}
internal void ResetSentinel()
{
if (ResetSentinelFlag != 0)
{
return;
}
if (Interlocked.Increment(ref ResetSentinelFlag) != 1)
{
Interlocked.Decrement(ref ResetSentinelFlag);
return;
}
string masterhostEnd = _masterHost;
var allkeys = _ib.GetKeys().ToList();
for (int i = 0; i < _sentinels.Count; i++)
{
if (i > 0)
{
var first = _sentinels.First;
_sentinels.RemoveFirst();
_sentinels.AddLast(first.Value);
}
try
{
using (var sentinelcli = new RedisSentinelClient(_sentinels.First.Value))
{
var masterhost = sentinelcli.GetMasterAddrByName(_connectionString.Host);
var masterConnectionString = localTestHost(masterhost, RoleType.Master);
if (masterConnectionString == null)
{
continue;
}
masterhostEnd = masterhost;
if (_rw_splitting)
{
foreach (var slave in sentinelcli.Salves(_connectionString.Host))
{
ConnectionStringBuilder slaveConnectionString = localTestHost($"{slave.ip}:{slave.port}", RoleType.Slave);
if (slaveConnectionString == null)
{
continue;
}
}
}
foreach (var sentinel in sentinelcli.Sentinels(_connectionString.Host))
{
var remoteSentinelHost = $"{sentinel.ip}:{sentinel.port}";
if (_sentinels.Contains(remoteSentinelHost))
{
continue;
}
_sentinels.AddLast(remoteSentinelHost);
}
}
break;
}
catch { }
}
foreach (var spkey in allkeys)
{
_ib.TryRemove(spkey, true);
}
Interlocked.Exchange(ref _masterHost, masterhostEnd);
Interlocked.Decrement(ref ResetSentinelFlag);
ConnectionStringBuilder localTestHost(string host, RoleType role)
{
ConnectionStringBuilder connectionString = _connectionString.ToString();
connectionString.Host = host;
connectionString.MinPoolSize = 1;
connectionString.MaxPoolSize = 1;
using (var cli = new RedisClient(connectionString))
{
if (cli.Role().role != role)
{
return(null);
}
if (role == RoleType.Master)
{
//test set/get
}
}
connectionString.MinPoolSize = connectionString.MinPoolSize;
connectionString.MaxPoolSize = connectionString.MaxPoolSize;
_ib.TryRegister(host, () => new RedisClientPool(connectionString, null, TopOwner));
allkeys.Remove(host);
return(connectionString);
}
}
// static methods
public static int GetNextId()
{
return(Interlocked.Increment(ref __lastId));
}
//
// Frees a queue's slot.
//
private void FreeSlot() {
//
// If there is at least a thread blocked on the semaphore,
// use the freed slot to store its data item and release it.
//
WaitNode w;
if ((w = waitQueue.TryDequeueAndLock()) != null) {
AddWorker(w.channel);
w.parker.Unpark(w.waitKey);
return;
}
//
// The wait queue is empty, so increment the number of
// free slots
//
Interlocked.Increment(ref free);
//
// If the wait queue is still empty, return.
//
if (waitQueue.IsEmpty) {
return;
}
//
// Try to release one of the waiter thraeds.
//
do {
//
// Try to acquire a free slot on behalf of a waiter thread.
//
if (!TryReserveSlot()) {
return;
}
//
// We got a free queue slot, so try to release a thread
// waiting to add.
//
if ((w = waitQueue.TryDequeueAndLock()) != null) {
AddWorker(w.channel);
w.parker.Unpark(w.waitKey);
return;
}
//
// Release the free slot, and retry the release process if
// wait queue is not empty.
//
Interlocked.Increment(ref free);
} while (!waitQueue.IsEmpty);
}
private async Task handleClient <TWebSocketBehavior>(HttpListenerContext listenerContext, Func <TWebSocketBehavior> behaviorBuilder, CancellationToken token)
where TWebSocketBehavior : HttpListenerWebSocketServerBehavior
{
Guid connectionId;
WebSocketContext webSocketContext = null;
HttpListenerWebSocketServerBehavior behavior = null;
try
{
int statusCode = 500;
var statusDescription = "BadContext";
behavior = behaviorBuilder();
if (!behavior.OnValidateContext(webSocketContext, ref statusCode, ref statusDescription))
{
listenerContext.Response.StatusDescription = statusDescription;
listenerContext.Response.StatusCode = statusCode;
listenerContext.Response.Close();
_logError($"Failed to validate client context. Closing connection. Status: {statusCode}. Description: {statusDescription}.");
return;
}
connectionId = Guid.NewGuid();
webSocketContext = await listenerContext.AcceptWebSocketAsync(subProtocol : null);
bool clientAdded = _clients.TryAdd(connectionId, webSocketContext);
if (!clientAdded)
{
throw new ArgumentException($"Attempted to add a new web socket connection to server for connection id '{connectionId}' that already exists.");
}
Interlocked.Increment(ref _connectedClientCount);
_logInfo($"Connection id '{connectionId}' accepted; there are now {_connectedClientCount} total clients.");
var safeconnected = MakeSafe <Guid, WebSocketContext>(behavior.OnConnectionEstablished, "behavior.OnClientConnected");
safeconnected(connectionId, webSocketContext);
}
catch (Exception e)
{
_logError($"Client handler exception: {e}");
listenerContext.Response.StatusCode = 500;
listenerContext.Response.Close();
return;
}
try
{
using (webSocketContext.WebSocket)
{
var stringBehavior = MakeSafe <StringMessageReceivedEventArgs>(behavior.OnStringMessage, "behavior.OnStringMessage");
var binaryBehavior = MakeSafe <BinaryMessageReceivedEventArgs>(behavior.OnBinaryMessage, "behavior.OnBinaryMessage");
var closeBehavior = MakeSafe <WebSocketReceivedResultEventArgs>((r) => behavior.OnClose(new WebSocketClosedEventArgs(connectionId, r)), "behavior.OnClose");
await webSocketContext.WebSocket.ProcessIncomingMessages(_messageQueue, connectionId, stringBehavior, binaryBehavior, closeBehavior, _logInfo, token);
}
}
finally
{
Interlocked.Decrement(ref _connectedClientCount);
_logInfo($"Connection id '{connectionId}' disconnected; there are now {_connectedClientCount} total clients.");
webSocketContext?.WebSocket.CleanupSendMutex();
bool clientRemoved = _clients.TryRemove(connectionId, out webSocketContext);
if (!clientRemoved)
{
_logError($"Attempted to remove an existing web socket connection to server for connection id '{connectionId}' that no longer exists.");
}
_logInfo($"Completed HandleClient task for connection id '{connectionId}'.");
}
}
public override int Next(EntityEntry entry) => Interlocked.Increment(ref current);
public void SetupFactory(int botCount)
{
while (!factoryGame.LoggedIn)
{
Log("Waiting for BotFactory account to login");
Thread.Sleep(1000);
}
Log("Setting up bot factory with " + botCount + " bots");
Stopwatch watch = new Stopwatch();
watch.Start();
int createdBots = 0;
List <BotInfo> infos;
if (Settings.Default.RandomBots)
{
infos = botInfos.TakeRandom(botCount).ToList();
}
else
{
infos = botInfos.Take(botCount).ToList();
}
Parallel.ForEach <BotInfo>(infos, info =>
{
var bot = LoadBot(info);
lock (bots)
bots.Add(bot);
Interlocked.Increment(ref createdBots);
});
Parallel.For(createdBots, botCount, index =>
{
try
{
var bot = CreateBot();
lock (bots)
{
bots.Add(bot);
if (bots.Count % 100 == 0)
{
SaveBotInfos();
}
}
}
catch (Exception ex)
{
Log("Error creating new bot: " + ex.Message + "\n" + ex.StackTrace, LogLevel.Error);
}
});
watch.Stop();
Log("Finished setting up bot factory with " + botCount + " bots in " + watch.Elapsed);
SaveBotInfos();
for (; ;)
{
string line = Console.ReadLine();
if (line == null)
{
return;
}
string[] lineSplit = line.Split(' ');
switch (lineSplit[0])
{
case "quit":
case "exit":
case "close":
case "shutdown":
return;
case "info":
case "infos":
case "stats":
case "statistics":
DisplayStatistics(lineSplit.Length > 1 ? lineSplit[1] : "");
break;
}
}
}
public void Increment()
{
Interlocked.Increment(ref this.count);
}
