/// <summary>
        /// Initialize server node with connection parameters.
        /// </summary>
        /// <param name="cluster">collection of active server nodes</param>
        /// <param name="nv">connection parameters</param>
        public Node(Cluster cluster, NodeValidator nv)
        {
            this.cluster           = cluster;
            this.name              = nv.name;
            this.aliases           = nv.aliases;
            this.host              = nv.primaryHost;
            this.address           = nv.primaryAddress;
            this.tendConnection    = nv.primaryConn;
            this.sessionToken      = nv.sessionToken;
            this.sessionExpiration = nv.sessionExpiration;
            this.features          = nv.features;

            connectionPools = new Pool <Connection> [cluster.connPoolsPerNode];
            int max = cluster.connectionQueueSize / cluster.connPoolsPerNode;
            int rem = cluster.connectionQueueSize - (max * cluster.connPoolsPerNode);

            for (int i = 0; i < connectionPools.Length; i++)
            {
                int capacity = i < rem ? max + 1 : max;
                connectionPools[i] = new Pool <Connection>(capacity);
            }

            if (cluster.rackAware)
            {
                this.racks = new Dictionary <string, int>();
            }
            else
            {
                this.racks = null;
            }
        }
        private List <Node> FindNodesToAdd(List <Host> hosts)
        {
            List <Node> list = new List <Node>(hosts.Count);

            foreach (Host host in hosts)
            {
                try
                {
                    NodeValidator nv   = new NodeValidator(this, host);
                    Node          node = FindNode(nv.name, list);

                    if (node != null)
                    {
                        // Duplicate node name found.  This usually occurs when the server
                        // services list contains both internal and external IP addresses
                        // for the same node.  Add new host to list of alias filters
                        // and do not add new node.
                        node.referenceCount++;
                        node.AddAlias(host);
                        aliases[host] = node;
                        continue;
                    }
                    node = CreateNode(nv);
                    list.Add(node);
                }
                catch (Exception e)
                {
                    if (Log.WarnEnabled())
                    {
                        Log.Warn("Add node " + host + " failed: " + Util.GetErrorMessage(e));
                    }
                }
            }
            return(list);
        }
Example #3
0
        protected internal virtual Node CreateNode(NodeValidator nv, bool createMinConn)
        {
            Node node = new Node(this, nv);

            if (createMinConn)
            {
                node.CreateMinConnections();
            }
            return(node);
        }
Example #4
0
        protected internal override Node CreateNode(NodeValidator nv, bool createMinConn)
        {
            AsyncNode node = new AsyncNode(this, nv);

            if (createMinConn)
            {
                node.CreateMinConnections();
            }
            return(node);
        }
        /// <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 Pool <AsyncConnection>(cluster.asyncMinConnsPerNode, cluster.asyncMaxConnsPerNode);

            if (cluster.asyncMinConnsPerNode > 0)
            {
                new AsyncConnectorExecutor(cluster, this, cluster.asyncMinConnsPerNode, 20, true);
            }
        }
        /// <summary>
        /// Initialize server node with connection parameters.
        /// </summary>
        /// <param name="cluster">collection of active server nodes</param>
        /// <param name="nv">connection parameters</param>
        public Node(Cluster cluster, NodeValidator nv)
        {
            this.cluster        = cluster;
            this.name           = nv.name;
            this.aliases        = nv.aliases;
            this.host           = nv.primaryHost;
            this.address        = nv.primaryAddress;
            this.tendConnection = nv.conn;
            this.features       = nv.features;

            connectionQueue = new BlockingCollection <Connection>(cluster.connectionQueueSize);
        }
Example #7
0
        /// <summary>
        /// Initialize server node with connection parameters.
        /// </summary>
        /// <param name="cluster">collection of active server nodes</param>
        /// <param name="nv">connection parameters</param>
        public Node(Cluster cluster, NodeValidator nv)
        {
            this.cluster        = cluster;
            this.name           = nv.name;
            this.aliases        = nv.aliases;
            this.address        = nv.address;
            this.hasReplicasAll = nv.hasReplicasAll;

            // Assign host to first IP alias because the server identifies nodes
            // by IP address (not hostname).
            this.host = aliases[0];

            connectionQueue = new BlockingCollection <Connection>(cluster.connectionQueueSize);
        }
