CSHARP-714 : AscendingGuidGenerator and tests

Author: Sridhar Nanjundeswaran

MongoDB.Bson/MongoDB.Bson.csproj

@@ -177,6 +177,7 @@
     <Compile Include="Serialization\CreatorMapDelegateCompiler.cs" />
     <Compile Include="Serialization\ExpressionVisitor.cs" />
     <Compile Include="Serialization\ICreatorSelector.cs" />
+    <Compile Include="Serialization\IdGenerators\AscendingGuidGenerator.cs" />
     <Compile Include="Serialization\IdGenerators\BsonBinaryDataGuidGenerator.cs" />
     <Compile Include="Serialization\IdGenerators\BsonObjectIdGenerator.cs" />
     <Compile Include="Serialization\IdGenerators\CombGuidGenerator.cs" />

MongoDB.Bson/Serialization/IdGenerators/AscendingGuidGenerator.cs

@@ -0,0 +1,155 @@
+/* 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.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Security;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+
+namespace MongoDB.Bson.Serialization.IdGenerators
+{
+    /// <summary>
+    /// A GUID generator that generates GUIDs in ascending order. To enable 
+    /// an index to make use of the ascending nature make sure to use
+    /// <see cref="GuidRepresentation.Standard">GuidRepresentation.Standard</see>
+    /// as the storage representation.
+    /// Internally the GUID is of the form
+    /// 8 bytes: Ticks from DateTime.UtcNow.Ticks
+    /// 3 bytes: hash of machine name
+    /// 2 bytes: low order bytes of process Id
+    /// 3 bytes: increment
+    /// </summary>
+    public class AscendingGuidGenerator : IIdGenerator
+    {
+        // private static fields
+        private static readonly AscendingGuidGenerator __instance = new AscendingGuidGenerator();
+        private static readonly byte[] __machineProcessId;
+        private static int __increment; 
+
+        // static constructor
+        static AscendingGuidGenerator()
+        {
+            var machineHash = GetMachineHash();
+            short processId;
+            try
+            {
+                // use low order two bytes only
+                processId = (short)GetCurrentProcessId(); 
+            }
+            catch (SecurityException)
+            {
+                processId = 0;
+            }
+
+            __machineProcessId = new byte[5]
+            {
+                machineHash[0],
+                machineHash[1],
+                machineHash[2],
+                (byte)(processId >> 8),
+                (byte)(processId)
+            };
+        }
+
+        // public static properties
+
+        /// <summary>
+        /// Gets an instance of AscendingGuidGenerator.
+        /// </summary>
+        public static AscendingGuidGenerator Instance
+        {
+            get { return __instance; }
+        }
+        
+        // public methods
+
+        /// <summary>
+        /// Generates an ascending Guid for a document. Consecutive invocations
+        /// should generate Guids that are ascending from a MongoDB perspective
+        /// </summary>
+        /// <param name="container">The container of the document (will be a 
+        /// MongoCollection when called from the driver). </param>
+        /// <param name="document">The document it was generated for.</param>
+        /// <returns>A Guid.</returns>
+        public object GenerateId(object container, object document)
+        {
+            var increment = Interlocked.Increment(ref __increment) & 0x00ffffff;
+            return GenerateId(DateTime.UtcNow.Ticks, __machineProcessId, increment);
+        }
+
+        /// <summary>
+        /// Generates a Guid for a document. Note - this is purely used for
+        /// unit testing
+        /// </summary>
+        /// <param name="tickCount">The time portion of the Guid</param>
+        /// <param name="machineProcessId">A 5 byte array with the first 3 bytes
+        /// representing a machine id and the next 2 representing a process
+        /// id</param>
+        /// <param name="increment">The increment portion of the Guid. Used
+        /// to distinguish between 2 Guids that have the timestamp. Note
+        /// only the least significant 3 bytes are used.</param>
+        /// <returns>A Guid.</returns>
+        public object GenerateId(
+            long tickCount,
+            byte[] machineProcessId,
+            int increment)
+        {
+            var a = (int)(tickCount >> 32);
+            var b = (short)(tickCount >> 16);
+            var c = (short)(tickCount);
+            var d = new byte[8];
+            Array.Copy(machineProcessId, d, 5);
+            d[5] = (byte)(increment >> 16);
+            d[6] = (byte)(increment >> 8);
+            d[7] = (byte)(increment);
+            return new Guid (a, b, c, d);
+        }
+
+        /// <summary>
+        /// Tests whether an id is empty.
+        /// </summary>
+        /// <param name="id">The id to test.</param>
+        /// <returns>True if the Id is empty. False otherwise</returns>
+        public bool IsEmpty(object id)
+        {
+            return id == null || (Guid)id == Guid.Empty;
+        }
+
+        // private static methods
+        /// <summary>
+        /// Gets the current process id.  This method exists because of how
+        /// CAS operates on the call stack, checking for permissions before
+        /// executing the method.  Hence, if we inlined this call, the calling
+        /// method would not execute before throwing an exception requiring the
+        /// try/catch at an even higher level that we don't necessarily control.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static int GetCurrentProcessId()
+        {
+            return Process.GetCurrentProcess().Id;
+        }
+
+        private static byte[] GetMachineHash()
+        {
+            // use instead of Dns.HostName so it will work offline
+            var hostName = Environment.MachineName; 
+            var sha1 = SHA1.Create();
+            return sha1.ComputeHash(Encoding.UTF8.GetBytes(hostName));
+        }
+    }
+}

MongoDB.BsonUnitTests/MongoDB.BsonUnitTests.csproj

@@ -117,6 +117,7 @@
     <Compile Include="Serialization\Conventions\PropertyFinderConventionsTests.cs" />
     <Compile Include="Serialization\Conventions\ReadWriteMemberFinderConventionsTests.cs" />
     <Compile Include="Serialization\Conventions\StringObjectIdGeneratorConventionsTests.cs" />
+    <Compile Include="Serialization\IdGenerators\AscendingGuidGeneratorTests.cs" />
     <Compile Include="Serialization\LegacyBsonClassMapTests.cs" />
     <Compile Include="Serialization\Serializers\ExtraElementsTests.cs" />
     <Compile Include="Serialization\Options\RepresentationSerializationOptionsTests.cs" />

MongoDB.BsonUnitTests/Serialization/IdGenerators/AscendingGuidGeneratorTests.cs

@@ -0,0 +1,90 @@
+/* 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.Linq;
+using MongoDB.Bson.Serialization.IdGenerators;
+using NUnit.Framework;
+
+namespace MongoDB.BsonUnitTests.Serialization
+{
+    [TestFixture]
+    public class AscendingGuidGeneratorTests
+    {
+        private AscendingGuidGenerator _generator = new AscendingGuidGenerator();
+
+        [Test]
+        public void TestIsEmpty()
+        {
+            Assert.IsTrue(_generator.IsEmpty(null));
+            Assert.IsTrue(_generator.IsEmpty(Guid.Empty));
+            var guid = _generator.GenerateId(null, null);
+            Assert.IsFalse(_generator.IsEmpty(guid));
+        }
+
+        [Test]
+        public void TestGuid()
+        {
+            var expectedTicks = DateTime.Now.Ticks;
+            var expectedIncrement = 1000;
+            var expectedMachineProcessId = new byte[] { 1, 32, 64, 128, 255 };
+            var guid = (Guid)_generator.GenerateId(expectedTicks, expectedMachineProcessId, expectedIncrement);
+            var bytes = guid.ToByteArray();
+            var actualTicks = GetTicks(bytes);
+            var actualMachineProcessId = GetMachineProcessId(bytes);
+            var actualIncrement = GetIncrement(bytes);
+            Assert.AreEqual(expectedTicks, actualTicks);
+            Assert.IsTrue(expectedMachineProcessId.SequenceEqual(actualMachineProcessId));
+            Assert.AreEqual(expectedIncrement, actualIncrement);
+        }
+
+        [Test]
+        public void TestGuidWithSpecifiedTicks()
+        {
+            var expectedTicks = 0x8000L;
+            var expectedIncrement = 32;
+            var expectedMachineProcessId = new byte[] { 1, 32, 64, 128, 255 };
+            var guid = (Guid)_generator.GenerateId(expectedTicks, expectedMachineProcessId, expectedIncrement);
+            var bytes = guid.ToByteArray();
+            var actualTicks = GetTicks(bytes);
+            var actualMachineProcessId = GetMachineProcessId(bytes);
+            var actualIncrement = GetIncrement(bytes);
+            Assert.AreEqual(expectedTicks, actualTicks);
+            Assert.IsTrue(expectedMachineProcessId.SequenceEqual(actualMachineProcessId));
+            Assert.AreEqual(expectedIncrement, actualIncrement);
+        }
+
+        private long GetTicks(byte[] bytes)
+        {
+            var a = (ulong)BitConverter.ToUInt32(bytes, 0);
+            var b = (ulong)BitConverter.ToUInt16(bytes, 4);
+            var c = (ulong)BitConverter.ToUInt16(bytes, 6);
+            return (long)((a << 32) | (b << 16) | c);
+        }
+
+        private byte[] GetMachineProcessId(byte[] bytes)
+        {
+            var result = new byte[5];
+            Array.Copy(bytes, 8, result, 0, 5);
+            return result;
+        }
+
+        private int GetIncrement(byte[] bytes)
+        {
+            var increment = (bytes[13] << 16) + (bytes[14] << 8) + bytes[15];
+            return increment;
+        }
+    }
+}

MongoDB.DriverUnitTests/Jira/CSharp714Tests.cs

@@ -0,0 +1,74 @@
+/* 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 MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.IdGenerators;
+using MongoDB.Driver;
+using MongoDB.Driver.Builders;
+using NUnit.Framework;
+
+namespace MongoDB.DriverUnitTests.Jira.CSharp714
+{
+    [TestFixture]
+    public class CSharp714Tests
+    {
+        public class C
+        {
+            public int Id { get; set; }
+            public Guid Guid { get; set; }
+        }
+
+        private MongoServer _server;
+        private MongoDatabase _database;
+        private MongoCollection<C> _collection;
+        private IIdGenerator _generator = new AscendingGuidGenerator();
+        private static int __maxNoOfDocuments = 100;
+        
+        [TestFixtureSetUp]
+        public void TestFixtureSetup()
+        {
+            _server = Configuration.TestServer;
+            _database = Configuration.TestDatabase;
+            var collectionSettings = new MongoCollectionSettings() { GuidRepresentation = GuidRepresentation.Standard };
+            _collection = _database.GetCollection<C>("csharp714", collectionSettings);
+            _collection.Drop();
+        }
+        
+        [Test]
+        public void TestGuidsAreAscending()
+        {
+            _collection.RemoveAll();
+            CreateTestData();
+            // sort descending just so we are not retrieving in insertion order
+            var cursor = _collection.FindAll().SetSortOrder(SortBy.Descending("Guid"));
+            var id = __maxNoOfDocuments - 1;
+            foreach (var c in cursor) 
+            {
+                Assert.AreEqual(id--, c.Id);
+            }
+        }
+
+        private void CreateTestData()
+        {
+            for (var i=0; i<__maxNoOfDocuments; i++) 
+            {
+                _collection.Insert(new C { Id = i, Guid = (Guid)_generator.GenerateId(null, null) });
+            }
+            _collection.CreateIndex("Guid");
+        }
+    }
+}

MongoDB.DriverUnitTests/MongoDB.DriverUnitTests.csproj

@@ -119,6 +119,7 @@
     <Compile Include="GeoJsonObjectModel\GeoJsonPolygonTests.cs" />
     <Compile Include="Jira\CSharp542Tests.cs" />
     <Compile Include="Jira\CSharp653Tests.cs" />
+    <Compile Include="Jira\CSharp714Tests.cs" />
     <Compile Include="MongoClientSettingsTests.cs" />
     <Compile Include="ReadPreferenceTests.cs" />
     <Compile Include="MongoCollectionSettingsTests.cs" />