nirvdrum-amazon-ec2 0.7.9

data/lib/AWS/EC2/snapshots.rb

@@ -0,0 +1,102 @@
+module AWS
+  module EC2
+
+    class Base < AWS::Base
+
+
+      # The DescribeSnapshots operation describes the status of Amazon EBS snapshots.
+      #
+      # @option options [optional,Array] :snapshot_id ([]) The ID of the Amazon EBS snapshot.
+      # @option options [optional,String] :owner ('') Returns snapshots owned by the specified owner. Multiple owners can be specified. Valid values self | amazon | AWS Account ID
+      # @option options [optional,String] :restorable_by ('') Account ID of a user that can create volumes from the snapshot.
+      #
+      def describe_snapshots( options = {} )
+        params = {}
+        params.merge!(pathlist("SnapshotId", options[:snapshot_id] )) unless options[:snapshot_id].nil? || options[:snapshot_id] == []
+        params["RestorableBy"] = options[:restorable_by] unless options[:restorable_by].nil?
+        params["Owner"] = options[:owner] unless options[:owner].nil?
+        return response_generator(:action => "DescribeSnapshots", :params => params)
+      end
+
+
+      # The CreateSnapshot operation creates a snapshot of an Amazon EBS volume and stores it in Amazon S3. You can use snapshots for backups, to launch instances from identical snapshots, and to save data before shutting down an instance.
+      #
+      # @option options [String] :volume_id ('')
+      #
+      def create_snapshot( options = {} )
+        options = { :volume_id => '' }.merge(options)
+        raise ArgumentError, "No :volume_id provided" if options[:volume_id].nil? || options[:volume_id].empty?
+        params = {
+          "VolumeId" => options[:volume_id]
+        }
+        return response_generator(:action => "CreateSnapshot", :params => params)
+      end
+
+
+      # The DeleteSnapshot operation deletes a snapshot of an Amazon EBS  volume that is stored in Amazon S3.
+      #
+      # @option options [String] :snapshot_id ('')
+      #
+      def delete_snapshot( options = {} )
+        options = { :snapshot_id => '' }.merge(options)
+        raise ArgumentError, "No :snapshot_id provided" if options[:snapshot_id].nil? || options[:snapshot_id].empty?
+        params = {
+          "SnapshotId" => options[:snapshot_id]
+        }
+        return response_generator(:action => "DeleteSnapshot", :params => params)
+      end
+
+
+      # The DescribeSnapshotAttribute operation returns information about an attribute of a snapshot. Only one attribute can be specified per call.
+      #
+      # @option options [String] :attribute ('createVolumePermission') Attribute to modify.
+      # @option options [optional,Array] :snapshot_id ([]) The ID of the Amazon EBS snapshot.
+      #
+      def describe_snapshot_attribute( options = {} )
+        params = { "Attribute" =>  options[:attribute] || 'createVolumePermission' }
+        params.merge!(pathlist("SnapshotId", options[:snapshot_id] )) unless options[:snapshot_id].nil? || options[:snapshot_id] == []
+        return response_generator(:action => "DescribeSnapshotAttribute", :params => params)
+      end
+
+
+      # The ModifySnapshotAttribute operation adds or remove permission settings for the specified snapshot.
+      #
+      # @option options [String] :snapshot_id ('') The ID of the Amazon EBS snapshot.
+      # @option options [String] :attribute ('createVolumePermission') Attribute to modify.
+      # @option options [String] :operation_type ('') Operation to perform on the attribute.
+      # @option options [optional,String] :user_id ('') Account ID of a user that can create volumes from the snapshot.
+      # @option options [optional,String] :user_group ('') Group that is allowed to create volumes from the snapshot.
+      #
+      def modify_snapshot_attribute( options = {} )
+        options = { :snapshot_id => '' }.merge(options)
+        raise ArgumentError, "No :snapshot_id provided" if options[:snapshot_id].nil? || options[:snapshot_id].empty?
+        options = { :operation_type => '' }.merge(options)
+        raise ArgumentError, "No :operation_type provided" if options[:snapshot_id].nil? || options[:snapshot_id].empty?
+	      params = {
+          "Attribute" =>  options[:attribute] || 'createVolumePermission',
+          "SnapshotId" => options[:snapshot_id],
+          "OperationType" => options[:operation_type]
+        }
+        params["UserId"] = options[:user_id] unless options[:user_id].nil?
+        params["UserGroup"] = options[:user_group] unless options[:user_group].nil?
+        return response_generator(:action => "ModifySnapshotAttribute", :params => params)
+      end
+
+
+      # The ResetSnapshotAttribute operation resets permission settings for the specified snapshot.
+      #
+      # @option options [optional,Array] :snapshot_id ([]) The ID of the Amazon EBS snapshot.
+      # @option options [String] :attribute ('createVolumePermission') Attribute to reset.
+      #
+      def reset_snapshot_attribute( options = {} )
+        options = { :snapshot_id => '' }.merge(options)
+        raise ArgumentError, "No :snapshot_id provided" if options[:snapshot_id].nil? || options[:snapshot_id].empty?
+        params = { "Attribute" =>  options[:attribute] || 'createVolumePermission' }
+        params["SnapshotId"] = options[:snapshot_id] unless options[:snapshot_id].nil? || options[:snapshot_id].empty?
+        return response_generator(:action => "ResetSnapshotAttribute", :params => params)
+      end
+
+    end
+  end
+end
+

