aws-sdk-v1 1.52.0

data/lib/aws/ec2/security_group/ip_permission.rb

@@ -0,0 +1,135 @@
+# 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
+    class SecurityGroup < Resource
+      class IpPermission
+
+        include Core::Model
+
+        # @param protocol [:tcp, :udp, :icmp]
+        #
+        # @param [Integer,Range<Integer>] ports A port or port range to allow.
+        #
+        # @param [Hash] options
+        #
+        # @option options [Array] :ip_ranges An array of CIDR ip address
+        #   to grant permission to.
+        #
+        # @option options [Array] :groups An array of SecurityGroup objects to
+        #   grant permission to.
+        #
+        # @option options [Boolean] :egress (false) When true this IpPermission
+        #   is assumed to be an egress permission.
+        #
+        def initialize security_group, protocol, ports, options = {}
+
+          @security_group = security_group
+
+          @protocol = protocol == '-1' ?  :any : protocol.to_s.downcase.to_sym
+
+          @ip_ranges = Array(options[:ip_ranges])
+
+          @groups = Array(options[:groups])
+
+          @egress = options[:egress] || false
+
+          # not all egress permissions require port ranges, depends on the
+          # protocol
+          if ports
+            if ports.is_a?(Range)
+              @port_range = ports
+            else
+              @port_range = Array(ports).first.to_i..Array(ports).last.to_i
+            end
+          end
+
+          super
+
+        end
+
+        # @return [SecurityGroup] The security group this permission is
+        #   authorized for.
+        attr_reader :security_group
+
+        # @return [Symbol] The protocol (:tcp, :udp, :icmp)
+        attr_reader :protocol
+
+        # @return [Range] The port range (e.g. 80..80, 4000..4010, etc)
+        attr_reader :port_range
+
+        # @return [Array] An array of string CIDR ip addresses.
+        attr_reader :ip_ranges
+
+        # @return [Array] An array of security groups that have been
+        #   granted access with this permission.
+        attr_reader :groups
+
+        # @return [Boolean] True if this is an egress permission
+        attr_reader :egress
+
+        # @return [Boolean] Returns true if this is an egress permission.
+        def egress?
+          @egress ? true : false
+        end
+
+        # Authorizes this permission from its security group.
+        # @return [IpPermission] Returns self
+        def authorize
+          update_sg(egress? ? :authorize_egress : :authorize_ingress)
+        end
+
+        # Revokes this permission from its security group.
+        # @return [IpPermission] Returns self
+        def revoke
+          update_sg(egress? ? :revoke_egress : :revoke_ingress)
+        end
+
+        # @return [Boolean] Returns true if the other IpPermission matches
+        #   this one.
+        def eql? other
+          other.is_a?(IpPermission) and
+          other.security_group == security_group and
+          other.protocol == protocol and
+          other.port_range == port_range and
+          other.ip_ranges.sort == ip_ranges.sort and
+          other.groups.sort == groups.sort and
+          other.egress? == egress?
+        end
+        alias_method :==, :eql?
+
+        protected
+        def update_sg method
+
+          sources = []
+          sources += ip_ranges
+          sources += groups
+
+          if egress?
+            opts = {}
+            opts[:protocol] = protocol
+            opts[:ports] = port_range if port_range
+            sources << opts
+            security_group.send(method, *sources)
+          else
+            security_group.send(method, protocol, port_range, *sources)
+          end
+
+          self
+        end
+
+      end
+    end
+  end
+end

data/lib/aws/ec2/security_group/ip_permission_collection.rb

@@ -0,0 +1,82 @@
+# 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
+    class SecurityGroup < Resource
+
+      class IpPermissionCollection
+
+        include Core::Collection::Simple
+
+        def initialize security_group, options = {}
+          @security_group = security_group
+          @egress = !!options[:egress]
+          super
+        end
+
+        # @return [SecurityGroup]
+        attr_reader :security_group
+
+        # @return [Boolean]
+        attr_reader :egress
+
+        alias_method :egress?, :egress
+
+        private
+
+        def _each_item options = {}
+
+          list_method = 'ip_permissions_list'
+          list_method += '_egress' if egress?
+
+          security_group.send(list_method).each do |p|
+
+            # egress permissions don't always have ports
+            ports = p[:from_port] ? [p[:from_port], p[:to_port]] : nil
+
+            ip_ranges = p[:ip_ranges].collect{|ip| ip[:cidr_ip] }
+
+            groups = p[:groups].collect do |group|
+              SecurityGroup.new(group[:group_id],
+                :owner_id => group[:user_id],
+                :vpc_id => security_group.vpc_id,
+                :config => config)
+            end
+
+            permission = IpPermission.new(security_group, p[:ip_protocol], ports,
+              :ip_ranges => ip_ranges,
+              :groups => groups,
+              :egress => egress?,
+              :config => config)
+
+            yield(permission)
+
+          end
+        end
+
+      end
+
+      class IngressIpPermissionCollection < IpPermissionCollection; end
+
+      class EgressIpPermissionCollection < IpPermissionCollection
+
+        def initialize security_group, options = {}
+          super(security_group, options.merge(:egress => true))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/aws/ec2/security_group_collection.rb

@@ -0,0 +1,133 @@
+# 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 all EC2 security groups in an AWS account.
+    class SecurityGroupCollection < Collection
+
+      include TaggedCollection
+
+      # Creates a new
+      # @param [String] name The name of the security group to create.
+      # @param [Hash] options
+      # @option options [String] :description An informal description
+      #   of this security group.  Accepts alphanumeric characters, spaces,
+      #   dashes, and underscores. If left blank the description will be set
+      #   to the name.
+      #
+      # @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
+
+        create_opts = {}
+        create_opts[:group_name] = name
+        create_opts[:description] = description
+
+        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 => create_opts[:vpc_id],
+          :config => config })
+
+      end
+
+      # @param [String] group_id The group id of a security group.
+      # @return [SecurityGroup] The group with the given id.
+      def [] group_id
+        SecurityGroup.new(group_id, :config => config)
+      end
+
+      # Specify one or more criteria to filter security groups by.
+      # A subsequent call to #each will limit the security groups returned
+      # by the set of filters.
+      #
+      # If you supply multiple values to #filter then these values are
+      # treated as an OR condition.  To return security groups named
+      # 'test' or 'fake':
+      #
+      #     security_groups.filter('group-name', 'test', 'fake')
+      #
+      # If you want to and conditions together you need to chain calls to
+      # filter.  To limit security groups to those with a name like
+      # 'test' and like 'ruby':
+      #
+      #     security_groups.
+      #       filter('group-name', '*test*').
+      #       filter('group-name', '*ruby*').each do |group|
+      #       #...
+      #     end
+      #
+      # Note that * matches one or more characters and ? matches any one
+      # character.
+      #
+      # ### Valid Filters
+      #
+      # * description - Description of the security group.
+      # * group-id - ID of the security group.
+      # * group-name - Name of the security group.
+      # * ip-permission.cidr - CIDR range that has been granted the
+      #   permission.
+      # * ip-permission.from-port - Start of port range for the TCP and UDP
+      #    protocols, or an ICMP type number.
+      # * ip-permission.group-name - Name of security group that has been
+      #   granted the permission.
+      # * ip-permission.protocol - IP protocol for the permission. Valid
+      #   values include 'tcp', 'udp', 'icmp' or a protocol number.
+      # * ip-permission.to-port - End of port range for the TCP and UDP
+      #   protocols, or an ICMP code.
+      # * ip-permission.user-id - ID of AWS account that has been granted
+      #   the permission.
+      # * owner-id - AWS account ID of the owner of the security group.
+      # * tag-key - Key of a tag assigned to the security group.
+      # * tag-value - Value of a tag assigned to the security group.
+      #
+      # @return [SecurityGroupCollection] A new collection that represents
+      #   a subset of the security groups associated with this account.
+      #
+      # @yield [group]
+      # @yieldparam [SecurityGroup] group
+      # @return [nil]
+      def each &block
+
+        response = filtered_request(:describe_security_groups)
+        response.security_group_info.each do |info|
+
+          group = SecurityGroup.new_from(:describe_security_groups, info,
+            info.group_id, :config => config)
+
+          yield(group)
+
+        end
+        nil
+      end
+
+    end
+  end
+end

