Task<object> IScriptingCommands.Eval(int db, string script, string[] keyArgs, object[] valueArgs, bool useCache, bool inferStrings, bool queueJump) { if (string.IsNullOrEmpty(script)) throw new ArgumentNullException("script"); var args = new RedisMessage.RedisParameter[ 2 + (keyArgs == null ? 0 : keyArgs.Length) + (valueArgs == null ? 0 : valueArgs.Length)]; args[1] = keyArgs == null ? 0 : keyArgs.Length; int idx = 2; if (keyArgs != null) { for (int i = 0; i < keyArgs.Length; i++) { args[idx++] = keyArgs[i]; } } if (valueArgs != null) { for (int i = 0; i < valueArgs.Length; i++) { args[idx++] = RedisMessage.RedisParameter.Create(valueArgs[i]); } } if (!useCache) { args[0] = script; return ExecuteScript(RedisMessage.Create(db, RedisLiteral.EVAL, args), inferStrings, queueJump); } // note this does a SCRIPT LOAD if it is the first time it is seen on this connection args[0] = GetScriptHash(script); return ExecuteScript(RedisMessage.Create(db, RedisLiteral.EVALSHA, args), inferStrings, queueJump); }
Task <object> IScriptingCommands.Eval(int db, string script, string[] keyArgs, object[] valueArgs, bool useCache, bool inferStrings, bool queueJump) { if (string.IsNullOrEmpty(script)) { throw new ArgumentNullException("script"); } var args = new RedisMessage.RedisParameter[2 + (keyArgs == null ? 0 : keyArgs.Length) + (valueArgs == null ? 0 : valueArgs.Length)]; args[1] = keyArgs == null ? 0 : keyArgs.Length; int idx = 2; if (keyArgs != null) { for (int i = 0; i < keyArgs.Length; i++) { args[idx++] = keyArgs[i]; } } if (valueArgs != null) { for (int i = 0; i < valueArgs.Length; i++) { args[idx++] = RedisMessage.RedisParameter.Create(valueArgs[i]); } } if (!useCache) { args[0] = script; return(ExecuteScript(RedisMessage.Create(db, RedisLiteral.EVAL, args), inferStrings, queueJump)); } // note this does a SCRIPT LOAD if it is the first time it is seen on this connection args[0] = GetScriptHash(script); return(ExecuteScript(RedisMessage.Create(db, RedisLiteral.EVALSHA, args), inferStrings, queueJump)); }
private Task <long> ExecMultiAddRemove(int db, RedisLiteral command, string key, byte[][] values, bool queueJump) { RedisFeatures features; if (values.Length > 1 && ((features = Features) == null || !features.SetVaradicAddRemove)) { RedisTransaction tran = this as RedisTransaction; bool execute = false; if (tran == null) { tran = CreateTransaction(); execute = true; } Task <bool>[] tasks = new Task <bool> [values.Length]; for (int i = 0; i < values.Length; i++) { tasks[i] = ExecuteBoolean(RedisMessage.Create(db, command, key, values[i]), queueJump); } TaskCompletionSource <long> final = new TaskCompletionSource <long>(); tasks[values.Length - 1].ContinueWith(t => { try { if (t.ShouldSetResult(final)) { long count = 0; for (int i = 0; i < tasks.Length; i++) { if (tran.Wait(tasks[i])) { count++; } } final.TrySetResult(count); } } catch (Exception ex) { final.SafeSetException(ex); } }); if (execute) { tran.Execute(queueJump); } return(final.Task); } else { var args = new RedisMessage.RedisParameter[values.Length + 1]; args[0] = key; for (int i = 0; i < values.Length; i++) { args[i + 1] = values[i]; } return(ExecuteInt64(RedisMessage.Create(db, command, args), queueJump)); } }
static RedisMessage GetBlockingPop(int db, RedisLiteral command, string[] keys, int timeoutSeconds) { var args = new RedisMessage.RedisParameter[keys.Length + 1]; for (int i = 0; i < keys.Length; i++) { args[i] = keys[i]; } args[keys.Length] = timeoutSeconds; return(RedisMessage.Create(db, command, args)); }
Task IHashCommands.Set(int db, string key, Dictionary <string, byte[]> values, bool queueJump) { var keyAndFields = new RedisMessage.RedisParameter[(values.Count * 2) + 1]; int index = 0; keyAndFields[index++] = key; foreach (var pair in values) { keyAndFields[index++] = pair.Key; keyAndFields[index++] = pair.Value; } return(ExecuteVoid(RedisMessage.Create(db, RedisLiteral.HMSET, keyAndFields), queueJump)); }
static RedisMessage.RedisParameter[] Parse(Dictionary <string, byte[]> values) { if (values == null) { return(new RedisMessage.RedisParameter[0]); } var arr = new RedisMessage.RedisParameter[values.Count * 2]; int index = 0; foreach (var pair in values) { arr[index++] = pair.Key; arr[index++] = pair.Value; } return(arr); }
internal virtual Task Prepare(string[] scripts) { if (scripts == null) { throw new ArgumentNullException(); } var seenHashes = new HashSet <string>(); List <Tuple <string, string> > fetch = new List <Tuple <string, string> >(scripts.Length); for (int i = 0; i < scripts.Length; i++) { string script = scripts[i]; if (!scriptCache.ContainsKey(script)) { string hash = ComputeHash(script); seenHashes.Add(hash); fetch.Add(Tuple.Create(hash, script)); } } if (fetch.Count == 0) { // no point checking, since we'd still be at the mercy of ad-hoc SCRIPT FLUSH timing return(AlwaysTrue); } RedisMessage.RedisParameter[] args = new RedisMessage.RedisParameter[1 + fetch.Count]; args[0] = RedisLiteral.EXISTS; int idx = 1; foreach (var pair in fetch) { args[idx++] = pair.Item1; // hash } TaskCompletionSource <bool> result = new TaskCompletionSource <bool>(); var state = Tuple.Create(result, this, fetch); ExecuteRaw(RedisMessage.Create(-1, RedisLiteral.SCRIPT, args), false, state).ContinueWith(scriptCompletionCallback); return(result.Task); }
private Task <long> BitOp(int db, RedisLiteral operation, string destination, string[] keys, bool queueJump) { if (keys == null) { throw new ArgumentNullException("keys"); } if (keys.Length == 0) { throw new ArgumentException("keys"); } var args = new RedisMessage.RedisParameter[keys.Length + 2]; args[0] = operation; args[1] = destination; for (int i = 0; i < keys.Length; i++) { args[i + 2] = keys[i]; } return(ExecuteInt64(RedisMessage.Create(db, RedisLiteral.BITOP, args), queueJump)); }
static RedisMessage GetBlockingPop(int db, RedisLiteral command, string[] keys, int timeoutSeconds) { var args = new RedisMessage.RedisParameter[keys.Length + 1]; for (int i = 0; i < keys.Length; i++) args[i] = keys[i]; args[keys.Length] = timeoutSeconds; return RedisMessage.Create(db, command, args); }
internal virtual Task Prepare(string[] scripts) { var result = new TaskCompletionSource <bool>(); if (scripts == null) { throw new ArgumentNullException(); } var seenHashes = new HashSet <string>(); var fetch = new List <Tuple <string, string> >(scripts.Length); for (int i = 0; i < scripts.Length; i++) { string script = scripts[i]; if (!scriptCache.ContainsKey(script)) { string hash = ComputeHash(script); seenHashes.Add(hash); fetch.Add(Tuple.Create(hash, script)); } } if (fetch.Count == 0) { // no point checking, since we'd still be at the mercy of ad-hoc SCRIPT FLUSH timing result.SetResult(true); return(result.Task); // already complete } var args = new RedisMessage.RedisParameter[1 + fetch.Count]; args[0] = RedisLiteral.EXISTS; int idx = 1; foreach (var pair in fetch) { args[idx++] = pair.Item1; // hash } ExecuteRaw(RedisMessage.Create(-1, RedisLiteral.SCRIPT, args), false).ContinueWith(queryTask => { if (Condition.ShouldSetResult(queryTask, result)) { RedisResult[] existResults = queryTask.Result.ValueItems; Task last = null; for (int i = 0; i < existResults.Length; i++) { string hash = fetch[i].Item1, script = fetch[i].Item2; if (existResults[i].ValueInt64 == 0) { // didn't exist last = ExecuteVoid( RedisMessage.Create(-1, RedisLiteral.SCRIPT, RedisLiteral.LOAD, script), true); } // at this point, either it *already* existed, or we've issued a queue-jumping LOAD command, // so all *subsequent* calles can reliably assume that it will exist on the server from now on lock (scriptCache) { scriptCache[script] = hash; } } if (last == null) { // nothing needed result.TrySetResult(true); } else { last.ContinueWith( loadTask => { if (Condition.ShouldSetResult(loadTask, result)) { result.TrySetResult(true); } }); } } }); return(result.Task); }
private Task<long> ExecMultiAddRemove(int db, RedisLiteral command, string key, byte[][] values, bool queueJump) { RedisFeatures features; if (values.Length > 1 && ((features = Features) == null || !features.SetVaradicAddRemove)) { RedisTransaction tran = this as RedisTransaction; bool execute = false; if (tran == null) { tran = CreateTransaction(); execute = true; } Task<bool>[] tasks = new Task<bool>[values.Length]; for (int i = 0; i < values.Length; i++) { tasks[i] = ExecuteBoolean(RedisMessage.Create(db, command, key, values[i]), queueJump); } TaskCompletionSource<long> final = new TaskCompletionSource<long>(); tasks[values.Length - 1].ContinueWith(t => { try { if (t.ShouldSetResult(final)) { long count = 0; for (int i = 0; i < tasks.Length; i++) { if (tran.Wait(tasks[i])) { count++; } } final.TrySetResult(count); } } catch (Exception ex) { final.SafeSetException(ex); } }); if (execute) tran.Execute(queueJump); return final.Task; } else { var args = new RedisMessage.RedisParameter[values.Length + 1]; args[0] = key; for (int i = 0; i < values.Length; i++) { args[i + 1] = values[i]; } return ExecuteInt64(RedisMessage.Create(db, command, args), queueJump); } }
Task IHashCommands.Set(int db, string key, Dictionary<string, byte[]> values, bool queueJump) { var keyAndFields = new RedisMessage.RedisParameter[(values.Count * 2) + 1]; int index = 0; keyAndFields[index++] = key; foreach (var pair in values) { keyAndFields[index++] = pair.Key; keyAndFields[index++] = pair.Value; } return ExecuteVoid(RedisMessage.Create(db, RedisLiteral.HMSET, keyAndFields), queueJump); }
internal virtual Task Prepare(string[] scripts) { var result = new TaskCompletionSource<bool>(); if (scripts == null) throw new ArgumentNullException(); var seenHashes = new HashSet<string>(); var fetch = new List<Tuple<string, string>>(scripts.Length); for (int i = 0; i < scripts.Length; i++) { string script = scripts[i]; if (!scriptCache.ContainsKey(script)) { string hash = ComputeHash(script); seenHashes.Add(hash); fetch.Add(Tuple.Create(hash, script)); } } if (fetch.Count == 0) { // no point checking, since we'd still be at the mercy of ad-hoc SCRIPT FLUSH timing result.SetResult(true); return result.Task; // already complete } var args = new RedisMessage.RedisParameter[1 + fetch.Count]; args[0] = RedisLiteral.EXISTS; int idx = 1; foreach (var pair in fetch) { args[idx++] = pair.Item1; // hash } ExecuteRaw(RedisMessage.Create(-1, RedisLiteral.SCRIPT, args), false).ContinueWith(queryTask => { if (Condition.ShouldSetResult(queryTask, result)) { RedisResult[] existResults = queryTask.Result.ValueItems; Task last = null; for (int i = 0; i < existResults.Length; i++) { string hash = fetch[i].Item1, script = fetch[i].Item2; if (existResults[i].ValueInt64 == 0) { // didn't exist last = ExecuteVoid( RedisMessage.Create(-1, RedisLiteral.SCRIPT, RedisLiteral.LOAD, script), true); } // at this point, either it *already* existed, or we've issued a queue-jumping LOAD command, // so all *subsequent* calles can reliably assume that it will exist on the server from now on lock (scriptCache) { scriptCache[script] = hash; } } if (last == null) { // nothing needed result.TrySetResult(true); } else { last.ContinueWith( loadTask => { if (Condition.ShouldSetResult(loadTask, result)) result.TrySetResult(true); }); } } }); return result.Task; }
static RedisMessage.RedisParameter[] Parse(Dictionary<string, byte[]> values) { if (values == null) return new RedisMessage.RedisParameter[0]; var arr = new RedisMessage.RedisParameter[values.Count * 2]; int index = 0; foreach (var pair in values) { arr[index++] = pair.Key; arr[index++] = pair.Value; } return arr; }
private Task<long> BitOp(int db, RedisLiteral operation, string destination, string[] keys, bool queueJump) { if (keys == null) throw new ArgumentNullException("keys"); if (keys.Length == 0) throw new ArgumentException("keys"); var args = new RedisMessage.RedisParameter[keys.Length + 2]; args[0] = operation; args[1] = destination; for (int i = 0; i < keys.Length; i++) { args[i + 2] = keys[i]; } return ExecuteInt64(RedisMessage.Create(db, RedisLiteral.BITOP, args), queueJump); }