fog 1.1.1 → 1.2.0

data/lib/fog/aws/elb.rb

@@ -4,9 +4,15 @@ module Fog
   module AWS
     class ELB < Fog::Service
 
-      class IdentifierTaken < Fog::Errors::Error; end
-      class InvalidInstance < Fog::Errors::Error; end
-      class Throttled       < Fog::Errors::Error; end
+      class DuplicatePolicyName         < Fog::Errors::Error; end
+      class IdentifierTaken             < Fog::Errors::Error; end
+      class InvalidInstance             < Fog::Errors::Error; end
+      class InvalidConfigurationRequest < Fog::Errors::Error; end
+      class PolicyNotFound              < Fog::Errors::Error; end
+      class PolicyTypeNotFound          < Fog::Errors::Error; end
+      class Throttled                   < Fog::Errors::Error; end
+      class TooManyPolicies             < Fog::Errors::Error; end
+      class ValidationError             < Fog::Errors::Error; end
 
       requires :aws_access_key_id, :aws_secret_access_key
       recognizes :region, :host, :path, :port, :scheme, :persistent
@@ -17,12 +23,15 @@ module Fog
       request :create_lb_cookie_stickiness_policy
       request :create_load_balancer
       request :create_load_balancer_listeners
+      request :create_load_balancer_policy
       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 :describe_load_balancer_policies
+      request :describe_load_balancer_policy_types
       request :disable_availability_zones_for_load_balancer
       request :enable_availability_zones_for_load_balancer
       request :register_instances_with_load_balancer
@@ -39,13 +48,16 @@ module Fog
 
       class Mock
 
+        require 'fog/aws/elb/policy_types'
+
         def self.data
           @data ||= Hash.new do |hash, region|
             owner_id = Fog::AWS::Mock.owner_id
             hash[region] = Hash.new do |region_hash, key|
               region_hash[key] = {
                 :owner_id => owner_id,
-                :load_balancers => {}
+                :load_balancers => {},
+                :policy_types => Fog::AWS::ELB::Mock::POLICY_TYPES
               }
             end
           end
@@ -94,7 +106,7 @@ module Fog
         #
         # ==== 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', 'us-west-2', 'ap-northeast-1', 'ap-southeast-1']
+        #   * region<~String> - optional region to use. For instance, 'eu-west-1', 'us-east-1', etc.
         #
         # ==== Returns
         # * ELB object with connection to AWS.
@@ -107,22 +119,7 @@ module Fog
           @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'
-          when 'us-west-2'
-            'elasticloadbalancing.us-west-2.amazonaws.com'
-          else
-            raise ArgumentError, "Unknown region: #{options[:region].inspect}"
-          end
+          @host = options[:host] || "elasticloadbalancing.#{options[:region]}.amazonaws.com"
           @path       = options[:path]        || '/'
           @persistent = options[:persistent]  || false
           @port       = options[:port]        || 443
@@ -148,7 +145,7 @@ module Fog
               :host               => @host,
               :path               => @path,
               :port               => @port,
-              :version            => '2011-04-05'
+              :version            => '2011-11-15'
           }
           )
 
@@ -166,14 +163,27 @@ module Fog
             case match[1]
             when 'CertificateNotFound'
               raise Fog::AWS::IAM::NotFound.slurp(error, match[2])
-            when 'LoadBalancerNotFound'
-              raise Fog::AWS::ELB::NotFound.slurp(error, match[2])
             when 'DuplicateLoadBalancerName'
               raise Fog::AWS::ELB::IdentifierTaken.slurp(error, match[2])
+            when 'DuplicatePolicyName'
+              raise Fog::AWS::ELB::DuplicatePolicyName.slurp(error, match[2])
             when 'InvalidInstance'
               raise Fog::AWS::ELB::InvalidInstance.slurp(error, match[2])
