The NServiceBus data bus allows you to send very large messages by putting them on a shared resource and sending the reference to it. An obvious use case for this is using RavenFS. I took a few moments and wrote an implementation for that*.

public class RavenFSDataBus : IDataBus, IDisposable
{
    private readonly FilesStore _filesStore;
    private Timer _timer;


    private object _locker = new object();
    private void RunExpiration(object state)
    {
        bool lockTaken = false;
        try
        {
            Monitor.TryEnter(_locker, ref lockTaken);
            if (lockTaken == false)
                return;

            using (var session = _filesStore.OpenAsyncSession())
            {
                var files = session.Query()
                    .WhereLessThan("Time-To-Be-Received", DateTime.UtcNow.ToString("O"))
                    .OrderBy("Time-To-Be-Received")
                    .ToListAsync();

                files.Wait();

                foreach (var fileHeader in files.Result)
                {
                    session.RegisterFileDeletion(fileHeader);
                }

                session.SaveChangesAsync().Wait();
            }
        }
        finally
        {
            if (lockTaken)
                Monitor.Exit(_locker);
        }
    }

    public RavenFSDataBus(string connectionString)
    {
        _filesStore = new FilesStore
        {
            ConnectionStringName = connectionString
        };
    }

    public RavenFSDataBus(FilesStore filesStore)
    {
        _filesStore = filesStore;
    }

    public Stream Get(string key)
    {
        return _filesStore.AsyncFilesCommands.DownloadAsync(key).Result;
    }

    public string Put(Stream stream, TimeSpan timeToBeReceived)
    {
        var key = "/data-bus/" + Guid.NewGuid();
        _filesStore.AsyncFilesCommands.UploadAsync(key, stream, new RavenJObject
        {
            {"Time-To-Be-Received", DateTime.UtcNow.Add(timeToBeReceived).ToString("O")}
        }).Wait();

        return key;
    }

    public void Start()
    {
        _filesStore.Initialize(ensureFileSystemExists: true);
        _timer = new Timer(RunExpiration);
        _timer.Change(TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));
    }

    public void Dispose()
    {
        if (_timer != null)
            _timer.Dispose();
        if (_filesStore != null)
            _filesStore.Dispose();
    }
}

* This is written to check it out, hasn’t been tested very well yet.

This started out as a question in the mailing list. Consider the following (highly simplified) model:

   public class Building
   {
       public string Name { get; set; }
       public List<Floor> Floors { get; set; }        
   }
   
   public class Floor
   {
       public int Number { get; set; }
       public List<Apartment> Apartments { get; set; }
   }
 
   public class Apartment
   {
       public string ApartmentNumber { get; set; }
       public int SquareFeet { get; set; }
   }

And here you can see an actual document:

{
    "Name": "Corex's Building - Herzliya",
    "Floors": [
        {
            "Number": 1,
            "Apartments": [
                {
                    "ApartmentNumber": 102,
                    "SquareFeet": 260
                },
                {
                    "ApartmentNumber": 104,
                    "SquareFeet": 260
                },
                {
                    "ApartmentNumber": 107,
                    "SquareFeet": 460
                }
            ]
        },
        {
            "Number": 2,
            "Apartments": [
                {
                    "ApartmentNumber": 201,
                    "SquareFeet": 260
                },
                {
                    "ApartmentNumber": 203,
                    "SquareFeet": 660
                }
            ]
        }
    ]
}

Usually the user is working with the Building document. But every now an then, they need to show just a specific apartment.

Normally, I would tell them that they can just load the relevant document and extract the inner information on the client, that is very cheap to do. And that is still the recommendation. But I thought that I would use this opportunity to show off some features that don’t get their due exposure.

We then define the following index:

Note that we can use the Query() method to fetch the query specific parameter from the user. Then we just search the data for the relevant item.

From the client code, this will look like:

var q = session.Query<Building>()
    .Where(b =>/* some query for building */)
    .TransformWith<SingleApartment, Apartment>()
    .AddTransformerParameter("apartmentNumber", 201)
    .ToList();


var apartment = session.Load<SingleApartment, Apartment>("building/123",
        configuration => configuration.AddTransformerParameter("apartmentNumber", 102));

And that is all there is to it.

I’m porting Voron to Mono (currently testing on Ubuntu). I’m using Mono 3.2.8, FWIW, and working in MonoDevelop.

So far, I have run into the following tangles that are annoying.  Attempting to write to memory that is write protected results in null reference exception, instead of access violation exception. I suspect that this is done because NRE is generated on any SIGSEGV, but that led me to a very different path of discovery.

Also, consider the following code:

using System.IO;
using System.IO.Compression;

namespace HelloWorld
{
    class MainClass
    {

        public static void Main (string[] args)
        {
            new ZipArchive (new MemoryStream ());
        }
    }
}

This results in the following error:

Unhandled Exception:
    System.NotImplementedException: The requested feature is not implemented.
        at HelloWorld.MainClass.Main (System.String[] args) [0x00006] in /home/ayende/HelloWorld/HelloWorld/Program.cs:11
        [ERROR] FATAL UNHANDLED EXCEPTION: System.NotImplementedException: The requested feature is not implemented.
        at HelloWorld.MainClass.Main (System.String[] args) [0x00006] in /home/ayende/HelloWorld/HelloWorld/Program.cs:11

This is annoying in that it isn’t implemented, but worse from my point of view is that I don’t see any ZipArchive in the stack trace. That made me think that it was my code that was throwing this.

Update: We delayed the RC release by a week or two because we wanted to finish the new website. But I decided that it doesn't make sense to at least give you the RC bits so you can play with them. You can look at the new website at http://beta.ravendb.net, it should be done in about a week (we are in a holidays period right now, which slow things down). 

I’m taking a break from explaining what is new in RavenDB 3.0 because we have more important news. This is still release candidate, because we want to get more feedback from the field before we can say that this is a final version. The plan is to give the RC a few weeks to mature, and then make a full release. This also comes with Go Live version, so this is fully support for production (and much easier to deal with on production).

This release also include a new website for RavenDB, as well as the updated licensing. Note that we provide a 20% discount for purchases during the RC period. For customers that purchased a RavenDB license since 1 Jul 2014, can upgrade (for no cost) to a RavenDB 3.0 release.

You can go to our site to see how things changes.

This took a bit less than what I expected, but…

And yes, it works. And this is running on Ubuntu.

And no, it isn’t ready.

In this talk I started out talking about polyglot persistence, but it actually turned out to be more of a discussion of where we want to take RavenDB in the next version (probably 4.0).

RavenDB - Polyglot Persistence from Øredev Conference on Vimeo.

Yesterday I talked about using multiple persistence technologies in a single application. You can download the code for this talk here and the slides are available here.

I’m pretty proud of that talk, it went very well, I think.

Mauro is talking in depth about using indexes & transformers here:

RavenDB - In Depth, mastering Indexes and Transformers from Øredev Conference on Vimeo.

Mauro and Manuel are talking about tax returns in Italy, and how RavenDB helps process a lot of them.

RavenDB - Case Study: Building multi-million document applications with scalability in mind from Øredev Conference on Vimeo.

This is frustrating. I’m trying to use the new Google Domains (if only because I’m sick of GoDaddy’s aggressive upsale approach).

This is what happened when I tried it.

That sucks, but I’m actually a business user for Google Apps, so I called their support. I’m currently on the 32th minute of the call, and so far they explained to me numerous times that this is not possible to do, and are still unable to tell me why they are refusing to take my card.

I can understand, beta service and all of that, but using Wallet isn’t beta, and not being able to tell me what is wrong is not cool.