RabbitMQ: Node Names on Windows (Gotcha)

Though this is stated in the clustering guide, I managed to miss it:

The node name of a RabbitMQ broker started from the rabbitmq-server shell script is rabbit@shorthostname, where the short node name is lower-case (as in rabbit@rabbit1, above). If you use the rabbitmq-server.bat batch file on Windows, the short node name is upper-case (as inrabbit@RABBIT1). When you type node names, case matters, and these strings must match exactly.

Note the remote server name is in upper case for the first request, but in lower case for the second:

IoC: Windsor TypedFactoryFacility and Generics

Preface

Castle.Windsor is a powerful IoC framework. Since being cajoled into using it by a co-worker, I've come to really like it's features. Today I'm making a brain dump of something cool the TypedFactoryFacility can do. For those that don't know, this facility provides, "... automatically generated abstract factories..."

The Problem

I was creating a service host which exposed a few endpoints. These in turn called the business specific functionality. The service class already had four or five business specific methods on it. That's a lot of dependencies to put in a constructor.

    public class DrinkServiceWithoutFactory : IDrinkService
    {
        private readonly Fridge fridge;
        private readonly Machine machine;

        public DrinkServiceWithoutFactory(Fridge fridge, Machine machine)
        {
            this.fridge = fridge;
            this.machine = machine;
        }

        public IList<Can> GetCans()
        {
            return fridge.Dispense();
        }

        public IList<Bottle> GetBottles()
        {
            return machine.Dispense();
        }
    }

    public class Fridge : IDispenser<Can>
    {
        public IList<Can> Dispense()
        {
            Console.WriteLine("Creating 1 Can...");

            return new List<Can>
                   {
                       default(Can)
                   };
        }
    }

    public class Machine : IDispenser<Bottle>
    {
        public IList<Bottle> Dispense()
        {
            Console.WriteLine("Creating 2 bottles...");

            return new List<Bottle>
                   {
                       default(Bottle),
                       default(Bottle)
                   };
        }
    }

The Solution

An abstract factory was used to create the business-specific objects on demand, reducing the number of dependencies being injected into the constructor. the TypedFactoryFacility provides a handy means of creating delegate- or interface- based abstract factories automagically. What's not illustrated on the Castle documents site is that it can also create factories with generic methods.

The interface-based factory docs page explains how to create and use a factory interface. It doesn't really mention that the create method can also contain a generic. Below is an example of one that does.

    public interface IDispenserFactory
    {
        T Create<T>()
            where T : IDispenser;

        void Release(IDispenser iDispenser);
    }

This depends on two other definitions:

    public interface IDispenser
    {
        
    }

    public interface IDispenser<T> : IDispenser
        where T : class 
    {
        IList<T> Dispense();
    }

Now that we have the factory setup, we can register the components:

    public class Program
    {
        static void Main()
        {
            try
            {
                var container = new WindsorContainer();

                container.AddFacility<TypedFactoryFacility>();

                container.Register(
                    Component.For<Demo>(),
                    Component.For<Machine>(),
                    Component.For<Fridge>(),
                    Component.For<IDispenserFactory>().AsFactory(),
                    Component.For<IDrinkService>().ImplementedBy<DrinkService>()
                    );

                var demo = container.Resolve<Demo>();
                demo.Run();
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception);
            }   
            finally
            {
                Console.ReadKey();
            }
        }
    }

    public class Demo
    {
        private readonly IDrinkService service;

        public Demo(IDrinkService service)
        {
            this.service = service;
        }

        public void Run()
        {
            var bottles = service.GetBottles();
            Console.WriteLine("Bottles created: {0}", bottles.Count);

            var cans = service.GetCans();
            Console.WriteLine("Cans created: {0}", cans.Count);
        } 
    }

