ceph_storage 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f11517603a21b107977fee01ece18f2974dc0d98
+  data.tar.gz: 033f874f008ff2e9e30f658bb68a8ed195877dd4
+SHA512:
+  metadata.gz: 79aa89777a93a9fa26d30e2db0886b6aa70ba0ab6ee008e7a3be6d0abf46597246fc56851cc3e9bda9921af26358e758eedea21237ebf26eaf754ecebe8e1506
+  data.tar.gz: dbe0c85a8d9739bc50f78ac44783341c8717ca13f7692d8fc0bfec40af556812a3c2bb1b2ba61ccdb26c2c07e46049d78e3574a543758a5879e07900dc1654c5

data/.cluster.yml.example

@@ -0,0 +1,19 @@
+---
+:cluster: ceph
+:config_dir: "/etc/ceph"
+:user: client.admin
+:flags: 0
+:readable: true # User has +r mon cap
+:writable: true # User has +w mon cap
+:pool:
+   :name: rspec_test
+   :create_delete: true # Means you can run create and delete on this pool {beware of dragons!}
+                        # If you accidentally set this and you have a pool with the same 'name' (see above) it will 
+                        # delete it at the end of the rspec test along with all of the data in it!
+                        # This only works if the user has +w mon cap
+   :rule_id: 2
+   :writable: true # Means this pool has read/write permissions {beware of dragons!}
+                   # If you accidentally set this to true and you have objects in your pool
+                   # that you want to keep with name = object_name, it will overwrite and then delete them!
+                   # this only works if the user has +w osd cap at least on pool[:name]
+   :object_name: rspec_test_object

data/.gitignore

