thingfish 0.5.0.pre20161103181816 → 0.8.0

data/lib/thingfish/metastore.rb

@@ -1,5 +1,5 @@
 # -*- ruby -*-
-#encoding: utf-8
+# frozen_string_literal: true
 
 require 'pluggability'
 require 'strelka'

data/lib/thingfish/metastore/memory.rb

@@ -1,5 +1,5 @@
 # -*- ruby -*-
-#encoding: utf-8
+# frozen_string_literal: true
 
 require 'thingfish' unless defined?( Thingfish )
 require 'thingfish/metastore' unless defined?( Thingfish::Metastore )

data/lib/thingfish/mixins.rb

@@ -1,6 +1,6 @@
 # -*- ruby -*-
 # vim: set nosta noet ts=4 sw=4:
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'securerandom'
 

data/lib/thingfish/processor.rb

@@ -1,5 +1,5 @@
 # -*- ruby -*-
-#encoding: utf-8
+# frozen_string_literal: true
 
 require 'pluggability'
 require 'strelka/httprequest/acceptparams'

data/lib/thingfish/processor/sha256.rb

@@ -0,0 +1,51 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'digest/sha2'
+
+require 'thingfish' unless defined?( Thingfish )
+require 'thingfish/processor' unless defined?( Thingfish::Processor )
+
+
+# Calculate and store a sha256 checksum for a resource.
+class Thingfish::Processor::SHA256 < Thingfish::Processor
+	extend Loggability
+
+	# The chunk size to read
+	CHUNK_SIZE = 32 * 1024
+
+	# Loggability API -- log to the :thingfish logger
+	log_to :thingfish
+
+	# The list of handled types
+	handled_types '*/*'
+
+
+	### Synchronous processor API -- generate a checksum during upload.
+	def on_request( request )
+		request.add_metadata( :checksum => self.checksum(request.body) )
+		request.related_resources.each_pair do |io, metadata|
+			metadata[ :checksum ] = self.checksum( io )
+		end
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Given an +io+, return a sha256 checksum of it's contents.
+	def checksum( io )
+		digest = Digest::SHA256.new
+		buf = String.new
+
+		while io.read( CHUNK_SIZE, buf )
+			digest.update( buf )
+		end
+
+		io.rewind
+		return digest.hexdigest
+	end
+
+end # class Thingfish::Processor::SHA256
+

data/lib/thingfish/spechelpers.rb

@@ -1,5 +1,5 @@
 # -*- ruby -*-
-#encoding: utf-8
+# frozen_string_literal: true
 # vim: set nosta noet ts=4 sw=4 ft=ruby:
 
 require 'time'

data/spec/helpers.rb

@@ -42,25 +42,32 @@ Loggability.format_with( :color ) if $stdout.tty?
 
 
 ### Mock with RSpec
-RSpec.configure do |c|
+RSpec.configure do |config|
 	include Strelka::Constants
 	include Thingfish::SpecHelpers
 	include Thingfish::SpecHelpers::Constants
 
-	c.run_all_when_everything_filtered = true
-	c.filter_run :focus
-	c.order = 'random'
-	c.mock_with( :rspec ) do |mock|
+	config.mock_with( :rspec ) do |mock|
 		mock.syntax = :expect
 	end
 
-	c.include( Loggability::SpecHelpers )
-	c.include( Mongrel2::SpecHelpers )
-	c.include( Mongrel2::Constants )
-	c.include( Mongrel2::Config::DSL )
-	c.include( Strelka::Constants )
-	c.include( Strelka::Testing )
-	c.include( Thingfish::SpecHelpers )
+	config.disable_monkey_patching!
+	config.example_status_persistence_file_path = "spec/.status"
+	config.filter_run :focus
+	config.filter_run_when_matching :focus
+	config.order = :random
+	config.profile_examples = 5
+	config.run_all_when_everything_filtered = true
+	config.shared_context_metadata_behavior = :apply_to_host_groups
+	# config.warnings = true
+
+	config.include( Loggability::SpecHelpers )
+	config.include( Mongrel2::SpecHelpers )
+	config.include( Mongrel2::Constants )
+	config.include( Mongrel2::Config::DSL )
+	config.include( Strelka::Constants )
+	config.include( Strelka::Testing )
+	config.include( Thingfish::SpecHelpers )
 end
 
 # vim: set nosta noet ts=4 sw=4:

data/spec/thingfish/datastore/memory_spec.rb

@@ -7,7 +7,7 @@ require 'thingfish/datastore'
 require 'thingfish/behaviors'
 
 
-describe Thingfish::Datastore, "memory" do
+RSpec.describe Thingfish::Datastore, "memory" do
 
 	let( :store ) { Thingfish::Datastore.create(:memory) }
 

data/spec/thingfish/datastore_spec.rb

@@ -9,7 +9,7 @@ class TestingDatastore < Thingfish::Datastore
 end
 
 
