ceph-ruby-ffi19 1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 75ba7f7ee122ea4ec987fcc523f523d6564a2acc
+  data.tar.gz: 9ac2d1b1d3f05ae2f74b6f44ee1b7dfc8f8cea7b
+SHA512:
+  metadata.gz: 761e5fa9f0e98077ec731a9f4e369aea8c8e70349e9e273a46138cfa4d864509da773e57c4129e4f7666d57d06053d6afb2d7f9ac1601891ccbbb9afb4b6c2bb
+  data.tar.gz: 6c04f18a1b4f489c6b0f7158829b678c6b53d4a53c84a77ce69d160308db83e4edeabbd8865203acf13026626ba8014d20408665558070b548c7e001a8ee349f

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ceph-ruby.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 - 2013 Netskin GmbH
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+# Ceph::Ruby
+
+Easy management of Ceph Distributed Storage System (rbd, images, rados objects) using ruby.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ceph-ruby'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ceph-ruby
+
+
+## Usage
+
+    require "ceph-ruby"
+
+    # version information
+    puts CephRuby::Lib::Rados.version_string
+    puts CephRuby::Lib::Rbd.version_string
+
+    # connect to cluster and open a pool
+    cluster = CephRuby::Cluster.new
+    pool = cluster.pool("my-pool-xyz")
+    pool.open
+
+    # simple example for using rados objects
+    object = pool.rados_object("my-object-xyz")
+    object.write(0, "This is a Test!")
+    puts object.size
+
+    # simple example for using rbd images
+    image = pool.rados_block_device("my-image-xyz")
+    puts image.exists?
+    image.create(10.gigabytes)
+    puts image.exists?
+    puts image.size
+    image.write(0, "This is a Test!")
+    pp image.stat
+    image.close
+
+    # clean up
+    pool.close
+    cluster.shutdown
+
+
+## Known bugs
+
+* Many features provided by ceph are not implemented yet. Please contribute!
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+## Copyright
+
+Copyright (c) 2012 - 2013 [Netskin GmbH](http://www.netskin.com). Released unter the MIT license.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/ceph-ruby.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ceph-ruby/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "ceph-ruby-ffi19"
+  gem.version       = CephRuby::VERSION
+  gem.authors       = ["Netskin GmbH", "Corin Langosch"]
+  gem.email         = ["info@netskin.com", "info@corinlangosch.com"]
+  gem.description   = %q{Easy management of Ceph}
+  gem.summary       = %q{Easy management of Ceph Distributed Storage System using ruby}
+  gem.homepage      = "https://github.com/ceph/ceph-ruby"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency('ffi', '~> 1.9.10')
+  gem.add_dependency('activesupport', '>= 3.0.0')
+end

data/lib/ceph-ruby/cluster.rb

@@ -0,0 +1,55 @@
+module CephRuby
+  class Cluster
+    attr_accessor :handle
+
+    def initialize(config_path = "/etc/ceph/ceph.conf")
+      log("init lib rados #{Lib::Rados.version_string}, lib rbd #{Lib::Rbd.version_string}")
+
+      handle_p = FFI::MemoryPointer.new(:pointer)
+      ret = Lib::Rados.rados_create(handle_p, nil)
+      raise SystemCallError.new("open of cluster failed", -ret) if ret < 0
+      self.handle = handle_p.get_pointer(0)
+
+      setup_using_file(config_path)
+
+      connect
+
+      if block_given?
+        begin
+          yield(self)
+        ensure
+          close
+        end
+      end
+    end
+
+    def close
+      return unless handle
+      log("close")
+      Lib::Rados.rados_shutdown(handle)
+      self.handle = nil
+    end
+
+    def pool(name, &block)
+      Pool.new(self, name, &block)
+    end
+
+    # helper methods below
+
+    def connect
+      log("connect")
+      ret = Lib::Rados.rados_connect(handle)
+      raise SystemCallError.new("connect to cluster failed", -ret) if ret < 0
+    end
+
+    def setup_using_file(path)
+      log("setup_using_file #{path}")
+      ret = Lib::Rados.rados_conf_read_file(handle, path)
+      raise SystemCallError.new("setup of cluster from config file '#{path}' failed", -ret) if ret < 0
+    end
+
+    def log(message)
+      CephRuby.log("cluster #{message}")
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require "ffi"
+
+# see https://github.com/ceph/ceph/blob/v0.48.2argonaut/src/pybind/rados.py
+
+module CephRuby
+  module Lib
+    module Rados
+      extend FFI::Library
+
+      ffi_lib ['rados', 'librados.so.2']
+
+      attach_function 'rados_version', [:pointer, :pointer, :pointer], :void
+
+      attach_function 'rados_create', [:pointer, :string], :int
+      attach_function 'rados_connect', [:pointer], :int
+      attach_function 'rados_conf_read_file', [:pointer, :string], :int
+      attach_function 'rados_shutdown', [:pointer], :void
+
+      attach_function 'rados_pool_lookup', [:pointer, :string], :int
+
+      attach_function 'rados_ioctx_create', [:pointer, :string, :pointer], :int
+      attach_function 'rados_ioctx_destroy', [:pointer], :void
+
+      attach_function 'rados_write', [:pointer, :string, :buffer_in, :size_t, :off_t], :int
+      attach_function 'rados_read', [:pointer, :string, :buffer_out, :size_t, :off_t], :int
+      attach_function 'rados_remove', [:pointer, :string], :int
+      attach_function 'rados_trunc', [:pointer, :string, :size_t], :int
+      attach_function 'rados_stat', [:pointer, :string, :pointer, :pointer], :int
+
+      def self.version
+        major = FFI::MemoryPointer.new(:int)
+        minor= FFI::MemoryPointer.new(:int)
+        extra = FFI::MemoryPointer.new(:int)
+        rados_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/lib/rbd.rb

@@ -0,0 +1,66 @@
+require "ffi"
+
+# see https://github.com/ceph/ceph/blob/v0.48.2argonaut/src/pybind/rbd.py
+
+module CephRuby
+  module Lib
+    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_get_size', [:pointer, :pointer], :int
+      attach_function 'rbd_get_features', [:pointer, :pointer], :int
+
+      attach_function 'rbd_copy', [:pointer, :pointer, :string], :int
+      attach_function 'rbd_copy_with_progress', [:pointer, :pointer, :string, :pointer, :pointer], :int
+
+      attach_function 'rbd_snap_create', [:pointer, :string], :int
+      attach_function 'rbd_snap_remove', [:pointer, :string], :int
+      attach_function 'rbd_snap_protect', [:pointer, :string], :int
+      attach_function 'rbd_snap_unprotect', [:pointer, :string], :int
+      attach_function 'rbd_snap_set', [:pointer, :string], :int
+
+      attach_function 'rbd_clone', [:pointer, :string, :string, :pointer, :string, :uint64, :pointer], :int
+      attach_function 'rbd_flatten', [:pointer], :int
+
+      class StatStruct < FFI::Struct
+        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,66 @@
+module CephRuby
+  class Pool
+    attr_accessor :cluster, :name, :handle
+
+    def initialize(cluster, name)
+      self.cluster = cluster
+      self.name = name
+      if block_given?
+        begin
+          yield(self)
+        ensure
+          close
+        end
+      end
+    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
+
+    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_block_device(name, &block)
+      ensure_open
+      RadosBlockDevice.new(self, name, &block)
+    end
+
+    # helper methods below
+
+    def open?
+      !!handle
+    end
+
+    def ensure_open
+      return if open?
+      open
+    end
+
+    def log(message)
+      CephRuby.log("pool #{name} #{message}")
+    end
+  end
+end

data/lib/ceph-ruby/rados_block_device.rb

@@ -0,0 +1,212 @@
+module CephRuby
+  class RadosBlockDevice
+    FEATURE_LAYERING = 1
+    FEATURE_STRIPING_V2 = 2
+    FEATURE_EXCLUSIVE_LOCK = 4
+    FEATURE_OBJECT_MAP = 8
+
+    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?")
+      handle_p = FFI::MemoryPointer.new(:pointer)
+      ret = Lib::Rbd.rbd_open(pool.handle, name, handle_p, nil)
+      case ret
+      when 0
+        handle = handle_p.get_pointer(0)
+        Lib::Rbd.rbd_close(handle)
+        true
+      when -Errno::ENOENT::Errno
+        false
+      else
+        raise SystemCallError.new("open of '#{name}' failed", -ret) if ret < 0
+      end
+    end
+
+    def create(size, features = 0, order = 0)
+      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")
+      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
+      self.handle = handle_p.get_pointer(0)
+    end
+
+    def close
+      return unless open?
+      log("close")
+      Lib::Rbd.rbd_close(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.new("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
+      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 size
+      ensure_open
+      log("size")
+      size_p = FFI::MemoryPointer.new(:uint64)
+      ret = Lib::Rbd.rbd_get_size(handle, size_p)
+      raise SystemCallError.new("size of '#{name}' failed", -ret) if ret < 0
+      size_p.read_uint64
+    end
+
+    def features
+      ensure_open
+      log("features")
+      features_p = FFI::MemoryPointer.new(:uint64)
+      ret = Lib::Rbd.rbd_get_features(handle, features_p)
+      raise SystemCallError.new("features of '#{name}' failed", -ret) if ret < 0
+      features_p.read_uint64
+    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 copy_to(dst_name, dst_pool = nil)
+      ensure_open
+      case dst_pool
+      when String
+        dst_pool = cluster.pool(dst_pool)
+      when nil
+        dst_pool = pool
+      end
+      dst_pool.ensure_open
+      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
+
+    def snapshot_create(name)
+      log("snapshot_create #{name}")
+      ensure_open
+      ret = Lib::Rbd.rbd_snap_create(handle, name)
+      raise SystemCallError.new("snapshot create '#{name}' of '#{self.name}' failed", -ret) if ret < 0
+    end
+
+    def snapshot_destroy(name)
+      log("snapshot_destroy #{name}")
+      ensure_open
+      ret = Lib::Rbd.rbd_snap_remove(handle, name)
+      raise SystemCallError.new("snapshot destroy '#{name}' of '#{self.name}' failed", -ret) if ret < 0
+    end
+
+    def snapshot_protect(name)
+      log("snapshot_protect #{name}")
+      ensure_open
+      ret = Lib::Rbd.rbd_snap_protect(handle, name)
+      raise SystemCallError.new("snapshot protect '#{name}' of '#{self.name}' failed", -ret) if ret < 0
+    end
+
+    def snapshot_unprotect(name)
+      log("snapshot_unprotect #{name}")
+      ensure_open
+      ret = Lib::Rbd.rbd_snap_unprotect(handle, name)
+      raise SystemCallError.new("snapshot unprotect '#{name}' of '#{self.name}' failed", -ret) if ret < 0
+    end
+
+    def snapshot_activate(name)
+      log("snapshot_activate #{name}")
+      ensure_open
+      ret = Lib::Rbd.rbd_snap_set(handle, name)
+      raise SystemCallError.new("activate snapshot '#{name}' of '#{self.name}' failed", -ret) if ret < 0
+    end
+
+    def clone(snapshot, dst_name, dst_pool = nil, features = 0, order = 0)
+      ensure_open
+      case dst_pool
+      when String
+        dst_pool = cluster.pool(dst_pool)
+      when nil
+        dst_pool = pool
+      end
+      dst_pool.ensure_open
+      log("clone snapshot #{snapshot} to #{dst_pool.name}/#{dst_name} features #{features} order #{order}")
+      order_p = FFI::MemoryPointer.new(:int)
+      order_p.put_int(0, order)
+      ret = Lib::Rbd.rbd_clone(pool.handle, name, snapshot, dst_pool.handle, dst_name, features, order_p)
+      raise SystemCallError.new("clone of '#{name}@#{snapshot}' to '#{dst_pool.name}/#{dst_name}' failed", -ret) if ret < 0
+    end
+
+    def flatten
+      log("flatten")
+      ensure_open
+      ret = Lib::Rbd.rbd_flatten(handle)
+      raise SystemCallError.new("flatten of '#{name}' failed", -ret) if ret < 0
+    end
+
+    # helper methods below
+
+    def open?
+      !!handle
+    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,71 @@
+module CephRuby
+  class RadosObject
+    attr_accessor :pool, :name
+
+    def initialize(pool, name)
+      self.pool = pool
+      self.name = name
+      if block_given?
+        yield(self)
+      end
+    end
+
+    def exists?
+      log("exists?")
+      !!stat
+    rescue SystemCallError => e
+      return false if e.errno == Errno::ENOENT::Errno
+      raise e
+    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
+      raise Errno::EIO.new("wrote only #{ret} of #{size} bytes to '#{name}' at #{offset}") if ret < size
+    end
+
+    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 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
+      {
+        :size => size_p.get_uint64(0),
+        :mtime => Time.at(mtime_p.get_uint64(0)),
+      }
+    end
+
+    def size
+      stat[:size]
+    end
+
+    # helper methods below
+
+    def log(message)
+      CephRuby.log("rados object #{pool.name}/#{name} #{message}")
+    end
+  end
+end

data/lib/ceph-ruby/version.rb

@@ -0,0 +1,3 @@
+module CephRuby
+  VERSION = "1.2"
+end

data/lib/ceph-ruby.rb

@@ -0,0 +1,22 @@
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/module/attribute_accessors"
+
+require "ffi"
+
+require "ceph-ruby/lib/rados"
+require "ceph-ruby/lib/rbd"
+
+require "ceph-ruby/version"
+require "ceph-ruby/cluster"
+require "ceph-ruby/pool"
+require "ceph-ruby/rados_block_device"
+require "ceph-ruby/rados_object"
+
+module CephRuby
+  mattr_accessor :logger
+
+  def self.log(message)
+    return unless logger
+    logger.info("CephRuby: #{message}")
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: ceph-ruby-ffi19
+version: !ruby/object:Gem::Version
+  version: '1.2'
+platform: ruby
+authors:
+- Netskin GmbH
+- Corin Langosch
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2016-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.9.10
+  name: ffi
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.9.10
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  name: activesupport
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Easy management of Ceph
+email:
+- info@netskin.com
+- info@corinlangosch.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ceph-ruby.gemspec
+- lib/ceph-ruby.rb
+- lib/ceph-ruby/cluster.rb
+- lib/ceph-ruby/lib/rados.rb
+- lib/ceph-ruby/lib/rbd.rb
+- lib/ceph-ruby/pool.rb
+- lib/ceph-ruby/rados_block_device.rb
+- lib/ceph-ruby/rados_object.rb
+- lib/ceph-ruby/version.rb
+homepage: https://github.com/ceph/ceph-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.5
+signing_key:
+specification_version: 4
+summary: Easy management of Ceph Distributed Storage System using ruby
+test_files: []