openc3 5.8.1 → 5.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6639b1c8a8f8b4902a85d6bdf1f23800aefd25b61b333c661c25236058e9595
-  data.tar.gz: e2b037827217d57a34a126189895afc3ff2c62e9758cc326f1cf24be08e1b791
+  metadata.gz: 35a757bea46ad5b21ac348aa90b6163595d04c702b752b728f628d7dd82f6132
+  data.tar.gz: 149be2f48cdb7864a3665bf46982a1e16fb37541f68203387297c14d0d55e7d8
 SHA512:
-  metadata.gz: 6d2b3412ed3db8cdee1772416419737fc895d54145f58c087168c8b8c17649ab155cc36c4563a6bb826852c02ae0f89ac0972f101e28db04fa2cdc9163799732
-  data.tar.gz: 39eacdb1118b721017fb84359426576ced5f08be342972a46429797b22e2f6ad46db4999171a03dc310dbb8c41e09d3bbbc8dc86145f807dfa50bfa0ffbacaf3
+  metadata.gz: 1595ea101a9473b1aa5a1894d08bcd5704943fae771f9e58c4506b905cae9cb5957ab0fc961349ec9ecc4466a3ae34b6987a2a9d21ed8b9d2b0d31592c16908b
+  data.tar.gz: afbf06dfc4d4dbbfd7916146b6ee2b3005959bae650735127710b257a675487591adb5739744e603ef5eb20cc545b4dc79962021aaef00127c9aa76017a4ba3e

data/ext/openc3/ext/crc/crc.c

@@ -410,7 +410,7 @@ static VALUE crc64_calculate(int argc, VALUE *argv, VALUE self)
 /*
  * Initialize methods for Crc
  */
