RubyGems - spiderfw - Versions diffs - 0.5 - Mend

spiderfw 0.5

Files changed (638) hide show

data/lib/spiderfw/controller/first_responder.rb ADDED Viewed

@@ -0,0 +1,59 @@
+module Spider
+    module FirstResponder
+        def before(action='', *arguments)
+            # if (Spider.conf.get('profiling.enable') && @request.env['QUERY_STRING'] =~ /profile=true/)
+            #     unless Spider.request_mutex
+            #         Spider.mutex_requests!
+            #         Spider.request_mutex.lock
+            #     end
+            #     require 'ruby-prof'
+            #     RubyProf.start
+            #     @profiling_started = true
+            # end
+            catch :done do
+                begin
+                    super
+                rescue => exc
+                    try_rescue(exc)
+                end
+            end
+        end
+        def execute(action='', *arguments)
+            catch :done do
+                begin
+                    super
+                rescue => exc
+                    try_rescue(exc)
+                end
+            end
+        end
+        def after(action='', *arguments)
+            catch :done do
+                begin
+                    super
+                rescue => exc
+                    try_rescue(exc)
+                end
+            end
+            # if (@profiling_started)
+            #     debugger
+            #     Spider.request_mutex.unlock
+            #     Spider.request_mutex = nil
+            #     result = RubyProf.stop
+            #     printer = ::RubyProf::GraphHtmlPrinter.new(result)
+            #     file_name = Spider.paths[:tmp]+"/prof_#{DateTime.now.to_s}.html"
+            #     File.open(file_name, 'w') do |f|
+            #         printer.print(f, :min_percent => 0)
+            #     end
+            #     Spider.logger.info("Written profiling info in #{file_name}")
+            # end
+        end
+    end
+end

data/lib/spiderfw/controller/formats/html.rb ADDED Viewed

@@ -0,0 +1,90 @@
+require 'spiderfw/controller/controller_mixin'
+module Spider
+    module HTML
+        include ControllerMixin
+        # before do
+        #     Spider.logger.debug('HTML before')
+        #     #@response.headers['Content-Type'] = 'text/html'
+        #
+        #     begin
+        #         run_chain(:before)
+        #     # rescue NotFound
+        #     #     render('errors/404')
+        #     rescue => exc
+        #         top
+        #         print_backtrace(exc)
+        #         bottom
+        #         raise exc
+        #     end
+        # end
+        def before(action='', *arguments)
+            Spider.logger.debug("HTML BEFORE")
+            @response.register(:js, [])
+            begin
+                super
+            rescue => exc
+                top
+                print_backtrace(exc)
+                bottom
+                raise exc
+            end
+        end
+        execute do
+            #top
+            run_chain(:execute)
+        end
+        after do
+            run_chain(:after)
+            #bottom
+        end
+        def top
+            puts "<html>"
+            puts "<head>"
+            @response.js.each do |js|
+                puts "<script type=\"text/javascript\" src=\"#{js}\"></script>"
+            end
+            puts "</head>"
+            puts "<body>"
+        end
+        def bottom
+            puts "</body></html>"
+        end
+        def try_rescue(exc)
+            print_backtrace(exc) if Spider.config.get('webserver.show_traces')
+            raise exc
+        end
+        def print_backtrace(exc)
+            html = "<h3>Error: "+exc.to_s+"</h3>"
+            html += "<ul>"
+            client_editor = (Spider.config.get('client.text_editor') || '').downcase
+            prefix = ''
+            prefix = 'txmt://open?url=' if (client_editor == 'textmate')
+            exc.backtrace.each do |trace_line|
+                parts = trace_line.split(':')
+                file_path = parts[0]
+                line = parts[1]
+                method = parts[2]
+                suffix = ''
+                suffix = '&line='+line if (client_editor == 'textmate')
+                html += "<li>"
+                html += "<a href='#{prefix}file://#{file_path}#{suffix}'>#{file_path}</a>:#{line}:#{method}"
+                html += "</li>"
+            end
+            html += "</ul>"
+            puts html
+        end
+    end
+end

data/lib/spiderfw/controller/helpers/widget_helper.rb ADDED Viewed

@@ -0,0 +1,73 @@
+module Spider; module Helpers
+    module WidgetHelper
+        def self.included(controller)
+            controller.extend(ClassMethods)
+        end
+        def prepare_scene(scene)
+            scene = super
+            if (self.is_a?(Widget))
+                scene.widget = widget_to_scene(self)
+            end
+            scene.widgets = {}
+            if (@widgets)
+                @widgets.each do |id, w|
+                    scene.widgets[id] = widget_to_scene(w)
+                end
+            end
+            return scene
+        end
+        def widget_to_scene(w)
+            {
+                :id_path => w.id_path,
+                :full_id => w.full_id,
+                :param => param_name(w),
+                :pub_path => w.class.pub_url,
+                :css_class => w.css_class,
+                :css_classes => w.css_classes.uniq.join(' ')
+            }
+        end
+        def get_scene(scene=nil)
+            scene = super(scene)
+            scene.extend(SceneMethods)
+            return scene
+        end
+        module ClassMethods
+            def route_widgets(route_name='')
+                route 'widgets', :serve_widgets
+            end
+        end
+        module SceneMethods
+            def param_name(widget_desc)
+                if (widget_desc.is_a?(Widget))
+                    id_path = widget_desc.id_path
+                elsif (widget_desc.is_a?(Hash))
+                    id_path = widget_desc[:id_path]
+                else
+                    id_path = widget_desc
+                end
+                pre = id_path.map{ |part| "[#{part}]"}.join('')
+            end
+            def params_for(widget_or_id_path, params)
+                pre = param_name(widget_or_id_path)
+                params.map{ |k, v| "#{pre}[#{k}]=#{v}"}.join('&')
+            end
+        end
+        include SceneMethods # FIXME
+    end
+end; end

data/lib/spiderfw/controller/home_controller.rb ADDED Viewed

@@ -0,0 +1,26 @@
+module Spider
+    class HomeController < Controller
+        include StaticContent
+        route 'spider/public', Spider.controller, :prepend => 'public/'
+        #        route 'spider', Spider.controller
+        def self.route_app(app)
+            #app_path = app.name.gsub('::', '/')
+            app_path = app.route_url
+            Spider::Logger.debug("ROUTING #{app_path} TO #{app.controller}")
+            route(app_path, app.controller, :ignore_case => true)
+        end
+        def self.pub_path
+            Spider.paths[:root]+'/public'
+        end
+        def self.pub_url
+            HTTPMixin.reverse_proxy_mapping('/public')
+        end
+    end
+end

data/lib/spiderfw/controller/http_controller.rb ADDED Viewed

@@ -0,0 +1,112 @@
+require 'spiderfw/controller/spider_controller'
+require 'spiderfw/controller/session/memory_session'
+require 'spiderfw/controller/session/file_session'
+module Spider
+    class HTTPController < Controller
+        include HTTPMixin
+        def initialize(request, response, scene=nil)
+            response.status = Spider::HTTP::OK
+            response.headers = {
+                'Content-Type' => 'text/plain',
+                'Connection' => 'close'
+            }
+            @previous_stdout = $stdout
+            Thread.current[:stdout] = response.server_output
+            $out = ThreadOut
+            $stdout = ThreadOut if Spider.conf.get('http.seize_stdout')
+            request.extend(HTTPRequest)
+            super(request, response, scene)
+        end
+        def before(action='', *arguments)
+            if (@request.env['HTTP_TRANSFER_ENCODING'] == 'Chunked' && !@request.server.supports?(:chunked_request))
+                raise HTTPStatus.NOT_IMPLEMENTED
+            end
+            @request.cookies = Spider::HTTP.parse_query(@request.env['HTTP_COOKIE'], ';')
+            @request.session = Session.get(@request.cookies['sid'])
+            @response.cookies['sid'] = @request.session.sid
+            @response.cookies['sid'].path = '/'
+            @request.params = {}
+            if (@request.env['QUERY_STRING'])
+                @request.params = Spider::HTTP.parse_query(@request.env['QUERY_STRING'])
+            end
+            if (@request.env['REQUEST_METHOD'] == 'POST' && @request.env['HTTP_CONTENT_TYPE'] && @request.env['HTTP_CONTENT_TYPE'].include?('application/x-www-form-urlencoded'))
+                @request.params.merge!(Spider::HTTP.parse_query(@request.read_body))
+            end
+            Locale.clear
+            Locale.init(:driver => :cgi)
+            Locale.set_request(@request.params['lang'], @request.cookies['lang'], @request.env['HTTP_ACCEPT_LANGUAGE'], @request.env['HTTP_ACCEPT_CHARSET'])
+            @request.locale = Locale.current[0]
+            if (action =~ /(.+)\.(\w+)$/) # strip extension, set format
+                action = $1
+                @request.format = $2.to_sym
+            end
+#            Spider.reload_sources if Spider.conf.get('webserver.reload_sources')
+            super(action, *arguments)
+        end
+        def execute(action='', *arguments)
+            # FIXME: cache stripped action?
+            action = $1 if (action =~ /(.+)\.(\w+)$/) # strip extension, set format
+            super(action, *arguments)
+        end
+        def after(action='', *arguments)
+            # FIXME: cache stripped action?
+            action = $1 if (action =~ /(.+)\.(\w+)$/) # strip extension, set format
+            @request.session.persist if @request.session
+            super(action, *arguments)
+        end
+        def ensure(action='', *arguments)
+            dispatch(:ensure, action, *arguments)
+            $stdout = @previous_stdout
+        end
+        def get_route(path)
+            path = path.clone
+            path.slice!(0) if path.length > 0 && path[0].chr == "/"
+            return Route.new(:path => path, :dest => Spider.home.controller, :action => path)
+        end
+        def try_rescue(exc)
+            if exc.is_a?(Spider::Controller::NotFound)
+                Spider.logger.error("Not found: #{exc.path}")
+            else
+                super
+            end
+        end
+        module HTTPRequest
+            # Returns PATH_INFO reversing any proxy mappings if needed.
+            def path
+                Spider::ControllerMixins::HTTPMixin.reverse_proxy_mapping(self.env['PATH_INFO'])
+            end
+            def full_path
+                'http://'+self.env['HTTP_HOST']+path
+            end
+            # Returns the REQUEST_URI reversing any proxy mappings if needed
+            def uri
+                Spider::ControllerMixins::HTTPMixin.reverse_proxy_mapping(self.env['REQUEST_URI'])
+            end
+            # Returns #uri prefixed with http:// and the HTTP_HOST
+            def full_uri
+                'http://'+self.env['HTTP_HOST']+uri
+            end
+        end
+    end
+end

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

@@ -0,0 +1,228 @@
+require 'base64'
+require 'uuid'
+require 'digest/md5'
+require 'macaddr'
+require 'spiderfw/http/http'
+module Spider; module ControllerMixins
+    module HTTPMixin
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+        def redirect(url, code=Spider::HTTP::MOVED_PERMANENTLY)
+            debug "REDIRECTING TO #{url}"
+            @response.status = code
+            @response.headers["Location"] = url
+            @response.headers.delete("Content-Type")
+            @response.headers.delete("Set-Cookie")
+            done
+        end
+        def self.reverse_proxy_mapping(url)
+            return '' unless url
+            if (maps = Spider.conf.get('http.proxy_mapping'))
+                maps.each do |proxy, spider|
+                    return proxy + url[spider.length..-1] if (spider == "" || url[0..spider.length-1] == spider)
+                end
+            end
+            return url
+        end
+        # Returns the http path needed to call the current controller & action.
+        # Reverses any proxy mappings to the Controller#request_path.
+        def request_path
+            HTTPMixin.reverse_proxy_mapping(super)
+        end
+        # Returns the request_path prefixed with http:// and the current host.
+        def request_url
+            'http://'+@request.env['HTTP_HOST']+request_path
+        end
+        # Returns the request_url with query params, if any
+        def request_full_url
+            url = request_url
+            if (@request.env['QUERY_STRING'] && !@request.env['QUERY_STRING'].empty?)
+                url += '?'+@request.env['QUERY_STRING']
+            end
+            return url
+        end
+        def self.output_charset(val)
+            @output_charset = val if val
+            @output_charset || Spider.conf.get('http.charset')
+        end
+        def content_type(ct)
+            @response.headers["Content-Type"] = "#{ct};charset=#{output_charset}"
+        end
+        def before(action='', *arguments)
+            return super if self.is_a?(Spider::Widget)
+             # FIXME: the Spider::Widget check
+            # is needed because with _wt the widget executes without action
+            # Redirect to url + slash if controller is called without action
+            dest = HTTPMixin.reverse_proxy_mapping(@request.env['PATH_INFO'])
+            if (action == '' && dest[-1].chr != '/' && !self.is_a?(Spider::Widget))
+                dest = dest += '/'
+                if (@request.env['QUERY_STRING'] && !@request.env['QUERY_STRING'].empty?)
+                    dest += '?'+@request.env['QUERY_STRING']
+                end
+                redirect(dest)
+            end
+            super
+        end
+        def base_url()
+            HTTPMixin.reverse_proxy_mapping("")
+        end
+        def prepare_scene(scene)
+            scene = super
+            scene.base_url = base_url
+            return scene
+        end
+        def try_rescue(exc)
+            if (exc.is_a?(Spider::Controller::NotFound))
+                @response.status = Spider::HTTP::NOT_FOUND
+                error("Not found: #{exc.path}")
+            elsif (exc.is_a?(Spider::Controller::BadRequest))
+                @response.status = Spider::HTTP::BAD_REQUEST
+            elsif (exc.is_a?(Spider::Controller::Forbidden))
+                @response.status = Spider::HTTP::FORBIDDEN
+            elsif (exc.is_a?(HTTPStatus))
+                @response.status = exc.code
+                Spider::Logger.debug("Sending HTTP status #{exc.code}")
+                return
+            else
+                @response.status = Spider::HTTP::INTERNAL_SERVER_ERROR
+            end
+            super
+        end
+        def challenge_basic_auth()
+            realm ||= http_auth_realm
+            realm ||= 'Secure Area'
+            @response.headers["WWW-Authenticate"] = "Basic realm=\"#{realm}\""
+            @response.status = Spider::HTTP::UNAUTHORIZED
+            render('errors/unauthorized') if self.is_a?(Visual)
+            done
+        end
+        def check_basic_auth(authenticator)
+            if (@request.env['HTTP_AUTHORIZATION'] =~ /Basic (.+)/)
+                pair = Base64.decode64($1)
+                user, pass = pair.split(':')
+                return authenticator.authenticate(:login, {:username => user, :password => pass})
+            end
+        end
+        def challenge_digest_auth(realm=nil)
+            realm ||= http_auth_realm
+            realm ||= 'Secure Area'
+            # nonce
+            now = "%012d" % @request.request_time
+            pk  = Digest::MD5.hexdigest("#{now}:#{digest_instance_key}")[0,32]
+            nonce = [now + ":" + pk].pack("m*").chop # it has 60 length of chars.
+            opaque = [UUID.new.generate].pack("m*").chop
+            header = "Digest realm=\"#{realm}\", qop=\"auth\", nonce=\"#{nonce}\", opaque=\"#{opaque}\""
+            @response.headers['WWW-Authenticate'] = header
+            @response.status = Spider::HTTP::UNAUTHORIZED
+            done
+        end
+        def check_digest_auth(authenticator)
+            # TODO: implement opaque, auth-int
+            if (@request.env['HTTP_AUTHORIZATION'] =~ /Digest (.+)/)
+                parts = $1.split(',')
+                params = {}
+                parts.each do |p|
+                    k, v = p.strip.split('=')
+                    v = v.sub(/^"+/, '').sub(/"+$/, '')
+                    params[k.downcase] = v
+                end
+                ['username', 'realm', 'nonce', 'uri', 'cnonce', 'qop', 'nc', 'response', 'opaque'].each{ |k| return unless params[k] }
+                user = params['username']
+                user = $1 if params['username'] =~ /.+\\(.+)/ # FIXME: Temp fix for windows sending DOMAIN/User
+                pub_time, pk = params['nonce'].unpack("m*")[0].split(":", 2)
+                return unless pub_time && pk
+                return unless Digest::MD5.hexdigest("#{pub_time}:#{digest_instance_key}")[0,32] == pk
+                diff_time = @request.request_time.to_i - pub_time.to_i
+                return if diff_time < 0
+                return if diff_time > Spider.conf.get('http.nonce_life')
+                user = authenticator.load(:username => user, :realm => params['realm'])
+                return unless user
+                ha1 = user.ha1
+                return unless ha1
+                ha2 = Digest::MD5.hexdigest("#{@request.env['REQUEST_METHOD']}:#{params['uri']}")
+                if (params['qop'] == "auth" || params['qop'] == "auth-int")
+                    param2 = ['nonce', 'nc', 'cnonce', 'qop'].map{|key| params[key] }.join(':')
+                    response = Digest::MD5.hexdigest([ha1, param2, ha2].join(':'))
+                else
+                    response = Digest::MD5.hexdigest([ha1, params['nonce'], ha2].join(':'))
+                end
+                # FIXME: temporaneamente disabilitato controllo perché con il login DOMINIO/Utente non corrisponde
+                #return unless response == params['response']
+                return user
+            end
+        end
+        def digest_instance_key
+            Digest::MD5.hexdigest("#{Mac.addr}:plaw15x857m4p671")
+        end
+        def http_auth_realm=(val)
+            @http_auth_realm = val
+        end
+        def http_auth_realm
+            @http_auth_realm || self.class.http_auth_realm
+        end
+        module ClassMethods
+            def http_auth_realm(val=nil)
+                @http_auth_realm = val if val
+                @http_auth_realm
+            end
+        end
+        class HTTPStatus < RuntimeError
+            class << self
+                def method_missing(meth, *args)
+                    if (Spider::HTTP::StatusCodes.const_defined?(meth))
+                        return self.new(Spider::HTTP::StatusCodes.const_get(meth))
+                    end
+                    super
+                end
+            end
+            attr_reader :code
+            def initialize(code)
+                @code = code
+            end
+            def status_message
+                Spider::HTTP.status_messages[@code]
+            end
+        end
+    end
+end; end

