cosmos 5.0.3 → 5.0.4

data/lib/cosmos/models/settings_model.rb

@@ -0,0 +1,55 @@
+# 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.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
+
+require 'cosmos/models/model'
+
+module Cosmos
+  class SettingsModel < Model
+    PRIMARY_KEY = 'cosmos__settings'
+
+    # 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(PRIMARY_KEY, name: name)
+    end
+
+    def self.names(scope: nil)
+      super(PRIMARY_KEY)
+    end
+
+    def self.all(scope: nil)
+      super(PRIMARY_KEY)
+    end
+    # END NOTE
+
+    def initialize(name:, scope: nil, data:)
+      super(PRIMARY_KEY, name: name, scope: scope)
+      @data = data
+    end
+
+    # @return [Hash] JSON encoding of this model
+    def as_json
+      {
+        'name' => @name,
+        'data' => @data,
+        'updated_at' => @updated_at
+      }
+    end
+  end
+end

data/lib/cosmos/models/sorted_model.rb

@@ -0,0 +1,165 @@
+# 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.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
+
+# https://www.rubydoc.info/gems/redis/Redis/Commands/SortedSets
+# https://redis.io/docs/manual/data-types/data-types-tutorial/#sorted-sets
+
+require 'cosmos/models/model'
+require 'cosmos/topics/calendar_topic'
+
+module Cosmos
+  # Put these under the Cosmos module so they are easily accessed in the controller as
+  # Cosmos::SortedError vs Cosmos::SortedModel::Error
+  class SortedError < StandardError; end
+  class SortedInputError < SortedError; end
+  class SortedOverlapError < SortedError; end
+
+  class SortedModel < Model
+    SORTED_TYPE = 'sorted'.freeze # To be overriden by base class
+    PRIMARY_KEY = '__SORTED'.freeze # To be overriden by base class
+
+    # MUST be overriden by any subclasses
+    def self.pk(scope)
+      "#{scope}#{PRIMARY_KEY}"
+    end
+
+    # @return [String|nil] String of the saved json or nil if start not found
+    def self.get(start:, scope:)
+      result = Store.zrangebyscore(self.pk(scope), start, start)
+      return JSON.parse(result[0]) unless result.empty?
+      nil
+    end
+
+    # @return [Array<Hash>] Array up to the limit of the models (as Hash objects) stored under the primary key
+    def self.all(scope:, limit: 100)
+      result = Store.zrevrangebyscore(self.pk(scope), '+inf', '-inf', limit: [0, limit])
+      result.map { |item| JSON.parse(item) }
+    end
+
+    # @return [String|nil] json or nil if metadata empty
+    def self.get_current_value(scope:)
+      start = Time.now.to_i
+      array = Store.zrevrangebyscore(self.pk(scope), start, '-inf', limit: [0, 1])
+      return nil if array.empty?
+      return array[0]
+    end
+
+    # @param start [Integer] Start time to return values (inclusive)
+    # @param stop [Integer] Stop time to return values (inclusive)
+    # @return [Array|nil] Array up to 100 of this model or empty array
+    def self.range(start:, stop:, scope:, limit: 100)
+      if start > stop
+        raise SortedInputError.new "start: #{start} must be before stop: #{stop}"
+      end
+      result = Store.zrangebyscore(self.pk(scope), start, stop, limit: [0, limit])
+      result.map { |item| JSON.parse(item) }
+    end
+
+    # @return [Integer] count of the members stored under the primary key
+    def self.count(scope:)
+      Store.zcard(self.pk(scope))
+    end
+
+    # Remove member from a sorted set
+    # @return [Integer] count of the members removed, 0 if not found
+    def self.destroy(scope:, start:)
+      Store.zremrangebyscore(self.pk(scope), start, start)
+    end
+
+    # Remove members from min to max of the sorted set.
+    # @return [Integer] count of the members removed
+    def self.range_destroy(scope:, start:, stop:)
+      Store.zremrangebyscore(self.pk(scope), start, stop)
+    end
+
+    attr_reader :start
+
+    # @param [Integer] start - start used to store data
+    # @param [String] scope - Cosmos scope to track event to
+    # @param [Anything] kwargs - Any kwargs to store in the JSON
+    def initialize(start:, scope:, type: SORTED_TYPE, **kwargs)
+      # Name becomes the start in the base class
+      super(self.class.pk(scope), name: start.to_s, scope: scope, **kwargs)
+      @type = type # For the as_json, from_json round trip
+      @start = start
+    end
+
+    # start MUST be a positive integer
+    def validate_start(update: false)
+      unless @start.is_a?(Integer)
+        raise SortedInputError.new "start must be integer: #{@start}"
+      end
+      if @start.to_i < 0
+        raise SortedInputError.new "start must be positive: #{@start}"
+      end
+      if !update and self.class.get(start: @start, scope: @scope)
+        raise SortedOverlapError.new "duplicate, existing data at #{@start}"
+      end
+      @start = @start.to_i
+    end
+
+    # Update the Redis hash at primary_key based on the initial passed start
+    # The member is set to the JSON generated via calling as_json
+    def create(update: false)
+      validate_start(update: update)
+      @updated_at = Time.now.to_nsec_from_epoch
+      Store.zadd(@primary_key, @start, JSON.generate(as_json()))
+      if update
+        notify(kind: 'updated')
+      else
+        notify(kind: 'created')
+      end
+    end
+
+    # Update the Redis hash at primary_key
+    def update(start:)
+      @start = start
+      create(update: true)
+    end
+
+    # destroy the activity from the redis database
+    def destroy
+      self.class.destroy(scope: @scope, start: @start)
+      notify(kind: 'deleted')
+    end
+
+    # @return [] update the redis stream / timeline topic that something has changed
+    def notify(kind:, extra: nil)
+      notification = {
+        'data' => JSON.generate(as_json()),
+        'kind' => kind,
+        'type' => 'calendar',
+      }
+      notification['extra'] = extra unless extra.nil?
+      begin
+        CalendarTopic.write_entry(notification, scope: @scope)
+      rescue StandardError => e
+        raise SortedError.new "Failed to write to stream: #{notification}, #{e}"
+      end
+    end
+
+    # @return [Hash] JSON encoding of this model
+    def as_json
+      { **super(),
+        'start' => @start,
+        'type' => SORTED_TYPE,
+      }
+    end
+  end
+end

