newrelic-amazon-ec2 0.6.2

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,89 @@
+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],
+                    "EndTime" => options[:end_time].iso8601,
+                    "MeasureName" => options[:measure_name],
+                    "Namespace" => options[:namespace],
+                    "Period" => options[:period].to_s,
+                    "StartTime" => options[:start_time].iso8601,
+                    "Unit" => options[:unit]
+        }
+
+        options[:statistics].each_index do |x|
+          params['Statistics.member.' + (x + 1).to_s] = options[:statistics][x]
+        end
+
+        index = 1
+        options[:dimensions].each_pair do |k, v|
+          params['Dimensions.member.' + index.to_s + '.Name'] = k
+          params['Dimensions.member.' + index.to_s + '.Value'] = v
+          index += 1
+        end
+
+        return response_generator(:action => 'GetMetricStatistics', :params => params)
+
+      end
+
+    end
+
+  end
+
+end
+

data/lib/AWS/EC2.rb

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

data/lib/AWS/EC2/availability_zones.rb

@@ -0,0 +1,21 @@
+module AWS
+  module EC2
+    class Base < AWS::Base
+
+      # The DescribeAvailabilityZones operation describes availability zones that are currently
+      # available to the account and their states.
+      #
+      # An optional list of zone names can be passed.
+      #
+      # @option options [optional, String] :zone_name ([]) an Array of zone names
+      #
+      def describe_availability_zones( options = {} )
+        options = { :zone_name => [] }.merge(options)
+        params = pathlist("ZoneName", options[:zone_name] )
+        return response_generator(:action => "DescribeAvailabilityZones", :params => params)
+      end
+
+    end
+  end
+end
+

data/lib/AWS/EC2/console.rb

@@ -0,0 +1,23 @@
+module AWS
+  module EC2
+    class Base < AWS::Base
+
+      # The GetConsoleOutput operation retrieves console output that has been posted for the specified instance.
+      #
+      # Instance console output is buffered and posted shortly after instance boot, reboot and once the instance
+      # is terminated. Only the most recent 64 KB of posted output is available. Console output is available for
+      # at least 1 hour after the most recent post.
+      #
+      # @option options [String] :instance_id ("") an Instance ID
+      #
+      def get_console_output( options = {} )
+        options = {:instance_id => ""}.merge(options)
+        raise ArgumentError, "No instance ID provided" if options[:instance_id].nil? || options[:instance_id].empty?
+        params = { "InstanceId" => options[:instance_id] }
+        return response_generator(:action => "GetConsoleOutput", :params => params)
+      end
+
+    end
+  end
+end
+

data/lib/AWS/EC2/elastic_ips.rb

