CSHARP-2021: Implement Driver Sessions API

Author: rstam

evergreen/evergreen.yml

@@ -136,12 +136,12 @@ functions:
       params:
         script: |
           ${PREPARE_SHELL}
-          find $MONGO_ORCHESTRATION_HOME -name \*.log | xargs tar czf ${PROJECT_DIRECTORY}/mongodb-logs.tar.gz
+          find $MONGO_ORCHESTRATION_HOME -name \*.log | xargs tar czf mongodb-logs.tar.gz
     - command: s3.put
       params:
         aws_key: ${aws_key}
         aws_secret: ${aws_secret}
-        local_file: ${PROJECT_DIRECTORY}/mongodb-logs.tar.gz
+        local_file: mongodb-logs.tar.gz
         remote_file: ${UPLOAD_BUCKET}/${build_variant}/${revision}/${version_id}/${build_id}/logs/${task_id}-${execution}-mongodb-logs.tar.gz
         bucket: mciuploads
         permissions: public-read
@@ -151,7 +151,7 @@ functions:
       params:
         aws_key: ${aws_key}
         aws_secret: ${aws_secret}
-        local_file: ${DRIVERS_TOOLS}/.evergreen/orchestration/server.log
+        local_file: drivers-tools/.evergreen/orchestration/server.log
         remote_file: ${UPLOAD_BUCKET}/${build_variant}/${revision}/${version_id}/${build_id}/logs/${task_id}-${execution}-orchestration.log
         bucket: mciuploads
         permissions: public-read
@@ -349,10 +349,14 @@ axes:
   - id: version
     display_name: MongoDB Version
     values:
-      - id: "latest"
-        display_name: "latest"
+#      - id: "latest"
+#        display_name: "latest"
+#        variables:
+#           VERSION: "latest"
+      - id: "3.6"
+        display_name: "3.6"
         variables:
-           VERSION: "latest"
+           VERSION: "3.6"
       - id: "3.4"
         display_name: "3.4"
         variables:

src/MongoDB.Bson/IO/BsonBinaryWriter.cs

