public QuoteBlotterService(IRequestTask requestTask, IDispatcherSchedulerProvider scheduler, IViewService viewService, Func<QuoteEditViewModel> quoteEditViewModelFactory)
{
_requestTask = requestTask;
_scheduler = scheduler;
_viewService = viewService;
_quoteEditViewModelFactory = quoteEditViewModelFactory;
}
public RequestExecutor(IRequestTask requestTask, string threadName)
{
_requestTask = requestTask;
_worker = new Thread(DoWork);
_worker.Name = threadName;
_worker.Start();
}
public FetchResult(string content, IRequestTask requestTask, HttpStatusCode httpStatus)
{
Content = content;
RequestTask = requestTask;
HttpStatus = httpStatus;
Uri = requestTask.Uri;
}
protected async Task <bool> TryFetchAsync(IRequestTask requestTask, CancellationToken cancellationToken)
{
try
{
if (cancellationToken.IsCancellationRequested)
{
_logger.LogInformation($"cancel fetch resource!");
return(true);
}
await _fetcherProvider.GetFetcher(requestTask.GetType()).FetchAsync(requestTask, OnReceivedContent, cancellationToken);
}
catch (TaskCanceledException ex)
{
_logger.LogInformation($"uri[{requestTask.Uri}] canceled!", ex);
}
catch (ObjectDisposedException ex)
{
_logger.LogInformation($"uri[{requestTask.Uri}] canceled!", ex);
}
catch (Exception ex)
{
_logger.LogError(ex, $"uri[{requestTask.Uri}] connect error!");
return(false);
}
return(true);
}
public async Task FetchAsync(IRequestTask requestTask, CancellationToken cancellationToken)
{
while (true)
{
var result = await TryFetchAsync(requestTask, cancellationToken);
if (result)
{
break;
}
requestTask.LastTryTime = Clock.Now;
requestTask.TryCount += 1;
requestTask.NextTryTime = requestTask.CalculateNextTryTime();
_logger.LogInformation($"try to connect to uri[{requestTask.Uri}] at {requestTask.NextTryTime.ToString("yyyyMMddHHmmss")}");
var now = Clock.Now;
var delayTimeSpan = new TimeSpan();
if (requestTask.NextTryTime > now)
{
delayTimeSpan = requestTask.NextTryTime - now;
}
await Task.Delay(delayTimeSpan, cancellationToken);
_logger.LogInformation($"try to connect to uri[{requestTask.Uri}]");
}
}
public QuoteBlotterService(IRequestTask requestTask, IDispatcherSchedulerProvider scheduler, IViewService viewService, Func <QuoteEditViewModel> quoteEditViewModelFactory)
{
_requestTask = requestTask;
_scheduler = scheduler;
_viewService = viewService;
_quoteEditViewModelFactory = quoteEditViewModelFactory;
}
public void AddToDownload(IRequestTask task)
{
if (task == null)
{
return;
}
Requests.Enqueue(task);
TryStartTask();
}
public RequestTaskException(IRequestTask requestTask, Exception innnerException)
: this(String.Format(
"RequestTask #{0} ({1}) finished unsuccessfully at step {2}.",
requestTask.Id,
requestTask.Request,
requestTask.StepCount
), innnerException, requestTask)
{
}
public ReportRunnerService(Func <DynamicReportDataViewModel> dynamicReportDataViewModelFactory,
IRequestTask requestTask, IBasicExportToExcel exportToExcel,
IDispatcherSchedulerProvider scheduler)
{
_dynamicReportDataViewModelFactory = dynamicReportDataViewModelFactory;
_requestTask = requestTask;
_exportToExcel = exportToExcel;
_scheduler = scheduler;
}
public async Task PushAsync(IRequestTask requestTask)
{
using (await _asyncLock.LockAsync())
{
if (!IsDuplicate(requestTask))
{
tasks.TryAdd(requestTask.Identity, requestTask);
}
}
}
public void StopRequest(IRequestTask task)
{
if (task == null)
{
return;
}
if (task.Coroutine != null && task.State == ResState.Loading)
{
CurrTrd--;
StopCoroutine(task.Coroutine);
}
}
public void AddTask(IRequestTask requestTask)
{
//Enqueue async tasks for processing
if (requestTask.IsAsyncRequest)
{
_requestTasks.Enqueue(requestTask);
}
else
{
//Create executor and execute syncronously
var executor = new RequestExecutor(requestTask, _threadName + _syncThreadIndex);
_syncThreadIndex++;
}
}
public void AddToRetry(IRequestTask task)
{
if (task == null)
{
return;
}
if (task.ErrorCount <= 0)
{
task.State = ResState.Completed;
return;
}
Retrys.Enqueue(task);
TryStartTask();
}
private IRequestTask GetNotEmptyTask(GQueue <IRequestTask> queue)
{
IRequestTask task = queue.Dequeue();
if (task == null)
{
return(null);
}
if (task.State == ResState.Cancel && queue.Count > 0)
{
return(GetNotEmptyTask(queue));
}
return(task);
}
public virtual async Task FetchAsync(IRequestTask requestTask, Action <IRequestTask, string> onReceivedContent, CancellationToken cancellationToken)
{
if (!TypeUtils.IsClassAssignableFrom(requestTask.GetType(), typeof(HttpRequestTask)))
{
throw new ArgumentException($"{nameof(requestTask)} is not http task");
}
var httpClient = _httpClientFactory.CreateClient("default");
var httpRequestTask = requestTask as HttpRequestTask;
HttpRequestMessage httpRequestMessage;
HttpResponseMessage httpResponse;
try
{
while (true && !cancellationToken.IsCancellationRequested)
{
httpRequestMessage = GenerateHttpRequestMessage(httpRequestTask);
httpResponse = await httpClient.SendAsync(httpRequestMessage, cancellationToken);
httpResponse.EnsureSuccessStatusCode();
var content = ReadContent(httpResponse, httpRequestTask);
onReceivedContent(requestTask, content);
if (!httpRequestTask.IsCycleRequest)
{
httpRequestTask.Status = RequestTaskStatus.Success;
break;
}
await Task.Delay(httpRequestTask.CycleRequestTimeSpan, cancellationToken);
}
}
catch (HttpRequestException hre)
{
_logger.LogError(hre, $"HttpMethod[{httpRequestTask.HttpMethod}] Uri[{requestTask.Uri}] response status error!");
throw hre;
}
catch (Exception ex)
{
_logger.LogError(ex, $"receive HttpMethod[{httpRequestTask.HttpMethod}] Uri[{requestTask.Uri}] data error!");
throw ex;
}
}
public void DoWork()
{
while (true)
{
if (_requestTasks == null)
{
break;
}
IRequestTask requestTask = null;
if (_requestTasks.TryDequeue(out requestTask))
{
_logger.Log(LogLevel.Info, string.Format("{0} is asyncronously executing request id: {1}", _worker.Name, requestTask.Request.Id));
requestTask.Execute();
}
_waitHandle.WaitOne();
}
}
protected virtual void OnReceivedContent(IRequestTask requestTask, string content)
{
requestTask.TryCount = 0;
var fetchResult = new FetchResult(content, requestTask);
var requestTaskType = requestTask.GetType();
var processors = _fetchResultProcessorProvider.GetFetchResultProcessors(requestTaskType);
foreach (var processor in processors)
{
processor.Process(fetchResult);
}
var pipelines = _pipelineProvider.GetPipelines(requestTaskType);
foreach (var pipeline in pipelines)
{
Task.Factory.StartNew(async() =>
{
await pipeline.HandleAsync(fetchResult);
});
}
}
public QuoteEditService(IRequestTask requestTask, ISchedulerProvider scheduler, Func <QuoteModel> quoteModelFactory)
{
_requestTask = requestTask;
_scheduler = scheduler;
_quoteModelFactory = quoteModelFactory;
}
public QuoteEditService(IRequestTask requestTask, ISchedulerProvider scheduler, Func<QuoteModel> quoteModelFactory)
{
_requestTask = requestTask;
_scheduler = scheduler;
_quoteModelFactory = quoteModelFactory;
}
public ReportParameterStepService(IRequestTask requestTask, ISchedulerProvider scheduler)
{
_requestTask = requestTask;
_scheduler = scheduler;
}
public virtual Task FetchAsync(IRequestTask requestTask, Action <IRequestTask, string> onReceivedContent, CancellationToken cancellationToken)
{
if (!TypeUtils.IsClassAssignableFrom(requestTask.GetType(), typeof(SocketIORequestTask)))
{
throw new ArgumentException($"{nameof(requestTask)} is not socket-io task");
}
var socketIORequestTask = requestTask as SocketIORequestTask;
var client = IO.Socket(socketIORequestTask.Uri, null);
client.Open();
try
{
bool isDisconnect = false;
client.On(Socket.EVENT_DISCONNECT, message =>
{
client.Disconnect();
isDisconnect = true;
});
client.On(Socket.EVENT_ERROR, message =>
{
client.Disconnect();
isDisconnect = true;
});
foreach (var @event in socketIORequestTask.Events)
{
client.On(@event, message =>
{
onReceivedContent(requestTask, message.ToString());
});
}
foreach (var command in socketIORequestTask.Commands)
{
var commandJson = JObject.FromObject(command.Value);
client.Emit(command.Key, commandJson);
}
while (!isDisconnect)
{
if (cancellationToken.IsCancellationRequested)
{
client.Disconnect();
client.Close();
isDisconnect = true;
return(Task.CompletedTask);
}
Thread.Sleep(1000);
}
throw new Exception("socket-io disconnected caused by unknown reason.");
}
catch (Exception ex)
{
_logger.LogError(ex, $"receive socket-io[{requestTask.Uri}] data error!");
client.Disconnect();
client.Close();
throw ex;
}
}
public DataSourceSelectorService(IRequestTask requestTask, ISchedulerProvider scheduler)
{
_requestTask = requestTask;
_scheduler = scheduler;
}
protected RequestTaskException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
this.RequestTask = (IRequestTask) info.GetValue("RequestTask", typeof(IRequestTask));
}
public RequestTaskException(String message, IRequestTask requestTask)
: this(message, null, requestTask)
{
}
public ReportParameterStepService(IRequestTask requestTask, ISchedulerProvider scheduler)
{
_requestTask = requestTask;
_scheduler = scheduler;
}
public ReportViewerService(IRequestTask requestTask, IDispatcherSchedulerProvider scheduler, Func <DynamicReportDataViewModel> simpleReportDataViewModelFactory)
{
_requestTask = requestTask;
_scheduler = scheduler;
_simpleReportDataViewModelFactory = simpleReportDataViewModelFactory;
}
public SearchService(IRequestTask requestTask, ISchedulerProvider scheduler)
{
_requestTask = requestTask;
_scheduler = scheduler;
}
public FetchResult(string content, IRequestTask requestTask) : this(content, requestTask, HttpStatusCode.OK)
{
}
public RequestTaskException(IRequestTask requestTask)
: this(requestTask, null)
{
}
public virtual async Task FetchAsync(IRequestTask requestTask, Action <IRequestTask, string> onReceivedContent, CancellationToken cancellationToken)
{
if (!TypeUtils.IsClassAssignableFrom(requestTask.GetType(), typeof(WebSocketRequestTask)))
{
throw new ArgumentException($"{nameof(requestTask)} is not websocket task");
}
var webSocketRequestTask = requestTask as WebSocketRequestTask;
var client = new ClientWebSocket();
await client.ConnectAsync(requestTask.Uri, cancellationToken);
//send command
await Task.Factory.StartNew(async() =>
{
try
{
await Task.Delay(1000, cancellationToken);
foreach (var command in webSocketRequestTask.Commands)
{
var commandBytes = Encoding.UTF8.GetBytes(command.Value);
await client.SendAsync(new ArraySegment <byte>(commandBytes), WebSocketMessageType.Text, true, cancellationToken);
}
}
catch (Exception ex)
{
_logger.LogError(ex, $"websocket[{requestTask.Uri}] send command error!");
}
});
//heartbeat
if (webSocketRequestTask.HeartBeatCommands != null && webSocketRequestTask.HeartBeatCommands.Count > 0)
{
await Task.Factory.StartNew(async() =>
{
while (client.State == WebSocketState.Open && !cancellationToken.IsCancellationRequested)
{
try
{
foreach (var command in webSocketRequestTask.HeartBeatCommands)
{
var commandBytes = Encoding.UTF8.GetBytes(command.Value);
await client.SendAsync(new ArraySegment <byte>(commandBytes), WebSocketMessageType.Text, true, cancellationToken);
}
await Task.Delay(TimeSpan.FromSeconds(webSocketRequestTask.HeartBeatInterval));
}
catch (Exception ex)
{
_logger.LogError(ex, $"websocket[{requestTask.Uri}] send heartbeat error!");
}
}
});
}
//receive message
try
{
while (client.State == WebSocketState.Open && !cancellationToken.IsCancellationRequested)
{
var buffer = new ArraySegment <byte>(new Byte[1024 * 16]);
string serializedMessage = null;
WebSocketReceiveResult result = null;
using (var ms = new MemoryStream())
{
do
{
result = await client.ReceiveAsync(buffer, cancellationToken).ConfigureAwait(false);
ms.Write(buffer.Array, buffer.Offset, result.Count);
}while (!result.EndOfMessage);
ms.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(ms, Encoding.UTF8))
{
serializedMessage = await reader.ReadToEndAsync().ConfigureAwait(false);
}
}
if (result.MessageType == WebSocketMessageType.Text)
{
onReceivedContent(requestTask, serializedMessage);
}
}
throw new Exception($"websocket disconnected caused by unknown reason, close description[{client.CloseStatusDescription}].");
}
catch (Exception ex)
{
_logger.LogError(ex, $"receive websocket[{requestTask.Uri}] data error, close description[{client.CloseStatusDescription}].");
client.Dispose();
throw;
}
}
public DataService(IDispatcherSchedulerProvider scheduler, IRequestTask requestTask)
{
_scheduler = scheduler;
_requestTask = requestTask;
}
public RequestTaskException(String message, Exception innerException, IRequestTask requestTask)
: base(message, innerException)
{
this.RequestTask = requestTask;
}
private bool IsDuplicate(IRequestTask requestTask)
{
return(tasks.ContainsKey(requestTask.Identity));
}
public SearchService(IRequestTask requestTask, ISchedulerProvider scheduler)
{
_requestTask = requestTask;
_scheduler = scheduler;
}
public DataSourceSelectorService(IRequestTask requestTask, ISchedulerProvider scheduler)
{
_requestTask = requestTask;
_scheduler = scheduler;
}
public ReportLayoutService(IRequestTask requestTask)
{
_requestTask = requestTask;
}
public async Task <Spider> AddTaskAsync(IRequestTask requestTask)
{
await Scheduler.PushAsync(requestTask);
return(this);
}
public DataService(IDispatcherSchedulerProvider scheduler, IRequestTask requestTask)
{
_scheduler = scheduler;
_requestTask = requestTask;
}
public RequestController(IRequestTask process)
{
_process = process;
}
public ReportLayoutService(IRequestTask requestTask)
{
_requestTask = requestTask;
}
public InboxController(IRequestTask process)
{
_process = process;
}
