asir 0.2.0 → 1.0.1

data/lib/asir/error.rb

@@ -7,6 +7,9 @@ module ASIR
     # Unsupported Feature.
     class Unsupported < self; end
 
+    # Unimplemented Feature
+    class Unimplemented < self; end
+
     # Requested Stop.
     class Terminate < self; end
 
@@ -28,7 +31,7 @@ module ASIR
       end
       def self.unforwardable;    @@unforwardable; end
       def self.unforwardable= x; @@unforwardable = x; end
-      @@unforwardable ||= [ ::SystemExit, ::Interrupt ]
+      @@unforwardable ||= [ ::SystemExit, ::Interrupt, ::SignalException ]
     end
   end
 end

data/lib/asir/invoker.rb

@@ -0,0 +1,14 @@
+module ASIR
+  # !SLIDE
+  # Invoker
+  #
+  # Invokes the Message or Exception on behalf of a Transport.
+  class Invoker
+    include Initialization, AdditionalData
+
+    def invoke! message, transport
+      message.invoke!
+    end
+  end
+end
+

data/lib/asir/main.rb

@@ -1,41 +1,36 @@
 require 'asir'
+require 'asir/environment'
 require 'time'
 
-
 module ASIR
 class Main
-  attr_accessor :verb, :adjective, :object, :identifier
-  attr_accessor :config_rb, :config
-  attr_accessor :log_dir, :pid_dir
-  attr_accessor :verbose
-  attr_accessor :exit_code
+  attr_accessor :env, :args, :exit_code
+  # Delegate getter/setters to @env.
+  [ :verb, :adjective, :object, :identifier,
+    :config_rb,
+    :verbose,
+    :log_dir, :log_file,
+    :pid_dir, :pid_file,
+  ].
+    map{|g| [ g, :"#{g}=" ]}.
+    flatten.each do | m |
+      define_method(m) { | *args | @env.send(m, *args) }
+    end
+  attr_accessor :progname
+  # Options:
+  attr_accessor :force
 
-  def initialize
-    @verbose = 0
-    @progname = File.basename($0)
-    @log_dir = find_writable_directory :log_dir,
-      ENV['ASIR_LOG_DIR'],
-      '/var/log/asir',
-      '~/asir/log',
-      '/tmp'
-    @pid_dir = find_writable_directory :pid_dir,
-      ENV['ASIR_PID_DIR'],
-      '/var/run/asir',
-      '~/asir/run',
-      '/tmp'
-    @exit_code = 0
-  end
+  # Transport selected from asir.phase = :transport.
+  attr_accessor :transport
 
-  def find_writable_directory kind, *list
-    list.
-      reject { | p | ! p }.
-      map { | p |  File.expand_path(p) }.
-      find { | p | File.writable?(p) } or
-      raise "Cannot find writable directory for #{kind}"
+  def initialize
+    self.env = ASIR::Environment.new
+    self.progname = File.basename($0)
+    self.exit_code = 0
   end
 
   def parse_args! args = ARGV.dup
-    @args = args
+    self.args = args
     until args.empty?
       case args.first
       when /^([a-z0-9_]+=)(.*)/i
@@ -47,25 +42,29 @@ class Main
         break
       end
     end
-    @verb, @adjective, @object, @identifier = args.map{|x| x.to_sym}
-    @identifier ||= :'0'
+    self.verb, self.adjective, self.object, self.identifier = args.map{|x| x.to_sym}
+    self.identifier ||= :'0'
     self
   end
 
+  def config! *args
+    @env.config! *args
+  end
+
   def log_str
     "#{Time.now.gmtime.iso8601(4)} #{$$} #{log_str_no_time}"
   end
 
   def log_str_no_time
-    "#{@progname} #{@verb} #{@adjective} #{@object} #{@identifier}"
+    "#{progname} #{verb} #{adjective} #{object} #{identifier}"
   end
 
   def run!
     unless verb && adjective && object
-      @exit_code = 1
+      self.exit_code = 1
       return usage!
     end
