zyre 0.1.0

data/ext/zyre_ext/poller.c

@@ -0,0 +1,272 @@
+/*
+ *  poller.c - A poller for doing evented IO on one or more Zyre nodes
+ *  $Id$
+ *
+ *  Authors:
+ *    * Michael Granger <ged@FaerieMUD.org>
+ *
+ */
+
+#include "zyre_ext.h"
+
+VALUE rzyre_cZyrePoller;
+
+
+static void rzyre_poller_free( void *ptr );
+
+static const rb_data_type_t rzyre_poller_t = {
+	"Zyre::Poller",
+	{
+		NULL,
+		rzyre_poller_free
+	},
+	0,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+
+/*
+ * Free function
+ */
+static void
+rzyre_poller_free( void *ptr )
+{
+	if ( ptr ) {
+		zpoller_destroy( (zpoller_t **)&ptr );
+	}
+}
+
+
+/*
+ * Alloc function
+ */
+static VALUE
+rzyre_poller_alloc( VALUE klass )
+{
+	return TypedData_Wrap_Struct( klass, &rzyre_poller_t, NULL );
+}
+
+
+/*
+ * Fetch the data pointer and check it for sanity.
+ */
+static inline zpoller_t *
+rzyre_get_poller( VALUE self )
+{
+	zpoller_t *ptr;
+
+	if ( !IsZyrePoller(self) ) {
+		rb_raise( rb_eTypeError, "wrong argument type %s (expected Zyre::Poller)",
+			rb_class2name(CLASS_OF( self )) );
+	}
+
+	ptr = DATA_PTR( self );
+	assert( ptr );
+
+	return ptr;
+}
+
+
+/*
+ * call-seq:
+ *    Zyre::Poller.new( *nodes )   -> poller
+ *
+ * Create a poller that will wait for input on any of the given +nodes+.
+ *
+ */
+static VALUE
+rzyre_poller_initialize( VALUE self, VALUE nodes )
+{
+	zpoller_t *ptr;
+
+	TypedData_Get_Struct( self, zpoller_t, &rzyre_poller_t, ptr );
+	if ( !ptr ) {
+		RTYPEDDATA_DATA( self ) = ptr = zpoller_new( NULL );
+		assert( ptr );
+
+		rb_ivar_set( self, rb_intern("@nodes"), rb_hash_new() );
+	}
+
+	rb_funcall( self, rb_intern("add"), 1, nodes );
+
+	return self;
+}
+
+
+/*
+ * call-seq:
+ *    poller.add( *nodes )
+ *
+ * Add the specified +nodes+ to the list which will be polled by a call to #wait.
+ *
+ */
+static VALUE
+rzyre_poller_add( VALUE self, VALUE nodes )
+{
+	zpoller_t *ptr = rzyre_get_poller( self );
+	VALUE nodemap = rb_ivar_get( self, rb_intern("@nodes") );
+	long i;
+
+	// For each node given, record its endpoint in @nodes so we can map it back to
+	// the node later and add it to the poller.
+	nodes = rb_funcall( nodes, rb_intern("flatten"), 0 );
+	for ( i=0; i < RARRAY_LEN(nodes); i++ ) {
+		VALUE node = RARRAY_AREF( nodes, i );
+		zyre_t *zyre_node = rzyre_get_node( node );
+		zsock_t *sock = zyre_socket( zyre_node );
+		const char *endpoint_str = zsock_endpoint( sock );
+
+		assert( endpoint_str );
+
+		rb_hash_aset( nodemap, rb_str_new2(endpoint_str), node );
+		zpoller_add( ptr, sock );
+	}
+
+	return Qtrue;
+}
+
+
+/*
+ * call-seq:
+ *    poller.nodes   -> hash
+ *
+ * Return a (frozen copy) of the Hash of the nodes the Poller will wait on.
+ *
+ */
+static VALUE
+rzyre_poller_nodes( VALUE self )
+{
+	VALUE rval = rb_obj_dup( rb_ivar_get(self, rb_intern( "@nodes" )) );
+
+	return rb_hash_freeze( rval );
+}
+
+
+/*
+ * call-seq:
+ *    poller.remove( *nodes )
+ *
+ * Add the specified +nodes+ to the list which will be polled by a call to #wait.
+ *
+ */
+static VALUE
+rzyre_poller_remove( VALUE self, VALUE nodes )
+{
+	zpoller_t *ptr = rzyre_get_poller( self );
+	VALUE nodemap = rb_ivar_get( self, rb_intern("@nodes") );
+	long i;
+
+	// For each node given, record its endpoint in @nodes so we can map it back to
+	// the node later and remove it to the poller.
+	nodes = rb_funcall( nodes, rb_intern("flatten"), 0 );
+	for ( i=0; i < RARRAY_LEN(nodes); i++ ) {
+		VALUE node = RARRAY_AREF( nodes, i );
+		zyre_t *zyre_node = rzyre_get_node( node );
+		zsock_t *sock = zyre_socket( zyre_node );
+		const char *endpoint_str = zsock_endpoint( sock );
+
+		assert( endpoint_str );
+
+		rb_hash_aset( nodemap, rb_str_new2(endpoint_str), node );
+		zpoller_remove( ptr, sock );
+	}
+
+	return Qtrue;
+}
+
+
+typedef struct {
+	zpoller_t *poller;
+	int timeout;
+} wait_call_t;
+
+/*
+ * Async wait function; called without the GVL.
+ */
+static void *
+rzyre_poller_wait_without_gvl( void *wait_call )
+{
+	wait_call_t *call = (wait_call_t *)wait_call;
+	return zpoller_wait( call->poller, call->timeout );
+}
+
+
+/*
+ * call-seq:
+ *    poller.wait( timeout=-1 )   -> node or nil
+ *
+ * Poll the registered nodes for I/O, return first one that has input. The
+ * timeout should be zero or greater, or -1 to wait indefinitely. Socket
+ * priority is defined by their order in the poll list. If the timeout expired,
+ * returns nil. If poll call is interrupted (SIGINT) or the ZMQ context was
+ * destroyed, an Interrupt is raised.
+ *
+ */
+static VALUE
+rzyre_poller_wait( int argc, VALUE *argv, VALUE self )
+{
+	zpoller_t *ptr = rzyre_get_poller( self );
+	VALUE rval = Qnil;
+	zsock_t *sock;
+	VALUE timeout_arg;
+	VALUE nodemap = rb_ivar_get( self, rb_intern("@nodes") );
+	int timeout = -1;
+	wait_call_t call;
+
+	if ( rb_scan_args(argc, argv, "01", &timeout_arg) ) {
+		timeout = floor( NUM2DBL(timeout_arg) * 1000 );
+	}
+
+	rzyre_log_obj( self, "debug", "waiting on %d socket/s (timeout: %d)",
+		 RHASH_SIZE(nodemap), timeout );
+
+	call.poller = ptr;
+	call.timeout = timeout;
+	sock = (zsock_t *)rb_thread_call_without_gvl2( rzyre_poller_wait_without_gvl, (void *)&call,
+		RUBY_UBF_IO, 0 );
+
+	if ( sock ) {
+		const char *endpoint = zsock_endpoint( sock );
+		rval = rb_hash_aref( nodemap, rb_str_new2(endpoint) );
+	}
+
+	return rval;
+}
+
+
+
+/*
+ * Initialize the Poller class.
+ */
+void
+rzyre_init_poller( void ) {
+
+#ifdef FOR_RDOC
+	rb_cData = rb_define_class( "Data" );
+	rzyre_mZyre = rb_define_module( "Zyre" );
+#endif
+
+	/*
+	 * Document-class: Zyre::Poller
+	 *
+	 * A poller for evented Zyre IO. Built on zpoller from czmq.
+	 *
+	 * Refs:
+	 * - http://api.zeromq.org/czmq3-0:zpoller
+	 *
+	 */
+	rzyre_cZyrePoller = rb_define_class_under( rzyre_mZyre, "Poller", rb_cObject );
+
+	rb_define_alloc_func( rzyre_cZyrePoller, rzyre_poller_alloc );
+
+	rb_define_protected_method( rzyre_cZyrePoller, "initialize", rzyre_poller_initialize, -2 );
+
+	rb_define_method( rzyre_cZyrePoller, "add", rzyre_poller_add, -2 );
+	rb_define_method( rzyre_cZyrePoller, "nodes", rzyre_poller_nodes, 0 );
+	rb_define_method( rzyre_cZyrePoller, "remove", rzyre_poller_remove, 1 );
+	rb_define_method( rzyre_cZyrePoller, "wait", rzyre_poller_wait, -1 );
+
+	rb_require( "zyre/poller" );
+}
+

data/ext/zyre_ext/zyre_ext.c

@@ -0,0 +1,154 @@
+/*
+ *  zyre_ext.c - Ruby binding for Zyre
+ *  $Id$
+ *
+ *  Authors:
+ *    * Michael Granger <ged@FaerieMUD.org>
+ *
+ */
+
+#include "zyre_ext.h"
+
+VALUE rzyre_mZyre;
+
+
+/* --------------------------------------------------------------
+ * Logging Functions
+ * -------------------------------------------------------------- */
+
+/*
+ * Log a message to the given +context+ object's logger.
+ */
+void
+#ifdef HAVE_STDARG_PROTOTYPES
+rzyre_log_obj( VALUE context, const char *level, const char *fmt, ... )
+#else
+rzyre_log_obj( VALUE context, const char *level, const char *fmt, va_dcl )
+#endif
+{
+	char buf[BUFSIZ];
+	va_list	args;
+	VALUE logger = Qnil;
+	VALUE message = Qnil;
+
+	va_init_list( args, fmt );
+	vsnprintf( buf, BUFSIZ, fmt, args );
+	message = rb_str_new2( buf );
+
+	logger = rb_funcall( context, rb_intern("log"), 0 );
+	rb_funcall( logger, rb_intern(level), 1, message );
+
+	va_end( args );
+}
+
+
+/*
+ * Log a message to the global logger.
+ */
+void
+#ifdef HAVE_STDARG_PROTOTYPES
+rzyre_log( const char *level, const char *fmt, ... )
+#else
+rzyre_log( const char *level, const char *fmt, va_dcl )
+#endif
+{
+	char buf[BUFSIZ];
+	va_list	args;
+	VALUE logger = Qnil;
+	VALUE message = Qnil;
+
+	va_init_list( args, fmt );
+	vsnprintf( buf, BUFSIZ, fmt, args );
+	message = rb_str_new2( buf );
+
+	logger = rb_funcall( rzyre_mZyre, rb_intern("logger"), 0 );
+	rb_funcall( logger, rb_intern(level), 1, message );
+
+	va_end( args );
+}
+
+
+
+/* --------------------------------------------------------------
+ * Module methods
+ * -------------------------------------------------------------- */
+
+/*
+ * call-seq:
+ *    Zyre.zyre_version   -> int
+ *
+ * Return the version of the underlying libzyre.
+ *
+ */
+static VALUE
+rzyre_s_zyre_version()
+{
+	static uint64_t version;
+
+	version = zyre_version();
+
+	return INT2NUM( version );
+}
+
+
+/*
+ * call-seq:
+ *    Zyre.interfaces   -> hash
+ *
+ * Return a Hash of broadcast-capable interfaces on the local host keyed by name. The
+ * values contain other information about the interface:
+ *
+ *    {
+ *      "<interface name>" => {
+ *        address: "<interface address>",
+ *        broadcast: "<interface broadcast address>",
+ *        netmask: "<interface network mask>",
+ *      }
+ *    }
+ */
+static VALUE
+rzyre_s_interfaces()
+{
+	ziflist_t *iflist = ziflist_new();
+	const VALUE rval = rb_hash_new();
+	const char *iface = ziflist_first( iflist );
+
+	while ( iface ) {
+		const char *address_s = ziflist_address( iflist );
+		const char *broadcast_s = ziflist_broadcast( iflist );
+		const char *netmask_s = ziflist_netmask( iflist );
+		const VALUE info_hash = rb_hash_new();
+
+		rb_hash_aset( info_hash, ID2SYM(rb_intern("address")), rb_usascii_str_new_cstr(address_s) );
+		rb_hash_aset( info_hash, ID2SYM(rb_intern("broadcast")), rb_usascii_str_new_cstr(broadcast_s) );
+		rb_hash_aset( info_hash, ID2SYM(rb_intern("netmask")), rb_usascii_str_new_cstr(netmask_s) );
+
+		rb_hash_aset( rval, rb_usascii_str_new_cstr(iface), info_hash );
+
+		iface = ziflist_next( iflist );
+	}
+
+	ziflist_destroy( &iflist );
+
+	return rval;
+}
+
+
+/*
+ * Zyre extension init function
+ */
+void
+Init_zyre_ext()
+{
+	rzyre_mZyre = rb_define_module( "Zyre" );
+
+	rb_define_singleton_method( rzyre_mZyre, "zyre_version", rzyre_s_zyre_version, 0 );
+	rb_define_singleton_method( rzyre_mZyre, "interfaces", rzyre_s_interfaces, 0 );
+
+	// :TODO: set up zsys_set_logsender()
+
+	rzyre_init_node();
+	rzyre_init_event();
+	rzyre_init_poller();
+}
+

data/ext/zyre_ext/zyre_ext.h

@@ -0,0 +1,99 @@
+/*
+ *  zyre_ext.h - Ruby binding for Zyre
+ *  $Id$
+ *
+ *  Authors:
+ *    * Michael Granger <ged@FaerieMUD.org>
+ *
+ */
+
+#ifndef ZYRE_EXT_H_90322ABD
+#define ZYRE_EXT_H_90322ABD
+
+#include <ruby.h>
+#include <ruby/intern.h>
+#include <ruby/thread.h>
+
+#include "zyre.h"
+#include "czmq.h"
+#include "extconf.h"
+
+#ifndef TRUE
+# define TRUE    1
+#endif
+
+#ifndef FALSE
+# define FALSE   0
+#endif
+
+
+// For synthesized events
+struct _zyre_event_t {
+    char *type;             //  Event type as string
+    char *peer_uuid;        //  Sender UUID as string
+    char *peer_name;        //  Sender public name as string
+    char *peer_addr;        //  Sender ipaddress as string, for an ENTER event
+    zhash_t *headers;       //  Headers, for an ENTER event
+    char *group;            //  Group name for a SHOUT event
+    zmsg_t *msg;            //  Message payload for SHOUT or WHISPER
+};
+
+
+/* --------------------------------------------------------------
+ * Declarations
+ * -------------------------------------------------------------- */
+
+#ifdef HAVE_STDARG_PROTOTYPES
+#include <stdarg.h>
+#define va_init_list(a,b) va_start(a,b)
+void rzyre_log_obj( VALUE, const char *, const char *, ... );
+void rzyre_log( const char *, const char *, ... );
+#else
+#include <varargs.h>
+#define va_init_list(a,b) va_start(a)
+void rzyre_log_obj( VALUE, const char *, const char *, va_dcl );
+void rzyre_log( const char *, const char *, va_dcl );
+#endif
+
+
+/* --------------------------------------------------------------
+ * Structs
+ * -------------------------------------------------------------- */
+
+
+
+/* -------------------------------------------------------
+ * Globals
+ * ------------------------------------------------------- */
+
+/*
+ * Modules
+ */
+extern VALUE rzyre_mZyre;
+extern VALUE rzyre_cZyreNode;
+extern VALUE rzyre_cZyreEvent;
+extern VALUE rzyre_cZyrePoller;
+
+
+/* --------------------------------------------------------------
+ * Type-check macros
+ * -------------------------------------------------------------- */
+
+#define IsZyreNode( obj ) rb_obj_is_kind_of( (obj), rzyre_cZyreNode )
+#define IsZyreEvent( obj ) rb_obj_is_kind_of( (obj), rzyre_cZyreEvent )
+#define IsZyrePoller( obj ) rb_obj_is_kind_of( (obj), rzyre_cZyrePoller )
+
+
+/* -------------------------------------------------------
+ * Initializer functions
+ * ------------------------------------------------------- */
+extern void Init_zyre_ext _(( void ));
+
+extern void rzyre_init_node _(( void ));
+extern void rzyre_init_event _(( void ));
+extern void rzyre_init_poller _(( void ));
+
+extern zyre_t * rzyre_get_node _(( VALUE ));
+
+#endif /* end of include guard: ZYRE_EXT_H_90322ABD */
+