sensu-em 2.4.1 → 2.5.0.beta

data/ext/em.h

@@ -22,10 +22,10 @@ See the file COPYING for complete licensing information.
 
 #ifdef BUILD_FOR_RUBY
   #include <ruby.h>
-
   #ifdef HAVE_RB_THREAD_FD_SELECT
     #define EmSelect rb_thread_fd_select
   #else
+    // ruby 1.9.1 and below
     #define EmSelect rb_thread_select
   #endif
 
@@ -69,9 +69,33 @@ See the file COPYING for complete licensing information.
   #define EmSelect select
 #endif
 
+#if !defined(HAVE_RB_FDSET_T)
+#define fd_check(n) (((n) < FD_SETSIZE) ? 1 : 0*fprintf(stderr, "fd %d too large for select\n", (n)))
+// These definitions are cribbed from include/ruby/intern.h in Ruby 1.9.3,
+// with this change: any macros that read or write the nth element of an
+// fdset first call fd_check to make sure n is in bounds.
+typedef fd_set rb_fdset_t;
+#define rb_fd_zero(f) FD_ZERO(f)
+#define rb_fd_set(n, f) do { if (fd_check(n)) FD_SET((n), (f)); } while(0)
+#define rb_fd_clr(n, f) do { if (fd_check(n)) FD_CLR((n), (f)); } while(0)
+#define rb_fd_isset(n, f) (fd_check(n) ? FD_ISSET((n), (f)) : 0)
+#define rb_fd_copy(d, s, n) (*(d) = *(s))
+#define rb_fd_dup(d, s) (*(d) = *(s))
+#define rb_fd_resize(n, f)  ((void)(f))
+#define rb_fd_ptr(f)  (f)
+#define rb_fd_init(f) FD_ZERO(f)
+#define rb_fd_init_copy(d, s) (*(d) = *(s))
+#define rb_fd_term(f) ((void)(f))
+#define rb_fd_max(f)  FD_SETSIZE
+#define rb_fd_select(n, rfds, wfds, efds, timeout)  \
+  select(fd_check((n)-1) ? (n) : FD_SETSIZE, (rfds), (wfds), (efds), (timeout))
+#define rb_thread_fd_select(n, rfds, wfds, efds, timeout)  \
+  rb_thread_select(fd_check((n)-1) ? (n) : FD_SETSIZE, (rfds), (wfds), (efds), (timeout))
+#endif
+
 class EventableDescriptor;
 class InotifyDescriptor;
