senotrusov-ruby-daemonic-threads 1.0.1

data/lib/ruby-daemonic-threads/patches/timezone.rb

@@ -0,0 +1,37 @@
+
+#  Copyright 2009 Stanislav Senotrusov <senotrusov@gmail.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.
+
+
+# To reproduce race condition, start daemon and do concurrent HTTP get for some resource
+# ab -c 100 -n 1000 http://127.0.0.1:4000/daemon/foo_resources/7.xml
+
+# Rails default to lazy load this, so it gaves random exceptions in multithreaded env
+ActiveSupport::TimeWithZone
+
+# @@loaded_zones hash must be mutexed
+class TZInfo::Timezone
+  @@loaded_zones_mutex = Mutex.new
+  
+  class << self
+    alias_method :unsafe_get, :get
+
+    def get(identifier)
+      @@loaded_zones_mutex.synchronize do
+        unsafe_get(identifier)
+      end
+    end
+  end
+end
+

data/lib/ruby-daemonic-threads/process.rb

@@ -0,0 +1,53 @@
+
+#  Copyright 2009 Stanislav Senotrusov <senotrusov@gmail.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 DaemonicThreads::Process
+  
+  def initialize(controller)
+    @controller = controller
+    @name = controller.name
+    
+    @config = DaemonicThreads::Config.new(RAILS_ROOT + '/config/daemons.yml')
+    @http = DaemonicThreads::HTTP::Server.new(self)
+    @queues = DaemonicThreads::Queues.new(self)
+    @daemons = DaemonicThreads::Daemons.new(self)
+  end
+  
+  attr_reader :controller, :name, :config, :http, :queues, :daemons
+  
+  def start
+    @queues.restore
+    
+    @http.start
+    @daemons.start
+  end
+  
+  def join
+    @http.join
+    @daemons.join
+  end    
+  
+  def stop
+    @http.stop
+    @daemons.stop
+  end
+
+  def before_exit
+    @queues.store
+  end
+
+end
+

data/lib/ruby-daemonic-threads/prototype.rb

