fog-maestrodev 1.14.0.20130806165225 → 1.15.0.20130829165835

data/lib/fog/aws/models/compute/route_tables.rb

@@ -0,0 +1,92 @@
+require 'fog/core/collection'
+require 'fog/aws/models/compute/route_table'
+
+module Fog
+  module Compute
+    class AWS
+
+      class RouteTables < Fog::Collection
+
+        attribute :filters
+
+        model Fog::Compute::AWS::RouteTable
+
+        # Creates a new route table
+        #
+        # AWS.route_tables.new
+        #
+        # ==== Returns
+        #
+        # Returns the details of the new route table
+        #
+        #>> AWS.route_tables.new
+        # <Fog::Compute::AWS::RouteTable
+        # id=nil,
+        # vpc_id=nil,
+        # routes=nil,
+        # associations=nil,
+        # tags=nil
+        # >
+        #
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        # Returns an array of all route tables that have been created
+        #
+        # AWS.route_tables.all
+        #
+        # ==== Returns
+        #
+        # Returns an array of all route tables
+        #
+        #>> AWS.route_tables.all
+        # <Fog::Compute::AWS::RouteTables
+        # filters={}
+        # [
+        # <Fog::Compute::AWS::RouteTable
+        # id="rtb-41e8552f",
+        # TODO
+        # >
+        # ]
+        # >
+        #
+
+        def all(filters = filters)
+          unless filters.is_a?(Hash)
+            Fog::Logger.warning("all with #{filters.class} param is deprecated, use all('route-table-id' => []) instead [light_black](#{caller.first})[/]")
+            filters = {'route-table-id' => [*filters]}
+          end
+          self.filters = filters
+          data = service.describe_route_tables(filters).body
+          load(data['routeTableSet'])
+        end
+
+        # Used to retrieve a route table
+        # route_table_id is required to get the associated route table information.
+        #
+        # You can run the following command to get the details:
+        # AWS.route_tables.get("rtb-41e8552f")
+        #
+        # ==== Returns
+        #
+        #>> AWS.route_tables.get("rtb-41e8552f")
+        # <Fog::Compute::AWS::RouteTable
+        # id="rtb-41e8552f",
+        # TODO
+        # >
+        #
+
+        def get(route_table_id)
+          if route_table_id
+            self.class.new(:service => service).all('route-table-id' => route_table_id).first
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class RDS
+
+      class InstanceOption < Fog::Model
+
+        attribute :multi_az_capable, :aliases => 'MultiAZCapable', :type => :boolean
+        attribute :engine, :aliases => 'Engine'
+        attribute :license_model, :aliases => 'LicenseModel'
+        attribute :read_replica_capable, :aliases => 'ReadReplicaCapable', :type => :boolean
+        attribute :engine_version, :aliases => 'EngineVersion'
+        attribute :availability_zones, :aliases => 'AvailabilityZones', :type => :array
+        attribute :db_instance_class, :aliases => 'DBInstanceClass'
+        attribute :vpc, :aliases => 'Vpc', :type => :boolean
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/aws/models/rds/instance_option'
+
+module Fog
+  module AWS
+    class RDS
+
+      class InstanceOptions < Fog::PagedCollection
+        attribute :filters
+        attribute :engine
+        model Fog::AWS::RDS::InstanceOption
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        # This method deliberately returns only a single page of results
+        def all(filters=filters)
+          self.filters.merge!(filters)
+
+          result = service.describe_orderable_db_instance_options(engine, self.filters).body['DescribeOrderableDBInstanceOptionsResult']
+          self.filters[:marker] = result['Marker']
+          load(result['OrderableDBInstanceOptions'])
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/compute/associate_route_table.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Parsers
+    module Compute
+      module AWS
+
+        class AssociateRouteTable < Fog::Parsers::Base
+
+          def end_element(name)
+            case name
+            when 'requestId', 'associationId'
+              @response[name] = value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/compute/create_route_table.rb

