aws-sdk 1.1.4 → 1.2.0

data/lib/aws/elb/listener_collection.rb

@@ -0,0 +1,119 @@
+# Copyright 2011 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class ELB
+
+    class ListenerCollection
+
+      include ListenerOpts
+      include Core::Collection::Simple
+
+      def initialize load_balancer, options = {}
+        @load_balancer = load_balancer
+        super
+      end
+
+      # @return [LoadBalancer]
+      attr_reader :load_balancer
+
+      # @param [Hash] options
+      #
+      # @option options [Integer] :port Specifies the external
+      #   load balancer port number. This property cannot be modified for 
+      #   the life of the LoadBalancer.
+      #
+      # @option options [String,Symbol] :protocol Specifies the load balancer
+      #   transport protocol to use for routing.  Valid values include:
+      #
+      # @option options [Integer] :instance_port Specifies the TCP port on 
+      #   which the instance server is listening. This property cannot be 
+      #   modified for the life of the load balancer.
+      #
+      # @option options [String,Symbol] :instance_protocol Specifies the 
+      #   protocol to use for routing traffic to back-end instances.  Valid 
+      #   values include:
+      #
+      #   * :http, 'HTTP'
+      #   * :https, 'HTTPS'
+      #   * :tcp, 'TCP'
+      #   * :ssl, 'SSL'
+      #
+      #   This property cannot be modified for the life of the load balacner.
+      #
+      #   NOTE: If the front-end protocol is HTTP or HTTPS, +:instance_protocol+
+      #   has to be at the same protocol layer, i.e., HTTP or HTTPS. Likewise,
+      #   if the front-end protocol is TCP or SSL, +:instance_protocol+ has 
+      #   to be TCP or SSL.
+      #
+      #   NOTE: If there is another listener with the same +:instance_port+
+      #   whose +:instance_protocol+ is secure, i.e., HTTPS or SSL, the 
+      #   listener's +:instance_protocol+ has to be secure, i.e., HTTPS 
+      #   or SSL. If there is another listener with the same +:instance_port+
+      #   whose +:instance_protocol+ is HTTP or TCP, the listener's 
+      #   +:instance_protocol+ must be either HTTP or TCP.
+      #
+      #   * :tcp, 'TCP'
+      #   * :http, 'HTTP'
+      #
+      #   This property cannot be modified for the life of the load balancer.
+      #
+      # @option options [String,IAM::ServerCertificate] :server_certificate The
+      #   ARN string of an IAM::ServerCertifcate or an IAM::ServerCertificate 
+      #   object.  Reqruied for HTTPs listeners.
+      #
+      # @return [Listener]
+      def create options = {}
+        
+        format_listener_opts(options)
+
+        client.create_load_balancer_listeners(
+          :load_balancer_name => load_balancer.name,
+          :listeners => [options])
+
+        Listener.new(load_balancer, 
+          options[:load_balancer_port], 
+          options.merge(:config => config))
+
+      end
+
+      # @return [Listener]
+      def [] port
+        Listener.new(load_balancer, port, :config => config)
+      end
+
+      protected
+      def _each_item options = {}
+        load_balancer.listener_descriptions.each do |desc|
+
+          desc = desc.listener
+
+          opts = {}
+          opts[:config] = config
+          opts[:protocol] = desc.protocol
+          opts[:instance_port] =  desc.instance_port
+          opts[:instance_protocol] = desc.instance_protocol
+          opts[:ssl_certificate_id] = desc.ssl_certificate_id if
+            desc.respond_to?(:ssl_certificate_id)
+
+          listener = Listener.new(load_balancer, desc.load_balancer_port, opts)
+
+          yield(listener)
+
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/aws/elb/listener_opts.rb