Example #8
0
        /// <summary>
        /// Initialize server node with connection parameters.
        /// </summary>
        /// <param name="cluster">collection of active server nodes</param>
        /// <param name="nv">connection parameters</param>
        public Node(Cluster cluster, NodeValidator nv)
        {
            this.cluster = cluster;
            this.name = nv.name;
            this.aliases = nv.aliases;
            this.address = nv.address;
            this.hasDouble = nv.hasDouble;
            this.hasBatchIndex = nv.hasBatchIndex;
            this.hasReplicasAll = nv.hasReplicasAll;

            // Assign host to first IP alias because the server identifies nodes
            // by IP address (not hostname).
            this.host = aliases[0];

            connectionQueue = new BlockingCollection<Connection>(cluster.connectionQueueSize);
        }
Example #9
0
        private bool PrepareFriend(Host host, Peers peers)
        {
            try
            {
                NodeValidator nv = new NodeValidator();
                nv.ValidateNode(cluster, host);

                // Check for duplicate nodes in nodes slated to be added.
                Node node;
                if (peers.nodes.TryGetValue(nv.name, out node))
                {
                    // Duplicate node name found.  This usually occurs when the server
                    // services list contains both internal and external IP addresses
                    // for the same node.
                    nv.primaryConn.Close();
                    peers.hosts.Add(host);
                    node.aliases.Add(host);
                    return(true);
                }

                // Check for duplicate nodes in cluster.
                if (cluster.nodesMap.TryGetValue(nv.name, out node))
                {
                    nv.primaryConn.Close();
                    peers.hosts.Add(host);
                    node.aliases.Add(host);
                    node.referenceCount++;
                    cluster.aliases[host] = node;
                    return(true);
                }

                node = cluster.CreateNode(nv);
                peers.hosts.Add(host);
                peers.nodes[nv.name] = node;
                return(true);
            }
            catch (Exception e)
            {
                if (Log.WarnEnabled())
                {
                    Log.Warn("Add node " + host + " failed: " + Util.GetErrorMessage(e));
                }
                return(false);
            }
        }
        /// <summary>
        /// Initialize server node with connection parameters.
        /// </summary>
        /// <param name="cluster">collection of active server nodes</param>
        /// <param name="nv">connection parameters</param>
        public Node(Cluster cluster, NodeValidator nv)
        {
            this.cluster        = cluster;
            this.name           = nv.name;
            this.aliases        = nv.aliases;
            this.host           = nv.primaryHost;
            this.address        = nv.primaryAddress;
            this.tendConnection = nv.conn;
            this.features       = nv.features;

            connectionPools = new Pool[cluster.connPoolsPerNode];
            int max = cluster.connectionQueueSize / cluster.connPoolsPerNode;
            int rem = cluster.connectionQueueSize - (max * cluster.connPoolsPerNode);

            for (int i = 0; i < connectionPools.Length; i++)
            {
                int capacity = i < rem ? max + 1 : max;
                connectionPools[i] = new Pool(capacity);
            }
        }
Example #11
0
        /// <summary>
        /// Initialize server node with connection parameters.
        /// </summary>
        /// <param name="cluster">collection of active server nodes</param>
        /// <param name="nv">connection parameters</param>
        public Node(Cluster cluster, NodeValidator nv)
        {
            this.cluster           = cluster;
            this.name              = nv.name;
            this.aliases           = nv.aliases;
            this.host              = nv.primaryHost;
            this.address           = nv.primaryAddress;
            this.tendConnection    = nv.primaryConn;
            this.sessionToken      = nv.sessionToken;
            this.sessionExpiration = nv.sessionExpiration;
            this.features          = nv.features;

            if (cluster.rackAware)
            {
                this.racks = new Dictionary <string, int>();
            }
            else
            {
                this.racks = null;
            }

            connectionPools = new Pool <Connection> [cluster.connPoolsPerNode];
            int min    = cluster.minConnsPerNode / cluster.connPoolsPerNode;
            int remMin = cluster.minConnsPerNode - (min * cluster.connPoolsPerNode);
            int max    = cluster.maxConnsPerNode / cluster.connPoolsPerNode;
            int remMax = cluster.maxConnsPerNode - (max * cluster.connPoolsPerNode);

            for (int i = 0; i < connectionPools.Length; i++)
            {
                int minSize = i < remMin ? min + 1 : min;
                int maxSize = i < remMax ? max + 1 : max;

                Pool <Connection> pool = new Pool <Connection>(minSize, maxSize);
                connectionPools[i] = pool;

                if (minSize > 0)
                {
                    CreateConnections(pool, minSize);
                }
            }
        }
 protected internal virtual Node CreateNode(NodeValidator nv)
 {
     return(new Node(this, nv));
 }
 protected internal override Node CreateNode(NodeValidator nv)
 {
     return new AsyncNode(this, nv);
 }
 /// <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 Pool <AsyncConnection>(cluster.asyncMinConnsPerNode, cluster.asyncMaxConnsPerNode);
 }
        private bool SeedNodes(bool failIfNotConnected)
        {
            // Must copy array reference for copy on write semantics to work.
            Host[]      seedArray  = seeds;
            Exception[] exceptions = null;

            // Add all nodes at once to avoid copying entire array multiple times.
            List <Node> list = new List <Node>();

            for (int i = 0; i < seedArray.Length; i++)
            {
                Host seed = seedArray[i];

                // Check if seed already exists in cluster.
                if (aliases.ContainsKey(seed))
                {
                    continue;
                }

                try
                {
                    NodeValidator nv = new NodeValidator();
                    nv.SeedNodes(this, seed, list);
                }
                catch (Exception e)
                {
                    if (Log.WarnEnabled())
                    {
                        Log.Warn("Seed " + seed + " failed: " + Util.GetErrorMessage(e));
                    }

                    // Store exception and try next host
                    if (failIfNotConnected)
                    {
                        if (exceptions == null)
                        {
                            exceptions = new Exception[seedArray.Length];
                        }
                        exceptions[i] = e;
                    }
                }
            }

            if (list.Count > 0)
            {
                AddNodesCopy(list);
                return(true);
            }
            else if (failIfNotConnected)
            {
                StringBuilder sb = new StringBuilder(500);
                sb.AppendLine("Failed to connect to host(s): ");

                for (int i = 0; i < seedArray.Length; i++)
                {
                    sb.Append(seedArray[i]);
                    sb.Append(' ');

                    Exception ex = exceptions[i];

                    if (ex != null)
                    {
                        sb.AppendLine(ex.Message);
                    }
                }
                throw new AerospikeException.Connection(sb.ToString());
            }
            return(false);
        }
        private bool SeedNodes(bool failIfNotConnected)
        {
            // Must copy array reference for copy on write semantics to work.
            Host[]      seedArray  = seeds;
            Exception[] exceptions = null;

            // Add all nodes at once to avoid copying entire array multiple times.
            List <Node> list = new List <Node>();

            for (int i = 0; i < seedArray.Length; i++)
            {
                Host seed = seedArray[i];

                // Check if seed already exists in cluster.
                if (aliases.ContainsKey(seed))
                {
                    continue;
                }

                try
                {
                    // Try to communicate with seed.
                    NodeValidator seedNodeValidator = new NodeValidator(this, seed);

                    // Seed host may have multiple aliases in the case of round-robin dns configurations.
                    foreach (Host alias in seedNodeValidator.aliases)
                    {
                        NodeValidator nv;

                        if (alias.Equals(seed))
                        {
                            nv = seedNodeValidator;
                        }
                        else
                        {
                            nv = new NodeValidator(this, alias);
                        }

                        if (!FindNodeName(list, nv.name))
                        {
                            Node node = CreateNode(nv);
                            AddAliases(node);
                            list.Add(node);
                        }
                    }
                }
                catch (Exception e)
                {
                    if (Log.WarnEnabled())
                    {
                        Log.Warn("Seed " + seed + " failed: " + Util.GetErrorMessage(e));
                    }

                    // Store exception and try next host
                    if (failIfNotConnected)
                    {
                        if (exceptions == null)
                        {
                            exceptions = new Exception[seedArray.Length];
                        }
                        exceptions[i] = e;
                    }
                }
            }

            if (list.Count > 0)
            {
                AddNodesCopy(list);
                return(true);
            }
            else if (failIfNotConnected)
            {
                StringBuilder sb = new StringBuilder(500);
                sb.AppendLine("Failed to connect to host(s): ");

                for (int i = 0; i < seedArray.Length; i++)
                {
                    sb.Append(seedArray[i]);
                    sb.Append(' ');

                    Exception ex = exceptions[i];

                    if (ex != null)
                    {
                        sb.AppendLine(ex.Message);
                    }
                }
                throw new AerospikeException.Connection(sb.ToString());
            }
            return(false);
        }
Example #17
0
        private bool SeedNode(Peers peers, bool failIfNotConnected)
        {
            // Must copy array reference for copy on write semantics to work.
            Host[]        seedArray  = seeds;
            Exception[]   exceptions = null;
            NodeValidator nv         = new NodeValidator();

            for (int i = 0; i < seedArray.Length; i++)
            {
                Host seed = seedArray[i];

                try
                {
                    Node node = nv.SeedNode(this, seed, peers);

                    if (node != null)
                    {
                        AddNode(node);
                        return(true);
                    }
                }
                catch (Exception e)
                {
                    // Store exception and try next seed.
                    if (failIfNotConnected)
                    {
                        if (exceptions == null)
                        {
                            exceptions = new Exception[seedArray.Length];
                        }
                        exceptions[i] = e;
                    }
                    else
                    {
                        if (Log.WarnEnabled())
                        {
                            Log.Warn("Seed " + seed + " failed: " + Util.GetErrorMessage(e));
                        }
                    }
                }
            }

            // No seeds valid. Use fallback node if it exists.
            if (nv.fallback != null)
            {
                AddNode(nv.fallback);
                return(true);
            }

            if (failIfNotConnected)
            {
                StringBuilder sb = new StringBuilder(500);
                sb.AppendLine("Failed to connect to host(s): ");

                for (int i = 0; i < seedArray.Length; i++)
                {
                    sb.Append(seedArray[i]);
                    sb.Append(' ');

                    Exception ex = exceptions[i];

                    if (ex != null)
                    {
                        sb.AppendLine(ex.Message);
                    }
                }
                throw new AerospikeException.Connection(sb.ToString());
            }
            return(false);
        }
Example #18
0
        private bool SeedNodes(bool failIfNotConnected)
        {
            // Must copy array reference for copy on write semantics to work.
            Host[] seedArray = seeds;
            Exception[] exceptions = null;

            // Add all nodes at once to avoid copying entire array multiple times.
            List<Node> list = new List<Node>();

            for (int i = 0; i < seedArray.Length; i++)
            {
                Host seed = seedArray[i];

                // Check if seed already exists in cluster.
                if (aliases.ContainsKey(seed))
                {
                    continue;
                }

                try
                {
                    // Try to communicate with seed.
                    NodeValidator seedNodeValidator = new NodeValidator(this, seed);

                    // Seed host may have multiple aliases in the case of round-robin dns configurations.
                    foreach (Host alias in seedNodeValidator.aliases)
                    {
                        NodeValidator nv;

                        if (alias.Equals(seed))
                        {
                            nv = seedNodeValidator;
                        }
                        else
                        {
                            nv = new NodeValidator(this, alias);
                        }

                        if (!FindNodeName(list, nv.name))
                        {
                            Node node = CreateNode(nv);
                            AddAliases(node);
                            list.Add(node);
                        }
                    }
                }
                catch (Exception e)
                {
                    if (Log.WarnEnabled())
                    {
                        Log.Warn("Seed " + seed + " failed: " + Util.GetErrorMessage(e));
                    }

                    // Store exception and try next host
                    if (failIfNotConnected)
                    {
                        if (exceptions == null)
                        {
                            exceptions = new Exception[seedArray.Length];
                        }
                        exceptions[i] = e;
                    }
                }
            }

            if (list.Count > 0)
            {
                AddNodesCopy(list);
                return true;
            }
            else if (failIfNotConnected)
            {
                StringBuilder sb = new StringBuilder(500);
                sb.AppendLine("Failed to connect to host(s): ");

                for (int i = 0; i < seedArray.Length; i++)
                {
                    sb.Append(seedArray[i]);
                    sb.Append(' ');

                    Exception ex = exceptions[i];

                    if (ex != null)
                    {
                        sb.AppendLine(ex.Message);
                    }
                }
                throw new AerospikeException.Connection(sb.ToString());
            }
            return false;
        }
