aws-sdk-v1 1.52.0

data/lib/aws/ec2/region_collection.rb

@@ -0,0 +1,51 @@
+# 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 the regions available to your account.
+    #
+    # @example Getting a map of endpoints by region name
+    #   ec2.regions.inject({}) { |m, r| m[r.name] = r.endpoint; m }
+    class RegionCollection < Collection
+
+      # @yield [Region] Each region that is available to your account.
+      # @return [nil]
+      def each
+        response = filtered_request(:describe_regions)
+        response.region_info.each do |r|
+          region = Region.new(r.region_name,
+                              :endpoint => r.region_endpoint,
+                              :config => config)
+          yield(region)
+        end
+        nil
+      end
+
+      # @return [Region] The region identified by the given name
+      #   (e.g. "us-west-2").
+      def [](name)
+        super
+      end
+
+      # @api private
+      protected
+      def member_class
+        Region
+      end
+
+    end
+
+  end
+end

data/lib/aws/ec2/reserved_instances.rb

@@ -0,0 +1,57 @@
+# 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 ReservedInstances < Resource
+
+      ATTRIBUTES = [
+        :start,
+        :instance_count,
+        :instance_type,
+        :availability_zone,
+        :duration,
+        :fixed_price,
+        :usage_price,
+        :product_description,
+        :instance_tenancy,
+        :currency_code,
+        :recurring_charges,
+        :offering_type,
+        :state,
+        :end,
+      ]
+
+      include TaggedItem
+
+      def initialize id, options = {}
+        @id = id
+        super
+      end
+
+      # @return [String] The id of this reserved instance.
+      attr_reader :id
+
+      ATTRIBUTES.each do |attr_name|
+        attribute(attr_name, :static => true)
+      end
+
+      populates_from(:describe_reserved_instances) do |resp|
+        resp.reserved_instances_set.find do |r|
+          r.reserved_instances_id == id
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/ec2/reserved_instances_collection.rb

@@ -0,0 +1,40 @@
+# 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 ReservedInstancesCollection < Collection
+
+      include TaggedCollection
+
+      def member_class
+        ReservedInstances
+      end
+
+      def each &block
+
+        response = filtered_request(:describe_reserved_instances)
+        response.reserved_instances_set.each do |item|
+
+          reserved_instance = ReservedInstances.new_from(
+            :describe_reserved_instances, item,
+            item.reserved_instances_id, :config => config)
+
+          yield(reserved_instance)
+
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/ec2/reserved_instances_offering.rb

@@ -0,0 +1,60 @@
+# 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 ReservedInstancesOffering < Resource
+
+      ATTRIBUTES = [
+        :instance_type,
+        :availability_zone,
+        :duration,
+        :fixed_price,
+        :usage_price,
+        :product_description,
+        :instance_tenancy,
+        :currency_code,
+        :recurring_charges,
+        :offering_type,
+      ]
+
+      include TaggedItem
+
+      def initialize id, options = {}
+        @id = id
+        super
+      end
+
+      # @return [String] The id of this reserved instance offering.
+      attr_reader :id
+
+      ATTRIBUTES.each do |attr_name|
+        attribute(attr_name, :static => true)
+      end
+
+      populates_from(:describe_reserved_instances_offerings) do |resp|
+        resp.reserved_instances_offerings_set.find do |r|
+          r.reserved_instances_offering_id == id
+        end
+      end
+
+      def purchase options = {}
+        options[:instance_count] = 1 unless options[:instance_count]
+        options[:reserved_instances_offering_id] = id
+        response = client.purchase_reserved_instances_offering(options)
+        ReservedInstances.new(response.reserved_instances_id, :config => config)
+      end
+
+    end
+  end
+end

data/lib/aws/ec2/reserved_instances_offering_collection.rb

@@ -0,0 +1,45 @@
+# 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 ReservedInstancesOfferingCollection < Collection
+
+      include TaggedCollection
+      include Core::Collection::WithLimitAndNextToken
+
+      def member_class
+        ReservedInstancesOffering
+      end
+
+      protected
+
+      def _each_item(next_token, max_results, options = {}, &block)
+        options[:next_token] = next_token if next_token
+        options[:max_results] = max_results if max_results
+        resp = filtered_request(:describe_reserved_instances_offerings, options)
+        resp.reserved_instances_offerings_set.each do |item|
+
+          reserved_instance_offering = ReservedInstancesOffering.new_from(
+            :describe_reserved_instances_offerings, item,
+            item.reserved_instances_offering_id, :config => config)
+
+          yield(reserved_instance_offering)
+
+        end
+        resp[:next_token]
+      end
+
+    end
+  end
+end

