fog 1.27.0 → 1.28.0

data/lib/fog/aws.rb

@@ -1,23 +0,0 @@
-require 'fog/aws/service_mapper'
-require 'fog/aws/auto_scaling'
-require 'fog/aws/beanstalk'
-require 'fog/aws/cdn'
-require 'fog/aws/cloud_formation'
-require 'fog/aws/cloud_watch'
-require 'fog/aws/compute'
-require 'fog/aws/data_pipeline'
-require 'fog/aws/dns'
-require 'fog/aws/dynamodb'
-require 'fog/aws/elasticache'
-require 'fog/aws/elb'
-require 'fog/aws/emr'
-require 'fog/aws/glacier'
-require 'fog/aws/iam'
-require 'fog/aws/rds'
-require 'fog/aws/redshift'
-require 'fog/aws/ses'
-require 'fog/aws/simpledb'
-require 'fog/aws/sns'
-require 'fog/aws/sqs'
-require 'fog/aws/storage'
-require 'fog/aws/sts'

data/lib/fog/bin/riakcs.rb

@@ -1,25 +0,0 @@
-class RiakCS < Fog::Bin
-  class << self
-    def class_for(key)
-      case key
-      when :provisioning
-        Fog::RiakCS::Provisioning
-      when :usage
-        Fog::RiakCS::Usage
-      else
-        raise ArgumentError, "Unrecognized service: #{key}"
-      end
-    end
-
-    def [](service)
-      @@connections ||= Hash.new do |hash, key|
-        hash[key] = class_for(key)
-      end
-      @@connections[service]
-    end
-
-    def services
-      Fog::RiakCS.services
-    end
-  end
-end

data/lib/fog/openstack/requests/orchestration/list_stacks.rb

@@ -1,47 +0,0 @@
-module Fog
-  module Orchestration
-    class OpenStack
-      class Real
-        # List stacks.
-        #
-        # @param options [Hash]
-        #
-        # @return [Excon::Response]
-        #   * body [Hash]:
-        #     * stacks [Array] - Matching stacks
-        #       * stack [Hash]:
-        #         * id [String] -
-        #         * stack_name [String] -
-        #         * description [String]
-        #         * links [Array]
-        #         * stack_status [String] -
-        #         * stack_status_reason [String]
-        #         * creation_time [Time] -
-        #         * updated_time [Time] -
-        #
-        #
-        # @see http://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ListStacks.html
-
-        def list_stacks(options = {})
-          request(
-            :expects  => 200,
-            :path => 'stacks',
-            :method => 'GET',
-            :query => options
-          )
-        end
-      end
-
-      class Mock
-        def list_stacks(options = {})
-          stacks = self.data[:stacks].values
-
-          Excon::Response.new(
-            :body   => { 'stacks' => stacks },
-            :status => 200
-          )
-        end
-      end
-    end
-  end
-end

data/lib/fog/riakcs.rb

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

data/lib/fog/riakcs/core.rb

@@ -1,121 +0,0 @@
-require 'fog/core'
-require 'fog/json'
-
-module Fog
-  module RiakCS
-    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_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
-
-    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
-
-    extend Fog::Provider
-
-    service(:provisioning, 'Provisioning')
-    service(:usage,        'Usage')
-  end
-end

data/lib/fog/riakcs/provisioning.rb

@@ -1,98 +0,0 @@
-require 'fog/riakcs/core'
-
-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, :path_style
-
-      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 = {})
-          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
-          @path_style               = options[:path_style]         || false
-
-          @raw_connection = Fog::XML::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,
-            :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::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 = Fog::JSON.decode(response.body)
-          end
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-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/requests/provisioning/disable_user.rb

@@ -1,23 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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