rsmp 0.37.0 → 0.38.0

data/lib/rsmp/proxy/modules/acknowledgements.rb

@@ -0,0 +1,144 @@
+module RSMP
+  class Proxy
+    module Modules
+      # Message acknowledgement handling
+      # Manages sending/receiving acks and nacks, and tracking acknowledged messages
+      module Acknowledgements
+        def acknowledge(original)
+          raise InvalidArgument unless original
+
+          ack = MessageAck.build_from(original)
+          ack.original = original.clone
+          send_message ack, "for #{ack.original.type} #{original.m_id_short}"
+          check_ingoing_acknowledged original
+        end
+
+        def dont_acknowledge(original, prefix = nil, reason = nil, force: true)
+          raise InvalidArgument unless original
+
+          str = [prefix, reason].join(' ')
+          log str, message: original, level: :warning if reason
+          message = MessageNotAck.new({
+                                        'oMId' => original.m_id,
+                                        'rea' => reason || 'Unknown reason'
+                                      })
+          message.original = original.clone
+          send_message message, "for #{original.type} #{original.m_id_short}", force: force
+        end
+
+        def expect_acknowledgement(message)
+          return if message.is_a?(MessageAck) || message.is_a?(MessageNotAck)
+
+          @awaiting_acknowledgement[message.m_id] = message
+        end
+
+        def dont_expect_acknowledgement(message)
+          @awaiting_acknowledgement.delete message.attribute('oMId')
+        end
+
+        def check_ack_timeout(now)
+          timeout = @site_settings['timeouts']['acknowledgement']
+          # hash cannot be modify during iteration, so clone it
+          @awaiting_acknowledgement.clone.each_pair do |_m_id, message|
+            latest = message.timestamp + timeout
+            next unless now > latest
+
+            str = "No acknowledgements for #{message.type} #{message.m_id_short} within #{timeout} seconds"
+            log str, level: :error
+            begin
+              close
+            ensure
+              distribute_error MissingAcknowledgment.new(str)
+            end
+          end
+        end
+
+        def find_original_for_message(message)
+          @awaiting_acknowledgement[message.attribute('oMId')]
+        end
+
+        # TODO: this might be better handled by a proper event machine using e.g. the EventMachine gem
+        def check_outgoing_acknowledged(message)
+          return if @outgoing_acknowledged[message.type]
+
+          @outgoing_acknowledged[message.type] = true
+          acknowledged_first_outgoing message
+        end
+
+        def check_ingoing_acknowledged(message)
+          return if @ingoing_acknowledged[message.type]
+
+          @ingoing_acknowledged[message.type] = true
+          acknowledged_first_ingoing message
+        end
+
+        def acknowledged_first_outgoing(message); end
+
+        def acknowledged_first_ingoing(message); end
+
+        def process_ack(message)
+          original = find_original_for_message message
+          if original
+            dont_expect_acknowledgement message
+            message.original = original
+            log_acknowledgement_for_original message, original
+
+            case original.type
+            when 'Version'
+              version_acknowledged
+            when 'StatusSubscribe'
+              status_subscribe_acknowledged original
+            end
+
+            check_outgoing_acknowledged original
+
+            @acknowledgements[original.m_id] = message
+            @acknowledgement_condition.signal message
+          else
+            log_acknowledgement_for_unknown message
+          end
+        end
+
+        def process_not_ack(message)
+          original = find_original_for_message message
+          if original
+            dont_expect_acknowledgement message
+            message.original = original
+            log_acknowledgement_for_original message, original
+            @acknowledgements[original.m_id] = message
+            @acknowledgement_condition.signal message
+          else
+            log_acknowledgement_for_unknown message
+          end
+        end
+
+        def log_acknowledgement_for_original(message, original)
+          str = "Received #{message.type} for #{original.type} #{message.attribute('oMId')[0..3]}"
+          if message.type == 'MessageNotAck'
+            reason = message.attributes['rea']
+            str = "#{str}: #{reason}" if reason
+            log str, message: message, level: :warning
+          else
+            log str, message: message, level: :log
+          end
+        end
+
+        def log_acknowledgement_for_unknown(message)
+          log "Received #{message.type} for unknown message #{message.attribute('oMId')[0..3]}", message: message,
+                                                                                                 level: :warning
+        end
+
+        def status_subscribe_acknowledged(original)
+          component = find_component original.attribute('cId')
+          return unless component
+
+          short = Message.shorten_m_id original.m_id
+          subscribe_list = original.attributes['sS']
+          log "StatusSubscribe #{short} acknowledged, allowing repeated status values for #{subscribe_list}",
+              level: :info
+          component.allow_repeat_updates subscribe_list
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/proxy/modules/receive.rb

@@ -0,0 +1,119 @@
+module RSMP
+  class Proxy
+    module Modules
+      # Message processing functionality
+      # Handles receiving and processing incoming messages
+      module Receive
+        def should_validate_ingoing_message?(message)
+          return true unless @site_settings
+
+          skip = @site_settings['skip_validation']
+          return true unless skip
+
+          klass = message.class.name.split('::').last
+          !skip.include?(klass)
+        end
+
+        def process_deferred
+          @node.process_deferred
+        end
+
+        def verify_sequence(message)
+          expect_version_message(message) unless @version_determined
+        end
+
+        def handle_invalid_packet(json, error)
+          str = "Received invalid package, must be valid JSON but got #{json.size} bytes: #{error.message}"
+          distribute_error error.exception(str)
+          log str, level: :warning
+          nil
+        end
+
+        def handle_malformed_message(attributes, error)
+          str = "Received malformed message, #{error.message}"
+          distribute_error error.exception(str)
+          log str, message: Malformed.new(attributes), level: :warning
+          nil
+        end
+
+        def handle_schema_error(message, error)
+          schemas_string = error.schemas.map { |schema| "#{schema.first}: #{schema.last}" }.join(', ')
+          reason = "schema errors (#{schemas_string}): #{error.message}"
+          str = "Received invalid #{message.type}"
+          distribute_error error.exception(str), message: message
+          dont_acknowledge message, str, reason
+          message
+        end
+
+        def handle_invalid_message(message, error)
+          reason = error.message.to_s
+          str = "Received invalid #{message.type},"
+          distribute_error error.exception("#{str} #{message.json}"), message: message
+          dont_acknowledge message, str, reason
+          message
+        end
+
+        def handle_fatal_error(message, error)
+          reason = error.message
+          str = "Rejected #{message.type},"
+          distribute_error error.exception(str), message: message
+          dont_acknowledge message, str, reason
+          close
+          message
+        end
+
+        def process_packet(json)
+          attributes = Message.parse_attributes json
+          message = Message.build attributes, json
+          message.validate(schemas) if should_validate_ingoing_message?(message)
+          verify_sequence message
+          with_deferred_distribution do
+            distribute message
+            process_message message
+          end
+          process_deferred
+          message
+        rescue InvalidPacket => e
+          handle_invalid_packet(json, e)
+        rescue MalformedMessage => e
+          handle_malformed_message(attributes, e)
+        rescue SchemaError, RSMP::Schema::Error => e
+          handle_schema_error(message, e)
+        rescue InvalidMessage => e
+          handle_invalid_message(message, e)
+        rescue FatalError => e
+          handle_fatal_error(message, e)
+        ensure
+          @node.clear_deferred
+        end
+
+        def process_message(message)
+          case message
+          when MessageAck
+            process_ack message
+          when MessageNotAck
+            process_not_ack message
+          when Version
+            process_version message
+          when RSMP::Watchdog
+            process_watchdog message
+          else
+            dont_acknowledge message, 'Received', "unknown message (#{message.type})"
+          end
+        end
+
+        def will_not_handle(message)
+          reason ||= "since we're a #{self.class.name.downcase}"
+          log "Ignoring #{message.type}, #{reason}", message: message, level: :warning
+          dont_acknowledge message, nil, reason
+        end
+
+        def expect_version_message(message)
+          return if message.is_a?(Version) || message.is_a?(MessageAck) || message.is_a?(MessageNotAck)
+
+          raise HandshakeError, 'Version must be received first'
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/proxy/modules/send.rb

