/// <summary>
/// Tracks the complete outstanding operation.
/// </summary>
/// <param name="asyncEvent">The asynchronous event.</param>
/// <param name="result">The result.</param>
/// <param name="executionStarted">if set to <c>true</c> [execution started].</param>
internal void TrackCompleteOutstandingOperation(AsyncEvent asyncEvent, AsyncHandlerResult result, bool executionStarted)
{
lock (_outstandingOperations)
{
if (result is AsyncInProgressResult) return;
if (!_outstandingOperations.Remove(asyncEvent)) return;
Counters.TrackCompleteOutstandingOperation(asyncEvent.OperationType, result, asyncEvent.ExecutionTime);
if (executionStarted)
{
_startThreadHandler();
}
}
}
/// <summary>
/// Determines whether this instance [can remove event] the specified asynchronous event.
/// </summary>
/// <param name="asyncEvent">The asynchronous event.</param>
/// <param name="result">The result.</param>
/// <returns></returns>
private bool CanRemoveEvent(AsyncEvent asyncEvent, AsyncHandlerResult result)
{
var asyncRemoveEventResult = result as AsyncRemoveEventResult;
return asyncRemoveEventResult != null;
}
/// <summary>
/// Ends the asynchronous event processing.
/// </summary>
/// <param name="asyncEvent">The asynchronous event.</param>
/// <param name="result">The result.</param>
public void EndAsynchronousEventProcessing(AsyncEvent asyncEvent, AsyncHandlerResult result)
{
UpdateEventState(asyncEvent, result);
TrackCompleteExecutingOperation(asyncEvent, result);
TrackCompleteOutstandingOperation(asyncEvent, result, true);
}
/// <summary>
/// Tracks the complete executing operation.
/// </summary>
/// <param name="asyncEvent">The asynchronous event.</param>
/// <param name="result">The result.</param>
internal void TrackCompleteExecutingOperation(AsyncEvent asyncEvent, AsyncHandlerResult result)
{
lock (_executingOperations)
{
if (result is AsyncInProgressResult) return;
if (_executingOperations.Remove(asyncEvent))
{
Counters.TrackCompleteExecutingOperation(asyncEvent.OperationType);
SemaphoreSlim semaphoreSlim = null;
if (Configuration.OperationTypeThrottle.TryGetValue(asyncEvent.OperationType, out semaphoreSlim))
{
semaphoreSlim.Release();
}
}
if (_shutdownEvent != null && _executingOperations.Count == 0)
{
_shutdownEvent.Set();
}
}
}
/// <summary>
/// Ends the asynchronous event processing.
/// </summary>
/// <param name="asyncEvent">The asynchronous event.</param>
/// <param name="result">The result.</param>
internal void EndAsynchronousEventProcessing(AsyncEvent asyncEvent, AsyncHandlerResult result)
{
_queueManager.EndAsynchronousEventProcessing(asyncEvent, result);
}
/// <summary>
/// Updates the state of the event.
/// </summary>
/// <param name="asyncEvent">The asynchronous event.</param>
/// <param name="result">The result.</param>
private void UpdateEventState(AsyncEvent asyncEvent, AsyncHandlerResult result)
{
var instance = this._dataAccessFactory.CreateInstance(this, Configuration.OrganizationConfiguration);
var newStatus = result.ResultCode;
int newState = 3;
int errorCode = 0;
string errorMessage = null;
string friendlyMessage = null;
bool retryOperation = false;
var handlerResultWithError = result as AsyncHandlerResultWithError;
if (handlerResultWithError != null)
{
errorCode = handlerResultWithError.ErrorCode;
errorMessage = handlerResultWithError.ErrorMessage;
friendlyMessage = handlerResultWithError.FriendlyMessage;
}
else
{
var resultWithMessage = result as AsyncHandlerResultWithMessage;
if (resultWithMessage != null)
friendlyMessage = resultWithMessage.Message;
}
var nextOccurrence = DateTime.MinValue;
if (result is AsyncRetryResult)
{
if (asyncEvent.RetryCount < this.Configuration.MaximumRetries || errorCode == -2147180543) // -2147180543 = The server is busy and the request was not completed. Try again later.
{
retryOperation = true;
}
else
{
nextOccurrence = DateTime.MaxValue;
LogEvent(EventLogEntryType.Error, 3221242897L, Environment.MachineName, asyncEvent.OperationType, errorCode.ToString("x", (IFormatProvider)CultureInfo.InvariantCulture),
errorMessage);
}
}
var asyncPausedResult = result as AsyncPausedResult;
if (asyncPausedResult != null && asyncPausedResult.PostponeUntil != DateTime.MinValue)
nextOccurrence = asyncPausedResult.PostponeUntil;
switch (newStatus)
{
case 20:
return;
case 21:
case 10:
if (retryOperation && this.HandleSpecialTransition(asyncEvent) != null)
return;
newState = 1;
newStatus = 10;
break;
case 22:
case 32:
newState = 3;
newStatus = 32;
break;
case 0:
AsyncServiceException.Assert(false, "错误状态: " + newStatus);
break;
}
if (result is AsyncSystemPausedResult)
nextOccurrence = DateTime.MaxValue;
if (asyncEvent.IsRecurrenceEvent)
{
nextOccurrence = NextOccurrence(asyncEvent);
if (nextOccurrence == DateTime.MinValue)
{
newState = 3;
newStatus = 30;
}
else
{
newState = 1;
newStatus = 10;
}
}
if (newState == 1 && newStatus == 10 && asyncEvent.AutoResumeFromPause)
nextOccurrence = DateTime.Now.AddMinutes(1.0);
var newEventState = new AsyncEventState()
{
EventId = asyncEvent.EventId,
NewState = newState,
NewStatus = newStatus,
NextOccurrence = nextOccurrence,
RetryOperation = retryOperation,
CurrentRetryCount = asyncEvent.RetryCount,
ErrorCode = errorCode,
ErrorMessage = errorMessage,
FriendlyMessage = friendlyMessage,
ClearData = this.CanClearData(newState, asyncEvent),
ExecutionTime = asyncEvent.ExecutionTimeSeconds,
CanRemoveEvent = this.CanRemoveEvent(asyncEvent, result),
HandlerResult = result
};
instance.UpdateStateAndStatus(newEventState);
RemoveSpecialTransition(asyncEvent.EventId);
}
/// <summary>
/// Ends the asynchronous event processing.
/// </summary>
/// <param name="result">The result.</param>
public void EndAsynchronousEventProcessing(AsyncHandlerResult result)
{
this._queueManager.EndAsynchronousEventProcessing(this, result);
}
/// <summary>
/// Tracks the complete outstanding operation.
/// </summary>
/// <param name="result">The result.</param>
/// <param name="completionTime">The completion time.</param>
public void TrackCompleteOutstandingOperation(AsyncHandlerResult result, System.TimeSpan completionTime)
{
this._itemsOutstanding.Decrement();
long num = this._itemsCompleted.Increment();
this._itemsCompletedThroughput.Increment();
if (num < 1L)
{
num = 1L;
}
if (result is AsyncFailedResult)
{
this._itemsFailedWithException.Increment();
}
else if (result is AsyncRetryResult)
{
this._itemsFailedWithRetry.Increment();
}
this._rateFailedWithException.RawValue =
(long) (this._itemsFailedWithException.RawValue/(double) num*100.0);
this._rateFailedWithRetry.RawValue =
(long) (this._itemsFailedWithRetry.RawValue/(double) num*100.0);
if (completionTime != System.TimeSpan.MinValue)
{
long value = System.Convert.ToInt64(completionTime.TotalSeconds);
long num2 = System.Threading.Interlocked.Add(ref this._totalTime, value);
long num3 = System.Threading.Interlocked.Increment(ref this._totalCount);
if (num2 < 0L || num3 <= 0L)
{
num3 = 1L;
num2 = this._averageTime.RawValue;
System.Threading.Interlocked.Exchange(ref this._totalCount, num3);
System.Threading.Interlocked.Exchange(ref this._totalTime, num2);
}
this._averageTime.RawValue = num2/num3;
}
}
/// <summary>
/// Tracks the complete outstanding operation.
/// </summary>
/// <param name="operationType">Type of the operation.</param>
/// <param name="result">The result.</param>
/// <param name="completionTime">The completion time.</param>
public void TrackCompleteOutstandingOperation(Guid operationType, AsyncHandlerResult result,
System.TimeSpan completionTime)
{
this._totalCounters.TrackCompleteOutstandingOperation(result, completionTime);
}
public void TrackCompleteOutstandingOperation(Guid operationType, AsyncHandlerResult result,
System.TimeSpan completionTime)
{
}
public void TrackCompleteOutstandingOperation(Guid operationType, AsyncHandlerResult result)
{
}