data/lib/aws/ec2/resource.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
+
+    # @api private
+    class Resource < Core::Resource
+
+      # @api private
+      protected
+      def resource_identifiers
+        [[resource_id_method, send(resource_id_method)]]
+      end
+
+      protected
+      def __resource_id__
+        send(resource_id_method)
+      end
+
+      protected
+      def response_id_method
+        # e.g. instance_id
+        inflected_name + "_" + resource_id_method.to_s
+      end
+
+      protected
+      def resource_id_method
+        @resource_id_method ||=
+          case
+          when respond_to?(:id) && method(:id).owner != Kernel
+            # id isn't defined on Object in some Ruby versions, in
+            # others it is an alias for object_id; if the method is
+            # not owned by Kernel we can assume that it has been
+            # overridden in a subclass
+            :id
+          when respond_to?(:name)
+            :name
+          else
+            raise NotImplementedError
+          end
+      end
+
+      protected
+      def get_resource attribute = nil
+        describe_call
+      end
+
+      protected
+      def retrieve_attribute attribute_or_attribute_name, &block
+        if attribute_or_attribute_name.is_a?(Symbol)
+          attribute = self.class.attributes[attribute_or_attribute_name]
+        else
+          attribute = attribute_or_attribute_name
+        end
+        super(attribute, &block)
+      end
+
+      protected
+      def describe_call
+        options = { :"#{response_id_method}s" => [__resource_id__] }
+        client.send(describe_call_name, options)
+      end
+
+      protected
+      def describe_attribute_call(attribute)
+        name = describe_attribute_call_name
+
+        attr_opt_name = Core::Inflection.class_name(attribute.from.to_s)
+        attr_opt_name = attr_opt_name[0,1].downcase + attr_opt_name[1..-1]
+
+        client.send(name, Hash[[[response_id_method.to_sym,
+                                 __resource_id__],
+                                [:attribute, attr_opt_name]]])
+      end
+
+      protected
+      def update_resource attribute, value
+        options = {}
+        if value.is_a?(Array)
+          options[attribute.set_as] = value
+        else
+          options[attribute.set_as] = { :value => value }
+        end
+        options[:"#{inflected_name}_id"] = __resource_id__
+        method_name = "modify_#{inflected_name}_attribute"
+        client.send(method_name, options)
+      end
+
+      # required for tagged item, which most ec2 resources are
+      protected
+      def find_in_response response
+        self.class.attribute_providers.each do |provider|
+          if provider.request_types.include?(response.request_type)
+            return send(provider.finder_method, response)
+          end
+        end
+      end
+
+      module InflectionMethods
+
+        protected
+        def describe_call_name
+          :"describe_#{plural_name}"
+        end
+
+        protected
+        def describe_attribute_call_name
+          "describe_#{inflected_name}_attribute"
+        end
+
+        protected
+        def inflected_name
+          Core::Inflection.ruby_name(class_name)
+        end
+
+        protected
+        def class_name
+          self.kind_of?(Class) ? name : self.class.name
+        end
+
+        protected
+        def plural_name
+          name = inflected_name
+          name[-1..-1] == 's' ? name : name + "s"
+        end
+
+        protected
+        def output_translator(name, type)
+          "translate_#{type}_output_for_#{name}"
+        end
+
+      end
+
+      extend InflectionMethods
+      include InflectionMethods
+
+      class << self
+
+        # @api private
+        protected
+        def describe_call_attribute(name, opts = {}, &blk)
+          attribute(name, opts, &blk)
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/aws/ec2/resource_tag_collection.rb

