hayabusa 0.0.1

data/bin/hayabusa_fcgi.rb

@@ -0,0 +1,159 @@
+#!/usr/bin/ruby
+
+#This scripts start an appserver, executes a HTTP-request for every FCGI-request and terminates when FCGI terminates.
+#Good for programming appserver-supported projects that doesnt need threadding without running an appserver all the time.
+
+#It doesnt support shared threadding or objects because multiple instances in form of processes will be executed.
+
+#Its a bit slower because it needs to flush writes to the database at end of every request and re-read them on spawn, because multiple instances might be present.
+
+error_log_file = "/tmp/hayabusa_fcgi.log"
+
+begin
+  File.unlink(error_log_file) if File.exists?(error_log_file)
+rescue Errno::ENOENT
+  #ignore.
+end
+
+begin
+  require "rubygems"
+  require "knjrbfw"
+  require "fcgi"
+  require "fileutils"
+  require "#{File.dirname(Knj::Os.realpath(__FILE__))}/../lib/hayabusa.rb"
+  
+  #Spawn CGI-variable to emulate FCGI part.
+  cgi_tools = Hayabusa::Cgi_tools.new
+  
+  #We cant define the Hayabusa-server untuil we receive the first headers, so wait for the first request.
+  hayabusa = nil
+  fcgi_proxy = nil
+  
+  FCGI.each_cgi do |cgi|
+    begin
+      #cgi.print "Content-Type: text/html\r\n"
+      #cgi.print "\r\n"
+      
+      cgi_tools.cgi = cgi
+      
+      if !hayabusa
+        raise "No HTTP_HAYABUSA_FCGI_CONFIG-header was given." if !cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]
+        require cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]
+        
+        begin
+          conf = Hayabusa::FCGI_CONF
+        rescue NameError
+          raise "No 'Hayabusa::FCGI_CONF'-constant was spawned by '#{cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]}'."
+        end
+        
+        hayabusa_conf = Hayabusa::FCGI_CONF[:hayabusa]
+        hayabusa_conf.merge!(
+          :cmdline => false,
+          :port => 0 #Ruby picks random port and we get the actual port after starting the appserver.
+        )
+        
+        #Figure out if this should be a host-FCGI-process or a proxy-FCGI-process.
+        fcgi_config_fp = "#{Knj::Os.tmpdir}/hayabusa_fcgi_#{hayabusa_conf[:title]}_fcgi.conf"
+        FileUtils.touch(fcgi_config_fp) if !File.exists?(fcgi_config_fp)
+        
+        begin
+          File.open(fcgi_config_fp) do |fp|
+            fp.flock(File::LOCK_EX)
+            
+            fcgi_config_cont = File.read(fcgi_config_fp)
+            
+            if !fcgi_config_cont.empty?
+              fcgi_config = Marshal.load(File.read(fcgi_config_fp))
+              pid = fcgi_config[:pid]
+              
+              if Knj::Unix_proc.pid_running?(pid)
+                fcgi_proxy = fcgi_config
+                
+                require "http2"
+                http = Http2.new(:host => "localhost", :port => fcgi_proxy[:port].to_i)
+                fcgi_proxy[:http] = http
+              end
+            else
+              fcgi_config = nil
+            end
+            
+            if !fcgi_proxy
+              File.open(fcgi_config_fp, "w") do |fp|
+                hayabusa = Hayabusa.new(hayabusa_conf)
+                
+                #Start web-server for proxy-requests.
+                hayabusa.start
+                
+                fp.write(Marshal.dump(
+                  :pid => Process.pid,
+                  :port => hayabusa.port
+                ))
+              end
+            end
+          end
+        ensure
+          File.open(fcgi_config_fp).flock(File::LOCK_UN)
+        end
+      end
+      
+      
+      
+      if fcgi_proxy
+        #Proxy request to the host-FCGI-process.
+        cgi_tools.proxy_request_to(:cgi => cgi, :http => fcgi_proxy[:http])
+      else
+        #Host the FCGI-process.
+        
+        #Enforce $stdout variable.
+        $stdout = hayabusa.cio
+        
+        #The rest is copied from the FCGI-part.
+        headers = {}
+        cgi.env_table.each do |key, val|
+          if key[0, 5] == "HTTP_" and key != "HTTP_HAYABUSA_FCGI_CONFIG"
+            key = key[5, key.length].gsub("_", " ").gsub(" ", "-")
+            headers[key] = val
+          end
+        end
+        
+        meta = cgi.env_table.to_hash
+        
+        uri = Knj::Web.parse_uri(meta["REQUEST_URI"])
+        meta["PATH_TRANSLATED"] = File.basename(uri[:path])
+        
+        cgi_data = {
+          :cgi => cgi,
+          :headers => headers,
+          :get => Knj::Web.parse_urlquery(cgi.env_table["QUERY_STRING"], :urldecode => true, :force_utf8 => true),
+          :meta => meta
+        }
+        if cgi.request_method == "POST"
+          cgi_data[:post] = cgi_tools.convert_fcgi_post(cgi.params)
+        else
+          cgi_data[:post] = {}
+        end
+        
+        hayabusa.config[:cgi] = cgi_data
+        
+        
+        #Handle request.
+        hayabusa.start_cgi_request
+      end
+    rescue Exception => e
+      cgi.print "Content-Type: text/html\r\n"
+      cgi.print "\r\n"
+      cgi.print Knj::Errors.error_str(e, :html => true)
+      cgi.print Knj.p(cgi_data, true) if cgi_data
+    end
+  end
+rescue Exception => e
+  if !e.is_a?(Interrupt)
+    File.open(error_log_file, "w") do |fp|
+      fp.puts e.inspect
+      fp.puts e.backtrace
+      fp.puts ""
+    end
+  end
+  
+  raise e
+end

data/bin/knjappserver_start.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require "#{File.dirname(__FILE__)}/../lib/hayabusa.rb"
+
+knjrbfw_path = ""
+
+ARGV.each do |arg|
+  if arg == "--active_support"
+    ARGV.delete(arg)
+    require "active_support"
+    require "active_support/core_ext"
+  elsif match = arg.match(/--knjrbfw_path=(.+)/)
+    knjrbfw_path = match[1]
+    ARGV.delete(arg)
+  else
+    print "Unknown argument: '#{arg}'.\n"
+    exit
+  end
+end
+
+require "#{knjrbfw_path}knjrbfw"
+
+filepath = File.dirname(__FILE__) + "/../lib/"
+
+if File.exists?($0)
+  conf_path = File.dirname($0) + "/../"
+else
+  conf_path = File.dirname(__FILE__) + "/../"
+end
+
+require "#{conf_path}conf/conf_vars"
+require "#{$hayabusa_config["knjrbfw"]}knj/autoload"
+
+$hayabusa = {
+  :path => File.realpath(File.dirname(__FILE__))
+}
+
+Knj::Os.chdir_file(File.realpath(__FILE__))
+require "#{filepath}include/class_hayabusa.rb"
+
+print "Starting knjAppServer.\n"
+require "#{conf_path}conf/conf"

data/conf/apache2_cgi_rhtml_conf.conf

@@ -0,0 +1,10 @@
+Alias /hayabusa_cgi_test "/path/to/hayabusa/tests/cgi_test"
+ScriptAlias /hayabusa/ "/path/to/hayabusa/bin/"
+
+<Directory "/path/to/hayabusa/tests/cgi_test">
+  Options +FollowSymLinks +ExecCGI
+  RequestHeader set HAYABUSA_CGI_CONFIG "/path/to/hayabusa/tests/cgi_test/config_cgi.rb"
+  AddHandler application/x-hayabusa-cgi .rhtml
+  Action application/x-hayabusa-cgi /hayabusa/hayabusa_cgi.rb
+  DirectoryIndex index.cgi
+</Directory>

data/conf/apache2_fcgi_rhtml_conf.conf

