A minimalistic message queue server, in Go

lineup, a tiny queue server

  lineup is a very simple queue server. all it
  does is serve a binary-safe priority queue with
  a simple protocol inspired by redis and
  memcached.
  
  it's designed to be as small, simple, and
  hackable as possible.
  
why?

  most of the reasons i made this are personal.
  
    - i wanted to
    - i learned a lot
    
  there are some pragmatic reasons too!
  
    - minimalist codebase
    - i don't agree with how other queue servers
      are implemented (except maybe resque)
    - i didn't make the other ones
    
  i kept lineup as simple as possible, because it
  needed to be that way. stuff like job timeouts,
  multiple queues, etc. can all be managed by
  client code. if your job takes too long, just
  stop processing and requeue it. want multiple
  queues? run multiple instances of lineupd.
  
  that's not to say that lineupd is complete, not
  to any degree.
  
usage

  run lineupd and it will listen on :9876, and
  create a logfile lineupd.log and pidfile
  lineupd.pid. if you want to explicitly set any
  options, there are --port, --logfile, and
  --pidfile command line options. there is also
  the --timeout option, which sets the number of
  seconds to wait to disconnect an idle client.
  
bugs

  - the --daemonize option doesn't work yet. most
    of the code is there, but i can't find a
    plain old fork() call in the go stdlib. help
    here would be great.

credits

  (c) 2009 justin poliey http://justinpoliey.com
  inspired by:
    redis http://code.google.com/p/redis
    memcached http://memcached.org
    beanstalkd http://kr.github.com/beanstalkd
    suckless http://suckless.org