giga-smart-mod 0.0.1

data/thin-2.0.1/lib/thin/connection.rb

@@ -0,0 +1,219 @@
+require 'socket'
+
+module Thin
+  # Connection between the server and client.
+  # This class is instanciated by EventMachine on each new connection
+  # that is opened.
+  class Connection < EventMachine::Connection
+    include Logging
+
+    # This is a template async response. N.B. Can't use string for body on 1.9
+    AsyncResponse = [-1, {}, []].freeze
+
+    # Rack application (adapter) served by this connection.
+    attr_accessor :app
+
+    # Backend to the server
+    attr_accessor :backend
+
+    # Current request served by the connection
+    attr_accessor :request
+
+    # Next response sent through the connection
+    attr_accessor :response
+
+    # Calling the application in a threaded allowing
+    # concurrent processing of requests.
+    attr_writer :threaded
+
+    # Get the connection ready to process a request.
+    def post_init
+      @request  = Request.new
+      @response = Response.new
+    end
+
+    # Called when data is received from the client.
+    def receive_data(data)
+      @idle = false
+      trace data
+      process if @request.parse(data)
+    rescue InvalidRequest => e
+      log_error("Invalid request", e)
+      post_process Response::BAD_REQUEST
+    end
+
+    # Called when all data was received and the request
+    # is ready to be processed.
+    def process
+      if threaded?
+        @request.threaded = true
+        EventMachine.defer { post_process(pre_process) }
+      else
+        @request.threaded = false
+        post_process(pre_process)
+      end
+    end
+
+    def ssl_verify_peer(cert)
+      # In order to make the cert available later we have to have made at least
+      # a show of verifying it.
+      true
+    end
+
+    def pre_process
+      # Add client info to the request env
+      @request.remote_address = remote_address
+
+      # Connection may be closed unless the App#call response was a [-1, ...]
+      # It should be noted that connection objects will linger until this
+      # callback is no longer referenced, so be tidy!
+      @request.async_callback = method(:post_process)
+
+      if @backend.ssl?
+        @request.env["rack.url_scheme"] = "https"
+
+        if @backend.respond_to?(:port)
+          @request.env['SERVER_PORT'] = @backend.port.to_s
+        end
+
+        if cert = get_peer_cert
+          @request.env['rack.peer_cert'] = cert
+        end
+      end
+
+      # When we're under a non-async framework like rails, we can still spawn
+      # off async responses using the callback info, so there's little point
+      # in removing this.
+      response = AsyncResponse
+      catch(:async) do
+        # Process the request calling the Rack adapter
+        response = @app.call(@request.env)
+      end
+      response
+    rescue Exception => e
+      unexpected_error(e)
+      # Pass through error response
+      can_persist? && @request.persistent? ? Response::PERSISTENT_ERROR : Response::ERROR
+    end
+
+    def post_process(result)
+      return unless result
+      result = result.to_a
+
+      # Status code -1 indicates that we're going to respond later (async).
+      return if result.first == AsyncResponse.first
+
+      @response.status, @response.headers, @response.body = *result
+
+      log_error("Rack application returned nil body. " \
+                "Probably you wanted it to be an empty string?") if @response.body.nil?
+
+      # HEAD requests should not return a body.
+      @response.skip_body! if @request.head?
+
+      # Make the response persistent if requested by the client
+      @response.persistent! if @request.persistent?
+
+      # Send the response
+      @response.each do |chunk|
+        trace chunk
+        send_data chunk
+      end
+
+    rescue Exception => e
+      unexpected_error(e)
+      # Close connection since we can't handle response gracefully
+      close_connection
+    ensure
+      # If the body is being deferred, then terminate afterward.
+      if @response.body.respond_to?(:callback) && @response.body.respond_to?(:errback)
+        @response.body.callback { terminate_request }
+        @response.body.errback  { terminate_request }
+      else
+        # Don't terminate the response if we're going async.
+        terminate_request unless result && result.first == AsyncResponse.first
+      end
+    end
+
+    # Logs information about an unexpected exceptional condition
+    def unexpected_error(e)
+      log_error("Unexpected error while processing request", e)
+    end
+
+    def close_request_response
+      @request.async_close.succeed if @request.async_close
+      @request.close  rescue nil
+      @response.close rescue nil
+    end
+
+    # Does request and response cleanup (closes open IO streams and
+    # deletes created temporary files).
+    # Re-initializes response and request if client supports persistent
+    # connection.
+    def terminate_request
+      unless persistent?
+        close_connection_after_writing rescue nil
+        close_request_response
+      else
+        close_request_response
+        # Connection become idle but it's still open
+        @idle = true
+        # Prepare the connection for another request if the client
+        # supports HTTP pipelining (persistent connection).
+        post_init
+      end
+    end
+
+    # Called when the connection is unbinded from the socket
+    # and can no longer be used to process requests.
+    def unbind
+      @request.async_close.succeed if @request.async_close
+      @response.body.fail if @response.body.respond_to?(:fail)
+      @backend.connection_finished(self)
+    end
+
+    # Allows this connection to be persistent.
+    def can_persist!
+      @can_persist = true
+    end
+
+    # Return +true+ if this connection is allowed to stay open and be persistent.
+    def can_persist?
+      @can_persist
+    end
+
+    # Return +true+ if the connection must be left open
+    # and ready to be reused for another request.
+    def persistent?
+      @can_persist && @response.persistent?
+    end
+
+    # Return +true+ if the connection is open but is not
+    # processing any user requests
+    def idle?
+      @idle
+    end
+
+    # +true+ if <tt>app.call</tt> will be called inside a thread.
+    # You can set all requests as threaded setting <tt>Connection#threaded=true</tt>
+    # or on a per-request case returning +true+ in <tt>app.deferred?</tt>.
+    def threaded?
+      @threaded || (@app.respond_to?(:deferred?) && @app.deferred?(@request.env))
+    end
+
+    # IP Address of the remote client.
+    def remote_address
+      socket_address
+    rescue Exception => e
+      log_error('Could not infer remote address', e)
+      nil
+    end
+
+    protected
+      # Returns IP address of peer as a string.
+      def socket_address
+        peer = get_peername
+        Socket.unpack_sockaddr_in(peer)[1] if peer
+      end
+  end
+end

