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

data/barlume.gemspec

@@ -14,5 +14,6 @@ Gem::Specification.new {|s|
 	s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
 	s.require_paths = ['lib']
 
-	s.add_dependency 'ffi'
+	s.add_runtime_dependency 'ffi'
+	s.add_runtime_dependency 'backports'
 }

data/examples/echo.rb

@@ -0,0 +1,78 @@
+#! /usr/bin/env ruby
+require 'rubygems'
+require 'barlume'
+
+class Echo < Barlume::Lucciola
+	CHUNK_SIZE = 2048
+
+	def initialize (*)
+		super
+		
+		@buffer = ''
+	end
+
+	def read_all
+		while chunk = read(CHUNK_SIZE)
+			@buffer << chunk
+		end
+	rescue Errno::EAGAIN; end
+
+	def write_all
+		while @buffer.length > 0
+			if @buffer.length <= CHUNK_SIZE
+				written = write @buffer
+
+				if written < @buffer.length
+					@buffer[0, written] = ''
+
+					return false
+				else
+					@buffer.clear
+				end
+			else
+				written = write @buffer[0, CHUNK_SIZE]
+
+				@buffer[0, written] = ''
+
+				if written < CHUNK_SIZE
+					return false
+				end
+			end
+		end
+
+		true
+	rescue Errno::EAGAIN
+		false
+	end
+end
+
+lanterna = Barlume::Lanterna.best
+server   = lanterna.add(TCPServer.new(1337)).asynchronous!.readable!
+server.listen(1024)
+
+puts "Using #{lanterna.name}..."
+
+loop do
+	lanterna.available {|event, lucciola|
+		if event == :error
+			lucciola.delete!.close rescue nil
+		elsif event == :readable
+			if lucciola == server
+				while client = lucciola.accept rescue nil
+					lanterna.add(Echo.new(client)).asynchronous!.readable!
+				end
+			else
+				begin
+					lucciola.read_all
+					lucciola.writable!
+				rescue EOFError, Errno::ECONNRESET
+					lucciola.delete!
+				end
+			end
+		elsif event == :writable
+			if lucciola.write_all
+				lucciola.no_writable!
+			end
+		end
+	}
+end

data/examples/slowpokes.rb

@@ -0,0 +1,75 @@
+#! /usr/bin/env ruby
+# encoding: utf-8
+require 'rubygems'
+require 'barlume'
+require 'optparse'
+
+options = {}
+
+OptionParser.new do |o|
+  options[:host]    = 'localhost'
+  options[:port]    = 4567
+  options[:threads] = 16
+  options[:content] = "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n"
+  options[:sleep]    = 1
+
+  o.on '-h', '--host host', 'the host of the server' do |value|
+    options[:host] = value
+  end
+
+  o.on '-p', '--port port', Integer, 'the port of the server' do |value|
+    options[:port] = value
+  end
+
+  o.on '-t', '--threads [MAX_THREADS]', 'the max amount of threads on the server' do |value|
+    options[:threads] = value
+  end
+
+  o.on '-c', '--content CONTENT', 'the string to send' do |value|
+    options[:content] = value
+  end
+
+  o.on '-s', '--sleep SECONDS', Float, 'the time to sleep before sending every character' do |value|
+    options[:sleep] = value
+  end
+end.parse!
+
+class Slowpoke < Barlume::Lucciola
+  def initialize (socket, message)
+    super(socket)
+
+    @message = message
+    @offset  = 0
+  end
+
+  def send_next
+    return if done?
+
+    write_nonblock @message[@offset]
+
+    @offset += 1
+  rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+  end
+
+  def done?
+    @offset >= @message.length
+  end
+end
+
+lantern = Barlume::Lanterna.best
+
+options[:threads].times {
+  lantern << Slowpoke.new(TCPSocket.new(options[:host], options[:port]), options[:content])
+}
+
+puts "oh noes, a wall on my path D:"
+
+until lantern.descriptors.all?(&:done?)
+  lantern.writable.each {|s|
+    s.send_next
+  }
+
+  sleep options[:sleep]
+end
+
+puts "oh, there's a door ( ･ ◡◡･)"

