cosmos 4.0.3-java → 4.1.0-java

data/spec/interfaces/serial_interface_spec.rb

@@ -41,7 +41,7 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
       describe "connect" do
         it "passes a new SerialStream to the stream protocol" do
           # Ensure the 'NONE' parity is coverted to a symbol
-          if Kernel.is_windows?
+          if Kernel.is_windows? && !ENV['APPVEYOR']
             i = SerialInterface.new('COM1','COM1','9600','NONE','1','0','0','burst')
             expect(i.connected?).to be false
             i.connect

data/spec/interfaces/udp_interface_spec.rb

@@ -83,6 +83,20 @@ module Cosmos
         expect(i.instance_variable_get(:@write_socket)).to be_nil
         expect(i.instance_variable_get(:@read_socket)).to be_nil
       end
+
+      it "creates one socket if read_port == write_src_port" do
+        i = UdpInterface.new('localhost','8888','8889', '8889')
+        expect(i.connected?).to be false
+        i.connect
+        expect(i.connected?).to be true
+        expect(i.instance_variable_get(:@write_socket)).to_not be_nil
+        expect(i.instance_variable_get(:@read_socket)).to_not be_nil
+        expect(i.instance_variable_get(:@read_socket)).to eql i.instance_variable_get(:@write_socket)
+        i.disconnect
+        expect(i.connected?).to be false
+        expect(i.instance_variable_get(:@write_socket)).to be_nil
+        expect(i.instance_variable_get(:@read_socket)).to be_nil
+      end
     end
 
     describe "read" do

data/spec/io/buffered_file_spec.rb

@@ -50,6 +50,17 @@ module Cosmos
         end
       end
 
+      it "handles trying to read past the end" do
+        file = BufferedFile.open(@filename, "rb") do |file|
+          file.seek(-16, IO::SEEK_END)
+          expect(file.pos).to eql ((2 * BufferedFile::BUFFER_SIZE) - 16)
+          expect(file.read(DATA.length * 10)).to eql(DATA)
+          expect(file.pos).to eql BufferedFile::BUFFER_SIZE * 2
+          expect(file.read(DATA.length)).to be_nil
+          expect(file.pos).to eql BufferedFile::BUFFER_SIZE * 2
+        end
+      end
+
       it "reads equal to the buffer size" do
         file = BufferedFile.open(@filename, "rb") do |file|
           expect(file.read(BufferedFile::BUFFER_SIZE)).to eql(DATA * (BufferedFile::BUFFER_SIZE / DATA.length))
@@ -69,9 +80,35 @@ module Cosmos
           expect(file.read(BufferedFile::BUFFER_SIZE + 1)).to be_nil
         end
       end
+
+      it "reads greater than the buffer size after a previous read" do
+        file = BufferedFile.open(@filename, "rb") do |file|
+          expect(file.read(DATA.length * 10)).to eql(DATA * 10)
+          expect(file.pos).to eql DATA.length * 10
+          expect(file.read(BufferedFile::BUFFER_SIZE + 1)).to eql(DATA * ((BufferedFile::BUFFER_SIZE + 10) / DATA.length) << DATA[0])
+          expect(file.pos).to eql(DATA.length * 10 + BufferedFile::BUFFER_SIZE + 1)
+        end
+      end
     end
 
     describe "seek" do
+      it "raises if given more than 2 arguments" do
+        file = BufferedFile.open(@filename, "rb") do |file|
+          expect { file.seek(0, 4, IO::SEEK_CUR) }.to raise_error(ArgumentError)
+        end
+      end
+
+      it "implies SEEK_SET with 1 argument" do
+        file = BufferedFile.open(@filename, "rb") do |file|
+          expect(file.read(8)).to eql DATA[0..7]
+          expect(file.pos).to eql 8
+          file.seek(4, IO::SEEK_CUR)
+          expect(file.pos).to eql 12
+          file.seek(0)
+          expect(file.pos).to eql 0
+        end
+      end
+
       it "has reads still work afterwards" do
         file = BufferedFile.open(@filename, "rb") do |file|
           expect(file.read(8)).to eql DATA[0..7]

data/spec/io/json_drb_object_spec.rb

@@ -38,30 +38,17 @@ module Cosmos
       end
 
       it "raises an exception if the remote connection can't be made" do
-        json = JsonDRb.new
-        json.start_service('127.0.0.1', 7777, self)
-        allow_any_instance_of(Socket).to receive(:connect_nonblock) { raise "Error" }
         obj = JsonDRbObject.new("localhost", 7777)
         expect { obj.my_method(10) }.to raise_error(DRb::DRbConnError)
         obj.disconnect
-        json.stop_service
         sleep(0.1)
       end
 
       it "retries the request and then raise an exception" do
