spiderfw 0.5

data/apps/drb_server/script/start_server.rb

@@ -0,0 +1,19 @@
+require 'spiderfw'
+require 'apps/drb_server/lib/model_server'
+
+unless ARGV.length == 2
+    puts "Usage: ruby start_server.rb type druby://bind_address:port"
+    exit
+end
+
+server_type = ARGV.shift
+uri = ARGV.shift
+
+case server_type
+when 'model'
+    server = SpiderApps::DrbServer::ModelServer.new(uri)
+    server.start
+else
+    puts "Unrecognized server #{type}"
+    exit
+end

data/apps/hippo/_init.rb

@@ -0,0 +1,10 @@
+module Hippo
+    @description = ""
+    @version = 0.1
+    @path = File.dirname(__FILE__)
+    include Spider::App
+end
+
+require 'apps/hippo/models/mixins/hippo_struct'
+require 'apps/hippo/models/security_user'
+require 'apps/hippo/models/security_group'

data/apps/hippo/models/mixins/hippo_struct.rb

@@ -0,0 +1,210 @@
+module Hippo
+    
+    class SecurityUser < Spider::Model::BaseModel; end
+    class SecurityGroup < Spider::Model::BaseModel; end
+    
+    module HippoStruct
+    
+        def self.included(mod)
+            mod.extend(ClassMethods)
+            mod.mapper_include(Mapper)
+            mod.element :id, Fixnum, :primary_key => true
+            mod.element :cr_date, DateTime
+            mod.element :mod_date, DateTime
+            mod.element :cr_user, Hippo::SecurityUser
+            mod.element :mod_user, Hippo::SecurityUser
+        end
+        
+        def self.base_elements
+            [:id, :cr_date, :mod_date, :cr_user, :mod_user]
+        end
+    
+        module ClassMethods
+            
+            def element(name, type, attributes={}, &proc)
+                el = super
+                if (el.attributes[:junction])
+                    el.model.elements[:id].attributes[:primary_key] = false
+                    el.model.elements[el.attributes[:reverse]].attributes[:primary_key] = true
+                    el.model.elements[el.attributes[:junction_their_element]].attributes[:primary_key] = true
+                end
+                return el
+            end
+
+        
+            def binding(val=nil)
+                if val
+                    @binding = val
+                    elements_array.select{ |el| el.attributes[:added_reverse] }.each do |el|
+                        reverse = el.attributes[:reverse]
+                        if (el.type.binding && el.type.binding[:elements][reverse.to_s])
+                            el_b = el.type.binding[:elements][reverse.to_s]
+                            if (el_b[:type] == "mmbind")
+                                @binding[:elements][el.name.to_s] = {
+                                    :type => "mmbind",
+                                    :table => el_b[:table],
+                                    :local_id => el_b[:remote_id],
+                                    :remote_id => el_b[:local_id]
+                                }
+                            end
+                        end
+                    end
+                    self.mapper.schema # generates the schema
+                end
+                return @binding
+            end
+        
+            def convert_type(type)
+                return type.inspect if (type.is_a?(Hash))
+                convert = {
+                    'text' => String,
+                    'longText' => Spider::DataTypes::Text,
+                    'dateTime' => DateTime,
+                    'int' => Fixnum,
+                    'order' => Fixnum,
+                    'bool' => Spider::DataTypes::Bool,
+                    'real' => Float,
+                    'password' => Spider::DataTypes::Password,
+                    'html' => Spider::DataTypes::Text,
+                    'richText' => Spider::DataTypes::Text
+                }
+                return convert[type] if (convert[type])
+                return convert_struct_name(type)
+            end
+
+            def convert_struct_name(struct_name)
+                ns, local = struct_name.split('::')
+                unless local
+                    local = ns
+                    ns = 'hippo'
+                end
+                local = local[1..-1] if local[0].chr == '_'
+                if @ns_mappings[ns]
+                    app = @ns_mappings[ns]
+                else
+                    app = Spider::Inflector.camelize(ns)
+                end
+                model_name = Spider::Inflector.camelize(local)
+                return "#{app}::#{model_name}"
+            end
+        
+            def extend_model(model, params={})
+                integrated_name = (self.parent_module == model.parent_module) ? model.short_name : model.name
+                integrated_name = Spider::Inflector.underscore(integrated_name).gsub('/', '_')
+                integrated_name = integrated_name.to_sym
+                @extended_models ||= {}
+                @extended_models[model] = integrated_name
+                attributes = {}
+                attributes[:hidden] = true
+                attributes[:delete_cascade] = params[:delete_cascade]
+            
+                # create junction            
+                orig_type = model
+                assoc_type_name = Spider::Inflector.camelize(model.name).split('::')[1]
+                
+                attributes[:junction] = true
+                attributes[:junction_id] ||= :id
+                self_name = self.short_name.gsub('/', '_').downcase.to_sym
+                attributes[:reverse] = self_name
+                other_name = Spider::Inflector.underscore(orig_type.short_name == self.short_name ? orig_type.name : orig_type.short_name).gsub('/', '_').downcase.to_sym
+                other_name = :"#{other_name}_ref" if (orig_type.elements[other_name])
+                attributes[:junction_their_element] = other_name
+                assoc_type = const_set(assoc_type_name, Class.new(Spider::Model::BaseModel)) # FIXME: maybe should extend self, not the type
+                assoc_type.attributes[:sub_model] = self
+                #assoc_type.element(attributes[:junction_id], Fixnum, :primary_key => true, :autoincrement => true, :hidden => true)
+                assoc_type.element(self_name, self, :hidden => true, :reverse => name, :primary_key => true) # FIXME: must check if reverse exists?
+                # FIXME! fix in case of clashes with existent elements
+                assoc_type.element(other_name, orig_type, :primary_key => true)
+                assoc_type.integrate(other_name, :hidden => true, :no_pks => true)
+                attributes[:association_type] = assoc_type
+                integrated = element(integrated_name, model, attributes)
+                integrate(integrated_name, :no_pks => true) # scazza perché prende le pks da sopra
+            end
+            
+            def get_storage(storage_string='default')
+                storage = super
+                storage.extend(HippoStorage)
+                return storage
+            end
+        
+        end
+    
+        module Mapper
+        
+            def generate_schema(schema=nil)
+                return super unless @model.binding
+                schema = Spider::Model::Storage::Db::DbSchema.new
+                schema.table = @model.binding[:table]
+                @model.binding[:elements].each do |el, binding|
+                    element = @model.elements[el.to_sym]
+                    next unless element
+                    if (binding[:type] == 'mmbind')
+                        junction = element.model.mapper.schema
+                        junction.table = binding[:table]
+                        junction.foreign_keys[element.attributes[:reverse]] ||= {}
+                        junction.foreign_keys[element.attributes[:reverse]][@model.primary_keys[0].name] ||= {}
+                        junction.foreign_keys[element.attributes[:reverse]][@model.primary_keys[0].name][:name] = binding[:local_id]
+                        junction.foreign_keys[element.attributes[:junction_their_element]] ||= {}
+                        junction.foreign_keys[element.attributes[:junction_their_element]][element.type.primary_keys[0].name] ||= {}
+                        junction.foreign_keys[element.attributes[:junction_their_element]][element.type.primary_keys[0].name][:name] = binding[:remote_id]
+                    elsif (element.model? && !element.multiple?)
+                        schema.foreign_keys[element.name] ||= {}
+                        schema.foreign_keys[element.name][element.model.primary_keys[0].name] ||= {}
+                        schema.foreign_keys[element.name][element.model.primary_keys[0].name][:name] = binding[:field]
+                    else
+                        schema.columns[element.name] ||= {}
+                        schema.columns[element.name][:name] = binding[:field]
+                    end
+                end
+                if (@model.binding[:parent_ref])
+                    pr = @model.binding[:parent_ref]
+                    extended = nil
+                    @model.extended_models.each { |k, v| extended = k; break }
+                    element = @model.elements[@model.extended_models[extended]]
+                    schema.foreign_keys.delete(@model.extended_models[extended])
+                    junction = element.model.mapper.schema
+                    junction.table = pr[:table]
+                    junction.foreign_keys[element.attributes[:reverse]] ||= {}
+                    junction.foreign_keys[element.attributes[:reverse]][@model.primary_keys[0].name] ||= {}
+                    junction.foreign_keys[element.attributes[:reverse]][@model.primary_keys[0].name][:name] = pr[:child_id]
+                    junction.foreign_keys[element.attributes[:junction_their_element]] ||= {}
+                    junction.foreign_keys[element.attributes[:junction_their_element]][element.type.primary_keys[0].name] ||= {}
+                    junction.foreign_keys[element.attributes[:junction_their_element]][element.type.primary_keys[0].name][:name] = pr[:parent_id]
+                end
+                @model.elements_array.each do |el|
+                    unless @model.binding[:elements][el.name.to_s] || HippoStruct.base_elements.include?(el.name)
+                        schema.pass[el.name] = true 
+                    end
+                end
+#                debugger if @model.name.to_s == "AgendaHippo::Ordine"
+                return super(schema)
+            end
+        
+        end
+        
+        module HippoStorage
+            
+            def column_type(type, attributes)
+                return super(String, attributes) if (type == DateTime)
+                return super
+            end
+            
+             def value_to_mapper(type, value)
+                 return value unless value
+                 case type.name
+                 when 'DateTime'
+                     begin
+                         return DateTime.parse(value)
+                     rescue ArgumentError
+                         return nil
+                     end
+                 end
+                 return super
+             end
+            
+        end
+    
+    
+    end
+    
+end

