public void Add(AsyncCommand command, int timeout)
{
queue.Enqueue(command);
if (timeout < sleepInterval)
{
sleepInterval = timeout;
thread.Interrupt();
}
}
public AsyncCommand(AsyncCommand other)
{
// Retry constructor.
this.sequence = other.sequence;
this.cluster = other.cluster;
this.policy = other.policy;
this.partition = other.partition;
this.node = other.node;
this.eventArgs = other.eventArgs;
this.eventArgs.UserToken = this;
this.segmentOrig = other.segmentOrig;
this.segment = other.segment;
this.watch = other.watch;
this.iteration = other.iteration + 1;
this.commandSentCounter = other.commandSentCounter;
this.isRead = other.isRead;
this.usingSocketTimeout = other.usingSocketTimeout;
}
private void Retry(AerospikeException ae)
{
// Prepare for retry.
if (!PrepareRetry(ae.Result != ResultCode.SERVER_NOT_AVAILABLE))
{
try
{
// Batch may be retried in separate commands.
if (RetryBatch())
{
// Batch was retried in separate commands. Complete this command.
return;
}
}
catch (Exception e)
{
NotifyFailure(new AerospikeException("Batch split retry failed", e));
return;
}
}
AsyncCommand command = CloneCommand();
if (command != null)
{
// Command should only be added to AsyncTimeoutQueue once.
// CheckTimeout() will verify both socketTimeout and totalTimeout.
if (socketTimeout > 0)
{
command.socketWatch = Stopwatch.StartNew();
AsyncTimeoutQueue.Instance.Add(command, socketTimeout);
}
else if (totalTimeout > 0)
{
int remain = (int)(totalTimeout - totalWatch.ElapsedMilliseconds);
AsyncTimeoutQueue.Instance.Add(command, remain);
}
command.ExecuteCommand();
}
else
{
FailCommand(ae);
}
}
protected internal virtual void Retry(AerospikeException ae)
{
// Prepare for retry.
AsyncCommand command = CloneCommand();
if (command != null)
{
if (policy.totalTimeout > 0)
{
AsyncTimeoutQueue.Instance.Add(command, policy.totalTimeout);
}
else if (policy.socketTimeout > 0)
{
command.watch = Stopwatch.StartNew();
AsyncTimeoutQueue.Instance.Add(command, policy.socketTimeout);
}
command.ExecuteCommand();
}
else
{
FailCommand(ae);
}
}
private void Retry(AerospikeException ae)
{
// Prepare for retry.
AsyncCommand command = CloneCommand();
if (command != null)
{
if (policy.totalTimeout > 0)
{
AsyncTimeoutQueue.Instance.Add(command, policy.totalTimeout);
}
else if (policy.socketTimeout > 0)
{
command.watch = Stopwatch.StartNew();
AsyncTimeoutQueue.Instance.Add(command, policy.socketTimeout);
}
command.ExecuteCommand();
}
else
{
PutBackArgsOnError();
NotifyFailure(ae);
}
}
private void HandleSocketEvent(object sender, SocketAsyncEventArgs args)
{
AsyncCommand command = args.UserToken as AsyncCommand;
if (args.SocketError != SocketError.Success)
{
command.ConnectionFailed(command.GetAerospikeException(args.SocketError));
return;
}
try
{
switch (args.LastOperation)
{
case SocketAsyncOperation.Receive:
command.ReceiveEvent();
break;
case SocketAsyncOperation.Send:
command.SendEvent();
break;
case SocketAsyncOperation.Connect:
command.ConnectionCreated();
break;
default:
command.FailOnApplicationError(new AerospikeException("Invalid socket operation: " + args.LastOperation));
break;
}
}
catch (AerospikeException.Connection ac)
{
command.ConnectionFailed(ac);
}
catch (AerospikeException ae)
{
// Fail without retry on non-network errors.
if (ae.Result == ResultCode.TIMEOUT)
{
// Create server timeout exception.
ae = new AerospikeException.Timeout(command.policy, false);
}
command.FailOnApplicationError(ae);
}
catch (SocketException se)
{
command.ConnectionFailed(command.GetAerospikeException(se.SocketErrorCode));
}
catch (ObjectDisposedException ode)
{
// This exception occurs because socket is being used after timeout thread closes socket.
// Retry when this happens.
command.ConnectionFailed(new AerospikeException(ode));
}
catch (Exception e)
{
// Fail without retry on unknown errors.
command.FailOnApplicationError(new AerospikeException(e));
}
}
public void ScheduleCommandExecution(AsyncCommand command)
{
commandQueue.ScheduleCommand(command);
}
public void SetBatchRetry(AsyncCommand other)
{
// This batch retry command will be added to the timeout queue in ExecuteCore().
this.iteration = other.iteration;
this.totalWatch = other.totalWatch;
}
// Schedules a command for later execution.
public override bool ScheduleCommand(AsyncCommand command)
{
command.ExecuteInline(_argsQueue.Take());
return(true);
}
// Schedules a command for later execution, and returns a boolean indicating if the command has been executed or is actually going be executed. public abstract bool ScheduleCommand(AsyncCommand command);
// Schedules a command for later execution. // Throws <see cref="AerospikeException.CommandRejected"/> if command is rejected. public abstract void ScheduleCommand(AsyncCommand command);
// Schedules a command for later execution.
public override void ScheduleCommand(AsyncCommand command)
{
// Block until EventArgs becomes available.
command.ExecuteInline(argsQueue.Take());
}
private void RetryAfterInit(AerospikeException ae)
{
if (iterations < policy.maxRetries && (policy.retryOnTimeout || watch == null || watch.ElapsedMilliseconds < policy.timeout))
{
int status = Interlocked.CompareExchange(ref state, RETRY, IN_PROGRESS);
if (status == IN_PROGRESS)
{
// Prepare for retry.
AsyncCommand command = CloneCommand();
if (command != null)
{
CloseConnection();
if (policy.timeout > 0)
{
if (policy.retryOnTimeout)
{
command.watch = Stopwatch.StartNew();
}
else
{
command.watch = this.watch;
}
AsyncTimeoutQueue.Instance.Add(command, policy.timeout);
}
try
{
command.ExecuteCommand();
}
catch (Exception)
{
// Command has already been cleaned up.
// Notify user of original exception.
OnFailure(ae);
}
}
else
{
CloseOnError();
OnFailure(ae);
}
}
else
{
AlreadyCompleted(status);
}
}
else
{
int status = Interlocked.CompareExchange(ref state, FAIL_NETWORK_ERROR, IN_PROGRESS);
if (status == IN_PROGRESS)
{
CloseOnError();
OnFailure(ae);
}
else
{
AlreadyCompleted(status);
}
}
}
