slow_server 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea6a54afb4bf9a70253d27ce0acff0b0dd5178fa
-  data.tar.gz: 3718dcc9e924ab3d5788a0af1fef4564f5ab94aa
+  metadata.gz: 7e993e4056d8bcf3c4f2aad4e5a826a9ff13a27f
+  data.tar.gz: 2ffe6af0c24b470cb1dd1d462dbacc5e3405c48b
 SHA512:
-  metadata.gz: 54def5b25784072b04d30b44f01dd53c3fcfa785b4b816004591a6b905d3e7426d3bffde040c50c8425d8bfba840dcdccfecfd048f1567b9d8ecda261324e7ed
-  data.tar.gz: 56e4395d19cd46f95754d6be0df4a03206e3284280f58bb0d64797f413cf41c8bbdc92bbce1406edbaeac293d58cc898c8475f42a8fccf176dd72135a4b57cd1
+  metadata.gz: cc65204f942fa8d813b831688f247f59371baa37de6cb593a4ba8d4cdee5f8100d47d3b8b92a2eba003e93086c40613cdd1a7f04534da9b8b3bef1d31dca1128
+  data.tar.gz: 9ffdf2608647676aec94d9172cae6a0c720cd89551b771fb65675288b25c502a65cd1c925585e14f1234ce31df1f8fa1547797cc2af101aff967707a02ef1fc1

data/README.md

@@ -1,28 +1,53 @@
 # SlowServer
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/slow_server`. To experiment with that code, run `bin/console` for an interactive prompt.
+This Gem has two parts, slow_server and slow_client, together they can be used to
+test timeouts in various stages of connections.
 
-TODO: Delete this and the text above, and describe your gem
+Currently there are two types of delays supported by both client and server,
+initial delay and chunk delay.
+
+Initial delay (--delay) causes both client and server to wait some amount of
+seconds after the connection is opened before sending anything.
+
+Chunk delay (--chunk-delay) works together with chunk count (--chunks) to split the
+message into chunks and send them one chunk at a time with some delay between.  You
+can think of this similar to Chunked Encoding for HTTP, but it's not actually using
+Chunked Encoding
 
 ## Installation
 
-Add this line to your application's Gemfile:
+    $ gem install slow_server
 
-```ruby
-gem 'slow_server'
-```
+## Usage
 
-And then execute:
+###slow_client
 
-    $ bundle
+slow_client is somewhat similar to slowloris, it has tunable delays for various different phases of connection.
 
-Or install it yourself as:
+```
+$ slow_client --help
+Usage: slow_client [OPTIONS] [URI]
+    -X, --method METHOD              Request Method                      (default: GET)
+    -p, --port NUMBER                Listen Port                         (default: 4000)
+    -c, --chunks BYTES               Chunks                              (default: 1)
+    -d, --delay SECONDS              Transmission delay after connecting (default: 0)
+    -k, --chunk-delay SECONDS        Delay between chunks                (default: 0)
+    -v, --version                    Show Version
+```
 
-    $ gem install slow_server
+###slow_server
 
-## Usage
+slow_server is the counterpart to slow_client, by default it will respond with the story of The Tortoise and The Hare, but it too has tunable delays.
 
-TODO: Write usage instructions here
+```
+$ slow_server --help
+Usage: slow_server [OPTIONS] [RESPONSE]
+    -p, --port NUMBER                Listen Port                         (default: 4000)
+    -c, --chunks BYTES               Chunks                              (default: 1)
+    -d, --delay SECONDS              Transmission delay after connecting (default: 0)
+    -k, --chunk-delay SECONDS        Delay between chunks                (default: 0)
+    -v, --version                    Show Version
+```
 
 ## Development
 
@@ -32,7 +57,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/slow_server.
+Bug reports and pull requests are welcome on GitHub at https://github.com/jscholl/slow_server.
 
 
 ## License

data/exe/slow_client

@@ -2,6 +2,6 @@
 require 'slow_server'
 
 catch :exit do
-  SlowServer.config.parse_opts
-  SlowServer::Client.new().start
+  SlowServer.client.config.parse
+  SlowServer.client.start
 end

data/exe/slow_server

@@ -2,6 +2,6 @@
 require 'slow_server'
 
 catch :exit do
-  SlowServer.config.parse_opts
-  SlowServer::Server.new().start
+  SlowServer.server.config.parse
+  SlowServer.server.start
 end

data/lib/slow_server.rb

@@ -6,17 +6,12 @@ require "slow_server/config"
 module SlowServer
   class << self
 
-    def config
-      @config ||= Config.new
+    def server
+      @server ||= Server.new
     end
 
-    def configure
-      yield config
-    end
-
-    def configure!
-      @config = Config.new
-      yield config
+    def client
+      @client ||= Client.new
     end
 
   end

data/lib/slow_server/client.rb

@@ -1,41 +1,51 @@
 require 'socket'
+require 'uri'
 
 module SlowServer
   class Client
 
     def config
-      SlowServer.config
+      @config ||= ClientConfig.new
     end
 
     def chunk_size
-      (request.size / config.chunks.to_f).ceil
+      (request_body.size / config.chunks.to_f).round
     end
 
     def chunks
-      request.scan(/.{1,#{chunk_size}}/m)
+      request_body.scan(/.{1,#{chunk_size}}/m)
     end
 
-    def request
-      "GET /"
+    def request_body
+      [].tap do |req|
+        req << [config.request_method, config.request_uri].join(" ")
+        req += config.request_headers
+      end.join("\n")
+    end
+
+    def send_request(socket)
+      chunks.each do |chunk|
+        STDERR.puts "Sending #{chunk_size} bytes"
+        socket.print chunk
+        STDERR.puts "Waiting for #{config.chunk_delay} seconds"
+        sleep config.chunk_delay
+      end
+      socket.print("\r\n\r\n")
+    end
+
+    def get_response(socket)
+      response = socket.read
+      headers,body = response.split("\r\n\r\n", 2)
+      STDERR.puts "\n"
+      print body
     end
 
     def start
-      TCPSocket.open("127.0.0.1", 4000) do |socket|
+      TCPSocket.open(config.host, config.port) do |socket|
         STDERR.puts "Waiting for #{config.response_delay} seconds"
         sleep config.response_delay
-
-        chunks.each do |chunk|
-          STDERR.puts "Sending #{chunk_size} bytes"
-          socket.print chunk
-          STDERR.puts "Waiting for #{config.chunk_delay} seconds"
-          sleep config.chunk_delay
-        end
-        socket.print("\r\n\r\n")
-
-        response = socket.read
-        headers,body = response.split("\r\n\r\n", 2)
-        STDERR.puts "\n"
-        print body
+        send_request(socket)
+        get_response(socket)
       end
     end
 

data/lib/slow_server/config.rb

@@ -1,12 +1,12 @@
 require 'optparse'
+require 'uri'
 
 module SlowServer
+
   class Config
-    attr_accessor :response, :port, :chunks, :response_delay, :chunk_delay
+    attr_accessor :port, :chunks, :response_delay, :chunk_delay
 
     def initialize
-      # set defaults
-      self.response = File.read(File.expand_path("../../../files/response.txt", __FILE__))
       self.port = 4000
       self.chunks = 1
       self.response_delay = 0
@@ -16,17 +16,59 @@ module SlowServer
     def opts
       @opts ||= OptionParser.new do |opt|
         opt.banner = "Usage: #{File.basename($PROGRAM_NAME)} [OPTIONS] [RESPONSE]"
-        opt.on("-p", "--port NUMBER",            Integer, "Listen Port                     (default: #{self.port}")            { |v| self.port = v }
-        opt.on("-c", "--chunks BYTES",           Integer, "Chunks                          (default: #{self.chunks})")         { |v| self.chunks = v }
-        opt.on("-r", "--response-delay SECONDS", Integer, "Response delay after connecting (default: #{self.response_delay})") { |v| self.response_delay = v }
-        opt.on("-k", "--chunk-delay SECONDS",    Float,   "Delay between chunks            (default: #{self.chunk_delay})")    { |v| self.chunk_delay = v }
-        opt.on("-v", "--version",                         "Show Version")                                                      { puts SlowServer::VERSION; throw :exit }
+        opt.on("-p", "--port NUMBER",            Integer, "Listen Port                         (default: #{self.port})")           { |v| self.port = v }
+        opt.on("-c", "--chunks BYTES",           Integer, "Chunks                              (default: #{self.chunks})")         { |v| self.chunks = v }
+        opt.on("-d", "--delay SECONDS",          Integer, "Transmission delay after connecting (default: #{self.response_delay})") { |v| self.response_delay = v }
+        opt.on("-k", "--chunk-delay SECONDS",    Float,   "Delay between chunks                (default: #{self.chunk_delay})")    { |v| self.chunk_delay = v }
+        opt.on("-v", "--version",                         "Show Version")                                                          { puts SlowServer::VERSION; throw :exit }
       end
     end
 
-    def parse_opts
-      response = opts.parse!.join(" ")
-      self.response = response unless response.empty?
+    def args
+      opts.parse!
+    end
+  end
+
+  class ServerConfig < Config
+    attr_accessor :response_body
+
+    def initialize
+      super
+      self.response_body = File.read(File.expand_path("../../../files/response.txt", __FILE__))
+    end
+
+    def parse
+      response = args.join(" ")
+      self.response_body = response unless response.empty?
+    end
+  end
+
+  class ClientConfig < Config
+    attr_accessor :request_method, :host, :request_uri, :request_headers
+
+    def initialize
+      super
+      self.request_method = 'GET'
+      self.host = 'localhost'
+      self.request_uri = "/"
+      self.request_headers = []
+    end
+
+    def opts
+      opts = super
+      opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} [OPTIONS] [URI]"
+      opts.on_head("-p", "--port NUMBER",            Integer, "Listen Port                         (default: #{self.port})")           { |v| @port_override = v }
+      opts.on_head("-X", "--method METHOD",          String,  "Request Method                      (default: #{self.request_method})") { |v| self.request_method = v }
+    end
+
+    def parse
+      uri = URI.parse(args[0])
+      if !uri.respond_to?(:request_uri) && uri !~ %r{^\w+:\/\/}
+        uri = URI.parse("http://#{uri}")
+      end
+      self.host = uri.host
+      self.port = @port_override || uri.port
+      self.request_uri = uri.request_uri if uri.request_uri
     end
 
   end

data/lib/slow_server/server.rb

@@ -4,7 +4,7 @@ module SlowServer
   class Server
 
     def config
-      SlowServer.config
+      @config ||= ServerConfig.new
     end
 
     def server
@@ -12,35 +12,64 @@ module SlowServer
     end
 
     def chunk_size
-      config.response.size / config.chunks
+      (config.response_body.size / config.chunks.to_f).round
     end
 
+
     def chunks
-      config.response.scan(/.{1,#{chunk_size}}/m)
+      #config.response_body.scan(/.{1,#{chunk_size}}/m)
+      # NOTE: to be accurate, chunk_size needs to be variable, or at least increase in a giant burst at the end
+      #
+
+      offset = 0
+      length = 0
+      out = []
+      config.chunks.times do |i|
+        length = ((config.response_body.size - out.join.size) / (config.chunks - i).to_f).floor
+        out << config.response_body[offset..(offset+length)]
+        offset += length + 1
+      end
+      out
+    end
+
+
+    def response_headers
+      [].tap do |h|
+        h << "HTTP/1.1 200 OK"
+        h << "Content-Type: text/plain"
+        h << "Content-Length: #{config.response_body.size}"
+        h << "Connection: close"
+      end
+    end
+
+    def get_request(socket)
+      STDERR.puts socket.gets
+      STDERR.puts "Waiting for #{config.response_delay} seconds"
+    end
+
+    def send_response(socket)
+      STDERR.puts "Sending response headers"
+      socket.print response_headers.join("\n")
+      socket.print "\r\n\r\n"
+      chunks.each do |chunk|
+        STDERR.puts "Sending #{chunk_size} bytes"
+        socket.print chunk
+        STDERR.puts "Waiting for #{config.chunk_delay} seconds"
+        sleep config.chunk_delay
+      end
     end
 
     def start
       loop do
         Thread.start(server.accept) do |socket|
+          STDERR.puts "Accepted Connection"
+          # NOTE: consider putting a delay in here too
+          get_request(socket)
 
-          STDERR.puts socket.gets
-          STDERR.puts "Waiting for #{config.response_delay} seconds"
           sleep config.response_delay
 
-          STDERR.puts "Sending response headers"
-
-          socket.print "HTTP/1.1 200 OK\r\n" +
-                       "Content-Type: text/plain\r\n" +
-                       "Content-Length: #{config.response.bytesize}\r\n" +
-                       "Connection: close\r\n\r\n"
-
-          chunks.each do |chunk|
-            STDERR.puts "Sending #{chunk_size} bytes"
-            socket.print chunk
-            STDERR.puts "Waiting for #{config.chunk_delay} seconds"
-            sleep config.chunk_delay
-          end
-
+          send_response(socket)
+          STDERR.print "\n"
           socket.close
         end
       end

data/lib/slow_server/version.rb

@@ -1,3 +1,3 @@
 module SlowServer
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slow_server
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Jason Scholl
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-06 00:00:00.000000000 Z
+date: 2016-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler