nitro 0.29.0 → 0.30.0

data/Rakefile

@@ -1,232 +0,0 @@
-require 'rake/rdoctask'
-require 'rake/testtask'
-require 'rake/gempackagetask'
-
-# Initialize some variables.
-
-readme = File.read('README')
-Release = (readme[/^= (.+) README$/, 1] || 'unknown').downcase.tr(" ", "-")
-Name = Release[/\D+/].sub(/\-+$/, '') || 'unknown'
-Version = Release[/[\d.]+/] || 'unknown'
-
-AuthorName, AuthorMail = 'George Moschovitis', 'gm@navel.gr'
-RubyVersion = '1.8.3' 
-
-# Description = (readme[/README\s+(.+?)\n\n/m, 1] || "unknown").gsub(/\s+/, " ")
-# Summary = Description[/^.+?>/] || "unknown"
-
-# DocFiles = %w(README NEWS TODO COPYING GPL)
-# RDocFiles = DocFiles - %w(GPL)
-RDocOpts = ["--inline-source", "--line-numbers","--title", Name ]
-# AdditionalFiles = DocFiles + %w(setup.rb)
-VersionFile = MainFile = File.join("lib", Name + '.rb')
-
-RubyForgeProject = Name
-RubyForgeUser = 'gmosx'
-Homepage = "http://www.nitrohq.org/"
-
-task :default => :package
-
-$NITRO_NO_ENVIRONMENT = true
-
-# Run the tests.
-
-Rake::TestTask.new do |t|
-  cwd = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-  t.libs << 'test'
-  %w[glue nitro og].each do |dir|
-    t.libs << File.join(cwd, dir, 'lib')
-  end
-  t.test_files = FileList['test/**/tc*.rb']
-  t.verbose = true
-end
-
-# Generate RDoc documentation.
-
-Rake::RDocTask.new do |rd|
-  rd.main = 'README'
-  rd.rdoc_dir = 'rdoc'
-  rd.rdoc_files.include('README', 'INSTALL', 'doc/RELEASES', 'lib/**/*.rb')
-  rd.options << '--all --inline-source'
-end
-
-# Build gem.
-
-spec = Gem::Specification.new do |s|
-  s.name = 'nitro'
-  if File.read('lib/nitro.rb') =~ /Version\s+=\s+'(\d+\.\d+\.\d+)'/
-    s.version = $1 
-  else
-    raise 'No version found'
-  end
-  s.summary = 'Nitro Web Engine'
-  s.description = 
-    'Nitro provides everything you need to develop real-world, scalable ' +
-    'web applications.'
-
-  s.add_dependency 'glue', "= #{s.version}"
-  s.add_dependency 'og', "= #{s.version}"
-  s.add_dependency 'gen', "= #{s.version}"
-  s.add_dependency 'ruby-breakpoint', '= 0.5'
-  s.add_dependency 'RedCloth', '= 3.0.3'
-
-  s.required_ruby_version = '= 1.8.3'
-
-  s.files = FileList[
-    '[A-Z]*', 'setup.rb', '{bin,benchmark,examples,doc,proto,lib,test,vendor}/**/*' 
-  ].exclude("_darcs").exclude("_darcs/**/*").exclude('*.og').exclude('**/*.log').to_a
-
-  s.require_path = 'lib'
-  s.autorequire = 'nitro'
-  
-  s.has_rdoc = true
-  s.extra_rdoc_files = FileList['[A-Z]*'].to_a
-  s.rdoc_options << '--main' << 'README' << '--title' << 'Nitro Documentation'
-  s.rdoc_options << '--all' << '--inline-source'
-
-  s.test_files = []
-  
-  s.bindir = 'bin'
-  s.executables = ['nitro', 'nitrogen']
-  s.default_executable = 'nitro'
-
-  s.author = 'George Moschovitis'
-  s.email = 'gm@navel.gr'
-  s.homepage = 'http://www.nitrohq.com'
-  s.rubyforge_project = 'nitro'
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.package_dir = 'dist'
-  pkg.need_zip = true
-  pkg.need_tar = true
-end
-
-# Manual install (not recommended).
-
-task :install do
-  ruby 'install.rb'
-end
-
-# Release files to Rubyforge.
-# The code for this task provided by Florian Gross.
-
-desc "Publish the release files to RubyForge."
-task :publish => [:package] do
-  files = ['gem', 'tgz', 'zip'].map { |ext| "dist/#{Release}.#{ext}" }
-
-  if RubyForgeProject then
-    require 'net/http'
-    require 'open-uri'
-
-    changes = ''
-    if File.exist?('doc/RELEASES') then
-      changes_re = /^== \s+ Version \s+ #{Regexp.quote(Version)} \s*
-                    (.+?) (?:==|\Z)/mx
-      changes = File.read('doc/RELEASES')[changes_re, 1] || ''
-    end
-
-    project_uri = "http://rubyforge.org/projects/#{RubyForgeProject}/"
-    project_data = open(project_uri) { |data| data.read }
-    group_id = project_data[/[?&]group_id=(\d+)/, 1]
-    raise "Couldn't get group id" unless group_id
-
-    print "#{RubyForgeUser}@rubyforge.org's password: "
-    password = STDIN.gets.chomp
-
-    login_response = Net::HTTP.start('rubyforge.org', 80) do |http|
-      data = [
-        "login=1",
-        "form_loginname=#{RubyForgeUser}",
-        "form_pw=#{password}"
-      ].join("&")
-      http.post('/account/login.php', data)
-    end
-
-    cookie = login_response['set-cookie']
-    raise 'Login failed' unless cookie
-    headers = { 'Cookie' => cookie }
-
-    release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"
-    release_data = open(release_uri, headers) { |data| data.read }
-    package_id = release_data[/[?&]package_id=(\d+)/, 1]
-    raise "Couldn't get package id" unless package_id
-
-    first_file = true
-    release_id = ""
-
-    files.each do |filename|
-      basename = File.basename(filename)
-      file_ext = File.extname(filename)
-      file_data = File.open(filename, "rb") { |file| file.read }
-
-      puts "Releasing #{basename}..."
-
-      release_response = Net::HTTP.start('rubyforge.org', 80) do |http|
-        release_date = Time.now.strftime('%Y-%m-%d %H:%M')
-        type_map = {
-          '.zip'    => '3000',
-          '.tgz'    => '3110',
-          '.gz'     => '3110',
-          '.gem'    => '1400',
-          '.md5sum' => '8100'
-        }; type_map.default = '9999'
-        type = type_map[file_ext]
-        boundary = 'rubyqMY6QN9bp6e4kS21H4y0zxcvoor'
-
-        query_hash = if first_file then
-          {
-            'group_id' => group_id,
-            'package_id' => package_id,
-            'release_name' => Release,
-            'release_date' => release_date,
-            'type_id' => type,
-            'processor_id' => '8000', # Any
-            'release_notes' => '',
-            'release_changes' => changes,
-            'preformatted' => '1',
-            'submit' => '1'
-          }
-        else
-          {
-            'group_id' => group_id,
-            'release_id' => release_id,
-            'package_id' => package_id,
-            'step2' => '1',
-            'type_id' => type,
-            'processor_id' => '8000', # Any
-            'submit' => 'Add This File'
-          }
-        end
-
-        query = '?' + query_hash.map do |(name, value)|
-          [name, URI.encode(value)].join('=')
-        end.join('&')
-
-        data = [
-          "--" + boundary,
-          "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",
-          "Content-Type: application/octet-stream",
-          "Content-Transfer-Encoding: binary",
-          "", file_data, ""
-          ].join("\x0D\x0A")
-
-        release_headers = headers.merge(
-          'Content-Type' => "multipart/form-data; boundary=#{boundary}"
-        )
-
-        target = first_file ? '/frs/admin/qrs.php' : '/frs/admin/editrelease.php'
-        http.post(target + query, data, release_headers)
-      end
-
-      if first_file then
-        release_id = release_response.body[/release_id=(\d+)/, 1]
-        raise("Couldn't get release id") unless release_id
-      end
-
-      first_file = false
-    end
-  end
-end
-
-# * George Moschovitis  <gm@navel.gr>