@@ -0,0 +1,22 @@
+Alias /hayabusa_fcgi_test "/path/to/hayabusa/tests/fcgi_test"
+Alias /hayabusa_fcgi_bin "/path/to/hayabusa/bin"
+
+<IfModule mod_fcgid.c>
+  SocketPath /tmp/fcgi_socket
+  FcgidIdleTimeout 30
+  FcgidMinProcessesPerClass 0
+  FcgidIdleScanInterval 15
+</IfModule>
+
+<Directory "/path/to/hayabusa/tests/fcgi_test">
+  RewriteEngine On
+  RewriteRule ^(.*)\.rhtml$ /hayabusa_fcgi_bin/hayabusa_fcgi.fcgi
+  
+  Options +FollowSymLinks
+  
+  RequestHeader set HAYABUSA_FCGI_CONFIG "/path/to/hayabusa/tests/fcgi_test/config_fcgi.rb"
+  
+  AddHandler fcgid-script .fgci
+  
+  DirectoryIndex index.rhtml
+</Directory>

data/hayabusa.gemspec

@@ -0,0 +1,151 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{hayabusa}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Kasper Johansen"]
+  s.date = %q{2012-08-16}
+  s.description = %q{A threadded web/app-server that focuses on threadding, shared ressources, speed and more.}
+  s.email = %q{k@spernj.org}
+  s.executables = ["check_running.rb", "hayabusa_benchmark.rb", "hayabusa_cgi.rb", "hayabusa_fcgi.fcgi", "hayabusa_fcgi.rb", "knjappserver_start.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "bin/check_running.rb",
+    "bin/hayabusa_benchmark.rb",
+    "bin/hayabusa_cgi.rb",
+    "bin/hayabusa_fcgi.fcgi",
+    "bin/hayabusa_fcgi.rb",
+    "bin/knjappserver_start.rb",
+    "conf/apache2_cgi_rhtml_conf.conf",
+    "conf/apache2_fcgi_rhtml_conf.conf",
+    "hayabusa.gemspec",
+    "lib/hayabusa.rb",
+    "lib/hayabusa_cgi_session.rb",
+    "lib/hayabusa_cgi_tools.rb",
+    "lib/hayabusa_custom_io.rb",
+    "lib/hayabusa_database.rb",
+    "lib/hayabusa_erb_handler.rb",
+    "lib/hayabusa_ext/cleaner.rb",
+    "lib/hayabusa_ext/cmdline.rb",
+    "lib/hayabusa_ext/errors.rb",
+    "lib/hayabusa_ext/logging.rb",
+    "lib/hayabusa_ext/mailing.rb",
+    "lib/hayabusa_ext/sessions.rb",
+    "lib/hayabusa_ext/threadding.rb",
+    "lib/hayabusa_ext/threadding_timeout.rb",
+    "lib/hayabusa_ext/translations.rb",
+    "lib/hayabusa_ext/web.rb",
+    "lib/hayabusa_http_server.rb",
+    "lib/hayabusa_http_session.rb",
+    "lib/hayabusa_http_session_contentgroup.rb",
+    "lib/hayabusa_http_session_page_environment.rb",
+    "lib/hayabusa_http_session_post_multipart.rb",
+    "lib/hayabusa_http_session_request.rb",
+    "lib/hayabusa_http_session_response.rb",
+    "lib/hayabusa_models.rb",
+    "lib/kernel_ext/gettext_methods.rb",
+    "lib/kernel_ext/magic_methods.rb",
+    "lib/models/log.rb",
+    "lib/models/log_access.rb",
+    "lib/models/log_data.rb",
+    "lib/models/log_data_link.rb",
+    "lib/models/log_data_value.rb",
+    "lib/models/log_link.rb",
+    "lib/models/session.rb",
+    "pages/benchmark.rhtml",
+    "pages/benchmark_print.rhtml",
+    "pages/benchmark_simple.rhtml",
+    "pages/benchmark_threadded_content.rhtml",
+    "pages/debug_database_connections.rhtml",
+    "pages/debug_http_sessions.rhtml",
+    "pages/debug_memory_usage.rhtml",
+    "pages/error_notfound.rhtml",
+    "pages/logs_latest.rhtml",
+    "pages/logs_show.rhtml",
+    "pages/spec.rhtml",
+    "pages/spec_post.rhtml",
+    "pages/spec_test_multiple_clients.rhtml",
+    "pages/spec_thread_joins.rhtml",
+    "pages/spec_threadded_content.rhtml",
+    "pages/tests.rhtml",
+    "spec/cgi_spec.rb",
+    "spec/custom_urls_spec.rb",
+    "spec/fcgi_multiple_processes_spec.rb",
+    "spec/fcgi_spec.rb",
+    "spec/hayabusa_spec.rb",
+    "spec/spec_helper.rb",
+    "tests/cgi_test/config_cgi.rb",
+    "tests/cgi_test/threadded_content_test.rhtml",
+    "tests/cgi_test/vars_get_test.rhtml",
+    "tests/cgi_test/vars_header_test.rhtml",
+    "tests/cgi_test/vars_post_test.rhtml",
+    "tests/fcgi_test/config_fcgi.rb",
+    "tests/fcgi_test/index.rhtml",
+    "tests/fcgi_test/sleeper.rhtml",
+    "tests/fcgi_test/threadded_content_test.rhtml",
+    "tests/fcgi_test/vars_get_test.rhtml",
+    "tests/fcgi_test/vars_header_test.rhtml",
+    "tests/fcgi_test/vars_post_test.rhtml"
+  ]
+  s.homepage = %q{http://github.com/kaspernj/hayabusa}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{A threadded web/app-server that supports stand-alone, CGI and FCGI-modes.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<knjrbfw>, [">= 0"])
+      s.add_runtime_dependency(%q<erubis>, [">= 0"])
+      s.add_runtime_dependency(%q<mail>, [">= 0"])
+      s.add_runtime_dependency(%q<datet>, [">= 0"])
+      s.add_runtime_dependency(%q<http2>, [">= 0"])
+      s.add_development_dependency(%q<json>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.3"])
+      s.add_development_dependency(%q<sqlite3>, [">= 0"])
+    else
+      s.add_dependency(%q<knjrbfw>, [">= 0"])
+      s.add_dependency(%q<erubis>, [">= 0"])
+      s.add_dependency(%q<mail>, [">= 0"])
+      s.add_dependency(%q<datet>, [">= 0"])
+      s.add_dependency(%q<http2>, [">= 0"])
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.3"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<knjrbfw>, [">= 0"])
+    s.add_dependency(%q<erubis>, [">= 0"])
+    s.add_dependency(%q<mail>, [">= 0"])
+    s.add_dependency(%q<datet>, [">= 0"])
+    s.add_dependency(%q<http2>, [">= 0"])
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, [">= 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.3"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+  end
+end
+

data/lib/hayabusa.rb

@@ -0,0 +1,518 @@
+require "base64"
+require "digest"
+require "stringio"
+require "timeout"
+
+#The class that stands for the whole appserver / webserver.
+#===Examples
+# appsrv = Hayabusa.new(
+#   :locales_root => "/some/path/locales",
+#   :locales_gettext_funcs => true,
+#   :magic_methods => true
+# )
+# appsrv.start
+# appsrv.join
+class Hayabusa
+  @@path = File.dirname(__FILE__)
+  
+  attr_reader :cio, :config, :httpserv, :debug, :db, :db_handler, :ob, :translations, :paused, :should_restart, :events, :mod_event, :db_handler, :gettext, :sessions, :logs_access_pending, :threadpool, :vars, :magic_procs, :magic_vars, :types, :eruby_cache, :httpsessions_ids
+  attr_accessor :served, :should_restart, :should_restart_done
+  
+  #Autoloader for subclasses.
+  def self.const_missing(name)
+    require "#{File.dirname(__FILE__)}/hayabusa_#{name.to_s.downcase}.rb"
+    return Hayabusa.const_get(name)
+  end
+  
+  def initialize(config)
+    raise "No arguments given." if !config.is_a?(Hash)
+    
+    @config = {
+      :host => "0.0.0.0",
+      :timeout => 30,
+      :default_page => "index.rhtml",
+      :default_filetype => "text/html",
+      :max_requests_working => 20,
+      :size_send => 1024,
+      :cleaner_timeout => 300
+    }.merge(config)
+    
+    @config[:smtp_args] = {"smtp_host" => "localhost", "smtp_port" => 25} if !@config[:smtp_args]
+    @config[:timeout] = 30 if !@config.has_key?(:timeout)
+    raise "No ':doc_root' was given in arguments." if !@config.has_key?(:doc_root)
+    
+    
+    #Require gems.
+    require "rubygems"
+    gems = [
+      [:Erubis, "erubis"],
+      [:Knj, "knjrbfw"],
+      [:Tsafe, "tsafe"]
+    ]
+    
+    gems.each do |gem|
+      if Kernel.const_defined?(gem[0])
+        puts "Gem already loaded: '#{gem[1]}'." if @debug
+        next
+      end
+      
+      fpath = "#{@@path}/../../#{gem[1]}/lib/#{gem[1]}.rb"
+      
+      if File.exists?(fpath)
+        puts "Loading custom gem-path: '#{fpath}'." if @debug
+        require fpath
+      else
+        puts "Loading gem: '#{gem[1]}'." if @debug
+        require gem[1]
+      end
+    end
+    
+    
+    #Setup default handlers if none are given.
+    if !@config.has_key?(:handlers)
+      @erb_handler = Hayabusa::Erb_handler.new
+      @config[:handlers] = [
+        {
+          :file_ext => "rhtml",
+          :callback => @erb_handler.method(:erb_handler)
+        },{
+          :path => "/fckeditor",
+          :mount => "/usr/share/fckeditor"
+        }
+      ]
+    end
+    
+    
+    #Add extra handlers if given.
+    @config[:handlers] += @config[:handlers_extra] if @config[:handlers_extra]
+    
+    
+    #Setup cache to make .rhtml-calls faster.
+    @config[:handlers_cache] = {}
+    @config[:handlers].each do |handler_info|
+      next if !handler_info[:file_ext] or !handler_info[:callback]
+      @config[:handlers_cache][handler_info[:file_ext]] = handler_info[:callback]
+    end
+    
+    
+    @debug = @config[:debug]
+    @paused = 0
+    @paused_mutex = Mutex.new
+    @should_restart = false
+    @mod_events = {}
+    @served = 0
+    @mod_files = {}
+    @sessions = {}
+    @eruby_cache = {}
+    @httpsessions_ids = {}
+    
+    @path_hayabusa = File.dirname(__FILE__)
+    
+    
+    #If auto-restarting is enabled - start the modified events-module.
+    if @config[:autorestart]
+      paths = [
+        "#{@path_hayabusa}/class_customio.rb"
+      ]
+      
+      print "Auto restarting.\n" if @debug
+      @mod_event = Knj::Event_filemod.new(:wait => 2, :paths => paths, &self.method(:on_event_filemod))
+    end
+    
+    
+    #Set up default file-types and merge given filetypes into it.
+    @types = {
+      :ico => "image/x-icon",
+      :jpeg => "image/jpeg",
+      :jpg => "image/jpeg",
+      :gif => "image/gif",
+      :png => "image/png",
+      :html => "text/html",
+      :htm => "text/html",
+      :rhtml => "text/html",
+      :css => "text/css",
+      :xml => "text/xml",
+      :js => "text/javascript"
+    }
+    @types.merge!(@config[:filetypes]) if @config.key?(:filetypes)
+    
+    
+    
+    #Load various required files in the hayabusa-framework.
+    files = [
+      "#{@path_hayabusa}/hayabusa_ext/errors.rb",
+      "#{@path_hayabusa}/hayabusa_ext/logging.rb",
+      "#{@path_hayabusa}/hayabusa_ext/mailing.rb",
+      "#{@path_hayabusa}/hayabusa_ext/sessions.rb",
+      "#{@path_hayabusa}/hayabusa_ext/translations.rb",
+      "#{@path_hayabusa}/hayabusa_ext/web.rb"
+    ]
+    
+    files.each do |file|
+      STDOUT.print "Loading: '#{file}'.\n" if @debug
+      self.loadfile(file)
+    end
+    
+    
+    print "Setting up database.\n" if @debug
+    if @config[:db].is_a?(Knj::Db)
+      @db = @config[:db]
+    elsif @config[:db].is_a?(Hash)
+      @db = Knj::Db.new(@config[:db])
+    elsif !@config[:db] and @config[:db_args]
+      @db = Knj::Db.new(@config[:db_args])
+    else
+      if @config[:title]
+        db_title = @config[:title]
+      else
+        db_title = Time.now.to_f.to_s.hash
+      end
+      
+      db_path = "#{Knj::Os.tmpdir}/hayabusa_fallback_db_#{db_title}.sqlite3"
+      @config[:dbrev] = true
+      
+      require "sqlite3" if RUBY_ENGINE != "jruby"
+      @db = Knj::Db.new(
+        :type => "sqlite3",
+        :path => db_path,
+        :return_keys => "symbols",
+        :index_append_table_name => true
+      )
+    end
+    
+    
+    if !@config.key?(:dbrev) or @config[:dbrev]
+      print "Updating database.\n" if @debug
+      dbrev_args = {"schema" => Hayabusa::Database::SCHEMA, "db" => @db}
+      dbrev_args.merge!(@config[:dbrev_args]) if @config.key?(:dbrev_args)
+      Knj::Db::Revision.new.init_db(dbrev_args)
+      dbrev_args = nil
+    end
+    
+    
+    print "Spawning objects.\n" if @debug
+    @ob = Knj::Objects.new(
+      :db => db,
+      :class_path => @path_hayabusa,
+      :module => Hayabusa::Models,
+      :datarow => true,
+      :hayabusa => self,
+      :require => false
+    )
+    @ob.events.connect(:no_date, &self.method(:no_date))
+    
+    
+    if @config[:httpsession_db_args]
+      @db_handler = Knj::Db.new(@config[:httpsession_db_args])
+    else
+      @db_handler = @db
+    end
+    
+    
+    if @config[:locales_root]
+      @gettext = Knj::Gettext_threadded.new("dir" => config[:locales_root])
+    end
+    
+    require "#{@path_hayabusa}/kernel_ext/gettext_methods" if @config[:locales_gettext_funcs]
+    
+    if @config[:magic_methods] or !@config.has_key?(:magic_methods)
+      print "Loading magic-methods.\n" if @debug
+      require "#{@path_hayabusa}/kernel_ext/magic_methods"
+    end
+    
+    if @config[:customio] or !@config.has_key?(:customio)
+      print "Loading custom-io.\n" if @debug
+      
+      if $stdout.class.name != "Hayabusa::Custom_io"
+        @cio = Hayabusa::Custom_io.new
+        $stdout = @cio
+      end
+    end
+    
+    
+    #Save the PID to the run-file.
+    print "Setting run-file.\n" if @debug
+    tmpdir = "#{Knj::Os.tmpdir}/hayabusa"
+    tmppath = "#{tmpdir}/run_#{@config[:title]}"
+    
+    if !File.exists?(tmpdir)
+      Dir.mkdir(tmpdir)
+      File.chmod(0777, tmpdir)
+    end
+    
+    File.open(tmppath, "w") do |fp|
+      fp.write(Process.pid)
+    end
+    File.chmod(0777, tmppath)
+    
+    
+    #Set up various events for the appserver.
+    if !@config.key?(:events) or @config[:events]
+      print "Loading events.\n" if @debug
+      @events = Knj::Event_handler.new
+      @events.add_event(
+        :name => :check_page_access,
+        :connections_max => 1
+      )
+      @events.add_event(
+        :name => :ob,
+        :connections_max => 1
+      )
+      @events.add_event(
+        :name => :trans_no_str,
+        :connections_max => 1
+      )
+      @events.add_event(
+        :name => :request_done,
+        :connections_max => 1
+      )
+      @events.add_event(
+        :name => :request_begin,
+        :connections_max => 1
+      )
+      
+      #This event is used if the user himself wants stuff to be cleaned up when the appserver is cleaning up stuff.
+      @events.add_event(
+        :name => :on_clean
+      )
+    end
+    
+    #Set up the 'vars'-variable that can be used to set custom global variables for web-requests.
+    @vars = Knj::Hash_methods.new
+    @magic_vars = {}
+    @magic_procs = {}
+    
+    
+    #Initialize the various feature-modules.
+    print "Init sessions.\n" if @debug
+    self.initialize_sessions
+    
+    if !@config.key?(:threadding) or @config[:threadding]
+      self.loadfile("#{@path_hayabusa}/hayabusa_ext/threadding.rb")
+      self.loadfile("#{@path_hayabusa}/hayabusa_ext/threadding_timeout.rb")
+      print "Init threadding.\n" if @debug
+      self.initialize_threadding
+    end
+    
+    print "Init mailing.\n" if @debug
+    self.initialize_mailing
+    
+    print "Init errors.\n" if @debug
+    self.initialize_errors
+    
+    print "Init logging.\n" if @debug
+    self.initialize_logging
+    
+    if !@config.key?(:cleaner) or @config[:cleaner]
+      self.loadfile("#{@path_hayabusa}/hayabusa_ext/cleaner.rb")
+      print "Init cleaner.\n" if @debug
+      self.initialize_cleaner
+    end
+    
+    if !@config.key?(:cmdline) or @config[:cmdline]
+      self.loadfile("#{@path_hayabusa}/hayabusa_ext/cmdline.rb")
+      print "Init cmdline.\n" if @debug
+      self.initialize_cmdline
+    end
+    
+    
+    #Clear memory at exit.
+    Kernel.at_exit(&self.method(:stop))
+    
+    
+    print "Appserver spawned.\n" if @debug
+  end
+  
+  def no_date(event, classname)
+    return "[no date]"
+  end
+  
+  def on_event_filemod(event, path)
+    print "File changed - restart server: #{path}\n"
+    @should_restart = true
+    @mod_event.destroy if @mod_event
+  end
+  
+  #If you want to use auto-restart, every file reloaded through loadfile will be watched for changes. When changed the server will do a restart to reflect that.
+  def loadfile(fpath)
+    if !@config[:autorestart]
+      require fpath
+      return nil
+    end
+    
+    rpath = File.realpath(fpath)
+    raise "No such filepath: #{fpath}" if !rpath or !File.exists?(rpath)
+    
+    return true if @mod_files[rpath]
+    
+    @mod_event.args[:paths] << rpath
+    @mod_files = rpath
+    
+    require rpath
+    return false
+  end
+  
+  #Start a new CGI-request.
+  def start_cgi_request
+    @cgi_http_session = Hayabusa::Cgi_session.new(:hb => self)
+  end
+  
+  #Starts the HTTP-server and threadpool.
+  def start
+    #Start the appserver.
+    print "Spawning appserver.\n" if @debug
+    @httpserv = Hayabusa::Http_server.new(self)
+    
+    
+    STDOUT.print "Starting appserver.\n" if @debug
+    Thread.current[:hayabusa] = {:hb => self} if !Thread.current[:hayabusa]
+    
+    if @config[:autoload]
+      STDOUT.print "Autoloading #{@config[:autoload]}\n" if @debug
+      require @config[:autoload]
+    end
+    
+    begin
+      @threadpool.start if @threadpool
+      STDOUT.print "Threadpool startet.\n" if @debug
+      @httpserv.start
+      STDOUT.print "Appserver startet.\n" if @debug
+    rescue Interrupt => e
+      STDOUT.print "Got interrupt - trying to stop appserver.\n" if @debug
+      self.stop
+      raise e
+    end
+  end
+  
+  #Stops the entire app and releases join.
+  def stop
+    return nil if @stop_called
+    @stop_called = true
+    
+    proc_stop = proc{
+      STDOUT.print "Stopping appserver.\n" if @debug
+      @httpserv.stop if @httpserv and @httpserv.respond_to?(:stop)
+      
+      STDOUT.print "Stopping threadpool.\n" if @debug
+      @threadpool.stop if @threadpool
+      
+      #This should be done first to be sure it finishes (else we have a serious bug).
+      STDOUT.print "Flush out loaded sessions.\n" if @debug
+      self.sessions_flush
+      
+      STDOUT.print "Stopping done...\n" if @debug
+    }
+    
+    #If we cant get a paused-execution in 5 secs - we just force the stop.
+    begin
+      Timeout.timeout(5) do
+        self.paused_exec(&proc_stop)
+      end
+    rescue Timeout::Error, SystemExit, Interrupt
+      STDOUT.print "Forcing stop-appserver - couldnt get timing window.\n" if @debug
+      proc_stop.call
+    end
+  end
+  
+  #Stop running any more HTTP-requests - make them wait.
+  def pause
+    @paused += 1
+  end
+  
+  #Unpause - start handeling HTTP-requests again.
+  def unpause
+    @paused -= 1
+  end
+  
+  #Returns true if paued - otherwise false.
+  def paused?
+    return true if @paused > 0
+    return false
+  end
+  
+  #Will stop handeling any more HTTP-requests, run the proc given and return handeling HTTP-requests.
+  def paused_exec
+    raise "No block given." if !block_given?
+    self.pause
+    
+    begin
+      sleep 0.2 while @httpserv and @httpserv.working_count and @httpserv.working_count > 0
+      @paused_mutex.synchronize do
+        Timeout.timeout(15) do
+          yield
+        end
+      end
+    ensure
+      self.unpause
+    end
+  end
+  
+  #Returns true if a HTTP-request is working. Otherwise false.
+  def working?
+    return true if @httpserv and @httpserv.working_count > 0
+    return false
+  end
+  
+  def self.data
+    raise "Could not register current thread." if !Thread.current[:hayabusa]
+    return Thread.current[:hayabusa]
+  end
+  
+  #Sleeps until the server is stopped.
+  def join
+    raise "No http-server or http-server not running." if !@httpserv or !@httpserv.thread_accept
+    
+    begin
+      @httpserv.thread_accept.join
+      @httpserv.thread_restart.join if @httpserv and @httpserv.thread_restart
+    rescue Interrupt => e
+      self.stop
+    end
+    
+    if @should_restart
+      loop do
+        if @should_restart_done
+          STDOUT.print "Ending join because the restart is done.\n"
+          break
+        end
+        
+        sleep 1
+      end
+    end
+  end
+  
+  #Defines a variable as a method bound to the threads spawned by this instance of Hayabusa.
+  def define_magic_var(method_name, var)
+    @magic_vars[method_name] = var
+    
+    if !Object.respond_to?(method_name)
+      Object.send(:define_method, method_name) do
+        return Thread.current[:hayabusa][:hb].magic_vars[method_name] if Thread.current[:hayabusa] and Thread.current[:hayabusa][:hb]
+        raise "Could not figure out the object: '#{method_name}'."
+      end
+    end
+  end
+  
+  def define_magic_proc(method_name, &block)
+    raise "No block given." if !block_given?
+    @magic_procs[method_name] = block
+    
+    if !Object.respond_to?(method_name)
+      Object.send(:define_method, method_name) do
+        return Thread.current[:hayabusa][:hb].magic_procs[method_name].call(:hb => self) if Thread.current[:hayabusa] and Thread.current[:hayabusa][:hb]
+        raise "Could not figure out the object: '#{method_name}'."
+      end
+    end
+  end
+  
+  def translations
+    if !@translations
+      #Start the Knj::Gettext_threadded- and Knj::Translations modules for translations.
+      print "Loading Gettext and translations.\n" if @debug
+      @translations = Knj::Translations.new(:db => @db)
+      @ob.requireclass(:Translation, :require => false, :class => Knj::Translations::Translation)
+    end
+    
+    return @translations
+  end
+end