raptor-io 0.0.1

data/spec/support/fixtures/raptor/protocol/http/request/manipulators/niccolo_machiavelli.rb

@@ -0,0 +1,20 @@
+module RaptorIO
+module Protocol::HTTP
+class Request
+
+#
+# Test manipulator.
+#
+# @author Tasos Laskos <tasos_laskos@rapid7.com>
+#
+class Manipulators::NiccoloMachiavelli < Manipulator
+
+  def run
+    [client, request, options, datastore]
+  end
+
+end
+
+end
+end
+end

data/spec/support/fixtures/raptor/protocol/http/request/manipulators/options_validator.rb

@@ -0,0 +1,28 @@
+module RaptorIO
+module Protocol::HTTP
+class Request
+
+#
+# Test manipulator.
+#
+# @author Tasos Laskos <tasos_laskos@rapid7.com>
+#
+class Manipulators::OptionsValidator < Manipulator
+
+  validate_options do |options, client, request|
+    errors = {}
+    next errors if options[:mandatory_string].is_a? String
+
+    errors[:mandatory_string] = 'Must be string.'
+    errors
+  end
+
+  def run
+    options[:mandatory_string] * 10
+  end
+
+end
+
+end
+end
+end

data/spec/support/fixtures/raptor/socket/ssl_server.crt

@@ -0,0 +1,18 @@
+-----BEGIN CERTIFICATE-----
+MIIC6TCCAlKgAwIBAgIEIRYEajANBgkqhkiG9w0BAQUFADBRMQswCQYDVQQGEwJV
+UzELMAkGA1UECAwCVFgxDzANBgNVBAcMBkF1c3RpbjEPMA0GA1UECgwGUmFwaWQ3
+MRMwEQYDVQQDDApyc3BlYy1ob3N0MB4XDTEzMDgxMDAyMjI1MVoXDTEzMDkwOTEy
+MjI1MVowUTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAlRYMQ8wDQYDVQQHDAZBdXN0
+aW4xDzANBgNVBAoMBlJhcGlkNzETMBEGA1UEAwwKcnNwZWMtaG9zdDCBnzANBgkq
+hkiG9w0BAQEFAAOBjQAwgYkCgYEAz5QxP0R5i0curO/f0Fgn8mZ/1ygJUUbrgsVp
+OOU1CarECbZmOU9iEhR/QB2IknOsm0QfVlkCH/gusOZWbQdIaqmrD5mnrgKLHS4N
+w/hvzg4tgTLtuJvlGq2zFXh9FKoTSV8IiXevc0i9DmbZ0Cx2uSjrx+DYdDTDdq9j
+1DVuKrECAwEAAaOBzTCByjAJBgNVHRMEAjAAMB0GA1UdDgQWBBQ1Um68pnvPrkGt
+lJsAT+drEdu7CzATBgNVHSUEDDAKBggrBgEFBQcDATALBgNVHQ8EBAMCBLAwfAYD
+VR0jBHUwc4AUNVJuvKZ7z65BrZSbAE/naxHbuwuhVaRTMFExCzAJBgNVBAYTAlVT
+MQswCQYDVQQIDAJUWDEPMA0GA1UEBwwGQXVzdGluMQ8wDQYDVQQKDAZSYXBpZDcx
+EzARBgNVBAMMCnJzcGVjLWhvc3SCBCEWBGowDQYJKoZIhvcNAQEFBQADgYEAw98n
+wL0Z/FIDflLJyVdFnohOqDadLTr3ms44u2ahSCf1dmXn0fd5784lz8tl44w/HeIO
+xCJvr33i+9+RS9bzkaogq73mw5spc/ZvBK1ivs6/rw+bH7MURr2htdO4gYsYLUVS
+baOu/+8LPjopJZEC/sj+b4ez8Fb9ex/7k1BZfnA=
+-----END CERTIFICATE-----

