cosmos 5.0.2 → 5.0.5

data/lib/cosmos/tools/table_manager/table_manager_core.rb

@@ -31,50 +31,111 @@ module Cosmos
     class MismatchError < CoreError
     end
 
-    # Raised when there is no current table configuration
-    class NoConfigError < CoreError
-      # @return [String] Error message
-      def message
-        'No current table configuration'
-      end
+    def self.binary(binary, definition_filename, table_name)
+      config = TableConfig.process_file(definition_filename)
+      load_binary(config, binary)
+      return config.table(table_name).buffer
     end
 
-    # Raised when there is no table in the current configuration
-    class NoTableError < CoreError
-      # @return [String] Error message
-      def message
-        'Table does not exist in current configuration'
-      end
+    def self.definition(definition_filename, table_name)
+      config = TableConfig.process_file(definition_filename)
+      return config.definition(table_name) # This returns an array: [filename, contents]
     end
 
-    # @return [TableConfig] Configuration instance
-    attr_reader :config
+    def self.report(binary, definition_filename, requested_table_name = nil)
+      report = StringIO.new
+      config = TableConfig.process_file(definition_filename)
+      begin
+        load_binary(config, binary)
+      rescue CoreError => err
+        report.puts "Error: #{err.message}\n"
+      end
+
+      config.tables.each do |table_name, table|
+        next if requested_table_name && table_name != requested_table_name
+        items = table.sorted_items
+        report.puts(table.table_name)
 
-    # Create the instance
-    def initialize
-      reset
+        # Write the column headers
+        if table.type == :ROW_COLUMN
+          columns = ['Item']
+
+          # Remove the '0' from the 'itemname0'
+          table.num_columns.times.each do |x|
+            columns << items[x].name[0...-1]
+          end
+          report.puts columns.join(', ')
+        else
+          report.puts 'Label, Value'
+        end
+
+        # Write the table item values
+        (0...table.num_rows).each do |r|
+          if table.type == :ROW_COLUMN
+            rowtext = "#{r + 1}"
+          else
+            rowtext = items[r].name
+          end
+
+          report.write "#{rowtext}, "
+          (0...table.num_columns).each do |c|
+            if table.type == :ROW_COLUMN
+              table_item = items[c + r * table.num_columns]
+            else
+              table_item = items[r]
+            end
+            value = table.read(table_item.name, :FORMATTED)
+            if value.is_printable?
+              report.write "#{value}, "
+            else
+              report.write "#{value.simple_formatted}, "
+            end
+          end
+          report.write("\n") # newline after each row
+        end
+        report.write("\n") # newline after each table
+      end
+      report.string
     end
 
-    # Clears the configuration
-    def reset
-      @config = nil
+    def self.generate(definition_filename)
+      config = TableConfig.process_file(definition_filename)
+      binary = ''
+      config.tables.each do |table_name, table|
+        table.restore_defaults
+        binary += table.buffer
+      end
+      binary
     end
 
-    # @param filename [String] Create a new TableConfig instance and process the filename
-    def process_definition(filename)
-      @config = TableConfig.new
-      @config.process_file(filename)
+    def self.save(definition_filename, tables)
+      config = TableConfig.process_file(definition_filename)
+      tables.each do |table|
+        table_def = config.tables[table['name']]
+        table['rows'].each do |row|
+          row.each do |item|
+            # TODO: I don't know how the frontend could edit an item like this:
+            # item:{"name"=>"BINARY", "value"=>{"json_class"=>"String", "raw"=>[222, 173, 190, 239]} }
+            next if item['value'].is_a? Hash
+            table_def.write(item['name'], item['value'])
+          end
+        end
+      end
+      binary = ''
+      config.tables.each { |table_name, table| binary += table.buffer }
+      binary
     end
 
-    def generate_json(bin_path, def_path)
+    def self.build_json(binary, definition_filename)
+      config = TableConfig.process_file(definition_filename)
       tables = []
       json = { tables: tables }
       begin
-        file_open(bin_path, def_path)
+        load_binary(config, binary)
       rescue CoreError => err
         json['errors'] = err.message
       end
-      @config.tables.each do |table_name, table|
+      config.tables.each do |table_name, table|
         tables << {
           name: table_name,
           numRows: table.num_rows,
@@ -129,301 +190,144 @@ module Cosmos
       json.to_json
     end
 
-    def save_tables(bin_path, def_path, tables)
-      file_open(bin_path, def_path)
-      tables.each do |table|
-        table_def = @config.tables[table['name']]
-        table['rows'].each do |row|
-          row.each do |item|
-            # TODO: I don't know how the frontend could edit an item like this:
-            # item:{"name"=>"BINARY", "value"=>{"json_class"=>"String", "raw"=>[222, 173, 190, 239]} }
-            next if item['value'].is_a? Hash
-            table_def.write(item['name'], item['value'])
-          end
-        end
-      end
-      file_save(bin_path)
-      bin_path
-    end
-
-    # @param def_path [String] Definition file to process
-    # @param output_dir [String] Output directory to create the new file
-    # @return [String] Binary file path
-    def file_new(def_path, output_dir)
-      process_definition(def_path)
-      @config.table_names.each do |table_name|
-        set_binary_data_to_default(table_name)
-      end
-      bin_path = File.join(output_dir, def_to_bin_filename(def_path))
-      file_save(bin_path)
-      bin_path
-    end
-
-    # @param bin_path [String] Binary file to open
-    # @param def_path [String] Definition file to use when opening
-    def file_open(bin_path, def_path)
-      process_definition(def_path)
-      open_and_load_binary_file(bin_path)
-    end
-
-    # Saves the current tables in the config instance to the given filename.
-    #
-    # @param filename [String] Filename to write, overwritten if it exists.
-    def file_save(filename)
-      raise NoConfigError unless @config
-      file_check
-      File.open(filename, 'wb') do |file|
-        @config.tables.each { |table_name, table| file.write(table.buffer) }
-      end
-      # file_report(filename, @config.filename)
-    end
-
-    # @return [String] Success string if parameters all check. Raises
-    #   a CoreError if errors are found.
-    def file_check
-      raise NoConfigError unless @config
-      result = ''
-      @config.table_names.each do |name|
-        table_result = table_check(name)
-        unless table_result.empty?
-          result << "Errors in #{name}:\n" + table_result
-        end
-      end
-      raise CoreError, result unless result.empty?
-      'All parameters are within their constraints.'
-    end
-
-    # Create a CSV report file based on the file contents.
-    #
-    # @param bin_path [String] Binary filename currently open. Used to generate the
-    #   report name such that it matches the binary filename.
-    # @param def_path [String] Definition filename currently open
-    # @return [String] Report filename path
-    def file_report(bin_path, def_path)
-      raise NoConfigError unless @config
-      file_check
-
-      basename = File.basename(bin_path, '.bin')
-      report_path = File.join(File.dirname(bin_path), "#{basename}.csv")
-      File.open(report_path, 'w+') do |file|
-        file.write("File Definition, #{def_path}\n")
-        file.write("File Binary, #{bin_path}\n\n")
-        @config.tables.values.each do |table|
-          items = table.sorted_items
-          file.puts(table.table_name)
-
-          # Write the column headers
-          if table.type == :ROW_COLUMN
-            columns = ['Item']
-
-            # Remove the '0' from the 'itemname0'
-            table.num_columns.times.each do |x|
-              columns << items[x].name[0...-1]
-            end
-            file.puts columns.join(', ')
-          else
-            file.puts 'Label, Value'
-          end
-
-          # Write the table item values
-          (0...table.num_rows).each do |r|
-            if table.type == :ROW_COLUMN
-              rowtext = "#{r + 1}"
-            else
-              rowtext = items[r].name
-            end
-
-            file.write "#{rowtext}, "
-            (0...table.num_columns).each do |c|
-              if table.type == :ROW_COLUMN
-                table_item = items[c + r * table.num_columns]
-              else
-                table_item = items[r]
-              end
-
-              file.write "#{table.read(table_item.name, :FORMATTED).to_s}, "
-            end
-            file.write("\n") # newline after each row
-          end
-          file.write("\n") # newline after each table
-        end
-      end
-      report_path
-    end
-
-    # Create a hex formatted string of all the file data
-    def file_hex
-      raise NoConfigError unless @config
-      data = ''
-      @config.tables.values.each { |table| data << table.buffer }
-      "#{data.formatted}\n\nTotal Bytes Read: #{data.length}"
-    end
-
-    # @param table_name [String] Name of the table to check for out of range values
-    def table_check(table_name)
-      raise NoConfigError unless @config
-      table = @config.table(table_name)
-      raise NoTableError unless table
-
-      result = ''
-      table_items = table.sorted_items
-
-      # Check the ranges and constraints for each item in the table
-      # We go through it this way (by row and columns) so we can grab the actual
-      # user input when we display any errors found
-      (0...table.num_rows).each do |r|
-        (0...table.num_columns).each do |c|
-          # get the table item definition so we know how to save it
-          table_item = table_items[r * table.num_columns + c]
-
-          value = table.read(table_item.name)
-          unless table_item.range.nil?
-            # If the item has states which include the value, then convert
-            # the state back to the numeric value for range checking
-            if table_item.states && table_item.states.include?(value)
-              value = table_item.states[value]
-            end
-
-            # check to see if the value lies within its valid range
-            unless table_item.range.include?(value)
-              if table_item.format_string
-                value = table.read(table_item.name, :FORMATTED)
-                range_first =
-                  sprintf(table_item.format_string, table_item.range.first)
-                range_last =
-                  sprintf(table_item.format_string, table_item.range.last)
-              else
-                range_first = table_item.range.first
-                range_last = table_item.range.last
-              end
-              result <<
-                "  #{table_item.name}: #{value} outside valid range of #{range_first}..#{range_last}\n"
-            end
-          end
-        end # end each column
-      end # end each row
-      result
-    end
-
-    # @param table_name [String] Name of the table to revert all values to default
-    def table_default(table_name)
-      raise NoConfigError unless @config
-      set_binary_data_to_default(table_name)
-    end
-
-    # @param table_name [String] Create a hex formatted string of the given table data
-    def table_hex(table_name)
-      raise NoConfigError unless @config
-      table = @config.table(table_name)
-      raise NoTableError unless table
-      "#{table.buffer.formatted}\n\nTotal Bytes Read: #{table.buffer.length}"
-    end
-
-    # @param table_name [String] Table name to write as a stand alone file
-    # @param filename [String] Filename to write the table data to. Existing
-    #   files will be overwritten.
-    def table_save(table_name, filename)
-      raise NoConfigError unless @config
-      result = table_check(table_name)
-      unless result.empty?
-        raise CoreError, "Errors in #{table_name}:\n#{result}"
-      end
-      File.open(filename, 'wb') do |file|
-        file.write(@config.table(table_name).buffer)
-      end
-    end
-
-    # Commit a table from the current configuration into a new binary
-    #
-    # @param table_name [String] Table name to commit to an existing binary
-    # @param bin_file [String] Binary file to open
-    # @param def_file [String] Definition file to use when opening
-    def table_commit(table_name, bin_file, def_file)
-      raise NoConfigError unless @config
-      save_table = @config.table(table_name)
-      raise NoTableError unless save_table
-
-      result = table_check(table_name)
-      unless result.empty?
-        raise CoreError, "Errors in #{table_name}:\n#{result}"
-      end
-
-      config = TableConfig.new
-      begin
-        config.process_file(def_file)
-      rescue => err
-        raise CoreError,
-              "The table definition file:#{def_file} has the following errors:\n#{err}"
-      end
-
-      if !config.table_names.include?(table_name.upcase)
-        raise NoTableError,
-              "#{table_name} not found in #{def_file} table definition file."
-      end
-
-      saved_config = @config
-      @config = config
-      open_and_load_binary_file(bin_file)
-
-      # Store the saved table data in the new table definition
-      table = config.table(save_table.table_name)
-      table.buffer = save_table.buffer[0...table.length]
-      file_save(bin_file)
-      @config = saved_config
-    end
-
-    protected
-
-    # Set all the binary data in the table to the default values
-    def set_binary_data_to_default(table_name)
-      table = @config.table(table_name)
-      raise NoTableError unless table
-      table.restore_defaults
-    end
-
-    # Get the binary filename equivalent for the given definition filename
-    def def_to_bin_filename(def_path)
-      if File.basename(def_path) =~ /_def\.txt$/
-        # Remove _def.txt if present (should be)
-        basename = File.basename(def_path)[0...-8]
-      else
-        # Remove any extension if present
-        basename = File.basename(def_path, File.extname(def_path))
-      end
-      "#{basename}.bin"
-    end
-
-    # Opens the given binary file and populates the table definition.
-    # The filename parameter should be a properly formatted file path.
-    def open_and_load_binary_file(filename)
-      begin
-        data = nil
-
-        # read the binary file and store it into an array
-        File.open(filename, 'rb') { |file| data = file.read }
-      rescue => err
-        raise "Unable to open and load #{filename} due to #{err}."
-      end
-
+    def self.load_binary(config, data)
       binary_data_index = 0
       total_table_length = 0
-      @config.tables.each do |table_name, table|
+      config.tables.each do |table_name, table|
         total_table_length += table.length
       end
-      @config.tables.each do |table_name, table|
+      config.tables.each do |table_name, table|
         if binary_data_index + table.length > data.length
           table.buffer = data[binary_data_index..-1]
           raise MismatchError,
-                "Binary size of #{data.length} not large enough to fully represent table definition of length #{total_table_length}. The remaining table definition (starting with byte #{data.length - binary_data_index} in #{table.table_name}) will be filled with 0."
+            "Binary size of #{data.length} not large enough to fully represent table definition of length #{total_table_length}. "+
+            "The remaining table definition (starting with byte #{data.length - binary_data_index} in #{table.table_name}) will be filled with 0."
         end
-        table.buffer =
-          data[binary_data_index...binary_data_index + table.length]
+        table.buffer = data[binary_data_index...binary_data_index + table.length]
         binary_data_index += table.length
       end
       if binary_data_index < data.length
         raise MismatchError,
-              "Binary size of #{data.length} larger than table definition of length #{total_table_length}. Discarding the remaing #{data.length - binary_data_index} bytes."
+          "Binary size of #{data.length} larger than table definition of length #{total_table_length}. "+
+          "Discarding the remaing #{data.length - binary_data_index} bytes."
       end
     end
+
+    # TODO: Potentially useful methods?
+    # # @return [String] Success string if parameters all check. Raises
+    # #   a CoreError if errors are found.
+    # def file_check
+    #   raise NoConfigError unless @config
+    #   result = ''
+    #   @config.table_names.each do |name|
+    #     table_result = table_check(name)
+    #     unless table_result.empty?
+    #       result << "Errors in #{name}:\n" + table_result
+    #     end
+    #   end
+    #   raise CoreError, result unless result.empty?
+    #   'All parameters are within their constraints.'
+    # end
+
+    # # Create a hex formatted string of all the file data
+    # def file_hex
+    #   raise NoConfigError unless @config
+    #   data = ''
+    #   @config.tables.values.each { |table| data << table.buffer }
+    #   "#{data.formatted}\n\nTotal Bytes Read: #{data.length}"
+    # end
+
+    # # @param table_name [String] Name of the table to check for out of range values
+    # def table_check(table_name)
+    #   raise NoConfigError unless @config
+    #   table = @config.table(table_name)
+    #   raise NoTableError unless table
+
+    #   result = ''
+    #   table_items = table.sorted_items
+
+    #   # Check the ranges and constraints for each item in the table
+    #   # We go through it this way (by row and columns) so we can grab the actual
+    #   # user input when we display any errors found
+    #   (0...table.num_rows).each do |r|
+    #     (0...table.num_columns).each do |c|
+    #       # get the table item definition so we know how to save it
+    #       table_item = table_items[r * table.num_columns + c]
+
+    #       value = table.read(table_item.name)
+    #       unless table_item.range.nil?
+    #         # If the item has states which include the value, then convert
+    #         # the state back to the numeric value for range checking
+    #         if table_item.states && table_item.states.include?(value)
+    #           value = table_item.states[value]
+    #         end
+
+    #         # check to see if the value lies within its valid range
+    #         unless table_item.range.include?(value)
+    #           if table_item.format_string
+    #             value = table.read(table_item.name, :FORMATTED)
+    #             range_first =
+    #               sprintf(table_item.format_string, table_item.range.first)
+    #             range_last =
+    #               sprintf(table_item.format_string, table_item.range.last)
+    #           else
+    #             range_first = table_item.range.first
+    #             range_last = table_item.range.last
+    #           end
+    #           result <<
+    #             "  #{table_item.name}: #{value} outside valid range of #{range_first}..#{range_last}\n"
+    #         end
+    #       end
+    #     end # end each column
+    #   end # end each row
+    #   result
+    # end
+
+    # # @param table_name [String] Create a hex formatted string of the given table data
+    # def table_hex(table_name)
+    #   raise NoConfigError unless @config
+    #   table = @config.table(table_name)
+    #   raise NoTableError unless table
+    #   "#{table.buffer.formatted}\n\nTotal Bytes Read: #{table.buffer.length}"
+    # end
+
+    # # Commit a table from the current configuration into a new binary
+    # #
+    # # @param table_name [String] Table name to commit to an existing binary
+    # # @param bin_file [String] Binary file to open
+    # # @param def_file [String] Definition file to use when opening
+    # def table_commit(table_name, bin_file, def_file)
+    #   raise NoConfigError unless @config
+    #   save_table = @config.table(table_name)
+    #   raise NoTableError unless save_table
+
+    #   result = table_check(table_name)
+    #   unless result.empty?
+    #     raise CoreError, "Errors in #{table_name}:\n#{result}"
+    #   end
+
+    #   config = TableConfig.new
+    #   begin
+    #     config.process_file(def_file)
+    #   rescue => err
+    #     raise CoreError,
+    #           "The table definition file:#{def_file} has the following errors:\n#{err}"
+    #   end
+
+    #   if !config.table_names.include?(table_name.upcase)
+    #     raise NoTableError,
+    #           "#{table_name} not found in #{def_file} table definition file."
+    #   end
+
+    #   saved_config = @config
+    #   @config = config
+    #   open_and_load_binary_file(bin_file)
+
+    #   # Store the saved table data in the new table definition
+    #   table = config.table(save_table.table_name)
+    #   table.buffer = save_table.buffer[0...table.length]
+    #   file_save(bin_file)
+    #   @config = saved_config
+    # end
   end
 end

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