lib/asir/main.rb in asir-1.2.2 vs lib/asir/main.rb in asir-1.2.3

@@ -117,25 +117,28 @@
     when /^log_([^_]+)_([^_]+)!$/
       puts log_file
     when /^taillog_([^_]+)_([^_]+)!$/
       exec "tail -f #{log_file.inspect}"
     when /^pid_([^_]+)_([^_]+)!$/
-      pid = server_pid rescue nil
-      alive = process_running? pid
+      pid = _alive?
       puts "#{pid_file} #{pid || :NA} #{alive}"
     when /^alive_([^_]+)_([^_]+)!$/
-      pid = server_pid rescue nil
-      alive = process_running? pid
+      pid = _alive?
       puts "#{pid_file} #{pid || :NA} #{alive}" if @verbose
       self.exit_code += 1 unless alive
     when /^stop_([^_]+)_([^_]+)!$/
       kill_server!
     else
       super
     end
   end
 
+  def _alive?
+    pid = server_pid rescue nil
+    process_running? pid
+  end
+
   def usage!
     $stderr.puts <<"END"
 SYNOPSIS:
   asir [ <<options>> ... ] <<verb>> <<adjective>> <<object>> [ <<identifier>> ]
 
@@ -187,19 +190,28 @@
 
   def start_resque_conduit!
     _start_conduit!
   end
 
-  def _start_conduit!
+  def _start_conduit! type = adjective
+    if (pid = _alive?) && ! force
+      log "already-running pid #{pid}", :stderr
+      return
+    end
+    log "start_conduit! #{type}"
     config!(:environment)
     self.transport = config!(:transport)
     fork_server! do
       transport.start_conduit! :fork => false
     end
   end
 
   def _start_worker! type = adjective
+    if (pid = _alive?) && ! force
+      log "already-running pid #{pid}", :stderr
+      return
+    end
     log "start_worker! #{type}"
     type = type.to_s
     config!(:environment)
     self.transport = config!(:transport)
 
@@ -233,17 +245,22 @@
     self
   end
 
   def run_server! cmd = nil
     lf = File.open(log_file, "a+")
+    lf.sync = true
     File.chmod(0666, log_file) rescue nil
     $stdin.close rescue nil
     STDIN.close rescue nil
     STDOUT.reopen(lf)
+    STDOUT.sync = true
     $stdout.reopen(lf) if $stdout.object_id != STDOUT.object_id
+    $stdout.sync = true
     STDERR.reopen(lf)
+    STDERR.sync = true
     $stderr.reopen(lf) if $stderr.object_id != STDERR.object_id
+    $stderr.sync = true
     # Process.daemon rescue nil # Ruby 1.9.x only.
     lf.puts "#{log_str} starting pid #{$$}"
     begin
       if cmd
         exec(cmd)
@@ -324,12 +341,13 @@
   def _run_transport_server! wid = 0
     log "running transport worker #{transport.class} #{wid}"
     config!(:start)
     $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, state | nil }
+    transport.after_receive_message = lambda do | transport, state |
+      message = state.message
       $0 = "#{old_arg0} #{transport.message_count} #{message.identifier}"
       after_receive_message.call(transport, message)
     end
     transport.run_server!
     self
@@ -369,16 +387,15 @@
   end
 
   def process_running? 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
+    pid
   rescue ::Errno::ESRCH
     false
   rescue ::Exception => exc
     $stderr.puts "  DEBUG: process_running? #{pid} => #{exc.inspect}"
     false