fog-aws 0.0.5

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

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class CloudWatch
+      class Real
+        require 'fog/aws/parsers/cloud_watch/describe_alarms_for_metric'
+
+        # Retrieves all alarms for a single metric
+        # ==== 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
+        # * Namespace<~String>: The namespace of the metric
+        # * Period<~Integer>: The period in seconds over which the statistic is applied
+        # * Statistics<~String>: The statistic for the metric
+        # * Unit<~String> The unit for the metric
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonCloudWatch/latest/APIReference/API_DescribeAlarms.html
+        #
+
+        def describe_alarms_for_metric(options)
+          if dimensions = options.delete('Dimensions')
+            options.merge!(AWS.indexed_param('Dimensions.member.%d.Name', dimensions.map {|dimension| dimension['Name']}))
+            options.merge!(AWS.indexed_param('Dimensions.member.%d.Value', dimensions.map {|dimension| dimension['Value']}))
+          end
+          request({
+              'Action'    => 'DescribeAlarmsForMetric',
+              :parser     => Fog::Parsers::AWS::CloudWatch::DescribeAlarmsForMetric.new
+            }.merge(options))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module AWS
+    class CloudWatch
+      class Real
+        require 'fog/aws/parsers/cloud_watch/disable_alarm_actions'
+
+        # Disables actions for the specified alarms
+        # ==== Options
+        # * AlarmNames<~Array>: The names of the alarms to disable actions for
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonCloudWatch/latest/APIReference/API_DisableAlarmActions.html
+        #
+
+        def disable_alarm_actions(alarm_names)
+          options = {}
+          options.merge!(AWS.indexed_param('AlarmNames.member.%d', [*alarm_names]))
+          request({
+              'Action'    => 'DisableAlarmActions',
+              :parser     => Fog::Parsers::AWS::CloudWatch::DisableAlarmActions.new
+            }.merge(options))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Fog
+  module AWS
+    class CloudWatch
+      class Real
+        require 'fog/aws/parsers/cloud_watch/enable_alarm_actions'
+
+        # Enables actions for the specified alarms
+        # ==== Options
+        # * AlarmNames<~Array>: The names of the alarms to enable actions for
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonCloudWatch/latest/APIReference/API_EnableAlarmActions.html
+        #
+
+        def enable_alarm_actions(alarm_names)
+          options = {}
+          options.merge!(AWS.indexed_param('AlarmNames.member.%d', [*alarm_names]))
+          request({
+              'Action'    => 'EnableAlarmActions',
+              :parser     => Fog::Parsers::AWS::CloudWatch::EnableAlarmActions.new
+            }.merge(options))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+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 provide #{required_parameter}" unless options.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.map {|dimension| dimension['Name']}))
+            options.merge!(AWS.indexed_param('Dimensions.member.%d.Value', dimensions.map {|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,62 @@
+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.map {|dimension| dimension['Name']}))
+            options.merge!(AWS.indexed_param('Dimensions.member.%d.Value', dimensions.map {|dimension| dimension['Value']}))
+          end
+
+          request({
+              'Action'    => 'ListMetrics',
+              :parser     => Fog::Parsers::AWS::CloudWatch::ListMetrics.new
+            }.merge(options))
+        end
+      end
+
+      class Mock
+        def list_metrics(options={})
+          body = case options["NextToken"]
+                 when nil
+                   { "ListMetricsResult" => {
+                      "Metrics" => (0...500).map{ {} },
+                      "NextToken" => '1'
+                   }}
+                 when "1"
+                   { "ListMetricsResult" => {
+                      "Metrics" => (0...500).map{ {} },
+                      "NextToken" => '2'
+                   }}
+                 when "2"
+                   { "ListMetricsResult" => {
+                      "Metrics" => (0...1).map{ {} }
+                   }}
+                 end
+
+          Excon::Response.new.tap do |response|
+            response.body = body
+            response.status = 200
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module Fog
+  module AWS
+    class CloudWatch
+      class Real
+        require 'fog/aws/parsers/cloud_watch/put_metric_alarm'
+
+        # Creates or updates an alarm and associates it with the specified Amazon CloudWatch metric
+        # ==== Options
+        # * ActionsEnabled<~Boolean>: Indicates whether or not actions should be executed during any changes to the alarm's state
+        # * AlarmActions<~Array>: A list of actions to execute
+        # * AlarmDescription<~String>: The description for the alarm
+        # * AlarmName<~String> The unique name for the alarm
+        # * ComparisonOperator<~String>: The arithmetic operation to use for comparison
+        # * Dimensions<~Array>: a list of dimensions to filter against,
+        #     Name : The name of the dimension
+        #     Value : The value to filter against
+        # * EvaluationPeriods<~Integer>: The number of periods over which data is compared to the specified threshold
+        # * InsufficientDataActions<~Array>: A list of actions to execute
+        # * MetricName<~String>: The name for the alarm's associated metric
+        # * Namespace<~String>: The namespace for the alarm's associated metric
+        # * OKActions<~Array>: A list of actions to execute
+        # * Period<~Integer>: The period in seconds over which the specified statistic is applied
+        # * Statistic<~String>: The statistic to apply to the alarm's associated metric
+        # * Threshold<~Double>: The value against which the specified statistic is compared
+        # * Unit<~String>: The unit for the alarm's associated metric
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonCloudWatch/latest/APIReference/API_PutMetricAlarm.html
+        #
+        def put_metric_alarm(options)
+          if dimensions = options.delete('Dimensions')
+            options.merge!(AWS.indexed_param('Dimensions.member.%d.Name', dimensions.map {|dimension| dimension['Name']}))
+            options.merge!(AWS.indexed_param('Dimensions.member.%d.Value', dimensions.map {|dimension| dimension['Value']}))
+          end
+          if alarm_actions = options.delete('AlarmActions')
+            options.merge!(AWS.indexed_param('AlarmActions.member.%d', [*alarm_actions]))
+          end
+          if insufficient_data_actions = options.delete('InsufficientDataActions')
+            options.merge!(AWS.indexed_param('InsufficientDataActions.member.%d', [*insufficient_data_actions]))
+          end
+          if ok_actions = options.delete('OKActions')
+            options.merge!(AWS.indexed_param('OKActions.member.%d', [*ok_actions]))
+          end
+
+          request({
+              'Action'    => 'PutMetricAlarm',
+              :parser     => Fog::Parsers::AWS::CloudWatch::PutMetricAlarm.new
+            }.merge(options))
+        end
+      end
+
+      class Mock
+        require 'fog/aws/parsers/cloud_watch/put_metric_alarm'
+
+        # See: Fog::AWS::CloudWatch::Real.put_metric_alarm()
+        #
+        def put_metric_alarm(options)
+          supported_actions = [ "InsufficientDataActions", "OKActions", "AlarmActions" ]
+          found_actions = options.keys.select {|key| supported_actions.include? key }
+          if found_actions.empty?
+            raise Fog::Compute::AWS::Error.new("The request must contain at least one of #{supported_actions.join(", ")}'")
+          end
+
+          requirements = [ "AlarmName", "ComparisonOperator", "EvaluationPeriods", "Namespace", "Period", "Statistic", "Threshold" ]
+          requirements.each do |req|
+            unless options.key?(req)
+              raise Fog::Compute::AWS::Error.new("The request must contain a the parameter '%s'" % req)
+            end
+          end
+
+          data[:metric_alarms][options['AlarmName']] = {
+            'AlarmARN' => "arn:aws:cloudwatch:eu-west-1:000000000000:metricAlarm:00000000-0000-0000-0000-000000000000:alarmName/#{options['AlarmName']}",
+            'ActionsEnabled' => false,
+            'AlarmActions' => [],
+            'AlarmConfigurationUpdatedTimestamp' => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
+            'Dimensions' => [],
+            'OKActions' => [],
+          }.merge!(options)
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            'requestId' => Fog::AWS::Mock.request_id
+          }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+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.map! do |metric_datum|
+            if dimensions = metric_datum.delete('Dimensions')
+              metric_datum.merge!(AWS.indexed_param('Dimensions.member.%d.Name', dimensions.map {|dimension| dimension['Name']}))
+              metric_datum.merge!(AWS.indexed_param('Dimensions.member.%d.Value', dimensions.map {|dimension| dimension['Value']}))
+            end
+            metric_datum
+          end
+          #then flatten out an hashes in the metric_data array
+          metric_data.map! { |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/cloud_watch/set_alarm_state.rb

@@ -0,0 +1,30 @@
+module Fog
+  module AWS
+    class CloudWatch
+      class Real
+        require 'fog/aws/parsers/cloud_watch/set_alarm_state'
+
+        # Temporarily sets the state of an alarm
+        # ==== Options
+        # * AlarmName<~String>: The names of the alarm
+        # * StateReason<~String>: The reason that this alarm is set to this specific state (in human-readable text format)
+        # * StateReasonData<~String>: The reason that this alarm is set to this specific state (in machine-readable JSON format)
+        # * StateValue<~String>: The value of the state
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonCloudWatch/latest/APIReference/API_SetAlarmState.html
+        #
+
+        def set_alarm_state(options)
+          request({
+              'Action'    => 'SetAlarmState',
+              :parser     => Fog::Parsers::AWS::CloudWatch::SetAlarmState.new
+            }.merge(options))
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/compute/allocate_address.rb

@@ -0,0 +1,55 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/allocate_address'
+
+        # Acquire an elastic IP address.
+        #
+        # ==== Parameters
+        # * domain<~String> - Type of EIP, either standard or vpc
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'publicIp'<~String> - The acquired address
+        #     * 'requestId'<~String> - Id of the request
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AllocateAddress.html]
+        def allocate_address(domain='standard')
+          domain = domain == 'vpc' ? 'vpc' : 'standard'
+          request(
+            'Action'  => 'AllocateAddress',
+            'Domain'  => domain,
+            :parser   => Fog::Parsers::Compute::AWS::AllocateAddress.new
+          )
+        end
+      end
+
+      class Mock
+        def allocate_address(domain = 'standard')
+          domain = domain == 'vpc' ? 'vpc' : 'standard'
+          response = Excon::Response.new
+          if describe_addresses.body['addressesSet'].size < self.data[:limits][:addresses]
+            response.status = 200
+            public_ip = Fog::AWS::Mock.ip_address
+            data = {
+              'instanceId' => nil,
+              'publicIp'   => public_ip,
+              'domain'     => domain
+            }
+            if domain == 'vpc'
+              data['allocationId'] = "eipalloc-#{Fog::Mock.random_hex(8)}"
+            end
+            self.data[:addresses][public_ip] = data
+            response.body = data.reject {|k, v| k == 'instanceId' }.merge('requestId' => Fog::AWS::Mock.request_id)
+            response
+          else
+            response.status = 400
+            response.body = "<?xml version=\"1.0\"?><Response><Errors><Error><Code>AddressLimitExceeded</Code><Message>Too many addresses allocated</Message></Error></Errors><RequestID>#{Fog::AWS::Mock.request_id}</RequestID></Response>"
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+        end
+      end
+    end
+  end
+end