data/lib/AWS/EC2/spot_instance_requests.rb

@@ -0,0 +1,105 @@
+module AWS
+  module EC2
+
+    class Base < AWS::Base
+
+      # Creates a Spot Instance request. Spot Instances are instances that Amazon EC2 starts on your behalf
+      # when the maximum price that you specify exceeds the current Spot Price. Amazon EC2 periodically sets
+      # the Spot Price based on available Spot Instance capacity and current spot instance requests. For conceptual
+      # information about Spot Instances, refer to the Amazon Elastic Compute Cloud Developer Guide or Amazon Elastic
+      # Compute Cloud User Guide.
+      #
+      # @option options [String] :spot_price (nil) Specifies the maximum hourly price for any Spot Instance launched to fulfill the request.
+      # @option options [optional,Integer] :instance_count (1) The maximum number of Spot Instances to launch.
+      # @option options [optional,String] :type (nil) Specifies the Spot Instance type.
+      # @option options [optional,Date] :valid_from (nil) Start date of the request. If this is a one-time request, the request becomes active at this date and time and remains active until all instances launch, the request expires, or the request is canceled. If the request is persistent, the request becomes active at this date and time and remains active until it expires or is canceled.
+      # @option options [optional,Date] :valid_until (nil) End date of the request. If this is a one-time request, the request remains active until all instances launch, the request is canceled, or this date is reached. If the request is persistent, it remains active until it is canceled or this date and time is reached.
+      # @option options [optional,String] :launch_group (nil) Specifies the instance launch group. Launch groups are Spot Instances that launch together and terminate together.
+      # @option options [optional,String] :availability_zone_group ("") Specifies the Availability Zone group. If you specify the same Availability Zone group for all Spot Instance requests, all Spot Instances are launched in the same Availability Zone.
+      # @option options [optional,String] :image_id (nil) The AMI ID.
+      # @option options [optional,String] :key_name (nil) The name of the key pair.
+      # @option options [optional,Array of Strings or String] :security_group (nil) Name of the security group(s).
+      # @option options [optional,String] :user_data (nil) MIME, Base64-encoded user data.
+      # @option options [optional,String] :instance_type ("m1.small") Specifies the instance type.
+      # @option options [optional,String] :kernel_id (nil) The ID of the kernel to select.
+      # @option options [optional,String] :ramdisk_id (nil) The ID of the RAM disk to select. Some kernels require additional drivers at launch. Check the kernel requirements for information on whether you need to specify a RAM disk and search for the kernel ID.
+      # @option options [optional,String] :subnet_id (nil) Specifies the Amazon VPC subnet ID within which to launch the instance(s) for Amazon Virtual Private Cloud.
+      # @option options [optional,String] :availability_zone (nil) Specifies the placement constraints (Availability Zones) for launching the instances.
+      # @option options [optional, Array] :block_device_mapping ([]) An array of Hashes representing the elements of the block device mapping.  e.g. [{:device_name => '/dev/sdh', :virtual_name => '', :ebs_snapshot_id => '', :ebs_volume_size => '', :ebs_delete_on_termination => ''},{},...]
+      # @option options [optional, Boolean] :monitoring_enabled (false) Enables monitoring for the instance.
+      #
+      def create_spot_instances_request( options = {} )
+        options = { :instance_count => 1,
+                    :instance_type => 'm1.small',
+                    :base64_encoded => false }.merge(options)
+
+        raise ArgumentError, ":addressing_type has been deprecated." if options[:addressing_type]
+        raise ArgumentError, ":spot_price must be provided" if options[:spot_price].nil? || options[:spot_price].empty?
+
+        user_data = extract_user_data(options)
+
+        params = {}
+
+        if options[:security_group]
+          params.merge!(pathlist("LaunchSpecification.SecurityGroup", options[:security_group]))
+        end
+
+        if options[:block_device_mapping]
+          params.merge!(pathhashlist('LaunchSpecification.BlockDeviceMapping', options[:block_device_mapping].flatten, {:device_name => 'DeviceName', :virtual_name => 'VirtualName', :ebs_snapshot_id => 'Ebs.SnapshotId', :ebs_volume_size => 'Ebs.VolumeSize', :ebs_delete_on_termination => 'Ebs.DeleteOnTermination' }))
+        end
+
+        params["SpotPrice"]                                             = options[:spot_price]
+        params["InstanceCount"]                                         = options[:instance_count].to_s
+        params["Type"]                                                  = options[:type] unless options[:type].nil?
+        params["ValidFrom"]                                             = options[:valid_from].to_s unless options[:valid_from].nil?
+        params["ValidUntil"]                                            = options[:valid_until].to_s unless options[:valid_until].nil?
+        params["LaunchGroup"]                                           = options[:launch_group] unless options[:launch_group].nil?
+        params["AvailabilityZoneGroup"]                                 = options[:availability_zone_group] unless options[:availability_zone_group].nil?
+        params["LaunchSpecification.ImageId"]                           = options[:image_id] unless options[:image_id].nil?
+        params["LaunchSpecification.KeyName"]                           = options[:key_name] unless options[:key_name].nil?
+        params["LaunchSpecification.UserData"]                          = user_data unless user_data.nil?
+        params["LaunchSpecification.InstanceType"]                      = options[:instance_type] unless options[:instance_type].nil?
+        params["LaunchSpecification.KernelId"]                          = options[:kernel_id] unless options[:kernel_id].nil?
+        params["LaunchSpecification.RamdiskId"]                         = options[:ramdisk_id] unless options[:ramdisk_id].nil?
+        params["LaunchSpecification.SubnetId"]                          = options[:subnet_id] unless options[:subnet_id].nil?
+        params["LaunchSpecification.Placement.AvailabilityZone"]        = options[:availability_zone] unless options[:availability_zone].nil?
+        params["LaunchSpecification.Monitoring.Enabled"]                = options[:monitoring_enabled].to_s unless options[:monitoring_enabled].nil?
+        
+        return response_generator(:action => "RequestSpotInstances", :params => params)
+      end
+
+      # Describes Spot Instance requests. Spot Instances are instances that Amazon EC2 starts on your behalf when the
+      # maximum price that you specify exceeds the current Spot Price. Amazon EC2 periodically sets the Spot Price
+      # based on available Spot Instance capacity and current spot instance requests. For conceptual information about
+      # Spot Instances, refer to the Amazon Elastic Compute Cloud Developer Guide or Amazon Elastic Compute Cloud User Guide.
+      #
+      # @option options [Array] :spot_instance_request_id ([])
+      #
+      def describe_spot_instance_requests( options = {} )
+        options = { :spot_instance_request_id => []}.merge(options)
+        params = pathlist( "SpotInstanceRequestId", options[:spot_instance_request_id] )
+
+        return response_generator(:action => "DescribeSpotInstanceRequests", :params => params)
+      end
+
+      # Cancels one or more Spot Instance requests. Spot Instances are instances that Amazon EC2 starts on your behalf
+      # when the maximum price that you specify exceeds the current Spot Price. Amazon EC2 periodically sets the Spot
+      # Price based on available Spot Instance capacity and current spot instance requests. For conceptual information
+      # about Spot Instances, refer to the Amazon Elastic Compute Cloud Developer Guide or Amazon Elastic Compute Cloud
+      # User Guide.
+      #
+      # NB: Canceling a Spot Instance request does not terminiate running Spot Instances associated with the request.
+      #
+      # @option options [Array] :spot_instance_request_id ([])
+      #
+      def destroy_spot_instance_requests( options = {} )
+        options = { :spot_instance_request_id => []}.merge(options)
+        params = pathlist( "SpotInstanceRequestId", options[:spot_instance_request_id] )
+
+        return response_generator(:action => "CancelSpotInstanceRequests", :params => params)
+      end
+
+    end
+  end
+end
+

