eventmachine 1.0.0.beta.3-java → 1.0.0.beta.4-java

data/ext/em.h

@@ -43,6 +43,15 @@ See the file COPYING for complete licensing information.
   #ifndef RUBY_UBF_IO
     #define RUBY_UBF_IO RB_UBF_DFL
   #endif
+  #ifndef RSTRING_PTR
+    #define RSTRING_PTR(str) RString(str)->ptr
+  #endif
+  #ifndef RSTRING_LEN
+    #define RSTRING_LEN(str) RString(str)->len
+  #endif
+  #ifndef RSTRING_LENINT
+    #define RSTRING_LENINT(str) RSTRING_LEN(str)
+  #endif
 #else
   #define EmSelect select
 #endif
@@ -81,6 +90,7 @@ class EventMachine_t
 
 		void Add (EventableDescriptor*);
 		void Modify (EventableDescriptor*);
+		void Deregister (EventableDescriptor*);
 
 		const unsigned long AttachFD (int, bool);
 		int DetachFD (EventableDescriptor*);
@@ -126,13 +136,13 @@ class EventMachine_t
 		bool UsingEpoll() { return bEpoll; }
 
 		void QueueHeartbeat(EventableDescriptor*);
-		void ClearHeartbeat(uint64_t);
+		void ClearHeartbeat(uint64_t, EventableDescriptor*);
 
 		uint64_t GetRealTime();
 
 	private:
 		bool _RunOnce();
-		bool _RunTimers();
+		void _RunTimers();
 		void _UpdateTime();
 		void _AddNewDescriptors();
 		void _ModifyDescriptors();

data/ext/extconf.rb

@@ -76,7 +76,7 @@ have_func('rb_time_new')
 # Minor platform details between *nix and Windows:
 
 if RUBY_PLATFORM =~ /(mswin|mingw|bccwin)/
-  GNU_CHAIN = $1 == 'mingw'
+  GNU_CHAIN = ENV['CROSS_COMPILING'] or $1 == 'mingw'
   OS_WIN32 = true
   add_define "OS_WIN32"
 else
@@ -92,7 +92,7 @@ end
 case RUBY_PLATFORM
 when /mswin32/, /mingw32/, /bccwin32/
   check_heads(%w[windows.h winsock.h], true)
-  check_libs(%w[kernel32 rpcrt4 gdi32], true)
+  check_libs(%w[kernel32 rpcrt4 gdi32], true) unless ENV['CROSS_COMPILING']
 
   if GNU_CHAIN
     CONFIG['LDSHARED'] = "$(CXX) -shared -lstdc++"
@@ -154,4 +154,4 @@ add_define 'HAVE_MAKE_PAIR' if try_link(<<SRC, '-lstdc++')
 SRC
 TRY_LINK.sub!('$(CXX)', '$(CC)')
 
-create_makefile "rubyeventmachine"
+create_makefile "rubyeventmachine"

data/ext/pipe.cpp

@@ -282,7 +282,7 @@ bool PipeDescriptor::SelectForRead()
 	 * a pending state, so this is simpler than for the
 	 * ConnectionDescriptor object.
 	 */
-	return true;
+	return bPaused ? false : true;
 }
 
 /******************************
@@ -295,7 +295,7 @@ bool PipeDescriptor::SelectForWrite()
 	 * a pending state, so this is simpler than for the
 	 * ConnectionDescriptor object.
 	 */
-	return (GetOutboundDataSize() > 0);
+	return (GetOutboundDataSize() > 0) && !bPaused ? true : false;
 }
 
 

data/ext/project.h

@@ -96,7 +96,7 @@ typedef int socklen_t;
 typedef int pid_t;
 #endif
 
-#if !defined(_MSC_VER) || _MSC_VER > 1400
+#if !defined(_MSC_VER) || _MSC_VER > 1500
 #include <stdint.h>
 #endif
 

data/ext/rubymain.cpp

@@ -95,9 +95,13 @@ static inline void event_callback (struct em_event* e)
 			return;
 		}
 		case EM_CONNECTION_ACCEPTED:
