Module: PuppetX::IntechWIFI::Declare_Environment_Resources::LoadBalancerHelper

Defined in:
lib/puppet_x/intechwifi/declare_environment_resources.rb

Class Method Summary collapse

Class Method Details

.CalculateSecurityGroups(name, server_roles, services) ⇒ Object



507
508
509
# File 'lib/puppet_x/intechwifi/declare_environment_resources.rb', line 507

def self.CalculateSecurityGroups(name, server_roles, services)
  GetRoleNamesWithLoadBalancers(server_roles, services).map{|role_name| "#{name}_#{role_name}_elb"}
end

.DoesServiceHaveLoadbalancedPorts(services, service_name) ⇒ Object



468
469
470
471
472
473
# File 'lib/puppet_x/intechwifi/declare_environment_resources.rb', line 468

def self.DoesServiceHaveLoadbalancedPorts(services, service_name)
  return false if !services.has_key?(service_name)
  return false if !services[service_name].has_key?('loadbalanced_ports')
  return false if services[service_name]['loadbalanced_ports'].length == 0
  true
end

.GenerateLoadBalancer(name, status, region, role_name, services, scratch) ⇒ Object



428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
# File 'lib/puppet_x/intechwifi/declare_environment_resources.rb', line 428

def self.GenerateLoadBalancer(name, status, region, role_name, services, scratch)
  {
      "#{GenerateLoadBalancerName(name, role_name)}" => {
          :ensure => status,
          :region => region,
          :subnets => scratch[:subnet_data].select{|data| data[:zone] == 'public' }.map{|data| data[:name] },
          :listeners => scratch[:loadbalancer_role_service_hash][role_name].map{|service|
            service['loadbalanced_ports'].map{|port| ParseSharedPort(port)}
          }.flatten.map{|porthash|
            (porthash.has_key?(:certificate) and porthash.has_key?(:protocol) and porthash[:protocol] == 'https') ?
                "https://#{GenerateLoadBalancerTargetName(name, role_name)}:#{porthash[:listen_port]}?certificate=#{porthash[:certificate]}" :
                "#{porthash[:protocol]}://#{GenerateLoadBalancerTargetName(name, role_name)}:#{porthash[:listen_port]}"
          }.uniq,
          :targets => [ GenerateLoadBalancerTarget(name, role_name) ],
          :security_groups => [ "#{name}_#{role_name}_elb" ],
          # :internet_gateway => ;
      }
  }
end

.GenerateLoadBalancerName(name, role_name) ⇒ Object



460
461
462
# File 'lib/puppet_x/intechwifi/declare_environment_resources.rb', line 460

def self.GenerateLoadBalancerName(name, role_name)
  "#{name}-#{role_name}"
end

.GenerateLoadbalancerResources(name, status, region, roles, services, scratch) ⇒ Object



422
423
424
425
426
# File 'lib/puppet_x/intechwifi/declare_environment_resources.rb', line 422

def self.GenerateLoadbalancerResources(name, status, region, roles, services, scratch)
  GetRoleNamesWithLoadBalancers(roles, services).map{|role_name|
    GenerateLoadBalancer(name, status, region, role_name, services, scratch)
  }.reduce({}){|hash, kv| hash.merge(kv) }
end

.GenerateLoadBalancerTarget(name, role_name) ⇒ Object



448
449
450
451
452
453
454
455
456
457
458
# File 'lib/puppet_x/intechwifi/declare_environment_resources.rb', line 448

def self.GenerateLoadBalancerTarget(name, role_name)
  {
      "name" => "#{GenerateLoadBalancerTargetName(name, role_name)}",
      "port" => 80,
      "check_interval" => 30,
      "timeout" => 5,
      "healthy" => 5,
      "failed" => 2,
      "vpc" => name
  }
end

.GenerateLoadBalancerTargetName(name, role_name) ⇒ Object



464
465
466
# File 'lib/puppet_x/intechwifi/declare_environment_resources.rb', line 464

def self.GenerateLoadBalancerTargetName(name, role_name)
  "#{name}-#{role_name}"
end

.GenerateServicesWithLoadBalancedPortsByRoleHash(server_roles, services) ⇒ Object



495
496
497
498
499
500
501
502
503
504
505
# File 'lib/puppet_x/intechwifi/declare_environment_resources.rb', line 495

def self.GenerateServicesWithLoadBalancedPortsByRoleHash(server_roles, services)
  server_roles.select {|role_name, role_data|
    role_data.has_key?('services') and role_data['services'].any?{|service_name| DoesServiceHaveLoadbalancedPorts(services, service_name)}
  }.map{|role_name, role_data|
    {
        role_name => role_data['services'].select{|service_name|
          DoesServiceHaveLoadbalancedPorts(services, service_name)
        }.map{|service_name| services[service_name].merge({'service_name' => service_name})}
    }
  }.reduce({}){|hash, kv| hash.merge(kv)}
end

.GetRoleLoadBalancedPorts(role, services) ⇒ Object



475
476
477
478
479
480
481
482
483
484
485
# File 'lib/puppet_x/intechwifi/declare_environment_resources.rb', line 475

def self.GetRoleLoadBalancedPorts(role, services)
  return [] if !role.has_key?('services')

  role['services'].map{ |service_name|
    services[service_name].select{|service|
      service.has_key?('loadbalanced_ports') and service['loadbalanced_ports'].length > 0
    }.map{|service|
      service['loadbalanced_ports']
    }
  }
end

.GetRoleNamesWithLoadBalancers(server_roles, services) ⇒ Object



489
490
491
492
493
# File 'lib/puppet_x/intechwifi/declare_environment_resources.rb', line 489

def self.GetRoleNamesWithLoadBalancers(server_roles, services)
  server_roles.select {|role_name, role_data|
    role_data.has_key?('services') and role_data['services'].any?{|service_name| DoesServiceHaveLoadbalancedPorts(services, service_name)}
  }.map{|role_name, role_data| role_name }
end

.ParseSharedPort(shared_port) ⇒ Object



511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
# File 'lib/puppet_x/intechwifi/declare_environment_resources.rb', line 511

def self.ParseSharedPort(shared_port)
  source_target_split = /^(.+)=>([0-9]{1,5})$/.match(shared_port)

  # no =>
  raise PuppetX::IntechWIFI::Exceptions::SharedPortFormatError, shared_port if source_target_split.nil?
  # Destination port a number?
  raise PuppetX::IntechWIFI::Exceptions::SharedPortFormatError, source_target_split[2] if /^[0-9]{1,5}$/.match(source_target_split[2]).nil?

  source_split = source_target_split[1].split('|')

  # Was it properly split?
  raise PuppetX::IntechWIFI::Exceptions::SharedPortFormatError, shared_port if source_target_split.nil?
  # too few segments?
  raise PuppetX::IntechWIFI::Exceptions::SharedPortFormatError, shared_port if source_split.length < 2
  # too many segments?
  raise PuppetX::IntechWIFI::Exceptions::SharedPortFormatError, shared_port if source_split.length > 3

  # Is the source port a number?
  raise PuppetX::IntechWIFI::Exceptions::SharedPortFormatError, shared_port if /^[0-9]{1,5}$/.match(source_split[1]).nil?

  {
      :protocol => source_split[0],
      :listen_port => source_split[1],
      :target_port => source_target_split[2]
  }.merge(source_split.length == 3 ? {
      :certificate => source_split[2]
  } : {})

end