foxbat 0.2.4 → 0.2.5

data/lib/em/connection.rb

@@ -17,6 +17,14 @@ module EventMachine
       @netty_handler.write(data)
     end
 
+    def broadcast(data)
+      @netty_handler.write(data, true)
+    end
+
+    def send_file_data(path)
+      @netty_handler.send_file(path)
+    end
+
     def post_init; end
 
     def unbind; end
@@ -28,11 +36,7 @@ module EventMachine
     end
 
     def close_connection(after_writing=false)
-      if after_writing
-        @close_scheduled = true
-      else
-        @netty_handler.close
-      end
+      @netty_handler.close
     end
 
     def close_connection_after_writing
@@ -44,7 +48,7 @@ module EventMachine
     end
 
     def comm_inactivity_timeout=(seconds)
-      # todo
+      @netty_handler.set_read_timeout(seconds)
     end
 
   end

data/lib/em/deferrable.rb

@@ -0,0 +1,210 @@
+#--
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 16 Jul 2006
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+
+module EventMachine
+  module Deferrable
+    autoload :Pool, 'em/deferrable/pool'
+
+    # Specify a block to be executed if and when the Deferrable object receives
+    # a status of :succeeded. See #set_deferred_status for more information.
+    #
+    # Calling this method on a Deferrable object whose status is not yet known
+    # will cause the callback block to be stored on an internal list.
+    # If you call this method on a Deferrable whose status is :succeeded, the
+    # block will be executed immediately, receiving the parameters given to the
+    # prior #set_deferred_status call.
+    #
+    #--
+    # If there is no status, add a callback to an internal list.
+    # If status is succeeded, execute the callback immediately.
+    # If status is failed, do nothing.
+    #
+    def callback &block
+      return unless block
+      @deferred_status ||= :unknown
+      if @deferred_status == :succeeded
+        block.call(*@deferred_args)
+      elsif @deferred_status != :failed
+        @callbacks ||= []
+        @callbacks.unshift block # << block
+      end
+      self
+    end
+
+    # Cancels an outstanding callback to &block if any. Undoes the action of #callback.
+    #
+    def cancel_callback block
+      @callbacks ||= []
+      @callbacks.delete block
+    end
+
+    # Specify a block to be executed if and when the Deferrable object receives
+    # a status of :failed. See #set_deferred_status for more information.
+    #--
+    # If there is no status, add an errback to an internal list.
+    # If status is failed, execute the errback immediately.
+    # If status is succeeded, do nothing.
+    #
+    def errback &block
+      return unless block
+      @deferred_status ||= :unknown
+      if @deferred_status == :failed
+        block.call(*@deferred_args)
+      elsif @deferred_status != :succeeded
+        @errbacks ||= []
+        @errbacks.unshift block # << block
+      end
+      self
+    end
+
+    # Cancels an outstanding errback to &block if any. Undoes the action of #errback.
+    #
+    def cancel_errback block
+      @errbacks ||= []
+      @errbacks.delete block
+    end
+
+    # Sets the "disposition" (status) of the Deferrable object. See also the large set of
+    # sugarings for this method.
+    # Note that if you call this method without arguments,
+    # no arguments will be passed to the callback/errback.
+    # If the user has coded these with arguments, then the
+    # user code will throw an argument exception.
+    # Implementors of deferrable classes <b>must</b>
+    # document the arguments they will supply to user callbacks.
+    #
+    # OBSERVE SOMETHING VERY SPECIAL here: you may call this method even
+    # on the INSIDE of a callback. This is very useful when a previously-registered
+    # callback wants to change the parameters that will be passed to subsequently-registered
+    # ones.
+    #
+    # You may give either :succeeded or :failed as the status argument.
+    #
+    # If you pass :succeeded, then all of the blocks passed to the object using the #callback
+    # method (if any) will be executed BEFORE the #set_deferred_status method returns. All of the blocks
+    # passed to the object using #errback will be discarded.
+    #
+    # If you pass :failed, then all of the blocks passed to the object using the #errback
+    # method (if any) will be executed BEFORE the #set_deferred_status method returns. All of the blocks
+    # passed to the object using # callback will be discarded.
+    #
+    # If you pass any arguments to #set_deferred_status in addition to the status argument,
+    # they will be passed as arguments to any callbacks or errbacks that are executed.
+    # It's your responsibility to ensure that the argument lists specified in your callbacks and
+    # errbacks match the arguments given in calls to #set_deferred_status, otherwise Ruby will raise
+    # an ArgumentError.
+    #
+    #--
+    # We're shifting callbacks off and discarding them as we execute them.
+    # This is valid because by definition callbacks are executed no more than
+    # once. It also has the magic effect of permitting recursive calls, which
+    # means that a callback can call #set_deferred_status and change the parameters
+    # that will be sent to subsequent callbacks down the chain.
+    #
+    # Changed @callbacks and @errbacks from push/shift to unshift/pop, per suggestion
+    # by Kirk Haines, to work around the memory leak bug that still exists in many Ruby
+    # versions.
+    #
+    # Changed 15Sep07: after processing callbacks or errbacks, CLEAR the other set of
+    # handlers. This gets us a little closer to the behavior of Twisted's "deferred,"
+    # which only allows status to be set once. Prior to making this change, it was possible
+    # to "succeed" a Deferrable (triggering its callbacks), and then immediately "fail" it,
+    # triggering its errbacks! That is clearly undesirable, but it's just as undesirable
+    # to raise an exception is status is set more than once on a Deferrable. The latter
+    # behavior would invalidate the idiom of resetting arguments by setting status from
+    # within a callback or errback, but more seriously it would cause spurious errors
+    # if a Deferrable was timed out and then an attempt was made to succeed it. See the
+    # comments under the new method #timeout.
+    #
+    def set_deferred_status status, *args
+      cancel_timeout
+      @errbacks ||= nil
+      @callbacks ||= nil
+      @deferred_status = status
+      @deferred_args = args
+      case @deferred_status
+      when :succeeded
+        if @callbacks
+          while cb = @callbacks.pop
+            cb.call(*@deferred_args)
+          end
+        end
+        @errbacks.clear if @errbacks
+      when :failed
+        if @errbacks
+          while eb = @errbacks.pop
+            eb.call(*@deferred_args)
+          end
+        end
+        @callbacks.clear if @callbacks
+      end
+    end
+
+
+    # Setting a timeout on a Deferrable causes it to go into the failed state after
+    # the Timeout expires (passing no arguments to the object's errbacks).
+    # Setting the status at any time prior to a call to the expiration of the timeout
+    # will cause the timer to be cancelled.
+    def timeout seconds, *args
+      cancel_timeout
+      me = self
+      @deferred_timeout = EventMachine::Timer.new(seconds) {me.fail(*args)}
+      self
+    end
+
+    # Cancels an outstanding timeout if any. Undoes the action of #timeout.
+    #
+    def cancel_timeout
+      @deferred_timeout ||= nil
+      if @deferred_timeout
+        @deferred_timeout.cancel
+        @deferred_timeout = nil
+      end
+    end
+
+
+    # Sugar for set_deferred_status(:succeeded, ...)
+    #
+    def succeed *args
+      set_deferred_status :succeeded, *args
+    end
+    alias set_deferred_success succeed
+
+    # Sugar for set_deferred_status(:failed, ...)
+    #
+    def fail *args
+      set_deferred_status :failed, *args
+    end
+    alias set_deferred_failure fail
+  end
+
+
+  # DefaultDeferrable is an otherwise empty class that includes Deferrable.
+  # This is very useful when you just need to return a Deferrable object
+  # as a way of communicating deferred status to some other part of a program.
+  class DefaultDeferrable
+    include Deferrable
+  end
+end

