aws-sdk-v1 1.52.0

data/lib/aws/ec2/snapshot_collection.rb

@@ -0,0 +1,131 @@
+# Copyright 2011-2013 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 Amazon EBS snapshots.  Typically
+    # you should get an instance of this class by calling
+    # {EC2#snapshots}.
+    #
+    # @example Create a snapshot from a volume
+    #   ec2.snapshots.create(:volume => ec2.volumes["vol-123"],
+    #                        :description => "my snapshot")
+    #   # or:
+    #   ec2.volumes["vol-123"].create_snapshot("my snapshot")
+    #
+    # @example Get a snapshot by ID
+    #   snapshot = ec2.snapshots["vol-123"]
+    #   snapshot.exists?
+    #
+    # @example Get a map of snapshot IDs to snapshot status
+    #   ec2.snapshots.inject({}) { |m, s| m[s.id] = s.status; m }
+    #   # => { "snap-12345678" => :pending, "snap-87654321" => :completed }
+    class SnapshotCollection < Collection
+
+      include TaggedCollection
+
+      # @api private
+      def initialize(options = {})
+        @owners = options[:owners] || []
+        @restorable_by = options[:restorable_by] || []
+        super(options)
+      end
+
+      # @yield [Snapshot] Yields each snapshot in the collection.
+      # @return [nil]
+      def each(&block)
+        opts = {}
+        opts[:owner_ids] = @owners.map { |id| id.to_s } unless @owners.empty?
+        opts[:restorable_by_user_ids] = @restorable_by.map { |id| id.to_s } unless
+          @restorable_by.empty?
+        resp = filtered_request(:describe_snapshots, opts)
+        resp[:snapshot_set].each do |details|
+          snapshot = Snapshot.new_from(:describe_snapshots, details,
+            details[:snapshot_id], :config => config)
+          yield(snapshot)
+        end
+        nil
+      end
+
+      # @return [SnapshotCollection] A new collection that only
+      #   includes snapshots owned by one or more of the specified AWS
+      #   accounts.  The IDs `:amazon` and `:self` can be used to
+      #   include snapshots owned by Amazon or AMIs owned by you,
+      #   respectively.
+      #
+      # @param [Array of Strings] owners The AWS account IDs by
+      #   which the new collection should be filtered.
+      def with_owner(*owners)
+        collection_with(:owners => @owners + owners)
+      end
+
+      # @return [ImageCollection] A new collection that only includes
+      #   images for which the specified user ID has explicit launch
+      #   permissions. The user ID can be an AWS account ID, `:self`
+      #   to return AMIs for which the sender of the request has
+      #   explicit launch permissions, or `:all` to return AMIs with
+      #   public launch permissions.
+      #
+      # @param [Array of Strings] users The AWS account IDs by which
+      #   the new collection should be filtered.
+      def restorable_by(*users)
+        collection_with(:restorable_by => @restorable_by + users)
+      end
+
+      # Creates a snapshot of an Amazon EBS volume and stores it in
+      # Amazon S3. You can use snapshots for backups, to make
+      # identical copies of instance devices, and to save data
+      # before shutting down an instance. For more information about
+      # Amazon EBS, go to the [Amazon Elastic Compute Cloud User Guide](http://docs.amazonwebservices.com/AWSEC2/latest/UserGuide/index.html?using-ebs.html).
+      #
+      # @return [Snapshot] An object representing the new snapshot.
+      #
+      # @param [Hash] opts Options for creating the snapshot.
+      #   Either `:volume` or `:volume_id` is required.
+      #
+      # @option opts [Volume] :volume The Amazon EBS volume of which
+      #   to take a snapshot.
+      #
+      # @option opts [String] :volume_id The ID of the Amazon EBS
+      #   volume of which to take a snapshot.
+      #
+      # @option opts [String] :description An optional description of
+      #   the snapshot.  May contain up to 255 characters.
+      #
+      # @return [Snapshot]
+      #
+      def create opts = {}
+        if volume = opts.delete(:volume)
+          opts[:volume_id] = volume.id
+        end
+        resp = client.create_snapshot(opts)
+        Snapshot.new(resp.snapshot_id, :config => config)
+      end
+
+      # @api private
+      protected
+      def member_class
+        Snapshot
+      end
+
+      # @api private
+      protected
+      def preserved_options
+        super.merge(:owners => @owners, :restorable_by => @restorable_by)
+      end
+
+    end
+
+  end
+end

data/lib/aws/ec2/subnet.rb

@@ -0,0 +1,161 @@
+# Copyright 2011-2013 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,
+        :from => :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.find{|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,119 @@
+# Copyright 2011-2013 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 an existing VPC. If you do not set an AvailabilityZone, then
+      # Amazon EC2 will select one for you (this is recommended).
+      #
+      # For complete information about creating subnets, see
+      # {http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-CreateSubnet.html
+      # CreateSubnet} in the Amazon EC2 API Reference.
+      #
+      # @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

data/lib/aws/ec2/tag.rb

@@ -0,0 +1,81 @@
+# Copyright 2011-2013 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 an EC2 tag.
+    # @attr [String] value The tag value.
+    class Tag < Resource
+
+      # @param [String] key The name of the tag
+      # @param [Hash] options
+      # @option options [String] :value ('') The optional value of the tag.
+      def initialize resource, key, options = {}
+        @resource = resource
+        @key = key.to_s
+        super
+      end
+
+      # @return [Object] The EC2 resource this tag belongs to.
+      attr_reader :resource
+
+      # @return [String] The name of this tag.
+      attr_reader :key
+
+      alias_method :name, :key
+
+      attribute :value
+
+      populates_from(:describe_tags) do |resp|
+        resp.tag_index[response_index_key]
+      end
+
+      # Deletes this tag.
+      # @return [nil]
+      def delete(value = nil)
+        tag_opts = { :key => key }
+        tag_opts[:value] = value if value
+        client.delete_tags(:resources => [resource.id], :tags => [tag_opts])
+        nil
+      end
+
+      # @api private
+      def inspect
+        "<#{self.class}:#{local_cache_key}>"
+      end
+
+      # @api private
+      def local_cache_key
+        response_index_key
+      end
+
+      private
+      def response_index_key
+        type = resource.tagging_resource_type
+        id = resource.send(:__resource_id__)
+        "#{type}:#{id}:#{key}"
+      end
+
+      protected
+      def get_resource attr
+        client.describe_tags(:filters => [
+          { :name => "key", :values => [key] },
+          { :name => "resource-type", :values => [resource.tagging_resource_type] },
+          { :name => "resource-id", :values => [resource.send(:__resource_id__)] }
+        ])
+      end
+
+    end
+  end
+end