@@ -0,0 +1 @@
+.cluster.yml

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,110 @@
+PATH
+  remote: .
+  specs:
+    ceph_storage (0.1.0)
+      activesupport (~> 3.0)
+      ceph-ruby-livelink (~> 1.5)
+      facets (~> 3.0)
+      ffi (~> 1.9)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.22.2)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    ast (2.2.0)
+    ceph-ruby-livelink (1.5.1)
+      activesupport (~> 3.0)
+      ffi (~> 1.9)
+    coderay (1.1.1)
+    diff-lcs (1.2.5)
+    facets (3.1.0)
+    ffi (1.9.10)
+    formatador (0.2.5)
+    guard (2.14.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-bundler (2.1.0)
+      bundler (~> 1.0)
+      guard (~> 2.2)
+      guard-compat (~> 1.1)
+    guard-compat (1.2.1)
+    guard-rake (1.0.0)
+      guard
+      rake
+    guard-rspec (4.7.0)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    i18n (0.7.0)
+    listen (3.0.6)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9.7)
+    lumberjack (1.0.10)
+    method_source (0.8.2)
+    multi_json (1.12.1)
+    nenv (0.3.0)
+    notiffany (0.1.0)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    parser (2.3.1.0)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rainbow (2.1.0)
+    rake (11.1.2)
+    rb-fsevent (0.9.7)
+    rb-inotify (0.9.7)
+      ffi (>= 0.5.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    rubocop (0.40.0)
+      parser (>= 2.3.1.0, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    shellany (0.0.1)
+    slop (3.6.0)
+    thor (0.19.1)
+    unicode-display_width (1.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  ceph_storage!
+  guard (~> 2.13)
+  guard-bundler (~> 2.1)
+  guard-rake (~> 1.0)
+  guard-rspec (~> 4.6)
+  listen (= 3.0.6)
+  rake (~> 11.1)
+  rspec (~> 3.4)
+  rubocop (~> 0.39)
+
+BUNDLED WITH
+   1.11.2

data/Guardfile

@@ -0,0 +1,20 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard 'rake', task: 'test' do
+  watch(%r{^(spec|lib/.*)/.*.rb})
+end

data/README.md

@@ -0,0 +1,108 @@
+# Ceph::Storage
+
+A userspace wrapper around the [http://github.com/ceph/ceph-ruby/](Ceph::Ruby) library to allow applications to pool their requests to the ceph backend and conduct thread safe operations with ceph
+
+## Installation
+Add this line to your appication's Gemfile
+    gem 'ceph_storage'
+
+And then execute:
+    $ bundle
+
+Or install it yourself as:
+    $gem install ceph_storage
+
+
+## About
+The Ceph-ruby gem provides an FFI wrapper around librados in order to facilitate connections to ceph and to provide an easy management of objects and cluster settings.
+There are some limitations of this model in that when using it to download large amounts of files in many scenarios there can be significant overhead of connecting to 
+the cluster.
+
+This library uses the Facets::Multiton model in order to ensure that if you pass the same attributes into cluster and pool objects, you will always get the same objects
+back.
+
+## Pool collection
+In order to provide thread safety, the Pool object carries with it a collection of `::CephRuby::Pool` objects. As such operations on this will reuse an unused connection or spawn a new pool
+connection if no free one exists. On completion (or push) the pool object will continue to stay open to serve further objects.
+
+## Usage
+
+    require 'ceph_storage'
+    config = { cluster: 'ceph', user: 'client.admin', flags: 0, config_dir: '/etc/ceph' } # defaults
+
+    cluster1 = CephStorage::ClusterFactory.build(config)
+
+    cluster2 = CephStorage::ClusterFactory.build(config)
+
+    cluster1.equal? cluster2 # => true
+
+    pool1 = cluster1.pool('foo') 
+    
+    pool2 = cluster2.pool('foo')
+
+    pool1.equal? pool2 # => true
+
+
+    pool1.storage_object('bar') do |file|
+      puts file.read_file
+    end
+
+### Using blocks
+    # Will connect to ceph, open a pool, download the contents 
+    # of a file
+    CephStorage::ClusterFactory.build(config) do |c|
+      c.pool('foo') do |p|
+        # NB Storage_object as opposed to rados_object
+        p.storage_object('bar') |f|
+          puts f.read_file
+        end
+      end
+    end
+
+    # Does the same thing, but should reuse the same objects
+    # Hence the only latency is downloading the file contents
+    CephStorage::ClusterFactory.build(config) do |c|
+      c.pool('foo') do |p|
+        p.storage_object('bar') |f|
+          puts f.read_file
+        end
+      end
+    end
+
+## Raw Pool object
+
+If there is some functionality that you need that isn't provided, you can expose the raw `::CephRuby::Pool` objects by calling `pool.rados_pool`. This will return an object and mark it 'in use' until you push it back into the collection via `rados_object=` Be sure to do this lest your memory leak.
+
+### Storage Object interfaces
+
+The `StorageObject` interface provides some additional functionality to ceph on top of the CephRuby bindings
+
+*  `CephStorage::StorageObject::FileStorageObject` (wrapper for ::File)
+*  `CephStorage::StorageObject::URLStorageObject`  (wrapper for url-open)
+
+These classes are designed to allow you to copy and move files from ceph to other storage mechanisms. It is designed to be extensible
+
+    f_storage_obj1 = CephStorage::StorageObject::FileStorageObject.new 'path/to/file1'
+    f_storage_obj2 = CephStorage::StorageObject::URLStorageObject.new 'http://example.com'
+
+    CephStorage::ClusterFactory.build(config) do |c|
+      c.pool('foo') do |p|
+        p.storage_object('bar') |f|
+          f.move f_storage_obj1
+        end
+      end
+    end
+
+    CephStorage::ClusterFactory.build(config) do |c|
+      c.pool('foo') do |p|
+        p.storage_object('baz') |f|
+          f_storage_obj1.copy f
+        end
+      end
+    end
+
+
+In order for this to work, you class should extend CephStorage::StorageObject and implement `read_file` and `write_file` methods.
+URLStorageObject will raise exception for `write_file` as not implemented (hence move will not work).
+
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+
+Dir.glob('tasks/**/*.rake').each(&method(:import))
+
+task test: [:rubocop_test, :spec]
+
+task dev_test: [:rubocop_dev, :spec]

data/ceph_storage.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ceph_storage/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'ceph_storage'
+  gem.version       = CephStorage::VERSION
+  gem.authors       = ['Livelink Technology LTD', 'Stuart Harland']
+  gem.email         = ['infraops@livelinktechnology.net']
+  gem.description   = 'Easy access of Objects in ceph'
+  gem.summary       = 'Ceph-ruby provides an API, however this gem provides '\
+                      'consistent connection to ceph pools and clusters '\
+                      'using multiton objects'
+  gem.homepage      = 'https://github.com/livelink/ceph_storage'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($RS)
+  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')
+  gem.add_dependency('ceph-ruby-livelink', '~> 1.5')
+  gem.add_dependency('activesupport', '~> 3.0')
+  gem.add_dependency('facets', '~> 3.0')
+  gem.add_development_dependency 'guard', '~> 2.13'
+  gem.add_development_dependency 'listen', '= 3.0.6'
+  gem.add_development_dependency 'guard-rake', '~> 1.0'
+  gem.add_development_dependency 'guard-rspec', '~> 4.6'
+  gem.add_development_dependency 'guard-bundler', '~> 2.1'
+  gem.add_development_dependency 'rubocop', '~> 0.39'
+  gem.add_development_dependency 'rspec', '~> 3.4'
+  gem.add_development_dependency 'rake', '~> 11.1'
+  gem.add_development_dependency 'bundler', '~> 1.3'
+end

data/lib/ceph_storage.rb

@@ -0,0 +1,28 @@
+require 'thread'
+require 'ceph-ruby'
+require 'facets/multiton'
+require 'ceph_storage/cluster_wrapper'
+require 'ceph_storage/cluster_factory'
+require 'ceph_storage/cluster'
+require 'ceph_storage/pool_wrapper'
+require 'ceph_storage/pool_factory'
+require 'ceph_storage/pool'
+require 'ceph_storage/pool_enumerator'
+require 'ceph_storage/storage_object'
+require 'ceph_storage/storage_object/rados_wrapper'
+require 'ceph_storage/storage_object/rados_storage_object'
+require 'ceph_storage/storage_object/rados_storage_object_enumerator'
+require 'ceph_storage/storage_object/file_storage_object'
+require 'ceph_storage/storage_object/url_storage_object'
+require 'ceph_storage/storage_object/xattr'
+require 'ceph_storage/storage_object/xattr_enumerator'
+
+# An application for moving files into and out of Ceph
+module CephStorage
+  mattr_accessor :logger
+
+  def self.log(message)
+    return unless logger
+    logger.info("CephStorage: #{message}")
+  end
+end

data/lib/ceph_storage/cluster.rb

@@ -0,0 +1,93 @@
+module CephStorage
+  # Create a cluster object
+  # Returns only a single cluster object for given settings
+  class Cluster < ClusterFactory
+    extend CephStorage::ClusterWrapper
+    include Multiton
+    # Configure default values for this object
+    attr_reader :cluster_fd, :cluster, :config_dir, :user, :flags
+
+    wrap_me :pool_id_by_name, :pool_name_by_id, :status, :fsid
+
+    private :connect, :setup_using_file
+
+    # Create a new object
+    def initialize(config_dir: CONFIG_DIR, cluster: CLUSTER,
+                   user: USER, flags: FLAGS)
+      CephRuby.logger = CephStorage.logger
+      init(config_dir, cluster, user, flags)
+      log("init config_dir #{config_dir}, cluster #{cluster}, user: #{user}")
+
+      open
+
+      yield(@cluster_fd) if block_given?
+    rescue StandardError
+      log("unable to open cluster #{cluster}")
+      raise
+    end
+
+    def rados_cluster
+      return @cluster_fd unless block_given?
+      yield(@cluster_fd)
+    end
+
+    def pool(name)
+      ensure_open
+      p = CephStorage::PoolFactory.build(self, name)
+      yield(p) if block_given?
+      p
+    end
+
+    def pools
+      CephStorage::PoolEnumerator.new(self)
+    end
+
+    def shutdown
+      return unless open?
+      log('shutdown')
+      @cluster_fd.shutdown
+    end
+
+    def open?
+      !@cluster_fd.nil? && !@cluster_fd.handle.nil?
+    end
+
+    def ensure_open
+      return if open?
+      open
+    end
+
+    def open
+      return if open?
+      log('open')
+      fd_init unless @cluster_fd
+      @cluster_fd.connect unless open?
+    end
+
+    def path
+      "ceph://#{cluster}"
+    end
+
+    private
+
+    def log(message)
+      CephStorage.log("cluster #{cluster} #{message}")
+    end
+
+    def fd_init
+      @cluster_fd = ::CephRuby::Cluster.new(
+        config_path: config_dir,
+        cluster: cluster,
+        user: user,
+        flags: flags
+      )
+    end
+
+    def init(config_dir, cluster, user, flags)
+      @cluster = cluster
+      @user = user
+      @config_dir = config_dir
+      @flags = flags
+    end
+  end
+end