@@ -0,0 +1,194 @@
+
+#  Copyright 2009 Stanislav Senotrusov <senotrusov@gmail.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 и join.
+#
+#  Как правило, initialize() не переопределяется, а для запуска тредов, поддемонов, сетевых подключение используется initialize_daemon().
+#
+#  initialize_daemon() более толерантен к ошибкам.
+#  Исключение из группы IPSocket::SOCKET_EXEPTIONS полученное из initialize_daemon() перестартовывает демон.
+#  Тем не менее, остальные исключения, полученные из initialize_daemon() останавливают весь процесс
+#
+#  Исключения, полученные из тредов, перестартовывает демон.
+#
+#  После отработки initialize в произвольной последовательности вызываются join() и stop().
+#  join() и stop() вызывается только один раз. 
+#  Исключение в stop() останавливает весь процесс, потому что непонятно - всему ли была доведена команда остановиться.
+#  Исключение в join() останавливает весь процесс, потому что непонятно - всё ли остановилось.
+#
+#  Таким образом, реализуется несколько боязливая стратегия работы - если что-то идёт не так, процесс останавливается.
+#  Рестарт демонов происходит только когда ошибка понятна, и она, скорее всего, не приводит к фатальным последствиям.
+#  Такой ошибкой является сбой сети.
+#  Если в ваших демонах есть другие понятные вам ошибки - ловити их сами или декларируйте в RESTART_ON.
+#
+#  Если тред запустит самостоятельно демона, то он может получить из этого демона exception.
+#  Если этот exception не относится к категории тех, которые решаются перезапуском демона, то весь процесс останавливается.
+#  На самом деле, когда вы получаете такой exception из spawn_daemon @runner.process.controller.stop уже выполнен. Вот-вот всё закроется.
+
+
+#  Вывод inspect очень большой, потому что он долго ходит по перекрёсным ссылкам.
+#  Сюрпризом будет то, что обычный exception no method error, message которого выполняет internaly some kind of inspect,
+#  может выполнятся секунду-другую, если exception случился паралельно.  
+
+
+module DaemonicThreads::Prototype
+  RESTART_ON = IPSocket::SOCKET_EXEPTIONS + [DaemonicThreads::MustTerminatedState] # TODO: inheritable
+  
+  def initialize(name, runner, parent = nil)
+    @name = name
+    @runner = runner
+    @config = runner.config
+    @process = runner.process
+    @logger = Rails.logger
+    @parent = parent
+    
+    @config["queues"].each do |queue_handler, queue_name|
+      instance_variable_set("@#{queue_handler}", @process.queues[queue_name])
+    end if @config["queues"]
+    
+    @threads = ThreadGroup.new
+    @daemons = []
+    @creatures_mutex = Mutex.new
+    @stop_condition = ConditionVariable.new
+    @must_terminate = false
+    
+    initialize_http if respond_to?(:initialize_http)
+  end
+  
+  attr_reader :logger
+  
+  def join
+    @creatures_mutex.synchronize do
+      @stop_condition.wait(@creatures_mutex) unless @must_terminate
+    end
+    
+    deinitialize_http if respond_to?(:deinitialize_http)
+    
+    @daemons.each {|daemon| daemon.join }
+    
+    @threads.list.each {|thread| thread.join }
+  end
+  
+  
+  def stop
+    @creatures_mutex.synchronize do
+      @must_terminate = true
+      @stop_condition.signal
+    end
+
+    @daemons.each {|daemon| daemon.stop }
+    
+    @threads.list.each do |thread|
+      @config["queues"].each do |queue_handler, queue_name|
+        instance_variable_get("@#{queue_handler}").release_blocked thread
+      end
+    end if @config["queues"]
+  end
+  
+  
+  def perform_initialize_daemon(*args)
+    initialize_daemon(*args) if respond_to? :initialize_daemon
+  end
+  
+
+  # Можно запускать из initialize_daemon или из любого треда
+  def spawn_daemon name, klass, *args
+    @creatures_mutex.synchronize do
+      raise(DaemonicThreads::MustTerminatedState, "Unable to spawn new daemons after stop() is called") if @must_terminate
+      
+      # Мы не ловим никаких exceptions, потому что они поймаются или panic_on_exception (тред или http-запрос) или runner-ом (initialize, initialize_daemon).
+      # Полагаться на себя тот должен, кто spawn_daemon вызвал из треда, запущенного без помощи spawn_thread, а значит без должной обработки ошибок.
+       
+      @daemons.push(daemon = klass.new(name, @runner, self))
+      daemon.perform_initialize_daemon(*args)
+      return daemon
+    end
+  end
+  
+  
+  # Можно запускать из initialize_daemon или из любого треда
+  def spawn_thread(thread_name, *args)
+    @creatures_mutex.synchronize do
+      raise(DaemonicThreads::MustTerminatedState, "Unable to spawn new threads after stop() is called") if @must_terminate
+      
+      thread_title = "#{self.class}#thread:`#{thread_name}' @name:`#{@name}'"
+      
+      @threads.add(thread = Thread.new { execute_thread(thread_name, thread_title, args) } )
+      
+      return thread
+    end
+  end
+  
+  def execute_thread(thread_name, thread_title, args)
+   
+    panic_on_exception(thread_title) do
+      Thread.current[:title] = thread_title
+      Thread.current[:started_at] = Time.now
+      
+      if block_given?
+        yield(*args)
+      elsif respond_to?(thread_name)
+        __send__(thread_name, *args)
+      else
+        raise("Thread block was not given or method `#{thread_name}' not found. Don't know what to do.")
+      end
+    end
+    
+  ensure
+    panic_on_exception("#{thread_title} -- Release ActiveRecord connection to pool") { ActiveRecord::Base.clear_active_connections! }
+  end
+  
+  
+  def panic_on_exception(title = nil, handler = nil)
+    yield
+  rescue *(RESTART_ON) => exception
+    begin
+      exception.log!(@logger, :warn, title, (@process.controller.env == "production" ? :inspect : :inspect_with_backtrace))
+      handler.call(exception) if handler
+      @runner.restart_daemon
+    rescue Exception => handler_exception
+      begin
+        handler_exception.log!(@logger, :fatal, title)
+      ensure
+        @process.controller.stop
+      end
+    end
+  rescue Exception => exception
+    begin
+      exception.log!(@logger, :fatal, title)
+      handler.call(exception) if handler
+    rescue Exception => handler_exception
+      handler_exception.log!(@logger, :fatal, title)
+    ensure
+      @process.controller.stop
+    end
+  end
+  
+  
+  def must_terminate?
+    @creatures_mutex.synchronize { @must_terminate }
+  end
+  
+  
+  def log severity, message = nil
+    @logger.__send__(severity, "#{self.class}##{caller.first.match(/`(.*)'/)[1]} -- #{block_given? ? yield : message}" )
+  end
+  
+end
+

data/lib/ruby-daemonic-threads/queues.rb

@@ -0,0 +1,72 @@
+
+#  Copyright 2009 Stanislav Senotrusov <senotrusov@gmail.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.
+
+
+# NOTE:
+#   It is not a quarantied delivery queues.
+#   It rely on normal process startup/shutdown sequence. 
+#   So, if you get sigfault all data will be lost.
+#   On the other hand, queues tends to be quite quickly, since all done in memory  
+
+class DaemonicThreads::Queues
+
+  DEFAULT_STORAGE_DIR = Rails.root + 'tmp' + 'queues'
+
+  def initialize(process)
+    @queues = {}
+    @storage_dir = DEFAULT_STORAGE_DIR
+    @queue_names = process.config.queue_names 
+    
+    raise("Queues storage directory #{@storage_dir} is not available!") unless storage_available?
+  end
+  
+  def restore
+    @queue_names.each do |name|
+      if File.exists?(filename = "#{@storage_dir}/#{name}")
+        @queues[name] = SmartQueue.new(File.read(filename))
+        File.unlink(filename)
+      else
+        @queues[name] = SmartQueue.new
+      end
+    end
+  end
+  
+  def store
+    @queues.each do |name, queue|
+      File.write("#{@storage_dir}/#{name}", queue.to_storage)
+    end
+  end
+
+  def [] name
+    @queues[name]
+  end
+  
+  private
+
+  def storage_available?
+    if File.directory?(@storage_dir) && File.writable?(@storage_dir)
+      return true
+    else
+      begin
+        Dir.mkdir(@storage_dir)
+        return true
+      rescue SystemCallError
+        return false
+      end
+    end
+  end
+  
+end
+

