Created relp input plugin

It just about works, but that's pretty much the only thing it's
got going for it; it's very crude and bodges a lot of the protocol
in order to get at the logs.
Done some cleaning up

Have created proper methods for some of the things I was bodging
and done some other minor tweaking
Sorted connection closing

Now deals properly with close commands and is able to send
serverclose hints. Also fixed what turned out to be an issue with
0 length messages not being read due to the lack of a space after
datalen.
Improved initialisation

relp_initialise now fails in a sensible way if the client does not
start with an open command or if a few other conditions are not
met. In the case of failure the whole connection is closed and we
wait for a new one to be made (as per the specification re. errors)
Added various logging bits
Rewritten relp bits as a separate class RelpSocket

All the functionality around handling the specifics of the relp
protocol are now in a separate class; this does not include
deciding when to send the ack. This allows the input code to
ensure that the data has made it into the queue before
acknowledging.

It might be a good idea to separate the RelpSocket class into a
gem of its own eventually?
Defined and starded using some exceptions

Defined RelpError and several subclasses; fiddled the methods so
that they raise exceptions where sensible instead of horrible
things I was doing. They are still somewhat arbitrary and haphazard
so may need to be changed in the future
Fixed the exception handling

Committing without proper testing meant that the last commit had
various problems with the exception handling; I've hopefully fixed
all these. I'm still a bit dubious about raising an error for them
all, I ought to look into how inputs generally report things.
Minor tweaks

Done some style cleanups to work towards complying with logstash
coding style. Also finally got round to defining the offer
parameters as contstants at the beginning of the class and tweaked
valid_command? appropriately
Broken RelpSocket out into Relp and RelpServer

Started the move towards a more general Relp library; Relp exists
as a source of inherited methods for RelpServer and RelpSource(not
yet in existance, will be required to write tests). I've also done
some more tweaking with exceptions.
Separated RelpServer out a bit more

You now no longer need to give RelpServer a TCPSocket, just an ip
and port number. It will handle setting up the connection itself.
Separated relp code out into util/relp.rb

The Relp, RelpServer have been separated out into a spearate file,
I've also made a start on RelpClient. The way in which this handles
replies doesn't feel right, so is liable to change; this incluedes
the way in which syslog_write blocks until a reply is recieved.
Written first attempt at tests

Copied test_gelf and altered the gelf specific parts to relp; not
entirely sure if there is a standard set of things to test. Should
I intentially send bad offer frames and check that the appropriate
exceptions get raised? What about invalid/inappropriate relp
commands? What about frames with an incorrect datalen to cause
frame misalignment?
Made required commands in handshake variables

Syslog is no longer hardcoded in as the one required command, you
can pass an array to RelpServer or RelpClient on creation. All
elements in this array must be offered by the other participant for
the handshake to complete.
Improved handling of txnrs

txnrs are now automatically handled for all client transmissions
unless they are hints (txnr=0). I think for server transmissions we
simply have to trust that the application code is getting them
correct.
Fixed teardown

Fixed the problem with the teardown. closing a connection and
stopping the server are two different things so need two different
methods; shutdown closes the server thread.
Odd bits & bobs

Cleaned up a variety of odd bits and pieces that were lying about
Fixed typo in last commit
Further tweaked exception/error handling
Improved the RelpClient interface

I've fiddled the model around slightly so that it is non-blocking
unless its buffer has filled up. Returning the unacked frames on
close is a bit dodgey, but does allow some way to recover them in
case of problems. I'm still not all that happy with RelpClient so
it is liable to be changed again