aws-sdk-v1-reinteractive 1.67.1

data/lib/aws/elb/backend_server_policy_collection.rb

@@ -0,0 +1,139 @@
+# 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
+
+    # Helps manage policies assigned to backend server instnace ports.
+    #
+    # ## Creating a Backend Server Policy
+    #
+    # Creating a backend server policy can be a bit tricky.  A
+    # BackendServerAuthenticationPolicyType policy only has one
+    # attribute, a list of public key policies.
+    #
+    # Before you can assign a policy to a backend server instance port you
+    # must create on of the appropriate type:
+    #
+    #     # step 1, create one (or more) PublicKeyPolicyType policies
+    #
+    #     public_key1 = <<-KEY
+    #     -----BEGIN CERTIFICATE-----
+    #     MIICaTCCAdICCQDuvCF4erLGSjANBgkqhkiG9w0BAQUFADB5MQswCQYDVQQGEwJa
+    #     ....
+    #     o50MymfqtoVcebZcXbiDVAXW1cPEHKLBXecX6/LZ+GOzEsUOxgt7Xs9uabqp
+    #     -----END CERTIFICATE-----
+    #     KEY
+    #
+    #     public_key_policy = load_balancer.policies.create("pkp",
+    #       'PublicKeyPolicyType', 'PublicKey' => public_key.strip)
+    #
+    #     # step 2, create the backend server policy, passing the public key policy
+    #
+    #     name = 'backend-policy'
+    #     type = 'BackendServerAuthenticationPolicyType'
+    #     attributes = {
+    #       # note: you can pass more than one public key policy here
+    #       'PublicKeyPolicyName' => [public_key_policy]
+    #     }
+    #
+    #     backend_policy = @load_balancer.policies.create(name, type, attributes)
+    #       'BackendServerAuthenticationPolicyType', attributes)
+    #
+    # Once you have created a backend server authentication policy, you
+    # can assign it to a backend instance port:
+    #
+    #     load_balancer.backend_server_policies[80] = backend_policy
+    #
+    # If you want to remove the policy you can pass nil instead.
+    #
+    #     # removes the policy from instance port 80
+    #     load_balancer.backend_server_policies[80] = nil
+    #
+    # You can also get the current policy:
+    #
+    #     load_balancer.backend_server_policies[80] # returns a policy or nil
+    #
+    class BackendServerPolicyCollection
+
+      include Core::Collection::Simple
+
+      def initialize load_balancer, options = {}
+        @load_balancer = load_balancer
+        super
+      end
+
+      # @return [LoadBalancer]
+      attr_reader :load_balancer
+
+      # Returns the policy currently assigned to the given instance port.
+      #
+      # @param [Integer] instance_port The backend server port to
+      #   get the currently policy of.
+      #
+      # @return [LoadBalancerPolicy,nil] Returns the load balancer policy
+      #   currently assigned to the given instance port.  Returns nil if
+      #   no policy has been assigned.
+      #
+      def [] instance_port
+        enum(:instance_port => instance_port).first
+      end
+
+      # Sets the policy for the given backend server instance port.
+      #
+      # @param [Integer] instance_port The instance port you want to set
+      #   backend server policies for.
+      #
+      # @param [String,LoadBalancerPolicy,nil] policy Load balancer policy
+      #   name or object.  Passing nil removes the current policy.
+      #
+      # @return [nil]
+      #
+      def []= instance_port, policy
+
+        client.set_load_balancer_policies_for_backend_server(
+          :load_balancer_name => load_balancer.name,
+          :instance_port => instance_port.to_i,
+          :policy_names => [policy_name(policy)].compact)
+
+        nil
+
+      end
+
+      protected
+      def policy_name policy
+        case policy
+        when nil then nil
+        when LoadBalancerPolicy then policy.name
+        else policy.to_s
+        end
+      end
+
+      protected
+      def _each_item options = {}
+
+        instance_port = options[:instance_port]
+
+        load_balancer.backend_server_descriptions.each do |desc|
+          if instance_port.nil? or desc[:instance_port] == instance_port
+            desc[:policy_names].each do |policy_name|
+              yield(load_balancer.policies[policy_name])
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/aws/elb/client.rb

@@ -0,0 +1,35 @@
+# 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
+
+    # Client class for Elastic Load Balancing (ELB).
+    class Client < Core::QueryClient
+
+      API_VERSION = '2012-06-01'
+
+      signature_version :Version4, 'elasticloadbalancing'
+
+      # @api private
+      CACHEABLE_REQUESTS = Set[]
+
+    end
+
+    class Client::V20120601 < Client
+
+      define_client_methods('2012-06-01')
+
+    end
+  end
+end

data/lib/aws/elb/config.rb

@@ -0,0 +1,18 @@
+# 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.
+
+AWS::Core::Configuration.module_eval do
+
+  add_service 'ELB', 'elb', 'elasticloadbalancing'
+
+end

