spiderfw 0.5

data/lib/spiderfw/controller/session/file_session.rb

@@ -0,0 +1,83 @@
+require 'spiderfw/controller/session'
+require 'fileutils'
+
+module Spider
+    
+    class FileSession < Session
+        
+        class << self
+            
+            def setup
+                @sync ||= Sync.new
+            end
+
+            def []=(sid, data)
+                dir = Spider.conf.get('session.file.path')
+                FileUtils.mkpath(dir)
+                path = "#{dir}/#{sid}"
+                
+                @sync.lock(Sync::EX)
+                f = File.new(path, 'w+')
+                f.flock(File::LOCK_EX)
+                f.puts(Marshal.dump(data))
+                f.flush
+                f.flock(File::LOCK_UN)
+                f.close
+                @sync.lock(Sync::UN)
+            end
+        
+            def [](sid)
+                check_purge
+                dir = Spider.conf.get('session.file.path')
+                path = "#{dir}/#{sid}"
+                data = nil
+                if (File.exist?(path))
+                    @sync.lock(Sync::SH)
+                    f = File.new(path, 'r+')
+                    f.flock(File::LOCK_SH)
+                    begin
+                        data = Marshal.restore(f.read)
+                    rescue => exc
+                        Spider::Logger.error("Corrupt session")
+                        data = {}
+                    end
+                    mtime = f.mtime
+                    f.flock(File::LOCK_UN)
+                    f.close
+                    @sync.lock(Sync::UN)
+                end
+                return data
+            end
+            
+            def purge(life)
+                dir = Spider.conf.get('session.file.path')
+                @sync.lock(Sync::EX)
+                Find.find(dir) do |path|
+                    next unless File.file?(path)
+                    File.unlink(path) if File.exist?(path) && (File.mtime(path) + life < Time.now)
+                end
+                @sync.lock(Sync::UN)
+            end
+            
+            def delete(sid)
+                dir = Spider.conf.get('session.file.path')
+                return unless File.exist?(dir+'/'+sid)
+                @sync.lock(Sync::EX)
+                f = File.new(dir+'/'+sid)
+                f.flock(File::LOCK_EX)
+                File.unlink(dir+'/'+sid)
+                f.flock(File::LOCK_UN)
+                f.close
+                @sync.lock(Sync::UN)
+            end
+                
+            
+        end
+        
+        
+        
+        
+    end
+    
+    
+end

data/lib/spiderfw/controller/session/flash_hash.rb

@@ -0,0 +1,56 @@
+module Spider
+    
+    class FlashHash < Hash
+        attr_accessor :parent_flash, :parent_flash_key
+        attr_reader :accessed, :active
+        
+        def initialize
+            super
+            @sub_flashes = {}
+            @parent_flash = nil
+            @parent_flash_key = nil
+            reset
+        end
+        
+        def reset
+            @active = {}
+            @accessed = {}
+            @sub_flashes.each{ |k, f| f.reset }
+        end
+        
+        def [](key)
+            @accessed[key] = true
+            super
+        end
+        
+        def []=(key, val)
+            super
+            active(key)
+            if (val.is_a?(FlashHash))
+                val.parent_flash = self
+                val.parent_flash_key = key
+                @sub_flashes[key] = val
+            end
+        end
+        
+        def active(key)
+            @active[key] = true
+            if (@parent_flash)
+                @parent_flash.active(@parent_flash_key)
+            end
+        end
+        
+        def delete(key)
+            super
+            @sub_flashes.delete(key)
+        end
+        
+        def purge
+            self.delete_if{ |k, v| @accessed[k] && !@active[k] }
+            @sub_flashes.each{ |k, f| f.purge }
+        end
+        
+    end
+    
+    
+end

data/lib/spiderfw/controller/session/memory_session.rb

@@ -0,0 +1,62 @@
+require 'spiderfw/controller/session'
+
+module Spider
+    
+    class MemorySession < Session
+        
+        class << self
+                
+            
+            def setup
+                unless @sessions
+                    @sync ||= Sync.new
+                    @sessions ||= Hash.new
+                end
+                super
+            end
+        
+            def []=(sid, data)
+                @sync.lock(Sync::EX)
+                @sessions[sid] = {
+                    :data => data,
+                    :mtime => Time.now
+                }
+                @sync.lock(Sync::UN)
+            end
+        
+            def [](sid)
+                check_purge
+                @sync.lock(Sync::SH)
+                sess = @sessions[sid] ? @sessions[sid][:data] : nil
+                @sync.lock(Sync::UN)
+                sess
+            end
+            
+            def purge(life)
+                @sync.lock(Sync::EX)
+                @sessions.each do |sid, session|
+                    if (session[:mtime] + life < Time.now)
+                        @sessions.delete(sid)
+                    end
+                end
+                @sync.lock(Sync::UN)
+            end
+            
+            def delete(sid)
+                @sync.lock(Sync::EX)
+                @sessions.delete(sid)
+                @sync.lock(Sync::UN)
+            end
+            
+        end
+        
+        
+        def restore
+            @data = self.class[@sid]
+        end
+        
+        
+    end
+    
+    
+end