@@ -0,0 +1,45 @@
+# Copyright 2011 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class ELB
+
+    # @private
+    module ListenerOpts
+      
+      # convert protocols from symbols to strings (e.g. :http to 'HTTP')
+      protected
+      def format_listener_opts options
+
+        # accept the :load_balancer_port option by :port
+        options[:load_balancer_port] = options.delete(:port) if
+          options[:port]
+
+        # convert symbolized protocol names into upper-cased strings
+        [:protocol, :instance_protocol].each do |opt|
+          options[opt] = options[opt].to_s.upcase if options[opt]
+        end
+
+        # convert iam server certificates into the ssl certificate id
+        if cert = options.delete(:server_certificate)
+          options[:ssl_certificate_id] = cert.is_a?(IAM::ServerCertificate) ?
+            cert.arn : cert
+        end
+
+        options
+
+      end
+
+    end
+  end
+end

data/lib/aws/elb/listener_spec.rb

@@ -0,0 +1,14 @@
+# Copyright 2011 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+

data/lib/aws/elb/load_balancer.rb

@@ -0,0 +1,255 @@
+# Copyright 2011 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class ELB
+
+  
+    #
+    # @attr_reader [String] name The name of the load balancer.
+    #
+    # @attr_reader [Array<String>] availability_zone_names Return the names of
+    #   the availability zones this load balancer routes traffic to.
+    #
+    # @attr_reader [String] canonical_hosted_zone_name Provides the name of 
+    #   the Amazon Route 53 hosted zone that is associated with the load
+    #   balancer.  For more information: {http://docs.amazonwebservices.com/ElasticLoadBalancing/latest/DeveloperGuide/index.html?using-domain-names-with-elb.html}.
+    #
+    # @attr_reader [String] canonical_hosted_zone_name_id Provides the ID of 
+    #   the Amazon Route 53 hosted zone name that is associated with the 
+    #   load balancer.  For more information: {http://docs.amazonwebservices.com/ElasticLoadBalancing/latest/DeveloperGuide/index.html?using-domain-names-with-elb.html}.
+    #
+    # @attr_reader [String] dns_name Specifies the external DNS name 
+    #   associated with this load balancer.
+    #
+    class LoadBalancer < Core::Resource
+
+      def initialize name, options = {}
+        super(options.merge(:name => name.to_s))
+      end
+
+      attribute :name, :as => :load_balancer_name, :static => true
+
+      #availability_zones
+      attribute :availability_zone_names, :as => :availability_zones
+
+      #backend_server_policies
+      attribute :backend_server_descriptions
+
+      attribute :canonical_hosted_zone_name, :static => true
+
+      attribute :canonical_hosted_zone_name_id, :static => true
+
+      attribute :created_time, :static => true
+
+      attribute :dns_name, :static => true
+
+      #health_check_configuration
+      attribute :health_check_description, :as => :health_check
+
+      #instances
+      attribute :instance_descriptions, :as => :instances
+
+      #listeners
+      attribute :listener_descriptions
+
+      #source_security_group
+      attribute :security_group_description, 
+        :as => :source_security_group, 
+        :static => true
+
+      populates_from(:describe_load_balancers) do |resp|
+        resp.load_balancer_descriptions.find do |lb|
+          lb.load_balancer_name == name
+        end
+      end
+
+      # A collection that help maanage the availability zones for 
+      # this load balancer.
+      #
+      # @example enable an availability zone
+      #
+      #   load_balancer.availability_zones.enable('us-east-1b')
+      #
+      # @example disable an availability zone
+      #
+      #   load_balancer.availability_zones.disable('us-east-1b')
+      #
+      # @example list enabled availability zoens
+      #
+      #   load_balancer.availability_zones.each do |zone|
+      #     puts zone.name
+      #   end
+      #
+      # @return [AvailabilityZoneCollection] Returns a collection that 
+      #   represents this load balancer's availability zones.  You can
+      #   use this collection to enable and disable availability zones.
+      def availability_zones
+        AvailabilityZoneCollection.new(self)
+      end
+
+      # @return [ListenerCollection]
+      def listeners
+        ListenerCollection.new(self)
+      end
+
+      # @return [PolicyCollection]
+      def policies
+        LoadBalancerPolicyCollection.new(self)
+      end
+
+      # @return [InstanceCollection]
+      def instances
+        InstanceCollection.new(self)
+      end
+
+      # @return [BackendServerPolicyCollection]
+      def backend_server_policies
+        BackendServerPolicyCollection.new(self)
+      end
+
+      # Updates the configuration that drives the instance health checks.
+      #
+      # You only need to pass the options you want to change.  You can 
+      # call {#health_check_configuration} if you want to see what the
+      # current configuration values are.
+      #
+      # @param [Hash] options
+      #
+      # @option options [Integer] :healthy_threshold Specifies the number of
+      #   consecutive health probe successes required before moving the 
+      #   instance to the Healthy state.
+      #
+      # @option options [Integer] :unhealthy_threshold Specifies the number 
+      #   of consecutive health probe failures required before moving the 
+      #   instance to the Unhealthy state.
+      #
+      # @option options [Integer] :interval Specifies the approximate 
+      #   interval, in seconds, between health checks of an individual 
+      #   instance.
+      #
+      # @option options [Integer] :timeout Specifies the amount of time, in 
+      #   seconds, during which no response means a failed health probe.  
+      #   This value must be less than the +:interval+ value.
+      #
+      # @option options [String] :target Specifies the instance being checked. 
+      #
+      #   This option should be formatted like: "TCP:80"
+      #
+      #   * The protocol is either TCP, HTTP, HTTPS, or SSL. 
+      #   * The range of valid ports is one (1) through 65535.
+      #
+      #   TCP is the default, specified as a TCP: port pair, for example 
+      #   "TCP:5000". In this case a healthcheck simply attempts to open a 
+      #   TCP connection to the instance on the specified port. Failure to 
+      #   connect within the configured timeout is considered unhealthy.
+      #
+      #   SSL is also specified as SSL: port pair, for example, SSL:5000.
+      #   For HTTP or HTTPS protocol, the situation is different. You have 
+      #   to include a ping path in the string. HTTP is specified as a 
+      #   HTTP:port;/;PathToPing; grouping, for example 
+      #   "HTTP:80/weather/us/wa/seattle". In this case, a HTTP GET request 
+      #   is issued to the instance on the given port and path. Any answer 
+      #   other than "200 OK" within the timeout period is considered 
+      #   unhealthy.
+      #
+      #   The total length of the HTTP ping target needs to be 1024 16-bit 
+      #   Unicode characters or less.
+      #
+      def configure_health_check options = {}
+
+        new_config = health_check_configuration.merge(options)
+
+        response = client.configure_health_check(
+          :load_balancer_name => name,
+          :health_check => new_config)
+
+        new_config
+
+      end
+
+      # Returns a hash of the various health probes conducted on the 
+      # load balancer instances.  The following entries are returned:
+      #
+      #   * +:healthy_threshold+
+      #   * +:unhealthy_threshold+
+      #   * +:interval+
+      #   * +:target+
+      #   * +:timeout+
+      #
+      # See {#configure_health_check} for more details on what each of the
+      # configuration values mean.
+      #
+      # @return [Hash]
+      #
+      def health_check_configuration
+        cfg = health_check_description
+        {
+          :healthy_threshold => cfg.healthy_threshold,
+          :unhealthy_threshold => cfg.unhealthy_threshold,
+          :interval => cfg.interval,
+          :target => cfg.target,
+          :timeout => cfg.timeout,
+        }
+      end
+
+      # Generally you don't need to call this method, rather you can
+      # just pass the load balancer as a source to the various
+      # authorize and revoke methods of {SecurityGroup}:
+      #
+      #   security_group.authorize_ingress(load_balancer)
+      #
+      #   security_group.revoke_ingress(load_balancer)
+      #
+      # @return [Hash] Returns a hash that can be passed to the following
+      #   {SecurityGroup} methods as a source:
+      #
+      #   * {SecurityGroup#authorize_ingress}
+      #   * {SecurityGroup#authorize_egress}
+      #
+      def source_security_group
+        { 
+          :group_name => security_group_description.group_name,
+          :user_id => security_group_description.owner_alias,
+        }
+      end
+
+      # @return [Boolean] Returns true if the load balancer exists.
+      def exists?
+        client.describe_load_balancers(:load_balancer_names => [name])
+        true
+      rescue Errors::LoadBalancerNotFound
+        false
+      end
+
+      # Deletes the load balancer.
+      # @return [nil]
+      def delete
+        client.delete_load_balancer(:load_balancer_name => name)
+        nil
+      end
+
+      protected
+      def resource_identifiers
+        [[:load_balancer_name,name]]
+      end
+
+      protected
+      def get_resource attr_name
+        # describing all, makes memoization more efficient
+        client.describe_load_balancers
+      end
+
+    end
+  end
+end