+		{
+			rb_funcall (EmModule, Intern_event_callback, 3, ULONG2NUM(signature), INT2FIX(event), ULONG2NUM(data_num));
+			return;
+		}
 		case EM_CONNECTION_UNBOUND:
 		{
-			rb_funcall (EmModule, Intern_event_callback, 3, ULONG2NUM(signature), INT2FIX(event), data_str ? rb_str_new(data_str,data_num) : ULONG2NUM(data_num));
+			rb_funcall (EmModule, Intern_event_callback, 3, ULONG2NUM(signature), INT2FIX(event), ULONG2NUM(data_num));
 			return;
 		}
 		case EM_CONNECTION_COMPLETED:
@@ -426,8 +430,9 @@ t_set_comm_inactivity_timeout
 static VALUE t_set_comm_inactivity_timeout (VALUE self, VALUE signature, VALUE timeout)
 {
 	float ti = RFLOAT_VALUE(timeout);
-	if (evma_set_comm_inactivity_timeout (NUM2ULONG (signature), ti));
+	if (evma_set_comm_inactivity_timeout(NUM2ULONG(signature), ti)) {
 		return Qtrue;
+	}
 	return Qfalse;
 }
 
@@ -447,8 +452,9 @@ t_set_pending_connect_timeout
 static VALUE t_set_pending_connect_timeout (VALUE self, VALUE signature, VALUE timeout)
 {
 	float ti = RFLOAT_VALUE(timeout);
-	if (evma_set_pending_connect_timeout (NUM2ULONG (signature), ti));
+	if (evma_set_pending_connect_timeout(NUM2ULONG(signature), ti)) {
 		return Qtrue;
+	}
 	return Qfalse;
 }
 
@@ -577,6 +583,44 @@ static VALUE t_get_sock_opt (VALUE self, VALUE signature, VALUE lev, VALUE optna
 	return rb_str_new(buf, len);
 }
 
+/**************
+t_set_sock_opt
+**************/
+
+static VALUE t_set_sock_opt (VALUE self, VALUE signature, VALUE lev, VALUE optname, VALUE optval)
+{
+	int fd = evma_get_file_descriptor (NUM2ULONG (signature));
+	int level = NUM2INT(lev), option = NUM2INT(optname);
+	int i;
+	void *v;
+	socklen_t len;
+
+	switch (TYPE(optval)) {
+	case T_FIXNUM:
+		i = FIX2INT(optval);
+		goto numval;
+	case T_FALSE:
+		i = 0;
+		goto numval;
+	case T_TRUE:
+		i = 1;
+		numval:
+		v = (void*)&i; len = sizeof(i);
+		break;
+	default:
+		StringValue(optval);
+		v = RSTRING_PTR(optval);
+		len = RSTRING_LENINT(optval);
+		break;
+	}
+
+
+	if (setsockopt(fd, level, option, (char *)v, len) < 0)
+		rb_sys_fail("setsockopt");
+
+	return INT2FIX(0);
+}
+
 /********************
 t_is_notify_readable
 ********************/
@@ -1127,6 +1171,7 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "attach_fd", (VALUE (*)(...))t_attach_fd, 2);
 	rb_define_module_function (EmModule, "detach_fd", (VALUE (*)(...))t_detach_fd, 1);
 	rb_define_module_function (EmModule, "get_sock_opt", (VALUE (*)(...))t_get_sock_opt, 3);
+	rb_define_module_function (EmModule, "set_sock_opt", (VALUE (*)(...))t_set_sock_opt, 4);
 	rb_define_module_function (EmModule, "set_notify_readable", (VALUE (*)(...))t_set_notify_readable, 2);
 	rb_define_module_function (EmModule, "set_notify_writable", (VALUE (*)(...))t_set_notify_writable, 2);
 	rb_define_module_function (EmModule, "is_notify_readable", (VALUE (*)(...))t_is_notify_readable, 1);

data/ext/ssl.cpp

