ceph-ruby-livelink 1.5.1

data/lib/ceph-ruby/rados_block_device_helper.rb

@@ -0,0 +1,39 @@
+module CephRuby
+  # Rados BlockDevice helper Methods
+  module RadosBlockDeviceHelper
+    def self.parse_stat(stat)
+      Hash[[:size, :obj_size, :num_objs, :order].map { |k| [k, stat[k]] }]
+        .tap do |hash|
+        hash[:block_name_prefix] = stat[:block_name_prefix].to_ptr.read_string
+      end
+    end
+
+    def self.close_handle(handle)
+      Lib::Rbd.rbd_close(handle)
+      true
+    end
+
+    def self.parse_dst_pool(dst_pool, pool)
+      if dst_pool.is_a? String
+        dst_pool = cluster.pool(dst_pool)
+      elsif dst_pool.nil?
+        dst_pool = pool
+      end
+      dst_pool.ensure_open
+      dst_pool
+    end
+
+    def open?
+      !handle.nil?
+    end
+
+    def ensure_open
+      return if open?
+      open
+    end
+
+    def log(message)
+      CephRuby.log("rbd image #{pool.name}/#{name} #{message}")
+    end
+  end
+end

data/lib/ceph-ruby/rados_object.rb

@@ -0,0 +1,124 @@
+module CephRuby
+  # An Object in Ceph
+  class RadosObject
+    attr_accessor :pool, :name
+
+    def initialize(pool, name)
+      self.pool = pool
+      self.name = name
+      yield(self) if block_given?
+    end
+
+    def exists?
+      log('exists?')
+      !stat.nil?
+    rescue SystemCallError => e
+      return false if e.errno == Errno::ENOENT::Errno
+      raise e
+    end
+
+    def overwrite(data)
+      size = data.bytesize
+      log("overwrite size #{size}")
+      ret = Lib::Rados.rados_write_full(pool.handle, name, data, size)
+      raise SystemCallError.new("overwrite of #{size} bytes to '#{name}'"\
+                                ' failed', -ret) if ret < 0
+    end
+
+    def write(offset, data)
+      size = data.bytesize
+      log("write offset #{offset}, size #{size}")
+      ret = Lib::Rados.rados_write(pool.handle, name, data, size, offset)
+      raise SystemCallError.new("write of #{size} bytes to '#{name}'"\
+                                " at #{offset} failed", -ret) if ret < 0
+    end
+
+    def append(data)
+      size = data.bytesize
+      log("append #{size}B")
+      ret = Lib::Rados.rados_append(pool.handle, name, data, size)
+      raise SystemCallError.new("appendment of #{size} bytes to '#{name}'"\
+                                ' failed', -ret) if ret < 0
+    end
+
+    alias exist? exists?
+
+    def read(offset, size)
+      log("read offset #{offset}, size #{size}")
+      data_p = FFI::MemoryPointer.new(:char, size)
+      ret = Lib::Rados.rados_read(pool.handle, name, data_p, size, offset)
+      raise SystemCallError.new("read of #{size} bytes from '#{name}'"\
+                                " at #{offset} failed", -ret) if ret < 0
+      data_p.get_bytes(0, ret)
+    end
+
+    def read_full
+      log('read_full')
+      read 0, size
+    end
+
+    def destroy
+      log('destroy')
+      ret = Lib::Rados.rados_remove(pool.handle, name)
+      raise SystemCallError.new("destroy of '#{name}' failed", -ret) if ret < 0
+    end
+
+    def resize(size)
+      log("resize size #{size}")
+      ret = Lib::Rados.rados_trunc(pool.handle, name, size)
+      raise SystemCallError.new("resize of '#{name}'"\
+                                " to #{size} failed", -ret) if ret < 0
+    end
+
+    def stat
+      log('stat')
+      size_p = FFI::MemoryPointer.new(:uint64)
+      mtime_p = FFI::MemoryPointer.new(:uint64)
+      ret = Lib::Rados.rados_stat(pool.handle, name, size_p, mtime_p)
+      raise SystemCallError.new("stat of '#{name}' failed", -ret) if ret < 0
+      RadosObject.stat_hash(size_p, mtime_p)
+    end
+
+    class << self
+      def stat_hash(size_p, mtime_p)
+        {
+          size: size_p.get_uint64(0),
+          mtime: Time.at(mtime_p.get_uint64(0))
+        }
+      end
+    end
+
+    def size
+      stat[:size]
+    end
+
+    def mtime
+      stat[:mtime]
+    end
+
+    def xattr(name = nil)
+      Xattr.new(self, name)
+    end
+
+    def xattr_enumerator
+      ::CephRuby::XattrEnumerator.new(self)
+    end
+
+    def <=>(other)
+      pool_check = pool <=> other.pool
+      return pool_check unless pool_check == 0
+      other.name <=> name
+    end
+
+    def eql?(other)
+      return false unless other.class == self.class
+      self == other
+    end
+
+    # helper methods below
+
+    def log(message)
+      CephRuby.log("rados object #{pool.name}/#{name} #{message}")
+    end
+  end
+end

