ceph_storage 0.1.0

data/lib/ceph_storage/cluster_factory.rb

@@ -0,0 +1,24 @@
+module CephStorage
+  # Factory Class to create a Cluster reference object
+  class ClusterFactory < ::CephRuby::Cluster
+    # Defaults
+    CONFIG_DIR = '/etc/ceph'.freeze
+    CLUSTER = 'ceph'.freeze
+    USER = 'client.admin'.freeze
+    FLAGS = 0
+    class << self
+      # Create a factory method for creating Cluster Objects
+      def build(config_dir: CONFIG_DIR, cluster: CLUSTER,
+                user: USER, flags: FLAGS)
+        c = Cluster.new(cluster: cluster, config_dir: config_dir,
+                        user: user, flags: flags)
+        yield(c) if block_given?
+        c
+      end
+
+      # Make this private otherwise the self.new {} returns a different
+      # Object to self.new {CONFIG_DIR, CLUSTER, USER}
+      private :new
+    end
+  end
+end

data/lib/ceph_storage/cluster_wrapper.rb

@@ -0,0 +1,16 @@
+module CephStorage
+  # This code is here to wrap around CephRuby::Cluster
+  # Methods. It assigns the rados cluster object around
+  # the called method
+  module ClusterWrapper
+    def wrap_me(*method_names)
+      method_names.each do |m|
+        define_method(m) do |*args|
+          rados_cluster do |c|
+            c.send(m, *args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ceph_storage/pool.rb

@@ -0,0 +1,126 @@
+module CephStorage
+  # A reference to a Ceph pool
+  # This is a collection of held open pool IOctx's for a given pool
+  class Pool < PoolFactory
+    extend CephStorage::PoolWrapper
+    include Multiton
+    attr_accessor :cartridges, :cluster, :name, :close_lock, :pop_lock
+
+    wrap_me :create, :exists?, :id, :auid=, :auid,
+            :rados_block_device, :destroy, :stat, :flush_aio
+
+    def initialize(cluster, name)
+      log("init #{name}")
+      self.close_lock = Mutex.new
+      self.pop_lock = Mutex.new
+      self.cluster = cluster
+      self.name = name.to_s
+      self.cartridges = []
+    end
+
+    def rados_pool
+      close_lock.synchronize {}
+      h = pop
+      return h unless block_given?
+      begin
+        yield(h)
+      ensure
+        push(h)
+      end
+    end
+
+    def rados_pool=(pool)
+      push(pool)
+    end
+
+    def storage_object(name, &block)
+      CephStorage::StorageObject::RadosStorageObject.new(self, name, &block)
+    end
+
+    def storage_object_enumerator(&block)
+      CephStorage::StorageObject::RadosStorageObjectEnumerator.new(self, &block)
+    end
+
+    def log(message)
+      CephStorage.log("pool #{name} #{message}")
+    end
+
+    def size
+      pop_lock.synchronize do
+        cartridges.size
+      end
+    end
+
+    def num_locked
+      pop_lock.synchronize do
+        cartridges.count { |c| c[:lock].locked? == true }
+      end
+    end
+
+    def num_free
+      pop_lock.synchronize do
+        cartridges.count { |c| c[:lock].locked? == false }
+      end
+    end
+
+    def close
+      close_lock.synchronize do
+        close_group(false)
+        close_group(true)
+      end
+    end
+
+    def path
+      "ceph://#{cluster.cluster}/#{name}"
+    end
+
+    private
+
+    def close_group(inuse)
+      log("close pool objects with locked==#{inuse}")
+      cartridges.select { |c| c[:lock].locked? == inuse }.each do |c|
+        c[:pool].close
+        cartridges.delete c
+      end
+    end
+
+    def pop
+      pop_lock.synchronize do
+        cartridge = first_available_cartridge
+        log("pop #{cartridge[:pool]}, #{cartridge[:lock].locked?}")
+        cartridge[:lock].lock
+        cartridge[:pool]
+      end
+    end
+
+    def push(pool)
+      log("push #{pool}")
+      cartridge = cartridges.find { |c| c[:pool].equal?(pool) }
+      cartridge[:lock].unlock if cartridge
+    end
+
+    def first_available_cartridge
+      cartridge = cartridges.find { |c| c[:lock].locked? == false }
+      cartridge = create_cartridge if cartridge.nil?
+      cartridge
+    end
+
+    def create_cartridge
+      log('create cartridge')
+      cartridge = new_cartridge
+      cartridges << cartridge
+      cartridge
+    end
+
+    def new_cartridge
+      {
+        lock: Mutex.new,
+        pool: new_pool
+      }
+    end
+
+    def new_pool
+      cluster.rados_cluster { |c| c.pool(name) }
+    end
+  end
+end

data/lib/ceph_storage/pool_enumerator.rb

@@ -0,0 +1,24 @@
+module CephStorage
+  # Enumerator of Ceph pools
+  class PoolEnumerator
+    include Enumerable
+    attr_accessor :cluster_factory
+    def initialize(cluster_factory)
+      self.cluster_factory = cluster_factory
+      @rados_pool_enumerator = cluster_factory.rados_cluster.pools
+      yield self if block_given?
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      @rados_pool_enumerator.each do |pool|
+        yield PoolFactory.build(cluster_factory, pool.name)
+      end
+    end
+
+    def size
+      cluster.rados_cluster.pools.size
+    end
+  end
+end

data/lib/ceph_storage/pool_factory.rb

@@ -0,0 +1,15 @@
+module CephStorage
+  # Creates a Pool Object
+  # Returns only a single pool object out of the cartridges available
+  class PoolFactory < ::CephRuby::Pool
+    class << self
+      def build(cluster, name)
+        p = CephStorage::Pool.new(cluster, name)
+        yield(p) if block_given?
+        p
+      end
+      # So behaviour is consistent with the cluster factory class
+      private :new
+    end
+  end
+end

data/lib/ceph_storage/pool_wrapper.rb

@@ -0,0 +1,17 @@
+module CephStorage
+  # This code is here to wrap around CephRuby::Pool
+  # Methods. It assigns one of the pool_factory cartridges
+  # to the method being calledt
+  module PoolWrapper
+    def wrap_me(*method_names)
+      method_names.each do |m|
+        define_method(m) do |*args|
+          log("wrapping #{m}")
+          rados_pool do |p|
+            p.send(m, *args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ceph_storage/storage_object.rb

@@ -0,0 +1,48 @@
+module CephStorage
+  # core representation of a file.
+  # This is a mixin module for other storage object modules
+  module StorageObject
+    # Represent an object that can be written to or read from
+    # This is designed to be modular so that you can expand into other
+    # technologies
+
+    attr_accessor :name
+    def move(dst_object)
+      log("move to '#{dst_object.class}/#{dst_object.name}'")
+      dst_object.write_file(read_file)
+      copy_xattrs(dst_object)
+      destroy
+    end
+
+    def copy(dst_object)
+      log("copy to '#{dst_object.class}/#{dst_object.name}'")
+      dst_object.write_file(read_file)
+      copy_xattrs(dst_object)
+    end
+
+    def copy_xattrs(dst_object)
+      log('copy xattrs')
+      return unless xattr_supported?(dst_object)
+      xattr_enumerator.each do |source_xattr|
+        dst_object.xattr(source_xattr.name) do |dst_xattr|
+          dst_xattr.value = source_xattr.value
+        end
+      end
+    end
+
+    def xattr_supported?(dst_object)
+      CephStorage::StorageObject.supports_xattr?(self) &&
+        CephStorage::StorageObject.supports_xattr?(dst_object)
+    end
+
+    class << self
+      def supports_xattr?(obj)
+        obj.respond_to? :xattr_enumerator
+      end
+    end
+
+    def log(message)
+      CephStorage.log("storage object #{name} #{message}")
+    end
+  end
+end

data/lib/ceph_storage/storage_object/file_storage_object.rb

@@ -0,0 +1,28 @@
+module CephStorage
+  module StorageObject
+    # File Storage Object
+    class FileStorageObject < ::File
+      include CephStorage::StorageObject
+
+      def name
+        path
+      end
+
+      def read_file
+        buf = read
+        rewind
+        buf
+      end
+
+      def write_file(contents)
+        write(contents)
+        flush
+        rewind
+      end
+
+      def destroy
+        File.unlink(path)
+      end
+    end
+  end
+end

data/lib/ceph_storage/storage_object/rados_storage_object.rb

@@ -0,0 +1,41 @@
+module CephStorage
+  module StorageObject
+    # Ceph Storage Object
+    class RadosStorageObject < ::CephRuby::RadosObject
+      extend CephStorage::StorageObject::RadosWrapper
+      include CephStorage::StorageObject
+      attr_accessor :pool_factory
+
+      def initialize(pool_factory, name)
+        log("init #{name}")
+        self.pool_factory = pool_factory
+        super(nil, name)
+      end
+
+      wrap_me :write, :append, :read, :destroy,
+              :resize, :overwrite, :stat
+
+      def read_file
+        log('read file')
+        read_full
+      end
+
+      def write_file(contents)
+        log("write file #{contents.length}")
+        overwrite(contents)
+      end
+
+      def xattr(name, &block)
+        Xattr.new(self, name, &block)
+      end
+
+      def xattr_enumerator(&block)
+        XattrEnumerator.new(self, &block)
+      end
+
+      def path
+        "ceph://#{pool_factory.cluster.cluster}/#{pool_factory.name}/#{name}"
+      end
+    end
+  end
+end

data/lib/ceph_storage/storage_object/rados_storage_object_enumerator.rb

@@ -0,0 +1,29 @@
+module CephStorage
+  module StorageObject
+    # Wrapper for RadosObjectEnumerator
+    class RadosStorageObjectEnumerator < ::CephRuby::RadosObjectEnumerator
+      extend CephStorage::StorageObject::RadosWrapper
+      attr_accessor :pool_factory
+
+      wrap_me :open, :close, :position, :seek, :next_rados_object
+
+      def initialize(pool_factory)
+        self.pool_factory = pool_factory
+        super(nil)
+        yield self if block_given?
+      end
+
+      def each
+        return enum_for(:each) unless block_given?
+
+        super do |rados_object|
+          yield pool_factory.storage_object(rados_object.name)
+        end
+      end
+
+      def log(message)
+        CephStorage.log("RadosStorageObjectEnumerator #{message}")
+      end
+    end
+  end
+end

data/lib/ceph_storage/storage_object/rados_wrapper.rb

@@ -0,0 +1,21 @@
+module CephStorage
+  module StorageObject
+    # This code is here to wrap around CephRuby::rados_object
+    # Methods. It assigns one of the pool_factory cartridges
+    # to the RadosObject
+    module RadosWrapper
+      def wrap_me(*method_names)
+        method_names.each do |m|
+          define_method(m) do |*args|
+            log("#{m} wrapping with rados_pool")
+            pool_factory.rados_pool do |p|
+              p.ensure_open
+              self.pool = p
+              super(*args)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ceph_storage/storage_object/url_storage_object.rb

@@ -0,0 +1,34 @@
+require 'open-uri'
+module CephStorage
+  module StorageObject
+    # Remote URL Storage Object
+    class URLStorageObject
+      include CephStorage::StorageObject
+      attr_accessor :url
+
+      def initialize(url)
+        self.name = url
+      end
+
+      def name
+        url
+      end
+
+      def path
+        url
+      end
+
+      def read_file
+        open(url).read
+      end
+
+      def write_file(_contents)
+        raise 'Unsupported file operation'
+      end
+
+      def destroy
+        raise 'Unsupported file operation'
+      end
+    end
+  end
+end

data/lib/ceph_storage/storage_object/xattr.rb

@@ -0,0 +1,18 @@
+module CephStorage
+  module StorageObject
+    # Wrapper for RadosObjectEnumerator
+    class Xattr < ::CephRuby::Xattr
+      extend CephStorage::StorageObject::RadosWrapper
+      attr_accessor :pool_factory, :object
+
+      wrap_me :read, :write, :destroy
+
+      def initialize(object, name)
+        self.pool_factory = object.pool_factory
+        self.object = object
+        self.name = name
+        super(object, name)
+      end
+    end
+  end
+end