lipsiadmin 3.3.4 → 3.4.0

data/lib/loops/process_manager.rb

@@ -0,0 +1,101 @@
+require 'loops/worker'
+require 'loops/worker_pool'
+
+module Lipsiadmin
+  module Loops
+    class ProcessManager#:nodoc:
+      attr_reader :logger
+
+      def initialize(config, logger)
+        @config = {
+          'poll_period' => 1,
+          'workers_engine' => 'fork'
+        }.merge(config)
+
+        @logger = logger
+        @worker_pools = {}
+        @shutdown = false
+      end
+
+      def start_workers(name, number, &blk)
+        raise "Need a worker block!" unless block_given?
+
+        logger.debug("Creating a workers pool of #{number} workers for #{name} loop...")
+        @worker_pools[name] = Lipsiadmin::Loops::WorkerPool.new(name, logger, @config['workers_engine'], &blk)
+        @worker_pools[name].start_workers(number)
+      end
+
+      def monitor_workers
+        setup_signals
+
+        logger.debug('Starting workers monitoring code...')
+        loop do
+          logger.debug('Checking workers\' health...')
+          @worker_pools.each do |name, pool|
+            break if @shutdown
+            pool.check_workers
+          end
+
+          break if @shutdown
+          logger.debug("Sleeping for #{@config['poll_period']} seconds...")
+          sleep(@config['poll_period']) 
+        end
+      ensure
+        unless wait_for_workers(10)
+          logger.debug("Some workers are still alive after 10 seconds of waiting. Killing them...")
+          stop_workers(true)
+          wait_for_workers(5)
+        end
+      end
+
+      def setup_signals
+        # Zombie rippers
+        trap('CHLD') {}
+        trap('EXIT') {}
+      end
+
+      def wait_for_workers(seconds)
+        seconds.times do
+          logger.debug("Shutting down... waiting for workers to die (we have #{seconds} seconds)...")
+          running_total = 0
+
+          @worker_pools.each do |name, pool|
+            running_total += pool.wait_workers
+          end
+
+          if running_total.zero?
+            logger.debug("All workers are dead. Exiting...")
+            return true
+          end
+
+          logger.debug("#{running_total} workers are still running! Sleeping for a second...")
+          sleep(1)
+        end    
+
+        return false
+      end
+
+      def stop_workers(force = false)
+        return unless start_shutdown || force
+        logger.debug("Stopping workers#{force ? '(forced)' : ''}...")
+
+        # Termination loop
+        @worker_pools.each do |name, pool|
+          pool.stop_workers(force)
+        end
+      end
+
+      def stop_workers!
+        return unless start_shutdown
+        stop_workers(false)
+        sleep(1)
+        stop_workers(true)
+      end
+
+      def start_shutdown
+        return false if @shutdown
+        @shutdown = true
+      end
+    end
+  end
+end

data/lib/loops/worker.rb

@@ -0,0 +1,81 @@
+module Lipsiadmin
+  module Loops
+    class Worker#:nodoc:
+      attr_reader :logger
+      attr_reader :name
+      attr_reader :pid
+
+      def initialize(name, logger, engine, &blk)
+        raise "Need a worker block!" unless block_given?
+
+        @name = name
+        @logger = logger
+        @engine = engine    
+        @worker_block = blk
+
+        @shutdown = false
+      end
+
+      def shutdown?
+        @shutdown
+      end
+
+      def run
+        return if shutdown?
+        if @engine == 'fork'
+          @pid = Kernel.fork do
+            $0 = "loop worker: #{@name}\0"
+            @pid = Process.pid
+            @worker_block.call
+            exit(0)
+          end
+        elsif @engine == 'thread'
+          @thread = Thread.start do
+            @worker_block.call
+          end
+        else
+          raise "Invalid engine name: #{@engine}"
+        end
+      rescue Exception => e
+        logger.error("Exception from worker: #{e} at #{e.backtrace.first}")
+      end
+
+      def running?(verbose = false)
+        return false if shutdown?
+        if @engine == 'fork'
+          return false unless @pid
+          begin
+            Process.waitpid(@pid, Process::WNOHANG)
+            res = Process.kill(0, @pid)
+            logger.debug("KILL(#{@pid}) = #{res}") if verbose
+            return true
+          rescue Errno::ESRCH, Errno::ECHILD, Errno::EPERM => e
+            logger.error("Exception from kill: #{e} at #{e.backtrace.first}") if verbose
+            return false
+          end
+        elsif @engine == 'thread'
+          @thread && @thread.alive?
+        else
+          raise "Invalid engine name: #{@engine}"
+        end
+      end
+
+      def stop(force = false)
+        @shutdown = true
+        if @engine == 'fork'
+          begin
+            sig = force ? 'SIGKILL' : 'SIGTERM'
+            logger.debug("Sending #{sig} to ##{@pid}")
+            Process.kill(sig, @pid)
+          rescue Errno::ESRCH, Errno::ECHILD, Errno::EPERM=> e
+            logger.error("Exception from kill: #{e} at #{e.backtrace.first}")
+          end
+        elsif @engine == 'thread'
+          force && !defined?(::JRuby) ? @thread.kill! : @thread.kill
+        else
+          raise "Invalid engine name: #{@engine}"
+        end
+      end
+    end
+  end
+end

data/lib/loops/worker_pool.rb

@@ -0,0 +1,53 @@
+module Lipsiadmin
+  module Loops
+    class WorkerPool#:nodoc:
+      attr_reader :logger
+      attr_reader :name
+
+      def initialize(name, logger, engine, &blk)
+        @name = name
+        @logger = logger
+        @worker_block = blk
+        @shutdown = false
+        @engine = engine
+        @workers = []
+      end
+
+      def start_workers(number)
+        logger.debug("Creating #{number} workers for #{name} loop...")
+        number.times do 
+          @workers << Lipsiadmin::Loops::Worker.new(name, logger, @engine, &@worker_block)
+        end
+      end
+
+      def check_workers
+        logger.debug("Checking loop #{name} workers...")
+        @workers.each do |worker|
+          next if worker.running? || worker.shutdown?
+          logger.debug("Worker #{worker.name} is not running. Restart!")
+          worker.run
+        end
+      end
+
+      def wait_workers
+        running = 0
+        @workers.each do |worker|
+          next unless worker.running?
+          running += 1
+          logger.debug("Worker #{name} is still running (#{worker.pid})")
+        end
+        return running
+      end
+
+      def stop_workers(force)
+        return if @shutdown
+        @shutdown = false
+        logger.debug("Stopping loop #{name} workers...")
+        @workers.each do |worker|
+          next unless worker.running?
+          worker.stop(force)
+        end
+      end
+    end
+  end
+end

data/lib/utils/html_entities.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 module Lipsiadmin
   module Utils
     # Convert common utf-8 chars to html entities, this is beautifull (but the code not)

data/lib/version.rb

@@ -1,8 +1,8 @@
 module Lipsiadmin
   module VERSION #:nodoc:
     MAJOR = 3
-    MINOR = 3
-    TINY  = 4
+    MINOR = 4
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/view/helpers/backend_helper.rb

@@ -22,9 +22,12 @@ module Lipsiadmin
         
         # This method add tab for in your view
         def tab(name, padding=true, options={}, &block)
-          options[:style] = "padding:10px;#{options[:style]}" if padding
-          options[:id] ||= name.to_s.downcase.gsub(/[^a-z0-9]+/, '_').gsub(/-+$/, '').gsub(/^-+$/, '')
-          concat content_tag(:div, capture(&block), { :id => options[:id], :class => "x-hide-display", :style => options[:style], :tabbed => true, :title => name })
+          options[:id]   ||= name.to_s.downcase.gsub(/[^a-z0-9]+/, '_').gsub(/-+$/, '').gsub(/^-+$/, '')
+          options[:style]  = "padding:10px;#{options[:style]}" if padding
+          options[:title]  = name
+          options[:tabbed] = true
+          options[:class]  = "x-hide-display"
+          concat content_tag(:div, capture(&block), options)
         end
         
         # Set the title of the page
@@ -49,7 +52,6 @@ module Lipsiadmin
         #   Example:
         #     
         #     # in app/views/dossiers/_form.html.haml
-
         #         %tr
         #           %td{:style=>"width:100px"} 
         #             %b Customer:

data/lib/view/helpers/ext/component.rb

@@ -178,6 +178,7 @@ module Lipsiadmin#:nodoc:
         
         def add_object(name, object)
           if object.class == Component || object.class.superclass == Component
+            @before.delete_if { |b| b.start_with?("var #{object.get_var} = new") }
             @before << object.to_s
             @config[name.to_sym] = l(object.get_var)
           else

data/lib/view/helpers/ext/grid.rb

@@ -157,22 +157,20 @@ module Lipsiadmin
       end
 
       # Generate or set a new Ext.grid.GroupingView
-      # You can pass tbar :default options that will autocreate a correct GroupingView
+      # You can pass view :default options that will autocreate a correct GroupingView
       # 
       #   Examples:
       #     view: new Ext.grid.GroupingView({
       #       forceFit:true,
       #       groupTextTpl: '{text} ({[values.rs.length]} {[values.rs.length > 1 ? "Foo" : "Bar"]})'
       #     })
-      #   view :forceFit => true, :groupTextTpl => "{text} ({[values.rs.length]} {[values.rs.length > 1 ? "Foo" : "Bar"]})"
+      #   view :forceFit => true, :groupTextTpl => '{text} ({[values.rs.length]} {[values.rs.length > 1 ? "Foo" : "Bar"]})'
       # 
       def view(object=nil, &block)
-        if object == :default
-          view = Component.new("Ext.grid.GroupingView", { :forceFit => true })
-        elsif value.is_a?(Hash)
-          view = Component.new("Ext.grid.GroupingView", { :forceFit => true }.merge(object))
-        else
-          view = object
+        view = case object
+          when :default then Component.new("Ext.grid.GroupingView", { :forceFit => true })
+          when Hash     then Component.new("Ext.grid.GroupingView", { :forceFit => true }.merge(object))
+          else object
         end
         add_object(:view, view)
       end

data/lipsiadmin_generators/backend/REMEMBER

@@ -14,6 +14,6 @@ Extra:
   in config/environment.rb
   
   - config.active_record.timestamped_migrations = false
-  - comment config.time_zone = 'UTC'
+  - config.time_zone = 'Rome'
   
 ================================================================

data/lipsiadmin_generators/backend/backend_generator.rb

@@ -30,6 +30,7 @@ class BackendGenerator < Rails::Generator::Base
       m.create_all("models", "app/models")
       m.create_all("views", "app/views")
       m.create_all("config", "config")
+      m.create_all("test", "test")
       
       # Using this for prevent raising errors
       migration = Dir.glob("db/migrate/[0-9]*_*.rb").grep(/[0-9]+_create_accounts.rb$/)

data/lipsiadmin_generators/backend/templates/models/account.rb

@@ -78,7 +78,7 @@ class Account < ActiveRecord::Base
   end
 
   def authenticated?(password)
-    crypted_password == encrypt(password)
+    crypted_password.chomp == encrypt(password).chomp
   end
 
   

data/lipsiadmin_generators/backend/templates/test/fixtures/accounts.yml

@@ -0,0 +1,8 @@
+admin:
+  id: 1
+  name: Davide
+  surname: D'Agostino
+  email: d.dagostino@lipsiasoft.com
+  salt: 066f31caf14fdf474c6b5586738be7cc190d8b33
+  crypted_password: UlMOC7qYsxw= #Admin
+  role: administrator

data/lipsiadmin_generators/backend/templates/test/unit/account_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class AccountTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  test "should be valid" do
+    Account.all.each do |a|
+      assert a.valid?
+    end
+  end
+end

data/lipsiadmin_generators/loops/loops_generator.rb

@@ -0,0 +1,27 @@
+# This generator bootstraps a Rails project for use with loops
+class LoopsGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      # Generate app/loops directory and an example loop files
+      m.directory 'app'
+      m.directory 'app/loops'
+      m.file      'app/loops/APP_README',     'app/loops/README'
+      m.file      'app/loops/simple_loop.rb', 'app/loops/simple_loop.rb'
+      
+      # Generate script/loops file
+      m.directory 'script'
+      m.file      'script/loops',             'script/loops', :chmod => 0755
+      
+      # Generate config/loops.yml file
+      m.directory 'config'
+      m.file      'config/loops.yml',         'config/loops.yml'
+    end
+  end
+
+protected
+
+  def banner
+    "Usage: #{$0} loops"
+  end
+
+end

data/lipsiadmin_generators/loops/templates/app/loops/APP_README

@@ -0,0 +1 @@
+This directory should be used to hold all application loops.

data/lipsiadmin_generators/loops/templates/app/loops/simple_loop.rb

@@ -0,0 +1,9 @@
+# Simple loop with its own custom run method
+#
+# Does nothing aside from printing loop's name, pid and current time every second
+#
+class SimpleLoop < Lipsiadmin::Loops::Base
+  def run
+    debug(Time.now)
+  end
+end

data/lipsiadmin_generators/loops/templates/config/loops.yml

@@ -0,0 +1,17 @@
+# This file is a configuration file for loops rails plugin
+#
+
+# This section is used to control loops manager
+global:
+  logger: stdout
+  poll_period: 5
+  workers_engine: fork
+
+# Each record in this section represents one loop which could be ran using loops plugin.
+# Each loop should have a file in app/loops directory with the same name as its config record.
+loops:
+
+  # Simple time printing loop
+  simple_loop:
+    workers_number: 1
+

data/lipsiadmin_generators/loops/templates/script/loops

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'rubygems'
+
+# We need this to be able to start the process w/o being 
+# in the RAILS_ROOT directory
+ROOT_DIR = File.expand_path('..', File.dirname(__FILE__))
+Dir.chdir(ROOT_DIR)
+
+# Default options
+options = { 
+  :daemonize => false, 
+  :loops => [], 
+  :all_loops => false, 
+  :list_loops => false, 
+  :pid_file => nil, 
+  :stop => false,
+  :framework => 'rails',
+  :environment => nil
+}
+
+# Parse command line options
+opts = OptionParser.new do |opt|
+  opt.banner = "Usage: loops [options]"
+  opt.separator ""
+  opt.separator "Specific options:"
+
+  opt.on('-d', '--daemonize', 'Daemonize when all loops started') { |v| options[:daemonize] = v }
+  opt.on('-s', '--stop', 'Stop daemonized loops if running.') { |v| options[:stop] = v }
+  opt.on('-p', '--pid=file', 'Override loops.yml pid_file option') { |v| options[:pid_file] = v }
+  opt.on('-l', '--loop=loop_name', 'Start specified loop(s) only') { |v| options[:loops] << v }
+  opt.on('-a', '--all', 'Start all loops') { |v| options[:all_loops] = v }
+  opt.on('-L', '--list', 'Shows all available loops with their options') { |v| options[:list_loops] = v }
+  opt.on('-f', '--framework=name', 'Starts within a Rails (rails) or Merb (merb) project. Default is rails.') { |v| options[:framework] = v }
+  opt.on('-e', '--environment=env', 'Set RAILS_ENV value') { |v| options[:environment] = v }
+
+  opt.on_tail("-h", "--help", "Show this message") do
+    puts(opt)
+    exit(0)
+  end
+
+  opt.parse!(ARGV)
+end
+
+ENV['RAILS_ENV'] = options[:environment] if options[:environment]
+
+# Bootstrap Rails
+require File.join(ROOT_DIR, 'config/boot')
+require File.join(ROOT_DIR, 'config/environment')
+
+# Loops default logger
+LOOPS_DEFAULT_LOGGER = Rails.logger
+
+#$LOAD_PATH.unshift("vendor/plugins/loops/lib")
+
+LOOPS_ROOT = ROOT_DIR
+LOOPS_CONFIG_FILE = File.join(LOOPS_ROOT, 'config/loops.yml')
+
+require 'loops'
+require 'loops/daemonize'
+
+# Load config file
+puts "Loading config..."
+Lipsiadmin::Loops.load_config(LOOPS_CONFIG_FILE)
+options[:pid_file] ||= (Lipsiadmin::Loops.global_config['pid_file'] || "#{Rails.root}/tmp/loops.pid")
+options[:pid_file] = File.join(LOOPS_ROOT, options[:pid_file]) unless options[:pid_file] =~ /^\//
+
+# Stop/kill loops if requested
+if options[:stop]
+  STDOUT.sync = true
+  raise "No pid file or a stale pid file!" unless Lipsiadmin::Loops::Daemonize.check_pid(options[:pid_file])
+  pid = Lipsiadmin::Loops::Daemonize.read_pid(options[:pid_file])
+  print "Killing the process: #{pid}: "
+  
+  loop do
+    Process.kill('SIGTERM', pid)
+    sleep(1)
+    break unless Lipsiadmin::Loops::Daemonize.check_pid(options[:pid_file])
+    print(".")
+  end
+  
+  puts " Done!"
+  exit(0)
+end
+
+# List loops if requested
+if options[:list_loops]
+  puts "Available loops:"
+  Lipsiadmin::Loops.loops_config.each do |name, config|
+    puts "Loop: #{name}" + (config['disabled'] ? ' (disabled)' : '')
+    config.each do |k,v|
+      puts " - #{k}: #{v}"
+    end
+  end
+  puts
+  exit(0)
+end
+
+# Ignore --loop options if --all parameter passed
+options[:loops] = :all if options[:all_loops]
+
+# Check what loops we gonna run
+if options[:loops] == []
+  puts opts
+  exit(0)
+end
+
+# Pid file check
+raise "Can't start, another process exists!" if Lipsiadmin::Loops::Daemonize.check_pid(options[:pid_file])
+
+# Daemonization
+app_name = "loops monitor: #{ options[:loops].join(' ') rescue 'all' }\0"
+Lipsiadmin::Loops::Daemonize.daemonize(app_name) if options[:daemonize]
+
+# Pid file creation
+Lipsiadmin::Loops::Daemonize.create_pid(options[:pid_file])
+
+# Workers processing
+puts "Starting workers"
+Lipsiadmin::Loops.start_loops!(options[:loops])
+
+# Workers exited, cleaning up
+puts "Cleaning pid file..."
+File.delete(options[:pid_file]) rescue nil