apply_security_groups(security_group_ids, lb_name)
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
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
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].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)
availability_zones = [*availability_zones].compact
region = availability_zones.empty? ? "us-east-1" : availability_zones.first.gsub(/[a-z]$/, '')
supported_platforms = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:account_attributes].find { |h| h["attributeName"] == "supported-platforms" }["values"]
subnet_ids = options[:subnet_ids] || []
subnets = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:subnets].select {|e| subnet_ids.include?(e["subnetId"]) }
elb_location = if supported_platforms.include?("EC2")
if subnet_ids.empty?
'EC2-Classic'
else
'EC2-VPC'
end
else
if subnet_ids.empty?
'EC2-VPC-Default'
else
'VPC'
end
end
security_group = case elb_location
when 'EC2-Classic'
Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['amazon-elb-sg']
when 'EC2-VPC-Default'
compute = Fog::Compute::AWS::new(:aws_access_key_id => @aws_access_key_id, :aws_secret_access_key => @aws_secret_access_key)
unless vpc = compute.vpcs.all.first
vpc = compute.vpcs.create('cidr_block' => '10.0.0.0/24')
end
default_sg = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
sg['groupName'] =~ /^default_elb/ &&
sg["vpcId"] == vpc.id
}
unless default_sg
default_sg = {
'groupDescription' => 'default_elb security group',
'groupName' => "default_elb_#{Fog::Mock.random_hex(6)}",
'groupId' => Fog::AWS::Mock.security_group_id,
'ipPermissionsEgress' => [],
'ipPermissions' => [],
'ownerId' => self.data[:owner_id],
'vpcId' => vpc.id
}
Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['default'] = default_sg
end
default_sg
when 'EC2-VPC'
vpc_id = subnets.first["vpcId"]
default_sg = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
sg['groupName'] == 'default' &&
sg["vpcId"] == vpc_id
}
unless default_sg
default_sg = {
'groupDescription' => 'default elb security group',
'groupName' => 'default',
'groupId' => Fog::AWS::Mock.security_group_id,
'ipPermissionsEgress' => [],
'ipPermissions' => [],
'ownerId' => self.data[:owner_id],
'vpcId' => vpc_id
}
Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['default'] = default_sg
end
default_sg
end
self.data[:load_balancers][lb_name] = {
'AvailabilityZones' => availability_zones,
'BackendServerDescriptions' => [],
'BackendServerDescriptionsRemote' => [],
'Subnets' => options[:subnet_ids] || [],
'Scheme' => options[:scheme].nil? ? 'internet-facing' : options[:scheme],
'SecurityGroups' => options[:security_groups].nil? ? [] : 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,
'LoadBalancerAttributes' => {
'ConnectionDraining' => {'Enabled' => false, 'Timeout' => 300},
'CrossZoneLoadBalancing' => {'Enabled' => false}
},
'LoadBalancerName' => lb_name,
'Policies' => {
'AppCookieStickinessPolicies' => [],
'LBCookieStickinessPolicies' => [],
'OtherPolicies' => [],
'Proper' => []
},
'SourceSecurityGroup' => {
'GroupName' => security_group['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::ELB::DuplicatePolicyName, name if policy = load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == name }
raise Fog::AWS::ELB::PolicyTypeNotFound, type_name unless policy_type = self.data[:policy_types].find { |pt| pt['PolicyTypeName'] == type_name }
response = Excon::Response.new
attributes = attributes.map do |key, value|
if key == "CookieExpirationPeriod" && !value
value = 0
end
{"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)
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'].map { |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_attributes(lb_name = nil, names = [])
click to toggle source
def describe_load_balancer_attributes(lb_name = nil, names = [])
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
attributes = load_balancer['LoadBalancerAttributes']
response = Excon::Response.new
response.status = 200
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
},
'DescribeLoadBalancerAttributesResult' => {
'LoadBalancerAttributes' => attributes
}
}
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']['Proper'].reduce({'AppCookieStickinessPolicies' => [], 'LBCookieStickinessPolicies' => [], 'OtherPolicies' => []}) { |m, policy|
case policy['PolicyTypeName']
when 'AppCookieStickinessPolicyType'
cookie_name = policy['PolicyAttributeDescriptions'].find{|h| h['AttributeName'] == 'CookieName'}['AttributeValue']
m['AppCookieStickinessPolicies'] << { 'PolicyName' => policy['PolicyName'], 'CookieName' => cookie_name }
when 'LBCookieStickinessPolicyType'
cookie_expiration_period = policy['PolicyAttributeDescriptions'].find{|h| h['AttributeName'] == 'CookieExpirationPeriod'}['AttributeValue'].to_i
lb_policy = { 'PolicyName' => policy['PolicyName'] }
lb_policy['CookieExpirationPeriod'] = cookie_expiration_period if cookie_expiration_period > 0
m['LBCookieStickinessPolicies'] << lb_policy
else
m['OtherPolicies'] << policy['PolicyName']
end
m
}
lb['BackendServerDescriptions'] = lb.delete('BackendServerDescriptionsRemote')
lb
end
}
}
if next_marker
response.body['DescribeLoadBalancersResult']['NextMarker'] = next_marker.to_s
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)
disable_zones(availability_zones, lb_name)
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)
enable_zones(availability_zones, lb_name)
modify_load_balancer_attributes(lb_name, attributes)
click to toggle source
def modify_load_balancer_attributes(lb_name, attributes)
raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
if attributes['CrossZoneLoadBalancing'] || attributes['ConnectionDraining']
load_balancer['LoadBalancerAttributes'].merge! attributes
end
response = Excon::Response.new
response.status = 200
response.body = {
"ResponseMetadata" => {
"RequestId" => Fog::AWS::Mock.request_id
}
}
response
end
register_instances(instance_ids, lb_name)
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_for_backend_server(lb_name, instance_port, policy_names)
click to toggle source
def set_load_balancer_policies_for_backend_server(lb_name, instance_port, policy_names)
if load_balancer = self.data[:load_balancers][lb_name]
policy_names.each do |policy_name|
unless load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == policy_name }
raise Fog::AWS::ELB::PolicyNotFound, "There is no policy with name #{policy_name} for load balancer #{lb_name}"
end
end
description = load_balancer['BackendServerDescriptionsRemote'].find{|d| d["InstancePort"] == instance_port } || {}
description["InstancePort"] = instance_port
description["PolicyNames"] = policy_names
load_balancer['BackendServerDescriptionsRemote'].delete_if{|d| d["InstancePort"] == instance_port }
load_balancer['BackendServerDescriptionsRemote'] << description
Excon::Response.new.tap do |response|
response.status = 200
response.body = {
'ResponseMetadata' => {
'RequestId' => Fog::AWS::Mock.request_id
}
}
end
else
raise Fog::AWS::ELB::NotFound
end
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
setup_credentials(options)
click to toggle source
def setup_credentials(options)
@aws_access_key_id = options[:aws_access_key_id]
@aws_secret_access_key = options[:aws_secret_access_key]
end