data/lib/cosmos/models/target_model.rb

@@ -208,7 +208,7 @@ module Cosmos
         tlm_log_cycle_time: tlm_log_cycle_time, tlm_log_cycle_size: tlm_log_cycle_size,
         tlm_log_retain_time: tlm_log_retain_time,
         tlm_decom_log_cycle_time: tlm_decom_log_cycle_time, tlm_decom_log_cycle_size: tlm_decom_log_cycle_size,
-        tlm_decom_log_retain_time: tlm_decom_log_retain_time, 
+        tlm_decom_log_retain_time: tlm_decom_log_retain_time,
         reduced_minute_log_retain_time: reduced_minute_log_retain_time,
         reduced_hour_log_retain_time: reduced_hour_log_retain_time, reduced_day_log_retain_time: reduced_day_log_retain_time,
         cleanup_poll_time: cleanup_poll_time, needs_dependencies: needs_dependencies,
@@ -269,7 +269,7 @@ module Cosmos
         'tlm_decom_log_retain_time' => @tlm_decom_log_retain_time,
         'reduced_minute_log_retain_time' => @reduced_minute_log_retain_time,
         'reduced_hour_log_retain_time' => @reduced_hour_log_retain_time,
-        'reduced_day_log_retain_time' => @reduced_day_log_retain_time,        
+        'reduced_day_log_retain_time' => @reduced_day_log_retain_time,
         'cleanup_poll_time' => @cleanup_poll_time,
         'needs_dependencies' => @needs_dependencies,
       }
@@ -301,7 +301,7 @@ module Cosmos
       when 'CMD_DECOM_LOG_RETAIN_TIME'
         parser.verify_num_parameters(1, 1, "#{keyword} <Retention time for cmd decom log files in seconds - nil = Forever>")
         @cmd_decom_log_retain_time = ConfigParser.handle_nil(parameters[0])
-        @cmd_decom_log_retain_time = @cmd_decom_log_retain_time.to_i if @cmd_decom_log_retain_time        
+        @cmd_decom_log_retain_time = @cmd_decom_log_retain_time.to_i if @cmd_decom_log_retain_time
       when 'TLM_LOG_CYCLE_TIME'
         parser.verify_num_parameters(1, 1, "#{keyword} <Maximum time between files in seconds>")
         @tlm_log_cycle_time = parameters[0].to_i
