aws-sdk-euca 1.8.5

data/lib/aws/ec2/internet_gateway/attachment.rb

@@ -0,0 +1,78 @@
+# 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 InternetGateway < Resource
+
+      # Represents the attachment between an internet gateway and a VPC.
+      #
+      # == Creating Attachments
+      #
+      # To create an attachment, just assign an internet gateway to a VPC
+      # or visa versa.
+      #
+      #   # attaches a gateway to a vpc
+      #   internet_gateway.vpc = vpc
+      #
+      #   # this can also be done in reverse
+      #   vpc.internet_gateway = internet_gateway
+      #
+      # == Enumerating Attachments
+      #
+      # You can enumerate the attachments for an {InternetGateway} like so:
+      #
+      #   internet_gateway.attachments.each do |attachment|
+      #      puts "#{attachment.internet_gateway.id} => #{attachment.vpc.id}"
+      #   end
+      #
+      # == Deleting Attachments
+      #
+      # You can delete an attachment from the Attachment object:
+      #
+      #   internet_gateway.attachments.each(&:delete)
+      #
+      # You can also delete an attachment by assigning a nil value:
+      #
+      #   # removes the current attachment to the vpc is one exists
+      #   internet_gateway.vpc = nil
+      #
+      class Attachment
+
+        # @private
+        def initialize internet_gateway, details
+          @internet_gateway = internet_gateway
+          @vpc = VPC.new(details.vpc_id, :config => internet_gateway.config)
+          @state = details.state.to_sym
+        end
+
+        # @return [InternetGateway]
+        attr_reader :internet_gateway
+
+        # @return [VPC]
+        attr_reader :vpc
+
+        # @return [Symbol]
+        attr_reader :state
+
+        # Deletes this attachment.
+        # @return (see InternetGateway#detach)
+        def delete
+          internet_gateway.detach(vpc)
+        end
+        alias_method :detach, :delete
+
+      end
+    end
+  end
+end

data/lib/aws/ec2/internet_gateway_collection.rb

@@ -0,0 +1,54 @@
+# 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 InternetGatewayCollection < Collection
+
+      include TaggedCollection
+      include Core::Collection::Simple
+
+      # Creates a new Internet gateway in your AWS account. After creating 
+      # the gateway you can attach it to a VPC.
+      #
+      # @return [InternetGateway]
+      #
+      def create
+        response = client.create_internet_gateway
+        self[response.internet_gateway.internet_gateway_id] 
+      end
+
+      # @param [String] internet_gateway_id
+      # @return [InternetGateway]
+      def [] internet_gateway_id
+        InternetGateway.new(internet_gateway_id, :config => config)
+      end
+
+      protected
+
+      def _each_item options = {}, &block
+        response = filtered_request(:describe_internet_gateways, options, &block)
+        response.internet_gateway_set.each do |g|
+
+          gateway = InternetGateway.new_from(:describe_internet_gateways, g, 
+            g.internet_gateway_id, :config => config)
+
+          yield(gateway)
+
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/ec2/key_pair.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
+
+    # Represents an EC2 key pair.
+    # @attr_reader [String] fingerprint A SHA-1 digest of the DER encoded 
+    #   private key
+    class KeyPair < Resource
+
+      def initialize name, options = {}
+        @name = name.to_s
+        @private_key = options[:private_key]
+        super
+      end
+
+      # @return [String] The name of the key pair.
+      attr_reader :name
+
+      attribute :fingerprint, :from => :key_fingerprint, :static => true
+
+      populates_from(:create_key_pair, :import_key_pair) do |resp|
+        resp if resp.key_name == name
+      end
+
+      populates_from(:describe_key_pairs) do |resp|
+        resp.key_set.find{|k| k.key_name == name }
+      end
+
+      # @return [Boolean] True if the key pair exists.
+      def exists?
+        resp = client.describe_key_pairs(:filters => [
+          { :name => "key-name", :values => [name] }
+        ])
+        !resp.key_set.empty?
+      end
+
+      # Returns the private key.  Raises an exception if called
+      # against an existing key.  You can only get the private key
+      # at the time of creation. 
+      #
+      # @see KeyPairCollection#import
+      # @note Only call this method on newly created keys.
+      # @return [String] An unencrypted PEM encoded RSA private key.
+      def private_key
+        unless @private_key
+          raise 'you can only get the private key for just-created keypairs'
+        end
+        @private_key
+      end
+
+      # Deletes this key pair from EC2.
+      # @return [true]
+      def delete
+        client.delete_key_pair(:key_name => name)  
+        true
+      end
+
+      protected
+      def response_id_method
+        :key_name
+      end
+
+      protected
+      def find_in_response(resp)
+        resp.key_index[name]
+      end
+
+    end
+  end
+end

