cosmos 4.3.0-java → 4.4.0-java

data/spec/streams/tcpip_socket_stream_spec.rb

@@ -57,82 +57,87 @@ module Cosmos
         ss = TcpipSocketStream.new('write',nil,nil,nil)
         ss.connect
         expect { ss.read }.to raise_error("Attempt to read from write only stream")
+        ss.disconnect
       end
 
       it "calls read_nonblock from the socket" do
         server = TCPServer.new(2000) # Server bound to port 2000
         thread = Thread.new do
-          loop do
-            client = server.accept    # Wait for a client to connect
-            sleep 0.1
-            client.write "test"
-            client.close
-          end
+          client = server.accept    # Wait for a client to connect
+          sleep 0.1
+          client.write "test"
+          client.close
         end
+        sleep 0.1
         socket = TCPSocket.new('localhost', 2000)
         ss = TcpipSocketStream.new(nil,socket,nil,nil)
         expect(ss.read_nonblock).to eql ''
         sleep 0.2
         expect(ss.read_nonblock).to eql 'test'
+        thread.join
         Cosmos.close_socket(socket)
         Cosmos.close_socket(server)
-        thread.kill
         sleep 0.1
+        ss.disconnect
       end
 
       it "handles socket blocking exceptions" do
         server = TCPServer.new(2000) # Server bound to port 2000
         thread = Thread.new do
-          loop do
-            client = server.accept    # Wait for a client to connect
-            sleep 0.2
-            client.write "test"
-            client.close
-          end
+          client = server.accept    # Wait for a client to connect
+          sleep 0.2
+          client.write "test"
+          client.close
         end
+        sleep 0.1
         socket = TCPSocket.new('localhost', 2000)
         ss = TcpipSocketStream.new(nil,socket,nil,nil)
         expect(ss.read).to eql 'test'
+        thread.join
         Cosmos.close_socket(socket)
         Cosmos.close_socket(server)
-        thread.kill
         sleep 0.1
+        ss.disconnect
       end
 
       it "handles socket timeouts" do
         server = TCPServer.new(2000) # Server bound to port 2000
         thread = Thread.new do
-          loop do
-            client = server.accept    # Wait for a client to connect
-            sleep 0.2
-            client.close
-          end
+          client = server.accept    # Wait for a client to connect
+          sleep 0.2
+          client.close
         end
         socket = TCPSocket.new('localhost', 2000)
         ss = TcpipSocketStream.new(nil,socket,nil,0.1)
         expect { ss.read }.to raise_error(Timeout::Error)
+        thread.join
         sleep 0.2
         Cosmos.close_socket(socket)
         Cosmos.close_socket(server)
-        thread.kill
+        ss.disconnect
         sleep 0.1
       end
 
       it "handles socket connection reset exceptions" do
         server = TCPServer.new(2000) # Server bound to port 2000
         thread = Thread.new do
-          loop do
-            client = server.accept    # Wait for a client to connect
+          client = server.accept    # Wait for a client to connect
+          sleep 0.2
+          begin
             client.close
+          rescue IOError
+            # Closing the socket causes an IOError
           end
         end
         socket = TCPSocket.new('localhost', 2000)
         ss = TcpipSocketStream.new(nil,socket,nil,5)
+        sleep 0.1 # Allow the server thread to accept
         # Close the socket before trying to read from it
         Cosmos.close_socket(socket)
         expect(ss.read).to eql ''
         Cosmos.close_socket(server)
-        thread.kill
+        thread.join
+        ss.disconnect
         sleep 0.1
       end
     end
@@ -142,6 +147,7 @@ module Cosmos
         ss = TcpipSocketStream.new(nil,'read',nil,nil)
         ss.connect
         expect { ss.write('test') }.to raise_error("Attempt to write to read only stream")
+        ss.disconnect
       end
 
       it "calls write from the driver" do
@@ -151,6 +157,7 @@ module Cosmos
         ss = TcpipSocketStream.new(write,nil,nil,nil)
         ss.connect
         ss.write('test')
+        ss.disconnect
       end
 
       it "handles socket blocking exceptions" do
@@ -169,6 +176,7 @@ module Cosmos
         ss = TcpipSocketStream.new(write,nil,nil,nil)
         ss.connect
         ss.write('test')