data/spec/support/fixtures/raptor/socket/ssl_server.key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXQIBAAKBgQDPlDE/RHmLRy6s79/QWCfyZn/XKAlRRuuCxWk45TUJqsQJtmY5
+T2ISFH9AHYiSc6ybRB9WWQIf+C6w5lZtB0hqqasPmaeuAosdLg3D+G/ODi2BMu24
+m+UarbMVeH0UqhNJXwiJd69zSL0OZtnQLHa5KOvH4Nh0NMN2r2PUNW4qsQIDAQAB
+AoGASP3eN1YXuz8DjbInrHZjTZx3VavxYtAiXnCWaHhIpyaSGqw10+8zGBJ3EI+S
+B5V/W3Wf41gXJDC8El5cg6gs8RoNz9koRrQ6+Rv5pivkuGsaHZWY2CnVzYfc7pCr
+wjqwkVgXgFT41LfoOLruppSxYuL8Bts0UT3Q1pSaH31lGsUCQQD7gkp4DAQ+ZS51
+NccmiVhTuzEYg6TEd29x1arLe9AXrqL3DtN6eDxkSmfc0ZUpL9xudD0nM/L1GEzW
+D8ygvnxzAkEA00kWGlpKPKMAaF0lXFOzCgjRKtEw7XrDENMdOvh1s1206vtn48OK
+/88q9twfjzPN6pc/dg4qd0+q9eGCTdE3SwJBANKzAR32uytmango+FDRaNykimnG
+ByfMAuHzpSTY8aiVVdLxabtEtRsztjUoovQhM2KZII4SGCy6EcyW6c+UJP8CQGfc
+jZj2uXeFSTYEU9FG88QDAY9itgKHTkx++ud6K6G4dq7sVu2HulR1qlEfdAQZGygu
+oWuPGyD7cLbd3AgUyHECQQC9wNYpbA4pSC3OBtzIOyIuCi+ROJN7nSx6kNuMm5LZ
+uX9znuOE6t6Yb0yw8M3Z9LUIKLJ1B9fhjiJb9fD9wCIC
+-----END RSA PRIVATE KEY-----

data/spec/support/lib/path_helpers.rb

@@ -0,0 +1,11 @@
+def manipulator_fixtures_path
+  "#{fixtures_path}/raptor/protocol/http/request/manipulators"
+end
+
+def fixtures_path
+  "#{spec_path}support/fixtures/"
+end
+
+def spec_path
+  File.expand_path( "#{File.dirname( __FILE__ )}/../.." ) + '/'
+end

data/spec/support/lib/webserver_option_parser.rb

@@ -0,0 +1,26 @@
+require 'optparse'
+
+class WebServerOptionParser
+  DEFAULT = {
+      address: '0.0.0.0',
+      port:    4567
+  }
+
+  def self.parse
+    options = {}
+
+    OptionParser.new do |opts|
+
+      opts.on( '-o', '--addr [host]', "set the host (default is #{options[:address]})" ) do |address|
+        options[:address] = address
+      end
+
+      opts.on( '-p', '--port [port]', Integer, "set the port (default is #{options[:port]})" ) do |port|
+        options[:port] = port
+      end
+
+    end.parse!
+
+    DEFAULT.merge( options )
+  end
+end

data/spec/support/lib/webservers.rb

@@ -0,0 +1,120 @@
+require 'singleton'
+require 'net/http'
+
+class WebServers
+  include Singleton
+
+  attr_reader :lib
+
+  def initialize
+    @lib     = File.expand_path( File.dirname(  __FILE__ ) + '/../webservers' )
+    @servers = {}
+
+    Dir.glob( File.join( @lib + '/**', '*.rb' ) ) do |path|
+      @servers[normalize_name( File.basename( path, '.rb' ) )] = {
+        port: available_port,
+        path: path
+      }
+    end
+  end
+
+  def start( name )
+    return if up?( name )
+
+    server_info = data_for( name )
+    server_info[:pid] = Process.spawn(
+      'ruby', server_info[:path], '-p', server_info[:port].to_s,
+      :out=>"/dev/null", :err=>"/dev/null"
+    )
+
+    sleep 0.2 while !up?( name )
+  end
+
+  def url_for( name )
+    "#{protocol_for( name )}://#{address_for( name )}:#{port_for( name )}"
+  end
+
+  def address_for( name )
+    '127.0.0.1'
+  end
+
+  def protocol_for( name )
+    'http'
+  end
+
+  def port_for( name )
+    data_for( name )[:port]
+  end
+
+  def target_for( name )
+    WebTarget.new( address_for( name ), port_for( name ) )
+  end
+
+  def data_for( name )
+    @servers[normalize_name( name )]
+  end
+
+  def up?( name )
+    begin
+      ::Net::HTTP.get_response( URI.parse( url_for( name ) ) )
+      true
+    rescue Errno::ECONNRESET
+      true
+    rescue => e
+      false
+    end
+  end
+
+  def kill( name )
+    server_info = data_for( name )
+    return if !server_info[:pid]
+
+    begin
+      10.times { Process.kill( 'KILL', server_info[:pid] ) }
+      return false
+    rescue Errno::ESRCH
+      server_info.delete( :pid )
+      return true
+    end
+  end
+
+  def killall
+    @servers.keys.each { |n| kill n }
+  end
+
+  def available_port
+    loop do
+      port = 5555 + rand( 9999 )
+      begin
+        socket = ::Socket.new( :INET, :STREAM, 0 )
+        socket.bind(::Socket.sockaddr_in(port, "127.0.0.1"))
+        socket.close
+        return port
+      rescue Errno::EADDRINUSE => e
+      end
+    end
+  end
+
+  def normalize_name( name )
+    name.to_s.to_sym
+  end
+
+  def self.method_missing( sym, *args, &block )
+    if instance.respond_to?( sym )
+      instance.send( sym, *args, &block )
+    elsif
+    super( sym, *args, &block )
+    end
+  end
+
+  def self.respond_to?( m )
+    super( m ) || instance.respond_to?( m )
+  end
+
+  private
+
+  def set_data_for( name, data )
+    @servers[normalize_name( name )] = data
+  end
+
+end

