protected override IOperationResult ProcessResponse(BinaryResponse response)
{
var status = response.StatusCode;
var result = new BinaryOperationResult();
this.StatusCode = status;
if (status == 0)
{
int flags = BinaryConverter.DecodeInt32(response.Extra, 0);
this.result = new CacheItem((ushort)flags, response.Data);
this.Cas = response.CAS;
#if EVEN_MORE_LOGGING
if (log.IsDebugEnabled)
{
log.DebugFormat("Get succeeded for key '{0}'.", this.Key);
}
#endif
return(result.Pass());
}
this.Cas = 0;
#if EVEN_MORE_LOGGING
if (log.IsDebugEnabled)
{
log.DebugFormat("Get failed for key '{0}'. Reason: {1}", this.Key, Encoding.ASCII.GetString(response.Data.Array, response.Data.Offset, response.Data.Count));
}
#endif
var message = ResultHelper.ProcessResponseData(response.Data);
return(result.Fail(message));
}
protected internal override async ValueTask <IOperationResult> ReadResponseAsync(PooledSocket socket)
{
var response = new BinaryResponse();
var retval = await response.ReadAsync(socket);
this.Cas = response.CAS;
this.StatusCode = response.StatusCode;
var result = new BinaryOperationResult()
{
Success = retval,
Cas = this.Cas,
StatusCode = this.StatusCode
};
IOperationResult responseResult;
if (!(responseResult = this.ProcessResponse(response)).Success)
{
result.InnerResult = responseResult;
responseResult.Combine(result);
}
return(result);
}
protected internal override async ValueTask <IOperationResult> ReadResponseAsync(PooledSocket socket)
{
var response = new BinaryResponse();
var serverData = new Dictionary <string, string>();
var retval = false;
while ((await response.ReadAsync(socket)) && response.KeyLength > 0)
{
retval = true;
var data = response.Data;
var key = BinaryConverter.DecodeKey(data.Array, data.Offset, response.KeyLength);
var value = BinaryConverter.DecodeKey(data.Array, data.Offset + response.KeyLength, data.Count - response.KeyLength);
serverData[key] = value;
}
this.result = serverData;
this.StatusCode = response.StatusCode;
var result = new BinaryOperationResult()
{
StatusCode = StatusCode
};
result.PassOrFail(retval, "Failed to read response");
return(result);
}
protected internal override async Task <IOperationResult> ReadResponseAsync(PooledSocket socket, CancellationToken cancellationToken = default(CancellationToken))
{
var response = new BinaryResponse();
var serverData = new Dictionary <string, string>();
var success = false;
while (await response.ReadAsync(socket, cancellationToken).ConfigureAwait(false) && response.KeyLength > 0)
{
success = true;
var data = response.Data;
var key = BinaryConverter.DecodeKey(data.Array, data.Offset, response.KeyLength);
var value = BinaryConverter.DecodeKey(data.Array, data.Offset + response.KeyLength, data.Count - response.KeyLength);
serverData[key] = value;
}
this._result = serverData;
this.StatusCode = response.StatusCode;
var result = new BinaryOperationResult()
{
StatusCode = StatusCode
};
result.PassOrFail(success, "Failed to read response");
return(result);
}
protected internal override IOperationResult ReadResponse(PooledSocket socket)
{
var response = new BinaryResponse();
var success = response.Read(socket);
this.Cas = response.CAS;
this.StatusCode = response.StatusCode;
var result = new BinaryOperationResult()
{
Success = success,
Cas = this.Cas,
StatusCode = this.StatusCode
};
IOperationResult responseResult;
if (!(responseResult = this.ProcessResponse(response)).Success)
{
result.InnerResult = responseResult;
responseResult.Combine(result);
}
return(result);
}
protected internal override async Task <IOperationResult> ReadResponseAsync(PooledSocket socket, CancellationToken cancellationToken = default(CancellationToken))
{
var response = new BinaryResponse();
var success = await response.ReadAsync(socket, cancellationToken).ConfigureAwait(false);
this.Cas = response.CAS;
this.StatusCode = response.StatusCode;
var result = new BinaryOperationResult()
{
Success = success,
Cas = this.Cas,
StatusCode = this.StatusCode
};
IOperationResult responseResult;
if (!(responseResult = this.ProcessResponse(response)).Success)
{
result.InnerResult = responseResult;
responseResult.Combine(result);
}
return(result);
}
protected internal override IOperationResult ReadResponse(PooledSocket socket)
{
var response = new BinaryResponse();
var retval = response.Read(socket);
this.Cas = response.CAS;
this.StatusCode = response.StatusCode;
var result = new BinaryOperationResult()
{
Success = retval,
Cas = this.Cas,
StatusCode = this.StatusCode
};
IOperationResult responseResult;
if (!(responseResult = this.ProcessResponse(response)).Success)
{
result.InnerResult = responseResult;
result.Fail("Failed to process response, see StatusCode or InnerResult for details");
}
return(result);
}
protected override IOperationResult ProcessResponse(BinaryResponse response)
{
var result = new BinaryOperationResult();
#if EVEN_MORE_LOGGING
if (log.IsDebugEnabled)
{
if (response.StatusCode == 0)
{
log.DebugFormat("Store succeeded for key '{0}'.", this.Key);
}
else
{
log.DebugFormat("Store failed for key '{0}'. Reason: {1}", this.Key, Encoding.ASCII.GetString(response.Data.Array, response.Data.Offset, response.Data.Count));
}
}
#endif
this.StatusCode = response.StatusCode;
if (response.StatusCode == 0)
{
return(result.Pass());
}
else
{
var message = ResultHelper.ProcessResponseData(response.Data);
return(result.Fail(message));
}
}
protected override IOperationResult ProcessResponse(BinaryResponse response)
{
var result = new BinaryOperationResult();
var status = response.StatusCode;
this.StatusCode = status;
if (status == 0)
{
if (mode != MutationMode.Touch)
{
var data = response.Data;
if (data.Count != 8)
{
return(result.Fail("Result must be 8 bytes long, received: " + data.Count, new InvalidOperationException()));
}
this.result = BinaryConverter.DecodeUInt64(data.Array, data.Offset);
}
return(result.Pass());
}
var message = ResultHelper.ProcessResponseData(response.Data);
return(result.Fail(message));
}
protected override IOperationResult CreateResult(BinaryResponse response)
{
var retval = new BinaryOperationResult();
return(response == null
? retval.Success(this)
: retval.WithResponse(response));
}
protected override IOperationResult ProcessResponse(BinaryResponse response)
{
var result = new BinaryOperationResult();
return(response.StatusCode == 0
? result.Pass()
: result.Fail(OperationResultHelper.ProcessResponseData(response.Data)));
}
protected override IOperationResult ProcessResponse(BinaryResponse response)
{
base.ProcessResponse(response);
var result = new BinaryOperationResult();
if (!GuessResponseState(response, out this.state))
{
var message = ResultHelper.ProcessResponseData(response.Data, "Failed to process response");
return(result.Fail(message));
}
return(result.Pass());
}
protected override IOperationResult ProcessResponse(BinaryResponse response)
{
var r = response.StatusCode == 0;
var result = new BinaryOperationResult();
if (this.locator != null &&
!VBucketAwareOperationFactory.GuessResponseState(response, out this.state))
{
return(result.Fail("Process response failed"));
}
return(result.PassOrFail(r, "Processing response failed"));
}
protected override IOperationResult ProcessResponse(BinaryResponse response)
{
var r = base.ProcessResponse(response);
var result = new BinaryOperationResult();
if (this.locator != null &&
!VBucketAwareOperationFactory.GuessResponseState(response, out this.state))
{
return(result.Fail("Failed to process response"));
}
return(r);
}
protected override IOperationResult ProcessResponse(BinaryResponse response)
{
var result = new BinaryOperationResult();
this.StatusCode = response.StatusCode;
if (response.StatusCode == 0)
{
return(result.Pass());
}
else
{
var message = ResultHelper.ProcessResponseData(response.Data);
return(result.Fail(message));
}
}
protected internal override async Task <IOperationResult> ReadResponseAsync(PooledSocket socket, CancellationToken cancellationToken = default(CancellationToken))
{
var response = new BinaryResponse();
var success = await response.ReadAsync(socket, cancellationToken).ConfigureAwait(false);
this.StatusCode = StatusCode;
var result = new BinaryOperationResult()
{
Success = success,
StatusCode = this.StatusCode
};
result.PassOrFail(success, "Failed to read response");
return(result);
}
protected internal override IOperationResult ReadResponse(PooledSocket socket)
{
var response = new BinaryResponse();
var retval = response.Read(socket);
this.StatusCode = StatusCode;
var result = new BinaryOperationResult()
{
Success = retval,
StatusCode = this.StatusCode
};
result.PassOrFail(retval, "Failed to read response");
return(result);
}
protected internal override IOperationResult ReadResponse(PooledSocket socket)
{
var response = new BinaryResponse();
var success = response.Read(socket);
this.StatusCode = response.StatusCode;
this.Data = response.Data.Array;
var result = new BinaryOperationResult
{
StatusCode = this.StatusCode
};
result.PassOrFail(success, "Failed to read response");
return(result);
}
protected override IOperationResult ReadResponse(PooledSocket socket)
{
var response = new BinaryResponse();
var result = new BinaryOperationResult();
if (response.Read(socket))
{
this.Result = DecodeResult(response.Data);
result.Pass();
return(result);
}
result.Fail("Processing of response failed");
return(result);
}
protected internal override async ValueTask <IOperationResult> ReadResponseAsync(PooledSocket socket)
{
var response = new BinaryResponse();
var retval = await response.ReadAsync(socket);
this.StatusCode = response.StatusCode;
this.Data = response.Data.Array;
var result = new BinaryOperationResult
{
StatusCode = this.StatusCode
};
result.PassOrFail(retval, "Failed to read response");
return(result);
}
protected override IOperationResult ProcessResponse(BinaryResponse response)
{
var status = response.StatusCode;
var result = new BinaryOperationResult();
this.StatusCode = status;
if (status == 0)
{
this.Cas = response.CAS;
return(result.Pass());
}
this.Cas = 0;
var message = ResultHelper.ProcessResponseData(response.Data);
return(result.Fail(message));
}
protected override IOperationResult ProcessResponse(BinaryResponse response)
{
var status = response.StatusCode;
var result = new BinaryOperationResult();
this.StatusCode = status;
if (status == 0)
{
int flags = BinaryConverter.DecodeInt32(response.Extra, 0);
this.result = new CacheItem((ushort)flags, response.Data);
this.Cas = response.CAS;
return(result.Pass());
}
this.Cas = 0;
return(result.Fail(OperationResultHelper.ProcessResponseData(response.Data)));
}
//protected internal virtual PooledSocket CreateSocket(IPEndPoint endpoint, TimeSpan connectionTimeout, TimeSpan receiveTimeout)
//{
// PooledSocket retval = new PooledSocket(endPoint, connectionTimeout, receiveTimeout);
// return retval;dis
//}
protected virtual IPooledSocketResult ExecuteOperation(IOperation op)
{
IOperationResult readResult = new BinaryOperationResult();
var result = this.Acquire();
if (result.Success && result.HasValue)
{
try
{
var socket = result.Value;
var b = op.GetBuffer();
socket.Write(b);
readResult = op.ReadResponse(socket);
if (readResult.Success)
{
result.Pass();
}
else
{
readResult.Combine(result);
}
return(result);
}
catch (IOException e)
{
log.Error(e);
result.Fail("Exception reading response", e);
return(result);
}
finally
{
((IDisposable)result.Value).Dispose();
}
}
else
{
readResult.Combine(result);
return(result);
}
}
protected override IOperationResult CreateResult(BinaryResponse response)
{
Debug.Assert(response != null);
return(BinaryOperationResult.FromResponse(response));
}
public IOperationResult Execute(IOperation op)
{
IOperationResult result = new BinaryOperationResult();
IPooledSocket socket = null;
try
{
socket = _pool.Acquire();
if (Log.IsDebugEnabled)
{
Log.DebugFormat("Start execute {0} with {1}", op.Key, socket.InstanceId);
}
var buffers = op.GetBuffer();
socket.Write(buffers);
result = op.ReadResponse(socket);
if (result.Success)
{
result.Pass();
}
}
catch (NodeShutdownException e)
{
string msg = String.Format("Node Shutdown - {0}.", EndPoint);
Log.DebugFormat("m:{0} i:{1}\n{2}", msg, op.Key, e);
result.Fail(msg, e);
result.StatusCode = StatusCode.NodeShutdown.ToInt();
}
catch (QueueTimeoutException e)
{
string msg = String.Format("Queue Timeout - {0}.", EndPoint);
Log.ErrorFormat("m:{0} i:{1}\n{2}", msg, op.Key, e);
result.Fail(msg, e);
result.StatusCode = StatusCode.SocketPoolTimeout.ToInt();
}
catch (IOException e)
{
string msg = String.Format("Exception reading response - {0}", EndPoint);
Log.ErrorFormat("m:{0} s:{1} i:{2}\n{3}", msg, op.Key,
socket == null ? Guid.Empty : socket.InstanceId, e);
result.Fail(msg, e);
if (result.StatusCode == null ||
result.StatusCode == StatusCode.Success.ToInt())
{
result.StatusCode = StatusCode.InternalError.ToInt();
}
}
catch (Exception e)
{
string msg = String.Format("Operation failed - {0}", EndPoint);
Log.ErrorFormat("m:{0} s:{1} i:{2}\n{3}", msg, op.Key,
socket == null ? Guid.Empty : socket.InstanceId, e);
result.Fail(msg, e);
if (result.StatusCode == null ||
result.StatusCode == StatusCode.Success.ToInt())
{
result.StatusCode = StatusCode.InternalError.ToInt();
}
}
finally
{
if (socket != null)
{
if (Log.IsDebugEnabled)
{
Log.DebugFormat("End execute {0} with {1}", op.Key, socket.InstanceId);
}
_pool.Release(socket);
}
}
if (Log.IsDebugEnabled)
{
const string msg = "Operation {0} :i {1} n: {2} t: {3} m: {4} sc: {5} r: {6}";
Log.DebugFormat(msg, result.Success ?
op.RetryAttempts > 0 ? "succeeded*" : "succeeded" :
op.RetryAttempts > 0 ? "failed*" : "failed",
op.Key,
_endpoint, Thread.CurrentThread.Name,
result.Message,
Enum.GetName(typeof(StatusCode), result.StatusCode ?? 0),
op.RetryAttempts);
}
return(result);
}
private IOperationResult ExecuteWithRedirect(IMemcachedNode startNode, ISingleItemOperation op)
{
var result = new BinaryOperationResult();
var opResult = startNode.Execute(op);
if (opResult.Success)
{
return(result.Pass());
}
var iows = op as IOperationWithState;
// different op factory, we do not know how to retry
if (iows == null)
{
result.InnerResult = opResult.InnerResult;
return(result.Fail("Operation state was invalid"));
}
#if HAS_FORWARD_MAP
// node responded with invalid vbucket
// this should happen only when a node is in a transitioning state
if (iows.State == OpState.InvalidVBucket)
{
// check if we have a forward-locator
// (whihc supposedly reflects the state of the cluster when all vbuckets have been migrated succesfully)
IMemcachedNodeLocator fl = this.nsPool.ForwardLocator;
if (fl != null)
{
var nextNode = fl.Locate(op.Key);
if (nextNode != null)
{
// the node accepted the requesta
if (nextNode.Execute(op))
{
return(true);
}
}
}
}
#endif
// still invalid vbucket, try all nodes in sequence
if (iows.State == OperationState.InvalidVBucket)
{
var nodes = this.Pool.GetWorkingNodes();
foreach (var node in nodes)
{
opResult = node.Execute(op);
if (opResult.Success)
{
return(result.Pass());
}
// the node accepted our request so quit
if (iows.State != OperationState.InvalidVBucket)
{
break;
}
}
}
//TODO: why would this happen?
return(result.Fail("Failed to execute operation"));
}
