raindrops 0.13.0 → 0.20.0

data/ext/raindrops/tcp_info.c

@@ -0,0 +1,245 @@
+#include <ruby.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#if defined(HAVE_LINUX_TCP_H)
+#  include <linux/tcp.h>
+#else
+#  if defined(HAVE_NETINET_TCP_H)
+#    include <netinet/tcp.h>
+#  endif
+#  if defined(HAVE_NETINET_TCP_FSM_H)
+#    include <netinet/tcp_fsm.h>
+#  endif
+#endif
+
+#ifdef HAVE_TYPE_STRUCT_TCP_INFO
+#include "my_fileno.h"
+
+CFUNC_tcp_info_tcpi_state
+CFUNC_tcp_info_tcpi_ca_state
+CFUNC_tcp_info_tcpi_retransmits
+CFUNC_tcp_info_tcpi_probes
+CFUNC_tcp_info_tcpi_backoff
+CFUNC_tcp_info_tcpi_options
+CFUNC_tcp_info_tcpi_snd_wscale
+CFUNC_tcp_info_tcpi_rcv_wscale
+CFUNC_tcp_info_tcpi_rto
+CFUNC_tcp_info_tcpi_ato
+CFUNC_tcp_info_tcpi_snd_mss
+CFUNC_tcp_info_tcpi_rcv_mss
+CFUNC_tcp_info_tcpi_unacked
+CFUNC_tcp_info_tcpi_sacked
+CFUNC_tcp_info_tcpi_lost
+CFUNC_tcp_info_tcpi_retrans
+CFUNC_tcp_info_tcpi_fackets
+CFUNC_tcp_info_tcpi_last_data_sent
+CFUNC_tcp_info_tcpi_last_ack_sent
+CFUNC_tcp_info_tcpi_last_data_recv
+CFUNC_tcp_info_tcpi_last_ack_recv
+CFUNC_tcp_info_tcpi_pmtu
+CFUNC_tcp_info_tcpi_rcv_ssthresh
+CFUNC_tcp_info_tcpi_rtt
+CFUNC_tcp_info_tcpi_rttvar
+CFUNC_tcp_info_tcpi_snd_ssthresh
+CFUNC_tcp_info_tcpi_snd_cwnd
+CFUNC_tcp_info_tcpi_advmss
+CFUNC_tcp_info_tcpi_reordering
+CFUNC_tcp_info_tcpi_rcv_rtt
+CFUNC_tcp_info_tcpi_rcv_space
+CFUNC_tcp_info_tcpi_total_retrans
+
+static size_t tcpi_memsize(const void *ptr)
+{
+	return sizeof(struct tcp_info);
+}
+
+static const rb_data_type_t tcpi_type = {
+	"tcp_info",
+	{ NULL, RUBY_TYPED_DEFAULT_FREE, tcpi_memsize, /* reserved */ },
+	/* parent, data, [ flags ] */
+};
+
+static VALUE alloc(VALUE klass)
+{
+	struct tcp_info *info;
+
+	return TypedData_Make_Struct(klass, struct tcp_info, &tcpi_type, info);
+}
+
+/*
+ * call-seq:
+ *
+ *	Raindrops::TCP_Info.new(tcp_socket)	-> TCP_Info object
+ *
+ * Reads a TCP_Info object from any given +tcp_socket+.  See the tcp(7)
+ * manpage and /usr/include/linux/tcp.h for more details.
+ */
+static VALUE init(VALUE self, VALUE io)
+{
+	int fd = my_fileno(io);
+	struct tcp_info *info = DATA_PTR(self);
+	socklen_t len = (socklen_t)sizeof(struct tcp_info);
+	int rc = getsockopt(fd, IPPROTO_TCP, TCP_INFO, info, &len);
+
+	if (rc != 0)
+		rb_sys_fail("getsockopt");
+
+	return self;
+}
+
+void Init_raindrops_tcp_info(void)
+{
+	VALUE cRaindrops = rb_define_class("Raindrops", rb_cObject);
+	VALUE cTCP_Info;
+
+	/*
+	 * Document-class: Raindrops::TCP_Info
+	 *
+	 * This is used to wrap "struct tcp_info" as described in tcp(7)
+	 * and /usr/include/linux/tcp.h.  The following readers methods
+	 * are defined corresponding to the "tcpi_" fields in the
+	 * tcp_info struct.
+	 *
+	 * As of raindrops 0.18.0+, this is supported on FreeBSD and OpenBSD
+	 * systems as well as Linux, although not all fields exist or
+	 * match the documentation, below.
+	 *
+	 * In particular, the +last_data_recv+ field is useful for measuring
+	 * the amount of time a client spent in the listen queue before
+	 * +accept()+, but only if +TCP_DEFER_ACCEPT+ is used with the
+	 * listen socket (it is on by default in Unicorn).
+	 *
+	 * - state
+	 * - ca_state
+	 * - retransmits
+	 * - probes
+	 * - backoff
+	 * - options
+	 * - snd_wscale
+	 * - rcv_wscale
+	 * - rto
+	 * - ato
+	 * - snd_mss
+	 * - rcv_mss
+	 * - unacked
+	 * - sacked
+	 * - lost
+	 * - retrans
+	 * - fackets
+	 * - last_data_sent
+	 * - last_ack_sent
+	 * - last_data_recv
+	 * - last_ack_recv
+	 * - pmtu
+	 * - rcv_ssthresh
+	 * - rtt
+	 * - rttvar
+	 * - snd_ssthresh
+	 * - snd_cwnd
+	 * - advmss
+	 * - reordering
+	 * - rcv_rtt
+	 * - rcv_space
+	 * - total_retrans
+	 *
+	 * https://kernel.org/doc/man-pages/online/pages/man7/tcp.7.html
+	 */
+	cTCP_Info = rb_define_class_under(cRaindrops, "TCP_Info", rb_cObject);
+	rb_define_alloc_func(cTCP_Info, alloc);
+	rb_define_private_method(cTCP_Info, "initialize", init, 1);
+
+	/*
+	 * Document-method: Raindrops::TCP_Info#get!
+	 *
+	 * call-seq:
+	 *
+	 *	info = Raindrops::TCP_Info.new(tcp_socket)
+	 *	info.get!(tcp_socket)
+	 *
+	 * Update an existing TCP_Info objects with the latest stats
+	 * from the given socket.  This even allows sharing TCP_Info
+	 * objects between different sockets to avoid garbage.
+	 */
+	rb_define_method(cTCP_Info, "get!", init, 1);
+
+	DEFINE_METHOD_tcp_info_tcpi_state;
+	DEFINE_METHOD_tcp_info_tcpi_ca_state;
+	DEFINE_METHOD_tcp_info_tcpi_retransmits;
+	DEFINE_METHOD_tcp_info_tcpi_probes;
+	DEFINE_METHOD_tcp_info_tcpi_backoff;
+	DEFINE_METHOD_tcp_info_tcpi_options;
+	DEFINE_METHOD_tcp_info_tcpi_snd_wscale;
+	DEFINE_METHOD_tcp_info_tcpi_rcv_wscale;
+	DEFINE_METHOD_tcp_info_tcpi_rto;
+	DEFINE_METHOD_tcp_info_tcpi_ato;
+	DEFINE_METHOD_tcp_info_tcpi_snd_mss;
+	DEFINE_METHOD_tcp_info_tcpi_rcv_mss;
+	DEFINE_METHOD_tcp_info_tcpi_unacked;
+	DEFINE_METHOD_tcp_info_tcpi_sacked;
+	DEFINE_METHOD_tcp_info_tcpi_lost;
+	DEFINE_METHOD_tcp_info_tcpi_retrans;
+	DEFINE_METHOD_tcp_info_tcpi_fackets;
+	DEFINE_METHOD_tcp_info_tcpi_last_data_sent;
+	DEFINE_METHOD_tcp_info_tcpi_last_ack_sent;
+	DEFINE_METHOD_tcp_info_tcpi_last_data_recv;
+	DEFINE_METHOD_tcp_info_tcpi_last_ack_recv;
+	DEFINE_METHOD_tcp_info_tcpi_pmtu;
+	DEFINE_METHOD_tcp_info_tcpi_rcv_ssthresh;
+	DEFINE_METHOD_tcp_info_tcpi_rtt;
+	DEFINE_METHOD_tcp_info_tcpi_rttvar;
+	DEFINE_METHOD_tcp_info_tcpi_snd_ssthresh;
+	DEFINE_METHOD_tcp_info_tcpi_snd_cwnd;
+	DEFINE_METHOD_tcp_info_tcpi_advmss;
+	DEFINE_METHOD_tcp_info_tcpi_reordering;
+	DEFINE_METHOD_tcp_info_tcpi_rcv_rtt;
+	DEFINE_METHOD_tcp_info_tcpi_rcv_space;
+	DEFINE_METHOD_tcp_info_tcpi_total_retrans;
+
+#ifdef RAINDROPS_TCP_STATES_ALL_KNOWN
+
+	/*
+	 * Document-const: Raindrops::TCP
+         *
+         * This is a frozen hash storing the numeric values
+         * maps platform-independent symbol keys to
+         * platform-dependent numeric values. These states
+         * are all valid values for the Raindrops::TCP_Info#state field.
+         *
+         * The platform-independent names of the keys in this hash are:
+         *
+         *  - :ESTABLISHED
+         *  - :SYN_SENT
+         *  - :SYN_RECV
+         *  - :FIN_WAIT1
+         *  - :FIN_WAIT2
+         *  - :TIME_WAIT
+         *  - :CLOSE
+         *  - :CLOSE_WAIT
+         *  - :LAST_ACK
+         *  - :LISTEN
+         *  - :CLOSING
+         *
+         * This is only supported on platforms where TCP_Info is supported,
+         * currently FreeBSD, OpenBSD, and Linux-based systems.
+         */
+	{
+#define TCPSET(n,v) rb_hash_aset(tcp, ID2SYM(rb_intern(#n)), INT2NUM(v))
+		VALUE tcp = rb_hash_new();
+		TCPSET(ESTABLISHED, RAINDROPS_TCP_ESTABLISHED);
+		TCPSET(SYN_SENT, RAINDROPS_TCP_SYN_SENT);
+		TCPSET(SYN_RECV, RAINDROPS_TCP_SYN_RECV);
+		TCPSET(FIN_WAIT1, RAINDROPS_TCP_FIN_WAIT1);
+		TCPSET(FIN_WAIT2, RAINDROPS_TCP_FIN_WAIT2);
+		TCPSET(TIME_WAIT, RAINDROPS_TCP_TIME_WAIT);
+		TCPSET(CLOSE, RAINDROPS_TCP_CLOSE);
+		TCPSET(CLOSE_WAIT, RAINDROPS_TCP_CLOSE_WAIT);
+		TCPSET(LAST_ACK, RAINDROPS_TCP_LAST_ACK);
+		TCPSET(LISTEN, RAINDROPS_TCP_LISTEN);
+		TCPSET(CLOSING, RAINDROPS_TCP_CLOSING);
+#undef TCPSET
+		OBJ_FREEZE(tcp);
+		rb_define_const(cRaindrops, "TCP", tcp);
+	}
+#endif
+}
+#endif /* HAVE_STRUCT_TCP_INFO */

