marquise 0.1.0

data/marquise.gemspec

@@ -0,0 +1,33 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'git-version-bump'
+
+Gem::Specification.new do |s|
+	s.name = "marquise"
+
+	s.version = GVB.version
+	s.date    = GVB.date
+
+	s.platform = Gem::Platform::RUBY
+
+	s.homepage = "https://github.com/mpalmer/marquise-ruby"
+	s.summary = "Ruby bindings for the marquise data-point transport "+
+	            "for Vaultaire"
+	s.authors = ["Matt Palmer"]
+
+	s.extra_rdoc_files = ["README.md"]
+	s.files = `git ls-files`.split("\n")
+
+	s.add_runtime_dependency 'ffi', '~> 1.9'
+	s.add_runtime_dependency 'ffi_dry'
+	s.add_runtime_dependency 'git-version-bump', '~> 0.7'
+
+	s.add_development_dependency 'rspec', "~> 2.14"
+	s.add_development_dependency 'rake'
+	s.add_development_dependency 'bundler'
+	s.add_development_dependency 'rdoc'
+	s.add_development_dependency 'guard-spork'
+	s.add_development_dependency 'guard-rspec'
+	s.add_development_dependency 'rb-inotify', '~> 0.9'
+	s.add_development_dependency 'plymouth'
+	s.add_development_dependency 'pry-debugger'
+end

data/spec/marquise_spec.rb

@@ -0,0 +1,274 @@
+require_relative './spec_helper'
+
+require 'marquise'
+
+describe Marquise do
+	describe ".new" do
+		it "bombs out without an argument" do
+			expect { Marquise.new }.to raise_error
+		end
+		
+		it "returns a Marquise instance when given a zmq URL" do
+			expect(Marquise.new('tcp://localhost:4567')).to be_a(Marquise)
+		end
+
+		it "calls marquise_consumer_new with a zmq URL" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return('19')
+
+			Marquise.new('tcp://localhost:4567')
+		end
+		
+		it "raises RuntimeError if marquise_consumer_new returns nil" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return(nil)
+
+			expect { Marquise.new('tcp://localhost:4567') }.
+			  to raise_error(RuntimeError, "libmarquise failed; check syslog (no, seriously)")
+		end
+		
+		it "passes non-default batch_period if given" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 0.05).
+			  and_return('38')
+
+			Marquise.new('tcp://localhost:4567', 0.05)
+		end
+		
+		it "defines a finalizer to call marquise_consumer_shutdown" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return('xyzzy')
+			ObjectSpace.
+			  should_receive(:define_finalizer).
+			  with(instance_of(Marquise), mock_janitor = double('janitor'))
+			Marquise::Janitor.
+			  should_receive(:new).
+			  with('xyzzy', {}).
+			  and_return(mock_janitor)
+
+			x = Marquise.new('tcp://localhost:4567')
+		end
+	end
+	
+	describe ".open" do
+		it "bombs out without an argument" do
+			expect { Marquise.open }.to raise_error
+		end
+		
+		it "returns a Marquise instance when given a zmq URL" do
+			expect(Marquise.open('tcp://localhost:4567')).to be_a(Marquise)
+		end
+
+		it "calls marquise_consumer_new with a zmq URL" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return('81')
+
+			Marquise.open('tcp://localhost:4567')
+		end
+		
+		it "raises RuntimeError if marquise_consumer_new returns nil" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return(nil)
+
+			expect { Marquise.open('tcp://localhost:4567') }.
+			  to raise_error(RuntimeError, "libmarquise failed; check syslog (no, seriously)")
+		end
+		
+		it "passes non-default batch_period if given" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 0.05).
+			  and_return('100')
+
+			Marquise.open('tcp://localhost:4567', 0.05)
+		end
+
+		it "bombs out with a block but without an argument" do
+			expect { Marquise.open() { |x| puts x } }.to raise_error
+		end
+		
+		it "yields a Marquise instance when given a block" do
+			expect do |b|
+				Marquise.open('tcp://localhost:4567', &b)
+			end.to yield_with_args(Marquise)
+		end
+	end
+	
+	describe "#connect" do
+		it "calls marquise_connect" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return('118')
+			Marquise::FFI.
+			  should_receive(:marquise_connect).
+			  with('118').
+			  and_return('122')
+
+			x = Marquise.open('tcp://localhost:4567').connect
+			# This is just cheating... avoid possibly sending insane data
+			# to libmarquise via calling close functions on GC
+			ObjectSpace.undefine_finalizer(x)
+		end
+
+		it "calls marquise_connect only once per thread" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return('118')
+			Marquise::FFI.
+			  should_receive(:marquise_connect).
+			  with('118').
+			  and_return('122')
+
+			x = Marquise.open('tcp://localhost:4567')
+			# This is just cheating... avoid possibly sending insane data
+			# to libmarquise via calling close functions on GC
+			ObjectSpace.undefine_finalizer(x)
+			
+			10.times { x.connect }
+		end
+
+		it "barfs if marquise_connect fails" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return('134')
+			Marquise::FFI.
+			  should_receive(:marquise_connect).
+			  with('134').
+			  and_return(nil)
+
+			x = Marquise.open('tcp://localhost:4567')
+			# This is just cheating... avoid possibly sending insane data
+			# to libmarquise via calling close functions on GC
+			ObjectSpace.undefine_finalizer(x)
+
+			expect { x.connect }.
+			  to raise_error(
+			       RuntimeError,
+			       "marquise_connect() failed... consult syslog (no, seriously)"
+			     )
+		end
+		
+		it "creates separate connections for each thread" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return('156')
+			Marquise::FFI.
+			  should_receive(:marquise_connect).
+			  twice.
+			  with('156').
+			  and_return('161.1', '161.2')
+
+			x = Marquise.open('tcp://localhost:4567')
+			# This is just cheating... avoid possibly sending insane data
+			# to libmarquise via calling close functions on GC
+			ObjectSpace.undefine_finalizer(x)
+			
+			th1 = Thread.new { 10.times { x.connect } }
+			th2 = Thread.new { 10.times { x.connect } }
+			
+			th1.join
+			th2.join
+			
+			# Digging inside the object... how naughty...
+			conns = x.instance_variable_get(:@connections)
+			
+			expect(conns[th1]).to_not eq(conns[th2])
+		end
+	end
+	
+	describe "#close" do
+		it "calls marquise_consumer_shutdown" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return('121')
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_shutdown).
+			  with('121')
+
+			Marquise.open('tcp://localhost:4567').close
+		end
+		
+		it "doesn't call marquise_consumer_shutdown more than once" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return('131')
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_shutdown).
+			  with('131')
+
+			x = Marquise.open('tcp://localhost:4567').close
+			
+			# Creating a huge chunk of junk memory and then releasing it should
+			# cause the GC to cleanup everything, running all finalizers
+			x = 'x' * 100_000_000
+			x = nil
+			GC.start
+		end
+		
+		it "calls marquise_close on the connection" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return('148')
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_shutdown).
+			  with('148')
+			Marquise::FFI.
+			  should_receive(:marquise_connect).
+			  with('148').
+			  and_return('155')
+			Marquise::FFI.
+			  should_receive(:marquise_close).
+			  with('155')
+
+			x = Marquise.open('tcp://localhost:4567')
+			x.connect
+			x.close
+		end
+
+		it "calls marquise_close on all connections" do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return('255')
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_shutdown).
+			  with('255')
+			Marquise::FFI.
+			  should_receive(:marquise_connect).
+			  with('255').
+			  twice.
+			  and_return('263.1', '263.2')
+			Marquise::FFI.
+			  should_receive(:marquise_close).
+			  with('263.1')
+			Marquise::FFI.
+			  should_receive(:marquise_close).
+			  with('263.2')
+
+			x = Marquise.open('tcp://localhost:4567')
+			
+			Thread.new { x.connect }.join
+			Thread.new { x.connect }.join
+
+			x.close
+		end
+	end
+end

