openc3 7.0.0.pre.rc2 → 7.0.0

data/lib/openc3/models/cvt_model.rb

@@ -15,20 +15,15 @@
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
-require 'pg'
-require 'set'
-require 'thread'
 require 'openc3/utilities/store'
 require 'openc3/utilities/store_queued'
 require 'openc3/utilities/questdb_client'
-require 'openc3/models/target_model'
+# require 'openc3/models/target_model' # Circular require
 
 module OpenC3
   class CvtModel
     @@packet_cache = {}
     @@override_cache = {}
-    @@conn = nil
-    @@conn_mutex = Mutex.new
 
     VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED]
     def self.build_json_from_packet(packet)
@@ -130,265 +125,7 @@ module OpenC3
     end
 
     def self.tsdb_lookup(items, start_time:, end_time: nil, scope: $openc3_scope)
-      tables = {}
-      names = []
-      nil_count = 0
-      # Cache packet definitions to avoid repeated lookups
-      packet_cache = {}
-      # Map column names to item type info for decoding
-      item_types = {}
-      # Track calculated timestamp items: { position => { source:, format:, table_index: } }
-      calculated_items = {}
-      # Track which timestamp columns we need per table
-      needed_timestamps = {} # { table_index => Set of column names }
-      current_position = 0
-
-      # Stored timestamp items that need conversion from timestamp_ns to float seconds
-      stored_timestamp_items = Set.new(['PACKET_TIMESECONDS', 'RECEIVED_TIMESECONDS'])
-      # Track stored timestamp items: { position => { column:, table_index: } }
-      stored_timestamp_positions = {}
-
-      items.each do |item|
-        target_name, packet_name, orig_item_name, value_type, limits = item
-        # They will all be nil when item is a nil value
-        # A nil value indicates a value that does not exist as returned by get_tlm_available
-        if orig_item_name.nil?
-          # We know PACKET_TIMESECONDS always exists so we can use it to fill in the nil value
-          names << "PACKET_TIMESECONDS as __nil#{nil_count}"
-          nil_count += 1
-          current_position += 1
-          next
-        end
-        table_name = QuestDBClient.sanitize_table_name(target_name, packet_name, scope: scope)
-        tables[table_name] = 1
-        index = tables.find_index {|k,v| k == table_name }
-
-        # Check if this is a stored timestamp item (PACKET_TIMESECONDS or RECEIVED_TIMESECONDS)
-        # These are stored as timestamp_ns columns and need conversion to float seconds on read
-        if stored_timestamp_items.include?(orig_item_name)
-          col_name = "T#{index}.#{orig_item_name}"
-          names << "\"#{col_name}\""
-          stored_timestamp_positions[current_position] = { column: col_name, table_index: index }
-          current_position += 1
-          next
-        end
-
-        # Check if this is a calculated timestamp item (PACKET_TIMEFORMATTED or RECEIVED_TIMEFORMATTED)
-        if QuestDBClient::TIMESTAMP_ITEMS.key?(orig_item_name)
-          ts_info = QuestDBClient::TIMESTAMP_ITEMS[orig_item_name]
-          calculated_items[current_position] = {
-            source: ts_info[:source],
-            format: ts_info[:format],
-            table_index: index
-          }
-          # Track that we need this timestamp column for this table
-          needed_timestamps[index] ||= Set.new
-          needed_timestamps[index] << ts_info[:source]
-          current_position += 1
-          next
-        end
-
-        safe_item_name = QuestDBClient.sanitize_column_name(orig_item_name)
-
-        # Look up item type info from packet definition
-        cache_key = [target_name, packet_name]
-        unless packet_cache.key?(cache_key)
-          begin
-            packet_cache[cache_key] = TargetModel.packet(target_name, packet_name, scope: scope)
-          rescue RuntimeError
-            packet_cache[cache_key] = nil
-          end
-        end
-
-        packet_def = packet_cache[cache_key]
-        item_def = nil
-        if packet_def
-          packet_def['items']&.each do |pkt_item|
-            if pkt_item['name'] == orig_item_name
-              item_def = pkt_item
-              break
-            end
-          end
-        end
-
-        case value_type
-        when 'FORMATTED', 'WITH_UNITS'
-          col_name = "T#{index}.#{safe_item_name}__F"
-          names << "\"#{col_name}\""
-          # Formatted values are always strings, no special decoding needed
-          item_types[col_name] = { 'data_type' => 'STRING', 'array_size' => nil }
-        when 'CONVERTED'
-          col_name = "T#{index}.#{safe_item_name}__C"
-          names << "\"#{col_name}\""
-          # Converted values may have different types based on read_conversion
-          if item_def
-            rc = item_def['read_conversion']
-            if rc && rc['converted_type']
-              item_types[col_name] = { 'data_type' => rc['converted_type'], 'array_size' => item_def['array_size'] }
-            elsif item_def['states']
-              # State values are strings
-              item_types[col_name] = { 'data_type' => 'STRING', 'array_size' => nil }
-            else
-              item_types[col_name] = { 'data_type' => item_def['data_type'], 'array_size' => item_def['array_size'] }
-            end
-          else
-            item_types[col_name] = { 'data_type' => nil, 'array_size' => nil }
-          end
-        else
-          col_name = "T#{index}.#{safe_item_name}"
-          names << "\"#{col_name}\""
-          if item_def
-            item_types[col_name] = { 'data_type' => item_def['data_type'], 'array_size' => item_def['array_size'] }
-          else
-            item_types[col_name] = { 'data_type' => nil, 'array_size' => nil }
-          end
-        end
-        current_position += 1
-        if limits
-          names << "\"T#{index}.#{safe_item_name}__L\""
-        end
-      end
-
-      # Add needed timestamp columns to the SELECT
-      # Track which column alias maps to which timestamp source for result processing
-      # Note: We use underscores in the alias name to avoid needing quotes, which QuestDB includes in returned field names
-      timestamp_columns = {} # { "T0___ts_timestamp" => { table_index: 0, source: 'timestamp' } }
-      needed_timestamps.each do |table_index, ts_columns|
-        ts_columns.each do |ts_col|
-          alias_name = "T#{table_index}___ts_#{ts_col}"
-          names << "T#{table_index}.#{ts_col} as #{alias_name}"
-          timestamp_columns[alias_name] = { table_index: table_index, source: ts_col }
-        end
-      end
-
-      # Build the SQL query
-      query = "SELECT #{names.join(", ")} FROM "
-      tables.each_with_index do |(table_name, _), index|
-        if index == 0
-          query += "#{table_name} as T#{index} "
-        else
-          query += "ASOF JOIN #{table_name} as T#{index} "
-        end
-      end
-      if start_time && !end_time
-        query += "WHERE T0.PACKET_TIMESECONDS < '#{start_time}' LIMIT -1"
-      elsif start_time && end_time
-        query += "WHERE T0.PACKET_TIMESECONDS >= '#{start_time}' AND T0.PACKET_TIMESECONDS < '#{end_time}'"
-      end
-
-      retry_count = 0
-      begin
-        @@conn_mutex.synchronize do
-          @@conn ||= PG::Connection.new(host: ENV['OPENC3_TSDB_HOSTNAME'],
-                                        port: ENV['OPENC3_TSDB_QUERY_PORT'],
-                                        user: ENV['OPENC3_TSDB_USERNAME'],
-                                        password: ENV['OPENC3_TSDB_PASSWORD'],
-                                        dbname: 'qdb')
-          # Default connection is all strings but we want to map to the correct types
-          if @@conn.type_map_for_results.is_a? PG::TypeMapAllStrings
-            # TODO: This doesn't seem to be round tripping UINT64 correctly
-            # Try playback with P_2.2,2 and P(:6;): from the DEMO
-            @@conn.type_map_for_results = PG::BasicTypeMapForResults.new @@conn
-          end
-
-          result = @@conn.exec(query)
-          if result.nil? or result.ntuples == 0
-            return {}
-          else
-            data = []
-            # Build up a results set that is an array of arrays
-            # Each nested array is a set of 2 items: [value, limits state]
-            # If the item does not have limits the limits state is nil
-            result.each_with_index do |tuples, row_num|
-              data[row_num] ||= []
-              row_index = 0
-              # Store timestamp values for this row: { "T0.PACKET_TIMESECONDS" => Time, ... }
-              row_timestamps = {}
-              tuples.each do |tuple|
-                col_name = tuple[0]
-                col_value = tuple[1]
-                if col_name.include?("__L")
-                  data[row_num][row_index - 1][1] = col_value
-                elsif col_name =~ /^__nil/
-                  data[row_num][row_index] = [nil, nil]
-                  row_index += 1
-                elsif col_name =~ /^T(\d+)___ts_(.+)$/
-                  # This is a timestamp column for calculated items (TIMEFORMATTED)
-                  table_idx = $1.to_i
-                  ts_source = $2
-                  row_timestamps["T#{table_idx}.#{ts_source}"] = col_value
-                elsif col_name.end_with?('.PACKET_TIMESECONDS', '.RECEIVED_TIMESECONDS') || col_name == 'PACKET_TIMESECONDS' || col_name == 'RECEIVED_TIMESECONDS'
-                  # Stored timestamp column - convert from datetime to float seconds
-                  ts_utc = QuestDBClient.pg_timestamp_to_utc(col_value)
-                  seconds_value = QuestDBClient.format_timestamp(ts_utc, :seconds)
-                  data[row_num][row_index] = [seconds_value, nil]
-                  row_index += 1
-                  # Also store for calculated items (TIMEFORMATTED) that may need this
-                  # Normalize key to T{index}.{col} format for consistency
-                  if col_name.include?('.')
-                    row_timestamps[col_name] = col_value
-                  else
-                    row_timestamps["T0.#{col_name}"] = col_value
-                  end
-                else
-                  # Decode value using item type info
-                  # QuestDB may return column names without table alias prefix
-                  # Try both the raw column name and prefixed versions
-                  type_info = item_types[col_name]
-                  unless type_info
-                    tables.length.times do |i|
-                      prefixed_name = "T#{i}.#{col_name}"
-                      type_info = item_types[prefixed_name]
-                      break if type_info
-                    end
-                    type_info ||= {}
-                  end
-                  decoded_value = QuestDBClient.decode_value(
-                    col_value,
-                    data_type: type_info['data_type'],
-                    array_size: type_info['array_size']
-                  )
-                  data[row_num][row_index] = [decoded_value, nil]
-                  row_index += 1
-                end
-              end
-
-              # Insert calculated timestamp items at their positions
-              # Insert in ascending order so positions remain valid after each insert
-              calculated_items.keys.sort.each do |position|
-                calc_info = calculated_items[position]
-                ts_key = "T#{calc_info[:table_index]}.#{calc_info[:source]}"
-                ts_value = row_timestamps[ts_key]
-                ts_utc = QuestDBClient.pg_timestamp_to_utc(ts_value)
-                calculated_value = QuestDBClient.format_timestamp(ts_utc, calc_info[:format])
-                data[row_num].insert(position, [calculated_value, nil])
-              end
-            end
-            # If we only have one row then we return a single array
-            if result.ntuples == 1
-              data = data[0]
-            end
-            return data
-          end
-        end
-      rescue IOError, PG::Error => e
-        # Retry the query because various errors can occur that are recoverable
-        retry_count += 1
-        if retry_count > 4
-          # After the 5th retry just raise the error
-          raise "Error querying TSDB: #{e.message}"
-        end
-        Logger.warn("TSDB: Retrying due to error: #{e.message}")
-        Logger.warn("TSDB: Last query: #{query}") # Log the last query for debugging
-        @@conn_mutex.synchronize do
-          if @@conn and !@@conn.finished?
-            @@conn.finish()
-          end
-          @@conn = nil # Force the new connection
-        end
-        sleep 0.1
-        retry
-      end
+      QuestDBClient.tsdb_lookup(items, start_time: start_time, end_time: end_time, scope: scope)
     end
 
     # Return all item values and limit state from the CVT

