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 AsyncMultiCommand(AsyncMultiExecutor parent, AsyncCluster cluster, AsyncNode node, bool stopOnNotFound)
: base(cluster)
{
this.parent = parent;
this.fixedNode = node;
this.stopOnNotFound = stopOnNotFound;
}
public AsyncBatchExistsArrayExecutor(
AsyncCluster cluster,
BatchPolicy policy,
Key[] keys,
ExistsArrayListener listener
)
: base(cluster, policy, keys)
{
this.existsArray = new bool[keys.Length];
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 AsyncBatchExistsArrayCommand(this, cluster, batchNode, policy, keys, existsArray);
}
else
{
// Old batch only allows one namespace per call.
foreach (BatchNode.BatchNamespace batchNamespace in batchNode.batchNamespaces)
{
tasks[count++] = new AsyncBatchExistsArrayDirect(this, cluster, (AsyncNode)batchNode.node, batchNamespace, policy, keys, existsArray);
}
}
}
// Dispatch commands to nodes.
Execute(tasks, policy.maxConcurrentThreads);
}
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 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;
}
public AsyncExecute(AsyncCluster cluster, WritePolicy writePolicy, ExecuteListener listener, Key key, string packageName, string functionName, Value[] args)
: base(cluster, writePolicy, null, key, null)
{
this.writePolicy = writePolicy;
this.executeListener = listener;
this.packageName = packageName;
this.functionName = functionName;
this.args = args;
}
public AsyncBatchExistsArrayCommand
(
AsyncMultiExecutor parent,
AsyncCluster cluster,
BatchNode batch,
BatchPolicy batchPolicy,
Key[] keys,
bool[] existsArray
) : base(parent, cluster, batch, batchPolicy)
{
this.keys = keys;
this.existsArray = existsArray;
}
public AsyncBatchReadSequenceCommand
(
AsyncMultiExecutor parent,
AsyncCluster cluster,
BatchNode batch,
BatchPolicy batchPolicy,
BatchSequenceListener listener,
List <BatchRead> records
) : base(parent, cluster, batch, batchPolicy)
{
this.listener = listener;
this.records = records;
}
public AsyncBatchExistsSequenceCommand
(
AsyncMultiExecutor parent,
AsyncCluster cluster,
BatchNode batch,
BatchPolicy batchPolicy,
Key[] keys,
ExistsSequenceListener listener
) : base(parent, cluster, batch, batchPolicy)
{
this.keys = keys;
this.listener = listener;
}
public AsyncBatchReadListCommand
(
AsyncMultiExecutor parent,
AsyncCluster cluster,
BatchNode batch,
BatchPolicy batchPolicy,
List <BatchRead> records
) : base(parent, cluster, batchPolicy, (AsyncNode)batch.node, false)
{
this.batch = batch;
this.batchPolicy = batchPolicy;
this.records = records;
}
public AsyncBatchExistsArrayDirect
(
AsyncMultiExecutor parent,
AsyncCluster cluster,
AsyncNode node,
BatchNode.BatchNamespace batch,
Policy policy,
Key[] keys,
bool[] existsArray
) : base(parent, cluster, policy, node, false)
{
this.batch = batch;
this.keys = keys;
this.existsArray = existsArray;
}
public AsyncBatchExistsSequenceDirect
(
AsyncMultiExecutor parent,
AsyncCluster cluster,
AsyncNode node,
BatchNode.BatchNamespace batch,
Policy policy,
Key[] keys,
ExistsSequenceListener listener
) : base(parent, cluster, policy, node, false)
{
this.batch = batch;
this.keys = keys;
this.listener = listener;
}
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();
}
}
}
/// <summary>
/// Clone constructor.
/// </summary>
public AsyncCommand(AsyncCommand other)
: base(other.socketTimeout, other.totalTimeout, other.maxRetries)
{
// Retry constructor.
this.cluster = other.cluster;
this.policy = other.policy;
this.node = other.node;
this.eventArgs = other.eventArgs;
this.eventArgs.UserToken = this;
this.segmentOrig = other.segmentOrig;
this.segment = other.segment;
this.totalWatch = other.totalWatch;
this.iteration = other.iteration;
this.commandSentCounter = other.commandSentCounter;
}
public AsyncBatchReadSequenceCommand
(
AsyncMultiExecutor parent,
AsyncCluster cluster,
BatchNode batch,
BatchPolicy policy,
BatchSequenceListener listener,
List <BatchRead> records
) : base(parent, cluster, (AsyncNode)batch.node, false)
{
this.batch = batch;
this.policy = policy;
this.listener = listener;
this.records = records;
}
public AsyncBatchExistsArrayCommand
(
AsyncMultiExecutor parent,
AsyncCluster cluster,
BatchNode batch,
BatchPolicy policy,
Key[] keys,
bool[] existsArray
) : base(parent, cluster, (AsyncNode)batch.node, false)
{
this.batch = batch;
this.policy = policy;
this.keys = keys;
this.existsArray = existsArray;
}
public AsyncBatchExistsSequenceCommand
(
AsyncMultiExecutor parent,
AsyncCluster cluster,
BatchNode batch,
BatchPolicy policy,
Key[] keys,
ExistsSequenceListener listener
) : base(parent, cluster, (AsyncNode)batch.node, false)
{
this.batch = batch;
this.policy = policy;
this.keys = keys;
this.listener = listener;
}
public AsyncCommand(AsyncCommand other)
{
// Retry constructor.
this.cluster = other.cluster;
this.policy = other.policy;
this.node = other.node;
this.eventArgs = other.eventArgs;
this.eventArgs.UserToken = this;
this.segmentOrig = other.segmentOrig;
this.segment = other.segment;
this.watch = other.watch;
this.iteration = other.iteration;
this.commandSentCounter = other.commandSentCounter;
this.isRead = other.isRead;
this.usingSocketTimeout = other.usingSocketTimeout;
}
public AsyncBatchExistsArrayExecutor(AsyncCluster cluster, BatchPolicy policy, Key[] keys, ExistsArrayListener listener)
: base(cluster, policy, keys)
{
this.existsArray = new bool[keys.Length];
this.listener = listener;
// Dispatch asynchronous commands to nodes.
foreach (BatchNode batchNode in batchNodes)
{
foreach (BatchNode.BatchNamespace batchNamespace in batchNode.batchNamespaces)
{
AsyncBatchExistsArray async = new AsyncBatchExistsArray(this, cluster, (AsyncNode)batchNode.node, batchNamespace, policy, keys, existsArray);
async.Execute();
}
}
}
public void SetArgs(AsyncCluster cluster, WritePolicy writePolicy, OperateArgs args)
{
base.policy = writePolicy;
this.writePolicy = writePolicy;
this.args = args;
if (args.hasWrite)
{
base.partition = Partition.Write(cluster, writePolicy, key);
}
else
{
base.isRead = true;
base.partition = Partition.Read(cluster, writePolicy, key);
}
}
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 AsyncBatchGetArrayCommand
(
AsyncMultiExecutor parent,
AsyncCluster cluster,
BatchNode batch,
BatchPolicy batchPolicy,
Key[] keys,
string[] binNames,
Record[] records,
int readAttr
) : base(parent, cluster, batch, batchPolicy)
{
this.keys = keys;
this.binNames = binNames;
this.records = records;
this.readAttr = readAttr;
}
public AsyncExecute
(
AsyncCluster cluster,
WritePolicy writePolicy,
ExecuteListener listener,
Key key,
string packageName,
string functionName,
Value[] args
) : base(cluster, writePolicy, key)
{
this.writePolicy = writePolicy;
this.executeListener = listener;
this.packageName = packageName;
this.functionName = functionName;
this.args = args;
}
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;
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(cluster, tasks, policy.maxConcurrentNodes, ns);
}
else
{
Execute(tasks, policy.maxConcurrentNodes);
}
}
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 AsyncBatchGetArray
(
AsyncMultiExecutor parent,
AsyncCluster cluster,
AsyncNode node,
BatchNode.BatchNamespace batch,
Policy policy,
Key[] keys,
HashSet <string> binNames,
Record[] records,
int readAttr
) : base(parent, cluster, node, false, binNames)
{
this.batch = batch;
this.policy = policy;
this.keys = keys;
this.records = records;
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 AsyncBatchExistsSequenceExecutor
(
AsyncCluster cluster,
BatchPolicy policy,
Key[] keys,
ExistsSequenceListener listener
) : 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 AsyncBatchExistsSequenceCommand(this, cluster, batchNode, policy, keys, listener);
}
// Dispatch commands to nodes.
Execute(tasks, 0);
}
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 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 AsyncBatchExistsArrayExecutor
(
AsyncCluster cluster,
BatchPolicy policy,
Key[] keys,
ExistsArrayListener listener
) : base(cluster, policy, keys, true)
{
this.existsArray = new bool[keys.Length];
this.listener = listener;
// Create commands.
AsyncMultiCommand[] tasks = new AsyncMultiCommand[base.taskSize];
int count = 0;
foreach (BatchNode batchNode in batchNodes)
{
tasks[count++] = new AsyncBatchExistsArrayCommand(this, cluster, batchNode, policy, keys, existsArray);
}
// Dispatch commands to nodes.
Execute(tasks, 0);
}
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 AsyncConnectorExecutor
(
AsyncCluster cluster,
AsyncNode node,
int maxConnections,
int maxConcurrent,
bool wait
)
{
this.cluster = cluster;
this.node = node;
this.maxConnections = maxConnections;
this.maxConcurrent = (maxConnections >= maxConcurrent) ? maxConcurrent : maxConnections;
this.wait = wait;
for (int i = 0; i < this.maxConcurrent; i++)
{
try
{
SocketAsyncEventArgs eventArgs = new SocketAsyncEventArgs();
eventArgs.RemoteEndPoint = node.address;
eventArgs.Completed += AsyncConnector.SocketListener;
byte[] dataBuffer = (cluster.user != null) ? new byte[256] : null;
new AsyncConnector(cluster, node, this, eventArgs, dataBuffer);
}
catch (Exception e)
{
OnFailure("Node " + node + " failed to create connection: " + e.Message);
return;
}
}
if (wait)
{
WaitTillComplete();
}
}
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 AsyncBatchReadSequenceExecutor
(
AsyncCluster cluster,
BatchPolicy policy,
BatchSequenceListener listener,
List <BatchRead> records
) : base(cluster, false)
{
this.listener = listener;
// Create commands.
List <BatchNode> batchNodes = BatchNode.GenerateList(cluster, policy, records);
AsyncMultiCommand[] tasks = new AsyncMultiCommand[batchNodes.Count];
int count = 0;
foreach (BatchNode batchNode in batchNodes)
{
tasks[count++] = new AsyncBatchReadSequenceCommand(this, cluster, batchNode, policy, listener, records);
}
// Dispatch commands to nodes.
Execute(tasks, 0);
}
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)
{
tasks[count++] = new AsyncBatchGetSequenceCommand(this, cluster, batchNode, policy, keys, binNames, listener, readAttr);
}
// Dispatch commands to nodes.
Execute(tasks, 0);
}
public AsyncConnection(IPEndPoint address, AsyncCluster cluster)
{
this.maxSocketIdleMillis = (double)(cluster.maxSocketIdleMillis);
try
{
socket = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.NoDelay = true;
// Docs say Blocking flag is ignored for async operations.
// socket.Blocking = false;
// Avoid internal TCP send/receive buffers.
// Use application buffers directly.
socket.SendBufferSize = 0;
socket.ReceiveBufferSize = 0;
timestamp = DateTime.UtcNow;
}
catch (Exception e)
{
throw new AerospikeException.Connection(e);
}
}
public AsyncBatchExistsSequenceCommand(
AsyncMultiExecutor parent,
AsyncCluster cluster,
BatchNode batch,
BatchPolicy policy,
Key[] keys,
ExistsSequenceListener listener
)
: base(parent, cluster, (AsyncNode)batch.node, false)
{
this.batch = batch;
this.policy = policy;
this.keys = keys;
this.listener = listener;
}
public AsyncBatchExistsArrayCommand(
AsyncMultiExecutor parent,
AsyncCluster cluster,
BatchNode batch,
BatchPolicy policy,
Key[] keys,
bool[] existsArray
)
: base(parent, cluster, (AsyncNode)batch.node, false)
{
this.batch = batch;
this.policy = policy;
this.keys = keys;
this.existsArray = existsArray;
}
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;
}
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 AsyncBatchReadSequenceExecutor(
AsyncCluster cluster,
BatchPolicy policy,
BatchSequenceListener listener,
List<BatchRead> records
)
{
this.listener = listener;
// Create commands.
List<BatchNode> batchNodes = BatchNode.GenerateList(cluster, policy, records);
AsyncMultiCommand[] tasks = new AsyncMultiCommand[batchNodes.Count];
int count = 0;
foreach (BatchNode batchNode in batchNodes)
{
if (!batchNode.node.hasBatchIndex)
{
throw new AerospikeException(ResultCode.PARAMETER_ERROR, "Requested command requires a server that supports new batch index protocol.");
}
tasks[count++] = new AsyncBatchReadSequenceCommand(this, cluster, batchNode, policy, listener, records);
}
// Dispatch commands to nodes.
Execute(tasks, policy.maxConcurrentThreads);
}
public AsyncBatchReadSequenceCommand(
AsyncMultiExecutor parent,
AsyncCluster cluster,
BatchNode batch,
BatchPolicy policy,
BatchSequenceListener listener,
List<BatchRead> records
)
: base(parent, cluster, (AsyncNode)batch.node, false)
{
this.batch = batch;
this.policy = policy;
this.listener = listener;
this.records = records;
}
public AsyncSingleCommand(AsyncCluster cluster)
: base(cluster)
{
}
public AsyncOperate(AsyncCluster cluster, WritePolicy policy, RecordListener listener, Key key, Operation[] operations)
: base(cluster, policy, listener, key, null)
{
this.writePolicy = policy;
this.operations = operations;
}
public AsyncCommand(AsyncCluster cluster)
{
this.cluster = cluster;
}
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;
}
public AsyncBatchGetArrayCommand(
AsyncMultiExecutor parent,
AsyncCluster cluster,
BatchNode batch,
BatchPolicy policy,
Key[] keys,
string[] binNames,
Record[] records,
int readAttr
)
: base(parent, cluster, (AsyncNode)batch.node, false)
{
this.batch = batch;
this.policy = policy;
this.keys = keys;
this.binNames = binNames;
this.records = records;
this.readAttr = readAttr;
}
/// <summary>
/// Initialize server node with connection parameters.
/// </summary>
/// <param name="cluster">collection of active server nodes</param>
/// <param name="nv">connection parameters</param>
public AsyncNode(AsyncCluster cluster, NodeValidator nv)
: base(cluster, nv)
{
this.cluster = cluster;
asyncConnQueue = new BlockingCollection<AsyncConnection>(cluster.MaxCommands);
}
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>
/// Initialize asynchronous client with suitable hosts to seed the cluster map.
/// The client policy is used to set defaults and size internal data structures.
/// For each host connection that succeeds, the client will:
/// <list type="bullet">
/// <item>Add host to the cluster map</item>
/// <item>Request host's list of other nodes in cluster</item>
/// <item>Add these nodes to cluster map</item>
/// </list>
/// <para>
/// In most cases, only one host is necessary to seed the cluster. The remaining hosts
/// are added as future seeds in case of a complete network failure.
/// </para>
/// <para>
/// If one connection succeeds, the client is ready to process database requests.
/// If all connections fail and the policy's failIfNotConnected is true, a connection
/// exception will be thrown. Otherwise, the cluster will remain in a disconnected state
/// until the server is activated.
/// </para>
/// </summary>
/// <param name="policy">client configuration parameters, pass in null for defaults</param>
/// <param name="hosts">array of potential hosts to seed the cluster</param>
/// <exception cref="AerospikeException">if all host connections fail</exception>
public AsyncClient(AsyncClientPolicy policy, params Host[] hosts)
: base(policy)
{
if (policy == null)
{
policy = new AsyncClientPolicy();
}
this.cluster = new AsyncCluster(policy, hosts);
base.cluster = this.cluster;
}