-    config!(:config)
+    config!(:configure)
     # $stderr.puts "log_file = #{log_file.inspect}"
     case self.verb
     when :restart
@@ -79,28 +78,28 @@ class Main
     self
   rescue ::Exception => exc
     $stderr.puts "#{log_str} ERROR\n#{exc.inspect}\n  #{exc.backtrace * "\n  "}"
-    @exit_code += 1
+    self.exit_code += 1
     self
   end
 
   def _run_verb!
     sel = :"#{verb}_#{adjective}_#{object}!"
-    if @verbose >= 3
-      $stderr.puts "verb      = #{verb.inspect}"
-      $stderr.puts "adjective = #{adjective.inspect}"
-      $stderr.puts "object    = #{object.inspect}"
-      $stderr.puts "sel       = #{sel.inspect}"
+    if verbose >= 3
+      $stderr.puts "  verb      = #{verb.inspect}"
+      $stderr.puts "  adjective = #{adjective.inspect}"
+      $stderr.puts "  object    = #{object.inspect}"
+      $stderr.puts "  sel       = #{sel.inspect}"
     end
     send(sel)
   rescue ::Exception => exc
     $stderr.puts "#{log_str} ERROR\n#{exc.inspect}\n  #{exc.backtrace * "\n  "}"
-    @exit_code += 1
+    self.exit_code += 1
     raise
     nil
   end
 
   def method_missing sel, *args
-    log "method_missing #{sel}" if @verbose >= 3
+    log "method_missing #{sel}" if verbose >= 3
     case sel.to_s
     when /^start_([^_]+)_worker!$/
       _start_worker!
@@ -113,7 +112,14 @@ class Main
     when /^taillog_([^_]+)_([^_]+)!$/
       exec "tail -f #{log_file.inspect}"
     when /^pid_([^_]+)_([^_]+)!$/
-      puts "#{pid_file} #{File.read(pid_file) rescue nil}"
+      pid = server_pid rescue nil
+      alive = process_running? pid
+      puts "#{pid_file} #{pid || :NA} #{alive}"
+    when /^alive_([^_]+)_([^_]+)!$/
+      pid = server_pid rescue nil
+      alive = process_running? pid
+      puts "#{pid_file} #{pid || :NA} #{alive}" if @verbose
+      self.exit_code += 1 unless alive
     when /^stop_([^_]+)_([^_]+)!$/
       kill_server!
     else
@@ -139,12 +145,15 @@ VERBS:
   status
   log
   pid
+  alive
 
 ADJECTIVE-OBJECTs:
   beanstalk conduit
   beanstalk worker
   zmq worker
   webrick worker
+  resque conduit
+  resque worker
 
 EXAMPLES:
 
@@ -153,6 +162,7 @@ EXAMPLES:
   asir status beanstalk conduit
 
   asir start webrick worker
+  asir pid   webrick worker
 
   asir start beanstalk worker 1
   asir start beanstalk worker 2
@@ -164,7 +174,19 @@ END
   end
 
   def start_beanstalk_conduit!
-    fork_server! "beanstalkd"
+    _start_conduit!
+  end
+
+  def start_resque_conduit!
+    _start_conduit!
+  end
+
+  def _start_conduit!
+    config!(:environment)
+    self.transport = config!(:transport)
+    fork_server! do
+      transport.start_conduit! :fork => false
+    end
   end
 
   def _start_worker! type = adjective
@@ -179,54 +201,6 @@ END
     end
   end
 
