procon_bypass_man 0.2.0 → 0.2.3

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/macro.rb

@@ -99,7 +99,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/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,84 @@
+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]
+  def summarize
+    sorted_write_time = @spans.map(&:write_time).sort
+    sorted_read_time = @spans.map(&:read_time).sort
+    gc_count = @spans.map(&:gc_count).sum
+    gc_time = @spans.map(&:gc_time).sum
+
+    sorted_time_taken = @spans.select(&:succeed).map(&:time_taken).sort
+    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 = percentile(sorted_list: sorted_interval_from_previous_succeed , percentile: 0.50)
+
+    write_time_max = sorted_write_time.last || 0
+    write_time_p50 = percentile(sorted_list: sorted_write_time , percentile: 0.50)
+
+    read_time_max = sorted_read_time.last || 0
+    read_time_p50 = percentile(sorted_list: sorted_read_time , percentile: 0.50)
+
+    time_taken_p50 = percentile(sorted_list: sorted_time_taken, percentile: 0.50)
+    time_taken_p95 = percentile(sorted_list: sorted_time_taken, percentile: 0.95)
+    time_taken_p99 = percentile(sorted_list: sorted_time_taken, percentile: 0.99)
+    time_taken_max = sorted_time_taken.last || 0
+
+    total_read_error_count = @spans.map(&:read_error_count).sum
+    total_write_error_count = @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
+
+    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
+    200
+  end
+end

data/lib/procon_bypass_man/procon/performance_measurement.rb

@@ -0,0 +1,103 @@
+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
+
+  # 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)
+
+    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
+
+    ProconBypassMan::GC.stop_gc_in do
+      # 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.dup)
+      end
+    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.rb

@@ -7,8 +7,9 @@ class ProconBypassMan::Procon
   require "procon_bypass_man/procon/value_objects/rumble_binary"
   require "procon_bypass_man/procon/value_objects/binary"
   require "procon_bypass_man/procon/value_objects/bypass_mode"
-
   require "procon_bypass_man/procon/consts"
+  require "procon_bypass_man/procon/performance_measurement"
+  require "procon_bypass_man/procon/performance_measurement/queue_over_process"
   require "procon_bypass_man/procon/mode_registry"
   require "procon_bypass_man/procon/macro"
   require "procon_bypass_man/procon/macro_registry"

data/lib/procon_bypass_man/procon_display/bypass_hook.rb

@@ -0,0 +1,12 @@
+module ProconBypassMan::ProconDisplay::BypassHook
+  include ProconBypassMan::Callbacks
+
+  define_callbacks :run
+
+  set_callback :run, :after, :write_procon_display_status
+
+  def write_procon_display_status
+    return unless bypass_value.binary
+    ProconBypassMan::ProconDisplay::Status.instance.current = bypass_value.binary.to_procon_reader.to_hash.dup
+  end
+end

data/lib/procon_bypass_man/procon_display/http_request.rb

@@ -0,0 +1,31 @@
+module ProconBypassMan::ProconDisplay
+  # NOTE Support GET only
+  class HttpRequest
+    def self.parse(conn)
+      headers = {}
+      loop do
+        line = conn.gets("\n")&.strip
+        break if line.nil? || line.strip.empty?
+        key, value = line.split(/:\s/, 2)
+        headers[key] = value
+      end
+
+      new(headers)
+    end
+
+    def initialize(headers)
+      @headers = headers
+    end
+
+    def path
+      request_method_and_path = @headers.detect { |key, _value| key.start_with?("GET") }.first
+      if request_method_and_path =~ /(?:GET) ([^ ]+)/ && (path = $1)
+        return path
+      end
+    end
+
+    def to_hash
+      { "PATH" => path }
+    end
+  end
+end

data/lib/procon_bypass_man/procon_display/http_response.rb

@@ -0,0 +1,23 @@
+module ProconBypassMan::ProconDisplay
+  class HttpResponse
+    def initialize(body, status: , format: "text/json")
+      @body = body&.to_json
+      @status = status
+      @format = format
+    end
+
+    def to_s
+      <<~EOH
+        HTTP/1.1 #{@status}
+        Content-Length: #{@body&.bytes&.size || 0}
+        Content-Type: #{@format}
+        Access-Control-Allow-Origin: *
+        Access-Control-Allow-Methods: GET
+        Access-Control-Allow-Private-Network：true
+        Connection: close
+
+        #{@body}
+      EOH
+    end
+  end
+end

data/lib/procon_bypass_man/procon_display/server.rb