@@ -311,7 +311,7 @@ module Cosmos
       when 'TLM_LOG_RETAIN_TIME'
         parser.verify_num_parameters(1, 1, "#{keyword} <Retention time for tlm log files in seconds - nil = Forever>")
         @tlm_log_retain_time = ConfigParser.handle_nil(parameters[0])
-        @tlm_log_retain_time = @tlm_log_retain_time.to_i if @tlm_log_retain_time        
+        @tlm_log_retain_time = @tlm_log_retain_time.to_i if @tlm_log_retain_time
       when 'TLM_DECOM_LOG_CYCLE_TIME'
         parser.verify_num_parameters(1, 1, "#{keyword} <Maximum time between files in seconds>")
         @tlm_decom_log_cycle_time = parameters[0].to_i
@@ -333,22 +333,22 @@ module Cosmos
       when 'REDUCED_DAY_LOG_RETAIN_TIME'
         parser.verify_num_parameters(1, 1, "#{keyword} <Retention time for reduced day log files in seconds - nil = Forever>")
         @reduced_day_log_retain_time = ConfigParser.handle_nil(parameters[0])
-        @reduced_day_log_retain_time = @reduced_day_log_retain_time.to_i if @reduced_day_log_retain_time                
+        @reduced_day_log_retain_time = @reduced_day_log_retain_time.to_i if @reduced_day_log_retain_time
       when 'LOG_RETAIN_TIME'
         parser.verify_num_parameters(1, 1, "#{keyword} <Retention time for all log files in seconds - nil = Forever>")
         log_retain_time = ConfigParser.handle_nil(parameters[0])
-        if log_retain_time 
+        if log_retain_time
           @cmd_log_retain_time = log_retain_time.to_i
-          @cmd_decom_log_retain_time = log_retain_time.to_i   
+          @cmd_decom_log_retain_time = log_retain_time.to_i
           @tlm_log_retain_time = log_retain_time.to_i
           @tlm_decom_log_retain_time = log_retain_time.to_i
-        end     
+        end
       when 'REDUCED_LOG_RETAIN_TIME'
         parser.verify_num_parameters(1, 1, "#{keyword} <Retention time for all reduced log files in seconds - nil = Forever>")
         reduced_log_retain_time = ConfigParser.handle_nil(parameters[0])
-        if reduced_log_retain_time 
+        if reduced_log_retain_time
           @reduced_minute_log_retain_time = reduced_log_retain_time.to_i
-          @reduced_hour_log_retain_time = reduced_log_retain_time.to_i   
+          @reduced_hour_log_retain_time = reduced_log_retain_time.to_i
           @reduced_day_log_retain_time = reduced_log_retain_time.to_i
         end
       when 'CLEANUP_POLL_TIME'
@@ -380,7 +380,7 @@ module Cosmos
           data = File.read(filename, mode: "rb")
           begin
             Cosmos.set_working_dir(File.dirname(filename)) do
-              data = ERB.new(data).result(binding.set_variables(variables)) if data.is_printable? and File.basename(filename)[0] != '_'
+              data = ERB.new(data, trim_mode: "-").result(binding.set_variables(variables)) if data.is_printable? and File.basename(filename)[0] != '_'
             end
           rescue => error
             raise "ERB error parsing: #{filename}: #{error.formatted}"
@@ -413,12 +413,12 @@ module Cosmos
         Store.hdel("#{@scope}__limits_groups", group)
       end
       self.class.packets(@name, type: :CMD, scope: @scope).each do |packet|
-        Store.del("#{@scope}__COMMAND__{#{@name}}__#{packet['packet_name']}")
-        Store.del("#{@scope}__DECOMCMD__{#{@name}}__#{packet['packet_name']}")
+        Topic.del("#{@scope}__COMMAND__{#{@name}}__#{packet['packet_name']}")
+        Topic.del("#{@scope}__DECOMCMD__{#{@name}}__#{packet['packet_name']}")
       end
       self.class.packets(@name, scope: @scope).each do |packet|
-        Store.del("#{@scope}__TELEMETRY__{#{@name}}__#{packet['packet_name']}")
-        Store.del("#{@scope}__DECOM__{#{@name}}__#{packet['packet_name']}")
+        Topic.del("#{@scope}__TELEMETRY__{#{@name}}__#{packet['packet_name']}")
+        Topic.del("#{@scope}__DECOM__{#{@name}}__#{packet['packet_name']}")
         CvtModel.del(target_name: @name, packet_name: packet['packet_name'], scope: @scope)
         LimitsEventTopic.delete(@name, packet['packet_name'], scope: @scope)
       end
@@ -455,7 +455,7 @@ module Cosmos
 
       begin
         Cosmos.set_working_dir(File.dirname(path)) do
-          return ERB.new(File.read(path)).result(b)
+          return ERB.new(File.read(path), trim_mode: "-").result(b)
         end
       rescue => error
         raise "ERB error parsing: #{path}: #{error.formatted}"
@@ -585,10 +585,10 @@ module Cosmos
         # No telemetry packets for this target
       end
       # It's ok to call initialize_streams with an empty array
-      Store.initialize_streams(command_topic_list)
-      Store.initialize_streams(decom_command_topic_list)
-      Store.initialize_streams(packet_topic_list)
-      Store.initialize_streams(decom_topic_list)
+      Topic.initialize_streams(command_topic_list)
+      Topic.initialize_streams(decom_command_topic_list)
+      Topic.initialize_streams(packet_topic_list)
+      Topic.initialize_streams(decom_topic_list)
 
       unless command_topic_list.empty?
         # CommandLog Microservice

data/lib/cosmos/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.
+#
+# This program may also be used under the terms of a commercial or
+# enterprise edition license of COSMOS if purchased from the
+# copyright holder
+
+module Cosmos
+  class ToolConfigModel
+    def self.list_configs(tool, scope: $cosmos_scope)
+      Store.hkeys("#{scope}__config__#{tool}")
+    end
+
+    def self.load_config(tool, name, scope: $cosmos_scope)
+      Store.hget("#{scope}__config__#{tool}", name)
+    end
+
+    def self.save_config(tool, name, data, scope: $cosmos_scope)
+      Store.hset("#{scope}__config__#{tool}", name, data)
+    end
+
+    def self.delete_config(tool, name, scope: $cosmos_scope)
+      Store.hdel("#{scope}__config__#{tool}", name)
+    end
+  end
+end

data/lib/cosmos/models/tool_model.rb

@@ -231,7 +231,7 @@ module Cosmos
 
         # Load tool files
         data = File.read(filename, mode: "rb")
-        data = ERB.new(data).result(binding.set_variables(variables)) if data.is_printable?
+        data = ERB.new(data, trim_mode: "-").result(binding.set_variables(variables)) if data.is_printable?
         rubys3_client.put_object(bucket: 'tools', content_type: content_type, cache_control: cache_control, key: key, body: data)
       end
     end

data/lib/cosmos/models/widget_model.rb

@@ -121,7 +121,7 @@ module Cosmos
       # Load widget file
       data = File.read(filename, mode: "rb")
       Cosmos.set_working_dir(File.dirname(filename)) do
-        data = ERB.new(data).result(binding.set_variables(variables)) if data.is_printable?
+        data = ERB.new(data, trim_mode: "-").result(binding.set_variables(variables)) if data.is_printable?
       end
       # TODO: support widgets that aren't just a single js file (and its associated map file)
       rubys3_client.put_object(bucket: 'tools', content_type: 'application/javascript', cache_control: cache_control, key: @s3_key, body: data)

data/lib/cosmos/operators/microservice_operator.rb

@@ -39,7 +39,7 @@ module Cosmos
     end
 
     def convert_microservice_to_process_definition(microservice_name, microservice_config)
-      process_definition = ["ruby", "plugin_microservice.rb", microservice_name]
+      process_definition = ["ruby", "plugin_microservice.rb"]
       work_dir = "/cosmos/lib/cosmos/microservices"
       env = microservice_config["env"].dup
       if microservice_config["needs_dependencies"]
@@ -47,6 +47,7 @@ module Cosmos
       else
         env['GEM_HOME'] = nil
       end
+      env['COSMOS_MICROSERVICE_NAME'] = microservice_name
       container = microservice_config["container"]
       scope = microservice_name.split("__")[0]
       return process_definition, work_dir, env, scope, container

data/lib/cosmos/script/calendar.rb

@@ -18,6 +18,7 @@
 # copyright holder
 
 require 'cosmos/script/extract'
+require 'time'
 
 module Cosmos
   module Script
@@ -25,38 +26,48 @@ module Cosmos
 
     private
 
-    # Sets the metadata value for a target
+    # Gets the current metadata
     #
-    # @param target [String] Target to set metadata on
     # @return The result of the method call.
-    def get_metadata(target)
-      endpoint = "/cosmos-api/metadata/_get/#{target}"
-      response = $api_server.request('get', endpoint)
+    def get_metadata()
+      response = $api_server.request('get', "/cosmos-api/metadata/latest")
       return nil if response.nil? || response.code != 200
       return JSON.parse(response.body)
     end
 
-    # Sets the metadata value for a target
+    # Sets the metadata
     #
-    # @param target [String] Target to set metadata on
     # @param metadata [Hash<Symbol, Variable>] A hash of metadata
-    # @param color [String] Events color to show on Calendar tool
-    # @param start (optional) [String] Metadata time value if nil will default to current time
+    # @param color [String] Events color to show on Calendar tool, if nil will be blue
+    # @param start [Time] Metadata time value, if nil will be current time
     # @return The result of the method call.
-    def set_metadata(target, metadata, color: nil, start: nil)
+    def set_metadata(metadata, color: nil, start: nil)
       color = color.nil? ? '#003784' : color
-      data = {:color => color, :metadata => metadata, :target => target}
-      data[:start] = start unless start.nil?
+      data = { color: color, metadata: metadata }
+      data[:start] = start.iso8601 unless start.nil?
       response = $api_server.request('post', '/cosmos-api/metadata', data: data, json: true)
       return nil if response.nil? || response.code != 201
       return JSON.parse(response.body)
     end
 
-    # Requests the metadata from the user for a target
+    # Updates the metadata
     #
-    def input_metadata(*args, **kwargs)
-      rasie StandardError "can only be used in script-runner"
+    # @param start [Integer] Metadata time value as integer seconds from epoch
+    # @param metadata [Hash<Symbol, Variable>] A hash of metadata
+    # @param color [String] Events color to show on Calendar tool, if nil will be blue
+    # @return The result of the method call.
+    def update_metadata(start, metadata, color: nil)
+      color = color.nil? ? '#003784' : color
+      data = { :color => color, :metadata => metadata }
+      data[:start] = Time.at(start).iso8601
+      response = $api_server.request('put', "/cosmos-api/metadata/#{start}", data: data, json: true)
+      return nil if response.nil? || response.code != 201
+      return JSON.parse(response.body)
     end
 
+    # Requests the metadata from the user for a target
+    def input_metadata(*args, **kwargs)
+      raise StandardError "can only be used in Script Runner"
+    end
   end
 end

data/lib/cosmos/system/system.rb

@@ -26,6 +26,7 @@ require 'cosmos/packets/limits'
 require 'cosmos/system/target'
 require 'cosmos/utilities/s3'
 require 'cosmos/utilities/zip'
+require 'cosmos/models/scope_model'
 require 'thread'
 require 'fileutils'
 
@@ -54,7 +55,7 @@ module Cosmos
 
     # @return [Symbol] The current limits_set of the system returned from Redis
     def self.limits_set
-      Store.hget("#{$cosmos_scope}__cosmos_system", 'limits_set').intern
+      ScopeModel.limits_set(scope: $cosmos_scope)
     end
 
     def self.setup_targets(target_names, base_dir, scope:)

data/lib/cosmos/top_level.rb

@@ -37,9 +37,13 @@ class HazardousError < StandardError
   attr_accessor :cmd_name
   attr_accessor :cmd_params
   attr_accessor :hazardous_description
+  attr_accessor :formatted # formatted command for use in resending original
 
   def to_s
-    "#{target_name} #{cmd_name} with #{cmd_params} is Hazardous due to #{hazardous_description}"
+    string = "#{target_name} #{cmd_name} with #{cmd_params} is Hazardous"
+    string << "due to '#{hazardous_description}'" if hazardous_description
+    # Pass along the original formatted command so it can be resent
+    string << ".\n#{formatted}"
   end
 end
 

data/lib/cosmos/topics/autonomic_topic.rb

@@ -26,7 +26,7 @@ module Cosmos
     # Notify to the topic
     #
     # ```json
-    #  {  
+    #  {
     #    "kind" => "created",
     #    "type" => "trigger",
     #    "data" => {
@@ -46,7 +46,7 @@ module Cosmos
     #  }
     # ```
     def self.write_notification(notification, scope:)
-      Store.write_topic("#{scope}#{PRIMARY_KEY}", notification, '*', 1000)
+      Topic.write_topic("#{scope}#{PRIMARY_KEY}", notification, '*', 1000)
     end
   end
 end

