fog 0.6.0 → 0.7.0

data/lib/fog/aws/parsers/rds/restore_db_instance_to_point_in_time.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Parsers
+    module AWS
+      module RDS
+
+        require 'fog/aws/parsers/rds/db_parser'
+
+        class RestoreDBInstanceToPointInTime < Fog::Parsers::AWS::RDS::DbParser
+
+          def reset
+            @response = { 'RestoreDBInstanceToPointInTime' => {}, 'ResponseMetadata' => {} }
+            super
+          end
+
+          def start_element(name, attrs = [])
+            super
+          end
+
+          def end_element(name)
+            case name
+            when 'DBInstance'
+              @response['RestoreDBInstanceToPointInTime']['DBInstance'] = @db_instance
+              @db_instance = fresh_instance
+            when 'RequestId'
+              @response['ResponseMetadata'][name] = @value
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/fog/aws/parsers/rds/revoke_db_security_group_ingress.rb

@@ -0,0 +1,39 @@
+module Fog
+  module Parsers
+    module AWS
+      module RDS
+
+        require 'fog/aws/parsers/rds/security_group_parser'
+
+        class RevokeDBSecurityGroupIngress < Fog::Parsers::AWS::RDS::SecurityGroupParser
+
+          def reset
+            @response = { 'RevokeDBSecurityGroupIngressResult' => {}, 'ResponseMetadata' => {} }
+            super
+          end
+
+          def start_element(name, attrs = [])
+            super
+          end
+
+          def end_element(name)
+            case name
+            when 'DBSecurityGroup' then
+              @response['RevokeDBSecurityGroupIngressResult']['DBSecurityGroup'] = @security_group
+              @security_group = fresh_security_group
+            when 'RequestId'
+              @response['ResponseMetadata'][name] = @value
+            else
+              super
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end
+
+

data/lib/fog/aws/parsers/rds/security_group_parser.rb

@@ -0,0 +1,39 @@
+module Fog
+  module Parsers
+    module AWS
+      module RDS
+
+        class SecurityGroupParser < Fog::Parsers::Base
+
+          def reset
+            @security_group = fresh_security_group
+          end
+
+          def fresh_security_group
+            {'EC2SecurityGroups' => [], 'IPRanges' => []}
+          end
+
+          def start_element(name, attrs = [])
+            super
+            case name
+            when 'EC2SecurityGroup', 'IPRange'; then @ingress = {}
+            end
+
+          end
+
+          def end_element(name)
+            case name
+            when 'DBSecurityGroupDescription' then @security_group['DBSecurityGroupDescription'] = @value
+            when 'DBSecurityGroupName' then @security_group['DBSecurityGroupName'] = @value
+            when 'OwnerId' then @security_group['OwnerId'] = @value
+            when 'EC2SecurityGroup', 'IPRange'
+              @security_group["#{name}s"] << @ingress unless @ingress.empty?
+            when 'EC2SecurityGroupName', 'EC2SecurityGroupOwnerId', 'CIDRIP', 'Status'
+              @ingress[name] = @value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/rds/snapshot_parser.rb

@@ -0,0 +1,40 @@
+module Fog
+  module Parsers
+    module AWS
+      module RDS
+
+        class SnapshotParser < Fog::Parsers::Base
+
+          def reset
+            @db_snapshot = fresh_snapshot
+          end
+          
+          def fresh_snapshot
+            {}
+          end
+
+          def start_element(name, attrs = [])
+            super
+            
+          end
+
+          def end_element(name)
+            case name
+            when 'AllocatedStorage' then @db_snapshot['AllocatedStorage'] = @value.to_i
+            when 'AvailabilityZone' then @db_snapshot['AvailabilityZone'] = @value
+            when 'DBInstanceIdentifier' then @db_snapshot['DBInstanceIdentifier'] = @value
+            when 'DBSnapshotIdentifier' then @db_snapshot['DBSnapshotIdentifier'] = @value
+            when 'Engine' then @db_snapshot['Engine'] = @value
+            when 'EngineVersion' then @db_snapshot['EngineVersion'] = @value
+            when 'InstanceCreateTime' then @db_snapshot['InstanceCreateTime'] = Time.parse @value
+            when 'MasterUsername' then @db_snapshot['MasterUsername'] = @value
+            when 'Port' then @db_snapshot['Port'] = @value.to_i
+            when 'SnapshotCreateTime' then @db_snapshot['SnapshotCreateTime'] = Time.parse @value
+            when 'Status' then @db_snapshot['Status'] = @value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/rds.rb

