procon_bypass_man 0.2.1 → 0.3.0

data/lib/procon_bypass_man/background/job_queue.rb

@@ -0,0 +1,50 @@
+class ProconBypassMan::Background::JobQueue
+  extend ProconBypassMan::CanOverProcess
+
+  include Singleton
+
+  attr_reader :distributed_queue
+
+  # @override
+  def self.enable?
+    true
+  end
+
+  # @override
+  def self.distributed_class
+    Queue
+  end
+
+  # @override
+  def self.socket_file_path
+    "/tmp/procon_bypass_man_background_job_queue_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 self.size
+    return unless enable?
+
+    instance.distributed_queue.size
+  end
+
+  def self.clear
+    return unless enable?
+
+    instance.distributed_queue.clear
+  end
+
+  def initialize
+    @distributed_queue = DRbObject.new_with_uri(self.class.socket_path)
+  end
+end

data/lib/procon_bypass_man/background/jobs/base_job.rb

@@ -1,5 +1,5 @@
 class ProconBypassMan::BaseJob
-  extend ProconBypassMan::Background::JobRunnable
+  extend ProconBypassMan::Background::JobPerformable
 
   def self.servers
     raise NotImplementedError

data/lib/procon_bypass_man/background/jobs/concerns/has_external_api_setting.rb

@@ -1,5 +1,5 @@
 module ProconBypassMan::HasExternalApiSetting
-  def server_pool
-    ProconBypassMan.config.server_pool
+  def api_server
+    ProconBypassMan.config.api_server
   end
 end

data/lib/procon_bypass_man/background/jobs/concerns/job_performable.rb

@@ -0,0 +1,16 @@
+module ProconBypassMan
+  module Background
+    module JobPerformable
+      def perform(*)
+        raise NotImplementedError, nil
+      end
+
+      def perform_async(*args)
+        ProconBypassMan::Background::JobQueue.push(
+          args: args,
+          job_class: self.name, # drb上のQueueに格納するので念の為文字列入れて、取り出すときにevalでクラス化する
+        )
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/background/jobs/post_completed_remote_macro_job.rb

@@ -5,7 +5,7 @@ class ProconBypassMan::PostCompletedRemoteMacroJob < ProconBypassMan::BaseJob
   def self.perform(job_id)
     ProconBypassMan::RemoteMacroHttpClient.new(
       path: path,
-      server_pool: server_pool,
+      server: api_server,
     ).post(job_id: job_id)
   end
 

data/lib/procon_bypass_man/background/jobs/report_boot_job.rb

@@ -5,7 +5,7 @@ class ProconBypassMan::ReportBootJob < ProconBypassMan::ReportEventBaseJob
   def self.perform(body)
     ProconBypassMan::ReportHttpClient.new(
       path: path,
-      server_pool: server_pool,
+      server: api_server,
       retry_on_connection_error: true,
     ).post(body: body, event_type: :boot)
   end

data/lib/procon_bypass_man/background/jobs/report_completed_upgrade_pbm_job.rb

@@ -4,7 +4,7 @@ class ProconBypassMan::ReportCompletedUpgradePbmJob < ProconBypassMan::ReportEve
   def self.perform
     ProconBypassMan::ReportHttpClient.new(
       path: path,
-      server_pool: server_pool,
+      server: api_server,
     ).post(body: nil, event_type: :completed_upgrade_pbm)
   end
 end

data/lib/procon_bypass_man/background/jobs/report_error_job.rb

@@ -5,7 +5,7 @@ class ProconBypassMan::ReportErrorJob < ProconBypassMan::ReportEventBaseJob
   def self.perform(body)
     ProconBypassMan::ReportHttpClient.new(
       path: path,
-      server_pool: server_pool,
+      server: api_server,
     ).post(body: body, event_type: :error)
   end
 end

data/lib/procon_bypass_man/background/jobs/report_error_reload_config_job.rb

@@ -5,7 +5,7 @@ class ProconBypassMan::ReportErrorReloadConfigJob < ProconBypassMan::ReportEvent
   def self.perform(body)
     ProconBypassMan::ReportHttpClient.new(
       path: path,
-      server_pool: server_pool,
+      server: api_server,
     ).post(body: body, event_type: :error_reload_config)
   end
 end

