zyre 0.1.0 → 0.4.1

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

@@ -68,6 +68,67 @@ rzyre_log( const char *level, const char *fmt, va_dcl )
 }
 
 
+/* --------------------------------------------------------------
+ * Utility functions
+ * -------------------------------------------------------------- */
+
+// Struct for passing arguments through rb_protect to rzyre_add_frames_to_zmsg()
+struct add_frames_to_zmsg_call {
+	zmsg_t *msg;
+	VALUE msg_parts;
+};
+typedef struct add_frames_to_zmsg_call add_frames_to_zmsg_call_t;
+
+
+/*
+ * Add a frame for each object in an Array.
+ */
+static VALUE
+rzyre_add_frames_to_zmsg( VALUE call )
+{
+	add_frames_to_zmsg_call_t *call_ptr = (add_frames_to_zmsg_call_t *)call;
+	VALUE msg_part, msg_str;
+	zframe_t *frame;
+
+	for ( long i = 0 ; i < RARRAY_LEN(call_ptr->msg_parts) ; i++ ) {
+		msg_part = rb_ary_entry(call_ptr->msg_parts, i);
+		msg_str = StringValue( msg_part );
+		frame = zframe_new( RSTRING_PTR(msg_str), RSTRING_LEN(msg_str) );
+		zmsg_append( call_ptr->msg, &frame );
+	}
+
+	return Qtrue;
+}
+
+
+/*
+ * Make and return a zmsg, with one frame per object in +messages+. Caller owns the returned
+ * zmsg. Can raise a TypeError if one of the +messages+ can't be stringified.
+ */
+zmsg_t *
+rzyre_make_zmsg_from( VALUE messages )
+{
+	VALUE msgarray = rb_Array( messages );
+	zmsg_t *msg = zmsg_new();
+	static add_frames_to_zmsg_call_t call;
+	int state;
+
+	call.msg = msg;
+	call.msg_parts = msgarray;
+
+	rb_protect( rzyre_add_frames_to_zmsg, (VALUE)&call, &state );
+
+	if ( state ) {
+		zmsg_destroy( &msg );
+		rb_jump_tag( state );
+	}
+
+	return msg;
+}
+
+
+
+
 
 /* --------------------------------------------------------------
  * Module methods
@@ -107,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();
@@ -134,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
  */
@@ -142,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();
 }
 

data/ext/zyre_ext/zyre_ext.h

@@ -10,13 +10,23 @@
 #ifndef ZYRE_EXT_H_90322ABD
 #define ZYRE_EXT_H_90322ABD
 
+#include "extconf.h"
+
 #include <ruby.h>
 #include <ruby/intern.h>
 #include <ruby/thread.h>
+#include <ruby/encoding.h>
+#include <ruby/version.h>
+
+#ifdef HAVE_ZCERT_UNSET_META
+#	define CZMQ_BUILD_DRAFT_API 1
+#endif
+#ifdef HAVE_ZYRE_SET_BEACON_PEER_PORT
+#	define ZYRE_BUILD_DRAFT_API 1
+#endif
 
 #include "zyre.h"
 #include "czmq.h"
-#include "extconf.h"
 
 #ifndef TRUE
 # define TRUE    1
@@ -27,7 +37,8 @@
 #endif
 
 
