/// <summary>
/// Constructs an instance of the UdpConnectionManager class.
/// </summary>
/// <param name="iTransportContext">The transport context.</param>
public UdpConnectionManager(ITransportContext iTransportContext) : base(iTransportContext)
{
this.Local = new HostInformation("_gudp://" + iTransportContext.HostIdentifier, iTransportContext);
this._sendBuffer = new byte[(int)iTransportContext.IParameterProvider[GenuineParameter.UdpPacketSize]];
TimerProvider.Attach(this);
this._closeInvocationConnectionAfterInactivity = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.CloseInvocationConnectionAfterInactivity]);
}
/// <summary>
/// Constructs an instance of the SharedMemoryConnectionManager class.
/// </summary>
/// <param name="iTransportContext">The transport context.</param>
public SharedMemoryConnectionManager(ITransportContext iTransportContext) : base(iTransportContext)
{
this._sendTimeoutSpan = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.SMSendTimeout]);
this.Local = new HostInformation("_gshmem://" + iTransportContext.HostIdentifier, iTransportContext);
TimerProvider.Attach(this);
}
/// <summary>
/// Initialise the state.
/// </summary>
/// <param name="algorithmConfiguration">Configuration of the algorithm.</param>
/// <param name="container">Exchange service container.</param>
/// <returns>The state that the Run method yields.</returns>
public State <T> Activate(T algorithmConfiguration, ExchangeProvidersContainer container)
{
Logger = container.LoggerFactory.CreateLogger(GetType());
AlgorithmConfiguration = algorithmConfiguration;
_timerProvider = container.TimerProvider;
return(Run(container.TradingProvider, container.DataProvider));
}
public GzipProcessorFactory(IFileService fileService, ILogger logger, Settings settings,
TimerProvider timerProvider)
{
_fileService = fileService;
_logger = logger;
_settings = settings;
_timerProvider = timerProvider;
}
public TimerProviderTests(ITestOutputHelper outputHelper)
: base(outputHelper)
{
var container =
ExchangeFactoryService.BuildContainer <TemplateAlgorithm>(AlgorithmConfiguration);
_time = container.TimerProvider;
}
/// <summary>
/// Initiates the HTTP web request.
/// </summary>
/// <param name="httpWebRequest">The HttpWebRequest.</param>
/// <param name="asyncCallback">The callback.</param>
/// <param name="state">The additional parameter to the request.</param>
/// <param name="timeoutSpan">The timeout of the operation.</param>
public HttpWebRequestCop(HttpWebRequest httpWebRequest, AsyncCallback asyncCallback, object state, int timeoutSpan)
{
this._httpWebRequest = httpWebRequest;
this._asyncCallback = asyncCallback;
this._state = state;
this._timeoutExpiresAt = GenuineUtility.GetTimeout(timeoutSpan);
// asyncCallback
this._httpWebRequest.BeginGetResponse(new AsyncCallback(this.HandleWebResponse), state);
TimerProvider.Attach(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExchangeProvidersContainer"/> class.
/// </summary>
/// <param name="loggerFactory">Provides logging capabilities.</param>
/// <param name="dataProvider">Provides data gathering capabilities.</param>
/// <param name="timerProvider">Provides timer and scheduling capabilities.</param>
/// <param name="tradingProvider">Provides trading capabilities.</param>
/// <param name="algorithm">The algorithm to represent.</param>
public ExchangeProvidersContainer(
ILoggerFactory loggerFactory,
DataProvider dataProvider,
TimerProvider timerProvider,
TradingProvider tradingProvider,
Type algorithm)
{
LoggerFactory = loggerFactory;
DataProvider = dataProvider;
TimerProvider = timerProvider;
TradingProvider = tradingProvider;
Algorithm = algorithm;
}
public static int Main(string[] args)
{
var logger = new ConsoleLogger();
var timerProvider = new TimerProvider();
try
{
var stopwatch = timerProvider.CreateTimer("total");
stopwatch.Start();
var fileService = new FileService();
var inputParser = new InputParser(new FileService());
var inputParseResult = inputParser.Parse(args);
if (inputParseResult.IsFail)
{
logger.Write(inputParseResult.ErrorMessage !);
return(1);
}
var settings = GetSettings();
var gzipProcessorFactory = new GzipProcessorFactory(fileService, logger, settings, timerProvider);
logger.Write($"--- Start process with settings {settings} ---");
gzipProcessorFactory
.Create(inputParseResult.OperationType)
.Process(inputParseResult.InputFilePath !, inputParseResult.OutputFilePath !);
stopwatch.Stop();
logger.Write(timerProvider.GetReport());
logger.Write($"--- Finish process ---");
return(0);
}
catch (Exception e)
{
logger.Write($"Something went wrong: {e.Message}");
return(1);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BinanceTradingProvider"/> class.
/// </summary>
/// <param name="loggerFactory">Used to create output stream.</param>
/// <param name="communications">For communication with Binance.</param>
/// <param name="timer">Timer for subscribing to periodic updates.</param>
public BinanceTradingProvider(ILoggerFactory loggerFactory, BinanceCommunicationsService communications, TimerProvider timer)
: base(loggerFactory, timer)
{
_communications = communications;
_orderCache = new ConcurrentQueue <OrderUpdate>();
_transformMiddleWare = new Dictionary <long, Action <OrderUpdate> >();
// Push order updates from the websocket in a concurrent queue
communications.OrderUpdateDispenser.Subscribe(new ConfigurableObserver <OrderUpdate>(
() => { },
_ => { },
order =>
{
lock (_orderCache)
{
if (_transformMiddleWare.TryGetValue(order.OrderId, out var transform))
{
transform(order);
}
}
_orderCache.Enqueue(order);
}));
}
public ExecuteMarketOrderWrongTypeImplementation(ILoggerFactory loggerFactory, TimerProvider timer)
: base(loggerFactory, timer)
{
}
/// <summary>
/// Constructs an instance of the UniqueCallTracer class.
/// </summary>
private UniqueCallTracer()
{
TimerProvider.Attach(this);
}
public PlaceFullStoplossOrderHappyFlowImplementation(ILoggerFactory loggerFactory, TimerProvider timer)
: base(loggerFactory, timer)
{
}
public PlaceStoplossOrderNeverConfirmedImplementation(ILoggerFactory loggerFactory, TimerProvider timer)
: base(loggerFactory, timer)
{
}
public PlaceStoplossOrderUnroundedImplementation(ILoggerFactory loggerFactory, TimerProvider timer)
: base(loggerFactory, timer)
{
}
public PlaceStoplossOrderReportWrongTypeImplementation(ILoggerFactory loggerFactory, TimerProvider timer)
: base(loggerFactory, timer)
{
}
public DataProviderGetCandlesImplementation(ILoggerFactory loggerFactory, TimerProvider timerProvider)
: base(loggerFactory, timerProvider)
{
}
protected TradingProviderTestImplementation(ILoggerFactory loggerFactory, TimerProvider timer)
: base(loggerFactory, timer)
{
Cache = new List <OrderUpdate>();
}
public ContentWriter(ILogger logger, TimerProvider timerProvider)
{
_logger = logger;
_timer = timerProvider.CreateTimer("Write to I/O");
}
public CompressedContentReader(ILogger logger, TimerProvider timerProvider)
{
_logger = logger;
_timer = timerProvider.CreateTimer("Read From I/O");
}
public ExecuteMarketOrderNeverFilledImplementation(ILoggerFactory loggerFactory, TimerProvider timer)
: base(loggerFactory, timer)
{
}
public ContentReader(ILogger logger, int chunkSize, TimerProvider timerProvider)
{
_logger = logger;
_chunkSize = chunkSize;
_timer = timerProvider.CreateTimer("Read From I/O");
}
public ExecuteFullMarketOrderHappyFlowImplementation(ILoggerFactory loggerFactory, TimerProvider timer)
: base(loggerFactory, timer)
{
}
/// <summary>
/// Constructs an instance of the UriStorage class.
/// </summary>
public UriStorage()
{
TimerProvider.Attach(this);
}
/// <summary>
/// Constructs an instance of the KnownHosts class.
/// </summary>
public KnownHosts(ITransportContext iTransportContext)
{
this.ITransportContext = iTransportContext;
TimerProvider.Attach(this);
}
public ExecuteMarketOrderQuantityUnroundedImplementation(ILoggerFactory loggerFactory, TimerProvider timer)
: base(loggerFactory, timer)
{
}
public DataProviderTestImplementation(ILoggerFactory loggerFactory, TimerProvider timerProvider)
: base(loggerFactory, timerProvider)
{
}
public PlaceLimitOrderHappyFlowImplementation(ILoggerFactory loggerFactory, TimerProvider timer)
: base(loggerFactory, timer)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BinanceDataProvider"/> class.
/// </summary>
/// <param name="loggerFactory">Used to create output stream.</param>
/// <param name="communications">For communication with Binance.</param>
/// <param name="timerProvider">Ability to keep track of pivots.</param>
public BinanceDataProvider(ILoggerFactory loggerFactory, BinanceCommunicationsService communications, TimerProvider timerProvider)
: base(loggerFactory, timerProvider)
{
_communications = communications;
}
public PlaceLimitOrderWrongTypeImplementation(ILoggerFactory loggerFactory, TimerProvider timer)
: base(loggerFactory, timer)
{
}