-        class JsonDRbObjectServer
-          def my_method(param)
-            param * 2
-          end
-        end
-
-        json = JsonDRb.new
-        json.start_service('127.0.0.1', 7777, JsonDRbObjectServer.new)
-        allow(JsonDRb).to receive(:send_data) { raise "Error" }
+        allow_any_instance_of(HTTPClient).to receive(:post) { raise "Error" }
         obj = JsonDRbObject.new("localhost", 7777)
         expect { obj.my_method(10) }.to raise_error(DRb::DRbConnError)
         obj.disconnect
-        json.stop_service
         sleep(0.1)
       end
 
@@ -86,7 +73,7 @@ module Cosmos
         json = JsonDRb.new
         json.start_service('127.0.0.1', 7777, JsonDRbObjectServer.new)
         obj = JsonDRbObject.new("localhost", 7777)
-        allow(JsonDRb).to receive(:receive_message) { nil }
+        allow_any_instance_of(JsonDrbRack).to receive(:call) { sleep(5.0); nil }
         expect { obj.my_method(10) }.to raise_error(DRb::DRbConnError)
         obj.disconnect
         json.stop_service

data/spec/io/json_drb_spec.rb

@@ -11,6 +11,7 @@
 require 'spec_helper'
 require 'cosmos/io/json_drb'
 require 'cosmos/io/json_rpc'
+require 'httpclient'
 
 module Cosmos
 
@@ -52,6 +53,18 @@ module Cosmos
     end
 
     describe "start_service" do
+
+      it "can be started again after stopping" do
+        @json.start_service('127.0.0.1', 7777, self)
+        @json.stop_service
+        @json.start_service('127.0.0.1', 7777, self)
+        @json.stop_service
+        expect { @json.start_service('blah', 7777, self) }.to raise_error(/JsonDRb http server could not be started/)
+        @json.stop_service
+        @json.start_service('127.0.0.1', 7777, self)
+        @json.stop_service
+      end
+
       it "does nothing when passed no parameters" do
         expect(@json.thread).to be_nil
         @json.start_service()
@@ -69,12 +82,10 @@ module Cosmos
         capture_io do |stdout|
           expect(@json.thread).to be_nil
           system_exit_count = $system_exit_count
-          @json.start_service('blah', 7777, self)
-          thread = @json.thread
+          expect { @json.start_service('blah', 7777, self) }.to raise_error(/JsonDRb http server could not be started/)
+          sleep 5
           expect($system_exit_count).to eql(system_exit_count + 1)
-          sleep 0.1
-
-          expect(stdout.string).to match /listen thread/
+          expect(stdout.string).to match /JsonDRb http server could not be started or unexpectedly died/
           @json.stop_service
           sleep(0.1)
         end
@@ -84,25 +95,33 @@ module Cosmos
         end
       end
 
+      it "raises an error if the server doesn't start" do
+        allow(Rack::Handler::Puma).to receive(:run) {}
+        expect { @json.start_service('127.0.0.1', 7777, self) }.to raise_error(/JsonDRb http server could not be started/)
+      end
+
       it "creates a single listen thread" do
         expect(@json.thread).to be_nil
         @json.start_service('127.0.0.1', 7777, self)
+        sleep(1)
         expect(@json.thread.alive?).to be true
-        expect { @json.start_service('127.0.0.1', 7777, self) }.to raise_error(/Error binding to port/)
+        num_threads = running_threads.length
+        @json.start_service('127.0.0.1', 7777, self)
+        sleep(1)
+        expect(running_threads.length).to eql num_threads
         @json.stop_service
         sleep(0.1)
       end
 
       it "rescues listen thread exceptions" do
         capture_io do |stdout|
-          allow_any_instance_of(TCPServer).to receive(:accept_nonblock) { raise "BLAH" }
-          @json.start_service('127.0.0.1', 7777, self)
-          socket = TCPSocket.open('127.0.0.1',7777)
-          sleep 0.1
+          allow(Rack::Handler::Puma).to receive(:run) { raise "BLAH" }
+          expect { @json.start_service('127.0.0.1', 7777, self) }.to raise_error(/JsonDRb http server could not be started/)
+          sleep(0.1)
           @json.stop_service
           sleep(0.1)
 
-          expect(stdout.string).to match /JsonDRb listen thread unexpectedly died/
+          expect(stdout.string).to match /JsonDRb http server could not be started or unexpectedly died/
         end
 
         Dir[File.join(Cosmos::USERPATH,"*_exception.txt")].each do |file|
@@ -110,19 +129,19 @@ module Cosmos
         end
       end
 
-      it "ignores connections via the ACL" do
+      it "rejects posts via the ACL" do
         @json.acl = ACL.new(['deny','127.0.0.1'], ACL::ALLOW_DENY)
         @json.start_service('127.0.0.1', 7777, self)
-        socket = TCPSocket.open('127.0.0.1',7777)
-        sleep 0.1
-        expect(socket.eof?).to be true
-        socket.close
+        client = HTTPClient.new
+        res = client.post("http://127.0.0.1:7777", "")
+        expect(res.status).to eq 403
+        expect(res.body).to match /Forbidden/
         @json.stop_service
         sleep(0.1)
       end
     end
 
-    describe "receive_message" do
+    describe "process_request" do
       it "processes success requests" do
         class MyServer1
           def my_method(param)
@@ -130,15 +149,9 @@ module Cosmos
         end
 
         @json.start_service('127.0.0.1', 7777, MyServer1.new)
-        socket = TCPSocket.open('127.0.0.1',7777)
-        sleep 0.1
-        request = JsonRpcRequest.new('my_method', 'param', 1).to_json
-        JsonDRb.send_data(socket, request)
-        response_data = JsonDRb.receive_message(socket, '', @pipe_reader)
-        response = JsonRpcResponse.from_json(response_data)
-        expect(response).to be_a(JsonRpcSuccessResponse)
-        socket.close
-        sleep 0.1
+        request_data = JsonRpcRequest.new('my_method', 'param', 1).to_json
+        response_data, error_code = @json.process_request(request_data, Time.now)
+        expect(error_code).to eq nil
         @json.stop_service
         sleep(0.1)
       end
@@ -148,17 +161,10 @@ module Cosmos
         end
 
         @json.start_service('127.0.0.1', 7777, MyServer2.new)
-        socket = TCPSocket.open('127.0.0.1',7777)
-        sleep 0.1
-        request = JsonRpcRequest.new('my_method', 'param', 1).to_json
-        JsonDRb.send_data(socket, request)
-        response_data = JsonDRb.receive_message(socket, '', @pipe_reader)
-        response = JsonRpcResponse.from_json(response_data)
-        expect(response).to be_a(JsonRpcErrorResponse)
-        expect(response.error.code).to eql -32601
-        expect(response.error.message).to eql "Method not found"
-        socket.close
-        sleep 0.1
+        request_data = JsonRpcRequest.new('my_method', 'param', 1).to_json
+        response_data, error_code = @json.process_request(request_data, Time.now)
+        expect(error_code).to eql -32601
+        expect(response_data).to match /Method not found/
         @json.stop_service
         sleep(0.1)
       end
@@ -170,17 +176,10 @@ module Cosmos
         end
 
         @json.start_service('127.0.0.1', 7777, MyServer3.new)
-        socket = TCPSocket.open('127.0.0.1',7777)
-        sleep 0.1
-        request = JsonRpcRequest.new('my_method', 'param1', 1).to_json
-        JsonDRb.send_data(socket, request)
-        response_data = JsonDRb.receive_message(socket, '', @pipe_reader)
-        response = JsonRpcResponse.from_json(response_data)
-        expect(response).to be_a(JsonRpcErrorResponse)
-        expect(response.error.code).to eql -32602
-        expect(response.error.message).to eql "Invalid params"
-        socket.close
-        sleep 0.1
+        request_data = JsonRpcRequest.new('my_method', 'param1', 1).to_json
+        response_data, error_code = @json.process_request(request_data, Time.now)
+        expect(error_code).to eql -32602
+        expect(response_data).to match /Invalid params/
         @json.stop_service
         sleep(0.1)
       end
@@ -193,91 +192,32 @@ module Cosmos
         end
 
         @json.start_service('127.0.0.1', 7777, MyServer4.new)
-        socket = TCPSocket.open('127.0.0.1',7777)
-        sleep 0.1
-        request = JsonRpcRequest.new('my_method', 'param', 1).to_json
-        JsonDRb.send_data(socket, request)
-        response_data = JsonDRb.receive_message(socket, '', @pipe_reader)
-        response = JsonRpcResponse.from_json(response_data)
-        expect(response).to be_a(JsonRpcErrorResponse)
-        expect(response.error.code).to eql -1
-        expect(response.error.message).to eql "Method Error"
-        socket.close
-        sleep 0.1
+        request_data = JsonRpcRequest.new('my_method', 'param', 1).to_json
+        response_data, error_code = @json.process_request(request_data, Time.now)
+        expect(error_code).to eql -1
+        expect(response_data).to match /Method Error/
         @json.stop_service
         sleep(0.1)
       end
 
       it "does not allow dangerous methods" do
         @json.start_service('127.0.0.1', 7777, self)
