lbspec 0.1.4 → 0.2.0

data/README.md

@@ -40,10 +40,10 @@ You can use following chains with `#transfer`.
   - Tests with an http request for the virtual host.
 - https
   - Tests with an https request for the virtual host.
-- path
-  - Specifies a path for http or https requests.
 - from
   - Specifies which host sends to the virtual host.
+- path
+  - Specifies a path for http or https requests.
 - options
   - Options which can be used in http or https request commands.
   - You can use `options` if you configure request commands or capture commands.
@@ -51,7 +51,8 @@ You can use following chains with `#transfer`.
 ## Requires
 * Users need to be able to login with ssh to the target nodes.
 * Users need to be able to `sudo` on the target nodes.
-* netcat and ngrep are needed to be installed.
+* Netcat and curl are needed on requesting host.
+* Grep and ngrep are needed on capturing host.
 
 ## Limitations
 * Lbspec uses only ssh configuration in ~/.ssh/config
@@ -87,23 +88,23 @@ describe 'vhost_c:80' do
   it { should transfer(['node_b','node_c']).port(53).udp }
 end
 
-describe 'vhost_c:80' do
-  it { should transfer('node_c').http.path('/test/') }
+describe 'vhost_c:80/test/' do
+  it { should transfer('node_c').http }
 end
 
 describe 'vhost_c:443' do
