poolparty 1.3.15 → 1.4.0

data/vendor/gems/amazon-ec2/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/vendor/gems/amazon-ec2/lib/AWS/ELB/load_balancers.rb

@@ -0,0 +1,205 @@
+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, {
+          :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!(pathhashlist('Instances.member', [options[:instances]].flatten, {
+          :instance_id => 'InstanceId'
+        }))
+        
+        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
+
+      #
+      # @todo Document this method
+      #
+      def describe_instance_health( options = {} )
+        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]
+        return response_generator(:action => "DescribeInstanceHealth", :params => params)
+      end
+
+      #
+      # @todo Document this method
+      #
+      def disable_availability_zones_for_load_balancer( options = {} )
+        raise ArgumentError, "No :load_balancer_name provided" if options[:load_balancer_name].nil? || options[:load_balancer_name].empty?
+        raise ArgumentError, "No availability_zones specified" unless options[:availability_zones]
+        
+        params = {}
+        params['LoadBalancerName'] = options[:load_balancer_name]
+        params.merge!(pathlist("AvailabilityZones.member", options[:availability_zones]))
+        
+        return response_generator(:action => "DisableAvailabilityZonesForLoadBalancer", :params => params)
+      end
+
+      #
+      # @todo Document this method
+      #
+      def enable_availability_zones_for_load_balancer( options = {} )
+        raise ArgumentError, "No :load_balancer_name provided" if options[:load_balancer_name].nil? || options[:load_balancer_name].empty?
+        raise ArgumentError, "No availability_zones specified" unless options[:availability_zones]
+        
+        params = {}
+        params['LoadBalancerName'] = options[:load_balancer_name]
+        params.merge!(pathlist("AvailabilityZones.member", options[:availability_zones]))
+        
+        return response_generator(:action => "EnableAvailabilityZonesForLoadBalancer", :params => params)
+      end
+      
+      #convenience methods
+      # return an array of hashes describing the load_balancers
+      def list
+        describe_load_balancers.DescribeLoadBalancersResult.LoadBalancerDescriptions.member
+      end
+
+    end
+  end
+end

data/vendor/gems/amazon-ec2/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/vendor/gems/amazon-ec2/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
+

data/vendor/gems/amazon-ec2/lib/AWS/responses.rb

@@ -0,0 +1,21 @@
+module AWS
+
+  class Response
+
+    # Parse the XML response from AWS
+    #
+    # @option options [String] :xml The XML response from AWS that we want to parse
+    # @option options [Hash] :parse_options Override the options for XmlSimple.
+    # @return [Hash] the input :xml converted to a custom Ruby Hash by XmlSimple.
+    def self.parse(options = {})
+      options = {
+        :xml => "",
+        :parse_options => { 'forcearray' => ['item', 'member'], 'suppressempty' => nil, 'keeproot' => false }
+      }.merge(options)
+      response = XmlSimple.xml_in(options[:xml], options[:parse_options])
+    end
+
+  end  # class Response
+
+end  # module AWS
+