bane 0.2.0 → 0.3.0

data/lib/bane/command_line_configuration.rb

@@ -0,0 +1,96 @@
+require 'optparse'
+
+module Bane
+  class CommandLineConfiguration
+    def initialize()
+      @options = { :host => BehaviorServer::DEFAULT_HOST }
+      @option_parser = init_option_parser
+    end
+
+    def parse(args)
+      parse_options(@options, args)
+
+      return [] if (args.empty?)
+
+      port = parse_port(args[0])
+      behaviors = parse_behaviors(args.drop(1))
+
+      behaviors = ServiceRegistry.all_servers if behaviors.empty?
+      LinearPortMappedBehaviorConfiguration.new(port, behaviors, @options[:host]).servers
+    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, (#{BehaviorServer::DEFAULT_HOST}). [default]") do
+          @options[:host] = BehaviorServer::DEFAULT_HOST
+        end
+        opts.on("-a", "--listen-on-all-hosts", "Listen on all interfaces, (#{BehaviorServer::ALL_INTERFACES})") do
+          @options[:host] = BehaviorServer::ALL_INTERFACES
+        end
+        opts.separator ""
+        opts.separator "All behaviors:"        
+        opts.separator ServiceRegistry.all_server_names.map { |title| " - #{title}" }.join("\n")
+
+      end
+    end
+
+    def parse_options(options, args)
+      @option_parser.parse!(args)
+      rescue OptionParser::InvalidOption => io
+        raise ConfigurationError, io.message
+    end
+
+    def parse_port(port)
+      Integer(port)
+      rescue ArgumentError => ae
+        raise ConfigurationError, "Invalid port number: #{port}"
+    end
+
+    def parse_behaviors(behavior_names)
+      behavior_names.map { |behavior| find(behavior) }
+      rescue UnknownBehaviorError => ube
+        raise ConfigurationError, ube.message
+    end
+
+    def find(behavior)
+      raise UnknownBehaviorError.new(behavior) unless Behaviors.const_defined?(behavior)
+      Behaviors.const_get(behavior)      
+    end
+
+    class LinearPortMappedBehaviorConfiguration
+      def initialize(port, behaviors, host)
+        @starting_port = port
+        @behaviors = behaviors
+        @host = host
+      end
+
+      def servers
+        configurations = []
+        @behaviors.each_with_index do |behavior, index|
+          configurations << BehaviorServer.new(@starting_port + index, behavior.new, @host)
+        end
+        configurations
+      end
+
+    end
+
+  end
+
+  class ConfigurationError < RuntimeError; end
+
+  class UnknownBehaviorError < RuntimeError
+    def initialize(name)
+      super "Unknown behavior: #{name}"
+    end
+  end
+
+end

data/lib/bane/configuration_parser.rb

@@ -4,8 +4,8 @@ module Bane
 
     attr_reader :configurations
 
-
     def initialize(*args)
+      warn_about_deprecation()
       @configurations = []
 
       @configurations = case args[0]
@@ -18,6 +18,10 @@ module Bane
       end
     end
 
+    def warn_about_deprecation
+      warn "Kernel#Configuration() and ConfigurationParser are deprecated. Please directly construct an array of BehaviorServers to pass to Launcher."
+    end
+
     private
 
     def map_integer_and_behavior_arguments(*args)
@@ -31,7 +35,7 @@ module Bane
 
     def setup_linear_ports(port, behavior_classes)
       behavior_classes.each_with_index do |behavior, index|
-        @configurations << Bane::Configuration::ConfigurationRecord.new(port + index, find(behavior))
+        @configurations << create_server(port + index, find(behavior))
       end
       @configurations
     end
@@ -59,16 +63,27 @@ module Bane
       case value
         when Module
           behavior = value
-          Bane::Configuration::ConfigurationRecord.new(port, behavior)
+          create_server(port, behavior)
         when Hash
           behavior = value.delete(:behavior)
           options = value
-          Bane::Configuration::ConfigurationRecord.new(port, behavior, options)
+          create_server(port, behavior, options)
         else
           raise ConfigurationError, "Unknown configuration option: #{value.inspect}"
       end
     end
 
+    def create_server(port, behavior, options = {})
+      BehaviorServer.new(port, behavior.new(options), BehaviorServer::DEFAULT_HOST)
+    end
+
   end
 
+end
+
+# Helper method to easily create configuration.
+module Kernel
+  def Configuration(*args)
+    Bane::ConfigurationParser.new(*args).configurations
+  end
 end

data/lib/bane/launcher.rb

@@ -2,24 +2,23 @@ module Bane
 
   class Launcher
 
-    def initialize(configurations, logger = $stderr)
-      @configuration = configurations
-      @logger = logger
-      @running_servers = []
+    def initialize(servers, logger = $stderr)
+      @servers = servers
+      @servers.each { |server| server.stdlog = logger }
     end
 
     def start
-      @running_servers = @configuration.start(@logger)
+      @servers.each { |server| server.start }
     end
 
     def join
-      @running_servers.each { |server| server.join }
+      @servers.each { |server| server.join }
     end
 
     def stop
-      @running_servers.each { |server| server.stop }
+      @servers.each { |server| server.stop }
     end
 
   end
-
+  
 end

data/lib/bane/service_registry.rb

@@ -5,6 +5,10 @@ module Bane
       @servers ||= []
     end
 
+    def self.all_server_names
+      all_servers.map(&:simple_name).sort
+    end
+
     def self.register(server)
       all_servers << server unless all_servers.include?(server)
     end

data/test/bane/{delegating_gserver_test.rb → behavior_server_test.rb}

@@ -1,30 +1,32 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
 require 'mocha'
 
-class DelegatingGserverTest < Test::Unit::TestCase
+class BehaviorServerTest < Test::Unit::TestCase
   include Bane
   
   IRRELEVANT_IO_STREAM = nil
   IRRELEVANT_OPTIONS = {}
+  IRRELEVANT_HOST = "1.1.1.1"
+  IRRELEVANT_BEHAVIOR = nil
 
-  def test_serve_passes_a_hash_of_options_even_if_not_initialized_with_options
-    behavior = mock()
-    server = DelegatingGServer.new(IRRELEVANT_PORT, behavior)
-
-    behavior.expects(:serve).with(anything(), is_a(Hash))
+  def test_initializes_server_on_specified_port
+    server = BehaviorServer.new(6000, IRRELEVANT_BEHAVIOR)
+    assert_equal 6000, server.port
+  end
 
-    server.serve(IRRELEVANT_IO_STREAM)
+  def test_initializes_server_on_specified_hostname
+    server = BehaviorServer.new(IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR, "hostname")
+    assert_equal "hostname", server.host
   end
 
-  def test_serve_passes_constructor_options_to_behaviors_serve_method
+  def test_delegates_serve_call_to_behavior
+    io = mock()
     behavior = mock()
-    
-    initialized_options = {:expected => :options}
-    server = DelegatingGServer.new(IRRELEVANT_PORT, behavior, initialized_options)
+    server = BehaviorServer.new(IRRELEVANT_PORT, behavior)
 
-    behavior.expects(:serve).with(anything(), equals(initialized_options))
+    behavior.expects(:serve).with(io)
 
-    server.serve(IRRELEVANT_IO_STREAM)
+    server.serve(io)
   end
 
   def test_connection_log_messages_use_short_behavior_name_to_shorten_log_messages
@@ -45,8 +47,9 @@ class DelegatingGserverTest < Test::Unit::TestCase
 
   def assert_log_message_uses_short_behavior_name_for(method)
     logger = StringIO.new
-    server = DelegatingGServer.new(IRRELEVANT_PORT, Bane::Behaviors::CloseImmediately.new, IRRELEVANT_OPTIONS, logger)
-
+    server = BehaviorServer.new(IRRELEVANT_PORT, Bane::Behaviors::CloseImmediately.new)
+    server.stdlog = logger
+    
     yield server
 
     assert_match /CloseImmediately/, logger.string, "Log for #{method} should contain class short name"

data/test/bane/behaviors_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
 require 'timeout'
 require 'mocha'
 
@@ -11,72 +11,80 @@ class BehaviorsTest < Test::Unit::TestCase
   end
 
   def test_fixed_response_sends_the_specified_message
-    query_server(create(FixedResponse), :message => "Test Message")
+    query_server(FixedResponse.new(:message => "Test Message"))
 
     assert_equal "Test Message", response
   end
 
   def test_newline_response_sends_only_a_newline_character
-    query_server(create(NewlineResponse))
+    query_server(NewlineResponse.new)
 
     assert_equal "\n", response
   end
 
   def test_deluge_response_sends_one_million_bytes_by_default
-    query_server(create(DelugeResponse))
+    query_server(DelugeResponse.new)
 
     assert_response_length 1_000_000
   end
 
   def test_deluge_response_accepts_length_parameter
-    query_server(create(DelugeResponse), :length => 1)
+    query_server(DelugeResponse.new(:length => 1))
 
     assert_response_length 1
   end
 
   def test_close_immediately_sends_no_response
-    query_server(create(CloseImmediately))
+    query_server(CloseImmediately.new)
 
     assert_empty_response()
   end
 
   def test_never_respond_never_sends_a_response
-    server = create(NeverRespond)
+    server = NeverRespond.new
 
     assert_raise Timeout::Error do
-      Timeout::timeout(3) { query_server(server) }
+      Timeout::timeout(1) { query_server(server) }
     end
     assert_empty_response
   end
 
-  def test_close_after_pause_sleeps_30_seconds_by_default_and_sends_nothing
-    server = create(CloseAfterPause)
+  def test_close_after_pause_sleeps_30_seconds_by_default
+    server = CloseAfterPause.new
     server.expects(:sleep).with(30)
-    
-    query_server(server)
 
-    assert_empty_response
+    query_server(server)
   end
 
+
   def test_close_after_pause_accepts_duration_parameter
-    server = create(CloseAfterPause)
+    server = CloseAfterPause.new(:duration => 1)
+    server.expects(:sleep).with(1)
 
-    within(2) { query_server(server, :duration => 1) }
+    query_server(server)
+  end
+
+  def test_close_after_pause_sends_nothing
+    server = CloseAfterPause.new
+    server.stubs(:sleep)
+
+    query_server(server)
   end
 
   def test_slow_response_sends_a_message_slowly
-    server = create(SlowResponse)
     message = "Hi!"
     delay = 0.5
-    max_delay = (message.length + 1) * delay
 
-    within(max_delay) { query_server(server, :pause_duration => delay, :message => message)}
+    server = SlowResponse.new(:pause_duration => delay, :message => message)
+    server.expects(:sleep).with(delay).at_least(message.length)
+
+    query_server(server)
 
     assert_equal message, response
   end
 
   def test_random_response_sends_a_nonempty_response
-    query_server(create(RandomResponse))
+    query_server(RandomResponse.new)
 
     assert (!response.empty?), "Should have served a nonempty response"
   end
@@ -84,7 +92,7 @@ class BehaviorsTest < Test::Unit::TestCase
   def test_refuse_all_http_credentials_sends_401_response_code
     @fake_connection.will_send("GET /some/irrelevant/path HTTP/1.1")
 
-    server = create(HttpRefuseAllCredentials)
+    server = HttpRefuseAllCredentials.new
     query_server(server)
 
     assert @fake_connection.read_all_queries?, "Should have read the HTTP query before sending response"
@@ -96,11 +104,11 @@ class BehaviorsTest < Test::Unit::TestCase
   end
 
   def test_for_each_line_reads_a_line_before_responding
-    server = create(Bane::Behaviors::FixedResponseForEachLine)
+    server = Bane::Behaviors::FixedResponseForEachLine.new({:message => "Dynamic"})
 
     @fake_connection.will_send "irrelevant\n"
 
-    query_server(server, {:message => "Dynamic"})
+    query_server(server)
     assert_equal "Dynamic", response
 
     assert @fake_connection.read_all_queries?
@@ -108,12 +116,8 @@ class BehaviorsTest < Test::Unit::TestCase
 
   private
 
-  def create(server_class)
-    server_class.new()
-  end
-
-  def query_server(server, options = {})
-    server.serve(@fake_connection, options)
+  def query_server(server)
+    server.serve(@fake_connection)
   end
 
   def response
@@ -128,12 +132,4 @@ class BehaviorsTest < Test::Unit::TestCase
     assert_equal expected_length, response.length, "Response was the wrong length"
   end
 
-  def within(duration)
-    begin
-      Timeout::timeout(duration) { yield }
-    rescue Timeout::Error
-      flunk "Test took too long - should have completed within #{duration} seconds."
-    end
-  end
-
 end

data/test/bane/command_line_configuration_test.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
+require 'mocha'
+
+class CommandLineConfigurationTest < Test::Unit::TestCase
+  include Bane
+
+  IRRELEVANT_BEHAVIOR = "CloseImmediately"
+
+  def test_creates_specified_behavior_on_given_port
+    expect_server_created_with(:port => 3000, :behavior => Behaviors::CloseImmediately)
+
+    create_configuration_for([3000, "CloseImmediately"])
+  end
+
+  def test_creates_all_known_behavior_if_only_port_specified
+    expect_server_created_with :port => 4000, :behavior => Behaviors::CloseImmediately
+    expect_server_created_with :port => 4001, :behavior => Behaviors::NeverRespond
+
+    ServiceRegistry.stubs(:all_servers).returns([Behaviors::CloseImmediately, Behaviors::NeverRespond])
+
+    create_configuration_for([4000])
+  end
+
+  def test_creates_multiple_behaviors_starting_on_given_port
+    expect_server_created_with :port => 3000, :behavior => Behaviors::CloseImmediately
+    expect_server_created_with :port => 3001, :behavior => Behaviors::CloseAfterPause
+
+    create_configuration_for([3000, "CloseImmediately", "CloseAfterPause"])
+  end
+
+  def test_dash_l_option_sets_listen_host_to_localhost
+    expect_server_created_with :host => BehaviorServer::DEFAULT_HOST
+
+    create_configuration_for(["-l", IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
+  end
+
+  def test_listen_on_localhost_sets_listen_host_to_localhost
+    expect_server_created_with :host => BehaviorServer::DEFAULT_HOST
+
+    create_configuration_for(["--listen-on-localhost", IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
+  end
+
+  def test_dash_a_option_sets_listen_host_to_all_interfaces
+    expect_server_created_with :host => BehaviorServer::ALL_INTERFACES
+
+    create_configuration_for(["-a", IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
+  end
+
+  def test_listen_on_all_hosts_option_sets_listen_host_to_all_interfaces
+    expect_server_created_with :host => BehaviorServer::ALL_INTERFACES
+
+    create_configuration_for(["--listen-on-all-hosts", IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
+  end
+
+  def test_no_arguments_returns_empty_configuration
+    assert(create_configuration_for([]).empty?,
+      "Should have returned no configurations for empty arguments")
+  end
+
+  def test_non_integer_port_fails_with_error_message
+    assert_invaild_arguments_fail_matching_message(["text_instead_of_an_integer"], /Invalid Port Number/i,
+      "Should have indicated the port was invalid.")
+  end
+
+  def test_unknown_behavior_fails_with_unknown_behavior_message
+    assert_invaild_arguments_fail_matching_message([IRRELEVANT_PORT, "AnUknownBehavior"], /Unknown Behavior/i,
+      "Should have indicated the given behavior is unknown.")
+  end
+
+  def test_invalid_option_fails_with_error_message
+    assert_invaild_arguments_fail_matching_message(["--unknown-option", IRRELEVANT_PORT], /Invalid Option/i,
+      "Should have indicated the --uknown-option switch was unknown.")
+  end
+
+
+  private
+
+  def create_configuration_for(array)
+    CommandLineConfiguration.new().parse(array)
+  end
+
+  def unique_behavior
+    Class.new
+  end
+
+  def expect_server_created_with(arguments)
+    arguments = { :port => anything(), :host => anything() }.merge(arguments)
+    behavior_matcher = arguments[:behavior] ? instance_of(arguments[:behavior]) : anything()
+    BehaviorServer.expects(:new).with(arguments[:port], behavior_matcher, arguments[:host])
+  end
+
+  def assert_invaild_arguments_fail_matching_message(arguments, message_matcher, assertion_failure_message)
+    create_configuration_for(arguments)
+    fail "Should have failed"
+    rescue ConfigurationError => ce
+      assert_match(message_matcher, ce.message, assertion_failure_message)
+  end
+
+
+end