data/lib/barlume/lanterna.rb

@@ -19,94 +19,88 @@
 
 require 'barlume/lucciola'
 
+require 'barlume/lanterna/helpers'
+require 'barlume/lanterna/select'
+require 'barlume/lanterna/poll'
+require 'barlume/lanterna/epoll'
+require 'barlume/lanterna/kqueue'
+require 'barlume/lanterna/port'
+require 'barlume/lanterna/dpoll'
+
 module Barlume
 
 class Lanterna
-	class << self
-		%w[select poll epoll kqueue].each {|name|
-			define_method "#{name}?" do
-				const_get(name.capitalize).supported?
-			end
+	%w[select poll epoll kqueue port dpoll].each {|name|
+		klass = Lanterna.const_get(Lanterna.constants.find { |c| c.downcase.to_s == name })
 
-			define_method name do
-				const_get(name.capitalize).new
-			end
-		}
+		define_singleton_method "#{name}?" do
+			klass.supported?
+		end
 
-		def best
-			return kqueue if kqueue?
+		define_singleton_method name do
+			klass.new
+		end
+	}
 
-			return epoll if epoll?
+	def self.best
+		return kqueue if kqueue?
 
-			return poll if poll?
+		return epoll if epoll?
+		
+		return port if port?
 
-			return select
-		end
+		return dpoll if dpoll? && RUBY_PLATFORM =~ /solaris/i
 
-		def new (*)
-			raise 'unsupported platform' unless supported?
+		return poll if poll?
 
-			super
-		end
+		return select
 	end
 
-	Available = Struct.new(:readable, :writable, :error)
+	def self.best_edge_triggered
+		return kqueue.edge_triggered! if kqueue?
 
-	class Breaker
-		def initialize
-			@pipes = IO.pipe
-		end
-
-		def break
-			@pipes.last.write_nonblock 'x'
-		end
+		return epoll.edge_triggered! if epoll?
 
-		def flush
-			@pipes.first.read_nonblock 2048 rescue nil
-		end
+		raise 'this platform does not support edge triggered primitives'
+	end
 
-		def to_io
-			@pipes.first
-		end
+	def self.new (*)
+		raise 'unsupported platform' unless supported?
 
-		def to_i
-			to_io.to_i
-		end
+		super
 	end
 
-	attr_reader :descriptors
+	include Enumerable
 
 	def initialize
-		@breaker       = Breaker.new
-		@descriptors   = []
-		@report_errors = false
+		@breaker     = Breaker.new
+		@descriptors = {}
+		@readable    = {}
+		@writable    = {}
 	end
 
 	def name
 		self.class.name[/(?:::)?([^:]*)$/, 1].downcase.to_sym
 	end
 
-	def report_errors?
-		@report_errors
-	end
-
-	def report_errors!
-		@report_errors = true
-	end
+	def break (with = nil)
+		@breaker.break(with)
 
-	def dont_report_errors!
-		@report_errors = false
+		self
 	end
 
