deac/select
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Compare commits

base: deac:master
Branches Tags
deac:master
deac:v0.2.0
deac:0.2.0
..
compare: deac:v0.2.0
Branches Tags
deac:master
deac:v0.2.0
deac:0.2.0

No commits in common. "master" and "v0.2.0" have entirely different histories.
master ... v0.2.0

4 changed files with 88 additions and 210 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -1 +0,0 @@
/pkg

4
README.md
View file

@ -1,4 +0,0 @@
Select
======
IO-Management select-based.

71
Rakefile
View file

@ -2,57 +2,56 @@ require 'rubygems'
require 'rake' require 'rake'
begin begin
require 'jeweler' require 'jeweler'
Jeweler::Tasks.new do |gem| Jeweler::Tasks.new do |gem|
gem.name = "select" gem.name = "select"
gem.summary = %Q{IO-event-handler based on select} gem.summary = %Q{IO-event-handler based on select}
gem.description = %Q{Select based event-handler for servers and sockets} gem.description = %Q{Select based event-handler for servers and sockets}
gem.email = "ich@denkn.at" gem.email = "Denis.Knauf@gmail.com"
gem.license = 'LGPL-3.0' gem.homepage = "http://github.com/DenisKnauf/select"
gem.homepage = "http://github.com/DenisKnauf/select" gem.authors = ["Denis Knauf"]
gem.authors = ["Denis Knauf"] gem.files = ["README", "VERSION", "lib/**/*.rb", "test/**/*.rb"]
gem.files = %w[README.md VERSION lib/**/*.rb test/**/*.rb] gem.require_paths = ["lib"]
gem.require_paths = %w[lib] end
end Jeweler::GemcutterTasks.new
Jeweler::GemcutterTasks.new
rescue LoadError rescue LoadError
puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler" puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
end end
require 'rake/testtask' require 'rake/testtask'
Rake::TestTask.new(:test) do |test| Rake::TestTask.new(:test) do |test|
test.libs << 'lib' << 'test' << 'ext' test.libs << 'lib' << 'test' << 'ext'
test.pattern = 'test/**/*_test.rb' test.pattern = 'test/**/*_test.rb'
test.verbose = true test.verbose = true
end end
begin begin
require 'rcov/rcovtask' require 'rcov/rcovtask'
Rcov::RcovTask.new do |test| Rcov::RcovTask.new do |test|
test.libs << 'test' test.libs << 'test'
test.pattern = 'test/**/*_test.rb' test.pattern = 'test/**/*_test.rb'
test.verbose = true test.verbose = true
end end
rescue LoadError rescue LoadError
task :rcov do task :rcov do
abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov" abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
end end
end end
task :test => :check_dependencies task :test => :check_dependencies
task :default => :test task :default => :test
require 'rdoc/task' require 'rake/rdoctask'
Rake::RDocTask.new do |rdoc| Rake::RDocTask.new do |rdoc|
if File.exist?('VERSION') if File.exist?('VERSION')
version = File.read('VERSION') version = File.read('VERSION')
else else
version = "" version = ""
end end
rdoc.rdoc_dir = 'rdoc' rdoc.rdoc_dir = 'rdoc'
rdoc.title = "select #{version}" rdoc.title = "sbdb #{version}"
rdoc.rdoc_files.include('README*') rdoc.rdoc_files.include('README*')
rdoc.rdoc_files.include('lib/**/*.rb') rdoc.rdoc_files.include('lib/**/*.rb')
end end

222
lib/select.rb
View file

