rsmp 0.1.17 → 0.1.19

data/lib/rsmp/site.rb

@@ -110,7 +110,9 @@ module RSMP
           if @site_settings["reconnect_interval"] != :no
             # sleep until waken by reconnect() or the reconnect interval passed
             proxy.set_state :wait_for_reconnect
-            task.with_timeout(@site_settings["reconnect_interval"]) { @sleep_condition.wait }
+            task.with_timeout(@site_settings["reconnect_interval"]) do
+              @sleep_condition.wait
+            end
           else
             proxy.set_state :cannot_connect
             break
@@ -141,5 +143,6 @@ module RSMP
         proxy.stop
       end
     end
+
   end
 end

data/lib/rsmp/site_proxy.rb

@@ -23,6 +23,11 @@ module RSMP
       start_reader
     end
 
+    def stop
+      log "Closing connection to site", level: :info
+      super
+    end
+
     def connection_complete
       super
       log "Connection to site #{@site_id} established", level: :info
@@ -50,6 +55,10 @@ module RSMP
       end
     end
 
+    def process_deferred
+      supervisor.process_deferred
+    end
+
     def version_accepted message
       log "Received Version message for site #{@site_id} using RSMP #{@rsmp_version}", message: message, level: :log
       start_timer
@@ -123,16 +132,38 @@ module RSMP
       @supervisor.site_ids_changed
     end
 
-    def request_status component, status_list, timeout=nil
-      raise NotReady unless @state == :ready
+    def fetch_status parent_task, options
+      wait_for_status_responses(parent_task,options) do |m_id|
+        request_status options.merge(m_id: m_id)
+      end
+    end
+
+    # Convert from a short ruby hash:
+    # {:S0001=>[:signalgroupstatus, :cyclecounter, :basecyclecounter, :stage]}
+    # to an rsmp-style list:
+    # [{"sCI"=>"S0001", "n"=>"signalgroupstatus"}, {"sCI"=>"S0001", "n"=>"cyclecounter"}, {"sCI"=>"S0001", "n"=>"basecyclecounter"}, {"sCI"=>"S0001", "n"=>"stage"}]
+    #
+    # If the input is already an array, just return it
+    def convert_status_list list
+      return list.clone if list.is_a? Array
+      list.map do |status_code_id,names|
+        names.map do |name|
+          { 'sCI' => status_code_id.to_s, 'n' => name.to_s }
+        end
+      end.flatten
+    end
+
+    def request_status options
+      raise NotReady unless ready?
       message = RSMP::StatusRequest.new({
           "ntsOId" => '',
           "xNId" => '',
-          "cId" => component,
-          "sS" => status_list
+          "cId" => options[:component],
+          "sS" => convert_status_list(options[:status_list]),
+          "mId" => options[:m_id]
       })
       send_message message
-      return message, wait_for_status_response(message: message, timeout: timeout)
+      message
     end
 
     def process_status_response message
@@ -140,41 +171,26 @@ module RSMP
       acknowledge message
     end
 
-    def wait_for_status_response options
-      raise ArgumentError unless options[:message]
-      item = @archive.capture(@task, options.merge(
-        type: ['StatusResponse','MessageNotAck'],
-        with_message: true,
-        num: 1
-      )) do |item|
-        if item[:message].type == 'MessageNotAck'
-          next item[:message].attribute('oMId') == options[:message].m_id
-        elsif item[:message].type == 'StatusResponse'
-          next item[:message].attribute('cId') == options[:message].attribute('cId')
-        end
-      end
-      item[:message] if item
-    end
-
-    def subscribe_to_status component, status_list, timeout
-      raise NotReady unless @state == :ready
+    def subscribe_to_status component, status_list, options={}
+      raise NotReady unless ready?
       message = RSMP::StatusSubscribe.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "sS" => status_list
+          "sS" => convert_status_list(status_list),
+          'mId'=>options[:m_id]
       })
       send_message message
-      return message, wait_for_status_update(component: component, timeout: timeout)[:message]
+      return message
     end
 
     def unsubscribe_to_status component, status_list
-      raise NotReady unless @state == :ready
+      raise NotReady unless ready?
       message = RSMP::StatusUnsubscribe.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "sS" => status_list
