cosmos 4.2.4 → 4.5.0

data/spec/io/json_drb_rack_spec.rb

@@ -0,0 +1,166 @@
+  # 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 'spec_helper'
+  require 'cosmos/io/json_drb_rack'
+
+  module Cosmos
+
+    describe JsonDrbRack do
+      before(:each) do
+        @env = {
+          "GATEWAY_INTERFACE" => "CGI/1.1",
+          "PATH_INFO" => "/index.html",
+          "QUERY_STRING" => "",
+          "REMOTE_ADDR" => "::1",
+          "REMOTE_HOST" => "localhost",
+          "REQUEST_METHOD" => "POST",
+          "REQUEST_URI" => "http://localhost:3000/index.html",
+          "SCRIPT_NAME" => "",
+          "SERVER_NAME" => "localhost",
+          "SERVER_PORT" => "3000",
+          "SERVER_PROTOCOL" => "HTTP/1.1",
+          "SERVER_SOFTWARE" => "WEBrick/1.3.1 (Ruby/2.0.0/2013-11-22)",
+          "HTTP_HOST" => "127.0.0.1:7777",
+          "HTTP_USER_AGENT" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.9; rv:26.0) Gecko/20100101 Firefox/26.0",
+          "HTTP_ACCEPT" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+          "HTTP_ACCEPT_LANGUAGE" => "zh-tw,zh;q=0.8,en-us;q=0.5,en;q=0.3",
+          "HTTP_ACCEPT_ENCODING" => "gzip, deflate",
+          "HTTP_COOKIE" => "jsonrpc.session=3iqp3ydRwFyqjcfO0GT2bzUh.bacc2786c7a81df0d0e950bec8fa1a9b1ba0bb61",
+          "HTTP_CONNECTION" => "keep-alive",
+          "HTTP_CACHE_CONTROL" => "max-age=0",
+          "rack.version" => [1, 2],
+          "rack.input" => StringIO.new(""),
+          "rack.errors" => nil,
+          "rack.multithread" => true,
+          "rack.multiprocess" => false,
+          "rack.run_once" => false,
+          "rack.url_scheme" => "http",
+          "HTTP_VERSION" => "HTTP/1.1",
+          "REQUEST_PATH" => "/index.html"
+        }
+      end
+
+      class MockDRb
+        class MockDRbAcl
+          def initialize(val = true)
+            @val = val
+          end
+          def allow_addr?(val)
+            return @val
+          end
+        end
+
+        def initialize(val, response_data = "response", error_code = nil)
+          @acl = MockDRbAcl.new(val)
+          @response_data = response_data
+          @error_code = error_code
+        end
+
+        def acl
+          @acl
+        end
+
+        def process_request(request_data, start_time)
+          return @response_data, @error_code
+        end
+      end
+
+      class MockSystem
+        def initialize(token = 'SuperSecret', hosts = ['127.0.0.1:7777'], origins = [])
+          @token = token
+          @hosts = hosts
+          @origins = origins
+        end
+        def x_csrf_token
+          @token
+        end
+        def allowed_hosts
+          @hosts
+        end
+        def allowed_origins
+          @origins
+        end
+      end
+
+      describe "call" do
+        it "supports the drb acl" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(false), MockSystem.new)
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 403
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Forbidden"]
+        end
+
+        it "handles X-Csrf-Token" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'TryToGuess'
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 403
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Forbidden: Bad X-Csrf-Token: #{@env['HTTP_X_CSRF_TOKEN']}"]
+
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 200
+          expect(type).to eql({'Content-Type' => "application/json-rpc"})
+          expect(body_array).to eql ["response"]
+        end
+
+        it "Handles Allowed Hosts" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env['HTTP_HOST'] = "5.6.7.8:7777"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 403
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Forbidden: #{@env['HTTP_HOST']} not in allowed hosts"]
+
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess', ['5.6.7.8:7777']))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env['HTTP_HOST'] = "5.6.7.8:7777"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 200
+          expect(type).to eql({'Content-Type' => "application/json-rpc"})
+          expect(body_array).to eql ["response"]
+        end
+
+        it "Handles Allowed Origins" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env['HTTP_ORIGIN'] = "5.6.7.8:7777"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 403
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Forbidden: #{@env['HTTP_ORIGIN']} not in allowed origins"]
+
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess', ['127.0.0.1:7777'], ['3.6.7.8:7777']))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env['HTTP_ORIGIN'] = "3.6.7.8:7777"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 200
+          expect(type).to eql({'Content-Type' => "application/json-rpc"})
+          expect(body_array).to eql ["response"]
+        end
+
+        it "Only accepts posts" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env["REQUEST_METHOD"] = "GET"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 405
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Request not allowed"]
+        end
+
+      end
+    end
+  end

data/spec/io/json_drb_spec.rb

@@ -200,6 +200,20 @@ module Cosmos
         sleep(0.1)
       end
 
+      it "processes success requests with uppercase" do
+        class MyServer5
+          def my_method(param)
+          end
+        end
+
+        @json.start_service('127.0.0.1', 7777, MyServer5.new)
+        request_data = JsonRpcRequest.new('MY_METHOD', 'param', 1).to_json
+        _, error_code = @json.process_request(request_data, Time.now)
+        expect(error_code).to eq nil
+        @json.stop_service
+        sleep(0.1)
+      end
+
       it "does not allow dangerous methods" do
         @json.start_service('127.0.0.1', 7777, self)
         request_data = JsonRpcRequest.new('send', 'param', 1).to_json

data/spec/io/json_rpc_spec.rb

@@ -238,25 +238,25 @@ module Cosmos
 
       it "reports an error if there is no 'result' or 'error' key" do
         json = JsonRpcResponse.new(10).as_json
-        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Response")
+        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error(/Invalid JSON-RPC 2.0 Response/)
       end
 
       it "reports an error if the version isn't 2.0" do
         json = JsonRpcResponse.new(10).as_json
         json['jsonrpc'] = "1.1"
         json['result'] = "true"
-        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Response")
+        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error(/Invalid JSON-RPC 2.0 Response/)
       end
 
       it "reports an error if there is both a 'result' and 'error' key" do
         json = JsonRpcResponse.new(10).as_json
         json['result'] = "true"
         json['error'] = {"code"=>-1, "message"=>"error"}
-        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Response")
+        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error(/Invalid JSON-RPC 2.0 Response/)
       end
 
       it "reports an error if it is not json" do
-        expect { JsonRpcResponse.from_json(Object.new) }.to raise_error("Invalid JSON-RPC 2.0 Response")
+        expect { JsonRpcResponse.from_json(Object.new) }.to raise_error(/Invalid JSON-RPC 2.0 Response/)
       end
 
       it "reports an error if the error hash is bad" do
@@ -268,4 +268,3 @@ module Cosmos
 
   end
 end
-

data/spec/io/posix_serial_driver_spec.rb

