aws-sdk-euca 1.8.5

data/lib/aws/auto_scaling/scheduled_action_collection.rb

@@ -0,0 +1,195 @@
+# 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 'time'
+
+module AWS
+  class AutoScaling
+
+    class ScheduledActionCollection
+
+      include Core::Collection::WithLimitAndNextToken
+      
+      # @private
+      def initialize options = {}
+        @filters = options[:filters] || {}
+        super
+      end
+
+      # Creates a scheduled scaling action for an Auto Scaling group. 
+      # If you leave a parameter unspecified, the corresponding attribute
+      # remains unchanged in the group.
+      #
+      # You must specify an Auto Scaling group.  This can be implicit
+      # or explicit:
+      #
+      #   # given explicitly
+      #   auto_scaling.scheduled_actions.create('action-name', :group => 'group-name')
+      #
+      #   # implied by the group
+      #   group = auto_scaling.groups.first
+      #   group.scheduled_actions.create('action-name')
+      #
+      # @param [String] name
+      #
+      # @param [Hash] options
+      #
+      # @option options [Group,String] :group
+      #
+      # @option options [Integer] :desired_capacity
+      #
+      # @option options [Integer] :max_size
+      #
+      # @option options [Integer] :min_size
+      #
+      # @option options [String] :recurrence
+      #
+      # @option options [Time] :start_time
+      # 
+      # @option options [Time] :end_time
+      #
+      # @return [ScheduledAction]
+      #
+      def create name, options = {}
+        
+        scheduled_action = ScheduledAction.new(name, 
+          :auto_scaling_group_name => auto_scaling_group_name_opt(options),
+          :config => config)
+
+        scheduled_action.update(options)
+        scheduled_action
+
+      end
+      alias_method :put, :create
+
+      # @param [String] name The name of the scheduled action.
+      # @return [ScheduledAction]
+      def [] name
+        options = {}
+        options[:config] = config
+        if group = @filters[:auto_scaling_group_name]
+          options[:auto_scaling_group_name] = group
+        end
+        ScheduledAction.new(name, options)
+      end
+
+      # Returns a new {ScheduledActionCollection} filtered
+      # by the given options.
+      #
+      #   auto_scaling.scheduled_actions.filter(:end_time => Time.now).each do |a|
+      #      # ...
+      #   end
+      #
+      # You can chain filter calls:
+      #
+      #   actions = auto_scaling.scheduled_actions.
+      #      filter(:group => 'auto-scaling-group-name').
+      #      filter(:start_time => Time.now - 3600).
+      #      filter(:end_time => Time.now)
+      #
+      #   actions.each {|scheduled_action| ... }
+      # 
+      # @param [Hash] filters
+      #
+      # @option filters [Group,String] :group
+      #
+      # @option filters [Array<String>] :scheduled_actions
+      #    A list of scheduled actions to be described. If this list is 
+      #    omitted, all scheduled actions are described. The list of 
+      #    requested scheduled actions cannot contain more than 50 items. 
+      #    If an Auto Scaling group name is provided, 
+      #    the results are limited to that group. If unknown scheduled 
+      #    actions are requested, they are ignored with no error.
+      #
+      # @option options [Time,String] :start_time The earliest scheduled
+      #   start time to return. If +:scheduled_actions+ is provided, 
+      #   this field will be ignored.  Should be a Time object or
+      #   an iso8601 string.
+      #
+      # @option filters [Time,String] :end_time 
+      #
+      # @return [ScheduledActionCollection] Returns a scheduled action
+      #   collection that will filter the actions returned by the
+      #   given criteria.
+      #
+      def filter filters = {}
+        init_opts = {}
+        init_opts[:config] = config
+        init_opts[:filters] = @filters
+        init_opts[:filters].merge!(filter_opts(filters))
+        ScheduledActionCollection.new(init_opts)
+      end
+
+      protected
+
+      def auto_scaling_group_name_opt options
+
+        group = options.delete(:group)
+        group ||= @filters[:auto_scaling_group_name]
+        group = group.name if group.is_a?(Group)
+
+        unless group
+          raise ArgumentError, 'missing required option :group'
+        end
+
+        group
+
+      end
+
+      def filter_opts options
+
+        opts = {}
+
+        if g = options[:group]
+          opts[:auto_scaling_group_name] = g.is_a?(Group) ? g.name : g
+        end
+
+        if actions = options[:scheduled_actions]
+          opts[:scheduled_action_names] = actions
+        end
+
+        [:end_time, :start_time].each do |opt|
+          if options[opt].is_a?(Time)
+            opts[opt] = options[opt].iso8601
+          end
+        end
+
+        opts
+
+      end
+
+      def _each_item next_token, limit, options = {}, &block
+
+        options[:next_token] = next_token if next_token
+        options[:max_records] = limit if limit
+
+        resp = client.describe_scheduled_actions(options.merge(@filters))
+        resp.scheduled_update_group_actions.each do |details|
+          
+          scheduled_action = ScheduledAction.new_from(
+            :describe_scheduled_actions,
+            details,
+            details.scheduled_action_name,
+            :config => config)
+
+          yield(scheduled_action)
+          
+        end
+
+        resp.data[:next_token]
+
+      end
+
+    end
+  end
+end

data/lib/aws/auto_scaling/tag.rb

@@ -0,0 +1,59 @@
+# 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 AutoScaling
+
+    # Auto Scaling tags are hashes with two helper methods:
+    #
+    # * {#resource}
+    # * {#delete}
+    #
+    class Tag < Hash
+
+      # @private
+      def initialize options = {}
+
+        super()
+
+        @resource =
+          case options[:resource_type]
+          when 'auto-scaling-group'
+            group_name = options[:resource_id]
+            config = options.delete(:config)
+            Group.new(group_name, :config => config)
+          else
+            msg = "unhandled resource type: #{options[:resource_type]}"
+            raise ArgumentError, msg
+          end
+
+        merge!(options)
+
+      end
+
+      # @return [Group] Returns the tagged resource.  Currently this is
+      #   always an Auto Scaling group.
+      def resource
+        @resource
+      end
+
+      # Deletes the tag from the resource.
+      # @return [nil]
+      def delete
+        resource.delete_tags([self])
+        nil
+      end
+
+    end
+  end
+end

data/lib/aws/auto_scaling/tag_collection.rb

@@ -0,0 +1,112 @@
+# 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 AutoScaling
+
+    # Provides an interface for enumerating tags defined in Auto Scaling.
+    #
+    #   auto_scaling = AWS::AutoScaling.new
+    #   auto_scaling.tags.each do |tag|
+    #      puts "#{tag.key}:#{tag.value}"
+    #   end
+    #
+    # == Filters
+    #
+    # You can filter the tags returned using {#filter}:
+    #
+    #   # returns tags with the key "role"
+    #   auto_scaling.filter(:key, 'role').to_a
+    #
+    #   # returns tags with the key "role" and value "webserver"
+    #   auto_scaling.filter(:key, 'role').filter(:value, 'webserver')to_a
+    #
+    #   # returns tags with the Auto Scaling group name "group1"
+    #   auto_scaling.filter(:auto_scaling_group, 'group1').to_a
+    #
+    #   # returns all tags that propagate at launch
+    #   auto_scaling.filter(:propagate_at_launch, true).to_a
+    #
+    # == Creating Tags
+    #
+    # You can create Auto Scaling tags when you:
+    #
+    # * [create]{GroupCollection#create} an Auto Scaling group
+    # * [update]{Group#update} an Auto Scaling group
+    #
+    # Both of these methods accept a +:tags+ option.
+    #
+    #   tags = [
+    #     { :key => 'auto-scaling-instance' },       # tag name only
+    #     { :key => 'role', :value => 'webserver' }, # tag name and value
+    #   ]
+    #
+    #   # creating a group with tags
+    #   group = auto_scaling.groups.create('group-name', :tags => tags, ...)
+    #
+    #   # updating a group's tags
+    #   group.update(:tags => tags)
+    # 
+    class TagCollection
+
+      include Core::Collection::WithLimitAndNextToken
+
+      # @private
+      def initialize options = {}
+        @filters = options.delete(:filters) || []
+        super
+      end
+      
+      # Filters the tags by the given filter name and value(s).
+      #
+      #   # return tags with the key "role" and the value "webserver"
+      #   auto_scaling.tags.filter(:key, 'role').filer(:value, 'webserver')
+      # 
+      # @param [Symbol] name Valid filter names include:
+      #
+      #   * :key
+      #   * :value
+      #   * :propagate_at_launch
+      #   * :auto_scaling_group
+      #
+      # @param [Array<String>] values
+      #
+      # @return [TagCollection]
+      #
+      def filter name, *values
+        name = name.to_s.gsub(/_/, '-')
+        values = values.flatten.map(&:to_s)
+        filter = { :name => name, :values => values }
+        TagCollection.new(:filters => @filters + [filter], :config => config)
+      end
+
+      protected
+
+      def _each_item next_token, limit, options = {}, &block
+
+        options[:next_token] = next_token if next_token
+        options[:max_records] = limit if limit
+        options[:filters] = @filters unless @filters.empty?
+
+        resp = client.describe_tags(options)
+        resp.tags.each do |tag|
+          yield(Tag.new(tag.to_hash.merge(:config => config)))
+        end
+
+        resp.data[:next_token]
+
+      end
+
+    end
+  end
+end