data/lib/raindrops/aggregate/last_data_recv.rb

@@ -13,10 +13,6 @@ require "socket"
 # - Kgio::TCPServer#kgio_accept
 # - Kgio::TCPServer#kgio_tryaccept
 module Raindrops::Aggregate::LastDataRecv
-  # :stopdoc:
-  TCP_Info = Raindrops::TCP_Info
-  # :startdoc:
-
   # The integer value of +last_data_recv+ is sent to this object.
   # This is usually a duck type compatible with the \Aggregate class,
   # but can be *anything* that accepts the *<<* method.
@@ -78,7 +74,7 @@ module Raindrops::Aggregate::LastDataRecv
   # +last_data_recv+ to be accurate
   def count!(io)
     if io
-      x = TCP_Info.new(io)
+      x = Raindrops::TCP_Info.new(io)
       @raindrops_aggregate << x.last_data_recv
     end
     io

data/lib/raindrops/aggregate/pmq.rb

@@ -3,10 +3,10 @@ require "tempfile"
 require "aggregate"
 require "posix_mq"
 require "fcntl"
-require "io/extra"
 require "thread"
+require "stringio"
 
-# \Aggregate + POSIX message queues support for Ruby 1.9 and \Linux
+# \Aggregate + POSIX message queues support for Ruby 1.9+ and \Linux
 #
 # This class is duck-type compatible with \Aggregate and allows us to
 # aggregate and share statistics from multiple processes/threads aided
