newrelic-amazon-ec2 0.6.2

data/lib/AWS/EC2/snapshots.rb

@@ -0,0 +1,59 @@
+module AWS
+  module EC2
+
+    class Base < AWS::Base
+
+      # The DescribeSnapshots operation describes the status of Amazon EBS snapshots.
+      #
+      # @option options [Array] :snapshot_id ([])
+      #
+      def describe_snapshots( options = {} )
+
+        options = { :snapshot_id => [] }.merge(options)
+
+        params = pathlist("SnapshotId", options[:snapshot_id] )
+
+        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
+
+    end
+  end
+end

data/lib/AWS/EC2/volumes.rb

@@ -0,0 +1,115 @@
+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 = {} )
+
+        # defaults
+        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

data/lib/AWS/exceptions.rb

@@ -0,0 +1,122 @@
+#--
+# AWS EC2 CLIENT ERROR CODES
+# AWS EC2 can throw error exceptions that contain a '.' in them.
+# since we can't name an exception class with that '.' I compressed
+# each class name into the non-dot version.  This allows us to retain
+# the granularity of the exception.
+#++
+
+module AWS
+
+  # All AWS errors are superclassed by Error < RuntimeError
+  class Error < RuntimeError; end
+
+  # CLIENT : A client side argument error
+  class ArgumentError < Error; end
+
+  # EC2 : User not authorized.
+  class AuthFailure < Error; end
+
+  # EC2 : Invalid AWS Account
+  class InvalidClientTokenId < Error; end
+
+  # EC2 : Invalid Parameters for Value
+  class InvalidParameterValue < Error; end
+
+  # EC2 : Specified AMI has an unparsable manifest.
+  class InvalidManifest < Error; end
+
+  # EC2 : Specified AMI ID is not valid.
+  class InvalidAMIIDMalformed < Error; end
+
+  # EC2 : Specified AMI ID does not exist.
+  class InvalidAMIIDNotFound < Error; end
+
+  # EC2 : Specified AMI ID has been deregistered and is no longer available.
+  class InvalidAMIIDUnavailable < Error; end
+
+  # EC2 : Specified instance ID is not valid.
+  class InvalidInstanceIDMalformed < Error; end
+
+  # EC2 : Specified instance ID does not exist.
+  class InvalidInstanceIDNotFound < Error; end
+
+  # EC2 : Specified keypair name does not exist.
+  class InvalidKeyPairNotFound < Error; end
+
+  # EC2 : Attempt to create a duplicate keypair.
+  class InvalidKeyPairDuplicate < Error; end
+
+  # EC2 : Specified group name does not exist.
+  class InvalidGroupNotFound < Error; end
+
+  # EC2 : Attempt to create a duplicate group.
+  class InvalidGroupDuplicate < Error; end
+
+  # EC2 : Specified group can not be deleted because it is in use.
+  class InvalidGroupInUse < Error; end
+
+  # EC2 : Specified group name is a reserved name.
+  class InvalidGroupReserved < Error; end
+
+  # EC2 : Attempt to authorize a permission that has already been authorized.
+  class InvalidPermissionDuplicate < Error; end
+
+  # EC2 : Specified permission is invalid.
+  class InvalidPermissionMalformed < Error; end
+
+  # EC2 : Specified reservation ID is invalid.
+  class InvalidReservationIDMalformed < Error; end
+
+  # EC2 : Specified reservation ID does not exist.
+  class InvalidReservationIDNotFound < Error; end
+
+  # EC2 : User has reached max allowed concurrent running instances.
+  class InstanceLimitExceeded < Error; end
+
+  # EC2 : An invalid set of parameters were passed as arguments
+  class InvalidParameterCombination < Error; end
+
+  # EC2 : An unknown parameter was passed as an argument
+  class UnknownParameter < Error; end
+
+  # EC2 : The user ID is neither in the form of an AWS account ID or one
+  # of the special values accepted by the owner or executableBy flags
+  # in the DescribeImages call.
+  class InvalidUserIDMalformed < Error; end
+
+  # EC2 : The value of an item added to, or removed from, an image attribute is invalid.
+  class InvalidAMIAttributeItemValue < Error; end
+
+  # ELB : The Load balancer specified was not found.
+  class LoadBalancerNotFound < Error; end
+
+  # ELB :
+  class ValidationError < Error; end
+
+  # ELB :
+  class DuplicateLoadBalancerName < Error; end
+
+  # ELB :
+  class TooManyLoadBalancers < Error; end
+
+  # ELB :
+  class InvalidInstance < Error; end
+
+  # ELB :
+  class InvalidConfigurationRequest < Error; end
+
+  # Server : Internal AWS EC2 Error.
+  class InternalError < Error; end
+
+  # Server : There are not enough available instances to satisfy your minimum request.
+  class InsufficientInstanceCapacity < Error; end
+
+  # Server : The server is overloaded and cannot handle the request.
+  class Unavailable < Error; end
+
+  # Server : The provided signature does not match.
+  class SignatureDoesNotMatch < Error; end
+
+end
+