fog 0.9.0 → 0.10.0

data/lib/fog/aws/iam.rb

@@ -2,16 +2,24 @@ module Fog
   module AWS
     class IAM < Fog::Service
 
+      class EntityAlreadyExists < Fog::AWS::IAM::Error; end
+      class KeyPairMismatch < Fog::AWS::IAM::Error; end
+      class LimitExceeded < Fog::AWS::IAM::Error; end
+      class MalformedCertificate < Fog::AWS::IAM::Error; end
+      class ValidationError < Fog::AWS::IAM::Error; end
+
       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_account_alias
       request :create_group
       request :create_user
       request :create_login_profile
       request :delete_access_key
+      request :delete_account_alias
       request :delete_group
       request :delete_group_policy
       request :delete_login_profile
@@ -23,7 +31,10 @@ module Fog
       request :get_user
       request :get_user_policy
       request :get_group
+      request :get_group_policy
+      request :get_server_certificate
       request :list_access_keys
+      request :list_account_aliases
       request :list_groups
       request :list_groups_for_user
       request :list_group_policies
@@ -43,11 +54,34 @@ module Fog
       request :upload_signing_certificate
 
       class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :owner_id => Fog::AWS::Mock.owner_id,
+              :server_certificates => {}
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def self.server_certificate_id
+          Fog::Mock.random_hex(16)
+        end
 
         def initialize(options={})
-          Fog::Mock.not_implemented
+          @aws_access_key_id = options[:aws_access_key_id]
         end
 
+        def data
+          self.class.data[@aws_access_key_id]
+        end
+
+        def reset_data
+          self.class.data.delete(@aws_access_key_id)
+        end
       end
 
       class Real
@@ -71,7 +105,7 @@ module Fog
         # * IAM object with connection to AWS.
         def initialize(options={})
           require 'fog/core/parser'
-          require 'json'
+          require 'multi_json'
 
           @aws_access_key_id      = options[:aws_access_key_id]
           @aws_secret_access_key  = options[:aws_secret_access_key]
@@ -105,17 +139,35 @@ module Fog
             }
           )
 
-          response = @connection.request({
-            :body       => body,
-            :expects    => 200,
-            :idempotent => idempotent,
-            :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
-            :host       => @host,
-            :method     => 'POST',
-            :parser     => parser
-          })
-
-          response
+          begin
+            response = @connection.request({
+              :body       => body,
+              :expects    => 200,
+              :idempotent => idempotent,
+              :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+              :host       => @host,
+              :method     => 'POST',
+              :parser     => parser
+            })
+
+            response
+          rescue Excon::Errors::HTTPStatusError => error
+            if match = error.message.match(/<Code>(.*)<\/Code>(?:.*<Message>(.*)<\/Message>)?/m)
+              case match[1]
+              when 'CertificateNotFound', 'NoSuchEntity'
+                raise Fog::AWS::IAM::NotFound.slurp(error, match[2])
+              when 'EntityAlreadyExists', 'KeyPairMismatch', 'LimitExceeded', 'MalformedCertificate', 'ValidationError'
+                raise Fog::AWS::IAM.const_get(match[1]).slurp(error, match[2])
+              else
+                raise Fog::AWS::IAM::Error.slurp(error, "#{match[1]} => #{match[2]}") if match[1]
+                raise
+              end
+            else
+              raise
+            end
+          end
+
+
         end
 
       end

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

