eventmachine 1.0.5-java → 1.0.6-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 909d153b45cd30ecad7ef4f2b91009aa978b70eb
-  data.tar.gz: 493058213b19e7b4d32c51e72b15a54f2832d1e6
+  metadata.gz: 4722f24a61f13ac737b777597b71542a5ea1b0bd
+  data.tar.gz: 2bc74d2fe5b8de6e467faeae30916f4cb1a71ddf
 SHA512:
-  metadata.gz: 342e305aa3bd8792f115e6c7c1795f3fe482e11d92a1195b7346ff6c2d20c98b1c9462d0a26030d9e1d350682140a79db199c470b4b8fe6cca492b8e7059943d
-  data.tar.gz: 23c2852e6fcfd419eb5dec0ce005a515b7561cfe75b417d2f93d02817992fc4345b8cc3beff619adea9e7f80656de2180bdc24d5b56a5192293f1a1ebb329a5f
+  metadata.gz: f2d16977dff27530edcd046a5503f7597a5f5859576592dc0b8e2f826f9cac227309b0f2fadf87c65348520257ea7f78a34f4f2c892f72876c31181df7b3487b
+  data.tar.gz: bdb3a2a7bcf18f803f8e002637b1809a2691e84025bb19ab3e319d82d13e21f39ab35ce1c96a865848e26ba586cc8dbd9be8e880a1bdbdd924498b7df73fdeff

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.0.6 (February 3, 2015)
+* add support for Rubinius Process::Status [#568]
+* small bugfixes for SmtpServer [#449]
+* update buftok.rb [#547]
+* fix assertion on Write() [#525]
+* work around mkmf.rb bug preventing gem installation [#574]
+* add pause/resume support to jruby reactor [#556]
+* fix pure ruby reactor to use 127.0.0.1 instead of localhost [#439]
+* fix compilation under macruby [#243]
+* add chunked encoding to http client [#111]
+* fix errors on win32 when dealing with pipes [1ea45498] [#105]
+
 ## 1.0.5 (February 2, 2015)
 * use monotonic clocks on Linux, OS X, Solaris, and Windows [#563]
 * use the rb_fd_* API to get autosized fd_sets [#502]

data/README.md

@@ -105,5 +105,4 @@ Copyright: (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
 
 ## Alternatives ##
 
-If you are unhappy with EventMachine and want to use Ruby, check out [Cool.io](http://coolio.github.com/).
-One caveat: by May 2011, it did not support JRuby and Windows.
+If you are unhappy with EventMachine and want to use Ruby, check out [Celluloid](https://celluloid.io/).

data/ext/em.cpp

@@ -938,7 +938,8 @@ void EventMachine_t::_RunSelectOnce()
 		/* 21Sep09: on windows, a non-blocking connect() that fails does not come up as writable.
 		   Instead, it is added to the error set. See http://www.mail-archive.com/openssl-users@openssl.org/msg58500.html
 		*/
-		rb_fd_set (sd, &(SelectData.fderrors));
+		if (ed->IsConnectPending())
+			rb_fd_set (sd, &(SelectData.fderrors));
 		#endif
 
 		if (SelectData.maxsocket < sd)
@@ -973,8 +974,12 @@ void EventMachine_t::_RunSelectOnce()
 					continue;
 				assert (sd != INVALID_SOCKET);
 
-				if (rb_fd_isset (sd, &(SelectData.fdwrites)))
-					ed->Write();
+				if (rb_fd_isset (sd, &(SelectData.fdwrites))) {
+					// Double-check SelectForWrite() still returns true. If not, one of the callbacks must have
+					// modified some value since we checked SelectForWrite() earlier in this method.
+					if (ed->SelectForWrite())
+						ed->Write();
+				}
 				if (rb_fd_isset (sd, &(SelectData.fdreads)))
 					ed->Read();
 				if (rb_fd_isset (sd, &(SelectData.fderrors)))

data/ext/extconf.rb

@@ -39,6 +39,9 @@ def manual_ssl_config
   check_libs(libs) and check_heads(heads)
 end
 
+# Eager check devs tools
+have_devel? if respond_to?(:have_devel?)
+
 if ENV['CROSS_COMPILING']
   openssl_version = ENV.fetch("OPENSSL_VERSION", "1.0.1i")
   openssl_dir = File.expand_path("~/.rake-compiler/builds/openssl-#{openssl_version}/")

data/ext/fastfilereader/extconf.rb

@@ -12,6 +12,9 @@ def add_define(name)
   $defs.push("-D#{name}")
 end
 
+# Eager check devs tools
+have_devel? if respond_to?(:have_devel?)
+
 add_define 'BUILD_FOR_RUBY'
 
 # Minor platform details between *nix and Windows:

data/ext/rubymain.cpp

@@ -408,8 +408,22 @@ static VALUE t_get_subprocess_status (VALUE self, VALUE signature)
 	if (evma_get_subprocess_status (NUM2ULONG (signature), &status)) {
 		if (evma_get_subprocess_pid (NUM2ULONG (signature), &pid)) {
 			proc_status = rb_obj_alloc(rb_cProcStatus);
+
+			/* MRI Ruby uses hidden instance vars */
 			rb_iv_set(proc_status, "status", INT2FIX(status));
 			rb_iv_set(proc_status, "pid", INT2FIX(pid));
+
+#ifdef RUBINIUS
+			/* Rubinius uses standard instance vars */
+			rb_iv_set(proc_status, "@pid", INT2FIX(pid));
+			if (WIFEXITED(status)) {
+				rb_iv_set(proc_status, "@status", INT2FIX(WEXITSTATUS(status)));
+			} else if(WIFSIGNALED(status)) {
+				rb_iv_set(proc_status, "@termsig", INT2FIX(WTERMSIG(status)));
+			} else if(WIFSTOPPED(status)){
+				rb_iv_set(proc_status, "@stopsig", INT2FIX(WSTOPSIG(status)));
+			}
+#endif
 		}
 	}
 
@@ -611,7 +625,7 @@ static VALUE t_set_sock_opt (VALUE self, VALUE signature, VALUE lev, VALUE optna
 	int fd = evma_get_file_descriptor (NUM2ULONG (signature));
 	int level = NUM2INT(lev), option = NUM2INT(optname);
 	int i;
-	void *v;
+	const void *v;
 	socklen_t len;
 
 	switch (TYPE(optval)) {

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

@@ -569,6 +569,22 @@ public class EmReactor {
 		return Connections.get(sig).isNotifyWritable();
 	}
 
+	public boolean pauseConnection (long sig) {
+		return ((EventableSocketChannel) Connections.get(sig)).pause();
+	}
+	
+	public boolean resumeConnection (long sig) {
+		return ((EventableSocketChannel) Connections.get(sig)).resume();
+	}
+
+	public boolean isConnectionPaused (long sig) {
+		return ((EventableSocketChannel) Connections.get(sig)).isPaused();
+	}
+
+	public long getOutboundDataSize (long sig) {
+		return Connections.get(sig).getOutboundDataSize();
+	}
+	
 	public int getConnectionCount() {
 	  return Connections.size() + Acceptors.size();
 	}

data/java/src/com/rubyeventmachine/EventableChannel.java

@@ -57,6 +57,8 @@ public interface EventableChannel {
 	
 	public boolean writeOutboundData() throws IOException;
 
+	public long getOutboundDataSize();
+
 	public void setCommInactivityTimeout (long seconds);
 
 	public Object[] getPeerName();

data/java/src/com/rubyeventmachine/EventableDatagramChannel.java

@@ -54,6 +54,7 @@ public class EventableDatagramChannel implements EventableChannel {
 	Selector selector;
 	boolean bCloseScheduled;
 	LinkedList<Packet> outboundQ;
+	long outboundS;
 	SocketAddress returnAddress;
 	
 
@@ -63,6 +64,7 @@ public class EventableDatagramChannel implements EventableChannel {
 		selector = sel;
 		bCloseScheduled = false;
 		outboundQ = new LinkedList<Packet>();
+		outboundS = 0;
 		
 		dc.register(selector, SelectionKey.OP_READ, this);
 	}
@@ -71,6 +73,7 @@ public class EventableDatagramChannel implements EventableChannel {
  		try {
 			if ((!bCloseScheduled) && (bb.remaining() > 0)) {
 				outboundQ.addLast(new Packet(bb, returnAddress));
+				outboundS += bb.remaining();
  				channel.register(selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ, this);
 			}
 		} catch (ClosedChannelException e) {
@@ -82,6 +85,7 @@ public class EventableDatagramChannel implements EventableChannel {
  		try {
 			if ((!bCloseScheduled) && (bb.remaining() > 0)) {
 				outboundQ.addLast(new Packet (bb, new InetSocketAddress (recipAddress, recipPort)));
+				outboundS += bb.remaining();
  				channel.register(selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ, this);
 			}
 		} catch (ClosedChannelException e) {
@@ -136,6 +140,7 @@ public class EventableDatagramChannel implements EventableChannel {
 			try {
 				// With a datagram socket, it's ok to send an empty buffer.
 				written = channel.send(p.bb, p.recipient);
+				outboundS -= written;
 			}
 			catch (IOException e) {
 				return false;
@@ -192,4 +197,5 @@ public class EventableDatagramChannel implements EventableChannel {
 	public boolean isWatchOnly() { return false; }
 	public boolean isNotifyReadable() { return false; }
 	public boolean isNotifyWritable() { return false; }
+	public long getOutboundDataSize() { return outboundS; }
 }

data/java/src/com/rubyeventmachine/EventableSocketChannel.java

@@ -54,6 +54,7 @@ public class EventableSocketChannel implements EventableChannel {
 
 	long binding;
 	LinkedList<ByteBuffer> outboundQ;
+	long outboundS;
 
 	boolean bCloseScheduled;
 	boolean bConnectPending;
@@ -61,6 +62,7 @@ public class EventableSocketChannel implements EventableChannel {
 	boolean bAttached;
 	boolean bNotifyReadable;
 	boolean bNotifyWritable;
+	boolean bPaused;
 	
 	SSLEngine sslEngine;
 	SSLContext sslContext;
@@ -76,6 +78,7 @@ public class EventableSocketChannel implements EventableChannel {
 		bNotifyReadable = false;
 		bNotifyWritable = false;
 		outboundQ = new LinkedList<ByteBuffer>();
+		outboundS = 0;
 	}
 	
 	public long getBinding() {
@@ -164,12 +167,14 @@ public class EventableSocketChannel implements EventableChannel {
 					sslEngine.wrap(bb, b);
 					b.flip();
 					outboundQ.addLast(b);
+					outboundS += b.remaining();
 				} catch (SSLException e) {
 					throw new RuntimeException ("ssl error");
 				}
 			}
 			else {
 				outboundQ.addLast(bb);
+				outboundS += bb.remaining();
 			}
 
 			updateEvents();
@@ -188,6 +193,8 @@ public class EventableSocketChannel implements EventableChannel {
 			throw new IOException ("eof");
 	}
 
+	public long getOutboundDataSize() { return outboundS; }
+
 	/**
 	 * Called by the reactor when we have selected writable.
 	 * Return false to indicate an error that should cause the connection to close.
@@ -196,23 +203,35 @@ public class EventableSocketChannel implements EventableChannel {
 	 * this code is written, we're depending on a nonblocking write NOT TO CONSUME
 	 * the whole outbound buffer in this case, rather than firing an exception.
 	 * We should somehow verify that this is indeed Java's defined behavior.
-	 * Also TODO, see if we can use gather I/O rather than one write at a time.
-	 * Ought to be a big performance enhancer.
 	 * @return
 	 */
 	public boolean writeOutboundData() throws IOException {
+		ByteBuffer[] bufs = new ByteBuffer[64];
+		int i;
+		long written, toWrite;
 		while (!outboundQ.isEmpty()) {
-			ByteBuffer b = outboundQ.getFirst();
-			if (b.remaining() > 0)
-				channel.write(b);
+			i = 0;
+			toWrite = 0;
+			written = 0;
+			while (i < 64 && !outboundQ.isEmpty()) {
+				bufs[i] = outboundQ.removeFirst();
+				toWrite += bufs[i].remaining();
+				i++;
+			}
+			if (toWrite > 0)
+				written = channel.write(bufs, 0, i);
 
+			outboundS -= written;
 			// Did we consume the whole outbound buffer? If yes,
 			// pop it off and keep looping. If no, the outbound network
 			// buffers are full, so break out of here.
-			if (b.remaining() == 0)
-				outboundQ.removeFirst();
-			else
+			if (written < toWrite) {
+				while (i > 0 && bufs[i-1].remaining() > 0) {
+					outboundQ.addFirst(bufs[i-1]);
+					i--;
+				}
 				break;
+			}
 		}
 
 		if (outboundQ.isEmpty() && !bCloseScheduled) {
@@ -244,8 +263,10 @@ public class EventableSocketChannel implements EventableChannel {
 	
 	public boolean scheduleClose (boolean afterWriting) {
 		// TODO: What the hell happens here if bConnectPending is set?
-		if (!afterWriting)
+		if (!afterWriting) {
 			outboundQ.clear();
+			outboundS = 0;
+		}
 
 		if (outboundQ.isEmpty())
 			return true;
@@ -331,6 +352,30 @@ public class EventableSocketChannel implements EventableChannel {
 	}
 	public boolean isNotifyWritable() { return bNotifyWritable; }
 
+	public boolean pause() {
+		if (bWatchOnly) {
+			throw new RuntimeException ("cannot pause/resume 'watch only' connections, set notify readable/writable instead");
+		}
+		boolean old = bPaused;
+		bPaused = true;
+		updateEvents();
+		return !old;
+	}
+
+	public boolean resume() {
+		if (bWatchOnly) {
+			throw new RuntimeException ("cannot pause/resume 'watch only' connections, set notify readable/writable instead");
+		}
+		boolean old = bPaused;
+		bPaused = false;
+		updateEvents();
+		return old;
+	}
+
+	public boolean isPaused() {
+		return bPaused;
+	}
+
 	private void updateEvents() {
 		if (channelKey == null)
 			return;
@@ -353,7 +398,7 @@ public class EventableSocketChannel implements EventableChannel {
 			if (bNotifyWritable)
 				events |= SelectionKey.OP_WRITE;
 		}
-		else
+		else if (!bPaused)
 		{
 			if (bConnectPending)
 				events |= SelectionKey.OP_CONNECT;

data/lib/em/buftok.rb

@@ -1,110 +1,59 @@
 # 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.
-#
-# 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
-#
-# @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
+# by which entities are delimited.  In this respect it's ideally paired with
+# something like EventMachine (http://rubyeventmachine.com/).
 class BufferedTokenizer
-  # @param [String] delimiter
-  # @param [Integer] size_limit
-  def initialize(delimiter = "\n", size_limit = nil)
-    @delimiter  = delimiter
-    @size_limit = size_limit
-
-    # The input buffer is stored as an array.  This is by far the most efficient
-    # approach given language constraints (in C a linked list would be a more
-    # appropriate data structure).  Segments of input data are stored in a list
-    # which is only joined when a token is reached, substantially reducing the
-    # number of objects required for the operation.
+  # New BufferedTokenizers will operate on lines delimited by a delimiter,
+  # which is by default the global input delimiter $/ ("\n").
+  #
+  # The input buffer is stored as an array.  This is by far the most efficient
+  # approach given language constraints (in C a linked list would be a more
+  # appropriate data structure).  Segments of input data are stored in a list
+  # which is only joined when a token is reached, substantially reducing the
+  # number of objects required for the operation.
+  def initialize(delimiter = $/)
+    @delimiter = delimiter
     @input = []
-
-    # Size of the input buffer
-    @input_size = 0
+    @tail = ''
+    @trim = @delimiter.length - 1
   end
 
   # Extract takes an arbitrary string of input data and returns an array of
-  # tokenized entities, provided there were any available to extract.
-  #
-  # @example
+  # tokenized entities, provided there were any available to extract.  This
+  # makes for easy processing of datagrams using a pattern like:
   #
-  #   tokenizer.extract(data).
-  #     map { |entity| Decode(entity) }.each { ... }
+  #   tokenizer.extract(data).map { |entity| Decode(entity) }.each do ...
   #
-  # @param [String] data
+  # Using -1 makes split to return "" if the token is at the end of
+  # the string, meaning the last element is the start of the next chunk.
   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
-    # 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
-    entities = data.split @delimiter, -1
-
-    # Check to see if the buffer has exceeded capacity, if we're imposing a limit
-    if @size_limit
-      raise 'input buffer full' if @input_size + entities.first.size > @size_limit
-      @input_size += entities.first.size
+    if @trim > 0
+      tail_end = @tail.slice!(-@trim, @trim) # returns nil if string is too short
+      data = tail_end + data if tail_end
     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
-
-    # If the resulting array from the split is empty, the token was not encountered
-    # (not even at the end of the buffer).  Since we've encountered no token-delimited
-    # entities this go-around, return an empty array.
-    return [] if entities.empty?
-
-    # At this point, we've hit a token, or potentially multiple tokens.  Now we can bring
-    # together all the data we've buffered from earlier calls without hitting a token,
-    # and add it to our list of discovered entities.
-    entities.unshift @input.join
+    @input << @tail
+    entities = data.split(@delimiter, -1)
+    @tail = entities.shift
 
-    # 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
-    # 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
+    unless entities.empty?
+      @input << @tail
+      entities.unshift @input.join
+      @input.clear
+      @tail = entities.pop
+    end
 
-    # Now we're left with the list of extracted token-delimited entities we wanted
-    # 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.
-  #
-  # @return [String]
+  # a token has not yet been encountered
   def flush
+    @input << @tail
     buffer = @input.join
     @input.clear
+    @tail = "" # @tail.clear is slightly faster, but not supported on 1.8.7
     buffer
   end
-
-  # @return [Boolean]
-  def empty?
-    @input.empty?
-  end
 end

data/lib/em/protocols/httpclient.rb

@@ -23,8 +23,6 @@
 #
 #
 
-
-
 module EventMachine
   module Protocols
 
@@ -52,7 +50,6 @@ module EventMachine
     # DNS: Some way to cache DNS lookups for hostnames we connect to. Ruby's
     # DNS lookups are unbelievably slow.
     # HEAD requests.
-    # Chunked transfer encoding.
     # Convenience methods for requests. get, post, url, etc.
     # SSL.
     # Handle status codes like 304, 100, etc.
@@ -191,7 +188,7 @@ module EventMachine
             if ary.length == 2
               data = ary.last
               if ary.first == ""
-                if (@content_length and @content_length > 0) || @connection_close
+                if (@content_length and @content_length > 0) || @chunked || @connection_close
                   @read_state = :content
                 else
                   dispatch_response
@@ -211,6 +208,8 @@ module EventMachine
                   @content_length ||= $'.to_i
                 elsif ary.first =~ /\Aconnection:\s*close/i
                   @connection_close = true
+                elsif ary.first =~ /\Atransfer-encoding:\s*chunked/i
+                  @chunked = true
                 end
               end
             else
@@ -218,12 +217,32 @@ module EventMachine
               data = ""
             end
           when :content
-            # If there was no content-length header, we have to wait until the connection
-            # closes. Everything we get until that point is content.
-            # TODO: Must impose a content-size limit, and also must implement chunking.
-            # Also, must support either temporary files for large content, or calling
-            # a content-consumer block supplied by the user.
-            if @content_length
+            if @chunked && @chunk_length
+              bytes_needed = @chunk_length - @chunk_read
+              new_data = data[0, bytes_needed]
+              @chunk_read += new_data.length
+              @content += new_data
+              data = data[bytes_needed..-1] || ""
+              if @chunk_length == @chunk_read && data[0,2] == "\r\n"
+                @chunk_length = nil
+                data = data[2..-1]
+              end
+            elsif @chunked
+              if (m = data.match(/\A(\S*)\r\n/m))
+                data = data[m[0].length..-1]
+                @chunk_length = m[1].to_i(16)
+                @chunk_read = 0
+                if @chunk_length == 0
+                  dispatch_response
+                  @read_state = :base
+                end
+              end
+            elsif @content_length
+              # If there was no content-length header, we have to wait until the connection
+              # closes. Everything we get until that point is content.
+              # TODO: Must impose a content-size limit, and also must implement chunking.
+              # Also, must support either temporary files for large content, or calling
+              # a content-consumer block supplied by the user.
               bytes_needed = @content_length - @content.length
               @content += data[0, bytes_needed]
               data = data[bytes_needed..-1] || ""
@@ -274,6 +293,5 @@ module EventMachine
         end
       end
     end
-
   end
 end

data/lib/em/protocols/line_and_text.rb

@@ -32,7 +32,6 @@ module EventMachine
     # for a version which is optimized for correctness with regard to binary text blocks
     # that can switch back to line mode.
     class LineAndTextProtocol < Connection
-      MaxLineLength = 16*1024
       MaxBinaryLength = 32*1024*1024
 
       def initialize *args
@@ -42,7 +41,7 @@ module EventMachine
       def receive_data data
         if @lbp_mode == :lines
           begin
-            @lpb_buffer.extract(data).each do |line| 
+            @lpb_buffer.extract(data).each do |line|
               receive_line(line.chomp) if respond_to?(:receive_line)
             end
           rescue Exception
@@ -116,7 +115,7 @@ module EventMachine
       #--
       # For internal use, establish protocol baseline for handling lines.
       def lbp_init_line_state
-        @lpb_buffer = BufferedTokenizer.new("\n", MaxLineLength)
+        @lpb_buffer = BufferedTokenizer.new("\n")
         @lbp_mode = :lines
       end
       private :lbp_init_line_state

data/lib/em/protocols/linetext2.rb

@@ -37,7 +37,6 @@ module EventMachine
       # When we get around to that, call #receive_error if the user defined it, otherwise
       # throw exceptions.
 
-      MaxLineLength = 16*1024
       MaxBinaryLength = 32*1024*1024
 
       #--

data/lib/em/protocols/smtpserver.rb

@@ -227,18 +227,26 @@ module EventMachine
           process_unknown
         end
       end
-
+      
       # TODO - implement this properly, the implementation is a stub!
-      def process_vrfy
+      def process_help
         send_data "250 Ok, but unimplemented\r\n"
       end
+      
+      # RFC2821, 3.5.3 Meaning of VRFY or EXPN Success Response:
+      #   A server MUST NOT return a 250 code in response to a VRFY or EXPN
+      #   command unless it has actually verified the address.  In particular,
+      #   a server MUST NOT return 250 if all it has done is to verify that the
+      #   syntax given is valid.  In that case, 502 (Command not implemented)
+      #   or 500 (Syntax error, command unrecognized) SHOULD be returned.
+      #
       # TODO - implement this properly, the implementation is a stub!
-      def process_help
-        send_data "250 Ok, but unimplemented\r\n"
+      def process_vrfy
+        send_data "502 Command not implemented\r\n"
       end
       # TODO - implement this properly, the implementation is a stub!
       def process_expn
-        send_data "250 Ok, but unimplemented\r\n"
+        send_data "502 Command not implemented\r\n"
       end
 
       #--
@@ -358,12 +366,23 @@ module EventMachine
       def process_auth_line(line)
         plain = line.unpack("m").first
         _,user,psw = plain.split("\000")
-        if receive_plain_auth user,psw
+        
+        succeeded = proc {
           send_data "235 authentication ok\r\n"
           @state << :auth
-        else
+        }
+        failed = proc {
           send_data "535 invalid authentication\r\n"
+        }
+        auth = receive_plain_auth user,psw
+        
+        if auth.respond_to?(:callback)
+          auth.callback(&succeeded)
+          auth.errback(&failed)
+        else
+          (auth ? succeeded : failed).call
         end
+        
         @state.delete :auth_incomplete
       end
 

data/lib/em/pure_ruby.rb

@@ -393,7 +393,7 @@ module EventMachine
       100.times {
         @loopbreak_port = rand(10000) + 40000
         begin
-          @loopbreak_reader.bind "localhost", @loopbreak_port
+          @loopbreak_reader.bind "127.0.0.1", @loopbreak_port
           bound = true
           break
         rescue
@@ -410,7 +410,7 @@ module EventMachine
 
     def signal_loopbreak
       #@loopbreak_writer.write '+' if @loopbreak_writer
-      @loopbreak_writer.send('+',0,"localhost",@loopbreak_port) if @loopbreak_writer
+      @loopbreak_writer.send('+',0,"127.0.0.1",@loopbreak_port) if @loopbreak_writer
     end
 
     def set_timer_quantum interval_in_seconds

data/lib/em/version.rb

@@ -1,3 +1,3 @@
 module EventMachine
-  VERSION = "1.0.5"
+  VERSION = "1.0.6"
 end

data/lib/jeventmachine.rb

@@ -268,6 +268,20 @@ module EventMachine
     @em.getConnectionCount
   end
 
+  def self.pause_connection(sig)
+    @em.pauseConnection(sig)
+  end
+  def self.resume_connection(sig)
+    @em.resumeConnection(sig)
+  end
+  def self.connection_paused?(sig)
+    @em.isConnectionPaused(sig)
+  end
+  def self._get_outbound_data_size(sig)
+    @em.getOutboundDataSize(sig)
+  end
+
+
   def self.set_tls_parms(sig, params)
   end
   def self.start_tls(sig)
@@ -279,6 +293,9 @@ module EventMachine
     def associate_callback_target sig
       # No-op for the time being
     end
+    def get_outbound_data_size
+      EM._get_outbound_data_size @signature
+    end
   end
 end
 

data/tests/em_test_helper.rb

@@ -45,6 +45,10 @@ class Test::Unit::TestCase
     def jruby?
       defined? JRUBY_VERSION
     end
+
+    def rbx?
+      defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+    end
   end
 
   include PlatformHelper

data/tests/test_basic.rb

@@ -246,6 +246,7 @@ class TestBasic < Test::Unit::TestCase
 
   def test_fork_safe
     omit_if(jruby?)
+    omit_if(rbx?, 'Omitting test on Rubinius because it hangs for unknown reasons')
 
     read, write = IO.pipe
     EM.run do

data/tests/test_connection_write.rb

@@ -0,0 +1,35 @@
+require 'em_test_helper'
+
+class TestConnectionWrite < Test::Unit::TestCase
+
+  # This test takes advantage of the fact that EM::_RunSelectOnce iterates over the connections twice:
+  #   - once to determine which ones to call Write() on
+  #   - and once to call Write() on each of them.
+  #
+  # But state may change in the meantime before Write() is finally called.
+  # And that is what we try to exploit to get Write() to be called when bWatchOnly is true, and bNotifyWritable is false,
+  # to cause an assertion failure.
+
+  module SimpleClient
+    def notify_writable
+      $conn2.notify_writable = false  # Being naughty in callback
+      # If this doesn't crash anything, the test passed!
+    end
+  end
+
+  def test_with_naughty_callback
+    EM.run do
+      r1, w1 = IO.pipe
+      r2, w2 = IO.pipe
+
+      # Adding EM.watches
+      $conn1 = EM.watch(r1, SimpleClient)
+      $conn2 = EM.watch(r2, SimpleClient)
+
+      $conn1.notify_writable = true
+      $conn2.notify_writable = true
+
+      EM.stop
+    end
+  end
+end

data/tests/test_httpclient.rb

@@ -187,4 +187,47 @@ class TestHttpClient < Test::Unit::TestCase
     assert ok
   end
 
+  #-----------------------------------------
+
+  # Test a server that returns chunked encoding
+  #
+  class ChunkedEncodingContent < EventMachine::Connection
+    def initialize *args
+      super
+    end
+    def receive_data data
+      send_data ["HTTP/1.1 200 OK",
+                "Server: nginx/0.7.67", 
+                "Date: Sat, 23 Oct 2010 16:41:32 GMT",
+                "Content-Type: application/json",
+                "Transfer-Encoding: chunked",
+                "Connection: keep-alive",
+                "", 
+                "1800",
+                "chunk1" * 1024,
+                "5a",
+                "chunk2" * 15,
+                "0",
+                ""].join("\r\n")
+      close_connection_after_writing
+    end
+  end
+
+  def test_http_chunked_encoding_content
+    ok = false
+    EventMachine.run {
+      EventMachine.start_server "127.0.0.1", 9701, ChunkedEncodingContent
+      c = EventMachine::Protocols::HttpClient.send :request, :host => "127.0.0.1", :port => 9701
+      c.callback {|result|
+        if result[:content] == "chunk1" * 1024 + "chunk2" * 15
+          ok = true
+        end
+        EventMachine.stop
+      }
+    }
+    assert ok
+  end
+
 end
+
+

data/tests/test_pause.rb

@@ -82,14 +82,19 @@ class TestPause < Test::Unit::TestCase
         end
       end
 
+      buf = 'a' * 1024
+
       EM.run do
         EM.start_server "127.0.0.1", @port, test_server
         cli = EM.connect "127.0.0.1", @port
-        cli.send_data 'a'*(17*1024)
+        128.times do
+          cli.send_data buf
+        end
       end
 
       assert_equal 1, incoming.size
-      assert_equal 16*1024, incoming[0].bytesize
+      assert incoming[0].bytesize > buf.bytesize
+      assert incoming[0].bytesize < buf.bytesize * 128
     end
   else
     warn "EM.pause_connection not implemented, skipping tests in #{__FILE__}"

data/tests/test_process_watch.rb

@@ -27,6 +27,7 @@ if EM.kqueue?
     end
 
     def test_events
+      omit_if(rbx?)
       omit_if(jruby?)
       EM.run{
         # watch ourselves for a fork notification

data/tests/test_ssl_methods.rb

@@ -27,6 +27,7 @@ class TestSSLMethods < Test::Unit::TestCase
 
   def test_ssl_methods
     omit_unless(EM.ssl?)
+    omit_if(rbx?)
     $server_called_back, $client_called_back = false, false
     $server_cert_value, $client_cert_value = nil, nil
 

data/tests/test_ssl_verify.rb

@@ -54,6 +54,7 @@ class TestSslVerify < Test::Unit::TestCase
 
   def test_accept_server
     omit_unless(EM.ssl?)
+    omit_if(rbx?)
     $client_handshake_completed, $server_handshake_completed = false, false
     EM.run {
       EM.start_server("127.0.0.1", 16784, AcceptServer)
@@ -67,6 +68,7 @@ class TestSslVerify < Test::Unit::TestCase
 
   def test_deny_server
     omit_unless(EM.ssl?)
+    omit_if(rbx?)
     $client_handshake_completed, $server_handshake_completed = false, false
     EM.run {
       EM.start_server("127.0.0.1", 16784, DenyServer)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eventmachine
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
 platform: java
 authors:
 - Francis Cianfrocca
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-02-02 00:00:00.000000000 Z
+date: 2015-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -203,6 +203,7 @@ files:
 - tests/test_channel.rb
 - tests/test_completion.rb
 - tests/test_connection_count.rb
+- tests/test_connection_write.rb
 - tests/test_defer.rb
 - tests/test_deferrable.rb
 - tests/test_epoll.rb