public TestBase()
{
s_log = new StringBuilder();
_traceWrapper = new TraceWrapper();
_laserCondig = new LaserConfig();
Log.AppendLine("TestBase.TestBase()");
}
private async Task ProcessMessageAsync(ExecutionEvent message)
{
try
{
LastMessageTime = DateTime.UtcNow;
if (message.Header.MessageType != MessageType.Order)
{
return;
}
string walletId = await _settingsService.GetWalletIdAsync();
Order[] orders = message.Orders
.Where(o => o.WalletId == walletId)
.Where(o => o.Side != OrderSide.UnknownOrderSide)
.Where(o => o.Trades?.Count > 0)
.ToArray();
_log.InfoWithDetails("Trades received", new { Count = orders.Length });
if (orders.Any())
{
await TraceWrapper.TraceExecutionTimeAsync("Trades handling", () => ExecuteAsync(orders), _log);
_log.InfoWithDetails("Trades handled", orders);
}
}
catch (Exception exception)
{
_log.Error(exception, "An error occurred while processing trades", message);
throw;
}
}
public async Task RegisterAsync(IReadOnlyCollection <InternalTrade> internalTrades)
{
foreach (IGrouping <string, InternalTrade> group in internalTrades.GroupBy(o => o.AssetPairId))
{
DateTime lastTradeTime = group.Max(o => o.Time);
_internalLastInternalTradeTime.AddOrUpdate(group.Key, lastTradeTime,
(assetPairId, time) => lastTradeTime);
}
foreach (InternalTrade internalTrade in internalTrades)
{
await TraceWrapper.TraceExecutionTimeAsync("Inserting internal trade to the Azure storage",
() => _internalTradeRepository.InsertAsync(internalTrade), _log);
try
{
await TraceWrapper.TraceExecutionTimeAsync("Inserting internal trade to the Postgres storage",
() => _internalTradeRepositoryPostgres.InsertAsync(internalTrade), _log);
}
catch (Exception exception)
{
_log.ErrorWithDetails(exception,
"An error occurred while inserting internal trade to the Postgres DB", internalTrade);
}
}
}
private void AddToBuffer(TraceWrapper trace)
{
// le lock va empiler les appelants (mais c'est ce que l'on souhaite)
lock (_key)
{
if (_buffer.IsAddingCompleted || _buffer.TryAdd(trace))
{
return;
}
}
// l'appel temporisé n'est pas locké et gère donc le catch des ajout alors que la collection a été marquée comme terminée (CompleteAdding = true)
// ReSharper disable InconsistentlySynchronizedField => pas de lock pour ce cas car on ne souhaite pas bloquer le completeAdding aussi.
try
{
// sinon, on envoie un évènement pour signaler que l'ajout n'a pu être fait immédiatement et on retente avec un temps d'attente
RaiseSentTraces(ListenerHelpers.GetExceptionArray($"impossible d'ajouter immédiatement le message {trace.Message}: buffer plein : {_buffer.Count}"));
if (!_buffer.TryAdd(trace, _maxTimeoutForFullBuffer))
{
// Dans le cas où l'on ne peut pas insérer une trace à la fin du timeout, on lance une exception
throw new ArgumentException(
$@"ERROR: Max timeout for trace insertion in buffer reached ({_maxTimeoutForFullBuffer.TotalMilliseconds} ms)");
}
}
catch (InvalidOperationException e)
{
RaiseSentTraces(ListenerHelpers.GetExceptionArray($"InvalidOperationException (cas du buffer où CompleteAdding = true par exemple) dans les traces. {e}"));
}
// ReSharper restore InconsistentlySynchronizedField
}
public unsafe void Run(Func <uint> statusCallback)
{
Logger.Write($"Initializing fuzzing monitor");
var traceBuffer = new byte[Fuzzer.MapSize];
var locations = new ConcurrentDictionary <string, ConcurrentDictionary <int, int> >();
var getLocations = false;
fixed(byte *traceArea = traceBuffer)
using (var traceWrapper = new TraceWrapper(
traceArea,
(i, s) => {
if (getLocations)
{
var entry = locations.GetOrAdd(s, new ConcurrentDictionary <int, int>());
entry.GetOrAdd(i, 1);
}
}))
{
var ctrlSocket = new ControlSocket.Server(_controlPort);
Logger.Write($"Server listening");
while (ctrlSocket.WaitConnection())
{
Logger.Write($"Client connected");
try
{
while (ctrlSocket.ProcessStartTest(
(collectLocations) =>
{
getLocations = collectLocations;
locations.Clear();
traceWrapper.ResetPrevLocation();
traceBuffer.Initialize();
Logger.Write($"State was reset");
}))
{
Logger.Write($"Gathering state");
ctrlSocket.ProcessGetStatus((out byte[] c, out string l) =>
{
Logger.Write($"Reporting state");
c = new byte[traceBuffer.Length];
traceBuffer.CopyTo(c, 0);
l = string.Join(Environment.NewLine,
locations.Select((i) => $"{i.Key};{i.Value.Count}"));
return((int)statusCallback());
});
}
}
catch (Exception e)
{
Logger.Write($"Client communication error: {e.ToString()}");
ctrlSocket.Abort();
}
}
}
}
public static IList <object> CreateDriver(string configuration, TraceWrapper traceWrapper)
{
Driver driver = new Driver();
driver.Initialize(configuration, traceWrapper);
return(new List <object>()
{
driver as IDevice
});
}
public void Initialize(string configuration, TraceWrapper traceWrapper)
{
try
{
_laserConfig = LaserConfig.LoadFromXml <LaserConfig>(configuration);
_traceWrapper = traceWrapper;
_traceWrapper.WriteInformation("Laser initialization start.");
_traceWrapper.WriteVerbose(string.Format("Configuration: {0}", configuration));
_telegram = new TelegramsOperating(_laserConfig.IPAddress, 2111, traceWrapper);
_telegram.ConnectingSuccessed += new ConnectingSuccessedEventHandler(on_ConnectingSuccessed);
_telegram.ConnectingFailed += new ConnectingFailedEventHandler(on_ConnectingFailed);
_telegram.CommandReceivingFailed += new CommandReceivingFailedEventHandler(on_CommandReceivingFailed);
_telegram.CommandSendingFailed += new CommandSendingFailedEventHandler(on_CommandSendingFailed);
_telegram.Sopas_Error_CMD += new EventHandler <SopasErrorEventArgs>(on_SopasError);
_telegram.SetAccessMode_CMD += new EventHandler <SetAccessModeEventArgs>(on_SetAccessMode);
_telegram.LSPsetdatetime_CMD += new EventHandler <LSPsetdatetimeEventArgs>(on_LSPsetdatetime);
_telegram.Run_CMD += new EventHandler <RunEventArgs>(on_Run);
_telegram.LMDscandataE_CMD += new EventHandler <LMDscandataEEventArgs>(on_LMDscandataE);
_telegram.LMDscandata_CMD += new EventHandler <LMDscandataEventArgs>(on_LMDscandata);
_telegram.mSCreboot_CMD += new EventHandler <mSCrebootEventArgs>(on_mSCreboot);
_telegram.mDOSetOutput_CMD += new EventHandler <mDOSetOutputEventArgs>(on_mDOSetOutput);
_telegram.mLMPsetscancfg_CMD += new EventHandler <mLMPsetscancfgEventArgs>(on_mLMPsetscancfg);
_telegram.LMDscandatacfg_CMD += new EventHandler <LMDscandatacfgEventArgs>(on_LMDscandatacfg);
_telegram.DeviceIdent_CMD += new EventHandler <DeviceIdentEventArgs>(on_DeviceIdent);
Run_CMD = start_Run;
SetAccessMode_client_CMD = start_SetAccessMode_client;
SetAccessMode_maintenance_CMD = start_SetAccessMode_maintenance;
SetAccessMode_service_CMD = start_SetAccessMode_service;
LSPsetdatetime_CMD = start_LSPsetdatetime;
LMDscandata_E_CMD = start_LMDscandata_E;
mSCreboot_CMD = start_mSCreboot;
mDOSetOutput_CMD = start_mDOSetOutput;
mLMPsetscancfg_CMD = start_mLMPsetscancfg;
LMDscandatacfg_CMD = start_LMDscandatacfg;
DeviceIdent_CMD = start_DeviceIdent;
if ((_laserConfig.TriggerOutputChannelNumber > 0) && (_laserConfig.TriggerOutputChannelNumber < 7))
{
_maskDigitalOutputs = (byte)(1 << (_laserConfig.TriggerOutputChannelNumber - 1));
}
else
{
_maskDigitalOutputs = (byte)(1);
}
_isInitialized = true;
ErrorStateCounter.PrintPropertiesSettings();
_traceWrapper.WriteInformation("Laser initialization end.");
}
catch (Exception ex)
{
_traceWrapper.WriteError(new ApplicationException("Unhandled exception in LaserDriver.Initialize()", ex));
}
}
public async Task RegisterAsync(ExternalTrade externalTrade)
{
await TraceWrapper.TraceExecutionTimeAsync("Inserting external trade to the Azure storage",
() => _externalTradeRepository.InsertAsync(externalTrade), _log);
try
{
await TraceWrapper.TraceExecutionTimeAsync("Inserting external trade to the Postgres storage",
() => _externalTradeRepositoryPostgres.InsertAsync(externalTrade), _log);
}
catch (Exception exception)
{
_log.ErrorWithDetails(exception,
"An error occurred while inserting external trade to the Postgres DB", externalTrade);
}
}
public void TraceWarningPassesThrough()
{
var target = new System.IO.StringWriter();
TextWriterTraceListener listener = new TextWriterTraceListener();
listener.Writer = target;
string expected = "some message";
Trace.Listeners.Add(listener);
ITrace tested = new TraceWrapper();
tested.TraceWarning(expected);
Assert.IsTrue(target.ToString().Contains(expected));
}
public async Task <InstanceDiscoveryMetadataEntry> GetMetadataEntryAsync(
Uri authority,
RequestContext requestContext)
{
bool foundInCache = TryGetValue(authority.Host, out var entry);
TraceWrapper.WriteLine("GetMetadataEntryAsync - response from cache? " + foundInCache);
if (!foundInCache)
{
await DoInstanceDiscoveryAndCacheAsync(authority, requestContext).ConfigureAwait(false);
TryGetValue(authority.Host, out entry);
}
return(entry);
}
public async Task OpenAsync(IReadOnlyCollection <InternalTrade> internalTrades)
{
var startedAt = DateTime.UtcNow;
var positions = new List <Position>();
foreach (InternalTrade internalTrade in internalTrades)
{
Instrument instrument = await _instrumentService.FindAsync(internalTrade.AssetPairId);
if (instrument == null)
{
_log.WarningWithDetails("Can not open position. Unknown instrument.", internalTrade);
continue;
}
if (internalTrade.AssetPairId != instrument.AssetPairId)
{
CrossInstrument crossInstrument = instrument.CrossInstruments
.Single(o => o.AssetPairId == internalTrade.AssetPairId);
Quote quote = await _quoteService.GetAsync(crossInstrument.QuoteSource,
crossInstrument.ExternalAssetPairId);
if (quote != null)
{
decimal price = internalTrade.Type == TradeType.Sell
? Calculator.CalculateDirectSellPrice(internalTrade.Price, quote, crossInstrument.IsInverse)
: Calculator.CalculateDirectBuyPrice(internalTrade.Price, quote, crossInstrument.IsInverse);
var position = Position.Open(instrument.AssetPairId, price, internalTrade.Price,
internalTrade.Volume, quote, crossInstrument.AssetPairId, internalTrade.Type,
internalTrade.Id);
positions.Add(position);
}
else
{
_log.WarningWithDetails("Can not open position. No quote.", internalTrade);
}
}
else
{
var position = Position.Open(instrument.AssetPairId, internalTrade.Price, internalTrade.Volume,
internalTrade.Type, internalTrade.Id);
positions.Add(position);
}
}
await _tradeService.RegisterAsync(internalTrades);
foreach (Position position in positions)
{
await TraceWrapper.TraceExecutionTimeAsync("Inserting position to the Azure storage",
() => _positionRepository.InsertAsync(position), _log);
await TraceWrapper.TraceExecutionTimeAsync("Inserting open position to the Azure storage",
() => _openPositionRepository.InsertAsync(position), _log);
try
{
await TraceWrapper.TraceExecutionTimeAsync("Inserting position to the Postgres storage",
() => _positionRepositoryPostgres.InsertAsync(position), _log);
}
catch (Exception exception)
{
_log.ErrorWithDetails(exception, "An error occurred while inserting position to the Postgres DB",
position);
}
await TraceWrapper.TraceExecutionTimeAsync("Updating summary report in the Azure storage",
() => _summaryReportService.RegisterOpenPositionAsync(position,
internalTrades.Where(o => o.Id == position.TradeId).ToArray()), _log);
_log.InfoWithDetails("Position opened", position);
}
var finishedAt = DateTime.UtcNow;
_log.Info("PositionService.OpenAsync() completed.", new
{
PositionsCount = positions.Count,
TradeIds = positions.Select(x => x.TradeId).ToList(),
StartedAt = startedAt,
FinishedAt = finishedAt,
Latency = (finishedAt - startedAt).TotalMilliseconds
});
}
public void Initialize()
{
TraceWrapper _traceWrapper = new TraceWrapper();
string _laserConfig = getLaserConfig();
IList <object> _laserDevices = Brace.Shared.DeviceDrivers.LMS511Laser.DriverFactory.CreateDriver(_laserConfig, _traceWrapper);
laserDevice = ((IDevice)_laserDevices[0]);
EventHandler <StatusChangeEventArgs> _statusHandler = (sender, e) =>
{
if (StatusComponentEvent != null)
{
if ((e.OldValue != null) && (e.OldValue.DisplayValue != null))
{
StatusComponentEvent(e.NewValue.DisplayValue + " ; old Msg: " + e.OldValue.DisplayValue + " ; date: " + e.TimeReached.ToUniversalTime());
}
else
{
StatusComponentEvent(e.NewValue.DisplayValue + " ; date: " + e.TimeReached.ToUniversalTime());
}
}
};
EventHandler <RaisingEdgeEventArgs> _raisingedgeHandler = (sender, e) =>
{
StatusComponentEvent(e.Raising.ToString() + " ; date: " + e.TimeReached.ToUniversalTime());
// _traceWrapper.WriteInformation("Raising: " + e.Raising.ToString() + " ; date: " + e.TimeReached.ToUniversalTime());
};
EventHandler <FallingEdgeEventArgs> _fallingedgeHandler = (sender, e) =>
{
StatusComponentEvent(e.Falling.ToString() + " ; date: " + e.TimeReached.ToUniversalTime());
//_traceWrapper.WriteInformation("FallingEdge: " + e.Falling.ToString() + " ; date: " + e.TimeReached.ToUniversalTime());
};
EventHandler <ScanDataEventArgs> _scandataHandler = (sender, e) =>
{
// string sTemp = "";
//string msg = "\nScandata -----------------------------------------------";
string msg = "\nVersion Number: " + e.ScanData.versionNumber.ToString();
msg += "\nDevice Number: " + e.ScanData.deviceNumber.ToString();
msg += "\nSerial Number: " + e.ScanData.serialNumber.ToString();
msg += "\nDevice Status: " + e.ScanData.deviceStatus.ToString();
msg += "\nTelegram Counter: " + e.ScanData.telegramCounter.ToString();
msg += "\nScan Counter: " + e.ScanData.scanCounter.ToString();
msg += "\nTime Since Start Up: " + e.ScanData.timeSinceStartUp.ToString();
msg += "\nTime Of Transmission: " + e.ScanData.timeOfTransmission.ToString();
msg += "\nDig. Input : " + String.Format("{0:X}", e.ScanData.statusOfDigitalInputs);
msg += "\nDig. Output: " + String.Format("{0:X}", e.ScanData.statusOfDigitalOutputs);
msg += "\nScan frequency: " + ((e.ScanData.scanFrequency) / 100).ToString();
msg += "\nMeasurement frequency: " + e.ScanData.measurementFrequency.ToString();
msg += "\nAmount of Encoder: " + e.ScanData.amountOfEncoder.ToString();
if (e.ScanData.amountOfEncoder != 0)
{
msg += "\nEncoderPosition: " + e.ScanData.encoderPosition.ToString();
msg += "\nEncoder Speed: " + e.ScanData.encoderSpeed.ToString();
}
msg += "\nAmount of 16 Bit Channels: " + e.ScanData.amountOf16BitChannels.ToString();
if (e.ScanData.amountOf16BitChannels > 0)
{
msg += "\nContent: " + e.ScanData.content16;
msg += "\nScale factor: " + e.ScanData.scaleFactor16.ToString();
msg += "\nScale factor offset: " + e.ScanData.scaleFactorOffset16.ToString();
msg += "\nStart angle: " + (e.ScanData.startAngle16 / 10000).ToString();
msg += "\nSteps: " + (e.ScanData.steps16 / 10000).ToString();
msg += "\nAmount of Data: " + e.ScanData.amountOfData16.ToString();
msg += "\nData0 .. DataN: NOW do not show!";
/* for (int ii = 0; ii < e.ScanData.amountOfData16; ii++)
* {
* if (((ii % 8) != 0) || (ii == 0))
* {
* sTemp += e.ScanData.data16[ii].ToString("D5") + ", ";
* }
* else
* {
* if (ii == 8)
* msg += "\n";
* else
* msg += "\n" + sTemp + e.ScanData.data16[ii].ToString("D5");
* sTemp = "";
* }
* }*/
}
msg += "\nAmount of 8 Bit Channels: " + e.ScanData.amountOf8BitChannels.ToString();
if (e.ScanData.amountOf8BitChannels > 0)
{
msg += "\nContent: " + e.ScanData.content8;
msg += "\nScale factor: " + e.ScanData.scaleFactor8.ToString();
msg += "\nScale factor offset: " + e.ScanData.scaleFactorOffset8.ToString();
msg += "\nStart angle: " + (e.ScanData.startAngle8 / 10000).ToString();
msg += "\nSteps: " + (e.ScanData.steps8 / 10000).ToString();
msg += "\nAmount of Data: " + e.ScanData.amountOfData8.ToString();
msg += "\nData0 .. DataN: NOW do not show!";
/* for (int ii = 0; ii < e.ScanData.amountOfData8; ii++)
* {
* if (((ii % 8) != 0) || (ii == 0))
* {
* sTemp += e.ScanData.data16[ii].ToString("D5") + ", ";
* }
* else
* {
* if (ii == 8)
* msg += "\n";
* else
* msg += "\n" + sTemp + e.ScanData.data8[ii].ToString("D5");
* sTemp = "";
* }
* }*/
}
msg += "\nPosition: " + e.ScanData.position.ToString();
msg += "\nDevice Name enabled: " + e.ScanData.nameMode.ToString();
if (e.ScanData.nameMode != 0)
{
msg += "\nLength of Name: " + e.ScanData.nameLength.ToString();
msg += "\nDevice Name: " + e.ScanData.name;
}
msg += "\nComment: " + e.ScanData.comment.ToString();
msg += "\nTime enabled: " + e.ScanData.timeMode.ToString();
if (e.ScanData.timeMode != 0)
{
msg += "\nTime: " + e.ScanData.timeYear.ToString("D4") + ":" + e.ScanData.timeMonth.ToString("D2") + ":" + e.ScanData.timeDay.ToString("D2") + " " + e.ScanData.timeHour.ToString("D2") + ":" + e.ScanData.timeMinute.ToString("D2") + ":" + e.ScanData.timeSecund.ToString("D2") + ":" + e.ScanData.timeUsecund.ToString("D4");
}
ScanResultComponentEvent(msg + "\nDate time: " + e.TimeReached.ToUniversalTime());
};
laserDevice.StatusChange += _statusHandler;
((ITriggerProvider)laserDevice).RaisingEdge += _raisingedgeHandler;
((ITriggerProvider)laserDevice).FallingEdge += _fallingedgeHandler;
((IScanDataReceiver)laserDevice).ScanDataEvent += _scandataHandler;
}
public static IList <object> CreateDriverInstance(DeviceType deviceType, string configuration, TraceWrapper traceWrapper)
{
switch (deviceType)
{
case DeviceType.LMS511Laser:
return(Brace.Shared.DeviceDrivers.LMS511Laser.DriverFactory.CreateDriver(configuration, traceWrapper));
case DeviceType.FTPServer:
break;
default:
break;
}
throw new InvalidDeviceTypeException(String.Format("Device type {0} is invalid. There is no such registered device type.", deviceType), null);
}