-
+struct SelectData_t;
 
 /********************
 class EventMachine_t
@@ -83,6 +107,9 @@ class EventMachine_t
 		static int GetMaxTimerCount();
 		static void SetMaxTimerCount (int);
 
+		static int GetSimultaneousAcceptCount();
+		static void SetSimultaneousAcceptCount (int);
+
 	public:
 		EventMachine_t (EMCallback);
 		virtual ~EventMachine_t();
@@ -175,7 +202,7 @@ class EventMachine_t
 	public:
 		void _ReadLoopBreaker();
 		void _ReadInotifyEvents();
-        int NumCloseScheduled;
+		int NumCloseScheduled;
 
 	private:
 		enum {
@@ -213,8 +240,13 @@ class EventMachine_t
 		unsigned LastTickCount;
 		#endif
 
+		#ifdef OS_DARWIN
+		mach_timebase_info_data_t mach_timebase;
+		#endif
+
 	private:
 		bool bTerminateSignalReceived;
+		SelectData_t *SelectData;
 
 		bool bEpoll;
 		int epfd; // Epoll file-descriptor
@@ -239,13 +271,15 @@ struct SelectData_t
 struct SelectData_t
 {
 	SelectData_t();
+	~SelectData_t();
 
 	int _Select();
+	void _Clear();
 
 	int maxsocket;
-	fd_set fdreads;
-	fd_set fdwrites;
-	fd_set fderrors;
+	rb_fdset_t fdreads;
+	rb_fdset_t fdwrites;
+	rb_fdset_t fderrors;
 	timeval tv;
 	int nSockets;
 };

data/ext/eventmachine.h

@@ -96,6 +96,8 @@ extern "C" {
 	void evma_set_timer_quantum (int);
 	int evma_get_max_timer_count();
 	void evma_set_max_timer_count (int);
+	int evma_get_simultaneous_accept_count();
+	void evma_set_simultaneous_accept_count (int);
 	void evma_setuid_string (const char *username);
 	void evma_stop_machine();
 	float evma_get_heartbeat_interval();

data/ext/extconf.rb

@@ -39,10 +39,13 @@ 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.0j")
+  openssl_version = ENV.fetch("OPENSSL_VERSION", "1.0.1i")
   openssl_dir = File.expand_path("~/.rake-compiler/builds/openssl-#{openssl_version}/")
-  if File.exists?(openssl_dir)
+  if File.exist?(openssl_dir)
     FileUtils.mkdir_p Dir.pwd+"/openssl/"
     FileUtils.cp Dir[openssl_dir+"/include/openssl/*.h"], Dir.pwd+"/openssl/", :verbose => true
     FileUtils.cp Dir[openssl_dir+"/lib*.a"], Dir.pwd, :verbose => true
@@ -72,6 +75,7 @@ add_define "HAVE_INOTIFY" if inotify = have_func('inotify_init', 'sys/inotify.h'
 add_define "HAVE_OLD_INOTIFY" if !inotify && have_macro('__NR_inotify_init', 'sys/syscall.h')
 add_define 'HAVE_WRITEV' if have_func('writev', 'sys/uio.h')
 add_define 'HAVE_RB_THREAD_FD_SELECT' if have_func('rb_thread_fd_select')
+add_define 'HAVE_RB_FDSET_T' if have_type('rb_fdset_t', 'ruby/intern.h')
 
 have_func('rb_wait_for_single_fd')
 have_func('rb_enable_interrupt')
@@ -139,6 +143,8 @@ when /openbsd/
   CONFIG['LDSHAREDXX'] = "$(CXX) -shared -lstdc++ -fPIC"
 
 when /darwin/
+  add_define 'OS_DARWIN'
+
   # on Unix we need a g++ link, not gcc.
   # Ff line contributed by Daniel Harple.
   CONFIG['LDSHARED'] = "$(CXX) " + CONFIG['LDSHARED'].split[1..-1].join(' ')
@@ -166,6 +172,14 @@ else
   CONFIG['LDSHARED'] = "$(CXX) -shared"
 end
 
+# Platform-specific time functions
+if have_func('clock_gettime')
+  # clock_gettime is POSIX, but the monotonic clocks are not
+  have_const('CLOCK_MONOTONIC_RAW', 'time.h') # Linux
+  have_const('CLOCK_MONOTONIC', 'time.h') # Linux, Solaris, BSDs
+else
+  have_func('gethrtime') # Older Solaris and HP-UX
+end
 
 # solaris c++ compiler doesn't have make_pair()
 TRY_LINK.sub!('$(CC)', '$(CXX)')

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/fastfilereader/mapper.cpp

@@ -195,7 +195,7 @@ void Mapper_t::Close()
 	}
 	if (hFile != INVALID_HANDLE_VALUE) {
 		CloseHandle (hFile);
-		hMapping = INVALID_HANDLE_VALUE;
+		hFile = INVALID_HANDLE_VALUE;
 	}
 }
 

data/ext/project.h

@@ -78,6 +78,11 @@ typedef int SOCKET;
 #endif
 #endif /* _AIX */
 
+#ifdef OS_DARWIN
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+#endif /* OS_DARWIN */
+
 #endif /* OS_UNIX */
 
 #ifdef OS_WIN32
@@ -85,7 +90,9 @@ typedef int SOCKET;
 // 18Jun12: fd_setsize must be changed in the ruby binary (not in this extension). redefining it also causes segvs, see eventmachine/eventmachine#333
 //#define FD_SETSIZE 1024
 
+// WIN32_LEAN_AND_MEAN excludes APIs such as Cryptography, DDE, RPC, Shell, and Windows Sockets.
 #define WIN32_LEAN_AND_MEAN
+
 #include <windows.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
@@ -93,13 +100,10 @@ typedef int SOCKET;
 #include <fcntl.h>
 #include <assert.h>
 
-#define close closesocket
-
-typedef int socklen_t;
-#ifndef _PID_T_
-#define _PID_T_
-typedef int pid_t;
-#endif /* _PID_T_ */
+// Use the Win32 wrapper library that Ruby owns to be able to close sockets with the close() function
+#define RUBY_EXPORT
+#include <ruby/defines.h>
+#include <ruby/win32.h>
 #endif /* OS_WIN32 */
 
 #if !defined(_MSC_VER) || _MSC_VER > 1500

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)) {
@@ -799,6 +813,21 @@ static VALUE t_set_max_timer_count (VALUE self, VALUE ct)
   return Qnil;
 }
 
