zebra 1.0.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+*.log
+*.pid
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in zebra.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/zebra

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path('.')) # Ruby 1.9 doesn't have . in the load path...
+$:.push(File.expand_path('lib/')) 
+$0 = __FILE__  + " " + ARGV.join(" ")
+
+require 'rubygems'
+require 'zebra'
+
+command_line = Zebra::CommandLine.new
+command_line.execute

data/contrib/config.yml

@@ -0,0 +1 @@
+#log_file: "/tmp/zebra.log"

data/lib/core_ext/hash.rb

@@ -0,0 +1,21 @@
+class Hash
+  def symbolize_keys!
+    t=self.dup
+    self.clear
+    t.each_pair do |k,v|
+      case v
+      when Hash
+        v.symbolize_keys!
+      when Array
+        v.each do |e|
+          if e.kind_of?(Hash)
+            e.symbolize_keys!
+          end
+        end
+      end
+      self[k.to_sym] = v
+      self
+    end
+    self
+  end
+end

data/lib/zebra.rb

@@ -0,0 +1,29 @@
+require 'core_ext/hash'
+require 'zebra/config'
+require 'zebra/command_line'
+require 'zebra/proxy_server'
+require 'zebra/proxy_worker'
+require 'zebra/queue'
+  
+module Zebra
+  @@config = Config.instance
+  @@log = Logger.new(STDERR)
+
+  def self.config=(config)
+    @@config=config
+  end
+
+  def self.config
+    @@config
+  end
+
+  def self.log=(log)
+    @@log=log
+  end
+
+  def self.log
+    @@log
+  end
+end
+
+

data/lib/zebra/command_line.rb

@@ -0,0 +1,137 @@
+require 'optparse'
+require 'daemons'
+
+module Zebra
+
+  class MissingArgumentException < Exception; end
+  class UnsupportedArgumentException < Exception; end
+
+  #Loads command line options and assigns them to singleton Config object
+  class CommandLine
+    attr_reader :controller
+
+    def initialize
+      Zebra.config.chdir = File.dirname(__FILE__)
+      Zebra.config.tmp_dir = '/tmp'
+      Zebra.config.daemonize = false
+
+      begin
+        @parser = OptionParser.new() do |opts|
+          opts.banner = "Usage: #{$0} --config CONFIG [worker|server|queue]"
+          
+          opts.on('-c', '--config CONFIG', 'Configuration file') do |config_file|
+            Zebra.config.config_file = config_file
+          end
+
+          opts.on('-d', '--daemonize', 'Daemonize the process') do |daemonize|
+            Zebra.config.daemonize = daemonize
+          end
+          
+          opts.on('-p', '--pid-file PID-FILE', 'Pid-File to save the process id') do |pid_file|
+            Zebra.config.pid_file = pid_file
+          end
+            
+          opts.on('-l', '--log-file LOG-FILE', 'Log File') do |log_file|
+            Zebra.config.log_file = log_file
+          end
+        end
+        @parser.parse!
+        Zebra.config.mode = ARGV.shift if ARGV.length > 0
+        raise MissingArgumentException.new("Missing --config parameter") unless Zebra.config.config_file?
+        raise MissingArgumentException.new("Missing mode of operation: server|proxy|queue") unless Zebra.config.mode?
+      rescue MissingArgumentException => e
+        puts usage(e)
+        exit 1
+      rescue ArgumentError => e
+        puts usage(e)
+        exit 1
+      rescue Exception => e
+        puts e.message
+        puts e.backtrace.join("\n\t")
+        exit 1
+      end
+    end
+
+    def usage(e = nil)
+      output = ''
+      case e
+      when MissingArgumentException
+        output += "#{e.message}\n"
+      when Exception
+        output += "#{e.class}: #{e.message}\n"
+      when Nil
+        # Do nothing 
+      end
+      output += @parser.to_s
+      output 
+    end
+
+    def daemonize
+      # Become a daemon
+      if RUBY_VERSION < "1.9"
+        exit if fork
+        Process.setsid
+        exit if fork
+        Dir.chdir "/" 
+        STDIN.reopen "/dev/null"
+        STDOUT.reopen "/dev/null", "a" 
+        STDERR.reopen "/dev/null", "a" 
+      else
+        Process.daemon
+      end 
+    end
+
+    def execute
+      #If log file is specified logs messages to that file, else on stdout
+      log_file = Zebra.config.log_file
+      fh = nil
+      if log_file
+        fh = File.open(log_file, 'a')
+      else
+        fh = STDERR
+      end
+
+      fh.sync = true
+      Zebra.log = Logger.new(fh)
+
+      Zebra.log.datetime_format = "%Y-%m-%d %H:%M:%S"
+      Zebra.log.formatter = proc { |severity, datetime, progname, msg| sprintf "%-15s | %5s | %s\n", datetime.strftime(Zebra.log.datetime_format), severity, msg }
+      Zebra.config.namespace ||= $0.to_s
+  
+      # ZMQ sockets are not thread/process safe
+      daemonize if Zebra.config.daemonize
+
+      begin
+        case Zebra.config.mode.to_sym
+        when :server
+          config = Zebra.config.server || {}
+          config[:logger] = Zebra.log
+          @controller = ProxyServer.new
+        when :worker
+          config = Zebra.config.worker || {}
+          config[:logger] = Zebra.log
+          @controller = ProxyWorker.new(config)
+        when :queue
+          config = Zebra.config.queue || {}
+          config[:logger] = Zebra.log
+          @controller = Queue.new(config)
+        else
+          raise UnsupportedArgumentException.new("Cannot handle #{Zebra.config.mode} mode")
+        end
+
+        
+        if Zebra.config.pid_file?
+          Zebra.log.debug("Writing pid file #{Zebra.config.pid_file}")
+          File.open(Zebra.config.pid_file, 'w') do |f| 
+            f.write(Process.pid)
+          end
+        end
+
+
+        @controller.dispatch
+      rescue Interrupt => e
+        Zebra.log.info e.message
+      end
+    end
+  end
+end

