public static void Prepare(TestContext testContext) { Policy policy = new Policy(); policy.timeout = 0; // Do not timeout on index create. IndexTask task = client.CreateIndex(policy, args.ns, args.set, indexName, binName, IndexType.NUMERIC); task.Wait(); }
public ReadHeaderCommand(Cluster cluster, Policy policy, Key key) { this.cluster = cluster; this.policy = policy; this.key = key; this.partition = new Partition(key); }
public static void Prepare(TestContext testContext) { Assembly assembly = Assembly.GetExecutingAssembly(); RegisterTask rtask = client.Register(null, assembly, "Aerospike.Test.Resources.record_example.lua", "record_example.lua", Language.LUA); rtask.Wait(); Policy policy = new Policy(); policy.timeout = 0; // Do not timeout on index create. IndexTask task = client.CreateIndex(policy, args.ns, args.set, indexName, binName, IndexType.STRING, IndexCollectionType.MAPKEYS); task.Wait(); for (int i = 1; i <= size; i++) { Key key = new Key(args.ns, args.set, keyPrefix + i); Dictionary<string, string> map = new Dictionary<string, string>(); map[mapKeyPrefix + 1] = mapValuePrefix + i; if (i % 2 == 0) { map[mapKeyPrefix + 2] = mapValuePrefix + i; } if (i % 3 == 0) { map[mapKeyPrefix + 3] = mapValuePrefix + i; } Bin bin = new Bin(binName, map); client.Put(null, key, bin); } }
public static void Main(string[] args) { var client = Connect(); var policy = new Policy(); var writePolicy = new WritePolicy(); var batchPolicy = new BatchPolicy(); //NOTE: adjust the timeout value depending on your demo machine writePolicy.timeout = 1000; var key = new Key("test", "myset", "mykey"); WriteSingleValue(client, writePolicy, key); CheckKeyExists(client, policy, key); AddSingleValue(client, writePolicy); WriteMultipleValues(client, writePolicy, key); WriteValueWithTtl(client); ReadAllValuesForKey(client, policy, key); ReadSomeValuesForKey(client, policy, key); DeleteValue(client, writePolicy, key); DeleteRecord(client, writePolicy, key); AddRecords(client, writePolicy); BatchReadRecords(client, batchPolicy); MultiOps(client, writePolicy, key); client.Close(); }
public QueryRecordCommand(Node node, Policy policy, Statement statement, RecordSet recordSet) : base(node, true) { this.policy = policy; this.statement = statement; this.recordSet = recordSet; }
public AsyncReadHeader(AsyncCluster cluster, Policy policy, RecordListener listener, Key key) : base(cluster) { this.policy = policy; this.listener = listener; this.key = key; this.partition = new Partition(key); }
public ReadCommand(Cluster cluster, Policy policy, Key key, string[] binNames) { this.cluster = cluster; this.policy = policy; this.key = key; this.partition = new Partition(key); this.binNames = binNames; }
private static void CheckKeyExists(AerospikeClient client, Policy policy, Key key) { Console.WriteLine("Check a record exists"); var exists = client.Exists(policy, key); Console.WriteLine(key + " exists? " + exists); Console.WriteLine(""); }
private void CreateIndex(AerospikeClient client, Arguments args, IndexCollectionType indexType, string indexName, string binName) { console.Info("Create GeoJSON {0} index: ns={1} set={2} index={3} bin={4}", indexType, args.ns, args.set, indexName, binName); Policy policy = new Policy(); policy.timeout = 0; // Do not timeout on index create. IndexTask task = client.CreateIndex(policy, args.ns, args.set, indexName, binName, IndexType.GEO2DSPHERE, indexType); task.Wait(); }
private void CreateIndex(AsyncClient client, Arguments args, string indexName, string binName) { console.Info("Create index: ns=" + args.ns + " set=" + args.set + " index=" + indexName + " bin=" + binName); Policy policy = new Policy(); policy.timeout = 0; // Do not timeout on index create. IndexTask task = client.CreateIndex(policy, args.ns, args.set, indexName, binName, IndexType.NUMERIC); task.Wait(); }
public AsyncRead(AsyncCluster cluster, Policy policy, RecordListener listener, Key key, string[] binNames) : base(cluster) { this.policy = policy; this.listener = listener; this.key = key; this.partition = new Partition(key); this.binNames = binNames; }
private void CreateIndex(AerospikeClient client, Arguments args, string indexName, string binName) { console.Info("Create index: ns={0} set={1} index={2} bin={3}", args.ns, args.set, indexName, binName); Policy policy = new Policy(); policy.timeout = 0; // Do not timeout on index create. IndexTask task = client.CreateIndex(policy, args.ns, args.set, indexName, binName, IndexType.NUMERIC); task.Wait(); }
public static void Prepare(TestContext testContext) { Policy policy = new Policy(); policy.timeout = 0; // Do not timeout on index create. IndexTask task = client.CreateIndex(policy, args.ns, args.set, indexName, binName, IndexType.NUMERIC); task.Wait(); for (int i = 1; i <= size; i++) { Key key = new Key(args.ns, args.set, keyPrefix + i); Bin bin = new Bin(binName, i); client.Put(null, key, bin); } }
public QueryAggregateCommand( Node node, Policy policy, Statement statement, BlockingCollection<object> inputQueue, CancellationToken cancelToken ) : base(node, true) { this.policy = policy; this.statement = statement; this.inputQueue = inputQueue; this.cancelToken = cancelToken; }
protected override void ReadRecord(Policy policy, Key key, string binName) { if (shared.readLatency != null) { Stopwatch watch = Stopwatch.StartNew(); Record record = client.Get(policy, key, binName); double elapsed = watch.Elapsed.TotalMilliseconds; OnReadSuccess(elapsed); } else { Record record = client.Get(policy, key, binName); OnReadSuccess(); } }
public static void Prepare(TestContext testContext) { Assembly assembly = Assembly.GetExecutingAssembly(); RegisterTask rtask = client.Register(null, assembly, "Aerospike.Test.Resources.filter_example.lua", "filter_example.lua", Language.LUA); rtask.Wait(); Policy policy = new Policy(); policy.timeout = 0; // Do not timeout on index create. IndexTask itask = client.CreateIndex(policy, args.ns, args.set, indexName, binName, IndexType.STRING); itask.Wait(); WriteRecord(keyPrefix + 1, "Charlie", "cpass"); WriteRecord(keyPrefix + 2, "Bill", "hknfpkj"); WriteRecord(keyPrefix + 3, "Doug", "dj6554"); }
public static void Prepare(TestContext testContext) { Assembly assembly = Assembly.GetExecutingAssembly(); RegisterTask rtask = client.Register(null, assembly, "Aerospike.Test.Resources.record_example.lua", "record_example.lua", Language.LUA); rtask.Wait(); Policy policy = new Policy(); policy.timeout = 0; // Do not timeout on index create. IndexTask itask = client.CreateIndex(policy, args.ns, args.set, indexName, binName1, IndexType.NUMERIC); itask.Wait(); for (int i = 1; i <= size; i++) { Key key = new Key(args.ns, args.set, keyPrefix + i); client.Put(null, key, new Bin(binName1, i), new Bin(binName2, i)); } }
protected override void ReadRecord(Policy policy, Key key, string binName) { // If timeout occurred, yield thread to back off throttle. // Fail counters are reset every second. if (shared.readTimeoutCount > 0) { Thread.Yield(); } if (shared.readLatency != null) { client.Get(policy, new LatencyReadHandler(this, key), key, binName); } else { client.Get(policy, new ReadHandler(this, key), key, binName); } }
private bool RetryOnInit() { if (complete != 0) { AlreadyCompleted(complete); return(true); } Policy policy = GetPolicy(); if (++iteration > policy.maxRetries) { return(FailOnNetworkInit()); } // Disable sleep between retries. Sleeping in asynchronous mode makes no sense. //if (watch != null && (watch.ElapsedMilliseconds + policy.sleepBetweenRetries) > timeout) if (watch != null && watch.ElapsedMilliseconds > timeout) { // Might as well stop here because the transaction will // timeout after sleep completed. return(FailOnNetworkInit()); } // Prepare for retry. ResetConnection(); // Disable sleep between retries. Sleeping in asynchronous mode makes no sense. //if (policy.sleepBetweenRetries > 0) //{ // Util.Sleep(policy.sleepBetweenRetries); //} // Retry command recursively. ExecuteCommand(); return(true); }
public AsyncBatchExistsArrayDirect( AsyncMultiExecutor parent, AsyncCluster cluster, AsyncNode node, BatchNode.BatchNamespace batch, Policy policy, Key[] keys, bool[] existsArray ) : base(parent, cluster, node, false) { this.batch = batch; this.policy = policy; this.keys = keys; this.existsArray = existsArray; }
/// <summary> /// Initialize task with fields needed to query server nodes. /// </summary> public IndexTask(Cluster cluster, Policy policy, string ns, string indexName) : base(cluster, policy) { this.ns = ns; this.indexName = indexName; }
/// <summary> /// Initialize task with fields needed to query server nodes. /// </summary> public RegisterTask(Cluster cluster, Policy policy, string packageName) : base(cluster, policy) { this.packageName = packageName; }
private void WriteKey(Policy policy, Key key) { // Write key into buffer. if (key.ns != null) { WriteField(key.ns, FieldType.NAMESPACE); } if (key.setName != null) { WriteField(key.setName, FieldType.TABLE); } WriteField(key.digest, FieldType.DIGEST_RIPE); if (policy.sendKey) { WriteField(key.userKey, FieldType.KEY); } }
public void Execute() { Policy policy = GetPolicy(); int remainingMillis = policy.timeout; DateTime limit = DateTime.UtcNow.AddMilliseconds(remainingMillis); Node node = null; Exception exception = null; int failedNodes = 0; int failedConns = 0; int iterations = 0; dataBuffer = ThreadLocalData.GetBuffer(); // Execute command until successful, timed out or maximum iterations have been reached. while (true) { try { node = GetNode(); Connection conn = node.GetConnection(remainingMillis); try { // Set command buffer. WriteBuffer(); // Check if timeout needs to be changed in send buffer. if (remainingMillis != policy.timeout) { // Reset timeout in send buffer (destined for server) and socket. ByteUtil.IntToBytes((uint)remainingMillis, dataBuffer, 22); } // Send command. conn.Write(dataBuffer, dataOffset); // Parse results. ParseResult(conn); // Put connection back in pool. node.PutConnection(conn); // Command has completed successfully. Exit method. return; } catch (AerospikeException ae) { if (ae.KeepConnection()) { // Put connection back in pool. node.PutConnection(conn); } else { // Close socket to flush out possible garbage. Do not put back in pool. node.CloseConnection(conn); } throw; } catch (SocketException se) { // Socket errors are considered temporary anomalies. // Retry after closing connection. node.CloseConnection(conn); exception = se; } catch (Exception) { // All other exceptions are considered fatal. Do not retry. // Close socket to flush out possible garbage. Do not put back in pool. node.CloseConnection(conn); throw; } } catch (AerospikeException.InvalidNode ine) { // Node is currently inactive. Retry. exception = ine; failedNodes++; } catch (AerospikeException.Connection ce) { // Socket connection error has occurred. Retry. exception = ce; failedConns++; } if (++iterations > policy.maxRetries) { break; } // Check for client timeout. if (policy.timeout > 0 && !policy.retryOnTimeout) { // Timeout is absolute. Stop if timeout has been reached. remainingMillis = (int)limit.Subtract(DateTime.UtcNow).TotalMilliseconds - policy.sleepBetweenRetries; if (remainingMillis <= 0) { break; } } if (policy.sleepBetweenRetries > 0) { // Sleep before trying again. Util.Sleep(policy.sleepBetweenRetries); } // Reset node reference and try again. node = null; } // Retries have been exhausted. Throw last exception. if (exception is SocketException && ((SocketException)exception).ErrorCode == (int)SocketError.TimedOut) { throw new AerospikeException.Timeout(node, policy.timeout, iterations, failedNodes, failedConns); } throw exception; }
public ReadCommand(Policy policy, Key key, string[] binNames) { this.policy = policy; this.key = key; this.binNames = binNames; }
public ReadCommand(Key key) { this.policy = null; this.key = key; this.binNames = null; }
public void SetReadHeader(Policy policy, Key key) { Begin(); int fieldCount = EstimateKeySize(policy, key); EstimateOperationSize((string)null); SizeBuffer(); WriteHeader(policy, Command.INFO1_READ | Command.INFO1_NOBINDATA, 0, fieldCount, 0); WriteKey(policy, key); End(); }
public void SetRead(Policy policy, Key key, string[] binNames) { if (binNames != null) { Begin(); int fieldCount = EstimateKeySize(policy, key); foreach (string binName in binNames) { EstimateOperationSize(binName); } SizeBuffer(); WriteHeader(policy, Command.INFO1_READ, 0, fieldCount, binNames.Length); WriteKey(policy, key); foreach (string binName in binNames) { WriteOperation(binName, Operation.Type.READ); } End(); } else { SetRead(policy, key); } }
public void SetRead(Policy policy, Key key) { Begin(); int fieldCount = EstimateKeySize(policy, key); SizeBuffer(); WriteHeader(policy, Command.INFO1_READ | Command.INFO1_GET_ALL, 0, fieldCount, 0); WriteKey(policy, key); End(); }
public void SetExists(Policy policy, Key key) { Begin(); int fieldCount = EstimateKeySize(policy, key); SizeBuffer(); WriteHeader(policy, Command.INFO1_READ | Command.INFO1_NOBINDATA, 0, fieldCount, 0); WriteKey(policy, key); End(); }
public Executor(Cluster cluster, Policy policy, int capacity) { this.cluster = cluster; this.policy = policy; threads = new List<ExecutorThread>(capacity); }
public AsyncBatchExistsSequenceDirect( AsyncMultiExecutor parent, AsyncCluster cluster, AsyncNode node, BatchNode.BatchNamespace batch, Policy policy, Key[] keys, ExistsSequenceListener listener ) : base(parent, cluster, node, false) { this.batch = batch; this.policy = policy; this.keys = keys; this.listener = listener; }
protected internal void SetQuery(Policy policy, Statement statement, bool write) { byte[] functionArgBuffer = null; int fieldCount = 0; int filterSize = 0; int binNameSize = 0; Begin(); if (statement.ns != null) { dataOffset += ByteUtil.EstimateSizeUtf8(statement.ns) + FIELD_HEADER_SIZE; fieldCount++; } if (statement.indexName != null) { dataOffset += ByteUtil.EstimateSizeUtf8(statement.indexName) + FIELD_HEADER_SIZE; fieldCount++; } if (statement.setName != null) { dataOffset += ByteUtil.EstimateSizeUtf8(statement.setName) + FIELD_HEADER_SIZE; fieldCount++; } // Allocate space for TaskId field. dataOffset += 8 + FIELD_HEADER_SIZE; fieldCount++; if (statement.filters != null) { if (statement.filters.Length >= 1) { IndexCollectionType type = statement.filters[0].CollectionType; if (type != IndexCollectionType.DEFAULT) { dataOffset += FIELD_HEADER_SIZE + 1; fieldCount++; } } dataOffset += FIELD_HEADER_SIZE; filterSize++; // num filters foreach (Filter filter in statement.filters) { filterSize += filter.EstimateSize(); } dataOffset += filterSize; fieldCount++; // Query bin names are specified as a field (Scan bin names are specified later as operations) if (statement.binNames != null) { dataOffset += FIELD_HEADER_SIZE; binNameSize++; // num bin names foreach (string binName in statement.binNames) { binNameSize += ByteUtil.EstimateSizeUtf8(binName) + 1; } dataOffset += binNameSize; fieldCount++; } } else { // Calling query with no filters is more efficiently handled by a primary index scan. // Estimate scan options size. dataOffset += 2 + FIELD_HEADER_SIZE; fieldCount++; } if (statement.functionName != null) { dataOffset += FIELD_HEADER_SIZE + 1; // udf type dataOffset += ByteUtil.EstimateSizeUtf8(statement.packageName) + FIELD_HEADER_SIZE; dataOffset += ByteUtil.EstimateSizeUtf8(statement.functionName) + FIELD_HEADER_SIZE; if (statement.functionArgs.Length > 0) { functionArgBuffer = Packer.Pack(statement.functionArgs); } else { functionArgBuffer = new byte[0]; } dataOffset += FIELD_HEADER_SIZE + functionArgBuffer.Length; fieldCount += 4; } if (statement.filters == null) { if (statement.binNames != null) { foreach (string binName in statement.binNames) { EstimateOperationSize(binName); } } } SizeBuffer(); int operationCount = (statement.filters == null && statement.binNames != null) ? statement.binNames.Length : 0; if (write) { WriteHeader((WritePolicy)policy, Command.INFO1_READ, Command.INFO2_WRITE, fieldCount, operationCount); } else { WriteHeader(policy, Command.INFO1_READ, 0, fieldCount, operationCount); } if (statement.ns != null) { WriteField(statement.ns, FieldType.NAMESPACE); } if (statement.indexName != null) { WriteField(statement.indexName, FieldType.INDEX_NAME); } if (statement.setName != null) { WriteField(statement.setName, FieldType.TABLE); } // Write taskId field WriteFieldHeader(8, FieldType.TRAN_ID); ByteUtil.LongToBytes(statement.taskId, dataBuffer, dataOffset); dataOffset += 8; if (statement.filters != null) { if (statement.filters.Length >= 1) { IndexCollectionType type = statement.filters[0].CollectionType; if (type != IndexCollectionType.DEFAULT) { WriteFieldHeader(1, FieldType.INDEX_TYPE); dataBuffer[dataOffset++] = (byte)type; } } WriteFieldHeader(filterSize, FieldType.INDEX_RANGE); dataBuffer[dataOffset++] = (byte)statement.filters.Length; foreach (Filter filter in statement.filters) { dataOffset = filter.Write(dataBuffer, dataOffset); } // Query bin names are specified as a field (Scan bin names are specified later as operations) if (statement.binNames != null) { WriteFieldHeader(binNameSize, FieldType.QUERY_BINLIST); dataBuffer[dataOffset++] = (byte)statement.binNames.Length; foreach (string binName in statement.binNames) { int len = ByteUtil.StringToUtf8(binName, dataBuffer, dataOffset + 1); dataBuffer[dataOffset] = (byte)len; dataOffset += len + 1; } } } else { // Calling query with no filters is more efficiently handled by a primary index scan. WriteFieldHeader(2, FieldType.SCAN_OPTIONS); byte priority = (byte)policy.priority; priority <<= 4; dataBuffer[dataOffset++] = priority; dataBuffer[dataOffset++] = (byte)100; } if (statement.functionName != null) { WriteFieldHeader(1, FieldType.UDF_OP); dataBuffer[dataOffset++] = (statement.returnData) ? (byte)1 : (byte)2; WriteField(statement.packageName, FieldType.UDF_PACKAGE_NAME); WriteField(statement.functionName, FieldType.UDF_FUNCTION); WriteField(functionArgBuffer, FieldType.UDF_ARGLIST); } // Scan bin names are specified after all fields. if (statement.filters == null) { if (statement.binNames != null) { foreach (string binName in statement.binNames) { WriteOperation(binName, Operation.Type.READ); } } } End(); }
public AsyncBatchGetSequenceDirect( AsyncMultiExecutor parent, AsyncCluster cluster, AsyncNode node, BatchNode.BatchNamespace batch, Policy policy, Key[] keys, string[] binNames, RecordSequenceListener listener, int readAttr ) : base(parent, cluster, node, false) { this.batch = batch; this.policy = policy; this.keys = keys; this.binNames = binNames; this.listener = listener; this.readAttr = readAttr; }
private int EstimateKeySize(Policy policy, Key key) { int fieldCount = 0; if (key.ns != null) { dataOffset += ByteUtil.EstimateSizeUtf8(key.ns) + FIELD_HEADER_SIZE; fieldCount++; } if (key.setName != null) { dataOffset += ByteUtil.EstimateSizeUtf8(key.setName) + FIELD_HEADER_SIZE; fieldCount++; } dataOffset += key.digest.Length + FIELD_HEADER_SIZE; fieldCount++; if (policy.sendKey) { dataOffset += key.userKey.EstimateSize() + FIELD_HEADER_SIZE + 1; fieldCount++; } return fieldCount; }
protected internal Arguments() { this.writePolicy = new WritePolicy(); this.policy = new Policy(); }
/// <summary> /// Generic header write. /// </summary> private void WriteHeader(Policy policy, int readAttr, int writeAttr, int fieldCount, int operationCount) { if (policy.consistencyLevel == ConsistencyLevel.CONSISTENCY_ALL) { readAttr |= Command.INFO1_CONSISTENCY_ALL; } dataOffset += 8; // Write all header data except total size which must be written last. dataBuffer[dataOffset++] = MSG_REMAINING_HEADER_SIZE; // Message header length. dataBuffer[dataOffset++] = (byte)readAttr; dataBuffer[dataOffset++] = (byte)writeAttr; for (int i = 0; i < 15; i++) { dataBuffer[dataOffset++] = 0; } dataOffset += ByteUtil.ShortToBytes((ushort)fieldCount, dataBuffer, dataOffset); dataOffset += ByteUtil.ShortToBytes((ushort)operationCount, dataBuffer, dataOffset); }
public ExistsCommand(Policy policy, Key key) { this.policy = policy; this.key = key; }
public AsyncMultiCommand(AsyncMultiExecutor parent, AsyncCluster cluster, Policy policy, AsyncNode node, bool stopOnNotFound) : base(cluster, policy, null, node, true) { this.parent = parent; this.stopOnNotFound = stopOnNotFound; }