CSHARP-589: Refactor some logic from MongoCollection and other classes into a set of Operations classes.

Author: rstam

MongoDB.Driver/CanCommandBeSentToSecondary.cs

@@ -0,0 +1,93 @@
+/* Copyright 2010-2013 10gen Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using MongoDB.Bson;
+using MongoDB.Driver.Internal;
+
+namespace MongoDB.Driver
+{
+    /// <summary>
+    /// Represents a container for the CanCommandBeSentToSecondary delegate.
+    /// </summary>
+    public static class CanCommandBeSentToSecondary
+    {
+        // private static fields
+        private static Func<BsonDocument, bool> __delegate = DefaultImplementation;
+        private static HashSet<string> __secondaryOkCommands = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase)
+        {
+            "group",
+            "aggregate",
+            "collStats",
+            "dbStats",
+            "count",
+            "distinct",
+            "geoNear",
+            "geoSearch",
+            "geoWalk"
+        };
+
+        // public static properties
+        /// <summary>
+        /// Gets or sets the CanCommandBeSentToSecondary delegate.
+        /// </summary>
+        public static Func<BsonDocument, bool> Delegate
+        {
+            get { return __delegate; }
+            set
+            {
+                if (value == null)
+                {
+                    throw new ArgumentNullException("value");
+                }
+                __delegate = value;
+            }
+        }
+
+        // public static methods
+        /// <summary>
+        /// Default implementation of the CanCommandBeSentToSecondary delegate.
+        /// </summary>
+        /// <param name="document">The command.</param>
+        /// <returns>True if the command can be sent to a secondary member of a replica set.</returns>
+        public static bool DefaultImplementation(BsonDocument document)
+        {
+            if (document.ElementCount == 0)
+            {
+                return false;
+            }
+
+            var commandName = document.GetElement(0).Name;
+
+            if (__secondaryOkCommands.Contains(commandName))
+            {
+                return true;
+            }
+
+            if (commandName.Equals("mapreduce", StringComparison.InvariantCultureIgnoreCase))
+            {
+                BsonValue outValue;
+                if (document.TryGetValue("out", out outValue) && outValue.IsBsonDocument)
+                {
+                    return outValue.AsBsonDocument.Contains("inline");
+                }
+            }
+
+            return false;
+        }
+    }
+}

MongoDB.Driver/Communication/MongoConnection.cs

@@ -19,10 +19,8 @@
 using System.Net.Sockets;
 using System.Security.Authentication;
 using System.Security.Cryptography.X509Certificates;
-using MongoDB.Bson;
 using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
-using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver.Communication.Security;
 
 namespace MongoDB.Driver.Internal
@@ -242,63 +240,6 @@ internal void Open()
                 .Authenticate();
         }
 
-        // this is a low level method that doesn't require a MongoServer
-        // so it can be used while connecting to a MongoServer
-        internal TCommandResult RunCommandAs<TCommandResult>(
-            string databaseName,
-            QueryFlags queryFlags,
-            CommandDocument command,
-            bool throwOnError) where TCommandResult : CommandResult
-        {
-            var commandResultSerializer = BsonSerializer.LookupSerializer(typeof(TCommandResult));
-            IBsonSerializationOptions commandResultSerializationOptions = null;
-            return RunCommandAs<TCommandResult>(databaseName, queryFlags, command, commandResultSerializer, commandResultSerializationOptions, throwOnError);
-        }
-
-        internal TCommandResult RunCommandAs<TCommandResult>(
-            string databaseName,
-            QueryFlags queryFlags,
-            CommandDocument command,
-            IBsonSerializer commandResultSerializer,
-            IBsonSerializationOptions commandResultSerializationOptions,
-            bool throwOnError) where TCommandResult : CommandResult
-        {
-            var commandName = command.GetElement(0).Name;
-
-            var writerSettings = new BsonBinaryWriterSettings
-            {
-                Encoding = _serverInstance.Settings.WriteEncoding ?? MongoDefaults.WriteEncoding,
-                GuidRepresentation = GuidRepresentation.Unspecified,
-                MaxDocumentSize = _serverInstance.MaxDocumentSize
-            };
-
-            var queryMessage = new MongoQueryMessage(writerSettings, databaseName + ".$cmd", queryFlags, 0, 1, command, null);
-            SendMessage(queryMessage, null, databaseName); // write concern doesn't apply to queries
-
-            var readerSettings = new BsonBinaryReaderSettings
-            {
-                Encoding = _serverInstance.Settings.ReadEncoding ?? MongoDefaults.ReadEncoding,
-                GuidRepresentation = GuidRepresentation.Unspecified,
-                MaxDocumentSize = _serverInstance.MaxDocumentSize
-            };
-            var reply = ReceiveMessage<TCommandResult>(readerSettings, commandResultSerializer, commandResultSerializationOptions);
-            if (reply.NumberReturned == 0)
-            {
-                var message = string.Format("Command '{0}' failed. No response returned.", commandName);
-                throw new MongoCommandException(message);
-            }
-
-            var commandResult = reply.Documents[0];
-            commandResult.Command = command;
-
-            if (throwOnError && !commandResult.Ok)
-            {
-                throw new MongoCommandException(commandResult);
-            }
-
-            return commandResult;
-        }
-
         internal MongoReplyMessage<TDocument> ReceiveMessage<TDocument>(
             BsonBinaryReaderSettings readerSettings,
             IBsonSerializer serializer,
@@ -334,35 +275,13 @@ internal MongoReplyMessage<TDocument> ReceiveMessage<TDocument>(
             }
         }
 
-        internal WriteConcernResult SendMessage(BsonBuffer buffer, MongoRequestMessage message, WriteConcern writeConcern, string databaseName)
+        internal void SendMessage(BsonBuffer buffer, int requestId)
         {
             if (_state == MongoConnectionState.Closed) { throw new InvalidOperationException("Connection is closed."); }
             lock (_connectionLock)
             {
                 _lastUsedAt = DateTime.UtcNow;
-                _requestId = message.RequestId;
-
-                CommandDocument getLastErrorCommand = null;
-                if (writeConcern != null && writeConcern.Enabled)
-                {
-                    var fsync = (writeConcern.FSync == null) ? null : (BsonValue)writeConcern.FSync;
-                    var journal = (writeConcern.Journal == null) ? null : (BsonValue)writeConcern.Journal;
-                    var w = (writeConcern.W == null) ? null : writeConcern.W.ToGetLastErrorWValue();
-                    var wTimeout = (writeConcern.WTimeout == null) ? null : (BsonValue)(int)writeConcern.WTimeout.Value.TotalMilliseconds;
-
-                    getLastErrorCommand = new CommandDocument
-                        {
-                            { "getlasterror", 1 }, // use all lowercase for backward compatibility
-                            { "fsync", fsync, fsync != null },
-                            { "j", journal, journal != null },
-                            { "w", w, w != null },
-                            { "wtimeout", wTimeout, wTimeout != null }
-                        };
-
-                    // piggy back on network transmission for message
-                    var getLastErrorMessage = new MongoQueryMessage(message.WriterSettings, databaseName + ".$cmd", QueryFlags.None, 0, 1, getLastErrorCommand, null);
-                    getLastErrorMessage.WriteToBuffer(buffer);
-                }
+                _requestId = requestId;
 
                 try
                 {
@@ -380,46 +299,15 @@ internal WriteConcernResult SendMessage(BsonBuffer buffer, MongoRequestMessage m
                     HandleException(ex);
                     throw;
                 }
-
-                WriteConcernResult writeConcernResult = null;
-                if (writeConcern != null && writeConcern.Enabled)
-                {
-                    var readerSettings = new BsonBinaryReaderSettings
-                    {
-                        Encoding = _serverInstance.Settings.ReadEncoding ?? MongoDefaults.ReadEncoding,
-                        GuidRepresentation = message.WriterSettings.GuidRepresentation,
-                        MaxDocumentSize = _serverInstance.MaxDocumentSize
-                    };
-                    var writeConcernResultSerializer = BsonSerializer.LookupSerializer(typeof(WriteConcernResult));
-                    var replyMessage = ReceiveMessage<WriteConcernResult>(readerSettings, writeConcernResultSerializer, null);
-                    writeConcernResult = replyMessage.Documents[0];
-                    writeConcernResult.Command = getLastErrorCommand;
-                    if (!writeConcernResult.Ok)
-                    {
-                        var errorMessage = string.Format(
-                            "WriteConcern detected an error '{0}'. (response was {1}).",
-                            writeConcernResult.ErrorMessage, writeConcernResult.Response.ToJson());
-                        throw new WriteConcernException(errorMessage, writeConcernResult);
-                    }
-                    if (writeConcernResult.HasLastErrorMessage)
-                    {
-                        var errorMessage = string.Format(
-                            "WriteConcern detected an error '{0}'. (Response was {1}).",
-                            writeConcernResult.LastErrorMessage, writeConcernResult.Response.ToJson());
-                        throw new WriteConcernException(errorMessage, writeConcernResult);
-                    }
-                }
-
-                return writeConcernResult;
             }
         }
 
-        internal WriteConcernResult SendMessage(MongoRequestMessage message, WriteConcern writeConcern, string databaseName)
+        internal void SendMessage(MongoRequestMessage message)
         {
             using (var buffer = new BsonBuffer(new MultiChunkBuffer(BsonChunkPool.Default), true))
             {
                 message.WriteToBuffer(buffer);
-                return SendMessage(buffer, message, writeConcern, databaseName);
+                SendMessage(buffer, message.RequestId);
             }
         }
 

MongoDB.Driver/Communication/MongoServerInstance.cs

@@ -19,7 +19,10 @@
 using System.Net;
 using System.Net.Sockets;
 using System.Threading;
+using MongoDB.Bson.IO;
+using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Internal;
+using MongoDB.Driver.Operations;
 
 namespace MongoDB.Driver
 {
@@ -535,26 +538,21 @@ private void LookupServerInformation(MongoConnection connection)
             try
             {
                 var isMasterCommand = new CommandDocument("ismaster", 1);
-                isMasterResult = connection.RunCommandAs<IsMasterResult>("admin", QueryFlags.SlaveOk, isMasterCommand, false);
-                isMasterResult.Command = isMasterCommand;
-                if (!isMasterResult.Ok)
-                {
-                    throw new MongoCommandException(isMasterResult);
-                }
+                isMasterResult = RunCommandAs<IsMasterResult>(connection, "admin", isMasterCommand);
 
                 MongoServerBuildInfo buildInfo;
-                var buildInfoCommand = new CommandDocument("buildinfo", 1);
-                var buildInfoResult = connection.RunCommandAs<CommandResult>("admin", QueryFlags.SlaveOk, buildInfoCommand, false);
-                if (buildInfoResult.Ok)
+                try
                 {
+                    var buildInfoCommand = new CommandDocument("buildinfo", 1);
+                    var buildInfoResult = RunCommandAs<CommandResult>(connection, "admin", buildInfoCommand);
                     buildInfo = MongoServerBuildInfo.FromCommandResult(buildInfoResult);
                 }
-                else
+                catch (MongoCommandException ex)
                 {
                     // short term fix: if buildInfo fails due to auth we don't know the server version; see CSHARP-324
-                    if (buildInfoResult.ErrorMessage != "need to login")
+                    if (ex.CommandResult.ErrorMessage != "need to login")
                     {
-                        throw new MongoCommandException(buildInfoResult);
+                        throw;
                     }
                     buildInfo = null;
                 }
@@ -648,7 +646,7 @@ private void Ping(MongoConnection connection)
             {
                 var pingCommand = new CommandDocument("ping", 1);
                 Stopwatch stopwatch = Stopwatch.StartNew();
-                connection.RunCommandAs<CommandResult>("admin", QueryFlags.SlaveOk, pingCommand, true);
+                RunCommandAs<CommandResult>(connection, "admin", pingCommand);
                 stopwatch.Stop();
                 var currentAverage = _pingTimeAggregator.Average;
                 _pingTimeAggregator.Include(stopwatch.Elapsed);
@@ -666,6 +664,27 @@ private void Ping(MongoConnection connection)
             }
         }
 
+        private TCommandResult RunCommandAs<TCommandResult>(MongoConnection connection, string databaseName, IMongoCommand command)
+            where TCommandResult : CommandResult
+        {
+            var readerSettings = new BsonBinaryReaderSettings();
+            var writerSettings = new BsonBinaryWriterSettings();
+            var resultSerializer = BsonSerializer.LookupSerializer(typeof(TCommandResult));
+
+            var commandOperation = new CommandOperation<TCommandResult>(
+                databaseName,
+                readerSettings,
+                writerSettings,
+                command,
+                QueryFlags.SlaveOk,
+                null, // options
+                null, // readPreference
+                null, // serializationOptions
+                resultSerializer);
+
+            return commandOperation.Execute(connection);
+        }
+
         private void StateVerificationTimerCallback()
         {
             if (_inStateVerification)