validates_presence_of :purpose : Tag couchapp, everything about couchapp

Ta-da! Here is my thesis.

Wed, 27 Oct 2010 14:02:00 +0000

I’m happy to announce the immediate availability of my thesis! It was handed in in July 2010 as my diplom thesis in the academic program of Media Informatics at Beuth Hochschule für Technik Berlin (University of Applied Sciences). A German Diplom is comparable to a combined bachelor’s and master’s degree. Originally it has been written in German, so I’m very happy it’s also available for English speaking readers now: thanks a lot to the awesome Sander Van de Moortel for translating it into English, and to CouchOne for sponsoring the translation. Read also my thank you notes for more gratefulness.

I hope the thesis is an interesting read and useful for your research or development!

The title is “Implementation of a distributed application using the document-oriented database CouchDB — An outliner as a replicable distributed system” (originally “Umsetzung einer verteilten Anwendung mit der dokumentenorientierten Datenbank — CouchDB Ein Gliederungseditor als replizierbares Verteiltes System”).

What is it about? I wrote a couple of words about that for the Upstream blog. Here is also the abstract — all the contents in ten sentences:

Modern web browsers and mobile devices are capable of running complex applications that allow collaboration and data exchange between their users. Laptops and mobile phones, however, cannot be expected to keep their internet connections alive at all times. This problem can be sidestepped using data replication, which means that data are regularly synchronised and kept consistent. This thesis describes the drafting and prototypical development of a JavaScript application that uses the document-oriented database CouchDB to form distributed outliner software. Outliners can be used to record thoughts or concepts in a hierarchically structured manner. Apart from categorising the system to be developed and analysing possible approaches, the thesis will also examine the technologies used. Special focus lies on CouchDB with its built-in master-master replication and its ability to implement complex applications without the use of middleware. The final application runs locally in the browser and is therefore also usable when off-line. Conflicts are resolved when the system is synchronised, sometimes steered by user input. The thesis also evaluates the applicability of CouchDB in distributed applications with particular regard to the use case at hand.

Download

Read the English version and the German version online,
check out the English LaTeX sources or the German LaTeX sources on github, or
download the pdf in English or in German.

BibTeX

In case you want to quote me in your paper/thesis/homework, here’s the BibTeX entry:

@mastersthesis{herrmann:couchdb,
  author = {Lena Herrmann},
  title = {Realisation of a Distributed Application Using the Document-Oriented Database CouchDB - An Outliner as a Replicable Distributed System},
  school = {University of Applied Sciences Berlin},
  year = {2010},
  month = {July}
}

@mastersthesis{herrmann:couchdb,
  author = {Lena Herrmann},
  title = {Umsetzung einer verteilten Anwendung mit der dokumentenorientierten Datenbank CouchDB - Ein Gliederungseditor als replizierbares Verteiltes System},
  school = {Beuth Hochschule für Technik Berlin},
  year = {2010},
  month = {Juli}
}

The Application

The hands-on part is an outliner that allows people to collaborate on documents even when they don’t have continuous internet access. If you want to read/clone/try out/improve/take apart/whatever the source code, it’s here on github. The github README contains installation and usage instructions, for more details read chapter 9, “Application”, in the thesis.

You can also try out the outliner online. Though, in order to enjoy the replication and conflict resolution features, you have to (also) install it locally. But it’s a couchapp - when you have CouchDB running you’re almost there already.

I hope you all like it!

Pretty URLs for you couchapp, the howto

Mon, 11 Oct 2010 15:34:00 +0000

If you have a couchapp and want to have nice URLS, go read this blogpost. If you still don’t get it, here is how to do it. It doesn’t work with my outliner app, because it is so entangled with old couchapp and jquery.couch.js versions and I’m not up to upgrade hell right now. But I’ll write it down for my next project and for you, yay.

Let’s say you have an app running at http://account.couchone.com/mydb/_design/doingnotes/index.html and want to add the additional URL http://account.couchone.com/index.html. First you have to set up a virtual host. (Want to know why? Go back read the blogpost). If you are using a hosted CouchDB instance and don’t have access to the local.ini file, you can also do this remotely:

curl -X PUT http://username:password@account.couchone.com/_config/vhosts/account.couchone.com -d '"/mydb/_design/doingnotes/_rewrite"'