data/lib/ruby-daemonic-threads/runner.rb

@@ -0,0 +1,134 @@
+
+#  Copyright 2009 Stanislav Senotrusov <senotrusov@gmail.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 DaemonicThreads::Runner
+  RESTART_DELAY = 15
+  
+  def initialize(name, config, process)
+    @name = name
+    @config = config
+    @process = process
+    @logger = Rails.logger
+    
+    @mutex = Mutex.new
+    @delay = ConditionVariable.new
+    @must_terminate = false
+    @restarting = false
+  end
+  
+  attr_reader :name, :config, :process
+  
+  def start
+    @watchdog_thread = Thread.new_with_exception_handling(lambda { @process.controller.stop }, @logger, :fatal, "#{self.class}#watchdog @name:`#{@name}'") { watchdog }
+  end
+  
+  def join
+    @watchdog_thread.join if @watchdog_thread
+  end
+
+  def stop
+    restart_process_on_exception do
+      @mutex.synchronize do
+        @must_terminate = true
+        @delay.signal
+
+        return if @restarting
+        
+        @daemon.stop if @daemon
+      end
+    end
+  end
+  
+  #
+  # Нельзя вызывать restart_daemon(), из initialize(), потому что перестартовывать ещё нечего.
+  # Такой вызов может произойти, если в initialize() запускаются треды, которые при ошибке вызывают restart_daemon.
+  # Запускайте новые треды в методе initialize_daemon(). Он выполняется после завершения initialize()
+  #
+  # Нельзя вызывать restart_daemon() после того, как отработал join().
+  # Таким действием можно непреднамеренно перезапустить новое, только что созданное приложение.
+  # Пауза между завершением старого и запуском нового приложения (RESTART_DELAY), несколько снижает вероятность такой ошибки.
+  # Польностью ошибку исключить можно, только если в join() делать join для всех запущенных тредов.
+  # Это делается автоматически, если использовать методы spawn_daemon и spawn_thread.
+  # 
+  def restart_daemon
+    restart_process_on_exception do
+      @mutex.synchronize do
+        return if @must_terminate || @restarting
+
+        @restarting = true
+        
+        unless @daemon
+          raise "#{self.class}#restart_daemon @name:`#{@name} -- Called restart_daemon(), but @daemon does not exists! This may occur when you somehow call restart_daemon() from initialize() and then raises then exception from initialize(). Or you spawn threads in initialize() instead of in spawn_threads() and one thread ends with exception before initialize() fully completes. Or it may be both cases." 
+        end
+        
+        @daemon.stop
+      end
+    end
+  end
+  
+  private
+
+  def watchdog
+    loop do
+      @mutex.synchronize do
+        return if @must_terminate
+        @restarting = false
+        
+        @logger.info "#{self.class}#watchdog @name:`#{@name}' -- Starting..."
+        @daemon = @config["class-constantized"].new(@name, self)
+      end
+      
+      begin
+        @daemon.perform_initialize_daemon
+      rescue *(@config["class-constantized"]::RESTART_ON) => exception
+        exception.log! @logger, :warn, "#{self.class}#watchdog @name:`#{@name}' -- Restarting daemon because of exception", (@process.controller.env == "production" ? :inspect : :inspect_with_backtrace)
+        restart_daemon
+      end
+      
+      @daemon.join
+      
+      delay
+    end
+  end
+  
+  def delay
+    @mutex.synchronize do
+      unless @must_terminate
+        @logger.info "#{self.class}#delay @name:`#{@name}' -- Catch termination, restarting in #{RESTART_DELAY} seconds..."
+        
+        Thread.new_with_exception_handling(lambda { @process.controller.stop }, @logger, :fatal, "#{self.class}#delay @name:`#{@name}'") do
+          # Если кто-то пошлёт сигнал во время сна, ожидающий получит два сигнала по пробуждении. В этом конкретном случае это не ппроблема, потому как этот кто-то - это стоп, и после него получать сигнал будет некому
+          sleep RESTART_DELAY
+          @delay.signal
+        end
+        
+        @delay.wait(@mutex)
+      end
+    end    
+  end
+  
+  def restart_process_on_exception
+    yield
+  rescue Exception => exception
+    begin
+      exception.log!(@logger, :fatal, "#{self.class}##{caller.first.match(/`(.*)'/)[1]} @name:`#{@name}' -- Stopping process because of exception") 
+    ensure
+      @process.controller.stop
+    end
+  end
+  
+end
+