evented_bluepill 0.0.46 → 0.0.47

data/lib/bluepill/application/client.rb

@@ -1,7 +1,9 @@
+# -*- encoding: utf-8 -*-
+
 module Bluepill
   module Application
     module Client
-      
+
     end
   end
 end

data/lib/bluepill/application/server.rb

@@ -1,7 +1,9 @@
+# -*- encoding: utf-8 -*-
+
 module Bluepill
   module Application
     module ServerMethods
-      
+
       def status
         buffer = ""
         self.processes.each do | process |
@@ -11,12 +13,12 @@ module Bluepill
       end
 
       def restart
-        self.socket = Bluepill::Socket.new(name, base_dir).client      
+        self.socket = Bluepill::Socket.new(name, base_dir).client
         socket.send("restart\n", 0)
       end
 
       def stop
-        self.socket = Bluepill::Socket.new(name, base_dir).client      
+        self.socket = Bluepill::Socket.new(name, base_dir).client
         socket.send("stop\n", 0)
       end
     end

data/lib/bluepill/condition_watch.rb

@@ -1,48 +1,54 @@
+# -*- encoding: utf-8 -*-
+
+require 'coolio'
+
 module Bluepill
-  class ConditionWatch
-    attr_accessor :logger, :name
-    EMPTY_ARRAY = [].freeze # no need to recreate one every tick
-    
-    def initialize(name, options = {})
+  class ConditionWatch < Coolio::TimerWatcher
+    attr_accessor :logger, :name, :process
+    attr_reader :every, :process_condition, :fires
+
+    def initialize(name, process, options = {})
       @name = name
 
-      @logger = options.delete(:logger)      
-      @fires = options.has_key?(:fires) ? Array(options.delete(:fires)) : [:restart]
+      @logger = options.delete(:logger)
+      @fires = options.delete(:fires) || :restart
       @every = options.delete(:every)
       @times = options.delete(:times) || [1,1]
       @times = [@times, @times] unless @times.is_a?(Array) # handles :times => 5
+      @process = process
 
       self.clear_history!
-      
+
       @process_condition = ProcessConditions[@name].new(options)
+
+      super(@every, true)
     end
-    
-    def run(pid, tick_number = Time.now.to_i)
-      if @last_ran_at.nil? || (@last_ran_at + @every) <= tick_number
-        @last_ran_at = tick_number
-        self.record_value(@process_condition.run(pid))
-        return @fires if self.fired?
+
+    def on_timer
+      self.record_value(self.process_condition.run(@process.actual_pid))
+      if self.fired?
+        @process.dispatch!(self.fires, self.to_s)
+        logger.info "#{self.name} dispatched: #{self.fires}"
       end
-      EMPTY_ARRAY
     end
-    
+
     def record_value(value)
       # TODO: record value in ProcessStatistics
       @history[@history_index] = [value, @process_condition.check(value)]
       @history_index = (@history_index + 1) % @history.size
       self.logger.info(self.to_s)
     end
-    
+
     def clear_history!
       @last_ran_at = nil
       @history = Array.new(@times[1])
       @history_index = 0
     end
-    
+
     def fired?
       @history.select {|v| v && !v[1]}.size >= @times[0]
     end
-    
+
     def to_s
       # TODO: this will be out of order because of the way history values are assigned
       # use (@history[(@history_index - 1)..1] + @history[0..(@history_index - 1)]).

data/lib/bluepill/controller.rb

@@ -1,23 +1,25 @@
+# -*- encoding: utf-8 -*-
+
 require 'fileutils'
 
 module Bluepill
   class Controller
     attr_accessor :base_dir, :log_file, :sockets_dir, :pids_dir
-    
+
     def initialize(options = {})
       self.log_file = options[:log_file]
       self.base_dir = options[:base_dir]
       self.sockets_dir = File.join(base_dir, 'socks')
       self.pids_dir = File.join(base_dir, 'pids')
-      
+
       setup_dir_structure
       cleanup_bluepill_directory
     end
-    
+
     def running_applications
       Dir[File.join(sockets_dir, "*.sock")].map{|x| File.basename(x, ".sock")}
     end
-    
+
     def handle_command(application, command, *args)
       case command.to_sym
       when :status
@@ -44,10 +46,10 @@ module Bluepill
       when :log
         log_file_location = self.send_to_daemon(application, :log_file)
         log_file_location = self.log_file if log_file_location.to_s.strip.empty?
-        
+
         requested_pattern = args.first
         grep_pattern = self.grep_pattern(application, requested_pattern)
-        
+
         tail = "tail -n 100 -f #{log_file_location} | grep -E '#{grep_pattern}'"
         puts "Tailing log for #{requested_pattern}..."
         Kernel.exec(tail)
@@ -56,7 +58,7 @@ module Bluepill
         exit(1)
       end
     end
-    
+
     def send_to_daemon(application, command, *args)
       begin
         verify_version!(application)
@@ -76,13 +78,13 @@ module Bluepill
         abort("Connection Refused: Server is not running")
       end
     end
-    
+
     def grep_pattern(application, query = nil)
       pattern = [application, query].compact.join(':')
       ['\[.*', Regexp.escape(pattern), '.*'].compact.join
     end
     private