We can then change the service implementation to use the abstract factory:

    public class DrinkService : IDrinkService
    {
        private readonly IDispenserFactory factory;

        public DrinkService(IDispenserFactory factory)
        {
            this.factory = factory;
        }

        public IList<Can> GetCans()
        {
            var fridge = factory.Create<Fridge>();
            return fridge.Dispense();
        }

        public IList<Bottle> GetBottles()
        {
            var machine = factory.Create<Machine>();
            return machine.Dispense();
        }
    }

The results (quick and dirty):

The results...

Summary

This was just a quick brain dump to illustrate that the TypedFactoryFacility can do generics as well.

TDD: NSubstitute, CQRS, and abstract classes...

Preface

I'm a fan of CQRS. It's a great way to separate concerns when dealing with data. In fact, I'm a pretty big fan of the command pattern as a whole. One of the big issues I've faced with using this pattern is unit testing the queries. (Note: this is a pretty contrived example, but it should get the idea across.) Sample code can be found on Github.

The Problem

I want to implement some kind of cache object, and I want to use CQRS in fetching the entities from the database. To top it off, I want to unit test the cache. Here's a look at the cache (and yes, I know it's not really caching anything):

    public class ReportCache
    {
        private readonly ISession session;
        private readonly GetReportByDateAndType getReportByDateAndType;

        public ReportCache(ISession session, GetReportByDateAndType getReportByDateAndType)
        {
            this.session = session;
            this.getReportByDateAndType = getReportByDateAndType;
        }

        public Report GetReportByDateAndType(DateTime reportDate, ReportType reportType)
        {
            getReportByDateAndType.ReportDate = reportDate;
            getReportByDateAndType.ReportType = reportType;
            var reports = getReportByDateAndType.Execute(session);

            return reports.First();
        }
    }

The Solution

The hurdle is how to mock out the query object. I've always tried to implement some kind of interface with varying levels of success. Following that approach made it difficult to use/inject the query into whatever object was using it.

I was usually left with an interface supplied in the constructor which had to be downcast to allow access to the properties. Another option would be to supply a factory object, which could create the appropriate query when necessary. The former being a Liskov Substitution Principle violation. The latter adding unnecessary complexity.

One day, I realized I could use abstract classes, and life became a little easier. Let's say we start with the query itself:

    public class GetReportByDateAndType : QueryBase
    {
        public DateTime ReportDate { get; set; }
        public ReportType ReportType { get; set; }

        public override IQueryable<Report> Execute(ISession session)
        {
            return session.Query<Report>()
                .Where(report => report.ReportDate == ReportDate && report.Type == ReportType);
        }
    }

You'll notice that the queries inherit from a base class. This class is an abstract, and enforces that the Execute() method can be overridden. I'm using this similar to an interface. It's a means to define what the queries will look like:

    public abstract class QueryBase
    {
        public abstract IQueryable<Report> Execute(ISession session);
    }

Doing a unit test with this setup, becomes a matter of simply mocking the query. This can be done with a framework or a hand-rolled mock. The following is an example using NSubstitute:

    public static class ReportCacheTests
    {
        public class ReportCacheSpecs : ContextSpecification
        {
            protected ReportCache Sut;
            protected GetReportByDateAndType TestQuery;
            protected ISession TestSession;

            protected override void Context()
            {
                TestSession = Substitute.For<ISession>();
                TestQuery = Substitute.For<GetReportByDateAndType>();
                Sut = new ReportCache(TestSession, TestQuery);
            }
        }

        [TestClass]
        public class MockWithNSubstitute : ReportCacheSpecs
        {
            private Report expectedReport;
            private Report result;
            private DateTime testDate;
            private ReportType testReportType;

            protected override void Context()
            {
                base.Context();

                testDate = new DateTime(2012, 01, 02);
                testReportType = ReportType.Cost;

                expectedReport = new Report
                                     {
                                         ReportId = 42L,
                                     };
                TestQuery.Execute(TestSession)
                    .Returns(new List<Report> { expectedReport }.AsQueryable());
            }

            protected override void BecauseOf()
            {
                result = Sut.GetReportByDateAndType(testDate, testReportType);
            }

            [TestMethod]
            public void TheCacheShouldReturnTheFirstReport()
            {
                result.Should().Be(expectedReport);
            }

            [TestMethod]
            public void TheCorrectParametersShouldBeSetOnTheQuery()
            {
                TestQuery.ReportDate.Should().Be(testDate);
                TestQuery.ReportType.Should().Be(testReportType);
            }
        }
    }

