fog 1.10.0 → 1.10.1

data/lib/fog/riakcs/provisioning.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'riakcs'))
+
+module Fog
+  module RiakCS
+    class Provisioning < Fog::Service
+
+      class UserAlreadyExists  < Fog::RiakCS::Provisioning::Error; end
+      class ServiceUnavailable < Fog::RiakCS::Provisioning::Error; end
+
+      requires :riakcs_access_key_id, :riakcs_secret_access_key
+      recognizes :host, :path, :port, :scheme, :persistent
+
+      request_path 'fog/riakcs/requests/provisioning'
+      request :create_user
+      request :update_user
+      request :disable_user
+      request :enable_user
+      request :list_users
+      request :get_user
+      request :regrant_secret
+
+      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[riakcs_uri]
+        end
+
+        def reset_data
+          self.class.data.delete(riakcs_uri)
+        end
+      end
+
+      class Real
+        include Utils
+
+        def initialize(options = {})
+          require 'mime/types'
+          require 'multi_json'
+
+          configure_uri_options(options)
+          @riakcs_access_key_id     = options[:riakcs_access_key_id]
+          @riakcs_secret_access_key = options[:riakcs_secret_access_key]
+          @connection_options       = options[:connection_options] || {}
+          @persistent               = options[:persistent]         || false
+
+          @raw_connection = Fog::Connection.new(riakcs_uri, @persistent, @connection_options)
+
+          @s3_connection  = Fog::Storage.new(
+            :provider              => 'AWS',
+            :aws_access_key_id     => @riakcs_access_key_id,
+            :aws_secret_access_key => @riakcs_secret_access_key,
+            :host                  => @host,
+            :port                  => @port,
+            :scheme                => @scheme
+          )
+        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::RiakCS::Provisioning.const_get(match[1]).new
+              when 'ServiceUnavailable'
+                raise Fog::RiakCS::Provisioning.const_get(match[1]).new
+              else
+                raise error
+              end
+            else
+              raise error
+            end
+          end
+          if !response.body.empty? && parse_response
+            response.body = MultiJson.decode(response.body)
+          end
+          response
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module Fog
+  module RiakCS
+    class Provisioning
+      class Real
+        def create_user(email, name, options = {})
+          payload = MultiJson.encode({ :email => email, :name => name })
+          headers = { 'Content-Type' => 'application/json' }
+
+          if(options[:anonymous])
+            request(
+              :expects => [201],
+              :method  => 'POST',
+              :path    => 'user',
+              :body    => payload,
+              :headers => headers
+            )
+          else
+            begin
+              response = @s3_connection.put_object('riak-cs', 'user', payload, headers)
+              if !response.body.empty?
+                case response.headers['Content-Type']
+                when 'application/json'
+                  response.body = MultiJson.decode(response.body)
+                end
+              end
+              response
+            rescue Excon::Errors::Conflict => e
+              raise Fog::RiakCS::Provisioning::UserAlreadyExists.new
+            rescue Excon::Errors::BadRequest => e
+              raise Fog::RiakCS::Provisioning::ServiceUnavailable.new
+            end
+          end
+        end
+      end
+
+      class Mock
+        def invalid_email?(email)
+          !email.include?('@')
+        end
+
+        def user_exists?(email)
+          data.detect do |key, value|
+            value[:email] == email
+          end
+        end
+
+        def create_user(email, name, options = {})
+          if invalid_email?(email)
+            raise Fog::RiakCS::Provisioning::ServiceUnavailable, "The email address you provided is not a valid."
+          end
+
+          if user_exists?(email)
+            raise Fog::RiakCS::Provisioning::UserAlreadyExists, "User with email #{email} already exists."
+          end
+
+          key_id       = rand(1000).to_s
+          key_secret   = rand(1000).to_s
+          data[key_id] = { :email => email, :name => name, :status => 'enabled', :key_secret => key_secret }
+
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.headers['Content-Type'] = 'application/json'
+            response.body = {
+              "email"        => data[:email],
+              "display_name" => data[:name],
+              "name"         => "user123",
+              "key_id"       => key_id,
+              "key_secret"   => key_secret,
+              "id"           => "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
+              "status"       => "enabled"
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fog
+  module RiakCS
+    class Provisioning
+      class Real
+        include Utils
+        include UserUtils
+        include MultipartUtils
+
+        def disable_user(key_id)
+          update_riakcs_user(key_id, { :status => 'disabled' })
+        end
+      end
+
+      class Mock
+        include UserUtils
+
+        def disable_user(key_id)
+          update_mock_user(key_id, { :status => 'disabled' })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fog
+  module RiakCS
+    class Provisioning
+      class Real
+        include Utils
+        include UserUtils
+        include MultipartUtils
+
+        def enable_user(key_id)
+          update_riakcs_user(key_id, { :status => 'enabled' })
+        end
+      end
+
+      class Mock
+        include UserUtils
+
+        def enable_user(key_id)
+          update_mock_user(key_id, { :status => 'enabled' })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Fog
+  module RiakCS
+    class Provisioning
+      class Real
+        include Utils
+        include MultipartUtils
+
+        def get_user(key_id)
+          response = @s3_connection.get_object('riak-cs', "user/#{key_id}", { 'Accept' => 'application/json' })
+          response.body = MultiJson.decode(response.body)
+          response
+        end
+      end
+
+      class Mock
+        def get_user(key_id)
+          if user = data[key_id]
+            Excon::Response.new.tap do |response|
+              response.status = 200
+              response.headers['Content-Type'] = 'application/json'
+              response.body = {
+                "email"        => user[:email],
+                "display_name" => user[:name],
+                "name"         => "user123",
+                "key_id"       => "XXXXXXXXXXXXXXXXXXXX",
+                "key_secret"   => user[:key_secret],
+                "id"           => "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
+                "status"       => user[:status]
+              }
+            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/riakcs/requests/provisioning/list_users.rb

@@ -0,0 +1,43 @@
+module Fog
+  module RiakCS
+    class Provisioning
+      class Real
+        include Utils
+        include MultipartUtils
+
+        def list_users(options = {})
+          response      = @s3_connection.get_object('riak-cs', 'users', { 'Accept' => 'application/json', 'query' => options })
+
+          boundary      = extract_boundary(response.headers['Content-Type'])
+          parts         = parse(response.body, boundary)
+          decoded       = parts.map { |part| MultiJson.decode(part[:body]) }
+
+          response.body = decoded.flatten
+
+          response
+        end
+      end
+
+      class Mock
+        def list_users(options = {})
+          filtered_data = options[:status] ? data.select { |key, value| value[:status] == options[:status] } : data
+
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.body   = filtered_data.map do |key, value|
+              {
+                "email"        => value[:email],
+                "display_name" => value[:name],
+                "name"         => "user123",
+                "key_id"       => key,
+                "key_secret"   => value[:key_secret],
+                "id"           => "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
+                "status"       => value[:status]
+              }
+            end.compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/riakcs/requests/provisioning/regrant_secret.rb

@@ -0,0 +1,23 @@
+module Fog
+  module RiakCS
+    class Provisioning
+      class Real
+        include Utils
+        include UserUtils
+        include MultipartUtils
+
+        def regrant_secret(key_id)
+          update_riakcs_user(key_id, { :new_key_secret => true })
+        end
+      end
+
+      class Mock
+        include UserUtils
+
+        def regrant_secret(key_id)
+          update_mock_user(key_id, { :new_key_secret => true })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fog
+  module RiakCS
+    class Provisioning
+      class Real
+        include Utils
+        include UserUtils
+        include MultipartUtils
+
+        def update_user(key_id, user)
+          update_riakcs_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/riakcs/requests/usage/get_usage.rb

@@ -0,0 +1,68 @@
+module Fog
+  module RiakCS
+    class Usage
+      module Utils
+        TYPES_TO_STRING = { :access  => 'a', :storage => 'b' }
+        DEFAULT_TYPES   = TYPES_TO_STRING.keys
+        DEFAULT_FORMAT  = :json
+
+        def sanitize_and_convert_time(time)
+          time.utc.iso8601.gsub(/[:-]/, '')
+        end
+
+        def format_and_types_to_path(format, types)
+          format_character = format.to_s.split('').first
+          type_characters  = types.map { |t| TYPES_TO_STRING[t] }.compact
+
+          [type_characters, format_character].flatten.compact.join
+        end
+
+        def request_uri(access_key_id, options)
+          format        = DEFAULT_FORMAT
+          types         = options[:types]       || DEFAULT_TYPES
+          start_time    = options[:start_time]  || Time.now.utc - 86400
+          end_time      = options[:end_time]    || Time.now.utc
+
+          [access_key_id,
+           format_and_types_to_path(format, types),
+           sanitize_and_convert_time(start_time),
+           sanitize_and_convert_time(end_time)].join('.')
+        end
+      end
+
+      class Real
+        include Utils
+
+        def get_usage(access_key_id, options = {})
+          response = @connection.get_object('riak-cs', ["usage", request_uri(access_key_id, options)].join("/"))
+
+          if !response.body.empty?
+            response.body = MultiJson.decode(response.body)
+          end
+          response
+        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 = {
+              'Access' => { 
+                'Nodes'   => [],
+                'Errors'  => [] 
+              },
+              'Storage' => { 
+                'Samples' => [],
+                'Errors'  => [] 
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/riakcs/usage.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'riakcs'))
+require 'time'
+
+module Fog
+  module RiakCS
+    class Usage < Fog::Service
+
+      requires :riakcs_access_key_id, :riakcs_secret_access_key
+      recognizes :host, :path, :port, :scheme, :persistent
+
+      request_path 'fog/riakcs/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[riakcs_uri]
+        end
+
+        def reset_data
+          self.class.data.delete(riakcs_uri)
+        end
+      end
+
+      class Real
+        include Utils
+
+        def initialize(options = {})
+          require 'mime/types'
+          require 'multi_json'
+
+          configure_uri_options(options)
+          @riakcs_access_key_id     = options[:riakcs_access_key_id]
+          @riakcs_secret_access_key = options[:riakcs_secret_access_key]
+          @connection_options       = options[:connection_options] || {}
+          @persistent               = options[:persistent]         || false
+
+          @connection = Fog::Storage.new(
+            :provider              => 'AWS',
+            :aws_access_key_id     => @riakcs_access_key_id,
+            :aws_secret_access_key => @riakcs_secret_access_key,
+            :host                  => @host,
+            :port                  => @port,
+            :scheme                => @scheme
+          )
+        end
+      end
+
+    end
+  end
+end