amazon-ec2 0.5.5 → 0.6.0

data/ChangeLog

@@ -1,3 +1,6 @@
+=== 0.6.0 2009-09-30
+ * Added support for AWS AutoScaling for EC2.  Thanks to Ari Lerner (auser)!
+
 === 0.5.2 2009-08-20
  * Converted to YardDoc documentation format. See : http://yard.soen.ca/getting_started
 

data/Rakefile

@@ -6,7 +6,7 @@ require 'jeweler'
 Jeweler::Tasks.new do |gem|
   gem.name = "amazon-ec2"
   gem.summary = %Q{Amazon EC2 Ruby Gem}
-  gem.description = %Q{A Ruby library for accessing the Amazon Web Services Elastic Compute Cloud (EC2) and Elastic Load Balancer (ELB) API's.}
+  gem.description = %Q{A Ruby library for accessing the Amazon Web Services Elastic Compute Cloud (EC2), Elastic Load Balancer (ELB), Cloudwatch, and Autoscaling API's.}
   gem.email = "glenn@rempe.us"
   gem.homepage = "http://github.com/grempe/amazon-ec2"
   gem.authors = ["Glenn Rempe"]

data/VERSION

@@ -1 +1 @@
-0.5.5
+0.6.0

data/amazon-ec2.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{amazon-ec2}
-  s.version = "0.5.5"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Glenn Rempe"]
-  s.date = %q{2009-08-20}
-  s.description = %q{A Ruby library for accessing the Amazon Web Services Elastic Compute Cloud (EC2) and Elastic Load Balancer (ELB) API's.}
+  s.date = %q{2009-09-30}
+  s.description = %q{A Ruby library for accessing the Amazon Web Services Elastic Compute Cloud (EC2), Elastic Load Balancer (ELB), Cloudwatch, and Autoscaling API's.}
   s.email = %q{glenn@rempe.us}
   s.executables = ["ec2-gem-example.rb", "ec2-gem-profile.rb", "ec2sh", "setup.rb"]
   s.extra_rdoc_files = [
@@ -35,6 +35,10 @@ Gem::Specification.new do |s|
      "bin/setup.rb",
      "deps.rip",
      "lib/AWS.rb",
+     "lib/AWS/Autoscaling.rb",
+     "lib/AWS/Autoscaling/autoscaling.rb",
+     "lib/AWS/Cloudwatch.rb",
+     "lib/AWS/Cloudwatch/monitoring.rb",
      "lib/AWS/EC2.rb",
      "lib/AWS/EC2/availability_zones.rb",
      "lib/AWS/EC2/console.rb",
@@ -55,6 +59,7 @@ Gem::Specification.new do |s|
      "perftools/ec2prof-results.dot",
      "perftools/ec2prof-results.txt",
      "perftools/ec2prof.symbols",
+     "test/test_Autoscaling_groups.rb",
      "test/test_EC2.rb",
      "test/test_EC2_availability_zones.rb",
      "test/test_EC2_console.rb",
@@ -83,7 +88,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{Amazon EC2 Ruby Gem}
   s.test_files = [
-    "test/test_EC2.rb",
+    "test/test_Autoscaling_groups.rb",
+     "test/test_EC2.rb",
      "test/test_EC2_availability_zones.rb",
      "test/test_EC2_console.rb",
      "test/test_EC2_elastic_ips.rb",

data/lib/AWS.rb

@@ -214,11 +214,10 @@ module AWS
           req['User-Agent'] = "github-amazon-ec2-ruby-gem"
 
           response = @http.request(req, query)
-
+          
           # Make a call to see if we need to throw an error based on the response given by EC2
           # All error classes are defined in EC2/exceptions.rb
           aws_error?(response)
-
           return response
 
         end

data/lib/AWS/Autoscaling.rb

@@ -0,0 +1,70 @@
+module AWS
+  module Autoscaling
+    # Which host FQDN will we connect to for all API calls to AWS?
+    # If AS_URL is defined in the users ENV we can override the default with that.
+    #
+    # @example
+    #   export AS_URL='http://autoscaling.amazonaws.com'
+    if ENV['AS_URL']
+      AS_URL = ENV['AS_URL']
+      VALID_HOSTS = ['http://autoscaling.amazonaws.com']
+      raise ArgumentError, "Invalid AS_URL environment variable : #{AS_URL}" unless VALID_HOSTS.include?(AS_URL)
+      DEFAULT_HOST = URI.parse(AS_URL).host
+    else
+      # Default US API endpoint
+      DEFAULT_HOST = 'autoscaling.amazonaws.com'
+    end
+
+    API_VERSION = '2009-05-15'
+
+    class Base < AWS::Base
+      def api_version
+        API_VERSION
+      end
+
+      def default_host
+        DEFAULT_HOST
+      end
+
+      # Raises the appropriate error if the specified Net::HTTPResponse object
+      # contains an Amazon EC2 error; returns +false+ otherwise.
+      def aws_error?(response)
+
+        # return false if we got a HTTP 200 code,
+        # otherwise there is some type of error (40x,50x) and
+        # we should try to raise an appropriate exception
+        # from one of our exception classes defined in
+        # exceptions.rb
+        return false if response.is_a?(Net::HTTPSuccess)
+
+        # parse the XML document so we can walk through it
+        doc = REXML::Document.new(response.body)
+
+        # Check that the Error element is in the place we would expect.
+        # and if not raise a generic error exception
+        unless doc.root.elements[1].name == "Error"
+          raise Error, "Unexpected error format. response.body is: #{response.body}"
+        end
+
+        # An valid error response looks like this:
+        # <?xml version="1.0"?><Response><Errors><Error><Code>InvalidParameterCombination</Code><Message>Unknown parameter: foo</Message></Error></Errors><RequestID>291cef62-3e86-414b-900e-17246eccfae8</RequestID></Response>
+        # AWS EC2 throws some exception codes that look like Error.SubError.  Since we can't name classes this way
+        # we need to strip out the '.' in the error 'Code' and we name the error exceptions with this
+        # non '.' name as well.
+        error_code    = doc.root.elements['//ErrorResponse/Error/Code'].text.gsub('.', '')
+        error_message = doc.root.elements['//ErrorResponse/Error/Message'].text
+
+        # Raise one of our specific error classes if it exists.
+        # otherwise, throw a generic EC2 Error with a few details.
+        if AWS.const_defined?(error_code)
+          raise AWS.const_get(error_code), error_message
+        else
+          raise AWS::Error, error_message
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/AWS/Autoscaling/autoscaling.rb

@@ -0,0 +1,273 @@
+module AWS
+  module Autoscaling
+    class Base < AWS::Base
+
+      # Create a launch configuration
+      # Creates a new Launch Configuration. Please note that the launch configuration name used must be unique, within the scope of your AWS account, and the maximum limit of launch configurations must not yet have been met, or else the call will fail.
+      # Once created, the new launch configuration is available for immediate use.
+      #
+      # @option options [String] :launch_configuration_name (nil) the name of the launch configuration
+      # @option options [String] :image_id (nil) the image id to use with this launch configuration
+      # @option options [String] :instance_type (nil) the type of instance to launch
+      # @option options [Array] :security_groups (nil) the names of security_groups to launch within
+      # @option options [String] :key_name (nil) the name of the EC2 key pair
+      # @option options [String] :user_data (nil) the user data available to the launched EC2 instances
+      # @option options [String] :kernel_id (nil) the ID of the kernel associated with the EC2 ami
+      # @option options [String] :ramdisk_id (nil) the name of the RAM disk associated with the EC2 ami
+      # @option options [Array] :block_device_mappings (nil) specifies how block devices are exposed to the instance
+      def create_launch_configuration( options = {})
+        raise ArgumentError, "No :image_id provided" if options[:image_id].nil? || options[:image_id].empty?
+        raise ArgumentError, "No :launch_configuration_name provided" if options[:launch_configuration_name].nil? || options[:launch_configuration_name].empty?
+        raise ArgumentError, "No :instance_type provided" if options[:instance_type].nil? || options[:instance_type].empty?
+
+        params = {}
+        params["ImageId"] = options[:image_id]
+        params["KeyName"] = options[:key_name] if options[:key_name]
+        params["LaunchConfigurationName"] = options[:launch_configuration_name]
+        params.merge!(pathlist('SecurityGroups.member', [options[:security_groups]].flatten)) if options[:security_groups]
+        params["UserData"] = options[:user_data] if options[:user_data]
+        params["InstanceType"] = options[:instance_type] if options[:instance_type]
+        params["KernelId"] = options[:kernel_id] if options[:kernel_id]
+        params["RamdiskId"] = options[:ramdisk_id] if options[:ramdisk_id]
+        params.merge!(pathlist('BlockDeviceMappings.member', [options[:block_device_mappings]].flatten)) if options[:block_device_mappings]
+
+        return response_generator(:action => "CreateLaunchConfiguration", :params => params)
+      end
+
+      # Creates a new AutoScalingGroup with the specified name.
+      # You must not have already used up your entire quota of AutoScalingGroups in order for this call to be successful. Once the creation request is completed, the AutoScalingGroup is ready to be used in other calls.
+      #
+      # @option options [String] :autoscaling_group_name (nil) the name of the autoscaling group
+      # @option options [Array] :availability_zones (nil) The availability_zones for the group
+      # @option options [String] :launch_configuration_name (nil) the name of the launch_configuration group
+      # @option options [String] :min_size (nil) minimum size of the group
+      # @option options [String] :max_size (nil) the maximum size of the group
+      # @option options [String] :load_balancer_names (nil) the names of the load balancers
+      # @option options [String] :cooldown (nil) the amount of time after a scaling activity complese before any further trigger-related scaling activities can start
+      def create_autoscaling_group( options = {} )
+        raise ArgumentError, "No :autoscaling_group_name provided" if options[:autoscaling_group_name].nil? || options[:autoscaling_group_name].empty?
+        raise ArgumentError, "No :availability_zones provided" if options[:availability_zones].nil? || options[:availability_zones].empty?
+        raise ArgumentError, "No :launch_configuration_name provided" if options[:launch_configuration_name].nil? || options[:launch_configuration_name].empty?
+        raise ArgumentError, "No :min_size provided" if options[:min_size].nil?
+        raise ArgumentError, "No :max_size provided" if options[:max_size].nil?
+
+        params = {}
+
+        params.merge!(pathlist('AvailabilityZones.member', [options[:availability_zones]].flatten))
+        params['LaunchConfigurationName'] = options[:launch_configuration_name]
+        params['AutoScalingGroupName'] = options[:autoscaling_group_name]
+        params['MinSize'] = options[:min_size].to_s
+        params['MaxSize'] = options[:max_size].to_s
+        params['LoadBalancerNames'] = options[:load_balancer_names] if options[:load_balancer_names]
+        params['CoolDown'] = options[:cooldown] if options[:cooldown]
+
+        return response_generator(:action => "CreateAutoScalingGroup", :params => params)
+      end
+
+      # Create or update scaling trigger
+      # This call sets the parameters that governs when and how to scale an AutoScalingGroup.
+      #
+      # @option options [String] :autoscaling_group_name (nil) the name of the autoscaling group
+      # @option options [Array|Hash] :dimensions (nil) The dimensions associated with the metric used by the trigger to determine whether to activate
+      #   This must be given as either an array or a hash
+      #   When called as a hash, the values must look like: {:name => "name", :value => "value"}
+      #   In the array format, the first value is assumed to be the name and the second is assumed to be the value
+      # @option options [String] :measure_name (nil) the measure name associated with the metric used by the trigger
+      # @option options [String|Integer] :period (nil) the period associated with the metric in seconds
+      # @option options [String] :statistic (nil) The particular statistic used by the trigger when fetching metric statistics to examine. Must be one of the following: Minimum, Maximum, Sum, Average
+      # @option options [String] :trigger_name (nil) the name for this trigger
+      # @option options [String] :unit (nil) the standard unit of measurement for a given measure
+      # @option options [String|Integer] :lower_threshold (nil) the lower limit for the metric. If all datapoints in the last :breach_duration seconds fall below the lower threshold, the trigger will activate
+      # @option options [String|Integer] :lower_breach_scale_increment (nil) the incremental amount to use when performing scaling activities when the lower threshold has been breached
+      # @option options [String|Integer] :upper_threshold (nil) the upper limit for the metric. If all datapoints in the last :breach_duration seconds exceed the upper threshold, the trigger will activate
+      # @option options [String|Integer] :upper_breach_scale_increment (nil) the incremental amount to use when performing scaling activities when the upper threshold has been breached
+      def create_or_updated_scaling_trigger( options = {} )
+        if options[:dimensions].nil? || options[:dimensions].empty?
+          raise ArgumentError, "No :dimensions provided"
+        end
+        raise ArgumentError, "No :autoscaling_group_name provided" if options[:autoscaling_group_name].nil? || options[:autoscaling_group_name].empty?
+        raise ArgumentError, "No :measure_name provided" if options[:measure_name].nil? || options[:measure_name].empty?
+        raise ArgumentError, "No :statistic provided" if options[:statistic].nil? || options[:statistic].empty?
+        raise ArgumentError, "No :period provided" if options[:period].nil?
+        raise ArgumentError, "No :trigger_name provided" if options[:trigger_name].nil? || options[:trigger_name].empty?
+        raise ArgumentError, "No :lower_threshold provided" if options[:lower_threshold].nil?
+        raise ArgumentError, "No :lower_breach_scale_increment provided" if options[:lower_breach_scale_increment].nil?
+        raise ArgumentError, "No :upper_threshold provided" if options[:upper_threshold].nil?
+        raise ArgumentError, "No :upper_breach_scale_increment provided" if options[:upper_breach_scale_increment].nil?
+        raise ArgumentError, "No :breach_duration provided" if options[:breach_duration].nil?
+
+        statistic_option_list = %w(Minimum Maximum Average Sum)
+        unless statistic_option_list.include?(options[:statistic])
+          raise ArgumentError, "The statistic option must be one of the following: #{statistic_option_list.join(", ")}"
+        end
+
+        params = {}
+        params['Unit'] = options[:unit] || "Seconds"
+        params['AutoScalingGroupName'] = options[:autoscaling_group_name]
+        case options[:dimensions]
+        when Array
+          params["Dimensions.member.1.Name"] = options[:dimensions][0]
+          params["Dimensions.member.1.Value"] = options[:dimensions][1]
+        when Hash
+          params["Dimensions.member.1.Name"] = options[:dimensions][:name]
+          params["Dimensions.member.1.Value"] = options[:dimensions][:value]
+        else
+          raise ArgumentError, "Dimensionss must be either an array or a hash"
+        end
+        params['MeasureName'] = options[:measure_name]
+        params['Statistic'] = options[:statistic]
+        params['Period'] = options[:period].to_s
+        params['TriggerName'] = options[:trigger_name]
+        params['LowerThreshold'] = options[:lower_threshold].to_s
+        params['LowerBreachScaleIncrement'] = options[:lower_breach_scale_increment].to_s
+        params['UpperThreshold'] = options[:upper_threshold].to_s
+        params['UpperBreachScaleIncrement'] = options[:upper_breach_scale_increment].to_s
+        params['BreachDuration'] = options[:breach_duration].to_s
+
+        return response_generator(:action => "CreateOrUpdateScalingTrigger", :params => params)
+      end
+
+      # Deletes all configuration for this AutoScalingGroup and also deletes the group.
+      # In order to successfully call this API, no triggers (and therefore, Scaling Activity) can be currently in progress. Once this call successfully executes, no further triggers will begin and the AutoScalingGroup will not be available for use in other API calls. See key term Trigger.
+      #
+      # @option options [String] :autoscaling_group_name (nil) the name of the autoscaling group
+      def delete_autoscaling_group( options = {} )
+        raise ArgumentError, "No :autoscaling_group_name provided" if options[:autoscaling_group_name].nil? || options[:autoscaling_group_name].empty?
+        params = { 'AutoScalingGroupName' => options[:autoscaling_group_name] }
+        return response_generator(:action => "DeleteAutoScalingGroup", :params => params)
+      end
+
+      # Deletes the given Launch Configuration.
+      # The launch configuration to be deleted must not be currently attached to any AutoScalingGroup. Once this call completes, the launch configuration is no longer available for use by any other API call.
+      #
+      # @option options [String] :launch_configuration_name (nil) the name of the launch_configuration
+      def delete_launch_configuration( options = {} )
+        raise ArgumentError, "No :launch_configuration_name provided" if options[:launch_configuration_name].nil? || options[:launch_configuration_name].empty?
+        params = { 'LaunchConfigurationName' => options[:launch_configuration_name] }
+        return response_generator(:action => "DeleteLaunchConfiguration", :params => params)
+      end
+
+      # Deletes the given trigger
+      # If a trigger is currently in progress, it will continue to run until its activities are complete.
+      #
+      # @option options [String] :trigger_name (nil) the name of the trigger to delete
+      def delete_trigger( options = {} )
+        raise ArgumentError, "No :trigger_name provided" if options[:trigger_name].nil? || options[:trigger_name].empty?
+        raise ArgumentError, "No :autoscaling_group_name provided" if options[:autoscaling_group_name].nil? || options[:autoscaling_group_name].empty?
+        params = { 'TriggerName' => options[:trigger_name], 'AutoScalingGroupName' => options[:autoscaling_group_name] }
+        return response_generator(:action => "DeleteTrigger", :params => params)
+      end
+
+      # Describe autoscaling group
+      # Returns a full description of the AutoScalingGroups from the given list. This includes all EC2 instances that are members of the group. If a list of names is not provided, then the full details of all AutoScalingGroups is returned. This style conforms to the EC2 DescribeInstances API behavior. See key term AutoScalingGroup.
+      #
+      # @option options [Array] :autoscaling_group_names (nil) the name of the autoscaling groups to describe
+      def describe_autoscaling_groups( options = {} )
+        options = { :autoscaling_group_names => [] }.merge(options)
+        params = pathlist("AutoScalingGroupNames.member", options[:autoscaling_group_names])
+        return response_generator(:action => "DescribeAutoScalingGroups", :params => params)
+      end
+
+      # Describe launch configurations
+      # Returns a full description of the launch configurations given the specified names. If no names are specified, then the full details of all launch configurations are returned. See key term Launch Configuration.
+      #
+      # @option options [Array] :launch_configuration_names (nil) the name of the launch_configurations to describe
+      def describe_launch_configurations( options = {} )
+        options = { :launch_configuration_names => [] }.merge(options)
+        params = pathlist("AutoScalingGroupNames.member", options[:launch_configuration_names])
+        params['MaxRecords'] = options[:max_records].to_s if options.has_key?(:max_records)
+        return response_generator(:action => "DescribeLaunchConfigurations", :params => params)
+      end
+
+      # Describe autoscaling activities
+      # Returns the scaling activities specified for the given group. If the input list is empty, all the activities from the past six weeks will be returned. Activities will be sorted by completion time. Activities that have no completion time will be considered as using the most recent possible time. See key term Scaling Activity.
+      #
+      # @option options [String] :autoscaling_group_name (nil) the name of the autoscaling_group_name
+      # @option options [String] :max_records (nil) the maximum number of scaling activities to return
+      # @option options [String] :launch_configuration_names (nil) activity_ids to return
+      def describe_scaling_activities( options = {} )
+        raise ArgumentError, "No :autoscaling_group_name provided" if options[:autoscaling_group_name].nil? || options[:autoscaling_group_name].empty?
+
+        params = {}
+        params['AutoScalingGroupName'] = options[:autoscaling_group_name]
+        params['MaxRecords'] = options[:max_records] if options.has_key?(:max_records)
+        params['ActivityIds'] = options[:activity_ids] if options.has_key?(:activity_ids)
+        return response_generator(:action => "DescribeScalingActivities", :params => params)
+      end
+
+      # Describe triggers
+      # Returns a full description of the trigger (see Trigger), in the specified AutoScalingGroup.
+      #
+      # @option options [String] :autoscaling_group_name (nil) the name of the autoscaling_group_name
+      def describe_triggers( options = {} )
+        raise ArgumentError, "No :autoscaling_group_name provided" if options[:autoscaling_group_name].nil? || options[:autoscaling_group_name].empty?
+        params = {}
+        params['AutoScalingGroupName'] = options[:autoscaling_group_name]
+
+        return response_generator(:action => "DescribeTriggers", :params => params)
+      end
+
+      # Set desired capacity
+      # This API adjusts the desired size of the AutoScalingGroup by initiating scaling activities, as necessary. When adjusting the size of the group downward, it is not possible to define which EC2 instances will be terminated. This applies to any auto-scaling decisions that might result in the termination of instances.
+      # To check the scaling status of the system, query the desired capacity using DescribeAutoScalingGroups and then query the actual capacity using DescribeAutoScalingGroups and looking at the instance lifecycle state in order to understand how close the system is to the desired capacity at any given time.
+      #
+      # @option options [String] :autoscaling_group_name (nil) the name of the autoscaling_group_name
+      # @option options [String] :desired_capacity (nil) the new capacity setting for the group
+      def set_desired_capacity( options = {} )
+        raise ArgumentError, "No :autoscaling_group_name provided" if options[:autoscaling_group_name].nil? || options[:autoscaling_group_name].empty?
+        raise ArgumentError, "No :desired_capacity provided" if options[:desired_capacity].nil? || options[:desired_capacity].empty?
+
+        params = {}
+        params['AutoScalingGroupName'] = options[:autoscaling_group_name]
+        params['DesiredCapacity'] = options[:desired_capacity].to_s
+
+        return response_generator(:action => "SetDesiredCapacity", :params => params)
+      end
+
+
+      # Terminate instance in an autoscaling group
+      # This call will terminate the specified Instance. Optionally, the desired group size can be adjusted. If set to true, the default, the AutoScalingGroup size will decrease by one. If the AutoScalingGroup is associated with a LoadBalancer, the system will deregister the instance before terminating it.
+      # This call simply registers a termination request. The termination of the instance can not happen immediately.
+      #
+      # @option options [String] :instance_id (nil) the instance id to terminate
+      # @option options [String] :decrement_desired_capacity (nil) specified whether terminating this instance should also decrement the size of the autoscaling group
+      def terminate_instance_in_autoscaling_group( options = {} )
+        raise ArgumentError, "No :instance_id provided" if options[:instance_id].nil? || options[:instance_id].empty?
+
+        params = {}
+        params['InstanceId'] = options[:instance_id]
+        params['ShouldDecrementDesiredCapacity'] = options[:decrement_desired_capacity].to_s if options.has_key?(:decrement_desired_capacity)
+
+        return response_generator(:action => "TerminateInstanceInAutoScalingGroup", :params => params)
+      end
+
+      # Creates a new AutoScalingGroup with the specified name.
+      # Updates the configuration for the given AutoScalingGroup. If MaxSize is lower than the current size, then there will be an implicit call to SetDesiredCapacity to set the group to the new MaxSize. The same is true for MinSize there will also be an implicit call to SetDesiredCapacity. All optional parameters are left unchanged if not passed in the request.=
+      # The new settings are registered upon the completion of this call. Any launch configuration settings will take effect on any triggers after this call returns. However, triggers that are currently in progress can not be affected. See key term Trigger.
+      #
+      # @option options [String] :autoscaling_group_name (nil) the name of the autoscaling group
+      # @option options [Array] :availability_zones (nil) The availability_zones for the group
+      # @option options [String] :launch_configuration_name (nil) the name of the launch_configuration group
+      # @option options [String] :min_size (nil) minimum size of the group
+      # @option options [String] :max_size (nil) the maximum size of the group
+      # @option options [String] :cooldown (nil) the amount of time after a scaling activity complese before any further trigger-related scaling activities can start
+      def update_autoscaling_group( options = {})
+        raise ArgumentError, "No :autoscaling_group_name provided" if options[:autoscaling_group_name].nil? || options[:autoscaling_group_name].empty?
+
+        params = {}
+
+        params.merge!(pathlist('AvailabilityZones.member', [options[:availability_zones]].flatten)) if options.has_key?(:availability_zones)
+        params['LaunchConfigurationName'] = options[:launch_configuration_name] if options.has_key?(:launch_configuration_name)
+        params['AutoScalingGroupName'] = options[:autoscaling_group_name]
+        params['MinSize'] = options[:min_size] if options.has_key?(:min_size)
+        params['MaxSize'] = options[:max_size] if options.has_key?(:max_size)
+        params['CoolDown'] = options[:cooldown]  if options.has_key?(:cooldown)
+
+        return response_generator(:action => "UpdateAutoScalingGroup", :params => params)
+
+      end
+
+    end
+  end
+end
+

data/lib/AWS/Cloudwatch.rb

@@ -0,0 +1,32 @@
+module AWS
+  module Cloudwatch
+
+    # Which host FQDN will we connect to for all API calls to AWS?
+    # If AWS_CLOUDWATCH_URL is defined in the users ENV we can override the default with that.
+    #
+    # @example
+    #   export AWS_CLOUDWATCH_URL='https://montoring.amazonaws.com'
+    if ENV['AWS_CLOUDWATCH_URL']
+      AWS_CLOUDWATCH_URL = ENV['AWS_CLOUDWATCH_URL']
+      VALID_HOSTS = ['monitoring.amazonaws.com']
+      raise ArgumentError, "Invalid AWS_CLOUDWATCH_URL environment variable : #{AWS_CLOUDWATCH_URL}" unless VALID_HOSTS.include?(AWS_CLOUDWATCH_URL)
+      DEFAULT_HOST = URI.parse(AWS_CLOUDWATCH_URL).host
+    else
+      # Default US API endpoint
+      DEFAULT_HOST = 'monitoring.amazonaws.com'
+    end
+
+    API_VERSION = '2009-05-15'
+
+    class Base < AWS::Base
+      def api_version
+        API_VERSION
+      end
+
+      def default_host
+        DEFAULT_HOST
+      end
+    end
+
+  end
+end

data/lib/AWS/Cloudwatch/monitoring.rb

@@ -0,0 +1,80 @@
+module AWS
+  module Cloudwatch
+    class Base < AWS::Base
+
+      # This method call lists available Cloudwatch metrics attached to your EC2
+      # account. To get further information from the metrics, you'll then need to
+      # call get_metric_statistics.
+      #
+      # there are no options available to this method.
+
+      def list_metrics
+        raise ArgumentError, "Server must be monitoring.amazonaws.com" if server != 'monitoring.amazonaws.com'
+        return response_generator(:action => 'ListMetrics', :params => {})
+      end
+
+      # get_metric_statistics pulls a hashed array from Cloudwatch with the stats
+      # of your requested metric.
+      # Once you get the data out, if you assign the results into an object like:
+      # res = @mon.get_metric_statistics(:measure_name => 'RequestCount', \
+      #     :statistics => 'Average', :namespace => 'AWS/ELB')
+      #
+      # This call gets the average request count against your ELB at each sampling period
+      # for the last 24 hours. You can then attach a block to the following iterator
+      # to do whatever you need to:
+      # res['GetMetricStatisticsResult']['Datapoints']['member'].each
+      #
+      # @option options [String] :custom_unit (nil) not currently available, placeholder
+      # @option options [String] :dimensions (nil) Option to filter your data on. Check the developer guide
+      # @option options [Time] :end_time (Time.now()) Outer bound of the date range you want to view
+      # @option options [String] :measure_name (nil) The measure you want to check. Must correspond to
+      # =>                                           provided options
+      # @option options [String] :namespace ('AWS/EC2') The namespace of your measure_name. Currently, 'AWS/EC2' and 'AWS/ELB' are available
+      # @option options [Integer] :period (60) Granularity in seconds of the returned datapoints. Multiples of 60 only
+      # @option options [String] :statistics (nil) The statistics to be returned for your metric. See the developer guide for valid options. Required.
+      # @option options [Time] :start_time (Time.now() - 86400) Inner bound of the date range you want to view. Defaults to 24 hours ago
+      # @option options [String] :unit (nil) Standard unit for a given Measure. See the developer guide for valid options.
+
+
+      def get_metric_statistics ( options ={} )
+        options = { :custom_unit => nil,
+                    :dimensions => nil,
+                    :end_time => Time.now(),      #req
+                    :measure_name => "",          #req
+                    :namespace => "AWS/EC2",
+                    :period => 60,
+                    :statistics => "",            # req
+                    :start_time => (Time.now() - 86400), # Default to yesterday
+                    :unit => "" }.merge(options)
+
+        raise ArgumentError, ":end_time must be provided" if options[:end_time].nil?
+        raise ArgumentError, ":end_time must be a Time object" if options[:end_time].class != Time
+        raise ArgumentError, ":start_time must be provided" if options[:start_time].nil?
+        raise ArgumentError, ":start_time must be a Time object" if options[:start_time].class != Time
+        raise ArgumentError, "Server must be monitoring.amazonaws.com" if server != 'monitoring.amazonaws.com'
+        raise ArgumentError, ":start_time must be before :end_time" if options[:start_time] > options[:end_time]
+        raise ArgumentError, ":measure_name must be provided" if options[:measure_name].nil? || options[:measure_name].empty?
+        raise ArgumentError, ":statistics must be provided" if options[:statistics].nil? || options[:statistics].empty?
+
+        params = {
+                    "CustomUnit" => options[:custom_unit],
+                    "Dimensions" => options[:dimensions],
+                    "EndTime" => options[:end_time].iso8601,
+                    "MeasureName" => options[:measure_name],
+                    "Namespace" => options[:namespace],
+                    "Period" => options[:period].to_s,
+                    "Statistics.member.1" => options[:statistics],
+                    "StartTime" => options[:start_time].iso8601,
+                    "Unit" => options[:unit]
+        }
+
+        return response_generator(:action => 'GetMetricStatistics', :params => params)
+
+      end
+
+    end
+
+  end
+
+end
+

data/lib/AWS/EC2.rb

@@ -16,7 +16,7 @@ module AWS
       DEFAULT_HOST = 'ec2.amazonaws.com'
     end
 
-    API_VERSION = '2008-12-01'
+    API_VERSION = '2009-07-15'
 
     class Base < AWS::Base
       def api_version

data/lib/AWS/EC2/instances.rb

@@ -171,6 +171,41 @@ module AWS
 
       end
 
+
+      # The MonitorInstances operation tells Cloudwatch to begin logging metrics from one or more EC2 instances
+      #
+      # @option options [Array] :instance_id ([])
+      #
+      def monitor_instances( options = {} )
+
+        options = { :instance_id => [] }.merge(options)
+
+        raise ArgumentError, "No :instance_id provided" if options[:instance_id].nil? || options[:instance_id].empty?
+
+        params = pathlist("InstanceId", options[:instance_id])
+
+        return response_generator(:action => "MonitorInstances", :params => params)
+
+      end
+
+
+
+      # The UnmonitorInstances operation tells Cloudwatch to stop logging metrics from one or more EC2 instances
+      #
+      # @option options [Array] :instance_id ([])
+      #
+      def unmonitor_instances( options = {} )
+
+        options = { :instance_id => [] }.merge(options)
+
+        raise ArgumentError, "No :instance_id provided" if options[:instance_id].nil? || options[:instance_id].empty?
+
+        params = pathlist("InstanceId", options[:instance_id])
+
+        return response_generator(:action => "UnmonitorInstances", :params => params)
+
+      end
+
     end
 
   end

data/lib/AWS/ELB.rb

@@ -26,6 +26,45 @@ module AWS
       def default_host
         DEFAULT_HOST
       end
+      
+      # Raises the appropriate error if the specified Net::HTTPResponse object
+      # contains an Amazon EC2 error; returns +false+ otherwise.
+      def aws_error?(response)
+
+        # return false if we got a HTTP 200 code,
+        # otherwise there is some type of error (40x,50x) and
+        # we should try to raise an appropriate exception
+        # from one of our exception classes defined in
+        # exceptions.rb
+        return false if response.is_a?(Net::HTTPSuccess)
+
+        # parse the XML document so we can walk through it
+        doc = REXML::Document.new(response.body)
+
+        # Check that the Error element is in the place we would expect.
+        # and if not raise a generic error exception
+        unless doc.root.elements[1].name == "Error"
+          raise Error, "Unexpected error format. response.body is: #{response.body}"
+        end
+
+        # An valid error response looks like this:
+        # <?xml version="1.0"?><Response><Errors><Error><Code>InvalidParameterCombination</Code><Message>Unknown parameter: foo</Message></Error></Errors><RequestID>291cef62-3e86-414b-900e-17246eccfae8</RequestID></Response>
+        # AWS EC2 throws some exception codes that look like Error.SubError.  Since we can't name classes this way
+        # we need to strip out the '.' in the error 'Code' and we name the error exceptions with this
+        # non '.' name as well.
+        error_code    = doc.root.elements['//ErrorResponse/Error/Code'].text.gsub('.', '')
+        error_message = doc.root.elements['//ErrorResponse/Error/Message'].text
+
+        # Raise one of our specific error classes if it exists.
+        # otherwise, throw a generic EC2 Error with a few details.
+        if AWS.const_defined?(error_code)
+          raise AWS.const_get(error_code), error_message
+        else
+          raise AWS::Error, error_message
+        end
+
+      end
+      
     end
 
   end

data/test/test_Autoscaling_groups.rb

@@ -0,0 +1,336 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "autoscaling " do
+  before do
+    @as = AWS::Autoscaling::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+
+    @valid_create_launch_configuration_params = {
+      :image_id => "ami-ed46a784",
+      :launch_configuration_name => "TestAutoscalingGroupName",
+      :instance_type => "m1.small"
+    }
+
+    @error_response_for_creation = <<-RESPONSE
+<ErrorResponse xmlns="http://autoscaling.amazonaws.com/doc/2009-05-15/">
+  <Error>
+    <Type>Sender</Type>
+    <Code>AlreadyExists</Code>
+    <Message>Launch Configuration by this name already exists - A launch configuration already exists with the name TestAutoscalingGroupName</Message>
+  </Error>
+  <RequestId>31d00b03-ad6a-11de-a47f-a5c562feca13</RequestId>
+</ErrorResponse>
+    RESPONSE
+
+    @delete_launch_configuration_response = <<-RESPONSE
+  <DeleteLaunchConfigurationResponse xmlns="http://autoscaling.amazonaws.com/doc/2009-05-15/">
+    <ResponseMetadata>
+      <RequestId>5f5717d3-ad6c-11de-b1c0-1b00aadc5f72</RequestId>
+    </ResponseMetadata>
+  </DeleteLaunchConfigurationResponse>
+    RESPONSE
+
+    @create_launch_configuration_response = "<CreateLaunchConfigurationResponse xmlns=\"http://autoscaling.amazonaws.com/doc/2009-05-15/\">\n  <ResponseMetadata>\n    <RequestId>6062466f-ad6c-11de-b82f-996c936914c5</RequestId>\n  </ResponseMetadata>\n</CreateLaunchConfigurationResponse>\n"
+
+    @create_autoscaling_group_response = "<CreateAutoScalingGroupResponse xmlns=\"http://autoscaling.amazonaws.com/doc/2009-05-15/\">\n  <ResponseMetadata>\n    <RequestId>cc4f9960-ad6e-11de-b82f-996c936914c5</RequestId>\n  </ResponseMetadata>\n</CreateAutoScalingGroupResponse>\n"
+
+    @delete_autoscaling_group = "<DeleteAutoScalingGroupResponse  xmlns=\"http://autoscaling.amazonaws.com/doc/2009-05-15/\">
+<ResponseMetadata><RequestId>e64fc4c3-e10b-11dd-a73e-2d774d6aee71</RequestId></ResponseMetadata></DeleteAutoScalingGroupResponse>"
+    @create_or_update_trigger_response = "<CreateOrUpdateScalingTriggerResponse  xmlns=\"http://autoscaling.amazonaws.com/doc/2009-05-15/\">
+      <ResponseMetadata>
+        <RequestId>503d309d-e10b-11dd-a73e-2d774d6aee71</RequestId>
+      </ResponseMetadata>
+    </CreateOrUpdateScalingTriggerResponse>"
+  end
+
+  specify "AWS::Autoscaling::Base should give back a nice response if there is an error" do
+    @as.stubs(:make_request).with('CreateLaunchConfiguration', {
+      'ImageId' => 'ami-ed46a784',
+      'LaunchConfigurationName' => 'TestAutoscalingGroupName',
+      'InstanceType' => "m1.small"
+    }).returns stub(:body => @error_response_for_creation, :is_a? => true)
+
+    response = @as.create_launch_configuration( :image_id => "ami-ed46a784", :launch_configuration_name => "TestAutoscalingGroupName", :instance_type => "m1.small")
+    response.should.be.an.instance_of Hash
+    response["Error"]["Message"].should.equal "Launch Configuration by this name already exists - A launch configuration already exists with the name TestAutoscalingGroupName"
+  end
+
+  specify "AWS::Autoscaling::Base should destroy a launch configuration just fine" do
+    @as.stubs(:make_request).with('DeleteLaunchConfiguration', {
+      'LaunchConfigurationName' => 'TestAutoscalingGroupName1'
+    }).returns stub(:body => @delete_launch_configuration_response, :is_a? => true)
+
+    response = @as.delete_launch_configuration( :launch_configuration_name => "TestAutoscalingGroupName1" )
+    response.should.be.an.instance_of Hash
+  end
+
+  specify "AWS::Autoscaling::Base should create a launch configuration" do
+    @as.stubs(:make_request).with('CreateLaunchConfiguration', {
+      'ImageId' => 'ami-ed46a784',
+      'LaunchConfigurationName' => 'CustomTestAutoscalingGroupName',
+      'InstanceType' => "m1.small"
+    }).returns stub(:body => @create_launch_configuration_response, :is_a? => true)
+
+    response = @as.create_launch_configuration( :image_id => "ami-ed46a784", :launch_configuration_name => "CustomTestAutoscalingGroupName", :instance_type => "m1.small")
+    response.should.be.an.instance_of Hash
+  end
+
+  specify "AWS::Autoscaling::Base should be able to create a new autoscaling group" do
+    @as.stubs(:make_request).with("CreateAutoScalingGroup", {
+      'AutoScalingGroupName' => 'CloudteamTestAutoscalingGroup1',
+      'AvailabilityZones.member.1' => 'us-east-1a',
+      'LoadBalancerNames' => 'TestLoadBalancerName',
+      'LaunchConfigurationName' => 'CloudteamTestAutoscaling',
+      'MinSize' => "1", 'MaxSize' => "3"
+    }).returns stub(:body => @create_autoscaling_group_response, :is_a? => true)
+    response = @as.create_autoscaling_group(:autoscaling_group_name => "CloudteamTestAutoscalingGroup1", :availability_zones => "us-east-1a", :load_balancer_names => "TestLoadBalancerName", :launch_configuration_name => "CloudteamTestAutoscaling", :min_size => 1, :max_size => 3)
+    response.should.be.an.instance_of Hash
+  end
+
+  specify "AWS::Autoscaling::Base should destroy an autoscaling group" do
+    @as.stubs(:make_request).with('DeleteAutoScalingGroup', {
+      'AutoScalingGroupName' => 'TestAutoscalingGroupName1'
+    }).returns stub(:body => @delete_autoscaling_group, :is_a? => true)
+
+    response = @as.delete_autoscaling_group( :autoscaling_group_name => "TestAutoscalingGroupName1" )
+    response.should.be.an.instance_of Hash
+  end
+
+  specify "AWS::Autoscaling::Base should be able to create a new scaling trigger" do
+    @as.stubs(:make_request).with("CreateOrUpdateScalingTrigger", {
+      'AutoScalingGroupName' => 'AutoScalingGroupName',
+      'Unit' => "Seconds",
+      'Dimensions.member.1.Name' => "AutoScalingGroupName",
+      'Dimensions.member.1.Value' => "Bob",
+      'MeasureName' => "CPUUtilization",
+      'Statistic' => 'Average',
+      'Period' => '120',
+      'TriggerName' => "AFunNameForATrigger",
+      'LowerThreshold' => "0.2",
+      'LowerBreachScaleIncrement' => "-1",
+      'UpperThreshold' => "1.5",
+      'UpperBreachScaleIncrement' => "1",
+      'BreachDuration' => "120"
+    }).returns stub(:body => @create_or_update_trigger_response, :is_a? => true)
+
+    valid_create_or_update_scaling_trigger_params = {:autoscaling_group_name => "AutoScalingGroupName", :dimensions => {:name => "AutoScalingGroupName", :value => "Bob"}, :unit => "Seconds", :measure_name => "CPUUtilization", :statistic => "Average", :period => 120, :trigger_name => "AFunNameForATrigger", :lower_threshold => 0.2, :lower_breach_scale_increment => "-1", :upper_threshold => 1.5, :upper_breach_scale_increment => 1, :breach_duration => 120}
+
+    %w(dimensions autoscaling_group_name measure_name statistic period trigger_name lower_threshold lower_breach_scale_increment upper_threshold upper_breach_scale_increment breach_duration).each do |meth_str|
+      lambda { @as.create_or_updated_scaling_trigger(valid_create_or_update_scaling_trigger_params.merge(meth_str.to_sym=>nil)) }.should.raise(AWS::ArgumentError)
+    end
+
+    response = @as.create_or_updated_scaling_trigger(valid_create_or_update_scaling_trigger_params)
+    response.should.be.an.instance_of Hash
+  end
+
+  specify "AWS::Autoscaling::Base should destroy a launch configuration group" do
+    @as.stubs(:make_request).with('DeleteLaunchConfiguration', {
+      'LaunchConfigurationName' => 'LaunchConfiguration'
+    }).returns stub(:body => " <DeleteLaunchConfigurationResponse  xmlns=\"http://autoscaling.amazonaws.com/doc/2009-05-15/\">
+<ResponseMetadata><RequestId>e64fc4c3-e10b-11dd-a73e-2d774d6aee71</RequestId></ResponseMetadata>
+</DeleteLaunchConfigurationResponse>", :is_a? => true)
+
+    response = @as.delete_launch_configuration( :launch_configuration_name => "LaunchConfiguration" )
+    response.should.be.an.instance_of Hash
+  end
+
+    specify "AWS::Autoscaling::Base should destroy a scaling trigger" do
+      @as.stubs(:make_request).with('DeleteTrigger', {
+        'TriggerName' => 'DeletingTrigger', 'AutoScalingGroupName' => "Name"
+      }).returns stub(:body => "  <DeleteTriggerResponse  xmlns=\"http://autoscaling.amazonaws.com/doc/2009-05-15/\">
+          <ResponseMetadata>
+            <RequestId>cca38097-e10b-11dd-a73e-2d774d6aee71</RequestId>
+          </ResponseMetadata>
+        </DeleteTriggerResponse>", :is_a? => true)
+
+      response = @as.delete_trigger( :trigger_name => "DeletingTrigger", :autoscaling_group_name => "Name" )
+      response.should.be.an.instance_of Hash
+    end
+
+    specify "AWS::Autoscaling::Base should describe the autoscaling groups" do
+      @as.stubs(:make_request).with('DescribeAutoScalingGroups', {
+        'AutoScalingGroupNames.member.1' => "webtier"
+      }).returns stub(:body => "<DescribeAutoScalingGroupsResponse  xmlns=\"http://autoscaling.amazonaws.com/doc/2009-05-15/\">
+          <DescribeAutoScalingGroupsResult>
+            <AutoScalingGroups>
+              <member>
+                <MinSize>0</MinSize>
+                <CreatedTime>2009-01-13T00:38:54Z</CreatedTime>
+                <AvailabilityZones>
+        	         <member>us-east-1c</member>
+                </AvailabilityZones>
+                <Cooldown>0</Cooldown>
+                <LaunchConfigurationName>wt20080929</LaunchConfigurationName>
+                <AutoScalingGroupName>webtier</AutoScalingGroupName>
+                <DesiredCapacity>1</DesiredCapacity>
+                <Instances>
+                  <member>
+                    <InstanceId>i-8fa224e6</InstanceId>
+                    <LifecycleState>InService</LifecycleState>
+                    <AvailabilityZone>us-east-1c</AvailabilityZone>
+                    </member>
+                </Instances>
+                <MaxSize>1</MaxSize>
+              </member>
+            </AutoScalingGroups>
+          </DescribeAutoScalingGroupsResult>
+          <ResponseMetadata>
+            <RequestId>70f2e8af-e10b-11dd-a73e-2d774d6aee71</RequestId>
+          </ResponseMetadata>
+        </DescribeAutoScalingGroupsResponse>", :is_a? => true)
+
+      response = @as.describe_autoscaling_groups( :autoscaling_group_names => ["webtier"] )
+      response.should.be.an.instance_of Hash
+    end
+
+    specify "AWS::Autoscaling::Base should describe the launch configurations" do
+      @as.stubs(:make_request).with('DescribeLaunchConfigurations', {
+        'AutoScalingGroupNames.member.1' => "webtier"
+      }).returns stub(:body => "<DescribeLaunchConfigurationsResponse  xmlns=\"http://autoscaling.amazonaws.com/doc/2009-05-15/\">
+          <DescribeLaunchConfigurationsResult>
+            <LaunchConfigurations>
+              <member>
+                <InstanceType>m1.small</InstanceType>
+                <BlockDeviceMappings/>
+                <KeyName/>
+                <SecurityGroups/>
+                <ImageId>ami-f7c5219e</ImageId>
+                <RamdiskId/>
+                <CreatedTime>2009-01-13T00:35:31Z</CreatedTime>
+                <KernelId/>
+                <LaunchConfigurationName>wt20080929</LaunchConfigurationName>
+                <UserData/>
+              </member>
+            </LaunchConfigurations>
+          </DescribeLaunchConfigurationsResult>
+          <ResponseMetadata>
+            <RequestId>2e14cb6c-e10a-11dd-a73e-2d774d6aee71</RequestId>
+          </ResponseMetadata>
+        </DescribeLaunchConfigurationsResponse>", :is_a? => true)
+
+      response = @as.describe_launch_configurations( :launch_configuration_names => ["webtier"] )
+      response.should.be.an.instance_of Hash
+    end
+
+
+    specify "AWS::Autoscaling::Base should describe the launch configurations" do
+      @as.stubs(:make_request).with('DescribeScalingActivities', {
+        'AutoScalingGroupName' => "webtier"
+      }).returns stub(:body => "<DescribeScalingActivitiesResponse  xmlns=\"http://autoscaling.amazonaws.com/doc/2009-05-15/\">
+          <DescribeScalingActivitiesResult>
+            <Activities>
+              <member>
+                <ActivityId>885b2900-0f2e-497a-8ec6-b1b90a9ddee0</ActivityId>
+                <StartTime>2009-03-29T04:07:07Z</StartTime>
+                <Progress>0</Progress>
+                <StatusCode>InProgress</StatusCode>
+                <Cause>Automated Capacity Adjustment</Cause>
+                <Description>Launching a new EC2 instance</Description>
+              </member>
+            </Activities>
+          </DescribeScalingActivitiesResult>
+          <ResponseMetadata>
+            <RequestId>f0321780-e10a-11dd-a73e-2d774d6aee71</RequestId>
+          </ResponseMetadata>
+        </DescribeScalingActivitiesResponse>", :is_a? => true)
+
+      response = @as.describe_scaling_activities( :autoscaling_group_name => "webtier" )
+      response.should.be.an.instance_of Hash
+    end
+
+    specify "AWS::Autoscaling::Base should describe triggers" do
+      @as.stubs(:make_request).with('DescribeTriggers', {
+        'AutoScalingGroupName' => "webtier"
+      }).returns stub(:body => "  <DescribeTriggersResponse  xmlns=\"http://autoscaling.amazonaws.com/doc/2009-05-15/\">
+          <DescribeTriggersResult>
+            <Triggers>
+              <member>
+                <BreachDuration>300</BreachDuration>
+                 <UpperBreachScaleIncrement>1</UpperBreachScaleIncrement>
+                <CreatedTime>2009-01-13T00:44:19Z</CreatedTime>
+                <UpperThreshold>60.0</UpperThreshold>
+                <Status>NoData</Status>
+                <LowerThreshold>0.0</LowerThreshold>
+                <Period>60</Period>
+                <LowerBreachScaleIncrement>-1</LowerBreachScaleIncrement>
+                <TriggerName>tenpct</TriggerName>
+                <Statistic>Average</Statistic>
+                <Unit>None</Unit>
+                <Namespace>AWS/EC2</Namespace>
+                <Dimensions>
+
+                  <member>
+                    <Name>AutoScalingGroupName</Name>
+                    <Value>webtier</Value>
+                  </member>
+                </Dimensions>
+                <AutoScalingGroupName>webtier</AutoScalingGroupName>
+                <MeasureName>CPUUtilization</MeasureName>
+              </member>
+            </Triggers>
+          </DescribeTriggersResult>
+          <ResponseMetadata>
+            <RequestId>5c33c82a-e10b-11dd-a73e-2d774d6aee71</RequestId>
+          </ResponseMetadata>
+        </DescribeTriggersResponse>", :is_a? => true)
+
+      response = @as.describe_triggers( :autoscaling_group_name => "webtier" )
+      response.should.be.an.instance_of Hash
+    end
+
+    specify "AWS::Autoscaling::Base should describe triggers" do
+      @as.stubs(:make_request).with('SetDesiredCapacity', {
+        'AutoScalingGroupName' => "name", 'DesiredCapacity' => '10'
+      }).returns stub(:body => "  <SetDesiredCapacityResponse  xmlns=\"http://autoscaling.amazonaws.com/doc/2009-05-15/\">
+          <ResponseMetadata>
+            <RequestId>d3f2091c-e10a-11dd-a73e- 2d774d6aee71</RequestId>
+          </ResponseMetadata>
+        </SetDesiredCapacityResponse>
+      ", :is_a? => true)
+
+      response = @as.set_desired_capacity( :autoscaling_group_name => "name", :desired_capacity => "10" )
+      response.should.be.an.instance_of Hash
+    end
+
+
+    specify "AWS::Autoscaling::Base should terminate an instance in an autoscaling group" do
+      @as.stubs(:make_request).with('TerminateInstanceInAutoScalingGroup', {
+        'InstanceId' => "i-instance1"
+      }).returns stub(:body => "  <DescribeTriggersResponse  xmlns=\"http://autoscaling.amazonaws.com/doc/2009-05-15/\">
+          <DescribeTriggersResult>
+            <Triggers>
+              <member>
+                <BreachDuration>300</BreachDuration>
+                 <UpperBreachScaleIncrement>1</UpperBreachScaleIncrement>
+                <CreatedTime>2009-01-13T00:44:19Z</CreatedTime>
+                <UpperThreshold>60.0</UpperThreshold>
+                <Status>NoData</Status>
+                <LowerThreshold>0.0</LowerThreshold>
+                <Period>60</Period>
+                <LowerBreachScaleIncrement>-1</LowerBreachScaleIncrement>
+                <TriggerName>tenpct</TriggerName>
+                <Statistic>Average</Statistic>
+                <Unit>None</Unit>
+                <Namespace>AWS/EC2</Namespace>
+                <Dimensions>
+
+                  <member>
+                    <Name>AutoScalingGroupName</Name>
+                    <Value>webtier</Value>
+                  </member>
+                </Dimensions>
+                <AutoScalingGroupName>webtier</AutoScalingGroupName>
+                <MeasureName>CPUUtilization</MeasureName>
+              </member>
+            </Triggers>
+          </DescribeTriggersResult>
+          <ResponseMetadata>
+            <RequestId>5c33c82a-e10b-11dd-a73e-2d774d6aee71</RequestId>
+          </ResponseMetadata>
+        </DescribeTriggersResponse>", :is_a? => true)
+
+      response = @as.terminate_instance_in_autoscaling_group( :instance_id => "i-instance1" )
+      response.should.be.an.instance_of Hash
+    end
+
+
+end

data/test/test_EC2_instances.rb

@@ -139,6 +139,47 @@ context "EC2 instances " do
       </instancesSet>
     </TerminateInstancesResponse>
     RESPONSE
+
+    @monitor_instances_response_body = <<-RESPONSE
+    <MonitorInstancesResponse xmlns="http://ec2.amazonaws.com/doc/2009-07-15/">
+        <requestId>fe62a64c-49fb-4a3c-8d9b-61aba146d390</requestId>
+        <instancesSet>
+            <item>
+                <instanceId>i-138fc47a</instanceId>
+                <monitoring>
+                    <state>pending</state>
+                </monitoring>
+            </item>
+            <item>
+                <instanceId>i-33457a5a</instanceId>
+                <monitoring>
+                    <state>pending</state>
+                </monitoring>
+            </item>
+        </instancesSet>
+    </MonitorInstancesResponse>
+    RESPONSE
+
+    @unmonitor_instances_response_body = <<-RESPONSE
+    <UnmonitorInstancesResponse xmlns="http://ec2.amazonaws.com/doc/2009-07-15/">
+        <requestId>7dbc5095-f3ae-46d8-a5b1-19df118ceb05</requestId>
+        <instancesSet>
+            <item>
+                <instanceId>i-138fc47a</instanceId>
+                <monitoring>
+                    <state>disabling</state>
+                </monitoring>
+            </item>
+            <item>
+                <instanceId>i-33457a5a</instanceId>
+                <monitoring>
+                    <state>disabling</state>
+                </monitoring>
+            </item>
+        </instancesSet>
+    </UnmonitorInstancesResponse>
+
+    RESPONSE
   end
 
 
@@ -345,4 +386,44 @@ context "EC2 instances " do
     @response.instancesSet.item[1].previousState.name.should.equal "pending"
   end
 
+  specify "method monitor_instances should raise an exception when called without nil/empty string arguments" do
+    lambda { @ec2.monitor_instances() }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.monitor_instances( :instance_id => nil ) }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.monitor_instances( :instance_id => "" ) }.should.raise(AWS::ArgumentError)
+  end
+
+  specify "should be able to be monitored when provided with an :instance_id" do
+    @ec2.stubs(:make_request).with('MonitorInstances', {"InstanceId.1"=>"i-138fc47a", "InstanceId.2"=>"i-33457a5a"}).
+      returns stub(:body => @monitor_instances_response_body, :is_a? => true)
+    @ec2.monitor_instances( :instance_id => ["i-138fc47a", "i-33457a5a"] ).class.should.equal Hash
+
+    @response = @ec2.monitor_instances( :instance_id => ["i-138fc47a", "i-33457a5a"] )
+
+    @response.instancesSet.item[0].instanceId.should.equal "i-138fc47a"
+    @response.instancesSet.item[0].monitoring.state.should.equal "pending"
+
+    @response.instancesSet.item[1].instanceId.should.equal "i-33457a5a"
+    @response.instancesSet.item[1].monitoring.state.should.equal "pending"
+  end
+
+  specify "method unmonitor_instances should raise an exception when called without nil/empty string arguments" do
+    lambda { @ec2.unmonitor_instances() }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.unmonitor_instances( :instance_id => nil ) }.should.raise(AWS::ArgumentError)
+    lambda { @ec2.unmonitor_instances( :instance_id => "" ) }.should.raise(AWS::ArgumentError)
+  end
+
+  specify "should be able to be unmonitored when provided with an :instance_id" do
+    @ec2.stubs(:make_request).with('UnmonitorInstances', {"InstanceId.1"=>"i-138fc47a", "InstanceId.2"=>"i-33457a5a"}).
+      returns stub(:body => @unmonitor_instances_response_body, :is_a? => true)
+    @ec2.unmonitor_instances( :instance_id => ["i-138fc47a", "i-33457a5a"] ).class.should.equal Hash
+
+    @response = @ec2.unmonitor_instances( :instance_id => ["i-138fc47a", "i-33457a5a"] )
+
+    @response.instancesSet.item[0].instanceId.should.equal "i-138fc47a"
+    @response.instancesSet.item[0].monitoring.state.should.equal "disabling"
+
+    @response.instancesSet.item[1].instanceId.should.equal "i-33457a5a"
+    @response.instancesSet.item[1].monitoring.state.should.equal "disabling"
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: amazon-ec2
 version: !ruby/object:Gem::Version 
-  version: 0.5.5
+  version: 0.6.0
 platform: ruby
 authors: 
 - Glenn Rempe
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-20 00:00:00 -07:00
+date: 2009-09-30 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -62,7 +62,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.1.6
     version: 
-description: A Ruby library for accessing the Amazon Web Services Elastic Compute Cloud (EC2) and Elastic Load Balancer (ELB) API's.
+description: A Ruby library for accessing the Amazon Web Services Elastic Compute Cloud (EC2), Elastic Load Balancer (ELB), Cloudwatch, and Autoscaling API's.
 email: glenn@rempe.us
 executables: 
 - ec2-gem-example.rb
@@ -92,6 +92,10 @@ files:
 - bin/setup.rb
 - deps.rip
 - lib/AWS.rb
+- lib/AWS/Autoscaling.rb
+- lib/AWS/Autoscaling/autoscaling.rb
+- lib/AWS/Cloudwatch.rb
+- lib/AWS/Cloudwatch/monitoring.rb
 - lib/AWS/EC2.rb
 - lib/AWS/EC2/availability_zones.rb
 - lib/AWS/EC2/console.rb
@@ -112,6 +116,7 @@ files:
 - perftools/ec2prof-results.dot
 - perftools/ec2prof-results.txt
 - perftools/ec2prof.symbols
+- test/test_Autoscaling_groups.rb
 - test/test_EC2.rb
 - test/test_EC2_availability_zones.rb
 - test/test_EC2_console.rb
@@ -165,6 +170,7 @@ signing_key:
 specification_version: 3
 summary: Amazon EC2 Ruby Gem
 test_files: 
+- test/test_Autoscaling_groups.rb
 - test/test_EC2.rb
 - test/test_EC2_availability_zones.rb
 - test/test_EC2_console.rb