ceph-ruby-livelink 1.5.1

data/lib/ceph-ruby/lib/rbd.rb

@@ -0,0 +1,65 @@
+require 'ffi'
+
+# see https://github.com/ceph/ceph/blob/v0.48.2argonaut/src/pybind/rbd.py
+
+module CephRuby
+  module Lib
+    # Ruby librbd bindings
+    module Rbd
+      extend FFI::Library
+
+      ffi_lib ['rbd', 'librbd.so.1']
+
+      attach_function 'rbd_version', [:pointer, :pointer, :pointer], :void
+
+      attach_function 'rbd_create2', [:pointer, :string, :size_t, :uint64,
+                                      :pointer], :int
+
+      attach_function 'rbd_remove', [:pointer, :string], :int
+
+      attach_function 'rbd_open', [:pointer, :string, :pointer, :string], :int
+
+      attach_function 'rbd_close', [:pointer], :void
+
+      attach_function 'rbd_write', [:pointer, :off_t, :size_t, :buffer_in], :int
+
+      attach_function 'rbd_read', [:pointer, :off_t, :size_t, :buffer_out], :int
+
+      attach_function 'rbd_stat', [:pointer, :pointer, :size_t], :int
+
+      attach_function 'rbd_resize', [:pointer, :size_t], :int
+
+      attach_function 'rbd_copy', [:pointer, :pointer, :string], :int
+
+      attach_function 'rbd_copy_with_progress', [:pointer, :pointer, :string,
+                                                 :pointer, :pointer], :int
+
+      # Datatype to store rbd status information
+      class StatStruct < FFI::Struct #:nodoc:
+        layout :size, :uint64,
+               :obj_size, :uint64,
+               :num_objs, :uint64,
+               :order, :int,
+               :block_name_prefix, [:char, 24],
+               :parent_pool, :int, # deprecated
+               :parent_name, [:char, 96] # deprecated
+      end
+
+      def self.version
+        major = FFI::MemoryPointer.new(:int)
+        minor = FFI::MemoryPointer.new(:int)
+        extra = FFI::MemoryPointer.new(:int)
+        rbd_version(major, minor, extra)
+        {
+          major: major.get_int(0),
+          minor: minor.get_int(0),
+          extra: extra.get_int(0)
+        }
+      end
+
+      def self.version_string
+        "#{version[:major]}.#{version[:minor]}.#{version[:extra]}"
+      end
+    end
+  end
+end

data/lib/ceph-ruby/pool.rb

@@ -0,0 +1,117 @@
+module CephRuby
+  # Represents a Ceph pool
+  # = usage
+  # pool = cluster.pool('name')
+  class Pool
+    extend CephRuby::PoolHelper
+    include CephRuby::PoolHelper
+    include ::Comparable
+    attr_accessor :cluster, :name, :handle
+
+    def initialize(cluster, name)
+      self.cluster = cluster
+      self.name = name
+      begin
+        yield(self)
+      ensure
+        close
+      end if block_given?
+    end
+
+    def exists?
+      log('exists?')
+      ret = Lib::Rados.rados_pool_lookup(cluster.handle, name)
+      return true if ret >= 0
+      return false if ret == -Errno::ENOENT::Errno
+      raise SystemCallError.new("lookup of '#{name}' failed", -ret) if ret < 0
+    end
+
+    alias exist? exists?
+
+    def id
+      ensure_open
+      Lib::Rados.rados_ioctx_get_id(handle)
+    end
+
+    def auid=(dst_auid)
+      log("auid=#{dst_auid}")
+      ensure_open
+      ret = Lib::Rados.rados_ioctx_pool_set_auid(handle, dst_auid)
+      raise SystemCallError.new('set of auid for'\
+                                 " '#{name}' failed", -ret) if ret < 0
+    end
+
+    def auid
+      log('auid')
+      ensure_open
+      auid_p = FFI::MemoryPointer.new(:uint64)
+      ret = Lib::Rados.rados_ioctx_pool_get_auid(handle, auid_p)
+      raise SystemCallError.new('get of auid for'\
+                                " '#{name}' failed", -ret) if ret < 0
+      auid_p.get_uint64(0)
+    end
+
+    def open
+      return if open?
+      log('open')
+      handle_p = FFI::MemoryPointer.new(:pointer)
+      ret = Lib::Rados.rados_ioctx_create(cluster.handle, name, handle_p)
+      raise SystemCallError.new('creation of io context for'\
+                                " '#{name}' failed", -ret) if ret < 0
+      self.handle = handle_p.get_pointer(0)
+    end
+
+    def close
+      return unless open?
+      log('close')
+      Lib::Rados.rados_ioctx_destroy(handle)
+      self.handle = nil
+    end
+
+    def rados_object(name, &block)
+      ensure_open
+      RadosObject.new(self, name, &block)
+    end
+
+    def rados_object_enumerator(&block)
+      ensure_open
+      RadosObjectEnumerator.new(self, &block)
+    end
+
+    def rados_block_device(name, &block)
+      ensure_open
+      RadosBlockDevice.new(self, name, &block)
+    end
+
+    def create(auid: nil, rule_id: nil)
+      log("create auid: #{auid}, rule: #{rule_id}")
+      rule_id ||= 0
+      return create_with_all(auid, rule_id) if auid
+      create_with_rule(rule_id)
+      close
+    end
+
+    def destroy
+      ret = Lib::Rados.rados_pool_delete(cluster.handle, name)
+      raise SystemCallError.new('delete pool failed',
+                                -ret) if ret < 0
+    end
+
+    def stat
+      log('stat')
+      stat_s = Lib::Rados::PoolStatStruct.new
+      ensure_open
+      ret = Lib::Rados.rados_ioctx_pool_stat(handle, stat_s)
+      raise SystemCallError.new('stat failed',
+                                -ret) if ret < 0
+      stat_s.to_hash
+    end
+
+    def flush_aio
+      ensure_open
+      ret = Lib::Rados.rados_aio_flush(handle)
+      raise SystemCallError.new('aio flush faield',
+                                -ret) if ret < 0
+    end
+  end
+end