-  ################################################################
-
-  def config_rb
-    @config_rb ||=
-      File.expand_path(ENV['ASIR_CONFIG_RB'] || 'config/asir_config.rb')
-  end
-
-  def config_lambda
-    @config_lambda ||=
-      begin
-        file = config_rb
-        $stderr.puts "#{log_str} loading #{file} ..." if @verbose >= 1
-        expr = File.read(file)
-        expr = "begin; lambda do | asir |; #{expr}\n end; end"
-        cfg = Object.new.send(:eval, expr, binding, file, 1)
-        # cfg = load file
-        # $stderr.puts "#{log_str} loading #{file} DONE" if @verbose >= 1
-        raise "#{file} did not return a Proc, returned a #{cfg.class}" unless Proc === cfg
-        cfg
-      end
-  end
-
-  def config! verb = @verb
-    (@config ||= { })[verb] ||=
-      begin
-        save_verb = @verb
-        @verb = verb
-        $stderr.puts "#{log_str} calling #{config_rb} asir.verb=#{@verb.inspect} ..." if @verbose >= 1
-        cfg = config_lambda.call(self)
-        $stderr.puts "#{log_str} calling #{config_rb} asir.verb=#{@verb.inspect} DONE" if @verbose >= 1
-        cfg
-      ensure
-        @verb = save_verb
-      end
-  end
-
-  def pid_file
-    "#{pid_dir}/#{asir_basename}.pid"
-  end
-
-  def log_file
-    "#{log_dir}/#{asir_basename}.log"
-  end
-
-  def asir_basename
-    "asir-#{adjective}-#{object}-#{identifier}"
-  end
-
   def fork_server! cmd = nil, &blk
     pid = Process.fork do
       run_server! cmd, &blk
@@ -301,22 +275,22 @@ END
     config!(:environment)
     case transport = config!(:transport)
     when default_class
-      @transport = transport
+      self.transport = transport
     else
       raise "Expected config to return a #{default_class}, not a #{transport.class}"
     end
   end
 
   def worker_pids
-    (@worker_pids ||= { })[@adjective] ||= { }
+    (@worker_pids ||= { })[adjective] ||= { }
   end
 
   def _run_workers!
-    $0 = "#{@progname} #{@adjective} #{@object} #{@identifier}"
+    $0 = "#{progname} #{adjective} #{object} #{identifier}"
 
     worker_id = 0
-    @transport.prepare_server!
-    worker_processes = @transport[:worker_processes] || 1
+    transport.prepare_server!
+    worker_processes = transport[:worker_processes] || 1
     (worker_processes - 1).times do
       wid = worker_id += 1
       pid = Process.fork do
@@ -334,16 +308,16 @@ END
   end
 
   def _run_transport_server! wid = 0
-    log "running transport worker #{@transport.class} #{wid}"
+    log "running transport worker #{transport.class} #{wid}"
     config!(:start)
-    $0 += " #{wid} #{@transport.uri rescue nil}"
+    $0 += " #{wid} #{transport.uri rescue nil}"
     old_arg0 = $0.dup
-    after_receive_message = @transport.after_receive_message || lambda { | transport, message | nil }
-    @transport.after_receive_message = lambda do | transport, message |
+    after_receive_message = transport.after_receive_message || lambda { | transport, message | nil }
+    transport.after_receive_message = lambda do | transport, message |
       $0 = "#{old_arg0} #{transport.message_count} #{message.identifier}"
       after_receive_message.call(transport, message)
     end
-    @transport.run_server!
+    transport.run_server!
     self
   end
 
@@ -368,7 +342,7 @@ END
       log "TERM pid #{pid}"
       Process.kill('TERM', pid) rescue nil
       sleep 3
-      if @force or process_running? pid
+      if force or process_running? pid
         log "KILL pid #{pid}", :stderr
         Process.kill('KILL', pid) rescue nil
       end
@@ -381,7 +355,14 @@ END
   end
 
   def process_running? pid
-    Process.kill(0, pid)
+    case pid
+    when false, nil
+      pid
+    when Integer
+      Process.kill(0, pid)
+    else
+      raise TypeError, "expected false, nil, Integer; given #{pid.inspect}"
+    end
     true
   rescue ::Errno::ESRCH
     false

data/lib/asir/message.rb

@@ -24,7 +24,7 @@ module ASIR
       @result = Result.new(self, nil, exc)
     end
 
-    # Optional: Specifies the Numeric seconds or absolute Time to delay the Message until actual processing.
+    # Optional: Specifies the Numeric seconds or absolute Time for the Transport to delay the Message until actual invocation.
     attr_accessor :delay
   end
   # !SLIDE END

