public Worker(ILogger <Worker> logger, IExchangeSettings exchangeSettings, IExchangeService exchangeService, IExchangePluginService exchangePluginService)
{
_logger = logger;
_exchangeSettings = exchangeSettings;
_exchangeService = exchangeService;
_exchangePluginService = exchangePluginService;
}
public Worker(ILogger <Worker> logger, IExchangeSettings exchangeSettings, IExchangeService exchangeService,
IExchangePluginService exchangePluginService)
{
_logger = logger;
_exchangeSettings = exchangeSettings;
_exchangeService = exchangeService;
_exchangePluginService = exchangePluginService;
logger.LogInformation("ExchangeHubService exchange plugin service loaded.");
}
public static async Task <IExchangeSettings> GetOrDefaultAsync(this IExchangeSettingsRepository exchangeSettingsRepository, string clientId)
{
var result = await exchangeSettingsRepository.GetAsync(clientId);
if (result != null)
{
return(result);
}
return(_defaultExchangeSettings ?? (_defaultExchangeSettings = ExchangeSettings.CreateDeafault()));
}
public ConnectionAdapter(HttpClient httpClient, IExchangeSettings exchangeSettings)
{
Authentication = new Authentication(
exchangeSettings.APIKey,
exchangeSettings.PassPhrase,
exchangeSettings.Secret,
exchangeSettings.EndpointUrl,
exchangeSettings.Uri);
HttpClient = httpClient;
ClientWebSocket = new ClientWebSocket();
_ioSemaphoreSlim = new SemaphoreSlim(1, 1);
_ioRequestSemaphoreSlim = new SemaphoreSlim(1, 1);
}
/// <inheritdoc />
public void RefreshSendCollection(IExchangeSettings settings)
{
LogEventManager.Logger.Info("Formation of packages started");
var rawData = TestFakeObject.GenerateFakeObjects(1000000);
var forQueueing = rawData.Select((it, i) => new { Index = i, Value = it })
.GroupBy(it => it.Index / settings.PackageSize)
.Select(it => it.Select(v => v.Value).ToList())
.ToList();
foreach (var item in forQueueing)
{
Queue.Enqueue(item);
}
}
/// <inheritdoc />
public void GetReceivePackage <T>(T dataSource, IExchangeSettings settings) where T : IReceiveDataSource
{
LogEventManager.Logger.Info("Formation of packages started");
var rawData = TestFakeObject.GenerateFakeObjects(1000000);
var forQueueing = rawData.Select((it, i) => new { Index = i, Value = it })
.GroupBy(it => it.Index / settings.PackageSize)
.Select(it => it.Select(v => v.Value).ToList())
.ToList();
foreach (var item in forQueueing)
{
Queue.Enqueue(item);
}
}
public String Generate(IExchangeSettings settings, String source)
{
if (settings is null)
{
throw new ArgumentNullException(nameof(settings));
}
if (source is null)
{
throw new ArgumentNullException(nameof(source));
}
StringBuilder builder = new StringBuilder(source);
foreach ((Char From, Char Into) in settings.CollectValues())
{
builder.Replace(From, Into);
}
return(builder.ToString());
}
/// <summary>
/// Sends the data
/// </summary>
/// <param name="worker">sender</param>
/// <param name="settings">sender settings</param>
private async void Send(ISendWorker worker, IExchangeSettings settings)
{
do
{
if (!settings.SilentCancel)
{
_cancellationToken.ThrowIfCancellationRequested();
}
worker.RefreshSendCollection(settings);
var lastDateUpdated = DateTime.Now;
if (!worker.IsSendQueueEmpty)
{
var tasks = new List <Task>();
for (var i = 0; i < settings.CountThreads; i++)
{
tasks.Add(SendAction(worker));
}
while (tasks.Count > 0)
{
var finishedTask = await Task.WhenAny(tasks);
tasks.Remove(finishedTask);
}
}
else
{
var timeOut = (int)(DateTime.Now - lastDateUpdated).TotalMilliseconds;
if (timeOut < settings.Timeout)
{
Thread.Sleep(settings.Timeout - timeOut);
}
}
} while (!settings.StopServiceAfterFirstRun);
}
/// <summary>
/// Receives the data
/// </summary>
/// <param name="worker">receiver</param>
/// <param name="source">data source from where we receive the data</param>
/// <param name="settings">settings</param>
private async void Receive(IPackageReceiveWorker worker, IReceiveDataSource source, IExchangeSettings settings)
{
do
{
if (!settings.SilentCancel)
{
_cancellationToken.ThrowIfCancellationRequested();
}
// Gets receive package. It should fill in the Buffer with packages
worker.GetReceivePackage(source, settings);
var lastDateUpdated = DateTime.Now;
if (!worker.IsBufferEmpty)
{
var tasks = new List <Task>();
for (var i = 0; i < settings.CountThreads; i++)
{
tasks.Add(ReceiveAction(worker, source));
}
while (tasks.Count > 0)
{
var finishedTask = await Task.WhenAny(tasks);
tasks.Remove(finishedTask);
}
}
else
{
var timeOut = (int)(DateTime.Now - lastDateUpdated).TotalMilliseconds;
if (timeOut < settings.Timeout)
{
Thread.Sleep(settings.Timeout - timeOut);
}
}
} while (!settings.StopServiceAfterFirstRun);
}
/// <summary>
/// Create an exchange service wrapper with the supplied settings (or null if defaults)
/// </summary>
/// <param name="exchangeSettings">null for default</param>
public ExchangeServiceContainer(IExchangeSettings exchangeSettings = null)
{
_exchangeSettings = exchangeSettings ?? new ExchangeSettings();
_allowSelfSignedCertificates = _exchangeSettings.AllowSelfSignedCertificates;
ServicePointManager.ServerCertificateValidationCallback = CertificateValidationCallBack;
}
/// <inheritdoc /> public abstract void RefreshSendCollection(IExchangeSettings settings);
public static string BaseAsset(this IExchangeSettings settings, bool isIosDevice)
{
return(isIosDevice ? settings.BaseAssetIos : settings.BaseAssetOther);
}
public virtual Task <bool> InitAsync(IExchangeSettings exchangeSettings)
{
throw new NotImplementedException();
}