+            when 'InvalidConfigurationRequest'
+              # when do they fucking use this shit?
+              raise Fog::AWS::ELB::InvalidConfigurationRequest.slurp(error, match[2])
+            when 'LoadBalancerNotFound'
+              raise Fog::AWS::ELB::NotFound.slurp(error, match[2])
+            when 'PolicyNotFound'
+              raise Fog::AWS::ELB::PolicyNotFound.slurp(error, match[2])
+            when 'PolicyTypeNotFound'
+              raise Fog::AWS::ELB::PolicyTypeNotFound.slurp(error, match[2])
             when 'Throttling'
               raise Fog::AWS::ELB::Throttled.slurp(error, match[2])
+            when 'TooManyPolicies'
+              raise Fog::AWS::ELB::TooManyPolicies.slurp(error, match[2])
+            when 'ValidationError'
+              raise Fog::AWS::ELB::ValidationError.slurp(error, match[2])
             else
               raise
             end

data/lib/fog/aws/emr.rb

@@ -26,10 +26,10 @@ module Fog
       # collection  :snapshots
       # model       :parameter_group
       # collection  :parameter_groups
-      # 
+      #
       # model       :parameter
       # collection  :parameters
-      # 
+      #
       # model       :security_group
       # collection  :security_groups
 
@@ -57,7 +57,7 @@ module Fog
         #
         # ==== 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', 'us-west-2', 'ap-southeast-1']
+        #   * region<~String> - optional region to use. For instance, in 'eu-west-1', 'us-east-1' and etc.
         #
         # ==== Returns
         # * EMR object with connection to AWS.
@@ -68,12 +68,13 @@ module Fog
           @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
 
           options[:region] ||= 'us-east-1'
-          @host = options[:host] || 'elasticmapreduce.amazonaws.com'
+          @host = options[:host] || "elasticmapreduce.#{options[:region]}.amazonaws.com"
           @path       = options[:path]        || '/'
           @persistent = options[:persistent]  || false
           @port       = options[:port]        || 443
           @scheme     = options[:scheme]      || 'https'
           @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
+          @region = options[:region]
         end
 
         def reload

data/lib/fog/aws/iam.rb

@@ -61,7 +61,22 @@ module Fog
           @data ||= Hash.new do |hash, key|
             hash[key] = {
               :owner_id => Fog::AWS::Mock.owner_id,
-              :server_certificates => {}
+              :server_certificates => {},
+              :users => Hash.new do |uhash, ukey|
+                uhash[ukey] = {
+                  :user_id     => Fog::AWS::Mock.key_id,
+                  :arn         => "arn:aws:iam::#{Fog::AWS::Mock.owner_id}:user/#{ukey}",
+                  :access_keys => [],
+                  :policies    => {}
+                }
+              end,
+              :groups => Hash.new do |ghash, gkey|
+                ghash[gkey] = {
+                  :group_id   => Fog::AWS::Mock.key_id,
+                  :arn        => "arn:aws:iam::#{Fog::AWS::Mock.owner_id}:group/#{gkey}",
+                  :members    => []
+                }
+              end
             }
           end
         end

data/lib/fog/aws/models/auto_scaling/activity.rb

@@ -9,7 +9,7 @@ module Fog
         attribute :auto_scaling_group_name, :aliases => 'AutoScalingGroupName'
         attribute :cause,                   :aliases => 'Cause'
         attribute :description,             :aliases => 'Description'
-	attribute :end_time,                :aliases => 'EndTime'
+        attribute :end_time,                :aliases => 'EndTime'
         attribute :progress,                :aliases => 'Progress'
         attribute :start_time,              :aliases => 'StartTime'
         attribute :status_code,             :aliases => 'StatusCode'

data/lib/fog/aws/models/auto_scaling/group.rb

@@ -65,9 +65,9 @@ module Fog
           reload
         end
 
-        def enable_metrics_collection(metrics = {})
+        def enable_metrics_collection(granularity = '1Minute', metrics = {})
           requires :id