@@ -14,12 +14,11 @@ require "thread"
 # Raindrops::LastDataRecv Rack application, but can be used independently
 # on compatible Runtimes.
 #
-# Unlike the core of raindrops, this is only supported on Ruby 1.9 and
-# Linux 2.6.  Using this class requires the following additional RubyGems
+# Unlike the core of raindrops, this is only supported on Ruby 1.9+ and
+# Linux 2.6+.  Using this class requires the following additional RubyGems
 # or libraries:
 #
 # * aggregate (tested with 0.2.2)
-# * io-extra  (tested with 1.2.3)
 # * posix_mq  (tested with 1.0.0)
 #
 # == Design
@@ -39,9 +38,9 @@ class Raindrops::Aggregate::PMQ
   # :stopdoc:
   # These constants are for Linux.  This is designed for aggregating
   # TCP_INFO.
-  RDLOCK = [ Fcntl::F_RDLCK ].pack("s @256")
-  WRLOCK = [ Fcntl::F_WRLCK ].pack("s @256")
-  UNLOCK = [ Fcntl::F_UNLCK ].pack("s @256")
+  RDLOCK = [ Fcntl::F_RDLCK ].pack("s @256".freeze).freeze
+  WRLOCK = [ Fcntl::F_WRLCK ].pack("s @256".freeze).freeze
+  UNLOCK = [ Fcntl::F_UNLCK ].pack("s @256".freeze).freeze
   # :startdoc:
 
   # returns the number of dropped messages sent to a POSIX message