+        ss.disconnect
       end
 
       it "handles socket timeouts" do
@@ -178,6 +186,7 @@ module Cosmos
         ss = TcpipSocketStream.new(write,nil,nil,nil)
         ss.connect
         expect { ss.write('test') }.to raise_error(Timeout::Error)
+        ss.disconnect
       end
     end
 
@@ -217,10 +226,6 @@ module Cosmos
         expect(ss.connected?).to be false
       end
     end
-
   end
-
   end # TEMP for Jruby
-
 end
-

data/spec/system/system_spec.rb

@@ -263,7 +263,7 @@ module Cosmos
       end
 
       describe "packets and System.packets" do
-        it "calculates MD5s across all the target files" do
+        it "calculates hash strings across all the target files" do
           capture_io do |stdout|
             # This line actually does the work of reading the configuration
             expect(System.telemetry.target_names).to eql ['INST', 'SYSTEM']
@@ -488,6 +488,8 @@ module Cosmos
           tf.close
           FileUtils.mkdir_p(File.join(@config_targets, 'TGT'))
           System.instance.process_file(tf.path)
+          expect(System.targets.key?('TGT')).to be true
+          expect(System.targets.key?('SYSTEM')).to be true
           tf.unlink
         end
 
@@ -870,12 +872,85 @@ module Cosmos
           tf.puts("ADD_MD5_FILE #{File.expand_path(md5f.path)}")
           tf.close
           System.instance.process_file(tf.path)
-          expect(System.additional_md5_files.include?(File.expand_path(md5f.path))).to be true
+          expect(System.additional_hashing_files.include?(File.expand_path(md5f.path))).to be true
           md5f.close
           md5f.unlink
           tf.unlink
         end
       end
+
+      context "with ADD_HASH_FILE" do
+        it "takes 1 parameter" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ADD_HASH_FILE")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Not enough parameters for ADD_HASH_FILE./)
+          tf.unlink
+
+          tf = Tempfile.new('unittest')
+          tf.puts("ADD_HASH_FILE 1 2")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for ADD_HASH_FILE./)
+          tf.unlink
+        end
+
+        it "complains about missing files" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ADD_HASH_FILE missing_file")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(/Missing expected file: missing_file/)
+          tf.unlink
+        end
+
+        it "adds a file to the hashing sum calculation" do
+          hashf = Tempfile.new('hash_file')
+          tf = Tempfile.new('unittest')
+          tf.puts("ADD_HASH_FILE #{File.expand_path(hashf.path)}")
+          tf.close
+          System.instance.process_file(tf.path)
+          expect(System.additional_hashing_files.include?(File.expand_path(hashf.path))).to be true
+          hashf.close
+          hashf.unlink
+          tf.unlink
+        end
+      end
+
+      context "with HASHING_ALGORITHM" do
+        it "takes 1 parameter" do
+          tf = Tempfile.new('unittest')
+          tf.puts("HASHING_ALGORITHM")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Not enough parameters for HASHING_ALGORITHM./)
+          tf.unlink
+
+          tf = Tempfile.new('unittest')
+          tf.puts("HASHING_ALGORITHM 1 2")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for HASHING_ALGORITHM./)
+          tf.unlink
+        end
+
+        it "complains about invalid algorithms" do
+          tf = Tempfile.new('unittest')
+          tf.puts("HASHING_ALGORITHM BAD")
+          tf.close
+          expect(Logger).to receive(:error) do |msg|
+            expect(msg).to eql "Unrecognized hashing algorithm: BAD, using default algorithm MD5"
+          end
+          System.instance.process_file(tf.path)
+          expect(System.hashing_algorithm).to eql 'MD5'
+          tf.unlink
+        end
+
+        it "sets the hashing algorithm" do
+          tf = Tempfile.new('unittest')
+          tf.puts("HASHING_ALGORITHM SHA256")
+          tf.close
+          System.instance.process_file(tf.path)
+          expect(System.hashing_algorithm).to eql 'SHA256'
+          tf.unlink
+        end
+      end
     end
 
     describe "Cosmos.write_exception_file" do

data/spec/system/target_spec.rb

@@ -12,6 +12,7 @@ require 'spec_helper'
 require 'cosmos'
 require 'cosmos/system/target'
 require 'tempfile'
+require 'pathname'
 
 module Cosmos
 
@@ -167,8 +168,28 @@ module Cosmos
 
           # Initial require in target lib shouldn't be reported as error
           expect(Logger).to_not receive(:error)
-          Target.new("INST").process_file(tf.path)
+          target = Target.new("INST")
+          target.process_file(tf.path)
           expect { SystemFile.new }.to_not raise_error
+          expect(Pathname.new(target.requires[0]).absolute?).to be true
+          File.delete filename
+          tf.unlink
+        end
+
+        it "requires a file with absolute path" do
+          filename = File.join(Cosmos::USERPATH, 'abs_path.rb')
+          File.open(filename, 'w') do |file|
+            file.puts "class AbsPath"
+            file.puts "end"
+          end
+          tf = Tempfile.new('unittest')
+          tf.puts("REQUIRE #{File.expand_path(filename)}")
+          tf.close
+
+          # Initial require in target lib shouldn't be reported as error
+          expect(Logger).to_not receive(:error)
+          Target.new("INST").process_file(tf.path)
+          expect { AbsPath.new }.to_not raise_error
           File.delete filename
           tf.unlink
         end
@@ -200,6 +221,46 @@ module Cosmos
         end
       end
 
+      context "with TLM_UNIQUE_ID_MODE" do
+        it "takes no parameters" do
+          tf = Tempfile.new('unittest')
+          tf.puts("")
+          tf.close
+          tgt = Target.new("TGT")
+          tgt.process_file(tf.path)
+          expect(tgt.tlm_unique_id_mode).to eql false
+          tf.unlink
+
+          tf = Tempfile.new('unittest')
+          tf.puts("TLM_UNIQUE_ID_MODE")
+          tf.close
+          tgt = Target.new("TGT")
+          tgt.process_file(tf.path)
+          expect(tgt.tlm_unique_id_mode).to eql true
+          tf.unlink
+        end
+      end
+
+      context "with CMD_UNIQUE_ID_MODE" do
+        it "takes no parameters" do
+          tf = Tempfile.new('unittest')
+          tf.puts("")
+          tf.close
+          tgt = Target.new("TGT")
+          tgt.process_file(tf.path)
+          expect(tgt.cmd_unique_id_mode).to eql false
+          tf.unlink
+
+          tf = Tempfile.new('unittest')
+          tf.puts("CMD_UNIQUE_ID_MODE")
+          tf.close
+          tgt = Target.new("TGT")
+          tgt.process_file(tf.path)
+          expect(tgt.cmd_unique_id_mode).to eql true
+          tf.unlink
+        end
+      end
+
       context "with COMMANDS and TELEMETRY" do
         it "takes 1 parameters" do
           tf = Tempfile.new('unittest')

data/spec/tools/cmd_tlm_server/api_spec.rb

@@ -497,7 +497,7 @@ DOC
         # Each element in the results array contains:
         #   name, default, states, description, full units, units, required
         expect(result).to include ['TYPE',0,{"NORMAL"=>0,"SPECIAL"=>1},'Collect type',nil,nil,true,"UINT"]
-        expect(result).to include ['TEMP',0.0,nil,'Collect temperature','Celcius','C',false,"FLOAT"]
+        expect(result).to include ['TEMP',0.0,nil,'Collect temperature','Celsius','C',false,"FLOAT"]
       end
 
       it "returns array parameters for the command" do

data/spec/tools/cmd_tlm_server/background_tasks_spec.rb

@@ -23,7 +23,7 @@ module Cosmos
           file.puts "require 'cosmos/tools/cmd_tlm_server/background_task'"
           file.puts "class MyBgTask#{i} < Cosmos::BackgroundTask"
           if i == 3
-            file.puts "  def call; raise 'Error'; end"
+            file.puts "  def call; puts 'BG#{i} START'; raise 'Error'; end"
           else
             file.puts "  def call; puts 'BG#{i} START'; @go = true; sleep 1 while @go; end"
           end
@@ -163,16 +163,24 @@ module Cosmos
           bt.start_all
           # 2 because the RSpec main thread plus the background task
           expect(running_threads.length).to eql(2)
+          expect(bt.instance_variable_get("@threads").length).to eq 1
+          expect(bt.instance_variable_get("@threads")[0].alive?).to eq true
           sleep 1.1 # Allow the thread to crash
           expect(running_threads.length).to eql(1)
