spiderfw 0.5

data/apps/worker/cmd.rb

@@ -0,0 +1,65 @@
+require 'cmdparse'
+
+module Spider; module Worker
+
+    class Cmd < ::CmdParse::Command
+
+        def initialize
+            super( 'worker', true)
+            
+            status = CmdParse::Command.new('status', false )
+            status.short_desc = _("Check worker process status")
+            status.set_execution_block do
+                pid = Worker.running?
+                if (pid)
+                    puts "Worker running (#{pid})"
+                else
+                    puts "Worker not running"
+                end
+            end
+            self.add_command(status)
+            
+            start = CmdParse::Command.new('start', false)
+            start.short_desc = _("Start worker")
+            start.options = CmdParse::OptionParserWrapper.new do |opt|
+                opt.on("--daemonize", _("Daemonize worker"), "-d"){ |d|
+                    @daemonize = true
+                }
+            end
+            start.set_execution_block do
+                if (@daemonize)
+                    Worker.options[:fork] = true
+                    Worker.options[:detach] = true
+                else
+                    Worker.options[:fork] = false
+                    Worker.options[:detach] = false
+                end
+                Worker.app_startup
+                if (@daemonize)
+                    STDIN.reopen "/dev/null"       # Free file descriptors and
+                    STDOUT.reopen "/dev/null", "a" # point them somewhere sensible
+                    STDERR.reopen STDOUT           # STDOUT/STDERR should go to a logfile
+                else
+                    # trap('TERM') { Worker.app_shutdown }
+                    #                     trap('INT') { Worker.app_shutdown }
+                    Worker.join
+                end
+            end
+            self.add_command(start)
+            
+            stop = CmdParse::Command.new('stop', false)
+            stop.short_desc = _("Stop worker")
+            stop.set_execution_block do
+                Worker.app_shutdown
+            end
+            self.add_command(stop)
+            
+            
+        end
+
+    end
+
+ 
+
+
+end; end

data/apps/worker/config/options.rb

@@ -0,0 +1,9 @@
+module Spider
+    
+    config_option 'worker.fork', :type => Spider::DataTypes::Bool, :default => lambda{
+      RUBY_PLATFORM =~ /win32|mingw32/ ? false : true
+    }
+    config_option 'worker.detach', :type => Spider::DataTypes::Bool, :default => true
+    config_option 'worker.jobs_interval', _("Seconds between each jobs run"), :type => Fixnum, :default => 60
+    
+end

data/apps/worker/lib/runner.rb

@@ -0,0 +1,43 @@
+require 'rufus/scheduler'
+
+module Spider; module Worker
+    
+    
+    class Runner
+        
+        def initialize
+            @scheduler = Rufus::Scheduler.start_new
+        end
+        
+        def stop
+            @scheduler.stop
+        end
+        
+        def join
+            @scheduler.join
+        end
+        
+        def every(time, params=nil, &proc)
+            if (params)
+                @scheduler.every(time) do
+                    params[:obj].send(params[:method], *params[:arguments])
+                end
+            else
+                @scheduler.every(time, &proc)
+            end
+        end
+        
+        def cron(time, params=nil, &proc)
+            if (params)
+                @scheduler.cron(time) do
+                    params[:obj].send(params[:method], *params[:arguments])
+                end
+            else
+                @scheduler.cron(time, &proc)
+            end
+        end
+        
+    end
+    
+    
+end; end

data/apps/worker/lib/task.rb

@@ -0,0 +1,9 @@
+module Spider; module Worker
+    
+    class Task
+       
+        
+        
+    end
+    
+end; end

data/apps/worker/models/job.rb

@@ -0,0 +1,20 @@
+module Spider; module Worker
+    
+    class Job < Spider::Model::Managed
+        element :uuid, UUID
+        element :description, String
+        element :time, DateTime
+        element :task, String
+        element :status, {
+            'done' => 'Done', 'failed' => 'Failed'
+        }
+        
+        def run
+            t = self.task.untaint
+            $SAFE = 4
+            eval(t)
+        end
+        
+    end
+    
+end; end

data/apps/worker/worker.rb

@@ -0,0 +1,168 @@
+require 'thread'
+require 'fileutils'
+require 'apps/worker/lib/runner'
+require 'apps/worker/models/job'
+
+module Spider
+
+    module Worker
+        @pid_file = Spider.paths[:var]+'/run/worker.pid'
+        @script_file = Spider.paths[:config]+'/worker.rb'
+        @scripts_dir = Spider.paths[:config]+'/worker'
+        @mutex = Mutex.new
+        @options = {
+            :fork => Spider.conf.get('worker.fork'),
+            :detach => Spider.conf.get('worker.detach')
+        }
+        
+        def self.pid_file
+            @pid_file
+        end
+        
+        def self.options
+            @options
+        end
+        
+        
+        def self.app_startup
+            
+        end
+        
+        def self.app_startup
+            @runner = start_runner unless running?
+        end
+        
+        def self.app_shutdown
+            @mutex.try_lock || return
+            Spider::Logger.info("Shutting down worker in #{Process.pid}")
+            if @runner
+                unless @runner == Thread.current
+                    @runner.stop
+                    @runner = nil
+                end
+            elsif(File.exist?(@pid_file))
+                begin
+                    pid = IO.read(@pid_file).to_i
+                    unless pid == Process.pid
+                        Spider::Logger.info("Sending TERM signal to worker #{pid}")
+                        Process::kill 'TERM', pid
+                    end
+                rescue Errno::ENOENT
+                end
+            end
+            begin
+                File.unlink(@pid_file)
+            rescue Errno::ENOENT
+            end
+            @mutex.unlock
+        end
+        
+        def self.start_runner
+            start = lambda do
+                if @mutex.try_lock
+                    return false if File.exist?(@pid_file)
+                    FileUtils.mkdir_p(File.dirname(@pid_file))
+                    pid_file = File.new(@pid_file, 'w')
+                    return false unless pid_file.flock(File::LOCK_EX|File::LOCK_NB) # another istance is creating the worker
+                    pid_file << Process.pid
+                    pid_file.flock(File::LOCK_UN)
+                    pid_file.close
+                    Spider::Logger.info("Starting worker #{Process.pid}")
+                    @runner = Runner.new
+                    if (File.exist?(@script_file))
+                        load @script_file
+                    end
+                    if File.directory?(@scripts_dir)
+                        Dir.new(@scripts_dir).each do |script|
+                            next if script[0].chr == '.'
+                            load @scripts_dir+'/'+script
+                        end
+                    end
+                    # every(Spider.conf.get('worker.jobs_interval').to_s+'s') do
+                    #     self.run_jobs
+                    # end
+                    @mutex.unlock
+                end
+            end
+            if (options[:fork])
+                forked = Spider.fork do
+                    $0 = 'spider-worker'
+                    trap('TERM') { app_shutdown }
+                    trap('INT') { app_shutdown }
+                    start.call
+                    @runner.join if @runner
+                end
+                Process.detach(forked) if (options[:detach])
+                @runner = nil
+            else
+                start.call
+            end
+            return @runner
+        end
+        
+        def self.running?
+            return Process.pid if @runner
+            
+            return false unless File.exist?(@pid_file)
+            pid = IO.read(@pid_file).to_i
+            begin
+                Process::kill 0, pid
+                return pid
+            rescue Errno::ESRCH
+                File.unlink(pid_file)
+                return false
+            end
+        end
+        
+        def self.in(time, proc_string)
+            secs = Rufus.parse_time_string(time)
+            self.at(Time.now+secs, proc_string)
+        end
+        
+        def self.at(time, proc_string)
+            job = Job.new(:uuid => ::UUID.new.generate, :time => time, :task => proc_string)
+            job.save
+            return job.uuid
+        end
+        
+        def self.cron(time, params, &proc)
+            raise "The cron method must be used only in worker init scripts" unless @runner
+            check_params(params) if params
+            @runner.cron(time, params)
+        end
+        
+        def self.every(time, params=nil, &proc)
+            raise "The every method must be used only in worker init scripts" unless @runner # Only in config?
+            check_params(params) if params
+            @runner.every(time, params, &proc)
+        end
+        
+        def self.check_params(params)
+            raise ArgumentError, "Missing object" unless params[:obj]
+            raise ArgumentError, "Missing method" unless params[:method]
+            params[:arguments] ||= []
+        end
+        
+        def self.join
+            @runner.join if @runner
+        end
+        
+        def self.run_jobs
+            Spider::Logger.debug("Worker running jobs queue")
+            jobs = Job.where{ (status == nil) & (time <= DateTime.now) }
+            jobs.each do |job|
+                begin
+                    job.run
+                    job.status = 'done'
+                rescue => exc
+                    Spider::Logger.error("Worker job #{job.uuid} failed with error: #{exc.message}")
+                    job.status = 'failed'
+                end
+                job.save
+            end
+        end
+
+    end
+
+
+end

data/bin/spider

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'spiderfw/env'
+require 'spiderfw/cmd/cmd'
+cmd = Spider::CommandLine::Cmd.new
+cmd.parse()
+
+