data/lib/spiderfw/controller/session/transient_hash.rb

@@ -0,0 +1,18 @@
+require 'spiderfw/controller/session/flash_hash'
+
+module Spider
+    
+    class TransientHash < FlashHash
+        
+        def purge
+            if (@parent_flash && @parent_flash_key && @parent_flash.accessed[@parent_flash_key])
+                self.delete_if{ |k, v| !@accessed[k] && !@active[k] }
+            end
+            @sub_flashes.each{ |k, f| f.purge }
+            @accessed = {}
+            @active = {}
+        end
+        
+    end
+    
+end

data/lib/spiderfw/controller/session.rb

@@ -0,0 +1,106 @@
+require 'uuid'
+require 'spiderfw/controller/session/flash_hash'
+require 'spiderfw/controller/session/transient_hash'
+
+module Spider
+    
+    class Session
+        attr_reader :sid
+        
+        def self.get(sid=nil)
+            klass = nil
+            case Spider.conf.get('session.store')
+            when 'db'
+            when 'memcached'
+            when 'file'
+                klass = FileSession
+            else
+                klass = MemorySession
+            end
+            klass.setup
+            return klass.new(sid)
+        end
+        
+        def self.setup
+            return if @setup
+            @setup = true
+        end
+        
+        def self.check_purge
+            if (!@last_purge || (Time.now - @last_purge) > Spider.conf.get('session.purge_check'))
+                purge(Spider.conf.get('session.life'))
+                @last_purge = Time.now
+            end
+        end
+        
+        def self.purge
+            raise RuntimeError, "Unimplemented"
+        end
+        
+        def initialize(sid=nil)
+            @sid = sid || generate_sid
+            restore
+            Spider::Logger.debug("SESSION RESTORED:")
+            Spider::Logger.debug(@data)
+            @data ||= {}
+            @data[:_flash].reset if @data[:_flash]
+        end
+        
+        def delete
+            self.class.delete(@sid)
+        end
+        
+        def generate_sid
+            UUID.new.generate
+        end
+        
+        def [](key)
+            @data[key]
+        end
+        
+        def []=(key, val)
+            @data[key] = val
+        end
+        
+        def delete(key)
+            @data.delete(key)
+        end
+        
+        def persist
+            clear_empty_hashes!(@data)
+            @data[:_flash].purge if @data[:_flash]
+            @data[:_transient].purge if @data[:_transient]
+            # Spider::Logger.debug("PERSISTING SESSION:")
+            # Spider::Logger.debug(@data)
+            self.class[@sid] = @data
+        end
+        
+        def restore
+            @data = self.class[@sid]
+        end
+        
+        def flash
+            @data[:_flash] ||= FlashHash.new
+        end
+        
+        def transient
+            @data[:_transient] ||= TransientHash.new
+        end
+        
+        def clear_empty_hashes!(h)
+            h.each do |k, v|
+                if (v.is_a?(Hash))
+                    if (v.empty?)
+                        h.delete(k)
+                    else
+                        clear_empty_hashes!(v)
+                    end
+                end
+            end
+        end
+        
+        
+    end
+    
+    
+end

data/lib/spiderfw/controller/spider_controller.rb

@@ -0,0 +1,20 @@
+module Spider
+    
+    class SpiderController < Controller
+        include HTTPMixin
+        include StaticContent
+        
+        
+        def self.pub_path
+            $SPIDER_PATH+'/public'
+        end
+        
+        def self.pub_url
+            HTTPMixin.reverse_proxy_mapping('/spider/public')
+        end
+        
+                
+    end
+    
+    
+end

data/lib/spiderfw/create.rb

@@ -0,0 +1,64 @@
+require 'fileutils'
+require 'find'
+require 'erb'
+require 'spiderfw/utils/inflector'
+
+module Spider
+    
+    module Create
+        
+        
+        def self.app(name, path, module_name=nil)
+            name_parts = name.split('/')
+            app_name = name_parts[-1]
+            app_path = name
+            module_full_name ||= Spider::Inflector.camelize(name)
+            modules = module_full_name.split('::')
+            module_name = modules[-1]
+            erb_binding = binding
+            dest_folder = path+'/'+name
+            
+            #FileUtils.mkdir_p(File.expand_path(dest_path+'/..'))
+            source_folder = $SPIDER_PATH+'/blueprints/app'
+            
+            replacements = {
+                '__APP__' => app_name,
+                '__MODULE__' => modules[modules.length-1]
+            }
+            create(source_folder, dest_folder, replacements, erb_binding)
+        end
+        
+        def self.install(name, path)
+            dest_path = path+'/'+name
+            source_path = $SPIDER_PATH+'/blueprints/install'
+            create(source_path, dest_path)
+        end
+        
+        def self.create(source_path, dest_path, replacements={}, erb_binding=nil)
+            raise RuntimeError, "Folder #{source_path} does not exist" unless File.exist?(source_path)
+            raise RuntimeError, "Folder #{dest_path} already exists" if File.exist?(dest_path)
+            FileUtils.mkdir_p(dest_path)
+            erb_binding ||= binding
+            Find.find(source_path) do |sp|
+                next if sp == source_path
+                sp =~ /\/([^\/]+)$/
+                file_name = $1
+                rel_path = sp[source_path.length+1..-1]
+                dp = rel_path
+                replacements.each do |search, replace|
+                    dp.gsub!(search, replace)
+                end
+                if (File.directory?(sp))
+                    FileUtils.mkdir(dest_path+'/'+dp)
+                else
+                    dst = File.new(dest_path+'/'+dp, 'w')
+                    res = ERB.new(IO.read(sp)).result(erb_binding)
+                    dst.puts(res)
+                    dst.close
+                end
+            end
+        end
+        
+    end
+    
+end

data/lib/spiderfw/env.rb

@@ -0,0 +1,17 @@
+RUBY_VERSION_PARTS = RUBY_VERSION.split('.')
+ENV['LC_CTYPE'] = 'en_US.UTF-8'
+
+$SPIDER_PATH = File.expand_path(File.dirname(__FILE__)+'/../..')
+$SPIDER_LIB = $SPIDER_PATH+'/lib'
+$SPIDER_RUN_PATH ||= Dir.pwd
+ENV['GETTEXT_PATH'] += ',' if (ENV['GETTEXT_PATH'])
+ENV['GETTEXT_PATH'] ||= ''
+ENV['GETTEXT_PATH'] += $SPIDER_PATH+'/data/locale,'+$SPIDER_RUN_PATH+'/data/locale'
+#$:.push($SPIDER_LIB+'/spiderfw')
+$:.push($SPIDER_RUN_PATH)
+
+$:.push($SPIDER_PATH)
+Dir.chdir($SPIDER_RUN_PATH)
+
+$SPIDER_RUNMODE = ENV['SPIDER_RUNMODE']
+$SPIDER_CONFIG_SETS = ENV['SPIDER_CONFIG_SETS'].split(/\s+,\s+/) if ENV['SPIDER_CONFIG_SETS']

data/lib/spiderfw/exceptions.rb

@@ -0,0 +1,2 @@
+class FormatError < RuntimeError; end
+class Forbidden < SecurityError; end

data/lib/spiderfw/home.rb

@@ -0,0 +1,26 @@
+module Spider
+    
+    class Home
+        attr_reader :path
+        
+        def initialize(path)
+            @path = path
+        end
+        
+        def controller
+            require 'spiderfw/controller/home_controller'
+            Spider::HomeController
+        end
+        
+        def route_apps
+            Spider.route_apps
+        end
+        
+        def load_apps(*args)
+            Spider.load_apps(*args)
+        end
+        
+    end
+    
+    
+end

data/lib/spiderfw/http/adapters/cgi.rb

@@ -0,0 +1,62 @@
+$:.push(ENV['SPIDER_PATH']+'/lib')
+require 'spiderfw'
+require 'spiderfw/controller/controller_io'
+require 'spiderfw/controller/http_controller'
+require 'spiderfw/http/adapters/cgi_io'
+
+module Spider; module HTTP
+    class CGIServer < Server
+        @supports = {
+            :chunked_request => false
+        }
+    end
+end; end
+
+def prepare_env
+    return {
+        'SERVER_NAME' => ENV['SERVER_NAME'],
+        'PATH_INFO' => ENV['PATH_INFO'],
+        'HTTP_ACCEPT_ENCODING' => ENV['HTTP_ACCEPT_ENCODING'],
+        'HTTP_USER_AGENT' => ENV['HTTP_USER_AGENT'],
+        'SCRIPT_NAME' => ENV['SCRIPT_NAME'],
+        'SERVER_PROTOCOL' => ENV['SERVER_PROTOCOL'],
+        'HTTP_COOKIE' => ENV['HTTP_COOKIE'],
+        'HTTP_HOST' => ENV['HTTP_HOST'],
+        'HTTP_ACCEPT_LANGUAGE' => ENV['HTTP_ACCEPT_LANGUAGE'],
+        'SERVER_SOFTWARE' => ENV['SERVER_SOFTWARE'],
+        'REQUEST_PATH' => ENV['REQUEST_PATH'],
+        'HTTP_VERSION' => ENV['HTTP_VERSION'],
+        'REQUEST_URI' => ENV['REQUEST_URI'],
+        'SERVER_PORT' => ENV['SERVER_PORT'],
+        'GATEWAY_INTERFACE' => ENV['GATEWAY_INTERFACE'],
+        'HTTP_ACCEPT' => ENV['HTTP_ACCEPT'],
+        'HTTP_CONNECTION' => ENV['HTTP_CONNECTION'],
+        'REQUEST_METHOD' => ENV['REQUEST_METHOD'],
+        'QUERY_STRING' => ENV['QUERY_STRING'],
+        'CONTENT_TYPE' => ENV['CONTENT_TYPE'],
+        'CONTENT_LENGTH' => ENV['CONTENT_LENGTH']
+    }
+end
+
+Spider::Logger.debug('-----------')
+
+env = prepare_env
+body = $stdin.read(env['CONTENT_LENGTH'].to_i)
+controller_request = Spider::Request.new(env)
+controller_request.server = Spider::HTTP::CGIServer
+controller_request.body = body
+path = env['REQUEST_PATH']+''
+controller_request.action = path
+controller_response = Spider::Response.new
+controller_response.server_output = CGIIO.new(STDOUT, controller_response)
+begin
+    controller = ::Spider::HTTPController.new(controller_request, controller_response)
+    controller.before(path)
+    controller.execute(path)
+    controller.after(path)                
+rescue => exc
+    Spider.logger.error(exc)
+    controller.ensure()
+ensure
+    controller_response.server_output.send_headers unless controller_response.server_output.headers_sent
+end

data/lib/spiderfw/http/adapters/cgi_io.rb

@@ -0,0 +1,27 @@
+class CGIIO < Spider::ControllerIO
+    attr_reader :headers_sent
+    
+    def initialize(out, controller_response)
+        @out = out
+        @controller_response = controller_response
+        @headers_sent = false
+    end
+    
+    def write(msg)
+        send_headers unless @headers_sent
+        @out << msg
+    end
+    
+    def send_headers
+        Spider::Logger.debug("CGI sending headers:")
+        @controller_response.prepare_headers
+        @headers_sent = true
+        @out << "Status: #{@controller_response.status}\n"
+        @controller_response.headers.each do |key, val|
+            @out << "#{key}: #{val}\n"
+        end
+        @out << "\n"
+    end
+    
+    
+end

data/lib/spiderfw/http/adapters/fcgi.rb

@@ -0,0 +1,62 @@
+require 'fcgi'
+
+require 'spiderfw/controller/controller_io'
+require 'spiderfw/controller/http_controller'
+require 'spiderfw/http/adapters/cgi_io'
+
+def prepare_env(env)
+    return env
+end
+
+module Spider; module HTTP
+    class FCGIServer < Server
+        @supports = {
+            :chunked_request => true
+        }
+    end
+end; end
+
+exit_graceful = false
+set_grace = lambda do 
+    STDERR << "RECEIVED SIGNAL\n";
+    exit_graceful = true; 
+    # result = RubyProf.stop
+    # printer = RubyProf::FlatPrinter.new(result)
+    # printer.print(STDERR, 0)
+    exit
+end
+trap('SIGTERM', &set_grace) 
+trap('SIGINT', &set_grace) 
+trap('SIGQUIT', &set_grace) 
+trap('SIGABRT', &set_grace) 
+
+# require 'ruby-prof'
+# RubyProf.start
+
+FCGI.each_request do |req|
+    env = prepare_env(req.env)
+    body = req.in
+    controller_request = Spider::Request.new(env)
+    controller_request.server = Spider::HTTP::FCGIServer
+    controller_request.body = body
+    path = env['REQUEST_URI']+''
+    controller_request.action = path
+    controller_response = Spider::Response.new
+    controller_response.server_output = CGIIO.new(req.out, controller_response)
+#    controllerThread = Thread.start do
+        begin
+            controller = ::Spider::HTTPController.new(controller_request, controller_response)
+            controller.before(path)
+            controller.execute(path)
+            controller.after(path)                
+        rescue => exc
+            Spider.logger.error(exc)
+            controller.ensure()
+        ensure
+            controller_response.server_output.send_headers unless controller_response.server_output.headers_sent
+            req.finish
+        end
+#    end
+    break if exit_graceful
+end
+