data/lib/ceph-ruby/rados_object_enumerator.rb

@@ -0,0 +1,89 @@
+module CephRuby
+  # Enumerator for Ceph Rados Objects
+  class RadosObjectEnumerator
+    include Enumerable
+
+    class << self
+       attr_accessor :limit
+    end
+
+    attr_accessor :pool
+    attr_reader :handle, :page
+
+    def initialize(pool)
+      self.pool = pool
+      @page = 0
+
+      open
+    end
+
+    def paginate(page = 0)
+      @page = page ||= 0
+      to = CephRuby::RadosObjectEnumerator.limit
+      to = 0 if to.nil?
+      seek page * to
+    end
+
+    def seek(to)
+      ret = Lib::Rados.rados_nobjects_list_seek(handle, to)
+      raise SystemCallError('unable to seek to position', -ret) if ret < 0
+      self
+    end
+
+    def position
+      Lib::Rados.rados_nobjects_list_get_pg_hash_position(handle)
+    end
+
+    def close
+      Lib::Rados.rados_nobjects_close(handle)
+      @handle = nil
+    end
+
+    def open?
+      !handle.nil?
+    end
+
+    def open
+      return if open?
+      pool.ensure_open
+      handle_p = FFI::MemoryPointer.new(:pointer)
+      ret = Lib::Rados.rados_nobjects_list_open(pool.handle, handle_p)
+      raise SystemCallError('unable to open object list', -ret) if ret < 0
+      @handle = handle_p.get_pointer(0)
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+      while within_limit
+        obj = next_rados_object
+        return if obj.nil?
+        yield obj
+      end
+    ensure
+      paginate(page)
+    end
+
+    def within_limit
+      return true if CephRuby::RadosObjectEnumerator.limit.nil?
+      position < (CephRuby::RadosObjectEnumerator.limit * (page + 1))
+    end
+
+    private
+
+    def next_rados_object
+      entry_buffer = FFI::MemoryPointer.new(:pointer, 1)
+      ret = Lib::Rados.rados_nobjects_list_next(handle, entry_buffer,
+                                                nil, nil)
+      return unless within_limit
+      return if ret == -Errno::ENOENT::Errno
+      raise SystemCallError.new('unable to fetch next object', -ret) if ret < 0
+      next_object(entry_buffer)
+    end
+
+    def next_object(entry_buffer)
+      str_ptr = entry_buffer.read_pointer
+      return if str_ptr.null?
+      RadosObject.new(pool, str_ptr.read_string)
+    end
+  end
+end

data/lib/ceph-ruby/version.rb

@@ -0,0 +1,3 @@
+module CephRuby
+  VERSION = '1.5.1'.freeze
+end

data/lib/ceph-ruby/xattr.rb

@@ -0,0 +1,67 @@
+module CephRuby
+  # Representation of a File extended Attribute
+  class Xattr
+    attr_accessor :rados_object, :name, :pool
+
+    def initialize(rados_object, name)
+      raise Errno::ENOENT, 'RadosObject is nil' unless rados_object.exists?
+      raise SystemCallError.new(
+        'xattr name cannot be nil',
+        Errno::ENOENT::Errno
+      ) if name.nil?
+      self.rados_object = rados_object
+      self.pool = rados_object.pool
+      self.name = name
+      yield(self) if block_given?
+    end
+
+    def value(size = 4096)
+      read size
+    end
+
+    def value=(value)
+      write value
+    end
+
+    def destroy
+      log('destroy')
+      ret = Lib::Rados.rados_rmxattr(pool.handle,
+                                     rados_object.name,
+                                     name)
+      raise SystemCallError.new("destruction of xattr '#{name}' failed",
+                                -ret) if ret < 0
+    end
+
+    def to_s
+      read
+    end
+
+    def log(message)
+      CephRuby.log('rados obj xattr '\
+                   "#{rados_object.name}/#{name} #{message}")
+    end
+
+    private
+
+    def read(size)
+      log("read #{size}b")
+      data_p = FFI::MemoryPointer.new(:char, size)
+      ret = Lib::Rados.rados_getxattr(pool.handle,
+                                      rados_object.name,
+                                      name, data_p, size)
+      raise SystemCallError.new("read of xattr '#{name}' failed",
+                                -ret) if ret < 0
+      data_p.get_bytes(0, ret)
+    end
+
+    def write(data)
+      size = data.bytesize
+      log("write size #{size}")
+      ret = Lib::Rados.rados_setxattr(pool.handle,
+                                      rados_object.name,
+                                      name, data, size)
+      raise SystemCallError.new("write of xattr '#{name}' failed",
+                                -ret) if ret < 0
+    end
+  end
+end

