zyre 0.1.0 → 0.4.1

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;
 
@@ -121,6 +126,7 @@ rzyre_copy_string( VALUE string )
 	const char *c_string = StringValueCStr( string );
 	char *copy = (char *) zmalloc( strnlen(c_string, BUFSIZ) + 1 );
 
+	rzyre_log( "debug", "Copying string `%s`.", c_string );
 	assert( copy );
 	stpncpy( copy, c_string, strnlen(c_string, BUFSIZ) + 1 );
 
@@ -134,6 +140,7 @@ rzyre_copy_required_string( VALUE string, const char *field_name )
 	if ( RB_TYPE_P(string, T_UNDEF) ) {
 		rb_raise( rb_eArgError, "missing required field :%s", field_name );
 	} else {
+		rzyre_log( "debug", "Required field %s is defined.", field_name );
 		return rzyre_copy_string( string );
 	}
 }
@@ -182,27 +189,37 @@ static VALUE
 rzyre_event_s_synthesize( int argc, VALUE *argv, VALUE klass )
 {
 	VALUE rval, event_type, peer_uuid, kwargs, event_class;
-	static VALUE kwvals[5];
+	VALUE kwvals[5] = { Qundef, Qundef, Qundef, Qundef, Qundef };
 	static ID keyword_ids[5];
 	zyre_event_t *ptr = NULL;
 
 	// Parse the arguments + keyword arguments
 	if ( !keyword_ids[0] ) {
-		CONST_ID( keyword_ids[0], "peer_name");
-		CONST_ID( keyword_ids[1], "headers");
-		CONST_ID( keyword_ids[2], "peer_addr");
-		CONST_ID( keyword_ids[3], "group");
-		CONST_ID( keyword_ids[4], "msg");
+		CONST_ID( keyword_ids[0], "peer_name" );
+		CONST_ID( keyword_ids[1], "headers" );
+		CONST_ID( keyword_ids[2], "peer_addr" );
+		CONST_ID( keyword_ids[3], "group" );
+		CONST_ID( keyword_ids[4], "msg" );
 	}
 
+	rzyre_log( "debug", "Scanning %d synthesize args.", argc );
 	rb_scan_args( argc, argv, "2:", &event_type, &peer_uuid, &kwargs );
 	if ( RTEST(kwargs) ) {
+		rzyre_log( "debug", "  scanning keyword args: %s", RSTRING_PTR(rb_inspect(kwargs)) );
 		rb_get_kwargs( kwargs, keyword_ids, 0, 5, kwvals );
 	}
 
 	// Translate the event type argument into the appropriate class and instantiate it
+	rzyre_log( "debug", "Creating an instance of a %s event.", RSTRING_PTR(rb_inspect(event_type )) );
 	event_class = rb_funcall( klass, rb_intern("type_by_name"), 1, event_type );
-	event_type = rb_funcall( event_class, rb_intern("type_name"), 0 );
+
+	if ( RTEST(event_class) ) {
+		event_type = rb_funcall( event_class, rb_intern("type_name"), 0 );
+	} else {
+		rb_raise( rb_eArgError, "don't know how to create %s events",
+			RSTRING_PTR(rb_inspect(event_type)) );
+	}
+
 	rval = rb_class_new_instance( 0, NULL, event_class );
 
 	// Set up the zyre_event memory for the object
@@ -213,6 +230,7 @@ rzyre_event_s_synthesize( int argc, VALUE *argv, VALUE klass )
 	ptr->peer_uuid = rzyre_copy_string( peer_uuid );
 
 	// Set the peer_name or default it if it wasn't specified
+	rzyre_log( "debug", "Starting type-specific setup." );
 	if ( !RB_TYPE_P(kwvals[0], T_UNDEF) ) {
 		ptr->peer_name = rzyre_copy_string( kwvals[0] );
 	} else {
@@ -234,27 +252,28 @@ rzyre_event_s_synthesize( int argc, VALUE *argv, VALUE klass )
 		ptr->group = rzyre_copy_required_string( kwvals[3], "group" );
 	}
 	else if ( streq(ptr->type, "WHISPER") ) {
-		const char *msg_str = rzyre_copy_required_string( kwvals[4], "msg" );
-		zmsg_t *msg = zmsg_new();
+		if ( RB_TYPE_P(kwvals[4], T_UNDEF) )
+			rb_raise( rb_eArgError, "missing required field :msg" );
 
-		zmsg_addstr( msg, msg_str );
-		ptr->msg = msg;
-		msg = NULL;
+		rzyre_log( "debug", "Making a WHISPER zmsg from the :msg value: %s",
+			RSTRING_PTR(rb_inspect(kwvals[4])) );
+		ptr->msg = rzyre_make_zmsg_from( kwvals[4] );
 	}
 	else if ( streq(ptr->type, "SHOUT") ) {
-		const char *msg_str = rzyre_copy_required_string( kwvals[4], "msg" );
-		zmsg_t *msg = zmsg_new();
-
-		zmsg_addstr( msg, msg_str );
+		if ( RB_TYPE_P(kwvals[4], T_UNDEF) )
+			rb_raise( rb_eArgError, "missing required field :msg" );
 
+		rzyre_log( "debug", "Making a SHOUT zmsg from the :msg value: %s",
+			RSTRING_PTR(rb_inspect(kwvals[4])) );
 		ptr->group = rzyre_copy_required_string( kwvals[3], "group" );
-		ptr->msg = msg;
-		msg = NULL;
+		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 );
+
 	return rval;
 }
 
