aws-sdk-v1 1.52.0

data/lib/aws/elb/listener_opts.rb

@@ -0,0 +1,45 @@
+# Copyright 2011-2013 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
+
+    # @api 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/load_balancer.rb

@@ -0,0 +1,280 @@
+# Copyright 2011-2013 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: [using-domain-names-with-elb.html](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: [using-domain-names-with-elb.html](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.
+    #
+    # @attr_reader [Hash] policy_descriptions Returns a hash of
+    #   `:app_cookie_stickiness_policies`, `:lb_cookie_stickiness_policies`
+    #   and `:other_policies`.  See also {#policies}.
+    #
+    # @attr_reader [String,nil] scheme Specifies the type of LoadBalancer.
+    #   This attribute it set only for LoadBalancers attached to an Amazon VPC.
+    #   If the Scheme is 'internet-facing', the LoadBalancer has a publicly
+    #   resolvable DNS name that resolves to public IP addresses.
+    #   If the Scheme is 'internal', the LoadBalancer has a publicly
+    #   resolvable DNS name that resolves to private IP addresses.
+    #
+    # @attr_reader [Array<String>] subnet_ids Provides a list of VPC subnet IDs
+    #   for the LoadBalancer.
+    #
+    # @attr_reader [Hash] health_check
+    #   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]
+    #
+    #
+    class LoadBalancer < Core::Resource
+
+      def initialize name, options = {}
+        super(options.merge(:name => name.to_s))
+      end
+
+      attribute :name, :from => :load_balancer_name, :static => true
+
+      # see #availability_zones
+      attribute :availability_zone_names, :from => :availability_zones
+
+      # see #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
+
+      attribute :health_check, :alias => :health_check_configuration
+
+      # see #instances
+      attribute :instance_descriptions, :from => :instances
+
+      # see #listeners
+      attribute :listener_descriptions
+
+      attribute :policy_descriptions, :from => :policies
+
+      attribute :scheme, :static => true
+
+      attribute :subnet_ids, :from => :subnets, :static => true
+
+      attribute :security_group_ids, :from => :security_groups, :static => true
+
+      attribute :source_security_group_owner_alias,
+        :from => [:source_security_group, :owner_alias],
+        :static => true
+
+      attribute :source_security_group_name,
+        :from => [:source_security_group, :group_name],
+        :static => true
+
+      populates_from(:describe_load_balancers) do |resp|
+        resp.data[: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-west-2b')
+      #
+      # @example disable an availability zone
+      #
+      #   load_balancer.availability_zones.disable('us-west-2b')
+      #
+      # @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} 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.merge(options)
+
+        response = client.configure_health_check(
+          :load_balancer_name => name,
+          :health_check => new_config)
+
+        new_config
+
+      end
+
+      # @note VPC only
+      # @return [Array<EC2::Subnet>] Returns an array of VPC subnets
+      #   for this load balancer.
+      def subnets
+        subnet_ids.map{|id| EC2::Subnet.new(id, :config => config) }
+      end
+
+      # @note VPC only
+      # Returns the VPC security groups assigned to this load balancer.
+      # @return [Array<EC2::SecurityGroup>]
+      def security_groups
+        security_group_ids.collect do |id|
+          EC2::SecurityGroup.new(id, :config => config)
+        end
+      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 {EC2::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
+      #   {EC2::SecurityGroup} methods as a source:
+      #
+      #   * {EC2::SecurityGroup#authorize_ingress}
+      #   * {EC2::SecurityGroup#authorize_egress}
+      #
+      def source_security_group
+        {
+          :group_name => source_security_group_name,
+          :user_id => source_security_group_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
+
+      def get_resource attr_name
+        client.describe_load_balancers(:load_balancer_names => [name])
+      end
+
+    end
+  end
+end

data/lib/aws/elb/load_balancer_collection.rb

@@ -0,0 +1,146 @@
+# Copyright 2011-2013 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-west-2a us-west-2b),
+      #       :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::AvailabilityZone} objects.
+      #
+      # @option options [required,Array<Hash>] :listeners An array of load
+      #   balancer listener options:
+      #     * `:protocol` - *required* - (String) Specifies the LoadBalancer
+      #       transport protocol to use for routing - HTTP, HTTPS, TCP or SSL.
+      #       This property cannot be modified for the life of the
+      #       LoadBalancer.
+      #     * `:load_balancer_port` - *required* - (Integer) Specifies the
+      #       external LoadBalancer port number. This property cannot be
+      #       modified for the life of the LoadBalancer.
+      #     * `:instance_protocol` - (String) Specifies the protocol to use for
+      #       routing traffic to back-end instances - HTTP, HTTPS, TCP, or SSL.
+      #       This property cannot be modified for the life of the
+      #       LoadBalancer. If the front-end protocol is HTTP or HTTPS,
+      #       InstanceProtocol has to be at the same protocol layer, i.e., HTTP
+      #       or HTTPS. Likewise, if the front-end protocol is TCP or SSL,
+      #       InstanceProtocol has to be TCP or SSL. If there is another
+      #       listener with the same InstancePort whose InstanceProtocol is
+      #       secure, i.e., HTTPS or SSL, the listener's InstanceProtocol has
+      #       to be secure, i.e., HTTPS or SSL. If there is another listener
+      #       with the same InstancePort whose InstanceProtocol is HTTP or TCP,
+      #       the listener's InstanceProtocol must be either HTTP or TCP.
+      #     * `:instance_port` - *required* - (Integer) Specifies the TCP port
+      #       on which the instance server is listening. This property cannot
+      #       be modified for the life of the LoadBalancer.
+      #     * `:ssl_certificate_id` - (String) The ARN string of the server
+      #       certificate. To get the ARN of the server certificate, call the
+      #       AWS Identity and Access Management UploadServerCertificate API.
+      #
+      # @option options [Array] :subnets An list of VPC subets to attach the
+      #   load balancer to.  This can be an array of subnet ids (strings) or
+      #   {EC2::Subnet} objects. VPC only.
+      #
+      # @option options [Array] :security_groups The security groups assigned to
+      #   your load balancer within your VPC.  This can be an array of
+      #   security group ids or {EC2::SecurityGroup} objects. VPC only.
+      #
+      # @option options [String] :scheme ('internal' The type of a load
+      #   balancer.  Accepts 'internet-facing' or 'internal'. VPC only.
+      #
+      def create name, options = {}
+
+        if listeners = options[:listeners]
+          options[:listeners] = [listeners].flatten.map do |listener|
+            format_listener_opts(listener)
+          end
+        end
+
+        if zones = options[:availability_zones]
+          options[:availability_zones] = [zones].flatten.map do |zone|
+            zone.is_a?(EC2::AvailabilityZone) ? zone.name : zone
+          end
+        end
+
+        if groups = options[:security_groups]
+          options[:security_groups] = [groups].flatten.map do |group|
+            group.is_a?(EC2::SecurityGroup) ? group.id : group
+          end
+        end
+
+        if subnets = options[:subnets]
+          options[:subnets] = [subnets].flatten.map do |subnet|
+            subnet.is_a?(EC2::Subnet) ? subnet.id : subnet
+          end
+        end
+
+        options[:load_balancer_name] = name.to_s
+
+        resp = client.create_load_balancer(options)
+
+        LoadBalancer.new(name, :dns_name => resp[:dns_name], :config => config)
+
+      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(options)
+        response.data[: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