fog 0.11.0 → 1.0.0

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

@@ -15,7 +15,7 @@ module Fog
         # * 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) 
+        # * Dimensions<~Array>: a list of dimensions to filter against (optional)
         #     Name : The name of the dimension
         #     Value : The value to filter against
         # ==== Returns
@@ -30,7 +30,7 @@ module Fog
           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']}))

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

@@ -8,7 +8,7 @@ module Fog
         # List availabe metrics
         #
         # ==== Options
-        # * Dimensions<~Array>: a list of dimensions to filter against, 
+        # * 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

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

@@ -10,7 +10,7 @@ module Fog
         # * 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 
+        #     * 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>:
@@ -27,10 +27,10 @@ module Fog
         # ==== 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')
@@ -45,14 +45,14 @@ module Fog
           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|

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

@@ -0,0 +1,53 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/allocate_address'
+
+        # Acquire an elastic IP address.
+        #
+        # ==== 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
+          request(
+            'Action'  => 'AllocateAddress',
+            :parser   => Fog::Parsers::Compute::AWS::AllocateAddress.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def allocate_address
+          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
+            }
+            self.data[:addresses][public_ip] = data
+            response.body = {
+              'publicIp'  => public_ip,
+              '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

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

@@ -0,0 +1,67 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/basic'
+
+        # Associate an elastic IP address with an instance
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Id of instance to associate address with
+        # * public_ip<~String> - Public ip to assign to instance
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AssociateAddress.html]
+        def associate_address(instance_id, public_ip)
+          request(
+            'Action'      => 'AssociateAddress',
+            'InstanceId'  => instance_id,
+            'PublicIp'    => public_ip,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::Compute::AWS::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def associate_address(instance_id, public_ip)
+          response = Excon::Response.new
+          response.status = 200
+          instance = self.data[:instances][instance_id]
+          address = self.data[:addresses][public_ip]
+          if instance && address
+            if current_instance = self.data[:instances][address['instanceId']]
+              current_instance['ipAddress'] = current_instance['originalIpAddress']
+            end
+            address['instanceId'] = instance_id
+            # detach other address (if any)
+            if self.data[:addresses][instance['ipAddress']]
+              self.data[:addresses][instance['ipAddress']]['instanceId'] = nil
+            end
+            instance['ipAddress'] = public_ip
+            instance['dnsName'] = Fog::AWS::Mock.dns_name_for(public_ip)
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          elsif !instance
+            raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_id}' does not exist")
+          elsif !address
+            raise Fog::Compute::AWS::Error.new("AuthFailure => The address '#{public_ip}' does not belong to you.")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/attach_volume'
+
+        # Attach an Amazon EBS volume with a running instance, exposing as specified device
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Id of instance to associate volume with
+        # * volume_id<~String> - Id of amazon EBS volume to associate with instance
+        # * device<~String> - Specifies how the device is exposed to the instance (e.g. "/dev/sdh")
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'attachTime'<~Time> - Time of attachment was initiated at
+        #     * 'device'<~String> - Device as it is exposed to the instance
+        #     * 'instanceId'<~String> - Id of instance for volume
+        #     * 'requestId'<~String> - Id of request
+        #     * 'status'<~String> - Status of volume
+        #     * 'volumeId'<~String> - Reference to volume
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AttachVolume.html]
+        def attach_volume(instance_id, volume_id, device)
+          request(
+            'Action'      => 'AttachVolume',
+            'VolumeId'    => volume_id,
+            'InstanceId'  => instance_id,
+            'Device'      => device,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::Compute::AWS::AttachVolume.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def attach_volume(instance_id, volume_id, device)
+          response = Excon::Response.new
+          if instance_id && volume_id && device
+            response.status = 200
+            instance = self.data[:instances][instance_id]
+            volume = self.data[:volumes][volume_id]
+            if instance && volume
+              unless volume['status'] == 'available'
+                raise Fog::Compute::AWS::Error.new("Client.VolumeInUse => Volume #{volume_id} is unavailable")
+              end
+
+              data = {
+                'attachTime'  => Time.now,
+                'device'      => device,
+                'instanceId'  => instance_id,
+                'status'      => 'attaching',
+                'volumeId'    => volume_id
+              }
+              volume['attachmentSet'] = [data]
+              volume['status'] = 'attaching'
+              response.status = 200
+              response.body = {
+                'requestId' => Fog::AWS::Mock.request_id
+              }.merge!(data)
+              response
+            elsif !instance
+              raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_id}' does not exist.")
+            elsif !volume
+              raise Fog::Compute::AWS::NotFound.new("The volume '#{volume_id}' does not exist.")
+            end
+          else
+            message = 'MissingParameter => '
+            if !instance_id
+              message << 'The request must contain the parameter instance_id'
+            elsif !volume_id
+              message << 'The request must contain the parameter volume_id'
+            else
+              message << 'The request must contain the parameter device'
+            end
+            raise Fog::Compute::AWS::Error.new(message)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/basic'
+
+        # Add permissions to a security group
+        #
+        # ==== Parameters
+        # * group_name<~String> - Name of group
+        # * options<~Hash>:
+        #   * '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)
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        #
+        # {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})[/]")
+            options = group_name
+            group_name = options['GroupName']
+          end
+          request({
+            'Action'    => 'AuthorizeSecurityGroupIngress',
+            'GroupName' => group_name,
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::Basic.new
+          }.merge!(options))
+        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})[/]")
+            options = group_name
+            group_name = options['GroupName']
+          end
+
+          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
+                }
+              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
+            end
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/cancel_spot_instance_requests'
+
+        # Terminate specified spot instance requests
+        #
+        # ==== Parameters
+        # * spot_instance_request_id<~Array> - Ids of instances to terminates
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> id of request
+        #     * 'spotInstanceRequestSet'<~Array>:
+        #       * 'spotInstanceRequestId'<~String> - id of cancelled spot instance
+        #       * 'state'<~String> - state of cancelled spot instance
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CancelSpotInstanceRequests.html]
+        def cancel_spot_instance_requests(spot_instance_request_id)
+          params = Fog::AWS.indexed_param('SpotInstanceRequestId', spot_instance_request_id)
+          request({
+            'Action'    => 'CancelSpotInstanceRequests',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::CancelSpotInstanceRequests.new
+          }.merge!(params))
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/create_image'
+
+        # Create a bootable EBS volume AMI
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Instance used to create image.
+        # * name<~Name> - Name to give image.
+        # * description<~Name> - Description of image.
+        # * no_reboot<~Boolean> - Optional, whether or not to reboot the image when making the snapshot
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'imageId'<~String> - The ID of the created AMI.
+        #     * 'requestId'<~String> - Id of request.
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateImage.html]
+        def create_image(instance_id, name, description, no_reboot = false)
+          request(
+            'Action'            => 'CreateImage',
+            'InstanceId'        => instance_id,
+            'Name'              => name,
+            'Description'       => description,
+            'NoReboot'          => no_reboot.to_s,
+            :parser             => Fog::Parsers::Compute::AWS::CreateImage.new
+          )
+        end
+      end
+
+      class Mock
+        
+        # Usage
+        # 
+        # AWS[:compute].create_image("i-ac65ee8c", "test", "something")
+        #
+        
+        def create_image(instance_id, name, description, no_reboot = false)
+          response = Excon::Response.new
+          if instance_id && !name.empty?
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'imageId' => Fog::AWS::Mock.image_id
+            }
+          else
+            response.status = 400
+            response.body = {
+              'Code' => 'InvalidParameterValue'
+            }
+            if name.empty?
+              response.body['Message'] = "Invalid value '' for name. Must be specified."
+            end
+          end
+          response
+        end
+
+      end
+    end
+  end
+end