openc3 7.2.1 → 7.4.0

data/lib/openc3/models/target_model.rb

@@ -30,6 +30,7 @@ require 'openc3/topics/config_topic'
 require 'openc3/system'
 require 'openc3/utilities/local_mode'
 require 'openc3/utilities/bucket'
+require 'openc3/utilities/target_file'
 require 'openc3/utilities/zip'
 require 'fileutils'
 require 'ostruct'
@@ -50,6 +51,7 @@ module OpenC3
     ERB_EXTENSIONS = %w(.txt .rb .py .json .yaml .yml)
     ITEM_MAP_CACHE_TIMEOUT = 10.0
     PACKET_CACHE_TIMEOUT = 10.0
+    MAX_COLUMN_HEADER_LENGTH = 127 # QuestDB column header limit for item/param names
     @@item_map_cache = {}
     @@packet_cache = {}
     @@packet_cache_mutex = Mutex.new
@@ -76,6 +78,7 @@ module OpenC3
     attr_accessor :tlm_log_retain_time
     attr_accessor :cmd_decom_retain_time
     attr_accessor :tlm_decom_retain_time
+    attr_accessor :decom_flush_period
     attr_accessor :cleanup_poll_time
     attr_accessor :needs_dependencies
     attr_accessor :target_microservices
@@ -103,49 +106,123 @@ module OpenC3
       targets = self.all(scope: scope)
       targets.each { |_target_name, target| target['modified'] = false }
 
+      modified_targets = []
       if ENV['OPENC3_LOCAL_MODE']
-        modified_targets = OpenC3::LocalMode.modified_targets(scope: scope)
-        modified_targets.each do |target_name|
-          targets[target_name]['modified'] = true if targets[target_name]
-        end
-      else
-        modified_targets = Bucket.getClient().list_files(bucket: ENV['OPENC3_CONFIG_BUCKET'], path: "DEFAULT/targets_modified/", only_directories: true)
-        modified_targets.each do |target_name|
-          # A target could have been deleted without removing the modified files
-          # Thus we have to check for the existence of the target_name key
-          if targets.has_key?(target_name)
-            targets[target_name]['modified'] = true
-          end
-        end
+        modified_targets += OpenC3::LocalMode.modified_targets(scope: scope)
+      end
+      # Always list the bucket, even in local mode, since the local directory
+      # only holds what COSMOS itself wrote there
+      modified_targets += Bucket.getClient().list_files(bucket: ENV['OPENC3_CONFIG_BUCKET'], path: "#{scope}/targets_modified/", only_directories: true)
+      modified_targets.each do |target_name|
+        # A target could have been deleted without removing the modified files
+        # Thus we have to check for the existence of the target_name key
+        targets[target_name]['modified'] = true if targets[target_name]
       end
       # Sort (which turns hash to array) and return hash
       # This enables a consistent listing of the targets
       targets.sort.to_h
     end
 
+    # Splits a plugin instance name ("openc3-cosmos-demo-7.2.0.gem__0") into
+    # [base_name, version] (["openc3-cosmos-demo", "7.2.0"]), or nil when the
+    # name doesn't carry a version segment. Drops the "__N" install-instance
+    # suffix and the ".gem" extension first.
+    def self.plugin_name_version(plugin_instance)
+      return nil if plugin_instance.nil? || plugin_instance.empty?
+      gem = plugin_instance.split('__')[0].sub(/\.gem\z/, '')
+      parts = gem.split('-')
+      return nil if parts.length < 2
+      [parts[0..-2].join('-'), parts[-1]]
+    end
+
+    # "name version" of the plugin that installed this target (e.g.
+    # "openc3-cosmos-demo 7.2.0"), derived from the plugin instance name
+    # ("openc3-cosmos-demo-7.2.0.gem__0"), or nil if unavailable. Used to
+    # annotate the Version History baseline with the file's origin.
+    def self.plugin_version_label(target_name, scope:)
+      model = get(name: target_name, scope: scope)
+      name, version = plugin_name_version(model && model['plugin'])
+      return nil unless name
+      "#{name} #{version}"
+    rescue
+      nil
+    end
+
+    # Version-stripped plugin base name that owns this target, e.g.
+    # "openc3-cosmos-demo" from instance "openc3-cosmos-demo-7.2.0.gem__0".
+    # Used as the per-plugin Version History repo key: stable across upgrades
+    # (only the version segment changes), so history survives version bumps.
+    # Returns nil when the target has no owning plugin (e.g. a hand-created
+    # target); callers fall back to a no-plugin bucket.
+    def self.plugin_base_name(target_name, scope:)
+      model = get(name: target_name, scope: scope)
+      name, _version = plugin_name_version(model && model['plugin'])
+      name
+    rescue
+      nil
+    end
+
+    # Uninstall-only: remove a plugin's entire Version History repo. Called
+    # from the CLI uninstall path with the plugin instance name; upgrade reuses
+    # the repo and must never call this. No-op in Core builds (or whenever
+    # OPENC3_VERSION_HISTORY_DIR is unset) since VersionStore is absent or
+    # disabled. Best-effort: a failure here must not abort the uninstall.
+    def self.destroy_script_versions(plugin_instance_name, scope:)
+      name, _version = plugin_name_version(plugin_instance_name)
+      return unless name
+      begin
+        require 'openc3-enterprise/utilities/version_store'
+      rescue LoadError
+        return
+      end
+      ::VersionStore.destroy_repo(scope: scope, plugin: name)
+    rescue => e
+      Logger.warn("destroy_script_versions failed for #{scope}/#{plugin_instance_name}: #{e.message}")
+    end
+
     # Given target's modified file list