data/lib/aws/ec2/key_pair_collection.rb

@@ -0,0 +1,99 @@
+# 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.
+
+require 'base64'
+require 'digest/md5'
+
+module AWS
+  class EC2
+
+    # Represents all key pairs in your account.  You can use this collection
+    # to create, import and find key pairs.
+    class KeyPairCollection < Collection
+
+      # @param [String] key_name A name for the key pair.
+      # @return [KeyPair] Returns a new key pair.
+      def create key_name
+        create_or_import(:create_key_pair, :key_name => key_name)
+      end
+
+      # Imports the public key from an RSA key pair that you created with 
+      # a third-party tool. Compare this with {#create}, in which EC2 
+      # creates the key pair and gives the keys to you (EC2 keeps a copy 
+      # of the public key). With ImportKeyPair, you create the key pair 
+      # and give EC2 just the public key. The private key is never 
+      # transferred between you and EC2.
+      # 
+      # === Supported formats:
+      #
+      # * OpenSSH public key format (e.g., the format in 
+      #   ~/.ssh/authorized_keys) 
+      # * Base64 encoded DER format 
+      # * SSH public key file format as specified in RFC4716
+      #
+      # DSA keys are *not* supported. Make sure your key generator is 
+      # set up to create RSA keys. Supported lengths: 1024, 2048, and 4096.
+      #
+      # @param [String] key_name A name for this key pair.
+      # @param [String] public_key The RSA public key.
+      # @return [KeyPair] Returns a new key pair.
+      def import key_name, public_key
+        create_or_import(:import_key_pair, 
+          :key_name => key_name,
+          :public_key_material => Base64.encode64(public_key.to_s))
+      end
+
+      # @return [KeyPair] key_name The name of the key pair.
+      def [] key_name
+        super
+      end
+
+      # Yields once for each key pair in your account.
+      # @return [nil]
+      def each &block
+        response = filtered_request(:describe_key_pairs)
+        response.key_set.each do |kp|
+          yield(KeyPair.new(kp.key_name,
+                            :fingerprint => kp.key_fingerprint,
+                            :config => config))
+        end
+        nil
+      end
+
+      # @private
+      protected
+      def member_class
+        KeyPair
+      end
+
+      # @private
+      private
+      def create_or_import client_method, options
+
+        # stringify option values
+        options = options.inject({}) {|h,v| h[v.first] = v.last.to_s; h }
+        response = client.send(client_method, options)
+
+        options = {}
+        options[:fingerprint] = response.data[:key_fingerprint]
+        if response[:key_material]
+          options[:private_key] = response.data[:key_material]
+        end
+
+        KeyPair.new(response.key_name, options.merge(:config => config))
+
+      end
+
+    end
+  end
+end

data/lib/aws/ec2/network_acl.rb

