attach_instances(auto_scaling_group_name, options = {})
click to toggle source
def attach_instances(auto_scaling_group_name, options = {})
unexpected_options = options.keys - ExpectedOptions[:asg_name] - ExpectedOptions[:instance_ids]
unless unexpected_options.empty?
raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
end
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
attach_load_balancer_target_groups(auto_scaling_group_name, options = {})
click to toggle source
def attach_load_balancer_target_groups(auto_scaling_group_name, options = {})
unexpected_options = options.keys - ExpectedOptions[:attach_load_balancer_target_groups]
unless unexpected_options.empty?
raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
end
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
attach_load_balancers(auto_scaling_group_name, options = {})
click to toggle source
def attach_load_balancers(auto_scaling_group_name, options = {})
unexpected_options = options.keys - ExpectedOptions[:attach_load_balancers]
unless unexpected_options.empty?
raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
end
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
create_auto_scaling_group(auto_scaling_group_name, availability_zones, launch_configuration_name, max_size, min_size, options = {})
click to toggle source
def create_auto_scaling_group(auto_scaling_group_name, availability_zones, launch_configuration_name, max_size, min_size, options = {})
unexpected_options = options.keys - ExpectedOptions[:create_auto_scaling_group]
unless unexpected_options.empty?
raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
end
if self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::IdentifierTaken.new("AutoScalingGroup by this name already exists - A group with the name #{auto_scaling_group_name} already exists")
end
unless self.data[:launch_configurations].key?(launch_configuration_name)
raise Fog::AWS::AutoScaling::ValidationError.new('Launch configuration name not found - null')
end
self.data[:auto_scaling_groups][auto_scaling_group_name] = {
'AutoScalingGroupARN' => Fog::AWS::Mock.arn('autoscaling', self.data[:owner_id], "autoScalingGroup:00000000-0000-0000-0000-000000000000:autoScalingGroupName/#{auto_scaling_group_name}", @region),
'AutoScalingGroupName' => auto_scaling_group_name,
'AvailabilityZones' => [*availability_zones],
'CreatedTime' => Time.now.utc,
'DefaultCooldown' => 300,
'DesiredCapacity' => 0,
'EnabledMetrics' => [],
'HealthCheckGracePeriod' => 0,
'HealthCheckType' => 'EC2',
'Instances' => [],
'LaunchConfigurationName' => launch_configuration_name,
'LoadBalancerNames' => [],
'MaxSize' => max_size,
'MinSize' => min_size,
'PlacementGroup' => nil,
'SuspendedProcesses' => [],
'Tags' => [],
'TargetGroupARNs' => [],
'TerminationPolicies' => ['Default'],
'VPCZoneIdentifier' => nil
}.merge!(options)
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
create_launch_configuration(image_id, instance_type, launch_configuration_name, options = {})
click to toggle source
def create_launch_configuration(image_id, instance_type, launch_configuration_name, options = {})
if self.data[:launch_configurations].key?(launch_configuration_name)
raise Fog::AWS::AutoScaling::IdentifierTaken.new("Launch Configuration by this name already exists - A launch configuration already exists with the name #{launch_configuration_name}")
end
self.data[:launch_configurations][launch_configuration_name] = {
'AssociatePublicIpAddress' => nil,
'BlockDeviceMappings' => [],
'CreatedTime' => Time.now.utc,
'EbsOptimized' => false,
'IamInstanceProfile' => nil,
'ImageId' => image_id,
'InstanceMonitoring' => {'Enabled' => true},
'InstanceType' => instance_type,
'KernelId' => nil,
'KeyName' => nil,
'LaunchConfigurationARN' => Fog::AWS::Mock.arn('autoscaling', self.data[:owner_id], "launchConfiguration:00000000-0000-0000-0000-000000000000:launchConfigurationName/#{launch_configuration_name}", @region),
'LaunchConfigurationName' => launch_configuration_name,
'PlacementTenancy' => nil,
'RamdiskId' => nil,
'SecurityGroups' => [],
'UserData' => nil
}.merge!(options)
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
data()
click to toggle source
def data
self.region_data[@aws_access_key_id]
end
delete_auto_scaling_group(auto_scaling_group_name, options = {})
click to toggle source
def delete_auto_scaling_group(auto_scaling_group_name, options = {})
unless self.data[:auto_scaling_groups].delete(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError, "The auto scaling group '#{auto_scaling_group_name}' does not exist."
end
self.data[:notification_configurations].delete(auto_scaling_group_name)
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
delete_launch_configuration(launch_configuration_name)
click to toggle source
def delete_launch_configuration(launch_configuration_name)
unless self.data[:launch_configurations].delete(launch_configuration_name)
raise Fog::AWS::AutoScaling::NotFound, "The launch configuration '#{launch_configuration_name}' does not exist."
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
delete_notification_configuration(auto_scaling_group_name, topic_arn)
click to toggle source
def delete_notification_configuration(auto_scaling_group_name, topic_arn)
unless self.data[:notification_configurations].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - %s' % auto_scaling_group_name)
end
unless self.data[:notification_configurations][auto_scaling_group_name].key?(topic_arn)
raise Fog::AWS::AutoScaling::ValidationError.new("Notification Topic '#{topic_arn}' doesn't exist for '#{self.data[:owner_id]}'")
end
self.data[:notification_configurations][auto_scaling_group_name].delete(topic_arn)
if self.data[:notification_configurations][auto_scaling_group_name].empty?
self.data[:notification_configurations].delete(auto_scaling_group_name)
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
delete_policy(auto_scaling_group_name, policy_name)
click to toggle source
def delete_policy(auto_scaling_group_name, policy_name)
unless self.data[:scaling_policies].delete(policy_name)
raise Fog::AWS::AutoScaling::NotFound, "The scaling policy '#{policy_name}' does not exist."
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
delete_scheduled_action(auto_scaling_group_name, scheduled_action_name)
click to toggle source
def delete_scheduled_action(auto_scaling_group_name, scheduled_action_name)
Fog::Mock.not_implemented
end
describe_adjustment_types()
click to toggle source
def describe_adjustment_types()
results = { 'AdjustmentTypes' => [] }
self.data[:adjustment_types].each do |adjustment_type|
results['AdjustmentTypes'] << { 'AdjustmentType' => adjustment_type }
end
response = Excon::Response.new
response.status = 200
response.body = {
'DescribeAdjustmentTypesResult' => results,
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
describe_auto_scaling_groups(options = {})
click to toggle source
def describe_auto_scaling_groups(options = {})
results = { 'AutoScalingGroups' => [] }
asg_set = self.data[:auto_scaling_groups]
if !options["AutoScalingGroupNames"].nil?
asg_set = asg_set.reject do |asg_name, asg_data|
![*options["AutoScalingGroupNames"]].include?(asg_name)
end
end
asg_set.each do |asg_name, asg_data|
results['AutoScalingGroups'] << {
'AutoScalingGroupName' => asg_name
}.merge!(asg_data)
end
response = Excon::Response.new
response.status = 200
response.body = {
'DescribeAutoScalingGroupsResult' => results,
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
describe_auto_scaling_instances(options = {})
click to toggle source
def describe_auto_scaling_instances(options = {})
results = { 'AutoScalingInstances' => [] }
self.data[:auto_scaling_groups].each do |asg_name, asg_data|
asg_data['Instances'].each do |instance|
results['AutoScalingInstances'] << {
'AutoScalingGroupName' => asg_name
}.merge!(instance)
end
end
response = Excon::Response.new
response.status = 200
response.body = {
'DescribeAutoScalingInstancesResult' => results,
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
describe_auto_scaling_notification_types()
click to toggle source
def describe_auto_scaling_notification_types()
results = {
'AutoScalingNotificationTypes' => [],
}
self.data[:notification_types].each do |notification_type|
results['AutoScalingNotificationTypes'] << notification_type
end
response = Excon::Response.new
response.status = 200
response.body = {
'DescribeAutoScalingNotificationTypesResult' => results,
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
describe_launch_configurations(options = {})
click to toggle source
def describe_launch_configurations(options = {})
launch_configuration_names = options.delete('LaunchConfigurationNames')
lc = [*launch_configuration_names]
launch_configurations =
if lc.any?
lc.map do |lc_name|
l_conf = self.data[:launch_configurations].find { |name, data| name == lc_name }
l_conf[1].dup if l_conf
end.compact
else
self.data[:launch_configurations].map { |lc, values| values.dup }
end
response = Excon::Response.new
response.status = 200
response.body = {
'DescribeLaunchConfigurationsResult' => { 'LaunchConfigurations' => launch_configurations },
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
describe_metric_collection_types()
click to toggle source
def describe_metric_collection_types()
results = {
'Granularities' => [],
'Metrics' => []
}
self.data[:metric_collection_types][:granularities].each do |granularity|
results['Granularities'] << { 'Granularity' => granularity }
end
self.data[:metric_collection_types][:metrics].each do |metric|
results['Metrics'] << { 'Metric' => metric }
end
response = Excon::Response.new
response.status = 200
response.body = {
'DescribeMetricCollectionTypesResult' => results,
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
describe_notification_configurations(options = {})
click to toggle source
def describe_notification_configurations(options = {})
results = { 'NotificationConfigurations' => [] }
(options['AutoScalingGroupNames']||self.data[:notification_configurations].keys).each do |asg_name|
(self.data[:notification_configurations][asg_name]||{}).each do |topic_arn, notification_types|
notification_types.each do |notification_type|
results['NotificationConfigurations'] << {
'AutoScalingGroupName' => asg_name,
'NotificationType' => notification_type,
'TopicARN' => topic_arn,
}
end
end
end
response = Excon::Response.new
response.status = 200
response.body = {
'DescribeNotificationConfigurationsResult' => results,
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
describe_policies(options = {})
click to toggle source
def describe_policies(options = {})
results = { 'ScalingPolicies' => [] }
policy_set = self.data[:scaling_policies]
for opt_key, opt_value in options
if opt_key == "PolicyNames" && opt_value != nil && opt_value != ""
policy_set = policy_set.reject do |asp_name, asp_data|
![*options["PolicyNames"]].include?(asp_name)
end
elsif opt_key == "AutoScalingGroupName" && opt_value != nil && opt_value != ""
policy_set = policy_set.reject do |asp_name, asp_data|
options["AutoScalingGroupName"] != asp_data["AutoScalingGroupName"]
end
end
end
policy_set.each do |asp_name, asp_data|
results['ScalingPolicies'] << {
'PolicyName' => asp_name
}.merge!(asp_data)
end
response = Excon::Response.new
response.status = 200
response.body = {
'DescribePoliciesResult' => results,
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
describe_scaling_activities(options = {})
click to toggle source
def describe_scaling_activities(options = {})
Fog::Mock.not_implemented
end
describe_scaling_process_types()
click to toggle source
def describe_scaling_process_types()
results = { 'Processes' => [] }
self.data[:process_types].each do |process_type|
results['Processes'] << { 'ProcessName' => process_type }
end
response = Excon::Response.new
response.status = 200
response.body = {
'DescribeScalingProcessTypesResult' => results,
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
describe_scheduled_actions(options = {})
click to toggle source
def describe_scheduled_actions(options = {})
Fog::Mock.not_implemented
end
describe_termination_policy_types()
click to toggle source
def describe_termination_policy_types()
results = { 'TerminationPolicyTypes' => [] }
self.data[:termination_policy_types].each do |termination_policy_type|
results['TerminationPolicyTypes'] << termination_policy_type
end
response = Excon::Response.new
response.status = 200
response.body = {
'DescribeTerminationPolicyTypesResult' => results,
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
detach_instances(auto_scaling_group_name, options = {})
click to toggle source
def detach_instances(auto_scaling_group_name, options = {})
unexpected_options = options.keys - ExpectedOptions[:asg_name] - ExpectedOptions[:instance_ids]
unless unexpected_options.empty?
raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
end
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
detach_load_balancer_target_groups(auto_scaling_group_name, options = {})
click to toggle source
def detach_load_balancer_target_groups(auto_scaling_group_name, options = {})
unexpected_options = options.keys - ExpectedOptions[:detach_load_balancer_target_groups]
unless unexpected_options.empty?
raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
end
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
detach_load_balancers(auto_scaling_group_name, options = {})
click to toggle source
def detach_load_balancers(auto_scaling_group_name, options = {})
unexpected_options = options.keys - ExpectedOptions[:detach_load_balancers]
unless unexpected_options.empty?
raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
end
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
disable_metrics_collection(auto_scaling_group_name, options = {})
click to toggle source
def disable_metrics_collection(auto_scaling_group_name, options = {})
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
Fog::AWS::AutoScaling::ValidationError.new("Group #{auto_scaling_group_name} not found")
end
Fog::Mock.not_implemented
end
enable_metrics_collection(auto_scaling_group_name, granularity, options = {})
click to toggle source
def enable_metrics_collection(auto_scaling_group_name, granularity, options = {})
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
Fog::AWS::AutoScaling::ValidationError.new("Group #{auto_scaling_group_name} not found")
end
unless self.data[:metric_collection_types][:granularities].include?(granularity)
Fog::AWS::AutoScaling::ValidationError.new('Valid metrics granularity type is: [1Minute].')
end
Fog::Mock.not_implemented
end
execute_policy(policy_name, options = {})
click to toggle source
def execute_policy(policy_name, options = {})
Fog::Mock.not_implemented
end
put_notification_configuration(auto_scaling_group_name, notification_types, topic_arn)
click to toggle source
def put_notification_configuration(auto_scaling_group_name, notification_types, topic_arn)
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new("AutoScalingGroup name not found - #{auto_scaling_group_name}")
end
if notification_types.to_a.empty?
raise Fog::AWS::AutoScaling::ValidationError.new("1 validation error detected: Value null at 'notificationTypes' failed to satisfy constraint: Member must not be null")
end
invalid_types = notification_types.to_a - self.data[:notification_types]
unless invalid_types.empty?
raise Fog::AWS::AutoScaling::ValidationError.new(""#{invalid_types.first}" is not a valid Notification Type.")
end
self.data[:notification_configurations][auto_scaling_group_name] ||= {}
self.data[:notification_configurations][auto_scaling_group_name][topic_arn] = notification_types.to_a.uniq
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
put_scaling_policy(adjustment_type, auto_scaling_group_name, policy_name, scaling_adjustment, options = {})
click to toggle source
def put_scaling_policy(adjustment_type, auto_scaling_group_name, policy_name, scaling_adjustment, options = {})
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new('Auto Scaling Group name not found - null')
end
self.data[:scaling_policies][policy_name] = {
'AdjustmentType' => adjustment_type,
'Alarms' => [],
'AutoScalingGroupName' => auto_scaling_group_name,
'Cooldown' => 0,
'MinAdjustmentStep' => 0,
'PolicyARN' => Fog::AWS::Mock.arn('autoscaling', self.data[:owner_id], "scalingPolicy:00000000-0000-0000-0000-000000000000:autoScalingGroupName/#{auto_scaling_group_name}:policyName/#{policy_name}", self.region),
'PolicyName' => policy_name,
'ScalingAdjustment' => scaling_adjustment
}.merge!(options)
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
put_scheduled_update_group_action(auto_scaling_group_name, scheduled_policy_name, time, options = {})
click to toggle source
def put_scheduled_update_group_action(auto_scaling_group_name, scheduled_policy_name, time, options = {})
Fog::Mock.not_implemented
end
region_data()
click to toggle source
def region_data
self.class.data[@region]
end
reset_data()
click to toggle source
def reset_data
self.region_data.delete(@aws_access_key_id)
end
resume_processes(auto_scaling_group_name, options = {})
click to toggle source
def resume_processes(auto_scaling_group_name, options = {})
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new("AutoScalingGroup name not found - no such group: #{auto_scaling_group_name}")
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
set_desired_capacity(auto_scaling_group_name, desired_capacity, options = {})
click to toggle source
def set_desired_capacity(auto_scaling_group_name, desired_capacity, options = {})
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
end
self.data[:auto_scaling_groups][auto_scaling_group_name]['DesiredCapacity'] = desired_capacity
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
set_instance_health(health_status, instance_id, options = {})
click to toggle source
def set_instance_health(health_status, instance_id, options = {})
unless self.data[:health_states].include?(health_status)
raise Fog::AWS::AutoScaling::ValidationError.new('Valid instance health states are: [#{self.data[:health_states].join(", ")}].')
end
Fog::Mock.not_implemented
end
setup_credentials(options)
click to toggle source
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
end
suspend_processes(auto_scaling_group_name, options = {})
click to toggle source
def suspend_processes(auto_scaling_group_name, options = {})
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new("AutoScalingGroup name not found - no such group: #{auto_scaling_group_name}")
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end
terminate_instance_in_auto_scaling_group(instance_id, should_decrement_desired_capacity)
click to toggle source
def terminate_instance_in_auto_scaling_group(instance_id, should_decrement_desired_capacity)
Fog::Mock.not_implemented
end
update_auto_scaling_group(auto_scaling_group_name, options = {})
click to toggle source
def update_auto_scaling_group(auto_scaling_group_name, options = {})
unexpected_options = options.keys - ExpectedOptions[:update_auto_scaling_group]
unless unexpected_options.empty?
raise Fog::AWS::AutoScaling::ValidationError.new("Options #{unexpected_options.join(',')} should not be included in request")
end
unless self.data[:auto_scaling_groups].key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
end
self.data[:auto_scaling_groups][auto_scaling_group_name].merge!(options)
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end