-void Init_crc()
+void Init_crc(void)
 {
   id_ivar_seed = rb_intern("@seed");
   id_ivar_xor = rb_intern("@xor");

data/lib/openc3/api/cmd_api.rb

@@ -393,7 +393,7 @@ module OpenC3
         # Check if any of the parameters have DISABLE_MESSAGES
         cmd_params.each do |key, value|
           item = packet['items'].find { |item| item['name'] == key.to_s }
-          if item['states'] && item['states'][value] && item['states'][value]["messages_disabled"]
+          if item && item['states'] && item['states'][value] && item['states'][value]["messages_disabled"]
             log_message = false
           end
         end

data/lib/openc3/microservices/decom_microservice.rb

@@ -124,14 +124,22 @@ module OpenC3
         when :BLUE, :GREEN, :GREEN_LOW, :GREEN_HIGH
           @logger.info message
         when :YELLOW, :YELLOW_LOW, :YELLOW_HIGH
+          notification = NotificationModel.new(
+            time: time_nsec,
+            severity: "caution",
+            url: "/tools/limitsmonitor",
+            title: "#{packet.target_name} #{packet.packet_name} #{item.name} #{item.limits.state}",
+            body: "#{item.name} is #{item.limits.state}"
+          )
+          NotificationsTopic.write_notification(notification.as_json(:allow_nan => true), scope: @scope)
           @logger.warn message
         when :RED, :RED_LOW, :RED_HIGH
           notification = NotificationModel.new(
             time: time_nsec,
             severity: "critical",
             url: "/tools/limitsmonitor",
-            title: "#{packet.target_name} #{packet.packet_name} #{item.name} out of limits",
-            body: "Item went into #{item.limits.state} limit status."
+            title: "#{packet.target_name} #{packet.packet_name} #{item.name} #{item.limits.state}",
+            body: "#{item.name} is #{item.limits.state}"
           )
           NotificationsTopic.write_notification(notification.as_json(:allow_nan => true), scope: @scope)
           @logger.error message

data/lib/openc3/microservices/reaction_microservice.rb

@@ -23,6 +23,7 @@
 require 'openc3/microservices/microservice'
 require 'openc3/models/reaction_model'
 require 'openc3/models/notification_model'
+require 'openc3/topics/notifications_topic'
 require 'openc3/models/trigger_model'
 require 'openc3/topics/autonomic_topic'
 require 'openc3/utilities/authentication'
@@ -30,12 +31,12 @@ require 'openc3/utilities/authentication'
 require 'openc3/script'
 
 module OpenC3
-
-  # This should remain a thread safe implamentation. This is the in memory
+  # This should remain a thread safe implementation. This is the in memory
   # cache that should mirror the database. This will update two hash
   # variables and will track triggers to lookup what triggers link to what
   # reactions.
   class ReactionBase
+    attr_reader :reactions
 
     def initialize(scope:)
       @scope = scope
@@ -45,7 +46,7 @@ module OpenC3
       @lookup = Hash.new
     end
 
-    # RETURNS an Array of active and not snoozed reactions
+    # RETURNS an Array of actively snoozed reactions
     def get_snoozed
       data = nil
       @reactions_mutex.synchronize do
@@ -53,15 +54,15 @@ module OpenC3
       end
       ret = Array.new
       return ret unless data
-      data.each do | _name, r_hash |
+      data.each do |_name, r_hash|
         data = Marshal.load( Marshal.dump(r_hash) )
         reaction = ReactionModel.from_json(data, name: data['name'], scope: data['scope'])
-        ret << reaction if reaction.active && reaction.snoozed_until
+        ret << reaction if reaction.enabled && reaction.snoozed_until
       end
       return ret
     end
 
-    # RETURNS an Array of active and not snoozed reactions
+    # RETURNS an Array of actively NOT snoozed reactions
     def get_reactions(trigger_name:)
       array_value = nil
       @lookup_mutex.synchronize do
@@ -69,26 +70,25 @@ module OpenC3
       end
       ret = Array.new
       return ret unless array_value
-      array_value.each do | name |
+      array_value.each do |name|
         @reactions_mutex.synchronize do
           data = Marshal.load( Marshal.dump(@reactions[name]) )
           reaction = ReactionModel.from_json(data, name: data['name'], scope: data['scope'])
-          ret << reaction if reaction.active && reaction.snoozed_until.nil?
+          ret << reaction if reaction.enabled && reaction.snoozed_until.nil?
         end
       end
       return ret
     end
 
-    # Update the memeory database with a HASH of reactions from the external
-    # database
+    # Update the memory database with a HASH of reactions from the external database
     def setup(reactions:)
       @reactions_mutex.synchronize do
         @reactions = Marshal.load( Marshal.dump(reactions) )
       end
       @lookup_mutex.synchronize do
         @lookup = Hash.new
-        reactions.each do | reaction_name, reaction |
-          reaction['triggers'].each do | trigger |
+        reactions.each do |reaction_name, reaction|
+          reaction['triggers'].each do |trigger|
             trigger_name = trigger['name']
             if @lookup[trigger_name].nil?
               @lookup[trigger_name] = [reaction_name]
@@ -132,7 +132,7 @@ module OpenC3
       @reactions_mutex.synchronize do
         @reactions[reaction_name] = reaction
       end
-      reaction['triggers'].each do | trigger |
+      reaction['triggers'].each do |trigger|
         trigger_name = trigger['name']
         @lookup_mutex.synchronize do
           if @lookup[trigger_name].nil?
@@ -147,30 +147,30 @@ module OpenC3
     # Updates a reaction to the in memory database. This current does not
     # update the lookup Hash for the triggers.
     def update(reaction:)
-      reaction_name = reaction['name']
       @reactions_mutex.synchronize do
-        @reactions[reaction_name] = reaction
+        model = ReactionModel.from_json(reaction, name: reaction['name'], scope: reaction['scope'])
+        model.update()
+        @reactions[reaction['name']] = model.as_json(:allow_nan => true)
       end
     end
 
     # Removes a reaction to the in memory database.
     def remove(reaction:)
-      reaction_name = reaction['name']
       @reactions_mutex.synchronize do
-        @reactions.delete(reaction_name)
+        @reactions.delete(reaction['name'])
+        ReactionModel.delete(name: reaction['name'], scope: reaction['scope'])
       end
-      reaction['triggers'].each do | trigger |
+      reaction['triggers'].each do |trigger|
         trigger_name = trigger['name']
         @lookup_mutex.synchronize do
-          @lookup[trigger_name].delete(reaction_name)
+          @lookup[trigger_name].delete(reaction['name'])
         end
       end
     end
   end
 
-  # This should remain a thread safe implamentation.
+  # This should remain a thread safe implementation.
   class QueueBase
-
     attr_reader :queue
 
     def initialize(scope:)
@@ -182,9 +182,8 @@ module OpenC3
     end
   end
 
-  # This should remain a thread safe implamentation.
+  # This should remain a thread safe implementation.
   class SnoozeBase
-
     def initialize(scope:)
       # store the round robin watch
       @watch_mutex = Mutex.new
@@ -207,7 +206,6 @@ module OpenC3
   # Shared between the monitor thread and the manager thread to
   # share the resources.
   class ReactionShare
-
     attr_reader :reaction_base, :queue_base, :snooze_base
 
     def initialize(scope:)
@@ -215,7 +213,6 @@ module OpenC3
       @queue_base = QueueBase.new(scope: scope)
       @snooze_base = SnoozeBase.new(scope: scope)
     end
-
   end
 
   # The Reaction worker is a very simple thread pool worker. Once the manager
@@ -262,7 +259,7 @@ module OpenC3
           when 'reaction'
             run_reaction(reaction: reaction(data: data))
           when 'trigger'
-            process_enabled_trigger(data: data)
+            process_true_trigger(data: data)
           end
         rescue StandardError => e
           @logger.error "ReactionWorker-#{@ident} failed to evaluate kind: #{kind} data: #{data}\n#{e.formatted}"
@@ -271,8 +268,8 @@ module OpenC3
       @logger.info "ReactionWorker-#{@ident} exiting"
     end
 
-    def process_enabled_trigger(data:)
-      @share.reaction_base.get_reactions(trigger_name: data['name']).each do | reaction |
+    def process_true_trigger(data:)
+      @share.reaction_base.get_reactions(trigger_name: data['name']).each do |reaction|
         run_reaction(reaction: reaction)
       end
     end
@@ -285,7 +282,21 @@ module OpenC3
     end
 
     def run_action(reaction:, action:)
+      reaction.updated_at = Time.now.to_nsec_from_epoch
+      reaction_json = reaction.as_json(:allow_nan => true)
+      # Let the frontend know which action is being run
+      # because we can combine commands and scripts with notifications
+      reaction_json['action'] = action['type']
+      notification = {
+        'kind' => 'run',
+        'type' => 'reaction',
+        'data' => JSON.generate(reaction_json),
+      }
+      AutonomicTopic.write_notification(notification, scope: @scope)
+
       case action['type']
+      when 'notify'
+        run_notify(reaction: reaction, action: action)
       when 'command'
         run_command(reaction: reaction, action: action)
       when 'script'
@@ -293,21 +304,31 @@ module OpenC3
       end
     end
 
+    def run_notify(reaction:, action:)
+      notification = NotificationModel.new(
+        time: Time.now.to_nsec_from_epoch,
+        severity: action['severity'],
+        url: "/tools/autonomic/reactions",
+        title: "#{reaction.name} run",
+        body: action['value']
+      )
+      NotificationsTopic.write_notification(notification.as_json(:allow_nan => true), scope: @scope)
+      @logger.info "ReactionWorker-#{@ident} #{reaction.name} notify action complete, body: #{action['value']}, severity: #{action['severity']}"
+    end
+
     def run_command(reaction:, action:)
-      @logger.debug "ReactionWorker-#{@ident} running reaction #{reaction.name}, command: '#{action['value']}' "
       begin
         username = reaction.username
         token = get_token(username)
         raise "No token available for username: #{username}" unless token
         cmd_no_hazardous_check(action['value'], scope: @scope, token: token)
-        @logger.info "ReactionWorker-#{@ident} #{reaction.name} command action complete, #{action['value']}"
+        @logger.info "ReactionWorker-#{@ident} #{reaction.name} command action complete, command: #{action['value']}"
       rescue StandardError => e
         @logger.error "ReactionWorker-#{@ident} #{reaction.name} command action failed, #{action}\n#{e.message}"
       end
     end
 
     def run_script(reaction:, action:)
-      @logger.debug "ReactionWorker-#{@ident} running reaction #{reaction.name}, script: '#{action['value']}'"
       begin
         username = reaction.username
         token = get_token(username)
@@ -351,7 +372,7 @@ module OpenC3
 
     def generate_thread_pool()
       thread_pool = []
-      @worker_count.times do | i |
+      @worker_count.times do |i|
         worker = ReactionWorker.new(name: @name, logger: @logger, scope: @scope, share: @share, ident: i)
         thread_pool << Thread.new { worker.run }
       end
@@ -376,7 +397,7 @@ module OpenC3
     end
 
     def active_triggers(reaction:)
-      reaction.triggers.each do | trigger |
+      reaction.triggers.each do |trigger|
         t = TriggerModel.get(name: trigger['name'], group: trigger['group'], scope: @scope)
         return true if t && t.state
       end
@@ -384,16 +405,11 @@ module OpenC3
     end
 
     def manage_snoozed_reactions(current_time:)
-      @share.reaction_base.get_snoozed.each do | reaction |
+      @share.reaction_base.get_snoozed.each do |reaction|
         time_difference = reaction.snoozed_until - current_time
         if time_difference <= 0 && @share.snooze_base.not_queued?(reaction: reaction)
-          @logger.info "#{reaction.name} current: #{current_time}, vs #{reaction.snoozed_until}, #{time_difference}"
-          unless reaction.review
-            @logger.debug "#{reaction.name} review set to false, setting snoozed_until back to nil"
-            @share.reaction_base.wake(name: reaction.name)
-            next
-          end
-          if active_triggers(reaction: reaction)
+          # LEVEL triggers mean we run if the trigger is active
+          if reaction.triggerLevel == 'LEVEL' and active_triggers(reaction: reaction)
             @share.queue_base.enqueue(kind: 'reaction', data: reaction.as_json(:allow_nan => true))
           else
             @share.reaction_base.wake(name: reaction.name)
@@ -404,7 +420,7 @@ module OpenC3
 
     def shutdown
       @cancel_thread = true
-      @worker_count.times do | i |
+      @worker_count.times do |i|
         @share.queue_base.enqueue(kind: nil, data: nil)
       end
     end
@@ -415,8 +431,39 @@ module OpenC3
   # AutonomicTopic for changes.
   class ReactionMicroservice < Microservice
     attr_reader :name, :scope, :share, :manager, :manager_thread
+    TOPIC_LOOKUP = {
+      'group' => {
+        'created' => :no_op,
+        'updated' => :no_op,
+        'deleted' => :no_op,
+      },
+      'trigger' => {
+        'error' => :no_op,
+        'created' => :no_op,
+        'updated' => :no_op,
+        'deleted' => :no_op,
+        'enabled' => :no_op,
+        'disabled' => :no_op,
+        'true' => :trigger_true_event,
+        'false' => :no_op,
+      },
+      'reaction' => {
+        'run' => :no_op,
+        'deployed' => :no_op,
+        'undeployed' => :no_op,
+        'created' => :reaction_created_event,
+        'updated' => :reaction_updated_event,
+        'deleted' => :reaction_deleted_event,
+        'enabled' => :reaction_enabled_event,
+        'disabled' => :reaction_disabled_event,
+        'snoozed' => :no_op,
+        'awakened' => :no_op,
+        'executed' => :reaction_execute_event,
+      }
+    }
 
     def initialize(*args)
+      # The name is passed in via the reaction_model as "#{scope}__OPENC3__REACTION"
       super(*args)
       @share = ReactionShare.new(scope: @scope)
       @manager = ReactionSnoozeManager.new(name: @name, logger: @logger, scope: @scope, share: @share)
@@ -426,53 +473,36 @@ module OpenC3
 
     def run
       @logger.info "ReactionMicroservice running"
+      # Let the frontend know that the microservice has been deployed and is running
+      notification = {
+        'kind' => 'deployed',
+        'type' => 'reaction',
+        # name and updated_at fields are required for Event formatting
+        'data' => JSON.generate({
+          'name' => @name,
+          'updated_at' => Time.now.to_nsec_from_epoch,
+        }),
+      }
+      AutonomicTopic.write_notification(notification, scope: @scope)
+
       @manager_thread = Thread.new { @manager.run }
       loop do
         reactions = ReactionModel.all(scope: @scope)
         @share.reaction_base.setup(reactions: reactions)
         break if @cancel_thread
-
         block_for_updates()
         break if @cancel_thread
       end
       @logger.info "ReactionMicroservice exiting"
     end
 
-    def topic_lookup_functions
-      return {
-        'group' => {
-          'created' => :no_op,
-          'updated' => :no_op,
-          'deleted' => :no_op,
-        },
-        'trigger' => {
-          'created' => :no_op,
-          'updated' => :no_op,
-          'deleted' => :no_op,
-          'enabled' => :trigger_enabled_event,
-          'disabled' => :no_op,
-          'activated' => :no_op,
-          'deactivated' => :no_op,
-        },
-        'reaction' => {
-          'created' => :reaction_created_event,
-          'updated' => :refresh_event,
-          'deleted' => :reaction_deleted_event,
-          'sleep' => :no_op,
-          'awaken' => :no_op,
-          'activated' => :reaction_updated_event,
-          'deactivated' => :reaction_updated_event,
-        }
-      }
-    end
-
     def block_for_updates
       @read_topic = true
-      while @read_topic
+      while @read_topic && !@cancel_thread
         begin
           AutonomicTopic.read_topics(@topics) do |_topic, _msg_id, msg_hash, _redis|
             @logger.debug "ReactionMicroservice block_for_updates: #{msg_hash.to_s}"
-            public_send(topic_lookup_functions[msg_hash['type']][msg_hash['kind']], msg_hash)
+            public_send(TOPIC_LOOKUP[msg_hash['type']][msg_hash['kind']], msg_hash)
           end
         rescue StandardError => e
           @logger.error "ReactionMicroservice failed to read topics #{@topics}\n#{e.formatted}"
@@ -484,29 +514,70 @@ module OpenC3
       @logger.debug "ReactionMicroservice web socket event: #{data}"
     end
 
-    def refresh_event(data)
-      @logger.debug "ReactionMicroservice web socket schedule refresh: #{data}"
+    def reaction_updated_event(msg_hash)
+      @logger.debug "ReactionMicroservice reaction updated msg_hash: #{msg_hash}"
+      reaction = JSON.parse(msg_hash['data'], :allow_nan => true, :create_additions => true)
+      @share.reaction_base.update(reaction: reaction)
       @read_topic = false
     end
 
-    #
-    def trigger_enabled_event(msg_hash)
-      @logger.debug "ReactionMicroservice trigger event msg_hash: #{msg_hash}"
+    def trigger_true_event(msg_hash)
+      @logger.debug "ReactionMicroservice trigger true msg_hash: #{msg_hash}"
       @share.queue_base.enqueue(kind: 'trigger', data: JSON.parse(msg_hash['data'], :allow_nan => true, :create_additions => true))
     end
 
     # Add the reaction to the shared data.
     def reaction_created_event(msg_hash)
       @logger.debug "ReactionMicroservice reaction created msg_hash: #{msg_hash}"
-      @share.reaction_base.add(reaction: JSON.parse(msg_hash['data'], :allow_nan => true, :create_additions => true))
+      reaction = JSON.parse(msg_hash['data'], :allow_nan => true, :create_additions => true)
+      @share.reaction_base.add(reaction: reaction)
+
+      # If the reaction triggerLevel is LEVEL we have to check its triggers
+      # on add because if the trigger is active it should run
+      if reaction['triggerLevel'] == 'LEVEL'
+        reaction['triggers'].each do |trigger_hash|
+          trigger = TriggerModel.get(name: trigger_hash['name'], group: trigger_hash['group'], scope: reaction['scope'])
+          if trigger && trigger.state
+            @logger.info "ReactionMicroservice reaction #{reaction['name']} created. Since triggerLevel is 'LEVEL' it was run due to #{trigger.name}."
+            @share.queue_base.enqueue(kind: 'reaction', data: reaction)
+          end
+        end
+      end
     end
 
     # Update the reaction to the shared data.
-    def reaction_updated_event(msg_hash)
-      @logger.debug "ReactionMicroservice reaction updated msg_hash: #{msg_hash}"
+    def reaction_enabled_event(msg_hash)
+      @logger.debug "ReactionMicroservice reaction enabled msg_hash: #{msg_hash}"
+      reaction = JSON.parse(msg_hash['data'], :allow_nan => true, :create_additions => true)
+      @share.reaction_base.update(reaction: reaction)
+
+      # If the reaction triggerLevel is LEVEL we have to check its triggers
+      # on add because if the trigger is active it should run
+      if reaction['triggerLevel'] == 'LEVEL'
+        reaction['triggers'].each do |trigger_hash|
+          trigger = TriggerModel.get(name: trigger_hash['name'], group: trigger_hash['group'], scope: reaction['scope'])
+          if trigger && trigger.state
+            @logger.info "ReactionMicroservice reaction #{reaction['name']} enabled. Since triggerLevel is 'LEVEL' it was run due to #{trigger.name}."
+            @share.queue_base.enqueue(kind: 'reaction', data: reaction)
+          end
+        end
+      end
+    end
+
+    # Update the reaction to the shared data.
+    def reaction_disabled_event(msg_hash)
+      @logger.debug "ReactionMicroservice reaction disabled msg_hash: #{msg_hash}"
       @share.reaction_base.update(reaction: JSON.parse(msg_hash['data'], :allow_nan => true, :create_additions => true))
     end
 
+    # Add the reaction to the shared data.
+    def reaction_execute_event(msg_hash)
+      @logger.debug "ReactionMicroservice reaction execute msg_hash: #{msg_hash}"
+      reaction = JSON.parse(msg_hash['data'], :allow_nan => true, :create_additions => true)
+      @share.reaction_base.update(reaction: reaction)
+      @share.queue_base.enqueue(kind: 'reaction', data: reaction)
+    end
+
     # Remove the reaction from the shared data
     def reaction_deleted_event(msg_hash)
       @logger.debug "ReactionMicroservice reaction deleted msg_hash: #{msg_hash}"

data/lib/openc3/microservices/timeline_microservice.rb

@@ -136,7 +136,7 @@ module OpenC3
 
   # Shared between the monitor thread and the manager thread to
   # share the planned activities. This should remain a thread
-  # safe implamentation.
+  # safe implementation.
   class Schedule
     def initialize(name)
       @name = name