@@ -84,6 +83,7 @@ class Raindrops::Aggregate::PMQ
       @wr = File.open(t.path, "wb")
       @rd = File.open(t.path, "rb")
     end
+    @wr.sync = true
     @cached_aggregate = @aggregate
     flush_master
     @mq_send = if opts[:lossy]
@@ -142,8 +142,8 @@ class Raindrops::Aggregate::PMQ
       warn "Unhandled exception in #{__FILE__}:#{__LINE__}: #{e}"
       break
     end while true
-    ensure
-      flush_master
+  ensure
+    flush_master
   end
 
   # Loads the last shared \Aggregate from the master thread/process
@@ -151,7 +151,10 @@ class Raindrops::Aggregate::PMQ
     @cached_aggregate ||= begin
       flush
       Marshal.load(synchronize(@rd, RDLOCK) do |rd|
-        IO.pread rd.fileno, rd.stat.size, 0
+        dst = StringIO.new
+        dst.binmode
+        IO.copy_stream(rd, dst, rd.size, 0)
+        dst.string
       end)
     end
   end
@@ -163,7 +166,8 @@ class Raindrops::Aggregate::PMQ
     dump = Marshal.dump @aggregate
     synchronize(@wr, WRLOCK) do |wr|
       wr.truncate 0
-      IO.pwrite wr.fileno, dump, 0
+      wr.rewind
+      wr.write(dump)
     end
   end
 