Example #19
0
        private bool SeedNodes(bool failIfNotConnected)
        {
            // Must copy array reference for copy on write semantics to work.
            Host[] seedArray = seeds;
            Exception[] exceptions = null;

            // Add all nodes at once to avoid copying entire array multiple times.
            List<Node> list = new List<Node>();

            for (int i = 0; i < seedArray.Length; i++)
            {
                Host seed = seedArray[i];

                // Check if seed already exists in cluster.
                if (aliases.ContainsKey(seed))
                {
                    continue;
                }

                try
                {
                    NodeValidator nv = new NodeValidator();
                    nv.SeedNodes(this, seed, list);
                }
                catch (Exception e)
                {
                    if (Log.WarnEnabled())
                    {
                        Log.Warn("Seed " + seed + " failed: " + Util.GetErrorMessage(e));
                    }

                    // Store exception and try next host
                    if (failIfNotConnected)
                    {
                        if (exceptions == null)
                        {
                            exceptions = new Exception[seedArray.Length];
                        }
                        exceptions[i] = e;
                    }
                }
            }

            if (list.Count > 0)
            {
                AddNodesCopy(list);
                return true;
            }
            else if (failIfNotConnected)
            {
                StringBuilder sb = new StringBuilder(500);
                sb.AppendLine("Failed to connect to host(s): ");

                for (int i = 0; i < seedArray.Length; i++)
                {
                    sb.Append(seedArray[i]);
                    sb.Append(' ');

                    Exception ex = exceptions[i];

                    if (ex != null)
                    {
                        sb.AppendLine(ex.Message);
                    }
                }
                throw new AerospikeException.Connection(sb.ToString());
            }
            return false;
        }
Example #20
0
 protected internal virtual Node CreateNode(NodeValidator nv)
 {
     return new Node(this, nv);
 }
Example #21
0
        private List<Node> FindNodesToAdd(List<Host> hosts)
        {
            List<Node> list = new List<Node>(hosts.Count);

            foreach (Host host in hosts)
            {
                try
                {
                    NodeValidator nv = new NodeValidator(this, host);
                    Node node = FindNode(nv.name, list);

                    if (node != null)
                    {
                        // Duplicate node name found.  This usually occurs when the server
                        // services list contains both internal and external IP addresses
                        // for the same node.  Add new host to list of alias filters
                        // and do not add new node.
                        node.referenceCount++;
                        node.AddAlias(host);
                        aliases[host] = node;
                        continue;
                    }
                    node = CreateNode(nv);
                    list.Add(node);
                }
                catch (Exception e)
                {
                    if (Log.WarnEnabled())
                    {
                        Log.Warn("Add node " + host + " failed: " + Util.GetErrorMessage(e));
                    }
                }
            }
            return list;
        }
Example #22
0
 /// <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 ConcurrentQueue <AsyncConnection>();
 }
