cosmos 3.0.0

data/spec/io/tcpip_server_spec.rb

@@ -0,0 +1,322 @@
+# 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/tcpip_server'
+
+module Cosmos
+
+  describe TcpipServer do
+
+    describe "instance" do
+      it "should rescue bad stream protocol names" do
+        expect { TcpipServer.new(8888,8889,nil,nil,'Unknown') }.to raise_error(/Unable to require/)
+      end
+    end
+
+    describe "connect, connected?, disconnect" do
+      it "should only allow connect once" do
+        server = TcpipServer.new(nil,8889,nil,nil,'Burst')
+        server.connect
+        sleep 0.2
+        expect { server.connect }.to raise_error(/Error binding/)
+        server.disconnect
+      end
+
+      it "should create a listener thread for the read port" do
+        server = TcpipServer.new(nil,8889,nil,nil,'Burst')
+        server.connect
+        sleep 0.2
+        server.connected?.should be_truthy
+        # 2 because the RSpec main thread plus the listener
+        Thread.list.length.should eql 2
+        server.disconnect
+        sleep 0.2
+        server.connected?.should be_falsey
+        Thread.list.length.should eql 1
+      end
+
+      it "should create a listener thread for the write port" do
+        server = TcpipServer.new(8888,nil,nil,nil,'Burst')
+        server.connect
+        sleep 0.2
+        server.connected?.should be_truthy
+        # 3 because the RSpec main thread plus the listener
+        # plus one for the write thread
+        Thread.list.length.should eql 3
+        server.disconnect
+        sleep 0.2
+        server.connected?.should be_falsey
+        Thread.list.length.should eql 1
+      end
+
+      it "should create a single listener thread if read = write port" do
+        server = TcpipServer.new(8888,8888,nil,nil,'Burst')
+        server.connect
+        sleep 0.2
+        server.connected?.should be_truthy
+        # 3 because the RSpec main thread plus the listener
+        # plus one for the write thread
+        Thread.list.length.should eql 3
+        server.disconnect
+        sleep 0.2
+        server.connected?.should be_falsey
+        Thread.list.length.should eql 1
+      end
+
+      it "should create a two listener threads if read != write port" do
+        server = TcpipServer.new(8888,8889,nil,nil,'Burst')
+        server.connect
+        sleep 0.2
+        server.connected?.should be_truthy
+        # 4 because the RSpec main thread plus the two listeners
+        # plus one for the write thread
+        Thread.list.length.should eql 4
+        server.disconnect
+        sleep 0.2
+        server.connected?.should be_falsey
+        Thread.list.length.should eql 1
+      end
+
+      it "should log an error if the listener thread dies" do
+        capture_io do |stdout|
+          system = double("System")
+          allow(system).to receive(:use_dns) { raise "Error" }
+          allow(System).to receive(:instance).and_return(system)
+
+          server = TcpipServer.new(8888,8888,nil,nil,'Burst')
+          server.connect
+          sleep 0.2
+          socket = TCPSocket.open("127.0.0.2",8888)
+          sleep 0.2
+          server.disconnect
+          socket.close
+
+          stdout.string.should match /Tcpip server listen thread unexpectedly died/
+        end
+      end
+    end
+
+    describe "read" do
+      it "should return nil if there is no read port" do
+        server = TcpipServer.new(8888,nil,nil,nil,'Burst')
+        server.read.should be_nil
+      end
+
+      #~ it "should block if no data is available" do
+        #~ server = TcpipServer.new(nil,8889,nil,nil,'Burst')
+        #~ lambda { server.read }.should raise_error
+      #~ end
+
+      it "should read from the client" do
+        allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
+        allow(System).to receive_message_chain(:instance, :acl).and_return(false)
+
+        server = TcpipServer.new(nil,8889,nil,nil,'Burst')
+        server.connect
+        sleep 0.2
+
+        socket = TCPSocket.open("127.0.0.2",8889)
+        socket.write("\x00\x01")
+        sleep 0.2
+        server.num_clients.should eql 1
+        server.read_queue_size.should eql 1
+        server.read.should be_a Packet
+        server.disconnect
+        sleep 0.2
+        server.num_clients.should eql 0
+        socket.close
+      end
+
+      it "should check the client against the ACL" do
+        capture_io do |stdout|
+          allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
+          allow(System).to receive_message_chain(:instance, :acl).and_return(true)
+          allow(System).to receive_message_chain(:instance, :acl, :allow_addr?).and_return(false)
+
+          server = TcpipServer.new(nil,8889,nil,nil,'Burst')
+          server.connect
+          sleep 0.2
+          socket = TCPSocket.open("127.0.0.2",8889)
+          sleep 0.2
+          server.num_clients.should eql 0
+          socket.eof?.should be_truthy
+          server.disconnect
+          sleep 0.2
+          socket.close
+
+          stdout.string.should match /Tcpip server rejected connection/
+        end
+      end
+
+      it "should log an error if the stream protocol can't disconnect" do
+        capture_io do |stdout|
+          allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
+          allow(System).to receive_message_chain(:instance, :acl).and_return(false)
+          allow_any_instance_of(BurstStreamProtocol).to receive(:read) { raise "Error" }
+          allow_any_instance_of(BurstStreamProtocol).to receive(:disconnect) { raise "Error" }
+
+          server = TcpipServer.new(nil,8889,nil,nil,'Burst')
+          server.connect
+          sleep 0.2
+          socket = TCPSocket.open("127.0.0.2",8889)
+          sleep 0.2
+          server.disconnect
+          sleep 0.2
+          server.num_clients.should eql 0
+          socket.close
+
+          stdout.string.should match /Tcpip server read thread unexpectedly died/
+        end
+      end
+
+      it "should log an error if the read thread dies" do
+        capture_io do |stdout|
+          allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
+          allow(System).to receive_message_chain(:instance, :acl).and_return(false)
+          allow_any_instance_of(BurstStreamProtocol).to receive(:read) { raise "Error" }
+
+          server = TcpipServer.new(8888,8888,nil,nil,'Burst')
+          server.connect
+          sleep 0.2
+          socket = TCPSocket.open("127.0.0.2",8888)
+          socket.write("\x00\x01")
+          sleep 0.2
+          server.disconnect
+          socket.close
+
+          stdout.string.should match /Tcpip server read thread unexpectedly died/
+        end
+      end
+    end
+
+    describe "write" do
+      it "should do nothing if there is no write port" do
+        server = TcpipServer.new(nil,8889,nil,nil,'Burst')
+        expect { server.write(Packet.new('TGT','PKT')) }.to_not raise_error
+      end
+
+      it "should write to the client" do
+        allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
+        allow(System).to receive_message_chain(:instance, :acl).and_return(false)
+
+        server = TcpipServer.new(8888,8889,nil,nil,'Burst')
+        server.connect
+        sleep 0.2
+
+        socket = TCPSocket.open("127.0.0.2",8888)
+        sleep 0.2
+        server.num_clients.should eql 1
+        packet = Packet.new("TGT","PKT")
+        packet.buffer = "\x01\x02\x03\x04"
+        server.write_queue_size.should eql 0
+        server.write(packet)
+        sleep 0.2
+        data = socket.read_nonblock(packet.length)
+        data.length.should eql 4
+        server.disconnect
+        sleep 0.2
+        server.num_clients.should eql 0
+        socket.close
+      end
+
+      it "should log an error if the write thread dies" do
+        class MyTcpipServer3 < TcpipServer
+          def write_thread_hook(packet)
+            raise "Error"
+          end
+        end
+        capture_io do |stdout|
+          allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
+          allow(System).to receive_message_chain(:instance, :acl).and_return(false)
+
+          server = MyTcpipServer3.new(8888,nil,nil,nil,'Burst')
+          server.connect
+          sleep 0.2
+          socket = TCPSocket.open("127.0.0.2",8888)
+          sleep 0.2
+          server.num_clients.should eql 1
+          server.write(Packet.new("TGT","PKT"))
+          sleep 0.2
+          server.num_clients.should eql 0
+          server.disconnect
+          socket.close
+
+          stdout.string.should match /Tcpip server write thread unexpectedly died/
+        end
+      end
+
+      it "log an error if the client disconnects" do
+        capture_io do |stdout|
+          allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
+          allow(System).to receive_message_chain(:instance, :acl).and_return(false)
+          allow_any_instance_of(BurstStreamProtocol).to receive_message_chain(:stream, :write_socket, :recvfrom_nonblock) { raise Errno::ECONNRESET }
+          allow_any_instance_of(BurstStreamProtocol).to receive_message_chain(:stream, :raw_logger_pair).and_return(nil)
+
+          server = TcpipServer.new(8888,8889,nil,nil,'Burst')
+          server.connect
+          server.num_clients.should eql 0
+          sleep 0.2
+          socket = TCPSocket.open("127.0.0.2",8888)
+          sleep 0.2
+          server.num_clients.should eql 0
+          server.disconnect
+          socket.close
+
+          stdout.string.should match /Tcpip server lost write connection/
+        end
+      end
+
+      it "should log an error if the client disconnects" do
+        capture_io do |stdout|
+          allow(System).to receive_message_chain(:instance, :use_dns).and_return(false)
+          allow(System).to receive_message_chain(:instance, :acl).and_return(false)
+          allow_any_instance_of(BurstStreamProtocol).to receive(:write) { raise Errno::ECONNABORTED }
+
+          server = TcpipServer.new(8888,8889,nil,nil,'Burst')
+          server.connect
+          sleep 0.2
+
+          socket1 = TCPSocket.open("127.0.0.2",8888)
+          socket2 = TCPSocket.open("127.0.0.2",8889)
+          sleep 0.2
+          server.num_clients.should eql 2
+          packet = Packet.new("TGT","PKT")
+          packet.buffer = "\x01\x02\x03\x04"
+          server.write_queue_size.should eql 0
+          server.write(packet)
+          sleep 0.2
+          server.num_clients.should eql 1
+          server.disconnect
+          socket1.close
+          socket2.close
+
+          stdout.string.should match /Tcpip server lost write connection/
+        end
+      end
+    end
+
+    describe "read_queue_size" do
+      it "should return 0 if there is no read port" do
+        server = TcpipServer.new(8888,nil,nil,nil,'Burst')
+        server.read_queue_size.should eql 0
+      end
+    end
+
+    describe "write_queue_size" do
+      it "should return 0 if there is no write port" do
+        server = TcpipServer.new(nil,8889,nil,nil,'Burst')
+        server.write_queue_size.should eql 0
+      end
+    end
+
+  end
+end
+