data/lib/aws/elb/load_balancer_collection.rb

@@ -0,0 +1,113 @@
+# Copyright 2011 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  class ELB
+
+    class LoadBalancerCollection
+
+      include ListenerOpts
+      include Core::Collection::Simple
+
+      # Creates and returns a load balancer.  A load balancer requires:
+      #
+      # * a unique name
+      # * at least one availability zone
+      # * at least one listener
+      #
+      # An example that creates a load balancer in two availability zones
+      # with a single listener:
+      #
+      #   load_balancer = elb.load_balancers.create('my-load-balancer',
+      #     :availability_zones => %w(us-east-1a us-east-1b),
+      #     :listeners => [{
+      #       :port => 80,
+      #       :protocol => :http,
+      #       :instance_port => 80,
+      #       :instance_protocol => :http,
+      #     }])
+      # 
+      # @param [String] name The name of your load balancer.  The name must
+      #   be unique within your set of load balancers.
+      #
+      # @param [Hash] options
+      #
+      # @option options [required,Array] :availability_zones An array of
+      #   one or more availability zones.  Values may be availability zone
+      #   name strings, or {AWS::EC2::AvabilityZone} objects.
+      #
+      # @option options [required,Array] :listeners An array of load balancer
+      #   listener options.  Each value must be an array with the following
+      #   keys:
+      #
+      #   +:port+
+      #   +:protocol+
+      #   +:instance_port+
+      #   +:instance_protocol+
+      #
+      #   Port values should be integers, and protocols should be symbols or
+      #   strings (e.g. :http, or 'HTTP').  See {ListenerCollection#create}
+      #   for more detailed description of each option.
+      #
+      # @option options [String,IAM::ServerCertificate] :server_certificate (nil)
+      #   The ARN string of an IAM::ServerCertifcate or an 
+      #   IAM::ServerCertificate object.  Reqruied for HTTPs listeners.
+      #
+      def create name, options = {}
+        
+        zones = [options[:availability_zones]].flatten.collect do |zone|
+          zone.is_a?(EC2::AvailabilityZone) ? zone.name : zone
+        end
+
+        listeners = [options[:listeners]].flatten.collect do |listener_opts|
+          format_listener_opts(listener_opts)
+        end
+
+        response = client.create_load_balancer(
+          :load_balancer_name => name.to_s,
+          :availability_zones => zones,
+          :listeners => listeners)
+
+        opts = {}
+        opts[:config] = config
+        opts[:dns_name] = response.dns_name
+
+        LoadBalancer.new(name, opts)
+
+      end
+
+      # @return [LoadBalancer] Returns the load balancer with the given
+      #   name.  This does not make a request, just returns a reference.
+      def [] name
+        LoadBalancer.new(name, :config => config)
+      end
+
+      protected
+      def _each_item options = {}, &block
+        response = client.describe_load_balancers
+        response.load_balancer_descriptions.each do |description|
+
+          load_balancer = LoadBalancer.new_from(
+            :describe_load_balancers, 
+            description, 
+            description.load_balancer_name,
+            :config => config)
+
+          yield(load_balancer)
+
+        end
+      end
+      
+    end
+  end
+end