cosmos 5.0.2.pre.beta2 → 5.0.4

data/lib/cosmos/models/target_model.rb

@@ -51,12 +51,20 @@ module Cosmos
     attr_accessor :id
     attr_accessor :cmd_log_cycle_time
     attr_accessor :cmd_log_cycle_size
+    attr_accessor :cmd_log_retain_time
     attr_accessor :cmd_decom_log_cycle_time
     attr_accessor :cmd_decom_log_cycle_size
+    attr_accessor :cmd_decom_log_retain_time
     attr_accessor :tlm_log_cycle_time
     attr_accessor :tlm_log_cycle_size
+    attr_accessor :tlm_log_retain_time
     attr_accessor :tlm_decom_log_cycle_time
     attr_accessor :tlm_decom_log_cycle_size
+    attr_accessor :tlm_decom_log_retain_time
+    attr_accessor :reduced_minute_log_retain_time
+    attr_accessor :reduced_hour_log_retain_time
+    attr_accessor :reduced_day_log_retain_time
+    attr_accessor :cleanup_poll_time
     attr_accessor :needs_dependencies
 
     # NOTE: The following three class methods are used by the ModelController
@@ -97,6 +105,11 @@ module Cosmos
       result
     end
 
+    # @return [Array>Hash>] All packet hashes under the target_name
+    def self.all_packet_name_descriptions(target_name, type: :TLM, scope:)
+      self.packets(target_name, type: type, scope: scope).map! { |hash| hash.slice("packet_name", "description") }
+    end
+
     def self.set_packet(target_name, packet_name, packet, type: :TLM, scope:)
       raise "Unknown type #{type} for #{target_name} #{packet_name}" unless VALID_TYPES.include?(type)
 
@@ -113,7 +126,6 @@ module Cosmos
       packet = packet(target_name, packet_name, type: type, scope: scope)
       item = packet['items'].find { |item| item['name'] == item_name.to_s }
       raise "Item '#{packet['target_name']} #{packet['packet_name']} #{item_name}' does not exist" unless item
-
       item
     end
 
@@ -149,7 +161,7 @@ module Cosmos
       when 'TARGET'
         usage = "#{keyword} <TARGET FOLDER NAME> <TARGET NAME>"
         parser.verify_num_parameters(2, 2, usage)
-        parser.verify_parameters_underscores(2) # Target name is the 2nd parameter
+        parser.verify_parameter_naming(2) # Target name is the 2nd parameter
         return self.new(name: parameters[1].to_s.upcase, folder_name: parameters[0].to_s.upcase, plugin: plugin, scope: scope)
       else
         raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Target: #{keyword} #{parameters.join(" ")}")
@@ -171,20 +183,35 @@ module Cosmos
       plugin: nil,
       cmd_log_cycle_time: 600,
       cmd_log_cycle_size: 50_000_000,
+      cmd_log_retain_time: nil,
       cmd_decom_log_cycle_time: 600,
       cmd_decom_log_cycle_size: 50_000_000,
+      cmd_decom_log_retain_time: nil,
       tlm_log_cycle_time: 600,
       tlm_log_cycle_size: 50_000_000,
+      tlm_log_retain_time: nil,
       tlm_decom_log_cycle_time: 600,
       tlm_decom_log_cycle_size: 50_000_000,
+      tlm_decom_log_retain_time: nil,
+      reduced_minute_log_retain_time: nil,
+      reduced_hour_log_retain_time: nil,
+      reduced_day_log_retain_time: nil,
+      cleanup_poll_time: 900,
       needs_dependencies: false,
       scope:
     )
       super("#{scope}__#{PRIMARY_KEY}", name: name, plugin: plugin, updated_at: updated_at,
         cmd_log_cycle_time: cmd_log_cycle_time, cmd_log_cycle_size: cmd_log_cycle_size,
+        cmd_log_retain_time: cmd_log_retain_time,
         cmd_decom_log_cycle_time: cmd_decom_log_cycle_time, cmd_decom_log_cycle_size: cmd_decom_log_cycle_size,
+        cmd_decom_log_retain_time: cmd_decom_log_retain_time,
         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,
+        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,
         scope: scope)
       @folder_name = folder_name
       @requires = requires
@@ -197,12 +224,20 @@ module Cosmos
       @id = id
       @cmd_log_cycle_time = cmd_log_cycle_time
       @cmd_log_cycle_size = cmd_log_cycle_size
+      @cmd_log_retain_time = cmd_log_retain_time
       @cmd_decom_log_cycle_time = cmd_decom_log_cycle_time
       @cmd_decom_log_cycle_size = cmd_decom_log_cycle_size
+      @cmd_decom_log_retain_time = cmd_decom_log_retain_time
       @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
+      @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
     end
 
@@ -222,12 +257,20 @@ module Cosmos
         'plugin' => @plugin,
         'cmd_log_cycle_time' => @cmd_log_cycle_time,
         'cmd_log_cycle_size' => @cmd_log_cycle_size,
+        'cmd_log_retain_time' => @cmd_log_retain_time,
         'cmd_decom_log_cycle_time' => @cmd_decom_log_cycle_time,
         'cmd_decom_log_cycle_size' => @cmd_decom_log_cycle_size,
+        'cmd_decom_log_retain_time' => @cmd_decom_log_retain_time,
         '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,
+        '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,
       }
     end
@@ -245,24 +288,72 @@ module Cosmos
       when 'CMD_LOG_CYCLE_SIZE'
         parser.verify_num_parameters(1, 1, "#{keyword} <Maximum file size in bytes>")
         @cmd_log_cycle_size = parameters[0].to_i
+      when 'CMD_LOG_RETAIN_TIME'
+        parser.verify_num_parameters(1, 1, "#{keyword} <Retention time for cmd log files in seconds - nil = Forever>")
+        @cmd_log_retain_time = ConfigParser.handle_nil(parameters[0])
+        @cmd_log_retain_time = @cmd_log_retain_time.to_i if @cmd_log_retain_time
       when 'CMD_DECOM_LOG_CYCLE_TIME'
         parser.verify_num_parameters(1, 1, "#{keyword} <Maximum time between files in seconds>")
         @cmd_decom_log_cycle_time = parameters[0].to_i
       when 'CMD_DECOM_LOG_CYCLE_SIZE'
         parser.verify_num_parameters(1, 1, "#{keyword} <Maximum file size in bytes>")
         @cmd_decom_log_cycle_size = parameters[0].to_i
+      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
       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
       when 'TLM_LOG_CYCLE_SIZE'
         parser.verify_num_parameters(1, 1, "#{keyword} <Maximum file size in bytes>")
         @tlm_log_cycle_size = parameters[0].to_i
+      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
       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
       when 'TLM_DECOM_LOG_CYCLE_SIZE'
         parser.verify_num_parameters(1, 1, "#{keyword} <Maximum file size in bytes>")
         @tlm_decom_log_cycle_size = parameters[0].to_i
+      when 'TLM_DECOM_LOG_RETAIN_TIME'
+        parser.verify_num_parameters(1, 1, "#{keyword} <Retention time for tlm decom log files in seconds - nil = Forever>")
+        @tlm_decom_log_retain_time = ConfigParser.handle_nil(parameters[0])
+        @tlm_decom_log_retain_time = @tlm_decom_log_retain_time.to_i if @tlm_decom_log_retain_time
+      when 'REDUCED_MINUTE_LOG_RETAIN_TIME'
+        parser.verify_num_parameters(1, 1, "#{keyword} <Retention time for reduced minute log files in seconds - nil = Forever>")
+        @reduced_minute_log_retain_time = ConfigParser.handle_nil(parameters[0])
+        @reduced_minute_log_retain_time = @reduced_minute_log_retain_time.to_i if @reduced_minute_log_retain_time
+      when 'REDUCED_HOUR_LOG_RETAIN_TIME'
+        parser.verify_num_parameters(1, 1, "#{keyword} <Retention time for reduced hour log files in seconds - nil = Forever>")
+        @reduced_hour_log_retain_time = ConfigParser.handle_nil(parameters[0])
+        @reduced_hour_log_retain_time = @reduced_hour_log_retain_time.to_i if @reduced_hour_log_retain_time
+      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
+      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
+          @cmd_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
+      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
+          @reduced_minute_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'
+        parser.verify_num_parameters(1, 1, "#{keyword} <Cleanup polling period in seconds>")
+        @cleanup_poll_time = parameters[0].to_i
       else
         raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Target: #{keyword} #{parameters.join(" ")}")
       end
@@ -289,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}"
@@ -322,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
@@ -335,7 +426,7 @@ module Cosmos
       Store.del("#{@scope}__cosmoscmd__#{@name}")
 
       # Note: these match the names of the services in deploy_microservices
-      %w(DECOM COMMANDLOG DECOMCMDLOG PACKETLOG DECOMLOG REDUCER).each do |type|
+      %w(DECOM COMMANDLOG DECOMCMDLOG PACKETLOG DECOMLOG REDUCER CLEANUP).each do |type|
         model = MicroserviceModel.get_model(name: "#{@scope}__#{type}__#{@name}", scope: @scope)
         model.destroy if model
       end
@@ -364,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}"
@@ -494,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
@@ -627,6 +718,22 @@ module Cosmos
         microservice.deploy(gem_path, variables)
         Logger.info "Configured microservice #{microservice_name}"
       end
+
+      if @cmd_log_retain_time or @cmd_decom_log_retain_time or @tlm_log_retain_time or @tlm_decom_log_retain_time or
+         @reduced_minute_log_retain_time or @reduced_hour_log_retain_time or @reduced_day_log_retain_time
+        # Cleanup Microservice
+        microservice_name = "#{@scope}__CLEANUP__#{@name}"
+        microservice = MicroserviceModel.new(
+          name: microservice_name,
+          cmd: ["ruby", "cleanup_microservice.rb", microservice_name],
+          work_dir: '/cosmos/lib/cosmos/microservices',
+          plugin: plugin,
+          scope: @scope
+        )
+        microservice.create
+        microservice.deploy(gem_path, variables)
+        Logger.info "Configured microservice #{microservice_name}"
+      end
     end
   end
 end

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/packets/packet.rb

@@ -445,6 +445,11 @@ module Cosmos
       @meta ||= {}
     end
 
+    # Sets packet specific metadata
+    def meta=(meta)
+      @meta = meta
+    end
+
     # Indicates if the packet has been identified
     # @return [TrueClass or FalseClass]
     def identified?
@@ -1009,6 +1014,24 @@ module Cosmos
       config
     end
 
+    def self.from_json(hash)
+      endianness = hash['endianness'] ? hash['endianness'].intern : nil # Convert to symbol
+      packet = Packet.new(hash['target_name'], hash['packet_name'], endianness, hash['description'])
+      packet.short_buffer_allowed = hash['short_buffer_allowed']
+      packet.hazardous = hash['hazardous']
+      packet.hazardous_description = hash['hazardous_description']
+      packet.messages_disabled = hash['messages_disabled']
+      packet.disabled = hash['disabled']
+      packet.hidden = hash['hidden']
+      # packet.stale is read only
+      packet.meta = hash['meta']
+      # Can't convert processors
+      hash['items'].each do |item|
+        packet.define(PacketItem.from_json(item))
+      end
+      packet
+    end
+
     protected
 
     # Performs packet specific processing on the packet.

data/lib/cosmos/packets/packet_config.rb

@@ -463,8 +463,8 @@ module Cosmos
       when 'POLY_READ_CONVERSION', 'POLY_WRITE_CONVERSION'
         usage = "#{keyword} <C0> <C1> <C2> ..."
         parser.verify_num_parameters(1, nil, usage)
-        @current_item.read_conversion = PolynomialConversion.new(params) if keyword.include? "READ"
-        @current_item.write_conversion = PolynomialConversion.new(params) if keyword.include? "WRITE"
+        @current_item.read_conversion = PolynomialConversion.new(*params) if keyword.include? "READ"
+        @current_item.write_conversion = PolynomialConversion.new(*params) if keyword.include? "WRITE"
 
       # Apply a segmented polynomial conversion to the current item
       # after it is read from the telemetry packet

data/lib/cosmos/packets/packet_item.rb

@@ -486,6 +486,63 @@ module Cosmos
       config
     end
 
+    def self.from_json(hash)
+      # Convert strings to symbols
+      endianness = hash['endianness'] ? hash['endianness'].intern : nil
+      data_type = hash['data_type'] ? hash['data_type'].intern : nil
+      overflow = hash['overflow'] ? hash['overflow'].intern : nil
+      item = PacketItem.new(hash['name'], hash['bit_offset'], hash['bit_size'],
+        data_type, endianness, hash['array_size'], overflow)
+      item.description = hash['description']
+      item.id_value = hash['id_value']
+      item.default = hash['default']
+      item.range = (hash['minimum']..hash['maximum']) if hash['minimum'] && hash['maximum']
+      item.required = hash['required']
+      item.format_string = hash['format_string']
+      item.units = hash['units']
+      item.units_full = hash['units_full']
+      if hash['states']
+        item.states = {}
+        item.hazardous = {}
+        item.state_colors = {}
+        hash['states'].each do |state_name, state|
+          item.states[state_name] = state['value']
+          item.hazardous[state_name] = state['hazardous']
+          item.state_colors[state_name] = state['color'].to_sym if state['color']
+        end
+      end
+      # Recreate COSMOS built-in conversions
+      if hash['read_conversion']
+        begin
+          item.read_conversion = Cosmos::const_get(hash['read_conversion']['class']).new(*hash['read_conversion']['params'])
+        rescue => error
+          Logger.instance.error "#{item.name} read_conversion of #{hash['read_conversion']} could not be instantiated due to #{error}"
+        end
+      end
+      if hash['write_conversion']
+        begin
+          item.write_conversion = Cosmos::const_get(hash['write_conversion']['class']).new(*hash['write_conversion']['params'])
+        rescue => error
+          Logger.instance.error "#{item.name} write_conversion of #{hash['write_conversion']} could not be instantiated due to #{error}"
+        end
+      end
+
+      if hash['limits']
+        item.limits = PacketItemLimits.new
+        # Delete these keys so the only ones left are limits sets
+        item.limits.persistence_setting = hash['limits'].delete('persistence_setting')
+        item.limits.enabled = true if hash['limits'].delete('enabled')
+        values = {}
+        hash['limits'].each do |set, items|
+          values[set.to_sym] = [items['red_low'], items['yellow_low'], items['yellow_high'], items['red_high']]
+          values[set.to_sym].concat([items['green_low'], items['green_high']]) if items['green_low'] && items['green_high']
+        end
+        item.limits.values = values
+      end
+      item.meta = hash['meta']
+      item
+    end
+
     protected
 
     def parameter_config

data/lib/cosmos/packets/packet_item_limits.rb

@@ -132,7 +132,7 @@ module Cosmos
     end
     alias dup clone
 
-    def to_hash
+    def as_json
       hash = {}
       hash['values'] = self.values
       hash['enabled'] = self.enabled
@@ -146,5 +146,17 @@ module Cosmos
       hash['persistence_count'] = self.persistence_count
       hash
     end
+
+    def self.from_json(hash)
+      limits = PacketItemLimits.new
+      limits.values = hash['values'].transform_keys(&:to_sym) if hash['values']
+      limits.enabled = hash['enabled']
+      limits.state = hash['state'] ? hash['state'].to_sym : nil
+      # Can't recreate a LimitsResponse class
+      # limits.response = hash['response']
+      limits.persistence_setting = hash['persistence_setting'] if hash['persistence_setting']
+      limits.persistence_count = hash['persistence_count'] if hash['persistence_count']
+      limits
+    end
   end
-end # module Cosmos
+end

data/lib/cosmos/packets/parsers/packet_item_parser.rb

@@ -56,7 +56,7 @@ module Cosmos
       max_options = @usage.count("<")
       # The last two options (description and endianness) are optional
       @parser.verify_num_parameters(max_options - 2, max_options, @usage)
-      @parser.verify_parameters_underscores(1) # Item name is the 1st parameter
+      @parser.verify_parameter_naming(1) # Item name is the 1st parameter
     end
 
     def create_packet_item(packet, cmd_or_tlm)

data/lib/cosmos/packets/parsers/packet_parser.rb

@@ -72,7 +72,7 @@ module Cosmos
     def verify_parameters
       @usage = "#{@parser.keyword} <TARGET NAME> <PACKET NAME> <ENDIANNESS: BIG_ENDIAN/LITTLE_ENDIAN> <DESCRIPTION (Optional)>"
       @parser.verify_num_parameters(3, 4, @usage)
-      @parser.verify_parameters_underscores(2) # Packet name is the 2nd parameter
+      @parser.verify_parameter_naming(2) # Packet name is the 2nd parameter
     end
 
     def create_command(target_name, commands, warnings)

data/lib/cosmos/packets/parsers/xtce_parser.rb

@@ -293,7 +293,7 @@ module Cosmos
         xtce_recurse_element(element) do |block_element|
           if block_element.name == 'Term'
             exponent = Float(block_element['exponent']).to_i
-            @current_type.conversion ||= PolynomialConversion.new([])
+            @current_type.conversion ||= PolynomialConversion.new()
             @current_type.conversion.coeffs[exponent] = Float(block_element['coefficient'])
             @current_type.conversion.coeffs.each_with_index do |value, index|
               @current_type.conversion.coeffs[index] = 0.0 if value.nil?

data/lib/cosmos/packets/structure_item.rb

@@ -292,7 +292,16 @@ module Cosmos
     end
     alias dup clone
 
-    def to_hash
+    def self.from_json(hash)
+      # Convert strings to symbols
+      endianness = hash['endianness'] ? hash['endianness'].intern : nil
+      data_type = hash['data_type'] ? hash['data_type'].intern : nil
+      overflow = hash['overflow'] ? hash['overflow'].intern : nil
+      StructureItem.new(hash['name'], hash['bit_offset'], hash['bit_size'], data_type,
+        endianness, hash['array_size'], overflow)
+    end
+
+    def as_json
       hash = {}
       hash['name'] = self.name
       hash['bit_offset'] = self.bit_offset