-describe Thingfish::Datastore do
+RSpec.describe Thingfish::Datastore do
 
 	it "is abstract" do
 		expect { described_class.new }.to raise_error( NoMethodError, /private/i )

data/spec/thingfish/handler_spec.rb

@@ -7,27 +7,18 @@ require 'thingfish/handler'
 require 'thingfish/processor'
 
 
-describe Thingfish::Handler do
+RSpec.describe Thingfish::Handler do
 
-	EVENT_SOCKET_URI = 'tcp://127.0.0.1:0'
+	EVENT_SOCKET_URI = 'tcp://127.0.0.1:*'
 
 	before( :all ) do
 		Thingfish::Handler.configure( :event_socket_uri => EVENT_SOCKET_URI )
 		Thingfish::Handler.install_plugins
 	end
 
-	before( :each ) do
-		@png_io  = StringIO.new( TEST_PNG_DATA.dup )
-		@text_io = StringIO.new( TEST_TEXT_DATA.dup )
-		@handler = described_class.new( TEST_APPID, TEST_SEND_SPEC, TEST_RECV_SPEC )
-	end
-
-
-	after( :each ) do
-		@handler.shutdown
-	end
-
-	# let( :handler ) { described_class.new(TEST_APPID, TEST_SEND_SPEC, TEST_RECV_SPEC) }
+    let( :png_io  ) { StringIO.new( TEST_PNG_DATA.dup ) }
+    let( :text_io ) { StringIO.new( TEST_TEXT_DATA.dup ) }
+	let( :handler ) { described_class.new(TEST_APPID, TEST_SEND_SPEC, TEST_RECV_SPEC) }
 
 
 	#
@@ -51,7 +42,7 @@ describe Thingfish::Handler do
 
 		it 'returns interesting configuration info' do
 			req = factory.get( '/serverinfo',  content_type: 'text/plain' )
-			res = @handler.handle( req )
+			res = handler.handle( req )
 
 			expect( res.status_line ).to match( /200 ok/i )
 			expect( res.headers ).to include( 'x-thingfish' )
@@ -73,7 +64,7 @@ describe Thingfish::Handler do
 			req = factory.post( '/', TEST_TEXT_DATA )
 			req.content_type = 'text/plain'
 			req.headers.content_length = TEST_TEXT_DATA.bytesize
