rsmp 0.8.3 → 0.9.0

data/lib/rsmp/convert/export/json_schema.rb

@@ -23,7 +23,7 @@ module RSMP
 
         def self.build_value item
           out = {}
-          
+
           if item['description']
             out["description"] = item['description']
           end
@@ -95,7 +95,7 @@ module RSMP
             }
           end
           json = {
-            "properties" => { 
+            "properties" => {
               "aCId" => { "enum" => items.keys.sort },
               "rvs" => { "items" => { "allOf" => list } }
             }
@@ -175,7 +175,7 @@ module RSMP
               }
             ]
           }
-          out["sxl.json"] = output_json json     
+          out["sxl.json"] = output_json json
         end
 
         def self.generate sxl
@@ -192,7 +192,7 @@ module RSMP
           out.each_pair do |relative_path,str|
             path = File.join(folder, relative_path)
             FileUtils.mkdir_p File.dirname(path)      # create folders if needed
-            file = File.open(path, 'w+')      # w+ means truncate or create new file 
+            file = File.open(path, 'w+')      # w+ means truncate or create new file
             file.puts str
           end
         end

data/lib/rsmp/convert/import/yaml.rb

@@ -24,7 +24,7 @@ module RSMP
             commands: {}
           }
 
-          yaml['objects'].each_pair do |type,object|  
+          yaml['objects'].each_pair do |type,object|
             object["alarms"].each { |id,item| sxl[:alarms][id] = item }
             object["statuses"].each { |id,item| sxl[:statuses][id] = item }
             object["commands"].each { |id,item| sxl[:commands][id] = item }

data/lib/rsmp/error.rb

@@ -64,7 +64,4 @@ module RSMP
 
 	class RepeatedStatusError < Error
 	end
-
-	class TimestampError < Error
-	end
 end

data/lib/rsmp/inspect.rb

@@ -1,5 +1,5 @@
 # Costume inspect, to reduce noise
-# 
+#
 # Instance variables of classes starting with Async or RSMP are shown
 # with only their class name and object id, which reduces output,
 # especially for deep object structures.

data/lib/rsmp/logger.rb

@@ -2,7 +2,7 @@ module RSMP
   class Logger
 
     attr_accessor :settings
-    
+
     def initialize settings={}
       defaults = {
         'active'=>true,
@@ -115,7 +115,7 @@ module RSMP
             end
           end
         end
-        return false if ack && @settings["acknowledgements"] == false && 
+        return false if ack && @settings["acknowledgements"] == false &&
           [:not_acknowledged,:warning,:error].include?(item[:level]) == false
       end
       true
@@ -159,7 +159,7 @@ module RSMP
 
     def log item, force:false
       if output?(item, force)
-        output item[:level], build_output(item) 
+        output item[:level], build_output(item)
       end
     end
 
@@ -169,7 +169,7 @@ module RSMP
       else
         ' '*length
       end
-    end 
+    end
 
     def dump archive, force:false, num:nil
       num ||= archive.items.size
@@ -183,7 +183,7 @@ module RSMP
     def build_part parts, item, key, &block
       skey = key.to_s
       return unless @settings[skey]
-      
+
       part = item[key]
       part = yield part if block
       part = part.to_s

data/lib/rsmp/logging.rb

@@ -8,7 +8,7 @@ module RSMP
 
     def initialize_logging options
       @archive = options[:archive] || RSMP::Archive.new
-      @logger = options[:logger] || RSMP::Logger.new(options[:log_settings]) 
+      @logger = options[:logger] || RSMP::Logger.new(options[:log_settings])
     end
 
     def author

data/lib/rsmp/message.rb

@@ -188,7 +188,7 @@ module RSMP
   class Unknown < Message
   end
 
-  class AggregatedStatus < Message 
+  class AggregatedStatus < Message
     def initialize attributes = {}
       super({
         "type" => "AggregatedStatus",

data/lib/rsmp/node.rb

@@ -3,14 +3,14 @@
 module RSMP
   class Node
     include Logging
-    include Wait
     include Inspect
+    include Task
 
     attr_reader :archive, :logger, :task, :deferred, :error_queue, :clock, :collector
 
     def initialize options
       initialize_logging options
-      @task = options[:task]
+      initialize_task
       @deferred = []
       @clock = Clock.new
       @error_queue = Async::Queue.new
@@ -18,6 +18,13 @@ module RSMP
       @collect = options[:collect]
     end
 
+    # stop proxies, then call super
+    def stop_subtasks
+      @proxies.each { |proxy| proxy.stop }
+      @proxies.clear
+      super
+    end
+
     def ignore_errors classes, &block
       was, @ignore_errors = @ignore_errors, [classes].flatten
       yield
@@ -50,55 +57,13 @@ module RSMP
 
     def clear_deferred
       @deferred.clear
-    end    
-
-    def do_start task
-      task.annotate self.class.to_s
-      @task = task
-      start_action
-      idle
-    end
-
-    def start
-      starting
-      if @task
-        do_start @task
-      else
-        Async do |task|
-          do_start task
-        end
-      end
-    rescue Errno::EADDRINUSE => e
-      log "Cannot start: #{e.to_s}", level: :error
-    rescue SystemExit, SignalException, Interrupt
-      @logger.unmute_all
-      exiting
-    end
-
-    def idle
-      loop do
-        @task.sleep 60
-      end
-    end
-
-    def stop
-      @task.stop if @task
-    end
-
-    def restart
-      stop
-      start
-    end
-
-    def exiting
-      log "Exiting", level: :info
     end
 
     def check_required_settings settings, required
       raise ArgumentError.new "Settings is empty" unless settings
       required.each do |setting|
         raise ArgumentError.new "Missing setting: #{setting}" unless settings.include? setting.to_s
-      end 
+      end
     end
 
     def author

data/lib/rsmp/proxy.rb

@@ -1,32 +1,104 @@
-# Logging class for a connection to a remote site or supervisor.
+# A connection to a remote site or supervisor.
+# Uses the Task module to handle asyncronous work, but adds
+# the concept of a connection that can be connected or disconnected.
 
 require 'rubygems'
 
-module RSMP  
+module RSMP
   class Proxy
     WRAPPING_DELIMITER = "\f"
 
     include Logging
-    include Wait
     include Notifier
     include Inspect
+    include Task
 
-    attr_reader :state, :archive, :connection_info, :sxl, :task, :collector, :ip, :port
+    attr_reader :state, :archive, :connection_info, :sxl, :collector, :ip, :port
 
     def initialize options
       initialize_logging options
       initialize_distributor
+      initialize_task
       setup options
       clear
+      @state = :disconnected
     end
 
+    def disconnect
+    end
+
+    # wait for the reader task to complete,
+    # which is not expected to happen before the connection is closed
+    def wait_for_reader
+      @reader.wait if @reader
+    end
+
+    # close connection, but keep our main task running so we can reconnect
+    def close
+      log "Closing connection", level: :warning
+      close_stream
+      close_socket
+      set_state :disconnected
+      notify_error DisconnectError.new("Connection was closed")
+      stop_timer
+    end
+
+    def stop_subtasks
+      stop_timer
+      stop_reader
+      clear
+      super
+    end
+
+    def stop_timer
+      return unless @timer
+      @timer.stop
+      @timer = nil
+    end
+
+    def stop_reader
+      return unless @reader
+      @reader.stop
+      @reader = nil
+    end
+
+    def close_stream
+      return unless @stream
+      @stream.close
+      @stream = nil
+    end
+
+    def close_socket
+      return unless @socket
+      @socket.close
+      @socket = nil
+    end
+
+    def stop_task
+      close
+      super
+    end
+
+    # change our state
+    def set_state state
+      return if state == @state
+      @state = state
+      state_changed
+    end
+
+    # the state changed
+    # override to to things like notifications
+    def state_changed
+      @state_condition.signal @state
+    end
+
+    # revive after a reconnect
     def revive options
       setup options
     end
 
     def setup options
       @settings = options[:settings]
-      @task = options[:task]
       @socket = options[:socket]
       @stream = options[:stream]
       @protocol = options[:protocol]
@@ -35,7 +107,6 @@ module RSMP
       @connection_info = options[:info]
       @sxl = nil
       @site_settings = nil  # can't pick until we know the site id
-      @state = :stopped
       if options[:collect]
         @collector = RSMP::Collector.new self, options[:collect]
         @collector.start
@@ -52,35 +123,16 @@ module RSMP
       node.clock
     end
 
-    def run
-      start
-      @reader.wait if @reader
-    ensure
-      stop unless [:stopped, :stopping].include? @state
-    end
-
     def ready?
       @state == :ready
     end
 
     def connected?
-      @state == :starting || @state == :ready
+      @state == :connected || @state == :ready
     end
 
-
-    def start
-      set_state :starting
-    end
-
-    def stop
-      return if @state == :stopped
-      set_state :stopping
-      stop_tasks
-      notify_error DisconnectError.new("Connection was closed")
-    ensure
-      close_socket
-      clear
-      set_state :stopped
+    def disconnected?
+      @state == :disconnected
     end
 
     def clear
@@ -97,56 +149,57 @@ module RSMP
       @acknowledgement_condition = Async::Notification.new
     end
 
-    def close_socket
-      if @stream
-        @stream.close
-        @stream = nil
-      end
-
-      if @socket
-        @socket.close
-        @socket = nil
+    # run an async task that reads from @socket
+    def start_reader
+      @reader = @task.async do |task|
+        task.annotate "reader"
+        run_reader
       end
     end
 
-    def start_reader  
-      @reader = @task.async do |task|
-        task.annotate "reader"
-        @stream ||= Async::IO::Stream.new(@socket)
-        @protocol ||= Async::IO::Protocol::Line.new(@stream,WRAPPING_DELIMITER) # rsmp messages are json terminated with a form-feed
-        while json = @protocol.read_line
-          beginning = Time.now
-          message = process_packet json
-          duration = Time.now - beginning
-          ms = (duration*1000).round(4)
-          if duration > 0
-            per_second = (1.0 / duration).round
-          else
-            per_second = 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
-      rescue Async::Wrapper::Cancelled
-        # ignore        
-      rescue EOFError
-        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
-        notify_error e, level: :internal
+    def run_reader
+      @stream ||= Async::IO::Stream.new(@socket)
+      @protocol ||= Async::IO::Protocol::Line.new(@stream,WRAPPING_DELIMITER) # rsmp messages are json terminated with a form-feed
+      loop do
+        read_line
+      end
+    rescue Restart
+      log "Closing connection", level: :warning
+      raise
+    rescue Async::Wrapper::Cancelled
+      # ignore exceptions raised when a wait is aborted because a task is stopped
+    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
+      notify_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)
+      if duration > 0
+        per_second = (1.0 / duration).round
+      else
+        per_second = 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 notify_error e, options={}
@@ -160,36 +213,40 @@ module RSMP
     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"
-        next_time = Time.now.to_f
-        loop do
-          begin
-            now = Clock.now
-            timer(now)
-          rescue RSMP::Schemer::Error => e
-            puts "Timer: Schema error: #{e}"
-          rescue EOFError => e
-            log "Timer: Connection closed: #{e}", level: :warning
-          rescue IOError => e
-            log "Timer: IOError", level: :warning
-          rescue Errno::ECONNRESET
-            log "Timer: Connection reset by peer", level: :warning
-          rescue Errno::EPIPE => e
-            log "Timer: Broken pipe", level: :warning
-          rescue StandardError => e
-            notify_error e, level: :internal
-          end
-        ensure
-          next_time += interval
-          duration = next_time - Time.now.to_f
-          task.sleep duration
+        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::Schemer::Error => e
+          log "Timer: Schema error: #{e}", level: :warning
+        rescue EOFError => e
+          log "Timer: Connection closed: #{e}", level: :warning
+        rescue IOError => e
+          log "Timer: IOError", level: :warning
+        rescue Errno::ECONNRESET
+          log "Timer: Connection reset by peer", level: :warning
+        rescue Errno::EPIPE => e
+          log "Timer: Broken pipe", level: :warning
+        rescue StandardError => e
+          notify_error e, level: :internal
         end
+      ensure
+        next_time += interval
+        duration = next_time - Time.now.to_f
+        task.sleep duration
       end
     end
 
@@ -200,7 +257,7 @@ module RSMP
     end
 
     def watchdog_send_timer now
-      return unless @watchdog_started  
+      return unless @watchdog_started
       return if @site_settings['intervals']['watchdog'] == :never
       if @latest_watchdog_send_at == nil
         send_watchdog now
@@ -226,9 +283,13 @@ module RSMP
       @awaiting_acknowledgement.clone.each_pair do |m_id, message|
         latest = message.timestamp + timeout
         if now > latest
-          log "No acknowledgements for #{message.type} #{message.m_id_short} within #{timeout} seconds", level: :error
-          stop
-          notify_error MissingAcknowledgment.new('No ack')
+          str = "No acknowledgements for #{message.type} #{message.m_id_short} within #{timeout} seconds"
+          log str, level: :error
+          begin
+            close
+          ensure
+            notify_error MissingAcknowledgment.new(str)
+          end
         end
       end
     end
@@ -238,16 +299,16 @@ module RSMP
       latest = @latest_watchdog_received + timeout
       left = latest - now
       if left < 0
-        log "No Watchdog within #{timeout} seconds", level: :error
-        stop
+        str = "No Watchdog within #{timeout} seconds"
+        log str, level: :error
+          begin
+            close                                   # this will stop the current task (ourself)
+          ensure
+            notify_error MissingWatchdog.new(str)   # but ensure block will still be reached
+          end
       end
     end
 
-    def stop_tasks
-      @timer.stop if @timer
-      @reader.stop if @reader
-    end
-
     def log str, options={}
       super str, options.merge(ip: @ip, port: @port, site_id: @site_id)
     end
@@ -355,7 +416,7 @@ module RSMP
       str = "Rejected #{message.type},"
       notify_error e.exception(str), message: message
       dont_acknowledge message, str, reason
-      stop
+      close
       message
     ensure
       node.clear_deferred
@@ -436,19 +497,14 @@ module RSMP
       send_message message, "for #{original.type} #{original.m_id_short}"
     end
 
-    def set_state state
-      @state = state
-      @state_condition.signal @state
-    end
-
-    def wait_for_state state, timeout
+    def wait_for_state state, timeout:
       states = [state].flatten
       return if states.include?(@state)
-      wait_for(@state_condition,timeout) do
+      wait_for_condition(@state_condition,timeout: timeout) do
         states.include?(@state)
       end
       @state
-    rescue Async::TimeoutError
+    rescue RSMP::TimeoutError
       raise RSMP::TimeoutError.new "Did not reach state #{state} within #{timeout}s"
     end
 
@@ -557,10 +613,10 @@ module RSMP
       end
     end
 
-    def connection_complete
+    def handshake_complete
       set_state :ready
     end
-    
+
     def version_acknowledged
     end
 
@@ -572,23 +628,17 @@ module RSMP
       node.site_id
     end
 
-    def wait_for_acknowledgement parent_task, options={}, m_id
-      collector = Collector.new self, options.merge(task: parent_task, type: ['MessageAck','MessageNotAck'])
-      collector.collect do |message|
-        if message.is_a?(MessageNotAck)
-          if message.attribute('oMId') == m_id
-            m_id_short = RSMP::Message.shorten_m_id m_id, 8
-            raise RSMP::MessageRejected.new "Aggregated status request #{m_id_short} was rejected with '#{message.attribute('rea')}'"
-          end
-        elsif message.is_a?(MessageAck)
-          collector.complete if message.attribute('oMId') == m_id
+    def send_and_optionally_collect message, options, &block
+      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
-      end
-    end
 
-    def send_and_optionally_collect message, options, &block
-      if options[:collect]
-        task = @task.async { |task| yield task }
         send_message message, validate: options[:validate]
         { sent: message, collector: task.wait }
       else

data/lib/rsmp/rsmp.rb

@@ -1,5 +1,5 @@
 # Get the current time in UTC, with optional adjustment
-# Convertion to string uses the RSMP format 2015-06-08T12:01:39.654Z 
+# Convertion to string uses the RSMP format 2015-06-08T12:01:39.654Z
 # Note that using to_s on a my_clock.to_s will not produce an RSMP formatted timestamp,
 # you need to use Clock.to_s my_clock