data/lib/aws/elb/errors.rb

@@ -0,0 +1,26 @@
+# 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
+    module Errors
+
+      extend Core::LazyErrorClasses
+
+      def self.error_class code
+        super(code.sub(/^ElasticLoadBalancing\./, ''))
+      end
+
+    end
+  end
+end

data/lib/aws/elb/instance_collection.rb

@@ -0,0 +1,168 @@
+# 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 InstanceCollection
+
+      include Core::Collection::Simple
+
+      def initialize load_balancer, options = {}
+        @load_balancer = load_balancer
+        super
+      end
+
+      # Returns an {EC2::Instance} object with 3 extra methods added:
+      #
+      # * `#load_balancer`
+      # * `#remove_from_load_balancer`
+      # * `#elb_health`
+      #
+      # See {#health} for more information about what `#elb_health` returns.
+      #
+      # @return [EC2::Instance] Return an EC2::Instance object with additional
+      #   methods added.
+      #
+      def [] instance_id
+
+        load_balancer = self.load_balancer
+
+        instance = EC2.new(:config => config).instances[instance_id]
+
+        Core::MetaUtils.extend_method(instance, :load_balancer) do
+          load_balancer
+        end
+
+        Core::MetaUtils.extend_method(instance, :elb_health) do
+          health = load_balancer.instances.health(id).first
+          health.delete(:instance)
+          health
+        end
+
+        Core::MetaUtils.extend_method(instance, :remove_from_load_balancer) do
+          load_balancer.instances.deregister(self)
+        end
+
+        instance
+
+      end
+
+      # Returns an array of instance health descriptions.  Each description
+      # is a hash with the following entries:
+      #
+      #   * `:instance` - The {EC2::Instance} being described.
+      #   * `:description` - Provides a description of the instance.
+      #   * `:state` - Specifies the current state of the instance.
+      #   * `:reason_code` - Provides information about the cause of
+      #     OutOfService instances. Specifically, it indicates whether the
+      #     cause is Elastic Load Balancing or the instance behind the
+      #     load balancer.
+      #
+      # You can get the health of all instances for this load balancer
+      # by passing no arguments to this method:
+      #
+      #     # get the health of all instances in the collection
+      #     load_balancer.instances.health.each do |instance_health|
+      #        puts "Instance: "    + instance_health[:instance].id
+      #        puts "description: " + instance_health[:description]
+      #        puts "state: "       + instance_health[:state]
+      #        puts "reason code: " + instance_health[:reason_code]
+      #     end
+      #
+      # If you want the health of a specific list of instances, pass
+      # instance ids or instance objects to this method:
+      #
+      #     # get the health for a few specific instances
+      #     load_balancer.instances.health('i-12345', 'i-67890').each{|h| ... }
+      #
+      # ## Health for a Single Instance
+      #
+      # If you want the health of a single instance you can use the {#[]}
+      # instead:
+      #
+      #     load_balancer.instances['i-123456'].elb_health
+      #     # => { :state => ..., :reason_code => ..., :description => ... }
+      #
+      # @param [String,EC2::Instance] instances A list of instances to
+      #   receive health information for.
+      #
+      # @return [Array<Hash>] Returns an array of hashes.  Each hash represents
+      #   the health of a single instance.  Each hash includes the following
+      #   entries:
+      #
+      def health *instances
+
+        instance_ids = instance_ids(instances)
+
+        opts = {}
+        opts[:load_balancer_name] = load_balancer.name
+        opts[:instances] = instance_ids unless instance_ids.empty?
+
+        client.describe_instance_health(opts).instance_states.map do |state|
+          {
+            :instance => self[state.instance_id],
+            :description => state.description,
+            :state => state.state,
+            :reason_code => state.reason_code,
+          }
+        end
+
+      end
+
+      # @return [LoadBalancer] Returns the load balancer this collection
+      #   belongs to.
+      attr_reader :load_balancer
+
+      def register *instances
+
+        client.register_instances_with_load_balancer(
+          :load_balancer_name => load_balancer.name,
+          :instances => instance_ids(instances))
+
+        nil
+
+      end
+      alias_method :add, :register
+
+      def deregister *instances
+
+        client.deregister_instances_from_load_balancer(
+          :load_balancer_name => load_balancer.name,
+          :instances => instance_ids(instances))
+
+        nil
+
+      end
+      alias_method :remove, :deregister
+
+      protected
+      def instance_ids instances
+        instances.flatten.collect do |instance|
+          case instance
+          when EC2::Instance then { :instance_id => instance.id }
+          else { :instance_id => instance }
+          end
+        end
+      end
+
+      protected
+      def _each_item options = {}
+        load_balancer.instance_descriptions.each do |instance|
+          yield(self[instance[:instance_id]])
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/elb/listener.rb