data/lib/ceph-ruby/xattr_enumerator.rb

@@ -0,0 +1,62 @@
+module CephRuby
+  # Enumerator for Ceph Rados Objects Xattr
+  class XattrEnumerator
+    include Enumerable
+
+    attr_accessor :object, :pool
+    attr_reader :handle
+
+    def initialize(object)
+      self.object = object
+      self.pool = object.pool
+      open
+    end
+
+    def close
+      Lib::Rados.rados_getxattrs_end(handle)
+      @handle = nil
+    end
+
+    def open?
+      !handle.nil?
+    end
+
+    def open
+      return if open?
+      pool.ensure_open
+      handle_p = FFI::MemoryPointer.new(:pointer)
+      ret = Lib::Rados.rados_getxattrs(pool.handle, object.name, handle_p)
+      raise SystemCallError.new('unable to open xattr list', -ret) if ret < 0
+      @handle = handle_p.get_pointer(0)
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+      open
+      loop do
+        obj = next_xattr_object
+        break if obj.nil?
+        yield obj
+      end
+      close
+    end
+
+    private
+
+    def next_xattr_object
+      key_buffer = FFI::MemoryPointer.new(:pointer, 1)
+      val_buffer = FFI::MemoryPointer.new(:pointer, 1)
+      size_t_buffer = FFI::MemoryPointer.new(:size_t)
+      ret = Lib::Rados.rados_getxattrs_next(handle, key_buffer,
+                                            val_buffer, size_t_buffer)
+      raise SystemCallError.new('unable to fetch next object', -ret) if ret < 0
+      next_xattr(key_buffer)
+    end
+
+    def next_xattr(key_buffer)
+      str_ptr = key_buffer.read_pointer
+      return if str_ptr.null?
+      Xattr.new(object, str_ptr.read_string)
+    end
+  end
+end

data/spec/ceph_ruby_cluster_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+describe CephRuby::Cluster do
+  let(:config) { cluster_config }
+  let(:cluster) { ::CephRuby::Cluster.new(config) }
+  subject { cluster }
+
+  describe 'should respond to' do
+    it 'shutdown' do
+      expect(subject).to respond_to :shutdown
+    end
+
+    it 'connect' do
+      expect(subject).to respond_to :connect
+    end
+
+    it 'setup_using_file' do
+      expect(subject).to respond_to :setup_using_file
+    end
+
+    it 'log' do
+      expect(subject).to respond_to :log
+    end
+
+    it 'pool' do
+      expect(subject).to respond_to :pool
+    end
+
+    it 'pools' do
+      expect(subject).to respond_to :pools
+    end
+
+    it 'pool_id_by_name' do
+      expect(subject).to respond_to :pool_id_by_name
+    end
+
+    it 'pool_name_by_id' do
+      expect(subject).to respond_to :pool_name_by_id
+    end
+
+    it 'status' do
+      expect(subject).to respond_to :status
+    end
+
+    it 'fsid' do
+      expect(subject).to respond_to :fsid
+    end
+  end
+
+  describe 'fsid' do
+    subject { cluster.fsid }
+    it 'should return a 36 byte string' do
+      expect(subject.length).to be 36
+    end
+  end
+
+  describe 'status' do
+    subject { cluster.status }
+    it 'should return a hash' do
+      expect(subject).to be_a Hash
+    end
+
+    it 'should have the correct keys' do
+      expect(subject.key?(:kb)).to be true
+      expect(subject.key?(:kb_used)).to be true
+      expect(subject.key?(:kb_avail)).to be true
+      expect(subject.key?(:num_objects)).to be true
+    end
+  end
+
+  # Starter pool functionality, check the cluster methods exist
+  describe 'pool functions' do
+    describe 'pool method' do
+      it 'should return a pool object' do
+        expect(subject.pool(config[:pool][:name])).to be_a ::CephRuby::Pool
+      end
+
+      describe 'when passed a block' do
+        it 'should pass a pool into the block' do
+          obj = nil
+          subject.pool(config[:pool][:name]) { |p| obj = p }
+          expect(obj).to be_a ::CephRuby::Pool
+        end
+      end
+    end
+
+    describe 'pools method' do
+      it 'should return a PoolEnumerator' do
+        expect(subject.pools).to be_a ::CephRuby::PoolEnumerator
+      end
+
+      describe 'when passed a block into each', require_cluster_read: true do
+        it 'should pass as many pools into the block as there are' do
+          subject.pools.each do |p|
+            # This won't prove anything unless there are some pools
+            expect(p).to be_a ::CephRuby::Pool
+          end
+        end
+      end
+    end
+  end
+end