data/thin-2.0.1/lib/thin/controllers/cluster.rb

@@ -0,0 +1,178 @@
+require 'socket'
+
+module Thin
+  # An exception class to handle the event that server didn't start on time
+  class RestartTimeout < RuntimeError; end
+  
+  module Controllers
+    # Control a set of servers.
+    # * Generate start and stop commands and run them.
+    # * Inject the port or socket number in the pid and log filenames.
+    # Servers are started throught the +thin+ command-line script.
+    class Cluster < Controller
+      # Cluster only options that should not be passed in the command sent
+      # to the indiviual servers.
+      CLUSTER_OPTIONS = [:servers, :only, :onebyone, :wait]
+      
+      # Maximum wait time for the server to be restarted
+      DEFAULT_WAIT_TIME = 30    # seconds
+      
+      # Create a new cluster of servers launched using +options+.
+      def initialize(options)
+        super
+        # Cluster can only contain daemonized servers
+        @options.merge!(:daemonize => true)
+      end
+      
+      def first_port; @options[:port]     end
+      def address;    @options[:address]  end
+      def socket;     @options[:socket]   end
+      def pid_file;   @options[:pid]      end
+      def log_file;   @options[:log]      end
+      def size;       @options[:servers]  end
+      def only;       @options[:only]     end
+      def onebyone;   @options[:onebyone] end
+      def wait;       @options[:wait]     end
+      
+      def swiftiply?
+        @options.has_key?(:swiftiply)
+      end
+    
+      # Start the servers
+      def start
+        with_each_server { |n| start_server n }
+      end
+    
+      # Start a single server
+      def start_server(number)
+        log_info "Starting server on #{server_id(number)} ... "
+      
+        run :start, number
+      end
+  
+      # Stop the servers
+      def stop
+        with_each_server { |n| stop_server n }
+      end
+    
+      # Stop a single server
+      def stop_server(number)
+        log_info "Stopping server on #{server_id(number)} ... "
+      
+        run :stop, number
+      end
+    
+      # Stop and start the servers.
+      def restart
+        unless onebyone
+          # Let's do a normal restart by defaults
+          stop
+          sleep 0.1 # Let's breath a bit shall we ?
+          start
+        else
+          with_each_server do |n| 
+            stop_server(n)
+            sleep 0.1 # Let's breath a bit shall we ?
+            start_server(n)
+            wait_until_server_started(n)
+          end
+        end
+      end
+      
+      def test_socket(number)
+        if socket
+          UNIXSocket.new(socket_for(number))
+        else
+          TCPSocket.new(address, number)
+        end
+      rescue
+        nil
+      end
+      
+      # Make sure the server is running before moving on to the next one.
+      def wait_until_server_started(number)
+        log_info "Waiting for server to start ..."
+        STDOUT.flush # Need this to make sure user got the message
+        
+        tries = 0
+        loop do
+          if test_socket = test_socket(number)
+            test_socket.close
+            break
+          elsif tries < wait
+            sleep 1
+            tries += 1
+          else
+            raise RestartTimeout, "The server didn't start in time. Please look at server's log file " +
+                                  "for more information, or set the value of 'wait' in your config " +
+                                  "file to be higher (defaults: 30)."
+          end
+        end
+      end
+    
+      def server_id(number)
+        if socket
+          socket_for(number)
+        elsif swiftiply?
+          [address, first_port, number].join(':')
+        else
+          [address, number].join(':')
+        end
+      end
+    
+      def log_file_for(number)
+        include_server_number log_file, number
+      end
+    
+      def pid_file_for(number)
+        include_server_number pid_file, number
+      end
+    
+      def socket_for(number)
+        include_server_number socket, number
+      end
+    
+      def pid_for(number)
+        File.read(pid_file_for(number)).chomp.to_i
+      end
+      
+      private
+        # Send the command to the +thin+ script
+        def run(cmd, number)
+          cmd_options = @options.reject { |option, value| CLUSTER_OPTIONS.include?(option) }
+          cmd_options.merge!(:pid => pid_file_for(number), :log => log_file_for(number))
+          if socket
+            cmd_options.merge!(:socket => socket_for(number))
+          elsif swiftiply?
+            cmd_options.merge!(:port => first_port)
+          else
+            cmd_options.merge!(:port => number)
+          end
+          Command.run(cmd, cmd_options)
+        end
+      
+        def with_each_server
+          if only
+            if first_port && only < 80
+              # interpret +only+ as a sequence number
+              yield first_port + only
+            else
+              # interpret +only+ as an absolute port number
+              yield only
+            end
+          elsif socket || swiftiply?
+            size.times { |n| yield n }
+          else
+            size.times { |n| yield first_port + n }
+          end
+        end
+      
+        # Add the server port or number in the filename
+        # so each instance get its own file
+        def include_server_number(path, number)
+          ext = File.extname(path)
+          path.gsub(/#{ext}$/, ".#{number}#{ext}")
+        end
+    end
+  end
+end

data/thin-2.0.1/lib/thin/controllers/controller.rb

@@ -0,0 +1,189 @@
+require 'yaml'
+
+module Thin
+  # Error raised that will abort the process and print not backtrace.
+  class RunnerError < RuntimeError; end
+  
+  # Raised when a mandatory option is missing to run a command.
+  class OptionRequired < RunnerError
+    def initialize(option)
+      super("#{option} option required")
+    end
+  end
+  
+  # Raised when an option is not valid.
+  class InvalidOption < RunnerError; end
+  
+  # Build and control Thin servers.
+  # Hey Controller pattern is not only for web apps yo!
+  module Controllers  
+    # Controls one Thin server.
+    # Allow to start, stop, restart and configure a single thin server.
+    class Controller
+      include Logging
+    
+      # Command line options passed to the thin script
+      attr_accessor :options
+    
+      def initialize(options)
+        @options = options
+        
+        if @options[:socket]
+          @options.delete(:address)
+          @options.delete(:port)
+        end
+      end
+    
+      def start
+        # Constantize backend class
+        @options[:backend] = eval(@options[:backend], TOPLEVEL_BINDING) if @options[:backend]
+
+        server = Server.new(@options[:socket] || @options[:address], # Server detects kind of socket
+                            @options[:port],                         # Port ignored on UNIX socket
+                            @options)
+        
+        # Set options
+        server.pid_file                       = @options[:pid]
+        server.log_file                       = @options[:log]
+        server.timeout                        = @options[:timeout]
+        server.maximum_connections            = @options[:max_conns]
+        server.maximum_persistent_connections = @options[:max_persistent_conns]
+        server.threaded                       = @options[:threaded]
+        server.no_epoll                       = @options[:no_epoll] if server.backend.respond_to?(:no_epoll=)
+        server.threadpool_size                = @options[:threadpool_size] if server.threaded?
+
+        # ssl support
+        if @options[:ssl]
+          server.ssl = true
+          server.ssl_options = { :private_key_file => @options[:ssl_key_file], :cert_chain_file => @options[:ssl_cert_file], :verify_peer => !@options[:ssl_disable_verify], :ssl_version => @options[:ssl_version], :cipher_list => @options[:ssl_cipher_list]}
+        end
+
+        # Detach the process, after this line the current process returns
+        server.daemonize if @options[:daemonize]
+
+        # +config+ must be called before changing privileges since it might require superuser power.
+        server.config
+        
+        server.change_privilege @options[:user], @options[:group] if @options[:user] && @options[:group]
+
+        # If a Rack config file is specified we eval it inside a Rack::Builder block to create
+        # a Rack adapter from it. Or else we guess which adapter to use and load it.
+        if @options[:rackup]
+          server.app = load_rackup_config
+        else
+          server.app = load_adapter
+        end
+
+        # If a prefix is required, wrap in Rack URL mapper
+        server.app = Rack::URLMap.new(@options[:prefix] => server.app) if @options[:prefix]
+
+        # If a stats URL is specified, wrap in Stats adapter
+        server.app = Stats::Adapter.new(server.app, @options[:stats]) if @options[:stats]
+
+        # Register restart procedure which just start another process with same options,
+        # so that's why this is done here.
+        server.on_restart { Command.run(:start, @options) }
+
+        server.start
+      end
+    
+      def stop
+        raise OptionRequired, :pid unless @options[:pid]
+      
+        tail_log(@options[:log]) do
+          if Server.kill(@options[:pid], @options[:force] ? 0 : (@options[:timeout] || 60))
+            wait_for_file :deletion, @options[:pid]
+          end
+        end
+      end
+    
+      def restart
+        raise OptionRequired, :pid unless @options[:pid]
+        
+        tail_log(@options[:log]) do
+          if Server.restart(@options[:pid])
+            wait_for_file :creation, @options[:pid]
+          end
+        end
+      end
+    
+      def config
+        config_file = @options.delete(:config) || raise(OptionRequired, :config)
+
+        # Stringify keys
+        @options.keys.each { |o| @options[o.to_s] = @options.delete(o) }
+
+        File.open(config_file, 'w') { |f| f << @options.to_yaml }
+        log_info "Wrote configuration to #{config_file}"
+      end
+      
+      protected
+        # Wait for a pid file to either be created or deleted.
+        def wait_for_file(state, file)
+          Timeout.timeout(@options[:timeout] || 30) do
+            case state
+            when :creation then sleep 0.1 until File.exist?(file)
+            when :deletion then sleep 0.1 while File.exist?(file)
+            end
+          end
+        end
+        
+        # Tail the log file of server +number+ during the execution of the block.        
+        def tail_log(log_file)
+          if log_file
+            tail_thread = tail(log_file)
+            yield
+            tail_thread.kill
+          else
+            yield
+          end
+        end
+        
+        # Acts like GNU tail command. Taken from Rails.
+        def tail(file)
+          cursor = File.exist?(file) ? File.size(file) : 0
+          last_checked = Time.now
+          tail_thread = Thread.new do
+            Thread.pass until File.exist?(file)
+            File.open(file, 'r') do |f|
+              loop do
+                f.seek cursor
+                if f.mtime > last_checked
+                  last_checked = f.mtime
+                  contents = f.read
+                  cursor += contents.length
+                  print contents
+                  STDOUT.flush
+                end
+                sleep 0.1
+              end
+            end
+          end
+          sleep 1 if File.exist?(file) # HACK Give the thread a little time to open the file
+          tail_thread
+        end
+
+      private
+        def load_adapter
+          adapter = @options[:adapter] || Rack::Adapter.guess(@options[:chdir])
+          log_info "Using #{adapter} adapter"
+          Rack::Adapter.for(adapter, @options)
+        rescue Rack::AdapterNotFound => e
+          raise InvalidOption, e.message
+        end
+        
+        def load_rackup_config
+          ENV['RACK_ENV'] = @options[:environment]
+          case @options[:rackup]
+          when /\.rb$/
+            Kernel.load(@options[:rackup])
+            Object.const_get(File.basename(@options[:rackup], '.rb').capitalize.to_sym)
+          when /\.ru$/
+            Rack::Adapter.load(@options[:rackup])
+          else
+            raise "Invalid rackup file.  please specify either a .ru or .rb file"
+          end
+        end
+    end
+  end
+end

data/thin-2.0.1/lib/thin/controllers/service.rb

@@ -0,0 +1,76 @@
+require 'erb'
+
+module Thin
+  module Controllers
+    # System service controller to launch all servers which
+    # config files are in a directory.
+    class Service < Controller
+      INITD_PATH          = File.directory?('/etc/rc.d') ? '/etc/rc.d/thin' : '/etc/init.d/thin'
+      DEFAULT_CONFIG_PATH = '/etc/thin'
+      TEMPLATE            = File.dirname(__FILE__) + '/service.sh.erb'
+    
+      def initialize(options)
+        super
+      
+        raise PlatformNotSupported, 'Running as a service only supported on Linux' unless Thin.linux?
+      end
+    
+      def config_path
+        @options[:all] || DEFAULT_CONFIG_PATH
+      end
+    
+      def start
+        run :start
+      end
+    
+      def stop
+        run :stop
+      end
+    
+      def restart
+        run :restart
+      end
+    
+      def install(config_files_path=DEFAULT_CONFIG_PATH)
+        if File.exist?(INITD_PATH)
+          log_info "Thin service already installed at #{INITD_PATH}"
+        else
+          log_info "Installing thin service at #{INITD_PATH} ..."
+          sh "mkdir -p #{File.dirname(INITD_PATH)}"
+          log_info "writing #{INITD_PATH}"        
+          File.open(INITD_PATH, 'w') do |f|
+            f << ERB.new(File.read(TEMPLATE)).result(binding)
+          end
+          sh "chmod +x #{INITD_PATH}" # Make executable
+        end
+      
+        sh "mkdir -p #{config_files_path}"
+
+        log_info ''
+        log_info "To configure thin to start at system boot:"
+        log_info "on RedHat like systems:"
+        log_info "  sudo /sbin/chkconfig --level 345 #{NAME} on"
+        log_info "on Debian-like systems (Ubuntu):"
+        log_info "  sudo /usr/sbin/update-rc.d -f #{NAME} defaults"
+        log_info "on Gentoo:"
+        log_info "  sudo rc-update add #{NAME} default"
+        log_info ''
+        log_info "Then put your config files in #{config_files_path}"
+      end
+    
+      private
+        def run(command)
+          Dir[config_path + '/*'].each do |config|
+            next if config.end_with?("~")
+            log_info "[#{command}] #{config} ..."
+            Command.run(command, :config => config, :daemonize => true)
+          end
+        end
+      
+        def sh(cmd)
+          log_info cmd
+          system(cmd)
+        end
+    end
+  end
+end

data/thin-2.0.1/lib/thin/controllers/service.sh.erb

@@ -0,0 +1,39 @@
+#!/bin/sh
+### BEGIN INIT INFO
+# Provides:          thin
+# Required-Start:    $local_fs $remote_fs
+# Required-Stop:     $local_fs $remote_fs
+# Default-Start:     2 3 4 5
+# Default-Stop:      S 0 1 6
+# Short-Description: thin initscript
+# Description:       thin
+### END INIT INFO
+
+# Original author: Forrest Robertson
+
+# Do NOT "set -e"
+
+DAEMON=<%= Command.script %>
+SCRIPT_NAME=<%= INITD_PATH %>
+CONFIG_PATH=<%= config_files_path %>
+
+# Exit if the package is not installed
+[ -x "$DAEMON" ] || exit 0
+
+case "$1" in
+  start)
+	$DAEMON start --all $CONFIG_PATH
+	;;
+  stop)
+	$DAEMON stop --all $CONFIG_PATH
+	;;
+  restart)
+	$DAEMON restart --all $CONFIG_PATH
+	;;
+  *)
+	echo "Usage: $SCRIPT_NAME {start|stop|restart}" >&2
+	exit 3
+	;;
+esac
+
+: