aws_sdk 3.1.5

data/lib/aws/ec2/route_table.rb

@@ -0,0 +1,205 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'aws/ec2/route_table/route'
+require 'aws/ec2/route_table/association'
+
+module AWS
+  class EC2
+
+    class RouteTable < Resource
+
+      include TaggedItem
+
+      def initialize route_table_id, options = {}
+        @route_table_id = route_table_id
+        super
+      end
+
+      # @return [String]
+      attr_reader :route_table_id
+
+      alias_method :id, :route_table_id
+    
+      attribute :vpc_id, :static => true
+
+      attribute :route_set
+
+      protected :route_set
+
+      attribute :association_set
+
+      protected :association_set
+
+      populates_from(:create_route_table) do |resp|
+        resp.route_table if resp.route_table.route_table_id == route_table_id
+      end
+
+      populates_from(:describe_route_tables) do |resp|
+        resp.route_table_set.find{|t| t.route_table_id == route_table_id }
+      end
+
+      # @return [Boolean] Returns true if this is the main (default) 
+      #   route table.
+      def main?
+        @main = !!associations.find{|a| a.main? } if @main.nil?
+        @main
+      end
+
+      # @return [VPC] Returns the VPC this route table belongs to.
+      def vpc
+        VPC.new(vpc_id, :config => config)
+      end
+
+      # @return [Array<Subnet>] Returns an array of subnets ({Subnet}) 
+      #   that currently associated to this route table.
+      def subnets
+
+        subnets = associations.map(&:subnet)
+
+        # The default route table has a single association where #subnet
+        # returns nil (the main association).  If this is not the main
+        # route table we can safely return the subnets.  
+        return subnets unless subnets.include?(nil)
+
+        subnets.compact!
+
+        # This is the default route table and to get the complete list of
+        # subnets we have to find all subnets without an association
+        AWS.memoize do
+
+          # every subnet
+          all_subnets = vpc.subnets.to_a
+
+          # subnets assigned directly to a route table
+          associated_subnets = vpc.route_tables.  
+            map(&:associations).flatten.
+            map(&:subnet).flatten.
+            compact
+
+          # subnets NOT assigned to a route table, these default as
+          # belonging to the default route table through the "main" 
+          # association
+          unassociated_subnets = all_subnets.inject([]) do |list,subnet|
+            unless associated_subnets.include?(subnet)
+              list << subnet
+            end
+            list
+          end
+
+          subnets + unassociated_subnets
+
+        end
+
+      end
+
+      # @return [Array<RouteTable::Association>] Returns an array of 
+      #   {RouteTable::Association} objects (association to subnets).
+      def associations
+        association_set.collect do |details| 
+          Association.new(self, 
+            details[:route_table_association_id], 
+            details[:subnet_id])
+        end
+      end
+
+      # @return [Array<Route>] Returns an array of routes ({Route} objects) 
+      #   belonging to this route table.
+      def routes
+        route_set.map do |route_details|
+          Route.new(self, route_details)
+        end
+      end
+
+      # Creates a new route in this route route.  The route must be attached
+      # to a gateway, instance or network interface.
+      #
+      # @param [String] destination_cidr_block The CIDR address block 
+      #   used for the destination match. For example: 0.0.0.0/0. 
+      #   Routing decisions are based on the most specific match.
+      #
+      # @param [Hash] options
+      #
+      # @option options [InternetGateway,String] :internet_gateway
+      #   An {InternetGateway} object or an internet gateway id string to
+      #   attach the route to.
+      #
+      # @option options [Instance,String] :instance An {Instance} object
+      #   or instance id string to attach the route to.
+      #
+      # @option options [NetworkInterface,String] :network_interface
+      #   A {NetworkInterface} object or network interface id string to
+      #   attach the route to.
+      #
+      # @return [nil]
+      #
+      def create_route destination_cidr_block, options = {}
+        client.create_route(route_options(destination_cidr_block, options))
+        nil
+      end
+
+      # Replaces an existing route within a route table in a VPC.
+      # @param (see #create_route)
+      # @option (see #create_route)
+      # @return [nil]
+      def replace_route destination_cidr_block, options = {}
+        client.replace_route(route_options(destination_cidr_block, options))
+        nil
+      end
+
+      # @param [String] destination_cidr_block The CIDR block address of the
+      #   route to delete.
+      # @return [nil]
+      def delete_route destination_cidr_block
+        client.delete_route(route_options(destination_cidr_block))
+        nil
+      end
+
+      # Deletes this route table.  The route table must not be 
+      # associated with a subnet. You can't delete the main route table.
+      # @return [nil]
+      def delete
+        client.delete_route_table(:route_table_id => route_table_id)
+        nil
+      end
+
+      protected
+      
+      def route_options destination_cidr_block, options = {}
+
+        client_opts = {}
+        client_opts[:route_table_id] = route_table_id
+        client_opts[:destination_cidr_block] = destination_cidr_block
+
+        if gateway = options[:internet_gateway]
+          gateway = gateway.id if gateway.is_a?(InternetGateway)
+          client_opts[:gateway_id] = gateway
+        end
+
+        if instance = options[:instance]
+          instance = instance.id if instance.is_a?(Instance)
+          client_opts[:instance_id] = instance
+        end
+
+        if interface = options[:network_interface]
+          interface = interface.id if interface.is_a?(NetworkInterface)
+          client_opts[:network_interface_id] = interface
+        end
+
+        client_opts
+
+      end
+
+    end
+  end
+end

data/lib/aws/ec2/route_table/association.rb

@@ -0,0 +1,119 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class EC2
+    class RouteTable < Resource
+
+      # Represents the association between a {RouteTable} and a {Subnet}.
+      #
+      # You can get a route table association 2 ways:
+      #
+      # * enumerating associations from a route table
+      # * Asking a subnet for its route table association
+      #
+      # == Enumerating Associations
+      #
+      # Given a route table:
+      #
+      #   route_table.associations.each do |assoc|
+      #     if assoc.main? # main association does not have a subnet
+      #       puts "#{assoc.id} : main association"
+      #     else
+      #       puts "#{assoc.id} : #{assoc.subnet.id}"
+      #     end
+      #   end
+      #
+      # == Getting a Subnet Route Table Association
+      #
+      # All subnets are associated with a route table.  If the association
+      # was never explicitly created, then they are associated by default
+      # with the main route table.
+      #
+      #   subnet.route_table_association #=> AWS::EC2::RouteTable::Association
+      #
+      #   subnet.route_table_association.main? #=> true/false
+      #
+      # == Creating and Replacing a Route Table Association
+      #
+      # To replace a route table association start at the subnet end:
+      #
+      #   subnet.route_table = some_other_route_table
+      #
+      # If this route table is associated (by default) to the main route
+      # table via the main (default) association a new association is created.
+      # If it was previously associated directly to a different route table
+      # then that association will be repalced.
+      #
+      # == Deleting an Association
+      #
+      # You can delete all but the main route table association.  When you
+      # delete an association, the subnet becomes associated with the
+      # main route table.
+      #
+      #   # delete all explicit route table associations -- as a result 
+      #   # all subnets will default to the main route table
+      #   vpc.subnets.each do |subnet|
+      #     assoc = subnet.route_table_association
+      #     assoc.delete unless assoc.main?
+      #   end
+      #   
+      class Association
+
+        # @private
+        def initialize route_table, association_id, subnet_id
+          @route_table = route_table
+          @association_id = association_id
+          if subnet_id
+            @main = false
+            @subnet = Subnet.new(subnet_id,
+              :config => route_table.config)
+          else
+            @main = true
+          end
+        end
+
+        # @return [String] An identifier representing the association 
+        #   between the network ACL and subnet.
+        attr_reader :association_id
+
+        alias_method :id, :association_id
+
+        # @return [RouteTable]
+        attr_reader :route_table
+
+        # @return [Subnet,nil] Returns the subnet this association belongs.
+        #   If this is the main (default) association, then this method 
+        #   returns nil.
+        attr_reader :subnet
+
+        # @return [Boolean] Returns true if this association is the main
+        #   (default) association for all subnets within this route table's
+        #   VPC.
+        attr_reader :main
+
+        alias_method :main?, :main
+
+        # Deletes the association between the route table and the subnet
+        # @return [nil]
+        def delete
+          route_table.client.disassociate_route_table(
+            :association_id => association_id)
+          nil
+        end
+        alias_method :disassociate, :delete
+
+      end
+    end
+  end
+end

data/lib/aws/ec2/route_table/route.rb