-			res = @handler.handle( req )
+			res = handler.handle( req )
 
 			expect( res.status_line ).to match( /201 created/i )
 			expect( res.headers.location.to_s ).to match( %r:/#{UUID_PATTERN}$: )
@@ -100,18 +91,18 @@ describe Thingfish::Handler do
 				with( spool_path, 'r', encoding: Encoding::ASCII_8BIT ).
 				and_return( fh )
 
-			start_req = factory.post( '/', nil,
+			start_req = factory.post( '/', '',
 				x_mongrel2_upload_start: spool_path,
 				content_length: upload_size,
 				content_type: 'text/plain' )
-			upload_req = factory.post( '/', nil,
+			upload_req = factory.post( '/', '',
 				x_mongrel2_upload_start: spool_path,
 				x_mongrel2_upload_done: spool_path,
 				content_length: upload_size,
 				content_type: 'text/plain' )
 
-			start_res = @handler.dispatch_request( start_req )
-			upload_res = @handler.dispatch_request( upload_req )
+			start_res = handler.dispatch_request( start_req )
+			upload_res = handler.dispatch_request( upload_req )
 
 			expect( start_res ).to be_nil
 
@@ -151,7 +142,7 @@ describe Thingfish::Handler do
 			req = factory.post( '/', TEST_TEXT_DATA )
 			req.content_type = 'text/plain'
 
-			res = @handler.handle( req )
+			res = handler.handle( req )
 			res.body.rewind
 			expect( res.status ).to be( HTTP::BAD_REQUEST )
 			expect( res.body.read ).to match( /missing operational attribute/i )
@@ -166,60 +157,60 @@ describe Thingfish::Handler do
 			}
 			req = factory.post( '/', TEST_TEXT_DATA, headers )
 			req.headers.content_length = TEST_TEXT_DATA.bytesize
-			res = @handler.handle( req )
+			res = handler.handle( req )
 
 			expect( res.status_line ).to match( /201 created/i )
 			expect( res.headers.location.to_s ).to match( %r:/#{UUID_PATTERN}$: )
 
 			uuid = res.headers.x_thingfish_uuid
-			expect( @handler.metastore.fetch_value(uuid, 'title') ).
+			expect( handler.metastore.fetch_value(uuid, 'title') ).
 				to eq( 'Muffin the Panda Goes To School' )
-			expect( @handler.metastore.fetch_value(uuid, 'tags') ).to eq( 'rapper,ukraine,potap' )
+			expect( handler.metastore.fetch_value(uuid, 'tags') ).to eq( 'rapper,ukraine,potap' )
 		end
 
 
 		it 'replaces content via PUT' do
-			uuid = @handler.datastore.save( @text_io )
-			@handler.metastore.save( uuid, {'format' => 'text/plain'} )
+			uuid = handler.datastore.save( text_io )
+			handler.metastore.save( uuid, {'format' => 'text/plain'} )
 
-			req = factory.put( "/#{uuid}", @png_io, content_type: 'image/png' )
-			req.headers.content_length = @png_io.read.bytesize
-			res = @handler.handle( req )
+			req = factory.put( "/#{uuid}", png_io, content_type: 'image/png' )
+			req.headers.content_length = png_io.read.bytesize
+			res = handler.handle( req )
 
 			expect( res.status ).to eq( HTTP::NO_CONTENT )
-			expect( @handler.datastore.fetch(uuid).read ).to eq( TEST_PNG_DATA )
-			expect( @handler.metastore.fetch(uuid) ).to include( 'format' => 'image/png' )
+			expect( handler.datastore.fetch(uuid).read ).to eq( TEST_PNG_DATA )
+			expect( handler.metastore.fetch(uuid) ).to include( 'format' => 'image/png' )
 		end
 
 
 		it "doesn't care about the case of the UUID when replacing content via PUT" do
-			uuid = @handler.datastore.save( @text_io )
-			@handler.metastore.save( uuid, {'format' => 'text/plain'} )
+			uuid = handler.datastore.save( text_io )
+			handler.metastore.save( uuid, {'format' => 'text/plain'} )
 
-			req = factory.put( "/#{uuid.upcase}", @png_io, content_type: 'image/png' )
-			req.headers.content_length = @png_io.read.bytesize
-			res = @handler.handle( req )
+			req = factory.put( "/#{uuid.upcase}", png_io, content_type: 'image/png' )
+			req.headers.content_length = png_io.read.bytesize
+			res = handler.handle( req )
 
 			expect( res.status ).to eq( HTTP::NO_CONTENT )
-			expect( @handler.datastore.fetch(uuid).read ).to eq( TEST_PNG_DATA )
-			expect( @handler.metastore.fetch(uuid) ).to include( 'format' => 'image/png' )
+			expect( handler.datastore.fetch(uuid).read ).to eq( TEST_PNG_DATA )
+			expect( handler.metastore.fetch(uuid) ).to include( 'format' => 'image/png' )
 		end
 
 
 		it 'can fetch all uploaded data' do
-			text_uuid = @handler.datastore.save( @text_io )
-			@handler.metastore.save( text_uuid, {
+			text_uuid = handler.datastore.save( text_io )
+			handler.metastore.save( text_uuid, {
 				'format' => 'text/plain',
-				'extent' => @text_io.string.bytesize
+				'extent' => text_io.string.bytesize
 			})
-			png_uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( png_uuid, {
+			png_uuid = handler.datastore.save( png_io )
+			handler.metastore.save( png_uuid, {
 				'format' => 'image/png',
-				'extent' => @png_io.string.bytesize
+				'extent' => png_io.string.bytesize
 			})
 
 			req = factory.get( '/' )
-			res = @handler.handle( req )
+			res = handler.handle( req )
 			content = Yajl::Parser.parse( res.body.read )
 
 			expect( res.status_line ).to match( /200 ok/i )
@@ -228,30 +219,30 @@ describe Thingfish::Handler do
 			expect( content[0] ).to be_a( Hash )
 			expect( content[0]['uri'] ).to eq( "#{req.base_uri}#{text_uuid}" )
 			expect( content[0]['format'] ).to eq( "text/plain" )
-			expect( content[0]['extent'] ).to eq( @text_io.string.bytesize )
+			expect( content[0]['extent'] ).to eq( text_io.string.bytesize )
 			expect( content[1] ).to be_a( Hash )
 			expect( content[1]['uri'] ).to eq( "#{req.base_uri}#{png_uuid}" )
 			expect( content[1]['format'] ).to eq( 'image/png' )
-			expect( content[1]['extent'] ).to eq( @png_io.string.bytesize )
+			expect( content[1]['extent'] ).to eq( png_io.string.bytesize )
 		end
 
 
 		it 'can fetch all related data for a single resource' do
-			main_uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( main_uuid, {
+			main_uuid = handler.datastore.save( png_io )
+			handler.metastore.save( main_uuid, {
 				'format' => 'image/png',
-				'extent' => @png_io.string.bytesize
+				'extent' => png_io.string.bytesize
 			})
-			related_uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( related_uuid, {
+			related_uuid = handler.datastore.save( png_io )
+			handler.metastore.save( related_uuid, {
 				'format'       => 'image/png',
-				'extent'       => @png_io.string.bytesize,
+				'extent'       => png_io.string.bytesize,
 				'relation'     => main_uuid,
 				'relationship' => "twinsies"
 			})
 
 			req = factory.get( "/#{main_uuid}/related" )
-			res = @handler.handle( req )
+			res = handler.handle( req )
 			content = Yajl::Parser.parse( res.body.read )
 
 			expect( res.status_line ).to match( /200 ok/i )
@@ -260,146 +251,190 @@ describe Thingfish::Handler do
 			expect( content[0] ).to be_a( Hash )
 			expect( content[0]['uri'] ).to eq( "#{req.base_uri}#{related_uuid}" )
 			expect( content[0]['format'] ).to eq( "image/png" )
-			expect( content[0]['extent'] ).to eq( @png_io.string.bytesize )
+			expect( content[0]['extent'] ).to eq( png_io.string.bytesize )
 			expect( content[0]['uuid'] ).to eq( related_uuid )
 			expect( content[0]['relation'] ).to eq( main_uuid )
 		end
 
 
 		it 'can fetch a related resource by name' do
-			main_uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( main_uuid, {
+			main_uuid = handler.datastore.save( png_io )
+			handler.metastore.save( main_uuid, {
 				'format' => 'image/png',
-				'extent' => @png_io.string.bytesize
+				'extent' => png_io.string.bytesize
 			})
-			related_uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( related_uuid, {
+			related_uuid = handler.datastore.save( png_io )
+			handler.metastore.save( related_uuid, {
 				'format'       => 'image/png',
-				'extent'       => @png_io.string.bytesize,
+				'extent'       => png_io.string.bytesize,
 				'relation'     => main_uuid,
-				'relationship' => "twinsies"
+				'relationship' => "twinsies",
+				'title'        => 'Make America Smart Again.png',
+				'checksum'     => '123456'
 			})
 
 			req = factory.get( "/#{main_uuid}/related/twinsies" )
-			res = @handler.handle( req )
+			res = handler.handle( req )
 
 			expect( res.status_line ).to match( /200 ok/i )
 			expect( res.headers.content_type ).to eq( 'image/png' )
+			expect( res.headers.etag ).to eq( '123456' )
+			expect( res.headers.content_disposition ).to eq( 'filename="Make America Smart Again.png"' )
 			expect( res.body.read ).to eq( TEST_PNG_DATA )
 		end
 
 
 		it "404s when attempting to fetch a resource related to a non-existant resource" do
 			req = factory.get( "/#{TEST_UUID}/related/twinsies" )
-			res = @handler.handle( req )
+			res = handler.handle( req )
 
 			expect( res.status_line ).to match( /404 not found/i )
 		end
 
 
 		it "404s when attempting to fetch a related resource that doesn't exist" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format' => 'image/png',
-				'extent' => @png_io.string.bytesize
+				'extent' => png_io.string.bytesize
 			})
 
 			req = factory.get( "/#{uuid}/related/twinsies" )
-			res = @handler.handle( req )
+			res = handler.handle( req )
 
 			expect( res.status_line ).to match( /404 not found/i )
 		end
 
 
 		it "can fetch an uploaded chunk of data" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {'format' => 'image/png'} )
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {'format' => 'image/png'} )
 
 			req = factory.get( "/#{uuid}" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status_line ).to match( /200 ok/i )
-			expect( result.body.read ).to eq( @png_io.string )
+			expect( result.body.read ).to eq( png_io.string )
 			expect( result.headers.content_type ).to eq( 'image/png' )
 		end
 
 
 		it "returns a 404 Not Found when asked to fetch an object that doesn't exist" do
 			req = factory.get( "/#{TEST_UUID}" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status_line ).to match( /404 not found/i )
 		end
 
 
 		it "returns a 404 Not Found when asked to fetch an object that doesn't exist in the metastore" do
-			uuid = @handler.datastore.save( @png_io )
+			uuid = handler.datastore.save( png_io )
 
 			req = factory.get( "/#{uuid}" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status_line ).to match( /404 not found/i )
 		end
 
 
 		it "doesn't care about the case of the UUID when fetching uploaded data" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {'format' => 'image/png'} )
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {'format' => 'image/png'} )
 
 			req = factory.get( "/#{uuid.upcase}" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status_line ).to match( /200 ok/i )
-			expect( result.body.read ).to eq( @png_io.string )
+			expect( result.body.read ).to eq( png_io.string )
 			expect( result.headers.content_type ).to eq( 'image/png' )
 		end
 
 
-		it "adds browser cache headers to resources with a checksum attribute" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, 'format' => 'image/png', 'checksum' => '123456' )
+		it "adds date cache headers to resources" do
+			created = Time.now
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, 'format' => 'image/png', 'created' => created )
 
 			req = factory.get( "/#{uuid}" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
+
+			expect( result.status_line ).to match( /200 ok/i )
+			expect( result.headers.last_modified ).to eq( created.httpdate )
+		end
+
+
+		it "adds content cache headers to resources with a checksum attribute" do
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, 'format' => 'image/png', 'checksum' => '123456' )
+
+			req = factory.get( "/#{uuid}" )
+			result = handler.handle( req )
 
 			expect( result.status_line ).to match( /200 ok/i )
 			expect( result.headers.etag ).to eq( '123456' )
 		end
 
 
-		it "returns a 304 not modified for unchanged client cache requests" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, 'format' => 'image/png', 'checksum' => '123456' )
+		it "adds content disposition filename, if the resource has a title" do
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {'format' => 'image/png', 'title' => 'spょler"py.txt'} )
 
 			req = factory.get( "/#{uuid}" )
-			req.headers[ :if_none_match ] = '123456'
-			result = @handler.handle( req )
+			result = handler.handle( req )
+
+			expect( result.status_line ).to match( /200 ok/i )
+			expect( result.body.read ).to eq( png_io.string )
+			expect( result.headers.content_type ).to eq( 'image/png' )
+			expect( result.headers.content_disposition ).to eq( 'filename="sp?ler\"py.txt"' )
+		end
+
+
+		it "returns a 304 not modified for unchanged date cache requests" do
+			created = Time.now
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, 'format' => 'image/png', 'created' => created )
+
+			req = factory.get( "/#{uuid}" )
+			req.headers[ :if_modified_since ] = ( Time.now - 300 ).httpdate
+			result = handler.handle( req )
 
 			expect( result.status_line ).to match( /304 not modified/i )
 			expect( result.body.read ).to be_empty
 		end
 
 
+		it "returns a 304 not modified for unchanged content cache requests" do
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, 'format' => 'image/png', 'checksum' => '123456' )
+
+			req = factory.get( "/#{uuid}" )
+			req.headers[ :if_none_match ] = '123456'
+			result = handler.handle( req )
+
+			expect( result.status_line ).to match( /304 not modified/i )
+			expect( result.body.read ).to be_empty
+		end
+
 
 		it "can remove everything associated with an object id" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format' => 'image/png',
 				'extent' => 288,
 			})
 
 			req = factory.delete( "/#{uuid}" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status_line ).to match( /200 ok/i )
-			expect( @handler.metastore.include?(uuid) ).to be_falsey
-			expect( @handler.datastore.include?(uuid) ).to be_falsey
+			expect( handler.metastore.include?(uuid) ).to be_falsey
+			expect( handler.datastore.include?(uuid) ).to be_falsey
 		end
 
 
 		it "returns a 404 Not Found when asked to remove an object that doesn't exist" do
 			req = factory.delete( "/#{TEST_UUID}" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status_line ).to match( /404 not found/i )
 		end
@@ -417,15 +452,15 @@ describe Thingfish::Handler do
 		end
 
 		it "can fetch the metadata associated with uploaded data" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format'  => 'image/png',
 				'extent'  => 288,
 				'created' => Time.at(1378313840),
 			})
 
 			req = factory.get( "/#{uuid}/metadata" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 			content = result.body.read
 
 			content_hash = Yajl::Parser.parse( content )
@@ -433,7 +468,7 @@ describe Thingfish::Handler do
 			expect( result.status ).to eq( 200 )
 			expect( result.headers.content_type ).to eq( 'application/json' )
 			expect( content_hash ).to be_a( Hash )
-			expect( content_hash['oid'] ).to eq( uuid )
+			expect( content_hash['uuid'] ).to eq( uuid )
 			expect( content_hash['extent'] ).to eq( 288 )
 			expect( content_hash['created'] ).to eq( Time.at(1378313840).to_s )
 		end
@@ -441,21 +476,21 @@ describe Thingfish::Handler do
 
 		it "returns a 404 Not Found when fetching metadata for an object that doesn't exist" do
 			req = factory.get( "/#{TEST_UUID}/metadata" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status_line ).to match( /404 not found/i )
 		end
 
 
 		it "can fetch a value for a single metadata key" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format' => 'image/png',
 				'extent' => 288,
 			})
 
 			req     = factory.get( "/#{uuid}/metadata/extent" )
-			result  = @handler.handle( req )
+			result  = handler.handle( req )
 			result.body.rewind
 			content = result.body.read
 
@@ -467,21 +502,21 @@ describe Thingfish::Handler do
 
 		it "returns a 404 Not Found when fetching a single metadata value for a uuid that doesn't exist" do
 			req = factory.get( "/#{TEST_UUID}/metadata/extent" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status_line ).to match( /404 not found/i )
 		end
 
 
 		it "doesn't error when fetching a non-existent metadata value" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format' => 'image/png',
 				'extent' => 288,
 			})
 
 			req = factory.get( "/#{uuid}/metadata/hururrgghh" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			content = Yajl::Parser.parse( result.body.read )
 
@@ -493,59 +528,58 @@ describe Thingfish::Handler do
 
 
 		it "can merge in new metadata for an existing resource with a POST" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format' => 'image/png',
-				'extent' => 288,
+				'extent' => 288
 			})
 
-			body_json = Yajl.dump({ 'comment' => 'Ignore me!' })
+			body_json = Yajl.dump({ 'comment' => 'Ignore me!', 'uuid' => 123 })
 			req = factory.post( "/#{uuid}/metadata", body_json, 'Content-type' => 'application/json' )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
-			expect( result.status ).to eq( HTTP::NO_CONTENT )
-			expect( @handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'Ignore me!' )
+			expect( result.status ).to eq( HTTP::OK )
+			expect( handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'Ignore me!' )
+			expect( handler.metastore.fetch_value(uuid, 'uuid') ).to be_nil
 		end
 
 
