openc3 5.8.1 → 5.9.0

data/lib/openc3/migrations/20230615000000_autonomic.rb

@@ -0,0 +1,86 @@
+require 'openc3/utilities/migration'
+require 'openc3/models/trigger_group_model'
+require 'openc3/models/trigger_model'
+require 'openc3/models/reaction_model'
+
+module OpenC3
+  class Autonomic < Migration
+    def self.run
+      ScopeModel.names.each do |scope|
+        puts "Processing scope #{scope}"
+
+        # Update all old TriggerModels just so they work when we delete the ReactionModel
+        # Because the ReactionModel verifies the triggers
+        delete_all_triggers = false
+        groups = TriggerGroupModel.all(scope: scope)
+        groups.each do |key, group_hash|
+          puts "Processing group #{group_hash['name']}"
+          if group_hash.has_key?('color')
+            group_hash.delete('color')
+            group = TriggerGroupModel.from_json(group_hash, name: group_hash['name'], scope: scope)
+            group.update()
+          end
+          TriggerModel.all(group: group_hash['name'], scope: scope).each do |key, model_hash|
+            if model_hash.has_key?('description') or model_hash.has_key?('active')
+              puts "Updating TriggerModel: #{model_hash['name']}"
+              model_hash.delete('description')
+              model_hash.delete('active')
+              model_hash['left'] = {'type' => 'item', 'target' => 'TGT', 'packet' => 'PKT', 'item' => 'ITEM', 'valueType' => 'CONVERTED'}
+              model_hash['operator'] = 'CHANGES'
+              model_hash['right'] = nil
+              TriggerModel.from_json(model_hash, name: model_hash['name'], scope: scope).update()
+              delete_all_triggers = true
+            end
+          end
+        end
+
+        # Remove all old ReactionModels
+        ReactionModel.all(scope: scope).each do |key, model_hash|
+          if model_hash.has_key?('description') or model_hash.has_key?('review') or model_hash.has_key?('active')
+            # Can't delete directly because delete calls get which calls from_json which calls new
+            # and at that point we get missing keyword: :triggerLevel (ArgumentError)
+            # So update to add triggerLevel
+            model_hash['triggerLevel'] = 'EDGE'
+            model_hash.delete('description')
+            model_hash.delete('review')
+            model_hash.delete('active')
+            ReactionModel.from_json(model_hash, name: model_hash['name'], scope: scope).update()
+            puts "Deleting ReactionModel: #{model_hash['name']}"
+            ReactionModel.delete(name: model_hash['name'], scope: scope)
+          end
+        end
+
+        # Remove all old TriggerModels and TriggerGroupModels
+        if delete_all_triggers
+          groups = TriggerGroupModel.all(scope: scope)
+          groups.each do |key, group_hash|
+            TriggerModel.all(group: group_hash['name'], scope: scope).each do |key, trigger_hash|
+              puts "Deleting TriggerModel: #{trigger_hash['name']}"
+              TriggerModel.delete(name: trigger_hash['name'], group: group_hash['name'], scope: scope)
+            end
+            group = TriggerGroupModel.from_json(group_hash, name: group_hash['name'], scope: scope)
+            group.undeploy()
+            puts "Deleting TriggerGroupModel: #{group_hash['name']}"
+            TriggerGroupModel.delete(name: group_hash['name'], scope: scope)
+          end
+        end
+
+        # Create DEFAULT trigger group model
+        model = TriggerGroupModel.get(name: 'DEFAULT', scope: scope)
+        unless model
+          puts "Creating TriggerGroupModel: DEFAULT"
+          model = TriggerGroupModel.new(name: 'DEFAULT', scope: scope)
+          model.create()
+          model.deploy()
+        end
+      end
+    rescue => error
+      puts error.message
+      puts error.backtrace
+    end
+  end
+end
+
+unless ENV['OPENC3_NO_MIGRATE']
+  OpenC3::Autonomic.run
+end

data/lib/openc3/models/activity_model.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 # https://www.rubydoc.info/gems/redis/Redis/Commands/SortedSets
@@ -107,9 +107,7 @@ module OpenC3
     def self.from_json(json, name:, scope:)
       json = JSON.parse(json, :allow_nan => true, :create_additions => true) if String === json
       raise "json data is nil" if json.nil?
-
-      json.transform_keys!(&:to_sym)
-      self.new(**json, name: name, scope: scope)
+      self.new(**json.transform_keys(&:to_sym), name: name, scope: scope)
     end
 
     attr_reader :duration, :start, :stop, :kind, :data, :events, :fulfillment

data/lib/openc3/models/microservice_model.rb

@@ -228,7 +228,9 @@ module OpenC3
         end
       end
       unless validate_only
-        ConfigTopic.write({ kind: 'created', type: 'microservice', name: @name, plugin: @plugin }, scope: @scope)
+        config = { kind: 'created', type: 'microservice', name: @name }
+        config[:plugin] = @plugin if @plugin
+        ConfigTopic.write(config, scope: @scope)
       end
     end
 
@@ -237,7 +239,9 @@ module OpenC3
       @bucket.list_objects(bucket: ENV['OPENC3_CONFIG_BUCKET'], prefix: prefix).each do |object|
         @bucket.delete_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: object.key)
       end
-      ConfigTopic.write({ kind: 'deleted', type: 'microservice', name: @name, plugin: @plugin }, scope: @scope)
+      config = { kind: 'deleted', type: 'microservice', name: @name }
+      config[:plugin] = @plugin if @plugin
+      ConfigTopic.write(config, scope: @scope)
     rescue Exception => error
       Logger.error("Error undeploying microservice model #{@name} in scope #{@scope} due to #{error}")
     end

data/lib/openc3/models/model.rb

@@ -85,10 +85,8 @@ module OpenC3
     def self.from_json(json, scope:)
       json = JSON.parse(json, :allow_nan => true, :create_additions => true) if String === json
       raise "json data is nil" if json.nil?
-
       json[:scope] = scope
-      json.transform_keys!(&:to_sym)
-      self.new(**json, scope: scope)
+      self.new(**json.transform_keys(&:to_sym), scope: scope)
     end
 
     # Calls self.get and then from_json to turn the Hash configuration into a Ruby Model object.

data/lib/openc3/models/reaction_model.rb

@@ -27,47 +27,22 @@ require 'openc3/topics/autonomic_topic'
 
 module OpenC3
   class ReactionError < StandardError; end
-
   class ReactionInputError < ReactionError; end
 
-  #  {
-  #    "description": "POSX greater than 200",
-  #    "snooze": 300,
-  #    "review": true,
-  #    "triggers": [
-  #      {
-  #        "name": "TV0-1234",
-  #        "group": "foo",
-  #      }
-  #    ],
-  #    "actions": [
-  #      {
-  #        "type": "command",
-  #        "value": "INST CLEAR",
-  #      }
-  #    ]
-  #  }
   class ReactionModel < Model
     PRIMARY_KEY = '__openc3__reaction'.freeze
-    COMMAND_REACTION = 'command'.freeze
     SCRIPT_REACTION = 'script'.freeze
-
-    def self.create_mini_id
-      time = (Time.now.to_f * 10_000_000).to_i
-      jitter = rand(10_000_000)
-      key = "#{jitter}#{time}".to_i.to_s(36)
-      return "RV0-#{key}"
-    end
-
-    # @return [Array<ReactionModel>]
-    def self.reactions(scope:)
-      reactions = Array.new
-      Store.hgetall("#{scope}#{PRIMARY_KEY}").each do |key, value|
-        data = JSON.parse(value, :allow_nan => true, :create_additions => true)
-        reaction = self.from_json(data, name: data['name'], scope: data['scope'])
-        reactions << reaction if reaction.active
+    COMMAND_REACTION = 'command'.freeze
+    NOTIFY_REACTION = 'notify'.freeze
+    ACTION_TYPES = [SCRIPT_REACTION, COMMAND_REACTION, NOTIFY_REACTION]
+
+    def self.create_unique_name(scope:)
+      reaction_names = self.names(scope: scope) # comes back sorted
+      num = 1 # Users count with 1
+      if reaction_names[-1]
+        num = reaction_names[-1][5..-1].to_i + 1
       end
-      return reactions
+      return "REACT#{num}"
     end
 
     # @return [ReactionModel] Return the object with the name at
@@ -89,10 +64,10 @@ module OpenC3
     end
 
     # Check dependents before delete.
-    def self.delete(name:, scope:, force: false)
+    def self.delete(name:, scope:)
       model = self.get(name: name, scope: scope)
       if model.nil?
-        raise ReactionInputError.new "failed to find reaction: #{name}"
+        raise ReactionInputError.new "reaction '#{name}' does not exist"
       end
       model.triggers.each do | trigger |
         trigger_model = TriggerModel.get(name: trigger['name'], group: trigger['group'], scope: scope)