@@ -0,0 +1,211 @@
+# 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 the EC2 tags associated with a single resource.
+    #
+    # @example Manipulating the tags of an EC2 instance
+    #   i = ec2.instances["i-123"]
+    #   i.tags.to_h                  # => { "foo" => "bar", ... }
+    #   i.tags.clear
+    #   i.tags.stage = "production"
+    #   i.tags.stage                 # => "production"
+    class ResourceTagCollection
+
+      include Core::Model
+      include Enumerable
+
+      # @api private
+      def initialize(resource, opts = {})
+        @resource = resource
+        super(opts)
+        @tags = TagCollection.new(:config => config).
+          filter("resource-id", @resource.send(:__resource_id__)).
+          filter("resource-type", @resource.tagging_resource_type)
+      end
+
+      # @return [String] The value of the tag with the given key, or
+      #   nil if no such tag exists.
+      #
+      # @param [String or Symbol] key The key of the tag to return.
+      def [](key)
+        if cached = cached_tags
+          return cached[key.to_s]
+        end
+        Tag.new(@resource, key, :config => config).value
+      rescue Resource::NotFound => e
+        nil
+      end
+
+      # @return [Boolean] True if the resource has no tags.
+      def empty?
+        if cached = cached_tags
+          return cached.empty?
+        end
+        @tags.to_a.empty?
+      end
+
+      # @param [String or Symbol] key The key of the tag to check.
+      # @return [Boolean] True if the resource has a tag for the given key.
+      def has_key?(key)
+        if cached = cached_tags
+          return cached.has_key?(key.to_s)
+        end
+        !@tags.filter("key", key.to_s).to_a.empty?
+      end
+      alias_method :key?, :has_key?
+      alias_method :include?, :has_key?
+      alias_method :member?, :has_key?
+
+      # @param [String or Symbol] value The value to check.
+      # @return [Boolean] True if the resource has a tag with the given value.
+      def has_value?(value)
+        if cached = cached_tags
+          return cached.values.include?(value)
+        end
+        !@tags.filter("value", value.to_s).to_a.empty?
+      end
+      alias_method :value?, :has_value?
+
+      # Changes the value of a tag.
+      # @param [String or Symbol] key The key of the tag to set.
+      # @param [String] value The new value.  If this is nil, the tag will
+      #   be deleted.
+      def []=(key, value)
+        if value
+          @tags.create(@resource, key.to_s, :value => value)
+        else
+          delete(key)
+        end
+      end
+      alias_method :store, :[]=
+
+        # Adds a tag with a blank value.
+        #
+        # @param [String or Symbol] key The key of the new tag.
+        def add(key)
+          @tags.create(@resource, key.to_s)
+        end
+      alias_method :<<, :add
+
+      # Sets multiple tags in a single request.
+      #
+      # @param [Hash] tags The tags to set.  The keys of the hash
+      #   may be strings or symbols, and the values must be strings.
+      #   Note that there is no way to both set and delete tags
+      #   simultaneously.
+      def set(tags)
+        client.create_tags(:resources => [@resource.send(:__resource_id__)],
+                           :tags => tags.map do |(key, value)|
+                             { :key => key.to_s,
+                               :value => value }
+                           end)
+      end
+      alias_method :update, :set
+
+      # Allows setting and getting individual tags through instance
+      # methods.  For example:
+      #
+      #  tags.color = "red"
+      #  tags.color         # => "red"
+      def method_missing(m, *args)
+        if m.to_s[-1,1] == "="
+          self.send(:[]=, m.to_s[0...-1], *args)
+        elsif args.empty?
+          self[m]
+        else
+          super
+        end
+      end
+
+      # Deletes the tags with the given keys (which may be strings
+      # or symbols).
+      def delete(*keys)
+        return if keys.empty?
+        client.delete_tags(:resources => [@resource.send(:__resource_id__)],
+                           :tags => keys.map do |key|
+                             { :key => key.to_s }
+                           end)
+      end
+
+      # Removes all tags from the resource.
+      def clear
+        client.delete_tags(:resources => [@resource.send(:__resource_id__)])
+      end
+
+      # @yield [key, value] The key/value pairs of each tag
+      #   associated with the resource.  If the block has an arity
+      #   of 1, the key and value will be yielded in an aray.
+      def each(&blk)
+        if cached = cached_tags
+          cached.each(&blk)
+          return
+        end
+        @tags.filtered_request(:describe_tags).tag_set.each do |tag|
+          if blk.arity == 2
+            yield(tag.key, tag.value)
+          else
+            yield([tag.key, tag.value])
+          end
+        end
+        nil
+      end
+      alias_method :each_pair, :each
+
+      # @return [Array] An array of the tag values associated with
+      #   the given keys.  An entry for a key that has no value
+      #   (i.e. there is no such tag) will be nil.
+      def values_at(*keys)
+        if cached = cached_tags
+          return cached.values_at(*keys.map { |k| k.to_s })
+        end
+        keys = keys.map { |k| k.to_s }
+        tag_set = @tags.
+          filter("key", *keys).
+          filtered_request(:describe_tags).tag_set
+        hash = tag_set.inject({}) do |hash, tag|
+          hash[tag.key] = tag.value
+          hash
+        end
+        keys.map do |key|
+          hash[key]
+        end
+      end
+
+      # @return [Hash] The current tags as a hash, where the keys
+      #   are the tag keys as strings and the values are the tag
+      #   values as strings.
+      def to_h
+        if cached = cached_tags
+          return cached
+        end
+        @tags.filtered_request(:describe_tags).tag_set.inject({}) do |hash, tag|
+          hash[tag.key] = tag.value
+          hash
+        end
+      end
+
+      private
+      def cached_tags
+        if @resource.respond_to?(:cached_tags) and
+            cached = @resource.cached_tags
+          cached
+        end
+      end
+
+    end
+
+  end
+end