barlume 0.0.1.rc.1 → 0.0.1.rc.2

data/lib/barlume/lanterna/dpoll.rb

@@ -0,0 +1,204 @@
+#--
+# Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
+#
+# This file is part of barlume.
+#
+# barlume is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# barlume is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with barlume. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module Barlume; class Lanterna
+
+class DPoll < Lanterna; begin
+	raise unless File.exists?('/dev/poll')
+
+	module C
+		extend FFI::Library
+
+		ffi_lib FFI::Library::LIBC
+
+		class PollFD < FFI::Struct
+			layout \
+				:fd,      :int,
+				:events,  :short,
+				:revents, :short
+		end
+
+		class DVPoll < FFI::Struct
+			layout \
+				:fds,     :pointer,
+				:nfds,    :nfds_t,
+				:timeout, :int
+		end
+
+		attach_function :malloc, [:size_t], :pointer
+		attach_function :realloc, [:pointer, :size_t], :pointer
+		attach_function :free, [:pointer], :void
+
+		DP_POLL = (0xD0 << 8) | 1
+
+		POLLIN  = 0x001
+		POLLPRI = 0x002
+		POLLOUT = 0x004
+
+		POLLERR  = 0x008
+		POLLHUP  = 0x010
+		POLLNVAL = 0x020
+
+		POLLRDNORM = 0x040
+		POLLRDBAND = 0x080
+		POLLWRNORM = 0x100
+		POLLWRBAND = 0x200
+
+		POLLMSG    = 0x0400
+		POLLREMOVE = 0x1000
+		POLLRDHUP  = 0x2000
+	end
+
+	def self.supported?
+		true
+	end
+
+	def initialize
+		super
+
+		@out        = C::DVPoll.new
+		@out[:fds]  = FFI::AutoPointer.new(C.malloc(C::PollFD.size), C.method(:free))
+		@out[:nfds] = 1
+
+		@set = FFI::AutoPointer.new(C.malloc(C::PollFD.size), C.method(:free))
+
+		pfd          = C::PollFD.new(@set + 0)
+		pfd[:fd]     = @breaker.to_i
+		pfd[:events] = C::POLLIN
+	end
+
+	def add (*)
+		super {|l|
+			@set.autorelease = false
+			@set = FFI::AutoPointer.new(C.realloc(@set, (@descriptors.length + 1) * C::PollFD.size), C.method(:free))
+
+			@out[:fds].autorelease = false
+			@out[:fds]   = FFI::AutoPointer.new(C.realloc(@out[:fds], (@descriptors.length + 1) * C::PollFD.size), C.method(:free))
+			@out[:nfds] += 1
+
+			pfd = C::PollFD.new(@set + (@descriptors.length * C::PollFD.size))
+			pfd[:fd] = l.to_i
+		}
+	end
+
+	def remove (*)
+		super {|l|
+			index   = index_of(l)
+			offset  = (index + 1) * C::PollFD.size
+			pointer = @set + offset
+
+			pointer.write_bytes((pointer + C::PollFD.size).read_bytes((@descriptors.length - index) * C::PollFD.size))
+
+			@set.autorelease = false
+			@set = FFI::AutoPointer.new(C.realloc(@set, (@descriptors.length) * C::PollFD.size), C.method(:free))
+
+			@out[:fds].autorelease = false
+			@out[:fds]   = FFI::AutoPointer.new(C.realloc(@out[:fds], @descriptors.length * C::PollFD.size), C.method(:free))
+			@out[:nfds] -= 1
+		}
+	end
+
+	def readable! (*)
+		super {|l|
+			pfd = C::PollFD.new(@set + ((index_of(l) + 1) * C::PollFD.size))
+			pfd[:events] |= C::POLLIN
+		}
+	end
+
+	def no_readable! (*)
+		super {|l|
+			pfd = C::PollFD.new(@set + ((index_of(l) + 1) * C::PollFD.size))
+			pfd[:events] &= ~C::POLLIN
+		}
+	end
+
+	def writable! (*)
+		super {|l|
+			pfd = C::PollFD.new(@set + ((index_of(l) + 1) * C::PollFD.size))
+			pfd[:events] |= C::POLLOUT
+		}
+	end
+
+	def no_writable! (*)
+		super {|l|
+			pfd = C::PollFD.new(@set + ((index_of(l) + 1) * C::PollFD.size))
+			pfd[:events] &= ~C::POLLOUT
+		}
+	end
+
+	def available (timeout = nil, &block)
+		return enum_for :available, timeout unless block
+
+		@out[:timeout] = timeout ? timeout * 1000 : -1
+
+		io = IO.for_fd(IO.sysopen('/dev/poll', IO::RDWR))
+		io.syswrite(@set.read_bytes((@descriptors.length + 1) * C::PollFD.size))
+
+		length = io.ioctl(C::DP_POLL, @out.pointer.address)
+		io.close
+
+		if length == 0
+			yield :timeout, timeout
+
+			return self
+		end
+
+		n    = 0
+		size = C::PollFD.size
+		while n < length
+			p        = C::PollFD.new(@out[:fds] + (n * size))
+			events   = p[:revents]
+			fd       = p[:fd]
+			lucciola = self[fd]
+
+			if lucciola
+				if (events & (C::POLLERR | C::POLLHUP)).nonzero?
+					yield :error, lucciola
+				else
+					if (events & C::POLLIN).nonzero?
+						yield :readable, lucciola
+					end
+
+					if (events & C::POLLOUT).nonzero?
+						yield :writable, lucciola
+					end
+				end
+			elsif fd == @breaker.to_i
+				yield :break, @breaker.reason
+			else
+				raise "#{fd} isn't trapped here"
+			end
+
+			n += 1
+		end
+
+		self
+	end
+
+private
+	def index_of (what)
+		@descriptors.keys.index(what.to_i)
+	end
+rescue Exception
+	def self.supported?
+		false
+	end
+end; end
+
+end; end

