RubyGems - bane - Versions diffs - 0.1.1 → 1.0.0 - Mend

bane 0.1.1 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (50) hide show

checksums.yaml +7 -0
data/HISTORY.md +49 -0
data/LICENSE +1 -1
data/README.md +41 -31
data/TODO +15 -10
data/bin/bane +8 -11
data/lib/bane/arguments_parser.rb +75 -0
data/lib/bane/behavior_maker.rb +41 -0
data/lib/bane/behaviors/responders/close_after_pause.rb +23 -0
data/lib/bane/behaviors/responders/close_immediately.rb +16 -0
data/lib/bane/behaviors/responders/deluge_response.rb +29 -0
data/lib/bane/behaviors/responders/echo_response.rb +18 -0
data/lib/bane/behaviors/responders/exported.rb +11 -0
data/lib/bane/behaviors/responders/fixed_response.rb +27 -0
data/lib/bane/behaviors/responders/for_each_line.rb +20 -0
data/lib/bane/behaviors/responders/http_refuse_all_credentials.rb +33 -0
data/lib/bane/behaviors/responders/never_respond.rb +29 -0
data/lib/bane/behaviors/responders/newline_response.rb +20 -0
data/lib/bane/behaviors/responders/random_response.rb +26 -0
data/lib/bane/behaviors/responders/slow_response.rb +34 -0
data/lib/bane/behaviors/servers/exported.rb +20 -0
data/lib/bane/behaviors/servers/responder_server.rb +52 -0
data/lib/bane/behaviors/servers/timeout_in_listen_queue.rb +53 -0
data/lib/bane/command_line_configuration.rb +41 -0
data/lib/bane/extensions.rb +9 -0
data/lib/bane/launcher.rb +9 -8
data/lib/bane/naive_http_response.rb +2 -0
data/lib/bane/version.rb +5 -0
data/lib/bane.rb +21 -6
metadata +104 -102
data/Rakefile +0 -60
data/examples/simple_port_and_class_as_constant.rb +0 -9
data/examples/simple_port_and_class_as_string.rb +0 -7
data/examples/specify_behavior_options.rb +0 -16
data/examples/specify_ports.rb +0 -15
data/lib/bane/behaviors.rb +0 -151
data/lib/bane/compatibility.rb +0 -36
data/lib/bane/configuration.rb +0 -50
data/lib/bane/configuration_parser.rb +0 -74
data/lib/bane/delegating_gserver.rb +0 -42
data/lib/bane/service_registry.rb +0 -17
data/test/bane/behaviors_test.rb +0 -137
data/test/bane/configuration_parser_test.rb +0 -124
data/test/bane/configuration_test.rb +0 -52
data/test/bane/delegating_gserver_test.rb +0 -56
data/test/bane/integration_test.rb +0 -67
data/test/bane/launcher_test.rb +0 -16
data/test/bane/naive_http_response_test.rb +0 -69
data/test/bane/service_registry_test.rb +0 -20
data/test/test_helper.rb +0 -9

data/lib/bane/behaviors.rb DELETED Viewed