-	def break
-		@breaker.break
-	end
+	def add (what, mode = nil, &block)
+		Lucciola.wrap(what).tap {|lucciola|
+			if @descriptors.has_key?(lucciola.to_i)
+				raise ArgumentError, "#{what.inspect} is already trapped"
+			end
 
-	def add (what)
-		Lucciola.wrap(what).tap {|l|
-			return false if @descriptors.member?(l)
+			@descriptors[lucciola.to_i] = lucciola
+			lucciola.trap_in self
+			block.call lucciola if block
 
-			@descriptors.push(l)
+			readable! lucciola if mode == :readable || mode == :both
+			writable! lucciola if mode == :writable || mode == :both
 		}
 	end
 
@@ -118,17 +112,201 @@ class Lanterna
 
 	alias << push
 
-	def remove (what)
-		@descriptors.delete(Lucciola.wrap(what))
+	def remove (what, &block)
+		unless lucciola = @descriptors[what.to_i]
+			raise ArgumentError, "#{what.inspect} isn't trapped here"
+		end
+
+		block.call lucciola if block
+
+		@descriptors.delete(lucciola.to_i)
+		@readable.delete(lucciola.to_i)
+		@writable.delete(lucciola.to_i)
+
+		lucciola.set_free
 	end
 
 	alias delete remove
-end
 
+	def has? (what)
+		@descriptors.has_key?(what.to_i)
+	end
+
+	def [] (what)
+		@descriptors[what.to_i]
+	end
+
+	def each (mode = nil, &block)
+		return enum_for :each, mode unless block
+
+		if mode.nil?
+			@descriptors.each_value(&block)
+		elsif mode == :readable
+			@readable.each_value(&block)
+		elsif mode == :writable
+			@writable.each_value(&block)
+		else
+			raise ArgumentError, "#{mode} is an unknown mode"
+		end
+
+		self
+	end
+
+	def each_readable (&block)
+		each(:readable, &block)
+	end
+
+	def each_writable (&block)
+		each(:writable, &block)
+	end
+
+	def readable! (*args, &block)
+		args.flatten!
+		args.compact!
+
+		if args.empty?
+			each { |c| readable! c, &block }
+		else
+			args.each {|what|
+				unless readable?(what)
+					what = self[what]
+
+					block.call what if block
+					@readable[what.to_i] = what
+				end
+			}
+		end
+
+		self
+	end
+
+	def no_readable! (*args, &block)
+		args.flatten!
+		args.compact!
+
+		if args.empty?
+			each(:readable) { |c| readable! c, &block }
+		else
+			args.each {|what|
+				if what = readable?(what)
+					@readable.delete(what.to_i)
+					block.call what if block
+				end
+			}
+		end
+
+		self
+	end
+
+	def readable? (what = nil)
+		return !@readable.empty? unless what
+
+		return false unless what = @readable[what.to_i]
+
+		what
+	end
+
+	def writable! (*args, &block)
+		args.flatten!
+		args.compact!
+
+		if args.empty?
+			each { |c| writable! c, &block }
+		else
+			args.each {|what|
+				unless writable?(what)
+					what = self[what]
+
+					block.call what if block
+					@writable[what.to_i] = what
+				end
+			}
+		end
+
+		self
+	end
+
+	def no_writable! (*args, &block)
+		args.flatten!
+		args.compact!
+
+		if args.empty?
+			each(:writable) { |c| writable! c, &block }
+		else
+			args.each {|what|
+				if what = writable?(what)
+					@writable.delete(what.to_i)
+					block.call what if block
+				end
+			}
+		end
+
+		self
+	end
+
+	def writable? (what = nil)
+		return !@writable.empty? unless what
+
+		return false unless what = @writable[what.to_i]
+
+		what
+	end
+
+	def available (timeout = nil, &block)
+		raise NotImplementedError, 'available has not been implemented'
+	end
+
+	def readable (timeout = nil, &block)
+		readable = @readable.dup
+		writable = @writable.dup
+
+		no_writable!
+		readable!
+
+		result = available(timeout, &block)
+
+		no_readable! @readable - readable
+		writable! writable
+
+		result
+	end
+
+	def writable (timeout = nil, &block)
+		readable = @readable.dup
+		writable = @writable.dup
+
+		no_readable!
+		writable!
+
+		result = available(timeout, &block)
+
+		no_writable! @writable - writable
+		readable! readable
+
+		result
+	end
+
+	class Breaker
+		def initialize
+			@pipes = IO.pipe
+		end
+
+		def break (with = nil)
+			@pipes.last.write(Marshal.dump(with))
+		end
+
+		def reason
+			Marshal.load(@pipes.first)
+		end
+
+		def to_io
+			@pipes.first
+		end
+
+		def to_i
+			to_io.to_i
+		end
+	end
 end
 
-require 'barlume/lanterna/utils'
-require 'barlume/lanterna/select'
-require 'barlume/lanterna/poll'
-require 'barlume/lanterna/epoll'
-require 'barlume/lanterna/kqueue'
+end