@@ -0,0 +1,75 @@
+module Fog
+  module Parsers
+    module Compute
+      module AWS
+
+        class CreateRouteTable < Fog::Parsers::Base
+
+          def reset
+            @in_route_set = false
+            @in_association_set = false
+            @route = {}
+            @association = {}
+            @route_table = { 'routeSet' => [], 'tagSet' => {}, 'associationSet' => [] }
+            @response = { 'routeTable' => [] }
+            @tag = {}
+          end
+
+          def start_element(name, attrs = [])
+            super
+            case name
+            when 'tagSet'
+              @in_tag_set = true
+            when 'routeSet'
+              @in_route_set = true
+            when 'associationSet'
+              @in_association_set = true
+            end
+          end
+
+          def end_element(name)
+            if @in_tag_set
+              case name
+                when 'item'
+                  @route_table['tagSet'][@tag['key']] = @tag['value']
+                  @tag = {}
+                when 'tagSet'
+                  @in_tag_set = false
+              end
+            elsif @in_route_set
+              case name
+              when 'routeSet'
+                @in_route_set = false
+              when 'destinationCidrBlock', 'gatewayId', 'state'
+                @route[name] = value
+              when 'item'
+                @route_table['routeSet'] << @route
+                @route = {}
+              end
+            elsif @in_association_set
+              case name
+              when 'routeTableAssociationId', 'routeTableId', 'main'
+                @association[name] = value
+              when 'associationSet'
+                @route_table['associationSet'] << @association
+                @in_association_set = false
+              end
+            else
+              case name
+              when 'routeTableId', 'vpcId'
+                @route_table[name] = value
+              when 'routeTable'
+                @response['routeTable'] << @route_table
+                @route_table = { 'routeSet' => {}, 'tagSet' => {}, 'associationSet' => {} }
+              when 'requestId'
+                @response[name] = value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/fog/aws/parsers/compute/describe_account_attributes.rb

@@ -0,0 +1,42 @@
+module Fog
+  module Parsers
+    module Compute
+      module AWS
+
+        class DescribeAccountAttributes < Fog::Parsers::Base
+          def reset
+            @attribute = { 'values' => []}
+            @account_attributes = []
+            @response = { 'accountAttributeSet' => [] }
+          end
+
+          def start_element(name, attrs = [])
+            super
+            case name
+            when 'attributeValueSet'
+              @in_attribute_value_set = true
+            end
+          end
+
+          def end_element(name)
+            case name
+            when 'attributeName'
+              @attribute[name] = value
+            when 'attributeValue'
+              @attribute['values'] << value
+            when['requestId']
+              @response[name] = value
+            when 'item'
+              @response['accountAttributeSet'] << @attribute
+              @attribute = { 'values' => []} unless @in_attribute_value_set
+            when 'attributeValueSet'
+              @in_attribute_value_set = false
+            else
+            end
+            @response['accountAttributeSet'].uniq!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/compute/describe_route_tables.rb