-          connection.enable_metrics_collection(id, 'Metrics' => metrics)
+          connection.enable_metrics_collection(id, granularity, 'Metrics' => metrics)
           reload
         end
 

data/lib/fog/aws/models/beanstalk/application.rb

@@ -0,0 +1,62 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class ElasticBeanstalk
+
+      class Application < Fog::Model
+        identity :name, :aliases => 'ApplicationName'
+        attribute :template_names, :aliases => 'ConfigurationTemplates'
+        attribute :created_at, :aliases => 'DateCreated'
+        attribute :updated_at, :aliases => 'DateUpdated'
+        attribute :description, :aliases => 'Description'
+        attribute :version_names, :aliases => 'Versions'
+
+        def initialize(attributes={})
+          super
+        end
+
+        def environments
+          requires :name
+          connection.environments.all({'ApplicationName' => name})
+        end
+
+        def events
+          requires :name
+          connection.events.all({'ApplicationName' => name})
+        end
+
+        def templates
+          requires :name
+          connection.templates.all({'ApplicationName' => name})
+        end
+
+        def versions
+          requires :name
+          connection.versions.all({'ApplicationName' => name})
+        end
+
+        def destroy
+          requires :name
+          connection.delete_application(name)
+          true
+        end
+
+        def save
+          requires :name
+
+          options = {
+              'ApplicationName' => name
+          }
+          options['Description'] = description unless description.nil?
+
+          data = connection.create_application(options).body['CreateApplicationResult']['Application']
+          merge_attributes(data)
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/beanstalk/applications.rb

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/aws/models/beanstalk/application'
+
+module Fog
+  module AWS
+    class ElasticBeanstalk
+
+      class Applications < Fog::Collection
+        model Fog::AWS::ElasticBeanstalk::Application
+
+        def all(application_names=[])
+          data = connection.describe_applications(application_names).body['DescribeApplicationsResult']['Applications']
+          load(data) # data is an array of attribute hashes
+        end
+
+        def get(application_name)
+          if data = connection.describe_applications([application_name]).body['DescribeApplicationsResult']['Applications'].first
+            new(data)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/beanstalk/environment.rb

