fog 0.9.0 → 0.10.0

data/lib/fog/aws/requests/auto_scaling/set_instance_health.rb

@@ -0,0 +1,55 @@
+module Fog
+  module AWS
+    class AutoScaling
+
+      class Real
+
+        require 'fog/aws/parsers/auto_scaling/basic'
+
+        # Sets the health status of an instance.
+        #
+        # ==== Parameters
+        # * health_status<~String> - The health status of the instance.
+        #   "Healthy" means that the instance is healthy and should remain in
+        #   service. "Unhealthy" means that the instance is unhealthy. Auto
+        #   Scaling should terminate and replace it.
+        # * instance_id<~String> - The identifier of the EC2 instance.
+        # * options<~Hash>:
+        #   * 'ShouldRespectGracePeriod'<~Boolean> - If true, this call should
+        #   respect the grace period associated with the group.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AutoScaling/latest/APIReference/API_SetInstanceHealth.html
+        #
+        def set_instance_health(health_status, instance_id, options = {})
+          request({
+            'Action'       => 'SetInstanceHealth',
+            'HealthStatus' => health_status,
+            'InstanceId'   => instance_id,
+            :parser        => Fog::Parsers::AWS::AutoScaling::Basic.new
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def set_instance_health(health_status, instance_id, options = {})
+          unless data[:health_states].include?(health_status)
+            raise Fog::AWS::AutoScaling::ValidationError.new('Valid instance health states are: [#{data[:health_states].join(", ")}].')
+          end
+
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/auto_scaling/suspend_processes.rb

@@ -0,0 +1,57 @@
+module Fog
+  module AWS
+    class AutoScaling
+
+      class Real
+
+        require 'fog/aws/parsers/auto_scaling/basic'
+
+        # Suspends Auto Scaling processes for an Auto Scaling group. To suspend
+        # specific process types, specify them by name with the
+        # ScalingProcesses parameter. To suspend all process types, omit the
+        # ScalingProcesses.member.N parameter.
+        #
+        # ==== Parameters
+        # * 'AutoScalingGroupName'<~String> - The name or Amazon Resource Name
+        #   (ARN) of the Auto Scaling group.
+        # * options<~Hash>:
+        #   * 'ScalingProcesses'<~Array> - The processes that you want to
+        #     suspend. To suspend all process types, omit this parameter.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AutoScaling/latest/APIReference/API_SuspendProcesses.html
+        #
+        def suspend_processes(auto_scaling_group_name, options = {})
+          if scaling_processes = options.delete('ScalingProcesses')
+            options.merge!(AWS.indexed_param('ScalingProcesses.member.%d', [*scaling_processes]))
+          end
+          request({
+            'Action'               => 'SuspendProcesses',
+            'AutoScalingGroupName' => auto_scaling_group_name,
+            :parser                => Fog::Parsers::AWS::AutoScaling::Basic.new
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def suspend_processes(auto_scaling_group_name, options = {})
+          unless data[:auto_scaling_groups].has_key?(auto_scaling_group_name)
+            raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
+          end
+
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/auto_scaling/terminate_instance_in_auto_scaling_group.rb

@@ -0,0 +1,65 @@
+module Fog
+  module AWS
+    class AutoScaling
+
+      class Real
+
+        require 'fog/aws/parsers/auto_scaling/terminate_instance_in_auto_scaling_group'
+
+        # Terminates the specified instance. Optionally, the desired group size
+        # can be adjusted.
+        #
+        # ==== Parameters
+        # * instance_id<~String> - The ID of the EC2 instance to be terminated.
+        # * should_decrement_desired_capacity<~Boolean> - Specifies whether
+        #   (true) or not (false) terminating this instance should also
+        #   decrement the size of the AutoScalingGroup.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'TerminateGroupInAutoScalingInstanceResult'<~Hash>:
+        #       * 'ActivityId'<~String> - Specifies the ID of the activity.
+        #       * 'AutoScalingGroupName'<~String> - The name of the Auto
+        #         Scaling group.
+        #       * 'Cause'<~String> - Contains the reason the activity was
+        #         begun.
+        #       * 'Description'<~String> - Contains a friendly, more verbose
+        #         description of the scaling activity.
+        #       * 'EndTime'<~Time> - Provides the end time of this activity.
+        #       * 'Progress'<~Integer> - Specifies a value between 0 and 100
+        #         that indicates the progress of the activity.
+        #       * 'StartTime'<~Time> - Provides the start time of this
+        #         activity.
+        #       * 'StatusCode'<~String> - Contains the current status of the
+        #         activity.
+        #       * 'StatusMessage'<~String> - Contains a friendly, more verbose
+        #         description of the activity status.
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AutoScaling/latest/APIReference/API_TerminateInstanceInAutoScalingGroup.html
+        #
+        def terminate_instance_in_auto_scaling_group(instance_id, should_decrement_desired_capacity)
+          request({
+            'Action'                         => 'TerminateInstanceInAutoScalingGroup',
+            'InstanceId'                     => instance_id,
+            'ShouldDecrementDesiredCapacity' => should_decrement_desired_capacity.to_s,
+            :parser                          => Fog::Parsers::AWS::AutoScaling::TerminateInstanceInAutoScalingGroup.new
+          })
+        end
+
+      end
+
+      class Mock
+
+        def terminate_instance_in_auto_scaling_group(instance_id, should_decrement_desired_capacity)
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/auto_scaling/update_auto_scaling_group.rb

@@ -0,0 +1,79 @@
+module Fog
+  module AWS
+    class AutoScaling
+
+      class Real
+
+        require 'fog/aws/parsers/auto_scaling/basic'
+
+        # Updates the configuration for the specified AutoScalingGroup.
+        #
+        # The new settings are registered upon the completion of this call. Any
+        # launch configuration settings take effect on any triggers after this
+        # call returns. Triggers that are currently in progress aren't
+        # affected.
+        #
+        # ==== Parameters
+        # * auto_scaling_group_name<~String> - The name of the Auto Scaling
+        #   group.
+        # * options<~Hash>:
+        #   * 'AvailabilityZones'<~Array>: Availability zones for the group
+        #   * 'DefaultCooldown'<~Integer> - Amount of time, in seconds, after a
+        #     scaling activity completes before any further trigger-related
+        #     scaling activities can start
+        #   * 'DesiredCapacity'<~Integer> - Desired capacity for the scaling group
+        #   * 'HealthCheckGracePeriod'<~Integer> - Length of time that Auto
+        #      Scaling waits before checking an instance's health status
+        #   * 'HealthCheckType'<~String> - Service of interest for the health
+        #     status check, either "EC2" or "ELB".
+        #   * 'LaunchConfigurationName'<~String> - Name of the launch configuration
+        #   * 'MaxSize'<~Integer> - Maximum size of the Auto Scaling group
+        #   * 'MinSize'<~Integer> - Minimum size of the Auto Scaling group
+        #   * 'PlacementGroup'<~String> - Name of the cluster placement group,
+        #     if applicable
+        #   * 'VPCZoneIdentifier'<~String> - Identifier for the VPC connection,
+        #     if applicable
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AutoScaling/latest/APIReference/API_UpdateAutoScalingGroup.html
+        #
+        def update_auto_scaling_group(auto_scaling_group_name, options = {})
+          if availability_zones = options.delete('AvailabilityZones')
+            options.merge!(AWS.indexed_param('AvailabilityZones.member.%d', [*availability_zones]))
+          end
+          request({
+            'Action'               => 'UpdateAutoScalingGroup',
+            'AutoScalingGroupName' => auto_scaling_group_name,
+            :parser                => Fog::Parsers::AWS::AutoScaling::Basic.new
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def update_auto_scaling_group(auto_scaling_group_name, options = {})
+          unless data[:auto_scaling_groups].has_key?(auto_scaling_group_name)
+            raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
+          end
+          data[:auto_scaling_group_name][auto_scaling_group_name].merge!(options)
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
+          }
+          response
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/cloud_watch/get_metric_statistics.rb

@@ -0,0 +1,48 @@
+module Fog
+  module AWS
+    class CloudWatch
+      class Real
+
+        require 'fog/aws/parsers/cloud_watch/get_metric_statistics'
+
+        # Fetch datapoints for a metric. At most 1440 datapoints will be returned, the most datapoints that can be queried is 50850
+        # StartTime is capped to 2 weeks ago
+        # ==== Options
+        # * Namespace<~String>: the namespace of the metric
+        # * MetricName<~String>: the name of the metric
+        # * StartTime<~Datetime>: when to start fetching datapoints from (inclusive)
+        # * EndTime<~Datetime>: used to determine the last datapoint to fetch (exclusive)
+        # * Period<~Integer>: Granularity, in seconds of the returned datapoints. Must be a multiple of 60, and at least 60
+        # * Statistics<~Array>: An array of up to 5 strings, which name the statistics to return
+        # * Unit<~String>: The unit for the metric
+        # * Dimensions<~Array>: a list of dimensions to filter against (optional) 
+        #     Name : The name of the dimension
+        #     Value : The value to filter against
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html
+        #
+        def get_metric_statistics(options={})
+          %w{Statistics StartTime EndTime Period MetricName Namespace}.each do |required_parameter|
+            raise ArgumentError, "Must prodide #{required_parameter}" unless options.has_key?(required_parameter)
+          end
+          statistics = options.delete 'Statistics'
+          options.merge!(AWS.indexed_param('Statistics.member.%d', [*statistics]))
+          
+          if dimensions = options.delete('Dimensions')
+            options.merge!(AWS.indexed_param('Dimensions.member.%d.Name', dimensions.collect {|dimension| dimension['Name']}))
+            options.merge!(AWS.indexed_param('Dimensions.member.%d.Value', dimensions.collect {|dimension| dimension['Value']}))
+          end
+
+          request({
+              'Action'    => 'GetMetricStatistics',
+              :parser     => Fog::Parsers::AWS::CloudWatch::GetMetricStatistics.new
+            }.merge(options))
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/cloud_watch/list_metrics.rb

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class CloudWatch
+      class Real
+
+        require 'fog/aws/parsers/cloud_watch/list_metrics'
+
+        # List availabe metrics
+        #
+        # ==== Options
+        # * Dimensions<~Array>: a list of dimensions to filter against, 
+        #     Name : The name of the dimension
+        #     Value : The value to filter against
+        # * MetricName<~String>: The name of the metric to filter against
+        # * Namespace<~String>: The namespace to filter against
+        # * NextToken<~String> The token returned by a previous call to indicate that there is more data available
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonCloudWatch/latest/APIReference/API_ListMetrics.html
+        #
+        def list_metrics(options={})
+          if dimensions = options.delete('Dimensions')
+            options.merge!(AWS.indexed_param('Dimensions.member.%d.Name', dimensions.collect {|dimension| dimension['Name']}))
+            options.merge!(AWS.indexed_param('Dimensions.member.%d.Value', dimensions.collect {|dimension| dimension['Value']}))
+          end
+
+          request({
+              'Action'    => 'ListMetrics',
+              :parser     => Fog::Parsers::AWS::CloudWatch::ListMetrics.new
+            }.merge(options))
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/cloud_watch/put_metric_data.rb

@@ -0,0 +1,73 @@
+module Fog
+  module AWS
+    class CloudWatch
+      class Real
+
+        require 'fog/aws/parsers/cloud_watch/put_metric_data'
+
+        # Publishes one or more data points to CloudWatch. A new metric is created if necessary
+        # ==== Options
+        # * Namespace<~String>: the namespace of the metric data
+        # * MetricData<~Array>: the datapoints to publish of the metric
+        #     * MetricName<~String>: the name of the metric
+        #     * Timestamp<~String>: the timestamp for the data point. If omitted defaults to the time at which the data is received by CloudWatch 
+        #     * Unit<~String>: the unit
+        #     * Value<~Double> the value for the metric
+        #     * StatisticValues<~Hash>:
+        #         * Maximum<~Double>: the maximum value of the sample set
+        #         * Sum<~Double>: the sum of the values of the sample set
+        #         * SampleCount<~Double>: the number of samples used for the statistic set
+        #         * Minimum<~Double>: the minimum value of the sample set
+        #     * Dimensions<~Array>: the dimensions for the metric. From 0 to 10 may be included
+        #          * Name<~String>
+        #         * Value<~String>
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html
+        #
+        
+        def put_metric_data(namespace, metric_data)
+          options = {'Namespace' => namespace}
+          
+          #first index the dimensions for any of the datums that have dimensions
+          metric_data.collect! do |metric_datum|
+            if dimensions = metric_datum.delete('Dimensions')
+              metric_datum.merge!(AWS.indexed_param('Dimensions.member.%d.Name', dimensions.collect {|dimension| dimension['Name']}))
+              metric_datum.merge!(AWS.indexed_param('Dimensions.member.%d.Value', dimensions.collect {|dimension| dimension['Value']}))
+            end
+            metric_datum
+          end
+          #then flatten out an hashes in the metric_data array
+          metric_data.collect! { |metric_datum| flatten_hash(metric_datum) }
+          #then index the metric_data array
+          options.merge!(AWS.indexed_param('MetricData.member.%d', [*metric_data]))
+          #then finally flatten out an hashes in the overall options array
+          options = flatten_hash(options)
+          
+          request({
+              'Action'    => 'PutMetricData',
+              :parser     => Fog::Parsers::AWS::CloudWatch::PutMetricData.new
+            }.merge(options))
+        end
+        private
+        
+        def flatten_hash(starting)
+          finishing = {}
+          starting.each do |top_level_key, top_level_value|
+            if top_level_value.is_a?(Hash)
+              nested_hash = top_level_value
+              nested_hash.each do |nested_key, nested_value|
+                finishing["#{top_level_key}.#{nested_key}"] = nested_value
+              end
+            else
+              finishing[top_level_key] = top_level_value
+            end
+          end
+          return finishing
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elb/configure_health_check.rb

@@ -36,6 +36,30 @@ module Fog
         end
 
       end
+
+      class Mock
+        def configure_health_check(lb_name, health_check)
+          if load_balancer = self.data[:load_balancers][lb_name]
+            response = Excon::Response.new
+            response.status = 200
+
+            load_balancer['HealthCheck'] = health_check
+
+            response.body = {
+              'ResponseMetadata' => {
+                'RequestId' => Fog::AWS::Mock.request_id
+              },
+              'ConfigureHealthCheckResult' => {
+                'HealthCheck' => load_balancer['HealthCheck']
+              }
+            }
+
+            response
+          else
+            raise Fog::AWS::ELB::NotFound
+          end
+        end
+      end
     end
   end
 end