data/lib/procon_bypass_man/background/jobs/report_load_config_job.rb

@@ -5,7 +5,7 @@ class ProconBypassMan::ReportLoadConfigJob < ProconBypassMan::ReportEventBaseJob
   def self.perform(body)
     ProconBypassMan::ReportHttpClient.new(
       path: path,
-      server_pool: server_pool,
+      server: api_server,
     ).post(body: body, event_type: :load_config)
   end
 end

data/lib/procon_bypass_man/background/jobs/report_procon_performance_measurements_job.rb

@@ -0,0 +1,43 @@
+class ProconBypassMan::ReportProconPerformanceMeasurementsJob < ProconBypassMan::BaseJob
+  extend ProconBypassMan::HasExternalApiSetting
+
+  # @param [ProconBypassMan::Procon::PerformanceMeasurement::MeasurementCollection] measurement_collection
+  def self.perform(measurement_collection)
+    return if measurement_collection.nil?
+
+    collected_spans_size = measurement_collection.spans.size
+    metric = ProconBypassMan::Procon::PerformanceMeasurement.summarize(
+      spans: measurement_collection.spans
+    )
+    body = {
+      timestamp: measurement_collection.timestamp_key,
+      interval_from_previous_succeed_max: metric.interval_from_previous_succeed_max,
+      interval_from_previous_succeed_p50: metric.interval_from_previous_succeed_p50,
+      write_time_max: metric.write_time_max,
+      write_time_p50: metric.write_time_p50,
+      read_time_max: metric.read_time_max,
+      read_time_p50: metric.read_time_p50,
+      time_taken_max: metric.time_taken_max,
+      time_taken_p50: metric.time_taken_p50,
+      time_taken_p95: metric.time_taken_p95,
+      time_taken_p99: metric.time_taken_p99,
+      read_error_count: metric.read_error_count,
+      write_error_count: metric.write_error_count,
+      gc_count: metric.gc_count,
+      gc_time: metric.gc_time,
+      succeed_rate: metric.succeed_rate,
+      load_agv: ProconBypassMan::LoadAgv.new.get,
+      collected_spans_size: collected_spans_size,
+    }
+    ProconBypassMan.logger.info(body)
+
+    ProconBypassMan::ProconPerformanceHttpClient.new(
+      path: path,
+      server: api_server,
+    ).post(body: body)
+  end
+
+  def self.path
+    "/api/devices/#{ProconBypassMan.device_id}/procon_performance_metrics"
+  end
+end

data/lib/procon_bypass_man/background/jobs/report_reload_config_job.rb

@@ -5,7 +5,7 @@ class ProconBypassMan::ReportReloadConfigJob < ProconBypassMan::ReportEventBaseJ
   def self.perform(body)
     ProconBypassMan::ReportHttpClient.new(
       path: path,
-      server_pool: server_pool,
+      server: api_server,
     ).post(body: body, event_type: :reload_config)
   end
 end

data/lib/procon_bypass_man/background/jobs/report_start_reboot_job.rb

@@ -4,7 +4,7 @@ class ProconBypassMan::ReportStartRebootJob < ProconBypassMan::ReportEventBaseJo
   def self.perform
     ProconBypassMan::ReportHttpClient.new(
       path: path,
-      server_pool: server_pool,
+      server: api_server,
     ).post(body: nil, event_type: :start_reboot)
   end
 end

data/lib/procon_bypass_man/background/jobs/sync_device_stats_job.rb

@@ -5,7 +5,7 @@ class ProconBypassMan::SyncDeviceStatsJob < ProconBypassMan::BaseJob
   def self.perform(status)
     ProconBypassMan::SendDeviceStatsHttpClient.new(
       path: path,
-      server_pool: server_pool,
+      server: api_server,
     ).post(status: status, pbm_session_id: ProconBypassMan.session_id)
   end
 

data/lib/procon_bypass_man/background.rb

@@ -1,7 +1,6 @@
-require "procon_bypass_man/background/jobs/concerns/has_internal_api_setting"
 require "procon_bypass_man/background/jobs/concerns/has_external_api_setting"