@@ -0,0 +1,161 @@
+module Fog
+  module AWS
+    class RDS < Fog::Service
+
+      class NotFound < Fog::Errors::Error; end
+      class IdentifierTaken < Fog::Errors::Error; end
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :region, :host, :path, :port, :scheme, :persistent
+
+      request_path 'fog/aws/requests/rds'
+
+      request :create_db_instance
+      request :modify_db_instance
+      request :describe_db_instances
+      request :delete_db_instance
+      request :reboot_db_instance
+      request :create_db_instance_read_replica
+
+      request :describe_db_snapshots
+      request :create_db_snapshot
+      request :delete_db_snapshot
+
+
+      request :create_db_parameter_group
+      request :delete_db_parameter_group
+      request :modify_db_parameter_group
+      request :describe_db_parameter_groups
+
+      request :describe_db_security_groups
+      request :create_db_security_group
+      request :delete_db_security_group
+      request :authorize_db_security_group_ingress
+      request :revoke_db_security_group_ingress
+
+      request :describe_db_parameters
+
+      request :restore_db_instance_from_db_snapshot
+      request :restore_db_instance_to_point_in_time
+
+      model_path 'fog/aws/rds/models'
+      model       :server
+      collection  :servers
+      model       :snapshot
+      collection  :snapshots
+      model       :parameter_group
+      collection  :parameter_groups
+
+      model       :parameter
+      collection  :parameters
+
+      model       :security_group
+      collection  :security_groups
+
+      class Mock
+
+        def initialize(options={})
+        end
+
+      end
+
+      class Real
+
+        # Initialize connection to ELB
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   elb = ELB.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 {}.
+        #   * region<~String> - optional region to use, in ['eu-west-1', 'us-east-1', 'us-west-1'i, 'ap-southeast-1']
+        #
+        # ==== Returns
+        # * ELB object with connection to AWS.
+        def initialize(options={})
+          @aws_access_key_id      = options[:aws_access_key_id]
+          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
+
+          options[:region] ||= 'us-east-1'
+          @host = options[:host] || case options[:region]
+          when 'ap-northeast-1'
+            'rds.ap-northeast-1.amazonaws.com'
+          when 'ap-southeast-1'
+            'rds.ap-southeast-1.amazonaws.com'
+          when 'eu-west-1'
+            'rds.eu-west-1.amazonaws.com'
+          when 'us-east-1'
+            'rds.us-east-1.amazonaws.com'
+          when 'us-west-1'
+            'rds.us-west-1.amazonaws.com'
+          else
+            raise ArgumentError, "Unknown region: #{options[:region].inspect}"
+          end
+          @path       = options[:path]      || '/'
+          @port       = options[:port]      || 443
+          @scheme     = options[:scheme]    || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        private
+
+        def request(params)
+          idempotent  = params.delete(:idempotent)
+          parser      = params.delete(:parser)
+
+          body = AWS.signed_params(
+            params,
+            {
+              :aws_access_key_id  => @aws_access_key_id,
+              :hmac               => @hmac,
+              :host               => @host,
+              :path               => @path,
+              :port               => @port,
+              :version            => '2010-07-28'
+            }
+          )
+
+          begin
+            response = @connection.request({
+              :body       => body,
+              :expects    => 200,
+              :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+              :idempotent => idempotent,
+              :host       => @host,
+              :method     => 'POST',
+              :parser     => parser
+            })
+          rescue Excon::Errors::HTTPStatusError => error
+            if match = error.message.match(/<Code>(.*)<\/Code>[\s\\\w]+<Message>(.*)<\/Message>/m)
+              case match[1].split('.').last
+              when 'DBInstanceNotFound', 'DBParameterGroupNotFound', 'DBSnapshotNotFound'
+                raise Fog::AWS::RDS::NotFound.slurp(error, match[2])
+              when 'DBParameterGroupAlreadyExists'
+                raise Fog::AWS::RDS::IdentifierTaken.slurp(error, match[2])
+              else
+                raise
+              end
+            else
+              raise
+            end
+          end
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/rds/models/parameter.rb

@@ -0,0 +1,21 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class RDS
+      
+      class Parameter < Fog::Model
+
+        attribute  :name, :aliases => ['ParameterName']
+        attribute  :data_type, :aliases => 'DataType'
+        attribute  :description, :aliases => 'Description'
+        attribute  :allowed_values, :aliases => 'AllowedValues'
+        attribute  :source, :aliases => 'Source'
+        attribute  :modifiable, :aliases => 'IsModifiable'
+        attribute  :apply_type, :aliases => 'ApplyType'
+        attribute  :value, :aliases => 'ParameterValue'
+        
+      end
+    end
+  end
+end

data/lib/fog/aws/rds/models/parameter_group.rb

