procon_bypass_man 0.1.9 → 0.1.13

data/lib/procon_bypass_man/{configuration → buttons_setting_configuration}/layer.rb

@@ -1,7 +1,7 @@
 module ProconBypassMan
-  class Configuration
+  class ButtonsSettingConfiguration
     class Layer
-      attr_accessor :mode, :flips, :macros, :remaps, :left_analog_stick_caps
+      attr_accessor :mode, :flips, :macros, :remaps, :left_analog_stick_caps, :disables
 
       def initialize(mode: :manual)
         self.mode = mode
@@ -9,6 +9,7 @@ module ProconBypassMan
         self.macros = {}
         self.remaps = {}
         self.left_analog_stick_caps = {}
+        self.disables = []
         instance_eval(&block) if block_given?
       end
 
@@ -19,21 +20,26 @@ module ProconBypassMan
           if_pressed = [button]
         when Symbol, String
           if_pressed = [if_pressed]
-        when Array, FalseClass
-          # sono mama
+        when Array
+          # if_pressed = if_pressed
+        when FalseClass, NilClass
+          # no-op
         else
           raise "not support class"
         end
+
         hash = { if_pressed: if_pressed }
-        if force_neutral
-          case force_neutral
-          when TrueClass, FalseClass
-            raise "ボタンを渡してください"
-          when Symbol, String
-            hash[:force_neutral] = [force_neutral]
-          when Array
-            hash[:force_neutral] = force_neutral
-          end
+        case force_neutral
+        when TrueClass
+          raise "ボタンを渡してください"
+        when Symbol, String
+          hash[:force_neutral] = [force_neutral]
+        when Array
+          hash[:force_neutral] = force_neutral
+        when FalseClass, NilClass
+          # no-op
+        else
+          raise "not support value"
         end
 
         if flip_interval
@@ -62,7 +68,7 @@ module ProconBypassMan
 
       def remap(button, to: )
         case to
-        when TrueClass, FalseClass
+        when TrueClass, FalseClass, NilClass
           raise "ボタンを渡してください"
         when Symbol, String
           self.remaps[button] = { to: [to] }
@@ -76,32 +82,47 @@ module ProconBypassMan
         hash = { cap: cap }
 
         case if_pressed
-        when TrueClass
-          raise "not support class"
+        when TrueClass, FalseClass
+          raise "ボタンを渡してください"
         when Symbol, String
           if_pressed = [if_pressed]
-        when Array, FalseClass
-          # sono mama
-        when NilClass
-          if_pressed = nil
+        when Array, NilClass
+          # no-op
         else
-          raise "not support if_pressed"
+          raise "not support value"
         end
 
-        if force_neutral
-          case force_neutral
-          when TrueClass, FalseClass
-            raise "ボタンを渡してください"
-          when Symbol, String
-            hash[:force_neutral] = [force_neutral]
-          when Array
-            hash[:force_neutral] = force_neutral
-          end
+        case force_neutral
+        when TrueClass
+          raise "ボタンを渡してください"
+        when Symbol, String
+          hash[:force_neutral] = [force_neutral]
+        when Array
+          hash[:force_neutral] = force_neutral
+        when FalseClass, NilClass
+          # no-op
+        else
+          raise "not support value"
         end
 
         left_analog_stick_caps[if_pressed] = hash
       end
 
+      def disable(button)
+        case button
+        when TrueClass, FalseClass, NilClass
+          raise "not support class"
+        when Symbol
+          disables << button
+        when String
+          disables << button.to_sym
+        when Array
+          button.each { |b| disables << b }
+        else
+          raise "not support value"
+        end
+      end
+
       # @return [Array]
       def flip_buttons
         flips

data/lib/procon_bypass_man/{configuration → buttons_setting_configuration}/loader.rb

@@ -1,13 +1,13 @@
 module ProconBypassMan
-  class Configuration
+  class ButtonsSettingConfiguration
     module Loader
       require 'digest/md5'
 
       def self.load(setting_path: )
-        ProconBypassMan::Configuration.switch_new_context(:validation) do |validation_instance|
+        ProconBypassMan::ButtonsSettingConfiguration.switch_new_context(:validation) do |new_instance|
           yaml = YAML.load_file(setting_path) or raise "読み込みに失敗しました"