data/lib/zebra/config.rb

@@ -0,0 +1,65 @@
+require 'singleton'
+require 'deep_merge'
+require 'yaml'
+require 'fileutils'
+require 'net/http'
+
+module Zebra
+  class UnsupportedURISchemeException < Exception; end
+  class ResourceNotFoundException < Exception; end
+
+  class Config
+    include Singleton
+    @config = nil
+    
+    def initialize
+      @config = {}
+    end
+
+    def read_config_file(config_file)
+      if File.exists?(config_file)
+        yaml = File.read(config_file)
+      else
+        raise ResourceNotFoundException.new("Unable to open #{config_file}")
+      end
+      return yaml
+    end
+
+    def config_file= config_file
+      @config[:config_file] = config_file
+
+      yaml = read_config_file(config_file)
+      config = YAML.load(yaml)
+      @config.deep_merge!(config)
+      @config.symbolize_keys!
+      return @config[:config_file]
+    end
+
+    def base_path
+      File.expand_path(File.dirname(__FILE__) + '/../../')
+    end
+    
+    def nil?
+      return @config.empty?
+    end
+
+    def empty?
+      return @config.empty?
+    end
+
+    def method_missing(id, *args)
+      return nil unless @config.instance_of?(Hash)
+
+      method_name = id.id2name
+      if method_name =~ /^(.*?)\?$/
+        return @config.has_key?($1.to_sym) && !@config[$1.to_sym].nil?
+      elsif method_name =~ /^(.*?)\=$/
+        return @config[$1.to_sym] = args[0]
+      elsif @config.has_key?(method_name.to_sym)
+        return @config[method_name.to_sym]
+      else
+        return nil
+      end
+    end
+  end
+end

data/lib/zebra/proxy_server.rb