data/lib/cosmos/topics/calendar_topic.rb

@@ -38,7 +38,7 @@ module Cosmos
     #  }
     # ```
     def self.write_entry(entry, scope:)
-      Store.write_topic("#{scope}#{PRIMARY_KEY}", entry, '*', 1000)
+      Topic.write_topic("#{scope}#{PRIMARY_KEY}", entry, '*', 1000)
     end
   end
 end

data/lib/cosmos/topics/command_decom_topic.rb

@@ -40,7 +40,37 @@ module Cosmos
         json_hash[item.name + "__U"] = packet.read_item(item, :WITH_UNITS) if item.units
       end
       msg_hash['json_data'] = JSON.generate(json_hash.as_json)
-      Store.write_topic(topic, msg_hash)
+      Topic.write_topic(topic, msg_hash)
+    end
+
+    def self.get_cmd_item(target_name, packet_name, param_name, type: :WITH_UNITS, scope: $cosmos_scope)
+      msg_id, msg_hash = Topic.get_newest_message("#{scope}__DECOMCMD__{#{target_name}}__#{packet_name}")
+      if msg_id
+        # TODO: We now have these reserved items directly on command packets
+        # Do we still calculate from msg_hash['time'] or use the times directly?
+        #
+        # if param_name == 'RECEIVED_TIMESECONDS' || param_name == 'PACKET_TIMESECONDS'
+        #   Time.from_nsec_from_epoch(msg_hash['time'].to_i).to_f
+        # elsif param_name == 'RECEIVED_TIMEFORMATTED' || param_name == 'PACKET_TIMEFORMATTED'
+        #   Time.from_nsec_from_epoch(msg_hash['time'].to_i).formatted
+        if param_name == 'RECEIVED_COUNT'
+          msg_hash['received_count'].to_i
+        else
+          json = msg_hash['json_data']
+          hash = JSON.parse(json)
+          # Start from the most complex down to the basic raw value
+          value = hash["#{param_name}__U"]
+          return value if value && type == :WITH_UNITS
+
+          value = hash["#{param_name}__F"]
+          return value if value && (type == :WITH_UNITS || type == :FORMATTED)
+
+          value = hash["#{param_name}__C"]
+          return value if value && (type == :WITH_UNITS || type == :FORMATTED || type == :CONVERTED)
+
+          return hash[param_name]
+        end
+      end
     end
   end
 end

data/lib/cosmos/topics/command_topic.rb

@@ -31,17 +31,17 @@ module Cosmos
                    received_count: packet.received_count,
                    stored: packet.stored,
                    buffer: packet.buffer(false) }
-      Store.write_topic(topic, msg_hash)
+      Topic.write_topic(topic, msg_hash)
     end
 
     # @param command [Hash] Command hash structure read to be written to a topic
     def self.send_command(command, scope:)
       ack_topic = "{#{scope}__ACKCMD}TARGET__#{command['target_name']}"
-      Store.update_topic_offsets([ack_topic])
+      Topic.update_topic_offsets([ack_topic])
       # Save the existing cmd_params Hash and JSON generate before writing to the topic
       cmd_params = command['cmd_params']
       command['cmd_params'] = JSON.generate(command['cmd_params'].as_json)
-      cmd_id = Store.write_topic("{#{scope}__CMD}TARGET__#{command['target_name']}", command, '*', 100)
+      cmd_id = Topic.write_topic("{#{scope}__CMD}TARGET__#{command['target_name']}", command, '*', 100)
       # TODO: This timeout is fine for most but can we get the write_timeout from the interface here?
       time = Time.now
       while (Time.now - time) < COMMAND_ACK_TIMEOUT_S
@@ -66,7 +66,7 @@ module Cosmos
     ###########################################################################
 
     def self.raise_hazardous_error(msg_hash, target_name, cmd_name, cmd_params)
-      _, description, _ = msg_hash["result"].split("\n")
+      _, description, formatted = msg_hash["result"].split("\n")
       # Create and populate a new HazardousError and raise it up
       # The _cmd method in script/commands.rb rescues this and calls prompt_for_hazardous
       error = HazardousError.new
@@ -74,6 +74,8 @@ module Cosmos
       error.cmd_name = cmd_name
       error.cmd_params = cmd_params
       error.hazardous_description = description
+      error.formatted = formatted
+
       # No Logger.info because the error is already logged by the Logger.info "Ack Received ...
       raise error
     end