fog 1.26.0 → 1.27.0

data/lib/fog/aws/auto_scaling.rb

@@ -1,279 +0,0 @@
-require 'fog/aws/core'
-
-module Fog
-  module AWS
-    class AutoScaling < Fog::Service
-      extend Fog::AWS::CredentialFetcher::ServiceMethods
-
-      class IdentifierTaken < Fog::Errors::Error; end
-      class ResourceInUse < Fog::Errors::Error; end
-      class ValidationError < Fog::Errors::Error; end
-
-      requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :host, :path, :port, :scheme, :persistent, :region, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
-
-      request_path 'fog/aws/requests/auto_scaling'
-      request :create_auto_scaling_group
-      request :create_launch_configuration
-      request :create_or_update_tags
-      request :delete_auto_scaling_group
-      request :delete_launch_configuration
-      request :delete_notification_configuration
-      request :delete_policy
-      request :delete_scheduled_action
-      request :delete_tags
-      request :describe_adjustment_types
-      request :describe_auto_scaling_groups
-      request :describe_auto_scaling_instances
-      request :describe_auto_scaling_notification_types
-      request :describe_launch_configurations
-      request :describe_metric_collection_types
-      request :describe_notification_configurations
-      request :describe_policies
-      request :describe_scaling_activities
-      request :describe_scaling_process_types
-      request :describe_scheduled_actions
-      request :describe_tags
-      request :describe_termination_policy_types
-      request :disable_metrics_collection
-      request :enable_metrics_collection
-      request :execute_policy
-      request :put_notification_configuration
-      request :put_scaling_policy
-      request :put_scheduled_update_group_action
-      request :resume_processes
-      request :set_desired_capacity
-      request :set_instance_health
-      request :suspend_processes
-      request :terminate_instance_in_auto_scaling_group
-      request :update_auto_scaling_group
-
-      model_path 'fog/aws/models/auto_scaling'
-      model      :activity
-      collection :activities
-      model      :configuration
-      collection :configurations
-      model      :group
-      collection :groups
-      model      :instance
-      collection :instances
-      model      :policy
-      collection :policies
-
-      ExpectedOptions = {}
-
-      class Real
-        include Fog::AWS::CredentialFetcher::ConnectionMethods
-
-        attr_accessor :region
-
-        # Initialize connection to AutoScaling
-        #
-        # ==== Notes
-        # options parameter must include values for :aws_access_key_id and
-        # :aws_secret_access_key in order to create a connection
-        #
-        # ==== Examples
-        #   as = AutoScaling.new(
-        #    :aws_access_key_id => your_aws_access_key_id,
-        #    :aws_secret_access_key => your_aws_secret_access_key
-        #   )
-        #
-        # ==== Parameters
-        # * options<~Hash> - config arguments for connection.  Defaults to {}.
-        #
-        # ==== Returns
-        # * AutoScaling object with connection to AWS.
-
-        def initialize(options={})
-          @use_iam_profile = options[:use_iam_profile]
-
-          @connection_options = options[:connection_options] || {}
-
-          @instrumentor           = options[:instrumentor]
-          @instrumentor_name      = options[:instrumentor_name] || 'fog.aws.auto_scaling'
-
-          options[:region] ||= 'us-east-1'
-          @region = options[:region]
-
-          @host = options[:host] || "autoscaling.#{options[:region]}.amazonaws.com"
-          @path       = options[:path]        || '/'
-          @port       = options[:port]        || 443
-          @persistent = options[:persistent]  || false
-          @scheme     = options[:scheme]      || 'https'
-          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
-
-          setup_credentials(options)
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        private
-
-        def request(params)
-          refresh_credentials_if_expired
-
-          idempotent  = params.delete(:idempotent)
-          parser      = params.delete(:parser)
-
-          body, headers = AWS.signed_params_v4(
-            params,
-            { 'Content-Type' => 'application/x-www-form-urlencoded' },
-            {
-              :aws_session_token  => @aws_session_token,
-              :method             => 'POST',
-              :signer             => @signer,
-              :host               => @host,
-              :path               => @path,
-              :port               => @port,
-              :version            => '2011-01-01'
-            }
-          )
-
-          if @instrumentor
-            @instrumentor.instrument("#{@instrumentor_name}.request", params) do
-              _request(body, headers, idempotent, parser)
-            end
-          else
-            _request(body,  headers, idempotent, parser)
-          end
-        end
-
-        def _request(body,  headers, idempotent, parser)
-          begin
-            @connection.request({
-              :body       => body,
-              :expects    => 200,
-              :idempotent => idempotent,
-              :headers    =>  headers, 
-              :method     => 'POST',
-              :parser     => parser
-            })
-          rescue Excon::Errors::HTTPStatusError => error
-            match = Fog::AWS::Errors.match_error(error)
-            raise if match.empty?
-            raise case match[:code]
-                  when 'AlreadyExists'
-                    Fog::AWS::AutoScaling::IdentifierTaken.slurp(error, match[:message])
-                  when 'ResourceInUse'
-                    Fog::AWS::AutoScaling::ResourceInUse.slurp(error, match[:message])
-                  when 'ValidationError'
-                    Fog::AWS::AutoScaling::ValidationError.slurp(error, match[:message])
-                  else
-                    Fog::AWS::AutoScaling::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
-                  end
-          end
-        end
-
-        def setup_credentials(options)
-          @aws_access_key_id         = options[:aws_access_key_id]
-          @aws_secret_access_key     = options[:aws_secret_access_key]
-          @aws_session_token         = options[:aws_session_token]
-          @aws_credentials_expire_at = options[:aws_credentials_expire_at]
-
-          @signer = Fog::AWS::SignatureV4.new( @aws_access_key_id, @aws_secret_access_key, @region, 'autoscaling')
-        end
-      end
-
-      class Mock
-        include Fog::AWS::CredentialFetcher::ConnectionMethods
-
-        attr_accessor :region
-
-        def self.data
-          @data ||= Hash.new do |hash, region|
-            owner_id = Fog::AWS::Mock.owner_id
-            hash[region] = Hash.new do |region_hash, key|
-              region_hash[key] = {
-                :adjustment_types => [
-                  'ChangeInCapacity',
-                  'ExactCapacity',
-                  'PercentChangeInCapacity'
-                ],
-                :auto_scaling_groups => {},
-                :scaling_policies => {},
-                :health_states => [
-                  'Healthy',
-                  'Unhealthy'
-                ],
-                :launch_configurations => {},
-                :metric_collection_types => {
-                  :granularities => [
-                    '1Minute'
-                  ],
-                  :metrics => [
-                    'GroupMinSize',
-                    'GroupMaxSize',
-                    'GroupDesiredCapacity',
-                    'GroupInServiceInstances',
-                    'GroupPendingInstances',
-                    'GroupTerminatingInstances',
-                    'GroupTotalInstances'
-                  ]
-                },
-                :notification_configurations => {},
-                :notification_types => [
-                  'autoscaling:EC2_INSTANCE_LAUNCH',
-                  'autoscaling:EC2_INSTANCE_LAUNCH_ERROR',
-                  'autoscaling:EC2_INSTANCE_TERMINATE',
-                  'autoscaling:EC2_INSTANCE_TERMINATE_ERROR',
-                  'autoscaling:TEST_NOTIFICATION'
-                ],
-                :owner_id => owner_id,
-                :process_types => [
-                  'AZRebalance',
-                  'AddToLoadBalancer',
-                  'AlarmNotification',
-                  'HealthCheck',
-                  'Launch',
-                  'ReplaceUnhealthy',
-                  'ScheduledActions',
-                  'Terminate'
-                ],
-                :termination_policy_types => [
-                  'ClosestToNextInstanceHour',
-                  'Default',
-                  'NewestInstance',
-                  'OldestInstance',
-                  'OldestLaunchConfiguration'
-                ]
-              }
-            end
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @use_iam_profile = options[:use_iam_profile]
-          setup_credentials(options)
-          @region = options[:region] || 'us-east-1'
-
-          unless ['ap-northeast-1', 'ap-southeast-1', 'ap-southeast-2', 'eu-central-1', 'eu-west-1', 'sa-east-1', 'us-east-1', 'us-west-1', 'us-west-2'].include?(@region)
-            raise ArgumentError, "Unknown region: #{@region.inspect}"
-          end
-        end
-
-        def region_data
-          self.class.data[@region]
-        end
-
-        def data
-          self.region_data[@aws_access_key_id]
-        end
-
-        def reset_data
-          self.region_data.delete(@aws_access_key_id)
-        end
-
-        def setup_credentials(options)
-          @aws_access_key_id = options[:aws_access_key_id]
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/beanstalk.rb