data/apps/hippo/models/security_group.rb

@@ -0,0 +1,21 @@
+module Hippo
+    
+   class SecurityGroup < Spider::Model::BaseModel
+       include HippoStruct
+
+       element :name, String
+#       element :parent, Hippo::SecurityGroup
+       
+       use_storage 'hippo'
+       # binding({
+       #     :table => '_SECURITY_GROUP',
+       #     :elements => {
+       #         "name" => {:field => "NAME"},
+       #         "parent" => {:field => "ID_PARENT"}
+       #     }
+       # 
+       # })
+
+   end
+   
+end

data/apps/hippo/models/security_user.rb

@@ -0,0 +1,29 @@
+require 'apps/hippo/models/security_group'
+
+module Hippo
+    
+   class SecurityUser < Spider::Model::BaseModel
+       include HippoStruct
+
+       element :login, String, :required => true
+       element :password, Spider::DataTypes::Password
+       element :groups, Hippo::SecurityGroup, :multiple => true, :label => "Gruppi"
+       
+       use_storage 'hippo'
+       binding({
+           :table => '_SECURITY_USER',
+           :elements => {
+               "login" => {:field => "LOGIN"},
+               "password" => {:field => "PASSWORD"},
+               "groups" => {
+                  :type=>"mmbind", 
+                  :local_id=>"ID__SECURITY_USER",
+                  :remote_id=>"ID__SECURITY_GROUP", 
+                  :table=>"_SECURITY_GROUP_REF__SECURITY_USER"
+              } 
+           }
+       })
+
+   end
+   
+end

