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 = {})
if data[:auto_scaling_groups].has_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 data[:launch_configurations].has_key?(launch_configuration_name)
raise Fog::AWS::AutoScaling::ValidationError.new('Launch configuration name not found - null')
end
data[:auto_scaling_groups][auto_scaling_group_name] = {
'AutoScalingGroupARN' => "arn:aws:autoscaling:eu-west-1:000000000000:autoScalingGroup:00000000-0000-0000-0000-000000000000:autoScalingGroupName/#{auto_scaling_group_name}",
'AutoScalingGroupName' => launch_configuration_name,
'AvailabilityZones' => availability_zones.to_a,
'CreatedTime' => Time.now.utc,
'DefaultCooldown' => 0,
'DesiredCapacity' => 0,
'EnabledMetrics' => [],
'HealthCheckGracePeriod' => 0,
'HealthCheckType' => 'EC2',
'Instances' => [],
'LaunchConfigurationName' => launch_configuration_name,
'LoadBalancerNames' => [],
'MaxSize' => max_size,
'MinSize' => min_size,
'PlacementGroup' => nil,
'SuspendedProcesses' => [],
'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 data[:launch_configurations].has_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
data[:launch_configurations][launch_configuration_name] = {
'BlockDeviceMappings' => [],
'CreatedTime' => Time.now.utc,
'IamInstanceProfile' => nil,
'ImageId' => image_id,
'InstanceMonitoring.Enabled' => true,
'InstanceType' => instance_type,
'KernelId' => nil,
'KeyName' => nil,
'LaunchConfigurationARN' => "arn:aws:autoscaling:eu-west-1:000000000000:launchConfiguration:00000000-0000-0000-0000-000000000000:launchConfigurationName/#{launch_configuration_name}",
'LaunchConfigurationName' => launch_configuration_name,
'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.class.data[@region][@aws_access_key_id]
end
delete_auto_scaling_group(auto_scaling_group_name)
click to toggle source
def delete_auto_scaling_group(auto_scaling_group_name)
Fog::Mock.not_implemented
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::ValidationError, "Launch configuration name not found - Launch configuration #{launch_configuration_name} not found"
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)
Fog::Mock.not_implemented
end
delete_policy(auto_scaling_group_name, policy_name)
click to toggle source
def delete_policy(auto_scaling_group_name, policy_name)
Fog::Mock.not_implemented
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' => [] }
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' => [] }
data[:auto_scaling_groups].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' => [] }
data[:auto_scaling_groups].each do |asg_name, asg_data|
lc_name = data[asg_data][lc_name]
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_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' => []
}
data[:metric_collection_types][:granularities].each do |granularity|
results['Granularities'] << { 'Granularity' => granularity }
end
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_policies(options = {})
click to toggle source
def describe_policies(options = {})
Fog::Mock.not_implemented
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' => [] }
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
disable_metrics_collection(auto_scaling_group_name, options = {})
click to toggle source
def disable_metrics_collection(auto_scaling_group_name, options = {})
unless data[:auto_scaling_groups].has_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 data[:auto_scaling_groups].has_key?(auto_scaling_group_name)
Fog::AWS::AutoScaling::ValidationError.new("Group #{auto_scaling_group_name} not found")
end
unless 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)
Fog::Mock.not_implemented
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 = {})
Fog::Mock.not_implemented
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
reset_data()
click to toggle source
def reset_data
self.class.data[@region].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 = {})
Fog::Mock.not_implemented
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 data[:auto_scaling_groups].has_key?(auto_scaling_group_name)
Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
end
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 data[:health_states].include?(health_status)
raise Fog::AWS::AutoScaling::ValidationError.new('Valid instance health states are: [#{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 data[:auto_scaling_groups].has_key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
end
Fog::Mock.not_implemented
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 = {})
unless data[:auto_scaling_groups].has_key?(auto_scaling_group_name)
raise Fog::AWS::AutoScaling::ValidationError.new('AutoScalingGroup name not found - null')
end
data[:auto_scaling_group_name][auto_scaling_group_name].merge!(options)
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
}
response
end