data/lib/AWS/EC2/volumes.rb

@@ -0,0 +1,100 @@
+module AWS
+  module EC2
+    class Base < AWS::Base
+
+
+      # The DescribeVolumes operation lists one or more Amazon EBS volumes that you own, If you do not specify any volumes, Amazon EBS returns all volumes that you own.
+      #
+      # @option options [optional, String] :volume_id ([])
+      #
+      def describe_volumes( options = {} )
+        options = { :volume_id => [] }.merge(options)
+        params = pathlist("VolumeId", options[:volume_id] )
+        return response_generator(:action => "DescribeVolumes", :params => params)
+      end
+
+
+      # The CreateVolume operation creates a new Amazon EBS volume that you can mount from any Amazon EC2 instance.
+      #
+      # @option options [String] :availability_zone ('')
+      # @option options [optional, String] :size ('')
+      # @option options [optional, String] :snapshot_id ('')
+      #
+      def create_volume( options = {} )
+        options = { :availability_zone => '' }.merge(options)
+        raise ArgumentError, "No :availability_zone provided" if options[:availability_zone].nil? || options[:availability_zone].empty?
+        options = { :size => '' }.merge(options)
+        options = { :snapshot_id => '' }.merge(options)
+        params = {
+          "AvailabilityZone" => options[:availability_zone],
+          "Size" => options[:size],
+          "SnapshotId" => options[:snapshot_id]
+        }
+        return response_generator(:action => "CreateVolume", :params => params)
+      end
+
+
+      # The DeleteVolume operation deletes an Amazon EBS volume.
+      #
+      # @option options [String] :volume_id ('')
+      #
+      def delete_volume( options = {} )
+        options = { :volume_id => '' }.merge(options)
+        raise ArgumentError, "No :volume_id provided" if options[:volume_id].nil? || options[:volume_id].empty?
+        params = {
+          "VolumeId" => options[:volume_id]
+        }
+        return response_generator(:action => "DeleteVolume", :params => params)
+      end
+
+
+      # The AttachVolume operation attaches an Amazon EBS volume to an instance.
+      #
+      # @option options [String] :volume_id ('')
+      # @option options [String] :instance_id ('')
+      # @option options [String] :device ('')
+      #
+      def attach_volume( options = {} )
+        options = { :volume_id => '' }.merge(options)
+        options = { :instance_id => '' }.merge(options)
+        options = { :device => '' }.merge(options)
+        raise ArgumentError, "No :volume_id provided" if options[:volume_id].nil? || options[:volume_id].empty?
+        raise ArgumentError, "No :instance_id provided" if options[:instance_id].nil? || options[:instance_id].empty?
+        raise ArgumentError, "No :device provided" if options[:device].nil? || options[:device].empty?
+
+        params = {
+          "VolumeId" => options[:volume_id],
+          "InstanceId" => options[:instance_id],
+          "Device" => options[:device]
+        }
+        return response_generator(:action => "AttachVolume", :params => params)
+      end
+
+
+      # The DetachVolume operation detaches an Amazon EBS volume from an instance.
+      #
+      # @option options [String] :volume_id ('')
+      # @option options [optional, String] :instance_id ('')
+      # @option options [optional, String] :device ('')
+      # @option options [optional, Boolean] :force ('')
+      #
+      def detach_volume( options = {} )
+        options = { :volume_id => '' }.merge(options)
+        raise ArgumentError, "No :volume_id provided" if options[:volume_id].nil? || options[:volume_id].empty?
+        options = { :instance_id => '' }.merge(options)
+        options = { :device => '' }.merge(options)
+        options = { :force => '' }.merge(options)
+        params = {
+          "VolumeId" => options[:volume_id],
+          "InstanceId" => options[:instance_id],
+          "Device" => options[:device],
+          "Force" => options[:force]
+        }
+        return response_generator(:action => "DetachVolume", :params => params)
+      end
+
+
+    end
+  end
+end
+