@@ -0,0 +1,256 @@
+# 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.
+
+require 'aws/ec2/network_acl/entry'
+require 'aws/ec2/network_acl/association'
+
+module AWS
+  class EC2
+
+    # Represents a network ACL in EC2.
+    #
+    # @attr_reader [String] vpc_id
+    #
+    # @attr_reader [Boolean] default Returns true if this is the default 
+    #   network ACL.
+    #
+    class NetworkACL < Resource
+
+      include TaggedItem
+
+      def initialize network_acl_id, options = {}
+        @network_acl_id = network_acl_id
+        super
+      end
+
+      # @return [String]
+      attr_reader :network_acl_id
+
+      alias_method :id, :network_acl_id
+
+      attribute :vpc_id, :static => true
+
+      attribute :default, :static => true
+
+      alias_method :default?, :default
+
+      attribute :entry_set
+
+      protected :entry_set
+
+      attribute :association_set
+
+      protected :association_set
+
+      populates_from(:create_network_acl) do |resp|
+        resp.network_acl if resp.network_acl.network_acl_id == network_acl_id
+      end
+
+      populates_from(:describe_network_acls) do |resp|
+        resp.network_acl_set.find{|acl| acl.network_acl_id == network_acl_id }
+      end
+
+      # @return [VPC] Returns the VPC this network ACL belongs to.
+      def vpc
+        VPC.new(vpc_id, :config => config)
+      end
+
+      # @return [Array<Subnet>] Returns an array of subnets ({Subnet}) 
+      #   that currently use this network ACL.
+      def subnets
+        associations.map(&:subnet)
+      end
+
+      # @return [Array<NetworkACL::Association>] Returns an array of 
+      #   {NetworkACL::Association} objects (association to subnets).
+      def associations
+        association_set.map do |assoc|
+
+          subnet = Subnet.new(assoc.subnet_id, 
+            :vpc_id => vpc_id, 
+            :config => config)
+
+          Association.new(assoc.network_acl_association_id, self, subnet)
+          
+        end
+      end
+
+      # @return [Array<NetworkACL::Entry>] Returns an array of 
+      #   all entries for this network ACL.
+      def entries
+        entry_set.map do |entry_details|
+          Entry.new(self, entry_details)
+        end
+      end
+
+      # Adds an entry to this network ACL.
+      #
+      # @param [Hash] options
+      #
+      # @option options [required,Integer] :rule_number Rule number to 
+      #   assign to the entry (e.g., 100). ACL entries are processed in 
+      #   ascending order by rule number.
+      #
+      # @option options [required,:allow,:deny] :action Whether to 
+      #   allow or deny traffic that matches the rule.
+      #
+      # @option options [required,Integer] :protocol IP protocol the rule 
+      #   applies to. You can use -1 to mean all protocols. You can see a 
+      #   list of #   supported protocol numbers here: 
+      #   http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xml
+      #
+      # @option options [required,String] :cidr_block The CIDR range to 
+      #   allow or deny, in CIDR notation (e.g., 172.16.0.0/24).
+      #
+      # @option options [Boolean] :egress (false) 
+      #   Whether this rule applies to egress traffic from the subnet (true) 
+      #   or ingress traffic to the subnet (false).
+      #
+      # @option options [Range<Integer>] :port_range A numeric range
+      #   of ports. Required if specifying TCP (6) or UDP (17) for the 
+      #   :protocol.
+      #
+      # @option options [Integer] :icmp_code For the ICMP protocol, the 
+      #   ICMP code. You can use -1 to specify all ICMP codes for the given 
+      #   ICMP type.
+      #
+      # @option options [Integer] :icmp_type For the ICMP protocol, 
+      #   the ICMP type. You can use -1 to specify all ICMP types.
+      #
+      # @return [nil]
+      #
+      def create_entry options = {}
+        client.create_network_acl_entry(entry_options(options))
+        nil
+      end
+
+      # Replaces the network ACL entry with the given :rule_number.
+      #
+      # @param [Hash] options
+      #
+      # @option options [required,Integer] :rule_number Rule number to 
+      #   assign to the entry (e.g., 100). ACL entries are processed in 
+      #   ascending order by rule number.
+      #
+      # @option options [required,:allow,:deny] :action Whether to 
+      #   allow or deny traffic that matches the rule.
+      #
+      # @option options [required,Integer] :protocol IP protocol the rule 
+      #   applies to. You can use -1 to mean all protocols. You can see a 
+      #   list of #   supported protocol numbers here: 
+      #   http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xml
+      #
+      # @option options [required,String] :cidr_block The CIDR range to 
+      #   allow or deny, in CIDR notation (e.g., 172.16.0.0/24).
+      #
+      # @option options [Boolean] :egress (false) 
+      #   Whether this rule applies to egress traffic from the subnet (true) 
+      #   or ingress traffic to the subnet (false).
+      #
+      # @option options [Range<Integer>] :port_range A numeric range
+      #   of ports. Required if specifying TCP (6) or UDP (17) for the 
+      #   :protocol.
+      #
+      # @option options [Integer] :icmp_code For the ICMP protocol, the 
+      #   ICMP code. You can use -1 to specify all ICMP codes for the given 
+      #   ICMP type.
+      #
+      # @option options [Integer] :icmp_type For the ICMP protocol, 
+      #   the ICMP type. You can use -1 to specify all ICMP types.
+      #
+      # @return [nil]
+      #
+      def replace_entry options = {}
+        client.replace_network_acl_entry(entry_options(options))
+        nil
+      end
+
+      # Deletes an entry from this network ACL. To delete an entry
+      # you need to know its rule number and if it is an egress or ingress
+      # rule.
+      # 
+      #   # delete ingress rule 10
+      #   network_acl.delete_entry :egress, 10
+      #
+      #   # delete egress rules 5
+      #   network_acl.delete_entry :ingress, 5
+      #
+      # @param [:ingress,:egress] egress_or_ingress Specifies if you want to
+      #   delete an ingress or an egress rule.
+      #
+      # @param [Integer] rule_number Which rule to delete.
+      #
+      # @return [nil]
+      #
+      def delete_entry egress_or_ingress, rule_number
+
+        unless [:ingress, :egress].include?(egress_or_ingress)
+          msg = "expected :ingress or :egress for egress_or_ingress param"
+          raise ArgumentError, msg
+        end
+
+        client_opts = {}
+        client_opts[:network_acl_id] = network_acl_id
+        client_opts[:egress] = egress_or_ingress == :egress
+        client_opts[:rule_number] = rule_number
+
+        client.delete_network_acl_entry(client_opts)
+
+        nil
+
+      end
+
+      # Deletes the current network ACL.  You can not delete the default
+      # network ACL.
+      # @return [nil]
+      def delete
+        client.delete_network_acl(:network_acl_id => network_acl_id)
+        nil
+      end
+
+      protected
+      
+      def entry_options options
+
+        unless [true,false].include?(options[:egress])
+          msg = "expected :egress option to be set to true or false"
+          raise ArgumentError, msg
+        end
+
+        entry_opts = {}
+        entry_opts[:network_acl_id] = network_acl_id
+        entry_opts[:rule_number] = options[:rule_number]
+        entry_opts[:protocol] = options[:protocol].to_s.downcase
+        entry_opts[:rule_action] = options[:action].to_s
+        entry_opts[:egress] = options[:egress] if options.key?(:egress)
+        entry_opts[:cidr_block] = options[:cidr_block]
+
+        if options[:icmp_code] or options[:icmp_type]
+          entry_opts[:icmp_type_code] = {}
+          entry_opts[:icmp_type_code][:type] = options[:icmp_type]
+          entry_opts[:icmp_type_code][:code] = options[:icmp_code]
+        end
+
+        if options[:port_range]
+          entry_opts[:port_range] = {}
+          entry_opts[:port_range][:from] = options[:port_range].first
+          entry_opts[:port_range][:to] = options[:port_range].last
+        end
+
+        entry_opts
+
+      end
+
+    end
+  end
+end