data/lib/eventmachine.rb

@@ -1,10 +1,13 @@
 import java.lang.Long
 import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
+import org.jboss.netty.util.HashedWheelTimer
+
+require 'foxbat/future'
 
 module EventMachine
 
-  def self.start_server host, port=nil, handler=nil, *args, &block
+  def self.start_server(host, port=nil, handler=nil, *args, &block)
     s = Foxbat::Server.new(host, port, handler, args.first || {}, &block)
 
     @@servers ||= []
@@ -13,6 +16,11 @@ module EventMachine
     s.start(@@threadpool)
   end
 
+  def self.connect(host, port=nil, handler=nil, *args, &block)
+    c = Foxbat::Client.new(host, port, handler, args.first ||  {}, &block)
+    c.start(@@threadpool)
+  end
+
   # We're on the JVM- this does nothing!
   def self.epoll; end
   def self.kqueue; end
@@ -20,24 +28,37 @@ module EventMachine
   def self.run(blk=nil, tail=nil, &block)
     @alive = true
     @@threadpool = Executors.newCachedThreadPool
+    @@timer = HashedWheelTimer.new
 
     block.call
 
     @@threadpool.awaitTermination(Long::MAX_VALUE, TimeUnit::SECONDS)
   end
 
+  def self.add_timer(*args, &block)
+    timeout = args.shift
+    callable = args.shift || block
+    task = lambda { |t| callable.call }
+    @@timer.newTimeout(task, timeout, TimeUnit::SECONDS)
+  end
+
   def self.stop
     @@servers.each { |s| s.stop }
     @@threadpool.shutdown