@@ -1,4 +1,4 @@
-/* Copyright 2010-2016 MongoDB Inc.
+/* Copyright 2010-2017 MongoDB Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -27,8 +27,6 @@ public class BsonBinaryWriter : BsonWriter
         // private fields
         private readonly Stream _baseStream;
         private readonly BsonStream _bsonStream;
-        private readonly BsonBinaryWriterSettings _settings; // same value as in base class just declared as derived class
-        private readonly Stack<int> _maxDocumentSizeStack = new Stack<int>();
         private BsonBinaryWriterContext _context;
 
         // constructors
@@ -60,8 +58,6 @@ public BsonBinaryWriter(Stream stream, BsonBinaryWriterSettings settings)
 
             _baseStream = stream;
             _bsonStream = (stream as BsonStream) ?? new BsonStreamAdapter(stream);
-            _settings = settings; // already frozen by base class
-            _maxDocumentSizeStack.Push(_settings.MaxDocumentSize);
 
             _context = null;
             State = BsonWriterState.Initial;
@@ -90,6 +86,18 @@ public BsonStream BsonStream
             get { return _bsonStream; }
         }
 
+        /// <inheritdoc />
+        public override long Position
+        {
+            get { return _baseStream.Position; }
+        }
+
+        /// <inheritdoc />
+        public new BsonBinaryWriterSettings Settings
+        {
+            get {  return (BsonBinaryWriterSettings)base.Settings; }
+        }
+
         // public methods
         /// <summary>
         /// Closes the writer. Also closes the base stream.
@@ -128,18 +136,20 @@ public override void Flush()
         /// <summary>
         /// Pops the max document size stack, restoring the previous max document size.
         /// </summary>
+        [Obsolete("Use PopSettings instead.")]
         public void PopMaxDocumentSize()
         {
-            _maxDocumentSizeStack.Pop();
+            PopSettings();
         }
 
         /// <summary>
         /// Pushes a new max document size onto the max document size stack.
         /// </summary>
         /// <param name="maxDocumentSize">The maximum size of the document.</param>
+        [Obsolete("Use PushSettings instead.")]
         public void PushMaxDocumentSize(int maxDocumentSize)
         {
-            _maxDocumentSizeStack.Push(Math.Min(maxDocumentSize, _maxDocumentSizeStack.Peek()));
+            PushSettings(s => ((BsonBinaryWriterSettings)s).MaxDocumentSize = maxDocumentSize);
         }
 
 #pragma warning disable 618 // about obsolete BsonBinarySubType.OldBinary
@@ -161,28 +171,28 @@ public override void WriteBinaryData(BsonBinaryData binaryData)
             switch (subType)
             {
                 case BsonBinarySubType.OldBinary:
-                    if (_settings.FixOldBinarySubTypeOnOutput)
+                    if (Settings.FixOldBinarySubTypeOnOutput)
                     {
                         subType = BsonBinarySubType.Binary; // replace obsolete OldBinary with new Binary sub type
                     }
                     break;
                 case BsonBinarySubType.UuidLegacy:
                 case BsonBinarySubType.UuidStandard:
-                    if (_settings.GuidRepresentation != GuidRepresentation.Unspecified)
+                    if (Settings.GuidRepresentation != GuidRepresentation.Unspecified)
                     {
-                        var expectedSubType = (_settings.GuidRepresentation == GuidRepresentation.Standard) ? BsonBinarySubType.UuidStandard : BsonBinarySubType.UuidLegacy;
+                        var expectedSubType = (Settings.GuidRepresentation == GuidRepresentation.Standard) ? BsonBinarySubType.UuidStandard : BsonBinarySubType.UuidLegacy;
                         if (subType != expectedSubType)
                         {
                             var message = string.Format(
                                 "The GuidRepresentation for the writer is {0}, which requires the subType argument to be {1}, not {2}.",
-                                _settings.GuidRepresentation, expectedSubType, subType);
+                                Settings.GuidRepresentation, expectedSubType, subType);
                             throw new BsonSerializationException(message);
                         }
-                        if (guidRepresentation != _settings.GuidRepresentation)
+                        if (guidRepresentation != Settings.GuidRepresentation)
                         {
                             var message = string.Format(
                                 "The GuidRepresentation for the writer is {0}, which requires the the guidRepresentation argument to also be {0}, not {1}.",
-                                _settings.GuidRepresentation, guidRepresentation);
+                                Settings.GuidRepresentation, guidRepresentation);
                             throw new BsonSerializationException(message);
                         }
                     }
@@ -413,7 +423,7 @@ public override void WriteJavaScript(string code)
 
             _bsonStream.WriteBsonType(BsonType.JavaScript);
             WriteNameHelper();
-            _bsonStream.WriteString(code, _settings.Encoding);
+            _bsonStream.WriteString(code, Settings.Encoding);
 
             State = GetNextState();
         }
@@ -434,7 +444,7 @@ public override void WriteJavaScriptWithScope(string code)
             WriteNameHelper();
             _context = new BsonBinaryWriterContext(_context, ContextType.JavaScriptWithScope, _bsonStream.Position);
             _bsonStream.WriteInt32(0); // reserve space for size of JavaScript with scope value
-            _bsonStream.WriteString(code, _settings.Encoding);
+            _bsonStream.WriteString(code, Settings.Encoding);
 
             State = BsonWriterState.ScopeDocument;
         }
@@ -640,7 +650,7 @@ public override void WriteString(string value)
 
             _bsonStream.WriteBsonType(BsonType.String);
             WriteNameHelper();
-            _bsonStream.WriteString(value, _settings.Encoding);
+            _bsonStream.WriteString(value, Settings.Encoding);
 
             State = GetNextState();
         }
@@ -659,7 +669,7 @@ public override void WriteSymbol(string value)
 
             _bsonStream.WriteBsonType(BsonType.Symbol);
             WriteNameHelper();
-            _bsonStream.WriteString(value, _settings.Encoding);
+            _bsonStream.WriteString(value, Settings.Encoding);
 
             State = GetNextState();
         }
@@ -722,9 +732,9 @@ protected override void Dispose(bool disposing)
         private void BackpatchSize()
         {
             var size = _bsonStream.Position - _context.StartPosition;
-            if (size > _maxDocumentSizeStack.Peek())
+            if (size > Settings.MaxDocumentSize)
             {
-                var message = string.Format("Size {0} is larger than MaxDocumentSize {1}.", size, _maxDocumentSizeStack.Peek());
+                var message = string.Format("Size {0} is larger than MaxDocumentSize {1}.", size, Settings.MaxDocumentSize);
                 throw new FormatException(message);
             }
 

src/MongoDB.Bson/IO/BsonDocumentWriter.cs

@@ -1,4 +1,4 @@
-/* Copyright 2010-2016 MongoDB Inc.
+/* Copyright 2010-2017 MongoDB Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -63,6 +63,9 @@ public BsonDocument Document
             get { return _document; }
         }
 
+        /// <inheritdoc />
+        public override long Position => 0L;
+
         // public methods
         /// <summary>
         /// Closes the writer.

src/MongoDB.Bson/IO/BsonWriter.cs

@@ -1,4 +1,4 @@
-/* Copyright 2010-2016 MongoDB Inc.
+/* Copyright 2010-2017 MongoDB Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -32,6 +32,7 @@ public abstract class BsonWriter : IBsonWriter
         private IElementNameValidator _elementNameValidator = NoOpElementNameValidator.Instance;
         private Stack<IElementNameValidator> _elementNameValidatorStack = new Stack<IElementNameValidator>();
         private BsonWriterSettings _settings;
+        private Stack<BsonWriterSettings> _settingsStack = new Stack<BsonWriterSettings>();
         private BsonWriterState _state;
         private string _name;
         private int _serializationDepth;
@@ -53,6 +54,9 @@ protected BsonWriter(BsonWriterSettings settings)
         }
 
         // public properties
+        /// <inheritdoc />
+        public abstract long Position { get; }
+
         /// <summary>
         /// Gets the current serialization depth.
         /// </summary>
@@ -130,6 +134,12 @@ public void PopElementNameValidator()
             _childElementNameValidatorFactory = () => _elementNameValidator;
         }
 
+        /// <inheritdoc />
+        public void PopSettings()
+        {
+            _settings = _settingsStack.Pop();
+        }
+
         /// <summary>
         /// Pushes the element name validator.
         /// </summary>
@@ -146,6 +156,16 @@ public void PushElementNameValidator(IElementNameValidator validator)
             _childElementNameValidatorFactory = () => _elementNameValidator;
         }
 
+        /// <inheritdoc />
+        public void PushSettings(Action<BsonWriterSettings> configurator)
+        {
+            var newSettings = _settings.Clone();
+            configurator(newSettings);
+            newSettings.Freeze();
+            _settingsStack.Push(_settings);
+            _settings = newSettings;
+        }
+
         /// <summary>
         /// Writes BSON binary data to the writer.
         /// </summary>

src/MongoDB.Bson/IO/ElementAppendingBsonWriter.cs

@@ -0,0 +1,84 @@
+/* Copyright 2017 MongoDB 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.Generic;
+using System.Linq;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
+
+namespace MongoDB.Bson.IO
+{
+    /// <summary>
+    /// A BsonWriter that appends elements to the end of a document.
+    /// </summary>
+    /// <seealso cref="MongoDB.Bson.IO.IBsonWriter" />
+    internal sealed class ElementAppendingBsonWriter : WrappingBsonWriter
+    {
+        // private fields
+        private int _depth;
+        private readonly List<BsonElement> _elements;
+        private readonly Action<BsonWriterSettings> _settingsConfigurator;
+
+        // constructors
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ElementAppendingBsonWriter" /> class.
+        /// </summary>
+        /// <param name="wrapped">The wrapped writer.</param>
+        /// <param name="elements">The elements to append.</param>
+        /// <param name="settingsConfigurator">The settings configurator.</param>
+        public ElementAppendingBsonWriter(
+            IBsonWriter wrapped,
+            IEnumerable<BsonElement> elements,
+            Action<BsonWriterSettings> settingsConfigurator)
+            : base(wrapped)
+        {
+            if (elements == null) { throw new ArgumentNullException(nameof(elements)); }
+            _elements = elements.ToList();
+            _settingsConfigurator = settingsConfigurator ?? (s => { });
+        }
+
+        // public methods
+        /// <inheritdoc />
+        public override void WriteEndDocument()
+        {
+            if (--_depth == 0)
+            {
+                Wrapped.PushSettings(_settingsConfigurator);
+                try
+                {
+                    var context = BsonSerializationContext.CreateRoot(Wrapped);
+                    foreach (var element in _elements)
+                    {
+                        Wrapped.WriteName(element.Name);
+                        BsonValueSerializer.Instance.Serialize(context, element.Value);
+                    }
+                }
+                finally
+                {
+                    Wrapped.PopSettings();
+                }
+            }
+            base.WriteEndDocument();
+        }
+
+        /// <inheritdoc />
+        public override void WriteStartDocument()
+        {
+            _depth++;
+            base.WriteStartDocument();
+        }
+    }
+}

src/MongoDB.Bson/IO/IBsonWriter.cs

@@ -1,4 +1,4 @@
-/* Copyright 2010-2016 MongoDB Inc.
+/* Copyright 2010-2017 MongoDB Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -20,9 +20,19 @@ namespace MongoDB.Bson.IO
     /// <summary>
     /// Represents a BSON writer.
     /// </summary>
+    /// <seealso cref="System.IDisposable" />
     public interface IBsonWriter : IDisposable
     {
         // properties
+        /// <summary>
+        /// Gets the position.
+        /// Not all writers are able to report the position. Those that can't simply return zero.
+        /// </summary>
+        /// <value>
+        /// The position.
+        /// </value>
+        long Position { get; }
+
         /// <summary>
         /// Gets the current serialization depth.
         /// </summary>
@@ -56,12 +66,23 @@ public interface IBsonWriter : IDisposable
         /// <returns>The popped element validator.</returns>
         void PopElementNameValidator();
 
+        /// <summary>
+        /// Pops the settings.
+        /// </summary>
+        void PopSettings();
+
         /// <summary>
         /// Pushes the element name validator.
         /// </summary>
         /// <param name="validator">The validator.</param>
         void PushElementNameValidator(IElementNameValidator validator);
 
+        /// <summary>
+        /// Pushes new settings for the writer.
+        /// </summary>
+        /// <param name="configurator">The settings configurator.</param>
+        void PushSettings(Action<BsonWriterSettings> configurator);
+
         /// <summary>
         /// Writes BSON binary data to the writer.
         /// </summary>