-		it "returns FORBIDDEN when attempting to merge metadata with operational keys" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+		it "ignores attempts to alter operational metadata when merging" do
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format' => 'image/png',
 				'extent' => 288,
 			})
 
 			body_json = Yajl.dump({ 'format' => 'text/plain', 'comment' => 'Ignore me!' })
 			req = factory.post( "/#{uuid}/metadata", body_json, 'Content-type' => 'application/json' )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
-			expect( result.status ).to eq( HTTP::FORBIDDEN )
-			expect( result.body.string ).to match( /unable to alter protected metadata/i )
-			expect( result.body.string ).to match( /format/i )
-			expect( @handler.metastore.fetch_value(uuid, 'comment') ).to be_nil
-			expect( @handler.metastore.fetch_value(uuid, 'format') ).to eq( 'image/png' )
+			expect( result.status ).to eq( HTTP::OK )
+			expect( handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'Ignore me!' )
+			expect( handler.metastore.fetch_value(uuid, 'format') ).to eq( 'image/png' )
 		end
 
 
 		it "can create single metadata values with a POST" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format' => 'image/png',
 				'extent' => 288,
 			})
 
 			req = factory.post( "/#{uuid}/metadata/comment", "urrrg", 'Content-type' => 'text/plain' )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status ).to eq( HTTP::CREATED )
 			expect( result.headers.location ).to match( %r|#{uuid}/metadata/comment$| )
-			expect( @handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'urrrg' )
+			expect( handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'urrrg' )
 		end
 
 
 		it "returns NOT_FOUND when attempting to create metadata for a non-existent object" do
 			req = factory.post( "/#{TEST_UUID}/metadata/comment", "urrrg", 'Content-type' => 'text/plain' )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status ).to eq( HTTP::NOT_FOUND )
 			expect( result.body.string ).to match( /no such object/i )