-    
+
     def cleanup_bluepill_directory
       self.running_applications.each do |app|
         pid = pid_for(app)
@@ -94,18 +96,18 @@ module Bluepill
         end
       end
     end
-    
+
     def pid_for(app)
       pid_file = File.join(self.pids_dir, "#{app}.pid")
       File.exists?(pid_file) && File.read(pid_file).to_i
     end
-    
+
     def setup_dir_structure
       [@sockets_dir, @pids_dir].each do |dir|
         FileUtils.mkdir_p(dir) unless File.exists?(dir)
       end
     end
-    
+
     def verify_version!(application)
       begin
         version = Socket.client_command(base_dir, application, "version")

data/lib/bluepill/dsl.rb

@@ -1,155 +1,11 @@
-require 'ostruct'
+# -*- encoding: utf-8 -*-
+
+require 'bluepill/dsl/app_proxy'
+
 module Bluepill
-  def self.define_process_condition(name, &block)
-    klass = Class.new(ProcessConditions::ProcessCondition, &block)
-    ProcessConditions.const_set("#{name.to_s.camelcase}", klass)
-  end
-  
   def self.application(app_name, options = {}, &block)
-    app = Application.new(app_name.to_s, options, &block)
-   
-    process_proxy = Class.new do
-      attr_reader :attributes, :watches
-      def initialize(process_name = nil)
-        @name = process_name
-        @attributes = {}
-        @watches = {}
-      end
-      
-      def method_missing(name, *args)
-        if args.size == 1 && name.to_s =~ /^(.*)=$/
-          @attributes[$1.to_sym] = args.first
-        elsif args.empty? && @attributes.key?(name.to_sym)
-          @attributes[name.to_sym]
-        else
-          super
-        end
-      end
-      
-      def checks(name, options = {})
-        @watches[name] = options
-      end
-      
-      def validate_child_process(child)
-        unless child.attributes.has_key?(:stop_command)
-          $stderr.puts "Config Error: Invalid child process monitor for #{@name}"
-          $stderr.puts "You must specify a stop command to monitor child processes."
-          exit(6)
-        end
-      end
-      
-      def create_child_process_template
-        if @child_process_block
-          child_proxy = self.class.new
-          # Children inherit some properties of the parent
-          [:start_grace_time, :stop_grace_time, :restart_grace_time].each do |attribute|
-            child_proxy.send("#{attribute}=", @attributes[attribute]) if @attributes.key?(attribute)
-          end
-          @child_process_block.call(child_proxy)
-          validate_child_process(child_proxy)
-          @attributes[:child_process_template] = child_proxy.to_process(nil)
-        end
-      end
-      
-      def monitor_children(&child_process_block)
-        @child_process_block = child_process_block
-        @attributes[:monitor_children] = true
-      end
-      
-      def to_process(process_name)
-        process = Bluepill::Process.new(process_name, @attributes)
-        @watches.each do |name, opts|
-          if Bluepill::Trigger[name]
-            process.add_trigger(name, opts)
-          else
-            process.add_watch(name, opts)
-          end
-        end
-
-        process
-      end
-    end
-    app_proxy = Class.new do
-      if RUBY_VERSION >= '1.9'
-        class_variable_set(:@@app, app)
-        class_variable_set(:@@process_proxy, process_proxy)
-        class_variable_set(:@@process_keys, Hash.new) # because I don't want to require Set just for validations
-        class_variable_set(:@@pid_files, Hash.new)
-      else
-        @@app = app
-        @@process_proxy = process_proxy
-        @@process_keys = Hash.new
-        @@pid_files = Hash.new
-      end
-      attr_accessor :working_dir, :uid, :gid, :environment
-      
-      def validate_process(process, process_name)
-        # validate uniqueness of group:process
-        process_key = [process.attributes[:group], process_name].join(":")
-        if @@process_keys.key?(process_key)
-          $stderr.print "Config Error: You have two entries for the process name '#{process_name}'"
-          $stderr.print " in the group '#{process.attributes[:group]}'" if process.attributes.key?(:group)
-          $stderr.puts
-          exit(6)
-        else
-          @@process_keys[process_key] = 0
-        end
-        
-        # validate required attributes
-        [:start_command].each do |required_attr|
-          if !process.attributes.key?(required_attr)
-            $stderr.puts "Config Error: You must specify a #{required_attr} for '#{process_name}'"
-            exit(6)
-          end
-        end
-        
-        # validate uniqueness of pid files
-        pid_key = process.pid_file.strip
-        if @@pid_files.key?(pid_key)
-          $stderr.puts "Config Error: You have two entries with the pid file: #{process.pid_file}"
-          exit(6)
-        else
-          @@pid_files[pid_key] = 0
-        end
-      end
-      
-      def process(process_name, &process_block)
-        process_proxy = @@process_proxy.new(process_name)
-        process_block.call(process_proxy)
-        process_proxy.create_child_process_template
-        
-        set_app_wide_attributes(process_proxy)
-        
-        assign_default_pid_file(process_proxy, process_name)
-        
-        validate_process(process_proxy, process_name)
-        
-        group = process_proxy.attributes.delete(:group)
-        process = process_proxy.to_process(process_name)
-        
-        
-        
-        @@app.add_process(process, group)
-      end
-      
-      def set_app_wide_attributes(process_proxy)
-        [:working_dir, :uid, :gid, :environment].each do |attribute|
-          unless process_proxy.attributes.key?(attribute)
-            process_proxy.attributes[attribute] = self.send(attribute)
-          end
-        end
-      end
-      
-      def assign_default_pid_file(process_proxy, process_name)
-        unless process_proxy.attributes.key?(:pid_file)
-          group_name = process_proxy.attributes["group"]
-          default_pid_name = [group_name, process_name].compact.join('_').gsub(/[^A-Za-z0-9_\-]/, "_")
-          process_proxy.pid_file = File.join(@@app.pids_dir, default_pid_name + ".pid")
-        end
-      end
-    end
-    
-    yield(app_proxy.new)
-    app.load
+    app_proxy = AppProxy.new(app_name, options)
+    yield(app_proxy)
+    app_proxy.app.load
   end
 end