@@ -0,0 +1,81 @@
+module AWS
+  module EC2
+    class Base < AWS::Base
+
+      # The AllocateAddress operation acquires an elastic IP address for use with your account.
+      #
+      def allocate_address
+        return response_generator(:action => "AllocateAddress")
+      end
+
+      # The DescribeAddresses operation lists elastic IP addresses assigned to your account.
+      #
+      # @option options [Array] :public_ip ([]) an IP address to be described
+      #
+      def describe_addresses( options = {} )
+        options = { :public_ip => [] }.merge(options)
+        params = pathlist("PublicIp", options[:public_ip])
+        return response_generator(:action => "DescribeAddresses", :params => params)
+      end
+
+      # The ReleaseAddress operation releases an elastic IP address associated with your account.
+      #
+      # If you run this operation on an elastic IP address that is already released, the address
+      # might be assigned to another account which will cause Amazon EC2 to return an error.
+      #
+      # Note : Releasing an IP address automatically disassociates it from any instance
+      # with which it is associated. For more information, see DisassociateAddress.
+      #
+      # Important! After releasing an elastic IP address, it is released to the IP
+      # address pool and might no longer be available to your account. Make sure
+      # to update your DNS records and any servers or devices that communicate
+      # with the address.
+      #
+      # @option options [String] :public_ip ('') an IP address to be released.
+      #
+      def release_address( options = {} )
+        options = { :public_ip => '' }.merge(options)
+        raise ArgumentError, "No ':public_ip' provided" if options[:public_ip].nil? || options[:public_ip].empty?
+        params = { "PublicIp" => options[:public_ip] }
+        return response_generator(:action => "ReleaseAddress", :params => params)
+      end
+
+      # The AssociateAddress operation associates an elastic IP address with an instance.
+      #
+      # If the IP address is currently assigned to another instance, the IP address
+      # is assigned to the new instance. This is an idempotent operation. If you enter
+      # it more than once, Amazon EC2 does not return an error.
+      #
+      # @option options [String] :instance_id ('') the instance ID to associate an IP with.
+      # @option options [String] :public_ip ('') the public IP to associate an instance with.
+      #
+      def associate_address( options = {} )
+        options = { :instance_id => '', :public_ip => '' }.merge(options)
+        raise ArgumentError, "No ':instance_id' provided" if options[:instance_id].nil? || options[:instance_id].empty?
+        raise ArgumentError, "No ':public_ip' provided" if options[:public_ip].nil? || options[:public_ip].empty?
+        params = {
+          "InstanceId" => options[:instance_id],
+          "PublicIp" => options[:public_ip]
+        }
+        return response_generator(:action => "AssociateAddress", :params => params)
+      end
+
+      # The DisassociateAddress operation disassociates the specified elastic IP
+      # address from the instance to which it is assigned. This is an idempotent
+      # operation. If you enter it more than once, Amazon EC2 does not return
+      # an error.
+      #
+      # @option options [String] :public_ip ('') the public IP to be dis-associated.
+      #
+      def disassociate_address( options = {} )
+        options = { :public_ip => '' }.merge(options)
+        raise ArgumentError, "No ':public_ip' provided" if options[:public_ip].nil? || options[:public_ip].empty?
+        params = { "PublicIp" => options[:public_ip] }
+        return response_generator(:action => "DisassociateAddress", :params => params)
+      end
+
+    end
+
+  end
+end
+

data/lib/AWS/EC2/image_attributes.rb

