ceph_storage 0.1.0

data/lib/ceph_storage/storage_object/xattr_enumerator.rb

@@ -0,0 +1,29 @@
+module CephStorage
+  module StorageObject
+    # Wrapper for RadosObjectEnumerator
+    class XattrEnumerator < ::CephRuby::XattrEnumerator
+      extend CephStorage::StorageObject::RadosWrapper
+      attr_accessor :pool_factory, :object
+
+      wrap_me :open, :close, :next_xattr_object
+
+      def initialize(object)
+        self.pool_factory = object.pool_factory
+        self.object = object
+        super(object)
+      end
+
+      def each
+        return enum_for(:each) unless block_given?
+
+        super do |x|
+          yield object.xattr(x.name)
+        end
+      end
+
+      def log(message)
+        CephStorage.log("xattr_enumerator #{object.name} #{message}")
+      end
+    end
+  end
+end

data/lib/ceph_storage/version.rb

@@ -0,0 +1,3 @@
+module CephStorage
+  VERSION = '0.1.0'.freeze
+end

data/spec/ceph_storage_cluster_factory_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe CephStorage::ClusterFactory do
+  let(:cluster_factory) { CephStorage::ClusterFactory }
+  subject { cluster_factory }
+
+  it 'should respond to build' do
+    expect(subject).to respond_to :build
+  end
+
+  it 'should not respond to new' do
+    expect(subject).not_to respond_to :new
+  end
+end

data/spec/ceph_storage_cluster_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe CephStorage::Cluster do
+  let(:config) { cluster_config }
+  let(:cluster) { CephStorage::ClusterFactory.build config }
+  subject { cluster }
+
+  it 'should respond to rados_cluster' do
+    expect(subject).to respond_to :rados_cluster
+  end
+
+  it 'should respond to pool' do
+    expect(subject).to respond_to :pool
+  end
+
+  it 'should respond to open?' do
+    expect(subject).to respond_to :open?
+  end
+
+  it 'should respond to open' do
+    expect(subject).to respond_to :open
+  end
+
+  it 'should respond to shutdown' do
+    expect(subject).to respond_to :shutdown
+  end
+
+  it 'should respond to ensure open' do
+    expect(subject).to respond_to :ensure_open
+  end
+
+  it 'should be a ClusterFactory' do
+    expect(subject).to be_a CephStorage::ClusterFactory
+  end
+
+  it 'should be a ::CephRuby::Cluster' do
+    expect(subject).to be_a ::CephRuby::Cluster
+  end
+
+  describe 'calling build with the same attributes' do
+    let(:second_cluster) { CephStorage::ClusterFactory.build config }
+    it 'should be the same object as subject' do
+      expect(subject).to be(second_cluster)
+    end
+
+    let(:third_config) { config.clone }
+    before { third_config.delete(:flags) }
+    let(:third_cluster) { CephStorage::ClusterFactory.build third_config }
+
+    it 'should be the same when changing attribute to equivilent default' do
+      expect(subject).to be(third_cluster)
+    end
+  end
+
+  describe 'Calling pool' do
+    let(:pool_name) { spec_config[:pool][:name] }
+    let(:pool) { cluster.pool(pool_name) }
+    subject { pool }
+
+    it 'should be a pool factory' do
+      expect(subject).to be_a CephStorage::PoolFactory
+    end
+  end
+
+  describe 'Calling inherited functions' do
+    describe 'status' do
+      it 'should not raise exception' do
+        expect { cluster.status }.not_to raise_exception
+      end
+
+      it 'should return a hash' do
+        expect(cluster.status).to be_a Hash
+      end
+    end
+  end
+end

data/spec/ceph_storage_file_storage_object_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe CephStorage::StorageObject::FileStorageObject do
+  let(:config) { cluster_config }
+  let(:spconfig) { spec_config }
+  let(:object_name) { "/tmp/#{spconfig[:pool][:object_name]}" }
+  let(:storage_object) do
+    CephStorage::StorageObject::FileStorageObject.new(object_name, 'w+')
+  end
+  subject { storage_object }
+
+  it 'should be a FileStorageObject' do
+    expect(subject).to be_a ::CephStorage::StorageObject::FileStorageObject
+  end
+
+  it 'should be a ::File' do
+    expect(subject).to be_a ::File
+  end
+
+  it 'should be a StorageObject' do
+    expect(subject).to be_a ::CephStorage::StorageObject
+  end
+
+  it 'should respond to write_file' do
+    expect(subject).to respond_to :write_file
+  end
+
+  it 'should respond to read_file' do
+    expect(subject).to respond_to :read_file
+  end
+end

data/spec/ceph_storage_pool_enumerator.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe CephStorage::PoolEnumerator do
+  let(:config) { cluster_config }
+  let(:spconfig) { spec_config }
+  let(:cluster) { CephStorage::ClusterFactory.build config }
+  let(:pool_name) { spconfig[:pool][:name] }
+  let(:pool) { cluster.pool(pool_name) }
+  let(:object_name) { spconfig[:pool][:object] }
+  let(:pool_enumerator) { cluster.pools }
+  subject { pool_enumerator }
+
+  it 'should be a CephStorage::PoolEnumerator' do
+    expect(subject).to be_a ::CephStorage::PoolEnumerator
+  end
+
+  describe 'before pool creation' do
+    it 'should not have the test pool in it' do
+      expect(subject.any? { |p| p.name ==  pool_name }).to be false
+    end
+  end
+
+  describe 'after pool creation' do
+    before { pool.create }
+    after { pool.destroy }
+    it 'should have the test pool in it' do
+      expect(subject.any? { |p| p.name ==  pool_name }).to be true
+    end
+
+    it 'should return pool objects' do
+      expect(subject.first).to be_a ::CephStorage::Pool
+    end
+  end
+end

data/spec/ceph_storage_pool_factory_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe CephStorage::PoolFactory do
+  let(:pool_factory) { CephStorage::PoolFactory }
+  subject { pool_factory }
+
+  it 'should respond to create' do
+    expect(subject).to respond_to :build
+  end
+
+  it 'should not respond to new' do
+    expect(subject).not_to respond_to :new
+  end
+end

data/spec/ceph_storage_pool_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe CephStorage::Pool do
+  let(:config) { cluster_config }
+  let(:spconfig) { spec_config }
+  let(:cluster) { CephStorage::ClusterFactory.build config }
+  let(:pool_name) { spconfig[:pool][:name] }
+  let(:pool) { cluster.pool(pool_name) }
+  let(:object_name) { spconfig[:pool][:object] }
+  subject { pool }
+
+  it 'should be a PoolFactory' do
+    expect(subject).to be_a CephStorage::PoolFactory
+  end
+
+  it 'should respond to rados_pool' do
+    expect(subject).to respond_to :rados_pool
+  end
+
+  it 'should respond to rados_pool=' do
+    expect(subject).to respond_to :rados_pool=
+  end
+
+  it 'should respond to storage_object' do
+    expect(subject).to respond_to :storage_object
+  end
+
+  it 'should respond to storage_object_enumerator' do
+    expect(subject).to respond_to :storage_object_enumerator
+  end
+
+  it 'should respond to size' do
+    expect(subject).to respond_to :size
+  end
+
+  it 'should respond to num_locked' do
+    expect(subject).to respond_to :num_locked
+  end
+
+  it 'should respond to num_free' do
+    expect(subject).to respond_to :num_free
+  end
+
+  it 'should respond to close' do
+    expect(subject).to respond_to :close
+  end
+
+  let(:rados_pool) { pool.rados_pool }
+
+  describe 'rados_pool method' do
+    subject { rados_pool }
+    it 'should be a CephRuby::Pool object' do
+      expect(subject).to be_a CephRuby::Pool
+    end
+
+    it 'should not equal another object popped off the stack' do
+      expect(subject).not_to equal(pool.rados_pool)
+    end
+
+    let(:rados_pool1) { pool.rados_pool { |p| return p } }
+    let(:rados_pool2) { pool.rados_pool { |p| return p } }
+
+    it 'should push the pool back on the queue when called with a block' do
+      expect(rados_pool1).to equal(rados_pool2)
+    end
+
+    describe 'when calling close on factory' do
+      it 'should close be closeable' do
+        expect { pool.close }.not_to raise_exception
+      end
+
+      it 'should have size 0' do
+        expect(pool.size).to eq(0)
+      end
+    end
+
+    describe 'behaviour when popping then pushing' do
+      before(:each) { pool.rados_pool = pool.rados_pool }
+
+      it 'size should be 1 after popping and pushing' do
+        expect(pool.size).to eq(1)
+        expect(pool.num_free).to eq(1)
+        expect(pool.num_locked).to eq(0)
+      end
+
+      it 'size should still be 1 after doing that again' do
+        expect(pool.num_free).to eq(1)
+        expect(pool.num_locked).to eq(0)
+      end
+    end
+  end
+
+  describe 'inherited methods' do
+    describe 'create' do
+      it 'should not throw exception' do
+        expect { subject.create }.not_to raise_exception
+      end
+    end
+
+    describe 'stat' do
+      subject { pool.stat }
+      it 'should not throw exception' do
+        expect { subject }.not_to raise_exception
+      end
+
+      it 'should be a Hash' do
+        expect(subject).to be_a Hash
+      end
+    end
+
+    describe 'id' do
+      subject { pool.id }
+
+      it 'should not throw an exception' do
+        expect { subject }.not_to raise_exception
+      end
+
+      it 'should return an integer' do
+        expect(subject).to be_a Fixnum
+      end
+    end
+
+    describe 'exists?' do
+      subject { pool.exists? }
+
+      it 'should not throw an exception' do
+        expect { subject }.not_to raise_exception
+      end
+
+      it 'should return true' do
+        expect(subject).to be true
+      end
+    end
+
+    describe 'auid' do
+      subject { pool.auid }
+
+      it 'should not throw an exception' do
+        expect { subject }.not_to raise_exception
+      end
+
+      it 'should return an integer' do
+        expect(subject).to be_a Fixnum
+      end
+    end
+
+    describe 'destroy' do
+      it 'should not throw an exception' do
+        expect { subject.destroy }.not_to raise_exception
+      end
+      describe 'after destroy' do
+        it 'should not exist' do
+          expect(subject.exists?).to be false
+        end
+      end
+    end
+  end
+
+  describe 'storage_object' do
+    let(:storage_object) { pool.storage_object(object_name) }
+    subject { storage_object }
+
+    it 'should be a CephStorage::StorageObject::RadosStorageObject' do
+      expect(subject).to be_a CephStorage::StorageObject::RadosStorageObject
+    end
+  end
+end

