openc3 5.0.6

data/lib/openc3/models/timeline_model.rb

@@ -0,0 +1,154 @@
+# 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/activity_model'
+require 'openc3/models/microservice_model'
+require 'openc3/topics/timeline_topic'
+
+module OpenC3
+  class TimelineError < StandardError; end
+
+  class TimelineInputError < TimelineError; end
+
+  class TimelineModel < Model
+    PRIMARY_KEY = 'openc3_timelines'.freeze # MUST be equal to ActivityModel::PRIMARY_KEY without leading __
+    KEY = '__TIMELINE__'.freeze
+
+    # @return [TimelineModel] Return the object with the name at
+    def self.get(name:, scope:)
+      json = super(PRIMARY_KEY, name: "#{scope}#{KEY}#{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
+      super(PRIMARY_KEY)
+    end
+
+    # @return [Array<String>] All the names stored under the name key
+    def self.names
+      super(PRIMARY_KEY)
+    end
+
+    # Remove the sorted set.
+    def self.delete(name:, scope:, force: false)
+      key = "#{scope}__#{PRIMARY_KEY}__#{name}"
+      z = Store.zcard(key)
+      if force == false && z > 0
+        raise TimelineError.new "timeline contains activities, must force remove"
+      end
+
+      Store.multi do |multi|
+        multi.del(key)
+        multi.hdel(PRIMARY_KEY, "#{scope}#{KEY}#{name}")
+      end
+      return name
+    end
+
+    # @return [TimelineModel] Model generated from the passed JSON
+    def self.from_json(json, name:, scope:)
+      json = JSON.parse(json) if String === json
+      raise "json data is nil" if json.nil?
+
+      json.transform_keys!(&:to_sym)
+      self.new(**json, name: name, scope: scope)
+    end
+
+    def initialize(name:, scope:, updated_at: nil, color: nil)
+      if name.nil? || scope.nil?
+        raise TimelineInputError.new "name or scope must not be nil"
+      end
+
+      super(PRIMARY_KEY, name: "#{scope}#{KEY}#{name}", scope: scope)
+      @updated_at = updated_at
+      @timeline_name = name
+      update_color(color: color)
+    end
+
+    def update_color(color: nil)
+      if color.nil?
+        color = '#%06x' % (rand * 0xffffff)
+      end
+      valid_color = color =~ /(#*)([0-9,a-f,A-f]{6})/
+      if valid_color.nil?
+        raise RuntimeError.new "invalid color but in hex format. #FF0000"
+      end
+
+      unless color.start_with?('#')
+        color = "##{color}"
+      end
+      @color = color
+    end
+
+    # @return [Hash] generated from the TimelineModel
+    def as_json(*a)
+      {
+        'name' => @timeline_name,
+        'color' => @color,
+        'scope' => @scope,
+        'updated_at' => @updated_at
+      }
+    end
+
+    # @return [] update the redis stream / timeline topic that something has changed
+    def notify(kind:)
+      notification = {
+        'data' => JSON.generate(as_json(:allow_nan => true)),
+        'kind' => kind,
+        'type' => 'timeline',
+        'timeline' => @timeline_name
+      }
+      begin
+        TimelineTopic.write_activity(notification, scope: @scope)
+      rescue StandardError => e
+        raise TimelineInputError.new "Failed to write to stream: #{notification}, #{e}"
+      end
+    end
+
+    def deploy
+      topics = ["#{@scope}__#{PRIMARY_KEY}"]
+      TimelineTopic.initialize_streams(topics)
+      # Timeline Microservice
+      microservice = MicroserviceModel.new(
+        name: @name,
+        folder_name: nil,
+        cmd: ['ruby', 'timeline_microservice.rb', @name],
+        work_dir: '/openc3/lib/openc3/microservices',
+        options: [],
+        topics: topics,
+        target_names: [],
+        plugin: nil,
+        scope: @scope
+      )
+      microservice.create
+      notify(kind: 'created')
+    end
+
+    def undeploy
+      model = MicroserviceModel.get_model(name: @name, scope: @scope)
+      if model
+        model.destroy
+        notify(kind: 'deleted')
+      end
+    end
+  end
+end

data/lib/openc3/models/tool_config_model.rb

@@ -0,0 +1,38 @@
+# 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
+
+module OpenC3
+  class ToolConfigModel
+    def self.list_configs(tool, scope: $openc3_scope)
+      Store.hkeys("#{scope}__config__#{tool}")
+    end
+
+    def self.load_config(tool, name, scope: $openc3_scope)
+      Store.hget("#{scope}__config__#{tool}", name)
+    end
+
+    def self.save_config(tool, name, data, scope: $openc3_scope)
+      Store.hset("#{scope}__config__#{tool}", name, data)
+    end
+
+    def self.delete_config(tool, name, scope: $openc3_scope)
+      Store.hdel("#{scope}__config__#{tool}", name)
+    end
+  end
+end

data/lib/openc3/models/tool_model.rb

@@ -0,0 +1,262 @@
+# 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/scope_model'
+require 'openc3/utilities/s3'
+require 'rack'
+
+module OpenC3
+  class ToolModel < Model
+    PRIMARY_KEY = 'openc3_tools'
+
+    attr_accessor :folder_name
+    attr_accessor :icon
+    attr_accessor :url
+    attr_accessor :inline_url
+    attr_accessor :window
+    attr_accessor :category
+    attr_accessor :shown
+    attr_accessor :position
+    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, _tool|
+        array << name
+      end
+      array
+    end
+
+    def self.all(scope: nil)
+      ordered_array = []
+      tools = unordered_all(scope: scope)
+      tools.each do |_name, tool|
+        ordered_array << tool
+      end
+      ordered_array.sort! { |a, b| a['position'] <=> b['position'] }
+      ordered_hash = {}
+      ordered_array.each do |tool|
+        ordered_hash[tool['name']] = tool
+      end
+      ordered_hash
+    end
+
+    def self.all_scopes
+      result = {}
+      scopes = OpenC3::ScopeModel.all
+      scopes.each do |key, _scope|
+        tools = unordered_all(scope: key)
+        result.merge!(tools)
+      end
+      result
+    end
+
+    # Called by the PluginModel to allow this class to validate it's top-level keyword: "TOOL"
+    def self.handle_config(parser, keyword, parameters, plugin: nil, needs_dependencies: false, scope:)
+      case keyword
+      when 'TOOL'
+        parser.verify_num_parameters(2, 2, "TOOL <Folder Name> <Name>")
+        return self.new(folder_name: parameters[0], name: parameters[1], plugin: plugin, needs_dependencies: needs_dependencies, scope: scope)
+      else
+        raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Tool: #{keyword} #{parameters.join(" ")}")
+      end
+      return nil
+    end
+
+    # The ToolsTab.vue calls the ToolsController which uses this method to reorder the tools
+    # Position is index in the list starting with 0 = first
+    def self.set_position(name:, position:, scope:)
+      position = Integer(position)
+      next_position = position + 1
+
+      # Go through all the tools and reorder
+      all(scope: scope).each do |_tool_name, tool|
+        tool_model = from_json(tool, scope: scope)
+        # Update the requested model to the new position
+        if tool_model.name == name
+          tool_model.position = position
+        # Move existing tools down in the order
+        elsif position > 0 && position >= tool_model.position
+          tool_model.position -= 1
+        else # Move existing tools up in the order
+          tool_model.position = next_position
+          next_position += 1
+        end
+        tool_model.update
+      end
+    end
+
+    def initialize(
+      name:,
+      folder_name: nil,
+      icon: '$astro-caution',
+      url: nil,
+      inline_url: nil,
+      window: 'INLINE',
+      category: nil,
+      shown: true,
+      position: nil,
+      updated_at: nil,
+      plugin: nil,
+      needs_dependencies: false,
+      scope:
+    )
+      super("#{scope}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at, scope: scope)
+      @folder_name = folder_name
+      @icon = icon
+      @url = url
+      @inline_url = inline_url
+      @window = window.to_s.upcase
+      @category = category
+      @shown = shown
+      @position = position
+
+      if @shown and @window == 'INLINE'
+        @inline_url = 'js/app.js' unless @inline_url
+        @url = "/tools/#{folder_name}" unless @url
+      end
+      @needs_dependencies = needs_dependencies
+    end
+
+    def create(update: false, force: false)
+      unless @position
+        tools = self.class.all(scope: @scope)
+        _, tool = tools.max_by { |_tool_name, tool| tool['position'] }
+        if tool
+          @position = tool['position'] + 1
+        else
+          @position = 0
+        end
+      end
+      super(update: update, force: force)
+    end
+
+    def as_json(*a)
+      {
+        'name' => @name,
+        'folder_name' => @folder_name,
+        'icon' => @icon,
+        'url' => @url,
+        'inline_url' => @inline_url,
+        'window' => @window,
+        'category' => @category,
+        'shown' => @shown,
+        'position' => @position,
+        'updated_at' => @updated_at,
+        'plugin' => @plugin,
+        'needs_dependencies' => @needs_dependencies,
+      }
+    end
+
+    def as_config
+      result = "TOOL #{@folder_name ? @folder_name : 'nil'} \"#{@name}\"\n"
+      result << "  URL #{@url}\n" if @url
+      result << "  INLINE_URL #{@inline_url}\n" if @inline_url
+      result << "  ICON #{@icon}\n" if @icon
+      result << "  WINDOW #{@window}\n" unless @window == 'INLINE'
+      result << "  CATEGORY #{@category}\n" if @category
+      result << "  SHOWN false\n" unless @shown
+      result
+    end
+
+    def handle_config(parser, keyword, parameters)
+      case keyword
+      when 'URL'
+        parser.verify_num_parameters(1, 1, "URL <URL>")
+        @url = parameters[0]
+      when 'INLINE_URL'
+        parser.verify_num_parameters(1, 1, "INLINE_URL <URL>")
+        @inline_url = parameters[0]
+      when 'ICON'
+        parser.verify_num_parameters(1, 1, "ICON <ICON Name>")
+        @icon = parameters[0]
+      when 'WINDOW'
+        parser.verify_num_parameters(1, 1, "WINDOW <INLINE | IFRAME | NEW>")
+        @window = parameters[0].to_s.upcase
+        raise ConfigParser::Error.new(parser, "Invalid WINDOW setting: #{@window}") unless ['INLINE', 'IFRAME', 'NEW'].include?(@window)
+      when 'CATEGORY'
+        parser.verify_num_parameters(1, 1, "CATEGORY <Category Name>")
+        @category = parameters[0].to_s
+      when 'SHOWN'
+        parser.verify_num_parameters(1, 1, "SHOWN <true/false>")
+        @shown = ConfigParser.handle_true_false(parameters[0])
+      else
+        raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Tool: #{keyword} #{parameters.join(" ")}")
+      end
+      return nil
+    end
+
+    def deploy(gem_path, variables, validate_only: false)
+      return unless @folder_name
+
+      # Ensure tools bucket exists
+      OpenC3::S3Utilities.ensure_public_bucket('tools') unless validate_only
+
+      variables["tool_name"] = @name
+      start_path = "/tools/#{@folder_name}/"
+      Dir.glob(gem_path + start_path + "**/*") do |filename|
+        next if filename == '.' or filename == '..' or File.directory?(filename)
+
+        key = filename.split(gem_path + '/tools/')[-1]
+        extension = filename.split('.')[-1]
+        content_type = Rack::Mime.mime_type(".#{extension}")
+
+        # Load tool files
+        data = File.read(filename, mode: "rb")
+        data = ERB.new(data, trim_mode: "-").result(binding.set_variables(variables)) if data.is_printable?
+        unless validate_only
+          cache_control = OpenC3::S3Utilities.get_cache_control(filename)
+          Aws::S3::Client.new.put_object(bucket: 'tools', content_type: content_type, cache_control: cache_control, key: key, body: data)
+          ConfigTopic.write({ kind: 'created', type: 'tool', name: @folder_name, plugin: @plugin }, scope: @scope)
+        end
+      end
+    end
+
+    def undeploy
+      if @folder_name and @folder_name.to_s.length > 0
+        rubys3_client = Aws::S3::Client.new
+        prefix = "#{@folder_name}/"
+        rubys3_client.list_objects(bucket: 'tools', prefix: prefix).contents.each do |object|
+          rubys3_client.delete_object(bucket: 'tools', key: object.key)
+          ConfigTopic.write({ kind: 'deleted', type: 'tool', name: @folder_name, plugin: @plugin }, scope: @scope)
+        end
+      end
+    end
+
+    ##################################################
+    # The following methods are implementation details
+    ##################################################
+
+    # Returns the list of tools or the default OpenC3 tool set if no tools have been created
+    def self.unordered_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
+  end
+end

data/lib/openc3/models/trigger_group_model.rb

@@ -0,0 +1,186 @@
+# 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/topics/autonomic_topic'
+
+module OpenC3
+  class TriggerGroupError < StandardError; end
+
+  class TriggerGroupInputError < TriggerGroupError; end
+
+  # INPUT:
+  #  {
+  #    "name": "FOOBAR",
+  #    "color": "#000000",
+  #  }
+  class TriggerGroupModel < Model
+    PRIMARY_KEY = '__TRIGGER__GROUP'.freeze
+
+    # @return [GroupModel] Return the object with the name at
+    def self.get(name:, scope:)
+      json = super("#{scope}#{PRIMARY_KEY}", 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(scope:)
+      super("#{scope}#{PRIMARY_KEY}")
+    end
+
+    # @return [Array<String>] All the uuids stored under the name key
+    def self.names(scope:)
+      super("#{scope}#{PRIMARY_KEY}")
+    end
+
+    # Check dependents before delete.
+    def self.delete(name:, scope:)
+      model = self.get(name: name, scope: scope)
+      if model.nil?
+        raise TriggerGroupInputError.new "invalid group: #{name} not found"
+      end
+      triggers = TriggerModel.names(scope: scope, group: name)
+      if triggers.empty?
+        Store.hdel("#{scope}#{PRIMARY_KEY}", name)
+        model.notify(kind: 'deleted')
+      else
+        raise TriggerGroupError.new "failed to delete #{name} triggers: #{triggers}"
+      end
+    end
+
+    attr_reader :name, :scope, :color, :updated_at
+
+    def initialize(name:, scope:, color: nil, updated_at: nil)
+      if name.nil? || scope.nil?
+        raise GroupTriggerInputError.new "name, or scope must not be nil"
+      end
+      unless name.is_a?(String)
+        raise TriggerGroupInputError.new "invalid name: '#{name}'"
+      end
+      if name.include?('_')
+        raise TriggerGroupInputError.new "invalid name: '#{name}' can not include an underscore '_'"
+      end
+      super("#{scope}#{PRIMARY_KEY}", name: name, scope: scope)
+      @microservice_name = "#{scope}__TRIGGER_GROUP__#{name}"
+      update_color(color: color)
+      @updated_at = updated_at
+    end
+
+    def update_color(color: nil)
+      if color.nil?
+        color = '#%06x' % (rand * 0xffffff)
+      end
+      valid_color = color =~ /(#*)([0-9,a-f,A-f]{6})/
+      if valid_color.nil?
+        raise TriggerGroupInputError.new "invalid color must be in hex format. #FF0000"
+      end
+
+      unless color.start_with?('#')
+        color = "##{color}"
+      end
+      @color = color
+    end
+
+    def create
+      unless Store.hget(@primary_key, @name).nil?
+        raise TriggerGroupInputError.new "exsisting TriggerGroup found: #{@name}"
+      end
+      @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
+      @updated_at = Time.now.to_nsec_from_epoch
+      Store.hset(@primary_key, @name, JSON.generate(as_json(:allow_nan => true)))
+      notify(kind: 'updated')
+    end
+
+    # @return [String] generated from the TriggerGroupModel
+    def to_s
+      return "(TriggerGroupModel :: #{@name})"
+    end
+
+    # @return [Hash] generated from the TriggerGroupModel
+    def as_json(*a)
+      return {
+        'name' => @name,
+        'scope' => @scope,
+        'color' => @color,
+        'updated_at' => @updated_at,
+      }
+    end
+
+    # @return [TriggerGroupModel] 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:, error: nil)
+      data = as_json(:allow_nan => true)
+      data['error'] = error unless error.nil?
+      notification = {
+        'kind' => kind,
+        'type' => 'group',
+        'data' => JSON.generate(data),
+      }
+      AutonomicTopic.write_notification(notification, scope: @scope)
+    end
+
+    def create_microservice(topics:)
+      # reaction Microservice
+      microservice = MicroserviceModel.new(
+        name: @microservice_name,
+        folder_name: nil,
+        cmd: ['ruby', "trigger_group_microservice.rb", @microservice_name],
+        work_dir: '/openc3/lib/openc3/microservices',
+        options: [],
+        topics: topics,
+        target_names: [],
+        plugin: nil,
+        scope: @scope
+      )
+      microservice.create
+    end
+
+    def deploy
+      topics = ["#{@scope}__openc3_autonomic"]
+      if MicroserviceModel.get_model(name: @microservice_name, scope: @scope).nil?
+        AutonomicTopic.initialize_streams(topics)
+        create_microservice(topics: topics)
+      end
+    end
+
+    def undeploy
+      if TriggerModel.names(scope: scope, group: name).empty?
+        model = MicroserviceModel.get_model(name: @microservice_name, scope: @scope)
+        model.destroy if model
+      end
+    end
+
+  end
+end