cosmos 4.5.2 → 5.0.2.pre.beta2

data/lib/cosmos/dart/processes/dart_util.rb

@@ -1,262 +0,0 @@
-# encoding: ascii-8bit
-
-# Copyright 2018 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 General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-# This code must be run on the database server
-
-require 'ostruct'
-require 'optparse'
-require 'cosmos/version'
-
-options = OpenStruct.new
-options.force = false
-
-parser = OptionParser.new do |option_parser|
-  option_parser.banner = "Usage: dart_util <action> [options]"
-  option_parser.separator("")
-
-  # Create the help option
-  option_parser.on("-h", "--help", "Show this message") do
-    puts option_parser
-    exit(0)
-  end
-
-  # Create the version option
-  option_parser.on("-v", "--version", "Show version") do
-    puts "COSMOS Version: #{COSMOS_VERSION}"
-    puts "User Version: #{USER_VERSION}" if defined? USER_VERSION
-    exit(0)
-  end
-
-  # Create the system option
-  option_parser.on("--system FILE", "Use an alternative system.txt file") do |arg|
-    System.instance(File.join(USERPATH, 'config', 'system', arg))
-  end
-
-  # Create the force option
-  option_parser.on("-f", "--force", "Force parsing entire file") do
-    options.force = true
-  end
-end
-
-parser.parse!(ARGV)
-action = ARGV[0]
-unless action
-  puts parser
-  exit(1)
-end
-
-ENV['RAILS_ENV'] = 'production'
-require File.expand_path('../../config/environment', __FILE__)
-require 'dart_database_cleaner'
-
-include DartCommon
-
-Cosmos.catch_fatal_exception do
-  case action.downcase
-  when 'showpleerrors'
-    ples = PacketLogEntry.where("decom_state >= 3").find_each do |ple|
-      puts "#{ple.id}: #{ple.decom_state_string}(#{ple.decom_state})"
-    end
-
-  when 'resetpleerrors'
-    PacketLogEntry.where("decom_state >= 3").update_all(:decom_state => 0)
-    puts "All errored PLEs set to decom_state 0"
-
-  when 'fullcleanup'
-    Cosmos::Logger.level = Cosmos::Logger::INFO
-    DartDatabaseCleaner.clean(false, true)
-
-  when 'removepacketlog'
-    puts "Removing database entries for packet log #{ARGV[1]}"
-    puts "Note!!! This does not delete the file"
-    Cosmos::Logger.level = Cosmos::Logger::INFO
-    DartDatabaseCleaner.new.remove_packet_log(ARGV[1])
-
-  when 'showdatabase'
-    puts "Status:"
-    status = Status.last
-    puts "  Updated At: #{status.updated_at.formatted}"
-    puts "  Decom Count: #{status.decom_count}"
-    puts "  Decom Error Count: #{status.decom_error_count}"
-    puts "  Decom Message: #{status.decom_message}"
-    puts "  Decom Message Time: #{status.decom_message_time.formatted}"
-    puts "  Reduction Count: #{status.reduction_count}"
-    puts "  Reduction Error Count: #{status.reduction_error_count}"
-    puts "  Reduction Message: #{status.reduction_message}"
-    puts "  Reduction Message Time: #{status.reduction_message_time}"
-    puts ""
-
-    puts "System Configs:"
-    SystemConfig.all.each do |system_config|
-      puts "  #{sprintf("%6d", system_config.id)} #{system_config.name}"
-    end
-    puts ""
-
-    puts "Targets:"
-    Target.all.each do |target|
-      puts "  #{sprintf("%6d", target.id)} #{target.name}"
-    end
-    puts ""
-    
-    puts "Packets:"
-    Packet.all.each do |packet|
-      target = Target.find(packet.target_id)
-      puts "  #{sprintf("%6d", packet.id)} #{target.name} #{packet.name} (#{packet.is_tlm ? "TLM" : "CMD"})"
-    end
-    puts ""
-
-    puts "Items:"
-    Item.find_each do |item|
-      packet = Packet.find(item.packet_id)
-      target = Target.find(packet.target_id)
-      puts "  #{sprintf("%6d", item.id)} #{target.name} #{packet.name} #{item.name}"
-    end
-    puts ""
-
-    puts "Packet Logs:"
-    PacketLog.all.each do |packet_log|
-      puts "  #{sprintf("%6d", packet_log.id)} #{packet_log.filename} (#{packet_log.is_tlm ? "TLM" : "CMD"}) #{packet_log.created_at.formatted}"
-    end
-    puts ""
-    
-    puts "Packet Log Entry Count: #{PacketLogEntry.count}"
-    puts ""
-    
-    puts "Packet Configs:"
-    PacketConfig.all.each do |packet_config|
-      packet = Packet.find(packet_config.packet_id)
-      target = Target.find(packet.target_id)
-      puts "  #{sprintf("%6d", packet_config.id)} #{target.name} #{packet.name} (#{packet_config.name}) sysconfig:#{packet_config.first_system_config_id} maxindex:#{packet_config.max_table_index} ready:#{packet_config.ready} start:#{packet_config.start_time.formatted} end:#{packet_config.end_time.formatted}"
-    end
-    puts ""
-    
-    value_type_lookup = {0 => "RAW", 1 => "CONVERTED", 2 => "RAW_CON"}
-    puts "Item to Decom Table Mappings:"
-    ItemToDecomTableMapping.find_each do |itdtm|
-      item = Item.find(itdtm.item_id)
-      packet = Packet.find(item.packet_id)
-      target = Target.find(packet.target_id)
-      puts "  #{sprintf("%6d", itdtm.id)} #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]} packet_config:#{itdtm.packet_config_id} item_index:#{itdtm.item_index} table_index:#{itdtm.table_index} reduced:#{itdtm.reduced}"
-    end
-    puts ""
-    
-    puts "Decom and Reduced Tables:"
-    each_decom_and_reduced_table do |packet_config_id, table_index, decom_model, minute_model, hour_model, day_model|
-      puts "  t#{decom_model.name.split("::")[1][1..-1]}: (#{decom_model.count} entries)"
-      ItemToDecomTableMapping.where("packet_config_id = ? and table_index = ?", packet_config_id, table_index).order("item_index ASC").each do |itdtm|
-        item = Item.find(itdtm.item_id)
-        packet = Packet.find(item.packet_id)
-        target = Target.find(packet.target_id)
-        puts "    i#{itdtm.item_index} #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-      end
-      puts ""
-      puts "  t#{minute_model.name.split("::")[1][1..-1]}: (#{minute_model.count} entries)"
-      ItemToDecomTableMapping.where("packet_config_id = ? and table_index = ? and reduced = true", packet_config_id, table_index).order("item_index ASC").each do |itdtm|
-        item = Item.find(itdtm.item_id)
-        packet = Packet.find(item.packet_id)
-        target = Target.find(packet.target_id)
-        puts "    i#{itdtm.item_index}max #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-        puts "    i#{itdtm.item_index}min #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-        puts "    i#{itdtm.item_index}avg #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-        puts "    i#{itdtm.item_index}stddev #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-      end      
-      puts ""
-      puts "  t#{hour_model.name.split("::")[1][1..-1]}: (#{hour_model.count} entries)"
-      ItemToDecomTableMapping.where("packet_config_id = ? and table_index = ? and reduced = true", packet_config_id, table_index).order("item_index ASC").each do |itdtm|
-        item = Item.find(itdtm.item_id)
-        packet = Packet.find(item.packet_id)
-        target = Target.find(packet.target_id)
-        puts "    i#{itdtm.item_index}max #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-        puts "    i#{itdtm.item_index}min #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-        puts "    i#{itdtm.item_index}avg #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-        puts "    i#{itdtm.item_index}stddev #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-      end    
-      puts ""      
-      puts "  t#{day_model.name.split("::")[1][1..-1]}: (#{day_model.count} entries)"
-      ItemToDecomTableMapping.where("packet_config_id = ? and table_index = ? and reduced = true", packet_config_id, table_index).order("item_index ASC").each do |itdtm|
-        item = Item.find(itdtm.item_id)
-        packet = Packet.find(item.packet_id)
-        target = Target.find(packet.target_id)
-        puts "    i#{itdtm.item_index}max #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-        puts "    i#{itdtm.item_index}min #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-        puts "    i#{itdtm.item_index}avg #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-        puts "    i#{itdtm.item_index}stddev #{target.name} #{packet.name} #{item.name} #{value_type_lookup[itdtm.value_type]}"
-      end      
-      puts ""
-    end
-    
-  when 'showpacketlogs'
-    total_size = 0
-    packet_logs = PacketLog.all
-    filenames = []
-    reader = Cosmos::PacketLogReader.new
-    packet_logs.each do |pl|
-      filenames << pl.filename
-      if File.exist?(pl.filename)
-        exists = "FOUND  "
-        size = File.size(pl.filename)
-        reader.open(pl.filename)
-        begin
-          first_packet = reader.first
-          last_packet = reader.last
-          start_time = first_packet.packet_time.formatted
-          end_time = last_packet.packet_time.formatted
-        rescue
-          if size == 128 or size == 0
-            start_time = "EMPTY                  "
-            end_time = "EMPTY                  "
-          else
-            start_time = "ERROR                  "
-            end_time = "ERROR                  "
-          end
-        ensure
-          reader.close
-        end
-      else
-        size = 0
-        start_time = "MISSING               "
-        end_time = "MISSING               "
-        exists = "MISSING"
-      end
-      puts "#{"%-32.32s" % File.basename(pl.filename)}  #{exists}  #{start_time}  #{end_time}  #{size}"
-      total_size += size
-    end
-    other_size = 0
-    Cosmos.set_working_dir do
-      Dir[Cosmos::System.paths['DART_DATA'] + '/*.bin'].each do |filename|
-        next if filename[0] == '.'
-        next if filenames.include?(filename)
-        exists = "NOTINDB"
-        size = File.size(filename)
-        reader.open(filename)
-        begin
-          first_packet = reader.first
-          last_packet = reader.last
-          start_time = first_packet.packet_time.formatted
-          end_time = last_packet.packet_time.formatted
-        rescue
-          if size == 128 or size == 0
-            start_time = "EMPTY                  "
-            end_time = "EMPTY                  "
-          else
-            start_time = "ERROR                  "
-            end_time = "ERROR                  "
-          end
-        ensure
-          reader.close
-        end
-        puts "#{"%-32.32s" % File.basename(filename)}  #{exists}  #{start_time}  #{end_time}  #{size}"
-        other_size += size
-      end
-    end
-    puts "Total size in database: #{"%0.2f GB" % (total_size.to_f / (1024 * 1024 * 1024))}"
-    puts "Total size not in database: #{"%0.2f GB" % (other_size.to_f / (1024 * 1024 * 1024))}"
-  end
-end

data/lib/cosmos/dart/processes/dart_worker.rb

@@ -1,38 +0,0 @@
-# encoding: ascii-8bit
-
-# Copyright 2018 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 General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-ENV['RAILS_ENV'] = 'production'
-require File.expand_path('../../config/environment', __FILE__)
-require 'dart_common'
-require 'dart_logging'
-require 'dart_decommutator'
-
-Cosmos.catch_fatal_exception do
-  DartCommon.handle_argv
-
-  # 0-based worker ID
-  worker_id = ARGV[0]
-  worker_id ||= 0
-  worker_id = worker_id.to_i
-  # Total number of workers
-  num_workers = ARGV[1]
-  num_workers ||= 1
-  num_workers = num_workers.to_i
-
-  Cosmos::Logger.level = Cosmos::Logger::INFO
-  dart_logging = DartLogging.new("dart_worker_#{worker_id}")
-  Cosmos::Logger.info("Dart Worker Starting...")
-  raise "Worker count #{num_workers} invalid" if num_workers < 1
-  raise "Worker id #{worker_id} too high for worker count of #{num_workers}" if worker_id >= num_workers
-  decom = DartDecommutator.new(worker_id, num_workers)
-  decom.run # Blocks forever
-  shutdown_cmd_tlm()
-  dart_logging.stop
-end

data/lib/cosmos/dart/spec/dart/dart_common_spec.rb

@@ -1,333 +0,0 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 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 General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'rails_helper'
-require 'dart_common'
-require 'database_cleaner'
-require 'cosmos/tools/cmd_tlm_server/cmd_tlm_server'
-require 'cosmos/tools/cmd_tlm_server/api'
-
-describe DartCommon do
-  let(:common) { Object.new.extend(DartCommon) }
-
-  describe "sync_targets_and_packets" do
-    it "configures the database" do
-      targets = Cosmos::System.telemetry.all.keys.sort
-      expect(targets).to eql Cosmos::System.commands.all.keys.sort
-
-      # Put all the known targets and packets into the DB
-      common.sync_targets_and_packets
-
-      # Verify the targets
-      Target.all.order(:name).each_with_index do |target, i|
-        expect(target.name).to eq targets[i]
-      end
-      # Verify the telemetry packets
-      Cosmos::System.telemetry.all.each do |target_name, packets|
-        target = Target.find_by_name(target_name)
-        expect(target.name).to eq target_name
-        packets.each do |name, packet|
-          pkt = Packet.where({target: target, name: name, is_tlm: true}).first
-          expect(pkt.name).to eq name
-          expect(pkt.is_tlm).to eq true
-          expect(pkt.target.name).to eq target_name
-        end
-      end
-      # Verify the command packets
-      Cosmos::System.commands.all.each do |target_name, packets|
-        target = Target.find_by_name(target_name)
-        expect(target.name).to eq target_name
-        packets.each do |name, packet|
-          pkt = Packet.where({target: target, name: name, is_tlm: false}).first
-          expect(pkt.name).to eq name
-          expect(pkt.is_tlm).to eq false
-          expect(pkt.target.name).to eq target_name
-        end
-      end
-
-      num_tgts = Target.all.length
-      tgt_created_at = Target.first.created_at
-      num_pkts = Packet.all.length
-      pkt_created_at = Packet.first.created_at
-      #num_items = Item.all.length
-      #item_created_at = Item.first.created_at
-
-      # Try to add the known targets and packets into the DB again
-      common.sync_targets_and_packets
-      # Verify nothing was added
-      expect(Target.all.length).to eq num_tgts
-      expect(Packet.all.length).to eq num_pkts
-      #expect(Item.all.length).to eq num_items
-      expect(Target.first.created_at).to eq tgt_created_at
-      expect(Packet.first.created_at).to eq pkt_created_at
-      #expect(Item.first.created_at).to eq item_created_at
-    end
-  end
-
-  describe "setup_packet_config" do
-    it "builds the packet configuration in the DB" do
-      common.sync_targets_and_packets
-      target_id, packet_id = common.lookup_target_and_packet_id("INST", "HEALTH_STATUS", true)
-      packet_log = PacketLog.create(:filename => "filename", :is_tlm => true)
-      ple = PacketLogEntry.new
-      ple.target_id = target_id
-      ple.packet_id = packet_id
-      ple.time = Time.now
-      ple.packet_log_id = packet_log.id
-      ple.data_offset = 0
-      ple.meta_id = 0
-      ple.is_tlm = true
-      ple.ready = true
-      ple.save!
-
-      packet = Cosmos::System.telemetry.packet("INST", "HEALTH_STATUS")
-      packet_config = PacketConfig.create(:packet_id => packet_id, :name => packet.config_name, :first_system_config_id => 0)
-      common.setup_packet_config(packet, packet_id, packet_config)
-
-      model = common.get_decom_table_model(packet_config.id, 0)
-      expect(model.column_names).to include("i0")
-      model = common.get_decom_table_model(packet_config.id, 0, '_m')
-      expect(model.column_names).to include("i0min")
-      expect(model.column_names).to include("i0max")
-      expect(model.column_names).to include("i0avg")
-      expect(model.column_names).to include("i0stddev")
-      model = common.get_decom_table_model(packet_config.id, 0, '_h')
-      expect(model.column_names).to include("i0min")
-      expect(model.column_names).to include("i0max")
-      expect(model.column_names).to include("i0avg")
-      expect(model.column_names).to include("i0stddev")
-      model = common.get_decom_table_model(packet_config.id, 0, '_d')
-      expect(model.column_names).to include("i0min")
-      expect(model.column_names).to include("i0max")
-      expect(model.column_names).to include("i0avg")
-      expect(model.column_names).to include("i0stddev")
-
-      # Useful debugging to pring out all the mapping items
-      # ItemToDecomTableMapping.all.each do |map|
-      #   item = Item.find(map.item_id)
-      #   puts "item name:#{item.name} id:#{item.id} val:#{map.value_type} reduced:#{map.reduced} config:#{map.packet_config_id} table_i:#{map.table_index} item_i:#{map.item_index}"
-      # end
-
-      ###################################
-      # Spot check some interesting items
-      ###################################
-
-      item = Item.find_by_name("RECEIVED_TIMESECONDS")
-      mapping = ItemToDecomTableMapping.where("item_id = ?", item.id)
-      # RECEIVED_TIMESECONDS is derived so it has a single mapping
-      expect(mapping.length).to eq 1
-      map = mapping.first
-      expect(map.value_type).to eq ItemToDecomTableMapping::RAW_CON
-      expect(map.reduced).to eq true # Seconds is an integer so it can be reduced
-      expect(map.packet_config_id).to eq packet_config.id
-      expect(map.table_index).to eq 0 # Not enough values to span multiple tables
-
-      item = Item.find_by_name("RECEIVED_TIMEFORMATTED")
-      mapping = ItemToDecomTableMapping.where("item_id = ?", item.id)
-      # RECEIVED_TIMEFORMATTED is derived so it has a single mapping
-      expect(mapping.length).to eq 1
-      map = mapping.first
-      expect(map.value_type).to eq ItemToDecomTableMapping::RAW_CON
-      expect(map.reduced).to eq false # Formatted is a string so it can't be reduced
-      expect(map.packet_config_id).to eq packet_config.id
-      expect(map.table_index).to eq 0 # Not enough values to span multiple tables
-
-      item = Item.find_by_name("TEMP1")
-      mapping = ItemToDecomTableMapping.where("item_id = ?", item.id)
-      # TEMP1 creates a separate RAW and CONVERTED table since it has a conversion
-      expect(mapping.length).to eq 2
-      map = mapping.where("value_type = ?", ItemToDecomTableMapping::RAW).first
-      expect(map.value_type).to eq ItemToDecomTableMapping::RAW
-      expect(map.reduced).to eq true # UINT32 can be reduced
-      expect(map.packet_config_id).to eq packet_config.id
-      expect(map.table_index).to eq 0 # Not enough values to span multiple tables
-      map = mapping.where("value_type = ?", ItemToDecomTableMapping::CONVERTED).first
-      expect(map.value_type).to eq ItemToDecomTableMapping::CONVERTED
-      expect(map.reduced).to eq true # UINT32 can be reduced
-      expect(map.packet_config_id).to eq packet_config.id
-      expect(map.table_index).to eq 0 # Not enough values to span multiple tables
-
-      item = Item.find_by_name("GROUND1STATUS")
-      mapping = ItemToDecomTableMapping.where("item_id = ?", item.id)
-      # GROUND1STATUS creates a separate RAW and CONVERTED table since it has states
-      expect(mapping.length).to eq 2
-      map = mapping.where("value_type = ?", ItemToDecomTableMapping::RAW).first
-      expect(map.value_type).to eq ItemToDecomTableMapping::RAW
-      expect(map.reduced).to eq true # Raw value can be reduced
-      expect(map.packet_config_id).to eq packet_config.id
-      expect(map.table_index).to eq 0 # Not enough values to span multiple tables
-      map = mapping.where("value_type = ?", ItemToDecomTableMapping::CONVERTED).first
-      expect(map.value_type).to eq ItemToDecomTableMapping::CONVERTED
-      expect(map.reduced).to eq false # Converted is a string and can't be reduced
-      expect(map.packet_config_id).to eq packet_config.id
-      expect(map.table_index).to eq 0 # Not enough values to span multiple tables
-    end
-
-    it "spans multiple DB tables with big packets" do
-      # Create a new packet with a bunch of items
-      packet = Cosmos::Packet.new('INST', 'BIGGIE', :BIG_ENDIAN)
-      num_items = DartCommon::MAX_COLUMNS_PER_TABLE + 1
-      num_items.times do |index|
-        packet.append_item("ITEM#{index}", 8, :INT)
-      end
-      # Push the new packet into the PacketConfig telemetry hash
-      Cosmos::System.telemetry.config.telemetry['INST']['BIGGIE'] = packet
-      common.sync_targets_and_packets
-      target_id, packet_id = common.lookup_target_and_packet_id("INST", "BIGGIE", true)
-      packet_log = PacketLog.create(:filename => "filename", :is_tlm => true)
-      ple = PacketLogEntry.new
-      ple.target_id = target_id
-      ple.packet_id = packet_id
-      ple.time = Time.now
-      ple.packet_log_id = packet_log.id
-      ple.data_offset = 0
-      ple.meta_id = 0
-      ple.is_tlm = true
-      ple.ready = true
-      ple.save!
-
-      packet = Cosmos::System.telemetry.packet("INST", "BIGGIE")
-      packet_config = PacketConfig.create(:packet_id => packet_id, :name => packet.config_name, :first_system_config_id => 0)
-      common.setup_packet_config(packet, packet_id, packet_config)
-
-      # Verify the decommutation and reduction tables were created
-      (0..1).each do |table_index|
-        model = common.get_decom_table_model(packet_config.id, table_index)
-        if table_index == 0
-          expect(model.column_names).to include("i0")
-          expect(model.column_names).to include("i#{DartCommon::MAX_COLUMNS_PER_TABLE - 1}")
-          # The base decommutation table doesn't average
-          expect(model.column_names).to_not include("i0avg")
-          expect(model.column_names).to_not include("i0stddev")
-        else
-          expect(model.column_names).to include("i#{DartCommon::MAX_COLUMNS_PER_TABLE}")
-          expect(model.column_names).to_not include("i#{DartCommon::MAX_COLUMNS_PER_TABLE + 1}")
-        end
-
-        %w(m h d).each do |suffix|
-          model = common.get_decom_table_model(packet_config.id, table_index, "_#{suffix}")
-          if table_index == 0
-            # The decommutation tables have min max avg only
-            expect(model.column_names).to_not include("i0")
-            expect(model.column_names).to include("i0min")
-            expect(model.column_names).to include("i0max")
-            expect(model.column_names).to include("i0avg")
-            expect(model.column_names).to include("i0stddev")
-            expect(model.column_names).to include("i#{DartCommon::MAX_COLUMNS_PER_TABLE - 1}min")
-            expect(model.column_names).to include("i#{DartCommon::MAX_COLUMNS_PER_TABLE - 1}max")
-            expect(model.column_names).to include("i#{DartCommon::MAX_COLUMNS_PER_TABLE - 1}avg")
-            expect(model.column_names).to include("i#{DartCommon::MAX_COLUMNS_PER_TABLE - 1}stddev")
-          else
-            expect(model.column_names).to include("i#{DartCommon::MAX_COLUMNS_PER_TABLE}min")
-            expect(model.column_names).to include("i#{DartCommon::MAX_COLUMNS_PER_TABLE}max")
-            expect(model.column_names).to include("i#{DartCommon::MAX_COLUMNS_PER_TABLE}avg")
-            expect(model.column_names).to include("i#{DartCommon::MAX_COLUMNS_PER_TABLE}stddev")
-          end
-        end
-      end
-
-      num_items.times do |index|
-        item = Item.where("name = ? AND packet_id = ?", "ITEM#{index}", packet_id).first
-        map = ItemToDecomTableMapping.where("item_id = ?", item.id).first
-        if index < DartCommon::MAX_COLUMNS_PER_TABLE
-          expect(map.table_index).to eq 0
-        else
-          expect(map.table_index).to eq 1 # Mapping spans another table
-        end
-      end
-    end
-  end
-
-  describe "switch_and_get_system_config" do
-    before(:each) do
-      allow_any_instance_of(Cosmos::Interface).to receive(:connected?)
-      allow_any_instance_of(Cosmos::Interface).to receive(:connect)
-      allow_any_instance_of(Cosmos::Interface).to receive(:disconnect)
-      allow_any_instance_of(Cosmos::Interface).to receive(:write_raw)
-      allow_any_instance_of(Cosmos::Interface).to receive(:read)
-      allow_any_instance_of(Cosmos::Interface).to receive(:write)
-      @tlm_file = File.join(Cosmos::USERPATH,'config','targets','SYSTEM','cmd_tlm','test1_tlm.txt')
-      FileUtils.rm @tlm_file if File.exist? @tlm_file
-    end
-
-    it "raises an error if the configuration can't be found" do
-      api = Cosmos::CmdTlmServer.new
-      expect { common.switch_and_get_system_config("abcd") }.to raise_error(/No saved config/)
-      api.stop
-    end
-
-    it "does nothing if loading the current config" do
-      api = Cosmos::CmdTlmServer.new
-      current = Cosmos::System.configuration_name
-      common.switch_and_get_system_config(current)
-      expect(Cosmos::System.configuration_name).to eq current
-      api.stop
-    end
-
-    it "loads new configuration" do
-      api = Cosmos::CmdTlmServer.new
-      initial_config = Cosmos::System.configuration_name
-
-      # Create a new configuration by writing another telemetry file
-      File.open(@tlm_file, 'w') do |file|
-        file.puts "TELEMETRY SYSTEM TEST1 BIG_ENDIAN"
-        file.puts "  APPEND_ITEM DATA 240 STRING"
-      end
-      # Reset the instance variable so it will create the new configuration
-      Cosmos::System.class_eval('@@instance = nil')
-      Cosmos::System.telemetry # Create the new config
-      new_config = Cosmos::System.configuration_name
-      expect(new_config).to_not eq initial_config
-
-      # Stub find_configuration to first return nil (not found) and then work
-      # This allows the switch_and_get_system_config to act like the local copy
-      # could not be found and then properly finds it
-      allow(Cosmos::System.instance).to receive(:find_configuration).and_return(nil, Cosmos::System.instance.find_configuration(initial_config))
-      messages = []
-      allow(Cosmos::Logger).to receive(:info) { |msg| messages << msg }
-
-      common.switch_and_get_system_config(initial_config)
-      expect(Cosmos::System.configuration_name).to eq initial_config
-      messages.each do |msg|
-        if msg =~ /Configuration retrieved/
-          expect(msg).to match(/#{initial_config}/)
-        end
-      end
-
-      api.stop
-      FileUtils.rm @tlm_file
-    end
-  end
-
-  describe "read_packet_from_ple" do
-    # NOTE: most of read_packet_from_ple is tested in the dart_packet_log_writer_spec
-    it "raises an error if the packet can't be found" do
-      common.sync_targets_and_packets
-      target_id, packet_id = common.lookup_target_and_packet_id("INST", "HEALTH_STATUS", true)
-      packet_log = PacketLog.create(:filename => "filename", :is_tlm => true)
-      ple = PacketLogEntry.new
-      ple.target_id = target_id
-      ple.packet_id = packet_id
-      ple.time = Time.now
-      ple.packet_log_id = packet_log.id
-      ple.data_offset = 999
-      ple.meta_id = 999
-      ple.is_tlm = true
-      ple.ready = true
-      ple.save!
-
-      expect(Cosmos::Logger).to receive(:error) do |msg|
-        expect(msg).to match(/Error Reading Packet/)
-      end
-      packet = common.read_packet_from_ple(ple)
-      expect(packet).to be_nil
-    end
-  end
-end