data/spec/ceph_storage_rados_storage_object_enumerator_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'logger'
+describe CephStorage::StorageObject::RadosStorageObjectEnumerator do
+  let(:config) { cluster_config }
+  let(:spconfig) { spec_config }
+  let(:cluster) { CephStorage::ClusterFactory.build config }
+  let(:rule_id) { spconfig[:pool][:rule_id] }
+  let(:pool_name) { spconfig[:pool][:name] }
+  let(:pool) { cluster.pool(pool_name) }
+
+  describe 'pool creation' do
+    subject { pool }
+    it 'should be able to create pool' do
+      expect { subject.create(rule_id: rule_id) }.to_not raise_exception
+    end
+
+    it 'should be writable' do
+      expect { pool.stat }.not_to raise_exception
+      expect(pool.stat).to be_a Hash
+    end
+  end
+
+  let(:object_name) { spconfig[:pool][:object_name] }
+
+  describe 'RadosStorageObjectEnumerator' do
+    let(:storage_object_enumerator) { pool.storage_object_enumerator }
+    subject { storage_object_enumerator }
+
+    it 'should be a StorageObject::RadosObjectEnumerator' do
+      expect(subject).to be_a(
+        ::CephStorage::StorageObject::RadosStorageObjectEnumerator
+      )
+    end
+
+    it 'should be a CephRuby::RadosObjectEnumerator' do
+      expect(subject).to be_a ::CephRuby::RadosObjectEnumerator
+    end
+
+    describe 'before creation' do
+      it 'should not throw have any objects in it' do
+        expect(subject.inject(0) { |a, _e| a + 1 }).to be 0
+      end
+    end
+
+    describe 'after populating' do
+      before do
+        10.times do |i|
+          pool.storage_object("#{object_name}.#{i}").overwrite(
+            'some important content'
+          )
+        end
+      end
+
+      it 'should have 10 objects in it' do
+        expect(subject.inject(0) { |a, _e| a + 1 }).to be 10
+      end
+
+      it 'should return CephStorage::RadosStorageObject' do
+        expect(subject.first).to be_a(
+          CephStorage::StorageObject::RadosStorageObject
+        )
+      end
+    end
+  end
+
+  describe 'pool deletion' do
+    subject { pool }
+    it 'should be able to delete pool' do
+      expect { subject.destroy }.not_to raise_exception
+    end
+  end
+end