@@ -0,0 +1,81 @@
+# 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
+
+if RbConfig::CONFIG['target_os'] !~ /mswin|mingw|cygwin/i and RUBY_ENGINE == 'ruby' and !ENV['TRAVIS']
+
+  require 'spec_helper'
+  require 'cosmos/io/posix_serial_driver'
+
+  module Cosmos
+
+    describe PosixSerialDriver do
+      describe "instance" do
+        it "enforces the baud rate to a known value" do
+          expect { PosixSerialDriver.new('/dev/ttyS0',10,:NONE) }.to raise_error(ArgumentError, "Invalid baud rate: 10")
+        end
+
+        it "supports even, odd, or no parity" do
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:EVEN).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:ODD).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:BLAH) }.to raise_error(ArgumentError, "Invalid parity: BLAH")
+        end
+
+        it "supports 1 or 2 stop bits" do
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,2).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,3) }.to raise_error(ArgumentError, "Invalid stop bits: 3")
+        end
+
+        it "supports 5-8 data bits" do
+          (5..8).each do |data_bits|
+            driver = PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1,10,nil,:NONE,data_bits)
+            handle = driver.instance_variable_get(:@handle)
+            expect(handle.tcgetattr.cflag & Termios::CSIZE).to eq(Termios.const_get("CS#{data_bits}"))
+            driver.close
+          end
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1,10,nil,:NONE,9) }.to raise_error(ArgumentError, "Invalid data bits: 9")
+        end
+
+        it "sets arbitrary Posix structure elements" do
+          driver = PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1,10,nil,:NONE,8)
+          handle = driver.instance_variable_get(:@handle)
+          # Verify non of the things we're going to set are already set
+          expect(handle.tcgetattr.iflag & Termios::IGNBRK).to eq(0)
+          expect(handle.tcgetattr.oflag & Termios::OPOST).to eq(0)
+          expect(handle.tcgetattr.cflag & Termios::CLOCAL).to eq(Termios::CLOCAL) # We set this by default
+          expect(handle.tcgetattr.lflag & Termios::ECHO).to eq(0)
+          expect(handle.tcgetattr.cc[Termios::VMIN]).to eq(1)
+          driver.close
+          # When setting a field the "1" is optional. When clearing a field the "0" is required.
+          # Entries in the "cc" special characters field are automatically converted to integers if they are numbers
+          struct = [["iflag", "IGNBRK"], ["oflag", "OPOST", "1"], ["cflag", "CLOCAL", "0"], ["lflag", "ECHO"], ["cc", "VMIN", "2"]]
+          driver = PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1,10,nil,:NONE,8,struct)
+          handle = driver.instance_variable_get(:@handle)
+          expect(handle.tcgetattr.iflag & Termios::IGNBRK).to eq(Termios::IGNBRK)
+          expect(handle.tcgetattr.oflag & Termios::OPOST).to eq(Termios::OPOST)
+          expect(handle.tcgetattr.cflag & Termios::CLOCAL).to eq(0)
+          expect(handle.tcgetattr.lflag & Termios::ECHO).to eq(Termios::ECHO)
+          expect(handle.tcgetattr.cc[Termios::VMIN]).to eq(2)
+          driver.close
+        end
+      end
+
+      describe "close, closed?" do
+        it "closes the handle" do
+          driver = PosixSerialDriver.new('/dev/ttyS0',9600)
+          expect(driver.closed?).to be false
+          driver.close
+          expect(driver.closed?).to be true
+        end
+      end
+    end
+  end
+end

data/spec/io/serial_driver_spec.rb

@@ -41,20 +41,22 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
         end
 
         it "defers to the posix serial driver on nix" do
-          class PosixSerialDriver
+          if RUBY_ENGINE == 'ruby'
+            class PosixSerialDriver
+            end
+            allow(Kernel).to receive(:is_windows?).and_return(false)
+            driver = double("PosixSerialDriver")
+            expect(driver).to receive(:close)
+            expect(driver).to receive(:closed?)
+            expect(driver).to receive(:write)
+            expect(driver).to receive(:read)
+            allow(PosixSerialDriver).to receive(:new).and_return(driver)
+            driver = SerialDriver.new('COM1',9600)
+            driver.close
+            driver.closed?
+            driver.write("hi")
+            driver.read
           end
-          allow(Kernel).to receive(:is_windows?).and_return(false)
-          driver = double("PosixSerialDriver")
-          expect(driver).to receive(:close)
-          expect(driver).to receive(:closed?)
-          expect(driver).to receive(:write)
-          expect(driver).to receive(:read)
-          allow(PosixSerialDriver).to receive(:new).and_return(driver)
-          driver = SerialDriver.new('COM1',9600)
-          driver.close
-          driver.closed?
-          driver.write("hi")
-          driver.read
         end
       end
     end

data/spec/io/win32_serial_driver_spec.rb

@@ -19,7 +19,8 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
       before(:each) do
         allow(Win32).to receive(:create_file).and_return(Object.new)
         state = double("comm_state")
-        allow(state).to receive(:write)
+        @dcb_struct = {}
+        allow(state).to receive(:write) { |key, value| @dcb_struct[key] = value }
         allow(Win32).to receive(:get_comm_state).and_return(state)
         allow(Win32).to receive(:set_comm_state)
         allow(Win32).to receive(:set_comm_timeouts)
@@ -34,12 +35,14 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
           expect { Win32SerialDriver.new('COM1',9600,:EVEN) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:ODD) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:NONE) }.to_not raise_error
+          expect(@dcb_struct["Parity"]).to_not be_nil # Simply check that Parity was set
           expect { Win32SerialDriver.new('COM1',9600,:BLAH) }.to raise_error(ArgumentError, "Invalid parity: BLAH")
         end
 
         it "supports 1 or 2 stop bits" do
           expect { Win32SerialDriver.new('COM1',9600,:NONE,1) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:NONE,2) }.to_not raise_error
+          expect(@dcb_struct["StopBits"]).to_not be_nil # Simply check that StopBits was set
           expect { Win32SerialDriver.new('COM1',9600,:NONE,3) }.to raise_error(ArgumentError, "Invalid stop bits: 3")
         end
 
@@ -49,6 +52,35 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
           expect { Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,7) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,8) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,9) }.to raise_error(ArgumentError, "Invalid data bits: 9")
+          expect(@dcb_struct["ByteSize"]).to_not be_nil # Simply check that ByteSize was set
+        end
+
+        it "sets arbitrary Windows DCB structure elements" do
+          Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,8)
+          expect(@dcb_struct["fOutxDsrFlow"]).to be_nil # This isn't set by default
+          expect(@dcb_struct["Parity"]).to eq(0)
+          # Set a new variable in the Windows DCB struct and override the :NONE parity
+          # We pass them in as strings because that's how they're parsed
+          struct = [["fOutxDsrFlow", "1"], ["Parity", "4"]]
+          Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,8,struct)
+          expect(@dcb_struct["fOutxDsrFlow"]).to eq(1)
+          expect(@dcb_struct["Parity"]).to eq(4)
+        end
+
+        it "calculates the correct timeouts" do
+          Win32::BAUD_RATES.each do |baud|
+            (5..8).each do |data_bits|
+              (1..2).each do |stop_bits|
+                [:EVEN, :ODD, :NONE].each do |parity|
+                  # data_bits + 1 start bit + stop bits + potentially a parity bit
+                  symbols = data_bits + 1 + stop_bits + (parity == :NONE ? 0 : 1)
+                  delay = 1000.0 / (baud.to_f / symbols)
+                  expect(Win32).to receive(:set_comm_timeouts).with(anything, 0xFFFFFFFF,0,0,delay.ceil,1000)
+                  Win32SerialDriver.new('COM1',baud,parity,stop_bits,10,nil,0.01,1000,:NONE,data_bits)
+                end
+              end
+            end
+          end
         end
       end
 
@@ -92,8 +124,6 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
           expect { driver.read }.to raise_error(Timeout::Error)
         end
       end
-
     end
   end
-
 end

data/spec/packet_logs/packet_log_reader_spec.rb

@@ -23,7 +23,10 @@ module Cosmos
       plw = PacketLogWriter.new(:CMD,nil,true,nil,10000000,nil,false)
       @cmd_packets = []
       pkt = System.commands.packet("SYSTEM","STARTLOGGING").clone
-      pkt.received_time = Time.new(2020,1,31,12,30,15)
+      # Avoid precision errors by rounding to nearest second and then add 1 to ensure
+      # the time is AFTER the initial META packet with the current time
+      @time = Time.now.round + 1
+      pkt.received_time = @time
       pkt.write('label','PKT1')
       plw.write(pkt)
       @cmd_packet_length = pkt.length
@@ -43,7 +46,7 @@ module Cosmos
       plw = PacketLogWriter.new(:TLM,nil,true,nil,10000000,nil,false)
       @tlm_packets = []
       pkt = System.telemetry.packet("SYSTEM","LIMITS_CHANGE").clone
-      pkt.received_time = Time.new(2020,2,1,12,30,15)
+      pkt.received_time = @time
       pkt.write('PACKET','PKT1')
       plw.write(pkt)
       @tlm_packet_length = pkt.length
@@ -121,7 +124,35 @@ module Cosmos
           file.write [pkt.buffer.length].pack('N')
           file.write pkt.buffer
         end
-        expect(@plr.open(filename)).to eql [false, nil]
+        expect(@plr.open(filename)[0]).to eql false
+        pkt1 = @plr.read
+        expect(pkt1.target_name).to eql 'TGT1'
+        expect(pkt1.packet_name).to eql 'PKT1'
+        pkt2 = @plr.read
+        expect(pkt2.target_name).to eql 'TGT2'
+        expect(pkt2.packet_name).to eql 'PKT2'
+        pkt3 = @plr.read
+        expect(pkt3.target_name).to eql 'TGT3'
+        expect(pkt3.packet_name).to eql 'PKT3'
+        @plr.close
+      end
+
+      it "opens COSMOS2 log files" do
+        pkt = System.telemetry.packet("SYSTEM","LIMITS_CHANGE").clone
+        filename = File.join(@log_path,'test.bin')
+        File.open(filename,'wb') do |file|
+          file.write ("COSMOS2_CMD                             TEST " + (" " * 83))
+          file.write [1000,100,4,"TGT1",4,"PKT1"].pack('NNCA4CA4')
+          file.write [pkt.buffer.length].pack('N')
+          file.write pkt.buffer
+          file.write [1000,100,4,"TGT2",4,"PKT2"].pack('NNCA4CA4')
+          file.write [pkt.buffer.length].pack('N')
+          file.write pkt.buffer
+          file.write [1000,100,4,"TGT3",4,"PKT3"].pack('NNCA4CA4')
+          file.write [pkt.buffer.length].pack('N')
+          file.write pkt.buffer
+        end
+        expect(@plr.open(filename)[0]).to eql false
         pkt1 = @plr.read
         expect(pkt1.target_name).to eql 'TGT1'
         expect(pkt1.packet_name).to eql 'PKT1'
@@ -205,16 +236,17 @@ module Cosmos
         expect(@plr.log_type).to eql :CMD
         expect(@plr.configuration_name).not_to be_nil
         expect(@plr.hostname).to eql Socket.gethostname
-        header_length = 8 + 1 + 6 + 1 + 12 + 4
-        meta_header_length = 8 + 1 + 6 + 1 + 4 + 4
+        header_length = 1 + 8 + 1 + 6 + 1 + 12 + 4
+        meta_header_length = 1 + 8 + 1 + 6 + 1 + 4 + 4
         meta_length = System.telemetry.packet('SYSTEM', 'META').length
-        expect(packet_offsets).to eql [PacketLogReader::COSMOS2_HEADER_LENGTH, PacketLogReader::COSMOS2_HEADER_LENGTH + meta_header_length + meta_length, PacketLogReader::COSMOS2_HEADER_LENGTH + meta_header_length + meta_length + header_length + @cmd_packet_length, PacketLogReader::COSMOS2_HEADER_LENGTH + meta_header_length + meta_length + (header_length + @cmd_packet_length) * 2]
+        expect(packet_offsets).to eql [PacketLogReader::COSMOS4_HEADER_LENGTH, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length + header_length + @cmd_packet_length, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length + (header_length + @cmd_packet_length) * 2]
 
         expect(@plr.open(Dir[File.join(@log_path,"*cmd.bin")][0])).to eql [true, nil]
-        pkt = @plr.read_at_offset(packet_offsets[2])
+        pkt = @plr.read_at_offset(packet_offsets[2]) # Grab the second STARTLOGGING (META is 0)
         expect(pkt.target_name).to eql "SYSTEM"
         expect(pkt.packet_name).to eql "STARTLOGGING"
-        expect(pkt.received_time).to eql Time.new(2020,1,31,12,30,16)
+        expect(pkt.read('LABEL')).to eql "PKT2"
+        expect(pkt.received_time).to eql @time + 1
         @plr.close
       end
 
@@ -223,16 +255,17 @@ module Cosmos
         expect(@plr.log_type).to eql :TLM
         expect(@plr.configuration_name).not_to be_nil
         expect(@plr.hostname).to eql Socket.gethostname
-        header_length = 8 + 1 + 6 + 1 + 13 + 4
-        meta_header_length = 8 + 1 + 6 + 1 + 4 + 4
+        header_length = 1 + 8 + 1 + 6 + 1 + 13 + 4
+        meta_header_length = 1 + 8 + 1 + 6 + 1 + 4 + 4
         meta_length = System.telemetry.packet('SYSTEM', 'META').length
-        expect(packet_offsets).to eql [PacketLogReader::COSMOS2_HEADER_LENGTH, PacketLogReader::COSMOS2_HEADER_LENGTH + meta_header_length + meta_length, PacketLogReader::COSMOS2_HEADER_LENGTH + meta_header_length + meta_length + header_length + @tlm_packet_length, PacketLogReader::COSMOS2_HEADER_LENGTH + meta_header_length + meta_length + (header_length + @tlm_packet_length) * 2]
+        expect(packet_offsets).to eql [PacketLogReader::COSMOS4_HEADER_LENGTH, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length + header_length + @tlm_packet_length, PacketLogReader::COSMOS4_HEADER_LENGTH + meta_header_length + meta_length + (header_length + @tlm_packet_length) * 2]
 
         expect(@plr.open(Dir[File.join(@log_path,"*tlm.bin")][0])).to eql [true, nil]
-        pkt = @plr.read_at_offset(packet_offsets[2])
+        pkt = @plr.read_at_offset(packet_offsets[2]) # Grab the second LIMITS_CHANGE (META is 0)
         expect(pkt.target_name).to eql "SYSTEM"
         expect(pkt.packet_name).to eql "LIMITS_CHANGE"
-        expect(pkt.received_time).to eql Time.new(2020,2,1,12,30,16)
+        expect(pkt.read('PACKET')).to eql "PKT2"
+        expect(pkt.received_time).to eql @time + 1
         @plr.close
       end
     end
@@ -240,10 +273,10 @@ module Cosmos
     describe "each" do
       it "returns packets" do
         index = 0
-        meta_header_length = 8 + 1 + 6 + 1 + 4 + 4
+        meta_header_length = 1 + 8 + 1 + 6 + 1 + 4 + 4
         meta_length = System.telemetry.packet('SYSTEM', 'META').length
         packet_length = System.commands.packet('SYSTEM', 'STARTLOGGING').length
-        packet_header_length = 8 + 1 + 'SYSTEM'.length + 1 + 'STARTLOGGING'.length + 4
+        packet_header_length = 1 + 8 + 1 + 'SYSTEM'.length + 1 + 'STARTLOGGING'.length + 4
         bytes_read = 128 + packet_header_length + packet_length + meta_header_length + meta_length
         @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0]) do |packet|
           next if packet.packet_name == 'META'
@@ -257,7 +290,7 @@ module Cosmos
         end
         index = 0
         packet_length = System.telemetry.packet('SYSTEM', 'LIMITS_CHANGE').length
-        packet_header_length = 8 + 1 + 'SYSTEM'.length + 1 + 'LIMITS_CHANGE'.length + 4
+        packet_header_length = 1 + 8 + 1 + 'SYSTEM'.length + 1 + 'LIMITS_CHANGE'.length + 4
         bytes_read = 128 + packet_header_length + packet_length + meta_header_length + meta_length
         @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0]) do |packet|
           next if packet.packet_name == 'META'
@@ -294,12 +327,20 @@ module Cosmos
 
       it "increments the command received count" do
         plw = PacketLogWriter.new(:CMD,'cnt',true,nil,10000000,nil,false)
-        plw.write(System.commands.packet("INST","COLLECT").clone)
-        plw.write(System.commands.packet("INST","ABORT").clone)
-        plw.write(System.commands.packet("INST","ABORT").clone)
-        plw.write(System.commands.packet("INST","COLLECT").clone)
-        plw.write(System.commands.packet("SYSTEM","STOPLOGGING").clone)
-        plw.write(System.commands.packet("INST","ABORT").clone)
+        collect_packet = System.commands.packet("INST","COLLECT").clone
+        collect_packet.stored = false
+        collect_packet.extra = {"vcid" => 2}
+        abort_packet = System.commands.packet("INST","ABORT").clone
+        abort_packet.stored = true
+        abort_packet.extra = {"test" => 1}
+        stop_packet = System.commands.packet("SYSTEM","STOPLOGGING").clone
+        stop_packet.stored = true
+        plw.write(collect_packet)
+        plw.write(abort_packet)
+        plw.write(abort_packet)
+        plw.write(collect_packet)
+        plw.write(stop_packet)
+        plw.write(abort_packet)
         plw.stop
 
         cnt = {}
@@ -308,6 +349,15 @@ module Cosmos
           cnt["#{packet.target_name}_#{packet.packet_name}"] ||= 0
           cnt["#{packet.target_name}_#{packet.packet_name}"] += 1
           expect(packet.received_count).to eql cnt["#{packet.target_name}_#{packet.packet_name}"]
+          if packet.packet_name == 'ABORT'
+            expect(packet.stored).to eql true
+            expect(packet.extra).to eql({"test" => 1})
+          elsif packet.packet_name == 'COLLECT'
+            expect(packet.stored).to eql false
+            expect(packet.extra).to eql({"vcid" => 2})
+          elsif packet.packet_name == 'STOPLOGGING'
+            expect(packet.stored).to eql true
+          end
         end
 
         # Resetting a packet should reset only that packet's received_count
@@ -328,10 +378,13 @@ module Cosmos
 
       it "increments the telemetry received count" do
         plw = PacketLogWriter.new(:TLM,'cnt',true,nil,10000000,nil,false)
-        plw.write(System.telemetry.packet("INST","HEALTH_STATUS").clone)
+        hs_packet = System.telemetry.packet("INST","HEALTH_STATUS").clone
+        hs_packet.stored = true
+        hs_packet.extra = {"vcid" => 2}
+        plw.write(hs_packet)
         plw.write(System.telemetry.packet("INST","ADCS").clone)
         plw.write(System.telemetry.packet("INST","ADCS").clone)
-        plw.write(System.telemetry.packet("INST","HEALTH_STATUS").clone)
+        plw.write(hs_packet)
         plw.write(System.telemetry.packet("INST","ADCS").clone)
         plw.stop
 
@@ -341,6 +394,13 @@ module Cosmos
           cnt["#{packet.target_name}_#{packet.packet_name}"] ||= 0
           cnt["#{packet.target_name}_#{packet.packet_name}"] += 1
           expect(packet.received_count).to eql cnt["#{packet.target_name}_#{packet.packet_name}"]
+          if packet.packet_name == 'HEALTH_STATUS'
+            expect(packet.stored).to eql true
+            expect(packet.extra).to eql({"vcid" => 2})
+          elsif packet.packet_name == 'ADCS'
+            expect(packet.stored).to eql false
+            expect(packet.extra).to eql nil
+          end
         end
 
         # Resetting a packet should reset only that packet's received_count
@@ -360,9 +420,8 @@ module Cosmos
       end
 
       it "returns all packets if the start time is before all" do
-        time = Time.new(2000,1,31,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, time) do |packet|
+        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, @time) do |packet|
           next if packet.packet_name == 'META'
           expect(packet.target_name).to eql @cmd_packets[index].target_name
           expect(packet.packet_name).to eql @cmd_packets[index].packet_name
