procon_bypass_man 0.3.6 → 0.3.8

data/lib/procon_bypass_man/external_input/channels/tcpip_channel.rb

@@ -0,0 +1,131 @@
+module ProconBypassMan
+  module ExternalInput
+    module Channels
+      class TCPIPChannel < Base
+        class ShutdownSignal < StandardError; end
+
+        class AppServer < SimpleTCPServer
+          @command_queue = Queue.new
+
+          class << self
+            attr_accessor :command_queue
+          end
+
+          def post_init
+            ProconBypassMan.logger.info { "[ExternalInput][TCPIPChannel] A client has connected" }
+          end
+
+          def unbind
+            ProconBypassMan.logger.info { "[ExternalInput][TCPIPChannel] A client has disconnected" }
+          end
+
+          # @return [String]
+          def receive_data(client, data)
+            case data
+            when /^{/
+              self.class.command_queue.push(data)
+              client.write("OK\n")
+              return
+            when /^\n/
+              if self.class.command_queue.empty?
+                client.write("EMPTY\n")
+                return
+              end
+
+              data = self.class.command_queue.pop
+              client.write("#{data}\n")
+              return
+            else
+              client.write("Unknown command\n")
+              return
+            end
+          end
+        end
+
+        def initialize(port: )
+          @port = port
+          super()
+
+          begin
+            @server = AppServer.new('0.0.0.0', @port)
+          rescue Errno::EADDRINUSE # NOTE: Address already in use - bind(2) for "0.0.0.0" port XXXX
+            ProconBypassMan::SendErrorCommand.execute(error: "[ExternalInput][TCPIPChannel] 起動に失敗しました。#{e.message}")
+            @server_thread = Thread.start {}
+            return
+          end
+
+          # NOTE: masterプロセスで起動する
+          @server_thread = Thread.start do
+            begin
+              loop do
+                @server.start_server
+                @server.run
+              end
+            rescue Errno::EPIPE, EOFError, Errno::ECONNRESET => e
+              ProconBypassMan::SendErrorCommand.execute(error: "[ExternalInput][TCPIPChannel] #{e.message}(#{e})")
+              sleep(5)
+
+              @server.shutdown
+              retry
+            rescue ShutdownSignal => e
+              ProconBypassMan::SendErrorCommand.execute(error: "[ExternalInput][TCPIPChannel] ShutdownSignalを受け取りました。終了します。")
+              @server.shutdown
+            rescue => e
+              ProconBypassMan::SendErrorCommand.execute(error: "[ExternalInput][TCPIPChannel] #{e.message}(#{e})")
+            end
+          end
+        end
+
+        # NOTE: bypassプロセスから呼ばれ、masterプロセスへ繋ぐ
+        # @return [String, NilClass]
+        def read
+          @socket ||= TCPSocket.new('0.0.0.0', @port)
+          read_command = "\n"
+          @socket.write(read_command)
+          response = @socket.gets&.strip
+          # ProconBypassMan.logger.debug { "Received: #{response}" }
+
+          case response
+          when /^{/
+            return response
+          when /^EMPTY/, ''
+            return nil
+          else
+            ProconBypassMan.logger.warn { "[ExternalInput][TCPIPChannel] Unknown response(#{response}, codepoints: #{response.codepoints})" }
+            return nil
+          end
+        rescue Errno::EPIPE, EOFError => e
+          @socket = nil
+          sleep(10)
+          ProconBypassMan.logger.error { "[ExternalInput][TCPIPChannel] #{e.message}!!!!!!!(#{e})" }
+          retry
+        rescue => e
+          @socket = nil
+          ProconBypassMan.logger.error { "[ExternalInput][TCPIPChannel] #{e.message} が起きました(#{e})" }
+          return nil
+        end
+
+        def shutdown
+          ProconBypassMan.logger.info { "[ExternalInput][TCPIPChannel] shutdown" }
+          @server_thread.raise(ShutdownSignal)
+        end
+
+        def alive_server?
+          return false if not @server_thread.alive?
+
+          begin
+            TCPSocket.new('0.0.0.0', @port).close
+          rescue Errno::ECONNREFUSED, Errno::ECONNRESET
+            return false
+          end
+
+          true
+        end
+
+        def display_name_for_boot_message
+          "TCPIP(port: #{@port})"
+        end
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/external_input/channels.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ProconBypassMan
+  module ExternalInput
+    module Channels
+    end
+  end
+end
+
+require "procon_bypass_man/external_input/channels/base"
+require "procon_bypass_man/external_input/channels/serial_port_channel"
+require "procon_bypass_man/external_input/channels/tcpip_channel"

data/lib/procon_bypass_man/external_input/external_data.rb

@@ -0,0 +1,79 @@
+module ProconBypassMan
+  module ExternalInput
+    class ExternalData
+      UNPRESS_BUTTONS = Set.new(ProconBypassMan::Procon::ButtonCollection.available.map { |x| "un#{x}".to_sym })
+
+      # @return [String, NilClass] 16進数表現のデータ
+      attr_reader :hex
+
+      # @return [String, NilClass] ログに表示する用
+      attr_reader :raw_data
+
+      # @raise [ParseError]
+      # @return [ExternalData] JSON か カンマ区切りのbuttons
+      def self.parse!(raw_data)
+        raise ParseError unless raw_data.ascii_only?
+
+        if is_json(raw_data)
+          begin
+            json = JSON.parse(raw_data)
+            return new(hex: json['hex'], buttons: json['buttons'])
+          rescue JSON::ParserError
+            raise ParseError
+          end
+        end
+
+        return new(hex: nil, buttons: raw_data.scan(/:\w+:/).map { |x| x.gsub(':', '') }, raw_data: raw_data)
+      end
+
+      # @param [String] raw_data
+      # @return [Boolean]
+      def self.is_json(raw_data)
+        raw_data.start_with?('{')
+      end
+
+      # @param [String, NilClass] hex
+      # @param [Array<String>, NilClass] buttons
+      # @param [String, NilClass] raw_data
+      def initialize(hex: , buttons: , raw_data: nil)
+        @hex = hex
+        @buttons = buttons || []
+        @raw_data = raw_data
+      end
+
+      # @return [String, NilClass]
+      def to_binary
+        return nil if @hex.nil?
+        [@hex].pack('H*')
+      end
+
+      # @return [Array<Symbol>]
+      def press_buttons
+        buttons.select do |button|
+          ProconBypassMan::Procon::ButtonCollection::BUTTONS_MAP[button]
+        end
+      end
+
+      # @return [Array<Symbol>]
+      def unpress_buttons
+        buttons.select { |button|
+          UNPRESS_BUTTONS.include?(button)
+        }.map { |b| to_button(b.to_s).to_sym }
+      end
+
+      # NOTE: ログに表示する用
+      # @return [Array<Symbol>]
+      def buttons
+        @buttons.map(&:to_sym)
+      end
+
+      private
+
+      # @return [String]
+      # NOTE: un#{button} って名前をbuttonに変換する
+      def to_button(button)
+        button.sub(/^un/, '')
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/external_input.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ProconBypassMan
+  module ExternalInput
+    class ParseError < StandardError; end
+
+    # @return [Array<ProconBypassMan::ExternalInput::Channels::Base>]
+    def self.channels
+      @@channels ||= ProconBypassMan.config.external_input_channels
+    end
+
+    def self.shutdown
+      channels.each(&:shutdown)
+    end
+
+    # @return [NilClass, String]
+    # NOTE: 外部入力からのreadがボトルネックになるなら、Concurrent::Futureを使ってプロコンからの読み出しと並列化することを検討する
+    def self.read
+      value = nil
+      channels.each do |channel|
+        value = channel.read
+        break if value
+      end
+      value
+    end
+  end
+end
+
+require "procon_bypass_man/external_input/external_data"
+require "procon_bypass_man/external_input/channels.rb"
+require "procon_bypass_man/external_input/boot_message"

data/lib/procon_bypass_man/processor.rb

@@ -5,12 +5,13 @@ class ProconBypassMan::Processor
     @binary = binary
   end
 
+  # @param [ProconBypassMan::ExternalInput::ExternalData, NilClass] external_input_data
   # @return [String] 加工後の入力データ
-  def process
+  def process(external_input_data: nil)
     return @binary.raw unless @binary.user_operation_data?
 
     procon = ProconBypassMan::Procon.new(@binary.raw)
     procon.apply!
-    procon.to_binary
+    procon.to_binary(external_input_data: external_input_data)
   end
 end

data/lib/procon_bypass_man/procon/button_collection.rb

@@ -37,4 +37,9 @@ class ProconBypassMan::Procon::ButtonCollection
   BUTTONS = ProconBypassMan::Procon::ButtonCollection::BUTTONS_MAP.keys.freeze
 
   LEFT_ANALOG_STICK = { byte_position: 6..8 }
+
+  # @return [Array<Symbol>]
+  def self.available
+    BUTTONS
+  end
 end

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

@@ -9,6 +9,7 @@ class ProconBypassMan::Procon::PerformanceMeasurement::MeasurementsSummarizer
                                        :time_taken_p95,
                                        :time_taken_p99,
                                        :time_taken_max,
+                                       :external_input_time_max,
                                        :read_error_count,
                                        :write_error_count,
                                        :gc_count,
@@ -26,6 +27,7 @@ class ProconBypassMan::Procon::PerformanceMeasurement::MeasurementsSummarizer
     write_time_max = 0
     read_time_max = 0
     time_taken_max = 0
+    external_input_time_max = 0
     interval_from_previous_succeed_max = 0
     @spans.each do |span|
       # NOTE @spans.map(&:write_time).sort.last と同じことだけど、処理コストを軽くするためにループを共通化する
@@ -33,6 +35,7 @@ class ProconBypassMan::Procon::PerformanceMeasurement::MeasurementsSummarizer
       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
+      external_input_time_max = span.external_input_time if span.succeed && external_input_time_max < span.external_input_time
     end
 
     # NOTE 今はGCを無効にしており、集計するまでもないのでコメントアウトにする. 今後GCを有効にしたバイパスをするかもしれないので残しておく
@@ -79,6 +82,7 @@ class ProconBypassMan::Procon::PerformanceMeasurement::MeasurementsSummarizer
                           time_taken_p95,
                           time_taken_p99,
                           time_taken_max,
+                          external_input_time_max,
                           total_read_error_count,
                           total_write_error_count,
                           gc_count,

data/lib/procon_bypass_man/procon/performance_measurement.rb

@@ -12,7 +12,7 @@ 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
+    attr_reader :write_error_count, :read_error_count, :write_time, :read_time, :external_input_time
 
     def initialize
       @write_error_count = 0
@@ -40,9 +40,15 @@ module ProconBypassMan::Procon::PerformanceMeasurement
       return result
     end
 
+    # @return [void]
     def record_read_time(&block)
       @read_time = Benchmark.realtime { block.call }
     end
+
+    # @return [void]
+    def record_external_input_time(&block)
+      @external_input_time = Benchmark.realtime { block.call }
+    end
   end
 
   # 全部送ると負荷になるので適当にまびく

data/lib/procon_bypass_man/procon.rb

@@ -128,7 +128,7 @@ class ProconBypassMan::Procon
     end
 
     # remote macro or pbm action
-    if task = ProconBypassMan::RemoteAction::TaskQueueInProcess.non_blocking_shift
+    if(task = ProconBypassMan::RemoteAction::TaskQueueInProcess.non_blocking_shift)
       case task.type
       when ProconBypassMan::RemoteAction::Task::TYPE_MACRO
         no_op_step = :wait_for_0_3 # マクロの最後に固まって最後の入力をし続けるので、無の状態を最後に注入する
@@ -187,12 +187,27 @@ class ProconBypassMan::Procon
     status
   end
 
+  # @param [ProconBypassMan::ExternalInput::ExternalData, NilClass] external_input_data
   # @return [String]
-  def to_binary
+  def to_binary(external_input_data: nil)
     if ongoing_mode.name != :manual
       return user_operation.binary.raw
     end
 
+    if external_input_data
+      if(external_input_data_raw_binary = external_input_data.to_binary)
+        self.user_operation.merge(external_input_data_raw_binary)
+      else
+        external_input_data.press_buttons.each do |button|
+          self.user_operation.press_button(button)
+        end
+        external_input_data.unpress_buttons.each do |button|
+          self.user_operation.unpress_button(button)
+        end
+      end
+      return self.user_operation.binary.raw
+    end
+
     if ongoing_macro.ongoing? && (step = ongoing_macro.next_step)
       BlueGreenProcess::SharedVariable.extend_run_on_this_process = true
       ongoing_macro.force_neutral_buttons&.each do |force_neutral_button|

data/lib/procon_bypass_man/procon_display/status.rb

@@ -1,5 +1,3 @@
-require 'singleton'
-
 class ProconBypassMan::ProconDisplay::Status
   include Singleton
 

data/lib/procon_bypass_man/support/forever.rb

@@ -0,0 +1,51 @@
+module ProconBypassMan
+  class Forever
+    # 動作確認方法
+    # - 10秒ごとにrefreshするのでタイムアウトは起きない
+    #   - ProconBypassMan::Forever.run { |watchdog| loop { puts(:hi); sleep(10); watchdog.active! } }
+    # - タイムアウトが起きること
+    #   - ProconBypassMan::Forever.run { |watchdog| loop { puts(:hi); sleep(10); } }
+    def self.run(&block)
+      loop do
+        new.run(&block)
+      end
+    end
+
+    # @return [void]
+    def run(&block)
+      raise(ArgumentError, "need a block") unless block_given?
+
+      thread, watchdog = work_one(callable: block)
+      wait_and_kill_if_outdated(thread, watchdog)
+    end
+
+    # @param [Proc] callable
+    # @return [Array<Thread, ProconBypassMan::Watchdog>]
+    def work_one(callable: )
+      watchdog = ProconBypassMan::Watchdog.new
+      thread = Thread.start do
+        callable.call(watchdog)
+      rescue => e
+        ProconBypassMan.logger.error("[Forever] #{e.full_message}")
+      end
+
+      return [thread, watchdog]
+    end
+
+    # @param [ProconBypassMan::Watchdog] watchdog
+    # @param [Thread] thread
+    # @return [void]
+    def wait_and_kill_if_outdated(thread, watchdog)
+      loop do
+        if watchdog.outdated?
+          watchdog.active!
+          ProconBypassMan.logger.error("watchdog timeout!!")
+          thread.kill
+          return
+        end
+
+        sleep(10)
+      end
+    end
+  end
+end

data/lib/procon_bypass_man/support/proccess_cheacker.rb

@@ -0,0 +1,14 @@
+class ProconBypassMan::ProcessChecker
+  # @param [integer] pid
+  # @return [Boolean]
+  def self.running?(pid)
+    begin
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    rescue Errno::EPERM
+      true
+    end
+  end
+end

data/lib/procon_bypass_man/support/retryable.rb

@@ -1,14 +1,17 @@
 module ProconBypassMan
   class Retryable
-    def self.retryable(tries: , retried: 0, on_no_retry: [])
+    def self.retryable(tries: , retried: 0, on_no_retry: [], log_label: nil, interval_on_retry: 0)
       return yield(retried)
     rescue *on_no_retry
       raise
-    rescue
+    rescue => e
       if tries <= retried
         raise
       else
         retried = retried + 1
+        ProconBypassMan.logger.debug "[Retryable]#{log_label && "[#{log_label}]"} #{e}が起きました。retryします。#{retried} / #{tries}"
+
+        sleep(interval_on_retry)
         retry
       end
     end

data/lib/procon_bypass_man/support/simple_tcp_server.rb

@@ -0,0 +1,63 @@
+require 'socket'
+
+class SimpleTCPServer
+  def initialize(host, port)
+    @host = host
+    @port = port
+  end
+
+  def start_server
+    @connections = []
+    @server = TCPServer.new(@host, @port)
+  end
+
+  def run
+    loop do
+      timeout = 5 # 5秒のタイムアウト
+      readable, _ = IO.select(@connections + [@server], nil, nil, timeout)
+      next if readable.nil? # timeoutを迎えるとnilになる
+
+      readable.each do |socket|
+        if socket == @server
+          client = @server.accept
+          post_init
+          @connections << client
+        else
+          data = socket.gets
+          if data.nil?
+            @connections.delete(socket)
+            unbind
+            socket.close
+          else
+            receive_data(socket, data)
+          end
+        end
+      end
+    rescue Errno::EBADF, IOError => e
+      unbind
+      @connections = []
+      @server.close
+    end
+  end
+
+  def shutdown
+    @server.close
+  end
+
+  # @return [Integer]
+  def connections_size
+    @connections.size
+  end
+
+  def post_init
+    # Override this method
+  end
+
+  def receive_data(socket, data)
+    # Override this method
+  end
+
+  def unbind
+    # Override this method
+  end
+end

data/lib/procon_bypass_man/support/watchdog.rb

@@ -0,0 +1,23 @@
+module ProconBypassMan
+  class Watchdog
+    def initialize(timeout: 100)
+      @timeout = timeout
+      active!
+    end
+
+    # @return [Boolean]
+    def outdated?
+      @time < Time.now
+    end
+
+    # @return [Time]
+    def time
+      @time
+    end
+
+    # @return [void]
+    def active!
+      @time = Time.now + @timeout
+    end
+  end
+end

data/lib/procon_bypass_man/support/web_connectivity_checker.rb

@@ -0,0 +1,41 @@
+class ProconBypassMan::WebConnectivityChecker
+  # @param [String, NilClass] url
+  # @param [String, NilClass] ws_url
+  def initialize(url, ws_url)
+    @url = url
+    @ws_url = ws_url
+  end
+
+  # @return [String]
+  def to_s
+    if @url.nil?
+      return "DISABLE"
+    end
+
+    if alive?
+      return "ENABLE (#{@url}, #{@ws_url})"
+    else
+     return "UNREACHABLE (#{@url})"
+    end
+  end
+
+  private
+
+  # @return [Boolean]
+  def alive?
+    uri = URI.parse(@url)
+    response = nil
+
+    begin
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        request = Net::HTTP::Head.new(uri)
+        response = http.request(request)
+      end
+    rescue StandardError => e
+      ProconBypassMan.logger.error e
+      return false
+    end
+
+    response.is_a?(Net::HTTPSuccess) or response.is_a?(Net::HTTPMovedPermanently)
+  end
+end

data/lib/procon_bypass_man/version.rb

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

data/lib/procon_bypass_man/websocket/client.rb

@@ -7,11 +7,13 @@ module ProconBypassMan
         return unless ProconBypassMan.config.enable_ws?
 
         Thread.start do
-          Forever.run { run }
+          ProconBypassMan::Forever.run do |watchdog|
+            run(watchdog: watchdog)
+          end
         end
       end
 
-      def self.run
+      def self.run(watchdog: )
         EventMachine.run do
           client = ActionCableClient.new(
             ProconBypassMan.config.current_ws_server_url, {
@@ -20,15 +22,15 @@ module ProconBypassMan
           )
 
           client.connected {
-            ProconBypassMan.logger.info('websocket client: successfully connected in ProconBypassMan::Websocket::Client')
+            ProconBypassMan.logger.info('[WebsocketClient] successfully connected in ProconBypassMan::Websocket::Client')
           }
           client.subscribed { |msg|
-            ProconBypassMan.logger.info("websocket client: subscribed(#{msg})")
+            ProconBypassMan.logger.info("[WebsocketClient] subscribed(#{msg})")
             ProconBypassMan::SyncDeviceStatsJob.perform(ProconBypassMan::DeviceStatus.current)
           }
 
           client.received do |data|
-            ProconBypassMan.logger.info('websocket client: received!!')
+            ProconBypassMan.logger.info('[WebsocketClient] received!!')
             ProconBypassMan.logger.info(data)
 
             dispatch(data: data, client: client)
@@ -37,20 +39,20 @@ module ProconBypassMan
           end
 
           client.disconnected {
-            ProconBypassMan.logger.info('websocket client: disconnected!!')
+            ProconBypassMan.logger.info('[WebsocketClient] disconnected!!')
             client.reconnect!
             sleep 2
           }
           client.errored { |msg|
-            ProconBypassMan.logger.error("websocket client: errored!!, #{msg}")
+            ProconBypassMan.logger.error("[WebsocketClient] errored!!, #{msg}")
             client.reconnect!
             sleep 2
           }
           client.pinged { |msg|
-            Watchdog.active!
+            watchdog.active!
 
             ProconBypassMan.cache.fetch key: 'ws_pinged', expires_in: 10 do
-              ProconBypassMan.logger.info('websocket client: pinged!!')
+              ProconBypassMan.logger.info('[WebsocketClient] pinged!!')
               ProconBypassMan.logger.info(msg)
             end
           }