data/lib/AWS/ELB.rb

@@ -0,0 +1,71 @@
+module AWS
+  module ELB
+
+    # Which host FQDN will we connect to for all API calls to AWS?
+    # If ELB_URL is defined in the users ENV we can override the default with that.
+    # 
+    # @example
+    #   export ELB_URL='https://elasticloadbalancing.amazonaws.com'
+    if ENV['ELB_URL']
+      ELB_URL = ENV['ELB_URL']
+      VALID_HOSTS = ['elasticloadbalancing.amazonaws.com']
+      raise ArgumentError, "Invalid ELB_URL environment variable : #{ELB_URL}" unless VALID_HOSTS.include?(ELB_URL)
+      DEFAULT_HOST = URI.parse(ELB_URL).host
+    else
+      # Default US API endpoint
+      DEFAULT_HOST = 'elasticloadbalancing.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/ELB/load_balancers.rb

@@ -0,0 +1,178 @@
+module AWS
+  module ELB
+    class Base < AWS::Base
+
+      # This API creates a new LoadBalancer. Once the call has completed
+      # successfully, a new LoadBalancer will be created, but it will not be
+      # usable until at least one instance has been registered. When the
+      # LoadBalancer creation is completed, you can check whether it is usable
+      # by using the DescribeInstanceHealth API. The LoadBalancer is usable as
+      # soon as any registered instance is InService.
+      #
+      # @option options [String] :load_balancer_name (nil) the name of the load balancer
+      # @option options [Array] :availability_zones (nil)
+      # @option options [Array] :listeners (nil) An Array of Hashes (:protocol, :load_balancer_port, :instance_port)
+      # @option options [Array] :availability_zones (nil) An Array of Strings
+      #
+      def create_load_balancer( options = {} )
+        raise ArgumentError, "No :availability_zones provided" if options[:availability_zones].nil? || options[:availability_zones].empty?
+        raise ArgumentError, "No :listeners provided" if options[:listeners].nil? || options[:listeners].empty?
+        raise ArgumentError, "No :load_balancer_name provided" if options[:load_balancer_name].nil? || options[:load_balancer_name].empty?
+
+        params = {}
+
+        params.merge!(pathlist('AvailabilityZones.member', [options[:availability_zones]].flatten))
+        params.merge!(pathhashlist('Listeners.member', [options[:listeners]].flatten, {
+          :protocol => 'Protocol',
+          :load_balancer_port => 'LoadBalancerPort',
+          :instance_port => 'InstancePort'
+        }))
+        params['LoadBalancerName'] = options[:load_balancer_name]
+
+        return response_generator(:action => "CreateLoadBalancer", :params => params)
+      end
+
+      # This API deletes the specified LoadBalancer. On deletion, all of the
+      # configured properties of the LoadBalancer will be deleted. If you
+      # attempt to recreate the LoadBalancer, you need to reconfigure all the
+      # settings. The DNS name associated with a deleted LoadBalancer is no
+      # longer be usable. Once deleted, the name and associated DNS record of
+      # the LoadBalancer no longer exist and traffic sent to any of its IP
+      # addresses will no longer be delivered to your instances. You will not
+      # get the same DNS name even if you create a new LoadBalancer with same
+      # LoadBalancerName.
+      #
+      # @option options [String] :load_balancer_name the name of the load balancer
+      #
+      def delete_load_balancer( options = {} )
+        raise ArgumentError, "No :load_balancer_name provided" if options[:load_balancer_name].nil? || options[:load_balancer_name].empty?
+        params = { 'LoadBalancerName' => options[:load_balancer_name] }
+        return response_generator(:action => "DeleteLoadBalancer", :params => params)
+      end
+
+      # This API returns detailed configuration information for the specified
+      # LoadBalancers, or if no LoadBalancers are specified, then the API
+      # returns configuration information for all LoadBalancers created by the
+      # caller. For more information, please see LoadBalancer.
+      #
+      # You must have created the specified input LoadBalancers in order to
+      # retrieve this information. In other words, in order to successfully call
+      # this API, you must provide the same account credentials as those that
+      # were used to create the LoadBalancer.
+      #
+      # @option options [Array<String>] :load_balancer_names ([]) An Array of names of load balancers to describe.
+      #
+      def describe_load_balancers( options = {} )
+        options = { :load_balancer_names => [] }.merge(options)
+        params = pathlist("LoadBalancerName.member", options[:load_balancer_names])
+        return response_generator(:action => "DescribeLoadBalancers", :params => params)
+      end
+
+      # This API adds new instances to the LoadBalancer.
+      #
+      # Once the instance is registered, it starts receiving traffic and
+      # requests from the LoadBalancer. Any instance that is not in any of the
+      # Availability Zones registered for the LoadBalancer will be moved to
+      # the OutOfService state. It will move to the InService state when the
+      # Availability Zone is added to the LoadBalancer.
+      #
+      # You must have been the one who created the LoadBalancer. In other
+      # words, in order to successfully call this API, you must provide the
+      # same account credentials as those that were used to create the
+      # LoadBalancer.
+      #
+      # NOTE: Completion of this API does not guarantee that operation has
+      # completed. Rather, it means that the request has been registered and
+      # the changes will happen shortly.
+      #
+      # @option options [Array<String>] :instances An Array of instance names to add to the load balancer.
+      # @option options [String] :load_balancer_name The name of the load balancer.
+      #
+      def register_instances_with_load_balancer( options = {} )
+        raise ArgumentError, "No :instances provided" if options[:instances].nil? || options[:instances].empty?
+        raise ArgumentError, "No :load_balancer_name provided" if options[:load_balancer_name].nil? || options[:load_balancer_name].empty?
+        params = {}
+        params.merge!(pathhashlist('Instances.member', options[:instances].flatten.collect{|e| {:instance_id => e}}, {:instance_id => 'InstanceId'}))
+        params['LoadBalancerName'] = options[:load_balancer_name]
+        return response_generator(:action => "RegisterInstancesWithLoadBalancer", :params => params)
+      end
+
+      # This API deregisters instances from the LoadBalancer. Trying to
+      # deregister an instance that is not registered with the LoadBalancer
+      # does nothing.
+      #
+      # In order to successfully call this API, you must provide the same
+      # account credentials as those that were used to create the
+      # LoadBalancer.
+      #
+      # Once the instance is deregistered, it will stop receiving traffic from
+      # the LoadBalancer.
+      #
+      # @option options [Array<String>] :instances An Array of instance names to remove from the load balancer.
+      # @option options [String] :load_balancer_name The name of the load balancer.
+      #
+      def deregister_instances_from_load_balancer( options = {} )
+        raise ArgumentError, "No :instances provided" if options[:instances].nil? || options[:instances].empty?
+        raise ArgumentError, "No :load_balancer_name provided" if options[:load_balancer_name].nil? || options[:load_balancer_name].empty?
+        params = {}
+        params.merge!(pathlist('Instances.member', [options[:instances]].flatten))
+        params['LoadBalancerName'] = options[:load_balancer_name]
+        return response_generator(:action => "DeregisterInstancesFromLoadBalancer", :params => params)
+      end
+
+      # This API enables you to define an application healthcheck for the
+      # instances.
+      #
+      # Note: Completion of this API does not guarantee that operation has completed. Rather, it means that the request has been registered and the changes will happen shortly.
+      #
+      # @option options [Hash] :health_check A Hash with the keys (:timeout, :interval, :unhealthy_threshold, :healthy_threshold)
+      # @option options [String] :load_balancer_name The name of the load balancer.
+      #
+      def configure_health_check( options = {} )
+        raise ArgumentError, "No :health_check provided" if options[:health_check].nil? || options[:health_check].empty?
+        raise ArgumentError, "No :health_check => :target provided" if options[:health_check][:target].nil? || options[:health_check][:target].empty?
+        raise ArgumentError, "No :health_check => :timeout provided" if options[:health_check][:timeout].nil? || options[:health_check][:timeout].empty?
+        raise ArgumentError, "No :health_check => :interval provided" if options[:health_check][:interval].nil? || options[:health_check][:interval].empty?
+        raise ArgumentError, "No :health_check => :unhealthy_threshold provided" if options[:health_check][:unhealthy_threshold].nil? || options[:health_check][:unhealthy_threshold].empty?
+        raise ArgumentError, "No :health_check => :healthy_threshold provided" if options[:health_check][:healthy_threshold].nil? || options[:health_check][:healthy_threshold].empty?
+        raise ArgumentError, "No :load_balancer_name provided" if options[:load_balancer_name].nil? || options[:load_balancer_name].empty?
+
+        params = {}
+
+        params['LoadBalancerName'] = options[:load_balancer_name]
+        params['HealthCheck.Target'] = options[:health_check][:target]
+        params['HealthCheck.Timeout'] = options[:health_check][:timeout]
+        params['HealthCheck.Interval'] = options[:health_check][:interval]
+        params['HealthCheck.UnhealthyThreshold'] = options[:health_check][:unhealthy_threshold]
+        params['HealthCheck.HealthyThreshold'] = options[:health_check][:healthy_threshold]
+
+        return response_generator(:action => "ConfigureHealthCheck", :params => params)
+      end
+
+      # Not yet implemented
+      #
+      # @todo Implement this method
+      #
+      def describe_instance_health( options = {} )
+        raise "Not yet implemented"
+      end
+
+      # Not yet implemented
+      #
+      # @todo Implement this method
+      #
+      def disable_availability_zones_for_load_balancer( options = {} )
+        raise "Not yet implemented"
+      end
+
+      # Not yet implemented
+      #
+      # @todo Implement this method
+      #
+      def enable_availability_zones_for_load_balancer( options = {} )
+        raise "Not yet implemented"
+      end
+
+    end
+  end
+end