nitro 0.23.0 → 0.24.0

data/proto/public/scaffold/list.xhtml

@@ -1,9 +1,12 @@
 <SystemPage name="List of %list_name%">
   <h2><a href="#@base/new_%name%">New %name%</a></h2>
+  <form action="search">
+    Search %list_name%: <input type="text" name="q" />&nbsp;<input type="submit" value="Search" /> (not implemented yet)
+  </form>
   <table>
   <?r for obj in @%list_name% ?>
     <tr>
-      <td width="100%">#{obj.to_s}</td>
+      <td width="100%"><a href="#@base/edit_%name%/#{obj.oid}">#{obj.to_s}</a></td>
       <?r if obj.respond_to?(:update_time) ?>
         <td nowrap="1">#{obj.update_time.stamp(:db)}</td>
       <?r end ?>

data/proto/scgi.rb

@@ -0,0 +1,333 @@
+#!/usr/bin/env ruby
+
+require 'stringio'
+require 'yaml'
+require 'digest/sha1'
+require 'logger'
+require 'fileutils'
+require 'socket'
+require 'cgi'
+require 'rubygems'
+require 'cmdparse'
+require 'monitor'
+
+def log(msg)
+    $stderr.print msg,"\n"
+end
+
+def error(msg, exc=nil)
+    if exc
+        $stderr.print "ERROR: #{msg}: #{exc}\n"
+        $stderr.puts exc.backtrace
+    else
+        $stderr.print "ERROR: #{msg}\n"
+    end
+end
+
+
+# Modifies CGI so that we can use it.
+class SCGIFixed < ::CGI
+    public :env_table
+    
+    def initialize(params, data, out, *args)
+        @env_table = params
+        @args = *args
+        @input = StringIO.new(data)
+        @out = out
+        super(*args)
+    end
+    def args
+        @args
+    end
+    def env_table
+        @env_table
+    end
+    def stdinput
+        @input
+    end
+    def stdoutput
+        @out
+    end
+end
+
+
+class SCGIProcessor < Monitor
+
+    def initialize(settings)
+        @env = settings[:env] || "development"
+        @debug = settings[:debug] || false
+        @host = settings[:host] || "127.0.0.1"
+        @port = settings[:port] || "9999"
+        @children = settings[:children] || 1
+        @pid_file = settings[:pid_file] || "children.yaml"
+        @status_dir = settings[:status_dir] || "/tmp"
+        @log_file = settings[:logfile] || "log/scgi.log"
+        @maxconns = settings[:maxconns]
+        @busy_msg = settings[:busy_msg] || "BUSY"
+        @settings = settings
+        @started = Time.now
+        @conns = 0
+        @total_conns = 0
+        @errors = 0
+        
+        if @maxconns
+            @maxconns = @maxconns.to_i
+        else
+            @maxconns = 2**30-1
+        end
+        
+        if settings[:conns_second]
+            @throttle_sleep = 1.0/settings[:conns_second].to_i
+        end
+
+        super()
+    end
+    
+    def run
+        ENV['NITRO_ENV'] = @env
+
+        require 'nitro'
+        server = TCPServer.new(@host, @port)
+        
+        if @debug
+            log("Listening for connections on #@host:#@port")
+            listen(server)
+        else
+            childpids = []
+            @children.to_i.times do
+                # fork each child listening to the same port.  very simple yet effective way to spread the load
+                # to multiple processes without using threads and still using high performance libevent
+                begin
+                    pid = fork do
+                        $stderr = open(@log_file,"w")
+                        $stderr.sync = false
+                        listen(server)
+                    end
+                    childpids << pid
+                    Process.detach(pid)
+                rescue Object
+                    error("Could not fork child processes.  Your system might not support fork.  Use -D instead.", $!)
+                end
+            end
+                
+            # tell the user what the sha1 is so they can check for modification later
+            log("#@pid_file will have SHA1 #{Digest::SHA1.hexdigest(YAML.dump(childpids))}")
+            log("Record this somewhere so you know if it was modified later by someone else.")
+            # all children forked and the pids are now ready to write to the pid file
+            open(@pid_file,"w") { |f| f.write(YAML.dump(childpids)) }
+        end
+    end
+
+    
+    def listen(socket)
+        thread = Thread.new do
+            while true
+                handle_client(socket.accept)
+                sleep @throttle_sleep if @throttle_sleep
+                
+                @total_conns += 1
+            end
+        end
+        
+        begin
+            thread.join
+        rescue Interrupt
+            log("Shutting down from SIGINT.")
+        rescue Object
+            error("while listening for connections on #@host:#@port", $!)
+        end
+    end
+    
+    
+    def handle_client(socket)
+        Thread.new do
+            begin
+                synchronize { @conns += 1}
+                
+                len = ""
+                # we only read 10 bytes of the length.  any request longer than this is invalid
+                while len.length <= 10
+                    c = socket.read(1)
+                    if c == ':'
+                        # found the terminal, len now has a length in it so read the payload
+                        break
+                    else
+                        len << c
+                    end
+                end
+                
+                # we should now either have a payload length to get
+                payload = socket.read(len.to_i)
+                if (c = socket.read(1)) != ','
+                    error("Malformed request, does not end with ','")
+                else
+                    read_header(socket, payload, @conns)
+                end
+            rescue IOError
+                error("received IOError #$! when handling client.  Your web server doesn't like me.")
+            rescue Object
+                @errors += 1
+                error("after accepting client #@host:#@port -- #{$!.class}", $!)
+            ensure
+                synchronize { @conns -= 1}
+                socket.close if not socket.closed?
+            end
+        end
+
+    end
+
+    
+    def read_header(socket, payload, conns)
+        return if socket.closed?
+        request = split_body(payload)
+        if request and request["CONTENT_LENGTH"]
+            length = request["CONTENT_LENGTH"].to_i
+            if length > 0
+                body = socket.read(length)
+            else
+                body = ""
+            end
+
+            if @conns > @maxconns
+                socket.write("Content-type: text/plain\r\n\r\n")
+                socket.write(@busy_msg)
+            else
+                process_request(request, body, socket)
+            end
+        end
+    end
+
+    
+    def process_request(request, body, socket)
+        return if socket.closed?
+        cgi = SCGIFixed.new(request, body, socket)
+        begin
+            synchronize do
+                # unfortuneatly, the dependencies.rb file is not thread safe and will throw exceptions
+                # claiming that Dispatcher is not defined, or that other classes are missing.  We have
+                # to sync the dispatch call to get around this.
+                Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, cgi.stdoutput)
+            end
+        rescue IOError
+            error("received IOError #$! when handling client.  Your web server doesn't like me.")
+        rescue Object => nitro_error
+            error("calling Dispatcher.dispatch", nitro_error)
+        end
+    end
+    
+    
+    def split_body(data)
+        result = {}
+        el = data.split("\0")
+        i = 0
+        len = el.length
+        while i < len
+            result[el[i]] = el[i+1]
+            i += 1
+        end
+    
+        return result
+    end
+            
+    def status
+        pid = Process.pid
+        open("#@status_dir/scgi_nitro_status.#{pid}","w") do |f|
+            status = { 
+               'time' => Time.now,  'pid' => pid, 'settings' => @settings,
+               'env' => @env, 'status_dir' => @status_dir, 'started' => @started,
+               'max_conns' => @maxconns, 'total_conns' => @total_conns,
+               'conns' => @conns, 'errors' => @errors, 'systimes' => Process.times
+             }
+            f.write(YAML.dump(status))
+        end
+    end
+end
+
+
+def signal_children(pidfile,  signal)
+    if not File.exists? pidfile
+        log("No #{pidfile} as specified.  Probably nothing running or wrong path.")
+        exit 1
+    end
+        
+    childpids = YAML.load_file(pidfile)
+    childpids.each do |pid|
+        begin
+            log("Signaling pid #{pid}")
+            Process.kill(signal, pid)
+        rescue Object
+            log("Couldn't send #{signal} signal to #{pid} pid.")
+        end
+    end
+end
+
+
+def make_command(parent, name, desc, options)
+    cmd = CmdParse::Command.new(name, false )
+    cmd.short_desc = desc
+    settings = {}
+    cmd.options = CmdParse::OptionParserWrapper.new do |opt|
+        options.each do |short, long, info, symbol|
+            opt.on(short, long, info) {|val| settings[symbol] = val}
+        end
+    end
+    cmd.set_execution_block do |args|
+        yield(settings, args)
+    end
+    parent.add_command(cmd)
+end
+
+
+cmd = CmdParse::CommandParser.new( true )
+cmd.program_name = 'scgi'
+cmd.program_version = [0, 2, 1]
+cmd.options = CmdParse::OptionParserWrapper.new do |opt|
+    opt.separator "Global options:"
+    opt.on("--verbose", "Be verbose when outputting info") {|t| $verbose = true }
+end
+
+cmd.add_command( CmdParse::HelpCommand.new )
+cmd.add_command( CmdParse::VersionCommand.new )
+
+make_command(cmd, 'start', "Start Nitro Application", 
+[['-e','--env STRING','Nitro environment', :env],
+['-D','--[no-]debug', 'Do not fork children, stay in foreground.', :debug],
+['-h','--host STRING', 'IP address to bind as server', :host],
+['-p','--port NUMBER', 'Port to bind to', :port],
+['-c','--children NUMBER', 'Number of children to start (not win32)', :children],
+['-f','--pid-file PATH', 'Where to read the list of running children', :pid_file],
+['-l','--log-file PATH', 'Use a different log from from log/scgi.log', :logfile],
+['-t','--throttle NUMBER', 'Max conn/second to allow.', :conns_second],
+['-m','--max-conns NUMBER', 'Max simultaneous connections before the busy message', :maxconns],
+['-b','--busy-msg', 'Busy message given to clients over the max connections ("busy")', :busy_msg],
+['-s','--status-dir PATH', 'Where to put the status files', :status_dir]]) do |settings, args|
+    scgi = SCGIProcessor.new(settings)
+    begin
+        trap("HUP") { scgi.status }
+    rescue Object
+        error("Could not setup a SIGHUP handler.  You won't be able to get status.")
+    end
+    
+    scgi.run
+end
+
+
+make_command(cmd, 'status', "Get status from all running children",
+[['-s','--status-dir PATH', 'Where to put the status files', :status_dir],
+['-f','--pid-file PATH', 'Where to read the list of running children', :pid_file]]) do |settings, args|
+    signal_children(settings[:pid_file] || 'children.yaml', "HUP")
+    log("Status files for each child should show up in the configured status directory (/tmp by default).")
+end
+
+make_command(cmd, 'stop', "Stop all running children",
+[['-s','--sig SIGNAL', 'Where to put the status files', :signal],
+['-n','--[no-]delete', 'Keep the children.yaml file rather than delete', :nodelete],
+['-f','--pid-file PATH', 'Where to read the list of running children', :pid_file]]) do |settings, args|
+    pid_file = settings[:pid_file] || "children.yaml"
+    signal_children(pid_file, settings[:signal] || "INT")
+    if not settings[:nodelete] and File.exist?(pid_file)
+        File.unlink(pid_file)
+    end
+end
+
+cmd.parse

