aws-sdk 1.3.5 → 1.3.6

data/lib/aws/ec2/route_table_collection.rb

@@ -0,0 +1,73 @@
+# 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.  This option is required if this 
+      #   collection does not have a populated vpc ({#vpc} returns nil).
+      #
+      # @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

data/lib/aws/ec2/security_group.rb

@@ -38,15 +38,17 @@ module AWS
 
       include TaggedItem
 
-      def initialize id, options = {}
-        @id = id
+      def initialize security_group_id, options = {}
+        @security_group_id = security_group_id
         super
       end
 
-      # @return [String] The ID of the security group.
-      attr_reader :id
+      # @return [String]
+      attr_reader :security_group_id
 
-      alias_method :group_id, :id
+      alias_method :group_id, :security_group_id
+
+      alias_method :id, :security_group_id
 
       attribute :name, :as => :group_name, :static => true
 
@@ -80,6 +82,14 @@ module AWS
         vpc_id ? true : false
       end
 
+      # @return [VPC,nil] Returns the VPC this security group belongs to,
+      #   or nil if this is not a VPC security group.
+      def vpc
+        if vpc_id
+          VPC.new(vpc_id, :config => config)
+        end
+      end
+
       # @return [SecurityGroup::IngressIpPermissionCollection] Returns a
       #   collection of {IpPermission} objects that represents all of
       #   the (ingress) permissions this security group has 

data/lib/aws/ec2/security_group_collection.rb

@@ -26,11 +26,13 @@ module AWS
       #   of this security group.  Accepts alphanumeric characters, spaces,
       #   dashes, and underscores. If left blank the description will be set
       #   to the name.
-      # @option options [String] :vpc_id (nil) The ID of a VPC to create
-      #   a security group in.  If this option is left blank then an 
-      #   EC2 security group is created.  If this option is provided a VPC
-      #   security group will be created.
+      #
+      # @option options [VPC,String] :vpc (nil) A VPC or VPC id string to 
+      #   create the security group in.  When specified a VPC security
+      #   group is created.
+      #
       # @return [SecurityGroup]
+      #
       def create name, options = {}
 
         description = options[:description] || name
@@ -38,14 +40,20 @@ module AWS
         create_opts = {}
         create_opts[:group_name] = name
         create_opts[:description] = description
-        create_opts[:vpc_id] = options[:vpc_id] if options[:vpc_id]
+
+        vpc_id = options[:vpc]
+        vpc_id ||= options[:vpc_id] # for backwards compatability
+        vpc_id ||= filter_value_for('vpc-id')
+        vpc_id = vpc_id.id if vpc_id.is_a?(VPC)
+
+        create_opts[:vpc_id] = vpc_id if vpc_id
 
         response = client.create_security_group(create_opts)
 
         SecurityGroup.new(response.group_id, {
           :name => name,
           :description => description,
-          :vpc_id => options[:vpc_id],
+          :vpc_id => create_opts[:vpc_id],
           :config => config })
 
       end
@@ -53,7 +61,7 @@ module AWS
       # @param [String] group_id The group id of a security group.
       # @return [SecurityGroup] The group with the given id.
       def [] group_id
-        super
+        SecurityGroup.new(group_id, :config => config)
       end
 
       # Specify one or more criteria to filter security groups by.
@@ -122,11 +130,6 @@ module AWS
         nil
       end
 
-      protected
-      def member_class
-        SecurityGroup
-      end
-
     end
   end
 end

data/lib/aws/ec2/subnet.rb