data/lib/spiderfw/controller/mixins/static_content.rb ADDED Viewed

@@ -0,0 +1,90 @@
+require 'spiderfw/controller/mixins/http_mixin'
+require 'webrick/httputils'
+require 'mime/types'
+module Spider; module ControllerMixins
+    module StaticContent
+        include Spider::ControllerMixins::HTTPMixin
+        def self.included(klass)
+            klass.extend(ClassMethods)
+            klass.route('public/', :serve_static)
+            klass.route('w/', :serve_widget_static)
+            if (klass < Visual)
+                klass.no_layout('public')
+                klass.no_layout('serve_static')
+            end
+        end
+        module ClassMethods
+            def output_format?(method, format)
+                return true if method == "serve_static"
+                return super
+            end
+            def pub_url
+                self.app.pub_url
+            end
+            def pub_path
+                self.app.pub_path
+            end
+        end
+        def pub_path
+            self.class.pub_path
+        end
+        def pub_url
+            self.class.pub_url
+        end
+        def sanitize_path(path)
+            return path.gsub('..', '')
+        end
+        def serve_static(path=nil)
+            path += ".#{@request.format}" if @request.format
+            raise Spider::Controller::NotFound.new(path) unless path
+            path = sanitize_path(path)
+            full_path = pub_path+'/'+path
+            raise Spider::Controller::NotFound.new(path) unless File.exist?(full_path)
+            output_static(full_path)
+        end
+        def serve_widget_static(path)
+            path = sanitize_path(path)
+            parts = path.split('/public/', 2)
+            raise Spider::Controller::NotFound.new(path) unless parts[1]
+            full_path = self.class.app.widgets_path+'/'+parts[0]+'/public/'+parts[1]
+            raise Spider::Controller::NotFound.new(path) unless File.exist?(full_path)
+            output_static(full_path)
+        end
+        def output_static(full_path)
+            debug("Serving asset: #{full_path}")
+            raise Spider::Controller::NotFound.new(full_path) unless File.exist?(full_path)
+            stat = File.lstat(full_path)
+            ct = File.directory?(full_path) ? "httpd/unix-directory" : WEBrick::HTTPUtils::mime_type(full_path, ::MIME::Types)
+            @response.headers['Content-Type'] = ct
+            @response.headers['Content-Length'] = stat.size
+            @response.headers['Last-Modified'] = stat.mtime.httpdate
+            f = File.open(full_path, 'r')
+            while (block = f.read(1024)) do
+                $out << block
+            end
+        end
+        def prepare_scene(scene)
+            scene = super
+            scene.controller[:pub_url] = pub_url
+            return scene
+        end
+    end
+end; end