openc3 5.0.6

data/lib/openc3/models/trigger_model.rb

@@ -0,0 +1,330 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/models/model'
+require 'openc3/models/microservice_model'
+require 'openc3/models/target_model'
+require 'openc3/topics/autonomic_topic'
+
+module OpenC3
+  class TriggerError < StandardError; end
+
+  class TriggerInputError < TriggerError; end
+
+  # INPUT:
+  #  {
+  #    "group": "someGroup",
+  #    "left": {
+  #      "type": "item",
+  #      "target": "INST",
+  #      "packet": "ADCS",
+  #      "item": "POSX",
+  #    },
+  #    "operator": ">",
+  #    "right": {
+  #      "type": "value",
+  #      "value": 690000,
+  #    }
+  #  }
+  class TriggerModel < Model
+    PRIMARY_KEY = '__TRIGGERS__'.freeze
+    ITEM_TYPE = 'item'.freeze
+    LIMIT_TYPE = 'limit'.freeze
+    FLOAT_TYPE = 'float'.freeze
+    STRING_TYPE = 'string'.freeze
+    TRIGGER_TYPE = 'trigger'.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 "TV0-#{key}"
+    end
+
+    # @return [TriggerModel] Return the object with the name at
+    def self.get(name:, group:, scope:)
+      json = super("#{scope}#{PRIMARY_KEY}#{group}", name: name)
+      unless json.nil?
+        self.from_json(json, name: name, scope: scope)
+      end
+    end
+
+    # @return [Array<Hash>] All the Key, Values stored under the name key
+    def self.all(group:, scope:)
+      super("#{scope}#{PRIMARY_KEY}#{group}")
+    end
+
+    # @return [Array<String>] All the uuids stored under the name key
+    def self.names(group:, scope:)
+      super("#{scope}#{PRIMARY_KEY}#{group}")
+    end
+
+    # Check dependents before delete.
+    def self.delete(name:, group:, scope:)
+      model = self.get(name: name, group: group, scope: scope)
+      if model.nil?
+        raise TriggerInputError.new "invalid operation group: #{group} trigger: #{name} not found"
+      end
+      unless model.dependents.empty?
+        raise TriggerError.new "failed to delete #{name} dependents: #{model.dependents}"
+      end
+      model.roots.each do | trigger |
+        trigger_model = self.get(name: trigger, group: group, scope: scope)
+        trigger_model.update_dependents(dependent: name, remove: true)
+        trigger_model.update()
+      end
+      Store.hdel("#{scope}#{PRIMARY_KEY}#{group}", name)
+      model.notify(kind: 'deleted')
+    end
+
+    def validate_operand(operand:)
+      unless operand.is_a?(Hash)
+        raise TriggerInputError.new "invalid operand: #{operand}"
+      end
+      operand_types = [ITEM_TYPE, LIMIT_TYPE, FLOAT_TYPE, STRING_TYPE, TRIGGER_TYPE]
+      unless operand_types.include?(operand['type'])
+        raise TriggerInputError.new "invalid operand type: #{operand['type']} must be of type: #{operand_types}"
+      end
+      if operand[operand['type']].nil?
+        raise TriggerInputError.new "invalid operand must contain type: #{operand}"
+      end
+      case operand['type']
+      when ITEM_TYPE
+        if operand['target'].nil? || operand['packet'].nil? || operand['raw'].nil?
+          raise TriggerInputError.new "invalid operand must contain target, packet, item, and raw: #{operand}"
+        end
+      when TRIGGER_TYPE
+        @roots << operand[operand['type']]
+      end
+      return operand
+    end
+
+    def validate_operator(operator:)
+      unless operator.is_a?(String)
+        raise TriggerInputError.new "invalid operator: #{operator}"
+      end
+      operators = ['>', '<', '>=', '<=']
+      match_operators = ['==', '!=']
+      trigger_operators = ['AND', 'OR']
+      if @roots.empty? && operators.include?(operator)
+        return operator
+      elsif @roots.empty? && match_operators.include?(operator)
+        return operator
+      elsif @roots.size() == 2 && trigger_operators.include?(operator)
+        return operator
+      elsif operators.include?(operator)
+        raise TriggerInputError.new "invalid operator pair: '#{operator}' must be of type: #{trigger_operators}"
+      else
+        raise TriggerInputError.new "invalid operator: '#{operator}' must be of type: #{operators}"
+      end
+    end
+
+    def validate_description(description:)
+      if description.nil?
+        left_type = @left['type']
+        right_type = @right['type']
+        return "#{@left[left_type]} #{@operator} #{@right[right_type]}"
+      end
+      unless description.is_a?(String)
+        raise TriggerInputError.new "invalid description: #{description}"
+      end
+      return description
+    end
+
+    attr_reader :name, :scope, :state, :group, :active, :left, :operator, :right, :dependents, :roots
+
+    #
+    def initialize(
+      name:,
+      scope:,
+      group:,
+      left:,
+      operator:,
+      right:,
+      state: false,
+      active: true,
+      description: nil,
+      dependents: nil,
+      updated_at: nil
+    )
+      if name.nil? || scope.nil? || group.nil? || left.nil? || operator.nil? || right.nil?
+        raise TriggerInputError.new "#{name}, #{scope}, #{group}, #{left}, #{operator}, or #{right} must not be nil"
+      end
+      super("#{scope}#{PRIMARY_KEY}#{group}", name: name, scope: scope)
+      @roots = []
+      @group = group
+      @state = state
+      @active = active
+      @left = validate_operand(operand: left)
+      @right = validate_operand(operand: right)
+      @operator = validate_operator(operator: operator)
+      @description = validate_description(description: description)
+      @dependents = dependents
+      @updated_at = updated_at
+    end
+
+    def verify_triggers
+      unless @group.is_a?(String)
+        raise TriggerInputError.new "invalid group: #{@group}"
+      end
+      selected_group = OpenC3::TriggerGroupModel.get(name: @group, scope: @scope)
+      if selected_group.nil?
+        raise TriggerGroupInputError.new "failed to find group: #{@group}"
+      end
+      @dependents = [] if @dependents.nil?
+      @roots.each do | trigger |
+        model = TriggerModel.get(name: trigger, group: @group, scope: @scope)
+        if model.nil?
+          raise TriggerInputError.new "failed to find dependent trigger: #{trigger}"
+        end
+        if model.group != @group
+          raise TriggerInputError.new "failed group dependent trigger: #{trigger}"
+        end
+        unless model.dependents.include?(@name)
+          model.update_dependents(dependent: @name)
+          model.update()
+        end
+      end
+    end
+
+    def create
+      unless Store.hget(@primary_key, @name).nil?
+        raise TriggerInputError.new "exsisting Trigger found: #{@name}"
+      end
+      verify_triggers()
+      @updated_at = Time.now.to_nsec_from_epoch
+      Store.hset(@primary_key, @name, JSON.generate(as_json(:allow_nan => true)))
+      notify(kind: 'created')
+    end
+
+    def update
+      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')
+    end
+
+    def enable
+      @state = true
+      @updated_at = Time.now.to_nsec_from_epoch
+      Store.hset(@primary_key, @name, JSON.generate(as_json(:allow_nan => true)))
+      notify(kind: 'enabled')
+    end
+
+    def disable
+      @state = false
+      @updated_at = Time.now.to_nsec_from_epoch
+      Store.hset(@primary_key, @name, JSON.generate(as_json(:allow_nan => true)))
+      notify(kind: 'disabled')
+    end
+
+    def activate
+      @active = true
+      @updated_at = Time.now.to_nsec_from_epoch
+      Store.hset(@primary_key, @name, JSON.generate(as_json(:allow_nan => true)))
+      notify(kind: 'activated')
+    end
+
+    def deactivate
+      @active = false
+      @state = false
+      @updated_at = Time.now.to_nsec_from_epoch
+      Store.hset(@primary_key, @name, JSON.generate(as_json(:allow_nan => true)))
+      notify(kind: 'deactivated')
+    end
+
+    def modify
+      raise "TODO"
+    end
+
+    # ["#{@scope}__DECOM__{#{@target}}__#{@packet}"]
+    def generate_topics
+      topics = Hash.new
+      if @left['type'] == ITEM_TYPE
+        topics["#{@scope}__DECOM__{#{left['target']}}__#{left['packet']}"] = 1
+      end
+      if @right['type'] == ITEM_TYPE
+        topics["#{@scope}__DECOM__{#{right['target']}}__#{right['packet']}"] = 1
+      end
+      return topics.keys
+    end
+
+    def update_dependents(dependent:, remove: false)
+      if remove
+        @dependents.delete(dependent)
+      elsif @dependents.index(dependent).nil?
+        @dependents << dependent
+      end
+    end
+
+    # @return [String] generated from the TriggerModel
+    def to_s
+      return "(TriggerModel :: #{@name} :: #{group} :: #{@description})"
+    end
+
+    # @return [Hash] generated from the TriggerModel
+    def as_json(*a)
+      return {
+        'name' => @name,
+        'scope' => @scope,
+        'state' => @state,
+        'active' => @active,
+        'group' => @group,
+        'description' => @description,
+        'dependents' => @dependents,
+        'left' => @left,
+        'operator' => @operator,
+        'right' => @right,
+        'updated_at' => @updated_at,
+      }
+    end
+
+    # @return [TriggerModel] Model generated from the passed JSON
+    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)
+    end
+
+    # @return [] update the redis stream / trigger topic that something has changed
+    def notify(kind:)
+      notification = {
+        'kind' => kind,
+        'type' => 'trigger',
+        'data' => JSON.generate(as_json(:allow_nan => true)),
+      }
+      AutonomicTopic.write_notification(notification, scope: @scope)
+    end
+
+    # @param [String] kind - the status such as "event" or "error"
+    # @param [String] message - an optional message to include in the event
+    def log(kind:, message: nil)
+      notification = {
+        'kind' => kind,
+        'type' => 'log',
+        'time' => Time.now.to_i,
+        'name' => @name,
+      }
+      notification['message'] = message unless message.nil?
+      AutonomicTopic.write_notification(notification, scope: @scope)
+    end
+  end
+end