I've posted an example to Github. You'll notice the example also shows how to extend the functionality of the query without using inheritance. I plan on writing a blog about this at a later date. An added bonus is any IoC container can be used to supply the query, so there's no need for a factory.

NHibernate Samples: Row Versioning with SQL Server Timestamp

Preface

I've recently switched from using FluentNHibernate to NHibernate. The decision was made to reduce the number of dependencies required by a solution. Since NHibernate (3.2+) now includes a means of mapping entities to database tables, I just didn't need to use FNH. The big problem I've run into as a result of the switch is the lack of samples on the 'net. Since I can't do my normal R&D (rip-off and duplicate), I've had to resort to actual learning. These articles are intended as a means to provide me with a way to consolidate what I've copied/learned. They should also serve as a way to give other people a handy reference.

I've also created a solution on github to host the code. Fee free to download it, copy it, recycle it, or ignore it.

The Problem

This post is related to a question on stackoverflow.com, NHibernate 3.2 By Code ClassMapping for Version Property. SQL Server has an 8-byte incremental number, the timestamp, which can be used for row versioning. However, it's not immediately obvious how to map the column in the database to an entity.

Note: DateTime is bad for Timestamp

It's worth noting that a DateTime does not have sufficient resolution to be used as a timestamp. See this stackoverflow question, and this msdn article.

The Solution

Since a SQL timestamp is equivalent to the C# byte[] type, NHibernate needs help making the translation. The solution is using a custom IUserVersionType. Conveniently, there is already an implementation buried within the NHibernate source code: the BinaryTimestamp. Using this class, it's possible to map an entity's property to the table's column.

The custom type

This type tells NHibernate how to handle the conversion between the SQL timestamp type and C# byte[] type.

    public class BinaryTimestamp : IUserVersionType
    {
        #region IUserVersionType Members

        public object Next(object current, ISessionImplementor session)
        {
            return current;
        }

        public object Seed(ISessionImplementor session)
        {
            return new byte[8];
        }

        public object Assemble(object cached, object owner)
        {
            return DeepCopy(cached);
        }

        public object DeepCopy(object value)
        {
            return value;
        }

        public object Disassemble(object value)
        {
            return DeepCopy(value);
        }

        public int GetHashCode(object x)
        {
            return x.GetHashCode();
        }

        public bool IsMutable
        {
            get { return false; }
        }

        public object NullSafeGet(IDataReader rs, string[] names, object owner)
        {
            return rs.GetValue(rs.GetOrdinal(names[0]));
        }

        public void NullSafeSet(IDbCommand cmd, object value, int index)
        {
            NHibernateUtil.Binary.NullSafeSet(cmd, value, index);
        }

        public object Replace(object original, object target, object owner)
        {
            return original;
        }

        public System.Type ReturnedType
        {
            get { return typeof(byte[]); }
        }

        public SqlType[] SqlTypes
        {
            get { return new[] { new SqlType(DbType.Binary, 8) }; }
        }

        public int Compare(object x, object y)
        {
            var xbytes = (byte[])x;
            var ybytes = (byte[])y;
            return CompareValues(xbytes, ybytes);
        }

        bool IUserType.Equals(object x, object y)
        {
            return (x == y);
        }

        #endregion

        private static int CompareValues(byte[] x, byte[] y)
        {
            if (x.Length < y.Length)
            {
                return -1;
            }
            if (x.Length > y.Length)
            {
                return 1;
            }
            for (int i = 0; i < x.Length; i++)
            {
                if (x[i] < y[i])
                {
                    return -1;
                }
                if (x[i] > y[i])
                {
                    return 1;
                }
            }
            return 0;
        }

        public static bool Equals(byte[] x, byte[] y)
        {
            return CompareValues(x, y) == 0;
        }
    }