@@ -397,9 +416,32 @@ rzyre_event_group( VALUE self ) {
 
 /*
  * call-seq:
- *    event.event_msg
+ *    event.msg_size   -> int
+ *
+ * Return the number of frames present in the event's message (if it has one). Returns
+ * nil if there is no message.
  *
- * Returns the incoming message payload.
+ */
+static VALUE
+rzyre_event_msg_size( VALUE self )
+{
+	zyre_event_t *ptr = rzyre_get_event( self );
+	zmsg_t *msg = zyre_event_msg( ptr );
+	VALUE rval = Qnil;
+
+	if ( msg ) {
+		rval = INT2FIX( zmsg_size(msg) );
+	}
+
+	return rval;
+}
+
+
+/*
+ * call-seq:
+ *    event.msg
+ *
+ * Returns the data from the first frame of the message from the receiver.
  */
 static VALUE
 rzyre_event_msg( VALUE self ) {
@@ -407,15 +449,43 @@ rzyre_event_msg( VALUE self ) {
 	zmsg_t *msg = zyre_event_msg( ptr );
 	VALUE rval = Qnil;
 
-	// :TODO: Support multipart messages when Zyre does.
 	if ( msg ) {
 		zframe_t *frame = zmsg_first( msg );
-		char *str = zframe_strdup( frame );
+		byte *data = zframe_data( frame );
 
-		rval = rb_utf8_str_new( str, zframe_size(frame) );
+		rval = rb_enc_str_new( (const char *)data, zframe_size(frame), rb_ascii8bit_encoding() );
 		rb_obj_freeze( rval );
+	}
+
+	return rval;
+}
+
 
-		free( str );
+/*
+ * call-seq:
+ *    event.multipart_msg
+ *
+ * Returns the data from every frame of the message from the receiver.
+ */
+static VALUE
+rzyre_event_multipart_msg( VALUE self ) {
+	zyre_event_t *ptr = rzyre_get_event( self );
+	zmsg_t *msg = zyre_event_msg( ptr );
+	VALUE rval = rb_ary_new();
+
+	if ( msg ) {
+		zframe_t *frame = zmsg_first( msg );
+
+		while ( frame ) {
+			char *str = zframe_strdup( frame );
+			VALUE data = rb_enc_str_new( str, zframe_size(frame), rb_ascii8bit_encoding() );
+
+			rb_obj_freeze( data );
+			rb_ary_push( rval, data );
+
+			free( str );
+			frame = zmsg_next( msg );
+		}
 	}
 
 	return rval;
@@ -471,7 +541,9 @@ rzyre_init_event( void ) {
 	rb_define_method( rzyre_cZyreEvent, "headers", rzyre_event_headers, 0 );
 	rb_define_method( rzyre_cZyreEvent, "header", rzyre_event_header, 1 );
 	rb_define_method( rzyre_cZyreEvent, "group", rzyre_event_group, 0 );
+	rb_define_method( rzyre_cZyreEvent, "msg_size", rzyre_event_msg_size, 0 );
 	rb_define_method( rzyre_cZyreEvent, "msg", rzyre_event_msg, 0 );
+	rb_define_method( rzyre_cZyreEvent, "multipart_msg", rzyre_event_multipart_msg, 0 );
 	rb_define_method( rzyre_cZyreEvent, "print", rzyre_event_print, 0 );
 
 	rb_require( "zyre/event" );

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
@@ -526,23 +530,26 @@ rzyre_node_recv( VALUE self )
 
 /*
  * call-seq:
- *    node.whisper( peer_uuid, message )  -> int
+ *    node.whisper( peer_uuid, *messages )  -> int
  *
  * Send a +message+ to a single +peer+ specified as a UUID string.
  *
  */
 static VALUE
-rzyre_node_whisper( VALUE self, VALUE peer_uuid, VALUE msg )
+rzyre_node_whisper( int argc, VALUE *argv, VALUE self )
 {
 	zyre_t *ptr = rzyre_get_node( self );
-	const char *peer_str = StringValueCStr( peer_uuid ),
-		*msg_str = StringValueCStr( msg );
+	VALUE peer_uuid, msg_parts;
+	char *peer_uuid_str;
+	zmsg_t *msg;
 	int rval;
 
-	assert( peer_str );
-	assert( msg_str );
+	rb_scan_args( argc, argv, "1*", &peer_uuid, &msg_parts );
+
+	peer_uuid_str = StringValueCStr( peer_uuid );
+	msg = rzyre_make_zmsg_from( msg_parts );
 
-	rval = zyre_whispers( ptr, peer_str, "%s", msg_str );
+	rval = zyre_whisper( ptr, peer_uuid_str, &msg );
 
 	return rval ? Qtrue : Qfalse;
 }
@@ -550,23 +557,26 @@ rzyre_node_whisper( VALUE self, VALUE peer_uuid, VALUE msg )
 
 /*
  * call-seq:
- *    node.shout( group, message )   -> int
+ *    node.shout( group, *messages )   -> int
  *
  * Send +message+ to a named +group+.
  *
  */
 static VALUE
-rzyre_node_shout( VALUE self, VALUE group, VALUE msg )
+rzyre_node_shout( int argc, VALUE *argv, VALUE self )
 {
 	zyre_t *ptr = rzyre_get_node( self );
-	const char *group_str = StringValueCStr( group ),
-		*msg_str = StringValueCStr( msg );
+	VALUE group, msg_parts;
+	char *group_str;
+	zmsg_t *msg;
 	int rval;
 
-	assert( group_str );
-	assert( msg_str );
+	rb_scan_args( argc, argv, "1*", &group, &msg_parts );
 
-	rval = zyre_shouts( ptr, group_str, "%s", msg_str );
+	group_str = StringValueCStr( group );
+	msg = rzyre_make_zmsg_from( msg_parts );
+
+	rval = zyre_shout( ptr, group_str, &msg );
 
 	return rval ? Qtrue : Qfalse;
 }
@@ -765,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
  */
@@ -785,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 );
 
@@ -819,8 +1068,8 @@ rzyre_init_node( void )
 
 	rb_define_method( rzyre_cZyreNode, "recv", rzyre_node_recv, 0 );
 
-	rb_define_method( rzyre_cZyreNode, "whisper", rzyre_node_whisper, 2 );
-	rb_define_method( rzyre_cZyreNode, "shout", rzyre_node_shout, 2 );
+	rb_define_method( rzyre_cZyreNode, "whisper", rzyre_node_whisper, -1 );
+	rb_define_method( rzyre_cZyreNode, "shout", rzyre_node_shout, -1 );
 
 	rb_define_method( rzyre_cZyreNode, "peers", rzyre_node_peers, 0 );
 	rb_define_method( rzyre_cZyreNode, "peers_by_group", rzyre_node_peers_by_group, 1 );
@@ -832,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" );
 }