+    @@timer.stop
   end
 
-  def self.executor
-    @@threadpool
+  def self.defer(op, callback)
+    Foxbat::Future.schedule(op, callback, @@threadpool)
   end
 
   def self.reactor_running?
     @alive
   end
 
+  def self.connection_count
+    @@servers.map { |s| s.connection_count }.reduce(:+)
+  end
+
 end
 

data/lib/foxbat/client.rb

@@ -0,0 +1,29 @@
+import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory
+import org.jboss.netty.bootstrap.ClientBootstrap
+
+module Foxbat
+
+  class Client
+
+    def initialize(host, port, klass, options, &block)
+      if options[:secure]
+        @context = Security.setup_ssl_client_context
+      end
+
+      @group = DefaultChannelGroup.new
+      @address = InetSocketAddress.new(host, port)
+      @pipeline = Pipeline.new(klass, @group, true, options, @context, &block)
+    end
+        
+    def start(threadpool)
+      factory = NioClientSocketChannelFactory.new(threadpool, threadpool)
+      @bootstrap = ClientBootstrap.new(factory)
+      @bootstrap.setPipelineFactory(@pipeline)
+      @bootstrap.setOption("child.tcpNoDelay", true)
+      @bootstrap.setOption("child.keepAlive", true)
+      @bootstrap.connect(@address)
+    end
+    
+  end
+
+end

data/lib/foxbat/future.rb

@@ -0,0 +1,15 @@
+import com.google.common.util.concurrent.ListenableFutureTask
+
+module Foxbat
+
+  class Future
+
+    def self.schedule(op, cb, executor)
+      future = ListenableFutureTask.create(op)
+      future.addListener(cb, executor)
+      executor.submit(future)
+    end
+    
+  end
+
+end

data/lib/foxbat/generic_connection.rb

@@ -0,0 +1,15 @@
+import java.net.InetSocketAddress
+import org.jboss.netty.channel.group.DefaultChannelGroup
+require_relative 'pipeline'
+require_relative 'security'
+
+module Foxbat
+
+  class GenericConnection
+
+
+
+    def start; end
+  end
+
+end

data/lib/foxbat/http_server.rb

