zyre 0.3.1 → 0.4.0

data/ext/zyre_ext/event.c

@@ -15,14 +15,13 @@ VALUE rzyre_cZyreEvent;
 static void rzyre_event_free( void *ptr );
 
 static const rb_data_type_t rzyre_event_t = {
-	"Zyre::Event",
-	{
-		NULL,
-		rzyre_event_free
+	.wrap_struct_name = "Zyre::Event",
+	.function = {
+		.dmark = NULL,
+		.dfree = rzyre_event_free,
 	},
-	0,
-	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
 
@@ -78,7 +77,7 @@ rzyre_read_event( void *node_ptr )
 	assert( node_ptr );
 
 	event_ptr = zyre_event_new( (zyre_t *)node_ptr );
-	assert( event_ptr );
+
 	return (void *)event_ptr;
 }
 
@@ -104,7 +103,13 @@ rzyre_event_s_from_node( VALUE klass, VALUE node )
 		const char *event_type = zyre_event_type( event );
 		VALUE event_type_s = rb_utf8_str_new_cstr( event_type );
 		VALUE event_class = rb_funcall( klass, rb_intern("type_by_name"), 1, event_type_s );
-		VALUE event_instance = rb_class_new_instance( 0, NULL, event_class );
+		VALUE event_instance;
+
+		if ( !RTEST(event_class) ) {
+			rb_raise( rb_eRuntimeError, "Unhandled event type '%s'", event_type );
+		}
+
+		event_instance = rb_class_new_instance( 0, NULL, event_class );
 
 		RTYPEDDATA_DATA( event_instance ) = event;
 
@@ -263,6 +268,9 @@ rzyre_event_s_synthesize( int argc, VALUE *argv, VALUE klass )
 		ptr->group = rzyre_copy_required_string( kwvals[3], "group" );
 		ptr->msg = rzyre_make_zmsg_from( kwvals[4] );
 	}
+	else if ( streq(ptr->type, "LEADER") ) {
+		ptr->group = rzyre_copy_required_string( kwvals[3], "group" );
+	}
 
 	rzyre_log_obj( rval, "debug", "Synthesized a %s event.", ptr->type );
 

data/ext/zyre_ext/extconf.rb

@@ -19,6 +19,11 @@ have_header( 'ruby/thread.h' ) or
 
 have_func( 'zyre_set_name', 'zyre.h' )
 have_func( 'zyre_set_silent_timeout', 'zyre.h' )
+have_func( 'zyre_set_beacon_peer_port', 'zyre.h' )
+have_func( 'zyre_set_contest_in_group', 'zyre.h' )
+have_func( 'zyre_set_zcert', 'zyre.h' )
+
+have_func( 'zcert_unset_meta', 'czmq.h' )
 
 create_header()
 create_makefile( 'zyre_ext' )

data/ext/zyre_ext/node.c

@@ -8,21 +8,26 @@
  */
 
 #include "zyre_ext.h"
+#include "extconf.h"
 
 
 VALUE rzyre_cZyreNode;
 
+// Null key; means curve isn't available or the secret side of a public cert.
+#define FORTY_ZEROES "0000000000000000000000000000000000000000"
+
+
 static void rzyre_node_free( void *ptr );
 
+
 static const rb_data_type_t rzyre_node_t = {
-	"Zyre::Node",
-	{
-		NULL,
-		rzyre_node_free
+	.wrap_struct_name = "Zyre::Node",
+	.function = {
+		.dmark = NULL,
+		.dfree = rzyre_node_free,
 	},
-	0,
-	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
 
@@ -38,6 +43,7 @@ rzyre_node_free( void *ptr )
 }
 
 
+
 /*
  * Alloc function
  */
@@ -512,9 +518,7 @@ rzyre_node_leave( VALUE self, VALUE group )
  * call-seq:
  *    node.recv -> zyre_event
  *
- * Receive the next event from the network; the message may be a control
- * message (ENTER, EXIT, JOIN, LEAVE) or data (WHISPER, SHOUT).
- * Returns a Zyre::Event.
+ * Receive the next event from the network as a Zyre::Event.
  *
  */
 static VALUE
@@ -771,6 +775,241 @@ rzyre_node_print( VALUE self )
 }
 
 