+          "sS" => convert_status_list(status_list)
       })
       send_message message
       message
@@ -185,34 +201,20 @@ module RSMP
       acknowledge message
     end
 
-    def wait_for_status_update options={}
-      raise ArgumentError unless options[:component]
-      matching_status = nil
-      item = @archive.capture(@task,options.merge(type: "StatusUpdate", with_message: true, num: 1)) do |item|
-        # TODO check components
-        matching_status = nil
-        sS = item[:message].attributes['sS']
-        sS.each do |status|
-          next if options[:sCI] && options[:sCI] != status['sCI']
-          next if options[:n] && options[:n] != status['n']
-          next if options[:q] && options[:q] != status['q']
-          if options[:s].is_a? Regexp
-            next if options[:s] && status['s'] !~ options[:s]
-          else
-            next if options[:s] && options[:s] != status['s']
-          end
-          matching_status = status
-          break
-        end
-        matching_status != nil
-      end
-      if item
-        { message: item[:message], status: matching_status }
+    def status_match? query, item
+      return false if query[:sCI] && query[:sCI] != item['sCI']
+      return false if query[:n] && query[:n] != item['n']
+      return false if query[:q] && query[:q] != item['q']
+      if query[:s].is_a? Regexp
+        return false if query[:s] && item['s'] !~ query[:s]
+      else
+        return false if query[:s] && item['s'] != query[:s]
       end
+      true
     end
 
     def wait_for_alarm options={}
-      raise ArgumentError unless options[:component]
+      raise ArgumentError.new("component argument is missing") unless options[:component]
       matching_alarm = nil
       item = @archive.capture(@task,options.merge(type: "Alarm", with_message: true, num: 1)) do |item|
         # TODO check components
@@ -229,31 +231,49 @@ module RSMP
       end
     end
 
-    def send_command component, args
-      raise NotReady unless @state == :ready
-      message = RSMP::CommandRequest.new({
+    def send_alarm_acknowledgement component, alarm_code
+      message = RSMP::AlarmAcknowledged.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "arg" => args
+          "aCId" => alarm_code,
+          "xACId" => '',
+          "xNACId" => '',
+          "aSp" => 'Acknowledge'
       })
       send_message message
       message
     end
 
-    def process_command_response message
-      log "Received #{message.type}", message: message, level: :log
-      acknowledge message
-    end
-
-    def wait_for_command_response options
-      raise ArgumentError unless options[:component]
-      item = @archive.capture(@task,options.merge(num: 1, type: "CommandResponse", with_message: true)) do |item|
-         # check component
+    def wait_for_alarm_acknowledgement_response options
+      raise ArgumentError.new("component argument is missing") unless options[:component]
+      item = @archive.capture(@task,options.merge(
+        num: 1,
+        type: ['AlarmAcknowledgedResponse','MessageNotAck'],
+        with_message: true
+      )) do |item|
+        if item[:message].type == 'MessageNotAck'
+          next item[:message].attribute('oMId') == options[:message].m_id
+        elsif item[:message].type == 'AlarmAcknowledgedResponse'
+          next item[:message].attribute('cId') == options[:message].attribute('cId')
+        end
       end
       item[:message] if item
     end
 
+    def send_command component, args, options={}
+      raise NotReady unless ready?
+      message = RSMP::CommandRequest.new({
+          "ntsOId" => '',
+          "xNId" => '',
+          "cId" => component,
+          "arg" => args,
+          "mId" => options[:m_id]
+      })
+      send_message message
+      message
+    end
+
     def set_watchdog_interval interval
       @settings["watchdog_interval"] = interval
     end
@@ -286,6 +306,5 @@ module RSMP
       site_ids_changed
     end
 
-
   end
 end

data/lib/rsmp/supervisor.rb

@@ -129,6 +129,7 @@ module RSMP
       @proxies.push proxy
       
       proxy.run     # will run until the site disconnects
+    ensure
       @proxies.delete proxy
       site_ids_changed
 
@@ -167,13 +168,13 @@ module RSMP
     def wait_for_site site_id, timeout
       site = find_site site_id
       return site if site
-      RSMP::Wait.wait_for(@task,@site_id_condition,timeout) { find_site site_id }
+      wait_for(@site_id_condition,timeout) { find_site site_id }
     rescue Async::TimeoutError
       nil
     end
 
     def wait_for_site_disconnect site_id, timeout
-      RSMP::Wait.wait_for(@task,@site_id_condition,timeout) { true unless find_site site_id }
+      wait_for(@site_id_condition,timeout) { true unless find_site site_id }
     rescue Async::TimeoutError
       false
     end

data/lib/rsmp/supervisor_proxy.rb

@@ -28,6 +28,7 @@ module RSMP
       super
       connect
       @logger.unmute @ip, @port
+      log "Connected to superviser at #{@ip}:#{@port}", level: :info
       start_reader
       send_version @site_settings['site_id'], @site_settings["rsmp_versions"]
     rescue Errno::ECONNREFUSED
@@ -38,6 +39,12 @@ module RSMP
       end
     end
 
+    def stop
+      log "Closing connection to supervisor", level: :info
+      super
+      @last_status_sent = nil
+    end
+
     def connect
       return if @socket
       @endpoint = Async::IO::Endpoint.tcp(@ip, @port)
@@ -72,14 +79,15 @@ module RSMP
         else
           super message
       end
-    rescue UnknownComponent => e
-      dont_acknowledge message, '', e.to_s
-    rescue UnknownCommand => e
-      dont_acknowledge message, '', e.to_s
-    rescue UnknownStatus => e
+    rescue UnknownComponent, UnknownCommand, UnknownStatus,
+           MessageRejected, MissingAttribute => e
       dont_acknowledge message, '', e.to_s
     end
 
+    def process_deferred
+      site.process_deferred
+    end
+
     def acknowledged_first_ingoing message
       # TODO
       # aggregateds status should only be send for later version of rsmp
@@ -118,7 +126,7 @@ module RSMP
       message = AggregatedStatus.new({
         "aSTS" => RSMP.now_string,
         "cId" =>  component.c_id,
-        "fP" => nil,
+        "fP" => 'NormalControl',
         "fS" => nil,
         "se" => component.aggregated_status_bools
       })
@@ -177,7 +185,7 @@ module RSMP
       send_message response
     end
 
-    def process_status_request message
+    def process_status_request message, options={}
       component_id = message.attributes["cId"]
       component = @site.find_component component_id
       log "Received #{message.type}", message: message, level: :log
@@ -188,7 +196,8 @@ module RSMP
       response = StatusResponse.new({
         "cId"=>component_id,
         "sTs"=>RSMP.now_string,
-        "sS"=>sS
+        "sS"=>sS,
+        "mId" => options[:m_id]
       })
       acknowledge message
       send_message response
@@ -213,10 +222,11 @@ module RSMP
       update_list[component] ||= {} 
 
       subs = @status_subscriptions[component]
+      now = RSMP::now_object
 
       message.attributes["sS"].each do |arg|
         sCI = arg["sCI"]
-        subcription = {interval: arg["uRt"].to_i, last_sent_at: nil}
+        subcription = {interval: arg["uRt"].to_i, last_sent_at: now}
         subs[sCI] ||= {}
         subs[sCI][arg["n"]] = subcription
 
@@ -250,18 +260,40 @@ module RSMP
       status_update_timer now if ready?
     end
 
+    def fetch_last_sent_status component, code, name
+      if @last_status_sent && @last_status_sent[component] && @last_status_sent[component][code]
+        @last_status_sent[component][code][name]
+      else
+        nil
+      end
+    end
+
+    def store_last_sent_status component, code, name, value
+      @last_status_sent ||= {}
+      @last_status_sent[component] ||= {}
+      @last_status_sent[component][code] ||= {}
+      @last_status_sent[component][code][name] = value
+    end
+
     def status_update_timer now
       update_list = {}
       # go through subscriptons and build a similarly organized list,
       # that only contains what should be send
 
       @status_subscriptions.each_pair do |component,by_code|
+        component_object = @site.find_component component
         by_code.each_pair do |code,by_name|
           by_name.each_pair do |name,subscription|
+            current = nil
             if subscription[:interval] == 0 
               # send as soon as the data changes
-              if rand(100) >= 90
+              if component_object
+                current, age = *(component_object.get_status code, name)
+              end
+              last_sent = fetch_last_sent_status component, code, name
+              if current != last_sent
                 should_send = true
+                store_last_sent_status component, code, name, current
               end
             else
               # send at regular intervals
@@ -272,8 +304,8 @@ module RSMP
             if should_send
               subscription[:last_sent_at] = now
               update_list[component] ||= {}
-              update_list[component][code] ||= []
-              update_list[component][code] << name
+              update_list[component][code] ||= {}
+              update_list[component][code][name] = current
            end
           end
         end
@@ -289,8 +321,12 @@ module RSMP
         component = @site.find_component component_id
         sS = []
         by_code.each_pair do |code,names|
-          names.map do |status_name|
-            value,quality = component.get_status code, status_name
+          names.map do |status_name,value|
+            if value
+              quality = 'recent'
+            else
+              value,quality = component.get_status code, status_name
+            end
             sS << { "sCI" => code,
                      "n" => status_name,
                      "s" => value.to_s,

data/lib/rsmp/tlc.rb

@@ -4,13 +4,21 @@ module RSMP
 
   class TrafficController < Component
     attr_reader :pos, :cycle_time
+
     def initialize node:, id:, cycle_time:
       super node: node, id: id, grouped: true
       @signal_groups = []
       @detector_logics = []
       @plans = []
-      @pos = 0
       @cycle_time = cycle_time
+      @num_traffic_situations = 1
+      @num_inputs = 8
+
+      reset
+    end
+
+    def reset
+      @pos = 0
       @plan = 0
       @dark_mode = false
       @yellow_flash = false
@@ -22,14 +30,12 @@ module RSMP
       @emergency_route = false
       @emergency_route_number = 0
       @traffic_situation = 0
-      @num_traffic_situations = 1
       @manual_control = false
       @fixed_time_control = false
       @isolated_control = false
       @yellow_flash = false
       @all_red = false
 
-      @num_inputs = 8
       @inputs = '0'*@num_inputs
       @input_activations = '0'*@num_inputs
       @input_results = '0'*@num_inputs
@@ -79,32 +85,24 @@ module RSMP
 
     def handle_command command_code, arg
       case command_code
-      when 'M0001'
-        handle_m0001 arg
-      when 'M0002'
-        handle_m0002 arg
-      when 'M0003'
-        handle_m0003 arg
-      when 'M0004'
-        handle_m0004 arg
-      when 'M0005'
-        handle_m0005 arg
-      when 'M0006'
-        handle_m0006 arg
-      when 'M0007'
-        handle_m0007 arg
+      when 'M0001', 'M0002', 'M0003', 'M0004', 'M0005', 'M0006', 'M0007',
+           'M0012', 'M0013', 'M0014', 'M0015', 'M0016', 'M0017', 'M0018',
+           'M0019', 'M0020', 'M0021', 'M0022',
+           'M0103', 'M0104'
+
+        return send("handle_#{command_code.downcase}", arg)
       else
         raise UnknownCommand.new "Unknown command #{command_code}"
       end
     end
 
     def handle_m0001 arg
-      @node.verify_security_code arg['securityCode']
+      @node.verify_security_code 2, arg['securityCode']
       switch_mode arg['status']
     end
 
     def handle_m0002 arg
-      @node.verify_security_code arg['securityCode']
+      @node.verify_security_code 2, arg['securityCode']
       if RSMP::Tlc.from_rsmp_bool(arg['status'])
         switch_plan arg['timeplan']
       else
@@ -113,32 +111,86 @@ module RSMP
     end
 
     def handle_m0003 arg
-      @node.verify_security_code arg['securityCode']
+      @node.verify_security_code 2, arg['securityCode']
       @traffic_situation = arg['traficsituation'].to_i
     end
 
     def handle_m0004 arg
-      @node.verify_security_code arg['securityCode']
-      # restarting the node means we will disconnect and reconnect.
-      # note that this will happen immediately, and no
-      # command response will therefore be sent
-      log "Restarting TLC", level: :info
-      @node.restart
+      @node.verify_security_code 2, arg['securityCode']
+      # don't restart immeediately, since we need to first send command response
+      # instead, defer an action, which will be handled by the TLC site
+      log "Sheduling restart of TLC", level: :info
+      @node.defer :restart
     end
 
     def handle_m0005 arg
-      @node.verify_security_code arg['securityCode']
+      @node.verify_security_code 2, arg['securityCode']
       @emergency_route = arg['status'] == 'True'
       @emergency_route_number = arg['emergencyroute'].to_i
     end
 
     def handle_m0006 arg
-      @node.verify_security_code arg['securityCode']
+      @node.verify_security_code 2, arg['securityCode']
       input = arg['input'].to_i
-      return unless input>=0 && input<@num_inputs
-      @input_activations[input] = (arg['status']=='True' ? '1' : '0')
-      result = @input_activations[input]=='1' || @inputs[input]=='1'
-      @input_results[input] = (result ? '1' : '0')
+      idx = input - 1
+      return unless idx>=0 && input<@num_inputs
+      @input_activations[idx] = (arg['status']=='True' ? '1' : '0')
+      result = @input_activations[idx]=='1' || @inputs[idx]=='1'
+      @input_results[idx] = (result ? '1' : '0')
+    end
+
+    def handle_m0007 arg
+      @node.verify_security_code 2, arg['securityCode']
+      set_fixed_time_control arg['status']
+    end
+
+    def handle_m0012 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0013 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0014 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0015 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0016 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0017 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0018 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0019 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0020 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0021 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0103 arg
+      level = {'Level1'=>1,'Level2'=>2}[arg['status']]
+      @node.change_security_code level, arg['oldSecurityCode'], arg['newSecurityCode']
+    end
+
+    def handle_m0104 arg
+      @node.verify_security_code 1, arg['securityCode']
     end
 
     def set_input i, value
@@ -146,11 +198,6 @@ module RSMP
       @inputs[i] = (arg['value'] ? '1' : '0')
     end
     
-    def handle_m0007 arg
-      @node.verify_security_code arg['securityCode']
-      set_fixed_time_control arg['status']
-    end
-
     def set_fixed_time_control status
       @fixed_time_control = status
     end
@@ -182,8 +229,8 @@ module RSMP
            'S0008', 'S0009', 'S0010', 'S0011', 'S0012', 'S0013', 'S0014',
            'S0015', 'S0016', 'S0017', 'S0018', 'S0019', 'S0020', 'S0021',
            'S0022', 'S0023', 'S0024', 'S0026', 'S0027', 'S0028',
-           'S0029',
-           'S0091', 'S0092', 'S0095', 'S0096',
+           'S0029', 'S0030', 'S0031',
+           'S0091', 'S0092', 'S0095', 'S0096', 'S0097',
            'S0205', 'S0206', 'S0207', 'S0208'
         return send("handle_#{code.downcase}", code, name)
       else
@@ -194,7 +241,7 @@ module RSMP
     def handle_s0001 status_code, status_name=nil
       case status_name
       when 'signalgroupstatus'
-        return RSMP::Tlc.make_status format_signal_group_status
+        RSMP::Tlc.make_status format_signal_group_status
       when 'cyclecounter'
         RSMP::Tlc.make_status @pos.to_s
       when 'basecyclecounter'
@@ -415,6 +462,20 @@ module RSMP
       end
     end
 
+    def handle_s0030 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status ''
+      end
+    end
+
+    def handle_s0031 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status ''
+      end
+    end
+
     def handle_s0091 status_code, status_name=nil
       case status_name
       when 'user'
@@ -457,6 +518,15 @@ module RSMP
       end
     end
 
+    def handle_s0097 status_code, status_name=nil
+      case status_name
+      when 'version'
+        RSMP::Tlc.make_status '1'
+      when 'hash'
+        RSMP::Tlc.make_status '1'
+      end
+    end
+
     def handle_s0205 status_code, status_name=nil
       case status_name
       when 'start'
@@ -532,6 +602,31 @@ module RSMP
       @state = get_state pos
     end
 
+    def handle_command command_code, arg
+      case command_code
+      when 'M0010', 'M0011'
+        return send("handle_#{command_code.downcase}", arg)
+      else
+        raise UnknownCommand.new "Unknown command #{command_code}"
+      end
+    end
+
+    # Start of signal group. Orders a signal group to green
+    def handle_m0010 arg
+      @node.verify_security_code 2, arg['securityCode']
+      if RSMP::Tlc.from_rsmp_bool arg['status']
+        log "Start signal group #{c_id}, go to green", level: :info
+      end
+    end
+
+    # Stop of signal group. Orders a signal group to red
+    def handle_m0011 arg
+      @node.verify_security_code 2, arg['securityCode']
+      if RSMP::Tlc.from_rsmp_bool arg['status']
+        log "Stop signal group #{c_id}, go to red", level: :info
+      end
+    end
+
     def get_status code, name=nil
       case code
       when 'S0025'
@@ -643,7 +738,7 @@ module RSMP
     end
 
     def handle_m0008 arg
-      @node.verify_security_code arg['securityCode']
+      @node.verify_security_code 2, arg['securityCode']
       force_detector_logic arg['status']=='True', arg['value']='True'
       arg
     end
@@ -658,9 +753,9 @@ module RSMP
   class Tlc < Site
     def initialize options={}
       super options
-
       @sxl = 'traffic_light_controller'
-
+      @security_codes = options[:site_settings]['security_codes']
+      @interval = options[:site_settings]['interval'] || 1
       unless @main
         raise ConfigurationError.new "TLC must have a main component"
       end
@@ -687,31 +782,39 @@ module RSMP
     end
 
     def start_timer
-      name = "tlc timer"
-      interval = 1 #@settings["timer_interval"] || 1
-      log "Starting #{name} with interval #{interval} seconds", level: :debug
+      task_name = "tlc timer"
+      log "Starting #{task_name} with interval #{@interval} seconds", level: :debug
 
       @timer = @task.async do |task|
-        task.annotate "timer"
+        task.annotate task_name
         next_time = Time.now.to_f
         loop do
-          now = RSMP.now_object
-          break if timer(now) == false
-        rescue StandardError => e
-          log ["#{name} exception: #{e}",e.backtrace].flatten.join("\n"), level: :error
-        ensure
-          # adjust sleep duration to avoid drift. so wake up always happens on the 
-          # same fractional second.
-          # note that Time.now is not monotonic. If the clock si changed,
-          # either manaully or via NTP, the sleep interval might jump.
-          # an alternative is to use ::Process.clock_gettime(::Process::CLOCK_MONOTONIC),
-          # to get the current time. this ensures a constant interval, but
-          # if the clock is changed, the wake up would then happen on a different 
-          # fractional second
-
-          next_time += interval
-          duration = next_time - Time.now.to_f
-          task.sleep duration
+          begin
+            now = RSMP.now_object
+            timer(now)
+          rescue EOFError => e
+            log "TLC timer: Connection closed: #{e}", level: :warning
+          rescue IOError => e
+            log "TLC timer: IOError", level: :warning
+          rescue Errno::ECONNRESET
+            log "TLC timer: Connection reset by peer", level: :warning
+          rescue Errno::EPIPE => e
+            log "TLC timer: Broken pipe", level: :warning
+          rescue StandardError => e
+            log "TLC timer: #{e}", level: :debug
+          ensure
+            # adjust sleep duration to avoid drift. so wake up always happens on the
+            # same fractional second.
+            # note that Time.now is not monotonic. If the clock si changed,
+            # either manaully or via NTP, the sleep interval might jump.
+            # an alternative is to use ::Process.clock_gettime(::Process::CLOCK_MONOTONIC),
+            # to get the current time. this ensures a constant interval, but
+            # if the clock is changed, the wake up would then happen on a different
+            # fractional second
+            next_time += @interval
+            duration = next_time - Time.now.to_f
+            task.sleep duration
+          end
         end
       end
     end
@@ -721,7 +824,16 @@ module RSMP
       @main.timer now
     end
 
-    def verify_security_code code
+    def verify_security_code level, code
+      raise ArgumentError.new("Level must be 1-2, got #{level}") unless (1..2).include?(level)
+      if @security_codes[level] != code
+        raise MessageRejected.new("Wrong security code for level #{level}")
+      end
+    end
+
+    def change_security_code level, old_code, new_code
+      verify_security_code level, old_code
+      @security_codes[level] = new_code
     end
 
     def self.to_rmsp_bool bool
@@ -745,5 +857,13 @@ module RSMP
       end
     end
 
+    def do_deferred item
+      case item
+      when :restart
+        log "Restarting TLC", level: :info
+        restart
+      end
+    end
+
   end
 end