/// <summary>
        /// Initializes migration with the connection object
        /// </summary>
        /// <param name="connection">MongoConnection object</param>
        public void Initialize(MongoConnection connection)
        {
            if (connection == null)
                throw new ArgumentNullException("connection");

            Connection = connection;
        }

 internal MongoInsertMessage(
     MongoConnection connection,
     string collectionFullName
 )
     : base(connection, MessageOpcode.Insert) {
     this.collectionFullName = collectionFullName;
 }

        public MongoDbDataTest()
        {
            var connection = new MongoConnection();

            DataContext = new DataContext(typeof(MongoConnection).Assembly);
            DataContext.SetRepositoryCreator(type => Activator.CreateInstance(type, connection));
        }

 protected MongoMessage(
     MongoConnection connection,
     MessageOpcode opcode
 ) {
     this.connection = connection;
     this.opcode = opcode;
 }

        // public methods
        /// <summary>
        /// Authenticates the connection against the given database.
        /// </summary>
        /// <param name="connection">The connection.</param>
        /// <param name="credential">The credential.</param>
        public void Authenticate(MongoConnection connection, MongoCredential credential)
        {
            string nonce;
            try
            {
                var nonceCommand = new CommandDocument("getnonce", 1);
                var nonceResult = RunCommand(connection, credential.Source, nonceCommand);
                nonce = nonceResult.Response["nonce"].AsString;
            }
            catch (MongoCommandException ex)
            {
                throw new MongoAuthenticationException("Error getting nonce for authentication.", ex);
            }

            try
            {
                var passwordDigest = ((PasswordEvidence)credential.Evidence).ComputeMongoCRPasswordDigest(credential.Username);
                var digest = MongoUtils.Hash(nonce + credential.Username + passwordDigest);
                var authenticateCommand = new CommandDocument
                {
                    { "authenticate", 1 },
                    { "user", credential.Username },
                    { "nonce", nonce },
                    { "key", digest }
                };

                RunCommand(connection, credential.Source, authenticateCommand);
            }
            catch (MongoCommandException ex)
            {
                var message = string.Format("Invalid credential for database '{0}'.", credential.Source);
                throw new MongoAuthenticationException(message, ex);
            }
        }

        // public methods
        public WriteConcernResult Execute(MongoConnection connection)
        {
            var serverInstance = connection.ServerInstance;
            if (serverInstance.Supports(FeatureId.WriteCommands) && _args.WriteConcern.Enabled)
            {
                var emulator = new UpdateOpcodeOperationEmulator(_args);
                return emulator.Execute(connection);
            }

            SendMessageWithWriteConcernResult sendMessageResult;
            using (var buffer = new BsonBuffer(new MultiChunkBuffer(BsonChunkPool.Default), true))
            {
                var requests = _args.Requests.ToList();
                if (requests.Count != 1)
                {
                    throw new NotSupportedException("Update opcode only supports a single update request.");
                }
                var updateRequest = (UpdateRequest)requests[0];

                var flags = UpdateFlags.None;
                if (updateRequest.IsMultiUpdate ?? false) { flags |= UpdateFlags.Multi; }
                if (updateRequest.IsUpsert ?? false) { flags |= UpdateFlags.Upsert; }

                var maxDocumentSize = connection.ServerInstance.MaxDocumentSize;
                var query = updateRequest.Query ?? new QueryDocument();

                var message = new MongoUpdateMessage(WriterSettings, CollectionFullName, _args.CheckElementNames, flags, maxDocumentSize, query, updateRequest.Update);
                message.WriteTo(buffer);

                sendMessageResult =  SendMessageWithWriteConcern(connection, buffer, message.RequestId, ReaderSettings, WriterSettings, WriteConcern);
            }

            return WriteConcern.Enabled ? ReadWriteConcernResult(connection, sendMessageResult) : null;
        }

        // public methods
        public BulkWriteResult Execute(MongoConnection connection)
        {
            var serverInstance = connection.ServerInstance;
            if (!serverInstance.Supports(FeatureId.WriteOpcodes))
            {
                throw new NotSupportedException("Write opcodes are not supported.");
            }

            var batchResults = new List<BulkWriteBatchResult>();
            var remainingRequests = new List<WriteRequest>();
            var hasWriteErrors = false;

            var originalIndex = 0;
            foreach (WriteRequest request in _args.Requests)
            {
                if (hasWriteErrors && _args.IsOrdered)
                {
                    remainingRequests.Add(request);
                    continue;
                }

                var batchResult = EmulateSingleRequest(connection, request, originalIndex);
                batchResults.Add(batchResult);

                hasWriteErrors |= batchResult.HasWriteErrors;
                originalIndex++;
            }

            var combiner = new BulkWriteBatchResultCombiner(batchResults, _args.WriteConcern.Enabled);
            return combiner.CreateResultOrThrowIfHasErrors(remainingRequests);
        }

        // public methods
        public virtual BulkWriteResult Execute(MongoConnection connection)
        {
            var batchResults = new List<BulkWriteBatchResult>();
            var remainingRequests = Enumerable.Empty<WriteRequest>();
            var hasWriteErrors = false;

            var decoratedRequests = DecorateRequests(_args.Requests);
            using (var enumerator = decoratedRequests.GetEnumerator())
            {
                var originalIndex = 0;
                Batch<WriteRequest> batch = new FirstBatch<WriteRequest>(enumerator);
                while (batch != null)
                {
                    if (hasWriteErrors && _args.IsOrdered)
                    {
                        remainingRequests = remainingRequests.Concat(batch.RemainingItems);
                        break;
                    }

                    var batchResult = ExecuteBatch(connection, batch, originalIndex);
                    batchResults.Add(batchResult);

                    hasWriteErrors |= batchResult.HasWriteErrors;
                    originalIndex += batchResult.BatchCount;
                    batch = batchResult.NextBatch;
                }
            }

            var combiner = new BulkWriteBatchResultCombiner(batchResults, _args.WriteConcern.Enabled);
            return combiner.CreateResultOrThrowIfHasErrors(remainingRequests);
        }

        // public methods
        public BulkWriteResult Execute(MongoConnection connection)
        {
            var batchResults = new List<BulkWriteBatchResult>();
            var remainingRequests = Enumerable.Empty<WriteRequest>();
            var hasWriteErrors = false;

            var runCount = 0;
            foreach (var run in FindRuns())
            {
                runCount++;

                if (hasWriteErrors && _isOrdered)
                {
                    remainingRequests = remainingRequests.Concat(run.Requests);
                    continue;
                }

                var batchResult = ExecuteBatch(connection, run);
                batchResults.Add(batchResult);

                hasWriteErrors |= batchResult.HasWriteErrors;
            }

            if (runCount == 0)
            {
                throw new InvalidOperationException("Bulk write operation is empty.");
            }

            var combiner = new BulkWriteBatchResultCombiner(batchResults, _writeConcern.Enabled);
            return combiner.CreateResultOrThrowIfHasErrors(remainingRequests);
        }

        public static void ImportToSqlAndMongo(BoardgameSimulatorData data, MongoConnection mongoData, string filePath = "../../../DataSources/xml/")
        {
            if (!Directory.Exists(filePath))
            {
                Console.WriteLine("There are no xml files present in " + filePath + " suitable for importing!");
                return;
            }

            var files = Directory.GetFiles(filePath).Select(x => x).Where(x => Path.GetExtension(x) == ".xml");

            Console.WriteLine("Importing from xml into Sql and MongoDb initialized.");

            foreach (var file in files)
            {
                var heroes = GetHeroes(file);
                var items = GetItems(file);

                Console.WriteLine("importing into sql...");
                AddHeroesToSql(heroes, data);
                AddItemsToSql(items, data);

                Console.WriteLine("importing into mongodb...");
                AddHeroesToMongo(heroes, mongoData);
                AddItemsToMongo(items, mongoData);
            }

            Console.WriteLine("Importing from xml into Sql and MongoDb completed!");
        }

        // public methods
        /// <summary>
        /// Authenticates the connection against the given database.
        /// </summary>
        /// <param name="connection">The connection.</param>
        /// <param name="credential">The credential.</param>
        public void Authenticate(MongoConnection connection, MongoCredential credential)
        {
            var nonceCommand = new CommandDocument("getnonce", 1);
            var commandResult = connection.RunCommand(credential.Source, QueryFlags.None, nonceCommand, false);
            if (!commandResult.Ok)
            {
                throw new MongoAuthenticationException(
                    "Error getting nonce for authentication.",
                    new MongoCommandException(commandResult));
            }

            var nonce = commandResult.Response["nonce"].AsString;
            var passwordDigest = MongoUtils.Hash(credential.Username + ":mongo:" + ((PasswordEvidence)credential.Evidence).Password);
            var digest = MongoUtils.Hash(nonce + credential.Username + passwordDigest);
            var authenticateCommand = new CommandDocument
                {
                    { "authenticate", 1 },
                    { "user", credential.Username },
                    { "nonce", nonce },
                    { "key", digest }
                };

            commandResult = connection.RunCommand(credential.Source, QueryFlags.None, authenticateCommand, false);
            if (!commandResult.Ok)
            {
                var message = string.Format("Invalid credential for database '{0}'.", credential.Source);
                throw new MongoAuthenticationException(
                    message,
                    new MongoCommandException(commandResult));
            }
        }

        /// <summary>
        /// Initializes the mechanism.
        /// </summary>
        /// <param name="connection">The connection.</param>
        /// <param name="credential">The credential.</param>
        /// <returns>The initial step.</returns>
        public ISaslStep Initialize(MongoConnection connection, MongoCredential credential)
        {
            var serviceName = credential.GetMechanismProperty<string>("SERVICE_NAME", "mongodb");
            var canonicalizeHostname = credential.GetMechanismProperty<bool>("CANONICALIZE_HOST_NAME", false);

            var hostname = connection.ServerInstance.Address.Host;
            if (canonicalizeHostname)
            {
                var entry = Dns.GetHostEntry(hostname);
                if (entry != null)
                {
                    hostname = entry.HostName;
                }
            }

            // TODO: provide an override to force the use of gsasl?
            if (__useGsasl)
            {
                return new GsaslGssapiImplementation(
                    serviceName,
                    hostname,
                    credential.Username,
                    credential.Evidence);
            }

            return new WindowsGssapiImplementation(
                serviceName,
                hostname,
                credential.Username,
                credential.Evidence);
        }

 internal MongoKillCursorsMessage(
     MongoConnection connection,
     params long[] cursorIds
 )
     : base(connection, MessageOpcode.KillCursors) {
     this.cursorIds = cursorIds;
 }

        private static void AddItemsToMongo(List<DummyItem> items, MongoConnection mongoData)
        {
            mongoData.Database.DropCollection("items");

            var itemsCollection = new GenericData<DummyItem>(mongoData.Database, "items");

            itemsCollection.Collection.InsertBatch(items);
        }

        private static MongoConnection[] CreateConnectionPool(Int32 count)
        {
            var connections = new MongoConnection[count];

            for (var i = 0; i < count; i++)
                connections[i] = new MongoConnection(Host, Port, Serializer);

            return connections;
        }

 public WriteConcernResult Execute(MongoConnection connection)
 {
     using (var buffer = new BsonBuffer(new MultiChunkBuffer(BsonChunkPool.Default), true))
     {
         var readerSettings = GetNodeAdjustedReaderSettings(connection.ServerInstance);
         var writerSettings = GetNodeAdjustedWriterSettings(connection.ServerInstance);
         var message = new MongoDeleteMessage(writerSettings, CollectionFullName, _flags, _query);
         message.WriteToBuffer(buffer);
         return SendMessageWithWriteConcern(connection, buffer, message.RequestId, readerSettings, writerSettings, WriteConcern);
     }
 }

 internal MongoGetMoreMessage(
     MongoConnection connection,
     string collectionFullName,
     int numberToReturn,
     long cursorId
 )
     : base(connection, MessageOpcode.GetMore) {
     this.collectionFullName = collectionFullName;
     this.numberToReturn = numberToReturn;
     this.cursorId = cursorId;
 }

        /// <summary>
        /// Specifies a MongoConnection to use
        /// </summary>
        /// <param name="connection">MongoConnection object</param>
        public Migrator(MongoConnection connection)
        {
            _connection = connection;
            _migrations = GetType().Assembly.GetTypes()
                .Where(t => !t.IsAbstract && typeof(MigrationBase).IsAssignableFrom(t))
                .Select(t => (MigrationBase)Activator.CreateInstance(t))
                .OrderBy(m => m.Version).ToList();

            foreach (var migration in _migrations)
                migration.Initialize(connection);
        }

 internal MongoQueryMessage(
     MongoConnection connection,
     string collectionFullName,
     QueryFlags flags,
     int numberToSkip,
     int numberToReturn,
     IMongoQuery query,
     IMongoFields fields
 ) :
     this(connection, collectionFullName, flags, numberToSkip, numberToReturn, query, fields, null) {
 }

 internal MongoDeleteMessage(
     MongoConnection connection,
     string collectionFullName,
     RemoveFlags flags,
     IMongoQuery query
 ) :
     base(connection, MessageOpcode.Delete) {
     this.collectionFullName = collectionFullName;
     this.flags = flags;
     this.query = query;
 }