@@ -0,0 +1,190 @@
+# 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 Listener
+
+      include Core::Model
+
+      # @param [LoadBalancer] load_balancer The load balancer this listener
+      #   belongs to.
+      #
+      # @param [Integer] port The external load balancer port number.
+      #
+      # @param [Hash] options
+      #
+      # @option (see ListenerCollection#create)
+      #
+      def initialize load_balancer, port, options = {}
+
+        @load_balancer = load_balancer
+        @port = port.to_i
+        @protocol = options[:protocol]
+        @instance_port = options[:instance_port]
+        @instance_protocol = options[:instance_protocol]
+
+        super
+
+      end
+
+      # @return [LoadBalancer]
+      attr_reader :load_balancer
+
+      # @return [Integer]
+      attr_reader :port
+
+      # @return [Symbol] Returns the protocl for this listener.
+      def protocol
+        proto = @protocol ||= _description[:listener][:protocol]
+        proto.to_s.downcase.to_sym
+      end
+
+      # @return [Integer]
+      def instance_port
+        @instance_port ||= _description[:listener][:instance_port]
+      end
+
+      # @return [Symbol]
+      def instance_protocol
+        proto = @instance_protocol ||= _description[:listener][:instance_protocol]
+        proto.to_s.downcase.to_sym
+      end
+
+      # Sets the certificate that terminates the specified listener's SSL
+      # connections. The specified certificate replaces any prior
+      # certificate for this listener.
+      #
+      # @param [String,IAM::ServerCertificate] server_certificate The ARN
+      #   of an IAM::ServerCertificate or an IAM::ServerCertificate object.
+      #
+      # @return [nil]
+      #
+      def server_certificate= server_certificate
+
+        arn = server_certificate.is_a?(IAM::ServerCertificate) ?
+          server_certificate.arn : server_certificate
+
+        client.set_load_balancer_listener_ssl_certificate(
+          :load_balancer_name => load_balancer.name,
+          :load_balancer_port => port,
+          :ssl_certificate_id => arn)
+
+        nil
+
+      end
+
+      # @return [IAM::ServerCertificate,nil] Returns the IAM::ServerCertificate
+      #   associated with this listener, or nil if there is none.
+      def server_certificate
+        desc = _description
+        if desc[:listener][:ssl_certificate_id]
+          AWS.memoize do
+            arn = desc[:listener][:ssl_certificate_id]
+            iam = IAM.new(:config => config)
+            iam.server_certificates.find{|cert| cert.arn == arn }
+          end
+        else
+          nil
+        end
+      end
+
+      # @return [LoadBalancerPolicy,nil] Returns the current policy for this
+      #   listener.  Returns nil if no load balancer policy has been
+      #   associated with it.
+      def policy
+        policy_name = _description[:policy_names].first
+        policy_name ? load_balancer.policies[policy_name] : nil
+      end
+
+      # @param [String,LoadBalancerPolicy] policy_or_policy_name Sets
+      #   the policy for this listener.
+      # @return [LoadBalancerPolicy]
+      def policy= policy_or_policy_name
+
+        policy_name = policy_or_policy_name.is_a?(LoadBalancerPolicy) ?
+          policy_or_policy_name.name : policy_or_policy_name.to_s
+
+        client.set_load_balancer_policies_of_listener(
+          :load_balancer_name => load_balancer.name,
+          :load_balancer_port => port,
+          :policy_names => [policy_name])
+
+        LoadBalancerPolicy.new(load_balancer, policy_name, :config => config)
+
+      end
+
+      # Removes the current policy from this listener.
+      # @return [nil]
+      def remove_policy
+
+        client.set_load_balancer_policies_of_listener(
+          :load_balancer_name => load_balancer.name,
+          :load_balancer_port => port,
+          :policy_names => [])
+
+        nil
+
+      end
+
+      # Returns true if this listener exists.
+      #
+      #     load_balancer = ELB.new.load_balancers['my-load-balancer']
+      #     listener = load_balancer.listeners[80] # port 80
+      #     listener.exists?
+      #
+      # @return [Boolean] Returns true if the load balancer has a listener
+      #   on this port.
+      def exists?
+        !_description.nil?
+      rescue AWS::Core::Resource::NotFound
+        false
+      end
+
+      # Deletes the listener from its load balancer.
+      # @return [nil]
+      def delete
+
+        client.delete_load_balancer_listeners(
+          :load_balancer_name => load_balancer.name,
+          :load_balancer_ports => [port])
+
+        nil
+
+      end
+
+      # @api private
+      def inspect
+        "#{self.class.name} port:#{port}>"
+      end
+
+      # @api private
+      def eql? other
+        other.is_a?(Listener) and
+        other.load_balancer == load_balancer and
+        other.port == port
+      end
+      alias_method :==, :eql?
+
+      protected
+
+      def _description
+        load_balancer.listener_descriptions.find do |desc|
+          desc[:listener][:load_balancer_port] == port
+        end
+      end
+
+    end
+  end
+end