@@ -1,156 +0,0 @@
-require 'fog/aws/core'
-
-module Fog
-  module AWS
-    class ElasticBeanstalk < Fog::Service
-      extend Fog::AWS::CredentialFetcher::ServiceMethods
-
-      class InvalidParameterError < Fog::Errors::Error; end
-
-      requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
-
-      request_path 'fog/aws/requests/beanstalk'
-
-      request :check_dns_availability
-      request :create_application
-      request :create_application_version
-      request :create_configuration_template
-      request :create_environment
-      request :create_storage_location
-      request :delete_application
-      request :delete_application_version
-      request :delete_configuration_template
-      request :delete_environment_configuration
-      request :describe_applications
-      request :describe_application_versions
-      request :describe_configuration_options
-      request :describe_configuration_settings
-      request :describe_environment_resources
-      request :describe_environments
-      request :describe_events
-      request :list_available_solution_stacks
-      request :rebuild_environment
-      request :request_environment_info
-      request :restart_app_server
-      request :retrieve_environment_info
-      request :swap_environment_cnames
-      request :terminate_environment
-      request :update_application
-      request :update_application_version
-      request :update_configuration_template
-      request :update_environment
-      request :validate_configuration_settings
-
-      model_path 'fog/aws/models/beanstalk'
-
-      model       :application
-      collection  :applications
-      model       :environment
-      collection  :environments
-      model       :event
-      collection  :events
-      model       :template
-      collection  :templates
-      model       :version
-      collection  :versions
-
-      class Mock
-        def initialize(options={})
-          Fog::Mock.not_implemented
-        end
-      end
-
-      class Real
-        include Fog::AWS::CredentialFetcher::ConnectionMethods
-        def initialize(options={})
-
-          @use_iam_profile = options[:use_iam_profile]
-
-          @connection_options = options[:connection_options] || {}
-          options[:region] ||= 'us-east-1'
-          @host = options[:host] || "elasticbeanstalk.#{options[:region]}.amazonaws.com"
-          @path       = options[:path]        || '/'
-          @persistent = options[:persistent]  || false
-          @port       = options[:port]        || 443
-          @scheme     = options[:scheme]      || 'https'
-          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
-          @instrumentor       = options[:instrumentor]
-          @instrumentor_name  = options[:instrumentor_name] || 'fog.aws.beanstalk'
-
-          @region = options[:region]
-          setup_credentials(options)
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        # Returns an array of available solutions stack details
-        def solution_stacks
-          list_available_solution_stacks.body['ListAvailableSolutionStacksResult']['SolutionStackDetails']
-        end
-
-        private
-
-        def setup_credentials(options)
-          @aws_access_key_id      = options[:aws_access_key_id]
-          @aws_secret_access_key  = options[:aws_secret_access_key]
-          @aws_session_token      = options[:aws_session_token]
-          @aws_credentials_expire_at = options[:aws_credentials_expire_at]
-
-          @signer = Fog::AWS::SignatureV4.new( @aws_access_key_id, @aws_secret_access_key, @region, 'elasticbeanstalk')
-        end
-
-        def request(params)
-          refresh_credentials_if_expired
-
-          idempotent  = params.delete(:idempotent)
-          parser      = params.delete(:parser)
-
-          body, headers = AWS.signed_params_v4(
-              params,
-              { 'Content-Type' => 'application/x-www-form-urlencoded' },
-              {
-                  :signer             => @signer,
-                  :aws_session_token  => @aws_session_token,
-                  :method             => "POST",
-                  :host               => @host,
-                  :path               => @path,
-                  :port               => @port,
-                  :version            => '2010-12-01'
-              }
-          )
-
-          if @instrumentor
-            @instrumentor.instrument("#{@instrumentor_name}.request", params) do
-              _request(body, headers, idempotent, parser)
-            end
-          else
-            _request(body, headers, idempotent, parser)
-          end
-        end
-
-        def _request(body, headers, idempotent, parser)
-          @connection.request({
-              :body       => body,
-              :expects    => 200,
-              :headers    => headers,
-              :idempotent => idempotent,
-              :method     => 'POST',
-              :parser     => parser
-          })
-        rescue Excon::Errors::HTTPStatusError => error
-          match = Fog::AWS::Errors.match_error(error)
-          raise if match.empty?
-          raise case match[:code]
-                when 'InvalidParameterValue'
-                  Fog::AWS::ElasticBeanstalk::InvalidParameterError.slurp(error, match[:message])
-                else
-                  Fog::AWS::ElasticBeanstalk::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
-                end
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/cdn.rb