@@ -0,0 +1,104 @@
+import org.jboss.netty.handler.codec.http.HttpRequestDecoder
+import org.jboss.netty.handler.codec.http.HttpResponseEncoder
+import org.jboss.netty.handler.codec.http.HttpContentCompressor
+import org.jboss.netty.channel.Channels
+import org.jboss.netty.channel.ChannelPipelineFactory
+import org.jboss.netty.buffer.ChannelBuffers
+import org.jboss.netty.handler.codec.http.DefaultHttpResponse
+import org.jboss.netty.handler.codec.http.HttpResponseStatus
+import org.jboss.netty.handler.codec.http.HttpVersion
+import org.jboss.netty.handler.codec.http.HttpHeaders
+
+require_relative 'server'
+
+module Foxbat
+
+  class WebPipeline
+    include ChannelPipelineFactory
+
+    HANDLER = "handler"
+    ENCODER = "encoder"
+    DECODER = "decoder"
+    DEFLATER = "deflater"
+
+    def initialize(app)
+      @app = app
+      @handler = ReadTimeoutHandler.new(EM.timer, 10)
+    end
+    
+    def getPipeline
+      pipeline = Channels.pipeline
+      pipeline.addLast(DECODER, HttpRequestDecoder.new)
+      pipeline.addLast(ENCODER, HttpResponseEncoder.new)
+      pipeline.addLast(DEFLATER, HttpContentCompressor.new)
+      pipeline.addLast(HANDLER, WebHandler.new(@app))
+      pipeline
+    end
+  end
+
+  class WebHandler < SimpleChannelUpstreamHandler
+
+    def initialize(app)
+      super()
+      @app = app
+    end
+    
+    def messageReceived(ctx, e)
+      req = e.getMessage
+      env = to_rack(req)
+      val = @app.call(env)
+
+      resp = to_netty(val)
+      future = e.getChannel.write(resp)
+
+      listener = Object.new
+      def listener.operationComplete(f)
+        f.getChannel.close
+      end
+
+      future.addListener(listener)
+    end
+
+    private
+
+    def to_rack(req)
+      env = {}
+      env['REQUEST_METHOD'] = req.getMethod.toString
+
+      req.getHeaders.each do |h|
+        header = "HTTP_" + h.getKey.upcase.gsub("-", "_")
+        env[header] = h.getValue
+      end
+      env
+    end
+
+    CODES = {200 => HttpResponseStatus::OK}
+    
+    def to_netty(resp)
+      code, headers, content = resp
+
+      netty_response = DefaultHttpResponse.new(HttpVersion::HTTP_1_1, CODES[code])
+      headers.each do |k,v|
+        netty_response.setHeader(k, v)
+      end
+
+      content = content.to_java_bytes if content.is_a?(String)
+      buf = ChannelBuffers.copiedBuffer(content)
+      netty_response.setContent(buf)
+      netty_response.setHeader('Content-Length', buf.writerIndex)
+      netty_response.setHeader('Server', 'Foxbat')
+      netty_response
+    end
+  end
+  
+  class HttpServer < Server
+
+    def initialize(host, port, klass, options, &block)
+      super(host, port, klass, options, &block)
+      @pipeline.releaseExternalResources
+      @pipeline = WebPipeline.new(block)
+    end
+    
+  end
+
+end

data/lib/foxbat/netty_connection.rb

@@ -1,5 +1,7 @@
+import java.io.RandomAccessFile
 import java.nio.ByteBuffer
 import org.jboss.netty.buffer.ChannelBuffers
+import org.jboss.netty.channel.DefaultFileRegion
 import org.jboss.netty.channel.SimpleChannelUpstreamHandler
 
 module Foxbat
@@ -13,21 +15,37 @@ module Foxbat
       super()
     end
 
-    def write(data)
+    def write(data, broadcast=false)
       data =  data.to_java_bytes if data.is_a?(String)
       buf = ChannelBuffers.copiedBuffer(data)
-      @channel.write(buf)
+
+      recipient = broadcast ? @group : @channel
+      recipient.write(buf)
+    end
+
+    def send_file(path)
+      file_channel = RandomAccessFile.new(path, 'r').getChannel
+      region = DefaultFileRegion.new(file_channel, 0, file_channel.size, true)
+      @channel.write(region)
     end
 
     def close
       @channel.close
     end
 
+    def set_read_timeout(seconds)
+      
+    end
+
     private
 
     def channelOpen(ctx, e)
       @group.add(e.getChannel)
     end
+
+    def channelClosed(ctx, e)
+      @group.remove(e.getChannel)
+    end
     
     def channelConnected(ctx, e)
       @pipeline = ctx.getPipeline