@@ -0,0 +1,133 @@
+module AWS
+  module EC2
+    class Base < AWS::Base
+
+      # The ModifyImageAttribute operation modifies an attribute of an AMI.  The following attributes may
+      # currently be modified:
+      #
+      # 'launchPermission' : Controls who has permission to launch the AMI. Launch permissions can be
+      # granted to specific users by adding userIds. The AMI can be made public by adding the 'all' group.
+      #
+      # 'productCodes' : Associates product codes with AMIs. This allows a developer to charge a user extra
+      # for using the AMIs. productCodes is a write once attribute - once it has been set it can not be
+      # changed or removed.  Currently only one product code is supported per AMI.
+      #
+      # @option options [String] :image_id ("")
+      # @option options [String] :attribute ("launchPermission") An attribute to modify, "launchPermission" or "productCodes"
+      # @option options [String] :operation_type ("")
+      # @option options [optional, Array] :user_id ([])
+      # @option options [optional, Array] :group ([])
+      # @option options [optional, Array] :product_code ([])
+      #
+      def modify_image_attribute( options = {} )
+
+        # defaults
+        options = { :image_id => "",
+                    :attribute => "launchPermission",
+                    :operation_type => "",
+                    :user_id => [],
+                    :group => [],
+                    :product_code => [] }.merge(options)
+
+        raise ArgumentError, "No ':image_id' provided" if options[:image_id].nil? || options[:image_id].empty?
+        raise ArgumentError, "No ':attribute' provided" if options[:attribute].nil? || options[:attribute].empty?
+
+        # OperationType is not required if modifying a product code.
+        unless options[:attribute] == 'productCodes'
+          raise ArgumentError, "No ':operation_type' provided" if options[:operation_type].nil? || options[:operation_type].empty?
+        end
+
+        params = {
+          "ImageId" => options[:image_id],
+          "Attribute" => options[:attribute],
+          "OperationType" => options[:operation_type]
+        }
+
+        # test options provided and make sure they are valid
+        case options[:attribute]
+        when "launchPermission"
+
+          unless options[:operation_type] == "add" || options[:operation_type] == "remove"
+            raise ArgumentError, ":operation_type was #{options[:operation_type].to_s} but must be either 'add' or 'remove'"
+          end
+
+          if (options[:user_id].nil? || options[:user_id].empty?) && (options[:group].nil? || options[:group].empty?)
+            raise ArgumentError, "Option :attribute=>'launchPermission' requires ':user_id' or ':group' options to also be specified"
+          end
+          params.merge!(pathlist("UserId", options[:user_id])) unless options[:user_id].nil?
+          params.merge!(pathlist("Group", options[:group])) unless options[:group].nil?
+        when "productCodes"
+          if (options[:product_code].nil? || options[:product_code].empty?)
+            raise ArgumentError, "Option :attribute=>'productCodes' requires ':product_code' to be specified"
+          end
+          params.merge!(pathlist("ProductCode", options[:product_code])) unless options[:product_code].nil?
+        else
+          raise ArgumentError, "attribute : #{options[:attribute].to_s} is not an known attribute."
+        end
+
+        return response_generator(:action => "ModifyImageAttribute", :params => params)
+
+      end
+
+      # The DescribeImageAttribute operation returns information about an attribute of an AMI.
+      #
+      # @option options [String] :image_id ("")
+      # @option options [String] :attribute ("launchPermission") An attribute to describe, "launchPermission" or "productCodes"
+      #
+      def describe_image_attribute( options = {} )
+
+        # defaults
+        options = {:image_id => "",
+                   :attribute => "launchPermission"
+                   }.merge(options)
+
+        raise ArgumentError, "No ':image_id' provided" if options[:image_id].nil? || options[:image_id].empty?
+        raise ArgumentError, "No ':attribute' provided" if options[:attribute].nil? || options[:attribute].empty?
+
+        params = { "ImageId" => options[:image_id], "Attribute" => options[:attribute] }
+
+        # test options provided and make sure they are valid
+        case options[:attribute]
+        when "launchPermission", "productCodes"
+          # these args are ok
+        else
+          raise ArgumentError, "attribute : #{options[:attribute].to_s} is not an known attribute."
+        end
+
+        return response_generator(:action => "DescribeImageAttribute", :params => params)
+
+      end
+
+
+      # The ResetImageAttribute operation resets an attribute of an AMI to its default value.
+      #
+      # @option options [String] :image_id ("")
+      # @option options [String] :attribute ("launchPermission") An attribute to reset
+      #
+      def reset_image_attribute( options = {} )
+
+        # defaults
+        options = {:image_id => "",
+                   :attribute => "launchPermission"}.merge(options)
+
+        raise ArgumentError, "No ':image_id' provided" if options[:image_id].nil? || options[:image_id].empty?
+        raise ArgumentError, "No ':attribute' provided" if options[:attribute].nil? || options[:attribute].empty?
+
+        params = {"ImageId" => options[:image_id],
+                  "Attribute" => options[:attribute] }
+
+        # test options provided and make sure they are valid
+        case options[:attribute]
+        when "launchPermission"
+          # these args are ok
+        else
+          raise ArgumentError, "attribute : #{options[:attribute].to_s} is not an known attribute."
+        end
+
+        return response_generator(:action => "ResetImageAttribute", :params => params)
+
+      end
+
+    end
+  end
+end

data/lib/AWS/EC2/images.rb