-          validation_instance.instance_eval(yaml["setting"])
-          validator = Validator.new(validation_instance)
+          new_instance.instance_eval(yaml["setting"])
+          validator = Validator.new(new_instance)
           if validator.valid?
             next
           else
@@ -19,26 +19,27 @@ module ProconBypassMan
           raise ProconBypassMan::CouldNotLoadConfigError, "yamlのシンタックスエラーです"
         end
 
-        yaml = YAML.load_file(setting_path)
-        ProconBypassMan::Configuration.instance.setting_path = setting_path
-        ProconBypassMan::Configuration.instance.reset!
+        ProconBypassMan::ButtonsSettingConfiguration.instance.setting_path = setting_path
+        ProconBypassMan::ButtonsSettingConfiguration.instance.reset!
         ProconBypassMan.reset!
 
+        yaml = YAML.load_file(setting_path)
+        ProconBypassMan.config.raw_setting = yaml.dup
         case yaml["version"]
         when 1.0, nil
-          ProconBypassMan::Configuration.instance.instance_eval(yaml["setting"])
+          ProconBypassMan::ButtonsSettingConfiguration.instance.instance_eval(yaml["setting"])
         else
           ProconBypassMan.logger.warn "不明なバージョンです。failoverします"
-          ProconBypassMan::Configuration.instance.instance_eval(yaml["setting"])
+          ProconBypassMan::ButtonsSettingConfiguration.instance.instance_eval(yaml["setting"])
         end
 
         File.write(ProconBypassMan.digest_path, Digest::MD5.hexdigest(yaml["setting"]))
 
-        ProconBypassMan::Configuration.instance
+        ProconBypassMan::ButtonsSettingConfiguration.instance
       end
 
       def self.reload_setting
-        self.load(setting_path: ProconBypassMan::Configuration.instance.setting_path)
+        self.load(setting_path: ProconBypassMan::ButtonsSettingConfiguration.instance.setting_path)
       end
     end
   end

data/lib/procon_bypass_man/{configuration → buttons_setting_configuration}/validator.rb

@@ -1,5 +1,5 @@
 module ProconBypassMan
-  class Configuration
+  class ButtonsSettingConfiguration
     class Validator
       def initialize(config)
         @layers = config.layers

data/lib/procon_bypass_man/buttons_setting_configuration.rb

@@ -0,0 +1,101 @@
+require "procon_bypass_man/buttons_setting_configuration/validator"
+require "procon_bypass_man/buttons_setting_configuration/loader"
+require "procon_bypass_man/buttons_setting_configuration/layer"
+
+module ProconBypassMan
+  class AnalogStickPosition < Struct.new(:x, :y); end
+
+  class ButtonsSettingConfiguration
+    attr_accessor :layers,
+      :setting_path,
+      :mode_plugins,
+      :macro_plugins,
+      :context,
+      :current_context_key,
+      :neutral_position
+
+    def self.instance
+      @@current_context_key ||= :main
+      @@context ||= {}
+      @@context[@@current_context_key] ||= new
+    end
+
+    def self.switch_new_context(key)
+      @@context[key] = new
+      previous_key = @@current_context_key
+      if block_given?
+        @@current_context_key = key
+        value = yield(@@context[key])
+        @@current_context_key = previous_key
+        return value
+      else
+        @@current_context_key = key
+      end
+    end
+
+    def initialize
+      reset!
+    end
+
+    module ManualMode
+      def self.name
+        'manual'
+      end
+    end
+    def layer(direction, mode: ManualMode, &block)
+      mode_name = case mode
+                  when String
+                    mode.to_sym
+                  when Symbol
+                    mode
+                  else
+                    mode.name.to_sym
+                  end
+      unless ([ManualMode.name.to_sym] + ProconBypassMan::Procon::ModeRegistry.plugins.keys).include?(mode_name)
+        raise("#{mode_name} mode is unknown")
+      end
+
+      layer = Layer.new(mode: mode_name)
+      layer.instance_eval(&block) if block_given?
+      self.layers[direction] = layer
+      self
+    end
+
+    def install_mode_plugin(klass)
+      ProconBypassMan::Procon::ModeRegistry.install_plugin(klass)
+      self
+    end
+
+    def install_macro_plugin(klass)
+      ProconBypassMan::Procon::MacroRegistry.install_plugin(klass)
+      self
+    end
+
+    def prefix_keys_for_changing_layer(buttons)
+      @prefix_keys_for_changing_layer = buttons
+      self
+    end
+
+    def set_neutral_position(x, y)
+      self.neutral_position = AnalogStickPosition.new(x, y).freeze
+      self
+    end
+
+    def prefix_keys
+      @prefix_keys_for_changing_layer
+    end
+
+    def reset!
+      @prefix_keys_for_changing_layer = []
+      self.mode_plugins = {}
+      self.macro_plugins = {}
+      self.layers = {
+        up: Layer.new,
+        down: Layer.new,
+        left: Layer.new,
+        right: Layer.new,
+      }
+      @neutral_position = AnalogStickPosition.new(2124, 1808).freeze
+    end
+  end
+end