@@ -553,73 +587,73 @@ describe Thingfish::Handler do
 
 
 		it "returns CONFLICT when attempting to create a single metadata value if it already exists" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format'  => 'image/png',
 				'extent'  => 288,
 				'comment' => 'nill bill'
 			})
 
 			req = factory.post( "/#{uuid}/metadata/comment", "urrrg", 'Content-type' => 'text/plain' )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status ).to eq( HTTP::CONFLICT )
 			expect( result.body.string ).to match( /already exists/i )
-			expect( @handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'nill bill' )
+			expect( handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'nill bill' )
 		end
 
 
 		it "can create single metadata values with a PUT" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format' => 'image/png',
 				'extent' => 288,
 			})
 
 			req = factory.put( "/#{uuid}/metadata/comment", "urrrg", 'Content-type' => 'text/plain' )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status ).to eq( HTTP::NO_CONTENT )
-			expect( @handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'urrrg' )
+			expect( handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'urrrg' )
 		end
 
 
 		it "can replace a single metadata value with a PUT" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format'  => 'image/png',
 				'extent'  => 288,
 				'comment' => 'nill bill'
 			})
 
 			req = factory.put( "/#{uuid}/metadata/comment", "urrrg", 'Content-type' => 'text/plain' )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status ).to eq( HTTP::NO_CONTENT )
-			expect( @handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'urrrg' )
+			expect( handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'urrrg' )
 		end
 
 
 		it "returns FORBIDDEN when attempting to replace a operational metadata value with a PUT" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format'  => 'image/png',
 				'extent'  => 288,
 				'comment' => 'nill bill'
 			})
 
 			req = factory.put( "/#{uuid}/metadata/format", "image/gif", 'Content-type' => 'text/plain' )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status ).to eq( HTTP::FORBIDDEN )
 			expect( result.body.string ).to match( /protected metadata/i )
-			expect( @handler.metastore.fetch_value(uuid, 'format') ).to eq( 'image/png' )
+			expect( handler.metastore.fetch_value(uuid, 'format') ).to eq( 'image/png' )
 		end
 
 
 		it "can replace all metadata with a PUT" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format'    => 'image/png',
 				'extent'    => 288,
 				'comment'   => 'nill bill',
@@ -628,19 +662,19 @@ describe Thingfish::Handler do
 
 			req = factory.put( "/#{uuid}/metadata", %[{"comment":"Yeah."}],
 			                   'Content-type' => 'application/json' )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
