workety 2.0.3

data/lib/workety/test/graceful_stop_thread.rb

@@ -0,0 +1,46 @@
+
+#  Copyright 2006-2012 Stanislav Senotrusov <stan@senotrusov.com>
+# 
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+class GracefulStopThread
+  # Before dropping privileges 
+  def initialize
+    @mutex = Mutex.new
+    @wakeup = ConditionVariable.new
+  end
+  
+  # After changing privileges to some user/group
+  def start
+    @worker = Thread.workety do
+      @mutex.synchronize do
+        until Workety.must_stop? do
+          
+          puts "Hello"
+          
+          @wakeup.wait(@mutex, 10)
+        end
+      end
+    end
+  end
+  
+  def join
+    @worker.join
+  end
+  
+  def stop
+    @mutex.synchronize do
+      @wakeup.signal
+    end
+  end
+end

data/lib/workety/test/simple_thread.rb

@@ -0,0 +1,42 @@
+#  Copyright 2006-2011 Stanislav Senotrusov <stan@senotrusov.com>
+# 
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+class SimpleThread
+  # Before dropping privileges 
+  def initialize
+  end
+  
+  # After changing privileges to some user/group
+  def start
+    @t = Thread.workety do
+      until Workety.must_stop? do
+        sleep 1
+      end
+    end
+    
+    Thread.workety do
+      sleep 10
+      Workety.stop
+    end
+  end
+  
+  def join
+    @t.join
+  end
+  
+  def stop
+    @t.kill
+  end
+end
+

data/lib/workety/test/test_thread.rb

@@ -0,0 +1,89 @@
+
+#  Copyright 2006-2011 Stanislav Senotrusov <stan@senotrusov.com>
+# 
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+class Workety::TestThread
+  # Before dropping privileges 
+  def initialize
+    STDOUT.write "#{self.class} init, pid #{Process.pid}\n"
+  end
+  
+  # After changing privileges to some user/group
+  def start
+    STDOUT.write "#{self.class} start, pid #{Process.pid}\n"
+
+#    nonexistant_method
+    
+    STDOUT.write "STDOUT test\n"
+    STDERR.write "STDERR test\n"
+
+    Thread.workety do
+      sleep 5
+      bad_method
+    end
+    
+#    Thread.new do
+#      begin
+#        sleep 5
+#        STDOUT.write "Workety.stop\n"
+#        Workety.stop
+#      rescue Exception => e
+#        e.report!
+#      end
+#    end
+    
+    @ws = Thread.new do
+      begin
+        until Workety.must_stop? do
+          STDOUT.write "Workety.must_stop?\n"
+          sleep 1
+        end
+        STDOUT.write "Workety.must_stop? is true\n"
+
+      rescue Exception => e
+        e.report!
+      end
+    end
+
+
+    @t = Thread.new do
+      600.times do |t|
+        STDOUT.write "#{self.class} Doing #{t}\n"
+        sleep 1
+      end
+    end
+    
+#    1000.times do 
+#      Thread.new { 1000.times { Rails.logger.error "test" } } 
+#      Thread.new { 1000.times { STDOUT.write "test\n" } }
+#    end
+    # cat log/workety-test_thread.log |grep -v "^test$"
+    
+  end
+  
+  def join
+    STDOUT.write "#{self.class} join\n"
+    @t.join
+    @ws.join
+    STDOUT.write "#{self.class} done join\n"
+    STDOUT.write "#{self.class} sleep\n"
+    #sleep 30
+    STDOUT.write "#{self.class} done sleep\n"
+  end
+  
+  def stop
+    STDOUT.write "#{self.class} stop\n"
+    @t.kill
+  end
+end

data/lib/workety/timed_exit.rb

@@ -0,0 +1,56 @@
+
+#  Copyright 2006-2011 Stanislav Senotrusov <stan@senotrusov.com>
+# 
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+
+class TimedExit
+  def initialize(timeout = 60, message = "Timeout reached")
+    @mutex = Mutex.new
+
+    @must_cancel = false
+    @timeout_reached = false
+    
+    Thread.rescue_exit do
+      sleep timeout
+      
+      @mutex.synchronize do
+        unless @must_cancel
+          @timeout_reached = true
+          Rails.logger.info message
+          Process.exit(false)
+        end
+      end
+    end
+    
+    if block_given?
+      yield
+      cancel
+    end
+  end
+  
+  def cancel
+    @mutex.synchronize do
+      Process.exit(false) if @timeout_reached # See comment below
+      @must_cancel = true
+    end
+  end
+end
+
+# In the following example block "ALIVE!\n" seems to not get execution, but I am not sure - does that behaviour consistent?  
+#require 'thread'
+#m = Mutex.new
+#Thread.new { m.synchronize { sleep 3; Process.exit(false) } }
+#sleep 1
+#m.synchronize { STDOUT.write "ALIVE!\n" }
+

data/lib/workety/workety.rb