data/spec/support/shared/contexts/with_ssl_server.rb

@@ -0,0 +1,70 @@
+
+shared_context 'with ssl server' do
+  include_context 'with tcp server'
+
+  let(:server_cert) { File.read(File.join(fixtures_path, 'raptor', 'socket', 'ssl_server.crt')) }
+  let(:server_key)  { File.read(File.join(fixtures_path, 'raptor', 'socket', 'ssl_server.key')) }
+  let(:server_context) do
+    OpenSSL::SSL::SSLContext.new.tap do |context|
+      context.cert = OpenSSL::X509::Certificate.new(server_cert)
+      context.key  = OpenSSL::PKey::RSA.new(server_key)
+    end
+  end
+
+  let(:ssl_server_sock) do
+    @ssl_server_sock = OpenSSL::SSL::SSLSocket.new(server_sock, server_context)
+  end
+
+  let(:io) do
+    #$stderr.puts("with_ssl_server :io, starting tcp server thread")
+    server_thread
+
+    #$stderr.puts(":io client_sock connecting")
+    client_sock
+
+    #$stderr.puts("starting ssl accept thread")
+    @ssl_server_thread = Thread.new { ssl_server_sock.accept }
+    #$stderr.puts(" ssl accept thread, #{@ssl_server_thread.inspect}")
+
+    # pass to make sure the server thread gets a slice before we return
+    Thread.pass
+
+    # this should now be a connected ::TCPSocket
+    client_sock
+  end
+
+  let(:server_thread) do
+    @server_thread = Thread.new do
+      begin
+        #$stderr.puts("ssl_server_sock.accept_nonblock")
+        peer = ssl_server_sock.accept_nonblock
+      rescue IO::WaitReadable, IO::WaitWritable
+        #$stderr.puts(":server_sock waiting for a client")
+        select([server_sock], [server_sock])
+        #$stderr.puts(":server_sock retrying")
+        retry
+      end
+      #$stderr.puts(":server_sock accepted peer #{peer.inspect}")
+      peer
+    end
+    @server_thread
+
+  end
+
+  subject do
+    #$stderr.puts("with_ssl_server subject (#{described_class})")
+    s = described_class.new(io, opts)
+
+    #$stderr.puts("Subject:  #{s.inspect}")
+    peer = @ssl_server_thread.value
+    #$stderr.puts("ssl_server_thread.value #{peer}")
+    s
+  end
+
+  after(:each) do
+    @ssl_server_sock.close if @ssl_server_sock
+    @ssl_server_thread.kill if @ssl_server_thread
+  end
+
+end
+

data/spec/support/shared/contexts/with_tcp_server.rb

@@ -0,0 +1,58 @@
+
+shared_context 'with tcp server' do
+  after(:each) do
+    if @server_sock
+      @server_sock.close rescue nil
+    end
+    if @server_thread
+      @server_thread.kill
+    end
+  end
+
+  let(:server_sock) do
+    @server_sock = TCPServer.new(example_addr, example_ssl_port)
+  end
+
+  let(:server_thread) do
+    @server_thread = Thread.new do
+      begin
+        #$stderr.puts("server_sock.accept_nonblock")
+        peer = server_sock.accept_nonblock
+      rescue IO::WaitReadable, IO::WaitWritable
+        #$stderr.puts(":server_sock waiting for a client")
+        select([server_sock], [server_sock])
+        #$stderr.puts(":server_sock retrying")
+        retry
+      end
+      #$stderr.puts(":server_sock accepted peer #{peer.inspect}")
+      peer
+    end
+    @server_thread
+  end
+
+  let(:client_sock) do
+    #$stderr.puts "client_sock connecting"
+    retries = 3
+    begin
+      #$stderr.puts "client_sock trying to connect (#{retries} left)"
+      connected_socket = TCPSocket.new(example_addr, example_ssl_port)
+    rescue Errno::ECONNREFUSED
+      # Give the server thread another chance to get it up
+      Thread.pass
+      sleep 0.1
+      retry if (retries -= 1) > 0
+      raise $!
+    end
+    #$stderr.puts "client_sock connected #{connected_socket}"
+    connected_socket
+  end
+
+  let(:io) do
+    server_thread
+    client_sock
+    server_thread.value.write(data)
+    client_sock
+  end
+
+end
+