-			expect( result.status ).to eq( HTTP::NO_CONTENT )
-			expect( @handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'Yeah.' )
-			expect( @handler.metastore.fetch_value(uuid, 'format') ).to eq( 'image/png' )
-			expect( @handler.metastore ).to_not include( 'ephemeral' )
+			expect( result.status ).to eq( HTTP::OK )
+			expect( handler.metastore.fetch_value(uuid, 'comment') ).to eq( 'Yeah.' )
+			expect( handler.metastore.fetch_value(uuid, 'format') ).to eq( 'image/png' )
+			expect( handler.metastore ).to_not include( 'ephemeral' )
 		end
 
 
 		it "can remove all non-default metadata with a DELETE" do
 			timestamp = Time.now.getgm
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format'        => 'image/png',
 				'extent'        => 288,
 				'comment'       => 'nill bill',
@@ -650,49 +684,49 @@ describe Thingfish::Handler do
 			})
 
 			req = factory.delete( "/#{uuid}/metadata" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
-			expect( result.status ).to eq( HTTP::NO_CONTENT )
-			expect( result.body.string ).to be_empty
-			expect( @handler.metastore.fetch_value(uuid, 'format') ).to eq( 'image/png' )
-			expect( @handler.metastore.fetch_value(uuid, 'extent') ).to eq( 288 )
-			expect( @handler.metastore.fetch_value(uuid, 'uploadaddress') ).to eq( '127.0.0.1' )
-			expect( @handler.metastore.fetch_value(uuid, 'created') ).to eq( timestamp )
+			expect( result.status ).to eq( HTTP::OK )
+			expect( result.body.string ).to_not be_empty
+			expect( handler.metastore.fetch_value(uuid, 'format') ).to eq( 'image/png' )
+			expect( handler.metastore.fetch_value(uuid, 'extent') ).to eq( 288 )
+			expect( handler.metastore.fetch_value(uuid, 'uploadaddress') ).to eq( '127.0.0.1' )
+			expect( handler.metastore.fetch_value(uuid, 'created') ).to eq( timestamp )
 
-			expect( @handler.metastore.fetch_value(uuid, 'comment') ).to be_nil
-			expect( @handler.metastore.fetch_value(uuid, 'useragent') ).to be_nil
+			expect( handler.metastore.fetch_value(uuid, 'comment') ).to be_nil
+			expect( handler.metastore.fetch_value(uuid, 'useragent') ).to be_nil
 		end
 
 
 		it "can remove a single metadata value with DELETE" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format'  => 'image/png',
 				'comment' => 'nill bill'
 			})
 
 			req = factory.delete( "/#{uuid}/metadata/comment" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status ).to eq( HTTP::NO_CONTENT )
 			expect( result.body.string ).to be_empty
-			expect( @handler.metastore.fetch_value(uuid, 'comment') ).to be_nil
-			expect( @handler.metastore.fetch_value(uuid, 'format') ).to eq( 'image/png' )
+			expect( handler.metastore.fetch_value(uuid, 'comment') ).to be_nil
+			expect( handler.metastore.fetch_value(uuid, 'format') ).to eq( 'image/png' )
 		end
 
 
 		it "returns FORBIDDEN when attempting to remove a operational metadata value with a DELETE" do