data/lib/bluepill/dsl/app_proxy.rb

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+require 'bluepill/application'
+require 'bluepill/dsl/process_factory'
+
+module Bluepill
+  class AppProxy
+    APP_ATTRIBUTES = [:working_dir, :uid, :gid, :environment]
+
+    attr_accessor *APP_ATTRIBUTES
+    attr_reader :app
+
+    def initialize(app_name, options)
+      @app = Application.new(app_name.to_s, options)
+    end
+
+    def process(process_name, &process_block)
+      attributes = {}
+      APP_ATTRIBUTES.each {|a| attributes[a] = self.send(a) }
+
+      process_factory = ProcessFactory.new(attributes, process_block)
+
+      process = process_factory.create_process(process_name, @app.pids_dir)
+      group = process_factory.attributes.delete(:group)
+
+      @app.add_process(process, group)
+    end
+  end
+end

data/lib/bluepill/dsl/process_factory.rb

@@ -0,0 +1,87 @@
+# -*- encoding: utf-8 -*-
+
+require 'bluepill/dsl/process_proxy'
+
+module Bluepill
+  class ProcessFactory
+    attr_reader :attributes
+
+    @@process_keys = Hash.new
+    @@pid_files = Hash.new
+
+    def initialize(attributes, process_block)
+      @attributes = attributes
+      @process_block = process_block
+    end
+
+    def create_process(name, pids_dir)
+      self.assign_default_pid_file(name, pids_dir)
+      
+      process = Bluepill::ProcessProxy.new(name, @attributes, @process_block)
+      child_process_block = @attributes.delete(:child_process_block)
+      @attributes[:child_process_factory] = ProcessFactory.new(@attributes, child_process_block) if @attributes[:monitor_children]
+      
+      self.validate_process! process
+      process.to_process
+    end
+
+    def create_child_process(name, pid, logger)
+      attributes = {}
+      [:start_grace_time, :stop_grace_time, :restart_grace_time].each {|a| attributes[a] = @attributes[a]}
+      attributes[:actual_pid] = pid
+      attributes[:logger] = logger
+
+      child = Bluepill::ProcessProxy.new(name, attributes, @process_block)
+      self.validate_child_process! child
+      child.to_process
+    end
+
+    protected
+
+    def assign_default_pid_file(process_name, pids_dir)
+      unless @attributes.key?(:pid_file)
+        group_name = @attributes[:group]
+        default_pid_name = [group_name, process_name].compact.join('_').gsub(/[^A-Za-z0-9_\-]/, "_")
+        @attributes[:pid_file] = File.join(pids_dir, default_pid_name + ".pid")
+      end
+    end
+
+    def validate_process!(process)
+      # validate uniqueness of group:process
+      process_key = [process.attributes[:group], process.name].join(":")
+      if @@process_keys.key?(process_key)
+        $stderr.print "Config Error: You have two entries for the process name '#{process.name}'"
+        $stderr.print " in the group '#{process.attributes[:group]}'" if process.attributes.key?(:group)
+        $stderr.puts
+        exit(6)
+      else
+        @@process_keys[process_key] = 0
+      end
+
+      # validate required attributes
+      [:start_command].each do |required_attr|
+        if !process.attributes.key?(required_attr)
+          $stderr.puts "Config Error: You must specify a #{required_attr} for '#{process.name}'"
+          exit(6)
+        end
+      end
+
+      # validate uniqueness of pid files
+      pid_key = process.attributes[:pid_file].strip
+      if @@pid_files.key?(pid_key)
+        $stderr.puts "Config Error: You have two entries with the pid file: #{pid_key}"
+        exit(6)
+      else
+        @@pid_files[pid_key] = 0
+      end
+    end
+
+    def validate_child_process!(child)
+      unless child.attributes.has_key?(:stop_command)
+        $stderr.puts "Config Error: Invalid child process monitor for #{child.name}"
+        $stderr.puts "You must specify a stop command to monitor child processes."
+        exit(6)
+      end
+    end
+  end
+end