Parent

Files

Class/Module Index [+]

Quicksearch

Fog::AWS::ELB::Mock

Public Class Methods

data() click to toggle source
# File lib/fog/aws/elb.rb, line 42
def self.data
  @data ||= Hash.new do |hash, region|
    owner_id = Fog::AWS::Mock.owner_id
    hash[region] = Hash.new do |region_hash, key|
      region_hash[key] = {
        :owner_id => owner_id,
        :load_balancers => {}
      }
    end
  end
end
dns_name(name, region) click to toggle source
# File lib/fog/aws/elb.rb, line 54
def self.dns_name(name, region)
  "#{name}-#{Fog::Mock.random_hex(8)}.#{region}.elb.amazonaws.com"
end
new(options={}) click to toggle source
# File lib/fog/aws/elb.rb, line 62
def initialize(options={})
  @aws_access_key_id = options[:aws_access_key_id]

  @region = options[:region] || 'us-east-1'

  unless ['ap-northeast-1', 'ap-southeast-1', 'eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2'].include?(@region)
    raise ArgumentError, "Unknown region: #{@region.inspect}"
  end
end
reset() click to toggle source
# File lib/fog/aws/elb.rb, line 58
def self.reset
  @data = nil
end

Public Instance Methods

configure_health_check(lb_name, health_check) click to toggle source
# File lib/fog/aws/requests/elb/configure_health_check.rb, line 41
def configure_health_check(lb_name, health_check)
  if load_balancer = self.data[:load_balancers][lb_name]
    response = Excon::Response.new
    response.status = 200

    load_balancer['HealthCheck'] = health_check

    response.body = {
      'ResponseMetadata' => {
        'RequestId' => Fog::AWS::Mock.request_id
      },
      'ConfigureHealthCheckResult' => {
        'HealthCheck' => load_balancer['HealthCheck']
      }
    }

    response
  else
    raise Fog::AWS::ELB::NotFound
  end
end
create_load_balancer(availability_zones, lb_name, listeners = []) click to toggle source
# File lib/fog/aws/requests/elb/create_load_balancer.rb, line 53
def create_load_balancer(availability_zones, lb_name, listeners = [])
  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,
    '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' => {
      'LBCookieStickinessPolicies' => [],
      'AppCookieStickinessPolicies' => []
    },
    '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
# File lib/fog/aws/requests/elb/create_load_balancer_listeners.rb, line 51
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
      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
data() click to toggle source
# File lib/fog/aws/elb.rb, line 72
def data
  self.class.data[@region][@aws_access_key_id]
end
delete_load_balancer(lb_name) click to toggle source
# File lib/fog/aws/requests/elb/delete_load_balancer.rb, line 33
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
# File lib/fog/aws/requests/elb/delete_load_balancer_listeners.rb, line 31
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
# File lib/fog/aws/requests/elb/delete_load_balancer_policy.rb, line 31
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 { |p| p['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
# File lib/fog/aws/requests/elb/deregister_instances_from_load_balancer.rb, line 36
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
Also aliased as: deregister_instances
describe_instance_health(lb_name, instance_ids = []) click to toggle source
# File lib/fog/aws/requests/elb/describe_instance_health.rb, line 37
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_balancers(lb_names = []) click to toggle source
# File lib/fog/aws/requests/elb/describe_load_balancers.rb, line 56
def describe_load_balancers(lb_names = [])
  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

  response = Excon::Response.new
  response.status = 200

  response.body = {
    'ResponseMetadata' => {
      'RequestId' => Fog::AWS::Mock.request_id
    },
    'DescribeLoadBalancersResult' => {
      'LoadBalancerDescriptions' => load_balancers.map { |lb| lb['Instances'] = lb['Instances'].map { |i| i['InstanceId'] }; lb }
    }
  }

  response
end
disable_availability_zones_for_load_balancer(availability_zones, lb_name) click to toggle source
# File lib/fog/aws/requests/elb/disable_availability_zones_for_load_balancer.rb, line 35
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
Also aliased as: disable_zones
disable_zones(availability_zones, lb_name) click to toggle source
enable_availability_zones_for_load_balancer(availability_zones, lb_name) click to toggle source
# File lib/fog/aws/requests/elb/enable_availability_zones_for_load_balancer.rb, line 36
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
Also aliased as: enable_zones
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
# File lib/fog/aws/requests/elb/register_instances_with_load_balancer.rb, line 36
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
Also aliased as: register_instances
reset_data() click to toggle source
# File lib/fog/aws/elb.rb, line 76
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
# File lib/fog/aws/requests/elb/set_load_balancer_listener_ssl_certificate.rb, line 37
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
# File lib/fog/aws/requests/elb/set_load_balancer_policies_of_listener.rb, line 43
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'].find { |name, policies| policies.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

[Validate]

Generated with the Darkfish Rdoc Generator 2.