@@ -0,0 +1,129 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class ElasticBeanstalk
+
+      class Environment < Fog::Model
+        identity :name, :aliases => 'EnvironmentName'
+        attribute :id, :aliases => 'EnvironmentId'
+
+        attribute :application_name, :aliases => 'ApplicationName'
+        attribute :cname, :aliases => 'CNAME'
+        attribute :cname_prefix, :aliases => 'CNAMEPrefix'
+        attribute :created_at, :aliases => 'DateCreated'
+        attribute :updated_at, :aliases => 'DateUpdated'
+        attribute :updated_at, :aliases => 'DateUpdated'
+        attribute :description, :aliases => 'Description'
+        attribute :endpoint_url, :aliases => 'EndpointURL'
+        attribute :health, :aliases => 'Health'
+        attribute :resources, :aliases => 'Resources'
+        attribute :solution_stack_name, :aliases => 'SolutionStackName'
+        attribute :status, :aliases => 'Status'
+        attribute :template_name, :aliases => 'TemplateName'
+        attribute :version_label, :aliases => 'VersionLabel'
+        attribute :option_settings, :aliases => 'OptionSettings'
+        attribute :options_to_remove, :aliases => 'OptionsToRemove'
+
+        def healthy?
+          health == 'Green'
+        end
+
+        def ready?
+          status == 'Ready'
+        end
+
+        def terminated?
+          status == 'Terminated'
+        end
+
+        # Returns the current live resources for this environment
+        def live_resources
+          requires :id
+          data = connection.describe_environment_resources({'EnvironmentId' => id}).body['DescribeEnvironmentResourcesResult']['EnvironmentResources']
+          data.delete('EnvironmentName') # Delete the environment name from the result, only return actual resources
+          data
+        end
+
+        # Return events related to this version
+        def events
+          requires :id
+          connection.events.all({'EnvironmentId' => id})
+        end
+
+        # Restarts the app servers in this environment
+        def restart_app_server
+          requires :id
+          connection.restart_app_server({'EnvironmentId' => id})
+          reload
+        end
+
+        # Rebuilds the environment
+        def rebuild
+          requires :id
+          connection.rebuild_environment({'EnvironmentId' => id})
+          reload
+        end
+
+        # Return the version object for this environment
+        def version
+          requires :application_name, :version_label
+          connection.versions.get(application_name, version_label)
+        end
+
+        # Update the running version of this environment
+        def version=(new_version)
+          requires :id
+          if new_version.is_a?(String)
+            new_version_label = new_version
+          elsif new_version.is_a?(Fog::AWS::ElasticBeanstalk::Version)
+            new_version_label = new_version.label
+          else
+            raise "Unknown type for new_version, must be either String or Fog::AWS::ElasticBeanstalk::Version"
+          end
+
+          if new_version.nil?
+            raise "Version label not specified."
+          end
+
+          data = connection.update_environment({
+              'EnvironmentId' => id,
+              'VersionLabel' => new_version_label
+                                        }).body['UpdateEnvironmentResult']
+
+          merge_attributes(data)
+        end
+
+        def destroy
+          requires :id
+          connection.terminate_environment({'EnvironmentId' => id})
+          true
+        end
+
+        def save
+          requires :name, :application_name
+          requires_one :template_name, :solution_stack_name
+
+          options = {
+              'ApplicationName' => application_name,
+              'CNAMEPrefix' => cname_prefix,
+              'Description' => description,
+              'EnvironmentName' => name,
+              'OptionSettings' => option_settings,
+              'OptionsToRemove' => options_to_remove,
+              'SolutionStackName' => solution_stack_name,
+              'TemplateName' => template_name,
+              'VersionLabel' => version_label
+          }
+          options.delete_if {|key, value| value.nil?}
+
+          data = connection.create_environment(options).body['CreateEnvironmentResult']
+          merge_attributes(data)
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/beanstalk/environments.rb

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/aws/models/beanstalk/environment'
+
+module Fog
+  module AWS
+    class ElasticBeanstalk
+
+      class Environments < Fog::Collection
+        model Fog::AWS::ElasticBeanstalk::Environment
+
+        def all(options={})
+          data = connection.describe_environments(options).body['DescribeEnvironmentsResult']['Environments']
+          load(data) # data is an array of attribute hashes
+        end
+
+        # Gets an environment given a name.
+        #
+        def get(environment_name)
+          options = { 'EnvironmentNames' => [environment_name] }
+
+          if data = connection.describe_environments(options).body['DescribeEnvironmentsResult']['Environments'].first
+            new(data)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/beanstalk/event.rb

@@ -0,0 +1,20 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class ElasticBeanstalk
+
+      class Event < Fog::Model
+        attribute :application_name, :aliases => 'ApplicationName'
+        attribute :environment_name, :aliases => 'EnvironmentName'
+        attribute :date, :aliases => 'EventDate'
+        attribute :message, :aliases => 'Message'
+        attribute :request_id, :aliases => 'RequestId'
+        attribute :severity, :aliases => 'Severity'
+        attribute :template_name, :aliases => 'TemplateName'
+        attribute :version_label, :aliases => 'VersionLabel'
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/beanstalk/events.rb

@@ -0,0 +1,19 @@
+require 'fog/core/collection'
+require 'fog/aws/models/beanstalk/event'
+
+module Fog
+  module AWS
+    class ElasticBeanstalk
+
+      class Events < Fog::Collection
+        model Fog::AWS::ElasticBeanstalk::Event
+
+        def all(options={})
+          data = connection.describe_events(options).body['DescribeEventsResult']['Events']
+          load(data) # data is an array of attribute hashes
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/beanstalk/template.rb

