hayabusa 0.0.23 → 0.0.24

data/Gemfile.lock

@@ -6,13 +6,13 @@ GEM
     erubis (2.7.0)
     fcgi (0.9.1)
     git (1.2.5)
-    http2 (0.0.21)
+    http2 (0.0.22)
     jeweler (1.6.4)
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
     json (1.8.0)
-    knjrbfw (0.0.105)
+    knjrbfw (0.0.107)
       datet
       http2
       php4r

data/VERSION

@@ -1 +1 @@
-0.0.23
+0.0.24

data/hayabusa.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = "hayabusa"
-  s.version = "0.0.23"
+  s.version = "0.0.24"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kasper Johansen"]
@@ -39,6 +39,7 @@ Gem::Specification.new do |s|
     "conf/apache2_hayabusa_conf.conf",
     "hayabusa.gemspec",
     "lib/hayabusa.rb",
+    "lib/hayabusa_cgi.rb",
     "lib/hayabusa_cgi_session.rb",
     "lib/hayabusa_cgi_tools.rb",
     "lib/hayabusa_client_session.rb",

data/lib/hayabusa_cgi.rb

@@ -0,0 +1,37 @@
+require "cgi"
+
+class CGI
+  public :env_table
+  def self.remove_params
+    if (const_defined?(:CGI_PARAMS))
+      remove_const(:CGI_PARAMS)
+      remove_const(:CGI_COOKIES)
+    end
+  end
+end
+
+# A hack to use CGI in FCGI mode (copied from the original FCGI framework).
+class Hayabusa::Cgi < ::CGI
+  def initialize(request, *args)
+    ::CGI.remove_params
+    @request = request
+    super(*args)
+    @args = *args
+  end
+  
+  def args
+    @args
+  end
+  
+  def env_table
+    @request.env
+  end
+  
+  def stdinput
+    @request.in
+  end
+  
+  def stdoutput
+    @request.out
+  end
+end

data/lib/hayabusa_cgi_tools.rb

@@ -68,10 +68,10 @@ class Hayabusa::Cgi_tools
   
   #This method is used to proxy a request to another FCGI-process, since a single FCGI-process cant handle more requests simultanious.
   def proxy_request_to(args)
-    cgi, http, fp_log = args[:cgi], args[:http], args[:fp_log]
+    @cgi, @http, fp_log = args[:cgi], args[:http], args[:fp_log]
     
     headers = {"Hayabusa_mode" => "proxy"}
-    cgi.env_table.each do |key, val|
+    @cgi.env.each do |key, val|
       keyl = key.to_s.downcase
       
       if key[0, 5] == "HTTP_"
@@ -87,66 +87,62 @@ class Hayabusa::Cgi_tools
     end
     
     #Make request.
-    uri = Knj::Web.parse_uri(cgi.env_table["REQUEST_URI"])
+    uri = Knj::Web.parse_uri(@cgi.env["REQUEST_URI"])
     url = File.basename(uri[:path])
     url = url[1, url.length] if url[0] == "/"
     
-    if cgi.env_table["QUERY_STRING"].to_s.length > 0
-      url << "?#{cgi.env_table["QUERY_STRING"]}"
-    end
-    
-    #cgi.print "Content-Type: text/html\r\n"
-    #cgi.print "\r\n"
-    
-    if args[:timeout]
-      ttime = args[:timeout]
-    else
-      ttime = 30
+    if @cgi.env["QUERY_STRING"].to_s.length > 0
+      url << "?#{cgi.env["QUERY_STRING"]}"
     end
     
     fp_log.puts("Proxying URL: '#{url}'.") if fp_log
     
     #The HTTP-connection can have closed mean while, so we have to test it.
-    raise Errno::ECONNABORTED if !http.socket_working?
+    raise Errno::ECONNABORTED unless @http.socket_working?
     