data/lib/procon_bypass_man/bypass/usb_hid_logger.rb

@@ -0,0 +1,42 @@
+class ProconBypassMan::Bypass
+  module UsbHidLogger
+    extend ProconBypassMan::Callbacks::ClassMethods
+    include ProconBypassMan::Callbacks
+
+    define_callbacks :send_gadget_to_procon
+    define_callbacks :send_procon_to_gadget
+
+    set_callback :send_gadget_to_procon, :after, :log_send_gadget_to_procon
+    set_callback :send_procon_to_gadget, :after, :log_procon_to_gadget
+
+    def log_send_gadget_to_procon
+      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
+
+    def log_procon_to_gadget
+      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
+
+      ProconBypassMan.cache.fetch key: 'pressed_buttons_reporter', expires_in: 5 do
+        ProconBypassMan::ReportPressedButtonsJob.perform_async(
+          ProconBypassMan::ProconReader.new(binary: bypass_value.binary).to_hash
+        )
+      end
+
+      ProconBypassMan.cache.fetch key: 'heartbeat_reporter', expires_in: 60 do
+        ProconBypassMan::ReportHeartbeatJob.perform_async(ProconBypassMan::BootMessage.new.to_hash)
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/bypass.rb

@@ -1,5 +1,15 @@
+require "procon_bypass_man/bypass/usb_hid_logger"
+
 class ProconBypassMan::Bypass
-  attr_accessor :gadget, :procon, :monitor
+  include ProconBypassMan::Bypass::UsbHidLogger
+
+  class BypassValue < Struct.new(:binary, :sent)
+    def to_text
+      "#{binary.unpack("H*").first} #{'x' unless sent}"
+    end
+  end
+
+  attr_accessor :gadget, :procon, :monitor, :bypass_value
 
   def initialize(gadget: , procon: , monitor: )
     self.gadget = gadget
@@ -11,22 +21,27 @@ class ProconBypassMan::Bypass
   def send_gadget_to_procon!
     monitor.record(:start_function)
     input = nil
-    begin
-      return if $will_terminate_token
-      # TODO blocking readにしたい
-      input = self.gadget.read_nonblock(64)
-      ProconBypassMan.logger.debug { ">>> #{input.unpack("H*")}" }
-    rescue IO::EAGAINWaitReadable
-      monitor.record(:eagain_wait_readable_on_read)
-      sleep(0.001)
-      retry
-    end
+    self.bypass_value = BypassValue.new(input, sent = false)
 
-    begin
-      self.procon.write_nonblock(input)
-    rescue IO::EAGAINWaitReadable
-      monitor.record(:eagain_wait_readable_on_write)
-      return
+    run_callbacks(:send_gadget_to_procon) do
+      begin
+        break if $will_terminate_token
+        # TODO blocking readにしたいが、接続時のフェーズによって長さが違うので厳しい
+        input = self.gadget.read_nonblock(64)
+        self.bypass_value.binary = input
+      rescue IO::EAGAINWaitReadable
+        monitor.record(:eagain_wait_readable_on_read)
+        sleep(0.001)
+        retry
+      end
+
+      begin
+        self.procon.write_nonblock(input)
+        self.bypass_value.sent = true
+      rescue IO::EAGAINWaitReadable
+        monitor.record(:eagain_wait_readable_on_write)
+        break
+      end
     end
 
     monitor.record(:end_function)
@@ -35,31 +50,35 @@ class ProconBypassMan::Bypass
   def send_procon_to_gadget!
     monitor.record(:start_function)
     output = nil
+    self.bypass_value = BypassValue.new(output, sent = false)
 
