class Vcloud::EdgeGateway::ConfigurationGenerator::LoadBalancerService

Public Class Methods

new(edge_gateway_interfaces) click to toggle source
# File lib/vcloud/edge_gateway/configuration_generator/load_balancer_service.rb, line 6
def initialize(edge_gateway_interfaces)
  @edge_gateway_interfaces = edge_gateway_interfaces
end

Public Instance Methods

generate_fog_config(load_balancer_input_config) click to toggle source
# File lib/vcloud/edge_gateway/configuration_generator/load_balancer_service.rb, line 10
def generate_fog_config(load_balancer_input_config)
  return nil if load_balancer_input_config.nil?
  vcloud_load_balancer_section = {}
  vcloud_load_balancer_section[:IsEnabled] =
    load_balancer_input_config.key?(:enabled) ?
      load_balancer_input_config[:enabled].to_s : 'true'
  vcloud_pools = []
  vcloud_virtual_servers = []
  if load_balancer_input_config[:pools]
    load_balancer_input_config[:pools].each do |pool_input_entry|
      vcloud_pools << generate_pool_entry(pool_input_entry)
    end
  end
  if load_balancer_input_config[:virtual_servers]
    load_balancer_input_config[:virtual_servers].each do |virtual_server_input_entry|
      vcloud_virtual_servers << generate_virtual_server_entry(virtual_server_input_entry)
    end
  end
  vcloud_load_balancer_section[:Pool] = vcloud_pools
  vcloud_load_balancer_section[:VirtualServer] = vcloud_virtual_servers
  vcloud_load_balancer_section
end

Private Instance Methods

default_port(protocol) click to toggle source
# File lib/vcloud/edge_gateway/configuration_generator/load_balancer_service.rb, line 99
def default_port(protocol)
  default_port_for = { http: '80', https: '443', tcp: '' }
  default_port_for[protocol]
end
generate_pool_entry(input_pool_entry) click to toggle source
# File lib/vcloud/edge_gateway/configuration_generator/load_balancer_service.rb, line 119
def generate_pool_entry(input_pool_entry)
  service_port_modes = [ :http, :https, :tcp ]
  vcloud_pool_entry = {}
  vcloud_pool_entry[:Name] = input_pool_entry[:name]
  if input_pool_entry.key?(:description)
    vcloud_pool_entry[:Description] = input_pool_entry[:description]
  end
  vcloud_pool_entry[:ServicePort] = service_port_modes.map do |mode|
    generate_pool_service_port(
      mode,
      input_pool_entry.key?(:service) ? input_pool_entry[:service][mode] : nil
    )
  end
  if input_pool_entry.key?(:members)
    vcloud_pool_entry[:Member] = []
    input_pool_entry[:members].each do |member|
      vcloud_pool_entry[:Member] << generate_pool_member_entry(member)
    end
  end
  vcloud_pool_entry
