fog 1.26.0 → 1.27.0

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

@@ -1,37 +0,0 @@
-require 'fog/aws/models/auto_scaling/activity'
-
-module Fog
-  module AWS
-    class AutoScaling
-      class Activities < Fog::Collection
-        model Fog::AWS::AutoScaling::Activity
-
-        attribute :filters
-
-        # Creates a new scaling policy.
-        def initialize(attributes={})
-          self.filters = attributes
-          super(attributes)
-        end
-
-        def all(filters = filters)
-          data = []
-          next_token = nil
-          self.filters = filters
-          loop do
-            result = service.describe_scaling_activities(filters.merge('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 = service.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

@@ -1,27 +0,0 @@
-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
-          service.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

@@ -1,69 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module AWS
-    class AutoScaling
-      class Configuration < Fog::Model
-        identity  :id,                    :aliases => 'LaunchConfigurationName'
-        attribute :arn,                   :aliases => 'LaunchConfigurationARN'
-        attribute :associate_public_ip,   :aliases => 'AssociatePublicIpAddress'
-        attribute :block_device_mappings, :aliases => 'BlockDeviceMappings'
-        attribute :created_at,            :aliases => 'CreatedTime'
-        attribute :ebs_optimized,         :aliases => 'EbsOptimized'
-        attribute :iam_instance_profile,  :aliases => 'IamInstanceProfile'
-        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'
-        attribute :spot_price,            :aliases => 'SpotPrice'
-        attribute :placement_tenancy,     :aliases => 'PlacementTenancy'
-
-
-        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
-
-          options = Hash[self.class.aliases.map { |key, value| [key, send(value)] }]
-          options.delete_if { |key, value| value.nil? }
-          service.create_launch_configuration(image_id, instance_type, id, options) #, 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
-          service.delete_launch_configuration(id)
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-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 = service.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 = service.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

@@ -1,150 +0,0 @@
-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 :tags,                      :aliases => 'Tags'
-        attribute :termination_policies,      :aliases => 'TerminationPolicies'
-        attribute :vpc_zone_identifier,       :aliases => 'VPCZoneIdentifier'
-
-        def initialize(attributes={})
-          self.instances = []
-          self.default_cooldown = 300
-          self.desired_capacity = 0
-          self.enabled_metrics = []
-          self.health_check_grace_period = 0
-          self.health_check_type = 'EC2'
-          self.load_balancer_names = []
-          self.max_size = 0
-          self.min_size = 0
-          self.suspended_processes = []
-          self.tags = {}
-          self.termination_policies = ['Default']
-          super
-        end
-
-        def activities
-          requires :id
-          data = []
-          next_token = nil
-          loop do
-            result = service.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,
-            :service => service,
-            #:load_balancer => self
-          })
-        end
-
-        def configuration
-          requires :launch_configuration_name
-          service.configurations.get(launch_configuration_name)
-        end
-
-        def disable_metrics_collection(metrics = {})
-          requires :id
-          service.disable_metrics_collection(id, 'Metrics' => metrics)
-          reload
-        end
-
-        def enable_metrics_collection(granularity = '1Minute', metrics = {})
-          requires :id
-          service.enable_metrics_collection(id, granularity, 'Metrics' => metrics)
-          reload
-        end
-
-        def instances
-          Fog::AWS::AutoScaling::Instances.new(:service => service).load(attributes[:instances])
-        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
-          service.resume_processes(id, 'ScalingProcesses' => processes)
-          reload
-        end
-
-        def suspend_processes(processes = [])
-          requires :id
-          service.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
-          service.create_auto_scaling_group(id, availability_zones, launch_configuration_name, max_size, min_size, filtered_options(:create_auto_scaling_group))
-          reload
-        end
-
-        #def reload
-        #  super
-        #  self
-        #end
-
-        def destroy(options = { :force => false })
-          requires :id
-
-          opts = {}
-          opts.merge!({'ForceDelete' => true}) if options[:force]
-
-          service.delete_auto_scaling_group(id, opts)
-        end
-
-        def update
-          requires :id
-          service.update_auto_scaling_group(id, filtered_options(:update_auto_scaling_group) )
-          reload
-        end
-
-        def filtered_options(method)
-          Hash[options.select{|k,_| ExpectedOptions[method].include?(k)}]
-        end
-
-        def options
-          ret = Hash[self.class.aliases.map { |key, value| [key, send(value)] }]
-          ret.delete_if { |key, value| value.nil? }
-          ret
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-require 'fog/aws/models/auto_scaling/group'
-
-module Fog
-  module AWS
-    class AutoScaling
-      class Groups < Fog::Collection
-        model Fog::AWS::AutoScaling::Group
-
-        attribute :filters
-
-        # Creates a new auto scaling group.
-        def initialize(attributes={})
-          self.filters = attributes
-          super
-        end
-
-        def all(filters = filters)
-          data = []
-          next_token = nil
-          self.filters = filters
-          loop do
-            result = service.describe_auto_scaling_groups(filters.merge('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 = service.describe_auto_scaling_groups('AutoScalingGroupNames' => identity).body['DescribeAutoScalingGroupsResult']['AutoScalingGroups'].first
-          new(data) unless data.nil?
-        end
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module AWS
-    class AutoScaling
-      class Instance < Fog::Model
-        identity  :id,                        :aliases => 'InstanceId'
-        attribute :auto_scaling_group_name,   :aliases => 'AutoScalingGroupName'
-        attribute :availability_zone,         :aliases => 'AvailabilityZone'
-        attribute :health_status,             :aliases => 'HealthStatus'
-        attribute :launch_configuration_name, :aliases => 'LaunchConfigurationName'
-        attribute :life_cycle_state,          :aliases => 'LifecycleState'
-
-        def initialize(attributes={})
-          super
-        end
-
-        def group
-          service.groups.get(attributes['AutoScalingGroupName'])
-        end
-
-        def configuration
-          service.configurations.get(attributes['LaunchConfigurationName'])
-        end
-
-        def set_health(health_status, options)
-          requires :id
-          service.set_instance_health(health_status, id, options)
-          reload
-        end
-
-        def terminate(should_decrement_desired_capacity)
-          requires :id
-          service.terminate_instance_in_auto_scaling_group(id, should_decrement_desired_capacity)
-          reload
-        end
-
-        def healthy?
-          health_status == 'Healthy'
-        end
-
-        def ready?
-          life_cycle_state == 'InService'
-        end
-
-        def reload
-          super
-          self
-        end
-
-        #def destroy
-        #  requires :id
-        #  service.delete_auto_scaling_group(id)
-        #end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'fog/aws/models/auto_scaling/instance'
-
-module Fog
-  module AWS
-    class AutoScaling
-      class Instances < Fog::Collection
-        model Fog::AWS::AutoScaling::Instance
-
-        def all
-          data = []
-          next_token = nil
-          loop do
-            result = service.describe_auto_scaling_instances('NextToken' => next_token).body['DescribeAutoScalingInstancesResult']
-            data += result['AutoScalingInstances']
-            next_token = result['NextToken']
-            break if next_token.nil?
-          end
-          load(data)
-        end
-
-        def get(identity)
-          data = service.describe_auto_scaling_instances('InstanceIds' => identity).body['DescribeAutoScalingInstancesResult']['AutoScalingInstances'].first
-          new(data) unless data.nil?
-        end
-      end
-    end
-  end
-end