@@ -0,0 +1,62 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class ElasticBeanstalk
+
+      class Template < Fog::Model
+        attribute :name, :aliases => 'TemplateName'
+        attribute :application_name, :aliases => 'ApplicationName'
+        attribute :created_at, :aliases => 'DateCreated'
+        attribute :updated_at, :aliases => 'DateUpdated'
+        attribute :deployment_status, :aliases => 'DeploymentStatus'
+        attribute :description, :aliases => 'Description'
+        attribute :environment_id
+        attribute :environment_name, :aliases => 'EnvironmentName'
+        attribute :solution_stack_name, :aliases => 'SolutionStackName'
+        attribute :source_configuration
+        attribute :option_settings, :aliases => 'OptionSettings'
+
+        def initialize(attributes={})
+          super
+        end
+
+        # Returns an array of options that may be set on this template
+        def options
+          requires :name, :application_name
+          data = connection.describe_configuration_options({
+              'ApplicationName' => application_name,
+              'TemplateName' => name
+                                                    })
+          data.body['DescribeConfigurationOptionsResult']['Options']
+        end
+
+        def destroy
+          requires :name, :application_name
+          connection.delete_configuration_template(application_name, name)
+          true
+        end
+
+        def save
+          requires :name, :application_name
+
+          options = {
+              'ApplicationName' => application_name,
+              'Description' => description,
+              'EnvironmentId' => environment_id,
+              'OptionSettings' => option_settings,
+              'SolutionStackName' => solution_stack_name,
+              'SourceConfiguration' => source_configuration,
+              'TemplateName' => name
+          }
+          options.delete_if {|key, value| value.nil?}
+
+          data = connection.create_configuration_template(options).body['CreateConfigurationTemplateResult']
+          merge_attributes(data)
+          true
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/beanstalk/templates.rb

@@ -0,0 +1,70 @@
+require 'fog/core/collection'
+require 'fog/aws/models/beanstalk/template'
+
+module Fog
+  module AWS
+    class ElasticBeanstalk
+
+      class Templates < Fog::Collection
+        model Fog::AWS::ElasticBeanstalk::Template
+
+        # Describes all configuration templates, may optionally pass an ApplicationName filter
+        #
+        # Note: This is currently an expensive operation requiring multiple API calls due to a lack of
+        # a describe configuration templates call in the AWS API.
+        def all(options={})
+          application_filter = []
+          if options.has_key?('ApplicationName')
+            application_filter << options['ApplicationName']
+          end
+
+          # Initialize with empty array
+          data = []
+
+          applications = connection.describe_applications(application_filter).body['DescribeApplicationsResult']['Applications']
+          applications.each { |application|
+            application['ConfigurationTemplates'].each { |template_name|
+              begin
+                options = {
+                    'ApplicationName' => application['ApplicationName'],
+                    'TemplateName' => template_name
+                }
+                settings = connection.describe_configuration_settings(options).body['DescribeConfigurationSettingsResult']['ConfigurationSettings']
+                if settings.length == 1
+                  # Add to data
+                  data << settings.first
+                end
+              rescue Fog::AWS::ElasticBeanstalk::InvalidParameterError
+                # Ignore
+              end
+
+            }
+          }
+
+          load(data) # data is an array of attribute hashes
+        end
+
+        def get(application_name, template_name)
+          options = {
+              'ApplicationName' => application_name,
+              'TemplateName' => template_name
+          }
+
+          result = nil
+          # There is no describe call for templates, so we must use describe_configuration_settings.  Unfortunately,
+          # it throws an exception if template name doesn't exist, which is inconsistent, catch and return nil
+          begin
+            data = connection.describe_configuration_settings(options).body['DescribeConfigurationSettingsResult']['ConfigurationSettings']
+            if data.length == 1
+              result = new(data.first)
+            end
+          rescue Fog::AWS::ElasticBeanstalk::InvalidParameterError
+
+          end
+            result
+        end
+
+      end
+    end
+  end
+end