nirvdrum-amazon-ec2 0.7.9

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

@@ -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://us-west-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-11-30'
+
+    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,29 @@
+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
+
+      # Not yet implemented
+      #
+      # @todo Implement this method
+      #
+      def describe_regions( options = {} )
+        raise "Not yet implemented"
+      end
+
+    end
+  end
+end
+

data/lib/AWS/EC2/console.rb

@@ -0,0 +1,25 @@
+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/devpay.rb

@@ -0,0 +1,18 @@
+module AWS
+  module EC2
+    class Base < AWS::Base
+
+
+      # Not yet implemented
+      #
+      # @todo Implement this method
+      #
+      def confirm_product_instance( options = {} )
+        raise "Not yet implemented"
+      end
+
+
+    end
+  end
+end
+

data/lib/AWS/EC2/elastic_ips.rb

@@ -0,0 +1,86 @@
+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 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 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 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
+
+
+      # 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
+
+
+    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,117 @@
+module AWS
+  module EC2
+
+    class Base < AWS::Base
+
+      # Creates an AMI that uses an Amazon EBS root device from a "running" or "stopped" instance.
+      #
+      # AMIs that use an Amazon EBS root device boot faster than AMIs that use instance stores.
+      # They can be up to 1 TiB in size, use storage that persists on instance failure, and can be
+      # stopped and started.
+      #
+      # @option options [String] :instance_id ("") The ID of the instance.
+      # @option options [String] :name ("") The name of the AMI that was provided during image creation. Constraints 3-128 alphanumeric characters, parenthesis (()), commas (,), slashes (/), dashes (-), or underscores(_)
+      # @option options [optional,String] :description ("") The description of the AMI that was provided during image creation.
+      # @option options [optional,Boolean] :no_reboot (false) By default this property is set to false, which means Amazon EC2 attempts to cleanly shut down the instance before image creation and reboots the instance afterwards. When set to true, Amazon EC2 does not shut down the instance before creating the image. When this option is used, file system integrity on the created image cannot be guaranteed.
+      #
+      def create_image( options = {} )
+        options = { :instance_id => "", :name => "" }.merge(options)
+        raise ArgumentError, "No :instance_id provided" if options.does_not_have? :instance_id
+        raise ArgumentError, "No :name provided" if options.does_not_have? :name
+        raise ArgumentError, "Invalid string length for :name provided" if options[:name] && options[:name].size < 3 || options[:name].size > 128
+        raise ArgumentError, "Invalid string length for :description provided (too long)" if options[:description] && options[:description].size > 255
+        raise ArgumentError, ":no_reboot option must be a Boolean" unless options[:no_reboot].nil? || [true, false].include?(options[:no_reboot])
+        params = {}
+        params["InstanceId"] = options[:instance_id].to_s
+        params["Name"] = options[:name].to_s
+        params["Description"] = options[:description].to_s
+        params["NoReboot"] = options[:no_reboot].to_s
+        return response_generator(:action => "CreateImage", :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
+
+
+      # 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
+
+
+    end
+  end
+end
+