@@ -0,0 +1,30 @@
+require 'fog/aws/models/auto_scaling/activity'
+
+module Fog
+  module AWS
+    class AutoScaling
+      class Activities < Fog::Collection
+
+        model Fog::AWS::AutoScaling::Activity
+
+        def all
+          data = []
+          next_token = nil
+          loop do
+            result = connection.describe_scaling_activities('NextToken' => next_token).body['DescribeScalingActivitiesResult']
+            data += result['Activities']
+            next_token = result['NextToken']
+            break if next_token.nil?
+          end
+          load(data)
+        end
+
+        def get(identity)
+          data = connection.describe_scaling_activities('ActivityId' => identity).body['DescribeScalingActivitiesResult']['Activities'].first
+          new(data) unless data.nil?
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class AutoScaling
+      class Activity < Fog::Model
+
+        identity  :id,                      :aliases => 'ActivityId'
+        attribute :auto_scaling_group_name, :aliases => 'AutoScalingGroupName'
+        attribute :cause,                   :aliases => 'Cause'
+        attribute :description,             :aliases => 'Description'
+	attribute :end_time,                :aliases => 'EndTime'
+        attribute :progress,                :aliases => 'Progress'
+        attribute :start_time,              :aliases => 'StartTime'
+        attribute :status_code,             :aliases => 'StatusCode'
+        attribute :status_message,          :aliases => 'StatusMessage'
+
+        def group
+          connection.groups.get(attributes['AutoScalingGroupName'])
+        end
+
+        def save
+          raise "Operation not supported"
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class AutoScaling
+      class Configuration < Fog::Model
+
+        identity  :id,                    :aliases => 'LaunchConfigurationName'
+        attribute :arn,                   :aliases => 'LaunchConfigurationARN'
+        attribute :block_device_mappings, :aliases => 'BlockDeviceMappings'
+        attribute :created_at,            :aliases => 'CreatedTime'
+        attribute :image_id,              :aliases => 'ImageId'
+        #attribute :instance_monitoring,   :aliases => 'InstanceMonitoring'
+        attribute :instance_monitoring,   :aliases => 'InstanceMonitoring', :squash => 'Enabled'
+        attribute :instance_type,         :aliases => 'InstanceType'
+        attribute :kernel_id,             :aliases => 'KernelId'
+        attribute :key_name,              :aliases => 'KeyName'
+        attribute :ramdisk_id,            :aliases => 'RamdiskId'
+        attribute :security_groups,       :aliases => 'SecurityGroups'
+        attribute :user_data,             :aliases => 'UserData'
+
+        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 ready?
+          # AutoScaling requests are synchronous
+          true
+        end
+
+        def save
+          requires :id
+          requires :image_id
+          requires :instance_type
+
+          connection.create_launch_configuration(image_id, instance_type, 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
+          self
+        end
+
+        def destroy
+          requires :id
+          connection.delete_launch_configuration(id)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'fog/aws/models/auto_scaling/configuration'
+
+module Fog
+  module AWS
+    class AutoScaling
+      class Configurations < Fog::Collection
+
+        model Fog::AWS::AutoScaling::Configuration
+
+        # Creates a new launch configuration
+        def initialize(attributes={})
+          super
+        end
+
+        def all
+          data = []
+          next_token = nil
+          loop do
+            result = connection.describe_launch_configurations('NextToken' => next_token).body['DescribeLaunchConfigurationsResult']
+            data += result['LaunchConfigurations']
+            next_token = result['NextToken']
+            break if next_token.nil?
+          end
+          load(data)
+        end
+
+        def get(identity)
+          data = connection.describe_launch_configurations('LaunchConfigurationNames' => identity).body['DescribeLaunchConfigurationsResult']['LaunchConfigurations'].first
+	  new(data) unless data.nil?
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class AutoScaling
+      class Group < Fog::Model
+
+        identity  :id,                        :aliases => 'AutoScalingGroupName'
+        attribute :arn,                       :aliases => 'AutoScalingGroupARN'
+        attribute :availability_zones,        :aliases => 'AvailabilityZones'
+        attribute :created_at,                :aliases => 'CreatedTime'
+        attribute :default_cooldown,          :aliases => 'DefaultCooldown'
+        attribute :desired_capacity,          :aliases => 'DesiredCapacity'
+        attribute :enabled_metrics,           :aliases => 'EnabledMetrics'
+        attribute :health_check_grace_period, :aliases => 'HealthCheckGracePeriod'
+        attribute :health_check_type,         :aliases => 'HealthCheckType'
+        attribute :instances,                 :aliases => 'Instances'
+        attribute :launch_configuration_name, :aliases => 'LaunchConfigurationName'
+        attribute :load_balancer_names,       :aliases => 'LoadBalancerNames'
+        attribute :max_size,                  :aliases => 'MaxSize'
+        attribute :min_size,                  :aliases => 'MinSize'
+        attribute :placement_group,           :aliases => 'PlacementGroup'
+        attribute :suspended_processes,       :aliases => 'SuspendedProcesses'
+        attribute :vpc_zone_identifier,       :aliases => 'VPCZoneIdentifier'
+
+        def initialize(attributes={})
+          attributes['DefaultCooldown'] ||= 0
+          attributes['DesiredCapacity'] ||= 0
+          attributes['EnabledMetrics'] ||= []
+          attributes['HealthCheckGracePeriod'] ||= 0
+          attributes['HealthCheckType'] ||= 'EC2'
+          attributes['Instances'] ||= []
+          attributes['LoadBalancerNames'] ||= []
+          attributes['MaxSize'] ||= 0
+          attributes['MinSize'] ||= 0
+          attributes['SuspendedProcesses'] ||= []
+          super
+        end
+
+        def activities
+          requires :id
+          data = []
+          next_token = nil
+          loop do
+            result = connection.describe_scaling_activities('AutoScalingGroupName' => id, 'NextToken' => next_token).body['DescribeScalingActivitiesResult']
+            data += result['Activities']
+            next_token = result['NextToken']
+            break if next_token.nil?
+          end
+          Fog::AWS::AutoScaling::Activities.new({
+            :data => data,
+            :connection => connection,
+            #:load_balancer => self
+          })
+        end
+
+        def configuration
+          requires :launch_configuration_name
+          connection.configurations.get(launch_configuration_name)
+        end
+
+        def disable_metrics_collection(metrics = {})
+          requires :id
+          connection.disable_metrics_collection(id, 'Metrics' => metrics)
+          reload
+        end
+
+        def enable_metrics_collection(metrics = {})
+          requires :id
+          connection.enable_metrics_collection(id, 'Metrics' => metrics)
+          reload
+        end
+
+        def instances
+          Fog::AWS::AutoScaling::Instances.new({
+            :data => attributes['Instances'],
+            :connection => connection
+          })
+        end
+
+        def instances_in_service
+          attributes[:instances].select {|hash| hash['LifecycleState'] == 'InService'}.map {|hash| hash['InstanceId']}
+        end
+
+        def instances_out_service
+          attributes[:instances].select {|hash| hash['LifecycleState'] == 'OutOfService'}.map {|hash| hash['InstanceId']}
+        end
+
+        def resume_processes(processes = [])
+          requires :id
+          connection.resume_processes(id, 'ScalingProcesses' => processes)
+          reload
+        end
+
+        def suspend_processes(processes = [])
+          requires :id
+          connection.suspend_processes(id, 'ScalingProcesses' => processes)
+          reload
+        end
+
+        def ready?
+          # Is this useful?
+          #instances_in_service.length == desired_capacity
+          #instances_in_service.length >= min_size
+          true
+        end
+
+        def save
+          requires :id
+          requires :availability_zones
+          requires :launch_configuration_name
+          requires :max_size
+          requires :min_size
+
+          connection.create_auto_scaling_group(id, availability_zones, launch_configuration_name, max_size, min_size)
+          reload
+        end
+
+        #def reload
+        #  super
+        #  self
+        #end
+
+        def destroy
+          requires :id
+          connection.delete_auto_scaling_group(id)
+        end
+
+      private
+
+        def update(options)
+          requires :id
+          connection.update_auto_scaling_group(id, options)
+          reload
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'fog/aws/models/auto_scaling/group'
+
+module Fog
+  module AWS
+    class AutoScaling
+      class Groups < Fog::Collection
+
+        model Fog::AWS::AutoScaling::Group
+
+        # Creates a new auto scaling group.
+        def initialize(attributes={})
+          super
+        end
+
+        def all
+          data = []
+          next_token = nil
+          loop do
+            result = connection.describe_auto_scaling_groups('NextToken' => next_token).body['DescribeAutoScalingGroupsResult']
+            data += result['AutoScalingGroups']
+            next_token = result['NextToken']
+            break if next_token.nil?
+          end
+          load(data)
+        end
+
+        def get(identity)
+          data = connection.describe_auto_scaling_groups('AutoScalingGroupNames' => identity).body['DescribeAutoScalingGroupsResult']['AutoScalingGroups'].first
+          new(data) unless data.nil?
+        end
+
+      end
+    end
+  end
+end