-			uuid = @handler.datastore.save( @png_io )
-			@handler.metastore.save( uuid, {
+			uuid = handler.datastore.save( png_io )
+			handler.metastore.save( uuid, {
 				'format'  => 'image/png'
 			})
 
 			req = factory.delete( "/#{uuid}/metadata/format" )
-			result = @handler.handle( req )
+			result = handler.handle( req )
 
 			expect( result.status ).to eq( HTTP::FORBIDDEN )
 			expect( result.body.string ).to match( /protected metadata/i )
-			expect( @handler.metastore.fetch_value(uuid, 'format') ).to eq( 'image/png' )
+			expect( handler.metastore.fetch_value(uuid, 'format') ).to eq( 'image/png' )
 		end
 	end
 
@@ -777,23 +811,23 @@ describe Thingfish::Handler do
 
 			req = factory.post( '/', TEST_TEXT_DATA, content_type: 'text/plain' )
 			req.headers.content_length = TEST_TEXT_DATA.bytesize
-			res = @handler.handle( req )
+			res = handler.handle( req )
 			uuid = res.headers.x_thingfish_uuid
 
-			Thingfish.logger.debug "Metastore contains: %p" % [ @handler.metastore.storage ]
+			Thingfish.logger.debug "Metastore contains: %p" % [ handler.metastore.storage ]
 
-			expect( @handler.metastore.fetch(uuid) ).
+			expect( handler.metastore.fetch(uuid) ).
 				to include( 'test:comment' => 'Yo, it totally worked.')
-			related_uuids = @handler.metastore.fetch_related_oids( uuid )
+			related_uuids = handler.metastore.fetch_related_oids( uuid )
 			expect( related_uuids.size ).to eq( 1 )
 
 			r_uuid = related_uuids.first.downcase
-			expect( @handler.metastore.fetch_value(r_uuid, 'relation') ).to eq( uuid )
-			expect( @handler.metastore.fetch_value(r_uuid, 'format') ).to eq( 'text/plain' )
-			expect( @handler.metastore.fetch_value(r_uuid, 'extent') ).to eq( 9 )
-			expect( @handler.metastore.fetch_value(r_uuid, 'relationship') ).to eq( 'comment' )
+			expect( handler.metastore.fetch_value(r_uuid, 'relation') ).to eq( uuid )
+			expect( handler.metastore.fetch_value(r_uuid, 'format') ).to eq( 'text/plain' )
+			expect( handler.metastore.fetch_value(r_uuid, 'extent') ).to eq( 9 )
+			expect( handler.metastore.fetch_value(r_uuid, 'relationship') ).to eq( 'comment' )
 
-			expect( @handler.datastore.fetch(r_uuid).read ).to eq( 'Chunkers!' )
+			expect( handler.datastore.fetch(r_uuid).read ).to eq( 'Chunkers!' )
 		end
 
 
@@ -802,7 +836,7 @@ describe Thingfish::Handler do
 			processor = described_class.processors.first
 
 			req = factory.post( "/#{TEST_UUID}/metadata", TEST_TEXT_DATA, content_type: 'text/plain' )
-			@handler.handle( req )
+			handler.handle( req )
 
 			expect( processor.was_called ).to be_falsey
 		end
@@ -811,11 +845,11 @@ describe Thingfish::Handler do
 		it "processes responses" do
 			described_class.configure( :processors => %w[test] )
 
-			uuid = @handler.datastore.save( @text_io )
-			@handler.metastore.save( uuid, {'format' => 'text/plain'} )
+			uuid = handler.datastore.save( text_io )
+			handler.metastore.save( uuid, {'format' => 'text/plain'} )
 
 			req = factory.get( "/#{uuid}" )
-			res = @handler.handle( req )
+			res = handler.handle( req )
 
 			res.body.rewind
 			expect( res.body.read ).to eq( TEST_TEXT_DATA.reverse )
@@ -826,11 +860,11 @@ describe Thingfish::Handler do
 			described_class.configure( :processors => %w[test] )
 			processor = described_class.processors.first
 
-			uuid = @handler.datastore.save( @text_io )
-			@handler.metastore.save( uuid, {'format' => 'text/plain'} )
+			uuid = handler.datastore.save( text_io )
+			handler.metastore.save( uuid, {'format' => 'text/plain'} )
 
 			req = factory.get( "/#{uuid}/metadata" )
-			@handler.handle( req )
+			handler.handle( req )
 
 			expect( processor.was_called ).to be_falsey
 		end
@@ -846,12 +880,12 @@ describe Thingfish::Handler do
 		end
 
 		before( :each ) do
-			@handler.setup_event_socket
+			handler.setup_event_socket
 
-			@subsock = Mongrel2.zmq_context.socket( :SUB )
-			@subsock.linger = 0
+			@subsock = CZTop::Socket::SUB.new
+			@subsock.options.linger = 0
 			@subsock.subscribe( '' )
-			@subsock.connect( @handler.event_socket.endpoint )
+			@subsock.connect( handler.event_socket.last_endpoint )
 		end
 
 		after( :each ) do
@@ -861,20 +895,20 @@ describe Thingfish::Handler do
 		it "publishes notifications about uploaded assets to a PUBSUB socket" do
 			req = factory.post( '/', TEST_TEXT_DATA, content_type: 'text/plain' )
 			req.headers.content_length = TEST_TEXT_DATA.bytesize
-			res = @handler.handle( req )
 
-			handles = ZMQ.select( [@subsock], nil, nil, 0 )
-			expect( handles ).to be_an( Array )
-			expect( handles[0].size ).to eq( 1 )
-			expect( handles[0].first ).to be( @subsock )
+			poller = CZTop::Poller.new
+			poller.add_reader( @subsock )
+
+			handler.handle( req )
+			event = poller.wait( 500 )
+
+			expect( event ).to_not be_nil
 
-			event = @subsock.recv
-			expect( @subsock.rcvmore? ).to be_truthy
-			expect( event ).to eq( 'created' )
+			message = event.socket.receive
+			expect( message.frames.count ).to be( 2 )
 
-			resource = @subsock.recv
-			expect( @subsock.rcvmore? ).to be_falsey
-			expect( resource ).to match( /^\{"uuid":"#{UUID_PATTERN}"\}$/ )
+			expect( message.frames.first.to_s ).to eq( 'created' )
+			expect( message.frames.last.to_s ).to match( /^\{"uuid":"#{UUID_PATTERN}"\}$/ )
 		end
 	end