An example table definition


This is an example table. Note the name of the timestamp column. Our entity will use a differently named property to store the value in memory.

create table Orders
(
 OrderId bigint primary key identity
 ,Comments varchar(max) not null default ''
 ,DatePlaced datetime not null default getdate()
 ,LastModified timestamp not null
)

An example model/entity

    public class Order
    {
        public virtual long OrderId { get; set; }
        public virtual string Comments { get; set; }
        public virtual DateTime DatePlaced { get; set; }
        public virtual byte[] Version { get; set; }

        public override string ToString()
        {
            return string.Format("Order ({0}) - {1}", OrderId, DatePlaced);
        }
    }

An example of the mapping

The version statement contains the instructions for NHibernate. mapper.Generated(VersionGeneration.Always) tells NHibernate that SQL Server will handle generation of the value. mapper.Column("LastModified") tells NHibernate that the name of the column is different from the name of the property. mapper.Type<BinaryTimestamp>() tells NHibernate what class to use in converting the sql timestamp type to a C# byte[] and vice versa.

    public class OrderMap : ClassMapping<Order>
    {
        public OrderMap()
        {
            Table(DatabaseTable.Orders);

            Id(order => order.OrderId, mapper => mapper.Generator(Generators.Identity));
            
            Property(order => order.Comments);
            Property(order => order.DatePlaced);
            
            Version(order => order.Version, mapper =>
                          {
                              mapper.Generated(VersionGeneration.Always);
                              mapper.Column("LastModified");
                              mapper.Type<BinaryTimestamp>();
                          });
        }
    }

NHibernate 3.2 One-To-One Mapping with Foreign Key

Preface


Until recently, I'd been using FluentNhibernate to do my entity mappings in code. Recently, I decided to try the Loquacious (in-code) mapping now part of NHibernate. Since the project was already setup with NHibernate, it the mapping classes had to be converted. This was a (fairly) direct process, except for an oddball mapping we had.


The Problem

Using Loquacious (in code) mapping with NHibernate 3.2, we needed to do a one-to-one mapping of entities where the SQL Server tables had a PK<->FK relationship.

Our Design

Our tables looked like...

User
-----------
UserId (PK)
UserName

UserDetail
--------------------
UserDetailId (PK)
UserId (FK / Unique)
Notes

Our entities looked like...

public class UserInfo
{
    public virtual int Id { get; set; }
    public virtual string UserName { get; set; }
    public virtual UserDetail Details { get; set; }
}

public class UserDetail
{
    public virtual int Id { get; set; }
    public virtual UserInfo User { get; set; }
    public virtual string Notes { get; set; }
}

The important thing to note here is that the User entity does not have a List<Details> property. There will only be one UserDetail for any particular User.

What is a One-To-One Relationship?

A one to one mapping shouldn't use a foreign key. Instead, the tables should both use a synchronized primary key (the pk on both tables are the same value:

UserInfo
-----------
UserInfoId (PK)
UserName

UserDetail
-----------------
UserDetailId (PK/FK)
DetailInfo

The Solution

