procon_bypass_man 0.2.0 → 0.2.3

data/lib/procon_bypass_man/remote_macro/remote_macro_object.rb

@@ -1,30 +1,28 @@
-module ProconBypassMan
-  class RemoteMacroObject
-    # valueobjectがvalidatorの責務も持っている. 今度分離する
-    class ValidationError < StandardError; end
-    class MustBeNotNilError < ValidationError; end
-    class NonSupportAction < ValidationError; end
+class ProconBypassMan::RemoteMacro::RemoteMacroObject
+  # valueobjectがvalidatorの責務も持っている. 今度分離する
+  class ValidationError < StandardError; end
+  class MustBeNotNilError < ValidationError; end
+  class NonSupportAction < ValidationError; end
 
-    attr_accessor :name, :uuid, :steps
+  attr_accessor :name, :uuid, :steps
 
-    # @param [String] name
-    # @param [String] uuid
-    # @param [Array] steps
-    def initialize(name: , uuid:, steps: )
-      @name = name
-      @uuid = uuid
-      @steps = steps
-      freeze
-    end
+  # @param [String] name
+  # @param [String] uuid
+  # @param [Array] steps
+  def initialize(name: , uuid:, steps: )
+    @name = name
+    @uuid = uuid
+    @steps = steps
+    freeze
+  end
 
-    # @raise [MustBeNotNilError]
-    # @raise [NonSupportAction]
-    # @return [void]
-    def validate!
-      self.uuid or raise MustBeNotNilError, "uuidは値が必須です"
-      unless self.steps.is_a?(Array)
-        raise ValidationError, "stepsは配列です"
-      end
+  # @raise [MustBeNotNilError]
+  # @raise [NonSupportAction]
+  # @return [void]
+  def validate!
+    self.uuid or raise MustBeNotNilError, "uuidは値が必須です"
+    unless self.steps.is_a?(Array)
+      raise ValidationError, "stepsは配列です"
     end
   end
 end

data/lib/procon_bypass_man/remote_macro/remote_macro_receiver.rb

@@ -15,7 +15,7 @@ class ProconBypassMan::RemoteMacroReceiver
   end
 
   def self.run
-    while(task = ProconBypassMan::QueueOverProcess.pop)
+    while(task = ProconBypassMan::RemoteMacro::QueueOverProcess.pop)
       receive(task)
     end
     shutdown

data/lib/procon_bypass_man/remote_macro/remote_macro_sender.rb

@@ -1,7 +1,7 @@
 class ProconBypassMan::RemoteMacroSender
   def self.execute(name: , uuid: , steps: )
     ProconBypassMan.logger.info "[remote macro][sender] name: #{name}, uuid: #{uuid}, steps: #{steps}"