data/spec/io/udp_sockets_spec.rb

@@ -0,0 +1,94 @@
+# 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/udp_sockets'
+
+module Cosmos
+
+  describe UdpWriteSocket do
+
+    describe "initialize" do
+      it "should create a socket" do
+        udp = UdpWriteSocket.new('127.0.0.1', 8888)
+        udp.peeraddr[2].should eql '127.0.0.1'
+        udp.peeraddr[1].should eql 8888
+        udp.close
+        udp = UdpWriteSocket.new('224.0.1.1', 8888, 7777, '127.0.0.1', 3)
+        udp.local_address.ip_port.should eql 7777
+        udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL).int.should eql 3
+        IPAddr.new_ntoh(udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF).data).to_s.should eql "127.0.0.1"
+        udp.close
+      end
+    end
+
+    describe "write" do
+      it "should write data" do
+        udp_read  = UdpReadSocket.new(8888)
+        udp_write = UdpWriteSocket.new('127.0.0.1', 8888)
+        udp_write.write("\x01\x02",2.0)
+        udp_read.read.should eql "\x01\x02"
+        udp_read.close
+        udp_write.close
+      end
+
+      it "should handle timeouts" do
+        allow_any_instance_of(UDPSocket).to receive(:write_nonblock) { raise Errno::EWOULDBLOCK }
+        expect(IO).to receive(:select).at_least(:once).and_return([], nil)
+        udp_write = UdpWriteSocket.new('127.0.0.1', 8888)
+        expect { udp_write.write("\x01\x02",2.0) }.to raise_error(Timeout::Error)
+        udp_write.close
+      end
+    end
+
+    describe "multicast" do
+      it "should determine if a host is multicast" do
+        UdpWriteSocket.multicast?('127.0.0.1').should be_falsey
+        UdpWriteSocket.multicast?('224.0.1.1').should be_truthy
+      end
+    end
+
+  end
+
+  describe UdpReadSocket do
+
+    describe "initialize" do
+      it "should create a socket" do
+        udp = UdpReadSocket.new(8888)
+        udp.local_address.ip_address.should eql '0.0.0.0'
+        udp.local_address.ip_port.should eql 8888
+        udp.close
+        udp = UdpReadSocket.new(8888, '224.0.1.1')
+        IPAddr.new_ntoh(udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF).data).to_s.should eql "0.0.0.0"
+        udp.close
+      end
+    end
+
+    describe "read" do
+      it "should read data" do
+        udp_read  = UdpReadSocket.new(8888)
+        udp_write = UdpWriteSocket.new('127.0.0.1', 8888)
+        udp_write.write("\x01\x02",2.0)
+        udp_read.read.should eql "\x01\x02"
+        udp_read.close
+        udp_write.close
+      end
+
+      it "should handle timeouts" do
+        allow_any_instance_of(UDPSocket).to receive(:recvfrom_nonblock) { raise Errno::EWOULDBLOCK }
+        expect(IO).to receive(:select).at_least(:once).and_return([], nil)
+        udp_read = UdpReadSocket.new(8889)
+        expect { udp_read.read(2.0) }.to raise_error(Timeout::Error)
+      end
+    end
+
+  end
+end
+

data/spec/io/win32_serial_driver_spec.rb

@@ -0,0 +1,88 @@
+# 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/win32_serial_driver'
+
+module Cosmos
+
+  describe Win32SerialDriver do
+    before(:each) do
+      allow(Win32).to receive(:create_file).and_return(Object.new)
+      state = double("comm_state")
+      allow(state).to receive(:write)
+      allow(Win32).to receive(:get_comm_state).and_return(state)
+      allow(Win32).to receive(:set_comm_state)
+      allow(Win32).to receive(:set_comm_timeouts)
+    end
+
+    describe "instance" do
+      it "should enforce the baud rate to a known value" do
+        expect { Win32SerialDriver.new('COM1',10,:NONE) }.to raise_error(ArgumentError, "Invalid baud rate: 10")
+      end
+
+      it "should support even, odd, or no parity" do
+        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 { Win32SerialDriver.new('COM1',9600,:BLAH) }.to raise_error(ArgumentError, "Invalid parity: BLAH")
+      end
+
+      it "should support 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 { Win32SerialDriver.new('COM1',9600,:NONE,3) }.to raise_error(ArgumentError, "Invalid stop bits: 3")
+      end
+    end
+
+    describe "close, closed?" do
+      it "should close the handle" do
+        expect(Win32).to receive(:close_handle)
+        driver = Win32SerialDriver.new('COM1',9600)
+        driver.closed?.should be_falsey
+        driver.close
+        driver.closed?.should be_truthy
+      end
+    end
+
+    describe "write" do
+      it "should handle write errors" do
+        expect(Win32).to receive(:write_file).and_return 0
+        driver = Win32SerialDriver.new('COM1',9600)
+        expect { driver.write('\x00') }.to raise_error("Error writing to comm port")
+      end
+
+      it "should use the write timeout" do
+        expect(Win32).to receive(:write_file) do
+          sleep 2
+          1
+        end
+        driver = Win32SerialDriver.new('COM1',9600,:NONE,1,1)
+        expect { driver.write('\x00\x01') }.to raise_error(Timeout::Error)
+      end
+    end
+
+    describe "read" do
+      it "return the data read" do
+        expect(Win32).to receive(:read_file) { '\x00' }
+        driver = Win32SerialDriver.new('COM1',9600,:NONE,1,1,nil,0.01,1)
+        driver.read.should eql '\x00'
+      end
+
+      it "should use the read timeout" do
+        allow(Win32).to receive(:read_file) { '' }
+        driver = Win32SerialDriver.new('COM1',9600,:NONE,1,1,1.0,0.5,10)
+        expect { driver.read }.to raise_error(Timeout::Error)
+      end
+    end
+
+  end
+end
+