data/lib/openc3/models/model.rb

@@ -194,6 +194,22 @@ module OpenC3
         'scope' => @scope }
     end
 
+    # Compare this model's as_json with a previous Hash and return an array
+    # of human-readable change descriptions (e.g. "key: old -> new").
+    # Skips the updated_at field since it always changes.
+    # @param existing [Hash] the previous model state (from .get)
+    # @return [Array<String>] list of changed fields
+    def diff(existing)
+      changes = []
+      new_json = as_json
+      existing.each do |key, old_value|
+        next if key == 'updated_at'
+        new_value = new_json[key]
+        changes << "#{key}: #{old_value} -> #{new_value}" if old_value != new_value
+      end
+      changes
+    end
+
     def check_disable_erb(filename)
       erb_disabled = false
       if @disable_erb

data/lib/openc3/models/plugin_model.rb

@@ -53,7 +53,8 @@ module OpenC3
     attr_accessor :plugin_txt_lines
     attr_accessor :minimum_cosmos_version
     attr_accessor :needs_dependencies
-    attr_accessor :store_id
+    attr_accessor :store_plugin_id
+    attr_accessor :store_version_id
     attr_accessor :title
     attr_accessor :description
     attr_accessor :licenses
@@ -78,7 +79,7 @@ module OpenC3
 
     # Called by the PluginsController to parse the plugin variables
     # Doesn't actually create the plugin during the phase
-    def self.install_phase1(gem_file_path, existing_variables: nil, existing_plugin_txt_lines: nil, store_id: nil, process_existing: false, scope:, validate_only: false)
+    def self.install_phase1(gem_file_path, existing_variables: nil, existing_plugin_txt_lines: nil, store_plugin_id: nil, store_version_id: nil, process_existing: false, scope:, validate_only: false)
       gem_name = File.basename(gem_file_path).split("__")[0]
 
       temp_dir = Dir.mktmpdir
@@ -167,8 +168,9 @@ module OpenC3
           end
         end
 
-        store_id = Integer(store_id) if store_id
-        model = PluginModel.new(name: gem_name, variables: variables, plugin_txt_lines: plugin_txt_lines, store_id: store_id, minimum_cosmos_version: minimum_cosmos_version, scope: scope)
+        store_plugin_id = Integer(store_plugin_id) if store_plugin_id
+        store_version_id = Integer(store_version_id) if store_version_id
+        model = PluginModel.new(name: gem_name, variables: variables, plugin_txt_lines: plugin_txt_lines, store_plugin_id: store_plugin_id, store_version_id: store_version_id, minimum_cosmos_version: minimum_cosmos_version, scope: scope)
         result = model.as_json()
         result['existing_plugin_txt_lines'] = existing_plugin_txt_lines if existing_plugin_txt_lines and not process_existing and existing_plugin_txt_lines != result['plugin_txt_lines']
         return result
@@ -233,7 +235,8 @@ module OpenC3
           full_default_path = File.join(gem_path, default_img_path)
           img_path = default_img_path if File.exist? full_default_path
         end
-        plugin_model.img_path = File.join('gems', gem_name.split(".gem")[0], img_path) if img_path # convert this filesystem path to volumes mount path
+        package_name = "#{pkg.spec.name}-#{pkg.spec.version}"
+        plugin_model.img_path = File.join('gems', package_name, img_path) if img_path # convert this filesystem path to volumes mount path
         plugin_model.update() unless validate_only
 
         needs_dependencies = pkg.spec.runtime_dependencies.length > 0
@@ -265,16 +268,16 @@ module OpenC3
             if File.exist?(pyproject_path)
               Logger.info "Installing python packages from pyproject.toml with pypi_url=#{pypi_url}"
               if ENV['PIP_ENABLE_TRUSTED_HOST'].nil?
-                pip_args = "--no-warn-script-location -i #{pypi_url} #{gem_path}"
+                pip_args = "-i #{pypi_url} #{gem_path}"
               else
-                pip_args = "--no-warn-script-location -i #{pypi_url} --trusted-host #{URI.parse(pypi_url).host} #{gem_path}"
+                pip_args = "-i #{pypi_url} --trusted-host #{URI.parse(pypi_url).host} #{gem_path}"
               end
             else
               Logger.info "Installing python packages from requirements.txt with pypi_url=#{pypi_url}"
               if ENV['PIP_ENABLE_TRUSTED_HOST'].nil?
-                pip_args = "--no-warn-script-location -i #{pypi_url} -r #{requirements_path}"
+                pip_args = "-i #{pypi_url} -r #{requirements_path}"
               else
-                pip_args = "--no-warn-script-location -i #{pypi_url} --trusted-host #{URI.parse(pypi_url).host} -r #{requirements_path}"
+                pip_args = "-i #{pypi_url} --trusted-host #{URI.parse(pypi_url).host} -r #{requirements_path}"
               end
             end
             puts `/openc3/bin/pipinstall #{pip_args}`
@@ -377,7 +380,8 @@ module OpenC3
       plugin_txt_lines: [],
       minimum_cosmos_version: nil,
       needs_dependencies: false,
-      store_id: nil,
+      store_plugin_id: nil,
+      store_version_id: nil,
       title: nil,
       description: nil,
       keywords: nil,
@@ -393,7 +397,8 @@ module OpenC3
       @plugin_txt_lines = plugin_txt_lines
       @minimum_cosmos_version = minimum_cosmos_version
       @needs_dependencies = ConfigParser.handle_true_false(needs_dependencies)
-      @store_id = store_id
+      @store_plugin_id = store_plugin_id
+      @store_version_id = store_version_id
       @title = title
       @description = description
       @keywords = keywords
@@ -420,7 +425,8 @@ module OpenC3
         'plugin_txt_lines' => @plugin_txt_lines,
         'minimum_cosmos_version' => @minimum_cosmos_version,
         'needs_dependencies' => @needs_dependencies,
-        'store_id' => @store_id,
+        'store_plugin_id' => @store_plugin_id,
+        'store_version_id' => @store_version_id,
         'title' => @title,
         'description' => @description,
         'keywords' => @keywords,

data/lib/openc3/models/plugin_store_model.rb

@@ -18,7 +18,7 @@ module OpenC3
   class PluginStoreModel < Model
     PRIMARY_KEY = 'openc3_plugin_store'
     DEFAULT_STORE_URL = 'https://store.openc3.com'
-    JSON_ENDPOINT = '/api/v1.1/cosmos_plugins'
+    JSON_ENDPOINT = '/api/v1.2/cosmos_plugins'
 
     def self.set(plugin_store_data)
       Store.set(PRIMARY_KEY, plugin_store_data)

data/lib/openc3/models/python_package_model.rb

@@ -88,9 +88,9 @@ module OpenC3
       end
       Logger.info "Installing python package: #{name_or_path}"
       if ENV['PIP_ENABLE_TRUSTED_HOST'].nil?
-        pip_args = ["--no-warn-script-location", "-i", pypi_url, package_file_path]
+        pip_args = ["-i", pypi_url, package_file_path]
       else
-        pip_args = ["--no-warn-script-location", "-i", pypi_url, "--trusted-host", URI.parse(pypi_url).host, package_file_path]
+        pip_args = ["-i", pypi_url, "--trusted-host", URI.parse(pypi_url).host, package_file_path]
       end
       result = OpenC3::ProcessManager.instance.spawn(["/openc3/bin/pipinstall"] + pip_args, "package_install", package_filename, Time.now + 3600.0, scope: scope)
       return result.name

data/lib/openc3/models/queue_model.rb

@@ -40,7 +40,7 @@ module OpenC3
     end
     # END NOTE
 
-    def self.queue_command(name, command: nil, target_name: nil, cmd_name: nil, cmd_params: nil, username:, scope:)
+    def self.queue_command(name, command: nil, target_name: nil, cmd_name: nil, cmd_params: nil, validate: true, timeout: nil, username:, scope:)
       model = get_model(name: name, scope: scope)
       raise QueueError, "Queue '#{name}' not found in scope '#{scope}'" unless model
 
@@ -53,7 +53,7 @@ module OpenC3
         end
 
         # Build command data with support for both formats
-        command_data = { username: username, timestamp: Time.now.to_nsec_from_epoch }
+        command_data = { username: username, timestamp: Time.now.to_nsec_from_epoch, validate: validate, timeout: timeout }
         if target_name && cmd_name
           # New format: store target_name, cmd_name, and cmd_params separately
           command_data[:target_name] = target_name
@@ -142,7 +142,7 @@ module OpenC3
       notify(kind: 'command')
     end
 
-    def update_command(id:, command:, username:)
+    def update_command(id:, command:, username:, validate: nil, timeout: nil)
       if @state == 'DISABLE'
         raise QueueError, "Queue '#{@name}' is disabled. Command at id #{id} not updated."
       end
