fog-radosgw 0.0.1

data/lib/fog/radosgw/requests/provisioning/create_user.rb

@@ -0,0 +1,83 @@
+module Fog
+  module Radosgw
+    class Provisioning
+      class Real
+        include Utils
+
+        def create_user(user_id, display_name, email, options = {})
+          if get_user(user_id).status != 404
+            raise Fog::Radosgw::Provisioning::UserAlreadyExists, "User with user_id #{user_id} already exists."
+          end
+
+          path         = "admin/user"
+          user_id      = Fog::AWS.escape(user_id)
+          display_name = Fog::AWS.escape(display_name)
+          email        = Fog::AWS.escape(email)
+          query        = "?uid=#{user_id}&display-name=#{display_name}&email=#{email}&format=json"
+          params       = {
+            :method => 'PUT',
+            :path => path,
+          }
+
+          begin
+            response = Excon.put("#{@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::Conflict => e
+            raise Fog::Radosgw::Provisioning::UserAlreadyExists.new
+          rescue Excon::Errors::BadRequest => e
+            raise Fog::Radosgw::Provisioning::ServiceUnavailable.new
+          end
+        end
+      end
+
+      class Mock
+        def user_exists?(user_id)
+          data.find do |key, value|
+            value[:user_id] == user_id
+          end
+        end
+
+        def create_user(user_id, display_name, email, options = {})
+          if user_exists?(user_id)
+            raise Fog::Radosgw::Provisioning::UserAlreadyExists, "User with user_id #{user_id} already exists."
+          end
+
+          secret_key   = rand(1000).to_s
+          data[user_id] = {
+            :email        => email, 
+            :user_id      => user_id, 
+            :display_name => display_name,
+            :suspended    => 0, 
+            :secret_key   => secret_key,
+          }
+
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.headers['Content-Type'] = 'application/json'
+            response.body = {
+              "email"        => email,
+              "user_id"      => user_id,
+              "display_name" => display_name,
+              "suspended"    => 0,
+              "keys"         =>
+              [
+               {
+                 "access_key" => "XXXXXXXXXXXXXXXXXXXX",
+                 "secret_key" => secret_key,
+                 "user"       => user_id,
+               }
+              ],
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/radosgw/requests/provisioning/delete_user.rb

@@ -0,0 +1,57 @@
+module Fog
+  module Radosgw
+    class Provisioning
+      class Real
+        include Utils
+
+        def delete_user(user_id)
+          path         = "admin/user"
+          user_id      = Fog::AWS.escape(user_id)
+          query        = "?uid=#{user_id}&format=json"
+          params       = {
+            :method => 'DELETE',
+            :path => path,
+          }
+
+          begin
+            response = Excon.delete("#{@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
+      end
+
+      class Mock
+        def user_exists?(user_id)
+          data.find do |key, value|
+            value[:user_id] == user_id
+          end
+        end
+
+        def delete_user(user_id)
+          if !user_exists?(user_id)
+            raise Fog::Radosgw::Provisioning::NoSuchUser, "No user with user_id #{user_id} exists."
+          end
+
+          data.delete(user_id)
+
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.headers['Content-Type'] = 'application/json'
+            response.body = ""
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/radosgw/requests/provisioning/disable_user.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Radosgw
+    class Provisioning
+      class Real
+        include Utils
+        include UserUtils
+        include MultipartUtils
+
+        def disable_user(user_id)
+          update_radosgw_user(user_id, { :suspended => 1 })
+        end
+      end
+
+      class Mock
+        include UserUtils
+
+        def disable_user(user_id)
+          update_mock_user(user_id, { :suspended => 1 })
+        end
+      end
+    end
+  end
+end

data/lib/fog/radosgw/requests/provisioning/enable_user.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Radosgw
+    class Provisioning
+      class Real
+        include Utils
+        include UserUtils
+        include MultipartUtils
+
+        def enable_user(user_id)
+          update_radosgw_user(user_id, { :suspended => 0 })
+        end
+      end
+
+      class Mock
+        include UserUtils
+
+        def enable_user(user_id)
+          update_mock_user(user_id, { :suspended => 0 })
+        end
+      end
+    end
+  end
+end

data/lib/fog/radosgw/requests/provisioning/get_user.rb

@@ -0,0 +1,66 @@
+module Fog
+  module Radosgw
+    class Provisioning
+      class Real
+        include Utils
+        include MultipartUtils
+
+        def get_user(user_id)
+          path = "admin/user"
+          user_id = Fog::AWS.escape(user_id)
+          query = "?uid=#{user_id}&format=json"
+          params = { 
+            :method => 'GET',
+            :path => path,
+          }
+
+          begin
+            response = Excon.get("#{@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
+      end
+
+      class Mock
+        def get_user(user_id)
+          if value = data[user_id]
+            Excon::Response.new.tap do |response|
+              response.status = 200
+              response.headers['Content-Type'] = 'application/json'
+              response.body = {
+                "email"        => value[:email],
+                "user_id"      => value[:user_id],
+                "display_name" => value[:display_name],
+                "suspended"    => value[:suspended],
+                "keys"         =>
+                [
+                 {
+                   "access_key" => "XXXXXXXXXXXXXXXXXXXX",
+                   "secret_key" => value[:secret_key],
+                   "user"       => value[:user_id],
+                 }
+                ],
+              }
+            end
+          else
+            Excon::Response.new.tap do |response|
+              response.status = 404
+              response.headers['Content-Type'] = 'application/json'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/radosgw/requests/provisioning/list_users.rb

@@ -0,0 +1,70 @@
+module Fog
+  module Radosgw
+    class Provisioning
+      class Real
+        include Utils
+        include MultipartUtils
+
+        def list_user_ids()
+          path = "admin/metadata/user"
+          query = "?format=json"
+          params = { 
+            :method => 'GET',
+            :path => path,
+          }
+
+          begin
+            response = Excon.get("#{@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
+            else
+              response.body = []
+            end
+            response
+          rescue Excon::Errors::BadRequest => e
+            raise Fog::Radosgw::Provisioning::ServiceUnavailable.new
+          end
+        end
+
+        def list_users(options = {})
+          response = list_user_ids
+          response.body = response.body.map { |user_id| get_user(user_id).body }
+          if options[:suspended]
+            response.body = response.body.select { |user| user[:suspended] == options[:suspended] }
+          end
+          response
+        end
+      end
+
+      class Mock
+        def list_users(options = {})
+          filtered_data = options[:suspended] ? data.select { |key, value| value[:suspended] == options[:suspended] } : data
+
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.body   = filtered_data.map do |key, value|
+              {
+                "email"        => value[:email],
+                "display_name" => value[:user_id],
+                "user_id"      => value[:user_id],
+                "suspended"    => value[:suspended],
+                "keys"         =>
+                [
+                 {
+                   "access_key" => "XXXXXXXXXXXXXXXXXXXX",
+                   "secret_key" => value[:secret_key],
+                   "user"       => value[:user_id],
+                 }
+                ],
+              }
+            end.compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/radosgw/requests/provisioning/update_user.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Radosgw
+    class Provisioning
+      class Real
+        include Utils
+        include UserUtils
+        include MultipartUtils
+
+        def update_user(key_id, user)
+          update_radosgw_user(key_id, user)
+        end
+      end
+
+      class Mock
+        include UserUtils
+
+        def update_user(key_id, user)
+          update_mock_user(key_id, user)
+        end
+      end
+    end
+  end
+end

data/lib/fog/radosgw/requests/provisioning/user.json

@@ -0,0 +1,17 @@
+{
+   "keys" : [
+      {
+         "access_key" : "UPET5548S0CU9112ID33",
+         "secret_key" : "aaw1AZ7+OlEEy6FrXkGy0oP2p4BvE/Eeg0L9ucmj",
+         "user" : "Fog User"
+      }
+   ],
+   "suspended" : 0,
+   "swift_keys" : [],
+   "subusers" : [],
+   "user_id" : "Fog User",
+   "caps" : [],
+   "display_name" : "Fog User",
+   "email" : "",
+   "max_buckets" : 1000
+}

data/lib/fog/radosgw/requests/usage/get_usage.rb

@@ -0,0 +1,60 @@
+module Fog
+  module Radosgw
+    class Usage
+      module Utils
+
+        def sanitize_and_convert_time(time)
+          fmt = '%Y-%m-%d %H:%M:%S'
+          Fog::AWS.escape(time.strftime(fmt))
+        end
+
+      end
+
+      class Real
+        include Utils
+
+        def get_usage(access_key_id, options = {})
+          path = "admin/usage"
+          t_now = Fog::Time.now
+          start_time  = sanitize_and_convert_time(options[:start_time] || t_now - 86400)
+          end_time    = sanitize_and_convert_time(options[:end_time]   || t_now)
+
+          query = "?format=json&start=#{start_time}&end=#{end_time}"
+          params = { 
+            :method => 'GET',
+            :path => path,
+          }
+
+          begin
+            response = Excon.get("#{@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::BadRequest => e
+            raise Fog::Radosgw::Provisioning::ServiceUnavailable.new
+          end
+        end
+      end
+
+      class Mock
+        include Utils
+
+        def get_usage(access_key, options = {})
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.headers['Content-Type'] = 'application/json'
+            response.body = {
+              'entries' =>  [],
+              'summary'  => []
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/radosgw/usage.rb

@@ -0,0 +1,62 @@
+require 'fog/radosgw/core'
+require 'time'
+
+module Fog
+  module Radosgw
+    class Usage < Fog::Service
+      requires :radosgw_access_key_id, :radosgw_secret_access_key
+      recognizes :host, :path, :port, :scheme, :persistent
+
+      request_path 'fog/radosgw/requests/usage'
+      request :get_usage
+
+      class Mock
+        include Utils
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        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
+
+          @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,
+            :connection_options    => @connection_options
+          )
+        end
+      end
+    end
+  end
+end