cosmos 5.0.2.pre.beta2 → 5.0.4

data/lib/cosmos/script/api_shared.rb

@@ -300,10 +300,10 @@ module Cosmos
     #
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED, or :WITH_UNITS
-    def wait_check(*args, type: :CONVERTED, scope: $cosmos_scope, token: $cosmos_token)
+    def wait_check(*args, type: :CONVERTED, scope: $cosmos_scope, token: $cosmos_token, &block)
       target_name, packet_name, item_name, comparison_to_eval, timeout, polling_rate = _wait_check_process_args(args, scope: scope, token: token)
       start_time = Time.now.sys
-      success, value = cosmos_script_wait_implementation(target_name, packet_name, item_name, type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token)
+      success, value = cosmos_script_wait_implementation(target_name, packet_name, item_name, type, comparison_to_eval, timeout, polling_rate, scope: scope, token: token, &block)
       time = Time.now.sys - start_time
       check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
       with_value_str = "with value == #{value} after waiting #{time} seconds"
@@ -321,8 +321,8 @@ module Cosmos
     end
 
     # @deprecated use wait_check with type: :RAW
-    def wait_check_raw(*args, scope: $cosmos_scope, token: $cosmos_token)
-      wait_check(*args, type: :RAW, scope: scope, token: token)
+    def wait_check_raw(*args, scope: $cosmos_scope, token: $cosmos_token, &block)
+      wait_check(*args, type: :RAW, scope: scope, token: token, &block)
     end
 
     # Wait for the value of a telmetry item to be within a tolerance of a value
@@ -334,7 +334,7 @@ module Cosmos
     #
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW or :CONVERTED (default)
-    def wait_check_tolerance(*args, type: :CONVERTED, scope: $cosmos_scope, token: $cosmos_token)
+    def wait_check_tolerance(*args, type: :CONVERTED, scope: $cosmos_scope, token: $cosmos_token, &block)
       raise "Invalid type '#{type}' for wait_check_tolerance" unless %i(RAW CONVERTED).include?(type)
 
       target_name, packet_name, item_name, expected_value, tolerance, timeout, polling_rate = _wait_tolerance_process_args(args, scope: scope, token: token)
@@ -343,7 +343,7 @@ module Cosmos
       if value.is_a?(Array)
         expected_value, tolerance = array_tolerance_process_args(value.size, expected_value, tolerance, 'wait_check_tolerance', scope: scope, token: token)
 
-        success, value = cosmos_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token)
+        success, value = cosmos_script_wait_implementation_array_tolerance(value.size, target_name, packet_name, item_name, type, expected_value, tolerance, timeout, polling_rate, scope: scope, token: token, &block)
         time = Time.now.sys - start_time
 
         message = ""
@@ -388,8 +388,8 @@ module Cosmos
     end
 
     # @deprecated Use wait_check_tolerance with type: :RAW
-    def wait_check_tolerance_raw(*args, scope: $cosmos_scope, token: $cosmos_token)
-      wait_check_tolerance(*args, type: :RAW, scope: scope, token: token)
+    def wait_check_tolerance_raw(*args, scope: $cosmos_scope, token: $cosmos_token, &block)
+      wait_check_tolerance(*args, type: :RAW, scope: scope, token: token, &block)
     end
 
     # Wait on an expression to be true.  On a timeout, the script will pause.
@@ -397,12 +397,12 @@ module Cosmos
                               timeout,
                               polling_rate = DEFAULT_TLM_POLLING_RATE,
                               context = nil,
-                              scope: $cosmos_scope, token: $cosmos_token)
+                              scope: $cosmos_scope, token: $cosmos_token, &block)
       start_time = Time.now.sys
       success = cosmos_script_wait_implementation_expression(exp_to_eval,
                                                              timeout,
                                                              polling_rate,
-                                                             context, scope: scope, token: token)
+                                                             context, scope: scope, token: token, &block)
       time = Time.now.sys - start_time
       if success
         Logger.info "CHECK: #{exp_to_eval} is TRUE after waiting #{time} seconds"
@@ -691,15 +691,20 @@ module Cosmos
       return [target_name, packet_name, item_name, comparison_to_eval, timeout, polling_rate]
     end
 
-    def _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, scope: $cosmos_scope, token: $cosmos_token)
+    def _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: $cosmos_scope, token: $cosmos_token, &block)
       end_time = Time.now.sys + timeout
-      exp_to_eval = yield
 
       while true
         work_start = Time.now.sys
         value = tlm(target_name, packet_name, item_name, type: value_type, scope: scope, token: token)