data/lib/asir/poll_throttle.rb

@@ -0,0 +1,53 @@
+require 'asir'
+
+module ASIR
+  module PollThrottle
+    # Polls block until non-nil block result.
+    # If non-nil, retry after sleeping for s sec, which starts at opts[:min_sleep].
+    # Will retry up to opts[:max_tries] times, if defined.
+    # s is multiplied by opts[:mul_sleep] and incremented by opts[:inc_sleep], if defined.
+    # s is limited by opts[:max_sleep].
+    # s is adjusted by s * opts[:rand_sleep], if defined.
+    # Returns result yield from block.
+    def poll_throttle opts = nil
+      opts ||= { }
+      i = 0
+      s = opts[:min_sleep] ||= 0.01
+      opts[:max_sleep] ||= 60
+      # opts[:inc_sleep] ||= 1
+      # opts[:mul_sleep] ||= 1.5
+      result = nil
+      loop do
+        i += 1
+        unless (result = yield).nil?
+          return result
+        end
+        if x = opts[:max_tries] and i >= x
+          return result
+        end
+        this_s = s
+        if x = opts[:rand_sleep]
+          this_s += s * rand * x
+        end
+        if opts[:verbose]
+          $stderr.puts "  #{self}: poll_throttle: sleeping for #{this_s} sec"
+        end
+        sleep this_s if this_s > 0
+        if x = opts[:mul_sleep]
+          s *= x
+        end
+        if x = opts[:inc_sleep]
+          s += x
+        end
+        if x = opts[:max_sleep] and s > x
+          s = x
+        end
+        if x = opts[:min_sleep] and s < x
+          s = x
+        end
+      end
+      result
+    end
+  end
+end
+

data/lib/asir/retry_behavior.rb

@@ -32,7 +32,7 @@ module ASIR
         if ! try_max || try_max > n_try
           yield :retry, exc
           if sleep_secs
-            sleep sleep_secs
+            sleep sleep_secs if sleep_secs > 0
             sleep_secs += try_sleep_increment if try_sleep_increment
             sleep_secs = try_sleep_max if try_sleep_max && sleep_secs > try_sleep_max
           end

data/lib/asir/thread_variable.rb