data/spec/support/shared/examples/raptor/comm_examples.rb

@@ -0,0 +1,26 @@
+
+# Requires let(:tcp_port) and let(:udp_port) to be set to something
+shared_examples "a comm" do
+  it { should respond_to(:create_tcp) }
+  it { should respond_to(:create_tcp_server) }
+  it { should respond_to(:resolve) }
+  it { should respond_to(:reverse_resolve) }
+  #pending { should respond_to(:create_udp) }
+  #pending { should respond_to(:create_udp_server) }
+
+  let(:peer_host) { "127.0.0.1" }
+
+  describe "#create_tcp" do
+    it "should create a TCP socket" do
+      sock = comm.create_tcp(peer_host: peer_host, peer_port: tcp_port)
+      sock.should be_a(RaptorIO::Socket::TCP)
+      raddr = sock.remote_address
+      raddr.should be_a(::Addrinfo)
+      raddr.ip_address.should == peer_host
+      raddr.ip_port.should == tcp_port
+    end
+  end
+
+end
+
+

data/spec/support/shared/examples/raptor/protocols/http/message.rb

@@ -0,0 +1,106 @@
+shared_examples_for 'RaptorIO::Protocol::HTTP::Message' do
+
+  let(:url) { 'http://test.com' }
+
+  describe '#initialize' do
+    it 'sets the instance attributes by the options' do
+      options = {
+          url:          url,
+          version: '1.0',
+          headers:      {
+              'X-Stuff' => 'Blah'
+          }
+      }
+      r = described_class.new( options )
+      r.version.should == options[:version]
+      r.headers.should == options[:headers]
+    end
+  end
+
+  describe '#version' do
+    it 'defaults to 1.1' do
+      described_class.new( url: url ).version.should == '1.1'
+    end
+  end
+
+  describe '#keep_alive?' do
+    context 'when the protocol version is 1.1 or higher' do
+      context 'and connection-token is set to \'close\'' do
+        it 'returns false' do
+          described_class.new( url: url,
+                               version: '1.1',
+                               headers: { 'connection' => 'close' }
+          ).keep_alive?.should be_false
+        end
+      end
+
+      it 'returns true' do
+        described_class.new( url: url, version: '1.1' ).keep_alive?.should be_true
+        described_class.new( url: url, version: '1.2' ).keep_alive?.should be_true
+      end
+    end
+
+    context 'when the protocol version is lower than 1.1' do
+      context 'and connection-token is set to \'keep-alive\'' do
+        it 'returns false' do
+          described_class.new( url: url,
+                               version: '1.0',
+                               headers: { 'connection' => 'keep-alive' }
+          ).keep_alive?.should be_true
+        end
+      end
+
+      it 'returns false' do
+        described_class.new( url: url, version: '1.0' ).keep_alive?.should be_false
+      end
+    end
+  end
+
+  describe '#http_1_1?' do
+    context 'when the protocol version is 1.1' do
+      it 'returns true' do
+        described_class.new( url: url, version: '1.1' ).http_1_1?.should be_true
+      end
+    end
+
+    context 'when the protocol version is not 1.1' do
+      it 'returns false' do
+        described_class.new( url: url, version: '1.2' ).http_1_1?.should be_false
+      end
+    end
+  end
+
+  describe '#http_1_0?' do
+    context 'when the protocol version is 1.0' do
+      it 'returns true' do
+        described_class.new( url: url, version: '1.0' ).http_1_0?.should be_true
+      end
+    end
+
+    context 'when the protocol version is not 1.0' do
+      it 'returns false' do
+        described_class.new( url: url, version: '1.2' ).http_1_0?.should be_false
+      end
+    end
+  end
+
+  describe '#headers' do
+    context 'when not configured' do
+      it 'defaults to an empty Hash' do
+        described_class.new( url: url ).headers.should == {}
+      end
+    end
+
+    it 'returns the configured value' do
+      headers = { 'Content-Type' => 'text/plain' }
+      described_class.new( url: url, headers: headers ).headers.should == headers
+    end
+  end
+
+  describe '#body' do
+    it 'returns the configured body' do
+      body = 'Stuff...'
+      described_class.new( url: url, body: body ).body.should == body
+    end
+  end
+end