@ -1,205 +1,89 @@
# IO-Management
# Fires if IO is ready a given block.
#
# Select.open do |sel|
# sock = TCPSocket.new 'localhost', 8090
# buffer = ''
#
# sel.on_read serv do |sock|
# buffer << sock.sysread
# end
#
# sel.on_write STDOUT do |sock|
# return if buffer.empty?
# written = sock.syswrite buffer
# buffer = buffer[written..-1]
# end
#
# sel.on_error sock do |sock|
# sel.close
# end
# end
class Select class Select
READ, WRITE, ERROR = 1, 2, 3 READ, WRITE, ERROR = 1, 2, 3
attr_reader :read, :write, :error attr_reader :read, :write, :error
attr_accessor :exit, :exit_on_empty attr_accessor :exit, :exit_on_empty
# There are no events to wait?
def empty? def empty?
@read.empty? && @write.empty? && @error.empty? @read.empty? && @write.empty? && @error.empty?
end end
class <<self def self.new *p, &e
# Creates a new Select-instance. r = super *p
# If you use a block, Select will close all IOs on end. if e
def self.new *args, &exe e.call r
r = super *args r.close
if exe else r
yield r
r.close
else r
end
end end
alias open new
end end
def initialize timeout = 30 def initialize timeout = 30
@read, @write, @error, @times = {}, {}, {}, [] @read, @write, @error = {}, {}, {}
@read.default = @write.default = @error.default = proc{} @read.default = @write.default = @error.default = lambda{}
@timeout, @tevent, @exit, @exit_on_empty = timeout, proc{}, false, true @timeout, @tevent, @exit = timeout, lambda{}, false
@pause = {read: {}, write: {}, error: {}}
end end
def timeout timeout = nil, &event def timeout timeout = nil, &event
return @timeout if timeout.nil? return @timeout if timeout.nil?
raise ArgumentError, "Numeric value expected, not: '#{timeout}'" unless Numeric === timeout raise ArgumentError, "Numeric value expected, not: '#{timeout}'" unless timeout.kind_of? Numeric
@timeout = timeout @timeout = timeout
@tevent = event if event @tevent = event if event
timeout timeout
end end
def set io, type = :read, &event def set hook, type = :read, &event
#raise ArgumentError, "This io isn't supported: '#{io.inspect}'" unless IO === io raise ArgumentError, "This hook isn't supported: '#{hook.inspect}'" unless hook.kind_of? IO
#raise ArgumentError, "Unexpected Event: '#{event.inspect}'" unless Proc === event raise ArgumentError, "Unexpected Event: '#{event.inspect}'" unless event.kind_of? Proc
case type case type
when READ, :read then @read[ io] = event when READ, :read then @read[ hook] = event
when WRITE, :write then @write[ io] = event when WRITE, :write then @write[ hook] = event
when ERROR, :error then @error[ io] = event when ERROR, :error then @error[ hook] = event
when nil, :all when nil
@read[ io] = event @read[ hook] = event
@write[ io] = event @write[ hook] = event
@error[ io] = event @error[ hook] = event
else else raise ArgumentError, "Unknown event-type: '#{type}'"
raise ArgumentError, "Unknown event-type: '#{type}'"
end end
end end
alias on set
def pause io, type = :read def del hook, type = nil
case type case type
when READ, :read then @pause[ :read][ io] = @read.delete io when READ, :read then @read.delete hook
when WRITE, :write then @pause[ :write][ io] = @write.delete io when WRITE, :write then @write.delete hook
when ERROR, :error then @pause[ :error][ io] = @error.delete io when ERROR, :error then @error.delete hook
when nil, :all when nil
@pause[ :read][ io] = @read.delete io @read.delete hook
@pause[ :write][ io] = @write.delete io @write.delete hook
@pause[ :error][ io] = @error.delete io @error.delete hook
else else raise ArgumentError, "Unknown event-type: '#{type}'"
raise ArgumentError, "Unknown event-type: '#{type}'"
end end
end end
def unpause io, type = :read def read_set( hook, &event) self.set hook, :read, &event end
case type def write_set( hook, &event) self.set hook, :write, &event end
when READ, :read then @read[ io] = @pause[ :read].delete io def error_set( hook, &event) self.set hook, :error, &event end
when WRITE, :write then @write[ io] = @pause[ :write].delete io def read_del( hook) @read.delete hook end
when ERROR, :error then @error[ io] = @pause[ :error].delete io def write_del( hook) @write.delete hook end
when nil, :all def error_del( hook) @error.delete hook end
@read[ io] = @pause[ :read].delete io
@write[ io] = @pause[ :write].delete io
@error[ io] = @pause[ :error].delete io
else
raise ArgumentError, "Unknown event-type: '#{type}'"
end
end
# Removes object from notification. def run_once timeout = @timeout
# If type is read/write/error, only this, else all.
def del io, type = nil
case type
when READ, :read then @read.delete io
when WRITE, :write then @write.delete io
when ERROR, :error then @error.delete io
when nil, :all
@read.delete io
@write.delete io
@error.delete io
else
raise ArgumentError, "Unknown event-type: '#{type}'"
end
end
alias off del
def read_set( io, &event) self.set io, :read, &event end
def write_set( io, &event) self.set io, :write, &event end
def error_set( io, &event) self.set io, :error, &event end
def read_del( io) @read.delete io end
def write_del( io) @write.delete io end
def error_del( io) @error.delete io end
alias on_read read_set
alias on_write write_set
alias on_error error_set
alias off_read read_del
alias off_write write_del
alias off_error error_del
# only once this will be fired
def one io, type = :read, &exe
on io, type do |*args|
off io, type
yield *args
end
end
# Runs once.
# Every ready disposed to read/write or has an error, will be fired.
def run_once timeout = nil
timeout ||= @timeout
r, w, e = Kernel.select( @read.keys, @write.keys, @error.keys, timeout) r, w, e = Kernel.select( @read.keys, @write.keys, @error.keys, timeout)
r and r.each {|h| @read[ h].call h, :read } return @tevent.call unless r or w or e
w and w.each {|h| @write[ h].call h, :write } r.each {|h| @read[ h].call h, :read }
e and e.each {|h| @error[ h].call h, :error } w.each {|h| @write[ h].call h, :write }
e.each {|h| @error[ h].call h, :error }
end end
# Runs in a loop
def run &e def run &e
if e if e
until @exit || (@exit_on_empty && empty?) until @exit || (@exit_on_empty && self.empty?)
cron self.run_once
self.run_once 1
e.call e.call
end end
else else
until @exit || (@exit_on_empty && empty?) self.run_once until @exit || (@exit_on_empty && self.empty?)
cron
self.run_once 1
end
end end
end end
attr_reader :times
def cron
@times.each do |e|
return if e > Time.now
e.call
@times.shift
end
end
class Entry < Time
attr_reader :do
def do &e
@do = e
end
def call *p
@do.call *p
end
def self.new *a, &e
x = self.at *a
x.do &e
x
end
end
def at a, &e
a = Entry.new a, &e if e
@times << a
@times.sort!
end
end end
class Select::Buffer <String class Select::Buffer <String
@ -233,11 +117,11 @@ class Select::Socket
@select.error_set @sock, &method( :event_error) @select.error_set @sock, &method( :event_error)
end end
def init sock: , delimiter: nil, select: nil, bufsize: nil, parent: nil def init opts
@sock = sock @select = opts[ :select] || Select.new
@select = select || Select.new @sock = opts[ :sock] || raise( ArgumentError, "need sock")
@bufsize = bufsize || 4096 @bufsize = opts[ :bufsize] || 4096
@parent = parent || nil @parent = opts[ :parent] || nil
self.delimiter = opts[ :delimiter] || $/ self.delimiter = opts[ :delimiter] || $/
@linebuf, @writebuf = Select::Buffer.new(""), Select::Buffer.new("") @linebuf, @writebuf = Select::Buffer.new(""), Select::Buffer.new("")
end end
@ -323,10 +207,10 @@ class Select::Server
select.read_set @sock, &self.method( :event_conn) select.read_set @sock, &self.method( :event_conn)
end end
def init sock: , select: nil, clientclass: nil def init opts
@sock = sock @sock = opts[ :sock] || raise( ArgumentError, "need sock")
@select = select || Select.new @select = opts[ :select] || Select.new
@clientclass = clientclass || Select::Socket @clientclass = opts[ :clientclass] || Select::Socket
@clients = [] @clients = []
end end