fog-radosgw 0.0.1

data/.gitignore

@@ -0,0 +1,23 @@
+*~
+*.gem
+*.rbc
+.rbenv
+.rvmrc
+.ruby-gemset
+.ruby-version
+.bundle
+.DS_Store
+.idea
+.yardoc
+/tests/.fog
+bin/*
+!bin/fog
+.fog
+coverage
+doc/*
+docs/_site/*
+Gemfile.lock
+gemfiles/*.lock
+yardoc
+pkg
+tags

data/CONTRIBUTORS.md

@@ -0,0 +1,3 @@
+* Jon Kåre Hellan <hellan@acm.org> - port of Riak CS provider to Radosgw
+* Christopher Meiklejohn <christopher.meiklejohn@gmail.com> - Riak CS provider
+and the [contributors to Fog](https://github.com/fog/fog/blob/master/CONTRIBUTORS.md)

data/Gemfile

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

data/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2009-2014 [CONTRIBUTORS.md](https://github.com/fog/fog-radosgw/blob/master/CONTRIBUTORS.md)
+
+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,65 @@
+# Fog::Radosgw
+
+[![Gem Version](https://badge.fury.io/rb/fog-radosgw.svg)](http://badge.fury.io/rb/fog-radosgw) [![Build Status](https://travis-ci.org/fog/fog-radosgw.svg?branch=master)](https://travis-ci.org/fog/fog-radosgw) [![Dependency Status](https://gemnasium.com/fog/fog-radosgw.svg)](https://gemnasium.com/fog/fog-radosgw) [![Coverage Status](https://img.shields.io/coveralls/fog/fog-radosgw.svg)](https://coveralls.io/r/fog/fog-radosgw) [![Code Climate](https://codeclimate.com/github/fog/fog-radosgw.png)](https://codeclimate.com/github/fog/fog-radosgw) [![Stories in Ready](https://badge.waffle.io/fog/fog-radosgw.png?label=ready&title=Ready)](https://waffle.io/fog/fog-radosgw)
+
+Fog backend for provisioning Ceph Radosgw - the Swift and S3 compatible REST API for Ceph.
+Currently, the gem only supports the S3 API, not Swift.
+
+Based on the Riak CS backend.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'fog-radosgw'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fog-radosgw
+
+## Usage
+
+Example:
+
+    require 'fog/radosgw'
+
+    provision_client =  Fog::Radosgw::Provisioning.new(
+        host:    'objects.example.com',
+        radosgw_access_key_id:     'CHIA1GEE0EIJ9OHSAIK6',
+        radosgw_secret_access_key: 'IFooJ7airaebaele6baihaiw2fequuto9Foh7Sei'
+    )
+
+    response = provision_client.create_user('fog', 'Fog User', 'fog@example.com')
+    userkey    = response.body['keys'][0]['access_key']
+    usersecret = response.body['keys'][0]['secret_key']
+
+## Tests
+
+Mock tests:
+
+    bundle exec rake mock[radosgw]
+
+Live tests:
+
+    bundle exec rake live[radosgw]
+
+To run live tests, you have to place credentials in `tests/.fog`, e.g.:
+
+    default:
+        host:    objects.example.com
+        radosgw_access_key_id:     CHIA1GEE0EIJ9OHSAIK6
+        radosgw_secret_access_key: IFooJ7airaebaele6baihaiw2fequuto9Foh7Sei
+
+## Contributing
+
+Please refer to the
+[CONTRIBUTING.md](https://github.com/fog/fog/blob/master/CONTRIBUTING.md)
+page for the main Fog project.
+
+## License
+
+Please refer to [LICENSE.md](https://github.com/fog/fog-radosgw/blob/master/LICENSE.md).

data/Rakefile

@@ -0,0 +1,82 @@
+require 'bundler/setup'
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'date'
+require 'rubygems'
+require 'rubygems/package_task'
+require 'yard'
+require 'fog/core'
+require 'fog/json'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  Fog::Radosgw::VERSION
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+GEM_NAME = "#{name}"
+task :default => :test
+task :travis  => ['test', 'test:travis']
+
+Rake::TestTask.new do |t|
+  t.pattern = File.join("spec", "**", "*_spec.rb")
+end
+
+namespace :test do
+  mock = ENV['FOG_MOCK'] || 'true'
+  task :travis do
+      sh("export FOG_MOCK=#{mock} && bundle exec shindont")
+  end
+end
+
+desc 'Run mocked tests for a specific provider'
+task :mock, :provider do |t, args|
+  if args.to_a.size != 1
+    fail 'USAGE: rake mock[<provider>]'
+  end
+  provider = args[:provider]
+  sh("export FOG_MOCK=true && bundle exec shindont tests/#{provider}")
+end
+
+desc 'Run live tests against a specific provider'
+task :live, :provider do |t, args|
+  if args.to_a.size != 1
+    fail 'USAGE: rake live[<provider>]'
+  end
+  provider = args[:provider]
+  sh("export FOG_MOCK=false PROVIDER=#{provider} && bundle exec shindont tests/#{provider}")
+end

data/fog-radosgw.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fog/radosgw/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'fog-radosgw'
+  s.version       = Fog::Radosgw::VERSION
+  s.authors       = %q(Jon Kåre Hellan)
+  s.email         = %q(hellan@acm.org)
+  s.summary       = %q{Fog backend for provisioning Ceph Radosgw.}
+  s.description   = %q{Fog backend for provisioning users on Ceph Radosgw - the Swift and S3 compatible REST API for Ceph.}
+  s.homepage      = 'https://github.com/fog/fog-radosgw'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = %w(lib)
+
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[README.md LICENSE.md]
+
+  s.add_dependency 'fog-json'
+  s.add_dependency 'fog', '>=1.21.0'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'shindo'
+end

data/lib/fog/radosgw.rb

@@ -0,0 +1,2 @@
+require 'fog/radosgw/provisioning'
+require 'fog/radosgw/usage'

data/lib/fog/radosgw/core.rb

@@ -0,0 +1,144 @@
+require 'fog'
+
+module Fog
+  module Radosgw
+    module MultipartUtils
+      require 'net/http'
+
+      class Headers
+        include Net::HTTPHeader
+
+        def initialize
+          initialize_http_header({})
+        end
+
+        # Parse a single header line into its key and value
+        # @param [String] chunk a single header line
+        def self.parse(chunk)
+          line = chunk.strip
+          # thanks Net::HTTPResponse
+          return [nil,nil] if chunk =~ /\AHTTP(?:\/(\d+\.\d+))?\s+(\d\d\d)\s*(.*)\z/in
+          m = /\A([^:]+):\s*/.match(line)
+          [m[1], m.post_match] rescue [nil, nil]
+        end
+
+        # Parses a header line and adds it to the header collection
+        # @param [String] chunk a single header line
+        def parse(chunk)
+          key, value = self.class.parse(chunk)
+          add_field(key, value) if key && value
+        end
+      end
+
+      def parse(data, boundary)
+        contents = data.match(end_boundary_regex(boundary)).pre_match rescue ""
+        contents.split(inner_boundary_regex(boundary)).reject(&:empty?).map do |part|
+          parse_multipart_section(part)
+        end.compact
+      end
+
+      def extract_boundary(header_string)
+        $1 if header_string =~ /boundary=([A-Za-z0-9\'()+_,-.\/:=?]+)/
+      end
+
+      private
+      def end_boundary_regex(boundary)
+        /\r?\n--#{Regexp.escape(boundary)}--\r?\n?/
+      end
+
+      def inner_boundary_regex(boundary)
+        /\r?\n--#{Regexp.escape(boundary)}\r?\n/
+      end
+
+      def parse_multipart_section(part)
+        headers = Headers.new
+        if md = part.match(/\r?\n\r?\n/)
+          body = md.post_match
+          md.pre_match.split(/\r?\n/).each do |line|
+            headers.parse(line)
+          end
+
+          if headers["content-type"] =~ /multipart\/mixed/
+            boundary = extract_boundary(headers.to_hash["content-type"].first)
+            parse(body, boundary)
+          else
+            {:headers => headers.to_hash, :body => body}
+          end
+        end
+      end
+    end
+
+    module UserUtils
+
+      def update_radosgw_user(user_id, user)
+        path         = "admin/user"
+        user_id      = Fog::AWS.escape(user_id)
+        params       = {
+          :method => 'POST',
+          :path => path,
+        }
+        query        = "?uid=#{user_id}&format=json&suspended=#{user[:suspended]}"
+        begin
+          response = Excon.post("#{@scheme}://#{@host}/#{path}#{query}",
+                                :headers => signed_headers(params))
+          if !response.body.empty?
+            case response.headers['Content-Type']
+            when 'application/json'
+              response.body = Fog::JSON.decode(response.body)
+            end
+          end
+          response
+        rescue Excon::Errors::NotFound => e
+          raise Fog::Radosgw::Provisioning::NoSuchUser.new
+        rescue Excon::Errors::BadRequest => e
+          raise Fog::Radosgw::Provisioning::ServiceUnavailable.new
+        end
+      end
+
+      def update_mock_user(user_id, user)
+        if data[user_id]
+          if suspended = user[:suspended]
+            data[user_id][:suspended] = suspended
+          end
+
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.body   = data[user_id]
+          end
+        else
+          Excon::Response.new.tap do |response|
+            response.status = 403
+          end
+        end
+      end
+    end
+
+    module Utils
+      def configure_uri_options(options = {})
+        @host       = options[:host]       || 'localhost'
+        @persistent = options[:persistent] || true
+        @port       = options[:port]       || 8080
+        @scheme     = options[:scheme]     || 'http'
+      end
+
+      def radosgw_uri
+        "#{@scheme}://#{@host}:#{@port}"
+      end
+
+      def signed_headers(params)
+        expires = Fog::Time.now.to_date_header
+        auth   =  @s3_connection.signature(params,expires)
+        awskey =  @radosgw_access_key_id
+        headers = {
+          'Date'          => expires,
+          'Authorization' => "AWS #{awskey}:#{auth}"
+        }
+      end
+    end
+
+    extend Fog::Provider
+
+    service(:provisioning, 'Provisioning')
+    service(:usage,        'Usage')
+  end
+end

data/lib/fog/radosgw/provisioning.rb

@@ -0,0 +1,101 @@
+require 'fog/radosgw/core'
+
+module Fog
+  module Radosgw
+    class Provisioning < Fog::Service
+
+      class UserAlreadyExists  < Fog::Radosgw::Provisioning::Error; end
+      class NoSuchUser  < Fog::Radosgw::Provisioning::Error; end
+      class ServiceUnavailable < Fog::Radosgw::Provisioning::Error; end
+
+      requires :radosgw_access_key_id, :radosgw_secret_access_key
+      recognizes :host, :path, :port, :scheme, :persistent, :path_style
+
+      request_path 'fog/radosgw/requests/provisioning'
+      request :create_user
+      request :delete_user
+      request :update_user
+      request :disable_user
+      request :enable_user
+      request :list_users
+      request :get_user
+
+      class Mock
+        include Utils
+
+        def self.data
+          @data ||= Hash.new({})
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options = {})
+          configure_uri_options(options)
+        end
+
+        def data
+          self.class.data[radosgw_uri]
+        end
+
+        def reset_data
+          self.class.data.delete(radosgw_uri)
+        end
+      end
+
+      class Real
+        include Utils
+
+        def initialize(options = {})
+          configure_uri_options(options)
+          @radosgw_access_key_id     = options[:radosgw_access_key_id]
+          @radosgw_secret_access_key = options[:radosgw_secret_access_key]
+          @connection_options       = options[:connection_options] || {}
+          @persistent               = options[:persistent]         || false
+          @path_style               = options[:path_style]         || false
+
+          @raw_connection = Fog::XML::Connection.new(radosgw_uri, @persistent, @connection_options)
+
+          @s3_connection  = Fog::Storage.new(
+            :provider              => 'AWS',
+            :aws_access_key_id     => @radosgw_access_key_id,
+            :aws_secret_access_key => @radosgw_secret_access_key,
+            :host                  => @host,
+            :port                  => @port,
+            :scheme                => @scheme,
+            :path_style            => @path_style,
+            :connection_options    => @connection_options
+          )
+        end
+
+        def request(params, parse_response = true, &block)
+          begin
+            response = @raw_connection.request(params.merge({
+              :host     => @host,
+              :path     => "#{@path}/#{params[:path]}",
+            }), &block)
+          rescue Excon::Errors::HTTPStatusError => error
+            if match = error.message.match(/<Code>(.*?)<\/Code>(?:.*<Message>(.*?)<\/Message>)?/m)
+              case match[1]
+              when 'UserAlreadyExists'
+                raise Fog::Radosgw::Provisioning.const_get(match[1]).new
+              when 'ServiceUnavailable'
+                raise Fog::Radosgw::Provisioning.const_get(match[1]).new
+              else
+                raise error
+              end
+            else
+              raise error
+            end
+          end
+          if !response.body.empty? && parse_response
+            response.body = Fog::JSON.decode(response.body)
+          end
+          response
+        end
+      end
+
+    end
+  end
+end