@@ -0,0 +1,113 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class EC2
+
+    # Represents a single route in a {RouteTable}.
+    #
+    #   # enumerating routes within a route table
+    #   ec2 = AWS::EC2.new
+    #   route_table = ec2.route_tables.first
+    #   route_table.routes.each do |route|
+    #     # ...  
+    #   end
+    # 
+    class RouteTable < Resource
+      class Route
+
+        def initialize route_table, details
+
+          @route_table = route_table
+
+          @destination_cidr_block = details.destination_cidr_block
+
+          if details[:gateway_id]
+            @internet_gateway = InternetGateway.new(
+              details[:gateway_id],
+              :config => route_table.config)
+          end
+
+          if details[:instance_id]
+            @instance = Instance.new(details[:instance_id],
+              :vpc_id => route_table.vpc_id,
+              :owner_id => details[:instance_owner_id],
+              :config => route_table.config)
+          end
+
+          if details[:network_interface_id]
+            @network_interface = NetworkInterface.new(
+              details[:network_interface_id], 
+              :vpc_id => route_table.vpc_id,
+              :config => route_table.config)
+          end
+
+          @target = (internet_gateway || instance || network_interface)
+
+          @state = details.state.to_sym
+
+        end
+
+        # @return [RouteTable]
+        attr_reader :route_table
+
+        # @return [String] destination_cidr_block
+        attr_reader :destination_cidr_block
+
+        alias_method :cidr_block, :destination_cidr_block
+
+        # @return [InternetGateway,nil]
+        attr_reader :internet_gateway
+
+        # @return [Instance,nil]
+        attr_reader :instance
+
+        # @return [NetworkInterface,nil]
+        attr_reader :network_interface
+
+        # @return [Gateway,Instance,NetworkInterface] Returns the target
+        #   of this route table.  It will be a gateway id, instance or a
+        #   network interface.
+        attr_reader :target
+
+        # @return [Symbol] Returns the state (:active or :blackhole).
+        attr_reader :state
+
+        # @param [Hash] options
+        #
+        # @option options [Gateway,String] :gateway A gateway (object or
+        #   string id) to attach the route to.
+        #
+        # @option options [Instance,String] :instance An instance (object
+        #   or string id) to attach the route to.
+        #
+        # @option options [NetworkInterface,String] :network_interface
+        #   A network interface (object or string id) to attach the route
+        #   to.
+        #
+        # @return [nil]
+        #
+        def replace options = {}
+          route_table.replace_route(destination_cidr_block, options)
+        end
+
+        # Deletes this route.
+        # @return [nil]
+        def delete
+          route_table.delete_route(destination_cidr_block)
+        end
+
+      end
+    end
+  end
+end

data/lib/aws/ec2/route_table_collection.rb

@@ -0,0 +1,72 @@
+# Copyright 2011-2012 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class EC2
+
+    class RouteTableCollection < Collection
+
+      include TaggedCollection
+      include Core::Collection::Simple
+
+      # Creates a route table.
+      #
+      # @param [Hash] options
+      #
+      # @option options [VPC,String] :vpc The vpc or vpc id of where you want
+      #   to create the route table. 
+      #
+      # @return [RouteTable]
+      #
+      def create options = {}
+
+        client_opts = {}
+        client_opts[:vpc_id] = vpc_id_option(options)
+        
+        resp = client.create_route_table(client_opts)
+
+        RouteTable.new_from(:create_route_table, resp.route_table,
+          resp.route_table.route_table_id, :config => config)
+
+      end
+
+      # @param [String] route_table_id
+      # @return [RouteTable]
+      def [] route_table_id
+        RouteTable.new(route_table_id, :config => config)
+      end
+
+      # @return [RouteTable] Returns the main (default) route table.
+      #   This route table is automatically assigned to new subnets
+      #   and can not be deleted.
+      def main_route_table
+        @main = AWS.memoize { self.find {|rt| rt.main? } } if @main.nil?
+        @main
+      end
+
+      protected
+      def _each_item options = {}, &block
+        response = filtered_request(:describe_route_tables, options, &block)
+        response.route_table_set.each do |t|
+
+          route_table = RouteTable.new_from(:describe_route_tables, t, 
+            t.route_table_id, :config => config)
+
+          yield(route_table)
+
+        end
+      end
+
+    end
+  end
+end