@@ -1,151 +0,0 @@
-module Bane
-  module Behaviors
-    class BasicBehavior
-      def self.inherited(clazz)
-        ServiceRegistry.register(clazz)
-      end
-      def self.simple_name
-        self.name.split("::").last
-      end
-    end
-    # This module can be used to wrap another behavior with
-    # a "while(io.gets)" loop, which reads a line from the input and
-    # then performs the given behavior.
-    module ForEachLine
-      def serve(io, options)
-        while (io.gets)
-          super(io, options)
-        end
-      end
-    end
-    # Closes the connection immediately after a connection is made.
-    class CloseImmediately < BasicBehavior
-      def serve(io, options)
-        # do nothing
-      end
-    end
-    # 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 < BasicBehavior
-      def serve(io, options)
-        options = {:duration => 30}.merge(options)
-        sleep(options[:duration])
-      end
-    end
-    # Sends a static response.
-    #
-    # Options:
-    #   - message: The response message to send. Default: "Hello, world!"
-    class FixedResponse < BasicBehavior
-      def serve(io, options)
-        options = {:message => "Hello, world!"}.merge(options)
-        io.write options[:message]
-      end
-    end
-    class FixedResponseForEachLine < FixedResponse
-      include ForEachLine
-    end
-    # Sends a random response.
-    class RandomResponse < BasicBehavior
-      def serve(io, options)
-        io.write random_string
-      end
-      private
-      def random_string
-        (1..rand(26)+1).map { |i| ('a'..'z').to_a[rand(26)] }.join
-      end
-    end
-    class RandomResponseForEachLine < RandomResponse
-      include ForEachLine
-    end
-    # Sends a fixed response chacter-by-character, pausing in between each character.
-    #
-    # Options:
-    #  - message: The response to send. Default: "Hello, world!"
-    #  - pause_duration: The number of seconds to pause between each character. Default: 10 seconds
-    class SlowResponse < BasicBehavior
-      def serve(io, options)
-        options = {:message => "Hello, world!", :pause_duration => 10}.merge(options)
-        message = options[:message]
-        pause_duration = options[:pause_duration]
-        message.each_char do |char|
-          io.write char
-          sleep pause_duration
-        end
-      end
-    end
-    class SlowResponseForEachLine < SlowResponse
-      include ForEachLine
-    end
-    # Accepts a connection and never sends a byte of data.  The connection is
-    # left open indefinitely.
-    class NeverRespond < BasicBehavior
-      def serve(io, options)
-        loop { sleep 1 }
-      end
-    end
-    # 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 < BasicBehavior
-      def serve(io, options)
-        options = {:length => 1_000_000}.merge(options)
-        length = options[:length]
-        length.times { io.write('x') }
-      end
-    end
-    class DelugeResponseForEachLine < DelugeResponse
-      include ForEachLine
-    end
-    # Sends an HTTP 401 response (Unauthorized) for every request.  This
-    # attempts to mimic an HTTP server by reading a line (the request)
-    # and then sending the response.  This behavior responds to all
-    # incoming request URLs on the running port.
-    class HttpRefuseAllCredentials < BasicBehavior
-      UNAUTHORIZED_RESPONSE_BODY = <<EOF
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Bane Server</title>
-  </head>
-  <body>
-    <h1>Unauthorized</h1>
-  </body>
-</html>
-EOF
-      def serve(io, options)
-        io.gets # Read the request before responding
-        response = NaiveHttpResponse.new(401, "Unauthorized", "text/html", UNAUTHORIZED_RESPONSE_BODY)
-        io.write(response.to_s)
-      end
-    end
-  end
-end

data/lib/bane/compatibility.rb DELETED Viewed

@@ -1,36 +0,0 @@
-class String
-  unless "".respond_to?(:each_char)
-    # copied from jcode in Ruby 1.8.6
-    def each_char
-      if block_given?
-        scan(/./m) do |x|
-          yield x
-        end
-      else
-        scan(/./m)
-      end
-    end
-  end
-  unless "".respond_to?(:lines)
-    require "enumerator"
-    alias_method :lines, :to_a
-  end
-end
-# Copied from ActiveSupport
-unless :to_proc.respond_to?(:to_proc)
-  class Symbol
-    # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
-    #
-    #   # The same as people.collect { |p| p.name }
-    #   people.collect(&:name)
-    #
-    #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
-    #   people.select(&:manager?).collect(&:salary)
-    def to_proc
-      Proc.new { |*args| args.shift.__send__(self, *args) }
-    end
-  end
-end

data/lib/bane/configuration.rb DELETED Viewed

@@ -1,50 +0,0 @@
-module Bane
-  class Configuration
-    def initialize(configurations)
-      @configurations = configurations
-    end
-    def start(logger)
-      @configurations.map do |config|
-        config.start(logger)
-      end
-    end
-    class ConfigurationRecord
-      def initialize(port, behavior, options = {})
-        @port = port
-        @behavior = behavior
-        @options = options
-      end
-      def start(logger)
-        new_server = DelegatingGServer.new(@port, @behavior.new, @options, logger)
-        new_server.start
-        new_server
-      end
-    end
-  end
-  class ConfigurationError < RuntimeError; end
-  class UnknownBehaviorError < RuntimeError
-    def initialize(name)
-      super "Unknown behavior: #{name}"
-    end
-  end
-end
-# Helper method to easily create configuration.
-#
-# This should likely take the constructor block from the Configuration class
-# and then we can simplify this class so it's not so big.
-module Kernel
-  def Configuration(*args)
-    Bane::Configuration.new(Bane::ConfigurationParser.new(*args).configurations)
-  end
-end

