private void ReJoin(DelayTask task)
{
var flag = false;
//不重试
if (task.MaxRetryCount < 0)
{
flag = false;
}
else if (task.ExecCount >= task.MaxRetryCount && task.MaxRetryCount > 0)
{
flag = false;
}
else
{
task.TriggerTime = DateTime.Now.AddSeconds(task.RetrySeconds);
_delayTaskDao.RetryUpdate(task);
flag = true;
}
if (flag)
{
_tw.Add(task.Id, task.RetrySeconds);
}
else
{
//如果不重试，是否要删除
_delayTaskDao.DeleteById(task.Id);
}
}
public int WaitCount => Interlocked.CompareExchange(ref _waitCount, 0, -1); // Just read, never xchg
public Task Delay(TimeSpan delay, CancellationToken cancellationToken)
{
if (delay <= TimeSpan.Zero)
{
return(_completedTask);
}
lock (_lock)
{
var delayTask = new DelayTask(Clock.GetCurrentDateTimeUtc() + delay, cancellationToken);
var delayNode = _delays.First;
while (delayNode != null && delayNode.Value.Scheduled < delayTask.Scheduled)
{
delayNode = delayNode.Next;
}
if (delayNode == null)
{
_delays.AddLast(delayTask);
}
else
{
_delays.AddBefore(delayNode, delayTask);
}
return(delayTask.Tcs.Task);
}
}
private void MoveBlockCheck()
{
if (queue_position_x.Count >= 32)
{
queue_position_x.Dequeue();
}
queue_position_x.Enqueue(character.transform.position.x);
if (queue_position_x.Count >= 32 && queue_position_x.Max() - queue_position_x.Min() < 0.1f)
{
if (RandomUtils.RandomBool())
{
isMoveBlocking = true;
//character.Move.Idle();
DelayTask.Invoke(() =>
{
isMoveBlocking = false;
queue_position_x.Clear();
}, RandomUtils.RandomMinMax(500, 2000));
}
else
{
GoToNextPatrolPoint();
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
for (int i = 0; i < 100; i++)
{
var index = i;
Task.Run(async() =>
{
var delayTask = DelayTask.AddTask(index,
new Func <object, int, Func <Task> >((state, count) => new Func <Task>(() =>
{
Console.WriteLine($"第{count}次执行:{state},threadId:{System.Threading.Thread.CurrentThread.ManagedThreadId}");
return(Task.CompletedTask);
})),
index,
TimeSpan.FromSeconds(1),
count =>
{
if (count > i)
{
return(null);
}
return(TimeSpan.FromMilliseconds((i % 3) * 100));
});
await Task.Delay(5000);
delayTask.Stop();
});
}
Console.ReadLine();
}
private void CalculateDelayMoves(Moves moves)
{
var maxMovesBeforeRiskyAttack = 7;
var minMovesBeforeRiskyAttack = 1;
var delayMoves = DelayTask.CalculateDelayTask(BotState, moves, maxMovesBeforeRiskyAttack,
minMovesBeforeRiskyAttack);
MovesCommitter.CommittMoves(BotState, delayMoves);
moves.MergeMoves(delayMoves);
}
private void AliveCountdown(int aliveTime)
{
taskAliveCountdown?.Release();
taskAliveCountdown = DelayTask.Invoke(() =>
{
if (this.gameObject != null)
{
GameObject.Destroy(this.gameObject);
}
}, aliveTime);
}
public ActionResult DelayEdit(long id = 0)
{
var m = _delayTaskService.SingleById(id);
if (m == null)
{
m = new DelayTask();
m.Enable = true;
m.Method = "GET";
m.TimeoutSeconds = 15;
m.MaxRetryCount = 3;
m.RetrySeconds = 30;
}
ViewBag.m = m;
return(View());
}
private Task Delay(Duration delay, CancellationToken cancellationToken = default(CancellationToken))
{
lock (_lock)
{
var delayTask = new DelayTask(_fakeClock.GetCurrentInstant() + delay, cancellationToken);
var delayNode = _delays.First;
while (delayNode != null && delayNode.Value.Scheduled < delayTask.Scheduled)
{
delayNode = delayNode.Next;
}
if (delayNode == null)
{
_delays.AddLast(delayTask);
}
else
{
_delays.AddBefore(delayNode, delayTask);
}
return(delayTask.Tcs.Task);
}
}
private void On_DelayTimer_Tick(object sender, EventArgs e)
{
DelayTask currentTask = _TaskQueue[_CurrentTaskIndex];
if (currentTask.CanRun == null)
{
RunTask();
}
else
if (currentTask.MaxAttempts > 0)
{
currentTask.AttemptCount++;
if (currentTask.CanRun() || currentTask.AttemptCount >= currentTask.MaxAttempts)
{
RunTask();
}
}
else
if (currentTask.CanRun())
{
RunTask();
}
}
public ResultObject Edit(DelayTask m)
{
if (string.IsNullOrEmpty(m.Url))
{
return(new ResultObject("url不能为空"));
}
if (m.Id > 0)
{
var flag = _delayTaskDao.Update(m, "Name", "Url", "Method", "PostData", "Enable",
"TriggerTime", "MaxRetryCount", "RetrySeconds", "SuccessFlag", "TimeoutSeconds");
return(new ResultObject(flag));
}
else
{
if (m.TriggerTime <= DateTime.Now)
{
return(new ResultObject("触发时间不正确"));
}
var flag = _delayTaskDao.Insert(m);
return(new ResultObject(flag));
}
}
/// <summary>
/// Implementation of the *RequestWithRetry methods.
/// </summary>
/// <typeparam name="T">The result type of the task.</typeparam>
/// <param name="retryOracle">The retry oracle.</param>
/// <param name="impl">The task implementation.</param>
/// <param name="setResult">The result report delegate.</param>
/// <returns>A <see cref="TaskSequence"/> that performs the request with retries.</returns>
internal static TaskSequence RequestWithRetryImpl <T>(ShouldRetry retryOracle, Func <Action <T>, TaskSequence> impl, Action <T> setResult)
{
int retryCount = 0;
bool succeeded = false;
bool shouldRetry = false;
do
{
var task = new InvokeTaskSequenceTask <T>(impl);
yield return(task);
TimeSpan delay = TimeSpan.FromMilliseconds(-1);
try
{
var result = task.Result;
succeeded = true;
setResult(result);
}
catch (TimeoutException e)
{
shouldRetry = retryOracle != null?retryOracle(retryCount ++, e, out delay) : false;
// We should just throw out the exception if we are not retrying
if (!shouldRetry)
{
throw;
}
}
catch (StorageServerException e)
{
if (e.StatusCode == HttpStatusCode.NotImplemented || e.StatusCode == HttpStatusCode.HttpVersionNotSupported)
{
throw;
}
shouldRetry = retryOracle != null?retryOracle(retryCount ++, e, out delay) : false;
// We should just throw out the exception if we are not retrying
if (!shouldRetry)
{
throw;
}
}
catch (InvalidOperationException e)
{
//DataServiceClientException dsce = CommonUtils.FindInnerDataServiceClientException(e);
/*
* // rethrow 400 class errors immediately as they can't be retried
* // 501 (Not Implemented) and 505 (HTTP Version Not Supported) shouldn't be retried either.
* if (dsce != null &&
* ((dsce.StatusCode >= 400 && dsce.StatusCode < 500)
|| dsce.StatusCode == (int)HttpStatusCode.NotImplemented
|| dsce.StatusCode == (int)HttpStatusCode.HttpVersionNotSupported))
||{
||throw;
||}*/
// If it is BlobTypeMismatchExceptionMessage, we should throw without retry
if (e.Message == SR.BlobTypeMismatchExceptionMessage)
{
throw;
}
shouldRetry = retryOracle != null?retryOracle(retryCount ++, e, out delay) : false;
// We should just throw out the exception if we are not retrying
if (!shouldRetry)
{
throw;
}
}
if (!succeeded && shouldRetry && delay > TimeSpan.Zero)
{
using (DelayTask delayTask = new DelayTask(delay))
{
yield return(delayTask);
// Materialize exceptions
var scratch = delayTask.Result;
Console.WriteLine(scratch);
}
}
}while (!succeeded && shouldRetry);
}
protected override Sims3.Gameplay.EventSystem.ListenerAction OnProcess(Sims3.Gameplay.EventSystem.Event e)
{
DelayTask.Perform(e, mFunc);
return(Sims3.Gameplay.EventSystem.ListenerAction.Keep);
}
private void Run(DelayTask task)
{
var hc = _httpClientFactory.CreateClient();
hc.Timeout = task.TimeoutSeconds == 0
? TimeSpan.FromSeconds(15)
: TimeSpan.FromSeconds(task.TimeoutSeconds);
Task <HttpResponseMessage> requestTask;
if (task.Method.Equals("GET", StringComparison.OrdinalIgnoreCase))
{
requestTask = hc.GetAsync(task.Url);
}
else
{
StringContent stringContent = new StringContent(task.PostData, Encoding.UTF8);
requestTask = hc.PostAsync(task.Url, stringContent);
}
requestTask.ContinueWith(reqTask =>
{
var log = new ExecuteLog()
{
PostData = task.PostData,
TaskId = task.Id,
TaskName = task.Name,
TaskUrl = task.Url,
TaskType = 2,
TaskMethod = task.Method,
};
if (reqTask.IsFaulted)
{
log.Status = 2;
log.Message = reqTask.Exception.GetBaseException().StackTrace;
_executeLogDao.Insert(log);
_logger.LogError(reqTask.Exception.InnerExceptions.FirstOrDefault(),
"执行DelayTask异常，id:{0},name:{1},url:{2}", task.Id, task.Name, task.Url);
ReJoin(task);
}
else if (reqTask.IsCanceled)
{
log.Status = 3;
log.Message = "timeout";
_executeLogDao.Insert(log);
ReJoin(task);
}
else
{
reqTask.Result.Content.ReadAsStringAsync().ContinueWith(readTask =>
{
if (readTask.Result == task.SuccessFlag)
{
//删除数据
_delayTaskDao.DeleteById(task.Id);
log.Status = 1;
log.Message = "success";
_executeLogDao.Insert(log);
}
else
{
log.Status = 2;
log.Message = readTask.Result;
_logger.LogError("执行DelayTask出错，id:{0},name:{1},url:{2},msg:{3}", task.Id, task.Name,
task.Url, readTask.Result);
_executeLogDao.Insert(log);
ReJoin(task);
}
});
}
});
}
public ActionResult DelaySave(DelayTask m)
{
var ro = _delayTaskService.Edit(m);
return(Json(ro));
}