@@ -0,0 +1,85 @@
+module Fog
+  module Parsers
+    module Compute
+      module AWS
+
+        class DescribeRouteTables < Fog::Parsers::Base
+
+          def reset
+            @association = { 'routeTableAssociationId' => nil, 'routeTableId' => nil, 'subnetId' => nil, 'main' => false }
+            @in_association_set = false
+            @in_route_set = false
+            @route = { 'destinationCidrBlock' => nil, 'gatewayId' => nil, 'instanceId' => nil, 'instanceOwnerId' => nil, 'networkInterfaceId' => nil, 'state' => nil, 'origin' => nil }
+            @response = { 'routeTableSet' => [] }
+            @tag = {}
+            @route_table = { 'associationSet' => [], 'tagSet' => {}, 'routeSet' => [] }
+          end
+
+          def start_element(name, attrs = [])
+            super
+            case name
+            when 'associationSet'
+              @in_association_set = true
+            when 'tagSet'
+              @in_tag_set = true
+            when 'routeSet'
+              @in_route_set = true
+            end
+          end
+
+          def end_element(name)
+            if @in_association_set
+              case name
+              when 'associationSet'
+                @in_association_set = false
+              when 'routeTableAssociationId', 'routeTableId', 'subnetId'
+                @association[name] = value
+              when 'main'
+                if value == 'true'
+                  @association[name] = true
+                else
+                  @association[name] = false
+                end
+              when 'item'
+                @route_table['associationSet'] << @association
+                @association = { 'routeTableAssociationId' => nil, 'routeTableId' => nil, 'subnetId' => nil, 'main' => false }
+              end
+            elsif @in_tag_set
+              case name
+              when 'key', 'value'
+                @tag[name] = value
+              when 'item'
+                @route_table['tagSet'][@tag['key']] = @tag['value']
+                @tag = {}
+              when 'tagSet'
+                @in_tag_set = false
+              end
+            elsif @in_route_set
+              case name
+              when 'destinationCidrBlock', 'gatewayId', 'instanceId', 'instanceOwnerId', 'networkInterfaceId', 'state', 'origin'
+                @route[name] = value
+              when 'item'
+                @route_table['routeSet'] << @route
+                @route = { 'destinationCidrBlock' => nil, 'gatewayId' => nil, 'instanceId' => nil, 'instanceOwnerId' => nil, 'networkInterfaceId' => nil, 'state' => nil, 'origin' => nil }
+              when 'routeSet'
+                @in_route_set = false
+              end
+            else
+              case name
+              when 'routeTableId', 'vpcId'
+                @route_table[name] = value
+              when 'item'
+                @response['routeTableSet'] << @route_table
+                @route_table = { 'associationSet' => [], 'tagSet' => {}, 'routeSet' => [] }
+              when 'requestId'
+                @response[name] = value
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Fog
+  module Parsers
+    module AWS
+      module RDS
+
+        class DescribeOrderableDBInstanceOptions < Fog::Parsers::Base
+
+          def reset
+            @response = { 'DescribeOrderableDBInstanceOptionsResult' => {'OrderableDBInstanceOptions' => []}, 'ResponseMetadata' => {} }
+            @db_instance_option = {}
+            @db_instance_options = []
+          end
+
+          def start_element(name, attrs = [])
+            case name
+            when 'AvailabilityZones' then @availability_zones = []
+            when 'AvailabilityZone' then @availability_zone = {}
+            end
+            super
+          end
+
+          def end_element(name)
+            case name
+            when 'MultiAZCapable', 'ReadReplicaCapable', 'Vpc' then @db_instance_option[name] = to_boolean(value)
+            when 'Engine', 'LicenseModel', 'EngineVersion', 'DBInstanceClass' then @db_instance_option[name] = value
+            when 'AvailabilityZones' then @db_instance_option[name] = @availability_zones
+            when 'AvailabilityZone' then @availability_zones << @availability_zone unless @availability_zone.empty?
+            when 'Name' then @availability_zone[name] = value
+            when 'ProvisionedIopsCapable' then @availability_zone[name] = to_boolean(value)
+            when 'OrderableDBInstanceOption'
+              @db_instance_options << @db_instance_option
+              @db_instance_option = {}
+            when 'OrderableDBInstanceOptions'
+              @response['DescribeOrderableDBInstanceOptionsResult']['OrderableDBInstanceOptions'] = @db_instance_options
+            when 'Marker' then @response['DescribeOrderableDBInstanceOptionsResult'][name] = value
+            when 'RequestId' then @response['ResponseMetadata'][name] = value
+            end
+          end
+
+          def to_boolean(v)
+            (v =~ /\A\s*(true|yes|1|y)\s*$/i) == 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/rds.rb

@@ -51,6 +51,8 @@ module Fog
       request :describe_db_subnet_groups
       # TODO: :delete_db_subnet_group, :modify_db_subnet_group
 
+      request :describe_orderable_db_instance_options
+
       request :describe_db_log_files
       request :download_db_logfile_portion
 
@@ -73,6 +75,9 @@ module Fog
       model       :subnet_group
       collection  :subnet_groups
 
+      model       :instance_option
+      collection  :instance_options
+
       model       :log_file
       collection  :log_files
 

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

@@ -111,7 +111,15 @@ module Fog
 
         def describe_auto_scaling_groups(options = {})
           results = { 'AutoScalingGroups' => [] }
-          self.data[:auto_scaling_groups].each do |asg_name, asg_data|
+          asg_set = self.data[:auto_scaling_groups]
+
+          if !options["AutoScalingGroupNames"].nil?
+            asg_set = asg_set.reject do |asg_name, asg_data|
+              ![*options["AutoScalingGroupNames"]].include?(asg_name)
+            end
+          end
+
+          asg_set.each do |asg_name, asg_data|
             results['AutoScalingGroups'] << {
               'AutoScalingGroupName' => asg_name
             }.merge!(asg_data)

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

@@ -76,7 +76,21 @@ module Fog
 
         def describe_policies(options = {})
           results = { 'ScalingPolicies' => [] }
-          self.data[:scaling_policies].each do |asp_name, asp_data|
+          policy_set = self.data[:scaling_policies]
+
+          for opt_key, opt_value in options
+            if opt_key == "PolicyNames" && opt_value != nil && opt_value != ""
+              policy_set = policy_set.reject do |asp_name, asp_data|
+                ![*options["PolicyNames"]].include?(asp_name)
+              end
+            elsif opt_key == "AutoScalingGroupName" && opt_value != nil && opt_value != ""
+              policy_set = policy_set.reject do |asp_name, asp_data|
+                options["AutoScalingGroupName"] != asp_data["AutoScalingGroupName"]
+              end
+            end
+          end
+
+          policy_set.each do |asp_name, asp_data|
             results['ScalingPolicies'] << {
               'PolicyName' => asp_name
             }.merge!(asp_data)

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

@@ -3,7 +3,7 @@ module Fog
     class AWS
       class Real
 
-        require 'fog/aws/parsers/compute/associate_dhcp_options'
+        require 'fog/aws/parsers/compute/basic'
         # 
         #
         # ==== Parameters
@@ -24,7 +24,7 @@ module Fog
             'DhcpOptionsId'        => dhcp_options_id,
             'VpcId'                => vpc_id,
             :idempotent   => true,
-            :parser       => Fog::Parsers::Compute::AWS::AttachInternetGateway.new
+            :parser       => Fog::Parsers::Compute::AWS::Basic.new
           )
         end
 

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

@@ -0,0 +1,75 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/associate_route_table'
+        # Associates a subnet with a route table.
+        #
+        # ==== Parameters
+        # * RouteTableId<~String> - The ID of the route table
+        # * SubnetId<~String> - The ID of the subnet
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - The ID of the request
+        #     * 'associationId'<~String> - The route table association ID (needed to disassociate the route table)
+        #
+        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-AssociateRouteTable.html]
+        def associate_route_table(routeTableId, subnetId)
+          request(
+            'Action'       => 'AssociateRouteTable',
+            'RouteTableId' => routeTableId,
+            'SubnetId'     => subnetId,
+            :parser        => Fog::Parsers::Compute::AWS::AssociateRouteTable.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def associate_route_table(routeTableId, subnetId)
+          routetable = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? routeTableId }
+          subnet = self.data[:subnets].find { |subnet| subnet["subnetId"].eql? subnetId }
+
+          if !routetable.nil? && !subnet.nil?
+            response = Excon::Response.new
+            response.status = 200
+            association = add_route_association(routeTableId, subnetId)
+            routetable["associationSet"].push(association)
+            response.body = {
+                'requestId'     => Fog::AWS::Mock.request_id,
+                'associationId' => association['routeTableAssociationId']
+            }
+            response
+          elsif routetable.nil?
+            raise Fog::Compute::AWS::NotFound.new("The routeTable ID '#{routeTableId}' does not exist")
+          else
+            raise Fog::Compute::AWS::NotFound.new("The subnet ID '#{subnetId}' does not exist")
+          end
+
+        end
+
+        private
+
+        def add_route_association(routeTableId, subnetId, main=nil)
+          response = {
+              "routeTableAssociationId" => "rtbassoc-#{Fog::Mock.random_hex(8)}", 
+              "routeTableId" => routeTableId,
+              "subnetId" => nil,
+              "main" => false
+            }
+          if main
+            response['main'] = true
+          else
+            response['subnetId'] = subnetId
+          end
+          response   
+        end
+        
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ module Fog
     class AWS
       class Real
 
-        require 'fog/aws/parsers/compute/attach_internet_gateway'
+        require 'fog/aws/parsers/compute/basic'
         # Attaches an Internet gateway to a VPC, enabling connectivity between the Internet and the VPC
         #
         # ==== Parameters
@@ -23,7 +23,7 @@ module Fog
             'InternetGatewayId'    => internet_gateway_id,
             'VpcId'                => vpc_id,
             :idempotent   => true,
