protobuf for the journal

Author: rofr

OrigoDB.Modules.Protobuf.Test/JournalFormattingTests.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Modules.ProtoBuf.Test.Domain;
+using NUnit.Framework;
+using OrigoDB.Core;
+using OrigoDB.Core.Journaling;
+using OrigoDB.Core.Test;
+using OrigoDB.Modules.ProtoBuf;
+using ProtoBuf;
+using ProtoBuf.Meta;
+
+namespace Modules.ProtoBuf.Test
+{
+    [ProtoContract(SkipConstructor = true)]
+    public class AddItemCommand : Command<TodoModel, Guid>
+    {
+        [ProtoMember(1)]
+        public readonly string ItemName;
+
+        public AddItemCommand(string itemName)
+        {
+            ItemName = itemName;
+        }
+
+        public override Guid Execute(TodoModel model)
+        {
+            return model.AddItem(ItemName);
+        }
+    }
+
+    public class RemoveItemCommand : Command<TodoModel>
+    {
+        public readonly Guid Id;
+
+        public RemoveItemCommand(Guid id)
+        {
+            Id = id;
+        }
+
+        public override void Execute(TodoModel model)
+        {
+            model.Items.Remove(Id);
+        }
+    }
+
+    [TestFixture]
+    public class JournalFormattingTests
+    {
+        EngineConfiguration _config;
+        IStore _store;
+
+        [SetUp]
+        public void Setup()
+        {
+            _config = new EngineConfiguration().ForIsolatedTest();
+            _config.PacketOptions = PacketOptions.Checksum;
+
+            //assign unique ints to commands
+            var commandTypeTags = new Dictionary<Type, int>
+            {
+                {typeof(AddItemCommand), 1},
+                {typeof(RemoveItemCommand), 2}
+            };
+
+            //dynamic registration of command type (no attributes)
+            var typeModel = TypeModel.Create();
+            MetaType mt = typeModel.Add(typeof(RemoveItemCommand), false)
+                .Add(1, "Id");
+            mt.UseConstructor = false;
+
+
+            ProtoBufFormatter.ConfigureJournaling(_config, commandTypeTags, typeModel);
+
+            _store = _config.CreateStore();            
+        }
+
+        [Test]
+        public void CanWriteaRollbackMarkerAndReadBack()
+        {
+            var writer = _store.CreateJournalWriter(0);
+            writer.Write(new JournalEntry<RollbackMarker>(32, new RollbackMarker()));
+            var resurrected = _store.GetJournalEntries().Single();
+            Assert.AreEqual(32, resurrected.Id);
+        }
+
+        [Test]
+        public void CanWriteModelCreatedEntryAndReadBack()
+        {
+            var writer = _store.CreateJournalWriter(0);
+            writer.Write(new JournalEntry<ModelCreated>(32, new ModelCreated(typeof(TodoModel))));
+            var resurrected = _store.GetJournalEntries().Single();
+            Assert.AreEqual(32, resurrected.Id);
+            Assert.AreEqual(typeof(TodoModel),(resurrected as JournalEntry<ModelCreated>).Item.Type);
+        }
+
+        [Test]
+        public void CanWriteCommandToJournalAndReadBack()
+        {
+            const string itemName = "Fish";
+            var entryTimestamp = DateTime.Now;
+
+            var writer = _store.CreateJournalWriter(0);
+            var entry = new JournalEntry<Command>(1, new AddItemCommand(itemName), entryTimestamp);
+            writer.Write(entry);
+            var resurrected = _store.GetJournalEntries().Single();
+
+            Assert.AreEqual(entryTimestamp, resurrected.Created);
+            Assert.AreEqual(1, resurrected.Id);
+            Assert.IsInstanceOf<JournalEntry<Command>>(resurrected);
+            var typedEntry = (JournalEntry<Command>)resurrected;
+            Assert.IsInstanceOf<AddItemCommand>(typedEntry.Item);
+            var typedCommand = (AddItemCommand)typedEntry.Item;
+            Assert.AreEqual(itemName, typedCommand.ItemName);
+        }
+    }
+}

OrigoDB.Modules.Protobuf.Test/OrigoDB.Modules.ProtoBuf.Test.csproj

@@ -62,6 +62,7 @@
     <Compile Include="Framework\SerializationHelper.cs" />
     <Compile Include="Domain\Employee.cs" />
     <Compile Include="Domain\Company.cs" />
+    <Compile Include="JournalFormattingTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ProtoBufFormatterTests.cs" />
     <Compile Include="TodoModelTests.cs" />

OrigoDB.Modules.Protobuf/OrigoDB.Modules.Protobuf.csproj

@@ -52,9 +52,9 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ProtoBufFormatterException.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ProtoBufFormatter.cs" />
+    <Compile Include="TypeModelExtensions.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