data/lib/ceph-ruby/pool_enumerator.rb

@@ -0,0 +1,32 @@
+module CephRuby
+  # Enumerator of Ceph pools
+  class PoolEnumerator
+    include Enumerable
+    attr_accessor :cluster, :members
+    def initialize(cluster)
+      self.cluster = cluster
+      yield self if block_given?
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      pools.each do |pool|
+        yield Pool.new(cluster, pool)
+      end
+    end
+
+    def size
+      pools.size
+    end
+
+    private
+
+    def pools(size = 512)
+      data_p = FFI::MemoryPointer.new(:char, size)
+      ret = Lib::Rados.rados_pool_list(cluster.handle, data_p, size)
+      return pools(ret) if ret > size
+      data_p.get_bytes(0, ret).split("\0")
+    end
+  end
+end

data/lib/ceph-ruby/pool_helper.rb

@@ -0,0 +1,46 @@
+module CephRuby
+  # Pool Helper MEthods
+  module PoolHelper
+    def by_id(cluster, id, &block)
+      Pool.new(cluster, cluster.pool_name_by_id(id), &block)
+    end
+
+    def create_with_all(auid, rule_id)
+      ret = Lib::Rados.rados_pool_create_with_all(cluster.handle, name,
+                                                  auid, rule_id)
+      raise SystemCallError.new("create pool with auid: #{auid}, "\
+                                "rule_id: #{rule_id} failed", -ret) if ret < 0
+    end
+
+    def create_with_rule(rule_id)
+      ret = Lib::Rados.rados_pool_create_with_crush_rule(cluster.handle, name,
+                                                         rule_id)
+      raise SystemCallError.new("create pool with rule_id: #{rule_id}"\
+                                ' failed', -ret) if ret < 0
+    end
+
+    def open?
+      !handle.nil?
+    end
+
+    def ensure_open
+      return if open?
+      open
+    end
+
+    def log(message)
+      CephRuby.log("pool #{name} #{message}")
+    end
+
+    def <=>(other)
+      cluster_check = other.cluster <=> cluster
+      return cluster_check unless cluster_check == 0
+      other.name <=> name
+    end
+
+    def eql?(other)
+      return false unless other.class == self.class
+      self == other
+    end
+  end
+end

data/lib/ceph-ruby/rados_aio_completion.rb

@@ -0,0 +1,42 @@
+module CephRuby
+  # A Completion for callbacks for asynchronous IO
+  class RadosCompletion
+    attr_accessor :completion_t
+
+    def initialize(args: nil, complete_callback: nil, safe_callback: nil)
+      self.completion_t = Lib::Rados.rados_completion(args,
+                                                      complete_callback,
+                                                      safe_callback)
+    end
+
+    def wait_for_complete
+    end
+
+    def wait_for_safe
+    end
+
+    def complete?
+    end
+
+    def safe?
+    end
+
+    def wait_for_complete_and_cb
+    end
+
+    def wait_for_safe_and_cb
+    end
+
+    def complete_and_cb?
+    end
+
+    def safe_and_cb?
+    end
+
+    def return_value
+    end
+
+    def destroy
+    end
+  end
+end

data/lib/ceph-ruby/rados_aio_object.rb