+/* --------------------------------------------------------------
+ * Draft API
+ * -------------------------------------------------------------- */
+
+
+#define RAISE_NO_DRAFT_APIS()\
+	rb_raise( rb_eNotImpError, "Zyre was not built with Draft APIs!" ); \
+	return Qnil;
+
+/*
+ * call-seq:
+ *   node.beacon_peer_port = 16668
+ *
+ * Set the TCP port bound by the ROUTER peer-to-peer socket (beacon mode).
+ * Defaults to * (the port is randomly assigned by the system).
+ * This call overrides this, to bypass some firewall issues when ports are
+ * random. Has no effect after #start.
+ *
+ * Note: this is part of the ZRE 43 Draft API, and may be changed or
+ * removed at any time.
+ */
+static VALUE
+rzyre_node_beacon_peer_port_eq( VALUE self, VALUE port_number )
+{
+#ifdef ZYRE_BUILD_DRAFT_API
+	zyre_t *ptr = rzyre_get_node( self );
+
+	zyre_set_beacon_peer_port( ptr, FIX2INT(port_number) );
+
+	return port_number;
+#else
+	RAISE_NO_DRAFT_APIS();
+#endif // ZYRE_BUILD_DRAFT_API
+}
+
+
+/*
+ * call-seq:
+ *   node.set_contest_in_group( group )
+ *
+ * This options enables a peer to actively contest for leadership in the
+ * given +group+. If this option is not set the peer will still participate in
+ * elections but never gets elected. This ensures that a consent for a leader
+ * is reached within a group even though not every peer is contesting for
+ * leadership.
+ *
+ * Note: this is part of the ZRE 43 Draft API, and may be changed or
+ * removed at any time.
+ */
+static VALUE
+rzyre_node_set_contest_in_group( VALUE self, VALUE group_name )
+{
+#ifdef ZYRE_BUILD_DRAFT_API
+	zyre_t *ptr = rzyre_get_node( self );
+	const char *group_str = StringValueCStr( group_name );
+
+	zyre_set_contest_in_group( ptr, group_str );
+
+	return group_name;
+#else
+	RAISE_NO_DRAFT_APIS();
+#endif // ZYRE_BUILD_DRAFT_API
+}
+
+
+/*
+ * call-seq:
+ *   node.advertised_endpoint = endpoint
+ *
+ * Set an alternative +endpoint+ value when using GOSSIP ONLY. This is useful
+ * if you're advertising an endpoint behind a NAT.
+ *
+ * Note: this is part of the ZRE 43 Draft API, and may be changed or
+ * removed at any time.
+ */
+static VALUE
+rzyre_node_advertised_endpoint_eq( VALUE self, VALUE endpoint )
+{
+#ifdef ZYRE_BUILD_DRAFT_API
+	zyre_t *ptr = rzyre_get_node( self );
+	const char *endpoint_str = StringValueCStr( endpoint );
+
+	zyre_set_advertised_endpoint( ptr, endpoint_str );
+
+	return endpoint;
+#else
+	RAISE_NO_DRAFT_APIS();
+#endif // ZYRE_BUILD_DRAFT_API
+}
+
+
+/*
+ * call-seq:
+ *   node.zcert = zcert
+ *
+ * Apply a +zcert+ to a Zyre node. See Zyre::Cert#apply and
+ * Authentication[rdoc-ref:Authentication].
+ *
+ * Note: this is part of the ZRE 43 Draft API, and may be changed or
+ * removed at any time.
+ */
+static VALUE
+rzyre_node_zcert_eq( VALUE self, VALUE cert )
+{
+#ifdef ZYRE_BUILD_DRAFT_API
+	zyre_t *ptr = rzyre_get_node( self );
+	zcert_t *zcert = rzyre_get_cert( cert );
+
+	if ( streq(zcert_secret_txt(zcert), FORTY_ZEROES) ) {
+		rb_raise( rb_eArgError,
+			"can't use this cert for authentication (no curve or missing secret key)" );
+	}
+
+	zyre_set_zcert( ptr, zcert );
+
+	return Qtrue;
+#else
+	RAISE_NO_DRAFT_APIS();
+#endif // ZYRE_BUILD_DRAFT_API
+}
+
+
+/*
+ * call-seq:
+ *   node.zap_domain = domain
+ *
+ * Specify the ZAP domain (for use with CURVE authentication). See
+ * Authentication[rdoc-ref:Authentication].
+ *
+ * Note: this is part of the ZRE 43 Draft API, and may be changed or
+ * removed at any time.
+ */
+static VALUE
+rzyre_node_zap_domain_eq( VALUE self, VALUE domain )
+{
+#ifdef ZYRE_BUILD_DRAFT_API
+	zyre_t *ptr = rzyre_get_node( self );
+	const char *domain_str = StringValueCStr( domain );
+
+	zyre_set_zap_domain( ptr, domain_str );
+
+	return Qtrue;
+#else
+	RAISE_NO_DRAFT_APIS();
+#endif // ZYRE_BUILD_DRAFT_API
+}
+
+
+/*
+ * call-seq:
+ *   node.gossip_connect_curve( public_key, endpoint )
+ *
+ * Connect to the gossip discovery endpoint with CURVE enabled. The +public_key+ is the
+ * Z85-armored public key of the connecting node's cert/
+ *
+ * Note: this is part of the ZRE 43 Draft API, and may be changed or
+ * removed at any time.
+ */
+static VALUE
+rzyre_node_gossip_connect_curve( VALUE self, VALUE public_key, VALUE endpoint )
+{
+#ifdef ZYRE_BUILD_DRAFT_API
+	zyre_t *ptr = rzyre_get_node( self );
+	const char *endpoint_str = StringValueCStr( endpoint );
+	const char *key = StringValueCStr( public_key );
+
+	assert( endpoint_str );
+	assert( key );
+
+	rzyre_log_obj( self, "debug", "Connecting to gossip endpoint %s (CURVE enabled).", endpoint_str );
+	zyre_gossip_connect_curve( ptr, key, "%s", endpoint_str );
+
+	return Qtrue;
+#else
+	RAISE_NO_DRAFT_APIS();
+#endif // ZYRE_BUILD_DRAFT_API
+}
+
+
+/*
+ * call-seq:
+ *   node.gossip_unpublish( node_uuid )
+ *
+ * Unpublish a GOSSIP node from local list, useful in removing nodes from list
+ * when they EXIT.
+ *
+ * Note: this is part of the ZRE 43 Draft API, and may be changed or
+ * removed at any time.
+ */
+static VALUE
+rzyre_node_gossip_unpublish( VALUE self, VALUE node_uuid )
+{
+#ifdef ZYRE_BUILD_DRAFT_API
+	zyre_t *ptr = rzyre_get_node( self );
+	const char *node = StringValueCStr( node_uuid );
+
+	zyre_gossip_unpublish( ptr, node );
+
+	return Qtrue;
+#else
+	RAISE_NO_DRAFT_APIS();
+#endif // ZYRE_BUILD_DRAFT_API
+}
+
+
+/*
+ * call-seq:
+ *   node.require_peer( node_uuid, router_endpoint, public_key )
+ *
+ * Explicitly connect to a peer with the given +node_uuid+ via the specified
+ * +router_endpoint+, using the given +public_key+ to authenticate.
+ *
+ * Note: this is part of the ZRE 43 Draft API, and may be changed or
+ * removed at any time.
+ */
+static VALUE
+rzyre_node_require_peer( VALUE self, VALUE uuid, VALUE endpoint, VALUE public_key )
+{
+#ifdef ZYRE_BUILD_DRAFT_API
+	zyre_t *ptr = rzyre_get_node( self );
+	const char *uuid_str = StringValueCStr( uuid ),
+		*endpoint_str = StringValueCStr( endpoint ),
+		*key_str = StringValueCStr( public_key );
+	int rval;
+
+	rval = zyre_require_peer( ptr, uuid_str, endpoint_str, key_str );
+
+	return rval == 0 ? Qtrue : Qfalse;
+#else
+	RAISE_NO_DRAFT_APIS();
+#endif // ZYRE_BUILD_DRAFT_API
+}
+
+
+
 /*
  * Node class init
  */