-        if eval(exp_to_eval)
-          return true, value
+        if not block.nil?
+          if block.call(value)
+            return true, value
+          end
+        else
+          if eval(exp_to_eval)
+            return true, value
+          end
         end
         break if Time.now.sys >= end_time
 
@@ -724,25 +729,25 @@ module Cosmos
     end
 
     # Wait for a converted telemetry item to pass a comparison
-    def cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token)
-      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, scope: scope, token: token) do
-        "value " + comparison_to_eval
+    def cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token, &block)
+      if comparison_to_eval
+        exp_to_eval = "value " + comparison_to_eval
+      else
+        exp_to_eval = nil
       end
+      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
-    def cosmos_script_wait_implementation_tolerance(target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token)
-      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, scope: scope, token: token) do
-        "((#{expected_value} - #{tolerance})..(#{expected_value} + #{tolerance})).include? value"
-      end
+    def cosmos_script_wait_implementation_tolerance(target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token, &block)
+      exp_to_eval = "((#{expected_value} - #{tolerance})..(#{expected_value} + #{tolerance})).include? value"
+      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
-    def cosmos_script_wait_implementation_array_tolerance(array_size, target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token)
+    def cosmos_script_wait_implementation_array_tolerance(array_size, target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $cosmos_scope, token: $cosmos_token, &block)
       statements = []
       array_size.times { |i| statements << "(((#{expected_value[i]} - #{tolerance[i]})..(#{expected_value[i]} + #{tolerance[i]})).include? value[#{i}])" }
       exp_to_eval = statements.join(" && ")
-      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, scope: scope, token: token) do
-        exp_to_eval
-      end
+      _cosmos_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
     end
 
     # Wait on an expression to be true.

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/script/commands.rb

@@ -112,13 +112,11 @@ module Cosmos
           target_name, cmd_name, cmd_params = $api_server.method_missing(cmd, *args)
           _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
         rescue HazardousError => e
-          ok_to_proceed = prompt_for_hazardous(e.target_name, e.cmd_name, e.hazardous_description)
-          if ok_to_proceed
-            target_name, cmd_name, cmd_params = $api_server.method_missing(cmd_no_hazardous, *args)
-            _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
-          else
-            retry unless prompt_for_script_abort()
-          end
+          # This opens a prompt at which point they can cancel and stop the script
+          # or say Yes and send the command. Thus we don't care about the return value.
+          prompt_for_hazardous(e.target_name, e.cmd_name, e.hazardous_description)
+          target_name, cmd_name, cmd_params = $api_server.method_missing(cmd_no_hazardous, *args)
+          _log_cmd(target_name, cmd_name, cmd_params, raw, no_range, no_hazardous)
         end
       end
     end

data/lib/cosmos/script/script.rb

@@ -129,58 +129,38 @@ module Cosmos
       message_box(string, *items, **options)
     end
 
-    def _file_dialog(message, directory, filter, select_files = true)
+    def _file_dialog(title, message, filter:)
       answer = ''
-      files = Dir["#{directory}/#{filter}"]
-      if select_files
-        files.select! { |f| !File.directory? f }
-      else
-        files.select! { |f| File.directory? f }
-      end
+      path = "./*"
+      path += filter if filter
+      files = Dir[path]
+      files.select! { |f| !File.directory? f }
       while answer.empty?
-        print message + "\n" + files.join("\n") + "\n<Type file name>:"
+        print "#{title}\n#{message}\n#{files.join("\n")}\n<Type file name>:"
         answer = gets
         answer.chomp!
       end
       return answer
     end
 
-    def save_file_dialog(directory, message = "Save File", filter = "*")
-      _file_dialog(message, directory, filter)
-    end
-
-    def open_file_dialog(directory, message = "Open File", filter = "*")
-      _file_dialog(message, directory, filter)
-    end
-
-    def open_files_dialog(directory, message = "Open File(s)", filter = "*")
-      _file_dialog(message, directory, filter)
+    def open_file_dialog(title, message = "Open File", filter:)
+      _file_dialog(title, message, filter)
     end
 
-    def open_directory_dialog(directory, message = "Open Directory")
-      _file_dialog(message, directory, "*", false)
+    def open_files_dialog(title, message = "Open File(s)", filter:)
+      _file_dialog(title, message, filter)
     end
 
     def prompt_for_hazardous(target_name, cmd_name, hazardous_description)
-      message = "Warning: Command #{target_name} #{cmd_name} is Hazardous. "
-      message << "\n#{hazardous_description}\n" if hazardous_description
-      message << "Send? (y,n): "
-      print message
-      answer = gets.chomp
-      if answer.downcase == 'y'
-        return true
-      else
-        return false
-      end
-    end
-
-    def prompt_for_script_abort
-      print "Stop running script? (y,n): "
-      answer = gets.chomp
-      if answer.downcase == 'y'
-        exit
-      else
-        return false # Not aborted - Retry
+      loop do
+        message = "Warning: Command #{target_name} #{cmd_name} is Hazardous. "
+        message << "\n#{hazardous_description}\n" if hazardous_description
+        message << "Send? (y): "
+        print message
+        answer = gets.chomp
+        if answer.downcase == 'y'
+          return true
+        end
       end
     end
 

data/lib/cosmos/script/storage.rb

@@ -23,137 +23,124 @@ module Cosmos
   module Script
     private
 
-    # Get a handle to access a target file
+    # Delete a file on a target
+    #
+    # @param [String] Path to a file in a target directory
+    def delete_target_file(path, scope: $cosmos_scope)
+      begin
+        # Only delete from the targets_modified
+        delete_path = "#{scope}/targets_modified/#{path}"
+        endpoint = "/cosmos-api/storage/delete/#{delete_path}"
+        Cosmos::Logger.info "Deleting #{delete_path}"
+        response = $api_server.request('delete', endpoint, query: {bucket: 'config'})
+        if response.nil? || response.code != 200
+          raise "Failed to delete #{delete_path}. Note: #{scope}/targets is read-only."
+        end
+      rescue => error
+        raise "Failed deleting #{path} due to #{error.message}"
+      end
+      nil
+    end
+
+    # Get a handle to write a target file
     #
     # @param path [String] Path to a file in a target directory
-    # @param original [Boolean] Whether to get the original or modified file
-    # @return [File|nil]
-    def get_target_file(path, original: false, scope: $cosmos_scope)
-      # Create Tempfile to store data
-      file = Tempfile.new('target', binmode: true)
+    # @param io_or_string [Io or String] IO object
+    def put_target_file(path, io_or_string, scope: $cosmos_scope)
+      raise "Disallowed path modifier '..' found in #{path}" if path.include?('..')
+      upload_path = "#{scope}/targets_modified/#{path}"
+      endpoint = "/cosmos-api/storage/upload/#{upload_path}"
+      Cosmos::Logger.info "Writing #{upload_path}"
+      result = _get_presigned_request(endpoint)
 
-      # Get presigned url
-      if original
-        part = "targets"
-      else
-        part = "targets_modified"
-      end
-      # Loop to allow redo
-      loop do
-        endpoint = "/cosmos-api/storage/download/#{scope}/#{part}/#{path}"
-        Cosmos::Logger.info "Reading #{scope}/#{part}/#{path}"
-        if $cosmos_in_cluster
-          response = $api_server.request('get', endpoint, query: {bucket: 'config', internal: true})
-        else
-          response = $api_server.request('get', endpoint, query: {bucket: 'config'})
-        end
-        if response.nil? || response.code != 201
-          Cosmos::Logger.error "Failed Get Presigned URL for #{scope}/#{part}/#{path}"
-          if part == "targets_modified"
-            part = "targets"
-            redo
+      # Try to put the file
+      success = false
+      begin
+        uri = _get_uri(result['url'])
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          request = Net::HTTP::Put.new(uri, {'Content-Length' => io_or_string.length.to_s})
+          if String === io_or_string
+            request.body = io_or_string
           else
-            raise "#{path} not found"
+            request.body_stream = io_or_string
+          end
+          result = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+            http.request(request)
           end
+          return result
         end
-        result = JSON.parse(response.body)
+      rescue => error
+        raise "Failed to write #{upload_path}"
+      end
+      nil
+    end
 
-        # Try to get the file
+    # Get a handle to access a target file
+    #
+    # @param path [String] Path to a file in a target directory, e.g. "INST/procedures/test.rb"
+    # @param original [Boolean] Whether to get the original or modified file
+    # @return [File|nil]
+    def get_target_file(path, original: false, scope: $cosmos_scope)
+      part = "targets"
+      part += "_modified" unless original
+      # Loop to allow redo when switching from modified to original
+      loop do
         begin
-          if $cosmos_in_cluster
-            uri = URI.parse("http://cosmos-minio:9000" + result['url'])
-          else
-            uri = URI.parse($api_server.generate_url + result['url'])
-          end
-          Net::HTTP.start(uri.host, uri.port) do |http|
-            request = Net::HTTP::Get.new uri
-
-            http.request request do |response|
-              response.read_body do |chunk|
-                puts chunk.length
-                file.write chunk
-              end
-            end
-            file.rewind
-          end
-          return file
+          return _get_storage_file("#{part}/#{path}", scope: scope)
         rescue => error
-          Cosmos::Logger.info("#{scope}/#{part}/#{path} not found")
           if part == "targets_modified"
             part = "targets"
             redo
           else
-            raise "#{path} not found"
+            raise error
           end
         end
         break
       end
     end
 
-    # Get a handle to write a target file
-    #
-    # @param path [String] Path to a file in a target directory
-    # @param io_or_string [Io or String] IO object
-    def put_target_file(path, io_or_string, scope: $cosmos_scope)
-      # Get presigned url
-      part = "targets_modified"
-      begin
-        endpoint = "/cosmos-api/storage/upload/#{scope}/#{part}/#{path}"
-        Cosmos::Logger.info "Writing #{scope}/#{part}/#{path}"
-        if $cosmos_in_cluster
-          response = $api_server.request('get', endpoint, query: {bucket: 'config', internal: true})
-        else
-          response = $api_server.request('get', endpoint, query: {bucket: 'config'})
-        end
-        if response.nil? || response.code != 201
-          Cosmos::Logger.error "Failed Get Presigned URL for #{scope}/#{part}/#{path}"
-          return nil
-        end
-        result = JSON.parse(response.body)
+    # These are helper methods ... should not be used directly
 
-        # Try to put the file
-        success = false
-        begin
-          if $cosmos_in_cluster
-            uri = URI.parse("http://cosmos-minio:9000" + result['url'])
-          else
-            uri = URI.parse($api_server.generate_url + result['url'])
-          end
-          Net::HTTP.start(uri.host, uri.port) do |http|
-            request = Net::HTTP::Put.new(uri, {'Content-Length' => io_or_string.length.to_s})
-            if String === io_or_string
-              request.body = io_or_string
-            else
-              request.body_stream = io_or_string
-            end
-            result = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
-              http.request(request)
-            end
-            return result
+    def _get_storage_file(path, scope: $cosmos_scope)
+      # Create Tempfile to store data
+      file = Tempfile.new('target', binmode: true)
+
+      endpoint = "/cosmos-api/storage/download/#{scope}/#{path}"
+      Cosmos::Logger.info "Reading #{scope}/#{path}"
+      result = _get_presigned_request(endpoint)
+
+      # Try to get the file
+      uri = _get_uri(result['url'])
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        request = Net::HTTP::Get.new uri
+        http.request request do |response|
+          response.read_body do |chunk|
+            file.write chunk
           end
-        rescue => error
-          raise "Failed to write #{scope}/#{part}/#{path}"
         end
+        file.rewind
       end
-      nil
+      return file
     end
 
-    # Delete a file on a target
-    #
-    # @param [String] Path to a file in a target directory
-    def delete_target_file(path, scope: $cosmos_scope)
-      begin
-        # Only delete from the targets_modified
-        endpoint = "/cosmos-api/storage/delete/#{scope}/targets_modified/#{path}"
-        Cosmos::Logger.info "Deleting #{scope}/targets_modified/#{path}"
-        response = $api_server.request('delete', endpoint, query: {bucket: 'config'})
-        if response.nil? || response.code != 200
-          raise "Failed to delete #{scope}/targets_modified/#{path}"
-        end
-      rescue => error
-        raise "Failed deleting #{path} due to #{error.message}"
+    def _get_uri(url)
+      if $cosmos_in_cluster
+        uri = URI.parse("http://cosmos-minio:9000" + url)
+      else
+        uri = URI.parse($api_server.generate_url + url)
       end
-      nil
+    end
+
+    def _get_presigned_request(endpoint)
+      if $cosmos_in_cluster
+        response = $api_server.request('get', endpoint, query: { bucket: 'config', internal: true })
+      else
+        response = $api_server.request('get', endpoint, query: { bucket: 'config' })
+      end
+      if response.nil? || response.code != 201
+        raise "Failed to get presigned URL for #{endpoint}"
+      end
+      JSON.parse(response.body)
     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/tools/table_manager/table_item.rb

@@ -80,7 +80,7 @@ module Cosmos
     alias dup clone
 
     # Create a hash of this item's attributes
-    def to_hash
+    def as_json
       hash = super()
       hash['editable'] = self.editable
       hash['hidden'] = self.hidden

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

@@ -21,6 +21,10 @@ require 'cosmos/topics/topic'
 
 module Cosmos
   class CommandDecomTopic < Topic
+    def self.topics(scope:)
+      super(scope, 'DECOMCMD')
+    end
+
     def self.write_packet(packet, scope:)
       topic = "#{scope}__DECOMCMD__{#{packet.target_name}}__#{packet.packet_name}"
       msg_hash = { time: packet.received_time.to_nsec_from_epoch,
@@ -36,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