-            :parser       => Fog::Parsers::Compute::AWS::AttachInternetGateway.new
+            :parser       => Fog::Parsers::Compute::AWS::Basic.new
           )
         end
 

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

@@ -0,0 +1,89 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/basic'
+
+        # Creates a route in a route table within a VPC.
+        #
+        # ==== Parameters
+        # * RouteTableId<~String> - The ID of the route table for the route.
+        # * DestinationCidrBlock<~String> - The CIDR address block used for the destination match. Routing decisions are based on the most specific match.
+        # * GatewayId<~String> - The ID of an Internet gateway attached to your VPC.
+        # * InstanceId<~String> - he ID of a NAT instance in your VPC. The operation fails if you specify an instance ID unless exactly one network interface is attached.
+        # * NetworkInterfaceId<~String> - The ID of a network interface.
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of the request
+        # * 'return'<~Boolean> - Returns true if the request succeeds. Otherwise, returns an error.
+        #
+        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-CreateRoute.html]
+        def create_route(route_table_id, destination_cidr_block, internet_gateway_id=nil, instance_id=nil, network_interface_id=nil)
+          request_vars = {
+            'Action'                => 'CreateRoute',
+            'RouteTableId'          => route_table_id,
+            'DestinationCidrBlock'  => destination_cidr_block,
+            :parser                 => Fog::Parsers::Compute::AWS::Basic.new
+          }
+          if internet_gateway_id
+            request_vars['GatewayId'] = internet_gateway_id
+          elsif instance_id
+            request_vars['InstanceId'] = instance_id
+          elsif network_interface_id
+            request_vars['NetworkInterfaceId'] = network_interface_id         
+          end
+          request(request_vars)
+        end
+      end
+
+      class Mock
+
+        def create_route(route_table_id, destination_cidr_block, internet_gateway_id=nil, instance_id=nil, network_interface_id=nil)
+          instance_owner_id = nil
+          route_table = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? route_table_id }
+          if !route_table.nil? && destination_cidr_block
+            if !internet_gateway_id.nil? || !instance_id.nil? || !network_interface_id.nil?
+              if !internet_gateway_id.nil? && self.internet_gateways.all('internet-gateway-id'=>internet_gateway_id).first.nil?
+                raise Fog::Compute::AWS::NotFound.new("The gateway ID '#{internet_gateway_id}' does not exist")
+              elsif !instance_id.nil? && self.servers.all('instance-id'=>instance_id).first.nil?
+                raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_id}' does not exist")
+              elsif !network_interface_id.nil? && self.network_interfaces.all('networkInterfaceId'=>network_interface_id).first.nil?
+                raise Fog::Compute::AWS::NotFound.new("The networkInterface ID '#{network_interface_id}' does not exist")
+              elsif !route_table['routeSet'].find { |route| route['destinationCidrBlock'].eql? destination_cidr_block }.nil?
+                raise Fog::Compute::AWS::Error, "RouteAlreadyExists => The route identified by #{destination_cidr_block} already exists."
+              else   
+                response = Excon::Response.new           
+                route_table['routeSet'].push({
+                  "destinationCidrBlock" => destination_cidr_block,
+                  "gatewayId" => internet_gateway_id,
+                  "instanceId"=>instance_id, 
+                  "instanceOwnerId"=>instance_owner_id, 
+                  "networkInterfaceId"=>network_interface_id, 
+                  "state" => "pending",
+                  "origin" => "CreateRoute"
+                })
+                response.status = 200
+                response.body = {
+                  'requestId'=> Fog::AWS::Mock.request_id,
+                  'return' => true
+                }
+                response
+              end
+            else
+              message = 'MissingParameter => '
+              message << 'The request must contain either a gateway id, a network interface id, or an instance id'
+              raise Fog::Compute::AWS::Error.new(message)
+            end
+          elsif route_table.nil?
+            raise Fog::Compute::AWS::NotFound.new("The routeTable ID '#{route_table_id}' does not exist")
+          elsif destination_cidr_block.empty?
+            raise Fog::Compute::AWS::InvalidParameterValue.new("Value () for parameter destinationCidrBlock is invalid. This is not a valid CIDR block.")
+          end
+        end        
+      end
+    end
+  end
+end