fog4encbs 0.9.0

data/lib/fog/aws/elb.rb

@@ -0,0 +1,146 @@
+module Fog
+  module AWS
+    class ELB < Fog::Service
+
+      class IdentifierTaken < Fog::Errors::Error; end
+      class InvalidInstance < Fog::Errors::Error; end
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :region, :host, :path, :port, :scheme, :persistent
+
+      request_path 'fog/aws/requests/elb'
+      request :configure_health_check
+      request :create_app_cookie_stickiness_policy
+      request :create_lb_cookie_stickiness_policy
+      request :create_load_balancer
+      request :create_load_balancer_listeners
+      request :delete_load_balancer
+      request :delete_load_balancer_listeners
+      request :delete_load_balancer_policy
+      request :deregister_instances_from_load_balancer
+      request :describe_instance_health
+      request :describe_load_balancers
+      request :disable_availability_zones_for_load_balancer
+      request :enable_availability_zones_for_load_balancer
+      request :register_instances_with_load_balancer
+      #request :set_load_balancer_listener_ssl_certificate
+      request :set_load_balancer_policies_of_listener
+
+      model_path 'fog/aws/models/elb'
+      model      :load_balancer
+      collection :load_balancers
+      model      :policy
+      collection :policies
+      model      :listener
+      collection :listeners
+
+      class Mock
+
+        def initialize(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+
+        # Initialize connection to ELB
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   elb = ELB.new(
+        #    :aws_access_key_id => your_aws_access_key_id,
+        #    :aws_secret_access_key => your_aws_secret_access_key
+        #   )
+        #
+        # ==== Parameters
+        # * options<~Hash> - config arguments for connection.  Defaults to {}.
+        #   * region<~String> - optional region to use, in ['eu-west-1', 'us-east-1', 'us-west-1', 'ap-northeast-1', 'ap-southeast-1']
+        #
+        # ==== Returns
+        # * ELB object with connection to AWS.
+        def initialize(options={})
+          require 'fog/core/parser'
+
+          @aws_access_key_id      = options[:aws_access_key_id]
+          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
+
+          options[:region] ||= 'us-east-1'
+          @host = options[:host] || case options[:region]
+          when 'ap-northeast-1'
+            'elasticloadbalancing.ap-northeast-1.amazonaws.com'
+          when 'ap-southeast-1'
+            'elasticloadbalancing.ap-southeast-1.amazonaws.com'
+          when 'eu-west-1'
+            'elasticloadbalancing.eu-west-1.amazonaws.com'
+          when 'us-east-1'
+            'elasticloadbalancing.us-east-1.amazonaws.com'
+          when 'us-west-1'
+            'elasticloadbalancing.us-west-1.amazonaws.com'
+          else
+            raise ArgumentError, "Unknown region: #{options[:region].inspect}"
+          end
+          @path       = options[:path]      || '/'
+          @port       = options[:port]      || 443
+          @scheme     = options[:scheme]    || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        private
+
+        def request(params)
+          idempotent  = params.delete(:idempotent)
+          parser      = params.delete(:parser)
+
+          body = Fog::AWS.signed_params(
+            params,
+            {
+              :aws_access_key_id  => @aws_access_key_id,
+              :hmac               => @hmac,
+              :host               => @host,
+              :path               => @path,
+              :port               => @port,
+              :version            => '2011-04-05'
+          }
+          )
+          begin
+            response = @connection.request({
+              :body       => body,
+              :expects    => 200,
+              :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+              :idempotent => idempotent,
+              :host       => @host,
+              :method     => 'POST',
+              :parser     => parser
+            })
+          rescue Excon::Errors::HTTPStatusError => error
+            if match = error.message.match(/<Code>(.*)<\/Code>/m)
+              case match[1]
+              when 'LoadBalancerNotFound'
+                raise Fog::AWS::ELB::NotFound
+              when 'DuplicateLoadBalancerName'
+                raise Fog::AWS::ELB::IdentifierTaken
+              when 'InvalidInstance'
+                raise Fog::AWS::ELB::InvalidInstance
+              else
+                raise
+              end
+            else
+              raise
+            end
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/iam.rb

@@ -0,0 +1,124 @@
+module Fog
+  module AWS
+    class IAM < Fog::Service
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :host, :path, :port, :scheme, :persistent
+
+      request_path 'fog/aws/requests/iam'
+      request :add_user_to_group
+      request :create_access_key
+      request :create_group
+      request :create_user
+      request :create_login_profile
+      request :delete_access_key
+      request :delete_group
+      request :delete_group_policy
+      request :delete_login_profile
+      request :delete_server_certificate
+      request :delete_signing_certificate
+      request :delete_user
+      request :delete_user_policy
+      request :get_login_profile
+      request :get_user
+      request :get_user_policy
+      request :get_group
+      request :list_access_keys
+      request :list_groups
+      request :list_groups_for_user
+      request :list_group_policies
+      request :list_server_certificates
+      request :list_signing_certificates
+      request :list_user_policies
+      request :list_users
+      request :put_group_policy
+      request :put_user_policy
+      request :remove_user_from_group
+      request :update_access_key
+      request :update_group
+      request :update_login_profile
+      request :update_user
+      request :update_signing_certificate
+      request :upload_server_certificate
+      request :upload_signing_certificate
+
+      class Mock
+
+        def initialize(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+
+        # Initialize connection to IAM
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   iam = IAM.new(
+        #    :aws_access_key_id => your_aws_access_key_id,
+        #    :aws_secret_access_key => your_aws_secret_access_key
+        #   )
+        #
+        # ==== Parameters
+        # * options<~Hash> - config arguments for connection.  Defaults to {}.
+        #
+        # ==== Returns
+        # * IAM object with connection to AWS.
+        def initialize(options={})
+          require 'fog/core/parser'
+          require 'json'
+
+          @aws_access_key_id      = options[:aws_access_key_id]
+          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @hmac       = Fog::HMAC.new('sha256', @aws_secret_access_key)
+          @host       = options[:host]      || 'iam.amazonaws.com'
+          @path       = options[:path]      || '/'
+          @port       = options[:port]      || 443
+          @scheme     = options[:scheme]    || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        private
+
+        def request(params)
+          idempotent  = params.delete(:idempotent)
+          parser      = params.delete(:parser)
+
+          body = Fog::AWS.signed_params(
+            params,
+            {
+              :aws_access_key_id  => @aws_access_key_id,
+              :hmac               => @hmac,
+              :host               => @host,
+              :path               => @path,
+              :port               => @port,
+              :version            => '2010-05-08'
+            }
+          )
+
+          response = @connection.request({
+            :body       => body,
+            :expects    => 200,
+            :idempotent => idempotent,
+            :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+            :host       => @host,
+            :method     => 'POST',
+            :parser     => parser
+          })
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/elb/listener.rb

@@ -0,0 +1,51 @@
+require 'fog/core/model'
+module Fog
+  module AWS
+    class ELB
+      class Listener < Fog::Model
+
+        attribute :policy_names,  :aliases => 'PolicyNames'
+        attribute :instance_port, :aliases => 'InstancePort'
+        attribute :lb_port,       :aliases => 'LoadBalancerPort'
+        attribute :protocol,      :aliases => 'Protocol'
+        attribute :ssl_id,        :aliases => 'SSLCertificateId'
+
+        def save
+          requires :load_balancer, :instance_port, :lb_port, :protocol
+          connection.create_load_balancer_listeners(load_balancer.id, [to_params])
+          reload
+        end
+
+        def destroy
+          requires :load_balancer, :lb_port
+          connection.delete_load_balancer_listeners(load_balancer.id, [lb_port])
+          reload
+        end
+
+        # Return the policy associated with this load balancer
+        def policy
+          load_balancer.policies.get(policy_names.first)
+        end
+
+        def reload
+          load_balancer.reload
+        end
+
+        def load_balancer
+          collection.load_balancer
+        end
+
+        def to_params
+          {
+            'InstancePort'     => instance_port,
+            'LoadBalancerPort' => lb_port,
+            'Protocol'         => protocol,
+            'SSLCertificateId' => ssl_id
+          }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/elb/listeners.rb

@@ -0,0 +1,32 @@
+require 'fog/aws/models/elb/listener'
+module Fog
+  module AWS
+    class ELB
+      class Listeners < Fog::Collection
+
+        model Fog::AWS::ELB::Listener
+
+        attr_accessor :data, :load_balancer
+
+        def all
+          load(munged_data)
+        end
+
+        def get(lb_port)
+          all.detect{|listener| listener.lb_port == lb_port}
+        end
+
+        private
+        # Munge an array of ListernerDescription hashes like:
+        # {'Listener' => listener, 'PolicyNames' => []}
+        # to an array of listeners withi a PolicyNames key
+        def munged_data
+          data.map {|description|
+            description['Listener'].merge('PolicyNames' => description['PolicyNames'])
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/elb/load_balancer.rb

@@ -0,0 +1,130 @@
+require 'fog/core/model'
+module Fog
+  module AWS
+    class ELB
+
+      class LoadBalancer < Fog::Model
+
+        identity  :id,                    :aliases => 'LoadBalancerName'
+        attribute :availability_zones,    :aliases => 'AvailabilityZones'
+        attribute :created_at,            :aliases => 'CreatedTime'
+        attribute :dns_name,              :aliases => 'DNSName'
+        attribute :health_check,          :aliases => 'HealthCheck'
+        attribute :instances,             :aliases => 'Instances'
+        attribute :source_group,          :aliases => 'SourceSecurityGroup'
+
+        def initialize(attributes={})
+          attributes[:availability_zones] ||= %w(us-east-1a us-east-1b us-east-1c us-east-1d)
+          attributes['ListenerDescriptions'] ||= [{
+            'Listener' => {'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'http'},
+            'PolicyNames' => []
+          }]
+          attributes['Policies'] ||= {'AppCookieStickinessPolicies' => [], 'LBCookieStickinessPolicies' => []}
+          super
+        end
+
+        def register_instances(instances)
+          requires :id
+          data = connection.register_instances_with_load_balancer(instances, id).body['RegisterInstancesWithLoadBalancerResult']
+          data['Instances'].map!{|h| h['InstanceId']}
+          merge_attributes(data)
+        end
+
+        def deregister_instances(instances)
+          requires :id
+          data = connection.deregister_instances_from_load_balancer(instances, id).body['DeregisterInstancesFromLoadBalancerResult']
+          data['Instances'].map!{|h| h['InstanceId']}
+          merge_attributes(data)
+        end
+
+        def enable_availability_zones(zones)
+          requires :id
+          data = connection.enable_availability_zones_for_load_balancer(zones, id).body['EnableAvailabilityZonesForLoadBalancerResult']
+          merge_attributes(data)
+        end
+
+        def disable_availability_zones(zones)
+          requires :id
+          data = connection.disable_availability_zones_for_load_balancer(zones, id).body['DisableAvailabilityZonesForLoadBalancerResult']
+          merge_attributes(data)
+        end
+
+        def instance_health
+          requires :id
+          @instance_health ||= connection.describe_instance_health(id).body['DescribeInstanceHealthResult']['InstanceStates']
+        end
+
+        def instances_in_service
+          instance_health.select{|hash| hash['State'] == 'InService'}.map{|hash| hash['InstanceId']}
+        end
+
+        def instances_out_of_service
+          instance_health.select{|hash| hash['State'] == 'OutOfService'}.map{|hash| hash['InstanceId']}
+        end
+
+        def configure_health_check(health_check)
+          requires :id
+          data = connection.configure_health_check(id, health_check).body['ConfigureHealthCheckResult']['HealthCheck']
+          merge_attributes(:health_check => data)
+        end
+
+        def listeners
+          Fog::AWS::ELB::Listeners.new({
+            :data => attributes['ListenerDescriptions'],
+            :connection => connection,
+            :load_balancer => self
+          })
+        end
+
+        def policies
+          Fog::AWS::ELB::Policies.new({
+            :data => attributes['Policies'],
+            :connection => connection,
+            :load_balancer => self
+          })
+        end
+
+        def set_listener_policy(port, policy_name)
+          requires :id
+          policy_name = [policy_name].flatten
+          connection.set_load_balancer_policies_of_listener(id, port, policy_name)
+          reload
+        end
+
+        def unset_listener_policy(port)
+          set_listener_policy(port, [])
+        end
+
+        def ready?
+          # ELB requests are synchronous
+          true
+        end
+
+        def save
+          requires :id
+          requires :listeners
+          requires :availability_zones
+
+          connection.create_load_balancer(availability_zones, id, listeners.map{|l| l.to_params})
+
+          # reload instead of merge attributes b/c some attrs (like HealthCheck)
+          # may be set, but only the DNS name is returned in the create_load_balance
+          # API call
+          reload
+        end
+
+        def reload
+          super
+          @instance_health = nil
+          self
+        end
+
+        def destroy
+          requires :id
+          connection.delete_load_balancer(id)
+        end
+
+      end
+    end
+  end
+end