-require "procon_bypass_man/background/jobs/concerns/job_runnable"
-require "procon_bypass_man/background/job_runner"
+require "procon_bypass_man/background/jobs/concerns/job_performable"
+require "procon_bypass_man/background/job_queue"
 require "procon_bypass_man/background/job_performer"
 require "procon_bypass_man/background/jobs/base_job"
 require "procon_bypass_man/background/jobs/report_event_base_job"
@@ -11,7 +10,7 @@ require "procon_bypass_man/background/jobs/report_reload_config_job"
 require "procon_bypass_man/background/jobs/report_error_reload_config_job"
 require "procon_bypass_man/background/jobs/report_load_config_job"
 require "procon_bypass_man/background/jobs/report_error_job"
-require "procon_bypass_man/background/jobs/report_pressed_buttons_job"
 require "procon_bypass_man/background/jobs/report_completed_upgrade_pbm_job"
+require "procon_bypass_man/background/jobs/report_procon_performance_measurements_job"
 require "procon_bypass_man/background/jobs/sync_device_stats_job"
 require "procon_bypass_man/background/jobs/post_completed_remote_macro_job"

data/lib/procon_bypass_man/bypass/bypass_command.rb

@@ -6,13 +6,9 @@ class ProconBypassMan::BypassCommand
     RESTART = :restart
   end
 
-  def initialize(gadget:, procon:)
+  def initialize(gadget: , procon: )
     @gadget = gadget
     @procon = procon
-
-    ProconBypassMan::IOMonitor.start! if ProconBypassMan.io_monitor_logging
-    ProconBypassMan::Background::JobRunner.queue.clear # forkしたときに残留物も移ってしまうため
-    ProconBypassMan::Background::JobRunner.start!
   end
 
   def execute
@@ -29,25 +25,17 @@ class ProconBypassMan::BypassCommand
 
     # gadget => procon
     # 遅くていい
-    monitor1 = ProconBypassMan::IOMonitor.new(label: "switch -> procon")
-    monitor2 = ProconBypassMan::IOMonitor.new(label: "procon -> switch")
     ProconBypassMan.logger.info "Thread1を起動します"
 
     cycle_sleep = ProconBypassMan::CycleSleep.new(cycle_interval: 1, execution_cycle: ProconBypassMan.config.bypass_mode.gadget_to_procon_interval)
 
     t1 = Thread.new do
-      if ProconBypassMan.config.bypass_mode.mode == ProconBypassMan::BypassMode::TYPE_AGGRESSIVE
-        ProconBypassMan.logger.info "TYPE_AGGRESSIVEなのでThread1を終了します"
-        monitor1.shutdown
-        next
-      end
-
+      bypass = ProconBypassMan::Bypass::SwitchToProcon.new(gadget: @gadget, procon: @procon)
       loop do
         break if $will_terminate_token
 
         cycle_sleep.sleep_or_execute do
-          bypass = ProconBypassMan::Bypass.new(gadget: @gadget, procon: @procon, monitor: monitor1)
-          bypass.send_gadget_to_procon!
+          bypass.run
         end
       rescue Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN => e
         ProconBypassMan::SendErrorCommand.execute(error: "Switchとの切断されました.終了処理を開始します. #{e.full_message}")
@@ -63,28 +51,36 @@ class ProconBypassMan::BypassCommand
 
     # procon => gadget
     # シビア
-    ProconBypassMan.logger.info "Thread2を起動します"
     t2 = Thread.new do
-      bypass = ProconBypassMan::Bypass.new(gadget: @gadget, procon: @procon, monitor: monitor2)
+      bypass = ProconBypassMan::Bypass::ProconToSwitch.new(gadget: @gadget, procon: @procon)
+      process = BlueGreenProcess.new(worker_instance: bypass, max_work: 200)
       loop do
         if $will_terminate_token
           if $will_terminate_token == WILL_TERMINATE_TOKEN::TERMINATE
             bypass.direct_connect_switch_via_bluetooth
+            process.shutdown
           end
           break
         end
 
-        bypass.send_procon_to_gadget!
+        process.work
+
+        process_switching_time_before_work = BlueGreenProcess.performance.process_switching_time_before_work
+        if process_switching_time_before_work > 0.1
+          ProconBypassMan.logger.info("slow process_switching_time_before_work: #{process_switching_time_before_work}")
+        end
+
       rescue EOFError => e
         ProconBypassMan::SendErrorCommand.execute(error: "Proconが切断されました。終了処理を開始します. #{e.full_message}")
         Process.kill "TERM", Process.ppid