-          expect(bt.instance_variable_get("@threads").length).to eq 1
-          expect(bt.instance_variable_get("@threads")[0].alive?).to eq false
+          expect(bt.instance_variable_get("@threads")[0]).to be_nil
+          expect(stdout.string).to match("unexpectedly died")
+        end
 
-          bt.stop_all
-          sleep 0.2
+        # Try to restart the task
+        capture_io do |stdout|
+          bt.start_all
+          # 2 because the RSpec main thread plus the background task
+          expect(running_threads.length).to eql(2)
+          expect(bt.instance_variable_get("@threads").length).to eq 1
+          expect(bt.instance_variable_get("@threads")[0].alive?).to eq true
+          sleep 1.1 # Allow the thread to crash
           expect(running_threads.length).to eql(1)
-          expect(bt.instance_variable_get("@threads").length).to eq 0
-
+          expect(bt.instance_variable_get("@threads")[0]).to be_nil
           expect(stdout.string).to match("unexpectedly died")
         end
         tf.unlink

data/spec/top_level/top_level_spec.rb

@@ -111,8 +111,8 @@ module Cosmos
       expect(filename).to eql File.join(Cosmos::PATH,'data','about.txt')
     end
 
-    it "complains if the file is not found" do
-      expect { Cosmos.data_path('nope.txt') }.to raise_error(/Could not find path/)
+    it "returns nil if the file is not found" do
+      expect(Cosmos.data_path('nope.txt')).to be_nil
     end
   end
 
@@ -171,6 +171,19 @@ module Cosmos
       Cosmos.cleanup_exceptions()
     end
 
+    it "rescues marshal dump errors in a Packet with a Mutex" do
+      capture_io do |stdout|
+        system_exit_count = $system_exit_count
+        pkt = Packet.new("TGT","PKT")
+        pkt.append_item("ITEM", 16, :UINT)
+        pkt.read_all
+        Cosmos.marshal_dump('marshal_test', pkt)
+        expect($system_exit_count).to be > system_exit_count
+        expect(stdout.string).to match("Mutex exists in a packet")
+      end
+      Cosmos.cleanup_exceptions()
+    end
+
     it "rescues marshal load errors" do
       # Attempt to load something that doesn't exist
       expect(Cosmos.marshal_load('blah')).to be_nil
@@ -222,18 +235,29 @@ module Cosmos
     end
   end
 
-  describe "md5_files" do
-    it "calculates a MD5 sum across files" do
+  describe "hash_files" do
+    it "calculates a hashing sum across files in md5 mode" do
       File.open(File.join(Cosmos::USERPATH,'test1.txt'),'w') {|f| f.puts "test1" }
       File.open(File.join(Cosmos::USERPATH,'test2.txt'),'w') {|f| f.puts "test2" }
-      digest = Cosmos.md5_files(["test1.txt", "test2.txt"])
+      digest = Cosmos.hash_files(["test1.txt", "test2.txt"])
       expect(digest.digest.length).to be 16
       expect(digest.hexdigest).to eql 'e51dfbea83de9c7e6b49560089d8a170'
       File.delete(File.join(Cosmos::USERPATH, 'test1.txt'))
       File.delete(File.join(Cosmos::USERPATH, 'test2.txt'))
     end
+
+    it "calculates a hashing sum across files in sha256 mode" do
+      File.open(File.join(Cosmos::USERPATH,'test1.txt'),'w') {|f| f.puts "test1" }
+      File.open(File.join(Cosmos::USERPATH,'test2.txt'),'w') {|f| f.puts "test2" }
+      digest = Cosmos.hash_files(["test1.txt", "test2.txt"], nil, 'SHA256')
+      expect(digest.digest.length).to be 32
+      expect(digest.hexdigest).to eql '49789e7c809eb38ea34864b00e2cfd68825e0c07cd7b7d0c6fe2642ac87a919c'
+      File.delete(File.join(Cosmos::USERPATH, 'test1.txt'))
+      File.delete(File.join(Cosmos::USERPATH, 'test2.txt'))
+    end
   end
 
+
   describe "create_log_file" do
     it "creates a log file in System LOGS" do
       filename1 = Cosmos.create_log_file('test')