data/blueprints/app/_init.rb

@@ -0,0 +1,10 @@
+require 'apps/<%= app_path %>/controllers/<%= app_name %>_controller.rb'<% tab = (modules.length > 1) ? "    " : "" %><%= "\n" if (modules.length > 1) %>
+<%= modules[0..-2].inject(""){ |s, mod| s+= "; " if (s.length > 0); s+="module #{mod}"}+"\n" if (modules.length > 1)%>
+<%=tab%>module <%=modules[-1]%>
+<%=tab%>    @description = ""
+<%=tab%>    @version = 0.1
+<%=tab%>    @path = File.dirname(__FILE__)
+<%=tab%>    @controller = :<%= module_name %>Controller
+<%=tab%>    include Spider::App
+<%=tab%>end
+<%= "\n"+modules[0..-2].inject(""){ |s, mod| s+= "; " if (s.length > 0); s+="end" if (modules.length > 1)} %>

data/blueprints/app/controllers/__APP___controller.rb

@@ -0,0 +1,14 @@
+<%= modules[0..-2].inject(""){ |s, mod| s+= "module #{mod}; "} %>module <%=modules[-1]%>
+    
+    class <%= module_name %>Controller < Spider::AppController
+        
+        layout '<%= app_name %>'
+    
+        def index
+            @scene.msg = 'Hello!'
+            render('index')
+        end
+    
+    end
+    
+<%= modules[0..-2].inject("") { |str, mod| str+= 'end; '} %>end

data/blueprints/app/views/__APP__.layout.shtml

@@ -0,0 +1,8 @@
+<html>
+    <head></head>
+    <body>
+        <div id="content">
+            <sp:yield />
+        </div>
+    </body>
+</html>

data/blueprints/app/views/index.shtml

@@ -0,0 +1,3 @@
+<div id="message">
+    { @msg }
+</div>

data/blueprints/install/config/config.yml

@@ -0,0 +1,14 @@
+runmode: 'devel'
+template.cache.disable: true
+client.text_editor: 'textmate'
+locale: 'it'
+session.store: 'file'
+
+#set devel:
+storages:
+    default: 
+        url: 'db:sqlite://var/db.sqlite'
+    
+set devel:
+    debugger.start: true
+    debug.console.level: DEBUG

data/blueprints/install/init.rb

@@ -0,0 +1,3 @@
+Spider.load_apps 'core'
+
+Spider.route_apps

data/lib/spiderfw/app.rb