@@ -156,6 +156,8 @@ module OpenC3
       # Remove the existing command and add the new one at the same id
       Store.zremrangebyscore("#{@scope}:#{@name}", id, id)
       command_data = { username: username, value: command, timestamp: Time.now.to_nsec_from_epoch }
+      command_data[:validate] = validate unless validate.nil?
+      command_data[:timeout] = timeout unless timeout.nil?
       Store.zadd("#{@scope}:#{@name}", id, command_data.to_json)
       notify(kind: 'command')
     end

data/lib/openc3/models/script_engine_model.rb

@@ -13,7 +13,7 @@
 
 require 'openc3/top_level'
 require 'openc3/models/model'
-require 'openc3/models/scope_model'
+# require 'openc3/models/scope_model' # Circular require
 require 'openc3/utilities/bucket'
 require 'openc3/utilities/bucket_utilities'
 

data/lib/openc3/models/target_model.rb

@@ -33,6 +33,7 @@ require 'openc3/utilities/bucket'
 require 'openc3/utilities/zip'
 require 'fileutils'
 require 'ostruct'
+require 'set'
 require 'tmpdir'
 
 module OpenC3
@@ -55,6 +56,7 @@ module OpenC3
     @@sync_packet_count_data = {}
     @@sync_packet_count_time = nil
     @@sync_packet_count_delay_seconds = 1.0 # Sync packet counts every second
+    @@stale_packet_keys_warned = Set.new # Track stale keys already warned about
 
     attr_accessor :folder_name
     attr_accessor :requires
@@ -162,36 +164,41 @@ module OpenC3
       if target_name.include?('..') || target_name.include?('/') || target_name.include?('\\')
         raise ArgumentError, "Invalid target_name: #{target_name.inspect}"
       end
-      tmp_dir = Dir.mktmpdir
-      zip_filename = File.join(tmp_dir, "#{target_name}.zip")
-      Zip.continue_on_exists_proc = true
-      zip = Zip::File.open(zip_filename, create: true)
+      temp_dir = Dir.mktmpdir
+      begin
+        zip_filename = OpenC3.sanitize_path(File.join(temp_dir, "#{target_name}.zip"))
+        Zip.continue_on_exists_proc = true
+        zip = Zip::File.open(zip_filename, create: true)
 
-      if ENV['OPENC3_LOCAL_MODE']
-        OpenC3::LocalMode.zip_target(target_name, zip, scope: scope)
-      else
-        bucket = Bucket.getClient()
-        # The trailing slash is important!
-        prefix = "#{scope}/targets_modified/#{target_name}/"
-        resp = bucket.list_objects(
-          bucket: ENV['OPENC3_CONFIG_BUCKET'],
-          prefix: prefix,
-        )
-        resp.each do |item|
-          # item.key looks like DEFAULT/targets_modified/INST/screens/blah.txt
-          base_path = item.key.sub(prefix, '') # remove prefix
-          local_path = File.join(tmp_dir, base_path)
-          # Ensure dir structure exists, get_object fails if not
-          FileUtils.mkdir_p(File.dirname(local_path))
-          bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: item.key, path: local_path)
-          zip.add(base_path, local_path)
+        if ENV['OPENC3_LOCAL_MODE']
+          OpenC3::LocalMode.zip_target(target_name, zip, scope: scope)
+        else
+          bucket = Bucket.getClient()
+          # The trailing slash is important!
+          prefix = "#{scope}/targets_modified/#{target_name}/"
+          resp = bucket.list_objects(
+            bucket: ENV['OPENC3_CONFIG_BUCKET'],
+            prefix: prefix,
+          )
+          resp.each do |item|
+            # item.key looks like DEFAULT/targets_modified/INST/screens/blah.txt
+            base_path = item.key.sub(prefix, '') # remove prefix
+            local_path = File.join(temp_dir, base_path)
+            # Ensure dir structure exists, get_object fails if not
+            FileUtils.mkdir_p(File.dirname(local_path))
+            bucket.get_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: item.key, path: local_path)
+            zip.add(base_path, local_path)
+          end
         end
+        zip.close
+
+        result = OpenStruct.new
+        result.filename = File.basename(zip_filename)
+        result.contents = File.read(zip_filename, mode: 'rb')
+      ensure
+        FileUtils.remove_entry_secure(temp_dir, true)
       end
-      zip.close
 
-      result = OpenStruct.new
-      result.filename = File.basename(zip_filename)
-      result.contents = File.read(zip_filename, mode: 'rb')
       return result
     end
 
@@ -391,14 +398,7 @@ module OpenC3
       shard: 0,
       scope:
     )
-      super("#{scope}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at,
-        cmd_buffer_depth: cmd_buffer_depth, cmd_log_cycle_time: cmd_log_cycle_time, cmd_log_cycle_size: cmd_log_cycle_size,
-        cmd_log_retain_time: cmd_log_retain_time,
-        tlm_buffer_depth: tlm_buffer_depth, tlm_log_cycle_time: tlm_log_cycle_time, tlm_log_cycle_size: tlm_log_cycle_size,
-        tlm_log_retain_time: tlm_log_retain_time,
-        cmd_decom_retain_time: cmd_decom_retain_time, tlm_decom_retain_time: tlm_decom_retain_time,
-        cleanup_poll_time: cleanup_poll_time, needs_dependencies: needs_dependencies, target_microservices: target_microservices,
-        scope: scope)
+      super("#{scope}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at, scope: scope)
       @folder_name = folder_name
       @requires = requires
       @ignored_parameters = ignored_parameters
@@ -1235,17 +1235,34 @@ module OpenC3
 
     def self.init_tlm_packet_counts(tlm_target_names, scope:)
       @@sync_packet_count_time = Time.now
+      @@stale_packet_keys_warned = Set.new
 
       # Get all the packet counts with the global counters
       tlm_target_names.each do |target_name|
         get_all_telemetry_counts(target_name, scope: scope).each do |packet_name, count|
-          update_packet = System.telemetry.packet(target_name, packet_name)
-          update_packet.received_count = count.to_i
+          begin
+            update_packet = System.telemetry.packet(target_name, packet_name)
+            update_packet.received_count = count.to_i
+          rescue RuntimeError
+            key = "#{target_name} #{packet_name}"
+            unless @@stale_packet_keys_warned.include?(key)
+              @@stale_packet_keys_warned.add(key)
+              Logger.warn("Stale tlmcnt Redis key detected for unknown packet #{key} - ignoring")
+            end
+          end
         end
       end
       get_all_telemetry_counts('UNKNOWN', scope: scope).each do |packet_name, count|
-        update_packet = System.telemetry.packet('UNKNOWN', packet_name)
-        update_packet.received_count = count.to_i
+        begin
+          update_packet = System.telemetry.packet('UNKNOWN', packet_name)
+          update_packet.received_count = count.to_i
+        rescue RuntimeError
+          key = "UNKNOWN #{packet_name}"
+          unless @@stale_packet_keys_warned.include?(key)
+            @@stale_packet_keys_warned.add(key)
+            Logger.warn("Stale tlmcnt Redis key detected for unknown packet #{key} - ignoring")
+          end
+        end
       end
     end
 
@@ -1291,14 +1308,30 @@ module OpenC3
           end
           tlm_target_names.each do |target_name|
             result[inc_count].each do |packet_name, count|
-              update_packet = System.telemetry.packet(target_name, packet_name)
-              update_packet.received_count = count.to_i
+              begin
+                update_packet = System.telemetry.packet(target_name, packet_name)
+                update_packet.received_count = count.to_i
+              rescue RuntimeError
+                key = "#{target_name} #{packet_name}"
+                unless @@stale_packet_keys_warned.include?(key)
+                  @@stale_packet_keys_warned.add(key)
+                  Logger.warn("Stale tlmcnt Redis key detected for unknown packet #{key} - ignoring")
+                end
+              end
             end
             inc_count += 1
           end
           result[inc_count].each do |packet_name, count|
-            update_packet = System.telemetry.packet('UNKNOWN', packet_name)
-            update_packet.received_count = count.to_i
+            begin
+              update_packet = System.telemetry.packet('UNKNOWN', packet_name)
+              update_packet.received_count = count.to_i
+            rescue RuntimeError
+              key = "UNKNOWN #{packet_name}"
+              unless @@stale_packet_keys_warned.include?(key)
+                @@stale_packet_keys_warned.add(key)
+                Logger.warn("Stale tlmcnt Redis key detected for unknown packet #{key} - ignoring")
+              end
+            end
           end
         end
       end