+/********************
+t_get/set_simultaneous_accept_count
+********************/
+
+static VALUE t_get_simultaneous_accept_count (VALUE self)
+{
+  return INT2FIX (evma_get_simultaneous_accept_count());
+}
+
+static VALUE t_set_simultaneous_accept_count (VALUE self, VALUE ct)
+{
+  evma_set_simultaneous_accept_count (FIX2INT (ct));
+  return Qnil;
+}
+
 /***************
 t_setuid_string
 ***************/
@@ -833,7 +862,12 @@ static VALUE t_invoke_popen (VALUE self, VALUE cmd)
 	}
 	strings[len] = NULL;
 
-	const unsigned long f = evma_popen (strings);
+	unsigned long f = 0;
+	try {
+		f = evma_popen (strings);
+	} catch (std::runtime_error e) {
+		f = 0; // raise exception below
+	}
 	if (!f) {
 		char *err = strerror (errno);
 		char buf[100];
@@ -1271,6 +1305,8 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "set_timer_quantum", (VALUE(*)(...))t_set_timer_quantum, 1);
 	rb_define_module_function (EmModule, "get_max_timer_count", (VALUE(*)(...))t_get_max_timer_count, 0);
 	rb_define_module_function (EmModule, "set_max_timer_count", (VALUE(*)(...))t_set_max_timer_count, 1);
+	rb_define_module_function (EmModule, "get_simultaneous_accept_count", (VALUE(*)(...))t_get_simultaneous_accept_count, 0);
+	rb_define_module_function (EmModule, "set_simultaneous_accept_count", (VALUE(*)(...))t_set_simultaneous_accept_count, 1);
 	rb_define_module_function (EmModule, "setuid_string", (VALUE(*)(...))t_setuid_string, 1);
 	rb_define_module_function (EmModule, "invoke_popen", (VALUE(*)(...))t_invoke_popen, 1);
 	rb_define_module_function (EmModule, "send_file_data", (VALUE(*)(...))t_send_file_data, 2);

data/ext/ssl.cpp

@@ -400,13 +400,16 @@ int SslBox_t::PutPlaintext (const char *buf, int bufsize)
 
 	bool fatal = false;
 	bool did_work = false;
+	int pending =  BIO_pending(pbioWrite);
 
-	while (OutboundQ.HasPages()) {
+	while (OutboundQ.HasPages() && pending < SSLBOX_WRITE_BUFFER_SIZE) {
 		const char *page;
 		int length;
 		OutboundQ.Front (&page, &length);
 		assert (page && (length > 0));
 		int n = SSL_write (pSSL, page, length);
+		pending =  BIO_pending(pbioWrite);
+
 		if (n > 0) {
 			did_work = true;
 			OutboundQ.PopFront();

data/ext/ssl.h

@@ -54,6 +54,10 @@ class SslContext_t
 class SslBox_t
 **************/
 
+#define SSLBOX_INPUT_CHUNKSIZE 2019
+#define SSLBOX_OUTPUT_CHUNKSIZE 2048
+#define SSLBOX_WRITE_BUFFER_SIZE 8192 // (SSLBOX_OUTPUT_CHUNKSIZE * 4)
+
 class SslBox_t
 {
 	public:

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

@@ -73,7 +73,14 @@ public abstract class EventableChannel<OutboundPacketType> {
 
 	public void setCommInactivityTimeout (long seconds) {
 		// TODO
-		System.out.println ("SET COMM INACTIVITY UNIMPLEMENTED IN JRUBY" + seconds);
+               /**
+                * A proper fix will require implementing a heartbeat in
+                * the java reactor similar to the one used for connect
+                * timeouts in the c++ reactor. You could also emulate
+                * it with timers in the jeventmachine.rb wrapper.
+                *
+                * https://github.com/igrigorik/em-http-request/issues/85
+                */
 	}
 
 	public abstract Object[] getPeerName();

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.
@@ -184,6 +181,8 @@ module EventMachine
             @content_length = nil # not zero
             @content = ""
             @status = nil
+            @chunked = false
+            @chunk_length = nil
             @read_state = :header
             @connection_close = nil
           when :header
@@ -191,7 +190,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 +210,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 +219,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 +295,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
 
       #--