@@ -0,0 +1,186 @@
+require 'spiderfw/controller/app_controller'
+require 'fileutils'
+
+module Spider
+    
+    module App
+        
+        def self.included(mod)
+            mod.module_eval do
+                
+                include Spider::DataTypes
+                
+                #@controller ||= :"Spider::AppController"
+                class << self
+                    attr_reader :path, :pub_path, :test_path, :setup_path, :widgets_path, :views_path, :tags_path, :models_path
+                    attr_reader :short_name, :route_url, :label, :version
+                    attr_reader :short_prefix
+                    attr_reader :command
+                    
+                    def init
+                        @short_name ||= Inflector.underscore(self.name).gsub('/', '_')
+                        @pub_path ||= @path+'/public'
+                        @test_path ||= @path+'/test'
+                        @setup_path ||= @path+'/setup'
+                        @models_path ||= @path+'/models'
+                        @widgets_path ||= @path+'/widgets'
+                        @views_path ||= @path+'/views'
+                        @tags_path ||= @path+'/tags'
+                        @route_url ||= Inflector.underscore(self.name)
+                        @label ||= @short_name.split('_').each{ |p| p[0] = p[0].chr.upcase }.join(' ')
+                        @version = Gem::Version.new(@version.to_s) unless @version.is_a?(Gem::Version)
+                        find_tags
+                    end
+                    
+                    def request_url
+                        Spider::ControllerMixins::HTTPMixin.reverse_proxy_mapping('/'+@route_url)
+                    end
+                    
+                    def pub_url
+                        request_url+'/public'
+                    end
+                    
+                    def controller
+                        #controllers = self.const_get(:Controllers)
+                        if (!@controller || !const_defined?(@controller))
+                            @controller = :AppController
+                            return const_set(@controller, Spider::AppController.clone)
+                            
+                        end
+                        return const_get(@controller)
+                    end
+                    
+                    def models(container=nil)
+                        container ||= self
+                        mods = []
+                        container.constants.each do |c|
+                            begin
+                                mods += get_models(container.const_get(c))
+                            rescue LoadError
+                            end
+                        end
+                        return mods
+                    end
+                    
+                    def get_models(m)
+                        ms = []
+                        if m.respond_to?(:subclass_of?) && m.subclass_of?(Spider::Model::BaseModel)
+                             ms << m
+                             m.constants.each do |c|
+                                 sub_mod = m.const_get(c)
+                                 next if !sub_mod.subclass_of?(Spider::Model::BaseModel) || sub_mod.app != self
+                                 next if sub_mod == m
+                                 ms += get_models(sub_mod)
+                             end
+                         elsif (m.is_a?(Module) && !m.is_a?(Class))
+                             return models(m)
+                         end
+                         return ms
+                    end
+                    
+                    def controllers
+                        self.constants.map{ |m| const_get(m) }.select{ |m| m.subclass_of? Spider::Controller }
+                    end
+                    
+                    def register_tag(tag, obj)
+                        @tags ||= {}
+                        @tags[tag] = obj
+                    end
+                    
+                    def get_tag(tag)
+                        @tags[tag]
+                    end
+                    
+                    def has_tag?(tag)
+                        return false unless @tags
+                        @tags[tag] ? true : false
+                    end
+                    
+                    def route(path, dest=nil, options=nil)
+                        self.controller.route(path, dest, options)
+                    end
+                    
+                    def relative_path
+                        if (@path.index(Spider.paths[:apps]) == 0)
+                            return @path[Spider.paths[:apps].length+1..-1]
+                        else
+                            return @path[Spider.paths[:core_apps].length+1..-1]
+                        end
+                    end
+                    
+                    def find_tags
+                        return unless File.directory?(@tags_path)
+                        Dir.new(@tags_path).each do |entry|
+                            next if entry[0].chr == '.'
+                            next unless File.extname(entry) == '.erb'
+                            name = File.basename(entry, '.erb')
+                            klass = Spider::Tag.new_class(@tags_path+'/'+entry)
+                            const_set(Spider::Inflector.camelize(name).to_sym, klass)
+                            Spider::Logger.debug("REGISTERED TAG #{name}, #{klass}")
+                            register_tag(name, klass)
+                        end
+                    end
+
+                    def app
+                        self
+                    end
+                    
+                    def req(*list)
+                        list.each do |file|
+                            require @path+'/'+file
+                        end
+                    end
+                    
+                    def installed_version_path
+                         "#{Spider.paths[:var]}/apps/#{self.name}/installed_version"
+                    end
+                    
+                    def installed_version
+                        FileUtils.mkpath(File.dirname(installed_version_path))
+                        return unless File.exist?(installed_version_path)
+                        return Gem::Version.new(IO.read(installed_version_path))
+                    end
+                    
+                    def installed_version=(version)
+                        FileUtils.mkpath(File.dirname(installed_version_path))
+                        version = Gem::Version.new(version) unless version.is_a?(Gem::Version)
+                        File.open(installed_version_path, 'w') do |f|
+                            f << version.to_s
+                        end
+                    end
+                    
+                    
+                end
+                
+                # controllers = Spider::App::Controllers.clone
+                # controllers.app = mod
+                # Spider.logger.debug("Controllers.app")
+                # Spider.logger.debug(controllers.to_s)
+                # Spider.logger.debug(controllers.app)
+                #     
+                # mod.const_set(:Controllers, controllers) unless mod.const_defined?(:Controllers)
+                # Spider.logger.debug(Controllers)
+            end
+            mod.init()
+            # routes_file = "#{mod.path}/routes.rb"
+            # if (File.exist?(routes_file))
+            #     load(routes_file)
+            # else
+            #     mod.controller.route('/', mod.name+'::MainController')
+            # end
+            Spider::add_app(mod)
+        end
+        
+        # module Controllers
+        #     def self.app=(app)
+        #         @app = app
+        #     end
+        #     def self.app
+        #         @app
+        #     end
+        # 
+        # end
+        
+    end
+    
+end

data/lib/spiderfw/autoload.rb

@@ -0,0 +1,12 @@
+module Spider
+    autoload :Logger,               "spiderfw/utils/logger"
+    autoload :App,                  "spiderfw/app"
+    autoload :Controller,           "spiderfw/controller/controller"
+    autoload :PageController,       "spiderfw/controller/page_controller"
+    autoload :Dispatcher,           "spiderfw/controller/dispatcher"
+    autoload :Router,               "spiderfw/controller/router"
+    autoload :Template,             "spiderfw/templates/template"
+    autoload :HTTP,                 "spiderfw/http/http"
+
+
+end