end
generate_pool_healthcheck(protocol, input_pool_healthcheck_entry = nil) click to toggle source
# File lib/vcloud/edge_gateway/configuration_generator/load_balancer_service.rb, line 184
def generate_pool_healthcheck(protocol, input_pool_healthcheck_entry = nil)
  vcloud_pool_healthcheck_entry = {}
  vcloud_pool_healthcheck_entry[:Mode] = ( protocol == :https ) ? 'SSL' : protocol.to_s.upcase
  vcloud_pool_healthcheck_entry[:Uri] = ( protocol == :http ) ? '/' : ''
  vcloud_pool_healthcheck_entry[:HealthThreshold] = '2'
  vcloud_pool_healthcheck_entry[:UnhealthThreshold] = '3'
  vcloud_pool_healthcheck_entry[:Interval] = '5'
  vcloud_pool_healthcheck_entry[:Timeout] = '15'

  if input_pool_healthcheck_entry
    if input_pool_healthcheck_entry.key?(:protocol)
      vcloud_pool_healthcheck_entry[:Mode] = input_pool_healthcheck_entry[:protocol]
    end
    if input_pool_healthcheck_entry.key?(:uri)
      if vcloud_pool_healthcheck_entry[:Mode] == 'HTTP'
        vcloud_pool_healthcheck_entry[:Uri] = input_pool_healthcheck_entry[:uri]
      else
        raise "vCloud Director does not support healthcheck URI on protocols other than HTTP"
      end
    elsif vcloud_pool_healthcheck_entry[:Mode] != 'HTTP'
        vcloud_pool_healthcheck_entry[:Uri] = ''
    end
    if input_pool_healthcheck_entry.key?(:health_threshold)
      vcloud_pool_healthcheck_entry[:HealthThreshold] =
        input_pool_healthcheck_entry[:health_threshold]
    end
    if input_pool_healthcheck_entry.key?(:unhealth_threshold)
      vcloud_pool_healthcheck_entry[:UnhealthThreshold] =
        input_pool_healthcheck_entry[:unhealth_threshold]
    end
    if input_pool_healthcheck_entry.key?(:interval)
      vcloud_pool_healthcheck_entry[:Interval] =
        input_pool_healthcheck_entry[:interval]
    end
    if input_pool_healthcheck_entry.key?(:timeout)
      vcloud_pool_healthcheck_entry[:Timeout] =
        input_pool_healthcheck_entry[:timeout]
    end
  end
  vcloud_pool_healthcheck_entry
end
generate_pool_member_entry(input_pool_member) click to toggle source
# File lib/vcloud/edge_gateway/configuration_generator/load_balancer_service.rb, line 141
def generate_pool_member_entry(input_pool_member)
  {
    IpAddress: input_pool_member[:ip_address],
    Weight:    input_pool_member.key?(:weight) ? input_pool_member[:weight].to_s : '1',
    ServicePort: [
      { Protocol: 'HTTP',  Port: '', HealthCheckPort: '' },
      { Protocol: 'HTTPS', Port: '', HealthCheckPort: '' },
      { Protocol: 'TCP',   Port: '', HealthCheckPort: '' },
    ]
  }
end
generate_pool_service_port(mode, input_pool_service_port) click to toggle source
# File lib/vcloud/edge_gateway/configuration_generator/load_balancer_service.rb, line 153
def generate_pool_service_port(mode, input_pool_service_port)

  vcloud_pool_service_port = {
    IsEnabled: 'false',
    Protocol: mode.to_s.upcase,
    Algorithm: 'ROUND_ROBIN',
    Port: default_port(mode),
    HealthCheckPort: '',
    HealthCheck: generate_pool_healthcheck(mode)
  }

  if input_pool_service_port
    vcloud_pool_service_port[:IsEnabled] =
      input_pool_service_port.key?(:enabled) ?
        input_pool_service_port[:enabled].to_s : 'true'
    if input_pool_service_port.key?(:algorithm)
      vcloud_pool_service_port[:Algorithm] = input_pool_service_port[:algorithm]
    end
    if input_pool_service_port.key?(:port)
      vcloud_pool_service_port[:Port] = input_pool_service_port[:port].to_s
    end
    if input_pool_service_port[:health_check]
      vcloud_pool_service_port[:HealthCheckPort] =
        input_pool_service_port[:health_check].fetch(:port, '').to_s
      vcloud_pool_service_port[:HealthCheck] =
        generate_pool_healthcheck(mode, input_pool_service_port[:health_check])
    end
  end
  vcloud_pool_service_port