-    begin
-      return if $will_terminate_token
-      Timeout.timeout(1) do
-        output = self.procon.read(64)
-        ProconBypassMan.logger.debug { "<<< #{output.unpack("H*")}" }
+    run_callbacks(:send_procon_to_gadget) do
+      begin
+        break if $will_terminate_token
+        Timeout.timeout(1) do
+          output = self.procon.read(64)
+          self.bypass_value.binary = 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
-    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!" }
-      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
-      # ProconBypassMan::Procon::DebugDumper.new(binary: output).dump_analog_sticks
-      self.gadget.write_nonblock(ProconBypassMan::Processor.new(output).process)
-    rescue IO::EAGAINWaitReadable
-      monitor.record(:eagain_wait_readable_on_write)
-      return
+      begin
+        self.gadget.write_nonblock(ProconBypassMan::Processor.new(output).process)
+        self.bypass_value.sent = true
+      rescue IO::EAGAINWaitReadable
+        monitor.record(:eagain_wait_readable_on_write)
+        break
+      end
     end
     monitor.record(:end_function)
   end

data/lib/procon_bypass_man/commands/bypass_command.rb

@@ -0,0 +1,86 @@
+class ProconBypassMan::BypassCommand
+  include ProconBypassMan::SignalHandler
+
+  def initialize(gadget:, procon:)
+    @gadget = gadget
+    @procon = procon
+
+    ProconBypassMan::IOMonitor.start!
+    ProconBypassMan::Background::JobRunner.queue.clear # forkしたときに残留物も移ってしまうため
+    ProconBypassMan::Background::JobRunner.start!
+  end
+
+  def execute
+    self_read, self_write = IO.pipe
+    %w(TERM INT).each do |sig|
+      begin
+        trap sig do
+          self_write.puts(sig)
+        end
+      rescue ArgumentError
+        puts "プロセスでSignal #{sig} not supported"
+      end
+    end
+
+    # gadget => procon
+    # 遅くていい
+    monitor1 = ProconBypassMan::IOMonitor.new(label: "switch -> procon")
+    monitor2 = ProconBypassMan::IOMonitor.new(label: "procon -> switch")
+    ProconBypassMan.logger.info "Thread1を起動します"
+    t1 = Thread.new do
+      timer = ProconBypassMan::SafeTimeout.new(timeout: Time.now + 10)
+      bypass = ProconBypassMan::Bypass.new(gadget: @gadget, procon: @procon, monitor: monitor1)
+      loop do
+        break if $will_terminate_token
+        timer.throw_if_timeout!
+        bypass.send_gadget_to_procon!
+        sleep(0.005)
+      rescue ProconBypassMan::SafeTimeout::Timeout
+        ProconBypassMan.logger.info "10秒経過したのでThread1を終了します"
+        monitor1.shutdown
+        puts "10秒経過したのでThread1を終了します"
+        break
+      rescue Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError => e
+        ProconBypassMan::SendErrorCommand.execute(error: "Switchとの切断されました.終了処理を開始します. #{e.full_message}")
+        Process.kill "TERM", Process.ppid
+      rescue Errno::ETIMEDOUT => e
+        # TODO まれにこれが発生する. 再接続したい
+        ProconBypassMan::SendErrorCommand.execute(error: "Switchと意図せず切断されました.終了処理を開始します. #{e.full_message}")
+        Process.kill "TERM", Process.ppid
+      end
+      ProconBypassMan.logger.info "Thread1を終了します"
+    end
+
+    # procon => gadget
+    # シビア
+    ProconBypassMan.logger.info "Thread2を起動します"
+    t2 = Thread.new do
+      bypass = ProconBypassMan::Bypass.new(gadget: @gadget, procon: @procon, monitor: monitor2)
+      loop do
+        break if $will_terminate_token
+        bypass.send_procon_to_gadget!
+      rescue EOFError => e
+        ProconBypassMan::SendErrorCommand.execute(error: "Proconが切断されました。終了処理を開始します. #{e.full_message}")
+        Process.kill "TERM", Process.ppid
+      rescue Errno::EIO, Errno::ENODEV, Errno::EPROTO, IOError => e
+        ProconBypassMan::SendErrorCommand.execute(error: "Proconが切断されました。終了処理を開始します2. #{e.full_message}")
+        Process.kill "TERM", Process.ppid
+      end
+      ProconBypassMan.logger.info "Thread2を終了します"
+    end
+
+    ProconBypassMan.logger.info "子プロセスでgraceful shutdownの準備ができました"
+    begin
+      while(readable_io = IO.select([self_read]))
+        signal = readable_io.first[0].gets.strip
+        handle_signal(signal)
+      end
+    rescue Interrupt
+      $will_terminate_token = true
+      [t1, t2].each(&:join)
+      @gadget&.close
+      @procon&.close
+      exit 1
+    end
+  end
+end

