public AsyncBatchGetSequenceExecutor ( AsyncCluster cluster, BatchPolicy policy, RecordSequenceListener listener, Key[] keys, string[] binNames, int readAttr ) : base(cluster, policy, keys) { this.listener = listener; // Create commands. AsyncMultiCommand[] tasks = new AsyncMultiCommand[base.taskSize]; int count = 0; foreach (BatchNode batchNode in batchNodes) { if (batchNode.node.UseNewBatch(policy)) { // New batch tasks[count++] = new AsyncBatchGetSequenceCommand(this, cluster, batchNode, policy, keys, binNames, listener, readAttr); } else { // Old batch only allows one namespace per call. foreach (BatchNode.BatchNamespace batchNamespace in batchNode.batchNamespaces) { tasks[count++] = new AsyncBatchGetSequenceDirect(this, cluster, (AsyncNode)batchNode.node, batchNamespace, policy, keys, binNames, listener, readAttr); } } } // Dispatch commands to nodes. Execute(tasks, policy.maxConcurrentThreads); }
public AsyncBatchGetSequenceExecutor ( AsyncCluster cluster, BatchPolicy policy, RecordSequenceListener listener, Key[] keys, string[] binNames, int readAttr ) { this.listener = listener; // Create commands. List <BatchNode> batchNodes = BatchNode.GenerateList(cluster, policy, keys); AsyncBatchCommand[] commands = new AsyncBatchCommand[batchNodes.Count]; int count = 0; foreach (BatchNode batchNode in batchNodes) { commands[count++] = new AsyncBatchGetSequenceCommand(this, cluster, batchNode, policy, keys, binNames, listener, readAttr); } // Dispatch commands to nodes. Execute(commands); }
public AsyncScanExecutor ( AsyncCluster cluster, ScanPolicy policy, RecordSequenceListener listener, string ns, string setName, string[] binNames ) { this.listener = listener; Node[] nodes = cluster.Nodes; if (nodes.Length == 0) { throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Scan failed because cluster is empty."); } completedSize = nodes.Length; long taskId = Environment.TickCount; foreach (Node node in nodes) { AsyncScan async = new AsyncScan(this, cluster, (AsyncNode)node, policy, listener, ns, setName, binNames, taskId); async.Execute(); } }
public AsyncQueryExecutor ( AsyncCluster cluster, QueryPolicy policy, RecordSequenceListener listener, Statement statement, Node[] nodes ) : base(cluster) { this.listener = listener; statement.Prepare(true); // Create commands. AsyncQuery[] tasks = new AsyncQuery[nodes.Length]; int count = 0; foreach (Node node in nodes) { tasks[count++] = new AsyncQuery(this, cluster, (AsyncNode)node, policy, listener, statement); } // Dispatch commands to nodes. if (policy.failOnClusterChange) { ExecuteValidate(tasks, policy.maxConcurrentNodes, statement.ns); } else { Execute(tasks, policy.maxConcurrentNodes); } }
public AsyncBatchGetSequenceCommand(AsyncBatchGetSequenceCommand other) : base(other) { this.keys = other.keys; this.binNames = other.binNames; this.listener = other.listener; this.readAttr = other.readAttr; }
public AsyncScanExecutor ( AsyncCluster cluster, ScanPolicy policy, RecordSequenceListener listener, string ns, string setName, string[] binNames ) { this.listener = listener; Node[] nodes = cluster.Nodes; if (nodes.Length == 0) { throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Scan failed because cluster is empty."); } ulong taskId = RandomShift.ThreadLocalInstance.NextLong(); // Create commands. AsyncScan[] tasks = new AsyncScan[nodes.Length]; int count = 0; foreach (Node node in nodes) { tasks[count++] = new AsyncScan(this, cluster, (AsyncNode)node, policy, listener, ns, setName, binNames, taskId); } // Dispatch commands to nodes. Execute(tasks, policy.maxConcurrentNodes); }
public AsyncScanExecutor( AsyncCluster cluster, ScanPolicy policy, RecordSequenceListener listener, string ns, string setName, string[] binNames ) { this.listener = listener; Node[] nodes = cluster.Nodes; if (nodes.Length == 0) { throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Scan failed because cluster is empty."); } ulong taskId = RandomShift.ThreadLocalInstance.NextLong(); // Create commands. AsyncScan[] tasks = new AsyncScan[nodes.Length]; int count = 0; foreach (Node node in nodes) { tasks[count++] = new AsyncScan(this, cluster, (AsyncNode)node, policy, listener, ns, setName, binNames, taskId); } // Dispatch commands to nodes. Execute(tasks, policy.maxConcurrentNodes); }
public AsyncQueryExecutor(AsyncCluster cluster, QueryPolicy policy, RecordSequenceListener listener, Statement statement) { this.listener = listener; statement.Prepare(true); Node[] nodes = cluster.Nodes; if (nodes.Length == 0) { throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Query failed because cluster is empty."); } // Create commands. AsyncQuery[] tasks = new AsyncQuery[nodes.Length]; int count = 0; bool hasClusterStable = true; foreach (Node node in nodes) { if (!node.HasClusterStable) { hasClusterStable = false; } tasks[count++] = new AsyncQuery(this, cluster, (AsyncNode)node, policy, listener, statement); } // Dispatch commands to nodes. if (policy.failOnClusterChange && hasClusterStable) { ExecuteValidate(cluster, tasks, policy.maxConcurrentNodes, statement.ns); } else { Execute(tasks, policy.maxConcurrentNodes); } }
public AsyncBatchGetSequenceDirect(AsyncBatchGetSequenceDirect other) : base(other) { this.batch = other.batch; this.keys = other.keys; this.binNames = other.binNames; this.listener = other.listener; this.readAttr = other.readAttr; }
public AsyncQuery ( AsyncMultiExecutor parent, AsyncCluster cluster, AsyncNode node, QueryPolicy policy, RecordSequenceListener listener, Statement statement ) : base(parent, cluster, policy, node, policy.socketTimeout, policy.totalTimeout) { this.listener = listener; this.statement = statement; }
public AsyncQuery ( AsyncMultiExecutor parent, AsyncCluster cluster, AsyncNode node, QueryPolicy queryPolicy, RecordSequenceListener listener, Statement statement ) : base(parent, cluster, queryPolicy, node, true) { this.queryPolicy = queryPolicy; this.listener = listener; this.statement = statement; }
public AsyncQuery( AsyncMultiExecutor parent, AsyncCluster cluster, AsyncNode node, QueryPolicy policy, RecordSequenceListener listener, Statement statement ) : base(parent, cluster, node, true) { this.policy = policy; this.listener = listener; this.statement = statement; }
public AsyncBatchGetSequenceExecutor(AsyncCluster cluster, BatchPolicy policy, RecordSequenceListener listener, Key[] keys, HashSet <string> binNames, int readAttr) : base(cluster, policy, keys) { this.listener = listener; // Dispatch asynchronous commands to nodes. foreach (BatchNode batchNode in batchNodes) { foreach (BatchNode.BatchNamespace batchNamespace in batchNode.batchNamespaces) { AsyncBatchGetSequence async = new AsyncBatchGetSequence(this, cluster, (AsyncNode)batchNode.node, batchNamespace, policy, keys, binNames, listener, readAttr); async.Execute(); } } }
public AsyncQueryPartition ( AsyncMultiExecutor parent, AsyncCluster cluster, QueryPolicy policy, RecordSequenceListener listener, Statement statement, PartitionTracker tracker, NodePartitions nodePartitions ) : base(parent, cluster, policy, (AsyncNode)nodePartitions.node, tracker.socketTimeout, tracker.totalTimeout) { this.listener = listener; this.statement = statement; this.tracker = tracker; this.nodePartitions = nodePartitions; }
public AsyncBatchGetSequenceCommand ( AsyncMultiExecutor parent, AsyncCluster cluster, BatchNode batch, BatchPolicy batchPolicy, Key[] keys, string[] binNames, RecordSequenceListener listener, int readAttr ) : base(parent, cluster, batch, batchPolicy) { this.keys = keys; this.binNames = binNames; this.listener = listener; this.readAttr = readAttr; }
public AsyncQueryPartitionExecutor ( AsyncCluster cluster, QueryPolicy policy, RecordSequenceListener listener, Statement statement, PartitionTracker tracker ) : base(cluster) { this.policy = policy; this.listener = listener; this.statement = statement; this.tracker = tracker; statement.returnData = true; tracker.SleepBetweenRetries = 0; QueryPartitions(); }
public AsyncBatchGetSequence ( AsyncMultiExecutor parent, AsyncCluster cluster, AsyncNode node, BatchNode.BatchNamespace batchNamespace, Policy policy, Key[] keys, HashSet <string> binNames, RecordSequenceListener listener, int readAttr ) : base(parent, cluster, node, false, binNames) { this.batchNamespace = batchNamespace; this.policy = policy; this.keys = keys; this.listener = listener; this.readAttr = readAttr; }
public AsyncBatchGetSequenceDirect ( AsyncMultiExecutor parent, AsyncCluster cluster, AsyncNode node, BatchNode.BatchNamespace batch, Policy policy, Key[] keys, string[] binNames, RecordSequenceListener listener, int readAttr ) : base(parent, cluster, policy, node, false) { this.batch = batch; this.keys = keys; this.binNames = binNames; this.listener = listener; this.readAttr = readAttr; }
public AsyncScan ( AsyncMultiExecutor parent, AsyncCluster cluster, AsyncNode node, ScanPolicy scanPolicy, RecordSequenceListener listener, string ns, string setName, string[] binNames, ulong taskId ) : base(parent, cluster, scanPolicy, node, scanPolicy.socketTimeout, scanPolicy.totalTimeout) { this.scanPolicy = scanPolicy; this.listener = listener; this.ns = ns; this.setName = setName; this.binNamesScan = binNames; this.taskId = taskId; }
public AsyncScan( AsyncMultiExecutor parent, AsyncCluster cluster, AsyncNode node, ScanPolicy policy, RecordSequenceListener listener, string ns, string setName, string[] binNames, ulong taskId ) : base(parent, cluster, node, true) { this.policy = policy; this.listener = listener; this.ns = ns; this.setName = setName; this.binNamesScan = binNames; this.taskId = taskId; }
public AsyncScan ( AsyncMultiExecutor parent, AsyncCluster cluster, AsyncNode node, ScanPolicy policy, RecordSequenceListener listener, string ns, string setName, string[] binNames, long taskId ) : base(parent, cluster, node, true) { this.policy = policy; this.listener = listener; this.ns = ns; this.setName = setName; this.binNamesScan = binNames; this.taskId = taskId; }
public AsyncScanExecutor ( AsyncCluster cluster, ScanPolicy policy, RecordSequenceListener listener, string ns, string setName, string[] binNames, Node[] nodes ) : base(cluster) { this.listener = listener; policy.Validate(); ulong taskId = RandomShift.ThreadLocalInstance.NextLong(); // Create commands. AsyncScan[] tasks = new AsyncScan[nodes.Length]; int count = 0; bool hasClusterStable = true; foreach (Node node in nodes) { if (!node.HasClusterStable) { hasClusterStable = false; } tasks[count++] = new AsyncScan(this, cluster, (AsyncNode)node, policy, listener, ns, setName, binNames, taskId); } // Dispatch commands to nodes. if (policy.failOnClusterChange && hasClusterStable) { ExecuteValidate(tasks, policy.maxConcurrentNodes, ns); } else { Execute(tasks, policy.maxConcurrentNodes); } }
public AsyncScanPartitionExecutor ( AsyncCluster cluster, ScanPolicy policy, RecordSequenceListener listener, string ns, string setName, string[] binNames, PartitionTracker tracker ) : base(cluster) { this.policy = policy; this.listener = listener; this.ns = ns; this.setName = setName; this.binNames = binNames; this.tracker = tracker; policy.Validate(); tracker.SleepBetweenRetries = 0; ScanPartitions(); }
public AsyncQueryExecutor(AsyncCluster cluster, QueryPolicy policy, RecordSequenceListener listener, Statement statement) { this.listener = listener; statement.Prepare(true); Node[] nodes = cluster.Nodes; if (nodes.Length == 0) { throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Query failed because cluster is empty."); } // Create commands. AsyncQuery[] tasks = new AsyncQuery[nodes.Length]; int count = 0; foreach (Node node in nodes) { tasks[count++] = new AsyncQuery(this, cluster, (AsyncNode)node, policy, listener, statement); } // Dispatch commands to nodes. Execute(tasks, policy.maxConcurrentNodes); }
public AsyncBatchGetSequenceExecutor ( AsyncCluster cluster, BatchPolicy policy, RecordSequenceListener listener, Key[] keys, string[] binNames, int readAttr ) : base(cluster, policy, keys, false) { this.listener = listener; // Create commands. AsyncMultiCommand[] tasks = new AsyncMultiCommand[base.taskSize]; int count = 0; foreach (BatchNode batchNode in batchNodes) { tasks[count++] = new AsyncBatchGetSequenceCommand(this, cluster, batchNode, policy, keys, binNames, listener, readAttr); } // Dispatch commands to nodes. Execute(tasks, 0); }
public AsyncScanPartition ( AsyncMultiExecutor executor, AsyncCluster cluster, ScanPolicy scanPolicy, RecordSequenceListener listener, string ns, string setName, string[] binNames, ulong taskId, PartitionTracker tracker, NodePartitions nodePartitions ) : base(executor, cluster, scanPolicy, (AsyncNode)nodePartitions.node, tracker.socketTimeout, tracker.totalTimeout) { this.scanPolicy = scanPolicy; this.listener = listener; this.ns = ns; this.setName = setName; this.binNames = binNames; this.taskId = taskId; this.tracker = tracker; this.nodePartitions = nodePartitions; }
public void Get(Policy policy, RecordSequenceListener listener, Key[] keys) { BatchPolicy batchPolicy = GetAsyncBatchPolicy(policy); Get(batchPolicy, listener, keys); }
//------------------------------------------------------- // Query Operations //------------------------------------------------------- /// <summary> /// Asynchronously execute query on all server nodes. The query policy's /// <code>maxConcurrentNodes</code> dictate how many nodes can be queried in parallel. /// The default is to query all nodes in parallel. /// <para> /// This method schedules the node's query commands with channel selectors and returns. /// Selector threads will process the commands and send the results to the listener. /// </para> /// </summary> /// <param name="policy">query configuration parameters, pass in null for defaults</param> /// <param name="listener">where to send results</param> /// <param name="statement">database query command parameters</param> /// <exception cref="AerospikeException">if query fails</exception> public void Query(QueryPolicy policy, RecordSequenceListener listener, Statement statement) { if (policy == null) { policy = queryPolicyDefault; } new AsyncQueryExecutor(cluster, policy, listener, statement); }
//------------------------------------------------------- // Scan Operations //------------------------------------------------------- /// <summary> /// Asynchronously read all records in specified namespace and set. If the policy's /// concurrentNodes is specified, each server node will be read in /// parallel. Otherwise, server nodes are read in series. /// <para> /// This method schedules the scan command with a channel selector and returns. /// Another thread will process the command and send the results to the listener. /// </para> /// </summary> /// <param name="policy">scan configuration parameters, pass in null for defaults</param> /// <param name="listener">where to send results, pass in null for fire and forget</param> /// <param name="ns">namespace - equivalent to database name</param> /// <param name="setName">optional set name - equivalent to database table</param> /// <param name="binNames"> /// optional bin to retrieve. All bins will be returned if not specified. /// Aerospike 2 servers ignore this parameter. /// </param> /// <exception cref="AerospikeException">if queue is full</exception> public void ScanAll(ScanPolicy policy, RecordSequenceListener listener, string ns, string setName, params string[] binNames) { if (policy == null) { policy = scanPolicyDefault; } new AsyncScanExecutor(cluster, policy, listener, ns, setName, binNames); }
public AsyncBatchGetSequenceExecutor( AsyncCluster cluster, BatchPolicy policy, RecordSequenceListener listener, Key[] keys, string[] binNames, int readAttr ) : base(cluster, policy, keys) { this.listener = listener; // Create commands. AsyncMultiCommand[] tasks = new AsyncMultiCommand[base.taskSize]; int count = 0; foreach (BatchNode batchNode in batchNodes) { if (batchNode.node.UseNewBatch(policy)) { // New batch tasks[count++] = new AsyncBatchGetSequenceCommand(this, cluster, batchNode, policy, keys, binNames, listener, readAttr); } else { // Old batch only allows one namespace per call. foreach (BatchNode.BatchNamespace batchNamespace in batchNode.batchNamespaces) { tasks[count++] = new AsyncBatchGetSequenceDirect(this, cluster, (AsyncNode)batchNode.node, batchNamespace, policy, keys, binNames, listener, readAttr); } } } // Dispatch commands to nodes. Execute(tasks, policy.maxConcurrentThreads); }
public void Get(Policy policy, RecordSequenceListener listener, Key[] keys, params string[] binNames) { BatchPolicy batchPolicy = GetAsyncBatchPolicy(policy); Get(batchPolicy, listener, keys, binNames); }
/// <summary> /// Asynchronously read multiple record headers and bins for specified keys in one batch call. /// Schedule the batch get command with a channel selector and return. /// Another thread will process the command and send the results to the listener in multiple unordered calls. /// <para> /// If a key is not found, the record will be null. /// The policy can be used to specify timeouts. /// </para> /// </summary> /// <param name="policy">generic configuration parameters, pass in null for defaults</param> /// <param name="listener">where to send results</param> /// <param name="keys">array of unique record identifiers</param> /// <param name="binNames">array of bins to retrieve</param> /// <exception cref="AerospikeException">if queue is full</exception> public void Get(BatchPolicy policy, RecordSequenceListener listener, Key[] keys, params string[] binNames) { if (keys.Length == 0) { listener.OnSuccess(); return; } if (policy == null) { policy = batchPolicyDefault; } new AsyncBatchGetSequenceExecutor(cluster, policy, listener, keys, binNames, Command.INFO1_READ); }
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; }
/// <summary> /// Asynchronously read multiple records for specified keys in one batch call. /// Schedule the get command with a channel selector and return. /// Another thread will process the command and send the results to the listener in multiple unordered calls. /// <para> /// If a key is not found, the record will be null. /// The policy can be used to specify timeouts. /// </para> /// </summary> /// <param name="policy">generic configuration parameters, pass in null for defaults</param> /// <param name="listener">where to send results</param> /// <param name="keys">array of unique record identifiers</param> /// <exception cref="AerospikeException">if queue is full</exception> public void Get(BatchPolicy policy, RecordSequenceListener listener, Key[] keys) { if (keys.Length == 0) { listener.OnSuccess(); return; } if (policy == null) { policy = batchPolicyDefault; } new AsyncBatchGetSequenceExecutor(cluster, policy, listener, keys, null, Command.INFO1_READ | Command.INFO1_GET_ALL); }