end
generate_virtual_server_entry(input_virtual_server) click to toggle source
# File lib/vcloud/edge_gateway/configuration_generator/load_balancer_service.rb, line 35
def generate_virtual_server_entry(input_virtual_server)
  vcloud_virtual_server = {}
  vcloud_virtual_server[:IsEnabled] =
    input_virtual_server.key(:enabled) ? input_virtual_server[:enabled] : 'true'
  vcloud_virtual_server[:Name] = input_virtual_server[:name]
  vcloud_virtual_server[:Description] =
    input_virtual_server[:description] || ''
  vcloud_virtual_server[:Interface] =
    generate_virtual_server_interface_section(input_virtual_server[:network])
  vcloud_virtual_server[:IpAddress] = input_virtual_server[:ip_address]
  vcloud_virtual_server[:ServiceProfile] =
    generate_virtual_server_service_profile_section(input_virtual_server[:service_profiles])
  vcloud_virtual_server[:Logging] =
    input_virtual_server.key(:logging) ? input_virtual_server[:logging] : 'false'
  vcloud_virtual_server[:Pool] = input_virtual_server[:pool]
  vcloud_virtual_server
end
generate_virtual_server_interface_section(network_id) click to toggle source
# File lib/vcloud/edge_gateway/configuration_generator/load_balancer_service.rb, line 53
def generate_virtual_server_interface_section(network_id)
  edge_gw_interface = @edge_gateway_interfaces.find do |interface|
    interface.network_id == network_id
  end
  raise "unable to find gateway network interface with id #{network_id}" unless edge_gw_interface
  vcloud_virtual_server_interface = {}
  vcloud_virtual_server_interface[:type] = 'application/vnd.vmware.vcloud.orgVdcNetwork+xml'
  vcloud_virtual_server_interface[:name] = edge_gw_interface.network_name
  vcloud_virtual_server_interface[:href] = edge_gw_interface.network_href
  vcloud_virtual_server_interface
end
generate_virtual_server_persistence_section(input_persistence_section) click to toggle source
# File lib/vcloud/edge_gateway/configuration_generator/load_balancer_service.rb, line 104
def generate_virtual_server_persistence_section(input_persistence_section)
  input_persistence_section = {} if input_persistence_section.nil?
  vcloud_persistence_section = { Method: '' }
  if input_persistence_section.key?(:method)
    if input_persistence_section.key?(:method)
      vcloud_persistence_section[:Method] = input_persistence_section[:method]
    end
    if input_persistence_section[:method] == 'COOKIE'
      vcloud_persistence_section[:CookieName] = input_persistence_section[:cookie_name]
      vcloud_persistence_section[:CookieMode] = input_persistence_section[:cookie_mode]
    end
  end
  vcloud_persistence_section
end
generate_virtual_server_service_profile_protocol_section(protocol, input_protocol_section) click to toggle source
# File lib/vcloud/edge_gateway/configuration_generator/load_balancer_service.rb, line 79
def generate_virtual_server_service_profile_protocol_section(protocol, input_protocol_section)
  vcloud_protocol_section = {
    IsEnabled: 'false',
    Protocol: protocol.to_s.upcase,
    Port:     default_port(protocol),
    Persistence: generate_virtual_server_persistence_section(nil)
  }
  if input_protocol_section
    vcloud_protocol_section[:IsEnabled] =
      input_protocol_section.key?(:enabled) ?
        input_protocol_section[:enabled].to_s : 'true'
    vcloud_protocol_section[:Port] =
      input_protocol_section.key?(:port) ?
        input_protocol_section[:port].to_s : default_port(protocol)
    vcloud_protocol_section[:Persistence] =
      generate_virtual_server_persistence_section(input_protocol_section[:persistence])
  end
  vcloud_protocol_section
end
generate_virtual_server_service_profile_section(input_service_profile) click to toggle source
# File lib/vcloud/edge_gateway/configuration_generator/load_balancer_service.rb, line 65
def generate_virtual_server_service_profile_section(input_service_profile)
  input_service_profile = {} if input_service_profile.nil?
  vcloud_service_profiles = []
  protocols = [ :http, :https, :tcp ]
  protocols.each do |protocol|
    vcloud_service_profiles <<
      generate_virtual_server_service_profile_protocol_section(
        protocol,
        input_service_profile[protocol]
      )
  end
  vcloud_service_profiles
end