Puppet Class: octavia::health_manager

Inherits:
octavia::params
Defined in:
manifests/health_manager.pp

Overview

Installs and configures the octavia health manager service

Parameters

enabled

(optional) Should the service be enabled. Defaults to true

manage_service

(optional) Whether the service should be managed by Puppet. Defaults to true.

package_ensure

(optional) ensure state for package. Defaults to ‘present’

ip

(optional) The bind ip for the health manager Defaults to $::os_service_default

port

(optional) The bind port for the health manager Defaults to $::os_service_default

health_update_threads

(optional) Number of processes for amphora health update Defaults to $::os_workers

stats_update_threads

(optional) Number of processes for amphora stats update Defaults to $::os_workers

failover_threads

(optional) The number of threads performing amphora failovers. Defaults to $::os_service_default

heartbeat_timeout

(optional) Interval, in seconds, to wait before failing over an amphora. Defaults to $::os_service_default

health_check_interval

(optional) Sleep time between health checks in seconds. Defaults to $::os_service_default

sock_rlimit

(optional) Sets the value of the heartbeat recv buffer Defaults to $::os_service_default

failover_threshold

(optional) Stop failovers if the count of simultaneously failed amphora reaches this number. Defaults to $::os_service_default

DEPRECATED PARAMETERS

workers

(optional) The number of workers health_manager spawns Defaults to undef

heartbeat_key

(optional) Key to validate amphora messages. Defaults to undef

heartbeat_interval

(optional) Sleep time between sending heartbeats. Defaults to undef

Parameters:

  • manage_service (Any) (defaults to: true)
  • enabled (Any) (defaults to: true)
  • package_ensure (Any) (defaults to: 'present')
  • ip (Any) (defaults to: $::os_service_default)
  • port (Any) (defaults to: $::os_service_default)
  • health_update_threads (Any) (defaults to: $::os_workers)
  • stats_update_threads (Any) (defaults to: $::os_workers)
  • failover_threads (Any) (defaults to: $::os_service_default)
  • heartbeat_timeout (Any) (defaults to: $::os_service_default)
  • health_check_interval (Any) (defaults to: $::os_service_default)
  • sock_rlimit (Any) (defaults to: $::os_service_default)
  • failover_threshold (Any) (defaults to: $::os_service_default)
  • workers (Any) (defaults to: undef)
  • heartbeat_key (Any) (defaults to: undef)
  • heartbeat_interval (Any) (defaults to: undef) 


68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'manifests/health_manager.pp', line 68

class octavia::health_manager (
  $manage_service        = true,
  $enabled               = true,
  $package_ensure        = 'present',
  $ip                    = $::os_service_default,
  $port                  = $::os_service_default,
  $health_update_threads = $::os_workers,
  $stats_update_threads  = $::os_workers,
  $failover_threads      = $::os_service_default,
  $heartbeat_timeout     = $::os_service_default,
  $health_check_interval = $::os_service_default,
  $sock_rlimit           = $::os_service_default,
  $failover_threshold    = $::os_service_default,
  # DEPRECATED PARAMETERS
  $workers               = undef,
  $heartbeat_key         = undef,
  $heartbeat_interval    = undef,
) inherits octavia::params {

  include octavia::deps
  include octavia::controller

  if $heartbeat_key != undef {
    warning('The heartbeat_key parameter is deprecated. Use the octavia::controller class parameter instead.')
    validate_legacy(String, 'validate_string', $heartbeat_key)
  }
  if $heartbeat_interval != undef {
    warning('The heartbeat_interval parameter is deprecated. Use the octavia::controller class parameter instead.')
  }

  package { 'octavia-health-manager':
    ensure => $package_ensure,
    name   => $::octavia::params::health_manager_package_name,
    tag    => ['openstack', 'octavia-package'],
  }

  if $manage_service {
    if $enabled {
      $service_ensure = 'running'
    } else {
      $service_ensure = 'stopped'
    }

    service { 'octavia-health-manager':
      ensure     => $service_ensure,
      name       => $::octavia::params::health_manager_service_name,
      enable     => $enabled,
      hasstatus  => true,
      hasrestart => true,
      tag        => ['octavia-service'],
    }
  }

  if $workers != undef {
    warning('The octavia::health_manager::workers parameter is deprecated. \
Use health_update_threads and stats_update_threads instead')
  }
  $health_update_threads_real = pick($workers, $health_update_threads)
  $stats_update_threads_real = pick($workers, $stats_update_threads)

  octavia_config {
    'health_manager/bind_ip'                : value => $ip;
    'health_manager/bind_port'              : value => $port;
    'health_manager/health_update_threads'  : value => $health_update_threads_real;
    'health_manager/stats_update_threads'   : value => $stats_update_threads_real;
    'health_manager/failover_threads'       : value => $failover_threads;
    'health_manager/heartbeat_timeout'      : value => $heartbeat_timeout;
    'health_manager/health_check_interval'  : value => $health_check_interval;
    'health_manager/sock_rlimit'            : value => $sock_rlimit;
    'health_manager/failover_threshold'     : value => $failover_threshold;
  }

  if $::octavia::controller::heartbeat_key == undef {
    if $heartbeat_key == undef {
      fail('The heartbeat_key parameter is required.')
    }
    octavia_config {
      'health_manager/heartbeat_key': value => $heartbeat_key, secret => true;
    }
  }
  if $::octavia::controller::heartbeat_interval == undef {
    octavia_config {
      'health_manager/heartbeat_interval': value => pick($heartbeat_interval, $::os_service_default);
    }
  }
}