@@ -0,0 +1,135 @@
+
+#  Copyright 2006-2011 Stanislav Senotrusov <stan@senotrusov.com>
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+
+# Initialize, start, stop and join worker class
+# Drop process privileges after initialize
+#
+# initialize() then start()
+# There is no strict order for stop and join - stop may be called before join 
+#
+# Use Workety.stop to shutdown process from within worker 
+# Use Workety.abort to shutdown and return exit code 1, thus leading to restart by watchdog
+#
+#
+# This is an implementation for threaded worker.
+#
+# TODO: If worker does not have any threads then a different path should be given:
+#   * no mutex/started/must_stop
+#   * no Signal.threaded_trap
+#   * no thread list on USR1
+#   * Just instantiate the class and call .start on it, leaving signal handling to that class
+#
+#
+module Workety
+  STOP_SELF_WATCHDOG_TIMEOUT = 65
+  
+  @thread = nil
+  @mutex = Mutex.new
+  @started = false
+  @must_stop = false
+  @aborted = false
+
+  class << self
+    
+    def start(class_name, user = nil, group = nil)
+      rescue_exit do
+        
+        # Class initialize is the place to things you should do before dropping privilegies (like start listening at port 80).
+        #
+        @mutex.synchronize do
+          Process.exit(!@aborted) if @must_stop
+          @thread = class_name.constantize.new
+        end
+
+        Process.change_privilegies(user, group) if user || group
+       
+        @mutex.synchronize do
+          Process.exit(!@aborted) if @must_stop
+          @thread.start
+          @started = true
+        end
+      end
+    end
+    
+    def join
+      rescue_exit { @thread.join }
+    end
+
+    def stop_sequence(aborted)
+      rescue_exit do
+        @mutex.synchronize do
+          @aborted = true if aborted
+          
+          unless @must_stop
+            @must_stop = true
+            
+            Thread.rescue_exit { stop_watchdog }
+            Thread.rescue_exit { @thread.stop } if @started
+          end
+        end
+      end
+    end
+
+    # Thread initialize/start occurs inside @mutex, so calling Workety.abort/stop/must_stop?/aborted? from within it will 
+    # lead to "ThreadError: deadlock; recursive locking"
+
+    def abort
+      stop_sequence(true)
+    end
+    
+    def stop
+      stop_sequence(false)
+    end
+    
+    def aborted?
+      @mutex.synchronize { @aborted }
+    end
+    
+    def must_stop?
+      @mutex.synchronize { @must_stop } 
+    end
+    
+    def loop
+      until must_stop?
+        yield
+      end
+    end
+    
+
+    def rescue_abort
+      yield
+    rescue ScriptError, StandardError => exception
+      begin
+        exception.report!
+      ensure
+        Workety.abort
+      end
+    end
+    
+    
+    # Timeout for stop() and join()
+    # When the process is stopped by a signal, watchdog or signal sender take care of timeout
+    # But when the process call Workety.stop/abort by itself, this timeout function will ensure successful termination  
+    def stop_watchdog
+      sleep Workety::STOP_SELF_WATCHDOG_TIMEOUT
+      Thread.log "Timeout stopping process"
+    ensure
+      Process.exit(false)
+    end
+    
+  end
+end
+

data/test/exception_tracker.rb

@@ -0,0 +1,7 @@
+begin
+  raise StandardError.details("ALARM!2", :foo => "bar", :name => "NAAME")
+rescue => ex
+  ex.log!
+  ex.report_to_exceptional!
+  #ex.report_to_airbrake!
+end

data/test/logger_init.rb

@@ -0,0 +1,26 @@
+if action == :console
+  Rails.logger = ActiveSupport::BufferedLogger.new(STDOUT)
+else
+  begin
+    Rails.logger = ActiveSupport::BufferedLogger.new(logfile)
+
+  rescue StandardError => exception
+    exception.view!
+
+    Rails.logger = ActiveSupport::BufferedLogger.new(STDOUT)
+    Rails.logger.warn "Continuing anyway"
+  end
+end
+
+Rails.logger.level = ActiveSupport::BufferedLogger.const_get(options[:log_level].upcase) if options[:log_level]
+
+Rails.logger.auto_flushing = true
+Rails.logger.flush
+at_exit { Rails.logger.flush }
+
+ActiveSupport::BufferedLogger.class_eval do
+  def chown_logfile(user_uid, group_gid)
+    @log.chown(user_uid, group_gid) if @log.respond_to?(:chown)
+  end
+end
+

data/test/mem_and_load_path.rb

@@ -0,0 +1,8 @@
+def mem? title = "Memory usage"
+  STDOUT.write "---- #{title} ----\n"  + File.read("/proc/#{Process.pid}/status").split("\n").select{|l|l.match(/VmSize/)}.first.to_s + "\n"
+end
+
+def load_path?
+  STDOUT.write $LOAD_PATH.join("\n") + "\n"
+end
+

data/test/new_thread_on_signal.rb

@@ -0,0 +1,39 @@
+
+#  Copyright 2006-2011 Stanislav Senotrusov <stan@senotrusov.com>
+# 
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require 'thread'
+
+t = nil
+
+term_signal_handler = Proc.new do
+  t = Thread.new do
+    begin
+      puts "THREAD"
+      sleep 5
+      puts "DONE"
+    rescue Exception => exception
+      puts exception.inspect
+    end 
+  end
+end
+
+Signal.trap('INT',  & term_signal_handler) # Ctrl+C
+Signal.trap('TERM', & term_signal_handler) # kill
+
+
+Process.kill("TERM", Process.pid)
+
+sleep 10
+