/// <summary>
///
/// </summary>
/// <param name="prefix"></param>
/// <param name="suffix"></param>
public BaseLogger(string prefix, string suffix)
{
// note: the following async thread queue must be constructed
// with a NULL logger, otherwise recursion occurs!
_asyncWriteQueue = new AsyncThreadQueue(null);
Format = "{dt:o},{severity},{host},{user},{prefix}{indent}{text}{suffix}{crlf}";
Prefix = prefix;
Suffix = suffix;
SplitLines = true;
try
{
AppDomain.CurrentDomain.UnhandledException +=
UnhandledDomainException;
}
catch (Exception excp)
{
Debug.WriteLine($"Unable to register AppDomain exception handler: {excp}");
}
// not used
//try
//{
// Application.ThreadException += new ThreadExceptionEventHandler(UnhandledThreadException);
//}
//catch (Exception excp)
//{
// Trace.WriteLine(String.Format("Unable to register Application exception handler: {0}", excp);
//}
}
protected override void OnServerStarted()
{
// create workflow
_workContext = new WorkContext(Logger, IntClient.Target, HostInstance, ServerInstance);
// create thread queues
_manageThreadQueue = new AsyncThreadQueue(Logger);
_workerEventQueue = new AsyncEventThrottle <object>(DequeueWorkerRequests);
}
protected override void OnServerStarted()
{
Logger.LogDebug("Instance/FarmSize: {0}/{1}", ServerInstance, ServerFarmSize);
// create workflow
_workContext = new WorkContext(Logger, IntClient.Target, HostInstance, ServerInstance);
// create event throttles
_workerEventQueue = new AsyncEventThrottle <object>(DequeueWorkerRequests);
_manageThreadQueue = new AsyncThreadQueue(Logger);
}
protected override void OnServerStarted()
{
// create workflow
_WorkContext = new WorkContext(Logger, this.Client);
_Workflow = new WFCalculatePortfolioValuation();
// create thread queues
_ManageThreadQueue = new AsyncThreadQueue(Logger);
_WorkerThreadQueue = new AsyncThreadQueue(Logger);
}
public StoreEngine(ILogger logger, ServerCfg serverCfg)
: base(PartNames.Store, logger)
{
_inboundCallQueue = new AsyncThreadQueue(Logger);
string connectionString = EnvHelper.FormatDbCfgStr(serverCfg.ModuleInfo.ConfigEnv, serverCfg.DbServer, serverCfg.DbPrefix);
Logger.LogDebug("Connection String: {0}", connectionString);
_state = new Guarded <StoreEngineState>(new StoreEngineState(serverCfg, connectionString));
}
public MarketDataRealtimeServer(
Reference <ILogger> loggerRef,
AsyncThreadQueue threadQueue,
ICoreClient client)
{
_loggerRef = loggerRef?.Clone() ?? throw new ArgumentNullException(nameof(loggerRef));
_threadQueue = threadQueue;
_client = client;
_subsDetailIndex = new Dictionary <Guid, SubscriptionDetail>();
}
public void TestQueueOrdering()
{
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
const int iterations = 500000; // yes 500,000 - takes about 1.0 seconds
int sendCount = 0;
int recvCount = 0;
int totalErrors = 0;
int threadCount = 0;
// dispatches a series of tasks
using (AsyncThreadQueue queue = new AsyncThreadQueue(loggerRef.Target))
{
AsyncQueueCallback <int> callback = delegate(int data)
{
int count = Interlocked.Increment(ref recvCount);
int threads = Interlocked.Increment(ref threadCount);
try
{
if (threads > 1)
{
// multithreading issue!
int errors = Interlocked.Increment(ref totalErrors);
if (errors <= 50)
{
loggerRef.Target.LogDebug("Thread count = {0}!", threads);
}
}
if (count != (data + 1))
{
int errors = Interlocked.Increment(ref totalErrors);
if (errors <= 50)
{
loggerRef.Target.LogDebug("Recv count = {0} but (data+1) = {1}", count, data + 1);
}
}
}
finally
{
Interlocked.Decrement(ref threadCount);
}
};
for (int i = 0; i < iterations; i++)
{
Interlocked.Increment(ref sendCount);
queue.Dispatch <int>(i, callback);
}
Assert.AreEqual <int>(iterations, sendCount);
long itemsRemaining = queue.WaitUntilEmpty(TimeSpan.FromSeconds(30));
Assert.AreEqual <long>(0, itemsRemaining);
Assert.AreEqual <int>(iterations, recvCount);
Assert.AreEqual <int>(0, totalErrors);
}
}
}
public void TestQueueConcurrency()
{
using (Reference <ILogger> loggerRef = Reference <ILogger> .Create(new TraceLogger(true)))
{
const int iterations = 10;
int sendCount = 0;
int totalErrors = 0;
int threadCount = 0;
int callbacksCommenced = 0;
int callbacksCompleted = 0;
// dispatches a series of tasks
using (AsyncThreadQueue queue = new AsyncThreadQueue(loggerRef.Target))
{
AsyncQueueCallback <int> callback = delegate(int data)
{
Interlocked.Increment(ref callbacksCommenced);
int threads = Interlocked.Increment(ref threadCount);
try
{
if (threads > 1)
{
// multithreading issue!
int errors = Interlocked.Increment(ref totalErrors);
if (errors <= 50)
{
loggerRef.Target.LogDebug("Thread count = {0}!", threads);
}
}
Thread.Sleep(TimeSpan.FromSeconds(0.5));
}
finally
{
Interlocked.Decrement(ref threadCount);
}
Interlocked.Increment(ref callbacksCompleted);
};
for (int i = 0; i < iterations; i++)
{
Interlocked.Increment(ref sendCount);
queue.Dispatch <int>(i, callback);
}
Assert.AreEqual <int>(iterations, sendCount);
long itemsRemaining = queue.WaitUntilEmpty(TimeSpan.FromSeconds(30));
Assert.AreEqual <long>(0, itemsRemaining);
Assert.AreEqual <int>(0, totalErrors);
Assert.AreEqual <int>(iterations, callbacksCommenced);
Assert.AreEqual <int>(iterations, callbacksCompleted);
}
}
}
public CoreCache(
ILogger logger,
ICoreClient client,
CacheChangeHandler dataChangeHandler,
SynchronizationContext syncContext)
{
_Logger = logger ?? throw new ArgumentNullException(nameof(logger));
Client = client ?? throw new ArgumentNullException(nameof(client));
SyncContext = syncContext;
Cache = new CoreItemCache(CacheId, Client);
UserThreadQueue = new AsyncThreadQueue(_Logger);
CacheItemPurgeTimer = new Timer(CacheItemPurgeTimeout, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));
if (dataChangeHandler != null)
{
OnDataChange += dataChangeHandler;
}
}
public MarketDataRealtimeClient(
Reference <ILogger> loggerRef,
AsyncThreadQueue clientThreadQueue,
ICoreClient client,
MDSProviderId dataProvider)
{
if (dataProvider == MDSProviderId.Undefined)
{
throw new ArgumentNullException(nameof(dataProvider));
}
ProviderId = dataProvider;
_loggerRef = loggerRef?.Clone() ?? throw new ArgumentNullException(nameof(loggerRef));
ClientThreadQueue = clientThreadQueue ?? new AsyncThreadQueue(_loggerRef.Target);
_mds = new MarketDataRealtimeServer(_loggerRef, clientThreadQueue, client);
var serverSettings = new NamedValueSet();
serverSettings.Set(MdpConfigName.ProviderId, (int)dataProvider);
_mds.ApplySettings(serverSettings);
_mds.Start();
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
public UnitTestStoreEngine(ILogger logger)
: base(PartNames.Store, logger)
{
_databaseQueue = new AsyncThreadQueue(Logger);
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="serverCfg"></param>
public CommsEngine(ILogger logger, ServerCfg serverCfg)
: base(PartNames.Comms, logger)
{
_serverCfg = serverCfg;
_mainCommsDispatcher = new AsyncThreadQueue(Logger);
}