Allow custom message-decoding functions for TCP and UDP servers.

Also rework server to use an in-IO-thread message decoder and run `handle`
calls over thread pools for both TCP and UDP.
Merge pull request #21 from banjiewen/pluggable-decoders

Allow custom message-decoding functions for TCP and UDP servers.
Minor tuning.
Add a graphite listener.

This will obviously be less efficient than the protobuf tcp-server
or udp-server. But it will allow easy set up with other tools
in the monitoring chain - collectd, statsd for instance -
with very little configuration.

In the configuration, a graphite server is simply started by
issuing `(graphite-server)`. The server will yield events with
only service, metric and timestamp filled. NaN values will be
discarded.

Should you want to do additional handling on the values you
can feed graphite-server a parser-fn yielding a map to
merge onto the event. For instance if you emit data
from collectd using the write_graphite output with the following
configuration:

```
<LoadPlugin write_graphite>
<Plugin write_graphite>
<Carbon>
        Prefix "collectd."
	Host "localhost"
	Port 2003
</Carbon>
</Plugin>
```

You can use the following to have a nicer event, containing hostname
and tags:

```clojure
(graphite-server
 :parser-fn (fn [{:keys [service] :as event}]
              (if-let [[src host service & tags]
                       (clojure.string/split service #"\.")]
                {:host (clojure.string/replace host #"_" ".")
                 :service (clojure.string/join "." (concat [service] tags))
                 :tags (concat tags [src])})))
```
Switch pubsub registry to an atom.

I suppose later on a protocol could be implemented for this,
allowing interfacing with external pubsub systems.
use clojure.set directly
Remove control flow funcs not used anywhere

Past a certain point futures are not as reliable or should
be started within a controlled thread-pool and not clojure's
default thread-pools.
kill tests for funcs that do not exist anymore
kill set functions that are unused
split where into where and where-event, avoiding symbol touching

This saves the guesswork to figure out the current event's symbol
name which is rather risky
Use an atom pointing to a simple list to store events in coalesce.

A possible further optimization would be to store events sorted
by their ttl, and thus dropping every expired events, then
returning the rest of the list.
Ensure only the last event per host/service pair shows up
Merge pull request #24 from pyr/feature-atomize-coalesce

Use an atom pointing to a simple list to store events in coalesce.
Merge pull request #25 from pyr/feature-atomize-pubsub

Switch pubsub registry to an atom.
Readme: obvious link to main site.
Fixed and moving windows in event and time space.

Fixed windows are disjoint partitions of the underlying stream at
regular intervals. Moving windows retain a set of recent events and
forward the most recent window on each event.

(fixed-time-window n ...)
(fixed-event-window n ...)
(moving-time-window n ...)
(moving-event-window n ...)
Merge branch 'master' of github.com:aphyr/riemann
Less aggressive/verbose JVM opts.
(window) is now an alias for (moving-event-window).
Change streams/moving-event-window to use take-last instead of subvec.

subvec maintains a reference to the head of the parent vector, which of
course causes memory leakage after a while. This version may be somewhat
less efficient (I've not profiled it) but memory usage will be stable.