data/lib/aws/cloud_formation.rb

@@ -0,0 +1,272 @@
+# 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/core'
+require 'aws/cloud_formation/config'
+
+module AWS
+
+  # = AWS::CloudFormation
+  #
+  # Provides an expressive, object-oriented interface to AWS CloudFormation.
+  #
+  # == Credentials
+  #
+  # You can setup default credentials for all AWS services via
+  # AWS.config:
+  #
+  #   AWS.config(
+  #     :access_key_id => 'YOUR_ACCESS_KEY_ID',
+  #     :secret_access_key => 'YOUR_SECRET_ACCESS_KEY')
+  #
+  # Or you can set them directly on the CloudFormation interface:
+  #
+  #   cf = AWS::CloudFormation.new(
+  #     :access_key_id => 'YOUR_ACCESS_KEY_ID',
+  #     :secret_access_key => 'YOUR_SECRET_ACCESS_KEY')
+  #
+  # = Stacks
+  #
+  # This is the starting point for working with CloudFormation.
+  #
+  # == Creating a Stack
+  #
+  # You can create a CloudFormation stack with a name and a template.
+  #
+  #   template = <<-TEMPLATE
+  #   {
+  #     "AWSTemplateFormatVersion" : "2010-09-09",
+  #     "Description": "A simple template",
+  #     "Resources": {
+  #       "web": {
+  #         "Type": "AWS::EC2::Instance",
+  #         "Properties": {
+  #           "ImageId": "ami-41814f28"
+  #         }
+  #       }
+  #     }
+  #   }
+  #   TEMPLATE
+  #
+  #   cfm = AWS::CloudFormation.new
+  #   stack = cfm.stacks.create('stack-name', template)
+  #
+  # See {StackCollection#create} for more information on creating templates
+  # with capabilities and parameters.
+  #
+  # == Getting a Stack
+  # 
+  # Given a name, you can fetch a {Stack}.
+  #
+  #   stack = cfm.stacks['stack-name']
+  #
+  # == Enumerating Stacks
+  #
+  # You can enumerate stacks in two ways.  You can enumerate {Stack}
+  # objects or stack summaries (simple hashes).  You can filter the stack
+  # summary collection by a status.
+  #
+  #   # enumerating all stack objects
+  #   cfm.stacks.each do |stack|
+  #     # ...
+  #   end
+  #
+  #   # enumerating stack summaries (hashes)
+  #   cfm.stack_summaries.each do |stack_summary|
+  #     # ...
+  #   end
+  #
+  #   # filtering stack summaries by status
+  #   cfm.stack_summaries.with_status(:create_failed).each do |summary|
+  #     puts summary.to_yaml
+  #   end
+  #
+  # == Template
+  #
+  # You can fetch the template body for a stack as a JSON string.
+  #
+  #   cfm.stacks['stack-name'].template
+  #   #=> "{...}"
+  #
+  # You can update the template for a {Stack} with the {Stack#update} method:
+  #
+  #   cfm.stacks['stack-name'].update(:template => new_template)
+  #
+  # == Stack Events
+  #
+  # You can enumerate events for a stack.
+  #
+  #   stack.events.each do |event|
+  #     puts "#{event.physical_resource_id}: #{event.resource_status}"
+  #   end
+  #
+  # See {StackEvent} for a complete list of event attributes.
+  #
+  # == Stack Resources
+  #
+  # You can enumerate stack resources or request a stack resource by its
+  # logical resource id.
+  #
+  #   # enumerating stack resources
+  #   stack.resources.each do |resource|
+  #     # ...
+  #   end
+  #
+  #   # getting a resource by its logical id
+  #   res = stack.resources['logical-resource-id']
+  #   puts res.physical_resource_id
+  #
+  # If you need a stack resource, but only have its physical resource 
+  # id, then you can call {CloudFormation#stack_resource}.
+  #
+  #   stack_resource = cfm.stack_resource('physical-resource-id')
+  #
+  # == Stack Resource Summaries
+  #
+  # As an alternative to stack resources, you can enumerate stack
+  # resource summaries (hashes).
+  #
+  #   # enumerate all resources, this collection can not be filtered
+  #   stack.resource_summaries.each do |summary|
+  #     # ...
+  #   end
+  #
+  # @!attribute [r] client
+  #   @return [Client] the low-level CloudFormation client object
+  class CloudFormation
+
+    AWS.register_autoloads(self, 'aws/cloud_formation') do
+      autoload :Client, 'client'
+      autoload :Errors, 'errors'
+      autoload :Request, 'request'
+      autoload :Stack, 'stack'
+      autoload :StackCollection, 'stack_collection'
+      autoload :StackEvent, 'stack_event'
+      autoload :StackEventCollection, 'stack_event_collection'
+      autoload :StackOptions, 'stack_options'
+      autoload :StackOutput, 'stack_output'
+      autoload :StackSummaryCollection, 'stack_summary_collection'
+      autoload :StackResource, 'stack_resource'
+      autoload :StackResourceCollection, 'stack_resource_collection'
+      autoload :StackResourceSummaryCollection, 'stack_resource_summary_collection'
+    end
+
+    include Core::ServiceInterface
+    include StackOptions
+
+    # @return [StackCollection]
+    def stacks
+      StackCollection.new(:config => config)
+    end
+
+    # @return [StackSummaryCollection]
+    def stack_summaries
+      StackSummaryCollection.new(:config => config)
+    end
+
+    # Returns a stack resource with the given physical resource
+    # id.  
+    #
+    #   resource = cfm.stack_resource('i-123456789')
+    #
+    # Alternatively, you may pass a stack name and logical resource id:
+    #
+    #   resource = cfm.stack_resource('stack-name', 'logical-resource-id')
+    #
+    # @overload stack_resource(physical_resource_id)
+    #   @param [String] physical_resource_id The physical resource id
+    #     of the stack resource you want returned.
+    #
+    # @overload stack_resource(stack_name, logical_resource_id)
+    #   @param [String] stack_name
+    #   @param [String] logical_resource_id
+    #
+    # @return [StackResource] Returns the stack resource with the
+    #   given physical resource id.
+    #
+    def stack_resource *args
+
+      client_opts = {}
+
+      if args.size == 1
+        client_opts[:physical_resource_id] = args.first
+      else
+        client_opts[:stack_name] = args[0]
+        client_opts[:logical_resource_id] = args[1]
+      end
+
+      response = client.describe_stack_resources(client_opts)
+
+      details = response.stack_resources.first
+
+      StackResource.new_from(
+        :describe_stack_resource, details,
+        Stack.new(details.stack_name, :config => config),
+        details.logical_resource_id)
+
+    end
+
+    # Validates the template and returns a hash.  If the template is valid,
+    # the returned hash may/will contain the following keys (actual
+    # key list depends on the template).
+    #
+    #   * +:description+
+    #   * +:capabilities+
+    #   * +:capabilities_reason+
+    #   * +:parameters+
+    #
+    # If the template is not parseable, then a hash will the following
+    # keys will be returned:
+    #
+    #   * +:code+
+    #   * +:message+
+    #
+    # @return [Hash]
+    # 
+    def validate_template template
+      begin
+
+        client_opts = {}
+        client_opts[:template] = template
+        apply_template(client_opts)  
+        client.validate_template(client_opts).data
+
+      rescue CloudFormation::Errors::ValidationError => e
+
+        results = {}  
+        results[:code] = e.code
+        results[:message] = e.message
+        results
+
+      end
+    end
+
+    # @param (see Stack#template=)
+    #
+    # @param [Hash] parameters A hash that specifies the input 
+    #   parameters for the template.
+    #
+    # @return [String] Returns a URL to the AWS Simple Monthly Calculator 
+    #   with a query string that describes the resources required to run 
+    #   the template.
+    #
+    def estimate_template_cost template, parameters = {}
+      client_opts = {}
+      client_opts[:template] = template
+      apply_template(client_opts)  
+      apply_parameters(client_opts)  
+      client.estimate_template_cost(client_opts).url
+    end
+
+  end
+end