data/lib/foxbat/pipeline.rb

@@ -10,9 +10,19 @@ module Foxbat
   class Pipeline
     include ChannelPipelineFactory
 
-    def initialize(handler, group, options={}, ssl_context=nil, &block)
+    HANDLER = "handler"
+    SSL_HANDLER = "ssl"
+
+    def initialize(handler, group, client, options={}, ssl_context=nil, &block)
       @options = options
       @handler = handler
+      @client_mode = client
+
+      if handler.class == Module
+        @handler = Class.new(EM::Connection)
+        @handler.send(:include, handler)
+      end
+
       @group = group
       @block = block
       @context = ssl_context
@@ -21,18 +31,19 @@ module Foxbat
     def getPipeline
       pipeline = Channels.pipeline
       if @context
-        engine = Security.create_ssl_engine(@context)
-        pipeline.addLast("ssl", SslHandler.new(engine))
+        engine = Security.create_ssl_engine(@context, @client_mode)
+        pipeline.addLast(SSL_HANDLER, SslHandler.new(engine))
       end
+
       h = @handler.new(@options)
       @block.call(h) if @block
       connection = NettyConnection.new(h, @group)
-      pipeline.addLast("handler", connection)
+      pipeline.addLast(HANDLER, connection)
       pipeline
     end
 
     def releaseExternalResources
-      p 'cleaning up factory...'
+      # todo
     end
   end
 

data/lib/foxbat/security.rb

@@ -24,8 +24,9 @@ module Foxbat
       end
       fis.close
 
-      kmf = KeyManagerFactory.getInstance('SunX509')
-      tmf = TrustManagerFactory.getInstance('SunX509')
+      algorithm = KeyManagerFactory.getDefaultAlgorithm
+      kmf = KeyManagerFactory.getInstance(algorithm)
+      tmf = TrustManagerFactory.getInstance(algorithm)
 
       kmf.init(keystore, password)
       tmf.init(keystore)
@@ -43,10 +44,20 @@ module Foxbat
       context.init(kmf.getKeyManagers, tmf.getTrustManagers, nil)
       context
     end
-    
-    def self.create_ssl_engine(context)
-      engine = context.createSSLEngine
-      engine.setUseClientMode(false)
+
+    def self.setup_ssl_client_context
+#      keystore = KeyStore.getInstance(KeyStore.getDefaultType)
+#      context = SSLContext.getInstance('TLSv1')
+#      tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm)
+#      tmf.init(keystore)
+#      context.init(nil, nil, nil)
+      #      context
+      SSLContext.getDefault
+    end
+
+    def self.create_ssl_engine(context, client=false)
+      context.createSSLEngine
+      engine.setUseClientMode(client)
       engine.setNeedClientAuth(false)
       engine
     end

data/lib/foxbat/server.rb

@@ -3,12 +3,10 @@ import org.jboss.netty.channel.group.DefaultChannelGroup
 import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory
 import org.jboss.netty.bootstrap.ServerBootstrap
 require_relative 'pipeline'
-require_relative 'security'
 
 module Foxbat
 
   class Server
-
     def initialize(host, port, klass, options, &block)
       if options[:secure]
         @context = Security.setup_ssl_context(options[:keystore])
@@ -16,15 +14,21 @@ module Foxbat
 
       @group = DefaultChannelGroup.new
       @address = InetSocketAddress.new(host, port)
-      @pipeline = Pipeline.new(klass, @group, options, @context, &block)
+      @pipeline = Pipeline.new(klass, @group, false, options, @context, &block)
     end
-
+    
     def start(threadpool)
-      @factory = NioServerSocketChannelFactory.new(threadpool, threadpool)
-      @bootstrap = ServerBootstrap.new(@factory)
+      sp = java.util.concurrent.Executors.newSingleThreadExecutor
+      factory = NioServerSocketChannelFactory.new(sp, threadpool)
+      @bootstrap = ServerBootstrap.new(factory)
       @bootstrap.setPipelineFactory(@pipeline)