data/lib/barlume/lanterna/epoll.rb

@@ -17,8 +17,6 @@
 # along with barlume. If not, see <http://www.gnu.org/licenses/>.
 #++
 
-require 'ffi'
-
 module Barlume; class Lanterna
 
 class Epoll < Lanterna; begin
@@ -48,9 +46,7 @@ class Epoll < Lanterna; begin
 		attach_function :epoll_create, [:int], :int
 		attach_function :epoll_create1, [:int], :int
 		attach_function :epoll_ctl, [:int, Control, :int, :pointer], :int
-		attach_function :epoll_wait, [:int, :pointer, :int, :int], :int
-
-		MAX = 4294967295
+		attach_function :epoll_wait, [:int, :pointer, :int, :int], :int, :blocking => true
 
 		EPOLLIN  = 0x001
 		EPOLLPRI = 0x002
@@ -89,114 +85,146 @@ class Epoll < Lanterna; begin
 		}
 	end
 
+	attr_reader :size
+
 	def initialize
 		super
 
 		FFI.raise_if((@fd = C.epoll_create1(0)) < 0)
 
-		p = C::EpollEvent.new
-		p[:events] = C::EPOLLIN
-		p[:data][:u32] = C::MAX
+		@ev = C::EpollEvent.new
+		@ev[:events]    = C::EPOLLIN
+		@ev[:data][:fd] = @breaker.to_i
 
-		FFI.raise_if(C.epoll_ctl(@fd, :add, @breaker.to_i, p) < 0)
+		FFI.raise_if(C.epoll_ctl(@fd, :add, @breaker.to_i, @ev) < 0)
 
 		self.size = 4096
 	end
 
-	def size
-		@events.size / C::EpollEvent.size
-	end
-
 	def size= (n)
 		@events = FFI::MemoryPointer.new C::EpollEvent.size, n
+		@size   = @events.size / C::EpollEvent.size
+	end
+
+	def edge_triggered?;   @edge; end
+	def level_triggered?; !@edge; end
+
+	def edge_triggered!
+		@edge = true
+
+		each {|l|
+			@ev[:events]    = C::EPOLLET | (l.readable? ? C::EPOLLIN : 0) | (l.writable? ? C::EPOLLOUT : 0)
+			@ev[:data][:fd] = l.to_i
+
+			FFI.raise_if(C.epoll_ctl(@fd, :mod, l.to_i, @ev) < 0)
+		}
+	end
+
+	def level_triggered!
+		@edge = false
+
+		each {|l|
+			@ev[:events]    = (l.readable? ? C::EPOLLIN : 0) | (l.writable? ? C::EPOLLOUT : 0)
+			@ev[:data][:fd] = l.to_i
+
+			FFI.raise_if(C.epoll_ctl(@fd, :mod, l.to_i, @ev) < 0)
+		}
 	end
 