@@ -171,24 +175,26 @@ class Raindrops::Aggregate::PMQ
   # worker thread or process
   def stop_master_loop
     sleep 0.1 until mq_send(false)
-    rescue Errno::EINTR
-      retry
+  rescue Errno::EINTR
+    retry
   end
 
   def lock! io, type # :nodoc:
     io.fcntl Fcntl::F_SETLKW, type
-    rescue Errno::EINTR
-      retry
+  rescue Errno::EINTR
+    retry
   end
 
   # we use both a mutex for thread-safety and fcntl lock for process-safety
   def synchronize io, type # :nodoc:
     @mutex.synchronize do
       begin
+        type = type.dup
         lock! io, type
         yield io
       ensure
-        lock! io, UNLOCK
+        lock! io, type.replace(UNLOCK)
+        type.clear
       end
     end
   end

data/lib/raindrops/aggregate.rb

@@ -1,6 +1,6 @@
 # -*- encoding: binary -*-
 #
-# raindrops may use the {aggregate}[http://github.com/josephruscio/aggregate]
+# raindrops may use the {aggregate}[https://github.com/josephruscio/aggregate]
 # RubyGem to aggregate statistics from TCP_Info lookups.
 module Raindrops::Aggregate
   autoload :PMQ, "raindrops/aggregate/pmq"

data/lib/raindrops/linux.rb

@@ -8,15 +8,13 @@
 # Instead of snapshotting, Raindrops::Aggregate::LastDataRecv may be used
 # to aggregate statistics from +all+ accepted sockets as they arrive
 # based on the +last_data_recv+ field in Raindrops::TCP_Info
-require 'pathname'
 
 module Raindrops::Linux
 
   # The standard proc path for active UNIX domain sockets, feel free to call
   # String#replace on this if your /proc is mounted in a non-standard location
   # for whatever reason
-  PROC_NET_UNIX_ARGS = %w(/proc/net/unix)
-  defined?(::Encoding) and PROC_NET_UNIX_ARGS.push({ :encoding => "binary" })
+  PROC_NET_UNIX_ARGS = [ '/proc/net/unix', { encoding: "binary" }]
 
   # Get ListenStats from an array of +paths+
   #
@@ -43,10 +41,11 @@ module Raindrops::Linux
     else
       paths = paths.map do |path|
         path = path.dup
-        path.force_encoding(Encoding::BINARY) if defined?(Encoding)
+        path.force_encoding(Encoding::BINARY)
         if File.symlink?(path)
           link = path
-          path = Pathname.new(link).realpath.to_s
+          path = File.readlink(link)
+          path.force_encoding(Encoding::BINARY)
           rv[link] = rv[path] # vivify ListenerStats
         else
           rv[path] # vivify ListenerStats
