fog 1.0.0 → 1.1.0

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

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class CloudWatch
+      class Real     
+
+        require 'fog/aws/parsers/cloud_watch/describe_alarms'
+
+        # Retrieves alarms with the specified names
+        # ==== Options
+        # * ActionPrefix<~String>: The action name prefix
+        # * AlarmNamePrefix<~String>: The alarm name prefix. 
+        #         AlarmNames cannot be specified if this parameter is specified
+        # * AlarmNames<~Array>: A list of alarm names to retrieve information for. 
+        # * MaxRecords<~Integer>: The maximum number of alarm descriptions to retrieve
+        # * NextToken<~String>: The token returned by a previous call to indicate that there is more data available
+        # * NextToken<~String> The token returned by a previous call to indicate that there is more data available
+        # * StateValue<~String>: The state value to be used in matching alarms
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonCloudWatch/latest/APIReference/API_DescribeAlarms.html
+        #
+
+        def describe_alarms(options={})
+          if alarm_names = options.delete('AlarmNames')
+            options.merge!(AWS.indexed_param('AlarmNames.member.%d', [*alarm_names]))
+          end
+          request({
+              'Action'    => 'DescribeAlarms',
+              :parser     => Fog::Parsers::AWS::CloudWatch::DescribeAlarms.new
+            }.merge(options))
+        end
+      end     
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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.collect {|dimension| dimension['Name']}))
+            options.merge!(AWS.indexed_param('Dimensions.member.%d.Value', dimensions.collect {|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,30 @@
+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,30 @@
+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/put_metric_alarm.rb

@@ -0,0 +1,84 @@
+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.collect {|dimension| dimension['Name']}))
+            options.merge!(AWS.indexed_param('Dimensions.member.%d.Value', dimensions.collect {|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.has_key?(req)
+              raise Fog::Compute::AWS::Error.new("The request must contain a the parameter '%s'" % req)
+            end
+          end
+
+          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/set_alarm_state.rb

@@ -0,0 +1,31 @@
+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/authorize_security_group_ingress.rb

@@ -13,11 +13,23 @@ module Fog
         #   * 'SourceSecurityGroupName'<~String> - Name of security group to authorize
         #   * 'SourceSecurityGroupOwnerId'<~String> - Name of owner to authorize
         #   or
-        #   * 'CidrIp' - CIDR range
-        #   * 'FromPort' - Start of port range (or -1 for ICMP wildcard)
-        #   * 'GroupName' - Name of group to modify
-        #   * 'IpProtocol' - Ip protocol, must be in ['tcp', 'udp', 'icmp']
-        #   * 'ToPort' - End of port range (or -1 for ICMP wildcard)
+        #   * 'CidrIp'<~String> - CIDR range
+        #   * 'FromPort'<~Integer> - Start of port range (or -1 for ICMP wildcard)
+        #   * 'IpProtocol'<~String> - Ip protocol, must be in ['tcp', 'udp', 'icmp']
+        #   * 'ToPort'<~Integer> - End of port range (or -1 for ICMP wildcard)
+        #   or
+        #   * 'IpPermissions'<~Array>:
+        #     * permission<~Hash>:
+        #       * 'FromPort'<~Integer> - Start of port range (or -1 for ICMP wildcard)
+        #       * 'Groups'<~Array>:
+        #         * group<~Hash>:
+        #           * 'GroupName'<~String> - Name of security group to authorize
+        #           * 'UserId'<~String> - Name of owner to authorize
+        #       * 'IpProtocol'<~String> - Ip protocol, must be in ['tcp', 'udp', 'icmp']
+        #       * 'IpRanges'<~Array>:
+        #         * ip_range<~Hash>:
+        #           * 'CidrIp'<~String> - CIDR range
+        #       * 'ToPort'<~Integer> - End of port range (or -1 for ICMP wildcard)
         #
         # === Returns
         # * response<~Excon::Response>:
@@ -28,10 +40,15 @@ module Fog
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AuthorizeSecurityGroupIngress.html]
         def authorize_security_group_ingress(group_name, options = {})
           if group_name.is_a?(Hash)
-            Fog::Logger.warning("Fog::AWS::Compute#authorize_security_group_ingress now requires the 'group_name' parameter. Only specifying an options hash is now deprecated [light_black](#{caller.first})[/]")
+            Fog::Logger.deprecation("Fog::AWS::Compute#authorize_security_group_ingress now requires the 'group_name' parameter. Only specifying an options hash is now deprecated [light_black](#{caller.first})[/]")
             options = group_name
-            group_name = options['GroupName']
+            group_name = options.delete('GroupName')
+          end
+
+          if ip_permissions = options.delete('IpPermissions')
+            options.merge!(indexed_ip_permissions_params(ip_permissions))
           end
+
           request({
             'Action'    => 'AuthorizeSecurityGroupIngress',
             'GroupName' => group_name,
@@ -40,51 +57,69 @@ module Fog
           }.merge!(options))
         end
 
+        private
+
+        def indexed_ip_permissions_params(ip_permissions)
+          params = {}
+          ip_permissions.each_with_index do |permission, key_index|
+            key_index += 1
+            params[format('IpPermissions.%d.IpProtocol', key_index)] = permission['IpProtocol']
+            params[format('IpPermissions.%d.FromPort', key_index)] = permission['FromPort']
+            params[format('IpPermissions.%d.ToPort', key_index)] = permission['ToPort']
+            (permission['Groups'] || []).each_with_index do |group, group_index|
+              group_index += 1
+              params[format('IpPermissions.%d.Groups.%d.UserId', key_index, group_index)] = group['UserId']
+              params[format('IpPermissions.%d.Groups.%d.GroupName', key_index, group_index)] = group['GroupName']
+              params[format('IpPermissions.%d.Groups.%d.GroupId', key_index, group_index)] = group['GroupId']
+            end
+            (permission['IpRanges'] || []).each_with_index do |ip_range, range_index|
+              range_index += 1
+              params[format('IpPermissions.%d.IpRanges.%d.CidrIp', key_index, range_index)] = ip_range['CidrIp']
+            end
+          end
+          params.reject {|k, v| v.nil? }
+        end
+
       end
 
       class Mock
 
         def authorize_security_group_ingress(group_name, options = {})
           if group_name.is_a?(Hash)
-            Fog::Logger.warning("Fog::AWS::Compute#authorize_security_group_ingress now requires the 'group_name' parameter. Only specifying an options hash is now deprecated [light_black](#{caller.first})[/]")
+            Fog::Logger.deprecation("Fog::AWS::Compute#authorize_security_group_ingress now requires the 'group_name' parameter. Only specifying an options hash is now deprecated [light_black](#{caller.first})[/]")
             options = group_name
-            group_name = options['GroupName']
+            group_name = options.delete('GroupName')
           end
 
+          verify_permission_options(options)
+
           response = Excon::Response.new
           group = self.data[:security_groups][group_name]
 
           if group
-            group['ipPermissions'] ||= []
-            if group_name && source_group_name = options['SourceSecurityGroupName']
-              ['tcp', 'udp'].each do |protocol|
-                group['ipPermissions'] << {
-                  'groups'      => [{'groupName' => source_group_name, 'userId' => (options['SourceSecurityGroupOwnerId'] || self.data[:owner_id]) }],
-                  'fromPort'    => 1,
-                  'ipRanges'    => [],
-                  'ipProtocol'  => protocol,
-                  'toPort'      => 65535
-                }
+            normalized_permissions = normalize_permissions(options)
+
+            normalized_permissions.each do |permission|
+              if matching_group_permission = find_matching_permission(group, permission)
+                if permission['groups'].any? {|pg| matching_group_permission['groups'].include?(pg) }
+                  raise Fog::Compute::AWS::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
+                end
+
+                if permission['ipRanges'].any? {|pr| matching_group_permission['ipRanges'].include?(pr) }
+                  raise Fog::Compute::AWS::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
+                end
               end
-              group['ipPermissions'] << {
-                'groups'      => [{'groupName' => source_group_name, 'userId' => (options['SourceSecurityGroupOwnerId'] || self.data[:owner_id]) }],
-                'fromPort'    => -1,
-                'ipRanges'    => [],
-                'ipProtocol'  => 'icmp',
-                'toPort'      => -1
-              }
-            else
-              group['ipPermissions'] << {
-                'groups'      => [],
-                'fromPort'    => options['FromPort'],
-                'ipRanges'    => [],
-                'ipProtocol'  => options['IpProtocol'],
-                'toPort'      => options['ToPort']
-              }
-              if options['CidrIp']
-                group['ipPermissions'].last['ipRanges'] << { 'cidrIp' => options['CidrIp'] }
+            end
+
+            normalized_permissions.each do |permission|
+              if matching_group_permission = find_matching_permission(group, permission)
+                matching_group_permission['groups'] += permission['groups']
+                matching_group_permission['ipRanges'] += permission['ipRanges']
+              else
+                group['ipPermissions'] << permission
               end
             end
+
             response.status = 200
             response.body = {
               'requestId' => Fog::AWS::Mock.request_id,
@@ -96,6 +131,76 @@ module Fog
           end
         end
 
+        private
+
+        def verify_permission_options(options)
+          if options.empty?
+            raise Fog::Compute::AWS::Error.new("InvalidRequest => The request received was invalid.")
+          end
+          if options['IpProtocol'] && !['tcp', 'udp', 'icmp'].include?(options['IpProtocol'])
+            raise Fog::Compute::AWS::Error.new("InvalidPermission.Malformed => Unsupported IP protocol \"#{options['IpProtocol']}\"  - supported: [tcp, udp, icmp]")
+          end
+          if options['IpProtocol'] && (!options['FromPort'] || !options['ToPort'])
+            raise Fog::Compute::AWS::Error.new("InvalidPermission.Malformed => TCP/UDP port (-1) out of range")
+          end
+          if options.has_key?('IpPermissions')
+            if !options['IpPermissions'].is_a?(Array) || options['IpPermissions'].empty?
+              raise Fog::Compute::AWS::Error.new("InvalidRequest => The request received was invalid.")
+            end
+            options['IpPermissions'].each {|p| verify_permission_options(p) }
+          end
+        end
+
+        def normalize_permissions(options)
+          normalized_permissions = []
+
+          if options['SourceSecurityGroupName']
+            ['tcp', 'udp'].each do |protocol|
+              normalized_permissions << {
+                'ipProtocol' => protocol,
+                'fromPort' => 1,
+                'toPort' => 65535,
+                'groups' => [{'groupName' => options['SourceSecurityGroupName'], 'userId' => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id]}],
+                'ipRanges' => []
+              }
+            end
+            normalized_permissions << {
+              'ipProtocol' => 'icmp',
+              'fromPort' => -1,
+              'toPort' => -1,
+              'groups' => [{'groupName' => options['SourceSecurityGroupName'], 'userId' => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id]}],
+              'ipRanges' => []
+            }
+          elsif options['CidrIp']
+            normalized_permissions << {
+              'ipProtocol' => options['IpProtocol'],
+              'fromPort' => Integer(options['FromPort']),
+              'toPort' => Integer(options['ToPort']),
+              'groups' => [],
+              'ipRanges' => [{'cidrIp' => options['CidrIp']}]
+            }
+          elsif options['IpPermissions']
+            options['IpPermissions'].each do |permission|
+              normalized_permissions << {
+                'ipProtocol' => permission['IpProtocol'],
+                'fromPort' => Integer(permission['FromPort']),
+                'toPort' => Integer(permission['ToPort']),
+                'groups' => (permission['Groups'] || []).map {|g| {'groupName' => g['GroupName'], 'userId' => g['UserId'] || self.data[:owner_id]} },
+                'ipRanges' => (permission['IpRanges'] || []).map {|r| { 'cidrIp' => r['CidrIp'] } }
+              }
+            end
+          end
+
+          normalized_permissions
+        end
+
+        def find_matching_permission(group, permission)
+          group['ipPermissions'].detect {|group_permission|
+            permission['ipProtocol'] == group_permission['ipProtocol'] &&
+            permission['fromPort'] == group_permission['fromPort'] &&
+            permission['toPort'] == group_permission['toPort'] }
+        end
+
       end
     end
   end