cosmos 5.0.4 → 5.0.5

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

@@ -32,12 +32,19 @@ module Cosmos
     # @return [String] Table configuration filename
     attr_reader :filename
 
+    def self.process_file(filename)
+      instance = self.new()
+      instance.process_file(filename)
+      instance
+    end
+
     # Create the table configuration
     def initialize
       super
-
       # Override commands with the Table::TARGET name to store tables
       @commands[Table::TARGET] = {}
+      @definitions = {}
+      @last_config = [] # Stores array of [filename, contents]
     end
 
     # @return [Array<Table>] All tables defined in the configuration file
@@ -45,6 +52,11 @@ module Cosmos
       @commands[Table::TARGET]
     end
 
+    # @return [String] Table definition for the specific table
+    def definition(table_name)
+      @definitions[table_name.upcase]
+    end
+
     # @return [Array<String>] All the table names
     def table_names
       tables.keys
@@ -64,6 +76,7 @@ module Cosmos
       # Partial files are included into another file and thus aren't directly processed
       return if File.basename(filename)[0] == '_' # Partials start with underscore
       @filename = filename
+      @last_config = [File.basename(filename), File.read(filename)]
       @converted_type = nil
       @converted_bit_size = nil
       @proc_text = ''
@@ -111,10 +124,12 @@ module Cosmos
                     )
             end
             process_file(table_filename)
+
           when 'TABLE'
             finish_packet
             @current_packet =
               TableParser.parse_table(parser, @commands, @warnings)
+            @definitions[@current_packet.packet_name] = @last_config
             @current_cmd_or_tlm = COMMAND
             @default_index = 0
 

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/topics/config_topic.rb

@@ -0,0 +1,68 @@
+# 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/topics/topic'
+
+module Cosmos
+  class ConfigTopic < Topic
+    PRIMARY_KEY = "__CONFIG"
+
+    # Helper method to initialize the stream and ensure a consistent key
+    def self.initialize_stream(scope)
+      self.initialize_streams(["#{scope}#{PRIMARY_KEY}"])
+    end
+
+    # Write a configuration change to the topic
+    # @param config [Hash] Hash with required keys 'kind', 'name', 'type'
+    def self.write(config, scope:)
+      unless config.keys.include?(:kind)
+        raise "ConfigTopic error, required key kind: not given"
+      end
+      unless ['created', 'deleted'].include?(config[:kind])
+        raise "ConfigTopic error unknown kind: #{config[:kind]}"
+      end
+      unless config.keys.include?(:name)
+        raise "ConfigTopic error, required key name: not given"
+      end
+      unless config.keys.include?(:type)
+        raise "ConfigTopic error, required key type: not given"
+      end
+      # Limit the configuration topics to 1000 entries
+      Topic.write_topic("#{scope}#{PRIMARY_KEY}", config, '*', 1000)
+    end
+
+    def self.read(offset = nil, count: 100, scope:)
+      topic = "#{scope}#{PRIMARY_KEY}"
+      if offset
+        result = Topic.read_topics([topic], [offset], nil, count)
+        if result.empty?
+          [] # We want to return an empty array rather than an empty hash
+        else
+          # result is a hash with the topic key followed by an array of results
+          # This returns just the array of arrays [[offset, hash], [offset, hash], ...]
+          result[topic]
+        end
+      else
+        result = Topic.get_newest_message(topic)
+        return [result] if result
+        return []
+      end
+    end
+  end
+end