Question

We have a data system in which writes and reads can be made in a couple of geographic locations which have high network latency between them (crossing a few continents, but not this slow). We can live with ‘last write wins’ conflict resolution, especially since edits can’t be meaningfully merged.

I’d ideally like to use a distributed system that allows fast, local reads and writes, and copes with the replication and write propagation over the slow connection in the background. Do the datacenter-aware features in e.g. Voldemort or Cassandra deliver this?

It’s either this, or we roll our own, probably based on collecting writes using something like
rsync and sorting out the conflict resolution ourselves.

Answer 1

You should be able to get the behavior you’re looking for using Voldemort. (I can’t speak to Cassandra, but imagine that it’s similarly possible using it.)

The key settings in the configuration will be:

• replication-factor — This is the total number of times the data is stored. Each put or delete operation must eventually hit this many nodes. A replication factor of n means it can be possible to tolerate up to n – 1 node failures without data loss.

• required-reads — The least number of reads that can succeed without throwing an exception.

• required-writes — The least number of writes that can succeed without the client getting back an exception.

So for your situation, the replication would be set to whatever number made sense for your redundancy requirements, while both required-reads and required-writes would be set to 1. Reads and writes would return quickly, with a concomitant risk of stale or lost data, and the data would only be replicated to the other nodes afterwards.