@@ -0,0 +1,76 @@
+module RSMP
+  class Proxy
+    module Modules
+      # Message sending functionality
+      # Handles sending messages, validation, and buffering
+      module Send
+        def handle_send_schema_error(message, error)
+          schemas_string = error.schemas.map { |schema| "#{schema.first}: #{schema.last}" }.join(', ')
+          str = "Could not send #{message.type} because schema validation failed (#{schemas_string}): #{error.message}"
+          log str, message: message, level: :error
+          distribute_error error.exception("#{str} #{message.json}")
+        end
+
+        def send_message(message, reason = nil, validate: true, force: false)
+          raise NotReady if !force && !connected?
+          raise IOError unless @protocol
+
+          message.direction = :out
+          message.generate_json
+          message.validate schemas unless validate == false
+          @protocol.write_lines message.json
+          expect_acknowledgement message
+          distribute message
+          log_send message, reason
+        rescue IOError
+          buffer_message message
+        rescue SchemaError, RSMP::Schema::Error => e
+          handle_send_schema_error(message, e)
+        end
+
+        def buffer_message(message)
+          # TODO
+          # log "Cannot send #{message.type} because the connection is closed.", message: message, level: :error
+        end
+
+        def log_send(message, reason = nil)
+          str = if reason
+                  "Sent #{message.type} #{reason}"
+                else
+                  "Sent #{message.type}"
+                end
+
+          if message.type == 'MessageNotAck'
+            log str, message: message, level: :warning
+          else
+            log str, message: message, level: :log
+          end
+        end
+
+        def send_and_optionally_collect(message, options)
+          collect_options = options[:collect] || options[:collect!]
+          if collect_options
+            task = @task.async do |task|
+              task.annotate 'send_and_optionally_collect'
+              collector = yield collect_options     # call block to create collector
+              collector.collect
+              collector.ok! if options[:collect!]   # raise any errors if the bang version was specified
+              collector
+            end
+
+            send_message message, validate: options[:validate]
+            { sent: message, collector: task.wait }
+          else
+            send_message message, validate: options[:validate]
+            { sent: message }
+          end
+        end
+
+        def apply_nts_message_attributes(message)
+          message.attributes['ntsOId'] = main && main.ntsoid ? main.ntsoid : ''
+          message.attributes['xNId'] = main && main.xnid ? main.xnid : ''
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/proxy/modules/state.rb

@@ -0,0 +1,25 @@
+module RSMP
+  class Proxy
+    module Modules
+      # State management helpers
+      # Utility methods for waiting on state changes
+      module State
+        def wait_for_state(state, timeout:)
+          states = [state].flatten
+          return true if states.include?(@state)
+
+          wait_for_condition(@state_condition, timeout: timeout) do
+            states.include?(@state)
+          end
+          true
+        rescue RSMP::TimeoutError
+          raise RSMP::TimeoutError, "Did not reach state #{state} within #{timeout}s"
+        end
+
+        def handshake_complete
+          self.state = :ready
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/proxy/modules/tasks.rb

@@ -0,0 +1,105 @@
+module RSMP
+  class Proxy
+    module Modules
+      # Reader and timer task management
+      # Handles async tasks for reading from socket and running periodic timers
+      module Tasks
+        # run an async task that reads from @socket
+        def start_reader
+          @reader = @task.async do |task|
+            task.annotate 'reader'
+            run_reader
+          end
+        end
+
+        def run_reader
+          @stream ||= IO::Stream::Buffered.new(@socket)
+          @protocol ||= RSMP::Protocol.new(@stream) # rsmp messages are json terminated with a form-feed
+          loop do
+            read_line
+          end
+        rescue Restart
+          log 'Closing connection', level: :warning
+          raise
+        rescue EOFError, Async::Stop
+          log 'Connection closed', level: :warning
+        rescue IOError => e
+          log "IOError: #{e}", level: :warning
+        rescue Errno::ECONNRESET
+          log 'Connection reset by peer', level: :warning
+        rescue Errno::EPIPE
+          log 'Broken pipe', level: :warning
+        rescue StandardError => e
+          distribute_error e, level: :internal
+        end
+
+        def read_line
+          json = @protocol.read_line
+          beginning = Time.now
+          message = process_packet json
+          duration = Time.now - beginning
+          ms = (duration * 1000).round(4)
+          per_second = if duration.positive?
+                         (1.0 / duration).round
+                       else
+                         Float::INFINITY
+                       end
+          if message
+            type = message.type
+            m_id = Logger.shorten_message_id(message.m_id)
+          else
+            type = 'Unknown'
+            m_id = nil
+          end
+          str = [type, m_id, "processed in #{ms}ms, #{per_second}req/s"].compact.join(' ')
+          log str, level: :statistics
+        end
+
+        def start_timer
+          return if @timer
+
+          name = 'timer'
+          interval = @site_settings['intervals']['timer'] || 1
+          log "Starting #{name} with interval #{interval} seconds", level: :debug
+          @latest_watchdog_received = Clock.now
+          @timer = @task.async do |task|
+            task.annotate 'timer'
+            run_timer task, interval
+          end
+        end
+
+        def run_timer(task, interval)
+          next_time = Time.now.to_f
+          loop do
+            begin
+              now = Clock.now
+              timer(now)
+            rescue RSMP::Schema::Error => e
+              log "Timer: Schema error: #{e}", level: :warning
+            rescue EOFError => e
+              log "Timer: Connection closed: #{e}", level: :warning
+            rescue IOError
+              log 'Timer: IOError', level: :warning
+            rescue Errno::ECONNRESET
+              log 'Timer: Connection reset by peer', level: :warning
+            rescue Errno::EPIPE
+              log 'Timer: Broken pipe', level: :warning
+            rescue StandardError => e
+              distribute_error e, level: :internal
+            end
+          ensure
+            next_time += interval
+            duration = next_time - Time.now.to_f
+            task.sleep duration
+          end
+        end
+
+        def timer(now)
+          watchdog_send_timer now
+          check_ack_timeout now
+          check_watchdog_timeout now
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/proxy/modules/versions.rb

@@ -0,0 +1,69 @@
+module RSMP
+  class Proxy
+    module Modules
+      # Version negotiation and handling
+      # Manages RSMP version handshake between sites and supervisors
+      module Versions
+        def core_versions
+          version = @site_settings['core_version']
+          if version == 'latest'
+            [RSMP::Schema.latest_core_version]
+          elsif version
+            [version]
+          else
+            RSMP::Schema.core_versions
+          end
+        end
+
+        def check_core_version(message)
+          versions = core_versions
+          # find versions that both we and the client support
+          candidates = message.versions & versions
+          if candidates.any?
+            @core_version = candidates.max_by { |v| Gem::Version.new(v) } # pick latest version
+          else
+            reason = "RSMP versions [#{message.versions.join(', ')}] requested, " \
+                     "but only [#{versions.join(', ')}] supported."
+            dont_acknowledge message, 'Version message rejected', reason, force: true
+            raise HandshakeError, reason
+          end
+        end
+
+        def process_version(message); end
+
+        def extraneous_version(message)
+          dont_acknowledge message, 'Received', 'extraneous Version message'
+        end
+
+        def send_version(site_id, core_versions)
+          versions = if core_versions == 'latest'
+                       [RSMP::Schema.latest_core_version]
+                     elsif core_versions == 'all'
+                       RSMP::Schema.core_versions
+                     else
+                       [core_versions].flatten
+                     end
+          versions_array = versions.map { |v| { 'vers' => v } }
+
+          site_id_array = [site_id].flatten.map { |id| { 'sId' => id } }
+
+          version_response = Version.new({
+                                           'RSMP' => versions_array,
+                                           'siteId' => site_id_array,
+                                           'SXL' => sxl_version.to_s
+                                         })
+          send_message version_response
+        end
+
+        def version_acknowledged; end
+
+        # Use Gem class to check version requirement
+        # Requirement must be a string like '1.1', '>=1.0.3' or '<2.1.4',
+        # or list of strings, like ['<=1.4','<1.5']
+        def self.version_meets_requirement?(version, requirement)
+          Gem::Requirement.new(requirement).satisfied_by?(Gem::Version.new(version))
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/proxy/modules/watchdogs.rb

@@ -0,0 +1,66 @@
+module RSMP
+  class Proxy
+    module Modules
+      # Watchdog functionality for monitoring connection health
+      # Handles sending and receiving watchdog messages
+      module Watchdogs
+        def start_watchdog
+          log "Starting watchdog with interval #{@site_settings['intervals']['watchdog']} seconds", level: :debug
+          @watchdog_started = true
+        end
+
+        def stop_watchdog
+          log 'Stopping watchdog', level: :debug
+          @watchdog_started = false
+        end
+
+        def with_watchdog_disabled
+          was = @watchdog_started
+          stop_watchdog if was
+          yield
+        ensure
+          start_watchdog if was
+        end
+
+        def watchdog_send_timer(now)
+          return unless @watchdog_started
+          return if @site_settings['intervals']['watchdog'] == :never
+
+          if @latest_watchdog_send_at.nil?
+            send_watchdog now
+          else
+            # we add half the timer interval to pick the timer
+            # event closes to the wanted wathcdog interval
+            diff = now - @latest_watchdog_send_at
+            if (diff + (0.5 * @site_settings['intervals']['timer'])) >= @site_settings['intervals']['watchdog']
+              send_watchdog now
+            end
+          end
+        end
+
+        def send_watchdog(now = Clock.now)
+          message = RSMP::Watchdog.new({ 'wTs' => clock.to_s })
+          send_message message
+          @latest_watchdog_send_at = now
+        end
+
+        def check_watchdog_timeout(now)
+          timeout = @site_settings['timeouts']['watchdog']
+          latest = @latest_watchdog_received + timeout
+          left = latest - now
+          return unless left.negative?
+
+          str = "No Watchdog received within #{timeout} seconds"
+          log str, level: :warning
+          distribute MissingWatchdog.new(str)
+        end
+
+        def process_watchdog(message)
+          log "Received #{message.type}", message: message, level: :log
+          @latest_watchdog_received = Clock.now
+          acknowledge message
+        end
+      end
+    end
+  end
+end