fog-riakcs 0.0.1

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

@@ -0,0 +1,77 @@
+module Fog
+  module RiakCS
+    class Provisioning
+      class Real
+        def create_user(email, name, options = {})
+          payload = Fog::JSON.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 = Fog::JSON.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.find 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/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/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/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 = Fog::JSON.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/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| Fog::JSON.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/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/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/usage.rb

@@ -0,0 +1,61 @@
+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/usage'
+      request :get_usage
+
+      class Mock
+        include Fog::RiakCS::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 Fog::RiakCS::Utils
+
+        def initialize(options = {})
+          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,
+            :connection_options    => @connection_options
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/riakcs/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 = Fog::JSON.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/user_utils.rb

@@ -0,0 +1,34 @@
+module Fog
+  module RiakCS
+    module UserUtils
+      def update_riakcs_user(key_id, user)
+        response = @s3_connection.put_object('riak-cs', "user/#{key_id}", Fog::JSON.encode(user), { 'Content-Type' => 'application/json' })
+        if !response.body.empty?
+          response.body = Fog::JSON.decode(response.body)
+        end
+        response
+      end
+
+      def update_mock_user(key_id, user)
+        if data[key_id]
+          if status = user[:status]
+            data[key_id][:status] = status
+          end
+
+          if user[:new_key_secret]
+            data[key_id][:key_secret] = rand(100).to_s
+          end
+
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.body   = data[key_id]
+          end
+        else
+          Excon::Response.new.tap do |response|
+            response.status = 403
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/riakcs/utils.rb

@@ -0,0 +1,16 @@
+module Fog
+  module RiakCS
+    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 riakcs_uri
+        "#{@scheme}://#{@host}:#{@port}"
+      end
+    end
+  end
+end