procon_bypass_man 0.2.1 → 0.3.0

data/lib/procon_bypass_man/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ProconBypassMan::Configuration
   module ClassMethods
     def root
@@ -47,14 +49,15 @@ class ProconBypassMan::Configuration
     def fallback_setting_path
       "/tmp/procon_bypass_man_fallback_setting.yaml"
     end
-
-    def io_monitor_logging
-      config.io_monitor_logging
-    end
   end
 
   attr_accessor :enable_critical_error_logging
-  attr_writer :verbose_bypass_log, :raw_setting, :enable_reporting_pressed_buttons, :never_exit_accidentally, :io_monitor_logging, :enable_home_led_on_connect
+  attr_writer :verbose_bypass_log, :raw_setting, :never_exit_accidentally, :enable_home_led_on_connect
+  # 削除予定
+  attr_writer :enable_reporting_pressed_buttons
+
+  # NOTE 非推奨. 削除したいが設定ファイルに残っているときにエラーにしたくないので互換性維持のため残す
+  attr_writer :io_monitor_logging
 
   def root=(path)
     @root = path
@@ -69,6 +72,7 @@ class ProconBypassMan::Configuration
     end
   end
 
+  # NOTE 不具合の原因は修正済みなので可変である必要は無くなった。削除したいが各端末内の設定ファイルに存在している場合があるのでしばらく残す
   def bypass_mode=(value)
     @bypass_mode = ProconBypassMan::BypassMode.new(
       mode: value[:mode],
@@ -114,35 +118,14 @@ class ProconBypassMan::Configuration
     "#{root}/.setting_yaml_digest"
   end
 
-  # @return [String] pbm-webの接続先
-  def internal_api_servers
-    if !!ENV["INTERNAL_API_SERVER"]
-      [ENV["INTERNAL_API_SERVER"]]
-    else
-      [ 'http://localhost:9090',
-        'http://localhost:8080',
-      ].compact
-    end
-  end
-
-  # @return [Array<ProconBypassMan::ServerPool>]
-  def internal_server_pool
-    @internal_server_pool ||= ProconBypassMan::ServerPool.new(servers: internal_api_servers)
-  end
-
-  # @return [Array<ProconBypassMan::ServerPool>]
-  def server_pool
-    @server_pool ||= ProconBypassMan::ServerPool.new(servers: api_servers)
-  end
-
   # @return [String, NilClass]
-  def current_server
-    server_pool.server
+  def api_server
+    api_servers&.first
   end
 
   # @return [String, NilClass]
   def current_ws_server
-    if (uri = URI.parse(server_pool.server))
+    if (uri = URI.parse(api_server))
       if uri.port == 443
         return "ws://#{uri.host}"
       else
@@ -161,7 +144,7 @@ class ProconBypassMan::Configuration
 
   # @return [Boolean]
   def enable_ws?
-    !!current_server
+    !!api_server
   end
 
   # @return [Boolean]
@@ -178,8 +161,9 @@ class ProconBypassMan::Configuration
     end
   end
 
+  # @return [Boolean]
   def has_api_server?
-    not api_servers.length.zero?
+    !!api_server
   end
 
   def verbose_bypass_log
@@ -190,19 +174,14 @@ class ProconBypassMan::Configuration
     @raw_setting ||= {}
   end
 
-  # @return [Boolean] default false
-  def enable_reporting_pressed_buttons
-    @enable_reporting_pressed_buttons ||= false
-  end
-
   # @return [Boolean] default false
   def never_exit_accidentally
     @never_exit_accidentally || false
   end
 
-  # @return [Boolean] default false
-  def io_monitor_logging
-    @io_monitor_logging ||= false
+  # @return [Boolean] プロコンから「入力にかかっている時間」と「1秒間あたり何回入力できているか」をサーバに送信する
+  def enable_procon_performance_measurement?
+    has_api_server?
   end
 
   # @return [Boolean] default true

data/lib/procon_bypass_man/device_connection/procon_setting_overrider.rb

@@ -2,17 +2,26 @@ class ProconBypassMan::DeviceConnection::ProconSettingOverrider
   attr_accessor :procon, :output_report_watcher, :output_report_generator
 
   SUB_COMMAND_HOME_LED_ON = "38"
+  SUB_COMMAND_VIBRATION = "48"
+
   SUB_COMMAND_ARG_HOME_LED_ON = "1FF0FF"
+  SUB_COMMAND_ARG_VIBRATION_OFF = "00"
+
+  ALL_SETTINGS = {
+    home_led_on: [SUB_COMMAND_HOME_LED_ON, SUB_COMMAND_ARG_HOME_LED_ON],
+    vibration_off: [SUB_COMMAND_VIBRATION, SUB_COMMAND_ARG_VIBRATION_OFF],
+  }
+
+  # TODO 自動生成する
   SPECIAL_SUB_COMMAND_ARGS =  {
     SUB_COMMAND_HOME_LED_ON => SUB_COMMAND_ARG_HOME_LED_ON,
+    SUB_COMMAND_VIBRATION => SUB_COMMAND_ARG_VIBRATION_OFF,
   }
-  SETTING_HOME_LED_ON = { home_led_on: [SUB_COMMAND_HOME_LED_ON, SUB_COMMAND_ARG_HOME_LED_ON] }
-  ALL_SETTINGS = SETTING_HOME_LED_ON
 
   def initialize(procon: )
     use_steps = {}
     if ProconBypassMan.config.enable_home_led_on_connect
-      use_steps.merge!(SETTING_HOME_LED_ON)
+      use_steps.merge!(ALL_SETTINGS)
     end
 
     @setting_steps = use_steps.keys

data/lib/procon_bypass_man/procon/analog_stick_manipulator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ProconBypassMan::Procon::AnalogStickManipulator
   attr_accessor :manipulated_abs_x, :manipulated_abs_y
 

data/lib/procon_bypass_man/procon/layer_changer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ProconBypassMan::Procon::LayerChanger
   # @param [ProconBypassMan::Domains::ProcessingProconBinary] binary
   def initialize(binary: )

data/lib/procon_bypass_man/procon/macro.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ProconBypassMan::Procon::Macro
   class BaseNestedStep
     def initialize(value)
@@ -99,7 +101,7 @@ class ProconBypassMan::Procon::Macro
 
       if nested_step.over?
         steps.shift # NestedStepを破棄する
-        self.after_callback_block.call if self.after_callback_block
+        self.after_callback_block.call if self.after_callback_block && steps.empty?
         return next_step
       else
         return nested_step.next_step

data/lib/procon_bypass_man/procon/macro_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ProconBypassMan::Procon::MacroBuilder
   class SubjectMerger
     def self.merge(subjects)

data/lib/procon_bypass_man/procon/macro_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ProconBypassMan::Procon::MacroRegistry
   PRESETS = {
     null: [],

data/lib/procon_bypass_man/procon/performance_measurement/last_bypass_at.rb

@@ -0,0 +1,17 @@
+class ProconBypassMan::Procon::PerformanceMeasurement::LastBypassAt
+  include Singleton
+
+  attr_accessor :mutex, :last_bypass_at
+
+  def initialize
+    self.mutex = Mutex.new
+    self.last_bypass_at = Time.now
+  end
+
+  def self.touch(&block)
+    instance.mutex.synchronize do
+      block.call(Time.now - instance.last_bypass_at)
+      instance.last_bypass_at = Time.now
+    end
+  end
+end

data/lib/procon_bypass_man/procon/performance_measurement/measurement_collection.rb

@@ -0,0 +1,9 @@
+# TODO SpanCollection にする
+class  ProconBypassMan::Procon::PerformanceMeasurement::MeasurementCollection
+  attr_accessor :timestamp_key, :spans
+
+  def initialize(timestamp_key: , spans: )
+    self.timestamp_key = timestamp_key
+    self.spans = spans
+  end
+end

data/lib/procon_bypass_man/procon/performance_measurement/measurements_summarizer.rb

@@ -0,0 +1,101 @@
+class ProconBypassMan::Procon::PerformanceMeasurement::MeasurementsSummarizer
+  class PerformanceMetric < Struct.new(:interval_from_previous_succeed_max,
+                                       :interval_from_previous_succeed_p50,
+                                       :write_time_max,
+                                       :write_time_p50,
+                                       :read_time_max,
+                                       :read_time_p50,
+                                       :time_taken_p50,
+                                       :time_taken_p95,
+                                       :time_taken_p99,
+                                       :time_taken_max,
+                                       :read_error_count,
+                                       :write_error_count,
+                                       :gc_count,
+                                       :gc_time,
+                                       :succeed_rate); end
+
+  def initialize(spans: )
+    @spans = spans
+  end
+
+  # @return [PerformanceMetric]
+  # NOTE 中央値の表示価値が低いのでコメントアウト
+  def summarize
+
+    write_time_max = 0
+    read_time_max = 0
+    time_taken_max = 0
+    interval_from_previous_succeed_max = 0
+    @spans.each do |span|
+      # NOTE @spans.map(&:write_time).sort.last と同じことだけど、処理コストを軽くするためにループを共通化する
+      write_time_max = span.write_time if write_time_max < span.write_time
+      read_time_max = span.read_time if write_time_max < span.read_time
+      time_taken_max = span.time_taken if span.succeed && time_taken_max < span.time_taken
+      interval_from_previous_succeed_max = span.interval_from_previous_succeed if span.succeed && interval_from_previous_succeed_max < span.interval_from_previous_succeed
+    end
+
+    # NOTE 今はGCを無効にしており、集計するまでもないのでコメントアウトにする. 今後GCを有効にしたバイパスをするかもしれないので残しておく
+    gc_count = 0 # @spans.map(&:gc_count).sum
+    gc_time = 0 # @spans.map(&:gc_time).sum
+
+    # sorted_interval_from_previous_succeed = @spans.select(&:succeed).map(&:interval_from_previous_succeed).sort
+    # interval_from_previous_succeed_max = sorted_interval_from_previous_succeed.last || 0
+    interval_from_previous_succeed_p50 = 0 # percentile(sorted_list: sorted_interval_from_previous_succeed , percentile: 0.50)
+
+    # sorted_read_time = @spans.map(&:read_time).sort
+    read_time_p50 = 0 # percentile(sorted_list: sorted_read_time , percentile: 0.50)
+    # read_time_max = sorted_read_time.last || 0
+
+    # sorted_write_time = @spans.map(&:write_time).sort
+    write_time_p50 = 0 # percentile(sorted_list: sorted_write_time , percentile: 0.50)
+    # write_time_max = sorted_write_time.last || 0
+
+    # sorted_time_taken = @spans.select(&:succeed).map(&:time_taken).sort
+    time_taken_p50 = 0 # percentile(sorted_list: sorted_time_taken, percentile: 0.50)
+    time_taken_p95 = 0 # percentile(sorted_list: sorted_time_taken, percentile: 0.95)
+    time_taken_p99 = 0 # percentile(sorted_list: sorted_time_taken, percentile: 0.99)
+    # time_taken_max = sorted_time_taken.last || 0
+
+    # NOTE webに表示していないのでコメントアウト. デバッグ時に見ることがあるので残しておく
+    total_read_error_count = 0 # @spans.map(&:read_error_count).sum
+    total_write_error_count = 0 # @spans.map(&:write_error_count).sum
+
+    # succeed_rate =
+    #   if @spans.length.zero?
+    #     0
+    #   else
+    #     succeed_rate = (sorted_time_taken.length / @spans.length.to_f).floor(3)
+    #   end
+    succeed_rate = 1 # Switchへの書き込みに失敗した時にretryしているので100%になるようになってる. succeedの個数をカウントコストを減らすためにハードコード
+
+    PerformanceMetric.new(interval_from_previous_succeed_max,
+                          interval_from_previous_succeed_p50,
+                          write_time_max,
+                          write_time_p50,
+                          read_time_max,
+                          read_time_p50,
+                          time_taken_p50,
+                          time_taken_p95,
+                          time_taken_p99,
+                          time_taken_max,
+                          total_read_error_count,
+                          total_write_error_count,
+                          gc_count,
+                          gc_time,
+                          succeed_rate)
+  end
+
+  private
+
+  # @param [Array<Numeric>] sorted_list
+  # @param [Float] percentile
+  # @return [Float]
+  def percentile(sorted_list: , percentile: )
+    return 0.0 if sorted_list.empty?
+    values_sorted = sorted_list
+    k = ((percentile*(values_sorted.length-1))+1).floor - 1
+    f = ((percentile*(values_sorted.length-1))+1).modulo(1)
+    return(values_sorted[k] + (f * (values_sorted[k+1] - values_sorted[k]))).floor(3)
+  end
+end

data/lib/procon_bypass_man/procon/performance_measurement/procon_performance_span_transfer_job.rb

@@ -0,0 +1,8 @@
+# Bypassプロセスが収集したパフォーマンスメトリクスを、集計するためにmasterプロセスに転送するためジョブ
+class ProconBypassMan::ProconPerformanceSpanTransferJob
+  extend ProconBypassMan::Background::JobPerformable
+
+  def self.perform(spans)
+    ProconBypassMan::Procon::PerformanceMeasurement::QueueOverProcess.push(spans)
+  end
+end

data/lib/procon_bypass_man/procon/performance_measurement/queue_over_process.rb

@@ -0,0 +1,38 @@
+class ProconBypassMan::Procon::PerformanceMeasurement::QueueOverProcess
+  extend ProconBypassMan::CanOverProcess
+
+  include Singleton
+
+  attr_reader :distributed_queue
+
+  # @override
+  def self.enable?
+    ProconBypassMan.config.enable_procon_performance_measurement?
+  end
+
+  # @override
+  def self.distributed_class
+    ProconBypassMan::Procon::PerformanceMeasurement::SpanQueue
+  end
+
+  # @override
+  def self.socket_file_path
+    "/tmp/procon_bypass_man_procon_performance_queue".freeze
+  end
+
+  def self.push(value)
+    return unless enable?
+
+    instance.distributed_queue.push(value)
+  end
+
+  def self.pop
+    return unless enable?
+
+    instance.distributed_queue.pop
+  end
+
+  def initialize
+    @distributed_queue = DRbObject.new_with_uri(self.class.socket_path)
+  end
+end

data/lib/procon_bypass_man/procon/performance_measurement/span_queue.rb

@@ -0,0 +1,42 @@
+class ProconBypassMan::Procon::PerformanceMeasurement::SpanQueue
+  def initialize
+    @current_table = {} # 1つのスレッドからしか触らないのでlockはいらない
+    @measurement_collection_list = [] # main threadとjob worker threadから触るのでlockが必要
+  end
+
+  # @param [Array<PerformanceSpan>] spans
+  # bypassプロセスから呼ばれる. 実際に実行を行なっているのはmasterプロセス
+  def push(new_spans)
+    current_key = generate_bucket_key
+
+    if @current_table[current_key].nil?
+      if not @current_table.empty?
+        timestamp_key = @current_table.keys.first
+        spans = @current_table.values.first
+        # 本当ならmutexでlockする必要があるけど、正確性はいらないのでパフォーマンスを上げるためにlockしない
+        @measurement_collection_list.push(
+          ProconBypassMan::Procon::PerformanceMeasurement::MeasurementCollection.new(timestamp_key: timestamp_key, spans: spans)
+        )
+      end
+
+      @current_table = {}
+      @current_table[current_key] = []
+      @current_table[current_key].concat(new_spans)
+    else
+      @current_table[current_key].concat(new_spans)
+    end
+  end
+
+  # job workerから呼ばれる
+  # @return [ProconBypassMan::Procon::PerformanceMeasurement::MeasurementCollection]
+  def pop
+    @measurement_collection_list.pop
+  end
+
+  private
+
+  # 1分単位で次の値になる
+  def generate_bucket_key
+    Time.new.strftime("%Y-%m-%d %H:%M:00%:z")
+  end
+end

data/lib/procon_bypass_man/procon/performance_measurement/span_transfer_buffer.rb

@@ -0,0 +1,39 @@
+class ProconBypassMan::Procon::PerformanceMeasurement::SpanTransferBuffer
+  include Singleton
+
+  def initialize
+    @buff = []
+  end
+
+  # @param [Span]
+  # @return [void]
+  def push_and_run_block_if_buffer_over(value, &block)
+    push(value)
+    return unless buffer_over?
+
+    block.call(spans)
+    clear
+  end
+
+  private
+
+  def spans
+    @buff
+  end
+
+  def clear
+    @buff.clear
+  end
+
+  def push(value)
+    @buff << value
+  end
+
+  def buffer_over?
+    @buff.length > max_buffer
+  end
+
+  def max_buffer
+    50
+  end
+end

data/lib/procon_bypass_man/procon/performance_measurement.rb

@@ -0,0 +1,110 @@
+module ProconBypassMan::Procon::PerformanceMeasurement; end
+
+require 'benchmark'
+require 'procon_bypass_man/procon/performance_measurement/measurements_summarizer'
+require 'procon_bypass_man/procon/performance_measurement/span_queue'
+require 'procon_bypass_man/procon/performance_measurement/procon_performance_span_transfer_job'
+require 'procon_bypass_man/procon/performance_measurement/span_transfer_buffer'
+require 'procon_bypass_man/procon/performance_measurement/measurement_collection'
+require 'procon_bypass_man/procon/performance_measurement/queue_over_process'
+require 'procon_bypass_man/procon/performance_measurement/last_bypass_at'
+
+module ProconBypassMan::Procon::PerformanceMeasurement
+  class PerformanceSpan
+    attr_accessor :time_taken, :succeed, :interval_from_previous_succeed, :gc_count, :gc_time
+    attr_reader :write_error_count, :read_error_count, :write_time, :read_time
+
+    def initialize
+      @write_error_count = 0
+      @read_error_count = 0
+      @time_taken = 0.0
+      @succeed = nil
+      @interval_from_previous_succeed = nil
+      @custom_metric = {}
+      @write_time = 0.0
+      @read_time = 0.0
+      @gc_time = 0.0
+    end
+
+    def record_read_error
+      @read_error_count += 1
+    end
+
+    def record_write_error
+      @write_error_count += 1
+    end
+
+    def record_write_time(&block)
+      result = nil
+      @write_time = Benchmark.realtime { result = block.call }
+      return result
+    end
+
+    def record_read_time(&block)
+      @read_time = Benchmark.realtime { block.call }
+    end
+  end
+
+  # 全部送ると負荷になるので適当にまびく
+  def self.is_not_measure_with_random_or_if_fast(span: )
+    return false if span.time_taken > 0.1
+    return true if rand(20) != 0 # 19/20は捨てる
+    return false
+  end
+
+  # measureをして、measureの結果をためる
+  # @return [Boolean] 成功したか. テスト時に戻り値を使いたい
+  def self.measure(&bypass_process_block)
+    unless ProconBypassMan.config.enable_procon_performance_measurement?
+      bypass_process_block.call(PerformanceSpan.new)
+      return
+    end
+
+    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.1.0")
+      snapshot_gc_time = GC.stat(:time) / 1000.0
+    end
+    snapshot_gc_count = GC.count
+    span = PerformanceSpan.new
+
+    span.time_taken = Benchmark.realtime {
+      span.succeed = bypass_process_block.call(span)
+    }.floor(3)
+
+    return if is_not_measure_with_random_or_if_fast(span: span)
+
+    if span.succeed
+      ProconBypassMan::Procon::PerformanceMeasurement::LastBypassAt.touch do |interval_from_previous_succeed|
+        span.interval_from_previous_succeed = interval_from_previous_succeed.floor(3)
+      end
+    end
+
+    (GC.count - snapshot_gc_count).tap do |increased_gc_count|
+      span.gc_count = increased_gc_count
+    end
+
+    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.1.0")
+      ((GC.stat(:time) / 1000.0) - snapshot_gc_time).tap do |increased_time|
+        span.gc_time = increased_time
+      end
+    end
+
+    # measureするたびにperform_asyncしているとjob queueが詰まるのでbufferingしている
+    ProconBypassMan::Procon::PerformanceMeasurement::SpanTransferBuffer.instance.push_and_run_block_if_buffer_over(span) do |spans|
+      ProconBypassMan::ProconPerformanceSpanTransferJob.perform_async(spans)
+    end
+    return span.succeed
+  end
+
+  # @return [MeasurementCollection, NilClass]
+  # bypassしているプロセスから呼ばれる
+  def self.pop_measurement_collection
+    ProconBypassMan::Procon::PerformanceMeasurement::QueueOverProcess.pop
+  end
+
+  # @param [MeasurementCollection] spans
+  # @return [ProconBypassMan::Procon::PerformanceMeasurement::MeasurementsSummarizer::PerformanceMetric]
+  # jobから呼ばれる予定
+  def self.summarize(spans: )
+    ProconBypassMan::Procon::PerformanceMeasurement::MeasurementsSummarizer.new(spans: spans).summarize
+  end
+end

data/lib/procon_bypass_man/procon/suppress_rumble.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ProconBypassMan::SuppressRumble
   # @param [String] binary
   def initialize(binary: )

data/lib/procon_bypass_man/procon/user_operation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # ボタンを押しているか判断するクラス。バイナリの書き換えはしない
 class ProconBypassMan::Procon::UserOperation
   attr_reader :binary

data/lib/procon_bypass_man/procon/value_objects/analog_stick.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ProconBypassMan::Procon::AnalogStick
   attr_accessor :neutral_position
   attr_writer :bin_x, :bin_y

data/lib/procon_bypass_man/procon/value_objects/binary/inbound_procon_binary.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # proconから取得したばかりのバイナリ
 class ProconBypassMan::Domains::InboundProconBinary < ProconBypassMan::Domains::Binary::Base
   include ProconBypassMan::Domains::HasImmutableBinary

data/lib/procon_bypass_man/procon/value_objects/binary/processing_procon_binary.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # バイナリの書き換えのみをする
 class ProconBypassMan::Domains::ProcessingProconBinary < ProconBypassMan::Domains::Binary::Base
   include ProconBypassMan::Domains::HasMutableBinary

data/lib/procon_bypass_man/procon/value_objects/rumble_binary.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ProconBypassMan::RumbleBinary
   # @param [String] binary
   def initialize(binary: )