@@ -0,0 +1,33 @@
+require 'socket'
+
+module ProconBypassMan::ProconDisplay
+  class Server
+    PORT = 9900
+
+    def self.start!
+      Thread.new do
+        new.start_with_foreground
+      end
+    end
+
+    def initialize
+      @server = TCPServer.new('0.0.0.0', PORT)
+    end
+
+    def start_with_foreground
+      loop do
+        conn = @server.accept
+        response = ServerApp.new(
+          HttpRequest.parse(conn).to_hash
+        ).call
+        conn.write(response)
+        conn.close
+      end
+    rescue Errno::EADDRINUSE => e
+      ProconBypassMan::SendErrorCommand.execute(error: e)
+    rescue => e
+      ProconBypassMan::SendErrorCommand.execute(error: e)
+      retry
+    end
+  end
+end

data/lib/procon_bypass_man/procon_display/server_app.rb

@@ -0,0 +1,17 @@
+module ProconBypassMan::ProconDisplay
+  class ServerApp
+    def initialize(env)
+      @env = env
+    end
+
+    def call
+      case @env["PATH"]
+      when "/input"
+        response = ProconBypassMan::ProconDisplay::Status.instance.current
+        HttpResponse.new(response, status: 200).to_s
+      else
+        HttpResponse.new(nil, status: 404).to_s
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/procon_display/status.rb

@@ -0,0 +1,20 @@
+require 'singleton'
+
+class ProconBypassMan::ProconDisplay::Status
+  include Singleton
+
+  # @return [Hash]
+  def current
+    @current || {}
+  end
+
+  # @return [void]
+  # @param [Hash] value
+  def current=(value)
+    if value.is_a?(Hash)
+      @current = value
+    else
+      @current = nil
+    end
+  end
+end

data/lib/procon_bypass_man/procon_display.rb

@@ -0,0 +1,11 @@
+# 入力表示用
+
+module ProconBypassMan::ProconDisplay
+end
+
+require "procon_bypass_man/procon_display/server"
+require "procon_bypass_man/procon_display/server_app"
+require "procon_bypass_man/procon_display/status"
+require "procon_bypass_man/procon_display/http_response"
+require "procon_bypass_man/procon_display/http_request"
+require "procon_bypass_man/procon_display/bypass_hook"

data/lib/procon_bypass_man/remote_macro/queue_over_process.rb

@@ -1,62 +1,44 @@
-class ProconBypassMan::QueueOverProcess
-  attr_reader :drb
-
-  @@drb_server = nil
-  @@drb_server_thread = nil
-
-  def self.start!
-    return unless ProconBypassMan.config.enable_remote_macro?
-    require 'drb/drb'
-
-    FileUtils.rm_rf(file_path) if File.exist?(file_path)
-    begin
-      @@drb_server = DRb.start_service(url, Queue.new, safe_level: 1)
-    rescue Errno::EADDRINUSE => e
-      ProconBypassMan.logger.error e
-      raise
-    end
-
-    @@drb_server_thread =
-      Thread.new do
-        DRb.thread.join
-      end
-  end
+class ProconBypassMan::RemoteMacro::QueueOverProcess
+  extend ProconBypassMan::CanOverProcess
 
-  def self.shutdown
-    if @@drb_server
-      @@drb_server_thread.kill
-      @@drb_server.stop_service
-    end
-  end
+  include Singleton
 
-  def self.push(value)
-    return unless ProconBypassMan.config.enable_remote_macro?
+  attr_reader :distributed_queue
 
-    drb.push(value)
+  # @override
+  def self.enable?
+    ProconBypassMan.config.enable_remote_macro?
   end
 
-  def self.pop
-    return unless ProconBypassMan.config.enable_remote_macro?
+  # @override
+  def self.distributed_class
+    Queue
+  end
 
-    drb.pop
+  # @override
+  def self.socket_file_path
+    "/tmp/procon_bypass_man_remote_macro_queue".freeze
   end
 
-  def self.drb
-    return unless ProconBypassMan.config.enable_remote_macro?
+  def self.push(value)
+    return unless enable?
 
-    @@drb ||= new.drb
+    instance.distributed_queue.push(value)
   end
 
-  PROTOCOL = "drbunix"
-  def self.url
-    "#{PROTOCOL}:/tmp/procon_bypass_man_queue"
+  def self.pop
+    return unless enable?
+
+    instance.distributed_queue.pop
   end
 
-  def self.file_path
-    url.gsub("#{PROTOCOL}:", "")
+  def self.clear
+    return unless enable?
+
+    instance.distributed_queue.clear
   end
 
   def initialize
-    @drb = DRbObject.new_with_uri(self.class.url)
+    @distributed_queue = DRbObject.new_with_uri(self.class.socket_path)
   end
 end