data/lib/nitro/adapter/acgi.rb

@@ -1,237 +0,0 @@
-require 'cgi'
-require 'posixlock'
-
-STDOUT.sync = STDERR.sync = true
-$VERBOSE = nil
-
-require 'nitro/context'
-require 'nitro/dispatcher'
-require 'nitro/cgi'
-
-# Speeds things up, more comaptible with OSX.
-
-Socket.do_not_reverse_lookup = true
-
-# No multi-threading.
-
-Og.thread_safe = false if defined?(Og) and Og.respond_to?(:thread_safe)
-
-module Nitro
-
-# ACGI Adaptor. ACGI is a language independent, 
-# scalable, open extension to CGI that provides high 
-# performance without the limitations of server 
-# specific APIs.
-#
-# This code is directly from the author. Please go to
-# http://codeforpeople.com/lib/ruby/acgi/ for more
-# information about ACGI.
-# or email: ara [dot] t [dot] howard [at] noaa [dot] gov
-#
-# It uses a compiled C cgi program to handle
-# connections compile the acgi.c by executing
-# "make -f Makefile.acgi" in your public/ folder.
-# then make your .htaccess redirect all calls to acgi.cgi
-# instead of fcgi.rb / cgi.rb
-#
-#--
-# gmosx: not tested! Use at your own risk!
-#++
-
-class ACGI < ::CGI
-  THIS                    = File::expand_path $0 
-  COMMAND_LINE            = [THIS, ARGV].join ' '
-  LOADED                  = Time::now
-  IPC_DIR                 = "/tmp/acgi_ipc"
-  CLIENT_LOCK_PATH        = File::join IPC_DIR, "client.lock"
-  SERVER_LOCK_PATH        = File::join IPC_DIR, "server.lock"
-  SERVER_ENVIRONMENT_PATH = File::join IPC_DIR, "server.environment"
-  SERVER_STDIN_PATH       = File::join IPC_DIR, "server.stdin"
-  SERVER_STDOUT_PATH      = File::join IPC_DIR, "server.stdout"
-  SERVER_STDERR_PATH      = File::join IPC_DIR, "server.stderr"
-  SERVER_PID_PATH         = File::join IPC_DIR, "server.pid"
-
-  RE_ENV                  = %r/^ ([^=]+) = (.*) $/ox
-  RE_NUL                  = %r/#{ Regexp::escape "\0" }/ox
-
-  SERVER                  = ENV['ACGI_SERVER'] || ARGV.delete('--server') || ARGV.delete('-s')
-
-  if SERVER
-    trap('HUP'){ exec ::ACGI::COMMAND_LINE }
-    %w( INT KILL TERM ).each{|s| trap(s){ exit }}
-  end
-
-  class << self
-    def each_cgi(*a, &b)
-      if SERVER
-        start_server(*a, &b)
-      else
-        munge_environment
-        @cgi = new(*a)
-        catching_errors{ b[ @cgi ] }
-      end
-    end
-    
-    def start_server(*a, &b)
-      daemon do
-        ENV.clear # __very__ important for speed!
-        aquire_server_lock
-        record_pid
-        loop do
-          load_environment
-          munge_environment
-          @cgi = redirecting_stdin{ new(*a) }
-          redirecting_stdout_and_stderr{ catching_errors{ b[ @cgi ] }}
-          restart_if_updated
-        end
-      end
-    end
-    
-    def restart_if_updated
-      # put the full path to your run.rb here if it doesn't work
-      #th = "/path/to/app/run.rb"
-      if File::stat(THIS).mtime > LOADED
-      #if File::stat(th).mtime > LOADED
-        exec COMMAND_LINE
-      end
-    end
-    
-    def aquire_server_lock
-      lockfile = File.open(SERVER_LOCK_PATH)
-      lockfile.reopen(SERVER_LOCK_PATH, 'w')
-      at_exit{ lockfile.close }
-      ret = lockfile.posixlock(File::LOCK_EX|File::LOCK_NB)
-      
-      raise("#{ File::basename $0 } already running..") if(!ret or !ret.zero?)
-    end
-    
-    def record_pid
-      begin
-        f = File::open(SERVER_PID_PATH)
-        f.reopen(SERVER_PID_PATH, 'w')
-        f.print Process::pid
-        f.chmod 0777 rescue nil
-      ensure
-        f.close
-      end
-    end
-    
-    def env_table
-      SERVER ? (@environment ||= {}) : ENV
-    end
-    
-    def env
-      env_table
-    end
-    
-    def load_environment
-      begin
-        f = File::open(SERVER_ENVIRONMENT_PATH)
-        f.reopen(SERVER_ENVIRONMENT_PATH, "r")
-        env_table.clear
-        kvs = f.read.chop.split RE_NUL 
-        kvs.each do |kv| 
-          m = RE_ENV.match(kv)
-          k, v = m[1], m[2]
-          env_table[k] = v 
-        end
-      ensure
-        f.close
-      end
-    end
-    
-    def munge_environment  # because CGI::Cookie::parse is broken!
-      env_table['HTTP_COOKIE'] = 
-        munge_http_cookie env_table['HTTP_COOKIE']
-    end
-    
-    def munge_http_cookie http_cookie
-      return unless http_cookie
-      kvs = http_cookie.split %r/[;,]\s+/o
-      h = Hash::new{|h,k| h[k] = []} 
-      kvs.each do |kv|
-        k, v = kv.split %r/=/o, 2 
-        next unless k
-        k = CGI::unescape k
-        vs = v.to_s.split(%r/&/).map{|v| CGI::unescape v}
-        h[k].push(*vs)
-      end
-      h.sort.map{|k,vs| [k, vs.join('&')].join('=')}.join('; ')
-    end
-    
-    def redirecting_stdin
-      stdin = $stdin
-      begin
-        @stdin = File::open(SERVER_STDIN_PATH)
-        @stdin.reopen(SERVER_STDIN_PATH, "r")
-        $stdin = @stdin
-        yield
-      ensure
-        @stdin.close if @stdin
-        $stdin = stdin
-      end
-    end
-    
-    def redirecting_stdout_and_stderr
-      stdout, stderr = $stdout, $stderr
-      begin
-        @stdout = File::open(SERVER_STDOUT_PATH)
-        @stdout.reopen(SERVER_STDOUT_PATH, "w")
-        @stderr = File::open(SERVER_STDERR_PATH)
-        @stderr.reopen(SERVER_STDERR_PATH, "w")
-        $stdout, $stderr = @stdout, @stderr
-        yield
-      ensure
-        @stdout.close if @stdout
-        @stderr.close if @stderr
-        $stdout, $stderr = stdout, stderr
-      end
-    end
-    
-    def catching_errors
-      @cgi ||= CGI::new
-      begin
-        yield
-      rescue Exception => e
-        m, c, b = e.message, e.class, e.backtrace.join("<br>\n")
-        @cgi.out{ "<hr><b><i>#{ m } (#{ c })</b></i><hr><hr>#{ b }" }
-      end
-    end
-    
-    def daemon
-      exit!(0) if fork
-      Process::setsid
-      exit!(0) if fork
-      # Dir::chdir("/")
-      # File::umask(0)
-      
-      # uncomment these if you don't want logs
-      #STDIN.reopen("/dev/null")
-      #STDOUT.reopen("/dev/null", "w")
-      #STDERR.reopen("/dev/null", "w")
-      yield if block_given?
-    end
-  end
-
-  def env_table
-    self::class.env_table
-  end
-  def env
-    self::class.env
-  end
-  
-  # use this to start the ACGI server.
-  
-  def self.start(server)
-    ACGI.each_cgi do |cgi|
-      begin
-        Cgi.process(server, cgi, $stdin, $stdout)
-      end
-    end
-  end
-
-end
-
-end
-
-# * Ara Howard <ara.t.howard@noaa.gov>