data/apps/messenger/_init.rb

@@ -0,0 +1,24 @@
+Spider.load_app('core/admin')
+Spider.load_app('worker')
+
+module Spider
+
+    module Messenger
+
+        @description = ""
+        @version = 0.1
+        @path = File.dirname(__FILE__)
+        @controller = :MessengerController
+        include Spider::App
+
+    end
+    
+    Spider::Admin.add(Messenger)
+    
+end
+
+require 'apps/messenger/messenger'
+require 'apps/messenger/controllers/messenger_controller'
+require 'apps/messenger/controllers/mixins/messenger_controller_mixin'
+
+# gem dependencies: mailfactory for sending email from templates

data/apps/messenger/config/options.rb

@@ -0,0 +1,15 @@
+module Spider
+    
+    config_option 'messenger.smtp.address', _("SMTP address to use when sending mail"), :default => 'localhost'
+    config_option 'messenger.smtp.port', _("SMTP port"), :default => 25
+    config_option 'messenger.smtp.domain', _("HELO domain"), :default => 'localhost'
+    config_option 'messenger.smtp.username', _("SMTP authentication username"), :default => nil
+    config_option 'messenger.smtp.password', _("SMTP authentication password"), :default => nil
+    config_option 'messenger.smtp.auth_scheme', _("SMTP authentication scheme"), :default => nil, :type => Symbol,
+        :choices => [nil, :plain, :login, :cram_md5]
+        
+    config_option 'messenger.email.retries', :type => Fixnum, :default => 5
+    config_option 'messenger.email.retry_time', _("Seconds to wait until retry (will be incremented at each retry)"), 
+        :type => Fixnum, :default => 10
+    
+end

data/apps/messenger/config/worker.rb

@@ -0,0 +1,3 @@
+Spider::Worker.every('2m') do
+    Spider::Messenger.process_queue(:email)
+end

data/apps/messenger/controllers/messenger_controller.rb