-	def add (what)
-		super.tap {|l|
-			FFI.raise_if(C.epoll_ctl(@fd, :add, l.to_i, C::EpollEvent.new) < 0)
+	def add (*)
+		super {|l|
+			@ev[:events]    = 0
+			@ev[:data][:fd] = l.to_i
 
-			@last = nil
+			FFI.raise_if(C.epoll_ctl(@fd, :add, l.to_i, @ev) < 0)
 		}
 	end
 
-	def remove (what)
-		super.tap {|l|
+	def remove (*)
+		super {|l|
 			begin
 				FFI.raise_if(C.epoll_ctl(@fd, :del, l.to_i, nil) < 0)
 			rescue Errno::ENOENT; end
-
-			@last = nil
 		}
 	end
 
-	def available (timeout = nil)
-		set :both; epoll timeout
+	def readable! (*)
+		super {|l|
+			@ev[:events]    = C::EPOLLIN | (l.writable? ? C::EPOLLOUT : 0) | (edge_triggered? ? C::EPOLLET : 0)
+			@ev[:data][:fd] = l.to_i
 
-		Available.new(to(:read), to(:write), to(:error))
+			FFI.raise_if(C.epoll_ctl(@fd, :mod, l.to_i, @ev) < 0)
+		}
 	end
 
-	def readable (timeout = nil)
-		set :read; epoll timeout
+	def no_readable! (*)
+		super {|l|
+			@ev[:events]    = (l.writable? ? C::EPOLLOUT : 0) | (edge_triggered? ? C::EPOLLET : 0)
+			@ev[:data][:fd] = l.to_i
 
-		if report_errors?
-			[to(:read), to(:error)]
-		else
-			to :read
-		end
+			FFI.raise_if(C.epoll_ctl(@fd, :mod, l.to_i, @ev) < 0)
+		}
 	end
 
-	def writable (timeout = nil)
-		set :write; epoll timeout
+	def writable! (*)
+		super {|l|
+			@ev[:events]    = C::EPOLLOUT | (l.readable? ? C::EPOLLIN : 0) | (edge_triggered? ? C::EPOLLET : 0)
+			@ev[:data][:fd] = l.to_i
 
-		if report_errors?
-			[to(:write), to(:error)]
-		else
-			to :write
-		end
+			FFI.raise_if(C.epoll_ctl(@fd, :mod, l.to_i, @ev) < 0)
+		}
 	end
 
-	def set (what)
-		return if @last == what
+	def no_writable! (*)
+		super {|l|
+			@ev[:events]    = (l.readable? ? C::EPOLLIN : 0) | (edge_triggered? ? C::EPOLLET : 0)
+			@ev[:data][:fd] = l.to_i
 
-		p = C::EpollEvent.new
-		p[:events] = case what
-			when :both  then C::EPOLLIN | C::EPOLLOUT
-			when :read  then C::EPOLLIN
-			when :write then C::EPOLLOUT
-		end
+			FFI.raise_if(C.epoll_ctl(@fd, :mod, l.to_i, @ev) < 0)
+		}
+	end
 
-		descriptors.each_with_index {|descriptor, index|
-			p[:data][:u32] = index
+	def available (timeout = nil, &block)
+		return enum_for :available, timeout unless block
 
-			FFI.raise_if(C.epoll_ctl(@fd, :mod, descriptor.to_i, p) < 0)
-		}
+		FFI.raise_if((length = C.epoll_wait(@fd, @events, @size, timeout ? timeout * 1000 : -1)) < 0)
 
-		@last = what
-	end
+		if length == 0
+			yield :timeout, timeout
 
-	def to (what)
-		result = []
-		events = case what
-			when :read  then C::EPOLLIN
-			when :write then C::EPOLLOUT
-			when :error then C::EPOLLERR | C::EPOLLHUP
+			return self
 		end
 
-		0.upto(@length - 1) {|n|
-			p = C::EpollEvent.new(@events + (n * C::EpollEvent.size))
-
-			if p[:data][:u32] != C::MAX && (p[:events] & events).nonzero?
-				result << descriptors[p[:data][:u32]]
+		n    = 0
+		size = C::EpollEvent.size
+		while n < length
+			p        = C::EpollEvent.new(@events + (n * size))
+			events   = p[:events]
+			fd       = p[:data][:fd]
+			lucciola = self[fd]
+
+			if lucciola
+				if (events & (C::EPOLLERR | C::EPOLLHUP)).nonzero?
+					yield :error, lucciola
+				else
+					if (events & C::EPOLLIN).nonzero?
+						yield :readable, lucciola
+					end
+
+					if (events & C::EPOLLOUT).nonzero?
+						yield :writable, lucciola
+					end
+				end
+			elsif fd == @breaker.to_i
+				yield :break, @breaker.reason
+			else
+				raise "#{fd} isn't trapped here"
 			end
-		}
-
-		result
-	end
 
-	def epoll (timeout = nil)
-		FFI.raise_if((@length = C.epoll_wait(@fd, @events, size, timeout ? timeout * 1000 : -1)) < 0)
+			n += 1
+		end
 
-		@breaker.flush
+		self
 	end
 rescue Exception
 	def self.supported?

data/lib/barlume/lanterna/{utils.rb → helpers.rb}

@@ -17,13 +17,16 @@
 # along with barlume. If not, see <http://www.gnu.org/licenses/>.
 #++
 
+require 'backports'
 require 'ffi'
 
 module FFI
-	def self.raise
-		value = FFI.errno
+	def self.errno_exception
+		Errno.const_get(Errno.constants[FFI.errno]).new
+	end
 
-		Kernel.raise Errno.constants[FFI.errno].new
+	def self.raise
+		Kernel.raise errno_exception
 	rescue Exception => e
 		e.backtrace.shift(3)