Example #23
0
        private bool SeedNode(bool failIfNotConnected)
        {
            // Must copy array reference for copy on write semantics to work.
            Host[]      seedArray  = seeds;
            Exception[] exceptions = null;

            for (int i = 0; i < seedArray.Length; i++)
            {
                Host seed = seedArray[i];

                try
                {
                    NodeValidator nv   = new NodeValidator();
                    Node          node = nv.SeedNode(this, seed);

                    Dictionary <string, Node> nodesToAdd = new Dictionary <string, Node>(1);
                    nodesToAdd[node.Name] = node;
                    AddNodes(nodesToAdd);
                    return(true);
                }
                catch (Exception e)
                {
                    // Store exception and try next seed.
                    if (failIfNotConnected)
                    {
                        if (exceptions == null)
                        {
                            exceptions = new Exception[seedArray.Length];
                        }
                        exceptions[i] = e;
                    }
                    else
                    {
                        if (Log.WarnEnabled())
                        {
                            Log.Warn("Seed " + seed + " failed: " + Util.GetErrorMessage(e));
                        }
                    }
                }
            }

            if (failIfNotConnected)
            {
                StringBuilder sb = new StringBuilder(500);
                sb.AppendLine("Failed to connect to host(s): ");

                for (int i = 0; i < seedArray.Length; i++)
                {
                    sb.Append(seedArray[i]);
                    sb.Append(' ');

                    Exception ex = exceptions[i];

                    if (ex != null)
                    {
                        sb.AppendLine(ex.Message);
                    }
                }
                throw new AerospikeException.Connection(sb.ToString());
            }
            return(false);
        }
Example #24
0
 /// <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 Pool <AsyncConnection>(cluster.maxCommands);
 }
Example #25
0
        protected internal void RefreshPeers(Peers peers)
        {
            // Do not refresh peers when node connection has already failed during this cluster tend iteration.
            if (failures > 0 || !active)
            {
                return;
            }

            try
            {
                if (Log.DebugEnabled())
                {
                    Log.Debug("Update peers for node " + this);
                }

                PeerParser parser = new PeerParser(cluster, tendConnection, peers.peers);
                peersCount = peers.peers.Count;

                bool peersValidated = true;

                foreach (Peer peer in peers.peers)
                {
                    if (FindPeerNode(cluster, peers, peer.nodeName))
                    {
                        // Node already exists. Do not even try to connect to hosts.
                        continue;
                    }

                    bool nodeValidated = false;

                    // Find first host that connects.
                    foreach (Host host in peer.hosts)
                    {
                        try
                        {
                            // Attempt connection to host.
                            NodeValidator nv = new NodeValidator();
                            nv.ValidateNode(cluster, host);

                            if (!peer.nodeName.Equals(nv.name))
                            {
                                // Must look for new node name in the unlikely event that node names do not agree.
                                if (Log.WarnEnabled())
                                {
                                    Log.Warn("Peer node " + peer.nodeName + " is different than actual node " + nv.name + " for host " + host);
                                }

                                if (FindPeerNode(cluster, peers, nv.name))
                                {
                                    // Node already exists. Do not even try to connect to hosts.
                                    nv.primaryConn.Close();
                                    nodeValidated = true;
                                    break;
                                }
                            }

                            // Create new node.
                            Node node = cluster.CreateNode(nv);
                            peers.nodes[nv.name] = node;
                            nodeValidated        = true;
                            break;
                        }
                        catch (Exception e)
                        {
                            if (Log.WarnEnabled())
                            {
                                Log.Warn("Add node " + host + " failed: " + Util.GetErrorMessage(e));
                            }
                        }
                    }

                    if (!nodeValidated)
                    {
                        peersValidated = false;
                    }
                }

                // Only set new peers generation if all referenced peers are added to the cluster.
                if (peersValidated)
                {
                    peersGeneration = parser.generation;
                }
                peers.refreshCount++;
            }
            catch (Exception e)
            {
                RefreshFailed(e);
            }
        }
Example #26
0
 protected internal override Node CreateNode(NodeValidator nv)
 {
     return(new AsyncNode(this, nv));
 }
 /// <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);
 }
Example #28
0
 /// <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);
 }