bane 0.3.0 → 0.4.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Y2M3MGZkYWY0NDNhNjZlYTY5M2I2MGViMDljNjY3YzRiYmY2MDg3OA==
+  data.tar.gz: !binary |-
+    OWY2YTY3ZDFmNDU4Y2I1MzEwZjViNDIzZGU0YzMzNzk4ZjdiMmIxOA==
+SHA512:
+  metadata.gz: !binary |-
+    ODE5MDJlYzkyMzNmYzllYzRlMTAwY2RjYjNhYzlkNjA1NTU0ODRiZmNhOGZh
+    NjczN2E4ZjM4YjcyMjUyYTBlODUxNjVkM2NiODc4MjIyM2Q2MjE3OWNmYzk0
+    YmFjZmVlNzVmYjMyOGE4ZmJhZmYzYzU3MTljOWMyODc5YjRiYjM=
+  data.tar.gz: !binary |-
+    MmI5ZjZmYjM5YTczYzQ0NjFmYjNlMTBlY2I5ZmJiY2ZkMmQ4MDM5MjczYjgw
+    MTJkMWQxOTVkOTExN2FiMjVjNjUxOGRlOWU1YTc3OGUxMjUxNDM1Mjk1Zjkw
+    NDU5YzgzYzE2OGQ0MTY4OTdlY2RjYzNlNDM0ZDEyZmEyMGI3YzI=

data/README.md

@@ -1,5 +1,7 @@
 # Bane
 