@@ -374,51 +433,48 @@ module Cosmos
       end
 
       it "returns no packets if the start time is after all" do
-        time = Time.new(2030,2,1,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, time) do |packet|
+        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, @time + 100) do |packet|
           index += 1
         end
         expect(index).to eql 0
       end
 
       it "returns all packets after a start time" do
-        time = Time.new(2020,1,31,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, time) do |packet|
-          expect(packet.target_name).to eql @cmd_packets[index+1].target_name
-          expect(packet.packet_name).to eql @cmd_packets[index+1].packet_name
-          expect(packet.received_time).to eql @cmd_packets[index+1].received_time
-          expect(packet.read('LABEL')).to eql @cmd_packets[index+1].read('LABEL')
+        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, @time) do |packet|
+          next if packet.packet_name == 'META'
+          expect(packet.target_name).to eql @cmd_packets[index].target_name
+          expect(packet.packet_name).to eql @cmd_packets[index].packet_name
+          expect(packet.received_time).to eql @cmd_packets[index].received_time
+          expect(packet.read('LABEL')).to eql @cmd_packets[index].read('LABEL')
           index += 1
         end
-        expect(index).to eql 2
+        expect(index).to eql 3
 
-        time = Time.new(2020,2,1,12,30,16)
-        index = 0
-        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, time) do |packet|
-          expect(packet.target_name).to eql @tlm_packets[index+1].target_name
-          expect(packet.packet_name).to eql @tlm_packets[index+1].packet_name
-          expect(packet.received_time).to eql @tlm_packets[index+1].received_time
-          expect(packet.read('PACKET')).to eql @tlm_packets[index+1].read('PACKET')
+        index = 1 # @time + 1
+        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, @time + 1) do |packet|
+          next if packet.packet_name == 'META'
+          expect(packet.target_name).to eql @tlm_packets[index].target_name
+          expect(packet.packet_name).to eql @tlm_packets[index].packet_name
+          expect(packet.received_time).to eql @tlm_packets[index].received_time
+          expect(packet.read('PACKET')).to eql @tlm_packets[index].read('PACKET')
           index += 1
         end
-        expect(index).to eql 2
+        expect(index).to eql 3
       end
 
       it "returns no packets if the end time is before all" do
-        time = Time.new(2000,1,31,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, nil, time) do |packet|
+        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, nil, @time - 10) do |packet|
           index += 1
         end
         expect(index).to eql 0
       end
 
       it "returns all packets if the end time is after all" do
-        time = Time.new(2030,2,1,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, nil, time) do |packet|
+        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, nil, @time + 10) do |packet|
           next if packet.packet_name == 'META'
           expect(packet.target_name).to eql @cmd_packets[index].target_name
           expect(packet.packet_name).to eql @cmd_packets[index].packet_name
@@ -430,9 +486,8 @@ module Cosmos
       end
 
       it "returns all packets before an end time" do
-        time = Time.new(2020,1,31,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, nil, time) do |packet|
+        @plr.each(Dir[File.join(@log_path,"*cmd.bin")][0], true, nil, @time) do |packet|
           next if packet.packet_name == 'META'
           expect(packet.target_name).to eql @cmd_packets[index].target_name
           expect(packet.packet_name).to eql @cmd_packets[index].packet_name
@@ -440,11 +495,10 @@ module Cosmos
           expect(packet.read('LABEL')).to eql @cmd_packets[index].read('LABEL')
           index += 1
         end
-        expect(index).to eql 2
+        expect(index).to eql 1
 
-        time = Time.new(2020,2,1,12,30,16)
         index = 0
-        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, nil, time) do |packet|
+        @plr.each(Dir[File.join(@log_path,"*tlm.bin")][0], true, nil, @time + 1) do |packet|
           next if packet.packet_name == 'META'
           expect(packet.target_name).to eql @tlm_packets[index].target_name
           expect(packet.packet_name).to eql @tlm_packets[index].packet_name