openc3 6.10.4 → 7.0.0.pre.rc2

data/lib/openc3/models/auth_model.rb

@@ -3,100 +3,119 @@
 # 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.
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE.md for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2024, OpenC3, Inc.
+# All changes Copyright 2026, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
-require 'digest'
+require 'argon2'
 require 'securerandom'
 require 'openc3/utilities/store'
 
 module OpenC3
   class AuthModel
-    PRIMARY_KEY = 'OPENC3__TOKEN'
-    SESSIONS_KEY = 'OPENC3__SESSIONS'
+    ARGON2_PROFILE = ENV["OPENC3_ARGON2_PROFILE"]&.to_sym || :rfc_9106_low_memory
+
+    # Redis keys
+    PRIMARY_KEY = 'OPENC3__TOKEN' # for argon2 password hash
+    SESSIONS_KEY = 'OPENC3__SESSIONS' # for hash containing session tokens
 
-    TOKEN_CACHE_TIMEOUT = 5
+    # The length of time in minutes to keep redis values in memory
+    PW_HASH_CACHE_TIMEOUT = 5
     SESSION_CACHE_TIMEOUT = 5
-    @@token_cache = nil
-    @@token_cache_time = nil
+
+    # Cached argon2 password hash
+    @@pw_hash_cache = nil
+    @@pw_hash_cache_time = nil
+
+    # Cached session tokens
     @@session_cache = nil
     @@session_cache_time = nil
 
-    MIN_TOKEN_LENGTH = 8
+    MIN_PASSWORD_LENGTH = 8
 
     def self.set?(key = PRIMARY_KEY)
       Store.exists(key) == 1
     end
 
-    def self.verify(token)
+    # Checks whether the provided token is a valid user password, service password, or session token.
+    # @param token [String] the plaintext password or session token to check (required)
+    # @param no_password [Boolean] enforces use of a session token or service password (default: true)
+    # @param service_only [Boolean] enforces use of a service password (default: false)
+    # @return [Boolean] whether the provided password/token is valid
+    def self.verify(token, no_password: true, service_only: false)
       # Handle a service password - Generally only used by ScriptRunner
       # TODO: Replace this with temporary service tokens
       service_password = ENV['OPENC3_SERVICE_PASSWORD']
       return true if service_password and service_password == token
 
-      return verify_no_service(token)
+      return false if service_only
+
+      return verify_no_service(token, no_password: no_password)
     end
 
-    def self.verify_no_service(token)
+    # Checks whether the provided token is a valid user password or session token.
+    # @param token [String] the plaintext password or session token to check (required)
+    # @param no_password [Boolean] enforces use of a session token (default: true)
+    # @return [Boolean] whether the provided password/token is valid
+    def self.verify_no_service(token, no_password: true)
       return false if token.nil? or token.empty?
 
+      # Check cached session tokens and password hash
       time = Time.now
       return true if @@session_cache and (time - @@session_cache_time) < SESSION_CACHE_TIMEOUT and @@session_cache[token]
-      token_hash = hash(token)
-      return true if @@token_cache and (time - @@token_cache_time) < TOKEN_CACHE_TIMEOUT and @@token_cache == token_hash
+      unless no_password
+        return true if @@pw_hash_cache and (time - @@pw_hash_cache_time) < PW_HASH_CACHE_TIMEOUT and Argon2::Password.verify_password(token, @@pw_hash_cache)
+      end
 
-      # Check sessions
+      # Check stored session tokens
       @@session_cache = Store.hgetall(SESSIONS_KEY)
       @@session_cache_time = time
       return true if @@session_cache[token]
 
-      # Check Direct password
-      @@token_cache = Store.get(PRIMARY_KEY)
-      @@token_cache_time = time
-      return true if @@token_cache == token_hash
+      return false if no_password
 
-      return false
+      # Check stored password hash
+      pw_hash = Store.get(PRIMARY_KEY)
+      raise "invalid password hash" unless pw_hash.start_with?("$argon2") # Catch users who didn't run the migration utility when upgrading to COSMOS 7
+      @@pw_hash_cache = pw_hash
+      @@pw_hash_cache_time = time
+      return Argon2::Password.verify_password(token, @@pw_hash_cache)
     end
 
-    def self.set(token, old_token, key = PRIMARY_KEY)
-      raise "token must not be nil or empty" if token.nil? or token.empty?
-      raise "token must be at least 8 characters" if token.length < MIN_TOKEN_LENGTH
+    def self.set(password, old_password, key = PRIMARY_KEY)
+      raise "password must not be nil or empty" if password.nil? or password.empty?
+      raise "password must be at least 8 characters" if password.length < MIN_PASSWORD_LENGTH
 
       if set?(key)
-        raise "old_token must not be nil or empty" if old_token.nil? or old_token.empty?
-        raise "old_token incorrect" unless verify(old_token)
+        raise "old_password must not be nil or empty" if old_password.nil? or old_password.empty?
+        raise "old_password incorrect" unless verify_no_service(old_password, no_password: false)
       end
-      Store.set(key, hash(token))
+      pw_hash = Argon2::Password.create(password, profile: ARGON2_PROFILE)
+      Store.set(key, pw_hash)
+      @@pw_hash_cache = nil
+      @@pw_hash_cache_time = nil
     end
 
+    # Creates a new session token. DO NOT CALL BEFORE VERIFYING.
     def self.generate_session
       token = SecureRandom.urlsafe_base64(nil, false)
       Store.hset(SESSIONS_KEY, token, Time.now.iso8601)
       return token
     end
 
+    # Terminates every session.
     def self.logout
       Store.del(SESSIONS_KEY)
-      @@sessions_cache = nil
-      @@sessions_cache_time = nil
-    end
-
-    def self.hash(token)
-      Digest::SHA2.hexdigest token
+      @@session_cache = nil
+      @@session_cache_time = nil
     end
   end
 end

data/lib/openc3/models/cvt_model.rb

@@ -3,27 +3,24 @@
 # 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.
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE.md for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2025, OpenC3, Inc.
+# All changes Copyright 2026, OpenC3, Inc.
 # All Rights Reserved
 #
 # 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'
 
 module OpenC3
@@ -33,7 +30,7 @@ module OpenC3
     @@conn = nil
     @@conn_mutex = Mutex.new
 
-    VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED, :WITH_UNITS]
+    VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED]
     def self.build_json_from_packet(packet)
       packet.decom
     end
@@ -59,6 +56,20 @@ module OpenC3
       end
     end
 
+    # Set the current value table with pre-serialized JSON (avoids double as_json call)
+    # @param packet_json [String] Pre-serialized JSON string
+    # @param hash [Hash] The JSON-safe hash (already had as_json called)
+    def self.set_json(packet_json, hash, target_name:, packet_name:, queued: false, scope: $openc3_scope)
+      key = "#{scope}__tlm__#{target_name}"
+      tgt_pkt_key = key + "__#{packet_name}"
+      @@packet_cache[tgt_pkt_key] = [Time.now, hash]
+      if queued
+        StoreQueued.hset(key, packet_name, packet_json)
+      else
+        Store.hset(key, packet_name, packet_json)
+      end
+    end
+
     # Get the hash for packet in the CVT
     # Note: Does not apply overrides
     def self.get(target_name:, packet_name:, cache_timeout: nil, scope: $openc3_scope)
@@ -80,16 +91,13 @@ module OpenC3
     def self.set_item(target_name, packet_name, item_name, value, type:, queued: false, scope: $openc3_scope)
       hash = get(target_name: target_name, packet_name: packet_name, cache_timeout: nil, scope: scope)
       case type
-      when :WITH_UNITS
-        hash["#{item_name}__U"] = value.to_s # WITH_UNITS should always be a string
-      when :FORMATTED
+      when :FORMATTED, :WITH_UNITS
         hash["#{item_name}__F"] = value.to_s # FORMATTED should always be a string
       when :CONVERTED
         hash["#{item_name}__C"] = value
       when :RAW
         hash[item_name] = value
       when :ALL
-        hash["#{item_name}__U"] = value.to_s # WITH_UNITS should always be a string
         hash["#{item_name}__F"] = value.to_s # FORMATTED should always be a string
         hash["#{item_name}__C"] = value
         hash[item_name] = value
@@ -121,39 +129,135 @@ module OpenC3
       end
     end
 
-    def self.tsdb_lookup(items, start_time:, end_time: nil)
+    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, item_name, value_type, limits = 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 item_name.nil?
-          # We know timestamp always exists so we can use it to fill in the nil value
-          names << "timestamp as __nil#{nil_count}"
+        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
-        # See https://questdb.com/docs/reference/api/ilp/advanced-settings/#name-restrictions
-        table_name = "#{target_name}__#{packet_name}".gsub(/[?,'"\/:\)\(\+\*\%~]/, '_')
+        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 }
-        # See https://questdb.com/docs/reference/api/ilp/advanced-settings/#name-restrictions
-        # NOTE: Semicolon added as it appears invalid
-        item_name = item_name.gsub(/[?\.,'"\\\/:\)\(\+\-\*\%~;]/, '_')
+
+        # 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 'WITH_UNITS'
-          names << "\"T#{index}.#{item_name}__U\""
-        when 'FORMATTED'
-          names << "\"T#{index}.#{item_name}__F\""
+        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'
-          names << "\"T#{index}.#{item_name}__C\""
+          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
-          names << "\"T#{index}.#{item_name}\""
+          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}.#{item_name}__L\""
+          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
 
@@ -167,9 +271,9 @@ module OpenC3
         end
       end
       if start_time && !end_time
-        query += "WHERE T0.timestamp < '#{start_time}' LIMIT -1"
+        query += "WHERE T0.PACKET_TIMESECONDS < '#{start_time}' LIMIT -1"
       elsif start_time && end_time
-        query += "WHERE T0.timestamp >= '#{start_time}' AND T0.timestamp < '#{end_time}'"
+        query += "WHERE T0.PACKET_TIMESECONDS >= '#{start_time}' AND T0.PACKET_TIMESECONDS < '#{end_time}'"
       end
 
       retry_count = 0
@@ -195,20 +299,70 @@ module OpenC3
             # 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, index|
-              data[index] ||= []
+            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|
-                if tuple[0].include?("__L")
-                  data[index][row_index - 1][1] = tuple[1]
-                elsif tuple[0] =~ /^__nil/
-                  data[index][row_index] = [nil, nil]
+                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
-                  data[index][row_index] = [tuple[1], nil]
+                  # 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
@@ -222,10 +376,10 @@ module OpenC3
         retry_count += 1
         if retry_count > 4
           # After the 5th retry just raise the error
-          raise "Error querying QuestDB: #{e.message}"
+          raise "Error querying TSDB: #{e.message}"
         end
-        Logger.warn("QuestDB: Retrying due to error: #{e.message}")
-        Logger.warn("QuestDB: Last query: #{query}") # Log the last query for debugging
+        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()
@@ -252,7 +406,7 @@ module OpenC3
       # If a start_time is passed we're doing a QuestDB lookup and directly return the results
       # TODO: This currently does NOT support the override values
       if start_time
-        return tsdb_lookup(items, start_time: start_time, end_time: end_time)
+        return tsdb_lookup(items, start_time: start_time, end_time: end_time, scope: scope)
       end
 
       # First generate a lookup hash of all the items represented so we can query the CVT
@@ -318,9 +472,7 @@ module OpenC3
             item_name, value_type_key = key.split('__')
             item['item_name'] = item_name
             case value_type_key
-            when 'U'
-              item['value_type'] = 'WITH_UNITS'
-            when 'F'
+            when 'F', 'U'
               item['value_type'] = 'FORMATTED'
             when 'C'
               item['value_type'] = 'CONVERTED'
@@ -346,15 +498,12 @@ module OpenC3
         hash[item_name] = value
         hash["#{item_name}__C"] = value
         hash["#{item_name}__F"] = value.to_s
-        hash["#{item_name}__U"] = value.to_s
       when :RAW
         hash[item_name] = value
       when :CONVERTED
         hash["#{item_name}__C"] = value
-      when :FORMATTED
+      when :FORMATTED, :WITH_UNITS
         hash["#{item_name}__F"] = value.to_s # Always a String
-      when :WITH_UNITS
-        hash["#{item_name}__U"] = value.to_s # Always a String
       else
         raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
       end
@@ -374,15 +523,12 @@ module OpenC3
         hash.delete(item_name)
         hash.delete("#{item_name}__C")
         hash.delete("#{item_name}__F")
-        hash.delete("#{item_name}__U")
       when :RAW
         hash.delete(item_name)
       when :CONVERTED
         hash.delete("#{item_name}__C")
-      when :FORMATTED
+      when :FORMATTED, :WITH_UNITS
         hash.delete("#{item_name}__F")
-      when :WITH_UNITS
-        hash.delete("#{item_name}__U")
       else
         raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
       end
@@ -424,10 +570,7 @@ module OpenC3
       override_key = item_name
       types = []
       case type
-      when :WITH_UNITS
-        types = ["#{item_name}__U", "#{item_name}__F", "#{item_name}__C", item_name]
-        override_key = "#{item_name}__U"
-      when :FORMATTED
+      when :FORMATTED, :WITH_UNITS
         types = ["#{item_name}__F", "#{item_name}__C", item_name]
         override_key = "#{item_name}__F"
       when :CONVERTED
@@ -477,16 +620,14 @@ module OpenC3
       end
 
       # We build lookup keys by including all the less formatted types to gracefully degrade lookups
-      # This allows the user to specify WITH_UNITS and if there is no conversions it will simply return the RAW value
+      # This allows the user to specify FORMATTED and if there is no conversions it will simply return the RAW value
       case value_type.to_s
       when 'RAW'
         keys = [item_name]
       when 'CONVERTED'
         keys = ["#{item_name}__C", item_name]
-      when 'FORMATTED'
+      when 'FORMATTED', 'WITH_UNITS'
         keys = ["#{item_name}__F", "#{item_name}__C", item_name]
-      when 'WITH_UNITS'
-        keys = ["#{item_name}__U", "#{item_name}__F", "#{item_name}__C", item_name]
       else
         raise "Unknown value type '#{value_type}'"
       end

data/lib/openc3/models/environment_model.rb

@@ -3,21 +3,16 @@
 # 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.
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE.md for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2026, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/models/model'

data/lib/openc3/models/gem_model.rb

@@ -3,18 +3,13 @@
 # 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.
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE.md for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2026, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license

data/lib/openc3/models/info_model.rb

@@ -3,21 +3,16 @@
 # 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.
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE.md for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2026, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/utilities/store'