+        process.shutdown
         break
       rescue Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN => e
         ProconBypassMan::SendErrorCommand.execute(error: "Proconが切断されました。終了処理を開始します2. #{e.full_message}")
         Process.kill "TERM", Process.ppid
+        process.shutdown
         break
       end
-      ProconBypassMan.logger.info "Thread2を終了します"
     end
 
     ProconBypassMan.logger.info "子プロセスでgraceful shutdownの準備ができました"
@@ -93,7 +89,7 @@ class ProconBypassMan::BypassCommand
         signal = readable_io.first[0].gets.strip
         handle_signal(signal)
       end
-    rescue ProconBypassMan::Runner::InterruptForRestart
+    rescue ProconBypassMan::InterruptForRestart
       $will_terminate_token = WILL_TERMINATE_TOKEN::RESTART
       [t1, t2].each(&:join)
       @gadget&.close

data/lib/procon_bypass_man/bypass/bypass_value.rb

@@ -0,0 +1,6 @@
+class ProconBypassMan::Bypass::BypassValue < Struct.new(:binary)
+  def to_text
+    return unless binary
+    binary.unpack.first
+  end
+end

data/lib/procon_bypass_man/bypass/procon_to_switch.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "procon_bypass_man/bypass/bypass_command"
+
+class ProconBypassMan::Bypass::ProconToSwitch
+  extend ProconBypassMan::CallbacksRegisterable
+  include ProconBypassMan::Callbacks
+
+  class CouldNotReadFromProconError < StandardError; end
+  class CouldNotWriteToSwitchError < StandardError; end
+
+  define_callbacks :work
+  set_callback :work, :after, :log_after_run
+
+  # マルチプロセス化したので一旦無効にする
+  # register_callback_module(ProconBypassMan::ProconDisplay::BypassHook)
+
+  attr_accessor :gadget, :procon, :bypass_value
+
+  def initialize(gadget: , procon: )
+    self.gadget = gadget
+    self.procon = procon
+  end
+
+  # @raise [Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN, Errno::ETIMEDOUT]
+  # @return [void]
+  def work(*)
+    ProconBypassMan::Procon::PerformanceMeasurement.measure do |measurement|
+      self.bypass_value = ProconBypassMan::Bypass::BypassValue.new(nil)
+
+      next(run_callbacks(:work) {
+        next(false) if $will_terminate_token
+
+        raw_output = nil
+        measurement.record_read_time do
+          begin
+            return(false) if $will_terminate_token
+            raw_output = self.procon.read_nonblock(64)
+          rescue IO::EAGAINWaitReadable
+            sleep(0.002)
+            retry
+          rescue Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN, Errno::ETIMEDOUT => e
+            return(false) if $will_terminate_token
+            raise
+          end
+
+          self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: raw_output)
+        end
+
+        result = measurement.record_write_time do
+          begin
+            ProconBypassMan::Retryable.retryable(tries: 5, on_no_retry: [Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN, Errno::ETIMEDOUT]) do
+              begin
+                # 終了処理を希望されているのでブロックを無視してメソッドを抜けてOK
+                return(false) if $will_terminate_token # rubocop:disable Lint/NoReturnInBeginEndBlocks
+                self.gadget.write_nonblock(
+                  ProconBypassMan::Processor.new(bypass_value.binary).process
+                )
+                next(true)
+              rescue IO::EAGAINWaitReadable
+                return(false) if $will_terminate_token # rubocop:disable Lint/NoReturnInBeginEndBlocks
+                measurement.record_write_error
+                raise CouldNotWriteToSwitchError
+              rescue Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError, Errno::ESHUTDOWN, Errno::ETIMEDOUT => e
+                return(false) if $will_terminate_token # rubocop:disable Lint/NoReturnInBeginEndBlocks
+                raise
+              end
+            end
+          rescue CouldNotWriteToSwitchError
+            next(false)
+          end
+        end
+
+        next(result)
+      })
+    end
+  end
+
+  # @return [void]
+  def direct_connect_switch_via_bluetooth
+    ProconBypassMan.logger.debug { "direct_connect_switch_via_bluetooth!" }
+    self.procon.write_nonblock(["010500000000000000003800"].pack("H*")) # home led off
+    self.procon.write_nonblock(["010600000000000000003800"].pack("H*")) # home led off
+    self.procon.write_nonblock(["010700000000000000003800"].pack("H*")) # home led off
+    self.procon.write_nonblock(["010800000000000000003800"].pack("H*")) # home led off
+    self.procon.write_nonblock(["8005"].pack("H*"))
+    self.procon.write_nonblock(["8005"].pack("H*"))
+    self.procon.write_nonblock(["8005"].pack("H*"))
+  end
+
+  private
+
+  def log_after_run
+    return unless ProconBypassMan.config.verbose_bypass_log
+    return unless bypass_value.to_text
+
+    ProconBypassMan.logger.debug { "<<< #{bypass_value.to_text}" }
+  end
+end