+[![Build Status](https://secure.travis-ci.org/danielwellman/bane.png)](http://travis-ci.org/danielwellman/bane) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/danielwellman/bane)
+
 Bane is a test harness used to test your application's interaction with other servers.  It is based upon the material from Michael Nygard's ["Release It!"](http://www.pragprog.com/titles/mnee/release-it) book as described in the "Test Harness" chapter.
 
 ## Why Use Bane?
@@ -8,12 +10,14 @@ If you are building an application, you may depend on third-party servers or web
 
 ## Setup
 
-Bane is available as a gem.  Install it with
+Bane is available as a Ruby gem.  Install it with
 
   `gem install bane`
 
 Note that Bane installs an executable, `bane`.  Simply invoke `bane` with no arguments to get a usage description.
 
+Bane requires Ruby 1.9 or later.  If you would like to use a Ruby 1.8.7-compatible version, install version 0.3.0.
+
 ## Usage
 
 Bane is designed with a few usage scenarios in mind:
@@ -40,13 +44,14 @@ require 'bane'
 include Bane
 
 launcher = Launcher.new(
-  [BehaviorServer.new(3000, Behaviors::FixedResponse.new(:message => "Shall we play a game?"))])
+  [BehaviorServer.new(3000, Behaviors::Responders::FixedResponse.new(message: "Shall we play a game?"))])
 launcher.start
 launcher.join
 ```
 
-   See the `examples`directory for more examples.  For a list of options supported by the
-   included behaviors, see the source for the behaviors in `Bane::Behaviors` at `lib/bane/behaviors.rb`.
+   See the `examples` directory for more examples.  For a list of options supported by the
+   included behaviors, see the source for the behaviors in `lib/bane/behaviors`; note that you will find both
+   servers (that bind to sockets directly) and responders (that assume a running TCP server and communicate with a socket connection).
 
 ## Listening on all hosts
 
@@ -60,7 +65,7 @@ By default, the socket behaviors that send any data will close the connection im
 
 For example, if you want to send a static response and then close the connection immediately, use `FixedResponse`.  If you want to keep the connection open and respond to every line of input with the same data, use `FixedResponseForEachLine`.  Note that these behaviors will never close the connection; they will happily respond to every line of input until you stop Bane.
 
-If you are implementing a new behavior, you should consider whether or not you would like to provide another variation which keeps a connection open and responds after every line of input.  If so, create the basic behavior which responds and closes the connection immediately, then create another behavior which includes the `ForEachLine` module.  See the source in `lib/bane/behaviors.rb` for some examples.
+If you are implementing a new behavior, you should consider whether or not you would like to provide another variation which keeps a connection open and responds after every line of input.  If so, create the basic behavior which responds and closes the connection immediately, then create another behavior which includes the `ForEachLine` module.  See the source in `lib/bane/behaviors/responders/fixed_response.rb` for some examples.
 
 ## Background
 
@@ -83,7 +88,7 @@ See the implementation of HttpRefuseAllCredentials for a simple example of an HT
 * The service can send a response of HTML instead of the expected XML.
 
 The following behaviors are not yet supported. These require the ability to manipulate
-TCP packets at a low level; which may require a C or C++ extension.
+TCP packets at a low level, which may require a C or C++ extension or raw sockets.
 
 * The connection can be refused.
 * The request can sit in a listen queue until the caller times out.
@@ -93,3 +98,8 @@ TCP packets at a low level; which may require a C or C++ extension.
 * The connection can be established, but packets could be lost causing retransmit delays
 * The connection can be established, but the remote end never acknowledges receiving a packet, causing endless retransmits
 
+## Support
+
+<a href="http://www.cyrusinnovation.com/"><img src="http://www.cyrusinnovation.com/marketing/logo.png" alt="Cyrus"></a>
+
+Thank you to [Cyrus](http://www.cyrusinnovation.com/) for supporting the development of this project.

data/Rakefile

@@ -22,7 +22,7 @@ Jeweler::Tasks.new do |gem|
     other servers. It is based upon the material from Michael Nygard's "Release
     It!" book as described in the "Test Harness" chapter.
   END
-  gem.authors = ["Daniel Wellman"]
+  gem.authors = ["Daniel Wellman", "Joe Leo"]
   gem.email = "dan@danielwellman.com"
   gem.files = FileList[ 'lib/**/*', 'bin/*', 'test/**/*', 'examples/*',
     'Rakefile' ]

data/TODO

@@ -1,21 +1,18 @@
 Features:
-- Quieter exits on Ctrl-C (than plain stack trace)
 
 Design questions / Ideas:
-- Make BasicBehavior a module called Behavior, and include that in each behavior?
-- Is there a natural separation in Configuration between parsing arguments and instantiating/finding behaviors?
-  In particular, mocking "new" on a class seems to be a smell -- at least because I keep forgetting that 'new' must
-  return an object, and my mocks didn't do that (see CommandLineConfigurationTest, and the messier ConfigurationParserTest)
-- Explore the ServiceRegistry usage -- should "find" behaviors be there? Printing?
-- Decide if the current behaviors should be tied more directly to BehaviorServer, via subclassing or some other way.
 - Figure out where the logger configuration logic belongs in the Launcher/BehaviorServer relationship
 - Should the default logger go to STDERR or STDOUT?
-- Break the Behaviors out into several files and test files?
 - Log every request to the server/behavior, in addition to open, close.  For this to work, it would have to be the
   behavior's responsibility, since GServer#serve gets called only once for the lifetime of the connection.
+- If we extract a commong logger, we might use that to test for proper disconnection in NeverRespondTest#test_disconnects_after_client_closes_connection
 
 Future Behaviors:
 - Create a more configurable version of the DelugeResponse which allows for a header, footer, content and times to repeat.
 - Write the remaining bad HTTP behaviors.  In addition, we may want to replace the NaiveHttpResponse with something
   from the standard Ruby library, so that there's less code in this project, and so we know that we're
   following the HTTP protocol.
+- Have a tiny listen queue (queue size 0) and a connection never gets into the queue
+- Have a giant listen queue (queue size max?) and only one thread processing -- times out in the listen queue
+- Close the write part of the connection, but not the read
+- Close the read part of the connection, but not the write

data/bin/bane

@@ -1,22 +1,14 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 require 'bane'
 
-config = Bane::CommandLineConfiguration.new()
-begin
-  servers = config.parse(ARGV)
-rescue Bane::ConfigurationError => ce
-  puts ce.message
-  puts config.usage
+parser = Bane::CommandLineConfiguration.new(Bane.find_makeables)
+servers = parser.process(ARGV) do |error_message|
+  puts error_message
   exit 1
 end
 
-if servers.empty?
-  puts config.usage
-  exit 0
-end
-
 launcher = Bane::Launcher.new(servers)
 launcher.start
+trap("SIGINT") { Thread.new { launcher.stop; exit } }
 launcher.join

data/examples/multiple_behaviors.rb

@@ -2,18 +2,19 @@ $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 require 'bane'
 
 include Bane
+include Behaviors
 
 # This example creates several behavior listening on distinct ports.
 # Note the FixedResponse port specifies to listen to all hosts (0.0.0.0), all
 # other servers listen to localhost only by default (127.0.0.1).
 
-close_immediately = Behaviors::CloseImmediately.new
-never_respond = Behaviors::NeverRespond.new
-fixed_response = Behaviors::FixedResponse.new(:message => "OK")
+close_immediately = Responders::CloseImmediately.new
+never_respond = Responders::NeverRespond.new
+fixed_response = Responders::FixedResponse.new(message: "OK")
 
-launcher = Launcher.new([BehaviorServer.new(3000, close_immediately),
-                        BehaviorServer.new(8000, never_respond),
-                        BehaviorServer.new(8080, fixed_response, BehaviorServer::ALL_INTERFACES)])
+launcher = Launcher.new([Servers::ResponderServer.new(3000, close_immediately),
+                         Servers::ResponderServer.new(8000, never_respond),
+                         Servers::ResponderServer.new(8080, fixed_response, Servers::ALL_INTERFACES)])
 launcher.start
 # To run until interrupt, use the following line:
 #launcher.join

data/examples/readme_example.rb

@@ -2,8 +2,9 @@ $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 require 'bane'
 
 include Bane
+include Behaviors
 
 launcher = Launcher.new(
-        [BehaviorServer.new(3000, Behaviors::FixedResponse.new(:message => "Shall we play a game?"))])
+        [Servers::ResponderServer.new(3000, Responders::FixedResponse.new(message: "Shall we play a game?"))])
 launcher.start
 launcher.join

data/examples/single_behavior.rb

@@ -2,11 +2,12 @@ $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 require 'bane'
 
 include Bane
+include Behaviors
 
 # This example creates a single behavior listening on port 3000.
 # Note that the behavior, CloseAfterPause, specifies a default duration to pause - 60 seconds.
 
-behavior = BehaviorServer.new(3000, Behaviors::CloseAfterPause.new(:duration => 60))
+behavior = Servers::ResponderServer.new(3000, Responders::CloseAfterPause.new(duration: 60))
 launcher = Launcher.new([behavior])
 launcher.start
 # To run until interrupt, use the following line:

data/lib/bane.rb

@@ -1,8 +1,21 @@
-require 'bane/compatibility'
-require 'bane/service_registry'
-require 'bane/behaviors'
+require 'bane/extensions'
+require 'bane/behavior_maker'
+require 'bane/behaviors/responders/for_each_line'
+require 'bane/behaviors/responders/close_after_pause'
+require 'bane/behaviors/responders/close_immediately'
+require 'bane/behaviors/responders/deluge_response'
+require 'bane/behaviors/responders/echo_response'
+require 'bane/behaviors/responders/fixed_response'
+require 'bane/behaviors/responders/http_refuse_all_credentials'
+require 'bane/behaviors/responders/never_respond'
+require 'bane/behaviors/responders/newline_response'
+require 'bane/behaviors/responders/random_response'
+require 'bane/behaviors/responders/slow_response'
+require 'bane/behaviors/responders/exported'
+require 'bane/behaviors/servers/responder_server'
+require 'bane/behaviors/servers/timeout_in_listen_queue'
+require 'bane/behaviors/servers/exported'
 require 'bane/launcher'
-require 'bane/behavior_server'
+require 'bane/arguments_parser'
 require 'bane/command_line_configuration'
-require 'bane/configuration_parser'
 require 'bane/naive_http_response'

data/lib/bane/arguments_parser.rb

@@ -0,0 +1,73 @@
+require 'optparse'
+
+module Bane
+  class ArgumentsParser
+    def initialize(makeable_names)
+      @makeable_names = makeable_names
+      @options = {host: default_host}
+      @option_parser = init_option_parser
+    end
+
+    def parse(args)
+      @option_parser.parse!(args)
+
+      raise ConfigurationError, "Missing arguments" if args.empty?
+
+      port = parse_port(args[0])
+      behaviors = args.drop(1)
+      ParsedArguments.new(port, @options[:host], behaviors)
+    rescue OptionParser::InvalidOption => io
+      raise ConfigurationError, io.message
+    end
+
+    def usage
+      @option_parser.help
+    end
+
+    private
+
+    def init_option_parser
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: bane [options] port [behaviors]'
+        opts.separator ''
+        opts.on('-l', '--listen-on-localhost',
+                "Listen on localhost, (#{default_host}). [default]") do
+          @options[:host] = default_host
+        end
+        opts.on('-a', '--listen-on-all-hosts', "Listen on all interfaces, (#{all_interfaces})") do
+          @options[:host] = all_interfaces
+        end
+        opts.separator ''
+        opts.separator 'All behaviors:'
+        opts.separator @makeable_names.sort.map { |title| " - #{title}" }.join("\n")
+      end
+    end
+
+    def parse_port(port)
+      Integer(port)
+    rescue ArgumentError
+      raise ConfigurationError, "Invalid port number: #{port}"
+    end
+
+    def all_interfaces
+      Behaviors::Servers::ALL_INTERFACES
+    end
+
+    def default_host
+      Behaviors::Servers::LOCALHOST
+    end
+  end
+
+  class ParsedArguments
+
+    attr_reader :port, :host, :behaviors
+
+    def initialize(port, host, behaviors)
+      @host = host
+      @port = port
+      @behaviors = behaviors
+    end
+
+  end
+
+end

data/lib/bane/behavior_maker.rb

@@ -0,0 +1,39 @@
+module Bane
+
+  class BehaviorMaker
+    def initialize(makeables)
+      @makeables = makeables
+    end
+
+    def create(behavior_names, starting_port, host)
+      behavior_names
+        .map { |behavior| makeables.fetch(behavior) { raise UnknownBehaviorError.new(behavior) } }
+        .map.with_index { |maker, index| maker.make(starting_port + index, host) }
+    end
+
+    def create_all(starting_port, host)
+      makeables.sort.map.with_index { |name_maker_pair, index| name_maker_pair.last.make(starting_port + index, host) }
+    end
+
+    private
+
+    attr_reader :makeables
+  end
+
+  class UnknownBehaviorError < RuntimeError
+    def initialize(name)
+      super "Unknown behavior: #{name}"
+    end
+  end
+
+  class ResponderMaker
+    def initialize(responder)
+      @responer = responder
+    end
+
+    def make(port, host)
+      Behaviors::Servers::ResponderServer.new(port, @responer.new, host)
+    end
+  end
+
+end

data/lib/bane/behaviors/responders/close_after_pause.rb

@@ -0,0 +1,21 @@
+module Bane
+  module Behaviors
+    module Responders
+
+      # Accepts a connection, pauses a fixed duration, then closes the connection.
+      #
+      # Options:
+      #   - duration: The number of seconds to wait before disconnect.  Default: 30
+      class CloseAfterPause
+        def initialize(options = {})
+          @options = {duration: 30}.merge(options)
+        end
+
+        def serve(io)
+          sleep(@options[:duration])
+        end
+      end
+
+    end
+  end
+end

data/lib/bane/behaviors/responders/close_immediately.rb

@@ -0,0 +1,14 @@
+module Bane
+  module Behaviors
+    module Responders
+
+      # Closes the connection immediately after a connection is made.
+      class CloseImmediately
+        def serve(io)
+          # do nothing
+        end
+      end
+
+    end
+  end
+end

data/lib/bane/behaviors/responders/deluge_response.rb

@@ -0,0 +1,27 @@
+module Bane
+  module Behaviors
+    module Responders
+
+      # Sends a large response.  Response consists of a repeated 'x' character.
+      #
+      # Options
+      #  - length: The size in bytes of the response to send. Default: 1,000,000 bytes
+      class DelugeResponse
+        def initialize(options = {})
+          @options = {length: 1_000_000}.merge(options)
+        end
+
+        def serve(io)
+          length = @options[:length]
+
+          length.times { io.write('x') }
+        end
+      end
+
+      class DelugeResponseForEachLine < DelugeResponse
+        include ForEachLine
+      end
+
+    end
+  end
+end

data/lib/bane/behaviors/responders/echo_response.rb

@@ -0,0 +1,16 @@
+module Bane
+  module Behaviors
+    module Responders
+
+      class EchoResponse
+        def serve(io)
+          while (input = io.gets)
+            io.write(input)
+          end
+          io.close
+        end
+      end
+
+    end
+  end
+end

data/lib/bane/behaviors/responders/exported.rb

@@ -0,0 +1,9 @@
+module Bane
+  module Behaviors
+    module Responders
+
+      EXPORTED = self.constants.map { |name| self.const_get(name) }.grep(Class)
+
+    end
+  end
+end

data/lib/bane/behaviors/responders/fixed_response.rb

@@ -0,0 +1,25 @@
+module Bane
+  module Behaviors
+    module Responders
+
+      # Sends a static response.
+      #
+      # Options:
+      #   - message: The response message to send. Default: "Hello, world!"
+      class FixedResponse
+        def initialize(options = {})
+          @options = {message: "Hello, world!"}.merge(options)
+        end
+
+        def serve(io)
+          io.write @options[:message]
+        end
+      end
+
+      class FixedResponseForEachLine < FixedResponse
+        include ForEachLine
+      end
+
+    end
+  end
+end