puppet/manifests/overcloud_controller.pp

   1 # Copyright 2014 Red Hat, Inc.
   2 # All Rights Reserved.
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   5 # not use this file except in compliance with the License. You may obtain
   6 # a copy of the License at
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  12 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  13 # License for the specific language governing permissions and limitations
  14 # under the License.
  15
  16 if !str2bool(hiera('enable_package_install', 'false')) {
  17   case $::osfamily {
  18     'RedHat': {
  19       Package { provider => 'norpm' } # provided by tripleo-puppet
  20     }
  21     default: {
  22       warning('enable_package_install option not supported.')
  23     }
  24   }
  25 }
  26
  27 $enable_pacemaker = str2bool(hiera('enable_pacemaker'))
  28 $enable_keepalived = !$enable_pacemaker
  29 if $::hostname == downcase(hiera('bootstrap_nodeid')) {
  30   $pacemaker_master = true
  31 } else {
  32   $pacemaker_master = false
  33 }
  34
  35 if hiera('step') >= 1 {
  36
  37   $controller_node_ips = split(hiera('controller_node_ips'), ',')
  38
  39   class { '::tripleo::loadbalancer' :
  40     controller_hosts => $controller_node_ips,
  41     manage_vip       => $enable_keepalived,
  42   }
  43
  44   if $enable_pacemaker {
  45     $pacemaker_cluster_members = regsubst(hiera('controller_node_ips'), ',', ' ', 'G')
  46     user { 'hacluster':
  47      ensure => present,
  48     } ->
  49     class { '::pacemaker':
  50       hacluster_pwd => hiera('hacluster_pwd'),
  51     } ->
  52     class { '::pacemaker::corosync':
  53       cluster_members => $pacemaker_cluster_members,
  54       setup_cluster   => $pacemaker_master,
  55     }
  56     class { '::pacemaker::stonith':
  57       disable => true,
  58     }
  59     if $pacemaker_master {
  60       $control_vip = hiera('tripleo::loadbalancer::controller_virtual_ip')
  61       pacemaker::resource::ip { 'control_vip':
  62         ip_address => $control_vip,
  63       }
  64       $public_vip = hiera('tripleo::loadbalancer::public_virtual_ip')
  65       pacemaker::resource::ip { 'public_vip':
  66         ip_address => $public_vip,
  67       }
  68       pacemaker::resource::systemd { 'haproxy':
  69         clone => true,
  70       }
  71     }
  72
  73     Class['::pacemaker::corosync'] -> Pacemaker::Resource::Systemd <| |>
  74   }
  75
  76 }
  77
  78 if hiera('step') >= 2 {
  79
  80   if count(hiera('ntp::servers')) > 0 {
  81     include ::ntp
  82   }
  83
  84   # MongoDB
  85   if downcase(hiera('ceilometer_backend')) == 'mongodb' {
  86     include ::mongodb::globals
  87
  88     if $enable_pacemaker {
  89       $mongodb_service_ensure = undef
  90     } else {
  91       $mongodb_service_ensure = 'running'
  92     }
  93
  94     class {'::mongodb::server' :
  95       service_ensure => $mongodb_service_ensure,
  96     }
  97     $mongo_node_ips = split(hiera('mongo_node_ips'), ',')
  98     $mongo_node_ips_with_port = suffix($mongo_node_ips, ':27017')
  99     $mongo_node_string = join($mongo_node_ips_with_port, ',')
 100
 101     $mongodb_replset = hiera('mongodb::server::replset')
 102     $ceilometer_mongodb_conn_string = "mongodb://${mongo_node_string}/ceilometer?replicaSet=${mongodb_replset}"
 103     if downcase(hiera('bootstrap_nodeid')) == $::hostname {
 104
 105       if $enable_pacemaker  {
 106         pacemaker::resource::systemd { 'mongod' :
 107           options => "op start timeout=120s",
 108           clone   => true,
 109           before  => Exec['mongodb-ready'],
 110         }
 111         # NOTE (spredzy) : The replset can only be run
 112         # once all the nodes have joined the cluster.
 113         $mongodb_cluster_ready_command = join(suffix(prefix($mongo_node_ips, '/bin/nc -w1 '), ' 27017 < /dev/null'), ' && ')
 114         exec { 'mongodb-ready' :
 115           command   => $mongodb_cluster_ready_command,
 116           timeout   => 600,
 117           tries     => 60,
 118           try_sleep => 10,
 119           before    => Mongodb_replset[$mongodb_replset],
 120         }
 121
 122       }
 123
 124       mongodb_replset { $mongodb_replset :
 125         members => $mongo_node_ips_with_port,
 126       }
 127     }
 128   }
 129
 130   # Redis
 131   $redis_node_ips = split(hiera('redis_node_ips'), ',')
 132   $redis_master_hostname = downcase(hiera('bootstrap_nodeid'))
 133
 134   if $redis_master_hostname == $::hostname {
 135     $slaveof = undef
 136   } else {
 137     $slaveof = "${redis_master_hostname} 6379"
 138   }
 139   class {'::redis' :
 140     slaveof => $slaveof,
 141   }
 142
 143   if count($redis_node_ips) > 1 {
 144     Class['::tripleo::redis_notification'] -> Service['redis-sentinel']
 145     include ::redis::sentinel
 146     class {'::tripleo::redis_notification' :
 147       haproxy_monitor_ip => hiera('tripleo::loadbalancer::controller_virtual_ip'),
 148     }
 149   }
 150
 151   if str2bool(hiera('enable_galera', 'true')) {
 152     $mysql_config_file = '/etc/my.cnf.d/galera.cnf'
 153   } else {
 154     $mysql_config_file = '/etc/my.cnf.d/server.cnf'
 155   }
 156   # TODO Galara
 157   class { 'mysql::server':
 158     config_file => $mysql_config_file,
 159     override_options => {
 160       'mysqld' => {
 161         'bind-address' => hiera('controller_host')
 162       }
 163     }
 164   }
 165
 166   # FIXME: this should only occur on the bootstrap host (ditto for db syncs)
 167   # Create all the database schemas
 168   # Example DSN format: mysql://user:password@host/dbname
 169   $allowed_hosts = ['%',hiera('controller_host')]
 170   $keystone_dsn = split(hiera('keystone::database_connection'), '[@:/?]')
 171   class { 'keystone::db::mysql':
 172     user          => $keystone_dsn[3],
 173     password      => $keystone_dsn[4],
 174     host          => $keystone_dsn[5],
 175     dbname        => $keystone_dsn[6],
 176     allowed_hosts => $allowed_hosts,
 177   }
 178   $glance_dsn = split(hiera('glance::api::database_connection'), '[@:/?]')
 179   class { 'glance::db::mysql':
 180     user          => $glance_dsn[3],
 181     password      => $glance_dsn[4],
 182     host          => $glance_dsn[5],
 183     dbname        => $glance_dsn[6],
 184     allowed_hosts => $allowed_hosts,
 185   }
 186   $nova_dsn = split(hiera('nova::database_connection'), '[@:/?]')
 187   class { 'nova::db::mysql':
 188     user          => $nova_dsn[3],
 189     password      => $nova_dsn[4],
 190     host          => $nova_dsn[5],
 191     dbname        => $nova_dsn[6],
 192     allowed_hosts => $allowed_hosts,
 193   }
 194   $neutron_dsn = split(hiera('neutron::server::database_connection'), '[@:/?]')
 195   class { 'neutron::db::mysql':
 196     user          => $neutron_dsn[3],
 197     password      => $neutron_dsn[4],
 198     host          => $neutron_dsn[5],
 199     dbname        => $neutron_dsn[6],
 200     allowed_hosts => $allowed_hosts,
 201   }
 202   $cinder_dsn = split(hiera('cinder::database_connection'), '[@:/?]')
 203   class { 'cinder::db::mysql':
 204     user          => $cinder_dsn[3],
 205     password      => $cinder_dsn[4],
 206     host          => $cinder_dsn[5],
 207     dbname        => $cinder_dsn[6],
 208     allowed_hosts => $allowed_hosts,
 209   }
 210   $heat_dsn = split(hiera('heat::database_connection'), '[@:/?]')
 211   class { 'heat::db::mysql':
 212     user          => $heat_dsn[3],
 213     password      => $heat_dsn[4],
 214     host          => $heat_dsn[5],
 215     dbname        => $heat_dsn[6],
 216     allowed_hosts => $allowed_hosts,
 217   }
 218   if downcase(hiera('ceilometer_backend')) == 'mysql' {
 219     $ceilometer_dsn = split(hiera('ceilometer_mysql_conn_string'), '[@:/?]')
 220     class { 'ceilometer::db::mysql':
 221       user          => $ceilometer_dsn[3],
 222       password      => $ceilometer_dsn[4],
 223       host          => $ceilometer_dsn[5],
 224       dbname        => $ceilometer_dsn[6],
 225       allowed_hosts => $allowed_hosts,
 226     }
 227   }
 228
 229   if $enable_pacemaker {
 230     # the module ignores erlang_cookie if cluster_config is false
 231     file { '/var/lib/rabbitmq/.erlang.cookie':
 232       ensure  => 'present',
 233       owner   => 'rabbitmq',
 234       group   => 'rabbitmq',
 235       mode    => '0400',
 236       content => hiera('rabbitmq::erlang_cookie'),
 237       replace => true,
 238     } ->
 239     class { '::rabbitmq':
 240       service_manage        => false,
 241       environment_variables => {
 242         'RABBITMQ_NODENAME' => "rabbit@$::hostname",
 243       },
 244     }
 245     if $pacemaker_master {
 246       pacemaker::resource::ocf { 'rabbitmq':
 247         resource_name => 'heartbeat:rabbitmq-cluster',
 248         options       => 'set_policy=\'ha-all ^(?!amq\.).* {"ha-mode":"all"}\'',
 249         clone         => true,
 250         require       => Class['::rabbitmq'],
 251       }
 252     }
 253   } else {
 254     $rabbit_nodes = split(hiera('rabbit_node_ips'), ',')
 255     if count($rabbit_nodes) > 1 {
 256       class { '::rabbitmq':
 257         config_cluster  => true,
 258         cluster_nodes   => $rabbit_nodes,
 259       }
 260       rabbitmq_policy { 'ha-all@/':
 261         pattern    => '^(?!amq\.).*',
 262         definition => {
 263           'ha-mode' => 'all',
 264         },
 265       }
 266     } else {
 267       include ::rabbitmq
 268     }
 269   }
 270
 271   # pre-install swift here so we can build rings
 272   include ::swift
 273
 274   $cinder_enable_rbd_backend = hiera('cinder_enable_rbd_backend', false)
 275   $enable_ceph = $cinder_enable_rbd_backend
 276
 277   if $enable_ceph {
 278     class { 'ceph::profile::params':
 279       mon_initial_members => downcase(hiera('ceph_mon_initial_members'))
 280     }
 281     include ::ceph::profile::mon
 282   }
 283
 284   if str2bool(hiera('enable_ceph_storage', 'false')) {
 285     include ::ceph::profile::client
 286     include ::ceph::profile::osd
 287   }
 288
 289 } #END STEP 2
 290
 291 if hiera('step') >= 3 {
 292
 293   include ::keystone
 294
 295   #TODO: need a cleanup-keystone-tokens.sh solution here
 296   keystone_config {
 297     'ec2/driver': value => 'keystone.contrib.ec2.backends.sql.Ec2';
 298   }
 299   file { [ '/etc/keystone/ssl', '/etc/keystone/ssl/certs', '/etc/keystone/ssl/private' ]:
 300     ensure  => 'directory',
 301     owner   => 'keystone',
 302     group   => 'keystone',
 303     require => Package['keystone'],
 304   }
 305   file { '/etc/keystone/ssl/certs/signing_cert.pem':
 306     content => hiera('keystone_signing_certificate'),
 307     owner   => 'keystone',
 308     group   => 'keystone',
 309     notify  => Service['keystone'],
 310     require => File['/etc/keystone/ssl/certs'],
 311   }
 312   file { '/etc/keystone/ssl/private/signing_key.pem':
 313     content => hiera('keystone_signing_key'),
 314     owner   => 'keystone',
 315     group   => 'keystone',
 316     notify  => Service['keystone'],
 317     require => File['/etc/keystone/ssl/private'],
 318   }
 319   file { '/etc/keystone/ssl/certs/ca.pem':
 320     content => hiera('keystone_ca_certificate'),
 321     owner   => 'keystone',
 322     group   => 'keystone',
 323     notify  => Service['keystone'],
 324     require => File['/etc/keystone/ssl/certs'],
 325   }
 326
 327   $glance_backend = downcase(hiera('glance_backend', 'swift'))
 328   case $glance_backend {
 329       swift: { $glance_store = 'glance.store.swift.Store' }
 330       file: { $glance_store = 'glance.store.filesystem.Store' }
 331       rbd: { $glance_store = 'glance.store.rbd.Store' }
 332       default: { fail('Unrecognized glance_backend parameter.') }
 333   }
 334
 335   # TODO: notifications, scrubber, etc.
 336   include ::glance
 337   class { 'glance::api':
 338     known_stores => [$glance_store]
 339   }
 340   include ::glance::registry
 341   include join(['::glance::backend::', $glance_backend])
 342
 343   class { 'nova':
 344     glance_api_servers     => join([hiera('glance_protocol'), '://', hiera('controller_virtual_ip'), ':', hiera('glance_port')]),
 345   }
 346
 347   include ::nova::api
 348   include ::nova::cert
 349   include ::nova::conductor
 350   include ::nova::consoleauth
 351   include ::nova::network::neutron
 352   include ::nova::vncproxy
 353   include ::nova::scheduler
 354
 355   include ::neutron
 356   include ::neutron::server
 357   include ::neutron::agents::dhcp
 358   include ::neutron::agents::l3
 359
 360   file { '/etc/neutron/dnsmasq-neutron.conf':
 361     content => hiera('neutron_dnsmasq_options'),
 362     owner   => 'neutron',
 363     group   => 'neutron',
 364     notify  => Service['neutron-dhcp-service'],
 365     require => Package['neutron'],
 366   }
 367
 368   class { 'neutron::plugins::ml2':
 369     flat_networks        => split(hiera('neutron_flat_networks'), ','),
 370     tenant_network_types => [hiera('neutron_tenant_network_type')],
 371     type_drivers         => [hiera('neutron_tenant_network_type')],
 372   }
 373
 374   class { 'neutron::agents::ml2::ovs':
 375     bridge_mappings  => split(hiera('neutron_bridge_mappings'), ','),
 376     tunnel_types     => split(hiera('neutron_tunnel_types'), ','),
 377   }
 378
 379   class { 'neutron::agents::metadata':
 380     auth_url => join(['http://', hiera('controller_virtual_ip'), ':35357/v2.0']),
 381   }
 382
 383   Service['neutron-server'] -> Service['neutron-dhcp-service']
 384   Service['neutron-server'] -> Service['neutron-l3']
 385   Service['neutron-server'] -> Service['neutron-ovs-agent-service']
 386   Service['neutron-server'] -> Service['neutron-metadata']
 387
 388   include ::cinder
 389   include ::cinder::api
 390   include ::cinder::glance
 391   include ::cinder::scheduler
 392   include ::cinder::volume
 393   class {'cinder::setup_test_volume':
 394     size => join([hiera('cinder_lvm_loop_device_size'), 'M']),
 395   }
 396
 397   $cinder_enable_iscsi = hiera('cinder_enable_iscsi_backend', true)
 398   if $cinder_enable_iscsi {
 399     $cinder_iscsi_backend = 'tripleo_iscsi'
 400
 401     cinder::backend::iscsi { $cinder_iscsi_backend :
 402       iscsi_ip_address => hiera('cinder_iscsi_ip_address'),
 403       iscsi_helper     => hiera('cinder_iscsi_helper'),
 404     }
 405   }
 406
 407   if $enable_ceph {
 408
 409     Ceph_pool {
 410       pg_num  => hiera('ceph::profile::params::osd_pool_default_pg_num'),
 411       pgp_num => hiera('ceph::profile::params::osd_pool_default_pgp_num'),
 412       size    => hiera('ceph::profile::params::osd_pool_default_size'),
 413     }
 414
 415     $ceph_pools = hiera('ceph_pools')
 416     ceph::pool { $ceph_pools : }
 417   }
 418
 419   if $cinder_enable_rbd_backend {
 420     $cinder_rbd_backend = 'tripleo_ceph'
 421
 422     cinder_config {
 423       "${cinder_rbd_backend}/host": value => 'hostgroup';
 424     }
 425
 426     cinder::backend::rbd { $cinder_rbd_backend :
 427       rbd_pool        => 'volumes',
 428       rbd_user        => 'openstack',
 429       rbd_secret_uuid => hiera('ceph::profile::params::fsid'),
 430       require         => Ceph::Pool['volumes'],
 431     }
 432   }
 433
 434   $cinder_enabled_backends = delete_undef_values([$cinder_iscsi_backend, $cinder_rbd_backend])
 435   class { '::cinder::backends' :
 436     enabled_backends => $cinder_enabled_backends,
 437   }
 438
 439   # swift proxy
 440   include ::memcached
 441   include ::swift::proxy
 442   include ::swift::proxy::proxy_logging
 443   include ::swift::proxy::healthcheck
 444   include ::swift::proxy::cache
 445   include ::swift::proxy::keystone
 446   include ::swift::proxy::authtoken
 447   include ::swift::proxy::staticweb
 448   include ::swift::proxy::ceilometer
 449   include ::swift::proxy::ratelimit
 450   include ::swift::proxy::catch_errors
 451   include ::swift::proxy::tempurl
 452   include ::swift::proxy::formpost
 453
 454   # swift storage
 455   if str2bool(hiera('enable_swift_storage', 'true')) {
 456     class {'swift::storage::all':
 457       mount_check => str2bool(hiera('swift_mount_check'))
 458     }
 459     if(!defined(File['/srv/node'])) {
 460       file { '/srv/node':
 461         ensure  => directory,
 462         owner   => 'swift',
 463         group   => 'swift',
 464         require => Package['openstack-swift'],
 465       }
 466     }
 467     $swift_components = ['account', 'container', 'object']
 468     swift::storage::filter::recon { $swift_components : }
 469     swift::storage::filter::healthcheck { $swift_components : }
 470   }
 471
 472   # Ceilometer
 473   $ceilometer_backend = downcase(hiera('ceilometer_backend'))
 474   case $ceilometer_backend {
 475     /mysql/ : {
 476       $ceilometer_database_connection = hiera('ceilometer_mysql_conn_string')
 477     }
 478     default : {
 479       $ceilometer_database_connection = $ceilometer_mongodb_conn_string
 480     }
 481   }
 482   include ::ceilometer
 483   include ::ceilometer::api
 484   include ::ceilometer::agent::notification
 485   include ::ceilometer::agent::central
 486   include ::ceilometer::alarm::notifier
 487   include ::ceilometer::alarm::evaluator
 488   include ::ceilometer::expirer
 489   include ::ceilometer::collector
 490   class { '::ceilometer::db' :
 491     database_connection => $ceilometer_database_connection,
 492   }
 493   class { 'ceilometer::agent::auth':
 494     auth_url => join(['http://', hiera('controller_virtual_ip'), ':5000/v2.0']),
 495   }
 496
 497   Cron <| title == 'ceilometer-expirer' |> { command => "sleep $((\$(od -A n -t d -N 3 /dev/urandom) % 86400)) && ${::ceilometer::params::expirer_command}" }
 498
 499   # Heat
 500   include ::heat
 501   include ::heat::api
 502   include ::heat::api_cfn
 503   include ::heat::api_cloudwatch
 504   include ::heat::engine
 505
 506   # Horizon
 507   $vhost_params = { add_listen => false }
 508   class { 'horizon':
 509     cache_server_ip    => split(hiera('memcache_node_ips', '127.0.0.1'), ','),
 510     vhost_extra_params => $vhost_params,
 511   }
 512
 513   $snmpd_user = hiera('snmpd_readonly_user_name')
 514   snmp::snmpv3_user { $snmpd_user:
 515     authtype => 'MD5',
 516     authpass => hiera('snmpd_readonly_user_password'),
 517   }
 518   class { 'snmp':
 519     agentaddress => ['udp:161','udp6:[::1]:161'],
 520     snmpd_config => [ join(['rouser ', hiera('snmpd_readonly_user_name')]), 'proc  cron', 'includeAllDisks  10%', 'master agentx', 'trapsink localhost public', 'iquerySecName internalUser', 'rouser internalUser', 'defaultMonitors yes', 'linkUpDownNotifications yes' ],
 521   }
 522
 523 } #END STEP 3