@@ -0,0 +1,80 @@
+module Spider; module Messenger
+
+    class MessengerController < Spider::PageController
+        layout [:spider_admin, 'messenger.layout']
+        
+        Messenger.queues.keys.each do |queue|
+            route queue.to_s, self, :do => lambda{ |action| @queue = @dispatch_action }
+        end
+
+        def before(action='', *params)
+            if (@queue)
+                q = Messenger.queues[@queue.to_sym]
+                raise NotFound(action) unless q
+                @queue_model = q[:model]
+                @scene.queue_model = @queue_model
+            end
+            super
+            @response.headers['Content-Type'] = 'text/html'
+        end
+        
+        def execute(action='', *params)
+            return super unless @queue
+            # debugger
+            # raise NotFound.new(action) unless @queue
+            super
+        end
+
+        def index
+            return queue if (@queue)
+            @scene.queues = []
+            @scene.queue_info = {}
+            Messenger.queues.each do |name, details|
+                @scene.queues << name
+                model = details[:model]
+                @scene.queue_info[name] = {
+                    :label => details[:label],
+                    :sent => model.sent_messages.total_rows,
+                    :queued => model.queued_messages.total_rows,
+                    :failed => model.failed_messages.total_rows
+                }
+            end
+            render 'index'
+        end
+
+        def queue
+            q = Messenger.queues[@queue.to_sym]
+            @scene.title = q[:label]
+            @scene.queued = q[:model].queued_messages
+            @scene.sent = q[:model].sent_messages
+            @scene.failed = q[:model].failed_messages
+            render 'queue'
+        end
+
+        def failed
+        end
+
+        def sent
+        end
+
+        private
+
+        def list(queryset=nil)
+            render 'list'
+            # 
+            # tmpl = init_template('list')
+            # tmpl.init(@scene)
+            # tmpl.exec
+            # tmpl.render(@scene)
+        end
+
+
+
+
+
+
+
+    end
+
+
+end; end

data/apps/messenger/controllers/mixins/messenger_controller_mixin.rb

@@ -0,0 +1,54 @@
+require 'erb'
+require 'mailfactory'
+
+Spider.register_resource_type(:email, :extensions => ['erb'], :path => 'templates/email')
+
+module Spider; module Messenger
+    
+    module MessengerControllerMixin
+        
+        # Compiles an e-mail from given template and scene, and sends it using
+        # #Messenger::email
+        # template is the template name (found in templates/email), without the extension
+        # will use template.html.erb and template.txt.erb if they exist, template.erb otherwise.
+        # attachments must be an array of hashes like 
+        # {:file => '/full/file/path', :type => 'mime type', :file_name => 'optional email file name', 
+        # :headers => 'optional string or array of additional headers'}
+        def email(template, scene, from, to, headers={}, attachments=[], params={})
+            path_txt = self.class.find_resource_path(:email, template+'.txt')
+            path_txt = nil unless File.exist?(path_txt)
+            path_html = self.class.find_resource_path(:email, template+'.txt')
+            path_html = nil unless File.exist?(path_html)
+            scene_binding = scene.instance_eval{ binding }
+            if (path_txt || path_html)
+                text = ERB.new(IO.read(path_txt)).result(scene_binding) if path_txt
+                html = ERB.new(IO.read(path_html)).result(scene_binding) if path_html
+            else
+                path = self.class.find_resource_path(:email, template)
+                text = ERB.new(IO.read(path)).result(scene_binding)
+            end
+            mail = MailFactory.new
+            mail.To = to
+            mail.From = from
+            headers.each do |key, value|
+                mail.add_header(key, value)
+            end
+            mail.html = html if html
+            mail.text = text if text
+            debugger
+            if (attachments && !attachments.empty?)
+                attachments.each do |att|
+                    if (att[:file_name])
+                        mail.add_attachment_as(att[:file], att[:file_name], att[:type], att[:headers])
+                    else
+                        mail.add_attachment(att[:file], att[:type], att[:headers])
+                    end
+                end
+            end
+            mail_headers, mail_body = mail.to_s.split("\r\n\r\n")
+            Messenger.email(from, to, mail_headers, mail_body, params)
+        end
+        
+    end
+    
+end; end

data/apps/messenger/messenger.rb