-  it { should transfer(['node_b','node_c']).port(80).https.path('/test/') }
+  it { should transfer(['node_b','node_c']).port(80).https.path('/test/' }
 end
 
-describe 'vhost_c:443' do
+describe 'vhost_c:443/test/' do
   it do
-    should transfer(['node_b','node_c']).port(80).https.path('/test/')
+    should transfer(['node_b','node_c']).port(80).https
       .options(ignore_valid_ssl: true)
   end
 end
 
-describe 'vhost_c:80' do
-  it { should transfer('node_c').http.path('/test/').from('node_a') }
+describe 'vhost_c:80/test/' do
+  it { should transfer('node_c').http.from('node_a') }
 end
 
 ```
@@ -111,47 +112,16 @@ end
 ### #transfer
 
  1. ssh to nodes
- 2. cupture probe
- 3. access with probe
+   - ssh to the nodes which receive requests via the target virtual host
+ 2. capture probe
+   - capture packets on the nodes 
+ 3. access to the nodes with probe
+   - netcat or curl to the virtual host with prove
  4. judge
+   - judge if expected request are captured on the capturing nodes
 
 ![#tranfer works][1]
 
-
-## Configuration
-### #transfer
-You can change how to capture probes and access to `vhost` with probes. You can replace default procedures to your procedures in spec_helpers or .spec files as follows. If you use `Lbspec::Util.exec_command()`, you can specify the node which generate request.
-```ruby
-RSpec.configuration.lbspec_capture_command =
-  lambda do |port, prove|
-  port_str = port > 0 ? "port #{port}" : ''
-  "sudo ngrep #{prove} #{port_str} | grep -v \"match:\""
-end
-
-RSpec.configuration.lbspec_https_request_command =
-  lambda do |addr, port, path, prove|
-  uri = 'https://' + "#{addr}:#{port}#{path}?#{prove}"
-  Lbspec::Util.exec_command("curl -o /dev/null -sk #{uri}", @request_node)
-end
-```
-You can also use the procedures with `options` with a chain `options`.
-```ruby
-RSpec.configuration.lbspec_https_request_command =
-  lambda do |addr, port, path, prove|
-  opt =  @options[:timeout] ? " -m #{@options[:timeout]}" : ''
-  opt << (@options[:ignore_valid_ssl] ? ' -k' : '')
-  Lbspec::Util.exec_command("curl -o /dev/null -s #{opt} #{uri}", @request_node)
-end
-```
-
-You can replace following items.
-
- - `lbspec_capture_command` with `|port, prove|`
- - `lbspec_udp_request_command` with `|addr, port, prove|`
- - `lbspec_tcp_request_command` with `|addr, port, prove|`
- - `lbspec_http_request_command` with `|addr, port, path, prove|`
- - `lbspec_https_request_command` with `|addr, port, path, prove|`
-
 ## Contributing
 
 1. Fork it ( http://github.com/otahi/lbspec/fork )

data/lib/lbspec/capture.rb

@@ -0,0 +1,100 @@
+# -*- encoding: utf-8 -*-
+require 'lbspec'
+
+# Lbspec is an RSpec plugin for easy Loadbalancer testing.
+module Lbspec
+  # Lbspec::Capture reqresent of capture
+  class Capture
+    Thread.abort_on_exception = true
+
+    attr_reader :result, :output
+
+    def initialize(nodes, port, prove, include_str = nil)
+      @nodes = nodes.respond_to?(:each) ? nodes : [nodes]
+      @port = port ? port : 0
+      @prove = prove
+      @include_str = include_str
+      @threads = []
+      @ssh = []
+      @nodes_connected = []
+      @result = false
+      @output = []
+    end
+
+    def open
+      @nodes.each do |node|
+        open_node(node)
+      end
+      wait_connected
+    end
+
+    def close
+      @threads.each do |t|
+        t.kill
+      end
+      @ssh.each do |ssh|
+        ssh.close unless ssh.closed?
+      end
+    end
+
+    private
+
+    def open_node(node)
+      @threads << Thread.new do
+        Net::SSH.start(node, nil, config: true) do |ssh|
+          @ssh << ssh
+          ssh.open_channel do |channel|
+            output = run_check channel
+            @output.push(node: node, output: output)
+          end
+        end
+      end
+    end
+
+    def wait_connected
+      sleep 0.5 until @nodes_connected.length == @nodes.length
+    end
+
+    def run_check(channel)
+      output = ''
+      channel.request_pty do |chan, success|
+        fail 'Could not obtain pty' unless success
+        @nodes_connected.push(true)
+        output = exec_capture(chan)
+      end
+      output
+    end
+
+    def exec_capture(channel)
+      output = exec_capture_command(channel, capture_command)
+      capture_command + "\n" +  output.to_s
+    end
+
+    def exec_capture_command(channel, command)
+      whole_data = ''
+      channel.exec command do |ch, stream, data|
+        ch.on_data do |c, d|
+          whole_data << d
+          patterns = [@prove]
+          patterns << @include_str if @include_str
+          @result = match_all?(whole_data, patterns)
+        end
+      end
+      whole_data
+    end
+
+    def match_all?(string, patterns)
+      num_patterns, num_match = 0, 0
+      patterns.each do |pat|
+        num_patterns += 1
+        num_match += 1 if /#{pat}/ =~ string
+      end
+      num_match == num_patterns
+    end
+
+    def capture_command
+      port_str = @port > 0 ? "port #{@port}" : ''
+      "sudo ngrep -W byline #{@prove} #{port_str} | grep -v \"match:\""
+    end
+  end
+end

data/lib/lbspec/request.rb

@@ -0,0 +1,92 @@
+# -*- encoding: utf-8 -*-
+require 'lbspec'
+
+# Lbspec is an RSpec plugin for easy Loadbalancer testing.
+module Lbspec
+  # Lbspec::Request reqresent of request
+  class Request
+    def initialize(target, from = nil, options = {})
+      @addr, @port, @path =
+        Lbspec::Util.split_addr_port_path(target)
+      @from = from
+      @protocol = options[:protocol] ? options[:protocol] : nil
+      @application = options[:application] ? options[:application] : nil
+      @path = options[:path] if options[:path]
+      @options = options[:options] ? options[:options] : {}
+    end
+
+    def send(prove)
+      if @application
+        send_application(prove)
+      else
+        send_transport(prove)
+      end
+    end
+
+    private
+
+    def send_application(prove)
+      case @application
+      when :http
+        send_http(prove)
+      when :https
+        send_https(prove)
+      end
+    end
+
+    def send_http(prove)
+      @port = 80 unless @port
+      uri = 'http://' + "#{@addr}:#{@port}#{@path}?#{prove}"
+      command = build_curl_command(uri, @options)
+      Lbspec::Util.exec_command(command, @from)
+    end
+
+    def send_https(prove)
+      @port = 443 unless @port == 0
+      uri = 'https://' + "#{@addr}:#{@port}#{@path}?#{prove}"
+      command = build_curl_command(uri, @options)
+      Lbspec::Util.exec_command(command, @from)
+    end
+
+    def build_curl_command(uri, options = {})
+      env, opt = '', ''
+      opt << (options[:timeout] ? " -m #{options[:timeout]}" : '')
+      opt << (options[:ignore_valid_ssl] ? ' -k' : '')
+      opt << (options[:proxy] ? %Q( -x "#{options[:proxy]}") : '')
+      if options[:noproxy]
+        env << %Q( no_proxy="#{options[:noproxy]}")
+        env << %Q( NO_PROXY="#{options[:noproxy]}")
+      end
+      opt << header_option(options[:header])
+      %Q(#{env} curl -o /dev/null -s #{opt} '#{uri}')
+    end
+
+    def header_option(header)
+      opt = ''
+      header = [header] unless header.respond_to? :each
+      header.each { |h| opt << %Q( -H '#{h}') }
+      opt
+    end
+
+    def send_transport(prove)
+      case @protocol
+      when :udp
+        send_udp(prove)
+      else
+        send_tcp(prove)
+      end
+    end
+
+    def send_udp(prove)
+      @port = 53 unless @port
+      Lbspec::Util
+        .exec_command("echo #{prove} | nc -u #{@addr} #{@port}", @from)
+    end
+
+    def send_tcp(prove)
+      @port = 80 unless @port
+      Lbspec::Util
+        .exec_command("echo #{prove} | nc #{@addr} #{@port}", @from)
+    end
+  end
+end

data/lib/lbspec/transfer.rb

@@ -4,69 +4,33 @@ require 'rspec/core'
 require 'rspec/expectations'
 require 'lbspec'
 
-RSpec.configure do |c|
-  c.add_setting :lbspec_capture_command      , default: nil
-  c.add_setting :lbspec_udp_request_command  , default: nil
-  c.add_setting :lbspec_tcp_request_command  , default: nil
-  c.add_setting :lbspec_http_request_command , default: nil
-  c.add_setting :lbspec_https_request_command, default: nil
-end
-
 RSpec::Matchers.define :transfer do |nodes|
-  @ssh = []
-  @threads = []
-  @nodes_connected = []
-  @chain_str = ''
-  @protocol = nil
-  @application = nil
-  @http_path = '/'
-  @vhost_port = 80
-  @node_port = 0
-  @request_node = nil
+
   @include_str = nil
-  @output_request = ''
-  @output_capture = []
+  @port = 0
+  @path = nil
+  @chain_str = ''
   @options = {}
-
-  @capture_command = lambda do |port, prove|
-    port_str = port > 0 ? "port #{port}" : ''
-    "sudo ngrep -W byline #{prove} #{port_str} | grep -v \"match:\""
-  end
-
-  @udp_request_command = lambda do |addr, port, prove|
-    Lbspec::Util
-      .exec_command("echo #{prove} | nc -u #{addr} #{port}", @request_node)
-  end
-  @tcp_request_command = lambda do |addr, port, prove|
-    Lbspec::Util
-      .exec_command("echo #{prove} | nc #{addr} #{port}", @request_node)
-  end
-  @http_request_command = lambda do |addr, port, path, prove|
-    uri = 'http://' + "#{addr}:#{port}#{path}?#{prove}"
-    command = Lbspec::Util.build_curl_command(uri, @options)
-    Lbspec::Util.exec_command(command, @request_node)
-  end
-  @https_request_command = lambda do |addr, port, path, prove|
-    uri = 'https://' + "#{addr}:#{port}#{path}?#{prove}"
-    command = Lbspec::Util.build_curl_command(uri, @options)
-    Lbspec::Util.exec_command(command, @request_node)
-  end
-
-  @result = false
-  Thread.abort_on_exception = true
+  @output_request = ''
+  @output_capture = ''
 
   match do |vhost|
-    @prove = Lbspec::Util.create_prove
-    override_commands
-    capture_on_nodes nodes
-    wait_nodes_connected nodes
-    send_request vhost
-    disconnect_nodes
-    @result
+    prove = Lbspec::Util.create_prove
+    capture =
+      Lbspec::Capture.new(nodes, @port, prove, @include_str)
+    capture.open
+    request =
+      Lbspec::Request.new(vhost, @from,
+                          protocol: @protocol, application: @application,
+                          path: @path, options: @options)
+    @output_request = request.send(prove)
+    @output_capture = capture.output
+    capture.close
+    capture.result
   end
 
   chain :port do |port|
-    @node_port = port
+    @port = port
     @chain_str << " port #{port}"
   end
 
@@ -92,13 +56,8 @@ RSpec::Matchers.define :transfer do |nodes|
     @chain_str << ' https'
   end
 
-  chain :path do |path|
-    @http_path = path
-    @chain_str << " via #{path}"
-  end
-
   chain :from do |from|
-    @request_node = from
+    @from = from
     @chain_str << " from #{from}"
   end
 
@@ -107,128 +66,13 @@ RSpec::Matchers.define :transfer do |nodes|
     @chain_str << " including #{str}"
   end
 
-  chain :options do |options|
-    @options = options
-  end
-
-  def override_commands
-    capture = RSpec.configuration.lbspec_capture_command
-    udp_request = RSpec.configuration.lbspec_udp_request_command
-    tcp_request = RSpec.configuration.lbspec_tcp_request_command
-    http_request = RSpec.configuration.lbspec_http_request_command
-    https_request = RSpec.configuration.lbspec_https_request_command
-    @capture_command = capture if capture
-    @udp_request_command = udp_request if udp_request
-    @tcp_request_command = tcp_request if tcp_request
-    @http_request_command = http_request if http_request
-    @https_request_command = https_request if https_request
-  end
-
-  def wait_nodes_connected(nodes)
-    nodes_length = (nodes.respond_to? :each) ? nodes.length : 1
-    sleep 0.5 until @nodes_connected.length == nodes_length
-  end
-
-  def capture_on_nodes(nodes)
-    if nodes.respond_to? :each
-      nodes.each { |node| capture_on_node(node) }
-    else
-      capture_on_node(nodes)
-    end
-  end
-
-  def capture_on_node(node)
-    @threads << Thread.new do
-      Net::SSH.start(node, nil, config: true) do |ssh|
-        @ssh << ssh
-        ssh.open_channel do |channel|
-          output = run_check channel
-          @output_capture.push(node: node, output: output)
-        end
-      end
-    end
-  end
-
-  def run_check(channel)
-    output = ''
-    channel.request_pty do |chan, success|
-      fail 'Could not obtain pty' unless success
-      @nodes_connected.push(true)
-      output = exec_capture(chan)
-    end
-    output
-  end
-
-  def exec_capture(channel)
-    command = capture_command(@node_port, @prove)
-    output = exec_capture_command(channel, command)
-    command + "\n" +  output
-  end
-
-  def exec_capture_command(channel, command)
-    channel.exec command do |ch, stream, data|
-      whole_data = ''
-      ch.on_data do |c, d|
-        whole_data << d
-        patterns = [@prove]
-        patterns << @include_str if @include_str
-        @result = match_all?(whole_data, patterns)
-      end
-      whole_data
-    end
-  end
-
-  def match_all?(string, patterns)
-    num_patterns, num_match = 0, 0
-    patterns.each do |pat|
-      num_patterns += 1
-      num_match += 1 if /#{pat}/ =~ string
-    end
-    num_match == num_patterns
-  end
-
-  def capture_command(port, prove)
-    @capture_command[port, prove]
-  end
-
-  def disconnect_nodes
-    @threads.each do |t|
-      t.kill
-    end
-    @ssh.each do |ssh|
-      ssh.close unless ssh.closed?
-    end
-  end
-
-  def send_request(vhost)
-    addr_port = Lbspec::Util.split_addr_port(vhost.to_s)
-    vhost_addr, vhost_port = addr_port[:addr], addr_port[:port]
-    @vhost_port = vhost_port if vhost_port > 0
-    if @application
-      @output_request =
-        send_request_application(vhost_addr, @vhost_port, @prove)
-    else
-      @output_request =
-        send_request_transport(vhost_addr, @vhost_port, @prove)
-    end
-  end
-
-  def send_request_application(addr, port, prove)
-    case @application
-    when :http
-      @http_request_command[addr, port, @http_path, prove]
-    when :https
-      @https_request_command[addr, port, @http_path, prove]
-    end
+  chain :path do |path|
+    @path = path
+    @chain_str << " via #{path}"
   end
 
-  def send_request_transport(addr, port, prove)
-    case @protocol
-    when :udp
-      @udp_request_command[addr, port, prove]
-    else
-      @tcp_request_command[addr, port, prove]
-    end
+  chain :options do |options|
+    @options = options
   end
 
   description do

data/lib/lbspec/util.rb

@@ -7,31 +7,15 @@ module Lbspec
       t = Time.now
       t.to_i.to_s + t.nsec.to_s
     end
-    def self.split_addr_port(addr_port_str)
-      port = 0
-      splits = addr_port_str.split(':')
-      addr = splits.first
-      port = splits.last.to_i if /\d+/ =~ splits.last
-      { addr: addr, port: port }
-    end
-    def self.build_curl_command(uri, options)
-      env, opt = '', ''
-      opt << (options[:timeout] ? " -m #{options[:timeout]}" : '')
-      opt << (options[:ignore_valid_ssl] ? ' -k' : '')
-      opt << (options[:proxy] ? %Q( -x "#{options[:proxy]}") : '')
-      if options[:noproxy]
-        env << %Q( no_proxy="#{options[:noproxy]}")
-        env << %Q( NO_PROXY="#{options[:noproxy]}")
-      end
-      opt << header_option(options[:header])
-      %Q(#{env} curl -o /dev/null -s #{opt} '#{uri}')
-    end
-    def self.header_option(header)
-      opt = ''
-      header = [header] unless header.respond_to? :each
-      header.each { |h| opt << %Q( -H '#{h}') }
-      opt
+
+    def self.split_addr_port_path(addr_port_path)
+      splits = addr_port_path.split(/[:\/]/)
+      addr = splits[0]
+      port = (/\d+/ =~ splits[1]) ? splits[1].to_i : nil
+      path = (/\d+/ =~ splits[1]) ? '/' + splits[2].to_s : '/' + splits[1].to_s
+      [addr, port, path]
     end
+
     def self.exec_command(command, node = nil)
       output = command
       if node

data/lib/lbspec/version.rb

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
 # Lbspec is an RSpec plugin for easy Loadbalancer testing.
 module Lbspec
-  VERSION = '0.1.4'
+  VERSION = '0.2.0'
 end

data/lib/lbspec.rb

@@ -1,6 +1,8 @@
 # -*- encoding: utf-8 -*-
 require 'lbspec/version'
 require 'lbspec/transfer'
+require 'lbspec/request'
+require 'lbspec/capture'
 require 'lbspec/util'
 
 # Lbspec is an RSpec plugin for easy Loadbalancer testing.

data/spec/lbspec_transfer_spec.rb

@@ -21,6 +21,7 @@ describe Lbspec do
       ssh_connected.stub(:exec!).and_return(true)
       Net::SSH.stub(:start).and_yield(ssh_connected).and_return(ssh_connected)
       Kernel.stub(:system).and_return true
+      Kernel.stub(:`).and_return(key + include_str) # `
     end
 
     it 'should test transfer a node' do