Check at the bottom of http://account.couchone.com/_utils/config.html if there is a key value pair “account.couchone.com” => “/mydb/_design/doingnotes/_rewrite”.

Now it won’t work yet, because you still have to add the rewrite(s) to your design document. Do this by adding a file “rewrites.json” in your project folder. I has to contain an array of json objects with a “from” and a “to” attribute each. They work down in the path starting with the design document (the “doingnotes” in the URL). You can use wildcards. “from” specifies where it should map from, “to” which file it should map to. This is how rewrites.json looks for my application:

[{
  "from": "",
  "to": "index.html"
},
{
  "from": "vendor/*",
  "to": "vendor/*"
},
{
  "from": "app/*",
  "to": "app/*"
},
{
  "from": "config/*",
  "to": "config/*"
},
{
  "from": "_view/*",
  "to": "_view/*"
}]

If you just put the first from/to pair in, you can already call the application, but it won’t work because the code in the design document needs access to all the folders that are stored in the application’s root level (that is not in the “_attachments” folder). The wildcards map everything down from that path. If you have code in other locations as well, you have to add rewrites for those folders too. That’s it.

Couchapp / Culerity glitches, part 1

Wed, 04 Nov 2009 10:07:00 +0000

Do you know what's behind these buzzwords: CouchDB / Couchapp / Sammy.js? Not really? Then please look at this article now: Sammy.js, CouchDB, and the new web architecture. The title says it all.

This setup happens to be the field of my diploma thesis, friendly sponsored and supported by Upstream. During the next months I'll develop a super duper thing with these technologies, and then I'll write 80 scientific pages about it. Yees, I'm not that much looking forward to the second part! Until then, I'm planning to semi-regularly blog about my findings.

I'm not allowed to share the code before I have the diploma in my hands. But, because my workmate Frank Proessdorf is so jealous of what I do, he and I started working on an app with a similar setup on our Upstream Research Fridays, to try things out. Here it is. Don't expect anything yet.

Today I'm going to tell you about some details of my testing setup. My *cough* supervising tutor Alexander Lang already wrote down all there is to know yet about Test-Driven Development with Cucumber-Culerity-Celerity and Couchapps.

But there are a few things that will make your life hard, when the almost perfect Rails testing world has spoiled you as much as me. One thing is that we have to deal with a lot of asynchrony. Sammy renders the page, loads the data from the couch, and whenever the data is there it gets rendered into the page. The best way to do this is via callbacks. I'm going to write another blog post about that soon.

In the integration test the problem is that celerity doesn't behave as it claims it does:

$browser.wait

is supposed to make the test wait until everything is rendered completely. But for whatever reason it doesn't. The result is that your test fails because it searches for your expressions in an unfinished page.

Because of that, in culerity we need something like:

sleep 0.4

after every follow, press and go-to-path step. When using culerity in a Rails environment, this usually is enough. Sammy behaves a bit more unpredictable - it sometimes takes more than a whole second until everything is loaded.

Solution? We can either increase the sleep time a lot, but that's not very nice, the features need long enough to run as it is. Fortunately we can use another method that's build into celerity: wait_while.

I created a div "spinner" somewhere in index.html:

 <div id="spinner"></div>

You can also add an actual spinner gif here. Just take care to place the div outside of your sammy element selector ("#main" by default), because this div gets replaced all the time.

We need to show that div before every route that gets run. In application.js:

before(function() {
  $('#spinner').show();
});

And we need to hide it after your rendering is completed. I haven't found an ideal solution where to do that, it depends on the application you are writing. As a quick and dirty fix, you can add it as a last line in sammy's partial function, in sammy.js:

partial: function(path, data, callback) {
  //...
  $('#spinner').hide();
},

I prefer to have more control about when I hide it, as my partial calls sometimes have nested callbacks. So I put it in application.js, resp. in my controllers, after each render call or in the partial callbacks. I admit this still sucks a bit.

Finally, amend the cucumber step:

When /I wait for the AJAX call to finish/ do
  sleep 0.2
  puts 'Waiting for page to load ...' if $browser.div(:id, 'spinner').visible?
  $browser.wait_while { $browser.div(:id, 'spinner').visible?} 
end

The browser still needs to sleep a bit before it actually finds the spinner div. But with this step in my common_culerity_steps.rb, the features finally run smoothly.