spiderfw 0.5.19 → 0.6.0

data/lib/spiderfw/controller/http_controller.rb

@@ -110,7 +110,7 @@ module Spider
         def after(action='', *arguments)
             # FIXME: cache stripped action?
             action = $1 if (action =~ /(.+)\.(\w+)$/) # strip extension, set format
-            @request.session.persist if @request.session
+            @request.session.persist if @request.session && @request.session.respond_to?(:persist)
             super(action, *arguments)
         end
         
@@ -147,6 +147,7 @@ module Spider
         
         def try_rescue(exc)
             log_done unless Spider::Request.current[:_http_logged_done]
+            self.done = true
             if exc.is_a?(Spider::Controller::NotFound)
                 Spider.logger.error("Not found: #{exc.path}")
             elsif exc.is_a?(Spider::Controller::Forbidden)

data/lib/spiderfw/controller/mixins/http_mixin.rb

@@ -58,7 +58,17 @@ module Spider; module ControllerMixins
         end
         
         def content_type(ct)
-            @response.headers["Content-Type"] = "#{ct};charset=#{output_charset}"
+            if ct.is_a?(Symbol)
+                ct = {
+                    :text       => 'text/plain',
+                    :json       => 'application/json',
+                    :js         => 'application/x-javascript',
+                    :javascript => 'application/x-javascript',
+                    :html       => 'text/html',
+                    :xml        => 'text/xml'
+                }[ct]
+            end
+            @response.headers["Content-Type"] = "#{ct};charset=utf-8"
         end
         
         def before(action='', *arguments)
@@ -88,6 +98,7 @@ module Spider; module ControllerMixins
         end
         
         def try_rescue(exc)
+            self.done = true
             if (exc.is_a?(Spider::Controller::NotFound))
                 @response.status = Spider::HTTP::NOT_FOUND
             elsif (exc.is_a?(Spider::Controller::BadRequest))

data/lib/spiderfw/controller/mixins/visual.rb

@@ -44,22 +44,8 @@ module Spider; module ControllerMixins
         end
         
         def output_format_headers(format)
-            case format
-            when :text
-                content_type('text/plain')
-            when :json
-                if (Spider.runmode == 'devel' && @request.params['_text'])
-                    content_type('text/plain')
-                else
-                    content_type('application/json')
-                end
-            when :js
-                content_type('application/x-javascript')
-            when :html
-                content_type('text/html')
-            when :xml
-                content_type('text/xml')
-            end
+            return content_type('application/json') if format == :json && Spider.runmode == 'devel' && @request.params['_text']
+            content_type(format)
         end
         
         def visual_params
@@ -86,6 +72,7 @@ module Spider; module ControllerMixins
             template.do_widgets_before
             layout.do_widgets_before if layout
             if @_widget
+                @_widget.before(widget_execute) if @_widget.is_target
                 @_widget.execute
                 done
             end

data/lib/spiderfw/env.rb

@@ -13,5 +13,5 @@ $:.push($SPIDER_RUN_PATH)
 $:.push($SPIDER_PATH)
 # Dir.chdir($SPIDER_RUN_PATH)
 
-$SPIDER_RUNMODE = ENV['SPIDER_RUNMODE']
+$SPIDER_RUNMODE ||= ENV['SPIDER_RUNMODE']
 $SPIDER_CONFIG_SETS = ENV['SPIDER_CONFIG_SETS'].split(/\s+,\s+/) if ENV['SPIDER_CONFIG_SETS']

data/lib/spiderfw/http/server.rb

@@ -1,5 +1,3 @@
-require 'spiderfw/controller/http_controller'
-
 module Spider; module HTTP
     
     class Server
@@ -36,6 +34,184 @@ module Spider; module HTTP
         def request_received
         end
         
+        def self.start(server_name, port, options={})
+            servers = {
+                'webrick'   => :WEBrick,
+                'mongrel'   => :Mongrel,
+                'thin'      => :Thin
+            }
+            
+            start = lambda{
+                require 'spiderfw'
+                require 'spiderfw/controller/http_controller'
+                
+                port ||= Spider.conf.get('webserver.port')
+                server_name ||= Spider.conf.get('http.server')
+                pid_file = File.join(Spider.paths[:var], 'run/server.pid')
+                puts _("Using webserver %s") % server_name if options[:verbose]
+                puts _("Listening on port %s") % port if options[:verbose]
+                server = Spider::HTTP.const_get(servers[server_name]).new
+                ssl_server = nil
+                Spider.startup
+                if Spider.conf.get('devel.trace.extended')
+                    require 'ruby-debug'
+                    require 'spiderfw/utils/monkey/debugger'
+                    Debugger.start
+                    Debugger.post_mortem
+                end
+                
+                thread = Thread.new do
+                    server.start(:port => port, :cgi => options[:cgi])
+                end
+                $stdout << "Spider server running on port #{port}\n"
+                if options[:ssl]
+                    options[:ssl_cert] ||= Spider.conf.get('orgs.default.cert')
+                    options[:ssl_key] ||= Spider.conf.get('orgs.default.private_key')
+                    raise "SSL Certificate not set" unless options[:ssl_cert]
+                    raise "SSL Key not set" unless options[:ssl_key]
+                    raise "SSL Certificate (#{options[:ssl_cert]}) not found" unless File.file?(options[:ssl_cert])
+                    raise "SSL Key (#{options[:ssl_key]}) not found" unless File.file?(options[:ssl_key])
+                    ssl_thread = Thread.new do
+                        ssl_server = Spider::HTTP.const_get(servers[server_name]).new
+                        ssl_server.start(:port => options[:ssl], :ssl => true, 
+                            :ssl_cert => options[:ssl_cert], :ssl_private_key => options[:ssl_key])
+                    end
+                end
+                do_shutdown = lambda{ |arg|
+                    server.shutdown
+                    ssl_server.shutdown if ssl_server
+                    Spider.shutdown
+                    pid_file = File.join(Spider.paths[:var], 'run/server.pid')
+                    begin
+                        File.unlink(pid_file)
+                    rescue Errno::ENOENT
+                    end
+                }
+                trap('TERM', &do_shutdown)
+                trap('INT', &do_shutdown)
+                
+                thread.join
+                ssl_thread.join if ssl_thread
+            }
+            if options[:daemonize]
+                require 'spiderfw'
+                require 'spiderfw/utils/fork'
+                pid_file = File.join(Spider.paths[:var], 'run/server.pid')
+                process_name = (options[:daemonize] == true) ? 'spider-server' : options[:daemonize]
+                forked = Spider.fork do
+                    File.open(pid_file, 'w') do |f|
+                        f.write(Process.pid)
+                    end
+                    $0 = process_name
+                    start.call
+                end
+                Process.detach(forked)
+            else
+                Spider.init_base
+                if Spider.conf.get('webserver.respawn_on_change')
+                    Spider.start_loggers
+                    begin
+                        Bundler.require :default, Spider.runmode.to_sym
+                    rescue
+                    end
+                    spawner = Spawner.new({'spawn' => start})
+                    spawner.run('spawn')
+                else
+                    start.call
+                end
+            end
+        end
+        
+    end
+    
+    class Spawner
+        attr_reader :child_pid
+        
+        def initialize(actions)
+            @actions = actions
+        end
+        
+        def run(action=nil)
+            @monitor_thread = monitor_fs
+            spawn(action)
+            @monitor_thread.join
+        end
+        
+        def spawn(action)
+            rd, wr = IO.pipe
+            if pid = fork
+                # Spawner
+                @child_pid = pid
+                exit_spawner = lambda{ 
+                    Spider.logger.debug "Spawner exiting" 
+                    exit 
+                }
+                trap('TERM', exit_spawner)
+                trap('INT', exit_spawner)
+                
+                $0 = 'spider-spawner'
+                wr.close
+                @monitor_thread[:spawner_child_pid] = pid
+                # TODO
+                # msg = rd.read(5)
+                # rd.close
+                # spawn(msg) unless msg.blank?
+
+            else
+                # Child
+                rd.close
+                Spider.spawner = wr
+                return unless @actions[action]
+                @actions[action].call
+            end
+        end
+        
+        def monitor_fs
+            require 'fssm'
+            spawner = self
+            action = 'spawn'
+            return Thread.new do
+                fsm_exclude = ['var', 'tmp']
+                FSSM.monitor do
+                    #Spider.logger.debug("Monitoring #{Spider.paths[:apps]} for changes")
+                    path Spider.paths[:apps] do 
+                        glob '**/*.rb'
+
+                        update { |base, relative| 
+                            Spider.logger.debug("#{relative} updated, restarting")
+                            Process.kill 'KILL', Thread.current[:spawner_child_pid]
+                            spawner.spawn(action)
+                        }
+                        delete { |base, relative|
+                            Spider.logger.debug("#{relative} deleted, restarting")
+                            Process.kill 'KILL', Thread.current[:spawner_child_pid]
+                            spawner.spawn(action)
+                        }
+                        create { |base, relative|
+                            Spider.logger.debug("#{relative} created, restarting")
+                            Process.kill 'KILL', Thread.current[:spawner_child_pid]
+                            spawner.spawn(action)
+                        }
+                    end
+                    # path Spider.paths[:root] do
+                    #     glob '**/*.shtml'
+                    #     
+                    #     update { |base, relative|
+                    #         puts "Changed #{base}, #{relative}"
+                    #         Spider::Template.cache.invalidate(File.join('ROOT', relative))
+                    #     }
+                    # end
+
+                    # path '/some/other/directory/' do
+                    #   update {|base, relative|}
+                    #   delete {|base, relative|}
+                    #   create {|base, relative|}
+                    # end
+                end
+            end
+            
+        end
+        
     end
     
 end; end