@@ -159,11 +159,14 @@ SslContext_t::SslContext_t (bool is_server, const string &privkeyfile, const str
 			e = SSL_CTX_use_PrivateKey_file (pCtx, privkeyfile.c_str(), SSL_FILETYPE_PEM);
 		else
 			e = SSL_CTX_use_PrivateKey (pCtx, DefaultPrivateKey);
+		if (e <= 0) ERR_print_errors_fp(stderr);
 		assert (e > 0);
+
 		if (certchainfile.length() > 0)
 			e = SSL_CTX_use_certificate_chain_file (pCtx, certchainfile.c_str());
 		else
 			e = SSL_CTX_use_certificate (pCtx, DefaultCertificate);
+		if (e <= 0) ERR_print_errors_fp(stderr);
 		assert (e > 0);
 	}
 
@@ -177,10 +180,12 @@ SslContext_t::SslContext_t (bool is_server, const string &privkeyfile, const str
 		int e;
 		if (privkeyfile.length() > 0) {
 			e = SSL_CTX_use_PrivateKey_file (pCtx, privkeyfile.c_str(), SSL_FILETYPE_PEM);
+			if (e <= 0) ERR_print_errors_fp(stderr);
 			assert (e > 0);
 		}
 		if (certchainfile.length() > 0) {
 			e = SSL_CTX_use_certificate_chain_file (pCtx, certchainfile.c_str());
+			if (e <= 0) ERR_print_errors_fp(stderr);
 			assert (e > 0);
 		}
 	}

data/java/src/com/rubyeventmachine/EmReactor.java

@@ -442,8 +442,8 @@ public class EmReactor {
 		Connections.get(sig).setCommInactivityTimeout (mills);
 	}
 
-	public void sendDatagram (long sig, String data, int length, String recipAddress, int recipPort) {
-		sendDatagram (sig, ByteBuffer.wrap(data.getBytes()), recipAddress, recipPort);
+	public void sendDatagram (long sig, byte[] data, int length, String recipAddress, int recipPort) {
+		sendDatagram (sig, ByteBuffer.wrap(data), recipAddress, recipPort);
 	}
 
 	public void sendDatagram (long sig, ByteBuffer bb, String recipAddress, int recipPort) {

data/lib/em/buftok.rb

@@ -1,43 +1,29 @@
-# BufferedTokenizer - Statefully split input data by a specifiable token
-#
-# Authors:: Tony Arcieri, Martin Emde
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Tony Arcieri and Martin Emde
-# 
-# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
-#
-#---------------------------------------------------------------------------
-#
-
-# (C)2006 Tony Arcieri, Martin Emde
-# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
-
 # BufferedTokenizer takes a delimiter upon instantiation, or acts line-based
 # by default.  It allows input to be spoon-fed from some outside source which
 # receives arbitrary length datagrams which may-or-may-not contain the token
 # by which entities are delimited.
 #
-# Commonly used to parse lines out of incoming data:
+# By default, new BufferedTokenizers will operate on lines delimited by "\n" by default
+# or allow you to specify any delimiter token you so choose, which will then
+# be used by String#split to tokenize the input data
 #
-#  module LineBufferedConnection
-#    def receive_data(data)
-#      (@buffer ||= BufferedTokenizer.new).extract(data).each do |line|
-#        receive_line(line)
-#      end
-#    end
-#  end
-
+# @example Using BufferedTokernizer to parse lines out of incoming data
+#
+#   module LineBufferedConnection
+#     def receive_data(data)
+#       (@buffer ||= BufferedTokenizer.new).extract(data).each do |line|
+#         receive_line(line)
+#       end
+#     end
+#   end
+#
+# @author Tony Arcieri
+# @author Martin Emde
 class BufferedTokenizer
-  # New BufferedTokenizers will operate on lines delimited by "\n" by default
-  # or allow you to specify any delimiter token you so choose, which will then
-  # be used by String#split to tokenize the input data
+  # @param [String] delimiter
+  # @param [Integer] size_limit
   def initialize(delimiter = "\n", size_limit = nil)
-    # Store the specified delimiter
-    @delimiter = delimiter
-
-    # Store the specified size limitation
+    @delimiter  = delimiter
     @size_limit = size_limit
 
     # The input buffer is stored as an array.  This is by far the most efficient
@@ -52,14 +38,18 @@ class BufferedTokenizer
   end
 
   # Extract takes an arbitrary string of input data and returns an array of
-  # tokenized entities, provided there were any available to extract.  This
-  # makes for easy processing of datagrams using a pattern like:
+  # tokenized entities, provided there were any available to extract.
   #
-  #   tokenizer.extract(data).map { |entity| Decode(entity) }.each do ...
+  # @example
+  #
+  #   tokenizer.extract(data).
+  #     map { |entity| Decode(entity) }.each { ... }
+  #
+  # @param [String] data
   def extract(data)
     # Extract token-delimited entities from the input string with the split command.
     # There's a bit of craftiness here with the -1 parameter.  Normally split would
-    # behave no differently regardless of if the token lies at the very end of the 
+    # behave no differently regardless of if the token lies at the very end of the
     # input buffer or not (i.e. a literal edge case)  Specifying -1 forces split to
     # return "" in this case, meaning that the last entry in the list represents a
     # new segment of data where the token has not been encountered
@@ -70,7 +60,7 @@ class BufferedTokenizer
       raise 'input buffer full' if @input_size + entities.first.size > @size_limit
       @input_size += entities.first.size
     end
-    
+
     # Move the first entry in the resulting array into the input buffer.  It represents
     # the last segment of a token-delimited entity unless it's the only entry in the list.
     @input << entities.shift
@@ -85,36 +75,16 @@ class BufferedTokenizer
     # and add it to our list of discovered entities.
     entities.unshift @input.join
 
-=begin
-    # Note added by FC, 10Jul07. This paragraph contains a regression. It breaks
-    # empty tokens. Think of the empty line that delimits an HTTP header. It will have
-    # two "\n" delimiters in a row, and this code mishandles the resulting empty token.
-    # It someone figures out how to fix the problem, we can re-enable this code branch.
-    # Multi-character token support.
-    # Split any tokens that were incomplete on the last iteration buf complete now.
-    entities.map! do |e|
-      e.split @delimiter, -1
-    end
-    # Flatten the resulting array.  This has the side effect of removing the empty
-    # entry at the end that was produced by passing -1 to split.  Add it again if
-    # necessary.
-    if (entities[-1] == [])
-      entities.flatten! << []
-    else
-      entities.flatten!
-    end
-=end
-
     # Now that we've hit a token, joined the input buffer and added it to the entities
     # list, we can go ahead and clear the input buffer.  All of the segments that were
     # stored before the join can now be garbage collected.
     @input.clear
-    
+
     # The last entity in the list is not token delimited, however, thanks to the -1
-    # passed to split.  It represents the beginning of a new list of as-yet-untokenized  
+    # passed to split.  It represents the beginning of a new list of as-yet-untokenized
     # data, so we add it to the start of the list.
     @input << entities.pop
-    
+
     # Set the new input buffer size, provided we're keeping track
     @input_size = @input.first.size if @size_limit
 
@@ -122,16 +92,18 @@ class BufferedTokenizer
     # in the first place.  Hooray!
     entities
   end
-  
+
   # Flush the contents of the input buffer, i.e. return the input buffer even though
-  # a token has not yet been encountered
+  # a token has not yet been encountered.
+  #
+  # @return [String]
   def flush
     buffer = @input.join
     @input.clear
     buffer
   end
 
-  # Is the buffer empty?
+  # @return [Boolean]
   def empty?
     @input.empty?
   end

data/lib/em/callback.rb

@@ -1,26 +1,58 @@
 module EventMachine
-  # Utility method for coercing arguments to an object that responds to #call
+  # Utility method for coercing arguments to an object that responds to :call.
   # Accepts an object and a method name to send to, or a block, or an object
-  # that responds to call.
+  # that responds to :call.
   #
-  #  cb = EM.Callback{ |msg| puts(msg) }
+  # @example EventMachine.Callback used with a block. Returns that block.
+  #
+  #  cb = EventMachine.Callback do |msg|
+  #    puts(msg)
+  #  end
+  #  # returned object is a callable
   #  cb.call('hello world')
   #
-  #  cb = EM.Callback(Object, :puts)
+  #
+  # @example EventMachine.Callback used with an object (to be more specific, class object) and a method name, returns an object that responds to #call
+  #
+  #  cb = EventMachine.Callback(Object, :puts)
+  #  # returned object is a callable that delegates to Kernel#puts (in this case Object.puts)
   #  cb.call('hello world')
   #
-  #  cb = EM.Callback(proc{ |msg| puts(msg) })
+  #
+  # @example EventMachine.Callback used with an object that responds to #call. Returns the argument.
+  #
+  #  cb = EventMachine.Callback(proc{ |msg| puts(msg) })
+  #  # returned object is a callable
   #  cb.call('hello world')
   #
+  #
+  # @overload Callback(object, method)
+  #   Wraps `method` invocation on `object` into an object that responds to #call that proxies all the arguments to that method
+  #   @param [Object] Object to invoke method on
+  #   @param [Symbol] Method name
+  #   @return [<#call>] An object that responds to #call that takes any number of arguments and invokes method on object with those arguments
+  #
+  # @overload Callback(object)
+  #   Returns callable object as is, without any coercion
+  #   @param [<#call>] An object that responds to #call
+  #   @return [<#call>] Its argument
+  #
+  # @overload Callback(&block)
+  #   Returns block passed to it without any coercion
+  #   @return [<#call>] Block passed to this method
+  #
+  # @raise [ArgumentError] When argument doesn't respond to #call, method name is missing or when invoked without arguments and block isn't given
+  #
+  # @return [<#call>]
   def self.Callback(object = nil, method = nil, &blk)
     if object && method
-      lambda { |*args| object.send method, *args }
+      lambda { |*args| object.__send__ method, *args }
     else
       if object.respond_to? :call
         object
-      else 
+      else
         blk || raise(ArgumentError)
-      end
-    end
-  end
-end
+      end # if
+    end # if
+  end # self.Callback
+end # EventMachine

data/lib/em/channel.rb

@@ -1,33 +1,38 @@
 module EventMachine
-  # Provides a simple interface to push items to a number of subscribers. The
-  # channel will schedule all operations on the main reactor thread for thread
-  # safe reactor operations.
+  # Provides a simple thread-safe way to transfer data between (typically) long running
+  # tasks in {EventMachine.defer} and event loop thread.
   #
-  # This provides a convenient way for connections to consume messages from 
-  # long running code in defer, without threading issues.
+  # @example
+  #
+  #  channel = EventMachine::Channel.new
+  #  sid     = channel.subscribe { |msg| p [:got, msg] }
   #
-  #  channel = EM::Channel.new
-  #  sid = channel.subscribe{ |msg| p [:got, msg] }
   #  channel.push('hello world')
   #  channel.unsubscribe(sid)
   #
-  # See examples/ex_channel.rb for a detailed example.
+  #
   class Channel
-    # Create a new channel
     def initialize
       @subs = {}
-      @uid = 0
+      @uid  = 0
     end
 
     # Takes any arguments suitable for EM::Callback() and returns a subscriber
     # id for use when unsubscribing.
+    #
+    # @return [Integer] Subscribe identifier
+    # @see #unsubscribe
     def subscribe(*a, &b)
       name = gen_id
       EM.schedule { @subs[name] = EM::Callback(*a, &b) }
+
       name
     end
 
-    # Removes this subscriber from the list.
+    # Removes subscriber from the list.
+    #
+    # @param [Integer] Subscriber identifier
+    # @see #subscribe
     def unsubscribe(name)
       EM.schedule { @subs.delete name }
     end
@@ -39,7 +44,7 @@ module EventMachine
     end
     alias << push
 
-    # Receive exactly one message from the channel.
+    # Fetches one message from the channel.
     def pop(*a, &b)
       EM.schedule {
         name = subscribe do |*args|
@@ -50,8 +55,10 @@ module EventMachine
     end
 
     private
-    def gen_id # :nodoc:
+
+    # @private
+    def gen_id
       @uid += 1
     end
   end
-end
+end