data/lib/aws/ec2/snapshot.rb

@@ -0,0 +1,143 @@
+# 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 Amazon EBS snapshot.
+    #
+    # @example Taking a snapshot from a volume
+    #  snapshot = volume.create_snapshot("Database Backup 12/21/2010")
+    #  sleep 1 until [:completed, :error].include?(snapshot.status)
+    #
+    # @example Managing snapshot permissions
+    #  unless snapshot.public?
+    #    snapshot.permissions.add("12345678901")
+    #  end
+    #
+    # @attr_reader [String] volume_id The ID of the volume this
+    #   snapshot was created from.
+    #
+    # @attr_reader [Symbol] status The status of the snapshot.
+    #   Possible values:
+    #
+    #     * `:pending`
+    #     * `:completed`
+    #     * `:error`
+    #
+    # @attr_reader [Time] start_time The time at which the snapshot
+    #   was initiated.
+    #
+    # @attr_reader [Integer] progress The progress of the snapshot
+    #   as a percentage.
+    #
+    # @attr_reader [String] owner_id The AWS account ID of the
+    #   snapshot owner.
+    #
+    # @attr_reader [Integer] volume_size The size of the volume from
+    #   which the snapshot was created.
+    #
+    # @attr_reader [String] description The description of the
+    #   snapshot provided at snapshot initiation.
+    class Snapshot < Resource
+
+      include TaggedItem
+      include HasPermissions
+
+      # @api private
+      def initialize id, options = {}
+        @id = id
+        super(options)
+      end
+
+      # @return [String] Returns the snapshot's ID.
+      attr_reader :id
+
+      attribute :status, :to_sym => true
+
+      attribute :start_time, :static => true
+
+      attribute :progress do
+        translates_output {|value| value.to_i if value }
+      end
+
+      attribute :owner_id, :static => true
+
+      attribute :volume_size, :static => true
+
+      attribute :volume_id, :static => true
+
+      attribute :owner_alias, :static => true
+
+      attribute :description, :static => true
+
+      alias_method :create_volume_permissions, :permissions
+
+      populates_from(:create_snapshot) do |resp|
+        resp if resp.snapshot_id == id
+      end
+
+      populates_from(:describe_snapshots) do |resp|
+        resp.snapshot_index[id]
+      end
+
+      # Deletes the snapshot.
+      # @return [nil]
+      def delete
+        client.delete_snapshot(:snapshot_id => id)
+        nil
+      end
+
+      # Creates a volume from the snapshot.
+      #
+      # @param [AvailabilityZone or String] availability_zone The
+      #   Availability Zone in which to create the new volume. See
+      #   {EC2#availability_zones} for how to get a list of
+      #   availability zones.
+      #
+      # @param [Hash] options Additional options for creating the volume
+      #
+      # @option options [Integer] size The desired size (in gigabytes)
+      #   for the volume.
+      #
+      # @return [Volume] The newly created volume
+      def create_volume availability_zone, options = {}
+        volumes = VolumeCollection.new(:config => config)
+        volumes.create(options.merge(
+          :availability_zone => availability_zone,
+          :snapshot => self
+        ))
+      end
+
+      # @return [Boolean] True if the snapshot exists.
+      def exists?
+        resp =
+          client.describe_snapshots(:filters => [{ :name => 'snapshot-id',
+                                                   :values => [id] }]) and
+          !resp.snapshot_set.empty?
+      end
+
+      # @return [Volume] The volume this snapshot was created from.
+      def volume
+        Volume.new(volume_id, :config => config) if volume_id
+      end
+
+      # @api private
+      def __permissions_attribute__
+        "createVolumePermission"
+      end
+
+    end
+
+  end
+end