internal void Connect(
            TimeSpan timeout
        ) {
            server.ClearInstances();

            var exceptions = new List<Exception>();
            foreach (var address in server.Settings.Servers) {
                try {
                    var serverInstance = new MongoServerInstance(server, address);
                    server.AddInstance(serverInstance);
                    try {
                        serverInstance.Connect(server.Settings.SlaveOk); // TODO: what about timeout?
                    } catch {
                        server.RemoveInstance(serverInstance);
                        throw;
                    }

                    return;
                } catch (Exception ex) {
                    exceptions.Add(ex);
                }
            }

            var innerException = exceptions.FirstOrDefault();
            var connectionException = new MongoConnectionException("Unable to connect to server", innerException);
            if (exceptions.Count > 1) {
                connectionException.Data.Add("exceptions", exceptions);
            }
            throw connectionException;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="DirectMongoServerProxy"/> class.
 /// </summary>
 /// <param name="sequentialId">The sequential id.</param>
 /// <param name="serverSettings">The server settings.</param>
 /// <param name="instance">The instance.</param>
 /// <param name="connectionAttempt">The connection attempt.</param>
 public DirectMongoServerProxy(int sequentialId, MongoServerProxySettings serverSettings, MongoServerInstance instance, int connectionAttempt)
 {
     _sequentialId = sequentialId;
     _settings = serverSettings;
     _instance = instance;
     _connectionAttempt = connectionAttempt;
 }

 /// <summary>
 /// Indicates if the instance exists in the chooser.
 /// </summary>
 /// <param name="instance">The instance.</param>
 /// <returns>
 ///   <c>true</c> if [contains] [the specified instance]; otherwise, <c>false</c>.
 /// </returns>
 public bool Contains(MongoServerInstance instance)
 {
     lock (_lock)
     {
         return _instances.Contains(instance);
     }
 }

        internal MongoConnectionPool(
            MongoServerInstance serverInstance
        ) {
            this.server = serverInstance.Server;
            this.serverInstance = serverInstance;

            poolSize = 0;
            timer = new Timer(TimerCallback, null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(10));
        }

        // constructors
        internal MongoConnectionPool(MongoServerInstance serverInstance)
        {
            _server = serverInstance.Server;
            _serverInstance = serverInstance;
            _poolSize = 0;

            var dueTime = TimeSpan.FromSeconds(0);
            var period = TimeSpan.FromSeconds(10);
            _timer = new Timer(TimerCallback, null, dueTime, period);
        }

 /// <summary>
 /// Gets a list of primary and secondary instances.
 /// </summary>
 /// <param name="primary">The current primary.</param>
 /// <returns>The list of primary and secondary instances.</returns>
 public List<InstanceWithPingTime> GetPrimaryAndSecondaries(MongoServerInstance primary)
 {
     lock (_connectedInstancesLock)
     {
         // note: make copies of InstanceWithPingTime values because they can change after we return
         return _instances
             .Where(x => x.Instance == primary || x.Instance.IsSecondary)
             .Select(x => new InstanceWithPingTime { Instance = x.Instance, CachedAveragePingTime = x.CachedAveragePingTime })
             .ToList();
     }
 }

        // constructors
        internal MongoConnectionPool(MongoServerInstance serverInstance)
        {
            _settings = serverInstance.Settings;
            _serverInstance = serverInstance;
            _poolSize = 0;

            _defaultAcquireConnectionOptions = new AcquireConnectionOptions
            {
                OkToAvoidWaitingByCreatingNewConnection = true,
                OkToExceedMaxConnectionPoolSize = false,
                OkToExceedWaitQueueSize = false,
                WaitQueueTimeout = _settings.WaitQueueTimeout
            };
        }

 // public methods
 /// <summary>
 /// Adds the specified instance.
 /// </summary>
 /// <param name="instance">The instance.</param>
 public void Add(MongoServerInstance instance)
 {
     lock (_lock)
     {
         var index = _instances.FindIndex(x => x.AveragePingTime >= instance.AveragePingTime);
         if (index == -1)
         {
             _instances.Add(instance);
         }
         else
         {
             _instances.Insert(index + 1, instance);
         }
         instance.AveragePingTimeChanged += InstanceAveragePingTimeChanged;
     }
 }

 /// <summary>
 /// Determines whether the instance is a valid.  If not, the instance is removed.
 /// </summary>
 /// <param name="instance">The instance.</param>
 /// <returns>
 ///   <c>true</c> if the instance is valid; otherwise, <c>false</c>.
 /// </returns>
 protected abstract bool IsValidInstance(MongoServerInstance instance);

 /// <summary>
 /// Determines whether the instance is a valid.  If not, the instance is removed.
 /// </summary>
 /// <param name="instance">The instance.</param>
 /// <returns>
 ///   <c>true</c> if the instance is valid; otherwise, <c>false</c>.
 /// </returns>
 protected override bool IsValidInstance(MongoServerInstance instance)
 {
     return instance.InstanceType == MongoServerInstanceType.ShardRouter;
 }

        /// <summary>
        /// Ensures that an instance with the address exists.
        /// </summary>
        /// <param name="address">The address.</param>
        protected void EnsureInstanceWithAddress(MongoServerAddress address)
        {
            if (address == null)
            {
                throw new ArgumentNullException("address");
            }

            lock (_lock)
            {
                if (!_instances.Any(x => x.Address == address))
                {
                    var instance = new MongoServerInstance(_server, address);
                    AddInstance(instance);
                    if (_state != MongoServerState.Disconnecting && _state != MongoServerState.Disconnected)
                    {
                        _state = MongoServerState.Connecting;
                        ConnectInstance(instance);
                    }
                }
            }
        }

 private void ProcessConnectedSecondaryStateChange(MongoServerInstance instance)
 {
     var address = instance.ReplicaSetInformation.Primary;
     if (address != null)
     {
         // make sure the primary exists in the instance list
         EnsureInstanceWithAddress(address);
     }
 }

        private void ProcessInstanceStateChange(MongoServerInstance instance)
        {
            lock (_lock)
            {
                if (instance.State == MongoServerState.Connected && _instances.Contains(instance))
                {
                    if (!IsValidInstance(instance))
                    {
                        RemoveInstance(instance);
                        // TODO: log this...
                        return;
                    }

                    if (instance.IsMasterResult.MyAddress != null && instance.Address != instance.IsMasterResult.MyAddress)
                    {
                        // NOTE: if this gets set inside the MongoServerInstance, then there is a race condition that could cause
                        // the instance to get added more than once to the list because the changes occur under different locks.
                        // I don't like this and would rather it be in the MongoServerInstance, but haven't figured out how to do
                        // it yet.
                        // One solution is for every instance change to check to see if two instances exist in the list and remove
                        // the other one, as the current one is more up-to-date.
                        instance.Address = instance.IsMasterResult.MyAddress;
                    }

                    if (!_connectedInstances.Contains(instance))
                    {
                        _connectedInstances.Add(instance);
                    }

                    ProcessConnectedInstanceStateChange(instance);
                }
                else
                {
                    _connectedInstances.Remove(instance);
                }

                SetState(DetermineServerState(_state, _instances));
            }
        }

 private void ConnectInstance(MongoServerInstance instance)
 {
     Interlocked.Increment(ref _outstandingInstanceConnections);
     ThreadPool.QueueUserWorkItem(_ =>
     {
         try
         {
             instance.Connect();
         }
         catch
         {
             // instance is keeping it's last ConnectionException
         }
         finally
         {
             Interlocked.Decrement(ref _outstandingInstanceConnections);
         }
     });
 }

 private void RemoveInstance(MongoServerInstance instance)
 {
     _connectedInstances.Remove(instance);
     lock (_lock)
     {
         _instances.Remove(instance);
         instance.StateChanged -= InstanceStateChanged;
         instance.DisconnectPermanently();
         ProcessInstanceStateChange(instance);
     }
 }

 /// <summary>
 /// Processes the connected instance state change.
 /// </summary>
 /// <param name="instance">The instance.</param>
 protected override void ProcessConnectedInstanceStateChange(MongoServerInstance instance)
 {
     if (instance.IsPrimary)
     {
         ProcessConnectedPrimaryStateChange(instance);
     }
     else
     {
         ProcessConnectedSecondaryStateChange(instance);
     }
 }

 private void QueueConnect(MongoServerInstance serverInstance)
 {
     var args = new ConnectArgs
     {
         ServerInstance = serverInstance,
         ResponseQueue = _responseQueue
     };
     ThreadPool.QueueUserWorkItem(ConnectWorkItem, args);
     _connects.Add(args);
 }

 // constructors
 /// <summary>
 /// Initializes a new instance of the <see cref="DirectMongoServerProxy"/> class.
 /// </summary>
 /// <param name="settings">The settings.</param>
 public DirectMongoServerProxy(MongoServerSettings settings)
 {
     _settings = settings;
     _instance = new MongoServerInstance(settings, settings.Servers.First());
 }

        private void CreateActualProxy(MongoServerInstance instance, BlockingQueue<MongoServerInstance> connectionQueue)
        {
            lock (_lock)
            {
                if (instance.InstanceType == MongoServerInstanceType.ReplicaSetMember)
                {
                    _serverProxy = new ReplicaSetMongoServerProxy(_settings, _instances, connectionQueue, _connectionAttempt);
                }
                else if (instance.InstanceType == MongoServerInstanceType.ShardRouter)
                {
                    _serverProxy = new ShardedMongoServerProxy(_settings, _instances, connectionQueue, _connectionAttempt);
                }
                else if (instance.InstanceType == MongoServerInstanceType.StandAlone)
                {
                    var otherInstances = _instances.Where(x => x != instance).ToList();
                    foreach (var otherInstance in otherInstances)
                    {
                        otherInstance.Disconnect();
                    }

                    _serverProxy = new DirectMongoServerProxy(_settings, instance, _connectionAttempt);
                }
                else
                {
                    throw new MongoConnectionException("The type of servers in the host list could not be determined.");
                }
            }
        }

        private void ProcessInstanceStateChange(MongoServerInstance instance)
        {
            List<MongoServerInstance> currentInstances;
            MongoServerState currentState;

            lock (_lock)
            {
                currentInstances = _instances;
                currentState = _state;
            }

            if (currentInstances.Contains(instance))
            {
                if (instance.State == MongoServerState.Connected)
                {
                    if (!IsValidInstance(instance))
                    {
                        RemoveInstance(instance);
                        return;
                    }

                    if (currentState != MongoServerState.Disconnecting && currentState != MongoServerState.Disconnected)
                    {
                        _connectedInstances.EnsureContains(instance);
                        ProcessConnectedInstanceStateChange(instance);
                    }
                }
                else
                {
                    _connectedInstances.Remove(instance);
                }
            }

            SetState(DetermineServerState(currentState, currentInstances));
        }