-      @server_channel = @bootstrap.bind(@address)
-      @group.add(@server_channel)
+      @bootstrap.setOption("child.tcpNoDelay", true)
+      server_channel = @bootstrap.bind(@address)
+      @group.add(server_channel)
+    end
+
+    def connection_count
+      @group.size - 1 # -1 to exclude the server's channel
     end
 
     def stop

data/lib/foxbat/version.rb

@@ -1,3 +1,3 @@
 module Foxbat
-  VERSION = '0.2.4'
+  VERSION = '0.2.5'
 end

data/lib/foxbat.rb

@@ -1,45 +1,53 @@
 require 'java'
 
-NETTY_VERSION = '3.5.0.Final'
-JAR_SIZE = 1110903.0 # TODO: remove hard-coded jar size
-
-netty_jar = File.dirname(__FILE__) + "/netty-#{NETTY_VERSION}.jar"
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end
 
-if !File.exist?(netty_jar)
-  puts "Couldn't find netty's JAR to load. Let's download it now."
+def require_or_get(lib, version, ns)
+  jar = "#{lib}-#{version}.jar"
+  jarpath = File.dirname(__FILE__) + '/' + jar
+  if !File.exist?(jarpath)
+    puts "Couldn't find #{lib}, let's download it now."
   
-  require 'net/http'
-  f = open(netty_jar, 'w')
-
-  Net::HTTP.start('search.maven.org') do |http|
-
-    begin
-    http.request_get("/remotecontent?filepath=io/netty/netty/#{NETTY_VERSION}/netty-#{NETTY_VERSION}.jar") do |resp|
-    acc = 0
-    resp.read_body do |segment|
-          acc += segment.length
-          percent = ((acc / JAR_SIZE) * 100).to_i
-          print "Downloading netty #{NETTY_VERSION} from maven repository... [#{percent}%]\r"
-          f.write(segment)
+    require 'net/http'
+    f = open(jarpath, 'w')
+
+    Net::HTTP.start('search.maven.org') do |http|
+
+      begin
+        http.request_get("/remotecontent?filepath=#{ns}/#{lib}/#{version}/#{jar}") do |resp|
+          puts "Downloading #{jar} from maven repository..."
+          resp.read_body do |segment|
+            f.write(segment)
+          end
+          puts "Done."
         end
-        puts "\nDone. You shouldn't see me again :)"
+      ensure
+        f.close()
       end
-  ensure
-    f.close()
     end
   end
+
+  require jar
 end
 
-require 'netty-3.5.0.Final.jar'
+require_or_get 'netty', '3.5.0.Final', 'io/netty'
+require_or_get 'guava', '13.0.1', 'com/google/guava'
 
 require 'em/connection'
+require 'em/deferrable'
 require 'em/periodic_timer'
 require 'em/timer'
+require 'foxbat/client'
 require 'foxbat/server'
 require 'foxbat/version'
-require_relative 'eventmachine'
-
 
+require_relative 'eventmachine'
 
 module EventMachine; end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foxbat
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-18 00:00:00.000000000 Z
+date: 2012-11-12 00:00:00.000000000 Z
 dependencies: []
 description: A drop-in replacement for EM, providing functionality missing from the
   Java port.
@@ -22,15 +22,21 @@ files:
 - lib/eventmachine.rb
 - lib/foxbat/barrier.rb
 - lib/foxbat/version.rb
+- lib/foxbat/generic_connection.rb
+- lib/foxbat/client.rb
 - lib/foxbat/server.rb
+- lib/foxbat/http_server.rb
 - lib/foxbat/pipeline.rb
+- lib/foxbat/future.rb
 - lib/foxbat/netty_connection.rb
 - lib/foxbat/security.rb
 - lib/netty-3.5.0.Final.jar
 - lib/foxbat.rb
 - lib/em/periodic_timer.rb
 - lib/em/timer.rb
+- lib/em/deferrable.rb
 - lib/em/connection.rb
+- lib/guava-13.0.1.jar
 homepage: http://github.com/m0wfo/foxbat
 licenses: []
 post_install_message: