antismoker 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in antismoker.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Yamashita Yuu
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+# antismoker
+
+Yet another HTTP smoke testing framework.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'antismoker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install antismoker
+
+## Usage
+
+The smoke tests are implemented as Rake task.
+You can use `antismoker` rake task with adding following lines in your `Rakefile` or so.
+
+    ## Rakefile
+    load "tasks/antismoker.rake"
+
+You can configure `antismoker` from `config/antismoker.yml`.
+
+    ## config/antismoker.yml
+    # GET http://127.0.0.1/foo
+    development:
+      127.0.0.1:
+        http:
+          :port: 80
+          :path: /foo
+    production:
+      127.0.0.1:
+        http:
+          :port: 80
+          :path: /foo
+
+And then run `rake antismoker`.
+
+    % rake antismoker
+    smoke testing: http://127.0.0.1:9001/server-status:  [ OK ]
+
+
+### Capistrano usage
+
+Also you can use `antismoker` from Capistrano.
+To use it, add following in your `config/deploy.rb` or so.
+
+    # config/deploy.rb
+    require "antismoker/capistrano"
+    set(:antismoker_use_rollback, false) # set true to enable rollback on failure
+
+After all, the `antismoker` task will be run after `deploy` and `deploy:cold`.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Author
+
+- YAMASHITA Yuu (https://github.com/yyuu)
+- Geisha Tokyo Entertainment Inc. (http://www.geishatokyo.com/)
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/antismoker.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/antismoker/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Yamashita Yuu"]
+  gem.email         = ["yamashita@geishatokyo.com"]
+  gem.description   = %q{Yet another HTTP smoke testing framework.}
+  gem.summary       = %q{Yet another HTTP smoke testing framework.}
+  gem.homepage      = "https://github.com/yyuu/antismoker"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "antismoker"
+  gem.require_paths = ["lib"]
+  gem.version       = AntiSmoker::VERSION
+
+  gem.add_dependency("rake")
+end

data/lib/antismoker/capistrano.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require "antismoker/deployment"
+
+Capistrano::Configuration.instance(:must_exist).load do
+  after "deploy", "antismoker:invoke"
+  after "deploy:cold", "antismoker:invoke"
+  AntiSmoker::Deployment.define_task(self, :task, :except => { :no_release => true })
+end
+
+# vim:set ft=ruby sw=2 ts=2 :

data/lib/antismoker/deployment.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+module AntiSmoker
+  class Deployment
+    def self.define_task(context, task_method = :task, opts = {})
+      if defined?(Capistrano) && context.is_a?(Capistrano::Configuration)
+        context_name = "capistrano"
+        role_default = "{:except => {:no_release => true}}"
+        error_type = ::Capistrano::CommandError
+      else
+        context_name = "vlad"
+        role_default = "[:app]"
+        error_type = ::Rake::CommandFailedError
+      end
+
+      roles = context.fetch(:antismoker_roles, false)
+      opts[:roles] = roles if roles
+
+      context.send :namespace, :antismoker do
+        send :desc, "Run smoke test."
+        send task_method, :invoke, opts do
+          rake_cmd = context.fetch(:rake, "rake")
+          antismoker_task = context.fetch(:antismoker_task, "antismoker:invoke")
+          rails_env = context.fetch(:rails_env, "production")
+          app_path = context.fetch(:latest_release)
+          if app_path.to_s.empty?
+            raise error_type.new("Cannot detect current release path - make sure you have deployed at least once.")
+          end
+          args = []
+          args += context.fetch(:antismoker_flags, [])
+          args << "RAILS_ENV=#{rails_env}"
+
+          begin
+            run "cd #{app_path} && #{rake_cmd} #{args.join(' ')} #{antismoker_task}"
+            antismoker_success
+          rescue => error
+            logger.info("[ERROR] #{error}")
+            antismoker_failure
+          ensure
+            finalize_antismoker
+          end
+        end
+
+        send task_method, :antismoker_success, opts do
+          logger.info("It works!")
+        end
+
+        send task_method, :antismoker_failure, opts do
+          if context.fetch(:antismoker_use_rollback, false)
+            logger.info("Rolling back application.")
+            rollback_task = context.fetch(:antismoker_rollback_task, "deploy:rollback")
+            find_and_execute_task(rollback_task)
+          end
+        end
+
+        send task_method, :finalize_antismoker, opts do
+          # nop
+        end
+      end
+    end
+  end
+end
+
+# vim:set ft=ruby sw=2 ts=2 :

data/lib/antismoker/loader.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require "socket"
+require "yaml"
+
+module AntiSmoker
+  DEFAULT_PROTOCOL_NAME = "__default__"
+  DEFAULT_PROTOCOL_OPTIONS = {
+    :count => 3, # test retry count
+    :delay => 0.0, # delay for first test in seconds.
+    :period => 3.0, # retry interval between each tests.
+    :timeout => 5.0, # test timeout
+  }
+
+  def load(file, options={})
+    env = options.fetch(:env, "development")
+    defs = YAML.load(File.read(file))
+    abort("No such environment was defined in #{file}: #{env}") unless defs.has_key?(env)
+
+    smoketests = []
+    defs[env].each do |host, smoke_spec|
+      default_options = smoke_spec.delete(DEFAULT_PROTOCOL_NAME)
+      DEFAULT_PROTOCOL_OPTIONS.update(default_options) if default_options
+
+      smoke_spec.each do |protocol, options|
+        begin
+          require "antismoker/tests/#{protocol}"
+        rescue LoadError => error
+          abort("Could not load smoke test for #{protocol}: #{error}")
+        end
+
+        begin
+          name = protocol.scan(/\w+/).map { |w| w.capitalize }.join
+          klass = AntiSmoker.const_get("#{name}Test")
+        rescue NameError => error
+          abort("[BUG] Broken smoke test for #{protocol}: #{error}")
+        end
+
+        if options.is_a?(Hash)
+          options = DEFAULT_PROTOCOL_OPTIONS.merge(options)
+        else
+          options = DEFAULT_PROTOCOL_OPTIONS.merge(:port => options)
+        end
+        begin
+          options[:port] = Socket.getservbyname(protocol) unless options.has_key?(:port)
+        rescue SocketError => error
+          abort("Could not resolve well-known port for #{protocol}: #{error}")
+        end
+        ports = [ options.delete(:port) ].flatten
+        smoketests += ports.map { |port| klass.new(host, port, options) }
+      end
+    end
+
+    smoketests
+  end
+  module_function :load
+end
+
+# vim:set ft=ruby sw=2 ts=2 :

data/lib/antismoker/runner.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require "thread"
+
+module AntiSmoker
+  def run(smoketests=[], options={})
+    results = smoketests.map { |smoketest|
+      run_single(smoketest, options)
+    }
+  rescue Interrupt
+    abort("Interrupted")
+  end
+  module_function :run
+
+  def run_single(smoketest, options={})
+    begin
+      smoketest.run(options)
+    rescue => error
+      false
+    end
+  end
+  module_function :run_single
+end
+
+# vim:set ft=ruby sw=2 ts=2 :

data/lib/antismoker/tests/http.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+require "antismoker/tests"
+require "net/http"
+require "uri"
+
+module AntiSmoker
+  class HttpTest < AbstractSmokeTest
+    def initialize(host, port, options={})
+      super
+      @data = options.fetch(:data, {})
+      @method = options.fetch(:method, "GET")
+      @path = options.fetch(:path, "/")
+      @ok = options.fetch(:ok, 200)
+    end
+    attr_reader :data
+    attr_reader :method
+    attr_reader :path
+
+    def run_once(options={})
+      response = fetch(uri, :method => method)
+      logger.debug("HTTP response: #{self} => #{response.code} (#{response.body.length} bytes)")
+      response_ok(response)
+    end
+
+    def fetch(uri, options={})
+      limit = options.fetch(:limit, 10)
+      method = options.fetch(:method, "GET")
+      raise(ArgumentError.new("HTTP redirect too deep")) if limit <= 0
+      case method
+      when /^post$/i
+        response = Net::HTTP.post_form(uri, data)
+      else
+        response = Net::HTTP.get_response(uri)
+      end
+      if Net::HTTPRedirection === response
+        location = URI.parse(response["location"])
+        new_uri = (location.absolute?) ? location : uri.merge(location)
+        fetch(new_uri, :limit => limit-1)
+      else
+        response
+      end
+    end
+
+    def response_ok(response)
+      code = response.code.to_i
+      [ @ok ].flatten.compact.map { |x| x === code }.any?
+    end
+
+    def uri
+      URI::HTTP.build(:host => host, :port => port, :path => path)
+    end
+
+    def to_s
+      "#{method} #{uri}"
+    end
+  end
+end
+
+# vim:set ft=ruby sw=2 ts=2 :

data/lib/antismoker/tests.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+require "logger"
+require "timeout"
+
+module AntiSmoker
+  class AbstractSmokeTest
+    def initialize(host, port, options={})
+      @host = host
+      @port = port
+      @options = options
+
+      @delay = options[:delay]
+      @count = options[:count]
+      @period = options[:period]
+      @timeout = options[:timeout]
+
+      @logger = Logger.new(STDERR)
+      @logger.level = Logger.const_get(options.fetch(:log, :info).to_s.upcase)
+    end
+    attr_reader :host
+    attr_reader :port
+    attr_reader :options
+
+    attr_reader :delay
+    attr_reader :count
+    attr_reader :period
+    attr_reader :timeout
+
+    attr_reader :logger
+
+    def sleep_with_progress(n)
+      deadline = Time.now + n
+      while Time.now < deadline
+        STDOUT.putc(?.)
+        STDOUT.flush
+        sleep(n / 3)
+      end
+    end
+
+    def run(options={})
+      STDOUT.write("smoke testing: #{self}: ")
+      sleep_with_progress(delay)
+      n = 0
+      while n < count
+        if run_once_with_timeout(options)
+          STDOUT.puts(" [\e[1;32m OK \e[0m]")
+          return true
+        else
+          STDOUT.putc(?!)
+          sleep_with_progress(period)
+          n += 1
+        end
+      end
+      STDOUT.puts(" [\e[31m NG \e[0m]")
+      return false
+    end
+
+    def run_once_with_timeout(options={})
+      begin
+        Timeout.timeout(timeout) {
+          return run_once(options)
+        }
+      rescue Timeout::Error => error
+        logger.warn("timed out: #{self}: #{error}")
+      rescue => error
+        logger.warn("unknown error: #{self}: #{error}")
+      end
+      false
+    end
+
+    def run_once(options={})
+      raise("must be overridden")
+    end
+  end
+end
+
+# vim:set ft=ruby sw=2 ts=2 :

data/lib/antismoker/version.rb

@@ -0,0 +1,3 @@
+module AntiSmoker
+  VERSION = "0.0.1"
+end

data/lib/antismoker.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require "antismoker/deployment"
+require "antismoker/loader"
+require "antismoker/runner"
+require "antismoker/tests"
+require "antismoker/version"
+
+module AntiSmoker
+  # Your code goes here...
+end
+
+# vim:set ft=ruby sw=2 ts=2 :

data/lib/tasks/antismoker.rake

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require "antismoker"
+
+desc("Run smoke test.")
+task(:antismoker) do
+  Rake::Task["antismoker:invoke"].invoke
+end
+
+namespace(:antismoker) do
+  desc("Run smoke test.")
+  task(:invoke) do
+    env = defined?(RAILS_ENV) ? RAILS_ENV : ENV.fetch("RAILS_ENV", "development")
+    smoketests = AntiSmoker.load("config/antismoker.yml", :env => env)
+    results = AntiSmoker.run(smoketests)
+    abort unless results.all?
+  end
+end
+
+# vim:set ft=ruby ts=2 sw=2 :

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: antismoker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Yamashita Yuu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Yet another HTTP smoke testing framework.
+email:
+- yamashita@geishatokyo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- antismoker.gemspec
+- lib/antismoker.rb
+- lib/antismoker/capistrano.rb
+- lib/antismoker/deployment.rb
+- lib/antismoker/loader.rb
+- lib/antismoker/runner.rb
+- lib/antismoker/tests.rb
+- lib/antismoker/tests/http.rb
+- lib/antismoker/version.rb
+- lib/tasks/antismoker.rake
+homepage: https://github.com/yyuu/antismoker
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Yet another HTTP smoke testing framework.
+test_files: []