@@ -100,29 +75,79 @@ module OpenC3
         trigger_model.update()
       end
       Store.hdel("#{scope}#{PRIMARY_KEY}", name)
-      model.notify(kind: 'deleted')
+      # No notification as this is only called via reaction_controller which already notifies
+
+      # undeploy only actually runs if no reactions are left
+      model.undeploy()
     end
 
-    #
-    def validate_snooze(snooze:)
-      unless snooze.is_a?(Integer)
-        raise ReactionInputError.new "invalid snooze value: #{snooze}"
+    attr_reader :name, :scope, :snooze, :triggers, :actions, :enabled, :triggerLevel, :snoozed_until
+    attr_accessor :username
+
+    def initialize(
+      name:,
+      scope:,
+      snooze:,
+      actions:,
+      triggers:,
+      triggerLevel:,
+      enabled: true,
+      snoozed_until: nil,
+      username: nil,
+      updated_at: nil
+    )
+      super("#{scope}#{PRIMARY_KEY}", name: name, scope: scope)
+      @microservice_name = "#{scope}__OPENC3__REACTION"
+      @enabled = enabled
+      @snoozed_until = snoozed_until
+      @triggerLevel = validate_level(triggerLevel)
+      @snooze = validate_snooze(snooze)
+      @actions = validate_actions(actions)
+      @triggers = validate_triggers(triggers)
+      @username = username
+      @updated_at = updated_at
+    end
+
+    # Modifiers for the reaction_controller update action
+    def triggerLevel=(triggerLevel)
+      @triggerLevel = validate_level(triggerLevel)
+    end
+    def snooze=(snooze)
+      @snooze = validate_snooze(snooze)
+    end
+    def actions=(actions)
+      @actions = validate_actions(actions)
+    end
+    def triggers=(triggers)
+      @triggers = validate_triggers(triggers)
+    end
+
+    def validate_level(level)
+      case level
+      when 'EDGE', 'LEVEL'
+        return level
+      else
+        raise ReactionInputError.new "invalid triggerLevel, must be EDGE or LEVEL: #{level}"
       end
-      return snooze
     end
 
-    #
-    def validate_triggers(triggers:)
+    def validate_snooze(snooze)
+      Integer(snooze)
+    rescue
+      raise ReactionInputError.new "invalid snooze value: #{snooze}"
+    end
+
+    def validate_triggers(triggers)
       unless triggers.is_a?(Array)
-        raise ReactionInputError.new "invalid operator: #{operator}"
+        raise ReactionInputError.new "invalid triggers, must be array of hashes: #{triggers}"
       end
       trigger_hash = Hash.new()
       triggers.each do | trigger |
         unless trigger.is_a?(Hash)
-          raise ReactionInputError.new "invalid trigger object: #{trigger}"
+          raise ReactionInputError.new "invalid trigger, must be hash: #{trigger}"
         end
         if trigger['name'].nil? || trigger['group'].nil?
-          raise ReactionInputError.new "allowed: #{triggers}"
+          raise ReactionInputError.new "invalid trigger, must contain 'name' and 'group' keys: #{trigger}"
         end
         trigger_name = trigger['name']
         unless trigger_hash[trigger_name].nil?
@@ -134,60 +159,27 @@ module OpenC3
       return triggers
     end
 
-    #
-    def validate_actions(actions:)
+    def validate_actions(actions)
       unless actions.is_a?(Array)
-        raise ReactionInputError.new "invalid actions object: #{actions}"
+        raise ReactionInputError.new "invalid actions, must be array of hashes: #{actions}"
       end
       actions.each do | action |
         unless action.is_a?(Hash)
-          raise ReactionInputError.new "invalid action object: #{action}"
+          raise ReactionInputError.new "invalid action, must be a hash: #{action}"
         end
         action_type = action['type']
         if action_type.nil?
-          raise ReactionInputError.new "reaction action must contain type: #{action_type}"
+          raise ReactionInputError.new "invalid action, must contain 'type': #{action}"
         elsif action['value'].nil?
-          raise ReactionInputError.new "reaction action: #{action} does not contain 'value'"
+          raise ReactionInputError.new "invalid action, must contain 'value': #{action}"
         end
-        unless [COMMAND_REACTION, SCRIPT_REACTION].include?(action_type)
-          raise ReactionInputError.new "reaction action contains invalid type: #{action_type}"
+        unless ACTION_TYPES.include?(action_type)
+          raise ReactionInputError.new "invalid action type '#{action_type}', must be one of #{ACTION_TYPES}"
         end
       end
       return actions
     end
 