+    # Returns the modified files as names relative to the scope,
+    # i.e. "INST/procedures/new.rb"
     def self.modified_files(target_name, scope:)
       modified = []
 
       if ENV['OPENC3_LOCAL_MODE']
-        modified = OpenC3::LocalMode.modified_files(target_name, scope: scope)
-      else
-        resp = Bucket.getClient().list_objects(
-          bucket: ENV['OPENC3_CONFIG_BUCKET'],
-          # The trailing slash is important!
-          prefix: "#{scope}/targets_modified/#{target_name}/",
-        )
-        resp.each do |item|
-          # Results look like DEFAULT/targets_modified/INST/procedures/new.rb
-          # so split on '/' and ignore the first two values
-          modified << item.key.split('/')[2..-1].join('/')
+        # LocalMode reports target relative paths, i.e. "procedures/new.rb",
+        # so add the target name to match the bucket listing below
+        modified += OpenC3::LocalMode.modified_files(target_name, scope: scope).map do |file_path|
+          "#{target_name}/#{file_path}"
         end
       end
+      # Always list the bucket, even in local mode. The local directory only
+      # holds what COSMOS itself wrote there, so a file placed directly in the
+      # bucket is modified but has no local copy.
+      resp = Bucket.getClient().list_objects(
+        bucket: ENV['OPENC3_CONFIG_BUCKET'],
+        # The trailing slash is important!
+        prefix: "#{scope}/targets_modified/#{target_name}/",
+      )
+      resp.each do |item|
+        # Results look like DEFAULT/targets_modified/INST/procedures/new.rb
+        # so split on '/' and ignore the first two values
+        modified << item.key.split('/')[2..-1].join('/')
+      end
       # Sort to enable a consistent listing of the modified files
-      modified.sort
+      modified.uniq.sort
     end
 
-    def self.delete_modified(target_name, scope:)
+    # files: optional list of specific modified files to delete, each a name
+    # relative to scope ("TARGET/sub/path", matching modified_files output).
+    # When given, only those files are removed (used by plugin upgrade to drop
+    # some modified files while keeping others); when nil, every modified file
+    # for the target is removed (the original behavior).
+    def self.delete_modified(target_name, scope:, files: nil)
+      if files && !files.empty?
+        files.each do |name|
+          # TargetFile.destroy handles both local mode and the bucket.
+          OpenC3::TargetFile.destroy(scope, name)
+        end
+        return
+      end
       if ENV['OPENC3_LOCAL_MODE']
         OpenC3::LocalMode.delete_modified(target_name, scope: scope)
       end
@@ -224,7 +301,7 @@ module OpenC3
 
       # Assume it exists and just try to get it to avoid an extra call to Store.exist?
       json = store_for_target(target_name, scope: scope).hget("#{scope}__openc3#{type.to_s.downcase}__#{target_name}", packet_name)
-      raise "Packet '#{target_name} #{packet_name}' does not exist" if json.nil?
+      raise "Packet definition '#{target_name} #{packet_name}' does not exist" if json.nil?
 
       packet = JSON.parse(json, allow_nan: true, create_additions: true)
 
@@ -245,7 +322,7 @@ module OpenC3
     # @return [Array<Hash>] All packet hashes under the target_name
     def self.packets(target_name, type: :TLM, scope:)
       raise "Unknown type #{type} for #{target_name}" unless VALID_TYPES.include?(type)
-      raise "Target '#{target_name}' does not exist for scope: #{scope}" unless get(name: target_name, scope: scope)
+      raise "Target '#{target_name}' does not exist for scope: #{scope} (TargetModel)" unless get(name: target_name, scope: scope)
 
       result = []
       packets = store_for_target(target_name, scope: scope).hgetall("#{scope}__openc3#{type.to_s.downcase}__#{target_name}")
@@ -281,7 +358,7 @@ module OpenC3
     def self.packet_item(target_name, packet_name, item_name, type: :TLM, scope:)
       packet = packet(target_name, packet_name, type: type, scope: scope)
       item = packet['items'].find { |item| item['name'] == item_name.to_s }
-      raise "Item '#{packet['target_name']} #{packet['packet_name']} #{item_name}' does not exist" unless item
+      raise "Item '#{packet['target_name']} #{packet['packet_name']} #{item_name}' does not exist (TargetModel)" unless item
       item
     end
 
@@ -400,6 +477,7 @@ module OpenC3
       tlm_log_retain_time: nil,
       cmd_decom_retain_time: nil,
       tlm_decom_retain_time: nil,
+      decom_flush_period: 5.0,
       cleanup_poll_time: 3600,
       needs_dependencies: false,
       target_microservices: {},
@@ -428,6 +506,7 @@ module OpenC3
       @tlm_log_retain_time = tlm_log_retain_time
       @cmd_decom_retain_time = cmd_decom_retain_time
       @tlm_decom_retain_time = tlm_decom_retain_time
+      @decom_flush_period = decom_flush_period
       @cleanup_poll_time = cleanup_poll_time
       @needs_dependencies = needs_dependencies
       @target_microservices = target_microservices
@@ -461,6 +540,7 @@ module OpenC3
         'tlm_log_retain_time' => @tlm_log_retain_time,
         'cmd_decom_retain_time' => @cmd_decom_retain_time,
         'tlm_decom_retain_time' => @tlm_decom_retain_time,
+        'decom_flush_period' => @decom_flush_period,
         'cleanup_poll_time' => @cleanup_poll_time,
         'needs_dependencies' => @needs_dependencies,
         'target_microservices' => @target_microservices.as_json(),
@@ -515,6 +595,9 @@ module OpenC3
         if @tlm_decom_retain_time and !@tlm_decom_retain_time.match?(/^\d+[hdwMy]$/)
           raise ConfigParser::Error.new(parser, "TLM_DECOM_RETAIN_TIME must be a number followed by h, d, w, M, or y (e.g., 24h, 7d, 1y)")
         end
+      when 'DECOM_FLUSH_PERIOD'
+        parser.verify_num_parameters(1, 1, "#{keyword} <Flush period in seconds>")
+        @decom_flush_period = Float(parameters[0])
       when 'REDUCED_MINUTE_LOG_RETAIN_TIME', 'REDUCED_HOUR_LOG_RETAIN_TIME', 'REDUCED_DAY_LOG_RETAIN_TIME', 'REDUCED_LOG_RETAIN_TIME'
         # DEPRECATED
       when 'REDUCER_DISABLE', 'REDUCER_DISABLED', 'REDUCER_MAX_CPU_UTILIZATION', 'REDUCED_MAX_CPU_UTILIZATION'
@@ -576,11 +659,23 @@ module OpenC3
       return nil
     end
 
-    def deploy(gem_path, variables, validate_only: false)
+    # upgrade_context (plugin upgrades only) drives two modes, both keyed by
+    # the deployed file name "TARGET/sub/path" (matches modified_files output):
+    #   { diff_collector: [] } — dry run (with validate_only): append the names
+    #     of modified files whose live content differs from the rendered plugin
+    #     content. Read-only; used to warn before an upgrade.
+    #   { username:, plugin: "name version", version_files: [<name>...] } — for
+    #     each listed file with a modified copy: record the modified copy in
+    #     Version History, drop the shadow so the plugin content becomes current,
+    #     then commit the incoming content as a plugin-upgrade version.
+    # nil (the default and Core builds without VersionStore) = no-op.
+    def deploy(gem_path, variables, validate_only: false, upgrade_context: nil)
       variables["target_name"] = @name
       start_path = "/targets/#{@folder_name}/"
       temp_dir = Dir.mktmpdir
       found = false
+      diff_collector = upgrade_context && upgrade_context[:diff_collector]
+      versioning = !validate_only && upgrade_context && upgrade_context[:version_files] && version_store_available?
       begin
         target_path = gem_path + start_path + "**/*"
         Dir.glob(target_path) do |filename|
@@ -616,15 +711,30 @@ module OpenC3
           File.open(local_path, 'wb') { |file| file.write(data) }
           found = true
           @bucket.put_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: key, body: data) unless validate_only
+
+          # Plugin upgrade: either collect this file into the diff (dry run) or
+          # take it from the plugin while preserving the modified copy in
+          # Version History. Both skip files with no modified copy.
+          name = "#{@name}/#{target_folder_path}"
+          if diff_collector
+            collect_modified_diff(name, data, diff_collector)
+          elsif versioning && upgrade_context[:version_files].include?(name)
+            apply_upgrade_version(name, data, upgrade_context)
+          end
         end
         raise "No target files found at #{target_path}" unless found
 
         target_folder = File.join(temp_dir, @name)
         # Build a System for just this target
         system = System.new([@name], temp_dir)
+        check_column_header_lengths(system)
         if variables["xtce_output"]
           puts "Converting target #{@name} to .xtce files in #{variables["xtce_output"]}/#{@name}"
-          puts "    Using mnemonic '#{variables['time_association_name']}' as the packet time item."
+          if variables['time_association_name'].to_s.empty?
+            puts "    No packet time item given, so no TimeAssociation will be written."
+          else
+            puts "    Using mnemonic '#{variables['time_association_name']}' as the packet time item."
+          end
           system.packet_config.to_xtce(variables["xtce_output"], variables['time_association_name'])
         end
         unless validate_only
@@ -638,6 +748,74 @@ module OpenC3
       end
     end
 
+    # Version History is an Enterprise feature. The plugin deploy runs in the
+    # cmd-tlm-api process, which (unlike script-runner-api) doesn't otherwise
+    # require the store, so lazily load it on demand. Returns false in Core
+    # builds where the Enterprise gem isn't present.
+    def version_store_available?
+      return true if defined?(::VersionStore)
+      require 'openc3-enterprise/utilities/version_store'
+      defined?(::VersionStore) ? true : false
+    rescue LoadError
+      false
+    end
+
+    # See deploy/upgrade_context. Reads the modified shadow directly (not
+    # TargetFile.body, which would fall back to the just-overwritten pristine
+    # copy), commits it, removes it, then commits the incoming plugin content.
+    # Best-effort: a versioning failure must not abort the plugin upgrade.
+    def apply_upgrade_version(name, new_data, ctx)
+      modified_key = "#{@scope}/targets_modified/#{name}"
+      resp = @bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: modified_key)
+      return unless resp && resp.body
+      old_body = resp.body.read
+      # Nothing actually changed — the modification already matches the plugin.
+      # Leave the (identical) shadow in place and create no version churn.
+      return if old_body.b == new_data.b
+      old_body = old_body.force_encoding('UTF-8') unless File.extname(name) == '.bin'
+      # Preserve the pre-upgrade (user-modified) content as a version.
+      # Idempotent: a no-op when it already matches the latest version.
+      ::VersionStore.commit(scope: @scope, name: name, text: old_body)
+      # Drop the modified shadow so the plugin file (already written to
+      # targets/) becomes the live content.
+      OpenC3::TargetFile.destroy(@scope, name)
+      # Commit the incoming plugin content as a plugin-upgrade version,
+      # attributed to the installing user.
+      ::VersionStore.commit(scope: @scope, name: name, text: new_data,
+        username: ctx[:username], source: 'plugin-upgrade', plugin: ctx[:plugin])
+    rescue => e
+      Logger.warn("Version History upgrade capture failed for #{@scope}/#{name}: #{e.message}")
+    end
+
+    # Dry-run companion to apply_upgrade_version: append name to collector when
+    # a modified copy exists and differs (by bytes) from the rendered plugin
+    # content. Read-only.
+    def collect_modified_diff(name, new_data, collector)
+      resp = @bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: "#{@scope}/targets_modified/#{name}")
+      return unless resp && resp.body
+      collector << name if resp.body.read.b != new_data.b
+    rescue => e
+      Logger.warn("Modified diff check failed for #{@scope}/#{name}: #{e.message}")
+    end
+
+    def check_column_header_lengths(system)
+      too_long = []
+      [system.packet_config.telemetry, system.packet_config.commands].each do |packets_by_target|
+        packets_by_target.each do |target_name, packets|
+          packets.each do |packet_name, packet|
+            packet.sorted_items.each do |item|
+              if item.name.length > MAX_COLUMN_HEADER_LENGTH
+                too_long << "#{target_name} #{packet_name} #{item.name} (#{item.name.length})"
+              end
+            end
+          end
+        end
+      end
+      unless too_long.empty?
+        raise "Item / parameter names must be #{MAX_COLUMN_HEADER_LENGTH} characters or less (QuestDB column header limit). The following are too long:\n  #{too_long.join("\n  ")}"
+      end
+    end
+
     def undeploy
       prefix = "#{@scope}/targets/#{@name}/"
       objects = @bucket.list_objects(bucket: ENV['OPENC3_CONFIG_BUCKET'], prefix: prefix)
@@ -1032,6 +1210,7 @@ module OpenC3
       options = []
       options << ["CMD_DECOM_RETAIN_TIME", @cmd_decom_retain_time] if @cmd_decom_retain_time
       options << ["TLM_DECOM_RETAIN_TIME", @tlm_decom_retain_time] if @tlm_decom_retain_time
+      options << ["DECOM_FLUSH_PERIOD", @decom_flush_period] if @decom_flush_period
       microservice = MicroserviceModel.new(
         name: microservice_name,
         folder_name: @folder_name,

data/lib/openc3/models/tool_model.rb

@@ -16,6 +16,7 @@
 # if purchased from OpenC3, Inc.
 
 require 'openc3/models/model'
+require 'openc3/topics/config_topic'
 # require 'openc3/models/scope_model' # Circular require
 require 'openc3/utilities/bucket'
 require 'openc3/utilities/bucket_utilities'
@@ -25,6 +26,13 @@ module OpenC3
   class ToolModel < Model
     PRIMARY_KEY = 'openc3_tools'
 
+    # Tools are global to the entire COSMOS installation and are always stored
+    # in the DEFAULT scope. The frontend navigation always requests the tool
+    # list from DEFAULT, so a tool installed into any other scope would be
+    # inaccessible. Every scope parameter in this class is therefore ignored
+    # and replaced with TOOL_SCOPE.
+    TOOL_SCOPE = 'DEFAULT'
+
     attr_accessor :folder_name
     attr_accessor :icon
     attr_accessor :url
@@ -39,21 +47,24 @@ module OpenC3
 
     # NOTE: The following three class methods are used by the ModelController
     # and are reimplemented to enable various Model class methods to work
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
     def self.get(name:, scope: nil)
-      super("#{scope}__#{PRIMARY_KEY}", name: name)
+      super("#{TOOL_SCOPE}__#{PRIMARY_KEY}", name: name)
     end
 
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
     def self.names(scope: nil)
       array = []
-      all(scope: scope).each do |name, _tool|
+      all().each do |name, _tool|
         array << name
       end
       array
     end
 
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
     def self.all(scope: nil)
       ordered_array = []
-      tools = unordered_all(scope: scope)
+      tools = unordered_all()
       tools.each do |_name, tool|
         ordered_array << tool
       end
@@ -65,14 +76,10 @@ module OpenC3
       ordered_hash
     end
 
+    # Tools only exist in the DEFAULT scope. Kept for backwards compatibility
+    # with the ToolsController importmap endpoint.
     def self.all_scopes
-      result = {}
-      scopes = OpenC3::ScopeModel.all
-      scopes.each do |key, _scope|
-        tools = unordered_all(scope: key)
-        result.merge!(tools)
-      end
-      result
+      unordered_all()
     end
 
     # Called by the PluginModel to allow this class to validate it's top-level keyword: "TOOL"
@@ -80,7 +87,8 @@ module OpenC3
       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)
+        # NOTE: scope is intentionally ignored, see TOOL_SCOPE
+        return self.new(folder_name: parameters[0], name: parameters[1], plugin: plugin, needs_dependencies: needs_dependencies, scope: TOOL_SCOPE)
       else
         raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Tool: #{keyword} #{parameters.join(" ")}")
       end
@@ -89,8 +97,10 @@ module OpenC3
 
     # 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:)
-      moving = from_json(get(name: name, scope: scope), scope: scope)
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
+    def self.set_position(name:, position:, scope: nil)
+      tool_scope = TOOL_SCOPE
+      moving = from_json(get(name: name, scope: tool_scope), scope: tool_scope)
       old_pos = moving.position
       new_pos = position
       direction = :down