-        socket = TCPSocket.open('127.0.0.1',7777)
-        sleep 0.1
-        request = JsonRpcRequest.new('send', 'param', 1).to_json
-        JsonDRb.send_data(socket, request)
-        response_data = JsonDRb.receive_message(socket, '', @pipe_reader)
-        response = JsonRpcResponse.from_json(response_data)
-        expect(response).to be_a(JsonRpcErrorResponse)
-        expect(response.error.code).to eql -1
-        expect(response.error.message).to eql "Cannot call unauthorized methods"
-        socket.close
-        sleep 0.1
+        request_data = JsonRpcRequest.new('send', 'param', 1).to_json
+        response_data, error_code = @json.process_request(request_data, Time.now)
+        expect(error_code).to eql -1
+        expect(response_data).to match /Cannot call unauthorized methods/
         @json.stop_service
         sleep(0.1)
       end
 
       it "handles an invalid JsonDRB request" do
         @json.start_service('127.0.0.1', 7777, self)
-        socket = TCPSocket.open('127.0.0.1',7777)
-        sleep 0.1
-        request = JsonRpcRequest.new('send', 'param', 1).to_json
-        request.gsub!("jsonrpc","version")
-        request.gsub!("2.0","1.1")
-        JsonDRb.send_data(socket, request)
-        response_data = JsonDRb.receive_message(socket, '', @pipe_reader)
-        response = JsonRpcResponse.from_json(response_data)
-        expect(response).to be_a(JsonRpcErrorResponse)
-        expect(response.error.code).to eql -32600
-        expect(response.error.message).to eql "Invalid Request"
-        socket.close
-        sleep 0.1
-        @json.stop_service
-        sleep(0.1)
-      end
-    end
-
-    describe "send_data" do
-      it "retries if the socket blocks" do
-        @json.start_service('127.0.0.1', 7777, self)
-        socket = TCPSocket.open('127.0.0.1',7777)
-        # Stub write_nonblock so it blocks
-        $index = 0
-        allow(socket).to receive(:write_nonblock) do
-          case $index
-          when 0
-            $index += 1
-            raise Errno::EWOULDBLOCK
-          when 1
-            $index += 1
-            5
-          end
-        end
-        JsonDRb.send_data(socket, "\x00")
-        socket.close
-        @json.stop_service
-        sleep(0.1)
-      end
-
-      it "eventuallies timeout if the socket blocks" do
-        @json.start_service('127.0.0.1', 7777, self)
-        socket = TCPSocket.open('127.0.0.1',7777)
-        # Stub write_nonblock so it blocks
-        $index = 0
-        allow(socket).to receive(:write_nonblock) do
-          raise Errno::EWOULDBLOCK
-        end
-        allow(IO).to receive(:select) { nil }
-        expect { JsonDRb.send_data(socket, "\x00", 2) }.to raise_error(Timeout::Error)
-        socket.close
+        request_data = JsonRpcRequest.new('send', 'param', 1).to_json
+        request_data.gsub!("jsonrpc","version")
+        request_data.gsub!("2.0","1.1")
+        response_data, error_code = @json.process_request(request_data, Time.now)
+        expect(error_code).to eql -32600
+        expect(response_data).to match /Invalid Request/
         @json.stop_service
         sleep(0.1)
       end

data/spec/io/udp_sockets_spec.rb

@@ -44,7 +44,7 @@ module Cosmos
 
       it "handles 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)
+        expect(IO).to receive(:fast_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
@@ -88,12 +88,52 @@ module Cosmos
 
       it "handles 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)
+        expect(IO).to receive(:fast_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
+
+  describe UdpReadWriteSocket do
+
+    describe "initialize" do
+      it "creates a socket" do
+        udp = UdpReadWriteSocket.new(8888)
+        expect(udp.local_address.ip_address).to eql '0.0.0.0'
+        expect(udp.local_address.ip_port).to eql 8888
+        udp.close
+        if RUBY_ENGINE == 'ruby' # UDP multicast does not work in Jruby
+          udp = UdpReadWriteSocket.new(8888, '0.0.0.0', 0, '224.0.1.1')
+          expect(IPAddr.new_ntoh(udp.getsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_IF).data).to_s).to eql "0.0.0.0"
+          udp.close
+        end
+      end
+    end
+
+    describe "read" do
+      it "reads data" do
+        udp_read  = UdpReadWriteSocket.new(8888)
+        udp_write = UdpWriteSocket.new('127.0.0.1', 8888)
+        udp_write.write("\x01\x02",2.0)
+        expect(udp_read.read).to eql "\x01\x02"
+        udp_read.close
+        udp_write.close
+      end
+    end
+
+    describe "write" do
+      it "writes data" do
+        udp_read  = UdpReadSocket.new(8888)
+        udp_write = UdpReadWriteSocket.new(0, "0.0.0.0", 8888, '127.0.0.1')
+        udp_write.write("\x01\x02",2.0)
+        expect(udp_read.read).to eql "\x01\x02"
+        udp_read.close
+        udp_write.close
+      end
+    end
+
+  end
 end