@@ -0,0 +1,183 @@
+module ASIR
+
+# Adds Thread-based class and instance variables.
+module ThreadVariable
+  def self.included target
+    super
+    target.instance_eval do
+      include CommonMethods
+      extend  CommonMethods
+      extend  ModuleMethods
+    end
+  end
+  DEBUG = false
+
+  module CommonMethods
+    # Yields to block while self.name = value.
+    # Restores self.name after yield.
+    def with_attr! name, value
+      save_value = send(name)
+      send(::ASIR::ThreadVariable.setter(name), value)
+      yield
+    ensure
+      send(::ASIR::ThreadVariable.setter(name), save_value)
+    end
+  end
+
+  def self.setter sym
+    SETTER[sym] ||= :"#{sym}="
+  end
+  SETTER = { }
+
+  module ModuleMethods
+    # Defines a Module or Class attribute stored in Thread.current.
+    def mattr_accessor_thread *names
+      mattr_getter_thread *names
+      mattr_setter_thread *names
+    end
+    alias :cattr_accessor_thread :mattr_accessor_thread
+
+    # Defines a Module or Class attribute setter stored in Thread.current.
+    def mattr_setter_thread *names
+      opts = Hash === names[-1] ? names.pop : EMPTY_HASH
+
+      transform = opts[:setter_transform]
+      transform = "__val = (#{transform})" if transform
+
+      names.each do | name |
+        instance_eval(expr = <<"END", __FILE__, __LINE__)
+def self.#{name}= __val
+  #{transform}
+  Thread.current[:'#{self.name}.#{name}'] = [ __val ]
+end
+END
+        # $stderr.puts "#{expr}"
+      end
+    end
+    alias :cattr_setter_thread :mattr_setter_thread
+
+    # Defines a class attribute getter stored in Thread.current.
+    #
+    # Options:
+    #
+    #   :initialize -- String: expression to initialize the variable is undefined.
+    #   :default    -- String: expression to return if the variable value if undefined.
+    #   :transform  -- String: expression to transform the __val variable before returning.
+    #
+    # Also defines clear_NAME method that undefines the thread variable.
+    def mattr_getter_thread *names
+      opts = Hash === names[-1] ? names.pop : EMPTY_HASH
+
+      initialize = opts[:initialize]
+      initialize = "||= [ #{initialize} ]" if initialize
+
+      default = opts[:default]
+      default = "__val ||= [ #{default} ]" if default
+
+      transform = opts[:transform]
+      transform = "__val = (#{transform})" if transform
+
+      names.each do | name |
+        instance_eval(expr = <<"END", __FILE__, __LINE__)
+def self.clear_#{name}
+  Thread.current[:'#{self.name}.#{name}'] = nil
+  self
+end
+
+def self.#{name}
+  __val = Thread.current[:'#{self.name}.#{name}'] #{initialize}
+  #{default}
+  __val &&= __val.first
+  #{transform}
+  __val
+end
+END
+        # $stderr.puts "#{expr}"
+      end
+    end
+    alias :cattr_getter_thread :mattr_getter_thread
+
+    # TODO: clear instance thread variables when instance is GCed.
+    def attr_accessor_thread *names
+      attr_getter_thread *names
+      attr_setter_thread *names
+    end
+
+    def attr_setter_thread *names
+      opts = Hash === names[-1] ? names.pop : EMPTY_HASH
+
+      transform = opts[:setter_transform]
+      transform = "__val = (#{transform})" if transform
+
+      names.each do | name |
+        expr = [ <<"END", __FILE__, __LINE__ ]
+def clear_#{name}
+  ((Thread.current[:'#{self.name}\#'] ||= { })[self.object_id] || { }).delete(:'#{name}')
+  self
+end
+
+def #{name}= __val
+  #{transform}
+  thread_attrs[:'#{name}'] = [ __val ]
+end
+END
+        $stderr.puts "expr::\n#{expr}\n====" if opts[:debug] || DEBUG
+        class_eval *expr
+      end
+    end
+
+    def attr_getter_thread *names
+      opts = Hash === names[-1] ? names.pop : EMPTY_HASH
+
+      expr = [ <<"END", __FILE__, __LINE__ ]
+def self.attr_thread_hash(obj)
+  thr = Thread.current
+  ObjectSpace.define_finalizer(obj) do | oid |
+    (thr[:'#{self.name}\#'] ||= { }).delete(oid)
+  end
+  { }
+end
+
+def thread_attrs
+  (Thread.current[:'#{self.name}\#'] ||= { })[self.object_id] ||= #{self.name}.attr_thread_hash(self)
+end
+
+def attr_thread_clear_all! oid = self.object_id
+  (Thread.current[:'#{self.name}\#'] ||= { }).delete(oid)
+end
+END
+      $stderr.puts "expr::\n#{expr}\n====" if opts[:debug] || DEBUG
+      class_eval *expr
+
+      initialize = opts[:initialize]
+      if initialize
+        initialize = "||= { }"
+      end
+
+      default = opts[:default]
+      default = "__val ||= [ #{default} ]" if default
+
+      transform = opts[:transform]
+      transform = "__val = (#{transform})" if transform
+
+      names.each do | name |
+        expr = [ <<"END", __FILE__, __LINE__ ]
+def #{name}
+  __val = (thread_attrs[:'#{name}'] #{initialize})
+  #{default}
+  __val &&= __val.first
+  #{transform}
+  __val
+end
+END
+        $stderr.puts "expr::\n#{expr}\n====" if opts[:debug] || DEBUG
+        class_eval *expr
+      end
+    end
+
+  end # module
+
+  EMPTY_HASH = { }.freeze
+end # module
+
+end # module