I failed at using Google to find a solution. There were a few mentions on Stack Overflow. One of the how-to articles on nhforge.org did get me started in the right direction. The problem with the article is that it uses xml mapping (didn't want to do that). It does not one of the major headaches I ran into: that when mapped it would fail to insert the dependent entity.

After poking around for some time, I stumbled on the solution (for our case): it was to reference the foreign key in the dependent entity. Our mapping classes turned out to look like the following:

public sealed class UserInfoMap : ClassMapping
{
    public UserInfoMap()
    {
        Table("UserInfos");

        Id(o => o.Id, map =>
        {
            map.Generator(Generators.Identity);
            map.Column("UserInfoId");
        });

        Property(o => o.UserName);

        OneToOne(o => o.Details,
                 map =>
                 {
                     map.PropertyReference(typeof(UserDetail).GetProperty("User"));
                     map.Cascade(Cascade.All);
                 });
    }
}


public class UserDetailMap : ClassMapping
{
    public UserDetailMap()
    {
        Table("UserDetails");

        Id(o => o.Id, map =>
        {
            map.Generator(Generators.Identity);
            map.Column("UserDetailId");
        });

        Property(o => o.Notes);

        ManyToOne(o => o.User,
                  o =>
                  {
                      o.Column("UserId");
                      o.Unique(true);
                      o.ForeignKey("Users_UserDetails_FK1");
                  });
    }
}

Hope this helps someone else...

NHibernate and Missing Castle dll

The Problem

MSbuild does not see a reference to the NHibernate.ByteCode.Castle assembly when building a project. Thus,  it does not copy the file into the output directory. This causes an exception when trying to execute code which relies on NHibernate.

The exception seen is usually something like: Could not load file or assembly 'NHibernate.ByteCode.Castle' or one of its dependencies...


The Solution


Bury a reference to the Castle assembly within your code:

class IncludeCastleDllInBuild : NHibernate.ByteCode.Castle.ProxyFactory
{
    //note : prevents missing dll issue with the Castle dll
}

FluentNhibernate and Bidirectional Relations

Preface

My last position had me using FluentNHibernate to handle my object persistence. We were using Oracle as a store. Many of the tables were quite large (100+ columns), and often did not have a primary key. The result was I often didn't have a good opportunity to use FNH's (NH's?) relationship capabilities.

My new position has me introducing FNH to some developers. The project is using SQL Server 2008 as a store, with tables that have primary keys, and other little should-haves.

The Problem

When saving new parents with new children, the children would not have their foreign key updated. The parent would save correctly. When any child object would save the database would throw an exception, because the foreign key constraint (not null) would be violated.

Our Design

Names changed to protect the innocent.

Our design was simple: a record in the database representing a file, and records being held in another table representing records within the file. After a bit of research, we realized that we needed a bi-directional relationship.

public class MyFile
{
    public virtual int MyFileId { get; set; }
    public virtual string FileName { get; set; }
    public virtual IList<Record> Records  { get; set; }
}

public class Record
{
    public virtual int MyRecordId { get; set; }
    public virtual int MyFileId { get; set; }
    public virtual MyFile SourceFile { get; set; }
    public virtual int RecordType { get; set; }
}

Our mapping classes were pretty simple too:

public sealed class MyFileMap : ClassMap<MyFile>
{
    public MyFileMap()
    {
        Table("MyFile");

         Id(o => o.MyFileID, "MyFileID").GeneratedBy.Identity();

        Map(o => o.FileName).Column("FileName");

        HasMany(o => o.Records).KeyColumn("InFileID")
            .Inverse().Cascade.All().AsBag();
    }
}

public sealed class RecordMap : ClassMap<Record>
{
    public WEXTicketRequestDetailMap()
    {
        Table("Record");

        Id(o => o.RecordID, "RecordID").UnsavedValue(0);

        References(o => o.SourceFile)
            .Column("MyFileID").Cascade.All();

        Map(o => o.RecordType).Column("RecordType");
    }
}

We'd create the classes and attempt to save them to the database:

// ... some code
var record = new Record();
var file = new MyFile{ // set some file stuffs here };
file.Records = new List<Record>{ record };
// ... more stuff here, including creating a session and transaction
session.Save(file);

This would result in an exception being thrown, as the foreign key on the Record object wasn't being set.

The Solution

A little searching (okay, a lot of searching) finally led us to a Stack Overflow post. Therein an answer by James Gregory showed us what we were doing wrong: we needed to set the parent entity on the child.

// ... some code
var record = new Record();
var file = new MyFile{ // set some file stuffs here };

record.SourceFile = file; // <-- this is the important part

// ... more stuff here, including creating a session and transaction
session.Save(file);

Once that was done, everything was good.