OrigoDB.Modules.Protobuf/ProtoBufFormatter.cs

@@ -1,9 +1,9 @@
 using System;
+using System.Collections.Generic;
 using System.Runtime.Serialization;
 using System.IO;
 using System.Text;
 using OrigoDB.Core;
-using OrigoDB.Core.Journaling;
 using ProtoBuf;
 using ProtoBuf.Meta;
 using OrigoDB.Core.Utilities;
@@ -38,15 +38,16 @@ public class ProtoBufFormatter : IFormatter
         /// </summary>
         public SerializationBinder Binder
         {
-            get; set;
+            get;
+            set;
         }
 
         /// <summary>
         /// The associated streaming context.
         /// </summary>
         public StreamingContext Context
         {
-            get; 
+            get;
             set;
         }
 
@@ -70,18 +71,6 @@ public ProtoBufFormatter(RuntimeTypeModel typeModel = null, bool includeTypeName
             Context = new StreamingContext(StreamingContextStates.Persistence);
         }
 
-        /// <summary>
-        /// Dynamically configure the origodb types written to the journal
-        /// </summary>
-        private void RegisterJournalTypes()
-        {
-            //TODO: incomplete
-            var je = _typeModel.Add(typeof(JournalEntry), false);
-            je.AddField(1, "Id");
-            je.AddField(2, "Created");
-            je.AddSubType(3, typeof(JournalEntry<RollbackMarker>));
-            je.AddSubType(4, typeof(JournalEntry<Command>)).Add(1, "Item");
-        }
 
         /// <summary>
         /// Deserializes the data on the provided stream and 
@@ -112,7 +101,7 @@ public void Serialize(Stream stream, object graph)
             Ensure.NotNull(stream, "stream");
             Ensure.NotNull(graph, "graph");
 
-            if (IncludeTypeName) 
+            if (IncludeTypeName)
                 new BinaryWriter(stream, Encoding.UTF8)
                 .Write(graph.GetType().AssemblyQualifiedName);
 
@@ -139,41 +128,37 @@ protected virtual Type GetType(Stream stream)
         }
 
         /// <summary>
-        /// Modify the given configuration to use ProtoBuf formatting
+        /// Modify the given configuration to use ProtoBuf formatting to clone results
         /// </summary>
         /// <param name="config"></param>
-        /// <param name="usage">the usage to configure</param>
         /// <param name="typeModel">An optional typemodel</param>
-        public static void Configure(EngineConfiguration config, FormatterUsage usage, RuntimeTypeModel typeModel = null)
+        public static void ConfigureResultCloning(EngineConfiguration config, RuntimeTypeModel typeModel = null)
         {
-            switch (usage)
-            {
-                case FormatterUsage.Default:
-                    throw new NotSupportedException("Call with a specific usage, not FormatterUsage.Default");
-                case FormatterUsage.Snapshot:
-                    throw new NotSupportedException("Can't configure for snapshots without a type parameter, call ConfigureSnapshots<T> passing the type of the model instead");
-                case FormatterUsage.Journal:
-                    config.SetFormatterFactory((cfg, fu) => new ProtoBufFormatter<JournalEntry>(typeModel: typeModel, useLengthPrefix: true), usage);
-                    break;
-                case FormatterUsage.Results:
-                    config.SetFormatterFactory((cfg,fu) => new ProtoBufFormatter(typeModel, true, true), usage);
-                    break;
-                case FormatterUsage.Messages:
-                    throw new NotSupportedException("Not supported in this version of the module");
-                default:
-                    throw new ArgumentOutOfRangeException("usage");
-            }
+            config.SetFormatterFactory((cfg, fu) => new ProtoBufFormatter(typeModel, true, true), FormatterUsage.Results);
         }
 
         /// <summary>
-        /// Modify the given configuration to use ProtoBuf formatting for snapshots.
+        /// Modify the given configuration to use ProtoBuf formatting for snapshots of type T.
         /// </summary>
         /// <typeparam name="T">The concrete type of the model</typeparam>
