private Queue <String> LoadUnexistentScripts(SocketReader reader, SocketWriter writer)
{
var loadQueue = new Queue <String>();
// read results
var result = RESPObject.Read(reader);
var array = result.Cast <RESPArray>();
// if a script does not exists, send 'script load'
for (int i = 0; i < array.Count; i++)
{
var found = array[i].Cast <RESPInteger>().Value != 0;
if (!found)
{
var digest = _procedures.Digests[i];
_logger.Info("Script with digest {0} not found, loading...", digest);
var load = GenerateLoadCommand(digest);
load.WriteTo(writer);
loadQueue.Enqueue(digest);
}
}
writer.Flush();
return(loadQueue);
}
protected override void ProcessResponse(RESPObject response)
{
if (response == null)
{
if (_current != null)
{
_current.SetCancelled();
_current = null;
}
return;
}
if (_current == null && !_pending.TryDequeue(out _current))
{
throw new InvalidOperationException("Received command response but no token available.");
}
try
{
HandleResponseWithToken(response);
}
catch (OperationCanceledException)
{
_current.SetCancelled();
throw;
}
catch (Exception ex)
{
_current.SetFaulted(ex);
throw;
}
}
internal static Boolean Same(RESPObject item, String comparand)
{
Contract.Assert(item != null, "Item is null");
Contract.Assert(item is RESPString, "Item is not RESPString");
return(Same((RESPString)item, comparand));
}
static void SetValue(String memberName, T instance, RESPObject obj, Setter <T> setter)
{
try
{
switch (obj.Header)
{
case RESPHeaders.Integer:
setter.NumericSetter(instance, obj.GetInt64());
break;
case RESPHeaders.BulkString:
case RESPHeaders.SimpleString:
setter.StringSetter(instance, obj.GetString());
break;
case RESPHeaders.Error:
throw new RedisClientCommandException((RESPError)obj);
default:
throw new RedisClientBindingException("The result includes a member of type '" + obj.GetType().Name + "', but that type cannot be bound to an object member.");
}
}
catch (Exception ex)
{
throw new RedisClientBindingException(String.Format("Cannot set member '{0}'", memberName), ex);
}
}
public void HandleResponse(RESPObject response)
{
Contract.Assert(_tracker != null, "Subscription tracker is not set when calling RemoveChannelOperation.HandleResponse");
Contract.Assert(response != null && response is RESPArray, "SubscriptionOperation cannot handle response: " + (response == null?"Null":response.GetType().Name));
_tracker.Acknowledge((RESPArray)response);
}
private Tuple <ICommandOperation, ISubscriptionOperation, RESPObject[]> Pack <T>(ExecutionPlan plan, T parameters)
where T : class
{
var respCommand = plan.Bind(parameters);
var responsesPlaceholder = new RESPObject[respCommand.Length];
ICommandOperation commandOperation = null;
ISubscriptionOperation subOp = null;
var hasSubscriptions = false;
var hasCommands = false;
IdentifyOperationMainRoute(respCommand, ref hasCommands, ref hasSubscriptions);
if (!hasCommands && !hasSubscriptions)
{
throw new RedisClientParsingException("The given RESP commands do not contain Redis commands.");
}
if (hasCommands)
{
commandOperation = new CommandOperation(respCommand, responsesPlaceholder, _procedures);
}
if (hasSubscriptions)
{
if (_subscriber == null)
{
_subscriber = _subscribers.Provide();
}
subOp = new SubscriptionOperation(this, respCommand, responsesPlaceholder, _subscriber.Subscriptions);
}
return(new Tuple <ICommandOperation, ISubscriptionOperation, RESPObject[]>(commandOperation, subOp, responsesPlaceholder));
}
static String GetPropertyName(RESPObject obj, Int32 index)
{
if (!RESPString.IsString(obj.Header))
{
throw new RedisClientBindingException("Element at index " + index + " must be an string in order to be a member name");
}
return(obj.GetString());
}
internal RedisResultInspector(RESPObject response, Int32 lineNumber)
{
Contract.Assert(response != null, "Result instpector without response object.");
Contract.Assert(lineNumber > 0, "Result inspectors start counting numbers from 1.");
_response = response;
_lineNumber = lineNumber;
RedisType = GetRedisType();
}
public void HandleResponse(RESPObject response)
{
Contract.Assert(_tracker != null, "Subscription tracker is not set when calling RemoveChannelOperation.HandleResponse");
var array = response.Cast <RESPArray>();
_tracker.Acknowledge(array);
IsCompleted = _tracker.IsCompleted;
}
internal static Int64 GetInt64(this RESPObject obj)
{
if (obj.Header == RESPHeaders.Integer)
{
return(((RESPInteger)obj).Value);
}
else
{
throw new RedisClientCastException("Type '" + obj.GetType().Name + "' cannot be cast to 'Int64'");
}
}
internal static String GetString(this RESPObject obj)
{
if (RESPString.IsString(obj.Header))
{
return(obj.ToString());
}
else
{
throw new RedisClientCastException("Type '" + obj.GetType().Name + "' cannot be cast to 'String'");
}
}
internal Boolean IsMessage(RESPObject response, out RESPArray message)
{
message = null;
if (response.Header != RESPHeaders.Array)
{
return(false);
}
message = response.Cast <RESPArray>();
return(IsSubscriptionMessage(message.ElementAt <RESPBulkString>(0).Value.ToUpperInvariant()));
}
private void HandleResponseWithToken(RESPObject response)
{
_current.CommandOperation.HandleResponse(response);
if (_current.CommandOperation.IsCompleted)
{
if (!_current.IsCancelled)
{
_connectionCancellation.Token.ThrowIfCancellationRequested();
_current.SetCompleted();
}
_current = null;
}
}
private void HandleResponseWithToken(RESPObject response)
{
Contract.Assert(_current.SubscriptionOperation != null, "A token without subscription reached the subscriber connection response handler.");
if (!_current.SubscriptionOperation.IsCompleted)
{
_current.SubscriptionOperation.HandleResponse(response);
}
if (_current.SubscriptionOperation.IsCompleted)
{
_current.SetCompleted();
_current = null;
}
}
private void ReadResults(SocketReader reader)
{
foreach (var command in _commands)
{
var response = RESPObject.Read(reader);
_logger.Info(" <- Response for initialization command '{0}' is type '{1}'.", command.Header, response != null ? response.Header.ToString() : "<null>.");
if (response == null)
{
throw new RedisClientSocketException("Initialization command did not return any response.");
}
if (response.Header == RESPHeaders.Error)
{
throw new RedisClientCommandException(response.Cast <RESPError>());
}
}
}
internal static Double AsDouble(this RESPObject obj)
{
if (RESPString.IsString(obj.Header))
{
var val = obj.ToString();
return(String.IsNullOrWhiteSpace(val) ? 0 : Double.Parse(val, RESPObject.FormatInfo));
}
else if (obj.Header == RESPHeaders.Integer)
{
return(((RESPInteger)obj).Value);
}
else
{
throw new RedisClientCastException("Type '" + obj.GetType().Name + "' cannot be formatted as 'Double'");
}
}
internal static TRESP Cast <TRESP>(this RESPObject obj)
where TRESP : RESPObject
{
TRESP value = obj as TRESP;
if (value == null)
{
if (obj.Header == RESPHeaders.Error)
{
throw new RedisClientCommandException((RESPError)obj);
}
throw new RedisClientCastException("Object '" + obj.GetType().Name + "' cannot be casted to '" + typeof(TRESP).Name + "'");
}
return(value);
}
private async Task ReadAsync(SocketReader reader)
{
try
{
while (!_connectionCancellation.IsCancellationRequested)
{
_logger.Debug("{0} listening...", _code);
var resp = await RESPObject.ReadAsync(reader, _connectionCancellation.Token).ConfigureAwait(false);
_logger.Debug("{0} Received response of type {1}.", _code, resp.Header);
RegisterActivity();
ProcessResponse(resp);
}
}
catch (OperationCanceledException) { }
catch (ObjectDisposedException) { }
catch (IOException) { }
}
static int ZipUpResults(RESPObject[] results, Int32 index, RESPObject result)
{
var array = result.Cast <RESPArray>();
results[index] = RESPSimpleString.OK;
index--;
var arrayIndex = array.Count - 1;
while (index >= 0 && arrayIndex >= 0)
{
var element = results[index];
if (RESPString.IsString(element.Header) && RESPString.Same(element, "QUEUED"))
{
results[index] = array[arrayIndex];
arrayIndex--;
}
index--;
}
return(index);
}
private void ValidateScriptLoadingResults(SocketReader reader, Queue <String> loadQueue)
{
// for loaded scripts, read responses and ensure
// returned SHA1 fits the locally calculated one
while (loadQueue.Any())
{
var digest = loadQueue.Dequeue();
var result = RESPObject.Read(reader);
if (result == null)
{
throw new RedisClientParsingException("Cannot read responses.");
}
try
{
var resultDigest = result.Cast <RESPString>().Value;
if (digest != resultDigest)
{
throw new RedisClientParsingException("Script digest differs.");
}
_logger.Info("Script with digest {0} loaded.", digest);
}
catch (RedisClientException rcex)
{
_logger.Error(rcex, "Script with digest {0} failed to load.", digest);
_procedures.SetFaulted(digest, rcex);
}
catch (Exception cmdEx)
{
_logger.Error(cmdEx, "Script with digest {0} failed to load.", digest);
_procedures.SetFaulted(digest, new RedisClientParsingException("Error validating script digest", cmdEx));
}
}
}
public void HandleResponse(RESPObject response)
{
Contract.Assert(response.ToString() == "OK", "DiscardTransactionOperation handler trying to handle a non OK response. ");
IsCompleted = true;
}
internal static String AsString(this RESPObject obj)
{
return(obj.ToString());
}
public void HandleResponse(RESPObject response)
{
Contract.Assert(response.ToString() == "PONG", "PingCommanderOperation handler trying to work out a non-ping response. ");
IsCompleted = true;
}
public void HandleResponse(RESPObject response)
{
_responses[_nextResponse] = response;
PointToNextResponse();
}
protected abstract void ProcessResponse(RESPObject response);
