zyre 0.1.0 → 0.4.1

data/lib/zyre/event/stop.rb

@@ -6,4 +6,9 @@ require 'zyre/event' unless defined?( Zyre::Event )
 
 class Zyre::Event::Stop < Zyre::Event
 
+	### Provide the details of the inspect message.
+	def inspect_details
+		return " node is stopping"
+	end
+
 end # class Zyre::Event::Stop

data/lib/zyre/testing.rb

@@ -154,8 +154,12 @@ module Zyre::Testing
 
 
 		### Generate a SHOUT event.
-		def shout( **overrides )
+		def shout( group=nil, *msg, **overrides )
 			uuid = overrides.delete( :peer_uuid ) || self.peer_uuid
+
+			overrides[:group] = group if group
+			overrides[:msg] = msg if !msg.empty?
+
 			config = {
 				peer_name: self.peer_name,
 				group: self.group,
@@ -166,9 +170,14 @@ module Zyre::Testing
 		end
 
 
-		### Generate a WHISPER event.
-		def whisper( **overrides )
+		### Generate a WHISPER event. The first positional argument, which would
+		### normally be the UUID of the peer to WHISPER to is ignored, since the
+		### generated event's +peer_uuid+ is the sending node's not the receiving one's.
+		def whisper( _ignored=nil, *msg, **overrides )
 			uuid = overrides.delete( :peer_uuid ) || self.peer_uuid
+
+			overrides[:msg] = msg if !msg.empty?
+
 			config = {
 				peer_name: self.peer_name,
 				msg: self.msg
@@ -212,6 +221,18 @@ module Zyre::Testing
 		end
 
 
+		### Generate a LEADER event.
+		def leader( **overrides )
+			uuid = overrides.delete( :peer_uuid ) || self.peer_uuid
+			config = {
+				peer_name: self.peer_name,
+				group: self.group
+			}.merge( overrides )
+
+			return Zyre::Event.synthesize( :leader, uuid, **config )
+		end
+
+
 		### Generate an EXIT event.
 		def exit( **overrides )
 			uuid = overrides.delete( :peer_uuid ) || self.peer_uuid
@@ -222,6 +243,17 @@ module Zyre::Testing
 			return Zyre::Event.synthesize( :exit, uuid, **config )
 		end
 
+
+		### Generate a STOP event.
+		def stop( **overrides )
+			uuid = overrides.delete( :peer_uuid ) || self.peer_uuid
+			config = {
+				peer_name: self.peer_name
+			}.merge( overrides )
+
+			return Zyre::Event.synthesize( :stop, uuid, **config )
+		end
+
 	end # class EventFactory
 
 
@@ -251,6 +283,7 @@ module Zyre::Testing
 	def started_node( name=nil )
 		node = Zyre::Node.new( name )
 		node.endpoint = 'inproc://node-test-%s' % [ SecureRandom.hex(16) ]
+
 		yield( node ) if block_given?
 
 		if @gossip_endpoint

data/spec/observability/instrumentation/zyre_spec.rb

@@ -31,7 +31,7 @@ RSpec.describe 'Observability::Instrumentation::Zyre', :observability do
 		events = Observability.observer.sender.find_events( 'zyre.node.whisper' )
 		expect( events.length ).to eq( 1 )
 		expect( events.first[:peer_uuid] ).to eq( node2.uuid )
-		expect( events.first[:message] ).to eq( 'a peer-to-peer message' )
+		expect( events.first[:messages] ).to eq( ['a peer-to-peer message'] )
 
 	end
 
@@ -49,7 +49,7 @@ RSpec.describe 'Observability::Instrumentation::Zyre', :observability do
 		events = Observability.observer.sender.find_events( 'zyre.node.shout' )
 		expect( events.length ).to eq( 1 )
 		expect( events.first[:group] ).to eq( 'observer-testing' )
-		expect( events.first[:message] ).to eq( 'a peer-to-peer message' )
+		expect( events.first[:messages] ).to eq( ['a peer-to-peer message'] )
 	end
 
 end

data/spec/spec_helper.rb

@@ -55,6 +55,10 @@ RSpec.configure do |config|
 		Zyre::Testing.check_fdmax
 	end
 
+	config.filter_run_excluding( :draft_api ) unless Zyre.has_draft_apis?
+	config.filter_run_excluding( :czmq_draft_api ) unless Zyre.has_draft_czmq_apis?
+	config.filter_run_excluding( :no_czmq_draft_api ) if Zyre.has_draft_czmq_apis?
+
 	config.include( Zyre::Testing )
 	config.include( Loggability::SpecHelpers )
 end

data/spec/zyre/cert_spec.rb

@@ -0,0 +1,218 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'tempfile'
+
+require 'zyre/cert'
+
+
+RSpec.describe( Zyre::Cert ) do
+
+	let( :cert_file ) { Tempfile.new('zyre_cert_test') }
+
+
+	it "can be created in-memory" do
+		expect( described_class.new ).to be_a( described_class )
+	end
+
+
+	it "can be created from a keypair" do
+		cert = described_class.new
+
+		result = described_class.from( cert.public_key, cert.private_key )
+
+		expect( result ).to be_a( described_class )
+		expect( result ).to eq( cert )
+	end
+
+
+	it "can be saved to and loaded from a file" do
+		cert = described_class.new
+		cert.save( cert_file.path )
+
+		result = described_class.load( cert_file.path )
+
+		expect( result ).to be_a( described_class )
+		expect( result ).to eq( cert )
+	end
+
+
+	it "can be saved as a public cert to and loaded from a file" do
+		cert = described_class.new
+		cert.save_public( cert_file.path )
+
+		result = described_class.load( cert_file.path )
+
+		expect( result ).to be_a( described_class )
+		expect( result.public_key ).to eq( cert.public_key )
+		expect( result.secret_key ).to eq( Zyre::Cert::EMPTY_KEY )
+	end
+
+
+	it "can be saved as a secret cert to and loaded from a file" do
+		cert = described_class.new
+		cert.save_secret( cert_file.path )
+
+		result = described_class.load( cert_file.path )
+
+		expect( result ).to be_a( described_class )
+		expect( result ).to eq( cert )
+	end
+
+
+	it "knows what its public key is" do
+		cert = described_class.new
+
+		key = cert.public_key
+
+		expect( key.encoding ).to eq( Encoding::ASCII_8BIT )
+		expect( key.bytesize ).to eq( 32 )
+	end
+
+
+	it "knows what its secret key is" do
+		cert = described_class.new
+
+		key = cert.secret_key
+
+		expect( key.encoding ).to eq( Encoding::ASCII_8BIT )
+		expect( key.bytesize ).to eq( 32 )
+	end
+
+
+	it "knows what its Z85-armored public key is" do
+		cert = described_class.new
+
+		key = cert.public_txt
+
+		expect( key.encoding ).to eq( Encoding::US_ASCII )
+		expect( key.length ).to eq( 40 )
+	end
+
+
+	it "knows what its Z85-armored secret key is" do
+		cert = described_class.new
+
+		key = cert.secret_txt
+
+		expect( key.encoding ).to eq( Encoding::US_ASCII )
+		expect( key.length ).to eq( 40 )
+	end
+
+
+	it "can set metadata on the cert" do
+		cert = described_class.new
+
+		cert[ :username ] = 'timmy'
+
+		expect( cert['username'] ).to eq( 'timmy' )
+	end
+
+
+	it "stringifies non-string metadata on the cert" do
+		cert = described_class.new
+
+		cert[ :euid ] = 12
+
+		expect( cert[:euid] ).to eq( '12' )
+	end
+
+
+	it "fetches non-existant values as nil" do
+		cert = described_class.new
+
+		expect( cert[:nonexistant_key] ).to be_nil
+	end
+
+
+	it "silently ignores overwrites of a metadata value if not built with Drafts", :no_czmq_draft_api do
+		cert = described_class.new
+
+		cert.set_meta( 'foo', 'bar' )
+		cert.set_meta( 'foo', 'baz' )
+
+		expect( cert.meta('foo') ).to eq( 'bar' )
+	end
+
+
+	it "can overwrite a metadata value if built with Drafts", :czmq_draft_api do
+		cert = described_class.new
+
+		cert.set_meta( 'foo', 'bar' )
+		cert.set_meta( 'foo', 'baz' )
+
+		expect( cert.meta('foo') ).to eq( 'baz' )
+	end
+
+
+	it "knows what metadata has been set on the cert" do
+		cert = described_class.new
+
+		cert[ :euid ]      = 0
+		cert[ :username ]  = 'jrandom'
+		cert[ 'firstname' ] = 'James'
+		cert[ :lastname ]  = 'Random'
+		cert[ 'key 2' ] = 'cf67c750-c704-4ef7-ab83-ecb2cd2e326c'
+
+		expect( cert.meta_keys ).
+			to contain_exactly( 'euid', 'username', 'firstname', 'lastname', 'key 2' )
+	end
+
+
+	it "can delete one of its metadata key-value pairs", :czmq_draft_api do
+		cert = described_class.new
+
+		cert[ :euid ]      = 0
+		cert[ :username ]  = 'jrandom'
+		cert[ 'firstname' ] = 'James'
+		cert[ :lastname ]  = 'Random'
+		cert[ 'key 2' ] = 'cf67c750-c704-4ef7-ab83-ecb2cd2e326c'
+
+		cert.delete( 'lastname' )
+
+		expect( cert.meta_keys ).
+			to contain_exactly( 'euid', 'username', 'firstname', 'key 2' )
+	end
+
+
+	it "can return all of its metadata as a Hash" do
+		cert = described_class.new
+
+		cert[ :euid ]      = 0
+		cert[ :username ]  = 'jrandom'
+		cert[ 'firstname' ] = 'James'
+		cert[ :lastname ]  = 'Random'
+		cert[ 'key 2' ] = 'cf67c750-c704-4ef7-ab83-ecb2cd2e326c'
+
+		expect( cert.meta_hash ).to eq({
+			'euid'      => '0',
+			'username'  => 'jrandom',
+			'firstname' => 'James',
+			'lastname'  => 'Random',
+			'key 2'     => 'cf67c750-c704-4ef7-ab83-ecb2cd2e326c',
+		})
+	end
+
+
+	it "can be applied to a Zyre node", :draft_apis do
+		node = instance_double( Zyre::Node )
+		cert = Zyre::Cert.new
+
+		expect( node ).to receive( :zcert= ).with( cert )
+		cert.apply( node )
+	end
+
+
+	it "can be duplicated" do
+		cert = described_class.new
+		cert[ :node_id ] = '05343500-f908-4903-9441-e648eb1754ec'
+		cert[ :node_order ] = 1
+
+		other = cert.dup
+
+		expect( other.object_id ).not_to eq( cert.object_id )
+	end
+
+
+end

data/spec/zyre/event_spec.rb

@@ -135,6 +135,68 @@ RSpec.describe( Zyre::Event ) do
 			expect( result.peer_name ).to eq( 'S-' + peer_uuid[0, 6] )
 		end
 
+
+		it "can generate a SHOUT event with binary data in its msg" do
+			data = "\xBF\x8D\x00\x9D\xDDg\x03_\xF2Nr\x01\xF0I8Au\x95\xC6L\xD37".b +
+				"\xFFt\xC7\xE1\xC0<l\x17\xA2N\xE3".b
+
+			result = described_class.synthesize( :SHOUT, peer_uuid, group: 'stream', msg: data )
+
+			expect( result ).to be_a( described_class::Shout )
+			expect( result.peer_uuid ).to eq( peer_uuid )
+			expect( result.group ).to eq( 'stream' )
+			expect( result.msg ).to eq( data )
+		end
+
+
+		it "raises when creating a WHISPER with no msg" do
+			expect {
+				described_class.synthesize( :WHISPER, peer_uuid )
+			}.to raise_error( ArgumentError, /missing required field :msg/i )
+		end
+
+
+		it "raises when creating a SHOUT with no msg" do
+			expect {
+				described_class.synthesize( :SHOUT, peer_uuid, group: 'agroup' )
+			}.to raise_error( ArgumentError, /missing required field :msg/i )
+		end
+
+
+		it "raises when creating a SHOUT with no group" do
+			expect {
+				described_class.synthesize( :SHOUT, peer_uuid, msg: 'amsg' )
+			}.to raise_error( ArgumentError, /missing required field :group/i )
+		end
+
+
+		it "raises when creating an ENTER with no peer_addr" do
+			expect {
+				described_class.synthesize( :ENTER, peer_uuid )
+			}.to raise_error( ArgumentError, /missing required field :peer_addr/i )
+		end
+
+
+		it "raises when creating a JOIN with no group" do
+			expect {
+				described_class.synthesize( :JOIN, peer_uuid )
+			}.to raise_error( ArgumentError, /missing required field :group/i )
+		end
+
+
+		it "raises when creating a LEAVE with no group" do
+			expect {
+				described_class.synthesize( :LEAVE, peer_uuid )
+			}.to raise_error( ArgumentError, /missing required field :group/i )
+		end
+
+
+		it "raises when creating an unknown type of event" do
+			expect {
+				described_class.synthesize( :BACKUP, peer_uuid )
+			}.to raise_error( ArgumentError, /don't know how to create :BACKUP events/i )
+		end
+
 	end
 
 end

data/spec/zyre/node_spec.rb

@@ -2,6 +2,7 @@
 
 require_relative '../spec_helper'
 
+require 'securerandom'
 require 'zyre/node'
 
 
@@ -17,6 +18,13 @@ RSpec.describe( Zyre::Node ) do
 	I sound my barbaric yawp over the roofs of the world.
 	END_SHOUT
 
+	TEST_BINARY_STRING_PARTS = [
+		SecureRandom.bytes( 128 ),
+		"\x00".b,
+		SecureRandom.bytes( 128 )
+	]
+	TEST_BINARY_STRING = TEST_BINARY_STRING_PARTS.join( '' )
+
 
 	it "can be created anonymously" do
 		node = described_class.new
@@ -162,13 +170,30 @@ RSpec.describe( Zyre::Node ) do
 		node1.wait_for( :ENTER, peer_uuid: node2.uuid )
 		node1.whisper( node2.uuid, TEST_WHISPER )
 
-		ev = node2.recv
-		expect( ev.type ).to eq( :ENTER )
+		ev = node2.wait_for( :WHISPER )
+		expect( ev ).to be_a( Zyre::Event::Whisper )
+		expect( ev ).to_not be_multipart
+		msg = ev.msg
+		expect( msg.encoding ).to eq( Encoding::ASCII_8BIT )
+		msg = msg.dup.force_encoding( 'utf-8' )
+		expect( msg ).to eq( TEST_WHISPER )
+		expect( ev.multipart_msg ).to eq( [TEST_WHISPER.b] )
+	end
 
-		ev = node2.recv
-		expect( ev.type ).to eq( :WHISPER )
-		expect( ev.msg.encoding ).to eq( Encoding::UTF_8 )
-		expect( ev.msg ).to eq( TEST_WHISPER )
+
+	it "can whisper a multipart message to another node" do
+		node1 = started_node()
+		node2 = started_node()
+
+		node1.wait_for( :ENTER, peer_uuid: node2.uuid )
+		node1.whisper( node2.uuid, 'poetry.snippet', TEST_WHISPER )
+
+		ev = node2.wait_for( :WHISPER, peer_uuid: node1.uuid )
+		expect( ev ).to be_a( Zyre::Event::Whisper )
+		expect( ev ).to be_multipart
+		expect( ev.msg.encoding ).to eq( Encoding::ASCII_8BIT )
+		expect( ev.msg ).to eq( 'poetry.snippet' )
+		expect( ev.multipart_msg ).to eq( ['poetry.snippet', TEST_WHISPER] )
 	end
 
 
@@ -190,8 +215,96 @@ RSpec.describe( Zyre::Node ) do
 
 		ev = node2.recv
 		expect( ev ).to be_a( Zyre::Event::Shout )
-		expect( ev.msg.encoding ).to eq( Encoding::UTF_8 )
-		expect( ev.msg ).to eq( TEST_SHOUT )
+		expect( ev ).to_not be_multipart
+		expect( ev.msg.encoding ).to eq( Encoding::ASCII_8BIT )
+		expect( ev.msg ).to eq( TEST_SHOUT.b )
+		expect( ev.multipart_msg ).to eq( [TEST_SHOUT.b] )
+	end
+
+
+	it "can shout a multipart message to a group of nodes" do
+		node1 = started_node()
+		node2 = started_node()
+		node3 = started_node()
+
+		node1.join( 'ROOFTOP' )
+		node2.join( 'ROOFTOP' )
+		node3.join( 'ROOFTOP' )
+
+		2.times do
+			node1.wait_for( :JOIN, group: 'ROOFTOP' )
+		end
+		node1.shout( 'ROOFTOP', "random.poetry", TEST_SHOUT )
+
+		ev = node2.wait_for( :SHOUT, group: 'ROOFTOP' )
+		expect( ev ).to be_a( Zyre::Event::Shout )
+		expect( ev ).to be_multipart
+		expect( ev.msg ).to eq( 'random.poetry'.b )
+		expect( ev.multipart_msg ).to eq( ['random.poetry'.b, TEST_SHOUT.b] )
+	end
+
+
+	it "can shout a binary message to a group of nodes" do
+		node1 = started_node()
+		node2 = started_node()
+		node3 = started_node()
+
+		node1.join( 'stream' )
+		node2.join( 'stream' )
+		node3.join( 'stream' )
+
+		2.times do
+			node1.wait_for( :JOIN, group: 'stream' )
+		end
+		node1.shout( 'stream', TEST_BINARY_STRING )
+
+		ev = node2.wait_for( :SHOUT, group: 'stream' )
+		expect( ev ).to be_a( Zyre::Event::Shout )
+		expect( ev ).to_not be_multipart
+		expect( ev.msg ).to eq( TEST_BINARY_STRING )
+
+		ev = node3.wait_for( :SHOUT, group: 'stream' )
+		expect( ev ).to be_a( Zyre::Event::Shout )
+		expect( ev ).to_not be_multipart
+		expect( ev.msg ).to eq( TEST_BINARY_STRING )
+	end
+
+
+	it "can shout a multipart binary message to a group of nodes" do
+		node1 = started_node()
+		node2 = started_node()
+		node3 = started_node()
+
+		node1.join( 'stream' )
+		node2.join( 'stream' )
+		node3.join( 'stream' )
+
+		2.times do
+			node1.wait_for( :JOIN, group: 'stream' )
+		end
+		node1.shout( 'stream', *TEST_BINARY_STRING_PARTS )
+
+		ev = node2.wait_for( :SHOUT, group: 'stream' )
+		expect( ev ).to be_a( Zyre::Event::Shout )
+		expect( ev ).to be_multipart
+		expect( ev.msg ).to eq( TEST_BINARY_STRING_PARTS[0] )
+		expect( ev.multipart_msg ).to eq( TEST_BINARY_STRING_PARTS )
+
+		ev = node3.wait_for( :SHOUT, group: 'stream' )
+		expect( ev ).to be_a( Zyre::Event::Shout )
+		expect( ev ).to be_multipart
+		expect( ev.msg ).to eq( TEST_BINARY_STRING_PARTS[0] )
+		expect( ev.multipart_msg ).to eq( TEST_BINARY_STRING_PARTS )
+	end
+
+
+	it "handles unstringifiable messages gracefully" do
+		node1 = started_node()
+		node1.join( 'ROOFTOP' )
+
+		expect {
+			node1.shout( 'ROOFTOP', nil )
+		}.to raise_error( TypeError, /nil/i )
 	end
 
 
@@ -236,6 +349,22 @@ RSpec.describe( Zyre::Node ) do
 	end
 
 
+	it "knows what the headers of its peers are" do
+		node1 = started_node()
+		node2 = started_node() do |node|
+			node.headers = {
+				protocol_version: 2,
+				content_type: 'application/javascript',
+				start_time: Time.now.to_f
+			}
+		end
+
+		node1.wait_for( :enter, peer_uuid: node2.uuid )
+
+		expect( node1.peer_header_value(node2.uuid, 'Protocol-version') ).to eq( '2' )
+	end
+
+
 	it "has a blocking iterator" do
 		node = described_class.new
 
@@ -352,5 +481,63 @@ RSpec.describe( Zyre::Node ) do
 	end
 
 
+	context "draft APIs", :draft_api do
+
+		it "can specify a port for the ROUTER socket" do
+			node = described_class.new
+
+			expect {
+				node.beacon_peer_port = 16181
+			}.to_not raise_error()
+		end
+
+
+		it "can specify that a node should try to assume leadership of a particular group" do
+			node1 = started_node( 'node1' ) do |node|
+				# node.verbose!
+				node.set_contest_in_group( "GROUP_1" )
+				node.join( 'GROUP_1' )
+				node.join( 'GROUP_2' )
+				node.join( 'GROUP_3' )
+			end
+
+			node2 = started_node( 'node2' ) do |node|
+				# node.verbose!
+				node.set_contest_in_group( 'GROUP_1' )
+				node.set_contest_in_group( 'GROUP_2' )
+				node.join( 'GROUP_1' )
+				node.join( 'GROUP_2' )
+				node.join( 'GROUP_3' )
+			end
+
+			poller = Zyre::Poller.new( node1, node2 )
+
+			leaders = {}
+			leadership_message_count = 0
+			while ( node = poller.wait(0.5) )
+				event = node.recv
+
+				if event.type == :LEADER
+					leadership_message_count += 1
+					leaders[ event.group ] = event.peer_uuid
+				end
+			end
+
+			expect( leadership_message_count ).to eq( 4 )
+			expect( leaders.keys ).to contain_exactly( 'GROUP_1', 'GROUP_2' )
+			expect( leaders['GROUP_1'] ).to eq( node1.uuid ).or( eq node2.uuid )
+			expect( leaders['GROUP_2'] ).to eq( node2.uuid )
+		end
+
+
+		it "supports CURVE authentication"
+
+		it "supports advertised_endpoint="
+		it "supports gossip_connect_curve"
+		it "supports gossip_unpublish"
+		it "supports require_peer"
+
+	end
+
 end