-    #require "timeout"
-    #Timeout.timeout(ttime) do
-      if cgi.request_method == "POST" and cgi.content_type.to_s.downcase.index("multipart/form-data") != nil
-        count = 0
-        http.post_multipart(
-          :url => url,
-          :post => self.convert_fcgi_post_fileuploads_to_http2(self.convert_fcgi_post(cgi.params, :http2_compatible => true)),
-          :default_headers => headers,
-          :cookies => false,
-          :on_content => proc{|line|
-            cgi.print(line) if count > 0
-            count += 1
-          }
-        )
-      elsif cgi.request_method == "POST"
-        count = 0
-        http.post(
+    # Count used to know what is the status line.
+    @count = 0
+    
+    if @cgi.env["REQUEST_METHOD"] == "POST"
+      # Use CGI to parse post.
+      real_cgi = Hayabusa::Cgi.new(@cgi)
+      params = real_cgi.params
+      
+      if cgi.env["CONTENT_TYPE"].to_s.downcase.include?("multipart/form-data")
+        @http.post_multipart(
           :url => url,
-          :post => self.convert_fcgi_post(cgi.params, :http2_compatible => true),
+          :post => self.convert_fcgi_post_fileuploads_to_http2(self.convert_fcgi_post(params, :http2_compatible => true)),
           :default_headers => headers,
           :cookies => false,
-          :on_content => proc{|line|
-            cgi.print(line) if count > 0
-            count += 1
-          }
+          :on_content => self.method(:on_content)
         )
       else
-        count = 0
-        http.get(
+        @http.post(
           :url => url,
+          :post => self.convert_fcgi_post(params, :http2_compatible => true),
           :default_headers => headers,
           :cookies => false,
-          :on_content => proc{|line|
-            cgi.print(line) if count > 0
-            count += 1
-          }
+          :on_content => self.method(:on_content)
         )
       end
-    #end
+    else
+      @http.get(
+        :url => url,
+        :default_headers => headers,
+        :cookies => false,
+        :on_content => self.method(:on_content)
+      )
+    end
+  end
+  
+  def on_content(line)
+    if @count <= 0
+      # This is needed to trick FCGI into writing out correct status codes by ignoring the original status code and outputting it as a "Status"-header instead which is defined in the response-file.
+    else
+      # Write the given line to the content.
+      @cgi.out.print(line)
+    end
+    
+    @count += 1
   end
 end

data/lib/hayabusa_fcgi.rb

@@ -1,3 +1,5 @@
+require "cgi"
+
 #This class is used for FCGI-sessions. It normally starts a Hayabusa-host-process which this (and other) FCGI-processes will proxy requests to. The host-process will automatically kill itself when no more FCGI-sessions are connected to emulate normal FCGI behaviour.
 class Hayabusa::Fcgi
   def initialize
@@ -24,10 +26,10 @@ class Hayabusa::Fcgi
     return nil if @hayabusa or @fcgi_proxy
     
     #Parse the configuration-header and generate Hayabusa-config-hash.
-    raise "No HTTP_HAYABUSA_FCGI_CONFIG-header was given." if !@cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]
-    @hayabusa_fcgi_conf_path = @cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]
+    raise "No HTTP_HAYABUSA_FCGI_CONFIG-header was given." if !@cgi.env["HTTP_HAYABUSA_FCGI_CONFIG"]
+    @hayabusa_fcgi_conf_path = @cgi.env["HTTP_HAYABUSA_FCGI_CONFIG"]
     require @hayabusa_fcgi_conf_path
-    raise "No 'Hayabusa::FCGI_CONF'-constant was spawned by '#{@cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]}'." if !Hayabusa.const_defined?(:FCGI_CONF)
+    raise "No 'Hayabusa::FCGI_CONF'-constant was spawned by '#{@cgi.env["HTTP_HAYABUSA_FCGI_CONFIG"]}'." if !Hayabusa.const_defined?(:FCGI_CONF)
     conf = Hayabusa::FCGI_CONF
     
     hayabusa_conf = Hayabusa::FCGI_CONF[:hayabusa]
@@ -132,11 +134,8 @@ class Hayabusa::Fcgi
     $stderr.puts "[hayabusa] Starting FCGI." if @debug
     
     begin
-      FCGI.each_cgi do |cgi|
+      FCGI.each do |cgi|
         begin
-          #cgi.print "Content-Type: text/html\r\n"
-          #cgi.print "\r\n"
-          
           #Set 'cgi'-variable for CGI-tools.
           @cgi_tools.cgi = cgi
           @cgi = cgi
@@ -149,23 +148,20 @@ class Hayabusa::Fcgi
           end
           
           #Ensure the same FCGI-process isnt active for more than one website.
-          raise "Expected 'HTTP_HAYABUSA_FCGI_CONFIG' to be '#{@hayabusa_fcgi_conf_path}' but it wasnt: '#{cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]}'." if @hayabusa_fcgi_conf_path and @hayabusa_fcgi_conf_path != cgi.env_table["HTTP_HAYABUSA_FCGI_CONFIG"]
+          raise "Expected 'HTTP_HAYABUSA_FCGI_CONFIG' to be '#{@hayabusa_fcgi_conf_path}' but it wasnt: '#{cgi.env["HTTP_HAYABUSA_FCGI_CONFIG"]}'." if @hayabusa_fcgi_conf_path and @hayabusa_fcgi_conf_path != cgi.env["HTTP_HAYABUSA_FCGI_CONFIG"]
           
-          if @fcgi_proxy
-            #Proxy request to the host-FCGI-process.
-            $stderr.puts "[hayabusa] Proxying request." if @debug
-            @cgi_tools.proxy_request_to(:cgi => cgi, :http => @fcgi_proxy[:http], :fp_log => @fcgi_proxy[:fp_log])
-          else
-            self.handle_fcgi_request(:cgi => cgi)
-          end
+          #Proxy request to the host-FCGI-process.
+          raise "No proxy spawned." unless @fcgi_proxy
+          $stderr.puts "[hayabusa] Proxying request." if @debug
+          @cgi_tools.proxy_request_to(:cgi => cgi, :http => @fcgi_proxy[:http], :fp_log => @fcgi_proxy[:fp_log])
         rescue Errno::ECONNABORTED, Errno::ECONNREFUSED, Errno::ECONNRESET => e
           $stderr.puts "[hayabusa] Connection to server was interrupted - trying again: <#{e.class.name}> #{e.message}"
           @fcgi_proxy = nil #Force re-evaluate if this process should be host or proxy.
           retry
         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.out.print "Content-Type: text/html\r\n"
+          @cgi.out.print "\r\n"
+          @cgi.out.print Knj::Errors.error_str(e, :html => true)
           
           if @hayabusa
             @hayabusa.log_puts e.inspect
@@ -175,6 +171,7 @@ class Hayabusa::Fcgi
             STDERR.puts e.backtrace
           end
         ensure
+          @cgi.finish
           @cgi = nil
           @cgi_tools.cgi = nil
         end
@@ -184,45 +181,4 @@ class Hayabusa::Fcgi
       @hayabusa.stop if @hayabusa
     end
   end
-  
-  #Handles the request as a real request on a Hayabusa-host running inside the current process. This is not used any more but kept if we need support for it once again (maybe the developer should be able to decide this in some kind of config?).
-  def handle_fcgi_request(args)
-    #Host the FCGI-process.
-    $stderr.puts "[hayabusa] Running request as CGI." if @debug
-    
-    #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
 end

data/lib/hayabusa_http_session_request.rb

@@ -193,16 +193,10 @@ class Hayabusa::Http_session::Request
           ).return
           post_data.close(true)
           
-          self.convert_post(@post, post_treated, {:urldecode => false})
+          Hayabusa::Http_session::Request.convert_post(@post, post_treated, {:urldecode => false})
         else
-          post_data.split("&").each do |splitted|
-            splitted = splitted.split("=")
-            key = Knj::Web.urldec(splitted[0]).to_s.encode("utf-8")
-            val = splitted[1].to_s.encode("utf-8")
-            post_treated[key] = val
-          end
-          
-          self.convert_post(@post, post_treated, {:urldecode => true})
+          Hayabusa::Http_session::Request.parse_post(post_data, post_treated)
+          Hayabusa::Http_session::Request.convert_post(@post, post_treated, {:urldecode => true})
         end
       end
     ensure
@@ -219,6 +213,16 @@ class Hayabusa::Http_session::Request
     end
   end
   
+  # Takes raw post data and puts it into a hash.
+  def self.parse_post(post_data, post_treated)
+    post_data.split("&").each do |splitted|
+      splitted = splitted.split("=")
+      key = Knj::Web.urldec(splitted[0]).to_s.encode("utf-8")
+      val = splitted[1].to_s.encode("utf-8")
+      post_treated[key] = val
+    end
+  end
+  
   #Parses the if-modified-since header and returns it as a Time-object. Returns false is no if-modified-since-header is given or raises an RuntimeError if it cant be parsed.
   def modified_since
     return @modified_since if @modified_since
@@ -233,8 +237,8 @@ class Hayabusa::Http_session::Request
     return @modified_since
   end
   
-  #Converts post-result to the right type of hash.
-  def convert_post(seton, post_val, args = {})
+  # Converts post-result to the right type of hash.
+  def self.convert_post(seton, post_val, args = {})
     post_val.each do |varname, value|
       Knj::Web.parse_name(seton, varname, value, args)
     end

data/lib/hayabusa_http_session_response.rb

@@ -116,6 +116,9 @@ class Hayabusa::Http_session::Response
       res << NL
     end
     
+    # The status header is used to make CGI or FCGI use the correct status-code.
+    self.header("Status", "#{@status} #{STATUS_CODES[@status]}")
+    
     @headers.each do |key, val|
       res << "#{val[0]}: #{val[1]}#{NL}"
     end

data/pages/config_cgi.rb

@@ -1,3 +1,6 @@
+require "rubygems"
+require "RMagick"
+
 Hayabusa::CGI_CONF = {
   :hayabusa => {
     :title => "Cgi_test",

data/pages/config_fcgi.rb

@@ -1,3 +1,6 @@
+require "rubygems"
+require "RMagick"
+
 Hayabusa::FCGI_CONF = {
   :hayabusa => {
     :title => "Fcgi_test",

data/spec/hayabusa_spec.rb

@@ -1,92 +1,92 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Hayabusa" do
-  it "should be able to start a sample-server" do
-    require "rubygems"
-    require "sqlite3" if RUBY_ENGINE != "jruby"
-    require "json"
-    
-    begin
-      require "#{File.realpath(File.dirname(__FILE__))}/../../knjrbfw/lib/knjrbfw.rb"
-    rescue LoadError
-      require "knjrbfw"
-    end
-    
-    require "#{File.realpath(File.dirname(__FILE__))}/../lib/hayabusa.rb"
-    
-    begin
-      require "#{File.realpath(File.dirname(__FILE__))}/../../http2/lib/http2.rb"
-    rescue LoadError
-      require "http2"
-    end
-    
-    db_path = "#{Knj::Os.tmpdir}/hayabusa_rspec.sqlite3"
-    File.unlink(db_path) if File.exists?(db_path)
-    
-    db = Knj::Db.new(
-      :type => "sqlite3",
-      :path => db_path,
-      :return_keys => "symbols"
-    )
-    
-    $appserver = Hayabusa.new(
-      :debug => false,
-      :title => "SpecTest",
-      :port => 1515,
-      :doc_root => "#{File.dirname(__FILE__)}/../pages",
-      :locales_gettext_funcs => true,
-      :locale_default => "da_DK",
-      :db => db,
-      :threadding => {
-        :priority => -3
-      }
-    )
-    
-    $appserver.config[:handlers] << {
-      :regex => /^\/Kasper$/,
-      :callback => proc{|data|
-        data[:httpsession].page_path = nil
-        
-        eruby = data[:httpsession].eruby
-        eruby.connect(:on_error) do |e|
-          _hb.handle_error(e)
-        end
-        
-        eruby.import("#{File.dirname(__FILE__)}/../pages/spec.rhtml")
-      }
+  require "rubygems"
+  require "sqlite3" if RUBY_ENGINE != "jruby"
+  require "json"
+  require "RMagick"
+  
+  begin
+    require "#{File.realpath(File.dirname(__FILE__))}/../../knjrbfw/lib/knjrbfw.rb"
+  rescue LoadError
+    require "knjrbfw"
+  end
+  
+  require "#{File.realpath(File.dirname(__FILE__))}/../lib/hayabusa.rb"
+  
+  begin
+    require "#{File.realpath(File.dirname(__FILE__))}/../../http2/lib/http2.rb"
+    puts "Loaded custom version of Http2."
+  rescue LoadError
+    require "http2"
+    puts "Loaded normal gem version of Http2."
+  end
+  
+  db_path = "#{Knj::Os.tmpdir}/hayabusa_rspec.sqlite3"
+  File.unlink(db_path) if File.exists?(db_path)
+  
+  db = Knj::Db.new(
+    :type => "sqlite3",
+    :path => db_path,
+    :return_keys => "symbols"
+  )
+  
+  $appserver = Hayabusa.new(
+    :debug => false,
+    :title => "SpecTest",
+    :port => 1515,
+    :doc_root => "#{File.dirname(__FILE__)}/../pages",
+    :locales_gettext_funcs => true,
+    :locale_default => "da_DK",
+    :db => db,
+    :threadding => {
+      :priority => -3
     }
-    
-    $appserver.vars[:test] = "kasper"
-    $appserver.define_magic_var(:_testvar1, "Kasper")
-    $appserver.define_magic_var(:_testvar2, "Johansen")
-    $appserver.start
-    
-    raise "Expected thread-pool-priority to be '-3' but it wasnt: '#{$appserver.threadpool.args[:priority]}'." if $appserver.threadpool.args[:priority] != -3
-    
-    http = Http2.new(:host => "localhost", :port => 80, :encoding_gzip => false, :debug => false) rescue nil
-    
-    $testmodes = [{
-      :name => :standalone,
-      :path_pre => "",
-      :http => Http2.new(:host => "localhost", :port => 1515, :debug => false)
+  )
+  
+  $appserver.config[:handlers] << {
+    :regex => /^\/Kasper$/,
+    :callback => proc{|data|
+      data[:httpsession].page_path = nil
+      
+      eruby = data[:httpsession].eruby
+      eruby.connect(:on_error) do |e|
+        _hb.handle_error(e)
+      end
+      
+      eruby.import("#{File.dirname(__FILE__)}/../pages/spec.rhtml")
+    }
+  }
+  
+  $appserver.vars[:test] = "kasper"
+  $appserver.define_magic_var(:_testvar1, "Kasper")
+  $appserver.define_magic_var(:_testvar2, "Johansen")
+  $appserver.start
+  
+  raise "Expected thread-pool-priority to be '-3' but it wasnt: '#{$appserver.threadpool.args[:priority]}'." if $appserver.threadpool.args[:priority] != -3
+  
+  http = Http2.new(:host => "localhost", :port => 80, :encoding_gzip => false, :debug => false) rescue nil
+  
+  $testmodes = [{
+    :name => :standalone,
+    :path_pre => "",
+    :http => Http2.new(:host => "localhost", :port => 1515, :debug => false)
+  }]
+  
+  if http
+    $testmodes += [{
+      :name => :cgi,
+      :path_pre => "hayabusa_cgi_test/",
+      :http => http
+    },{
+      :name => :fcgi,
+      :path_pre => "hayabusa_fcgi_test/",
+      :http => http
     }]
-    
-    if http
-      $testmodes += [{
-        :name => :cgi,
-        :path_pre => "hayabusa_cgi_test/",
-        :http => http
-      },{
-        :name => :fcgi,
-        :path_pre => "hayabusa_fcgi_test/",
-        :http => http
-      }]
-    end
   end
   
   it "should be able to get multiple pictures" do
     require "base64"
-    require "RMagick"
     
     # Symlink 'image.rhtml' first.
     img_from_path = "#{Knj.knjrbfw_path}/webscripts/image.rhtml"
@@ -97,13 +97,12 @@ describe "Hayabusa" do
     File.unlink(img_to_path) if File.symlink?(img_to_path)
     File.symlink(img_from_path, img_to_path)
     
+    last_tdata = nil
+    
     begin
-      http = $testmodes.first[:http]
-      res = http.get("image.rhtml?path64=#{Base64.encode64("image.png").to_s.strip}&rounded_corners=8&width=550")
-      res.contenttype.should eql("image/png")
-      res.header?("content-length").should eql(true)
-      
       $testmodes.each do |tdata|
+        last_tdata = tdata
+        
         3.times do
           path = "#{File.dirname(__FILE__)}/../pages/testpic.jpeg"
           
@@ -122,6 +121,7 @@ describe "Hayabusa" do
           #puts "Getting exit-script through #{tdata[:name]}"
           res_exit = tdata[:http].get("#{tdata[:path_pre]}spec_exit.rhtml")
           res_exit.body.should eql("ExitOutput\n")
+          res_exit.code.to_i.should eql(304)
           
           #puts "Getting normal image through #{tdata[:name]}"
           res2 = tdata[:http].get("#{tdata[:path_pre]}image.rhtml?path64=#{Base64.encode64("image.png").to_s.strip}&rounded_corners=8&width=550")
@@ -130,6 +130,11 @@ describe "Hayabusa" do
           res1.body.bytesize.should eql(res2.body.bytesize)
         end
       end
+    rescue => e
+      puts "Mode: #{last_tdata[:name]}" if last_tdata
+      STDERR.puts e.inspect
+      STDERR.puts e.backtrace
+      raise e
     ensure
       File.unlink(img_to_path) if File.exists?(img_to_path)
     end
@@ -162,9 +167,12 @@ describe "Hayabusa" do
       
       1.upto(2) do |count|
         data = Marshal.load(res.body)
+        raise "No data returned?" unless data
         
         if count != 2
-          if data["testfile#{count}"]["val"] != File.read(fpaths["fpath#{count}"])
+          key = "testfile#{count}"
+          raise "Not defined in returned data: '#{key}' in '#{data}'." unless data.key?(key)
+          if data[key]["val"] != File.read(fpaths["fpath#{count}"])
             File.open("/tmp/hayabusa_spec_testfile#{count}_1", "w") do |fp|
               fp.puts("Class: #{data["testfile#{count}"].class.name}")
               fp.write(data["testfile#{count}"])
@@ -205,7 +213,7 @@ describe "Hayabusa" do
       res = tdata[:http].post(:url => "#{tdata[:path_pre]}spec.rhtml", :post => {
         "postdata" => "Test post"
       })
-      raise "POST-request did not return expected data: '#{res.body}' for '#{tdata[:name]}'." if res.body.to_s.strip != "Test post"
+      raise "POST-request did not return expected data: '#{res.body}' for '#{tdata[:name]}' data: '#{res.body}'." if res.body.to_s.strip != "Test post"
       
       res = tdata[:http].post(:url => "#{tdata[:path_pre]}spec.rhtml?choice=dopostconvert", :post => {
         "postdata" => "Test post",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hayabusa
 version: !ruby/object:Gem::Version
-  version: 0.0.23
+  version: 0.0.24
   prerelease: 
 platform: ruby
 authors:
@@ -273,6 +273,7 @@ files:
 - conf/apache2_hayabusa_conf.conf
 - hayabusa.gemspec
 - lib/hayabusa.rb
+- lib/hayabusa_cgi.rb
 - lib/hayabusa_cgi_session.rb
 - lib/hayabusa_cgi_tools.rb
 - lib/hayabusa_client_session.rb
@@ -354,7 +355,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4394094248699079700
+      hash: 635854692325218381
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: