pipeline_toolkit 1.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/README.rdoc

@@ -0,0 +1,54 @@
+= Pipeline Toolkit
+by VisFleet
+
+Command line tools for processing messages by constructing a pipeline of workers. AMQP and Unix pipes are used to construct the pipeline. Messages are simple Hashs (serialized as YAML) so they can hold any values and change throughout the processing.
+
+Provides:
+- Processing acknowledgments, ensuring the a message is only disposed of once it has been successful processed
+- Performance. Messages are moved through the pipeline fast
+- Command line tools for:
+  - Subscribing to messages from an AMQP queue
+  - Pushing messages back onto an AMQP exchange
+  - Monitoring performance (see msg_probe)
+- A base module (MessageCommand) to include into your own classes to quickly make workers.
+
+== Install
+
+  > gem sources -a http://gems.github.com
+  > sudo gem install visfleet-pipeline_toolkit
+
+=== Dependancies
+
+It is assumed that you have:
+- An AMQP msg server to pop and push messages to (e.g. http://www.rabbitmq.com/)
+- A *nix system, such as Linux or Mac OS X.
+
+== Usage
+
+1. Create your worker
+
+  class MyWorker
+    include MessageCommand
+    
+    def process_message(msg)
+      # do stuff here
+      msg
+    end
+  end  
+  MyWorker.new.start
+
+2. Hook it up to the main pipe (i.e. the AMQP server)
+
+  > msg_subscribe.rb -q source | my_worker.rb | msg_push.rb -x dest
+
+You can learn more about the command line tools and what options are available by using their help command.
+  
+  > msg_subscriber --help
+  > msg_push --help
+  > msg_sink --help
+  > msg_probe --help
+
+
+  
+
+

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "pipeline_toolkit"
+    gem.summary = %Q{Toolkit for building processing pipelines using Unix Pipes and AMQP messages}
+    gem.email = "labs@visfleet.com"
+    gem.homepage = "http://github.com/visfleet/pipeline_toolkit"
+    gem.authors = ["Aisha Fenton"]
+    gem.executables = ["msg_probe.rb", "msg_subscribe.rb", "msg_push.rb", "msg_sink.rb", "msg_generator.rb"]
+    gem.add_runtime_dependency('amqp', ">=0.6.4")
+    gem.add_runtime_dependency('trollop', ">=1.14")
+    gem.add_runtime_dependency('eventmachine', ">=0.12.8")
+  end
+  Jeweler::GemcutterTasks.new  
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+task :default => :build
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "pipeline_toolkit #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.1

data/bin/msg_generator.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'trollop'
+require 'pipeline_toolkit'
+
+opts = Trollop::options do
+  banner <<-EOS
+  Generates messages for testing the pipeline
+  Usage:
+        msg_generator.rb -m "My message"
+  EOS
+  opt :msg, "The message to send", :short => "m", :default => "Test message"
+  opt :delay, "Sleep time between sends in seconds", :short => "d", :type => :float
+end
+
+class MsgGenerator
+
+  def initialize(opts)
+    @delay = opts.delay
+    @msg = opts.msg
+  end
+
+  def start
+    loop do
+      self.send_msg(@msg)
+      sleep(@delay) unless @delay.nil?
+    end
+  end
+
+  def send_msg(msg)
+    puts MessageCoder.encode(@msg)
+    $stdout.flush
+  end
+end
+
+MsgGenerator.new(opts).start

data/bin/msg_probe.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'trollop'
+require 'pipeline_toolkit'
+
+opts = Trollop::options do
+  opt :interval, "Time in seconds between updates", :short => "i", :default => 2
+  opt :http_port, "The HTTP server port for accessing the stats", :default => 9070
+  opt :name, "The name of the probe. Used in monitoring", :type => :string, :short => 'n'
+end
+
+MessageProbe.new(opts).start

data/bin/msg_push.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'trollop'
+require 'pipeline_toolkit'
+
+opts = Trollop::options do
+  opt :exchanges, "The destination exchange(s)", :short => "x", :type => :strings
+  opt :key_eval, "A string of ruby code that is evaluated to produce a routing key for a given message. 
+                  By default each message has no routing key", :short => "e", :type => :string
+  opt :key_file, "A ruby file that gets included which contains a custom route_key method", :short => "f", :type => :string
+  
+  # Msg server
+  opt :host, "The AMQP message server host", :default => "localhost"
+  opt :port, "The AMQP message server port", :default => "5672"
+  opt :user, "The AMQP message server username", :default => "guest"
+  opt :pass, "The AMQP message server username", :default => "guest"
+  opt :vhost, "The AMQP message server vhost", :default => "/"
+end
+
+mp = MessagePusher.new(opts)
+# FIXME. Should be in MessageCommand class
+Signal.trap('INT') { mp.stop }
+Signal.trap('TERM'){ mp.stop }
+mp.start

data/bin/msg_sink.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'trollop'
+require 'pipeline_toolkit'
+
+# opts = Trollop::options do
+#   opt :interval, "Interval", :short => "i", :default => 100
+# end
+
+MessageSink.new.start

data/bin/msg_subscribe.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'trollop'
+require 'pipeline_toolkit'
+
+opts = Trollop::options do
+  opt :exchange, "The exchange to subscribe to", :short => "x", :type => :string
+  opt :queue, "The source queue", :short => "q", :type => :string
+  opt :ack, "Switch that requires that messages are successfully processed before continuing with the next message", :short => "a"
+  opt :topic, "The queue topic to subscribe to", :short => "t", :type => :string
+  opt :max_unackd, "The maximum number of unaknowledged messages to buffer before waiting for them to be acknowledged. Defaults to 100", :default => 100
+  
+  # Msg server
+  opt :host, "The AMQP message server host", :default => "localhost"
+  opt :port, "The AMQP message server port", :default => "5672"
+  opt :user, "The AMQP message server username", :default => "guest"
+  opt :pass, "The AMQP message server username", :default => "guest", :short => "w"
+  opt :vhost, "The AMQP message server vhost", :default => "/"
+end
+
+ms = MessageSubscriber.new(opts).start

data/lib/pipeline_toolkit.rb

@@ -0,0 +1,8 @@
+require "pipeline_toolkit/default_logger"
+require "pipeline_toolkit/message_coder"
+require "pipeline_toolkit/message_command"
+require "pipeline_toolkit/message_probe"
+require "pipeline_toolkit/message_pusher"
+require "pipeline_toolkit/message_subscriber"
+require "pipeline_toolkit/message_sink"
+require "pipeline_toolkit/open_hash"

data/lib/pipeline_toolkit/default_logger.rb

@@ -0,0 +1,18 @@
+require "logger"
+require 'syslog_logger'
+
+# OPTIMIZE. Is there a better way to handle default/common/shared logging?
+module DefaultLogger
+  
+  # Return the logger for this class
+  def log
+    @logger ||= SyslogLogger.new(self.syslog_name)
+  end
+  
+  def syslog_name
+    "pipeline-" + Process.ppid.to_s
+  end
+  
+end
+
+

data/lib/pipeline_toolkit/message_coder.rb

@@ -0,0 +1,19 @@
+
+# Encodes messages
+# 
+class MessageCoder
+
+  def self.encode(msg)
+    # NB: Using Marshal here because it's 9-10x faster than to_yaml
+    # See http://gist.github.com/190849
+    str = Marshal.dump(msg)
+    str.gsub!("\n", '--\\n')
+    str
+  end
+
+  def self.decode(str)
+    str.gsub!('--\\n', "\n")
+    Marshal.load(str)
+  end
+  
+end

data/lib/pipeline_toolkit/message_command.rb

@@ -0,0 +1,97 @@
+require "rubygems"
+require "eventmachine"
+
+module MessageCommand
+  include DefaultLogger
+  
+  attr_reader :sys_pipe
+
+  def start
+    log.info("starting")
+
+    Signal.trap('INT') { EM.stop }
+    Signal.trap('TERM'){ EM.stop }
+
+    @ack_buffer ||= ""
+
+    begin
+      EM.run do
+        self.init_loop
+        conn = EM.watch($stdin, ProcessLine, self)
+        conn.notify_readable = true
+      end
+    rescue StandardError => e
+      log.info e
+      raise e
+    ensure
+      self.shutdown
+    end
+  end
+  
+  def shutdown
+    log.info("shutting down")
+    @sys_pipe && @sys_pipe.close
+  end
+  
+  def process_line(line)
+    msg = MessageCoder.decode(line)
+    
+    case msg[:msg_type]
+    when :system
+      result = process_system(msg)
+    else
+      result = process_message(msg)
+    end
+    
+    case result
+    when :ack
+      self.ack_msg(msg)
+    else
+      self.pass_on_msg(result)
+    end
+  end
+  
+  def ack_msg(msg)
+    return unless @use_ack
+    @sys_pipe.syswrite(msg.ack_id + "\n")
+  end
+
+  def pass_on_msg(msg)
+    $stdout.syswrite(MessageCoder.encode(msg) << "\n")
+  end
+
+  # Override in included class. Provides a chance to initialize any
+  # code that needs to take place once the EM loop has started.
+  def init_loop
+    # Implemented in class that includes me
+  end
+
+  # Override in included class. Processes a message. This method
+  # must return either a msg object -- which may or may not have been modified -- or the symbol :ack.
+  # Returning :ack mean that the message has been dealt with and can be acknowledged back to the queue 
+  # server. All messages must be acknowledged by at least one message_command.
+  def process_message(msg)
+    # Implemented in class that includes me
+    msg
+  end
+
+  def process_system(msg)
+    @sys_pipe = File.open(msg.sys_pipe, "w")
+    @use_ack = msg.use_ack
+    @max_unackd = msg.max_unackd
+    msg
+  end
+
+  module ProcessLine
+    include DefaultLogger
+    
+    def initialize(msg_command)
+      @msg_command = msg_command
+    end
+    
+    def notify_readable
+      @msg_command.process_line(@io.gets)
+    end
+  end
+
+end

data/lib/pipeline_toolkit/message_probe.rb

@@ -0,0 +1,107 @@
+require 'evma_httpserver'
+
+class MessageProbe
+  include MessageCommand
+  attr_reader :mps, :uptime, :name
+
+  def initialize(opts)
+    @interval = opts.interval
+    @http_port= opts.http_port
+    @start_time = Time.now
+    @name = opts.name
+    self.reset
+  end
+
+  def init_loop
+    EM.start_server('0.0.0.0', @http_port, ProbeHttpRequest, self)
+    EM.add_periodic_timer(@interval) { self.tick }
+  end
+
+  def tick
+    @time_delta = Time.now - @prev_time
+    @mps = @count / @time_delta
+    
+    self.reset
+  end
+
+  def reset
+    @count = 0
+    @prev_time = Time.now
+  end
+  
+  def uptime
+    Time.now - @start_time
+  end
+  
+  def process_message(msg)
+    @count += 1
+    msg
+  end
+    
+end
+
+class ProbeHttpRequest < EM::Connection
+  include EM::HttpServer
+
+  def initialize(probe)
+    @probe = probe
+  end
+
+  def post_init
+    super
+    no_environment_strings
+  end
+
+  def process_http_request
+    response = EM::DelegatedHttpResponse.new(self)
+    response.status = 200
+    response.content_type 'text/html'
+    response.content = <<-EOL
+    <html>
+      <head>
+        <title>Message Probe</title>
+        <style type="text/css">
+          body {
+            background: black;
+            color: #80c0c0;
+          }
+          h1 {
+            font: 12pt Monospace;
+            text-align:center;
+          }
+          table {
+            font: 10pt Monospace;
+            margin-left:auto;
+            margin-right:auto;
+            text-align:right;
+          }
+          .page {
+            position:relative;
+            top: 20%;
+            # border-style:solid;
+            # border-width:5px;
+            width: 30%;
+            margin-left:auto;
+            margin-right:auto;
+          }
+        </style>
+      </head>
+      <body>
+        <div class=page>
+          <h1><span class="name">#{@probe.name}</span></h1>
+          <table>
+            <tr>
+              <td>messages per second:</td><td><span class="mps">#{@probe.mps}</span></td><td></td>
+            </tr>
+            <tr>
+              <td>uptime:</td><td><span class="uptime">#{@probe.uptime.to_i / 60}</span></td><td>mins</td
+            </tr>
+          </table>
+        </div>
+      </body>
+    </html>
+    EOL
+
+    response.send_response
+  end
+end

data/lib/pipeline_toolkit/message_pusher.rb

@@ -0,0 +1,54 @@
+require "mq"
+
+class MessagePusher 
+  include MessageCommand
+
+  def initialize(opts)
+    @key_eval = opts.key_eval
+    if opts.key_file
+      @key_file = opts.key_file
+      load_route(@key_file)
+      self.init_route
+    end
+    @exchange_names = opts.exchanges.map { |str| str.split(":") }
+    @msg_server_config = opts.select_keys(:host, :port, :user, :pass, :vhost)
+  end
+
+  def init_loop
+    @msg_server = MQ.new(AMQP.connect(@msg_server_config))
+    self.setup_exchanges
+  end
+
+  def setup_exchanges
+    @exchanges = []
+    @exchange_names.each do |name, type|
+      type ||= :fanout
+      @exchanges << MQ::Exchange.new(@msg_server, type.to_sym, name, :durable => true, :passive => false)
+    end
+  end
+
+  def load_route(key_file)
+    require key_file
+    self.extend eval(classify(key_file.gsub(".rb", "")))
+  end
+  
+  # Turn path Class or Module name (i.e. strip directories and turn into camel-case)
+  def classify(str)
+    str.gsub(/^.*\//, '').gsub(".rb","").gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+  
+  # is overriden by included fork_file if specified
+  def route_key(msg)
+    @key_eval ? eval(@key_eval) : nil
+  end
+
+  def process_message(msg)
+    @exchanges.each do |exchange|
+      key = route_key(msg)
+      exchange.publish(msg.to_yaml, :routing_key => key)
+      # OPTIMIZE. Using MessageCoder.encode(msg) instead of to_yaml is 2x faster. But won't be easy to debug. Worth it?
+    end
+    :ack
+  end
+
+end

data/lib/pipeline_toolkit/message_sink.rb

@@ -0,0 +1,8 @@
+class MessageSink
+  include MessageCommand
+  
+  def process_message(msg)
+    :ack
+  end
+    
+end

data/lib/pipeline_toolkit/message_subscriber.rb

@@ -0,0 +1,138 @@
+require "eventmachine"
+require "mq"
+require "time"
+require "socket"
+
+class MessageSubscriber
+  include DefaultLogger
+   
+  PIPE_PATH = "/tmp"
+  
+  def initialize(opts)
+    @exchange_name, @exchange_type = opts[:exchange].split(":")
+    @queue_name = opts[:queue]
+    @use_ack = opts[:ack]
+    @topic = opts[:topic]
+    @msg_server_opts = opts.select_keys(:host, :port, :user, :pass, :vhost)
+    @unackd_msgs = {}
+    @max_unackd = opts[:max_unackd]
+  end
+
+  def start
+    Signal.trap('INT') { AMQP.stop{ EM.stop } }
+    Signal.trap('TERM'){ AMQP.stop{ EM.stop } }
+
+    begin
+      self.create_sys_pipe
+      AMQP.start(@msg_server_opts) do
+        # For ack to work appropriatly you must shutdown AMQP gracefully,
+        # otherwise all items in your queue will be returned
+        # FIXME. Doesn't shut down cleanly with these commands included. Why?
+
+        self.setup_queue
+        # NB. prefetch limits the amount of unknowledged messages that come down the pipe.
+        MQ.prefetch(@max_unackd)
+        @queue.subscribe(:ack => @use_ack) do |header, body|
+            self.process_msg(header, body)
+        end
+        
+        EM.attach(@sys_pipe, HandleAcks, @sys_pipe, @unackd_msgs)
+      end
+    rescue StandardError => e
+      log.info e
+      raise e
+    ensure
+      self.shutdown
+    end
+  end
+
+  def shutdown
+    log.info "Shutting down"
+    self.destroy_sys_pipe
+  end
+
+  def setup_queue
+    # If a queue_name is given then we treat the queue as fixed, otherwise as temporary
+    @queue = @queue_name ? MQ.queue(@queue_name, :durable => true) : 
+                           self.generate_temporary_queue
+    if @exchange_name
+      create_exchange(@exchange_name, (@exchange_type || :fanout))
+      log.info("Binding to exchange:#{@exchange_str} #{@topic ? "using topic:" + @topic : ""}")
+      @queue.bind(@exchange_str, :key => @topic)
+    end
+  end
+
+  def create_exchange(name, type)
+    MQ::Exchange.new(MQ.default, type.to_sym, @exchange_name, :durable => true, :passive => false)    
+  end
+
+  def create_sys_pipe
+    log.debug("creating sys-pipe")
+    name = File.join(PIPE_PATH, "sys_pipe_#{self.generate_guid}")
+    `mkfifo #{name}`
+    @sys_pipe = File.new(name, "r+")
+    $stdout.puts(MessageCoder.encode({:msg_type => :system, 
+                                      :sys_pipe => name,
+                                      :use_ack => @use_ack,
+                                      :max_unackd => @max_unackd}))
+    $stdout.flush
+  end
+
+  def destroy_sys_pipe
+    `rm #{@sys_pipe.path}`
+  end
+  
+  def generate_temporary_queue
+    qname = "#{Socket.gethostname}_#{self.generate_guid}"
+    log.debug("Binding temporary queue #{qname}")
+    MQ.queue(qname, :auto_delete => true, :durable => false)
+  end
+  
+  # Generates a guid. Stolen from EM.
+  def generate_guid
+    # Cache uuidgen seed for better performance
+    if @ix and @ix >= 10_000
+      @ix = nil
+      @seed = nil
+    end
+    
+    # NB. This will only work on *nix platforms
+    @seed ||= `uuidgen`.chomp.gsub(/-/,"")
+    @ix ||= 0
+
+    "#{@seed}#{@ix += 1}"
+  end
+    
+  def process_msg(header, body)
+    msg = YAML.load(body)
+    store_ack(msg, header) if @use_ack
+    write_msg(msg)
+  end
+  
+  def write_msg(msg)
+    $stdout.syswrite(MessageCoder.encode(msg) << "\n")
+  end
+  
+  def store_ack(msg, header)
+    msg.ack_id = header.delivery_tag.to_s
+    @unackd_msgs[msg.ack_id] = header
+  end
+
+  # Handles msg acks
+  module HandleAcks
+    include DefaultLogger
+
+    def initialize(sys_pipe, unackd_msgs)
+      @sys_pipe = sys_pipe
+      @unackd_msgs = unackd_msgs
+    end
+
+    def notify_readable
+      ack_id = @sys_pipe.gets.chomp!
+      header = @unackd_msgs.delete(ack_id)
+      header.ack
+    end
+  end
+    
+end
+

data/lib/pipeline_toolkit/open_hash.rb

@@ -0,0 +1,24 @@
+# Stolen from
+#   http://github.com/karottenreibe/ohash/
+module OpenHash
+  def method_missing(meth, *args)
+    method = meth.to_s
+
+    if method =~ %r{.+=$}
+      super unless args.length == 1
+      self[method[0...-1].to_sym] = args.first
+    else
+      self[meth]
+    end
+  end
+
+  def select_keys(*keys)
+    h = {}
+    self.each do |key, value|
+      h[key] = value if keys.include?(key)
+    end
+  end
+
+end
+ 
+Hash.send(:include, OpenHash)

data/monitor/munin.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'open-uri'
+require 'trollop'
+require 'nokogiri'
+
+class MuninPlugin
+
+  def initialize(is_config, opts)
+    @probe_urls = opts.probe_urls
+
+    self.get_probes
+
+    if is_config
+       self.config
+    else
+      self.data
+    end
+  end
+
+  def get_probes
+    @probes = []
+    @probe_urls.each_with_index do |url, idx|
+      @probes << get_probe(url)
+    end
+    @probes
+  end
+
+  def get_probe(url)
+    probe = Probe.new
+    doc = Nokogiri::HTML(open(url))
+    probe.name   = extract_mf_value(doc, "name")
+    probe.mps    = extract_mf_value(doc, "mps")
+    probe.uptime = extract_mf_value(doc, "uptime")
+    probe
+  end
+
+  # Extracts the microformat value from the HTML doc
+  def extract_mf_value(doc, key)
+    doc.css(".#{key}").first.content
+  end
+
+  def config
+    config=<<-EOL
+graph_title Message Probe Throughput
+graph_vlabel messages per second
+graph_category Message Probe
+    EOL
+    
+    @probes.each do |probe|
+      config << "probe_#{probe.name}.label #{probe.name}\n"
+    end
+    
+    puts config
+  end
+
+  def data
+    data = ""
+    @probes.each do |probe|
+      data << "#{probe.name}.value #{probe.mps}\n"
+    end
+    
+    puts data
+  end
+
+end
+
+class Probe
+  attr_accessor :name, :mps, :uptime
+end
+
+SUB_COMMANDS = %w{run config}
+
+global_opts = Trollop::options do
+  banner <<-EOS
+  Munin plugin
+  Usage:
+        munin.rb [run|config] [options]
+
+  For more help run
+        munin.rb [command] --help
+  EOS
+  stop_on SUB_COMMANDS
+end
+
+is_config = (ARGV.shift == "config")
+opts = Trollop::options do
+  opt :probe_urls, "The probe's URL", :short => "p", :type => :strings, :default => ["http://127.0.0.1:9070"]
+end
+
+MuninPlugin.new(is_config, opts)

data/pipeline_toolkit.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{pipeline_toolkit}
+  s.version = "1.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aisha Fenton"]
+  s.date = %q{2009-12-06}
+  s.email = %q{labs@visfleet.com}
+  s.executables = ["msg_probe.rb", "msg_subscribe.rb", "msg_push.rb", "msg_sink.rb", "msg_generator.rb"]
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "bin/msg_generator.rb",
+     "bin/msg_probe.rb",
+     "bin/msg_push.rb",
+     "bin/msg_sink.rb",
+     "bin/msg_subscribe.rb",
+     "lib/pipeline_toolkit.rb",
+     "lib/pipeline_toolkit/default_logger.rb",
+     "lib/pipeline_toolkit/message_coder.rb",
+     "lib/pipeline_toolkit/message_command.rb",
+     "lib/pipeline_toolkit/message_probe.rb",
+     "lib/pipeline_toolkit/message_pusher.rb",
+     "lib/pipeline_toolkit/message_sink.rb",
+     "lib/pipeline_toolkit/message_subscriber.rb",
+     "lib/pipeline_toolkit/open_hash.rb",
+     "monitor/munin.rb",
+     "pipeline_toolkit.gemspec"
+  ]
+  s.homepage = %q{http://github.com/visfleet/pipeline_toolkit}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Toolkit for building processing pipelines using Unix Pipes and AMQP messages}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<amqp>, [">= 0.6.4"])
+      s.add_runtime_dependency(%q<trollop>, [">= 1.14"])
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0.12.8"])
+    else
+      s.add_dependency(%q<amqp>, [">= 0.6.4"])
+      s.add_dependency(%q<trollop>, [">= 1.14"])
+      s.add_dependency(%q<eventmachine>, [">= 0.12.8"])
+    end
+  else
+    s.add_dependency(%q<amqp>, [">= 0.6.4"])
+    s.add_dependency(%q<trollop>, [">= 1.14"])
+    s.add_dependency(%q<eventmachine>, [">= 0.12.8"])
+  end
+end
+

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: pipeline_toolkit
+version: !ruby/object:Gem::Version 
+  version: 1.0.1
+platform: ruby
+authors: 
+- Aisha Fenton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-06 00:00:00 +13:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: amqp
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.6.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.14"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.12.8
+    version: 
+description: 
+email: labs@visfleet.com
+executables: 
+- msg_probe.rb
+- msg_subscribe.rb
+- msg_push.rb
+- msg_sink.rb
+- msg_generator.rb
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/msg_generator.rb
+- bin/msg_probe.rb
+- bin/msg_push.rb
+- bin/msg_sink.rb
+- bin/msg_subscribe.rb
+- lib/pipeline_toolkit.rb
+- lib/pipeline_toolkit/default_logger.rb
+- lib/pipeline_toolkit/message_coder.rb
+- lib/pipeline_toolkit/message_command.rb
+- lib/pipeline_toolkit/message_probe.rb
+- lib/pipeline_toolkit/message_pusher.rb
+- lib/pipeline_toolkit/message_sink.rb
+- lib/pipeline_toolkit/message_subscriber.rb
+- lib/pipeline_toolkit/open_hash.rb
+- monitor/munin.rb
+- pipeline_toolkit.gemspec
+has_rdoc: true
+homepage: http://github.com/visfleet/pipeline_toolkit
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Toolkit for building processing pipelines using Unix Pipes and AMQP messages
+test_files: []
+