-    ProconBypassMan::QueueOverProcess.push(
+    ProconBypassMan::RemoteMacro::QueueOverProcess.push(
       ProconBypassMan::RemoteMacro::Task.new(name, uuid, steps)
     )
   end

data/lib/procon_bypass_man/remote_macro/task.rb

@@ -1,6 +1,2 @@
-module ProconBypassMan
-  module RemoteMacro
-    class Task < Struct.new(:name, :uuid, :steps)
-    end
-  end
+class ProconBypassMan::RemoteMacro::Task < ::Struct.new(:name, :uuid, :steps)
 end

data/lib/procon_bypass_man/remote_macro/task_queue.rb

@@ -1,13 +1,9 @@
-module ProconBypassMan
-  module RemoteMacro
-    class TaskQueue < ::Queue
-      def present?
-        not empty?
-      end
+class ProconBypassMan::RemoteMacro::TaskQueue < ::Queue
+  def present?
+    not empty?
+  end
 
-      def non_blocking_shift
-        present? && shift
-      end
-    end
+  def non_blocking_shift
+    present? && shift
   end
 end

data/lib/procon_bypass_man/remote_pbm_action/commands/update_remote_pbm_action_status_command.rb

@@ -10,7 +10,7 @@ module ProconBypassMan
     def execute(to_status: )
       ProconBypassMan::UpdateRemotePbmActionStatusHttpClient.new(
         path: path,
-        server_pool: ProconBypassMan.config.server_pool,
+        server: ProconBypassMan.config.api_server,
       ).put(to_status: to_status)
     end
 

data/lib/procon_bypass_man/runner.rb

@@ -1,8 +1,4 @@
-require_relative "io_monitor"
-
 class ProconBypassMan::Runner
-  class InterruptForRestart < StandardError; end
-
   include ProconBypassMan::SignalHandler
 
   def initialize(gadget: , procon: )
@@ -24,13 +20,12 @@ class ProconBypassMan::Runner
 
     loop do
       # NOTE メインプロセスではThreadをいくつか起動しているので念のためパフォーマンスを優先するためにforkしていく
-      child_pid = Kernel.fork {
+      child_pid = Kernel.fork do
         $will_terminate_token = false
-        DRb.start_service if defined?(DRb)
-        ProconBypassMan::RemoteMacroReceiver.start!
+        ProconBypassMan.after_fork_on_bypass_process
         ProconBypassMan::BypassCommand.new(gadget: @gadget, procon: @procon).execute # ここでblockingする
         next
-      }
+      end
 
       begin
         # TODO 子プロセスが消滅した時に、メインプロセスは生き続けてしまい、何もできなくなる問題がある
@@ -38,7 +33,7 @@ class ProconBypassMan::Runner
           signal = readable_io.first[0].gets.strip
           handle_signal(signal)
         end
-      rescue InterruptForRestart
+      rescue ProconBypassMan::InterruptForRestart
         ProconBypassMan::PrintMessageCommand.execute(text: "設定ファイルの再読み込みを開始します")
         Process.kill("USR2", child_pid)
         Process.wait

data/lib/procon_bypass_man/scheduler.rb

@@ -68,13 +68,22 @@ module ProconBypassMan
     end
 
     def self.register_schedules
-      register(
-        schedule: Schedule.new(
-          klass: ProconBypassMan::SyncDeviceStatsJob,
-          args: [->{ ProconBypassMan::DeviceStatus.current }],
-          interval: 60,
+      if ProconBypassMan.config.has_api_server?
+        register(
+          schedule: Schedule.new(
+            klass: ProconBypassMan::SyncDeviceStatsJob,
+            args: [->{ ProconBypassMan::DeviceStatus.current }],
+            interval: 60,
+          )
         )
-      ) if ProconBypassMan.config.has_api_server?
+        register(
+          schedule: Schedule.new(
+            klass: ProconBypassMan::ReportProconPerformanceMeasurementsJob,
+            args: [->{ ProconBypassMan::Procon::PerformanceMeasurement.pop_measurement_collection }],
+            interval: 60,
+          )
+        )
+      end
     end
 
     # @param [Schedule] schedule

data/lib/procon_bypass_man/support/callbacks.rb

@@ -1,21 +1,15 @@
 module ProconBypassMan
-  module Callbacks
-    class CallbacksChain
-      attr_accessor :filter, :chain_method
-      def initialize(filter: , chain_method: , block: )
-        @filter = filter
-        @chain_method = chain_method
-        @block = block
-      end
-    end
+  module CallbacksRegisterable
+    attr_accessor :callbacks
 
-    # TODO __callbacksをincludeしたクラス側で保持する. 今はnemespaceがない
-    module M
-      class << self
-        attr_accessor :__callbacks
-      end
+    def register_callback_module(mod)
+      self.callbacks ||= []
+      callbacks << mod
+      self.include(mod)
     end
+  end
 
+  module Callbacks
     module ClassMethods
       def define_callbacks(name)
         self.singleton_class.attr_accessor "_#{name}_callbacks"
@@ -29,8 +23,9 @@ module ProconBypassMan
       end
 
       def set_callback(kind, filter, chain_method, &block)
-        ProconBypassMan::Callbacks::M.__callbacks ||= {}
-        ProconBypassMan::Callbacks::M.__callbacks[kind] = CallbacksChain.new(
+        self.__callbacks ||= {}
+        self.__callbacks[kind] ||= CallbackChain.new
+        self.__callbacks[kind].append Callback.new(
           filter: filter,
           chain_method: chain_method,
           block: block,
@@ -38,33 +33,76 @@ module ProconBypassMan
       end
     end
 
+    def self.included(mod)
+      mod.singleton_class.attr_accessor :__callbacks
+      mod.extend(ClassMethods)
+    end
+
+    class CallbackChain
+      attr_accessor :callbacks
+
+      def initialize
+        self.callbacks = {}
+      end
+
+      def empty?
+        callbacks.empty?
+      end
+
+      def append(callback)
+        self.callbacks[callback.filter] ||= []
+        self.callbacks[callback.filter] << callback
+      end
+
+      def [](filter)
+        self.callbacks[filter]
+      end
+    end
+
+    class Callback
+      attr_accessor :filter, :chain_method
+
+      def initialize(filter: , chain_method: , block: )
+        @filter = filter
+        @chain_method = chain_method
+        @block = block
+      end
+    end
+
     # TODO haltしたらcallbackを止める
-    # TODO 複数をチェインできるようにする
     def run_callbacks(kind, &block)
-      chain = get_callbacks(kind) or raise("unknown callback")
-      case chain.filter
-      when :before
+      chains = get_callbacks(kind) or raise("unknown callback")
+      if chains.nil? || chains.empty?
+        return block.call
+      end
+
+      chains[:before]&.each do |chain|
         send chain.chain_method
-        block.call
-      when :after
-        block.call
+      end
+      result = block.call
+      chains[:after]&.each do |chain|
         send chain.chain_method
-      else
-        raise("unknown filter")
       end
-    end
 
-    # def __run_callbacks__(name, &block)
-    #   puts "called"
-    # end
+      return result
+    end
 
     def get_callbacks(kind) # :nodoc:
-      ProconBypassMan::Callbacks::M.__callbacks[kind.to_sym]
-    end
+      # classに直接moduleをincludeしている場合
+      if defined?(self.class.__callbacks) && !self.class.respond_to?(:callbacks)
+        return self.class.__callbacks[kind.to_sym]
+      end
 
-    def set_callbacks(name, callbacks) # :nodoc:
-      send "_#{name}_callbacks=", callbacks
-      ProconBypassMan::Callbacks::M.__callbacks[kind.to_sym] = callbacks
+      list = self.class.callbacks.flat_map { |callback_mod|
+        callback_mod.__callbacks && callback_mod.__callbacks[kind.to_sym]
+      }.compact
+      if(self.class.respond_to?(:__callbacks) && chain = self.class.__callbacks[kind.to_sym])
+        list << chain
+      end
+      table = {}
+      table[:before] = list.flat_map { |x| x[:before] }.compact
+      table[:after] = list.flat_map { |x| x[:after] }.compact
+      table
     end
   end
 end

data/lib/procon_bypass_man/support/can_over_process.rb

@@ -0,0 +1,60 @@
+require 'drb/drb'
+
+# NOTE マスタープロセスでstart_distributed_object!をコールする必要がある
+#      forkをしたらそのさきでDRb.start_serviceをコールする必要がある
+module ProconBypassMan::CanOverProcess
+  PROTOCOL = "drbunix".freeze
+
+  def self.extended(mod)
+    mod.singleton_class.attr_accessor :drb_server, :drb_server_thread
+  end
+
+  # @return [void]
+  def start_distributed_object!
+    return unless enable?
+
+    FileUtils.rm_rf(socket_file_path) if File.exist?(socket_file_path)
+    begin
+      self.drb_server = DRb.start_service(socket_path, distributed_class.new, safe_level: 1)
+    rescue Errno::EADDRINUSE => e
+      ProconBypassMan.logger.error e
+      raise
+    end
+
+    self.drb_server_thread =
+      Thread.new do
+        DRb.thread.join
+      end
+  end
+  alias start! start_distributed_object!
+
+  # @return [void]
+  def shutdown_distributed_object
+    if self.drb_server
+      self.drb_server_thread&.kill
+      self.drb_server_thread = nil
+      self.drb_server.stop_service
+    end
+  end
+  alias shutdown shutdown_distributed_object
+
+  # @return [Boolean]
+  def enable?
+    raise NotImplementedError
+  end
+
+  # @return [String]
+  def socket_file_path
+    raise NotImplementedError
+  end
+
+  # @return [any]
+  def distributed_class
+    raise NotImplementedError
+  end
+
+  # @return [String]
+  def socket_path
+    "#{PROTOCOL}:#{socket_file_path}".freeze
+  end
+end

data/lib/procon_bypass_man/support/gc.rb

@@ -0,0 +1,8 @@
+class ProconBypassMan::GC
+  def self.stop_gc_in(&block)
+    ::GC.disable
+    result = block.call
+    ::GC.enable
+    return result
+  end
+end

data/lib/procon_bypass_man/support/http_client.rb

@@ -26,9 +26,9 @@ module ProconBypassMan
       end
     end
 
-    def initialize(path: , server_pool: , retry_on_connection_error: false)
-      @server_pool = server_pool
-      @uri = URI.parse("#{server_pool.server}#{path}")
+    def initialize(path: , server: , retry_on_connection_error: false)
+      @server = server
+      @uri = URI.parse("#{server}#{path}")
       @retry_on_connection_error = retry_on_connection_error
     end
 
@@ -76,14 +76,13 @@ module ProconBypassMan
           return response.body
         end
       else
-        @server_pool.next!
         ProconBypassMan.logger.error("#{@uri}から200以外(#{response.code})が帰ってきました. #{response.body}")
       end
     end
 
     def handle_request
       raise "need block" unless block_given?
-      if @server_pool.server.nil?
+      if @server.nil?
         ProconBypassMan.logger.info('送信先が未設定なのでスキップしました')
         return
       end
@@ -94,6 +93,10 @@ module ProconBypassMan
         sleep(10)
         retry
       end
+    rescue Timeout::Error
+      ProconBypassMan.logger.error(e)
+      sleep(10)
+      retry
     rescue => e
       puts e
       ProconBypassMan.logger.error(e)
@@ -102,5 +105,5 @@ module ProconBypassMan
 end
 
 if $0 == __FILE__
-  ProconBypassMan::HttpClient.new(path: '/', server_pool: nil, retry_on_connection_error: false).get(response_body: '')
+  ProconBypassMan::HttpClient.new(path: '/', server: nil, retry_on_connection_error: false).get(response_body: '')
 end

data/lib/procon_bypass_man/support/load_agv.rb

@@ -0,0 +1,20 @@
+module ProconBypassMan
+  class LoadAgv
+    PATH = '/proc/loadavg'
+
+    # @return [[Integer, Integer, Integer]]
+    def get
+      loadavg = get_proc_loadavg
+      loadavg =~ /^([0-9.]+)\s([0-9.]+)\s([0-9.]+)/
+      return [$1.to_f, $2.to_f, $3.to_f].join("-")
+    rescue Errno::ENOENT
+      ""
+    end
+
+    private
+
+    def get_proc_loadavg
+      File.read('/proc/loadavg')
+    end
+  end
+end

data/lib/procon_bypass_man/support/procon_performance_http_client.rb

@@ -0,0 +1,7 @@
+module ProconBypassMan
+  class ProconPerformanceHttpClient < HttpClient
+    def post(body: )
+      super(request_body: { body: body })
+    end
+  end
+end

data/lib/procon_bypass_man/support/retryable.rb

@@ -0,0 +1,16 @@
+module ProconBypassMan
+  class Retryable
+    def self.retryable(tries: , retried: 0, on_no_retry: [])
+      return yield(retried)
+    rescue *on_no_retry
+      raise
+    rescue
+      if tries <= retried
+        raise
+      else
+        retried = retried + 1
+        retry
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/support/signal_handler.rb

@@ -3,7 +3,7 @@ module ProconBypassMan::SignalHandler
     ProconBypassMan.logger.info "#{$$}で#{sig}を受け取りました"
     case sig
     when 'USR2'
-      raise ProconBypassMan::Runner::InterruptForRestart
+      raise ProconBypassMan::InterruptForRestart
     when 'INT', 'TERM'
       raise Interrupt
     end

data/lib/procon_bypass_man/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ProconBypassMan
-  VERSION = "0.2.0"
+  VERSION = "0.2.3"
 end

data/lib/procon_bypass_man/websocket/client.rb

@@ -99,11 +99,11 @@ module ProconBypassMan
       def self.validate_and_run_remote_macro(data: )
         pbm_job_hash = data.dig("message")
         begin
-          remote_macro_object = ProconBypassMan::RemoteMacroObject.new(name: pbm_job_hash["name"],
+          remote_macro_object = ProconBypassMan::RemoteMacro::RemoteMacroObject.new(name: pbm_job_hash["name"],
                                                                        uuid: pbm_job_hash["uuid"],
                                                                        steps: pbm_job_hash["steps"])
           remote_macro_object.validate!
-        rescue ProconBypassMan::RemoteMacroObject::ValidationError => e
+        rescue ProconBypassMan::RemoteMacro::RemoteMacroObject::ValidationError => e
           ProconBypassMan::SendErrorCommand.execute(error: e)
           return
         end

data/lib/procon_bypass_man/worker.rb

@@ -0,0 +1,32 @@
+module ProconBypassMan
+  class Worker
+    attr_accessor :pid
+
+    def self.run
+      new.run
+    end
+
+    # @param [Boolean]
+    def run
+      return self if @thread
+      @thread = Thread.new do
+        while(item = ProconBypassMan::Background::JobQueue.pop)
+          begin
+            # プロセスを越えるので、文字列でenqueueしてくれる前提. evalしてクラスにする
+            ProconBypassMan::Background::JobPerformer.new(klass: eval(item[:job_class]), args: item[:args]).perform
+          rescue => e
+            ProconBypassMan.logger.error(e)
+            sleep(0.2) # busy loopしないように
+          end
+        end
+      end
+
+      return self
+    end
+
+    # 重要な非同期ジョブは存在しないのでqueueが捌けるのを待たずにkill
+    def shutdown
+      @thread&.kill
+    end
+  end
+end