@@ -0,0 +1,36 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class RDS
+      
+      class ParameterGroup < Fog::Model
+
+        identity  :id, :aliases => ['DBParameterGroupName', :name]
+        attribute  :family, :aliases => 'DBParameterGroupFamily'
+        attribute  :description, :aliases => 'Description'
+        
+        def save
+          requires :family
+          requires :description
+          requires :id
+          connection.create_db_parameter_group(id, family, description)
+        end
+        
+        def modify(changes)
+          connection.modify_db_parameter_group id, changes.collect {|c| {'ParameterName' => c[:name], 'ParameterValue' => c[:value], 'ApplyMethod' => c[:apply_method]}}
+        end
+        
+        def destroy
+          requires :id
+          connection.delete_db_parameter_group(id)
+          true
+        end
+        
+        def parameters(filters={})
+          connection.parameters({:group => self}.merge(filters))
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/rds/models/parameter_groups.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/aws/rds/models/parameter_group'
+
+module Fog
+  module AWS
+    class RDS
+
+      class ParameterGroups < Fog::Collection
+
+        model Fog::AWS::RDS::ParameterGroup
+
+        def all
+          data = connection.describe_db_parameter_groups.body['DescribeDBParameterGroupsResult']['DBParameterGroups']
+          load(data) # data is an array of attribute hashes
+        end
+
+        def get(identity)
+          data = connection.describe_db_parameter_groups(identity).body['DescribeDBParameterGroupsResult']['DBParameterGroups'].first
+          new(data) # data is an attribute hash
+        rescue Fog::AWS::RDS::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/rds/models/parameters.rb

@@ -0,0 +1,37 @@
+require 'fog/core/collection'
+require 'fog/aws/rds/models/parameter'
+
+module Fog
+  module AWS
+    class RDS
+
+      class Parameters < Fog::Collection
+        attribute :group
+        attribute :filters
+        model Fog::AWS::RDS::Parameter
+
+        def initialize(attributes)
+          self.filters ||= {}
+          if attributes[:source]
+            filters[:source] = attributes[:source]
+          end
+          super
+        end
+
+        def all(filters = filters)
+          self.filters = filters
+          result = []
+          marker = nil
+          finished = false
+          while !finished
+            data = connection.describe_db_parameters(group.id, filters.merge(:marker => marker)).body
+            result.concat(data['DescribeDBParametersResult']['Parameters'])
+            marker = data['DescribeDBParametersResult']['Marker']
+            finished = marker.nil?
+          end
+          load(result) # data is an array of attribute hashes
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/rds/models/security_group.rb

@@ -0,0 +1,73 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class RDS
+
+      class SecurityGroup < Fog::Model
+
+        identity   :id, :aliases => ['DBSecurityGroupName']
+        attribute  :description, :aliases => 'DBSecurityGroupDescription'
+        attribute  :ec2_security_groups, :aliases => 'EC2SecurityGroups', :type => :array
+        attribute  :ip_ranges, :aliases => 'IPRanges', :type => :array
+        attribute  :owner_id, :aliases => 'OwnerId'
+
+        def ready?
+          (ec2_security_groups + ip_ranges).all?{|ingress| ingress['Status'] == 'authorized'}
+        end
+
+        def destroy
+          requires :id
+          connection.delete_db_security_group(id)
+          true
+        end
+
+        def save
+          requires :id
+          requires :description
+
+          data = connection.create_db_security_group(id, description).body['CreateDBSecurityGroupResult']['DBSecurityGroup']
+          merge_attributes(data)
+          true
+        end
+
+        # group_owner_id defaults to the current owner_id
+        def authorize_ec2_security_group(group_name, group_owner_id=owner_id)
+          authorize_ingress({
+            'EC2SecurityGroupName' => group_name,
+            'EC2SecurityGroupOwnerId' => group_owner_id
+          })
+        end
+
+        def authorize_cidrip(cidrip)
+          authorize_ingress({'CIDRIP' => cidrip})
+        end
+
+        def authorize_ingress(opts)
+          data = connection.authorize_db_security_group_ingress(id, opts).body['AuthorizeDBSecurityGroupIngressResult']['DBSecurityGroup']
+          merge_attributes(data)
+        end
+
+        # group_owner_id defaults to the current owner_id
+        def revoke_ec2_security_group(group_name, group_owner_id=owner_id)
+          revoke_ingress({
+            'EC2SecurityGroupName' => group_name,
+            'EC2SecurityGroupOwnerId' => group_owner_id
+          })
+        end
+
+        def revoke_cidrip(cidrip)
+          revoke_ingress({'CIDRIP' => cidrip})
+        end
+
+        def revoke_ingress(opts)
+          data = connection.revoke_db_security_group_ingress(id, opts).body['RevokeDBSecurityGroupIngressResult']['DBSecurityGroup']
+          merge_attributes(data)
+        end
+
+
+
+      end
+    end
+  end
+end