apply_security_groups(security_group_ids, lb_name)
click to toggle source
apply_security_groups_to_load_balancer(security_group_ids, lb_name)
click to toggle source
def apply_security_groups_to_load_balancer(security_group_ids, lb_name)
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
response = Excon::Response.new
response.status = 200
load_balancer['SecurityGroups'] << security_group_ids
load_balancer['SecurityGroups'].flatten!.uniq!
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'DetachLoadBalancerFromSubnetsResult' => {
'SecurityGroups' => load_balancer['SecurityGroups']
}
}
response
end
attach_load_balancer_to_subnets(subnet_ids, lb_name)
click to toggle source
def attach_load_balancer_to_subnets(subnet_ids, lb_name)
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
response = Excon::Response.new
response.status = 200
load_balancer['Subnets'] << subnet_ids
load_balancer['Subnets'].flatten!.uniq!
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'AttachLoadBalancerToSubnetsResult' => {
'Subnets' => load_balancer['Subnets']
}
}
response
end
create_app_cookie_stickiness_policy(lb_name, policy_name, cookie_name)
click to toggle source
def create_app_cookie_stickiness_policy(lb_name, policy_name, cookie_name)
if load_balancer = self.data[:load_balancers][lb_name]
response = Excon::Response.new
response.status = 200
load_balancer['Policies']['AppCookieStickinessPolicies'] << { 'CookieName' => cookie_name, 'PolicyName' => policy_name }
create_load_balancer_policy(lb_name, policy_name, 'AppCookieStickinessPolicyType', {'CookieName' => cookie_name})
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
}
}
response
else
raise Fog::AWS::ELB::NotFound
end
end
create_lb_cookie_stickiness_policy(lb_name, policy_name, cookie_expiration_period=nil)
click to toggle source
def create_lb_cookie_stickiness_policy(lb_name, policy_name, cookie_expiration_period=nil)
if load_balancer = self.data[:load_balancers][lb_name]
response = Excon::Response.new
response.status = 200
load_balancer['Policies']['LBCookieStickinessPolicies'] << { 'CookieExpirationPeriod' => cookie_expiration_period, 'PolicyName' => policy_name }
create_load_balancer_policy(lb_name, policy_name, 'LBCookieStickinessPolicyType', {'CookieExpirationPeriod' => cookie_expiration_period})
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
}
}
response
else
raise Fog::AWS::ELB::NotFound
end
end
create_load_balancer(availability_zones, lb_name, listeners = [], options = {})
click to toggle source
def create_load_balancer(availability_zones, lb_name, listeners = [], options = {})
response = Excon::Response.new
response.status = 200
raise Fog::AWS::ELB::IdentifierTaken if self.data[:load_balancers].has_key? lb_name
certificate_ids = Fog::AWS::IAM::Mock.data[@aws_access_key_id][:server_certificates].map {|n, c| c['Arn'] }
listeners = [*listeners].map do |listener|
if listener['SSLCertificateId'] and !certificate_ids.include? listener['SSLCertificateId']
raise Fog::AWS::IAM::NotFound.new('CertificateNotFound')
end
{'Listener' => listener, 'PolicyNames' => []}
end
dns_name = Fog::AWS::ELB::Mock.dns_name(lb_name, @region)
self.data[:load_balancers][lb_name] = {
'AvailabilityZones' => availability_zones,
'Subnets' => options[:subnet_ids],
'Scheme' => options[:scheme],
'SecurityGroups' => options[:security_groups],
'CanonicalHostedZoneName' => '',
'CanonicalHostedZoneNameID' => '',
'CreatedTime' => Time.now,
'DNSName' => dns_name,
'HealthCheck' => {
'HealthyThreshold' => 10,
'Timeout' => 5,
'UnhealthyThreshold' => 2,
'Interval' => 30,
'Target' => 'TCP:80'
},
'Instances' => [],
'ListenerDescriptions' => listeners,
'LoadBalancerName' => lb_name,
'Policies' => {
'AppCookieStickinessPolicies' => [],
'LBCookieStickinessPolicies' => [],
'Proper' => []
},
'SourceSecurityGroup' => {
'GroupName' => '',
'OwnerAlias' => ''
}
}
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'CreateLoadBalancerResult' => {
'DNSName' => dns_name
}
}
response
end
create_load_balancer_listeners(lb_name, listeners)
click to toggle source
def create_load_balancer_listeners(lb_name, listeners)
if load_balancer = self.data[:load_balancers][lb_name]
response = Excon::Response.new
certificate_ids = Fog::AWS::IAM::Mock.data[@aws_access_key_id][:server_certificates].map {|n, c| c['Arn'] }
listeners.each do |listener|
if listener['SSLCertificateId'] and !certificate_ids.include? listener['SSLCertificateId']
raise Fog::AWS::IAM::NotFound.new('CertificateNotFound')
end
if (%w( HTTP HTTPS).include?(listener['Protocol']) && !%w( HTTP HTTPS ).include?(listener['InstanceProtocol'])) ||
(%w( TCP SSL).include?(listener['Protocol']) && !%w( TCP SSL ).include?(listener['InstanceProtocol']))
raise Fog::AWS::ELB::ValidationError
end if listener['Protocol'] && listener['InstanceProtocol']
load_balancer['ListenerDescriptions'] << {'Listener' => listener, 'PolicyNames' => []}
end
response.status = 200
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
}
}
response
else
raise Fog::AWS::ELB::NotFound
end
end
create_load_balancer_policy(lb_name, name, type_name, attributes = {})
click to toggle source
def create_load_balancer_policy(lb_name, name, type_name, attributes = {})
if load_balancer = self.data[:load_balancers][lb_name]
raise Fog::AWS::IAM::DuplicatePolicyName if policy = load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == name }
raise Fog::AWS::IAM::PolicyTypeNotFound unless policy_type = self.data[:policy_types].find { |pt| pt['PolicyTypeName'] == type_name }
response = Excon::Response.new
attributes = attributes.map do |key, value|
{"AttributeName" => key, "AttributeValue" => value.to_s}
end
load_balancer['Policies']['Proper'] << {
'PolicyAttributeDescriptions' => attributes,
'PolicyName' => name,
'PolicyTypeName' => type_name
}
response.status = 200
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
}
}
response
else
raise Fog::AWS::ELB::NotFound
end
end
data()
click to toggle source
def data
self.class.data[@region][@aws_access_key_id]
end
delete_load_balancer(lb_name)
click to toggle source
def delete_load_balancer(lb_name)
response = Excon::Response.new
response.status = 200
self.data[:load_balancers].delete(lb_name)
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'DeleteLoadBalancerResult' => nil
}
response
end
delete_load_balancer_listeners(lb_name, load_balancer_ports)
click to toggle source
def delete_load_balancer_listeners(lb_name, load_balancer_ports)
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
response = Excon::Response.new
response.status = 200
load_balancer['ListenerDescriptions'].delete_if { |listener| load_balancer_ports.include? listener['Listener']['LoadBalancerPort'] }
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
}
}
response
end
delete_load_balancer_policy(lb_name, policy_name)
click to toggle source
def delete_load_balancer_policy(lb_name, policy_name)
if load_balancer = self.data[:load_balancers][lb_name]
response = Excon::Response.new
response.status = 200
load_balancer['Policies'].each do |name, policies|
policies.delete_if { |policy| policy['PolicyName'] == policy_name }
end
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
}
}
response
else
raise Fog::AWS::ELB::NotFound
end
end
deregister_instances(instance_ids, lb_name)
click to toggle source
deregister_instances_from_load_balancer(instance_ids, lb_name)
click to toggle source
def deregister_instances_from_load_balancer(instance_ids, lb_name)
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
instance_ids = [*instance_ids]
instance_ids.each do |instance|
raise Fog::AWS::ELB::InvalidInstance unless Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:instances][instance]
end
response = Excon::Response.new
response.status = 200
load_balancer['Instances'].delete_if { |i| instance_ids.include? i['InstanceId'] }
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'DeregisterInstancesFromLoadBalancerResult' => {
'Instances' => load_balancer['Instances'].dup
}
}
response
end
describe_instance_health(lb_name, instance_ids = [])
click to toggle source
def describe_instance_health(lb_name, instance_ids = [])
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
instance_ids = [*instance_ids]
instance_ids = load_balancer['Instances'].collect { |i| i['InstanceId'] } unless instance_ids.any?
data = instance_ids.map do |id|
unless Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:instances][id]
raise Fog::AWS::ELB::InvalidInstance
end
{
'Description' => "",
'InstanceId' => id,
'ReasonCode' => "",
'State' => 'OutOfService'
}
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'DescribeInstanceHealthResult' => {
'InstanceStates' => data
}
}
response
end
describe_load_balancer_policies(lb_name = nil, names = [])
click to toggle source
def describe_load_balancer_policies(lb_name = nil, names = [])
if lb_name
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
names = [*names]
policies = if names.any?
names.map do |name|
raise Fog::AWS::ELB::PolicyNotFound unless policy = load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == name }
policy.dup
end.compact
else
load_balancer['Policies']['Proper']
end
else
policies = []
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'DescribeLoadBalancerPoliciesResult' => {
'PolicyDescriptions' => policies
}
}
response
end
describe_load_balancer_policy_types(type_names = [])
click to toggle source
def describe_load_balancer_policy_types(type_names = [])
type_names = [*type_names]
policy_types = if type_names.any?
type_names.map do |type_name|
policy_type = self.data[:policy_types].find { |pt| pt['PolicyTypeName'] == type_name }
raise Fog::AWS::ELB::PolicyTypeNotFound unless policy_type
policy_type[1].dup
end.compact
else
self.data[:policy_types].map { |policy_type| policy_type.dup }
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'DescribeLoadBalancerPolicyTypesResult' => {
'PolicyTypeDescriptions' => policy_types
}
}
response
end
describe_load_balancers(options = {})
click to toggle source
def describe_load_balancers(options = {})
unless options.is_a?(Hash)
Fog::Logger.deprecation("describe_load_balancers with #{options.class} is deprecated, use all('LoadBalancerNames' => []) instead [light_black](#{caller.first})[/]")
options = { 'LoadBalancerNames' => [options].flatten }
end
lb_names = options['LoadBalancerNames'] || []
lb_names = [*lb_names]
load_balancers = if lb_names.any?
lb_names.map do |lb_name|
lb = self.data[:load_balancers].find { |name, data| name == lb_name }
raise Fog::AWS::ELB::NotFound unless lb
lb[1].dup
end.compact
else
self.data[:load_balancers].map { |lb, values| values.dup }
end
marker = options.fetch('Marker', 0).to_i
if load_balancers.count - marker > 400
next_marker = marker + 400
load_balancers = load_balancers[marker...next_marker]
else
next_marker = nil
end
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'DescribeLoadBalancersResult' => {
'LoadBalancerDescriptions' => load_balancers.map do |lb|
lb['Instances'] = lb['Instances'].map { |i| i['InstanceId'] }
lb['Policies'] = lb['Policies'].reject { |name, policies| name == 'Proper' }
lb
end
}
}
if next_marker
response.body['DescribeLoadBalancersResult']['NextMarker'] = next_marker
end
response
end
detach_load_balancer_from_subnets(subnet_ids, lb_name)
click to toggle source
def detach_load_balancer_from_subnets(subnet_ids, lb_name)
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
response = Excon::Response.new
response.status = 200
load_balancer['Subnets'] << subnet_ids
load_balancer['Subnets'].flatten!.uniq!
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'DetachLoadBalancerFromSubnetsResult' => {
'Subnets' => load_balancer['Subnets']
}
}
response
end
disable_availability_zones_for_load_balancer(availability_zones, lb_name)
click to toggle source
def disable_availability_zones_for_load_balancer(availability_zones, lb_name)
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
response = Excon::Response.new
response.status = 200
load_balancer['AvailabilityZones'].delete_if { |az| availability_zones.include? az }
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'DisableAvailabilityZonesForLoadBalancerResult' => {
'AvailabilityZones' => load_balancer['AvailabilityZones']
}
}
response
end
disable_subnets(subnet_ids, lb_name)
click to toggle source
disable_zones(availability_zones, lb_name)
click to toggle source
enable_availability_zones_for_load_balancer(availability_zones, lb_name)
click to toggle source
def enable_availability_zones_for_load_balancer(availability_zones, lb_name)
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
response = Excon::Response.new
response.status = 200
load_balancer['AvailabilityZones'] << availability_zones
load_balancer['AvailabilityZones'].flatten!.uniq!
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'EnableAvailabilityZonesForLoadBalancerResult' => {
'AvailabilityZones' => load_balancer['AvailabilityZones']
}
}
response
end
enable_subnets(subnet_ids, lb_name)
click to toggle source
enable_zones(availability_zones, lb_name)
click to toggle source
register_instances(instance_ids, lb_name)
click to toggle source
register_instances_with_load_balancer(instance_ids, lb_name)
click to toggle source
def register_instances_with_load_balancer(instance_ids, lb_name)
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
instance_ids = [*instance_ids]
instances = instance_ids.map do |instance|
raise Fog::AWS::ELB::InvalidInstance unless Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:instances][instance]
{'InstanceId' => instance}
end
response = Excon::Response.new
response.status = 200
load_balancer['Instances'] = load_balancer['Instances'] | instances.dup
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'RegisterInstancesWithLoadBalancerResult' => {
'Instances' => instances
}
}
response
end
reset_data()
click to toggle source
def reset_data
self.class.data[@region].delete(@aws_access_key_id)
end
set_load_balancer_listener_ssl_certificate(lb_name, load_balancer_port, ssl_certificate_id)
click to toggle source
def set_load_balancer_listener_ssl_certificate(lb_name, load_balancer_port, ssl_certificate_id)
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
certificate_ids = Fog::AWS::IAM::Mock.data[@aws_access_key_id][:server_certificates].map {|n, c| c['Arn'] }
if !certificate_ids.include? ssl_certificate_id
raise Fog::AWS::IAM::NotFound.new('CertificateNotFound')
end
response = Excon::Response.new
unless listener = load_balancer['ListenerDescriptions'].find { |listener| listener['Listener']['LoadBalancerPort'] == load_balancer_port }
response.status = 400
response.body = "<?xml version=\"1.0\"?><Response><Errors><Error><Code>ListenerNotFound</Code><Message>LoadBalancer does not have a listnener configured at the given port.</Message></Error></Errors><RequestID>#{Fog::AWS::Mock.request_id}</RequestId></Response>"
raise Excon::Errors.status_error({:expects => 200}, response)
end
listener['Listener']['SSLCertificateId'] = ssl_certificate_id
response.status = 200
response.body = {
"ResponseMetadata" => {
"RequestId" => Fog::AWS::Mock.request_id
}
}
response
end
set_load_balancer_policies_of_listener(lb_name, load_balancer_port, policy_names)
click to toggle source
def set_load_balancer_policies_of_listener(lb_name, load_balancer_port, policy_names)
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
policy_names = [*policy_names]
response = Excon::Response.new
if policy_names.size > 1
response.status = 409
response.body = "<?xml version=\"1.0\"?><Response><Errors><Error><Code>InvalidConfigurationRequest</Code><Message>Requested configuration change is invalid.</Message></Error></Errors><RequestID>#{Fog::AWS::Mock.request_id}</RequestId></Response>"
raise Excon::Errors.status_error({:expects => 200}, response)
end
unless listener = load_balancer['ListenerDescriptions'].find { |listener| listener['Listener']['LoadBalancerPort'] == load_balancer_port }
response.status = 400
response.body = "<?xml version=\"1.0\"?><Response><Errors><Error><Code>ListenerNotFound</Code><Message>LoadBalancer does not have a listnener configured at the given port.</Message></Error></Errors><RequestID>#{Fog::AWS::Mock.request_id}</RequestId></Response>"
raise Excon::Errors.status_error({:expects => 200}, response)
end
unless load_balancer['Policies']['Proper'].find { |policy| policy['PolicyName'] == policy_names.first }
response.status = 400
response.body = "<?xml version=\"1.0\"?><Response><Errors><Error><Code>PolicyNotFound</Code><Message>One or more specified policies were not found.</Message></Error></Errors><RequestID>#{Fog::AWS::Mock.request_id}</RequestId></Response>"
raise Excon::Errors.status_error({:expects => 200}, response)
end if policy_names.any?
listener['PolicyNames'] = policy_names
response.status = 200
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
}
}
response
end