blobby 1.0.0

data/lib/blobby/in_memory_store.rb

@@ -0,0 +1,64 @@
+require "blobby/key_constraint"
+
+module Blobby
+
+  # A BLOB store backed by a Hash.
+  #
+  class InMemoryStore
+
+    def initialize(hash = {})
+      @hash = hash
+    end
+
+    def available?
+      true
+    end
+
+    def [](key)
+      KeyConstraint.must_allow!(key)
+      StoredObject.new(@hash, key)
+    end
+
+    class StoredObject
+
+      def initialize(hash, key)
+        @hash = hash
+        @key = key
+      end
+
+      attr_reader :key
+
+      def exists?
+        @hash.key?(key)
+      end
+
+      def read
+        content = @hash[key]
+        if block_given?
+          yield content
+          nil
+        else
+          content
+        end
+      end
+
+      def write(content)
+        if content.respond_to?(:read)
+          content = content.read
+        else
+          content = content.to_str.dup
+        end
+        content = content.force_encoding("BINARY") if content.respond_to?(:force_encoding)
+        @hash[key] = content
+        nil
+      end
+
+      def delete
+        !!@hash.delete(key)
+      end
+
+    end
+
+  end
+
+end

data/lib/blobby/key_constraint.rb

@@ -0,0 +1,34 @@
+require "uri"
+
+module Blobby
+
+  # Defines the keys we allow for use in BLOB-store implementations.
+  #
+  # Basically, we allow anything that would be a valid URI "path" component.
+  #
+  module KeyConstraint
+
+    extend self
+
+    BAD_PATTERNS = [
+      %r{\A\Z}, # blank
+      %r{\A/}, # leading slash
+      %r{/\Z}, # trailing slash
+      %r{//+}, # multiple slashes
+      %r{:} # colon
+    ].freeze
+
+    def allows?(key)
+      BAD_PATTERNS.none? { |pattern| pattern =~ key } &&
+        URI.parse(key).path == key
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def must_allow!(key)
+      fail ArgumentError, "invalid key: #{key.inspect}" unless allows?(key)
+    end
+
+  end
+
+end

data/lib/blobby/key_transforming_store.rb

@@ -0,0 +1,25 @@
+require "blobby/key_constraint"
+require "fileutils"
+require "forwardable"
+require "pathname"
+require "tempfile"
+
+module Blobby
+
+  # A BLOB store that decorates another store and allows key transformation
+  #
+  class KeyTransformingStore < SimpleDelegator
+
+    def initialize(store, &key_transformation_strategy)
+      super(store)
+      @key_transformation_strategy = key_transformation_strategy
+    end
+
+    def [](key)
+      transformed_key = @key_transformation_strategy.call(key)
+      __getobj__[transformed_key]
+    end
+
+  end
+
+end

data/lib/blobby/logging_store.rb

@@ -0,0 +1,67 @@
+module Blobby
+
+  # A store decorator that logs writes and deletes
+  #
+  class LoggingStore
+
+    def initialize(store, store_name, logger)
+      @store = store
+      @store_name = store_name
+      @logger = logger
+    end
+
+    def available?
+      store.available?
+    end
+
+    def [](key)
+      StoredObject.new(store[key],
+                       :on_write => -> { logger.info(%(wrote to #{key.inspect} in #{store_name})) },
+                       :on_delete => -> { logger.info(%(deleted #{key.inspect} from #{store_name})) }
+      )
+    end
+
+    private
+
+    attr_reader :logger
+    attr_reader :store
+    attr_reader :store_name
+
+    class StoredObject
+
+      def initialize(object, callbacks = {})
+        @object = object
+        @on_write = callbacks[:on_write] || -> {}
+        @on_delete = callbacks[:on_delete] || -> {}
+      end
+
+      def exists?
+        @object.exists?
+      end
+
+      def read(&block)
+        @object.read(&block)
+      end
+
+      def write(*args)
+        @object.write(*args)
+        @on_write.call
+        nil
+      end
+
+      def delete
+        deleted = @object.delete
+        @on_delete.call if deleted
+        deleted
+      end
+
+      private
+
+      attr_reader :object
+      attr_reader :on_write
+
+    end
+
+  end
+
+end

data/lib/blobby/version.rb

@@ -0,0 +1,3 @@
+module Blobby
+  VERSION = "1.0.0"
+end

data/spec/blobby/composite_store_spec.rb

@@ -0,0 +1,54 @@
+require "blobby/composite_store"
+require "blobby/in_memory_store"
+require "blobby/store_behaviour"
+
+describe Blobby::CompositeStore do
+
+  let(:storeA) { Blobby::InMemoryStore.new }
+  let(:storeB) { Blobby::InMemoryStore.new }
+  let(:stores) { [storeA, storeB] }
+
+  subject do
+    described_class.new(stores)
+  end
+
+  it_behaves_like Blobby::Store
+
+  let(:key) { "KEY" }
+  let(:content) { "CONTENT" }
+
+  describe "#write" do
+
+    before do
+      subject[key].write(content)
+    end
+
+    it "writes to all stores" do
+      stores.all? do |store|
+        expect(store[key].read).to eq(content)
+      end
+    end
+
+  end
+
+  context "for a key that only exists in the second store" do
+
+    before do
+      storeB[key].write(content)
+    end
+
+    describe "#exists?" do
+      it "is true" do
+        expect(subject[key]).to exist
+      end
+    end
+
+    describe "#read" do
+      it "returns the content" do
+        expect(subject[key].read).to eq(content)
+      end
+    end
+
+  end
+
+end

data/spec/blobby/fake_success_store_spec.rb

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+
+require "blobby/fake_success_store"
+require "blobby/store_behaviour"
+
+describe Blobby::FakeSuccessStore do
+
+  subject do
+    described_class.new
+  end
+
+  let(:key) { "KEY" }
+  let(:content) { "CONTENT" }
+
+  it "is available" do
+    expect(subject).to be_available
+  end
+
+  context "for a valid key" do
+
+    let(:stored_object) { subject[key] }
+
+    context "after content has been written" do
+
+      before do
+        stored_object.write(content)
+      end
+
+      describe "#exists?" do
+        it "is true" do
+          expect(stored_object).to exist
+        end
+      end
+
+      describe "#read" do
+
+        it "returns some content" do
+          expect(stored_object.read).not_to be_nil
+        end
+
+        context "with a block" do
+
+          before do
+            @chunks = []
+            @rval = stored_object.read do |chunk|
+              @chunks << chunk
+            end
+          end
+
+          it "yields some content in chunks" do
+            expect(@chunks.join).not_to be_nil
+          end
+
+          it "returns nil" do
+            expect(@rval).to be_nil
+          end
+
+        end
+
+      end
+
+      describe "#delete" do
+        it "returns true" do
+          expect(stored_object.delete).to eq(true)
+        end
+      end
+    end
+
+    if "Strings".respond_to?(:encoding)
+
+      context "for UTF-8 content" do
+
+        let(:content) { "SN☃WMAN" }
+
+        before do
+          stored_object.write(content)
+        end
+
+        describe "#read" do
+
+          it "returns binary data" do
+            expect(stored_object.read.encoding.name).to eq("ASCII-8BIT")
+          end
+
+        end
+
+      end
+
+    end
+
+    describe "#write" do
+
+      it "returns nil" do
+        expect(stored_object.write(content)).to be_nil
+      end
+
+    end
+
+  end
+
+  class << self
+
+    def it_allows_keys_containing(description, example_key)
+      it "allows keys containing #{description}" do
+        expect { subject[example_key] }.not_to raise_error
+      end
+    end
+
+    def it_disallows_keys_containing(description, example_key)
+      it "disallows keys containing #{description}" do
+        expect { subject[example_key] }.to raise_error(ArgumentError)
+      end
+    end
+
+  end
+
+  it_disallows_keys_containing "nil", nil
+  it_disallows_keys_containing "blank", ""
+
+  it_allows_keys_containing "slashes", "foo/bar/baz"
+  it_allows_keys_containing "selected metacharacters", "@$&*.,;()~"
+
+  it_disallows_keys_containing "spaces", "foo bar"
+  it_disallows_keys_containing "tabs", "foo\tbar"
+  it_disallows_keys_containing "newlines", "foo\nbar"
+
+  it_disallows_keys_containing "a question mark", "foo?"
+  it_disallows_keys_containing "a colon", "foo:blah"
+
+  it_disallows_keys_containing "a leading slash", "/foo"
+  it_disallows_keys_containing "a trailing slash", "foo/"
+  it_disallows_keys_containing "double slashes", "foo//bar"
+
+end

data/spec/blobby/filesystem_store_spec.rb

@@ -0,0 +1,206 @@
+# encoding: utf-8
+
+require "blobby/filesystem_store"
+require "blobby/store_behaviour"
+require "tmpdir"
+
+describe Blobby::FilesystemStore do
+
+  around(:each) do |example|
+    Dir.mktmpdir do |tmpdir|
+      @tmpdir = tmpdir
+      example.run
+      @tmpdir = nil
+    end
+  end
+
+  around(:each) do |example|
+    original_umask = File.umask
+    begin
+      File.umask(0077) # something stupid
+      example.run
+    ensure
+      File.umask(original_umask)
+    end
+  end
+
+  subject do
+    described_class.new(@tmpdir)
+  end
+
+  it_behaves_like Blobby::Store
+
+  let(:key) { "NAMESPACED/KEY" }
+  let(:content) { "CONTENT" }
+
+  let(:expected_file_path) { Pathname(@tmpdir) + key }
+
+  describe "#write" do
+
+    it "writes to the file-system" do
+      expect { subject[key].write(content) }.to change { expected_file_path.exist? }.from(false).to(true)
+    end
+
+    it "should have correct contents" do
+      expect { subject[key].write(content) }.to change { File.read(expected_file_path) rescue nil }.from(nil).to(content)
+    end
+
+    it "retries if renaming throws an ESTALE" do
+      raise_stack = [Errno::ESTALE]
+      expect_any_instance_of(Pathname).to receive(:rename).twice do |_args|
+        fail(raise_stack.shift) unless raise_stack.empty?
+        1
+      end
+      expect { subject[key].write(content) }.to_not raise_error
+    end
+
+  end
+
+  context "with a sharding strategy" do
+
+    subject do
+      described_class.new(@tmpdir) do |key|
+        [key[0, 2], key[2, 2], key[4, 2], key].join "/"
+      end
+    end
+
+    describe "#write" do
+
+      let(:key) { "aabbccdd.png" }
+      let(:expected_file_path) { Pathname(@tmpdir) + "aa/bb/cc/aabbccdd.png" }
+
+      before do
+        subject[key].write(content)
+      end
+
+      it "uses the key as the filename" do
+        expect(expected_file_path).to exist
+      end
+
+    end
+
+  end
+
+  context "when the directory doesn't exist" do
+
+    subject do
+      described_class.new("/tmp/bogus/directory")
+    end
+
+    it { is_expected.not_to be_available }
+
+  end
+
+  context "when the directory isn't writable" do
+
+    around do |example|
+      FileUtils.chmod(0500, @tmpdir)
+      example.run
+      FileUtils.chmod(0700, @tmpdir)
+    end
+
+    it { is_expected.not_to be_available }
+
+  end
+
+  context "when the directory isn't readable" do
+
+    around do |example|
+      FileUtils.chmod(0300, @tmpdir)
+      example.run
+      FileUtils.chmod(0700, @tmpdir)
+    end
+
+    it { is_expected.not_to be_available }
+
+  end
+
+  context "when the path isn't a directory" do
+
+    subject do
+      tempfile = "#{@tmpdir}/tempfile"
+      FileUtils.touch(tempfile)
+      described_class.new(tempfile)
+    end
+
+    it { is_expected.not_to be_available }
+
+  end
+
+  context "when an IO error occurs" do
+
+    before do
+      allow_any_instance_of(IO).to receive(:write) do
+        fail IOError
+      end
+    end
+
+    describe "#write" do
+
+      before do
+        expect do
+          subject[key].write(content)
+        end.to raise_error(IOError)
+      end
+
+      it "doesn't write anything" do
+        expect(subject[key]).not_to exist
+      end
+
+    end
+
+  end
+
+  def mode_string_of(path)
+    format("0%o", path.stat.mode & 0777)
+  end
+
+  context "with a umask of 0027" do
+
+    subject do
+      described_class.new(@tmpdir, :umask => 0027)
+    end
+
+    it "has the specified umask" do
+      expect(subject.umask).to eq(0027)
+    end
+
+    describe "#write" do
+
+      before do
+        subject[key].write(content)
+      end
+
+      it "creates files with mode 0640" do
+        expect(mode_string_of(expected_file_path)).to eq("0640")
+      end
+
+      it "creates directories with mode 0750" do
+        expect(mode_string_of(expected_file_path.parent)).to eq("0750")
+      end
+
+    end
+
+  end
+
+  context "without an explicit umask" do
+
+    let(:system_umask) { 0024 }
+
+    around(:each) do |example|
+      original_umask = File.umask
+      begin
+        File.umask(system_umask)
+        example.run
+      ensure
+        File.umask(original_umask)
+      end
+    end
+
+    it "uses the system default umask" do
+      expect(subject.umask).to eq(system_umask)
+    end
+
+  end
+
+end