data/lib/bane/configuration_parser.rb DELETED Viewed

@@ -1,74 +0,0 @@
-module Bane
-  class ConfigurationParser
-    attr_reader :configurations
-    def initialize(*args)
-      @configurations = []
-      @configurations = case args[0]
-        when String, Integer
-          map_integer_and_behavior_arguments(*args)
-        when Hash
-          map_hash_arguments(args[0])
-        else
-          raise ConfigurationError, "Unknown configuration arguments #{args.inspect}"
-      end
-    end
-    private
-    def map_integer_and_behavior_arguments(*args)
-      port = Integer(args.shift)
-      behavior_classes = args
-      behavior_classes = ServiceRegistry.all_servers if behavior_classes.empty?
-      setup_linear_ports(port, behavior_classes)
-    end
-    def setup_linear_ports(port, behavior_classes)
-      behavior_classes.each_with_index do |behavior, index|
-        @configurations << Bane::Configuration::ConfigurationRecord.new(port + index, find(behavior))
-      end
-      @configurations
-    end
-    def find(behavior)
-      case behavior
-        when String
-          raise UnknownBehaviorError.new(behavior) unless Behaviors.const_defined?(behavior.to_sym)
-          Behaviors.const_get(behavior)
-        when Module
-          behavior
-        else
-          raise UnknownBehaviorError.new(behavior)
-      end
-    end
-    def map_hash_arguments(options)
-      options.each_pair do |key, value|
-        @configurations << extract_configuration_from(key, value)
-      end
-      @configurations
-    end
-    def extract_configuration_from(port, value)
-      case value
-        when Module
-          behavior = value
-          Bane::Configuration::ConfigurationRecord.new(port, behavior)
-        when Hash
-          behavior = value.delete(:behavior)
-          options = value
-          Bane::Configuration::ConfigurationRecord.new(port, behavior, options)
-        else
-          raise ConfigurationError, "Unknown configuration option: #{value.inspect}"
-      end
-    end
-  end
-end

data/lib/bane/delegating_gserver.rb DELETED Viewed

@@ -1,42 +0,0 @@
-require 'gserver'
-module Bane
-  class DelegatingGServer < GServer
-    def initialize(port, behavior, options = {}, logger = $stderr)
-      super(port)
-      @behavior = behavior
-      @options = options
-      self.audit = true
-      self.stdlog = logger
-    end
-    def serve(io)
-      @behavior.serve(io, @options)
-    end
-    protected
-    alias_method :original_log, :log
-    def log(message)
-      original_log("#{@behavior.class.simple_name} #{@host}:#{@port} #{message}")
-    end
-    def connecting(client)
-      addr = client.peeraddr
-      log("client:#{addr[1]} #{addr[2]}<#{addr[3]}> connect")
-    end
-    def disconnecting(client_port)
-      log("client:#{client_port} disconnect")
-    end
-    def starting()
-      log("start")
-    end
-    def stopping()
-      log("stop")
-    end
-  end
-end

data/lib/bane/service_registry.rb DELETED Viewed

@@ -1,17 +0,0 @@
-module Bane
-  module ServiceRegistry
-    def self.all_servers
-      @servers ||= []
-    end
-    def self.register(server)
-      all_servers << server unless all_servers.include?(server)
-    end
-    def self.unregister(server)
-      all_servers.delete server
-    end
-  end
-end

data/test/bane/behaviors_test.rb DELETED Viewed

@@ -1,137 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require 'timeout'
-require 'mocha'
-class BehaviorsTest < Test::Unit::TestCase
-  include Bane::Behaviors
-  class FakeConnection < StringIO
-    def will_send(query)
-      @query = query
-    end
-    def gets
-      @query
-      @read_query = true
-    end
-    def read_query?
-      @read_query
-    end
-  end
-  def setup
-    @fake_connection = FakeConnection.new
-  end
-  def test_fixed_response_sends_the_specified_message
-    query_server(create(FixedResponse), :message => "Test Message")
-    assert_equal "Test Message", response
-  end
-  def test_deluge_response_sends_one_million_bytes_by_default
-    query_server(create DelugeResponse)
-    assert_response_length 1_000_000
-  end
-  def test_deluge_response_accepts_length_parameter
-    query_server(create(DelugeResponse), :length => 1)
-    assert_response_length 1
-  end
-  def test_close_immediately_sends_no_response
-    query_server(create CloseImmediately)
-    assert_empty_response()
-  end
-  def test_never_respond_never_sends_a_response
-    server = create NeverRespond
-    assert_raise Timeout::Error do
-      Timeout::timeout(3) { query_server(server) }
-    end
-    assert_empty_response
-  end
-  def test_close_after_pause_sleeps_30_seconds_by_default_and_sends_nothing
-    server = create CloseAfterPause
-    server.expects(:sleep).with(30)
-    query_server(server)
-    assert_empty_response
-  end
-  def test_close_after_pause_accepts_duration_parameter
-    server = create CloseAfterPause
-    within(2) { query_server(server, :duration => 1) }
-  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)}
-    assert_equal message, response
-  end
-  def test_random_response_sends_a_nonempty_response
-    query_server(create RandomResponse)
-    assert (!response.empty?), "Should have served a nonempty response"
-  end
-  def test_refuse_all_http_credentials_sends_401_response_code
-    @fake_connection.will_send("GET /some/irrelevant/path HTTP/1.1")
-    server = create(HttpRefuseAllCredentials)
-    query_server(server)
-    assert @fake_connection.read_query?, "Should have read the HTTP query before sending response"
-    assert_match /HTTP\/1.1 401 Unauthorized/, response, 'Should have responded with the 401 response code'
-  end
-  def test_simple_name_strips_away_the_namespace
-    assert_equal "SlowResponse", Bane::Behaviors::SlowResponse.simple_name
-  end
-  private
-  def create(server_class)
-    server_class.new()
-  end
-  def query_server(server, options = {})
-    server.serve(@fake_connection, options)
-  end
-  def response
-    @fake_connection.string
-  end
-  def assert_empty_response
-    assert_equal 0, response.length, "Should have sent nothing"
-  end
-  def assert_response_length(expected_length)
-    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/configuration_parser_test.rb DELETED Viewed

@@ -1,124 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require 'mocha'
-class ConfigurationParserTest < Test::Unit::TestCase
-  include Bane
-  IRRELEVANT_BEHAVIOR = Module.new
-  def test_should_map_single_port_and_server_name
-    parser = ConfigurationParser.new(3000, "CloseAfterPause")
-    assert_matches_configuration([
-            {:port => 3000, :behavior => Behaviors::CloseAfterPause}
-    ], parser)
-  end
-  def test_should_map_multiple_servers_given_one_starting_port
-    parser = ConfigurationParser.new(3000, "CloseImmediately", "CloseAfterPause")
-    assert_matches_configuration([
-            {:port => 3000, :behavior => Behaviors::CloseImmediately},
-            {:port => 3001, :behavior => Behaviors::CloseAfterPause}
-    ], parser)
-  end
-  def test_should_map_string_port
-    parser = Bane::ConfigurationParser.new("3000", IRRELEVANT_BEHAVIOR)
-    actual = parser.configurations[0]
-    assert_equal 3000, actual.instance_variable_get(:@port), "Should have mapped port given a String"
-  end
-  def test_should_raise_if_unknown_server_name
-    assert_raises Bane::UnknownBehaviorError do
-      Bane::ConfigurationParser.new(IRRELEVANT_PORT, "ABehaviorThatDoesNotExist")
-    end
-  end
-  def test_should_map_server_when_given_class
-    parser = ConfigurationParser.new(IRRELEVANT_PORT, Behaviors::CloseAfterPause)
-    actual = parser.configurations[0]
-    assert_equal Behaviors::CloseAfterPause, actual.instance_variable_get(:@behavior), "Wrong behavior"
-  end
-  def test_should_ask_service_registry_for_all_behaviors_if_none_specified
-    fake_behavior = unique_behavior
-    another_fake_behavior = unique_behavior
-    ServiceRegistry.expects(:all_servers).returns([fake_behavior, another_fake_behavior])
-    parser = ConfigurationParser.new(4000)
-    assert_matches_configuration([
-            {:port => 4000, :behavior => fake_behavior},
-            {:port => 4001, :behavior => another_fake_behavior}
-    ], parser)
-  end
-  def test_should_raise_exception_if_no_arguments
-    assert_raises ConfigurationError do
-      ConfigurationParser.new
-    end
-  end
-  def test_should_raise_exception_if_nil_port_with_behaviors
-    assert_raises ConfigurationError do
-      ConfigurationParser.new(nil, IRRELEVANT_BEHAVIOR)
-    end
-  end
-  def test_should_map_single_hash_entry_as_port_and_behavior
-    parser = ConfigurationParser.new(
-            10256 => Behaviors::CloseAfterPause
-    )
-    assert_matches_configuration([
-            {:port => 10256, :behavior => Behaviors::CloseAfterPause}
-    ], parser)
-  end
-  def test_should_map_multiple_hash_entries_as_port_and_behavior
-    parser = ConfigurationParser.new(
-            10256 => Behaviors::CloseAfterPause,
-            6450 => Behaviors::CloseImmediately
-    )
-    assert_matches_configuration([
-            {:port => 10256, :behavior => Behaviors::CloseAfterPause},
-            {:port => 6450, :behavior => Behaviors::CloseImmediately}
-    ], parser)
-  end
-  def test_should_map_hash_with_options
-    parser = ConfigurationParser.new(
-            10256 => {:behavior => Behaviors::CloseAfterPause, :duration => 3},
-            11239 => Behaviors::CloseImmediately
-    )
-    assert_matches_configuration([
-            {:port => 10256, :behavior => Behaviors::CloseAfterPause},
-            {:port => 11239, :behavior => Behaviors::CloseImmediately}
-    ], parser)
-  end
-  private
-  def assert_matches_configuration(expected_config, actual_config)
-    actual_elements = actual_config.configurations
-    assert_equal expected_config.size, actual_elements.size, "Did not create correct number of configurations. Actual: #{actual_elements}, expected #{expected_config}"
-    expected_config.each do |expected|
-      # We make no guarantee on the order of the configurations
-      assert_includes_configuration(actual_elements, expected)
-    end
-  end
-  def assert_includes_configuration(actual_elements, expected)
-    expected_port = expected[:port]
-    matching_config = actual_elements.detect { |actual| actual.instance_variable_get(:@port) == expected_port }
-    assert_not_nil matching_config, "Should have found a configuration with port #{expected_port}"
-    assert_equal expected[:behavior], matching_config.instance_variable_get(:@behavior), "Wrong behavior for port #{expected_port}"
-  end
-  def unique_behavior
-    Module.new
-  end
-end

data/test/bane/configuration_test.rb DELETED Viewed

@@ -1,52 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-require 'mocha'
-module Bane
-  module Behaviors
-    class FakeTestServer < BasicBehavior
-    end
-  end
-end
-class ConfigurationTest < Test::Unit::TestCase
-  include Bane
-  def test_starts_server_on_specified_port
-    target_port = 4000
-    DelegatingGServer.expects(:new).with(equals(target_port), anything(), anything(), anything()).returns(fake_server)
-    start_configuration(target_port, Behaviors::FakeTestServer)
-  end
-  def test_starts_server_with_specified_behavior
-    behavior_instance = stub('constructed behavior instance')
-    Behaviors::FakeTestServer.expects(:new).returns(behavior_instance)
-    DelegatingGServer.expects(:new).with(anything(), equals(behavior_instance), anything(), anything()).returns(fake_server)
-    start_configuration(IRRELEVANT_PORT, Behaviors::FakeTestServer)
-  end
-  def test_constructs_server_with_specified_options
-    options = { :an_option => :a_value, :another_option => :another_value }
-    DelegatingGServer.expects(:new).with(anything(), anything, has_entries(options), anything()).returns(fake_server)
-    start_configuration(IRRELEVANT_PORT, Behaviors::FakeTestServer, options)
-  end
-  private
-  def start_configuration(target_port, behavior, options = {})
-    configuration = configuration_with(target_port, behavior, options)
-    configuration.start(StringIO.new)
-  end
-  def configuration_with(port, behavior, options)
-    Configuration.new([Configuration::ConfigurationRecord.new(port, behavior, options)])
-  end
-  def fake_server
-    stub_everything('fake_server')
-  end
-end