@@ -0,0 +1,106 @@
+require 'goliath'
+require 'goliath/plugins/latency'
+require 'em-synchrony'
+require 'em-zeromq'
+require 'yajl'
+require 'json'
+require 'base64'
+
+module Zebra
+  trap('INT') do
+    EM::stop() if EM::reactor_running?
+  end
+
+  class Goliath::Server
+    def load_config(file = nil)
+      config[:context] = EM::ZeroMQ::Context.new(1)
+      config[:connection_pool] = EM::Synchrony::ConnectionPool.new(:size => 20) do  
+        config[:context].socket(ZMQ::REQ) do |socket|
+          socket.connect("tcp://localhost:5559")
+        end
+      end
+    end
+  end
+
+  class Goliath::Runner
+    def run
+      $LOADED_FEATURES.unshift(File.basename($0))
+      Dir.chdir(File.expand_path(Zebra.config.chdir))
+      @port = 8000
+      if Zebra.config.server?
+        @port = ::Zebra.config.server[:port]
+      end
+      run_server
+    end
+  end
+
+  class ProxyServer < Goliath::API
+    attr_accessor :log
+
+    use Goliath::Rack::Tracer             # log trace statistics
+    use Goliath::Rack::DefaultMimeType    # cleanup accepted media types
+    use Goliath::Rack::Render, 'json'     # auto-negotiate response format
+    use Goliath::Rack::Params             # parse & merge query and body parameters
+    use Goliath::Rack::Heartbeat          # respond to /status with 200, OK (monitoring, etc)
+
+    # If you are using Golaith version <=0.9.1 you need to Goliath::Rack::ValidationError
+    # to prevent the request from remaining open after an error occurs
+    #use Goliath::Rack::ValidationError
+    use Goliath::Rack::Validation::RequestMethod, %w(GET POST PUT DELETE)           # allow GET and POST requests only
+
+    plugin Goliath::Plugin::Latency       # output reactor latency every second
+
+    def response(env)
+      #ap env
+      json = env.select { |k,v| v.instance_of?(String) }.to_json
+      @log.debug "Sending #{json}"
+
+      config[:connection_pool].execute(false) do |conn|
+        handler = EM::Protocols::ZMQConnectionHandler.new(conn)
+        reply = handler.send_msg(json).first
+        #ap reply
+        if reply.eql?('null')
+          response = [500, {}, 'Server Error']
+        else
+          response = JSON.parse(reply)
+          response[2] = Base64.decode64(response[2])
+        end
+        #ap response
+        return response
+        #[200, {}, resp]
+      end
+    end
+
+    def initialize(config={})
+      super
+      @log = config[:logger] || Logger.new(STDERR)
+    end
+
+    def dispatch
+      # Don't need to do anything, handled by Goliath
+    end
+  end
+
+  class EM::Protocols::ZMQConnectionHandler
+    attr_reader :received
+
+    def initialize(connection)
+      @connection = connection
+      @client_fiber = Fiber.current
+      @connection.setsockopt(ZMQ::IDENTITY, "req-#{@client_fiber.object_id}")
+      @connection.handler = self
+    end
+
+    def send_msg(*parts)
+      queued = @connection.send_msg(*parts)
+      @connection.register_readable
+      messages = Fiber.yield
+      messages.map(&:copy_out_string)
+    end
+
+    def on_readable(socket, messages)
+      @client_fiber.resume(messages)
+    end
+  end
+end
+

data/lib/zebra/proxy_worker.rb