data/lib/openc3/models/widget_model.rb

@@ -0,0 +1,138 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/top_level'
+require 'openc3/models/model'
+require 'openc3/models/scope_model'
+require 'openc3/utilities/s3'
+
+module OpenC3
+  class WidgetModel < Model
+    PRIMARY_KEY = 'openc3_widgets'
+
+    attr_accessor :name
+    attr_accessor :full_name
+    attr_accessor :filename
+    attr_accessor :s3_key
+    attr_accessor :needs_dependencies
+
+    # NOTE: The following three class methods are used by the ModelController
+    # and are reimplemented to enable various Model class methods to work
+    def self.get(name:, scope: nil)
+      super("#{scope}__#{PRIMARY_KEY}", name: name)
+    end
+
+    def self.names(scope: nil)
+      array = []
+      all(scope: scope).each do |name, _widget|
+        array << name
+      end
+      array
+    end
+
+    def self.all(scope: nil)
+      tools = Store.hgetall("#{scope}__#{PRIMARY_KEY}")
+      tools.each do |key, value|
+        tools[key] = JSON.parse(value, :allow_nan => true, :create_additions => true)
+      end
+      return tools
+    end
+
+    def self.all_scopes
+      result = {}
+      scopes = OpenC3::ScopeModel.all
+      scopes.each do |key, _scope|
+        widgets = all(scope: key)
+        result.merge!(widgets)
+      end
+      result
+    end
+
+    # Called by the PluginModel to allow this class to validate it's top-level keyword: "WIDGET"
+    def self.handle_config(parser, keyword, parameters, plugin: nil, needs_dependencies: false, scope:)
+      case keyword
+      when 'WIDGET'
+        parser.verify_num_parameters(1, 1, "WIDGET <Name>")
+        return self.new(name: parameters[0], plugin: plugin, needs_dependencies: needs_dependencies, scope: scope)
+      else
+        raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Widget: #{keyword} #{parameters.join(" ")}")
+      end
+      return nil
+    end
+
+    def initialize(
+      name:,
+      updated_at: nil,
+      plugin: nil,
+      needs_dependencies: false,
+      scope:
+    )
+      super("#{scope}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at, scope: scope)
+      @full_name = @name.capitalize + 'Widget'
+      @filename = @full_name + '.umd.min.js'
+      @s3_key = 'widgets/' + @full_name + '/' + @filename
+      @needs_dependencies = needs_dependencies
+    end
+
+    def as_json(*a)
+      {
+        'name' => @name,
+        'updated_at' => @updated_at,
+        'plugin' => @plugin,
+        'needs_dependencies' => @needs_dependencies,
+      }
+    end
+
+    def as_config
+      result = "WIDGET \"#{@name}\"\n"
+      result
+    end
+
+    def handle_config(parser, keyword, parameters)
+      raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Widget: #{keyword} #{parameters.join(" ")}")
+    end
+
+    def deploy(gem_path, variables, validate_only: false)
+      # Ensure tools bucket exists
+      OpenC3::S3Utilities.ensure_public_bucket('tools') unless validate_only
+
+      filename = gem_path + "/tools/widgets/" + @full_name + '/' + @filename
+
+      # Load widget file
+      data = File.read(filename, mode: "rb")
+      OpenC3.set_working_dir(File.dirname(filename)) do
+        data = ERB.new(data, trim_mode: "-").result(binding.set_variables(variables)) if data.is_printable?
+      end
+      unless validate_only
+        cache_control = OpenC3::S3Utilities.get_cache_control(@filename)
+        # TODO: support widgets that aren't just a single js file (and its associated map file)
+        rubys3_client = Aws::S3::Client.new
+        rubys3_client.put_object(bucket: 'tools', content_type: 'application/javascript', cache_control: cache_control, key: @s3_key, body: data)
+        data = File.read(filename + '.map', mode: "rb")
+        rubys3_client.put_object(bucket: 'tools', content_type: 'application/json', cache_control: cache_control, key: @s3_key + '.map', body: data)
+      end
+    end
+
+    def undeploy
+      rubys3_client = Aws::S3::Client.new
+      rubys3_client.delete_object(bucket: 'tools', key: @s3_key)
+      rubys3_client.delete_object(bucket: 'tools', key: @s3_key + '.map')
+    end
+  end
+end

data/lib/openc3/operators/microservice_operator.rb

@@ -0,0 +1,128 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3'
+require 'openc3/models/microservice_model'
+require 'openc3/operators/operator'
+require 'redis'
+require 'open3'
+
+module OpenC3
+  # Creates new OperatorProcess objects based on querying the Redis key value store.
+  # Any keys under 'openc3_microservices' will be created into microservices.
+  class MicroserviceOperator < Operator
+    def initialize
+      Logger.microservice_name = "MicroserviceOperator"
+      super
+
+      @microservices = {}
+      @previous_microservices = {}
+      @new_microservices = {}
+      @changed_microservices = {}
+      @removed_microservices = {}
+    end
+
+    def convert_microservice_to_process_definition(microservice_name, microservice_config)
+      process_definition = ["ruby", "plugin_microservice.rb"]
+      work_dir = "/openc3/lib/openc3/microservices"
+      env = microservice_config["env"].dup
+      if microservice_config["needs_dependencies"]
+        env['GEM_HOME'] = '/gems'
+      else
+        env['GEM_HOME'] = nil
+      end
+      env['OPENC3_MICROSERVICE_NAME'] = microservice_name
+      container = microservice_config["container"]
+      scope = microservice_name.split("__")[0]
+      return process_definition, work_dir, env, scope, container
+    end
+
+    def update
+      @previous_microservices = @microservices.dup
+      # Get all the microservice configuration
+      @microservices = MicroserviceModel.all
+
+      # Detect new and changed microservices
+      @new_microservices = {}
+      @changed_microservices = {}
+      @microservices.each do |microservice_name, microservice_config|
+        if @previous_microservices[microservice_name]
+          if @previous_microservices[microservice_name] != microservice_config
+            scope = microservice_name.split("__")[0]
+            Logger.info("Changed microservice detected: #{microservice_name}\nWas: #{@previous_microservices[microservice_name]}\nIs: #{microservice_config}", scope: scope)
+            @changed_microservices[microservice_name] = microservice_config
+          end
+        else
+          scope = microservice_name.split("__")[0]
+          Logger.info("New microservice detected: #{microservice_name}", scope: scope)
+          @new_microservices[microservice_name] = microservice_config
+        end
+      end
+
+      # Detect removed microservices
+      @removed_microservices = {}
+      @previous_microservices.each do |microservice_name, microservice_config|
+        unless @microservices[microservice_name]
+          scope = microservice_name.split("__")[0]
+          Logger.info("Removed microservice detected: #{microservice_name}", scope: scope)
+          @removed_microservices[microservice_name] = microservice_config
+        end
+      end
+
+      # Convert to processes
+      @mutex.synchronize do
+        @new_microservices.each do |microservice_name, microservice_config|
+          cmd_array, work_dir, env, scope, container = convert_microservice_to_process_definition(microservice_name, microservice_config)
+          if cmd_array
+            process = OperatorProcess.new(cmd_array, work_dir: work_dir, env: env, scope: scope, container: container)
+            @new_processes[microservice_name] = process
+            @processes[microservice_name] = process
+          end
+        end
+
+        @changed_microservices.each do |microservice_name, microservice_config|
+          cmd_array, work_dir, env, scope, container = convert_microservice_to_process_definition(microservice_name, microservice_config)
+          if cmd_array
+            process = @processes[microservice_name]
+            if process
+              process.process_definition = cmd_array
+              process.work_dir = work_dir
+              process.new_temp_dir = nil
+              process.env = env
+              @changed_processes[microservice_name] = process
+            else # TODO: How is this even possible?
+              Logger.error("Changed microservice #{microservice_name} does not exist. Creating new...", scope: scope)
+              process = OperatorProcess.new(cmd_array, work_dir: work_dir, env: env, scope: scope, container: container)
+              @new_processes[microservice_name] = process
+              @processes[microservice_name] = process
+            end
+          end
+        end
+
+        @removed_microservices.each do |microservice_name, microservice_config|
+          process = @processes[microservice_name]
+          @processes.delete(microservice_name)
+          @removed_processes[microservice_name] = process
+        end
+      end
+    end
+  end
+end
+
+OpenC3::MicroserviceOperator.run if __FILE__ == $0