data/lib/procon_bypass_man/bypass/switch_to_procon.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "procon_bypass_man/bypass/bypass_command"
+
+class ProconBypassMan::Bypass::SwitchToProcon
+  include ProconBypassMan::Callbacks
+
+  define_callbacks :run
+  set_callback :run, :after, :log_after_run
+
+  attr_accessor :gadget, :procon, :bypass_value
+
+  def initialize(gadget: , procon: )
+    self.gadget = gadget
+    self.procon = procon
+  end
+
+  # ゆっくりでいい
+  def run
+    self.bypass_value = ProconBypassMan::Bypass::BypassValue.new(nil)
+
+    run_callbacks(:run) do
+      next if $will_terminate_token
+
+      raw_input = nil
+      begin
+        raw_input = self.gadget.read_nonblock(64)
+        self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: raw_input)
+      rescue IO::EAGAINWaitReadable
+        next
+      end
+
+      if self.bypass_value.binary
+        begin
+          raw_data =
+            case
+            when self.bypass_value.binary.rumble_data? # TODO そもそも無効になっているので消していい
+              binary = ProconBypassMan::RumbleBinary.new(binary: self.bypass_value.binary.raw)
+              binary.noop!
+              binary.raw
+            else
+              self.bypass_value.binary.raw
+            end
+          # バイブレーションを無効にしているのでおそらく書き込む必要はない
+          # self.procon.write_nonblock(raw_data)
+        rescue IO::EAGAINWaitReadable
+          next
+        end
+      end
+    end
+  end
+
+  private
+
+  def log_after_run
+    return unless bypass_value.to_text
+
+    if ProconBypassMan.config.verbose_bypass_log
+      ProconBypassMan.logger.debug { ">>> #{bypass_value.to_text}" }
+    else
+      ProconBypassMan.cache.fetch key: 'bypass_log', expires_in: 1 do
+        ProconBypassMan.logger.debug { ">>> #{bypass_value.to_text}" }
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/bypass.rb

@@ -1,110 +1,6 @@
-require "procon_bypass_man/bypass/usb_hid_logger"
-require "procon_bypass_man/bypass/bypass_command"
-
-class ProconBypassMan::Bypass
-  include ProconBypassMan::Bypass::UsbHidLogger
-  # TODO callbackモジュールを修正して複数のメソッドをチェインできるようにする
-  # include ProconBypassMan::ProconDisplay::BypassCallback
-
-  class BypassValue < Struct.new(:binary)
-    def to_text
-      return unless binary
-      binary.unpack.first
-    end
-  end
-
-  attr_accessor :gadget, :procon, :monitor, :bypass_value
-
-  def initialize(gadget: , procon: , monitor: )
-    self.gadget = gadget
-    self.procon = procon
-    self.monitor = monitor
-  end
-
-  # ゆっくりでいい
-  def send_gadget_to_procon!
-    monitor.record(:start_function)
-    self.bypass_value = BypassValue.new(nil)
-
-    run_callbacks(:send_gadget_to_procon) do
-      break if $will_terminate_token
-
-      raw_input = nil
-      begin
-        raw_input = self.gadget.read_nonblock(64)
-        self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: raw_input)
-      rescue IO::EAGAINWaitReadable
-        monitor.record(:eagain_wait_readable_on_read)
-      end
+module ProconBypassMan::Bypass; end
 