@@ -0,0 +1,101 @@
+module AWS
+  module EC2
+
+    class Base < AWS::Base
+
+      # The RegisterImage operation registers an AMI with Amazon EC2. Images must be registered before
+      # they can be launched.  Each AMI is associated with an unique ID which is provided by the EC2
+      # service via the Registerimage operation. As part of the registration process, Amazon EC2 will
+      # retrieve the specified image manifest from Amazon S3 and verify that the image is owned by the
+      # user requesting image registration.  The image manifest is retrieved once and stored within the
+      # Amazon EC2 network. Any modifications to an image in Amazon S3 invalidate this registration.
+      # If you do have to make changes and upload a new image deregister the previous image and register
+      # the new image.
+      #
+      # @option options [String] :image_location ("")
+      #
+      def register_image( options = {} )
+
+        options = {:image_location => ""}.merge(options)
+
+        raise ArgumentError, "No :image_location provided" if options[:image_location].nil? || options[:image_location].empty?
+
+        params = { "ImageLocation" => options[:image_location] }
+
+        return response_generator(:action => "RegisterImage", :params => params)
+
+      end
+
+      # The DescribeImages operation returns information about AMIs available for use by the user. This
+      # includes both public AMIs (those available for any user to launch) and private AMIs (those owned by
+      # the user making the request and those owned by other users that the user making the request has explicit
+      # launch permissions for).
+      #
+      # The list of AMIs returned can be modified via optional lists of AMI IDs, owners or users with launch
+      # permissions. If all three optional lists are empty all AMIs the user has launch permissions for are
+      # returned. Launch permissions fall into three categories:
+      #
+      # Launch Permission Description
+      #
+      # public - The all group has launch permissions for the AMI. All users have launch permissions for these AMIs.
+      # explicit - The owner of the AMIs has granted a specific user launch permissions for the AMI.
+      # implicit - A user has implicit launch permissions for all AMIs he or she owns.
+      #
+      # If one or more of the lists are specified the result set is the intersection of AMIs matching the criteria of
+      # the individual lists.
+      #
+      # Providing the list of AMI IDs requests information for those AMIs only. If no AMI IDs are provided,
+      # information of all relevant AMIs will be returned. If an AMI is specified that does not exist a fault is
+      # returned. If an AMI is specified that exists but the user making the request does not have launch
+      # permissions for, then that AMI will not be included in the returned results.
+      #
+      # Providing the list of owners requests information for AMIs owned by the specified owners only. Only
+      # AMIs the user has launch permissions for are returned. The items of the list may be account ids for
+      # AMIs owned by users with those account ids, amazon for AMIs owned by Amazon or self for AMIs
+      # owned by the user making the request.
+      #
+      # The executable list may be provided to request information for AMIs that only the specified users have
+      # launch permissions for. The items of the list may be account ids for AMIs owned by the user making the
+      # request that the users with the specified account ids have explicit launch permissions for, self for AMIs
+      # the user making the request has explicit launch permissions for or all for public AMIs.
+      #
+      # Deregistered images will be included in the returned results for an unspecified interval subsequent to
+      # deregistration.
+      #
+      # @option options [Array] :image_id ([])
+      # @option options [Array] :owner_id ([])
+      # @option options [Array] :executable_by ([])
+      #
+      def describe_images( options = {} )
+
+        options = { :image_id => [], :owner_id => [], :executable_by => [] }.merge(options)
+
+        params = pathlist( "ImageId", options[:image_id] )
+        params.merge!(pathlist( "Owner", options[:owner_id] ))
+        params.merge!(pathlist( "ExecutableBy", options[:executable_by] ))
+
+        return response_generator(:action => "DescribeImages", :params => params)
+
+      end
+
+      # The DeregisterImage operation deregisters an AMI. Once deregistered, instances of the AMI may no
+      # longer be launched.
+      #
+      # @option options [String] :image_id ("")
+      #
+      def deregister_image( options = {} )
+
+        options = { :image_id => "" }.merge(options)
+
+        raise ArgumentError, "No :image_id provided" if options[:image_id].nil? || options[:image_id].empty?
+
+        params = { "ImageId" => options[:image_id] }
+
+        return response_generator(:action => "DeregisterImage", :params => params)
+
+      end
+
+    end
+
+  end
+end