@@ -57,7 +56,7 @@ module Raindrops::Linux
     paths = /^\w+: \d+ \d+ (\d+) \d+ (\d+)\s+\d+ (#{paths.join('|')})$/n
 
     # no point in pread since we can't stat for size on this file
-    File.read(*PROC_NET_UNIX_ARGS).scan(paths) do |s|
+    File.read(PROC_NET_UNIX_ARGS[0], encoding: 'binary').scan(paths) do |s|
       path = s[-1]
       case s[0]
       when "00000000" # client sockets

data/lib/raindrops/middleware/proxy.rb

@@ -27,9 +27,9 @@ class Raindrops::Middleware::Proxy
 
   # Rack servers use +respond_to?+ to check for the presence of +close+
   # and +to_path+ methods.
-  def respond_to?(m)
+  def respond_to?(m, include_all = false)
     m = m.to_sym
-    :close == m || @body.respond_to?(m)
+    :close == m || @body.respond_to?(m, include_all)
   end
 
   # Avoid breaking users of non-standard extensions (e.g. #body)

data/lib/raindrops/middleware.rb

@@ -62,9 +62,9 @@ require 'raindrops'
 # = Demo Server
 #
 # There is a server running this middleware (and Watcher) at
-#  http://raindrops-demo.bogomips.org/_raindrops
+#  https://yhbt.net/raindrops-demo/_raindrops
 #
-# Also check out the Watcher demo at http://raindrops-demo.bogomips.org/
+# Also check out the Watcher demo at https://yhbt.net/raindrops-demo/
 #
 # The demo server is only limited to 30 users, so be sure not to abuse it
 # by using the /tail/ endpoint too much.
@@ -77,11 +77,9 @@ class Raindrops::Middleware
   # and both counters are updated atomically.
   #
   # This is supported on all operating systems supported by Raindrops
-  class Stats < Raindrops::Struct.new(:calling, :writing)
-  end
+  Stats = Raindrops::Struct.new(:calling, :writing)
 
   # :stopdoc:
-  PATH_INFO = "PATH_INFO"
   require "raindrops/middleware/proxy"
   # :startdoc:
 
@@ -111,7 +109,7 @@ class Raindrops::Middleware
 
   # standard Rack endpoint
   def call(env) # :nodoc:
-    env[PATH_INFO] == @path and return stats_response
+    env['PATH_INFO'] == @path and return stats_response
     begin
       @stats.incr_calling
 

data/lib/raindrops/watcher.rb

@@ -8,7 +8,7 @@ require "aggregate"
 # Raindrops::Watcher is a stand-alone Rack application for watching
 # any number of TCP and UNIX listeners (all of them by default).
 #
-# It depends on the {Aggregate RubyGem}[http://rubygems.org/gems/aggregate]
+# It depends on the {Aggregate RubyGem}[https://rubygems.org/gems/aggregate]
 #
 # In your Rack config.ru:
 #
@@ -35,28 +35,28 @@ require "aggregate"
 # Returns a plain text summary + histogram with X-* HTTP headers for
 # active connections.
 #
-# e.g.: curl http://raindrops-demo.bogomips.org/active/0.0.0.0%3A80.txt
+# e.g.: curl https://yhbt.net/raindrops-demo/active/0.0.0.0%3A80.txt
 #
 # === GET /active/$LISTENER.html
 #
 # Returns an HTML summary + histogram with X-* HTTP headers for
 # active connections.
 #
-# e.g.: curl http://raindrops-demo.bogomips.org/active/0.0.0.0%3A80.html
+# e.g.: curl https://yhbt.net/raindrops-demo/active/0.0.0.0%3A80.html
 #
 # === GET /queued/$LISTENER.txt
 #
 # Returns a plain text summary + histogram with X-* HTTP headers for
 # queued connections.
 #
-# e.g.: curl http://raindrops-demo.bogomips.org/queued/0.0.0.0%3A80.txt
+# e.g.: curl https://yhbt.net/raindrops-demo/queued/0.0.0.0%3A80.txt
 #
 # === GET /queued/$LISTENER.html
 #
 # Returns an HTML summary + histogram with X-* HTTP headers for
 # queued connections.
 #
-# e.g.: curl http://raindrops-demo.bogomips.org/queued/0.0.0.0%3A80.html
+# e.g.: curl https://yhbt.net/raindrops-demo/queued/0.0.0.0%3A80.html
 #
 # === POST /reset/$LISTENER
 #
@@ -95,9 +95,9 @@ require "aggregate"
 #
 # = Demo Server
 #
-# There is a server running this app at http://raindrops-demo.bogomips.org/
+# There is a server running this app at https://yhbt.net/raindrops-demo/
 # The Raindrops::Middleware demo is also accessible at
-# http://raindrops-demo.bogomips.org/_raindrops
+# https://yhbt.net/raindrops-demo/_raindrops
 #
 # The demo server is only limited to 30 users, so be sure not to abuse it
 # by using the /tail/ endpoint too much.
@@ -106,7 +106,7 @@ class Raindrops::Watcher
   attr_reader :snapshot
   include Rack::Utils
   include Raindrops::Linux
-  DOC_URL = "http://raindrops.bogomips.org/Raindrops/Watcher.html"
+  DOC_URL = "https://yhbt.net/raindrops/Raindrops/Watcher.html"
   Peak = Struct.new(:first, :last)
 
   def initialize(opts = {})
@@ -244,10 +244,10 @@ class Raindrops::Watcher
   def histogram_txt(agg)
     updated_at, reset_at, agg, current, peak = *agg
     headers = agg_to_hash(reset_at, agg, current, peak)
-    body = agg.to_s
+    body = agg.to_s # 7-bit ASCII-clean
     headers["Content-Type"] = "text/plain"
     headers["Expires"] = (updated_at + @delay).httpdate
-    headers["Content-Length"] = bytesize(body).to_s
+    headers["Content-Length"] = body.size.to_s
     [ 200, headers, [ body ] ]
   end
 
@@ -265,7 +265,7 @@ class Raindrops::Watcher
       "</body>"
     headers["Content-Type"] = "text/html"
     headers["Expires"] = (updated_at + @delay).httpdate
-    headers["Content-Length"] = bytesize(body).to_s
+    headers["Content-Length"] = body.size.to_s
     [ 200, headers, [ body ] ]
   end
 
@@ -364,7 +364,7 @@ class Raindrops::Watcher
         "for more information and options." \
       "</p>" \
       "</body></html>"
-    headers["Content-Length"] = bytesize(body).to_s
+    headers["Content-Length"] = body.size.to_s
     [ 200, headers, [ body ] ]
   end
 
@@ -382,7 +382,7 @@ class Raindrops::Watcher
       q = Rack::Utils.parse_query env["QUERY_STRING"]
       @active_min = q["active_min"].to_i
       @queued_min = q["queued_min"].to_i
-      len = Rack::Utils.bytesize(addr)
+      len = addr.size
       len = 35 if len > 35
       @fmt = "%20s % #{len}s % 10u % 10u\n"
       case env["HTTP_VERSION"]

data/lib/raindrops.rb

@@ -12,7 +12,7 @@
 # Unlike many classes in this package, the core Raindrops class is
 # intended to be portable to all reasonably modern *nix systems
 # supporting mmap().  Please let us know if you have portability
-# issues, patches or pull requests at mailto:raindrops@librelist.org
+# issues, patches or pull requests at mailto:raindrops-public@yhbt.net
 class Raindrops
 
   # Used to represent the number of +active+ and +queued+ sockets for
@@ -36,6 +36,30 @@ class Raindrops
     def total
       active + queued
     end
+  end unless defined? ListenStats
+
+  # call-seq:
+  #	Raindrops.new(size, io: nil)	-> raindrops object
+  #
+  # Initializes a Raindrops object to hold +size+ counters.  +size+ is
+  # only a hint and the actual number of counters the object has is
+  # dependent on the CPU model, number of cores, and page size of
+  # the machine.  The actual size of the object will always be equal
+  # or greater than the specified +size+.
+  # If +io+ is provided, then the Raindrops memory will be backed by
+  # the specified file; otherwise, it will allocate anonymous memory.
+  # The IO object must respond to +truncate+, as this is used to set
+  # the size of the file.
+  # If +zero+ is provided, then the memory region is zeroed prior to
+  # returning. This is only meaningful if +io+ is also provided; in
+  # that case it controls whether any existing counter values in +io+
+  # are retained (false) or whether it is entirely zeroed (true).
+  def initialize(size, io: nil, zero: false)
+    # This ruby wrapper exists to handle the keyword-argument handling,
+    # which is otherwise kind of awkward in C. We delegate the keyword
+    # arguments to the _actual_ initialize implementation as positional
+    # args.
+    initialize_cimpl(size, io, zero)
   end
 
   autoload :Linux, 'raindrops/linux'