@@ -51,17 +52,17 @@ describe Lbspec do
       'vhost_a:443'.should transfer('node_a').port(80).https
     end
     it 'should test transfer vhost:443 and a node with https /test' do
-      'vhost_a:443'.should transfer('node_a').https.path('/test')
+      'vhost_a:443/test'.should transfer('node_a').https
     end
     it 'should test transfer vhost:443 with options for requests' do
       'vhost_a:443'.should transfer('node_a').https.path('/test')
         .options(ignore_valid_ssl: true)
-      'vhost_a:443'.should transfer('node_a').https.path('/test')
+      'vhost_a:443/test'.should transfer('node_a').https
         .options(ignore_valid_ssl: false, timeout: 5)
     end
     it 'should test transfer vhost:443 requests from specified host' do
-      'vhost_a:443'.should transfer('node_a')
-        .https.path('/test').from('node_a')
+      'vhost_a:443/test'.should transfer('node_a')
+        .https.from('node_a')
     end
     it 'should test transfer vhost:80 and a node with http includes ' do
       'vhost_a:80'.should transfer('node_a').http

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lbspec
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-29 00:00:00.000000000 Z
+date: 2014-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -160,6 +160,8 @@ files:
 - images/transfer_overview.svg
 - lbspec.gemspec
 - lib/lbspec.rb
+- lib/lbspec/capture.rb
+- lib/lbspec/request.rb
 - lib/lbspec/transfer.rb
 - lib/lbspec/util.rb
 - lib/lbspec/version.rb
@@ -184,7 +186,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2692456461482340401
+      hash: -1301553932859158891
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -193,7 +195,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2692456461482340401
+      hash: -1301553932859158891
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.21