data/spec/marquise_tell_binary_spec.rb

@@ -0,0 +1,183 @@
+require_relative './spec_helper'
+require 'marquise'
+
+describe Marquise do
+	describe "#tell" do
+		let(:marquise) do
+			Marquise::FFI.
+			  should_receive(:marquise_consumer_new).
+			  with('tcp://localhost:4567', 5).
+			  and_return('#tell')
+			Marquise::FFI.
+			  should_receive(:marquise_connect).
+			  with('#tell').
+			  and_return('#tellconn')
+
+			x = Marquise.new('tcp://localhost:4567')
+			# Neuter the Marquise
+			ObjectSpace.undefine_finalizer(x)
+			
+			x
+		end
+		
+		describe "(binary)" do
+			it "sends a simple binary" do
+				Marquise::FFI.stub(:send) do |*args|
+					expect(args).to be_an(Array)
+					expect(args.length).to eq(8)
+
+					method, conn, src_f, src_v, src_c, data, len, tstamp = args
+					
+					expect(method).to eq(:marquise_send_binary)
+					expect(conn).to eq('#tellconn')
+
+					expect(tstamp).
+					  to be_within(1_000_000_000).
+					  of(Time.now.to_f * 1_000_000_000)
+
+					expect(src_c).to eq(0)
+					expect(src_f).to be(nil)
+					expect(src_v).to be(nil)
+					
+					expect(len).to eq("hello world".length)
+					expect(data).to eq("hello world")
+					
+					0
+				end
+				
+				marquise.tell "hello world".encode('ASCII-8BIT')
+			end
+
+			it "sends a non-UTF-8 string as binary" do
+				Marquise::FFI.stub(:send) do |*args|
+					expect(args).to be_an(Array)
+					expect(args.length).to eq(8)
+
+					method, conn, src_f, src_v, src_c, data, len, tstamp = args
+					
+					expect(method).to eq(:marquise_send_binary)
+					expect(conn).to eq('#tellconn')
+
+					expect(tstamp).
+					  to be_within(1_000_000_000).
+					  of(Time.now.to_f * 1_000_000_000)
+
+					expect(src_c).to eq(0)
+					expect(src_f).to be(nil)
+					expect(src_v).to be(nil)
+					
+					expect(len).to eq(1)
+					expect(data).to eq("\xC0")
+					
+					0
+				end
+				
+				marquise.tell "\xC0"
+			end
+
+			it "sends binary and a timestamp" do
+				t = Time.now - 86400
+				
+				Marquise::FFI.stub(:send) do |*args|
+					expect(args).to be_an(Array)
+					expect(args.length).to eq(8)
+
+					method, conn, src_f, src_v, src_c, data, len, tstamp = args
+					
+					expect(method).to eq(:marquise_send_binary)
+					expect(conn).to eq('#tellconn')
+
+					expect(tstamp).to eq(t.to_f * 1_000_000_000)
+
+					expect(src_c).to eq(0)
+					expect(src_f).to be(nil)
+					expect(src_v).to be(nil)
+					
+					expect(len).to eq("hello world".length)
+					expect(data).to eq("hello world")
+					
+					0
+				end
+				
+				marquise.tell "hello world".encode('ASCII-8BIT'), t
+			end
+
+			it "sends binary and tags" do
+				Marquise::FFI.stub(:send) do |*args|
+					expect(args).to be_an(Array)
+					expect(args.length).to eq(8)
+
+					method, conn, src_f, src_v, src_c, data, len, tstamp = args
+					
+					expect(method).to eq(:marquise_send_binary)
+					expect(conn).to eq('#tellconn')
+
+					expect(tstamp).
+					  to be_within(1_000_000_000).
+					  of(Time.now.to_f * 1_000_000_000)
+
+					expect(src_c).to eq(2)
+					
+					expect(src_f).to be_a(FFI::MemoryPointer)
+					expect(src_f.size).to eq(3*src_f.type_size)
+					expect(src_f[0].read_pointer.read_string).to eq('foo')
+					expect(src_f[1].read_pointer.read_string).to eq('answer')
+					expect(src_f[2].read_pointer.address).to eq(0)
+
+					expect(src_v).to be_a(FFI::MemoryPointer)
+					expect(src_v.size).to eq(3*src_f.type_size)
+					expect(src_v[0].read_pointer.read_string).to eq('bar')
+					expect(src_v[1].read_pointer.read_string).to eq('42')
+					expect(src_v[2].read_pointer.address).to eq(0)
+					
+					expect(len).to eq("hello world".length)
+					expect(data).to eq("hello world")
+					
+					0
+				end
+				
+				marquise.tell "hello world".encode('ASCII-8BIT'),
+				              :foo => 'bar', 'answer' => 42
+			end
+
+			it "sends binary, timestamp and source" do
+				t = Time.now + 86400
+				
+				Marquise::FFI.stub(:send) do |*args|
+					expect(args).to be_an(Array)
+					expect(args.length).to eq(8)
+
+					method, conn, src_f, src_v, src_c, data, len, tstamp = args
+					
+					expect(method).to eq(:marquise_send_binary)
+					expect(conn).to eq('#tellconn')
+
+					expect(tstamp).to eq(t.to_f * 1_000_000_000)
+
+					expect(src_c).to eq(2)
+					
+					expect(src_f).to be_a(FFI::MemoryPointer)
+					expect(src_f.size).to eq(3*src_f.type_size)
+					expect(src_f[0].read_pointer.read_string).to eq('foo')
+					expect(src_f[1].read_pointer.read_string).to eq('answer')
+					expect(src_f[2].read_pointer.address).to eq(0)
+
+					expect(src_v).to be_a(FFI::MemoryPointer)
+					expect(src_v.size).to eq(3*src_f.type_size)
+					expect(src_v[0].read_pointer.read_string).to eq('bar')
+					expect(src_v[1].read_pointer.read_string).to eq('42')
+					expect(src_v[2].read_pointer.address).to eq(0)
+					
+					expect(len).to eq("hello world".length)
+					expect(data).to eq("hello world")
+					
+					0
+				end
+				
+				marquise.tell "hello world".encode('ASCII-8BIT'),
+				              t,
+				              :foo => 'bar', 'answer' => 42
+			end
+		end
+	end
+end