@@ -0,0 +1,94 @@
+require 'apps/messenger/models/email'
+
+
+module Spider
+    
+    module Messenger
+        
+        def self.queues
+            {
+                :email => {
+                    :label => _("Email"),
+                    :model => Email
+                }
+            }
+        end
+                
+        def self.process_queue(queue)
+            @mutex ||= Mutex.new
+            return if @mutex.locked?
+            raise ArgumentError, "Queue #{name} not found" unless self.queues[queue]
+            model = self.queues[queue][:model]
+            @mutex.synchronize do
+                now = DateTime.now
+                list = model.where{ (sent == nil) & (next_try <= now) }
+                list.each do |msg|
+                    res = false
+                    exc = nil
+                    begin
+                        res = self.send(:"send_#{queue}", msg)
+                    rescue => exc
+                    end
+                    if (res)
+                        msg.sent = now
+                        msg.next_try = nil
+                        msg.backend_response = res
+                        msg.save
+                    else
+                        msg.last_try = now
+                        msg.attempts ||= 0
+                        msg.attempts += 1
+                        if (exc)
+                            msg.backend_response = exc.to_s
+                        else
+                            msg.backend_response = res
+                        end
+                        if (msg.attempts >= Spider.conf.get("messenger.#{queue}.retries"))
+                            msg.next_try = nil
+                        else
+                            msg.next_try = msg.last_try.to_local_time + (msg.attempts * Spider.conf.get("messenger.#{queue}.retry_time") * 60)
+                        end
+                        msg.save
+                    end
+                            
+                end
+            end
+        end
+        
+        def self.email(from, to, headers, body, params={})
+            if (headers.is_a?(Hash))
+                headers = headers.inject(""){ |h, p| h += "#{p[0]}: #{p[1]}\n"}
+            elsif(headers.is_a?(Array))
+                headers = headers.join("\n")
+            end
+            headers = "To: #{to}\r\n"+headers unless headers =~ /^To/
+            headers = "From: #{from}\r\n"+headers unless headers =~ /^From/
+            msg = Email.new(
+                :from => from, :to => to, :headers => headers, :body => body
+            )
+            msg.next_try = params[:send_from] || DateTime.now
+            msg.save
+            return msg
+        end
+        
+        # Actual SMTP send.
+        def self.send_email(msg)
+            require 'net/smtp'
+            res = false
+            Net::SMTP.start(
+              Spider.conf.get('messenger.smtp.address'),
+              Spider.conf.get('messenger.smpt.port'),
+              Spider.conf.get('messenger.smtp.domain'),
+              Spider.conf.get('messenger.smtp.username'),
+              Spider.conf.get('messenger.smtp.password'),
+              Spider.conf.get('messenger.smtp.auth_scheme')
+            ) do |smtp|
+                msg_str = msg.headers+"\r\n"+msg.body
+                res = smtp.send_message msg_str, msg.from, msg.to
+            end
+            return res.string
+        end
+        
+    end
+    
+end

data/apps/messenger/models/email.rb

@@ -0,0 +1,22 @@
+require 'apps/messenger/models/message'
+
+module Spider; module Messenger
+    
+    class Email < Message
+        class_table_inheritance :add_polymorphic => true
+        element :from, String, :label => _("From")
+        element :to, String, :label => _("To")
+        element :headers, Text, :label => _("Headers")
+        element :subject, String, :label => _("Subject"), :computed_from => [:headers]
+        element :body, Text, :label => _("Body")
+        
+        def subject
+            if (self.headers =~ /^Subject: (.+)$/)
+                return $1
+            end
+            return ''
+        end
+                
+    end
+    
+end; end

data/apps/messenger/models/message.rb

@@ -0,0 +1,44 @@
+require 'uuid'
+
+module Spider; module Messenger
+    
+    class Message < Spider::Model::Managed
+        element :ticket, UUID, :label => _("Ticket")
+        element :last_try, DateTime, :label => _("Last try")
+        element :next_try, DateTime, :label => _("Next try")
+        element :attempts, Fixnum, :label => _("Attempts")
+        element :backend_response, String, :label => _("Last status")
+        element :sent, DateTime, :label => _("Sent at")
+        
+        def status
+            if self.sent
+                :sent
+            elsif (self.next_try)
+                :queue
+            else
+                :failed
+            end
+        end
+        
+        def self.sent_messages
+            self.where{ q.sent .not nil }
+        end
+        
+        def self.queued_messages
+            self.where{ (q.sent == nil) & (q.next_try .not nil) }
+        end
+        
+        def self.failed_messages
+            self.where{ (q.sent == nil) & (q.next_try .not nil) }
+        end
+        
+        with_mapper do
+            def before_save(obj, mode)
+                obj.ticket = ::UUID.generate if mode == :insert
+                super
+            end
+        end
+        
+    end
+    
+end; end