class Miasma::Models::LoadBalancer::Aws

AWS load balancer API

Constants

API_SERVICE

Service name of API

API_VERSION

Supported version of the ELB API

Public Instance Methods

balancer_all(options = {}) click to toggle source

Return all load balancers

@param options [Hash] filter @return [Array<Models::LoadBalancer::Balancer>]

# File lib/miasma/contrib/aws/load_balancer.rb, line 205
def balancer_all(options = {})
  load_balancer_data
end
balancer_destroy(balancer) click to toggle source

Delete load balancer

@param balancer [Models::LoadBalancer::Balancer] @return [TrueClass, FalseClass]

# File lib/miasma/contrib/aws/load_balancer.rb, line 182
def balancer_destroy(balancer)
  if balancer.persisted?
    request(
      :method => :post,
      :path => "/",
      :form => Smash.new(
        "Action" => "DeleteLoadBalancer",
        "LoadBalancerName" => balancer.name,
      ),
    )
    balancer.state = :pending
    balancer.status = "DELETE_IN_PROGRESS"
    balancer.valid_state
    true
  else
    false
  end
end
balancer_health_check(balancer) click to toggle source

Save the load balancer health check

@param balancer [Models::LoadBalancer::Balancer] @return [Models::LoadBalancer::Balancer]

# File lib/miasma/contrib/aws/load_balancer.rb, line 78
def balancer_health_check(balancer)
  balancer
end
balancer_reload(balancer) click to toggle source

Reload the balancer data from the API

@param balancer [Models::LoadBalancer::Balancer] @return [Models::LoadBalancer::Balancer]

# File lib/miasma/contrib/aws/load_balancer.rb, line 94
def balancer_reload(balancer)
  if balancer.persisted?
    begin
      load_balancer_data(balancer)
    rescue Miasma::Error::ApiError::RequestError => e
      if e.response_error_msg.include?("LoadBalancerNotFound")
        balancer.state = :terminated
        balancer.status = "terminated"
        balancer.valid_state
      else
        raise
      end
    end
  end
  balancer
end
balancer_save(balancer) click to toggle source

Save load balancer

@param balancer [Models::LoadBalancer::Balancer] @return [Models::LoadBalancer::Balancer]

# File lib/miasma/contrib/aws/load_balancer.rb, line 20
def balancer_save(balancer)
  unless balancer.persisted?
    params = Smash.new(
      "LoadBalancerName" => balancer.name,
    )
    availability_zones.each_with_index do |az, i|
      params["AvailabilityZones.member.#{i + 1}"] = az
    end
    if balancer.listeners
      balancer.listeners.each_with_index do |listener, i|
        key = "Listeners.member.#{i + 1}"
        params["#{key}.Protocol"] = listener.protocol
        params["#{key}.InstanceProtocol"] = listener.instance_protocol
        params["#{key}.LoadBalancerPort"] = listener.load_balancer_port
        params["#{key}.InstancePort"] = listener.instance_port
        if listener.ssl_certificate_id
          params["#{key}.SSLCertificateId"] = listener.ssl_certificate_id
        end
      end
    end
    result = request(
      :method => :post,
      :path => "/",
      :form => params.merge(
        Smash.new(
          "Action" => "CreateLoadBalancer",
        )
      ),
    )
    balancer.public_addresses = [
      :address => result.get(:body,
                             "CreateLoadBalancerResponse", "CreateLoadBalancerResult", "DNSName"),
    ]
    balancer.load_data(:id => balancer.name).valid_state
    if balancer.health_check
      balancer_health_check(balancer)
    end
    if balancer.servers && !balancer.servers.empty?
      balancer_set_instances(balancer)
    end
  else
    if balancer.dirty?
      if balancer.dirty?(:health_check)
        balancer_health_check(balancer)
      end
      if balancer.dirty?(:servers)
        balancer_set_instances(balancer)
      end
      balancer.reload
    end
    balancer
  end
end
balancer_set_instances(balancer) click to toggle source

Save the load balancer attached servers

@param balancer [Models::LoadBalancer::Balancer] @return [Models::LoadBalancer::Balancer]

# File lib/miasma/contrib/aws/load_balancer.rb, line 86
def balancer_set_instances(balancer)
  balancer
end
load_balancer_data(balancer = nil) click to toggle source

Fetch balancers or update provided balancer data

@param balancer [Models::LoadBalancer::Balancer] @return [Array<Models::LoadBalancer::Balancer>]

# File lib/miasma/contrib/aws/load_balancer.rb, line 115
def load_balancer_data(balancer = nil)
  params = Smash.new("Action" => "DescribeLoadBalancers")
  if balancer
    params["LoadBalancerNames.member.1"] = balancer.id || balancer.name
  end
  result = all_result_pages(nil, :body,
                            "DescribeLoadBalancersResponse", "DescribeLoadBalancersResult",
                            "LoadBalancerDescriptions", "member") do |options|
    request(
      :method => :post,
      :path => "/",
      :form => options.merge(params),
    )
  end
  if balancer
    health_result = all_result_pages(nil, :body,
                                     "DescribeInstanceHealthResponse", "DescribeInstanceHealthResult",
                                     "InstanceStates", "member") do |options|
      request(
        :method => :post,
        :path => "/",
        :form => options.merge(
          "LoadBalancerName" => balancer.id || balancer.name,
          "Action" => "DescribeInstanceHealth",
        ),
      )
    end
  end
  result.map do |blr|
    (balancer || Balancer.new(self)).load_data(
      Smash.new(
        :id => blr["LoadBalancerName"],
        :name => blr["LoadBalancerName"],
        :state => :active,
        :status => "ACTIVE",
        :created => blr["CreatedTime"],
        :updated => blr["CreatedTime"],
        :public_addresses => [
          Balancer::Address.new(
            :address => blr["DNSName"],
            :version => 4,
          ),
        ],
        :servers => [blr.get("Instances", "member")].flatten(1).compact.map { |i|
          Balancer::Server.new(self.api_for(:compute), :id => i["InstanceId"])
        },
      ).merge(
        health_result.nil? ? {} : Smash.new(
          :server_states => health_result.nil? ? nil : health_result.map { |i|
            Balancer::ServerState.new(
              self.api_for(:compute),
              :id => i["InstanceId"],
              :status => i["State"],
              :reason => i["ReasonCode"],
              :state => i["State"] == "InService" ? :up : :down,
            )
          },
        )
      )
    ).valid_state
  end
end

Protected Instance Methods

availability_zones() click to toggle source

@return [Array<String>] availability zones

# File lib/miasma/contrib/aws/load_balancer.rb, line 212
def availability_zones
  memoize(:availability_zones) do
    res = api_for(:compute).request(
      :method => :post,
      :path => "/",
      :form => Smash.new(
        "Action" => "DescribeAvailabilityZones",
      ),
    ).fetch(:body,
            "DescribeAvailabilityZonesResponse", "availabilityZoneInfo", "item", [])
    [res].flatten.compact.map do |item|
      if item["zoneState"] == "available"
        item["zoneName"]
      end
    end.compact
  end
end