-// For synthesized events
+// For synthesized events, sizeof calculations, copied from the czmq and zyre
+// source
 struct _zyre_event_t {
     char *type;             //  Event type as string
     char *peer_uuid;        //  Sender UUID as string
@@ -39,6 +50,7 @@ struct _zyre_event_t {
 };
 
 
+
 /* --------------------------------------------------------------
  * Declarations
  * -------------------------------------------------------------- */
@@ -73,6 +85,9 @@ extern VALUE rzyre_mZyre;
 extern VALUE rzyre_cZyreNode;
 extern VALUE rzyre_cZyreEvent;
 extern VALUE rzyre_cZyrePoller;
+extern VALUE rzyre_cZyreCert;
+
+extern zactor_t *auth_actor;
 
 
 /* --------------------------------------------------------------
@@ -82,6 +97,12 @@ extern VALUE rzyre_cZyrePoller;
 #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 )
+#define IsZyreCert( obj ) rb_obj_is_kind_of( (obj), rzyre_cZyreCert )
+
+/* --------------------------------------------------------------
+ * Utility functions
+ * -------------------------------------------------------------- */
+extern zmsg_t * rzyre_make_zmsg_from _(( VALUE ));
 
 
 /* -------------------------------------------------------
@@ -92,8 +113,10 @@ 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 void rzyre_init_cert _(( void ));
 
 extern zyre_t * rzyre_get_node _(( VALUE ));
+extern zcert_t * rzyre_get_cert _(( VALUE ));
 
 #endif /* end of include guard: ZYRE_EXT_H_90322ABD */
 

data/lib/observability/instrumentation/zyre.rb

@@ -38,14 +38,14 @@ module Observability::Instrumentation::Zyre
 	###############
 
 	### Observer callback for the #whisper method.
-	def observe_whisper( peer_uuid, msg )
-		Observability.observer.add( peer_uuid: peer_uuid, message: msg )
+	def observe_whisper( peer_uuid, *msgs )
+		Observability.observer.add( peer_uuid: peer_uuid, messages: msgs )
 	end
 
 
 	### Observer callback for the #shout method.
-	def observe_shout( group, msg )
-		Observability.observer.add( group: group, message: msg )
+	def observe_shout( group, *msgs )
+		Observability.observer.add( group: group, messages: msgs )
 	end
 
 end # module Observability::Instrumentation::Zyre

data/lib/zyre.rb

@@ -1,35 +1,27 @@
 # -*- ruby -*-
 # frozen_string_literal: true
 
+require 'set'
 require 'loggability'
 
 require_relative 'zyre_ext'
 
 
-# A binding to libzyre
+#--
+# See also: ext/zyre_ext/zyre_ext.c
 module Zyre
 	extend Loggability
 
 
 	# Gem version (semver)
-	VERSION = '0.1.0'
-
+	VERSION = '0.4.1'
 
 	# Set up a logger for Zyre classes
 	log_as :zyre
 
 
-	### Wait on one or more +nodes+ to become readable, returning the first one that does
-	### or +nil+ if the +timeout+ is zero or greater and at least that many seconds elapse.
-	### Specify a +timeout+ of -1 to wait indefinitely. The timeout is in floating-point
-	### seconds.
-	###
-	### Raises an Interrupt if the call is interrupted or the ZMQ context is destroyed.
-	def self::wait( *nodes, timeout: -1 )
-		nodes = nodes.flatten
-		return nil if nodes.empty?
-		return self.wait2( nodes, timeout )
-	end
+	@whitelisted_ips = Set.new
+	@blacklisted_ips = Set.new
 
 
 	### If the given +key+ is a Symbol, transform it into an RFC822-style header key. If
@@ -50,4 +42,36 @@ module Zyre
 			transform_values {|v| v.to_s.encode('us-ascii') }
 	end
 
+
+	### Allow (whitelist) a list of IP +addresses+. For NULL, all clients from
+	### these addresses will be accepted. For PLAIN and CURVE, they will be
+	### allowed to continue with authentication. You can call this method
+	### multiple times to whitelist more IP addresses. If you whitelist one
+	### or more addresses, any non-whitelisted addresses are treated as
+	### blacklisted:
+	def self::allow( *addresses )
+		@whitelisted_ips.merge( addresses )
+	end
+
+
+	### Deny (blacklist) a list of IP +addresses+. For all security mechanisms,
+	### this rejects the connection without any further authentication. Use
+	### either a whitelist, or a blacklist, not not both. If you define both
+	### a whitelist and a blacklist, only the whitelist takes effect:
+	def self::deny( *addresses )
+		@blacklisted_ips.merge( addresses )
+	end
+
+
+	### Returns +true+ if the underlying Czmq library was built with draft APIs.
+	def self::has_draft_czmq_apis?
+		return Zyre::BUILT_WITH_DRAFT_CZMQ_API ? true : false
+	end
+
+
+	### Returns +true+ if the underlying Zyre library was built with draft APIs.
+	def self::has_draft_apis?
+		return Zyre::BUILT_WITH_DRAFT_API ? true : false
+	end
+
 end # module Zyre

data/lib/zyre/cert.rb

@@ -0,0 +1,75 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'loggability'
+
+require 'zyre' unless defined?( Zyre )
+
+
+#--
+# See also: ext/zyre_ext/cert.c
+class Zyre::Cert
+	extend Loggability
+
+
+	# The placeholder key that is set as the secret key for a public certificate.
+	EMPTY_KEY = "\x00" * 32
+
+
+	# Use the Zyre module's logger
+	log_to :zyre
+
+
+	# Set up some more Rubyish aliases
+	alias_method :private_key, :secret_key
+	alias_method :==, :eql?
+
+
+	### Fetch the value for the cert metadata with the given +name+.
+	def []( name )
+		return self.meta( name.to_s )
+	end
+
+
+	### Set the value for the cert metadata with the given +name+ to +value+.
+	def []=( name, value )
+		return self.set_meta( name.to_s, value.to_s )
+	end
+
+
+	### Return the metadata from the cert as a Hash.
+	def meta_hash
+		hash = self.meta_keys.each_with_object( {} ) do |key, h|
+			h[ key ] = self[ key ]
+		end
+		hash.freeze
+		return hash
+	end
+
+
+	### Delete the value for the cert metadata with the given +name+. Requires
+	### CZMQ to have been built with Draft APIs.
+	def delete( name )
+		name = name.to_s
+
+		deleted_val = self[ name ]
+		self.unset_meta( name )
+
+		return deleted_val
+	end
+
+
+	### Returns +true+ if the certificate has a secret key.
+	def have_secret_key?
+		return self.secret_key != EMPTY_KEY
+	end
+
+
+	### Apply the certificate to the specified +zyre_node+, i.e. use the
+	### cert for CURVE security. If the receiving certificate doesn't have a
+	### private key, an exception will be raised.
+	def apply( zyre_node )
+		return zyre_node.zcert = self
+	end
+
+end # class Zyre::Cert

data/lib/zyre/event.rb

@@ -25,6 +25,7 @@ class Zyre::Event
 	autoload :Exit, 'zyre/event/exit'
 	autoload :Join, 'zyre/event/join'
 	autoload :Leave, 'zyre/event/leave'
+	autoload :Leader, 'zyre/event/leader'
 	autoload :Shout, 'zyre/event/shout'
 	autoload :Silent, 'zyre/event/silent'
 	autoload :Stop, 'zyre/event/stop'
@@ -60,6 +61,14 @@ class Zyre::Event
 	end
 
 
+	### Returns +true+ if the receiving event has a multipart message.
+	def multipart?
+		size = self.msg_size
+		return size && size > 1
+	end
+	alias_method :is_multipart?, :multipart?
+
+
 	### Return a string describing this event, suitable for debugging.
 	def inspect
 		details = self.inspect_details

data/lib/zyre/event/leader.rb

@@ -0,0 +1,18 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'zyre/event' unless defined?( Zyre::Event )
+
+
+class Zyre::Event::Leader < Zyre::Event
+
+	### Provide the details of the inspect message.
+	def inspect_details
+		return "%s (%s) has been elected leader of «%s»" % [
+			self.peer_uuid,
+			self.peer_name,
+			self.group
+		]
+	end
+
+end # class Zyre::Event::Leader