@@ -0,0 +1,37 @@
+module CephRuby
+  # Asynchronous object operations on Rados Object
+  class RadosAIOObject < RadosObject
+    attr_accessor :completions
+
+    def initialize(pool, name)
+      super(pool, name)
+      self.completions = []
+    end
+
+    def read(completion, _offset, _size)
+      completions << completion
+    end
+
+    def write(completion, _offset, data)
+      completions << completion
+      size = data.size
+      p size
+    end
+
+    def destroy(completion)
+      completions << completion
+    end
+
+    def append(completion, _data)
+      completions << completion
+    end
+
+    def stat(completion)
+      completions << completion
+    end
+
+    def cancel(completion)
+      completions << completion
+    end
+  end
+end

data/lib/ceph-ruby/rados_block_device.rb

@@ -0,0 +1,118 @@
+module CephRuby
+  # Rados Block Device
+  class RadosBlockDevice
+    extend CephRuby::RadosBlockDeviceHelper
+    attr_accessor :pool, :name, :handle
+
+    delegate :cluster, to: :pool
+
+    def initialize(pool, name)
+      self.pool = pool
+      self.name = name
+      if block_given?
+        begin
+          yield(self)
+        ensure
+          close
+        end
+      end
+    end
+
+    def exists?
+      log('exists?')
+      RadosBlockDevice.close_handle(open_handle)
+    rescue SystemCallError => e
+      return false if e.errno == -Errno::ENOENT::Errno
+      raise
+    end
+
+    def create(size, features = 0, order = 26)
+      log("create size #{size}, features #{features}, order #{order}")
+      order_p = FFI::MemoryPointer.new(:int)
+      order_p.put_int(0, order)
+      ret = Lib::Rbd.rbd_create2(pool.handle, name, size, features, order_p)
+      raise SystemCallError.new("creation of '#{name}' failed", -ret) if ret < 0
+    end
+
+    def open
+      return if open?
+      log('open')
+      self.handle = open_handle
+    end
+
+    def open_handle
+      handle_p = FFI::MemoryPointer.new(:pointer)
+      ret = Lib::Rbd.rbd_open(pool.handle, name, handle_p, nil)
+      raise SystemCallError.new("open of '#{name}' failed", -ret) if ret < 0
+      handle_p.get_pointer(0)
+    end
+
+    def close
+      return unless open?
+      log('close')
+      RadosBlockDevice.close_handle(handle)
+      self.handle = nil
+    end
+
+    def destroy
+      close if open?
+      log('destroy')
+      ret = Lib::Rbd.rbd_remove(pool.handle, name)
+      raise SystemCallError.new("destroy of '#{name}' failed", -ret) if ret < 0
+    end
+
+    def write(offset, data)
+      ensure_open
+      size = data.bytesize
+      log("write offset #{offset}, size #{size}")
+      ret = Lib::Rbd.rbd_write(handle, offset, size, data)
+      raise SystemCallError.new("write of #{size} bytes to '#{name}' "\
+                                "at #{offset} failed", -ret) if ret < 0
+      raise Errno::EIO, "wrote only #{ret} of #{size} bytes to "\
+                           "'#{name}' at #{offset}" if ret < size
+    end
+
+    def read(offset, size)
+      ensure_open
+      log("read offset #{offset}, size #{size}")
+      data_p = FFI::MemoryPointer.new(:char, size)
+      ret = Lib::Rbd.rbd_read(handle, offset, size, data_p)
+      raise SystemCallError.new("read of #{size} bytes from "\
+                                "'#{name}' at #{offset} failed",
+                                -ret) if ret < 0
+      data_p.get_bytes(0, ret)
+    end
+
+    def stat
+      ensure_open
+      log('stat')
+      stat = Lib::Rbd::StatStruct.new
+      ret = Lib::Rbd.rbd_stat(handle, stat, stat.size)
+      raise SystemCallError.new("stat of '#{name}' failed", -ret) if ret < 0
+      RadosBlockDevice.parse_stat(stat)
+    end
+
+    def resize(size)
+      ensure_open
+      log("resize size #{size}")
+      ret = Lib::Rbd.rbd_resize(handle, size)
+      raise SystemCallError.new("resize of '#{name}' to #{size} failed",
+                                -ret) if ret < 0
+    end
+
+    def size
+      stat[:size]
+    end
+
+    def copy_to(dst_name, dst_pool = nil)
+      ensure_open
+      dst_pool = parse_dst(dst, pool)
+      dst_pool_name = dst_pool.name
+      log("copy_to #{dst_pool_name}/#{dst_name}")
+      ret = Lib::Rbd.rbd_copy(handle, dst_pool.handle, dst_name)
+      raise SystemCallError.new("copy of '#{name}' to "\
+                                "'#{dst_pool_name}/#{dst_name}' failed",
+                                -ret) if ret < 0
+    end
+  end
+end