@@ -1,205 +0,0 @@
-require 'fog/aws/core'
-
-module Fog
-  module CDN
-    class AWS < Fog::Service
-      extend Fog::AWS::CredentialFetcher::ServiceMethods
-
-      requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :host, :path, :port, :scheme, :version, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
-
-      model_path 'fog/aws/models/cdn'
-      model       :distribution
-      collection  :distributions
-      model       :streaming_distribution
-      collection  :streaming_distributions
-
-      request_path 'fog/aws/requests/cdn'
-      request 'delete_distribution'
-      request 'delete_streaming_distribution'
-      request 'get_distribution'
-      request 'get_distribution_list'
-      request 'get_invalidation_list'
-      request 'get_invalidation'
-      request 'get_streaming_distribution'
-      request 'get_streaming_distribution_list'
-      request 'post_distribution'
-      request 'post_streaming_distribution'
-      request 'post_invalidation'
-      request 'put_distribution_config'
-      request 'put_streaming_distribution_config'
-
-      class Mock
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] =  {
-                :distributions => {},
-                :streaming_distributions => {},
-                :invalidations => {}
-              }
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @use_iam_profile = options[:use_iam_profile]
-          setup_credentials(options)
-        end
-
-        def data
-          self.class.data[@aws_access_key_id]
-        end
-
-        def reset_data
-          self.class.data.delete(@aws_access_key_id)
-        end
-
-        def signature(params)
-          "foo"
-        end
-
-        def setup_credentials(options={})
-          @aws_access_key_id  = options[:aws_access_key_id]
-        end
-
-        def self.distribution_id
-          random_id(14)
-        end
-
-        def self.generic_id
-          random_id(14)
-        end
-
-        def self.domain_name
-          "#{random_id(12).downcase}.cloudfront.net"
-        end
-
-        def self.random_id(length)
-          Fog::Mock.random_selection("abcdefghijklmnopqrstuvwxyz0123456789", length).upcase
-        end
-
-        CDN_ERRORS = {
-          :access_denies => {:code => 'AccessDenied',:msg  => 'Access denied.',:status => 403},
-          :inappropriate_xml => {:code => 'InappropriateXML',:msg  => 'The XML document you provided was well-formed and valid, but not appropriate for this operation.',:status => 400},
-          :internal_error => {:code => 'InternalError',:msg  => 'We encountered an internal error. Please try again.',:status => 500},
-          :invalid_action => {:code => 'InvalidAction',:msg  => 'The action specified is not valid.',:status => 400},
-          :invalid_argument => {:code => 'InvalidArgument',:msg  => '%s', :status => 400},
-          :not_implemented => {:code => 'NotImplemented', :msg  => 'Not implemented.',:status => 501},
-          :no_such_distribution => { :code => 'NoSuchDistribution', :msg => 'The specified distribution does not exist', :status => 404 },
-          :no_such_streaming_distribution => { :code => 'NoSuchStreamingDistribution', :msg => 'The specified streaming distribution does not exist', :status => 404 },
-          :no_such_invalidation => { :code => 'NoSuchInvalidation', :msg => 'The specified invalidation does not exist', :status => 404 },
-          :cname_exists => { :code => 'CNAMEAlreadyExists', :msg => 'One or more of the CNAMEs you provided are already associated with a different distribution', :status => 409 },
-          :illegal_update => { :code => 'IllegalUpdate', :msg => 'Origin and CallerReference cannot be updated.', :status => 400 },
-          :invalid_if_match_version => { :code => 'InvalidIfMatchVersion', :msg => 'The If-Match version is missing or not valid for the distribution.', :status => 400},
-          :distribution_not_disabled => { :code => 'DistributionNotDisabled', :msg => 'The distribution you are trying to delete has not been disabled.', :status => 409 },
-
-        }
-
-        def self.error(code, argument = '')
-          if error = CDN_ERRORS[code]
-            raise_error(error[:status], error[:code], error[:msg] % argument)
-          end
-        end
-
-        def self.raise_error(status, code, message='')
-          response = Excon::Response.new
-          response.status = status
-          response.body = <<EOF
-<ErrorResponse xmlns="http://cloudfront.amazonaws.com/doc/2010-11-01/">
-   <Error>
-      <Type>Sender</Type>
-      <Code>#{code}</Code>
-      <Message>#{message}.</Message>
-   </Error>
-   <RequestId>#{Fog::AWS::Mock.request_id}</RequestId>
-</ErrorResponse>
-EOF
-
-          raise(Excon::Errors.status_error({:expects => 201}, response))
-        end
-      end
-
-      class Real
-        include Fog::AWS::CredentialFetcher::ConnectionMethods
-        # Initialize connection to Cloudfront
-        #
-        # ==== Notes
-        # options parameter must include values for :aws_access_key_id and
-        # :aws_secret_access_key in order to create a connection
-        #
-        # ==== Examples
-        #   cdn = Fog::AWS::CDN.new(
-        #     :aws_access_key_id => your_aws_access_key_id,
-        #     :aws_secret_access_key => your_aws_secret_access_key
-        #   )
-        #
-        # ==== Parameters
-        # * options<~Hash> - config arguments for connection.  Defaults to {}.
-        #
-        # ==== Returns
-        # * cdn object with connection to aws.
-        def initialize(options={})
-
-          @use_iam_profile = options[:use_iam_profile]
-          setup_credentials(options)
-          @instrumentor      = options[:instrumentor]
-          @instrumentor_name = options[:instrumentor_name] || 'fog.aws.cdn'
-          @connection_options = options[:connection_options] || {}
-          @host       = options[:host]      || 'cloudfront.amazonaws.com'
-          @path       = options[:path]      || '/'
-          @persistent = options.fetch(:persistent, true)
-          @port       = options[:port]      || 443
-          @scheme     = options[:scheme]    || 'https'
-          @version    = options[:version]  || '2010-11-01'
-          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        private
-
-        def setup_credentials(options)
-          @aws_access_key_id     = options[:aws_access_key_id]
-          @aws_secret_access_key = options[:aws_secret_access_key]
-          @aws_session_token     = options[:aws_session_token]
-          @aws_credentials_expire_at = options[:aws_credentials_expire_at]
-
-          @hmac       = Fog::HMAC.new('sha1', @aws_secret_access_key)
-        end
-
-        def request(params, &block)
-          refresh_credentials_if_expired
-
-          params[:headers] ||= {}
-          params[:headers]['Date'] = Fog::Time.now.to_date_header
-          params[:headers]['x-amz-security-token'] = @aws_session_token if @aws_session_token
-          params[:headers]['Authorization'] = "AWS #{@aws_access_key_id}:#{signature(params)}"
-          params[:path] = "/#{@version}/#{params[:path]}"
-
-          if @instrumentor
-            @instrumentor.instrument("#{@instrumentor_name}.request", params) do
-              _request(params, &block)
-            end
-          else
-            _request(params, &block)
-          end
-        end
-
-        def _request(params, &block)
-          @connection.request(params, &block)
-        end
-
-        def signature(params)
-          string_to_sign = params[:headers]['Date']
-          signed_string = @hmac.sign(string_to_sign)
-          Base64.encode64(signed_string).chomp!
-        end
-      end
-    end
-  end
-end