-    attr_reader :name, :scope, :description, :snooze, :triggers, :actions, :active, :review, :snoozed_until
-    attr_accessor :username
-
-    def initialize(
-      name:,
-      scope:,
-      description:,
-      snooze:,
-      actions:,
-      triggers:,
-      active: true,
-      review: true,
-      snoozed_until: nil,
-      username: nil,
-      updated_at: nil
-    )
-      if name.nil? || scope.nil? || description.nil? || snooze.nil? || triggers.nil? || actions.nil?
-        raise ReactionInputError.new "#{name}, #{scope}, #{description}, #{snooze}, #{triggers}, or #{actions} must not be nil"
-      end
-      super("#{scope}#{PRIMARY_KEY}", name: name, scope: scope)
-      @microservice_name = "#{scope}__OPENC3__REACTION"
-      @active = active
-      @review = review
-      @description = description
-      @snoozed_until = snoozed_until
-      @snooze = validate_snooze(snooze: snooze)
-      @actions = validate_actions(actions: actions)
-      @triggers = validate_triggers(triggers: triggers)
-      @username = username
-      @updated_at = updated_at
-    end
-
     def verify_triggers
       trigger_models = []
       @triggers.each do | trigger |
@@ -208,7 +200,7 @@ module OpenC3
 
     def create
       unless Store.hget(@primary_key, @name).nil?
-        raise ReactionInputError.new "exsisting Reaction found: #{@name}"
+        raise ReactionInputError.new "existing reaction found: #{@name}"
       end
       verify_triggers()
       @updated_at = Time.now.to_nsec_from_epoch
@@ -220,41 +212,43 @@ module OpenC3
       verify_triggers()
       @updated_at = Time.now.to_nsec_from_epoch
       Store.hset(@primary_key, @name, JSON.generate(as_json(:allow_nan => true)))
-      notify(kind: 'updated')
+      # No notification as this is only called via reaction_controller which already notifies
     end
 
-    def activate
-      @active = true
-      @snoozed_until = nil if @snoozed_until && @snoozed_until < Time.now.to_i
-      @updated_at = Time.now.to_nsec_from_epoch
-      Store.hset(@primary_key, @name, JSON.generate(as_json(:allow_nan => true)))
-      notify(kind: 'activated')
+    def notify_enable
+      @enabled = true
+      notify(kind: 'enabled')
+      # update() will be called by the reaction_microservice
+    end
+
+    def notify_disable
+      @enabled = false
+      # disabling clears the snooze so when it's enabled it can immediately run
+      @snoozed_until = nil
+      notify(kind: 'disabled')
+      # update() will be called by the reaction_microservice
     end
 
-    def deactivate
-      @active = false
+    def notify_execute
+      # Set updated_at because the event is all we get ... no update later
       @updated_at = Time.now.to_nsec_from_epoch
-      Store.hset(@primary_key, @name, JSON.generate(as_json(:allow_nan => true)))
-      notify(kind: 'deactivated')
+      notify(kind: 'executed')
     end
 
     def sleep
-      @snoozed_until = Time.now.to_i + @snooze
-      @updated_at = Time.now.to_nsec_from_epoch
-      Store.hset(@primary_key, @name, JSON.generate(as_json(:allow_nan => true)))
-      notify(kind: 'sleep')
+      if @snooze > 0
+        @snoozed_until = Time.now.to_i + @snooze
+        @updated_at = Time.now.to_nsec_from_epoch
+        Store.hset(@primary_key, @name, JSON.generate(as_json(:allow_nan => true)))
+        notify(kind: 'snoozed')
+      end
     end
 
     def awaken
       @snoozed_until = nil
       @updated_at = Time.now.to_nsec_from_epoch
       Store.hset(@primary_key, @name, JSON.generate(as_json(:allow_nan => true)))
-      notify(kind: 'awaken')
-    end
-
-    # @return [String] generated from the TriggerModel
-    def to_s
-      return "(ReactionModel :: #{@name} :: #{@active} :: #{@review} :: #{@description} :: #{@snooze} :: #{@snoozed_until})"
+      notify(kind: 'awakened')
     end
 
     # @return [Hash] generated from the ReactionModel