@@ -791,7 +1030,11 @@ rzyre_init_node( void )
 	 * Refs:
 	 * - https://github.com/zeromq/zyre#readme
 	 */
+#if RUBY_API_VERSION_MAJOR >= 3
+	rzyre_cZyreNode = rb_define_class_under( rzyre_mZyre, "Node", rb_cObject );
+#else
 	rzyre_cZyreNode = rb_define_class_under( rzyre_mZyre, "Node", rb_cData );
+#endif
 
 	rb_define_alloc_func( rzyre_cZyreNode, rzyre_node_alloc );
 
@@ -838,18 +1081,14 @@ rzyre_init_node( void )
 	rb_define_method( rzyre_cZyreNode, "verbose!", rzyre_node_verbose_bang, 0 );
 	rb_define_method( rzyre_cZyreNode, "print", rzyre_node_print, 0 );
 
-#ifdef ZYRE_BUILD_DRAFT_API
-
-	rb_define_method( rzyre_cZyreNode, "set_beacon_peer_port", rzyre_node_set_beacon_peer_port, -1 );
-	rb_define_method( rzyre_cZyreNode, "set_contest_in_group", rzyre_node_set_contest_in_group, -1 );
-	rb_define_method( rzyre_cZyreNode, "set_advertised_endpoint", rzyre_node_set_advertised_endpoint, -1 );
-	rb_define_method( rzyre_cZyreNode, "set_zcert", rzyre_node_set_zcert, -1 );
-	rb_define_method( rzyre_cZyreNode, "set_zap_domain", rzyre_node_set_zap_domain, -1 );
-	rb_define_method( rzyre_cZyreNode, "gossip_connect_curve", rzyre_node_gossip_connect_curve, -1 );
-	rb_define_method( rzyre_cZyreNode, "gossip_unpublish", rzyre_node_gossip_unpublish, -1 );
-	rb_define_method( rzyre_cZyreNode, "require_peer", rzyre_node_require_peer, -1 );
-
-#endif // ZYRE_BUILD_DRAFT_API
+	rb_define_method( rzyre_cZyreNode, "beacon_peer_port=", rzyre_node_beacon_peer_port_eq, 1 );
+	rb_define_method( rzyre_cZyreNode, "set_contest_in_group", rzyre_node_set_contest_in_group, 1 );
+	rb_define_method( rzyre_cZyreNode, "advertised_endpoint=", rzyre_node_advertised_endpoint_eq, 1 );
+	rb_define_method( rzyre_cZyreNode, "zcert=", rzyre_node_zcert_eq, 1 );
+	rb_define_method( rzyre_cZyreNode, "zap_domain=", rzyre_node_zap_domain_eq, 1 );
+	rb_define_method( rzyre_cZyreNode, "gossip_connect_curve", rzyre_node_gossip_connect_curve, 2 );
+	rb_define_method( rzyre_cZyreNode, "gossip_unpublish", rzyre_node_gossip_unpublish, 1 );
+	rb_define_method( rzyre_cZyreNode, "require_peer", rzyre_node_require_peer, 3 );
 
 	rb_require( "zyre/node" );
 }

