ptomato-ramaze 2009.02

data/Rakefile

@@ -0,0 +1,248 @@
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+require 'rake'
+require 'rake/clean'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+require 'pp'
+require 'date'
+require 'time'
+require 'fileutils'
+
+include FileUtils
+
+$:.unshift File.join(File.dirname(__FILE__), "lib")
+
+require 'ramaze/version'
+load 'rake_tasks/conf.rake'
+load 'rake_tasks/maintenance.rake'
+load 'rake_tasks/spec.rake'
+load 'rake_tasks/coverage.rake'
+load 'rake_tasks/release.rake'
+load 'rake_tasks/git.rake'
+load 'rake_tasks/gem.rake'
+load 'rake_tasks/metric.rake'
+
+task :default => ['spec']
+task :test => ['spec']
+# task :package => ['jquery']
+
+desc 'download latest jquery and put in /lib/proto/public/js/jquery.js'
+task :jquery do
+  require 'open-uri'
+  $stdout.sync = true
+
+  File.open('lib/proto/public/js/jquery.js', 'w+') do |jquery|
+    remote = open('http://code.jquery.com/jquery-latest.js')
+    print "openend remote side, copying..."
+    while chunk = remote.read(4096)
+      print '.'
+      jquery.write(chunk)
+    end
+    puts " done."
+  end
+end
+
+desc 'Check gemspec file list against real file list'
+task :check_gemspec do
+  base_dir = File.expand_path(File.dirname(__FILE__))
+  gemspec_files = eval(File.read(File.join(base_dir,'ramaze.gemspec'))).files.map{|file|File.join(base_dir,file)}
+
+  deleted_files = gemspec_files.select{|file|!File.exists?(file)}.map{|file|file[(base_dir.size+1)..-1]}
+
+  added_files = Dir.glob(File.join(File.dirname(__FILE__),'**/*')).select do |file|
+    !gemspec_files.index(file)
+  end.map do |file|
+    file[(base_dir.size+1)..-1]
+  end.select do |file|
+    !( file == 'pkg' or file =~ /.*\.gem/ )
+  end
+
+  unless deleted_files.empty?
+    puts "The following files appear in the gemspec but cannot be found:"
+    deleted_files.each do |file|
+      puts "\t#{file}"
+    end
+  end
+  unless added_files.empty?
+    puts "The following files exist, but cannot be found in the gemspec:"
+    added_files.each do |file|
+      puts "\t#{file}"
+    end
+  end
+end
+
+task :rcov_dir do
+  mkdir_p 'doc/output/tools/rcov/'
+end
+
+desc "Generate HTML coverage report"
+task :rcov_summary => :rcov_dir do
+  `rcov --version`
+  raise LoadError, "Please `gem install rcov` first" if $?.exitstatus == 127
+  raise "Run `rake coverage` to generate coverage data first" unless File.exists? 'coverage.data'
+  sh "rcov --aggregate coverage.data -o doc/output/tools/rcov/"
+end
+
+desc "generate rdoc"
+task :rdoc => [:clean] do
+  sh "rdoc #{(RDOC_OPTS + RDOC_FILES).join(' ')}"
+end
+
+desc "generate improved allison-rdoc"
+task :allison => :clean do
+  opts = RDOC_OPTS
+  path = `allison --path`.strip
+  raise LoadError, "Please `gem install allison` first" if $?.exitstatus == 127
+  opts << %W[--template '#{path}']
+  sh "rdoc #{(RDOC_OPTS + RDOC_FILES).join(' ')}"
+end
+
+desc "create bzip2 and tarball"
+task :distribute => :gem do
+  sh "rm -rf pkg/ramaze-#{VERS}"
+  sh "mkdir -p pkg/ramaze-#{VERS}"
+  sh "cp -r {bin,doc,lib,examples,spec,Rakefile,README.md,rake_tasks} pkg/ramaze-#{VERS}/"
+
+  Dir.chdir('pkg') do |pwd|
+    sh "tar -zcvf ramaze-#{VERS}.tar.gz ramaze-#{VERS}"
+    sh "tar -jcvf ramaze-#{VERS}.tar.bz2 ramaze-#{VERS}"
+  end
+
+  sh "rm -rf pkg/ramaze-#{VERS}"
+end
+
+desc "show a todolist from all the TODO tags in the source"
+task :todo do
+  files = Dir[File.join(BASEDIR, '{lib,spec}', '**/*.rb')]
+
+  files.each do |file|
+    lastline = todo = comment = long_comment = false
+
+    File.readlines(file).each_with_index do |line, lineno|
+      lineno += 1
+      comment = line =~ /^\s*?#.*?$/
+      long_comment = line =~ /^=begin/
+      long_comment = line =~ /^=end/
+      todo = true if line =~ /TODO/ and (long_comment or comment)
+      todo = false if line.gsub('#', '').strip.empty?
+      todo = false unless comment or long_comment
+      if todo
+        unless lastline and lastline + 1 == lineno
+          puts
+          puts "vim #{file} +#{lineno}"
+        end
+
+        l = line.strip.gsub(/^#\s*/, '')
+        print '  ' unless l =~ /^-/
+        puts l
+        lastline = lineno
+      end
+    end
+  end
+end
+
+desc "opens a simple readline that makes making requests easier"
+task 'request' do
+  ARGV.clear
+  require 'open-uri'
+  require 'pp'
+
+  loop do
+    print 'do request? [enter] '
+    gets
+    begin
+      pp open('http://localhost:7000/xxx').read
+    rescue Object => ex
+      puts ex
+    end
+  end
+end
+
+desc 'listing of available traits per class/module'
+task 'traits' do
+  nodes = Hash.new{|h,k| h[k] = []}
+  Dir['lib/**/*.rb'].each do |file|
+    content = File.read(file)
+    traits = content.grep(/^\s*trait\s*:/)
+    traits.each do |trait|
+      space = content[0..content.index(trait)].scan(/^\s*(?:class|module)\s+(.*)$/)
+      space = space.flatten.join('::')
+      nodes[space] << trait.strip
+    end
+  end
+
+  nodes.each do |space, traits|
+    puts space
+    traits.each do |trait|
+      print '  ', trait, "\n"
+    end
+    puts
+  end
+end
+
+desc "Update doc/CHANGELOG"
+task 'doc/CHANGELOG' do
+  File.open('doc/CHANGELOG', 'w+') do |f|
+    f.puts `git log`
+  end
+end
+
+desc "#{README} to doc/README.html"
+task 'doc/README.html' => [README] do
+  sh "maruku #{README}"
+  mv 'README.html', 'doc/README.html'
+end
+
+desc "Compile the #{README} from the parts of doc/readme"
+task README do
+  require 'enumerator'
+
+  chapters = [
+    'About Ramaze',         'introduction',
+    'Features Overview',    'features',
+    'Basic Principles',     'principles',
+    'Installation',         'installing',
+    'Getting Started',      'getting_started',
+    'A couple of Examples', 'examples',
+    'How to find Help',     'getting_help',
+    'Appendix',             'appendix',
+    'And thanks to...',     'thanks',
+  ]
+
+  File.open(README, 'w+') do |readme|
+    readme.puts COPYRIGHT.map{|l| l[1..-1]}, ''
+
+    chapters.each_slice(2) do |title, file|
+      file = File.join('doc', 'readme_chunks', "#{file}.txt")
+      chapter = File.read(file)
+      readme.puts "# #{title}", '', chapter
+      readme.puts '', '' unless title == chapters[-2]
+    end
+  end
+end
+
+desc 'Generate YARD documentation'
+task :ydoc do
+  sh('yardoc -o ydoc -r README.md')
+end
+
+task :publish => [:ydoc]
+
+begin
+  require 'grancher/task'
+
+  Grancher::Task.new do |g|
+    g.branch = 'gh-pages'
+#     g.push_to = 'origin'
+    g.message = 'Updated website'
+    g.directory 'ydoc', '.'
+  end
+rescue LoadError
+  # oh well :)
+end

data/benchmark/results.txt

@@ -0,0 +1,131 @@
+====== simple ======
+<code ruby>
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  def index
+    "Hello, World!"
+  end
+end
+</code>
+
+=== webrick ===
+  Mem usage before:       20.32MB
+  Time taken for tests:   7.747022 seconds
+  Failed requests:        0
+  Requests per second:    129.08 [#/sec] (mean)
+  Time per request:       77.470 [ms] (mean)
+  Time per request:       7.747 [ms] (mean, across all concurrent requests)
+  Mem usage after:        25.43MB
+
+=== mongrel ===
+  Mem usage before:       20.25MB
+  Time taken for tests:   2.205161 seconds
+  Failed requests:        0
+  Requests per second:    453.48 [#/sec] (mean)
+  Time per request:       22.052 [ms] (mean)
+  Time per request:       2.205 [ms] (mean, across all concurrent requests)
+  Mem usage after:        21.91MB
+
+=== evented_mongrel ===
+  Mem usage before:       22.64MB
+  Time taken for tests:   1.311583 seconds
+  Failed requests:        0
+  Requests per second:    762.44 [#/sec] (mean)
+  Time per request:       13.116 [ms] (mean)
+  Time per request:       1.312 [ms] (mean, across all concurrent requests)
+  Mem usage after:        27.03MB
+
+====== no_template ======
+<code ruby>
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :None
+
+  def index
+    "Hello, World!"
+  end
+end
+</code>
+
+=== evented_mongrel ===
+  Mem usage before:       22.63MB
+  Time taken for tests:   1.151947 seconds
+  Failed requests:        0
+  Requests per second:    868.10 [#/sec] (mean)
+  Time per request:       11.519 [ms] (mean)
+  Time per request:       1.152 [ms] (mean, across all concurrent requests)
+  Mem usage after:        27.11MB
+
+====== no_informer ======
+<code ruby>
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  def index
+    "Hello, World!"
+  end
+end
+
+Ramaze::Inform.loggers = []
+</code>
+
+=== evented_mongrel ===
+  Mem usage before:       22.63MB
+  Time taken for tests:   1.202878 seconds
+  Failed requests:        0
+  Requests per second:    831.34 [#/sec] (mean)
+  Time per request:       12.029 [ms] (mean)
+  Time per request:       1.203 [ms] (mean, across all concurrent requests)
+  Mem usage after:        27.07MB
+
+====== no_sessions ======
+<code ruby>
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  def index
+    "Hello, World!"
+  end
+end
+
+Ramaze::Inform.loggers = []
+Ramaze::Global.sessions = false
+</code>
+
+=== evented_mongrel ===
+  Mem usage before:       22.63MB
+  Time taken for tests:   0.835254 seconds
+  Failed requests:        0
+  Requests per second:    1197.24 [#/sec] (mean)
+  Time per request:       8.353 [ms] (mean)
+  Time per request:       0.835 [ms] (mean, across all concurrent requests)
+  Mem usage after:        26.38MB
+
+====== minimal ======
+<code ruby>
+require 'ramaze'
+
+class MainController < Ramaze::Controller
+  engine :None
+
+  def index
+    "Hello, World!"
+  end
+end
+
+Ramaze::Global.sourcereload = false
+Ramaze::Global.sessions = false
+Ramaze::Inform.loggers = []
+</code>
+
+=== evented_mongrel ===
+  Mem usage before:       22.62MB
+  Time taken for tests:   0.647273 seconds
+  Failed requests:        0
+  Requests per second:    1544.94 [#/sec] (mean)
+  Time per request:       6.473 [ms] (mean)
+  Time per request:       0.647 [ms] (mean, across all concurrent requests)
+  Mem usage after:        26.42MB
+

data/benchmark/run.rb

@@ -0,0 +1,362 @@
+require "optparse"
+require "timeout"
+require "net/http"
+
+class String
+  def /(o) File.join(self, o.to_s) end
+end
+
+class RamazeBenchmark
+
+  class BasicWriter
+    def initialize
+      @ljust = 24
+    end
+
+    def write(key, val)
+      if key == "Name"
+        puts "====== #{val} ======"
+      else
+        puts((key.to_s + ":").ljust(@ljust) + val.to_s)
+      end
+    end
+
+    def flush
+      puts
+      $stdout.flush
+    end
+
+    def close; end
+  end
+
+  class CSVWriter
+    def initialize
+      @keys, @vals = [], []
+    end
+
+    def write(key, val)
+      @keys << key
+      @vals << (val =~ /^\d[\d.]+/ ? $& : val)
+    end
+
+    def flush
+      unless @header
+        puts FasterCSV.generate{|csv| csv << @keys }
+        @header = true
+      end
+
+      puts FasterCSV.generate{|csv| csv << @vals }
+      @keys, @vals = [], []
+    end
+
+    def close; end
+  end
+
+  class GruffWriter
+    RPS = "Requests per second"
+
+    def initialize
+      @benchmarks = {}
+      @order = []
+    end
+
+    def write(key, val)
+      @benchmark ||= {}
+      @benchmark[key] = (val =~ /^\d[\d.]+/ ? $&.to_f : val)
+    end
+
+    def flush
+      if @benchmark["Requests per second"]
+        name = @benchmark["Name"]
+        @benchmarks[name] ||= []
+        @benchmarks[name] << @benchmark
+        @order << name unless @order.include?(name)
+      end
+      @benchmark = nil
+    end
+
+    def close
+      g = Gruff::SideBar.new(800)
+      g.title = "Ramaze Benchmark"
+      setup_gruff_data(g)
+      g.labels = gruff_labels
+      g.sort = false
+      g.hide_legend = true if graph_type == :simple
+      g.x_axis_label = "requests/sec"
+      g.minimum_value = 0
+      g.write
+    end
+
+    private
+
+    def gruff_labels
+      table = {}
+      @order.each_with_index do |bname, idx|
+        table[idx] = bname
+      end
+      return table
+    end
+
+    def adapters
+      @benchmarks.to_a[0][1].map{|bm| bm["Adapter"]}.uniq
+    end
+
+    def paths
+      @benchmarks.to_a[0][1].map{|bm| bm["Path"]}.uniq
+    end
+
+    def graph_type
+      case [adapters.size > 1, paths.size > 1]
+      when [true , true ]; :both
+      when [true , false]; :adapter
+      when [false, true ]; :path
+      else :simple; end
+    end
+
+    def setup_gruff_data(g)
+      case graph_type
+      when :simple
+        g.data("", @order.map{|name| @benchmarks[name][0][RPS] }, '#6886B4')
+      when :adapter
+        adapters.each do |adapter|
+          g.data(adapter, @order.map{|name|
+                   @benchmarks[name].find{|bm| bm["Adapter"] == adapter}[RPS]
+                 })
+        end
+      when :path
+        paths.each do |path|
+          g.data(path, @order.map{|name|
+                   @benchmarks[name].find{|bm| bm["Path"] == path}[RPS]
+                 })
+        end
+      when :both
+        adapters.each do |adapter|
+          paths.each do |path|
+            g.data("#{adapter}, #{path}", @order.map{|name|
+                     @benchmarks[name].find{|bm|
+                       bm["Adapter"] == adapter && bm["Path"] == path
+                     }[RPS]
+                   })
+          end
+        end
+      end
+    end
+  end
+
+  attr_accessor :requests, :adapters, :port, :log, :display_code, :target
+  attr_accessor :concurrent, :paths, :benchmarker, :informer, :sessions
+  attr_accessor :show_log, :ignored_tags, :formats
+
+  def initialize()
+    @adapters = [:webrick]
+    @port = rand(32768-1)+32768
+    @requests = 100
+    @concurrent = 10
+    @signal = 'SIGKILL'
+    @host = "127.0.0.1"
+    @paths = ["/"]
+    @target = /.+/
+    @informer = true
+    @sessions = true
+    @ignored_tags = [:debug, :dev]
+    @formats = ["text"]
+    @writers = []
+    yield self
+  end
+
+  def start
+    # setup writers
+    @formats.each do |format|
+      case format
+      when "csv"  ; @writers << CSVWriter.new
+      when "gruff"; @writers << GruffWriter.new
+      when "text" ; @writers << BasicWriter.new
+      end
+    end
+
+    # benchmarks
+    __DIR__ = File.expand_path(File.dirname(__FILE__))
+    Dir[__DIR__('suite/*.rb')].each do |filename|
+      @adapters.each do |adapter|
+        @paths.each do |path|
+          benchmark(filename, adapter, path) if @target.match(filename)
+        end
+      end
+    end
+
+    # close writers
+    @writers.each do |writer|
+      writer.close
+    end
+  end
+
+  # start to measure
+  def benchmark(filename, adapter, path)
+    # output informations
+    l :Name,       filename.scan(/\/([^\/]+)\.rb/).to_s
+    l :Adapter,    adapter
+    l :Requests,   @requests
+    l :Concurrent, @concurrent
+    l :Path,       path
+    l :Informer,   @informer
+    l :Sessions,   @sessions
+    if @display_code
+      l :Code, "<code ruby>\n#{File.read(filename)}\n</code>\n\n"
+    end
+
+    # real benchmark
+    ramaze(filename, adapter) do |pid|
+      l "Mem usage before", "#{memsize(pid)}MB"
+      ab(path).each do |line|
+        l *line.split(/:\s*/)
+      end
+      l "Mem usage after", "#{memsize(pid)}MB"
+    end
+
+    # flush writers
+    @writers.each do |writer|
+      writer.flush
+    end
+  end
+
+  private
+
+  # memory usage size
+  def memsize(pid)
+    (`ps -p #{pid} -o rss=`.strip.to_f/10.24).round/100.0
+  end
+
+  # output
+  def l(key, val)
+    @writers.each do |writer|
+      writer.write(key.to_s, val)
+    end
+  end
+
+  # url of ramaze server
+  def url(path)
+    "http://#{@host}:#{@port}#{path}"
+  end
+
+  # apache benchmark
+  def ab(path)
+    re = /^(Fail|Req|Time|Total transferred|Document Length|Transfer rate)/
+    `ab -c #{@concurrent} -n #{@requests} #{url(path)}`.split("\n").grep(re)
+  end
+
+  # startup
+  def ramaze(filename, adapter)
+    pid = fork do
+      begin
+        require filename
+        Ramaze::Log.ignored_tags = @ignored_tags
+        if @informer
+          unless @show_log
+            Ramaze::Log.loggers = [Ramaze::Logging::Logger::Informer.new("/dev/null")]
+          end
+        else
+          Ramaze::Log.loggers = []
+        end
+        Ramaze::Global.sessions = @sessions
+        Ramaze::Global.sourcereload = false
+        Ramaze.start :adapter => adapter, :port => @port
+      rescue LoadError => ex; l :Error, ex; end
+    end
+
+    yield pid if wait_to_startup
+
+    Process.kill(@signal, pid)
+    Process.waitpid2(pid)
+  end
+
+  # wait for ramaze to start up
+  def wait_to_startup
+    begin
+      Timeout.timeout(5) do
+        loop do
+          begin
+            sleep 1; Net::HTTP.new(@host, @port).head("/"); return true
+          rescue Errno::ECONNREFUSED; end
+        end
+      end
+    rescue Timeout::Error
+      l "Error", "failed to start benchmark script"; return false
+    end
+  end
+end
+
+Signal.trap(:INT, proc{exit})
+
+RamazeBenchmark.new do |bm|
+  OptionParser.new(false, 24, "  ") do |opt|
+    opt.on('-a', '--adapters NAMES', '[webrick] Specify adapters') do |adapters|
+      bm.adapters = adapters.split(",")
+    end
+
+    opt.on('--formats (text|csv|gruff)', '[text] Specify output formats') do |formats|
+      bm.formats = formats.split(",")
+      bm.formats.each do |format|
+        case format
+        when "csv"  ; require "fastercsv"
+        when "gruff"; require "gruff"
+        end
+      end
+    end
+
+    opt.on('-n', '--requests NUM', '[100] Number of requests') do |n|
+      bm.requests = n
+    end
+
+    opt.on('-c', '--concurrent NUM', '[10] Number of multiple requests') do |n|
+      bm.concurrent = n
+    end
+
+    opt.on('--code', 'Display benchmark code') do |n|
+      bm.display_code = true
+    end
+
+    opt.on('-p', '--port NUM',
+           '[random(32768-65535)] Specify port number') do |n|
+      bm.port = n
+    end
+
+    opt.on('--paths PATHS', '[/] Specify request paths') do |paths|
+      bm.paths = paths.split(",")
+    end
+
+    opt.on('--no-informer', 'Disable informer') do
+      bm.informer = false
+    end
+
+    opt.on('--ignored-tags TAGS',
+           '[debug,dev] Specify ignored tags for Ramaze::Log') do |tags|
+      bm.ignored_tags = tags.split(",").map{|e| e.to_sym }
+    end
+
+    opt.on('--show-log', 'Show log') do
+      bm.show_log = true
+    end
+
+    opt.on('--no-sessions', 'Disable sessions') do
+      bm.sessions = false
+    end
+
+    opt.on('--target REGEXP',
+           '[/.+/] Specify benchmark scripts to measure') do |name|
+      bm.target = Regexp.compile(name)
+    end
+
+    opt.on('-h', '--help', 'Show this message') do
+      puts opt.help
+      exit
+    end
+
+    begin
+      opt.parse!(ARGV)
+    rescue OptionParser::ParseError => ex
+      puts "[ERROR] " + ex
+      puts opt.help
+      exit
+    end
+  end
+end.start