data/script/scgi_ctl

@@ -0,0 +1,221 @@
+#!/usr/bin/env ruby
+require 'drb'
+require 'rubygems'
+require 'cmdparse'
+require 'yaml'
+require 'highline'
+
+UI = HighLine.new
+DEFAULT_CONFIG = "conf/scgi.yaml"
+
+def safe(error)
+    begin
+        yield
+    rescue Object
+        STDERR.puts("ERROR: #{error}: #$!")
+        exit 1
+    end
+end
+
+def load_config(file)
+    safe("Could not load config") do
+        return YAML.load_file(file)
+    end
+end
+
+def connect(url)
+    conn = nil
+    safe("Can't connect to #{url}") do
+         conn = DRbObject.new(nil, url)
+    end
+    
+    safe("Failed communicating with #{url}") do
+        yield conn
+    end
+end
+
+def deduce_url(settings)
+    settings[:control_url] || load_config(settings[:config] || DEFAULT_CONFIG)[:control_url]
+end
+
+def defaults(settings)
+    defaults = nil
+    if settings[:merge]
+        UI.say("Merging with previous settings.")
+        defaults = load_config(settings[:config] || DEFAULT_CONFIG)
+    else
+        defaults = {
+        :env => "production",
+        :host => "127.0.0.1",
+        :port => 9999,
+        :logfile => "log/scgi.log",
+        :config => DEFAULT_CONFIG }
+    end
+    
+    settings = defaults.merge(settings)
+    # fix up the stuff that's not quite right yet
+    settings[:control_url] = "druby://127.0.0.1:#{settings[:port]-1000}"
+    settings[:port] = settings[:port].to_i
+    settings[:throttle] = settings[:throttle].to_i if settings[:throttle]
+    settings[:maxconns] = settings[:maxconns].to_i if settings[:maxconns]
+    
+    return settings
+end
+    
+
+def configure(settings)
+    settings = defaults(settings)
+    
+    pass = settings[:password] || UI.ask("What password do you want? ")
+    salting = ('a' .. 'z').to_a + ('A' .. 'Z').to_a + ('0' .. '9').to_a
+    settings[:password] = pass.crypt(salting[rand(salting.length)] + salting[rand(salting.length)])
+    
+    # great, they are not idiots.  Well, they can read --help at least.
+    safe("Could not write config") do
+        open(settings[:config],"w") {|f| f.write(YAML.dump(settings)) }
+        UI.say("Configuration settings written to #{settings[:config]}")
+    end
+end
+
+def password
+    if not $password
+        $password = UI.ask("Password: ")
+    end
+    $password
+end
+
+def start(cmd, config)
+    fork do
+        exec cmd, config
+    end
+end
+
+def status(url)
+    connect(url) do |conn|
+        s = conn.status(password)
+        times = s[:systimes]
+        
+        puts <<-END
+#{UI.color("Status as of #{s[:time]}:",:green,:bold)}
+PID: #{s[:pid]}\tStarted: #{s[:started]}\tEnvironment: #{s[:env]}
+Connected Requests: #{s[:conns]}
+Conns/Second: #{s[:conns_second] || "Not Set"}
+Max Simultaneous Conns: #{s[:max_conns]}
+Shutdown Started: #{s[:shutdown]}
+Processing Time:  #{times.utime} #{times.stime} #{times.cutime} #{times.cstime}
+Current Settings:
+#{s[:settings].to_yaml.gsub(/:([a-z])/, '   \1')}
+END
+    end
+end
+
+def reconfigure(url)
+    connect(url) do |conn|
+        conn.reconfigure(password)
+    end
+end
+
+def stop(url, force)
+    connect(url) do |conn|
+        conn.shutdown(password, force)
+    end
+end
+
+def restart(url, force)
+    connect(url) do |conn|
+        conn.restart(password, force)
+    end
+end
+
+def monitor(url)
+    connect(url) do |conn|
+        while true
+            sleep 3
+            puts "\e[2J"
+            status(url)
+        end
+    end
+end
+
+
+def make_command(parent, name, desc, options)
+    cmd = CmdParse::Command.new(name, false )
+    cmd.short_desc = desc
+    settings = {}
+    cmd.options = CmdParse::OptionParserWrapper.new do |opt|
+        options.each do |short, long, info, symbol|
+            opt.on(short, long, info) {|val| settings[symbol] = val}
+        end
+    end
+    cmd.set_execution_block do |args|
+        yield(settings, args)
+    end
+    parent.add_command(cmd)
+end
+
+
+cmd = CmdParse::CommandParser.new( true )
+cmd.program_name = "scgi_nitro"
+cmd.program_version = [0, 4, 0]
+cmd.options = CmdParse::OptionParserWrapper.new do |opt|
+    opt.separator "Global options:"
+    opt.on("--verbose", "Be verbose when outputting info") {|t| $verbose = true }
+end
+
+cmd.add_command( CmdParse::HelpCommand.new )
+cmd.add_command( CmdParse::VersionCommand.new )
+
+make_command(cmd, 'config', "Configure the SCGI servers", 
+[['-e','--env STRING','Nitro environment', :env],
+['-h','--host STRING', 'IP address to bind as server', :host],
+['-p','--port NUMBER', 'Port to bind to (starts at 9999)', :port],
+['-u','--control-url URL', 'DRuby URL to run control on (same as SCGI -1000)', :control_url],
+['-l','--log-file PATH', 'Use a different log from from log/scgi.log', :logfile],
+['-t','--throttle NUMBER', 'Max conn/second to allow.', :conns_second],
+['-m','--max-conns NUMBER', 'Max simultaneous connections before the busy message', :maxconns],
+['-P','--moron-mode PASSWORD', 'You are an idiot and you want your password on the command line', :password],
+['-M','--merge', 'Merge new settings with previous rather than defaults', :merge],
+['-c','--config PATH', 'Config file to use (#{DEFAULT_CONFIG})', :config]]) do |settings, args|
+    configure(settings)
+end
+
+make_command(cmd, 'start', "Start the application",
+[['-u','--control-url URL', 'DRuby URL to run control on (same as SCGI -1000)', :control_url],
+['-c','--config PATH', 'Config file to use (#{DEFAULT_CONFIG})', :config]]) do |settings, args|
+    cmd = File.dirname(__FILE__) + "/scgi_service"
+    start(cmd, settings[:config] || DEFAULT_CONFIG)
+end
+
+make_command(cmd, 'reconfig', "Reconfigure the SCGI servers with a new config", 
+[['-u','--control-url URL', 'DRuby URL to run control on (same as SCGI -1000)', :control_url],
+['-c','--config PATH', 'Config file to use (#{DEFAULT_CONFIG})', :config]]) do |settings, args|
+    reconfigure(deduce_url(settings))
+end
+
+make_command(cmd, 'status', "Get status",
+[['-u','--control-url URL', 'DRuby URL to run control on (same as SCGI -1000)', :control_url],
+['-c','--config PATH', 'Config file to use (#{DEFAULT_CONFIG})', :config]]) do |settings, args|
+    status(deduce_url(settings))
+end
+
+make_command(cmd, 'stop', "Stop the application",
+[['-u','--control-url URL', 'DRuby URL to run control on (same as SCGI -1000)', :control_url],
+['-c','--config PATH', 'Config file to use (#{DEFAULT_CONFIG})', :config],
+['-f','--force', 'Forced shutdown rather than graceful (default graceful)', :force]]) do |settings, args|
+    stop(deduce_url(settings), settings[:force] || false)
+end
+
+make_command(cmd, 'restart', "Restart the application",
+[['-u','--control-url URL', 'DRuby URL to run control on (same as SCGI -1000)', :control_url],
+['-c','--config PATH', 'Config file to use (#{DEFAULT_CONFIG})', :config],
+['-f','--force', 'Forced shutdown rather than graceful (default graceful)', :force]]) do |settings, args|
+    restart(deduce_url(settings), settings[:force] || false)
+end
+
+make_command(cmd, 'monitor', "Monitor the application",
+[['-u','--control-url URL', 'DRuby URL to run control on (same as SCGI -1000)', :control_url],
+['-c','--config PATH', 'Config file to use (#{DEFAULT_CONFIG})', :config]]) do |settings, args|
+    monitor(deduce_url(settings))
+end
+
+cmd.parse