data/ext/zyre_ext/poller.c

@@ -15,14 +15,13 @@ 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
+	.wrap_struct_name = "Zyre::Poller",
+	.function = {
+		.dmark = NULL,
+		.dfree = rzyre_poller_free,
 	},
-	0,
-	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
 

data/ext/zyre_ext/zyre_ext.c

@@ -168,7 +168,7 @@ rzyre_s_zyre_version()
  *    }
  */
 static VALUE
-rzyre_s_interfaces()
+rzyre_s_interfaces( VALUE module )
 {
 	ziflist_t *iflist = ziflist_new();
 	const VALUE rval = rb_hash_new();
@@ -195,6 +195,30 @@ rzyre_s_interfaces()
 }
 
 
+/*
+ * call-seq:
+ *    Zyre.disable_zsys_handler
+ *
+ * Disable CZMQ's default signal handler, which allows for handling it in Ruby instead.
+ *
+ */
+static VALUE
+rzyre_s_disable_zsys_handler( VALUE module )
+{
+	rzyre_log( "info", "Disabling zsys INT/TERM handler." );
+	zsys_handler_set( NULL );
+	return Qtrue;
+}
+
+
+
+static VALUE
+rzyre_s_start_authenticator( VALUE module )
+{
+	return Qnil;
+}
+
+
 /*
  * Zyre extension init function
  */
@@ -203,13 +227,31 @@ Init_zyre_ext()
 {
 	rzyre_mZyre = rb_define_module( "Zyre" );
 
+#ifdef CZMQ_BUILD_DRAFT_API
+	rb_define_const( rzyre_mZyre, "BUILT_WITH_DRAFT_CZMQ_API", Qtrue );
+#else
+	rb_define_const( rzyre_mZyre, "BUILT_WITH_DRAFT_CZMQ_API", Qfalse );
+#endif
+#ifdef ZYRE_BUILD_DRAFT_API
+	rb_define_const( rzyre_mZyre, "BUILT_WITH_DRAFT_API", Qtrue );
+#else
+	rb_define_const( rzyre_mZyre, "BUILT_WITH_DRAFT_API", Qfalse );
+#endif
+
 	rb_define_singleton_method( rzyre_mZyre, "zyre_version", rzyre_s_zyre_version, 0 );
 	rb_define_singleton_method( rzyre_mZyre, "interfaces", rzyre_s_interfaces, 0 );
+	rb_define_singleton_method( rzyre_mZyre, "disable_zsys_handler", rzyre_s_disable_zsys_handler, 0 );
+
+	// :TODO: Allow for startup of the zauth agent. This will require enough of a
+	// subset of CZMQ that I hesitate to do it in Zyre. Maybe better to just write a
+	// decent CZMQ library instead?
+	rb_define_singleton_method( rzyre_mZyre, "start_authenticator", rzyre_s_start_authenticator, 0 );
 
 	// :TODO: set up zsys_set_logsender()
 
 	rzyre_init_node();
 	rzyre_init_event();
 	rzyre_init_poller();
+	rzyre_init_cert();
 }