data/lib/procon_bypass_man/commands/connect_device_command.rb

@@ -0,0 +1,11 @@
+class ProconBypassMan::ConnectDeviceCommand
+  # @return [void]
+  def self.execute!
+    gadget, procon = ProconBypassMan::DeviceConnector.connect
+  rescue ProconBypassMan::SafeTimeout::Timeout
+    ::ProconBypassMan.logger.error "デバイスとの通信でタイムアウトが起きて接続ができませんでした。"
+    gadget&.close
+    procon&.close
+    raise ::ProconBypassMan::EternalConnectionError
+  end
+end

data/lib/procon_bypass_man/commands/print_boot_message_command.rb

@@ -0,0 +1,9 @@
+class ProconBypassMan::PrintBootMessageCommand
+  # @return [void]
+  def self.execute
+    message = ProconBypassMan::BootMessage.new
+    ProconBypassMan::ReportBootJob.perform_async(message.to_hash)
+    ProconBypassMan::ReportLoadConfigJob.perform_async(ProconBypassMan.config.raw_setting)
+    puts message.to_s
+  end
+end

data/lib/procon_bypass_man/commands/send_error_command.rb

@@ -0,0 +1,19 @@
+class ProconBypassMan::SendErrorCommand
+  # @param [String, Hash, Exception] error
+  # @return [void]
+  def self.execute(error: )
+    body =
+      case error
+      when String, Hash
+        error
+      else
+        error.full_message
+      end
+
+    ProconBypassMan.logger.error body
+    ProconBypassMan.error_logger.error body
+    puts body
+
+    ProconBypassMan::ReportErrorJob.perform_async(error)
+  end
+end

data/lib/procon_bypass_man/commands/send_reload_config_event_command.rb

@@ -0,0 +1,11 @@
+class ProconBypassMan::SendReloadConfigEventCommand
+  # @return [void]
+  def self.execute
+    puts "設定ファイルの再読み込みができました"
+    ProconBypassMan.logger.info "設定ファイルの再読み込みができました"
+    ProconBypassMan::ReportReloadConfigJob.perform_async(
+      ProconBypassMan.config.raw_setting
+    )
+  end
+end
+

data/lib/procon_bypass_man/commands/write_device_id_command.rb

@@ -0,0 +1,12 @@
+class ProconBypassMan::WriteDeviceIdCommand
+  # @return [String]
+  def self.execute
+    path = "#{ProconBypassMan.root}/device_id"
+    if(sid = File.read(path))
+      return sid
+    end
+  rescue Errno::ENOENT
+    File.write(path, "m_#{SecureRandom.uuid}")
+    return SecureRandom.uuid
+  end
+end

data/lib/procon_bypass_man/commands/write_session_id_command.rb

@@ -0,0 +1,13 @@
+class ProconBypassMan::WriteSessionIdCommand
+  # @return [String] session_id ラズパイが起動してからshutdownするまで同じ文字列を返す
+  # 起動すると/tmp がなくなる前提の実装
+  def self.execute
+    path = "/tmp/pbm_session_id"
+    if(sid = File.read(path))
+      return sid
+    end
+  rescue Errno::ENOENT
+    File.write(path, "s_#{SecureRandom.uuid}")
+    return SecureRandom.uuid
+  end
+end

data/lib/procon_bypass_man/commands.rb

@@ -0,0 +1,7 @@
+require "procon_bypass_man/commands/print_boot_message_command"
+require "procon_bypass_man/commands/write_session_id_command"
+require "procon_bypass_man/commands/write_device_id_command"
+require "procon_bypass_man/commands/send_reload_config_event_command"
+require "procon_bypass_man/commands/send_error_command"
+require "procon_bypass_man/commands/connect_device_command"
+require "procon_bypass_man/commands/bypass_command"