-        /// <param name="config">the configuration to modify</param>
-        /// <param name="typeModel">An optional runtime type configuration</param>
-        public static void ConfigureSnapshots<T>(EngineConfiguration config, RuntimeTypeModel typeModel)
+        public static void ConfigureSnapshots<T>(EngineConfiguration config, RuntimeTypeModel typeModel = null) where T : Model
         {
-            config.SetFormatterFactory((cfg,fu) => new ProtoBufFormatter<T>(typeModel: typeModel), FormatterUsage.Snapshot);
+            config.SetFormatterFactory((cfg, fu) => new ProtoBufFormatter<T>(typeModel), FormatterUsage.Snapshot);
+        }
+
+        /// <summary>
+        /// Modify the given EngineConfiguration to use ProtoBuf for journaling. Pass unique ints for each type of command.
+        /// The id's must be maintained across versions of your assembly.
+        /// </summary>
+        public static void ConfigureJournaling(EngineConfiguration config, IDictionary<Type, int> commandTypeTags, RuntimeTypeModel typeModel = null)
+        {
+            config.SetFormatterFactory((cfg, fu) =>
+            {
+                var formatter = new ProtoBufFormatter<JournalEntry>(typeModel, includeTypeName: false, useLengthPrefix: true);
+                typeModel.RegisterCommandSubTypes(commandTypeTags);
+                return formatter;
+            }, 
+            FormatterUsage.Journal);
         }
     }
 
@@ -186,11 +171,9 @@ public sealed class ProtoBufFormatter<T> : ProtoBufFormatter
         /// <summary>
         /// Create a typed formatter. Type name won't be prepended to the stream because the type is known.
         /// </summary>
-        /// <param name="typeModel"></param>
-        /// <param name="useLengthPrefix"></param>
-        public ProtoBufFormatter(RuntimeTypeModel typeModel = null, bool useLengthPrefix = false) 
-            : base(includeTypeName: false, typeModel: typeModel, useLengthPrefix: useLengthPrefix)
-        {}
+        public ProtoBufFormatter(RuntimeTypeModel typeModel = null, bool useLengthPrefix = false, bool includeTypeName = false)
+            : base(includeTypeName: includeTypeName, typeModel: typeModel, useLengthPrefix: useLengthPrefix)
+        { }
 
         /// <summary>
         /// Derive the type from the generic type parameter as opposed to reading the type name from the stream
@@ -199,7 +182,7 @@ public ProtoBufFormatter(RuntimeTypeModel typeModel = null, bool useLengthPrefix
         /// <returns></returns>
         protected override Type GetType(Stream stream)
         {
-            return typeof (T);
+            return typeof(T);
         }
     }
 }

OrigoDB.Modules.Protobuf/ProtoBufFormatterException.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using OrigoDB.Core;
+using OrigoDB.Core.Journaling;
+using ProtoBuf.Meta;
+
+namespace OrigoDB.Modules.ProtoBuf
+{
+    /// <summary>
+    /// Extension methods
+    /// </summary>
+    public static class TypeModelExtensions
+    {
+        /// <summary>
+        /// Inejct contracts for origodb core types into given RuntimeTypeModel. Can safely be called multiple times.
+        /// </summary>
+        /// <param name="typeModel"></param>
+        public static void RegisterFrameworkTypes(this RuntimeTypeModel typeModel)
+        {
+            if (typeModel.IsDefined(typeof (Command))) return;
+
+            typeModel.Add(typeof(Command), true);
+
+            var journalEntry = typeModel.Add(typeof (JournalEntry), false)
+                .Add(1, "Id")
+                .Add(2, "Created");
+
+            journalEntry.UseConstructor = false;
+
+            journalEntry.AddSubType(3, typeof(JournalEntry<Command>));
+            journalEntry.AddSubType(4, typeof (JournalEntry<RollbackMarker>));
+            journalEntry.AddSubType(5, typeof(JournalEntry<ModelCreated>));
+
+
+            typeModel.Add(typeof(JournalEntry<Command>), false)
+                .Add(1, "Item")
+                .UseConstructor = false;
+
+            typeModel.Add(typeof (JournalEntry<ModelCreated>), false)
+                .Add(1, "Item")
+                .UseConstructor = false;
+
+            typeModel.Add(typeof (JournalEntry<RollbackMarker>), false)
+                .Add(1, "Item")
+                .UseConstructor = false;
+            
+            typeModel.Add(typeof (ModelCreated), false)
+                .Add(1, "Type")
+                .UseConstructor = false;
+
+            typeModel.Add(typeof(RollbackMarker), false)
+                .UseConstructor = false;
+
+        }
+
+        /// <summary>
+        /// Register the passed commands as sub classes of OrigoDB.Core.Command. The id must be unique for each command
+        /// and constant across versions of your system. If any of the command types are already registered nothing will happen.
+        /// </summary>
+        public static void RegisterCommandSubTypes(this RuntimeTypeModel typeModel, IDictionary<Type, int> commandIdsByType)
+        {
+            RegisterFrameworkTypes(typeModel);
+            var commandMeta = typeModel[typeof(Command)];
+            if (commandMeta.GetSubtypes().Any(st => commandIdsByType.ContainsKey(st.DerivedType.Type))) return;
+            foreach (var type in commandIdsByType.Keys)
+            {
+                commandMeta.AddSubType(commandIdsByType[type], type);
+            }
+        }
+    }
+}