-      if self.bypass_value.binary
-        begin
-          raw_data =
-            case
-            when self.bypass_value.binary.rumble_data?
-              binary = ProconBypassMan::RumbleBinary.new(binary: self.bypass_value.binary.raw)
-              binary.noop!
-              binary.raw
-            else
-              self.bypass_value.binary.raw
-            end
-          self.procon.write_nonblock(raw_data)
-        rescue IO::EAGAINWaitReadable
-          monitor.record(:eagain_wait_readable_on_write)
-          break
-        end
-      end
-    end
-
-    monitor.record(:end_function)
-  end
-
-  def send_procon_to_gadget!
-    monitor.record(:start_function)
-    self.bypass_value = BypassValue.new(nil)
-
-    run_callbacks(:send_procon_to_gadget) do
-      break if $will_terminate_token
-
-      begin
-        Timeout.timeout(1) do
-          raw_output = self.procon.read(64)
-          self.bypass_value.binary = ProconBypassMan::Domains::InboundProconBinary.new(binary: raw_output)
-        end
-      rescue Timeout::Error
-        ProconBypassMan.logger.debug { "read timeout! do sleep. by send_procon_to_gadget!" }
-        ProconBypassMan.error_logger.error { "read timeout! do sleep. by send_procon_to_gadget!" }
-        ProconBypassMan::SendErrorCommand.execute(error: "read timeout! do sleep. by send_procon_to_gadget!")
-        monitor.record(:eagain_wait_readable_on_read)
-        retry
-      rescue IO::EAGAINWaitReadable
-        ProconBypassMan.logger.debug { "EAGAINWaitReadable" }
-        monitor.record(:eagain_wait_readable_on_read)
-        sleep(0.005)
-        retry
-      end
-
-      begin
-        self.gadget.write_nonblock(
-          ProconBypassMan::Processor.new(bypass_value.binary).process
-        )
-      rescue IO::EAGAINWaitReadable
-        monitor.record(:eagain_wait_readable_on_write)
-        break
-      end
-    end
-    monitor.record(:end_function)
-  end
-
-  # @return [void]
-  def direct_connect_switch_via_bluetooth
-    ProconBypassMan.logger.debug { "direct_connect_switch_via_bluetooth!" }
-    self.procon.write_nonblock(["010500000000000000003800"].pack("H*")) # home led off
-    self.procon.write_nonblock(["010600000000000000003800"].pack("H*")) # home led off
-    self.procon.write_nonblock(["010700000000000000003800"].pack("H*")) # home led off
-    self.procon.write_nonblock(["010800000000000000003800"].pack("H*")) # home led off
-    self.procon.write_nonblock(["8005"].pack("H*"))
-    self.procon.write_nonblock(["8005"].pack("H*"))
-    self.procon.write_nonblock(["8005"].pack("H*"))
-  end
-end
+require "procon_bypass_man/bypass/bypass_command"
+require "procon_bypass_man/bypass/bypass_value"
+require "procon_bypass_man/bypass/procon_to_switch"
+require "procon_bypass_man/bypass/switch_to_procon"

data/lib/procon_bypass_man/commands/print_boot_message_command.rb

@@ -13,7 +13,6 @@ class ProconBypassMan::PrintBootMessageCommand
       @table[:use_pbmenv] = !(!!`which pbmenv`.empty?)
       @table[:session_id] = ProconBypassMan.session_id
       @table[:device_id] = ProconBypassMan.device_id
-      @table[:bypass_mode] = ProconBypassMan.config.bypass_mode.to_s
       @table[:never_exit_accidentally] = ProconBypassMan.config.never_exit_accidentally
       @table[:uname] = `uname -a`.chomp
 
@@ -43,7 +42,6 @@ class ProconBypassMan::PrintBootMessageCommand
       use_pbmenv: #{@table[:use_pbmenv]}
       session_id: #{ProconBypassMan.session_id}
       device_id: #{ProconBypassMan.device_id.gsub(/.{25}$/, "*"*25)}
-      bypass_mode: #{ProconBypassMan.config.bypass_mode}
       ----
       EOF
     end