@@ -0,0 +1,125 @@
+require 'rubygems'
+require 'ffi-rzmq'
+require 'json'
+require 'logger'
+require 'uuid'
+require 'em-zeromq'
+require 'em-synchrony'
+require 'em-synchrony/em-http'
+require 'em-synchrony/fiber_iterator'
+require 'fiber'
+require 'base64'
+require 'preforker'
+
+module Zebra
+  class ProxyWorkerReceiveMessageHandler
+    attr_reader :received
+
+    def initialize(config)
+      @config = config
+      @logger = config[:logger] || Logger.new(STDERR)
+      @conns = {}
+    end
+
+    def to_headers(response_headers)
+      raw_headers = {}
+      response_headers.select { |k,v| k =~ /^[A-Z0-9_]+$/ }.each_pair { |k,v| raw_headers[ k.downcase.split('_').collect { |e| e.capitalize }.join('-') ] = v}
+      raw_headers
+    end
+
+    def get_conn(url)
+      uri = URI.parse(url)
+      conn_key = uri.scheme + '://' + uri.host
+      return EM::HttpRequest.new(conn_key, :connect_timeout => 1, :inactivity_timeout => 1)
+      if @conns.has_key?(conn_key)
+        return @conns[conn_key]
+      else
+        return @conns[conn_key] = EM::HttpRequest.new(conn_key, :connect_timeout => 1, :inactivity_timeout => 1)
+      end
+    end
+
+    def fetch(method, url, request_headers = {})
+      @response = nil
+      @logger.debug "Proxying #{method} #{url} #{request_headers.inspect}"
+      t_start = Time.now
+      uri = URI.parse(url)
+      conn = get_conn(url)
+      request_headers['Host'] = uri.host
+      http = conn.send(method, path: uri.path, query: uri.query, head: request_headers, :keepalive => true)
+      @logger.debug "Request finished"
+      response_headers = to_headers(http.response_header)
+      #ap response_headers
+      response_headers['X-Proxied-By'] = 'Zebra'
+      response_headers.delete('Connection')
+      response_headers.delete('Content-Length')
+      response_headers.delete('Transfer-Encoding')
+      t_end = Time.now
+      elapsed = t_end.to_f - t_start.to_f
+      @logger.info "#{elapsed} elapsed"
+      @logger.info "Received #{http.response_header.status} from server, #{http.response.length} bytes"
+      [http.response_header.status, response_headers, Base64.encode64(http.response)]
+    end
+
+    def on_writeable(socket)
+      @logger.debug("Writable")
+    end
+
+    def handle_message(m)
+      #ap m.copy_out_string
+      env = JSON.parse(m.copy_out_string)
+      #url = 'http://' + env['HTTP_HOST'] + env['REQUEST_URI']
+      url = env['REQUEST_URI'] 
+      method = env['REQUEST_METHOD'].downcase.to_sym
+      fetch(method, url)
+    end
+
+    def on_readable(socket, messages)
+      @logger.debug "on_readable #{messages.inspect}"
+      fiber = Fiber.new do
+        m = messages.first
+        response = handle_message(m).to_json
+        socket.send_msg response
+      end
+      fiber.resume
+      @logger.debug "Finished on_readable"
+    end
+  end
+
+  class ProxyWorker
+    attr_accessor :log, :workers, :app_name, :timeout
+
+    def initialize(config = {})
+      @log = config[:logger] || Logger.new(STDERR)
+      @workers = config[:workers] || 10
+      @timeout = config[:timeout] || 3600
+      @app_name = config[:app_name] || File.basename($0.split(/ /)[0], '.rb')
+    end
+
+    def dispatch
+      params = { :workers => @workers,
+                 :app_name => @app_name,
+                 :logger => @log,
+                 :timeout => @timeout }
+      workers = Preforker.new(params) do |master|
+        config = {:logger => @log}
+        handler = ProxyWorkerReceiveMessageHandler.new(config)
+        while master.wants_me_alive? do
+          EM.synchrony do
+            master.logger.info "Server started..."
+
+            timer = EventMachine::PeriodicTimer.new(5) do
+              master.logger.info "ping #{Process.pid}"
+            end
+
+            context = EM::ZeroMQ::Context.new(1)
+          #  connection_pool = EM::Synchrony::ConnectionPool.new(:size => 1) do  
+              socket = context.socket(ZMQ::REP, handler)
+              socket.connect('tcp://localhost:5560')
+          #  end
+          end
+        end
+      end
+      workers.run
+    end
+  end
+end

data/lib/zebra/queue.rb