@@ -0,0 +1,161 @@
+# 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
+
+    # @attr_reader [String] vpc_id
+    #
+    # @attr_reader [Symbol] state
+    #
+    # @attr_reader [String] cidr_block
+    #
+    # @attr_reader [Integer] available_ip_address_count
+    #
+    # @attr_reader [String] availability_zone_name
+    #
+    class Subnet < Resource
+
+      include TaggedItem
+
+      def initialize subnet_id, options = {}
+        @subnet_id = subnet_id
+        super
+      end
+
+      # @return [String]
+      attr_reader :subnet_id
+
+      alias_method :id, :subnet_id
+
+      attribute :vpc_id, :static => true
+
+      attribute :state, :to_sym => true
+
+      attribute :cidr_block, :static => true
+
+      attribute :available_ip_address_count, :integer => true, :static => true
+
+      attribute :availability_zone_name,
+        :as => :availability_zone, :static => true
+
+      populates_from(:create_subnet) do |resp|
+        resp.subnet if resp.subnet.subnet_id == subnet_id
+      end
+
+      populates_from(:describe_subnets) do |resp|
+        resp.subnet_set.find{|s| s.subnet_id == subnet_id }
+      end
+
+      # @return [VPC] Returns the VPC this subnet belongs to.
+      def vpc
+        VPC.new(vpc_id, :config => config)
+      end
+
+      # @return [NetworkACL] Returns the network ACL currently assigned
+      #   to this subnet.
+      def network_acl
+        network_acl_association.network_acl
+      end
+
+      # Replaces the currently assigned network ACL with the passed one.
+      # @param [NetworkACL,String] network_acl A {NetworkACL} or network
+      #   ACL id to assign to this subnet.
+      def network_acl= network_acl
+        network_acl_association.replace_network_acl(network_acl)
+      end
+
+      # @return [NetworkACL::Association] Returns the association between
+      #   this subnet and its network ACL.
+      def network_acl_association
+        associations = AWS.memoize { vpc.network_acls.map(&:associations) }.flatten
+        associations.first{|a| a.subnet == self }
+      end
+
+      # @return [RouteTable] Returns the route table currently associated 
+      #   with this subnet.
+      def route_table
+        route_table_association.route_table
+      end
+
+      # Sets the route table for this subnet.  If there is already a
+      # route table associated with this subnet, that association
+      # is replaced.
+      #
+      # @param [RouteTable,String] route_Table A {RouteTable} object or
+      #   a route table id string.
+      #
+      # @return [RouteTable::Association]
+      #
+      def set_route_table route_table
+
+        unless route_table.is_a?(RouteTable)
+          route_table = RouteTable.new(route_table, :config => config)
+        end
+
+        client_opts = {}
+        client_opts[:route_table_id] = route_table.id
+
+        assoc = route_table_association
+
+        if assoc.main?
+          client_opts[:subnet_id] = subnet_id
+          response = client.associate_route_table(client_opts)
+          association_id = response.association_id 
+        else
+          client_opts[:association_id] = assoc.association_id
+          resp = client.replace_route_table_association(client_opts)
+          association_id = resp.new_association_id
+        end
+
+        RouteTable::Association.new(route_table, association_id, subnet_id)
+
+      end
+      alias_method :route_table=, :set_route_table
+
+      # @return [RouteTable::Association] Returns the association between
+      #   this subnet and its route table.
+      def route_table_association
+        assocs = AWS.memoize { vpc.route_tables.map(&:associations) }.flatten
+        assocs.find{|a| a.subnet == self } || assocs.find{|a| a.main? }
+      end
+
+      # See also {#availability_zone_name}.
+      # @return [AvailabilityZone]
+      def availability_zone
+        AvailabilityZone.new(availability_zone_name, :config => config)
+      end
+
+      # @return [InstanceCollection] Returns a filtered collection of
+      #   instances launched in this subnet.
+      def instances
+        InstanceCollection.new(:config => config).filter('subnet-id', id)
+      end
+
+      # @return [NetworkInterfaceCollection] Returns a collection that
+      #   represents all of the network interfaces for this subnet.
+      def network_interfaces
+        NetworkInterfaceCollection.new(:config => config).filter('subnet-id', id)
+      end
+
+      # Deletes the current subnet.  The subnet must be empty before it can
+      # be deleted.
+      # @return [nil]
+      def delete
+        client.delete_subnet(:subnet_id => subnet_id)
+        nil
+      end
+
+    end
+  end
+end

data/lib/aws/ec2/subnet_collection.rb

@@ -0,0 +1,115 @@
+# 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 collection of VPC subnets.  You can get a subnet collection
+    # two ways.  You can get a collection that represents ALL subnets (across
+    # all your VPCs).  You can also get a subnet collection that represents
+    # subnets within a single vpc.
+    #
+    #   # represents all subnets
+    #   subnets = ec2.subnets
+    #
+    #   # represents subnets within the named vpc
+    #   subnets = ec2.vpcs['vpc-12345'].subnets
+    #
+    # == Creating a Subnet
+    #
+    # To create a subnet, call {#create} on a subnet collection, passing in
+    # a suitable CIDR block.
+    #
+    #   subnet = subnets.create('10.0.0.0/20')
+    #
+    # You can optionally pass the availability zone you want the subnet
+    # created in.
+    #
+    # == Getting a Subnet
+    #
+    # If you know the subnet id, you can get a subnet using {#[]}.
+    #
+    #   subnet = subnets['subnet-id-here']
+    #
+    # You can filter subnets as well.  See the EC2 API documentation 
+    # (http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeSubnets.html) for a complete list of accepted filters.
+    #
+    #   subnet = subnets.filter('state', 'available').first
+    #
+    class SubnetCollection < Collection
+
+      include TaggedCollection
+      include Core::Collection::Simple
+
+      # Creates a Subnet.  Subnets require a valid CIDR block and
+      # are created inside a VPC.  If this collection does not
+      # have a 
+      #
+      # @param [String] cidr_block The CIDR block you want the subnet to
+      #   cover (e.g., 10.0.0.0/24).
+      #
+      # @param [Hash] options
+      #
+      # @option options [VPC,String] :vpc The VPC (or VPC id string) to
+      #   create the subnet in.
+      #
+      # @option options [String,AvailabilityZone] :availability_zone 
+      #   The Availability Zone you want the subnet in. 
+      #   AWS selects a default zone for you (recommended).
+      #
+      # @return [Subnet]
+      #
+      def create cidr_block, options = {}
+
+        client_opts = {}
+        client_opts[:vpc_id] = vpc_id_option(options)
+        client_opts[:cidr_block] = cidr_block
+        client_opts[:availability_zone] = az_option(options) if 
+          options[:availability_zone]
+
+        resp = client.create_subnet(client_opts)
+
+        Subnet.new_from(:create_subnet, resp.subnet, 
+          resp.subnet.subnet_id, :config => config)
+
+      end
+
+      # @param [String] subnet_id
+      # @return [Subnet] Returns a subnet with the given id.
+      def [] subnet_id
+        Subnet.new(subnet_id, :config => config)
+      end
+
+      protected
+      def az_option options
+        options[:availability_zone].is_a?(AvailabilityZone) ?
+          options[:availability_zone].name : 
+          options[:availability_zone]
+      end
+
+      protected
+      def _each_item options = {}, &block
+        response = filtered_request(:describe_subnets, options, &block)
+        response.subnet_set.each do |s|
+
+          subnet = Subnet.new_from(:describe_subnets, 
+            s, s.subnet_id, :config => config)
+
+          yield(subnet)
+
+        end
+      end
+
+    end
+  end
+end