@@ -101,8 +111,8 @@ module OpenC3
       end
 
       # Go through all the tools and reorder
-      all(scope: scope).each do |_tool_name, tool|
-        tool_model = from_json(tool, scope: scope)
+      all(scope: tool_scope).each do |_tool_name, tool|
+        tool_model = from_json(tool, scope: tool_scope)
         # Update the requested model to the new position
         if tool_model.name == name
           tool_model.position = position
@@ -134,9 +144,11 @@ module OpenC3
       needs_dependencies: false,
       disable_erb: nil,
       import_map_items: nil,
-      scope:
+      scope: nil  # NOTE: deprecated since 7.3.0 as tools are always created in the DEFAULT scope, see TOOL_SCOPE
     )
-      super("#{scope}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at, scope: scope)
+      # Tools are always created in the DEFAULT scope regardless of the scope
+      # the plugin is being installed into, see TOOL_SCOPE
+      super("#{TOOL_SCOPE}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at, scope: TOOL_SCOPE)
       @folder_name = folder_name
       @icon = icon
       @url = url
@@ -156,14 +168,15 @@ module OpenC3
     end
 
     def create(update: false, force: false, queued: false)
-      tools = self.class.all(scope: @scope)
+      tools = self.class.all()
 
       # Make sure a tool with this folder_name doesn't already exist
+      # NOTE: Tools are global (TOOL_SCOPE) so this check is across all scopes
       unless update
         if @folder_name
           tools.each do |_tool_name, tool|
             if tool['folder_name'] == @folder_name
-              raise "Tool with folder_name #{@folder_name} already exists at create"
+              raise "Tool with folder_name #{@folder_name} already exists at create. Tools are global to the entire COSMOS installation and can only be installed once."
             end
           end
         end
@@ -308,8 +321,9 @@ module OpenC3
     ##################################################
 
     # Returns the list of tools or the default OpenC3 tool set if no tools have been created
+    # NOTE: scope is deprecated since 7.3.0 as tools always live in the DEFAULT scope, see TOOL_SCOPE
     def self.unordered_all(scope: nil)
-      tools = Store.hgetall("#{scope}__#{PRIMARY_KEY}")
+      tools = Store.hgetall("#{TOOL_SCOPE}__#{PRIMARY_KEY}")
       tools.each do |key, value|
         tools[key] = JSON.parse(value, allow_nan: true, create_additions: true)
       end

data/lib/openc3/models/trigger_model.rb

@@ -50,6 +50,7 @@ module OpenC3
     STRING_TYPE = 'string'.freeze
     REGEX_TYPE = 'regex'.freeze
     TRIGGER_TYPE = 'trigger'.freeze
+    ITEM_VALUE_TYPES = ['RAW', 'CONVERTED', 'FORMATTED', 'WITH_UNITS'].freeze
 
     def self.create_unique_name(group:, scope:)
       trigger_names = self.names(group: group, scope: scope)
@@ -180,6 +181,24 @@ module OpenC3
       end
     end
 
+    # Validate the items hold a legal valueType and reference telemetry items
+    # which actually exist. Only called on create and update, never from initialize.
+    # Anything which can reject an already persisted trigger must live here rather than
+    # in validate_operand, because validate_operand runs on every from_json
+    def validate_trigger_items
+      {'left' => @left, 'right' => @right}.each do |side, operand|
+        next unless operand.is_a?(Hash) and operand['type'] == ITEM_TYPE
+        unless ITEM_VALUE_TYPES.include?(operand['valueType'])
+          raise TriggerInputError.new "invalid #{side} operand, valueType '#{operand['valueType']}' must be one of #{ITEM_VALUE_TYPES}"
+        end
+        begin
+          TargetModel.packet_item(operand['target'], operand['packet'], operand['item'], scope: @scope)
+        rescue StandardError => e
+          raise TriggerInputError.new "invalid #{side} trigger: #{e.message}"
+        end
+      end
+    end
+
     # Validate that all root triggers exist, but do not persist dependent changes yet.
     # Returns the list of root trigger models that need updating.
     def validate_roots
@@ -207,6 +226,7 @@ module OpenC3
       unless Store.hget(@primary_key, @name).nil?
         raise TriggerInputError.new "existing trigger found: '#{@name}'"
       end
+      validate_trigger_items()
       models = validate_roots()
       @updated_at = Time.now.to_nsec_from_epoch
       Store.hset(@primary_key, @name, JSON.generate(as_json, allow_nan: true))