@@ -0,0 +1,41 @@
+require 'ffi-rzmq'
+
+module Zebra
+  class Queue
+    attr_accessor :context, :frontend, :backend, :poller, :log, :frontend_uri, :backend_uri
+    def initialize(config)
+      @log = config[:logger] || Logger.new(STDERR)
+      @frontend_uri = config[:frontend] || 'tcp://*:5559'
+      @backend_uri = config[:backend] || 'tcp://*:5560'
+      @context = ZMQ::Context.new
+
+      # Socket facing clients
+      @frontend = context.socket(ZMQ::ROUTER)
+
+      # Socket facing services
+      @backend = context.socket(ZMQ::DEALER)
+      trap("INT") do
+        @log.info "Shutting down."
+        @frontend.close unless @frontend.nil?
+        @backend.close unless @backend.nil?
+        @context.terminate unless @context.nil?
+        exit
+      end
+    end
+
+    def dispatch
+      @frontend.bind(@frontend_uri)
+      @backend.bind(@backend_uri)
+      begin
+        # Start built-in device
+        @poller = ZMQ::Device.new(ZMQ::QUEUE,frontend,backend)
+      rescue Interrupt => e
+        @log.info("Caught interrupt signal...")
+      end
+
+      @frontend.close
+      @backend.close
+      @context.terminate
+    end
+  end
+end

data/lib/zebra/version.rb

@@ -0,0 +1,3 @@
+module Zebra
+  VERSION = '1.0.0'
+end

data/zebra.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "zebra/version"
+
+Gem::Specification.new do |s|
+  s.name        = "zebra"
+  s.version     = Zebra::VERSION
+  s.authors     = ["osterman"]
+  s.email       = ["e@osterman.com"]
+  s.homepage    = "https://github.com/osterman/zebra"
+  s.summary     = %q{A Goliath ZMQ Reverse HTTP Proxy Implementation}
+  s.description = %q{A proxy that uses ZMQ as the wire protocol between HTTP proxy gateway and backend worker nodes. This allows for each load distribution to worker nodes behind a firewall.}
+
+  s.rubyforge_project = "zebra"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "bundler"
+  s.add_runtime_dependency "deep_merge", ">= 1.0.0"
+  s.add_runtime_dependency "em-synchrony", ">= 1.0.0"
+  s.add_runtime_dependency "em-http-request",  ">=1.0.2"
+  s.add_runtime_dependency "em-zeromq", ">= 0.3.0"
+  s.add_runtime_dependency "ffi-rzmq", ">= 0.9.3"
+  s.add_runtime_dependency "goliath", ">= 0.9.4"
+  s.add_runtime_dependency "json", ">= 1.6.5"
+  s.add_runtime_dependency "preforker", ">= 0.1.1"
+  s.add_runtime_dependency "uuid", ">= 2.3.5"
+  s.add_runtime_dependency "yajl-ruby", ">= 1.1.0"
+end

metadata

@@ -0,0 +1,254 @@
+--- !ruby/object:Gem::Specification 
+name: zebra
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- osterman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-03 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: deep_merge
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: em-synchrony
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: em-http-request
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 0
+        - 2
+        version: 1.0.2
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: em-zeromq
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 3
+        - 0
+        version: 0.3.0
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: ffi-rzmq
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 61
+        segments: 
+        - 0
+        - 9
+        - 3
+        version: 0.9.3
+  type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: goliath
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 51
+        segments: 
+        - 0
+        - 9
+        - 4
+        version: 0.9.4
+  type: :runtime
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 1
+        - 6
+        - 5
+        version: 1.6.5
+  type: :runtime
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: preforker
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 1
+        - 1
+        version: 0.1.1
+  type: :runtime
+  version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: uuid
+  prerelease: false
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  type: :runtime
+  version_requirements: *id010
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :runtime
+  version_requirements: *id011
+description: A proxy that uses ZMQ as the wire protocol between HTTP proxy gateway and backend worker nodes. This allows for each load distribution to worker nodes behind a firewall.
+email: 
+- e@osterman.com
+executables: 
+- zebra
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- bin/zebra
+- contrib/config.yml
+- lib/core_ext/hash.rb
+- lib/zebra.rb
+- lib/zebra/command_line.rb
+- lib/zebra/config.rb
+- lib/zebra/proxy_server.rb
+- lib/zebra/proxy_worker.rb
+- lib/zebra/queue.rb
+- lib/zebra/version.rb
+- zebra.gemspec
+has_rdoc: true
+homepage: https://github.com/osterman/zebra
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: zebra
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Goliath ZMQ Reverse HTTP Proxy Implementation
+test_files: []
+