@@ -262,9 +256,8 @@ module OpenC3
       return {
         'name' => @name,
         'scope' => @scope,
-        'active' => @active,
-        'review' => @review,
-        'description' => @description,
+        'enabled' => @enabled,
+        'triggerLevel' => @triggerLevel,
         'snooze' => @snooze,
         'snoozed_until' => @snoozed_until,
         'triggers' => @triggers,
@@ -278,9 +271,7 @@ module OpenC3
     def self.from_json(json, name:, scope:)
       json = JSON.parse(json, :allow_nan => true, :create_additions => true) if String === json
       raise "json data is nil" if json.nil?
-
-      json.transform_keys!(&:to_sym)
-      self.new(**json, name: name, scope: scope)
+      self.new(**json.transform_keys(&:to_sym), name: name, scope: scope)
     end
 
     # @return [] update the redis stream / reaction topic that something has changed
@@ -317,9 +308,23 @@ module OpenC3
     end
 
     def undeploy
-      if ReactionModel.names(scope: @scope).empty?
-        model = MicroserviceModel.get_model(name: @microservice_name, scope: @scope)
-        model.destroy if model
+      return unless ReactionModel.names(scope: @scope).empty?
+
+      model = MicroserviceModel.get_model(name: @microservice_name, scope: @scope)
+      if model
+        # Let the frontend know that the microservice is shutting down
+        # Custom event which matches the 'deployed' event in ReactionMicroservice
+        notification = {
+          'kind' => 'undeployed',
+          'type' => 'reaction',
+          # name and updated_at fields are required for Event formatting
+          'data' => JSON.generate({
+            'name' => @microservice_name,
+            'updated_at' => Time.now.to_nsec_from_epoch,
+          }),
+        }
+        AutonomicTopic.write_notification(notification, scope: @scope)
+        model.destroy
       end
     end
   end

data/lib/openc3/models/scope_model.rb

@@ -25,6 +25,7 @@ require 'openc3/models/model'
 require 'openc3/models/plugin_model'
 require 'openc3/models/microservice_model'
 require 'openc3/models/setting_model'
+require 'openc3/models/trigger_group_model'
 
 module OpenC3
   class ScopeModel < Model
@@ -49,9 +50,7 @@ module OpenC3
     def self.from_json(json, scope: nil)
       json = JSON.parse(json, :allow_nan => true, :create_additions => true) if String === json
       raise "json data is nil" if json.nil?
-
-      json.transform_keys!(&:to_sym)
-      self.new(**json, scope: scope)
+      self.new(**json.transform_keys(&:to_sym), scope: scope)
     end
 
     def self.get_model(name:, scope: nil)
@@ -210,6 +209,14 @@ module OpenC3
     def deploy(gem_path, variables)
       seed_database()
 
+      # Create DEFAULT trigger group model
+      model = TriggerGroupModel.get(name: 'DEFAULT', scope: @scope)
+      unless model
+        model = TriggerGroupModel.new(name: 'DEFAULT', scope: @scope)
+        model.create()
+        model.deploy()
+      end
+
       # Create UNKNOWN target for display of unknown data
       model = TargetModel.new(name: "UNKNOWN", scope: @scope)
       model.create
@@ -250,11 +257,16 @@ module OpenC3
       model.destroy if model
       model = MicroserviceModel.get_model(name: "#{@scope}__PERIODIC__#{@scope}", scope: @scope)
       model.destroy if model
+      model = MicroserviceModel.get_model(name: "#{@scope}__TRIGGER_GROUP__DEFAULT", scope: @scope)
+      model.destroy if model
+
       # Delete the topics we created for the scope
       Topic.del("#{@scope}__COMMAND__{UNKNOWN}__UNKNOWN")
       Topic.del("#{@scope}__TELEMETRY__{UNKNOWN}__UNKNOWN")
       Topic.del("#{@scope}__openc3_targets")
       Topic.del("#{@scope}__CONFIG")
+      Topic.del("#{@scope}__openc3_autonomic")
+      Topic.del("#{@scope}__TRIGGER__GROUP")
     end
 
     def seed_database

data/lib/openc3/models/timeline_model.rb

@@ -71,9 +71,7 @@ module OpenC3
     def self.from_json(json, name:, scope:)
       json = JSON.parse(json, :allow_nan => true, :create_additions => true) if String === json
       raise "json data is nil" if json.nil?
-
-      json.transform_keys!(&:to_sym)
-      self.new(**json, name: name, scope: scope)
+      self.new(**json.transform_keys(&:to_sym), name: name, scope: scope)
     end
 
     def initialize(name:, scope:, updated_at: nil, color: nil)