public Node GetSequenceNode(Cluster cluster, Partition partition) { // Must copy hashmap reference for copy on write semantics to work. Dictionary <string, Node[][]> map = cluster.partitionMap; Node[][] replicaArray; if (map.TryGetValue(partition.ns, out replicaArray)) { for (int i = 0; i < replicaArray.Length; i++) { int index = Math.Abs(sequence % replicaArray.Length); sequence++; Node node = replicaArray[index][partition.partitionId]; if (node != null && node.Active) { return(node); } } } /* * if (Log.debugEnabled()) { * Log.debug("Choose random node for " + partition); * } */ return(cluster.GetRandomNode()); }
public Node GetSequenceNode(Cluster cluster, Partition partition) { // Must copy hashmap reference for copy on write semantics to work. Dictionary <string, Partitions> map = cluster.partitionMap; Partitions partitions; if (!map.TryGetValue(partition.ns, out partitions)) { throw new AerospikeException("Invalid namespace: " + partition.ns); } Node[][] replicas = partitions.replicas; for (int i = 0; i < replicas.Length; i++) { uint index = sequence % (uint)replicas.Length; Node node = replicas[index][partition.partitionId]; if (node != null && node.Active) { return(node); } sequence++; } if (partitions.cpMode) { throw new AerospikeException.InvalidNode(); } return(cluster.GetRandomNode()); }
private void ExecuteCommand(Cluster cluster, AdminPolicy policy) { WriteSize(); Node node = cluster.GetRandomNode(); int timeout = (policy == null) ? 1000 : policy.timeout; Connection conn = node.GetConnection(timeout); try { conn.Write(dataBuffer, dataOffset); conn.ReadFully(dataBuffer, HEADER_SIZE); node.PutConnection(conn); } catch (Exception) { // Garbage may be in socket. Do not put back into pool. node.CloseConnection(conn); throw; } int result = dataBuffer[RESULT_CODE]; if (result != 0) { throw new AerospikeException(result); } }
private void ExecuteQuery(Cluster cluster, AdminPolicy policy) { WriteSize(); Node node = cluster.GetRandomNode(); int timeout = (policy == null) ? 1000 : policy.timeout; int status = 0; Connection conn = node.GetConnection(timeout); try { conn.Write(dataBuffer, dataOffset); status = ReadBlocks(conn); node.PutConnection(conn); } catch (Exception e) { // Garbage may be in socket. Do not put back into pool. node.CloseConnection(conn); throw new AerospikeException(e); } if (status != QUERY_END && status > 0) { throw new AerospikeException(status, "Query failed."); } }
public Node GetNode(Cluster cluster, Policy policy, Partition partition, bool isRead) { // Must copy hashmap reference for copy on write semantics to work. Dictionary <string, Partitions> map = cluster.partitionMap; Partitions partitions; if (!map.TryGetValue(partition.ns, out partitions)) { throw new AerospikeException.InvalidNamespace(partition.ns, map.Count); } if (partitions.cpMode && isRead && !policy.linearizeRead) { // Strong Consistency namespaces always use master node when read policy is sequential. return(cluster.GetMasterNode(partitions, partition)); } // Handle default case first. if (policy.replica == Replica.SEQUENCE) { // Sequence always starts at master, so writes can go through the same algorithm. return(GetSequenceNode(cluster, partitions, partition)); } if (!isRead) { // Writes will always proxy to master node. return(cluster.GetMasterNode(partitions, partition)); } switch (policy.replica) { default: case Replica.MASTER: return(cluster.GetMasterNode(partitions, partition)); case Replica.PREFER_RACK: return(GetRackNode(cluster, partitions, partition)); case Replica.MASTER_PROLES: return(cluster.GetMasterProlesNode(partitions, partition)); case Replica.RANDOM: return(cluster.GetRandomNode()); } }
public Node GetReadNode(Cluster cluster, Partition partition, Replica replica) { switch (replica) { case Replica.MASTER: return(cluster.GetMasterNode(partition)); case Replica.MASTER_PROLES: return(cluster.GetMasterProlesNode(partition)); case Replica.SEQUENCE: return(GetSequenceNode(cluster, partition)); default: case Replica.RANDOM: return(cluster.GetRandomNode()); } }
public Node GetNode(Cluster cluster, Partition partition, Replica replica, bool isRead) { // Handle default case first. if (replica == Replica.SEQUENCE) { return(GetSequenceNode(cluster, partition)); } if (replica == Replica.MASTER || !isRead) { return(cluster.GetMasterNode(partition)); } if (replica == Replica.MASTER_PROLES) { return(cluster.GetMasterProlesNode(partition)); } return(cluster.GetRandomNode()); }
public Node GetSequenceNode(Cluster cluster, Partition partition) { // Must copy hashmap reference for copy on write semantics to work. Dictionary <string, Partitions> map = cluster.partitionMap; Partitions partitions; if (!map.TryGetValue(partition.ns, out partitions)) { // Add these lines StringBuilder sb = new StringBuilder(1000); sb.Append("Invalid namespace: "); sb.Append(partition.ns); sb.Append(" current namespaces: "); foreach (string key in map.Keys) { sb.Append(key); sb.Append(' '); } throw new AerospikeException(sb.ToString()); } Node[][] replicas = partitions.replicas; for (int i = 0; i < replicas.Length; i++) { uint index = sequence % (uint)replicas.Length; Node node = replicas[index][partition.partitionId]; if (node != null && node.Active) { return(node); } sequence++; } if (partitions.cpMode) { throw new AerospikeException.InvalidNode(); } return(cluster.GetRandomNode()); }
public Node GetNodeRead(Cluster cluster) { switch (replica) { default: case Replica.SEQUENCE: return(GetSequenceNode(cluster)); case Replica.PREFER_RACK: return(GetRackNode(cluster)); case Replica.MASTER: return(GetMasterNode(cluster)); case Replica.MASTER_PROLES: return(GetMasterProlesNode(cluster)); case Replica.RANDOM: return(cluster.GetRandomNode()); } }
private static Node GetNode(Cluster cluster, Policy policy, Partition partition, uint sequence) { // Must copy hashmap reference for copy on write semantics to work. Dictionary <string, Partitions> map = cluster.partitionMap; Partitions partitions; if (!map.TryGetValue(partition.ns, out partitions)) { throw new AerospikeException.InvalidNamespace(partition.ns, map.Count); } if (partitions.cpMode && !policy.linearizeRead) { // Strong Consistency namespaces always use master node when read policy is sequential. return(cluster.GetMasterNode(partitions, partition)); } switch (policy.replica) { case Replica.SEQUENCE: return(GetSequenceNode(cluster, partitions, partition, sequence)); case Replica.PREFER_RACK: return(GetRackNode(cluster, partitions, partition, sequence)); default: case Replica.MASTER: return(cluster.GetMasterNode(partitions, partition)); case Replica.MASTER_PROLES: return(cluster.GetMasterProlesNode(partitions, partition)); case Replica.RANDOM: return(cluster.GetRandomNode()); } }
private void ExecuteQuery(Cluster cluster, AdminPolicy policy) { WriteSize(); Node node = cluster.GetRandomNode(); int timeout = (policy == null) ? 1000 : policy.timeout; int status = 0; Connection conn = node.GetConnection(timeout); try { conn.Write(dataBuffer, dataOffset); status = ReadBlocks(conn); node.PutConnection(conn); } catch (Exception e) { // Garbage may be in socket. Do not put back into pool. node.CloseConnection(conn); throw new AerospikeException(e); } if (status != QUERY_END && status > 0) { throw new AerospikeException(status, "Query failed."); } }
public static void Execute ( Cluster cluster, BatchPolicy policy, Key[] keys, bool[] existsArray, Record[] records, string[] binNames, int readAttr ) { if (keys.Length == 0) { return; } if (policy.allowProleReads) { // Send all requests to a single node chosen in round-robin fashion in this transaction thread. Node node = cluster.GetRandomNode(); BatchNode batchNode = new BatchNode(node, keys); ExecuteNode(cluster, batchNode, policy, keys, existsArray, records, binNames, readAttr); return; } List <BatchNode> batchNodes = BatchNode.GenerateList(cluster, policy, keys); if (policy.maxConcurrentThreads == 1 || batchNodes.Count <= 1) { // Run batch requests sequentially in same thread. foreach (BatchNode batchNode in batchNodes) { ExecuteNode(cluster, batchNode, policy, keys, existsArray, records, binNames, readAttr); } } else { // Run batch requests in parallel in separate threads. // // Multiple threads write to the record/exists array, so one might think that // volatile or memory barriers are needed on the write threads and this read thread. // This should not be necessary here because it happens in Executor which does a // volatile write (Interlocked.Increment(ref completedCount)) at the end of write threads // and a synchronized WaitTillComplete() in this thread. Executor executor = new Executor(batchNodes.Count * 2); // Initialize threads. foreach (BatchNode batchNode in batchNodes) { if (records != null) { MultiCommand command = new BatchGetArrayCommand(cluster, executor, batchNode, policy, keys, binNames, records, readAttr); executor.AddCommand(command); } else { MultiCommand command = new BatchExistsArrayCommand(cluster, executor, batchNode, policy, keys, existsArray); executor.AddCommand(command); } } executor.Execute(policy.maxConcurrentThreads); } }
public static void Execute(Cluster cluster, BatchPolicy policy, Key[] keys, bool[] existsArray, Record[] records, HashSet <string> binNames, int readAttr) { if (keys.Length == 0) { return; } if (policy.allowProleReads) { // Send all requests to a single node chosen in round-robin fashion in this transaction thread. Node node = cluster.GetRandomNode(); if (records != null) { BatchCommandNodeGet command = new BatchCommandNodeGet(node, policy, keys, records, binNames, readAttr); command.Execute(); } else { BatchCommandNodeExists command = new BatchCommandNodeExists(node, policy, keys, existsArray); command.Execute(); } return; } List <BatchNode> batchNodes = BatchNode.GenerateList(cluster, policy, keys); if (policy.maxConcurrentThreads == 1) { // Run batch requests sequentially in same thread. foreach (BatchNode batchNode in batchNodes) { foreach (BatchNode.BatchNamespace batchNamespace in batchNode.batchNamespaces) { if (records != null) { BatchCommandGet command = new BatchCommandGet(batchNode.node, batchNamespace, policy, keys, binNames, records, readAttr); command.Execute(); } else { BatchCommandExists command = new BatchCommandExists(batchNode.node, batchNamespace, policy, keys, existsArray); command.Execute(); } } } } else { // Run batch requests in parallel in separate threads. Executor executor = new Executor(batchNodes.Count * 2); // Initialize threads. There may be multiple threads for a single node because the // wire protocol only allows one namespace per command. Multiple namespaces // require multiple threads per node. foreach (BatchNode batchNode in batchNodes) { foreach (BatchNode.BatchNamespace batchNamespace in batchNode.batchNamespaces) { if (records != null) { MultiCommand command = new BatchCommandGet(batchNode.node, batchNamespace, policy, keys, binNames, records, readAttr); executor.AddCommand(command); } else { MultiCommand command = new BatchCommandExists(batchNode.node, batchNamespace, policy, keys, existsArray); executor.AddCommand(command); } } } executor.Execute(policy.maxConcurrentThreads); } }
public static void Execute(Cluster cluster, BatchPolicy policy, Key[] keys, bool[] existsArray, Record[] records, string[] binNames, int readAttr) { if (keys.Length == 0) { return; } if (policy.allowProleReads) { // Send all requests to a single node chosen in round-robin fashion in this transaction thread. Node node = cluster.GetRandomNode(); BatchNode batchNode = new BatchNode(node, keys); ExecuteNode(batchNode, policy, keys, existsArray, records, binNames, readAttr); return; } List<BatchNode> batchNodes = BatchNode.GenerateList(cluster, policy, keys); if (policy.maxConcurrentThreads == 1 || batchNodes.Count <= 1) { // Run batch requests sequentially in same thread. foreach (BatchNode batchNode in batchNodes) { ExecuteNode(batchNode, policy, keys, existsArray, records, binNames, readAttr); } } else { // Run batch requests in parallel in separate threads. // // Multiple threads write to the record/exists array, so one might think that // volatile or memory barriers are needed on the write threads and this read thread. // This should not be necessary here because it happens in Executor which does a // volatile write (Interlocked.Increment(ref completedCount)) at the end of write threads // and a synchronized WaitTillComplete() in this thread. Executor executor = new Executor(batchNodes.Count * 2); // Initialize threads. foreach (BatchNode batchNode in batchNodes) { if (batchNode.node.UseNewBatch(policy)) { // New batch if (records != null) { MultiCommand command = new BatchGetArrayCommand(batchNode, policy, keys, binNames, records, readAttr); executor.AddCommand(command); } else { MultiCommand command = new BatchExistsArrayCommand(batchNode, policy, keys, existsArray); executor.AddCommand(command); } } else { // There may be multiple threads for a single node because the // wire protocol only allows one namespace per command. Multiple namespaces // require multiple threads per node. batchNode.SplitByNamespace(keys); foreach (BatchNode.BatchNamespace batchNamespace in batchNode.batchNamespaces) { if (records != null) { MultiCommand command = new BatchGetArrayDirect(batchNode.node, batchNamespace, policy, keys, binNames, records, readAttr); executor.AddCommand(command); } else { MultiCommand command = new BatchExistsArrayDirect(batchNode.node, batchNamespace, policy, keys, existsArray); executor.AddCommand(command); } } } } executor.Execute(policy.maxConcurrentThreads); } }
private void ExecuteCommand(Cluster cluster, AdminPolicy policy) { WriteSize(); Node node = cluster.GetRandomNode(); int timeout = (policy == null) ? 1000 : policy.timeout; Connection conn = node.GetConnection(timeout); try { conn.Write(dataBuffer, dataOffset); conn.ReadFully(dataBuffer, HEADER_SIZE); node.PutConnection(conn); } catch (Exception) { // Garbage may be in socket. Do not put back into pool. node.CloseConnection(conn); throw; } int result = dataBuffer[RESULT_CODE]; if (result != 0) { throw new AerospikeException(result); } }
public static RegisterTask Register(Cluster cluster, Policy policy, string content, string serverPath, Language language) { StringBuilder sb = new StringBuilder(serverPath.Length + content.Length + 100); sb.Append("udf-put:filename="); sb.Append(serverPath); sb.Append(";content="); sb.Append(content); sb.Append(";content-len="); sb.Append(content.Length); sb.Append(";udf-type="); sb.Append(language); sb.Append(";"); // Send UDF to one node. That node will distribute the UDF to other nodes. string command = sb.ToString(); Node node = cluster.GetRandomNode(); Connection conn = node.GetConnection(policy.timeout); try { Info info = new Info(conn, command); Info.NameValueParser parser = info.GetNameValueParser(); string error = null; string file = null; string line = null; string message = null; while (parser.Next()) { string name = parser.GetName(); if (name.Equals("error")) { error = parser.GetValue(); } else if (name.Equals("file")) { file = parser.GetValue(); } else if (name.Equals("line")) { line = parser.GetValue(); } else if (name.Equals("message")) { message = parser.GetStringBase64(); } } if (error != null) { throw new AerospikeException("Registration failed: " + error + Environment.NewLine + "File: " + file + Environment.NewLine + "Line: " + line + Environment.NewLine + "Message: " + message ); } node.PutConnection(conn); return new RegisterTask(cluster, policy, serverPath); } catch (Exception) { conn.Close(); throw; } }
public static RegisterTask Register(Cluster cluster, Policy policy, string content, string serverPath, Language language) { StringBuilder sb = new StringBuilder(serverPath.Length + content.Length + 100); sb.Append("udf-put:filename="); sb.Append(serverPath); sb.Append(";content="); sb.Append(content); sb.Append(";content-len="); sb.Append(content.Length); sb.Append(";udf-type="); sb.Append(language); sb.Append(";"); // Send UDF to one node. That node will distribute the UDF to other nodes. string command = sb.ToString(); Node node = cluster.GetRandomNode(); Connection conn = node.GetConnection(policy.timeout); try { Info info = new Info(conn, command); Info.NameValueParser parser = info.GetNameValueParser(); string error = null; string file = null; string line = null; string message = null; while (parser.Next()) { string name = parser.GetName(); if (name.Equals("error")) { error = parser.GetValue(); } else if (name.Equals("file")) { file = parser.GetValue(); } else if (name.Equals("line")) { line = parser.GetValue(); } else if (name.Equals("message")) { message = parser.GetStringBase64(); } } if (error != null) { throw new AerospikeException("Registration failed: " + error + Environment.NewLine + "File: " + file + Environment.NewLine + "Line: " + line + Environment.NewLine + "Message: " + message ); } node.PutConnection(conn); return(new RegisterTask(cluster, policy, serverPath)); } catch (Exception) { node.CloseConnection(conn); throw; } }