data/spec/packet_logs/meta_packet_log_writer_spec.rb

@@ -0,0 +1,170 @@
+# 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/packet_logs/packet_log_writer'
+require 'cosmos/packet_logs/packet_log_reader'
+require 'tempfile'
+
+module Cosmos
+
+  describe MetaPacketLogWriter do
+    before(:each) do
+      System.class_eval('@@instance = nil')
+      System.load_configuration
+      @log_path = System.paths['LOGS']
+    end
+
+    after(:each) do
+      clean_config()
+    end
+
+    it "should create a command log writer" do
+      meta_packet = System.commands.packet('META', 'DATA')
+      meta_packet.write('VERSION', 'Great Version')
+      meta_packet.write('NUMBER', 5)
+
+      plw = MetaPacketLogWriter.new(:CMD,'META','DATA',nil,true,false,nil,true,nil,nil,nil,false)
+      packet = System.commands.packet('INST', 'ABORT')
+      packet.restore_defaults
+      plw.write(packet)
+      plw.stop
+
+      filename = Dir[File.join(@log_path,"*.bin")][-1]
+      expect(filename).to match("_cmd.bin")
+
+      reader = PacketLogReader.new
+      count = 0
+      reader.each(filename) do |packet|
+        if count == 0
+          packet.target_name.should eql('META')
+          packet.packet_name.should eql('DATA')
+          packet.read('VERSION').should eql('Great Version')
+          packet.read('NUMBER').should eql(5)
+        else
+          packet.target_name.should eql('INST')
+          packet.packet_name.should eql('ABORT')
+        end
+        count += 1
+      end
+    end
+
+    it "should create a telemetry log writer" do
+      meta_packet = System.telemetry.packet('META', 'DATA')
+      meta_packet.write('VERSION', 'Good Version')
+      meta_packet.write('NUMBER', 3)
+
+      plw = MetaPacketLogWriter.new(:TLM,'META','DATA',nil,true,true,nil,true,nil,nil,nil,false)
+      packet = System.telemetry.packet('INST', 'ADCS')
+      packet.write('CCSDSAPID', 2)
+      packet.write('PKTID', 1)
+      plw.write(packet)
+      plw.write(meta_packet)
+      plw.stop
+
+      filename = Dir[File.join(@log_path,"*.bin")][-1]
+      expect(filename).to match("_tlm.bin")
+
+      reader = PacketLogReader.new
+      count = 0
+      reader.each(filename) do |packet|
+        if count == 0 or count == 2
+          packet.target_name.should eql('META')
+          packet.packet_name.should eql('DATA')
+          packet.read('VERSION').should eql('Good Version')
+          packet.read('NUMBER').should eql(3)
+        else
+          packet.target_name.should eql('INST')
+          packet.packet_name.should eql('ADCS')
+        end
+        count += 1
+      end
+      count.should eql 3
+    end
+
+    it "should not log metadata packets if configured not to" do
+      meta_packet = System.telemetry.packet('META', 'DATA')
+      meta_packet.write('VERSION', 'Good Version')
+      meta_packet.write('NUMBER', 1)
+
+      plw = MetaPacketLogWriter.new(:TLM,'META','DATA',nil,false,true,nil,true,nil,nil,nil,false)
+      plw.write(meta_packet)
+      packet = System.telemetry.packet('INST', 'ADCS')
+      packet.write('CCSDSAPID', 2)
+      packet.write('PKTID', 1)
+      plw.write(packet)
+      plw.write(meta_packet)
+      plw.stop
+
+      filename = Dir[File.join(@log_path,"*.bin")][-1]
+      expect(filename).to match("_tlm.bin")
+
+      reader = PacketLogReader.new
+      count = 0
+      reader.each(filename) do |packet|
+        if count == 0
+          packet.target_name.should eql('META')
+          packet.packet_name.should eql('DATA')
+          packet.read('VERSION').should eql('Good Version')
+          packet.read('NUMBER').should eql(1)
+        else
+          packet.target_name.should eql('INST')
+          packet.packet_name.should eql('ADCS')
+        end
+        count += 1
+      end
+      count.should eql(2)
+    end
+
+    it "should initialize the meta packet if configured to" do
+      tf = Tempfile.new('unittest')
+      tf.puts("VERSION 'Ok Version'")
+      tf.puts("NUMBER 11")
+      tf.close
+
+      meta_packet = System.telemetry.packet('META', 'DATA')
+      meta_packet.write('VERSION', 'Bad Version')
+      meta_packet.write('NUMBER', 3)
+
+      plw = MetaPacketLogWriter.new(:TLM,'META','DATA',tf.path,false,true,nil,true,nil,nil,nil,false)
+      packet = System.telemetry.packet('INST', 'ADCS')
+      packet.write('CCSDSAPID', 2)
+      packet.write('PKTID', 1)
+      plw.write(packet)
+      plw.write(meta_packet)
+      plw.stop
+
+      filename = Dir[File.join(@log_path,"*.bin")][-1]
+      expect(filename).to match("_tlm.bin")
+
+      reader = PacketLogReader.new
+      count = 0
+      reader.each(filename) do |packet|
+        if count == 0
+          packet.target_name.should eql('META')
+          packet.packet_name.should eql('DATA')
+          packet.read('VERSION').should eql('Ok Version')
+          packet.read('NUMBER').should eql(11)
+        else
+          packet.target_name.should eql('INST')
+          packet.packet_name.should eql('ADCS')
+        end
+        count += 1
+      end
+      count.should eql(2)
+      tf.unlink
+    end
+
+    it "should complain if the packet does not exist" do
+      expect {plw = MetaPacketLogWriter.new(:CMD,'INST','ADCS',nil,true,true)}.to raise_error(RuntimeError)
+      expect {plw = MetaPacketLogWriter.new(:CMD,'INST','ABORT',nil,true,true)}.to raise_error(RuntimeError)
+    end
+  end
+end