public Task <int> UpdateRunTrace(long traceId, double elapsed, TaskRunResult result)
{
var de = decimal.Parse(elapsed.ToString("f4"));
if (traceId == 0)
{
return(default);
void _worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
try
{
if (e.Result is TaskRunResult)
{
TaskRunResult _result = e.Result as TaskRunResult;
TaskListItem _task = TaskList.Tasks[_result.TaskName];
_task.TaskRunResult = _result;
_task.LastResult = 0;
_task.LastFinishedTime = DateTime.Now;
_task.State = 0;
application.WriteMessage(string.Format("任务[{0}]执行完毕！{1}", _task.TaskName, _result.ResultMsg), EventLogEntryType.Information);
}
else if (e.Result is string)
{
string _ex = e.Result as string;
application.WriteMessage("任务执行失败！" + _ex, EventLogEntryType.Error);
}
else
{
application.WriteMessage("任务执行失败！返回信息为null!", EventLogEntryType.Error);
}
}
catch (Exception ex)
{
application.WriteMessage("未知错误！", EventLogEntryType.Error);
}
}
public async Task <TaskRunResult <bool> > PostHttpContent(string path, HttpContent content)
{
var r_Post = await _Post <bool, HttpContent>(path, content, false);
TaskRunResult <bool> r = new TaskRunResult <bool>(r_Post.IsSuccess, r_Post.Exception, r_Post.Canceled);
return(r);
}
public async Task <TaskRunResult <bool> > Post <TInput>(string path, TInput arg)
{
var r_Post = await _Post <bool, TInput>(path, arg, false);
TaskRunResult <bool> r = new TaskRunResult <bool>(r_Post.IsSuccess, r_Post.Exception, r_Post.Canceled);
return(r);
}
private TaskRunResult CreateTaskResult(List <CheckInfoResult> _result)
{
TaskRunResult _ret = new TaskRunResult();
_ret.StateFlag = 0; //暂设为未知
foreach (CheckInfoResult _ci in _result)
{
_ret.StateFlag = Math.Max(_ret.StateFlag, _ci.StateFlag);
}
var jser = new JavaScriptSerializer();
//序列化
_ret.ResultMsg = jser.Serialize(_result);
return(_ret);
}
void _worker_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker _w = sender as BackgroundWorker;
TaskListItem _item = e.Argument as TaskListItem;
TaskBase _task = _item.TaskPlugin.GetTaskObject() as TaskBase;
try
{
_w.ReportProgress(1, string.Format("开始执行[{0}]任务！", _item.TaskName));
List <CheckInfoResult> _result = _task.ThreadProc();
TaskRunResult _ret = CreateTaskResult(_result);
_ret.TaskName = _item.TaskName;
_item.NextStartTime = _task.GetNextTime();
e.Result = _ret;
}
catch (Exception ex)
{
_item.NextStartTime = _task.GetNextTime();
e.Result = "ERROR:" + ex.Message;
}
}
private async Task <TaskRunResult <byte[]> > _Download(string path)
{
TaskRunResult <byte[]> r;
try
{
using (var client = new HttpClient())
{
if (!string.IsNullOrWhiteSpace(_ServiceURL))
{
client.BaseAddress = new Uri(_ServiceURL);
}
client.Timeout = TimeSpan.FromSeconds(15);
if (Request_AuthorizationHeaderValue != null)
{
client.DefaultRequestHeaders.Authorization = Request_AuthorizationHeaderValue;
}
// New code:
HttpResponseMessage response;
response = await client.GetAsync(path, HttpCompletionOption.ResponseHeadersRead);
if (!response.IsSuccessStatusCode)
{
var ex1 = new System.Net.WebException(response.StatusCode.ToString());
r = new TaskRunResult <byte[]>(null, ex1);
}
else
{
var responseSize = int.Parse(response.Headers.GetValues("ContentLength").First());
byte[] responseReadBuffer = new byte[4096];
List <byte> responseContent = new List <byte>();
using (var responseS1 = await response.Content.ReadAsStreamAsync())
{
int countRead = 0;
while (countRead < responseSize)
{
var taskRead = responseS1.ReadAsync(responseReadBuffer, 0, responseReadBuffer.Length);
var taskTimeout = Task.Delay(2000); //buffer size: 4096 => on a 32Kbit/s it will take 1 second
var taskDone = await Task.WhenAny(taskRead, taskTimeout);
if (taskDone == taskRead && taskRead.Result > 0)
{
for (int i1 = 0; i1 < taskRead.Result; i1++)
{
responseContent.Add(responseReadBuffer[i1]);
}
countRead += taskRead.Result;
}
else
{
throw new TimeoutException();
}
}
}
if (responseContent.Count <= 0)
{
throw new ArgumentException();
}
r = new TaskRunResult <byte[]>(responseContent.ToArray());
}
}
}
catch (Exception ex1)
{
r = new TaskRunResult <byte[]>(null, ex1);
}
return(r);
}
private async Task <TaskRunResult <TResult> > _Run <TResult, TInput>(RunModes mode, string path, TInput arg, bool hasReturn, bool hasArg = true, bool returnContentAsString = false)
{
TaskRunResult <TResult> r;
try
{
using (var client = HttpClientCreate?.Invoke() ?? new HttpClient())
{
if (!string.IsNullOrWhiteSpace(_ServiceURL))
{
client.BaseAddress = new Uri(_ServiceURL);
}
client.DefaultRequestHeaders.AcceptEncoding.Clear();
client.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("deflate"));
client.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
if (Request_AuthorizationHeaderValue != null)
{
client.DefaultRequestHeaders.Authorization = Request_AuthorizationHeaderValue;
}
// New code:
HttpResponseMessage response;
switch (mode)
{
case RunModes.Post:
if (hasArg)
{
if (typeof(TInput) == typeof(HttpContent))
{
response = await client.PostAsync(path, arg as HttpContent);
}
else
{
response = await client.PostAsync(path, new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(arg), Encoding.UTF8, "application/json")); // .PostAsJsonAsync<TInput>(path, arg);
}
}
else
{
response = await client.PostAsync(path, null);
}
break;
case RunModes.Get:
response = await client.GetAsync(path);
break;
case RunModes.Put:
if (hasArg)
{
if (typeof(TInput) == typeof(HttpContent))
{
response = await client.PutAsync(path, arg as HttpContent);
}
else
{
response = await client.PutAsync(path, new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(arg), Encoding.UTF8, "application/json")); // .PostAsJsonAsync<TInput>(path, arg);
}
}
else
{
response = await client.PutAsync(path, null);
}
break;
case RunModes.Delete:
response = await client.DeleteAsync(path);
break;
default:
throw new ArgumentException();
}
if (!response.IsSuccessStatusCode)
{
var ex1 = new System.Net.WebException(response.StatusCode.ToString());
ex1.Data.Add("content", await _Response_ReadContent(response));
r = new TaskRunResult <TResult>(default(TResult), ex1);
}
else
{
TResult r_InPost = default(TResult);
if (hasReturn)
{
if (returnContentAsString)
{
r_InPost = (TResult)((object)await _Response_ReadContent(response));
}
else
{
r_InPost = Newtonsoft.Json.JsonConvert.DeserializeObject <TResult>(await _Response_ReadContent(response));
}
}
r = new TaskRunResult <TResult>(r_InPost);
}
}
}
catch (Exception ex1)
{
r = new TaskRunResult <TResult>(default(TResult), ex1);
}
return(r);
}
