libuv 0.11.22 → 0.12.0

data/spec/idle_spec.rb

@@ -1,56 +1,56 @@
-require 'libuv'
-
-
-describe Libuv::Idle do
-	before :each do
-		@log = []
-		@general_failure = []
-
-		@loop = Libuv::Loop.default
-		@server = @loop.pipe
-		@client = @loop.pipe
-		@timeout = @loop.timer do
-			@loop.stop
-			@general_failure << "test timed out"
-		end
-		@timeout.start(5000)
-
-		@loop.all(@server, @client, @timeout).catch do |reason|
-			@general_failure << reason.inspect
-			p "Failed with: #{reason.message}\n#{reason.backtrace.join("\n")}\n"
-		end
-	end
-	
-	it "should increase the idle count when there is nothing to process" do
-		@loop.run { |logger|
-			logger.progress do |level, errorid, error|
-				begin
-					p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
-				rescue Exception
-					p 'error in logger'
-				end
-			end
-
-			@idle_calls = 0
-  
-			idle = @loop.idle do |e|
-				@idle_calls += 1
-			end
-			idle.start
-
-			timer = @loop.timer proc {}
-			timer.start(1, 0)
-
-			stopper = @loop.timer do
-				idle.close
-				timer.close
-				stopper.close
-				@loop.stop
-			end
-			stopper.start(1000, 0)
-		}
-
-		expect(@general_failure).to eq([])
-		expect((@idle_calls > 0)).to eq(true)
-	end
-end
+require 'libuv'
+
+
+describe Libuv::Idle do
+	before :each do
+		@log = []
+		@general_failure = []
+
+		@loop = Libuv::Loop.default
+		@server = @loop.pipe
+		@client = @loop.pipe
+		@timeout = @loop.timer do
+			@loop.stop
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+
+		@loop.all(@server, @client, @timeout).catch do |reason|
+			@general_failure << reason.inspect
+			p "Failed with: #{reason.message}\n#{reason.backtrace.join("\n")}\n"
+		end
+	end
+	
+	it "should increase the idle count when there is nothing to process" do
+		@loop.run { |logger|
+			logger.progress do |level, errorid, error|
+				begin
+					p "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+				rescue Exception
+					p 'error in logger'
+				end
+			end
+
+			@idle_calls = 0
+  
+			idle = @loop.idle do |e|
+				@idle_calls += 1
+			end
+			idle.start
+
+			timer = @loop.timer proc {}
+			timer.start(1, 0)
+
+			stopper = @loop.timer do
+				idle.close
+				timer.close
+				stopper.close
+				@loop.stop
+			end
+			stopper.start(1000, 0)
+		}
+
+		expect(@general_failure).to eq([])
+		expect((@idle_calls > 0)).to eq(true)
+	end
+end

data/spec/pipe_spec.rb

@@ -1,160 +1,160 @@
-require 'libuv'
-
-
-describe Libuv::Pipe do
-	before :each do
-		@log = []
-		@general_failure = []
-
-		@loop = Libuv::Loop.new
-		@server = @loop.pipe
-		@client = @loop.pipe
-		@timeout = @loop.timer do
-			@loop.stop
-			@general_failure << "test timed out"
-		end
-		@timeout.start(5000)
-
-		@pipefile = "/tmp/test-pipes.pipe"
-
-		@loop.all(@server, @client, @timeout).catch do |reason|
-			@general_failure << reason.inspect
-			@general_failure << "Failed with: #{reason.message}\n#{reason.backtrace}\n"
-		end
-
-		begin
-			File.unlink(@pipefile)
-		rescue
-		end
-	end
-
-	after :each do
-		begin
-			File.unlink(@pipefile)
-		rescue
-		end
-	end
-	
-	describe 'bidirectional inter process communication' do
-
-		it "should send a ping and return a pong" do
-			@loop.run { |logger|
-				logger.progress do |level, errorid, error|
-					begin
-						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace}\n"
-					rescue Exception
-						@general_failure << 'error in logger'
-					end
-				end
-
-				@server.bind(@pipefile) do |connection|
-					connection.accept do |client|
-						client.progress do |data|
-							@log << data
-							client.write('pong')
-						end
-						client.start_read
-					end
-				end
-
-				# catch server errors
-				@server.catch do |reason|
-					@general_failure << reason.inspect
-					@loop.stop
-
-					@general_failure << "Failed with: #{reason.message}\n#{reason.backtrace}\n"
-				end
-
-				# start listening
-				@server.listen(1024)
-
-
-
-				# connect client to server
-				@client.connect(@pipefile) do |client|
-					@client.progress do |data|
-						@log << data
-
-						@client.close
-					end
-
-					@client.start_read
-					@client.write('ping')
-				end
-
-				@client.catch do |reason|
-					@general_failure << reason.inspect
-					@loop.stop
-
-					@general_failure << "Failed with: #{reason.message}\n#{reason.backtrace}\n"
-				end
-
-				# Stop the loop once the client handle is closed
-				@client.finally do
-					@server.close
-					@loop.stop
-				end
-			}
-
-			expect(@general_failure).to eq([])
-			expect(@log).to eq(['ping', 'pong'])
-		end
-	end
-
-	# This test won't pass on windows as pipes don't work like this on windows
-	describe 'unidirectional pipeline', :unix_only => true do
-		before :each do
-			system "/usr/bin/mkfifo", @pipefile
-		end
-
-		it "should send work to a consumer" do
-			@loop.run { |logger|
-				logger.progress do |level, errorid, error|
-					@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
-				end
-
-
-				heartbeat = @loop.timer
-				@file1 = @loop.file(@pipefile, File::RDWR|File::NONBLOCK)
-				@file1.progress do
-					@server.open(@file1.fileno) do |server|
-						heartbeat.progress  do
-							@server.write('workload').catch do |err|
-								@general_failure << err
-							end
-						end
-						heartbeat.start(0, 200)
-					end
-				end
-				@file1.catch do |e|
-					@general_failure << "Log called: #{e.inspect} - #{e.message}\n"
-				end
-
-				@file2 = @loop.file(@pipefile, File::RDWR|File::NONBLOCK)
-				@file2.progress do
-					# connect client to server
-					@client.open(@file2.fileno) do |consumer|
-						consumer.progress do |data|
-							@log = data
-						end
-
-						consumer.start_read
-					end
-				end
-
-
-				timeout = @loop.timer do
-					@server.close
-					@client.close
-					timeout.close
-					heartbeat.close
-					@loop.stop
-				end
-				timeout.start(1000)
-			}
-
-			expect(@general_failure).to eq([])
-			expect(@log).to eq('workload')
-		end
-	end
-end
+require 'libuv'
+
+
+describe Libuv::Pipe do
+	before :each do
+		@log = []
+		@general_failure = []
+
+		@loop = Libuv::Loop.new
+		@server = @loop.pipe
+		@client = @loop.pipe
+		@timeout = @loop.timer do
+			@loop.stop
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+
+		@pipefile = "/tmp/test-pipes.pipe"
+
+		@loop.all(@server, @client, @timeout).catch do |reason|
+			@general_failure << reason.inspect
+			@general_failure << "Failed with: #{reason.message}\n#{reason.backtrace}\n"
+		end
+
+		begin
+			File.unlink(@pipefile)
+		rescue
+		end
+	end
+
+	after :each do
+		begin
+			File.unlink(@pipefile)
+		rescue
+		end
+	end
+	
+	describe 'bidirectional inter process communication' do
+
+		it "should send a ping and return a pong" do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+				@server.bind(@pipefile) do |connection|
+					connection.accept do |client|
+						client.progress do |data|
+							@log << data
+							client.write('pong')
+						end
+						client.start_read
+					end
+				end
+
+				# catch server errors
+				@server.catch do |reason|
+					@general_failure << reason.inspect
+					@loop.stop
+
+					@general_failure << "Failed with: #{reason.message}\n#{reason.backtrace}\n"
+				end
+
+				# start listening
+				@server.listen(1024)
+
+
+
+				# connect client to server
+				@client.connect(@pipefile) do |client|
+					@client.progress do |data|
+						@log << data
+
+						@client.close
+					end
+
+					@client.start_read
+					@client.write('ping')
+				end
+
+				@client.catch do |reason|
+					@general_failure << reason.inspect
+					@loop.stop
+
+					@general_failure << "Failed with: #{reason.message}\n#{reason.backtrace}\n"
+				end
+
+				# Stop the loop once the client handle is closed
+				@client.finally do
+					@server.close
+					@loop.stop
+				end
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log).to eq(['ping', 'pong'])
+		end
+	end
+
+	# This test won't pass on windows as pipes don't work like this on windows
+	describe 'unidirectional pipeline', :unix_only => true do
+		before :each do
+			system "/usr/bin/mkfifo", @pipefile
+		end
+
+		it "should send work to a consumer" do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+				end
+
+
+				heartbeat = @loop.timer
+				@file1 = @loop.file(@pipefile, File::RDWR|File::NONBLOCK)
+				@file1.progress do
+					@server.open(@file1.fileno) do |server|
+						heartbeat.progress  do
+							@server.write('workload').catch do |err|
+								@general_failure << err
+							end
+						end
+						heartbeat.start(0, 200)
+					end
+				end
+				@file1.catch do |e|
+					@general_failure << "Log called: #{e.inspect} - #{e.message}\n"
+				end
+
+				@file2 = @loop.file(@pipefile, File::RDWR|File::NONBLOCK)
+				@file2.progress do
+					# connect client to server
+					@client.open(@file2.fileno) do |consumer|
+						consumer.progress do |data|
+							@log = data
+						end
+
+						consumer.start_read
+					end
+				end
+
+
+				timeout = @loop.timer do
+					@server.close
+					@client.close
+					timeout.close
+					heartbeat.close
+					@loop.stop
+				end
+				timeout.start(1000)
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log).to eq('workload')
+		end
+	end
+end

data/spec/tcp_spec.rb

@@ -1,267 +1,271 @@
-require 'libuv'
-require 'thread'
-
-
-describe Libuv::TCP do
-	before :each do
-		@log = []
-		@general_failure = []
-
-		@loop = Libuv::Loop.new
-		@server = @loop.tcp
-		@client = @loop.tcp
-		@timeout = @loop.timer do
-			@loop.stop
-			@loop2.stop if @loop2
-			@general_failure << "test timed out"
-		end
-		@timeout.start(5000)
-
-		@loop.all(@server, @client, @timeout).catch do |reason|
-			@general_failure << reason.inspect
-		end
-
-
-		@pipefile = "/tmp/test-pipe.pipe"
-
-		begin
-			File.unlink(@pipefile)
-		rescue
-		end
-	end
-	
-	describe 'basic client server' do
-		it "should send a ping and return a pong", :network => true do
-			@loop.run { |logger|
-				logger.progress do |level, errorid, error|
-					begin
-						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
-					rescue Exception
-						@general_failure << 'error in logger'
-					end
-				end
-
-
-				@server.bind('127.0.0.1', 34567) do |server|
-					server.accept do |client|
-						client.progress do |data|
-							@log << data
-
-							client.write('pong')
-						end
-						client.start_read
-					end
-				end
-
-				# catch errors
-				@server.catch do |reason|
-					@general_failure << reason.inspect
-				end
-
-				# start listening
-				@server.listen(1024)
-
-
-
-				# connect client to server
-				@client.connect('127.0.0.1', 34567) do |client|
-					client.progress do |data|
-						@log << data
-
-						@client.shutdown
-					end
-
-					@client.start_read
-					@client.write('ping')
-				end
-
-				# catch errors
-				@client.catch do |reason|
-					@general_failure << reason.inspect
-				end
-
-				# close the handle
-				@client.finally do
-					@server.close
-					@loop.stop
-				end
-			}
-
-			expect(@general_failure).to eq([])
-			expect(@log).to eq(['ping', 'pong'])
-		end
-	end
-
-	it "should handle requests on different threads", :network => true do
-		@sync = Mutex.new
-
-		@loop.run { |logger|
-			logger.progress do |level, errorid, error|
-				begin
-					@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
-				rescue Exception
-					@general_failure << 'error in logger'
-				end
-			end
-
-
-			@remote = nil
-			@server.bind('127.0.0.1', 45678) do |server|
-				server.accept do |client|
-					@remote.write2(client)
-				end
-			end
-
-			# catch errors
-			@server.catch do |reason|
-				@general_failure << reason.inspect
-			end
-
-
-			@pipeserve = @loop.pipe(true)
-			@pipeserve.bind(@pipefile) do |connection|
-				connection.accept do |client|
-					@remote = client
-
-					# start listening on TCP server
-					@server.listen(1024)
-
-					# connect client to server
-					@client.connect('127.0.0.1', 45678) do |client|
-						client.progress do |data|
-							@sync.synchronize {
-								@log << data
-							}
-							@client.shutdown
-						end
-
-						@client.start_read
-						@client.write('ping')
-					end
-				end
-			end
-
-			# start listening
-			@pipeserve.listen(1024)
-
-
-
-			# catch errors
-			@client.catch do |reason|
-				@general_failure << reason.inspect
-			end
-
-			# close the handle
-			@client.finally do
-				@server.close
-				@pipeserve.close
-			end
-			
-
-
-			Thread.new do
-				@loop2 = Libuv::Loop.new
-				@pipeclient = @loop2.pipe(true)
-
-
-				@loop2.run do  |logger|
-					logger.progress do |level, errorid, error|
-						begin
-							@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
-						rescue Exception
-							@general_failure << 'error in logger'
-						end
-					end
-			
-					# connect client to server
-					@pipeclient.connect(@pipefile) do |client|
-						@pipeclient.progress do |data, connection|
-							connection.progress do |data|
-								@sync.synchronize {
-									@log << data
-								}
-								connection.write('pong')
-							end
-							connection.start_read
-							connection.finally do
-								@pipeclient.close
-								@loop2.stop
-								@loop.stop
-							end
-						end
-
-						@pipeclient.start_read2
-					end
-				end
-			end
-		}
-
-		expect(@general_failure).to eq([])
-		expect(@log).to eq(['ping', 'pong'])
-	end
-
-	describe 'basic TLS client and server' do
-		it "should send a ping and return a pong", :network => true do
-			@loop.run { |logger|
-				logger.progress do |level, errorid, error|
-					begin
-						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
-					rescue Exception
-						@general_failure << 'error in logger'
-					end
-				end
-
-
-				@server.bind('127.0.0.1', 34567) do |server|
-					server.accept do |client|
-						client.start_tls(server: true)
-						client.progress do |data|
-							@log << data
-
-							client.write('pong')
-						end
-						client.start_read
-					end
-				end
-
-				# catch errors
-				@server.catch do |reason|
-					@general_failure << reason.inspect
-				end
-
-				# start listening
-				@server.listen(1024)
-
-
-
-				# connect client to server
-				@client.connect('127.0.0.1', 34567) do |client|
-					client.start_tls
-					client.progress do |data|
-						@log << data
-
-						@client.shutdown
-					end
-
-					@client.start_read
-					@client.write('ping')
-				end
-
-				# catch errors
-				@client.catch do |reason|
-					@general_failure << reason.inspect
-				end
-
-				# close the handle
-				@client.finally do
-					@server.close
-					@loop.stop
-				end
-			}
-
-			expect(@general_failure).to eq([])
-			expect(@log).to eq(['ping', 'pong'])
-		end
-	end
-
-end
+require 'libuv'
+require 'thread'
+
+
+describe Libuv::TCP do
+	before :each do
+		@log = []
+		@general_failure = []
+
+		@loop = Libuv::Loop.new
+		@server = @loop.tcp
+		@client = @loop.tcp
+		@timeout = @loop.timer do
+			@loop.stop
+			@loop2.stop if @loop2
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+
+		@loop.all(@server, @client, @timeout).catch do |reason|
+			@general_failure << reason.inspect
+		end
+
+
+		@pipefile = "/tmp/test-pipe.pipe"
+
+		begin
+			File.unlink(@pipefile)
+		rescue
+		end
+	end
+	
+	describe 'basic client server' do
+		it "should send a ping and return a pong", :network => true do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+
+				@server.bind('127.0.0.1', 34567) do |server|
+					server.accept do |client|
+						client.progress do |data|
+							@log << data
+
+							client.write('pong')
+						end
+						client.start_read
+					end
+				end
+
+				# catch errors
+				@server.catch do |reason|
+					@general_failure << reason.inspect
+				end
+
+				# start listening
+				@server.listen(1024)
+
+
+
+				# connect client to server
+				@client.connect('127.0.0.1', 34567) do |client|
+					client.progress do |data|
+						@log << data
+
+						@client.shutdown
+					end
+
+					@client.start_read
+					@client.write('ping')
+				end
+
+				# catch errors
+				@client.catch do |reason|
+					@general_failure << reason.inspect
+				end
+
+				# close the handle
+				@client.finally do
+					@server.close
+					@loop.stop
+				end
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log).to eq(['ping', 'pong'])
+		end
+	end
+
+	it "should handle requests on different threads", :network => true do
+		@sync = Mutex.new
+
+		@loop.run { |logger|
+			logger.progress do |level, errorid, error|
+				begin
+					@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+				rescue Exception
+					@general_failure << 'error in logger'
+				end
+			end
+
+
+			@remote = nil
+			@server.bind('127.0.0.1', 45678) do |server|
+				server.accept do |client|
+					@remote.write2(client)
+				end
+			end
+
+			# catch errors
+			@server.catch do |reason|
+				@general_failure << reason.inspect
+			end
+
+
+			@pipeserve = @loop.pipe(true)
+			@pipeserve.bind(@pipefile) do |connection|
+				connection.accept do |client|
+					@remote = client
+
+					# start listening on TCP server
+					@server.listen(1024)
+
+					# connect client to server
+					@client.connect('127.0.0.1', 45678) do |client|
+						client.progress do |data|
+							@sync.synchronize {
+								@log << data
+							}
+							@client.shutdown
+						end
+
+						@client.start_read
+						@client.write('ping')
+					end
+				end
+
+				@pipeserve.getsockname
+			end
+
+			# start listening
+			@pipeserve.listen(1024)
+
+
+
+			# catch errors
+			@client.catch do |reason|
+				@general_failure << reason.inspect
+			end
+
+			# close the handle
+			@client.finally do
+				@server.close
+				@pipeserve.close
+			end
+			
+
+
+			Thread.new do
+				@loop2 = Libuv::Loop.new
+				@pipeclient = @loop2.pipe(true)
+
+
+				@loop2.run do  |logger|
+					logger.progress do |level, errorid, error|
+						begin
+							@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+						rescue Exception
+							@general_failure << 'error in logger'
+						end
+					end
+			
+					# connect client to server
+					@pipeclient.connect(@pipefile) do |client|
+						@pipeclient.progress do |data|
+							connection = @pipeclient.check_pending
+
+							connection.progress do |data|
+								@sync.synchronize {
+									@log << data
+								}
+								connection.write('pong')
+							end
+							connection.start_read
+							connection.finally do
+								@pipeclient.close
+								@loop2.stop
+								@loop.stop
+							end
+						end
+
+						@pipeclient.start_read
+					end
+				end
+			end
+		}
+
+		expect(@general_failure).to eq([])
+		expect(@log).to eq(['ping', 'pong'])
+	end
+
+	describe 'basic TLS client and server' do
+		it "should send a ping and return a pong", :network => true do
+			@loop.run { |logger|
+				logger.progress do |level, errorid, error|
+					begin
+						@general_failure << "Log called: #{level}: #{errorid}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+					rescue Exception
+						@general_failure << 'error in logger'
+					end
+				end
+
+
+				@server.bind('127.0.0.1', 34567) do |server|
+					server.accept do |client|
+						client.start_tls(server: true)
+						client.progress do |data|
+							@log << data
+
+							client.write('pong')
+						end
+						client.start_read
+					end
+				end
+
+				# catch errors
+				@server.catch do |reason|
+					@general_failure << reason.inspect
+				end
+
+				# start listening
+				@server.listen(1024)
+
+
+
+				# connect client to server
+				@client.connect('127.0.0.1', 34567) do |client|
+					client.start_tls
+					client.progress do |data|
+						@log << data
+
+						@client.shutdown
+					end
+
+					@client.start_read
+					@client.write('ping')
+				end
+
+				# catch errors
+				@client.catch do |reason|
+					@general_failure << reason.inspect
+				end
+
+				# close the handle
+				@client.finally do
+					@server.close
+					@loop.stop
+				end
+			}
+
+			expect(@general_failure).to eq([])
+			expect(@log).to eq(['ping', 'pong'])
+		end
+	end
+
+end