puppet/manifests/overcloud_controller_pacemaker.pp

   1 # Copyright 2015 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 Pcmk_resource <| |> {
  17   tries     => 10,
  18   try_sleep => 3,
  19 }
  20
  21 if !str2bool(hiera('enable_package_install', 'false')) {
  22   case $::osfamily {
  23     'RedHat': {
  24       Package { provider => 'norpm' } # provided by tripleo-puppet
  25     }
  26     default: {
  27       warning('enable_package_install option not supported.')
  28     }
  29   }
  30 }
  31
  32 if $::hostname == downcase(hiera('bootstrap_nodeid')) {
  33   $pacemaker_master = true
  34   $sync_db = true
  35 } else {
  36   $pacemaker_master = false
  37   $sync_db = false
  38 }
  39
  40 $enable_fencing = str2bool(hiera('enable_fencing', 'false')) and hiera('step') >= 5
  41
  42 # When to start and enable services which haven't been Pacemakerized
  43 # FIXME: remove when we start all OpenStack services using Pacemaker
  44 # (occurences of this variable will be gradually replaced with false)
  45 $non_pcmk_start = hiera('step') >= 4
  46
  47 if hiera('step') >= 1 {
  48
  49   create_resources(sysctl::value, hiera('sysctl_settings'), {})
  50
  51   if count(hiera('ntp::servers')) > 0 {
  52     include ::ntp
  53   }
  54
  55   $controller_node_ips = split(hiera('controller_node_ips'), ',')
  56   $controller_node_names = split(downcase(hiera('controller_node_names')), ',')
  57   class { '::tripleo::loadbalancer' :
  58     controller_hosts       => $controller_node_ips,
  59     controller_hosts_names => $controller_node_names,
  60     manage_vip             => false,
  61     mysql_clustercheck     => true,
  62     haproxy_service_manage => false,
  63   }
  64
  65   $pacemaker_cluster_members = downcase(regsubst(hiera('controller_node_names'), ',', ' ', 'G'))
  66   user { 'hacluster':
  67    ensure => present,
  68   } ->
  69   class { '::pacemaker':
  70     hacluster_pwd => hiera('hacluster_pwd'),
  71   } ->
  72   class { '::pacemaker::corosync':
  73     cluster_members => $pacemaker_cluster_members,
  74     setup_cluster   => $pacemaker_master,
  75   }
  76   class { '::pacemaker::stonith':
  77     disable => !$enable_fencing,
  78   }
  79   if $enable_fencing {
  80     include tripleo::fencing
  81
  82     # enable stonith after all fencing devices have been created
  83     Class['tripleo::fencing'] -> Class['pacemaker::stonith']
  84   }
  85
  86   # Only configure RabbitMQ in this step, don't start it yet to
  87   # avoid races where non-master nodes attempt to start without
  88   # config (eg. binding on 0.0.0.0)
  89   # The module ignores erlang_cookie if cluster_config is false
  90   class { '::rabbitmq':
  91     service_manage          => false,
  92     tcp_keepalive           => false,
  93     config_kernel_variables => hiera('rabbitmq_kernel_variables'),
  94     config_variables        => hiera('rabbitmq_config_variables'),
  95     environment_variables   => hiera('rabbitmq_environment'),
  96   } ->
  97   file { '/var/lib/rabbitmq/.erlang.cookie':
  98     ensure  => 'present',
  99     owner   => 'rabbitmq',
 100     group   => 'rabbitmq',
 101     mode    => '0400',
 102     content => hiera('rabbitmq::erlang_cookie'),
 103     replace => true,
 104   }
 105
 106   if downcase(hiera('ceilometer_backend')) == 'mongodb' {
 107     include ::mongodb::globals
 108     class { '::mongodb::server' :
 109       service_manage => false,
 110     }
 111   }
 112
 113   # Memcached
 114   class {'::memcached' :
 115     service_manage => false,
 116   }
 117
 118   # Redis
 119   class { '::redis' :
 120     service_manage => false,
 121     notify_service => false,
 122   }
 123
 124   # Galera
 125   if str2bool(hiera('enable_galera', 'true')) {
 126     $mysql_config_file = '/etc/my.cnf.d/galera.cnf'
 127   } else {
 128     $mysql_config_file = '/etc/my.cnf.d/server.cnf'
 129   }
 130   $galera_nodes = downcase(hiera('galera_node_names', $::hostname))
 131   $galera_nodes_count = count(split($galera_nodes, ','))
 132
 133   $mysqld_options = {
 134     'mysqld' => {
 135       'skip-name-resolve'             => '1',
 136       'binlog_format'                 => 'ROW',
 137       'default-storage-engine'        => 'innodb',
 138       'innodb_autoinc_lock_mode'      => '2',
 139       'innodb_locks_unsafe_for_binlog'=> '1',
 140       'query_cache_size'              => '0',
 141       'query_cache_type'              => '0',
 142       'bind-address'                  => hiera('mysql_bind_host'),
 143       'max_connections'               => hiera('mysql_max_connections'),
 144       'open_files_limit'              => '-1',
 145       'wsrep_provider'                => '/usr/lib64/galera/libgalera_smm.so',
 146       'wsrep_cluster_name'            => 'galera_cluster',
 147       'wsrep_slave_threads'           => '1',
 148       'wsrep_certify_nonPK'           => '1',
 149       'wsrep_max_ws_rows'             => '131072',
 150       'wsrep_max_ws_size'             => '1073741824',
 151       'wsrep_debug'                   => '0',
 152       'wsrep_convert_LOCK_to_trx'     => '0',
 153       'wsrep_retry_autocommit'        => '1',
 154       'wsrep_auto_increment_control'  => '1',
 155       'wsrep_drupal_282555_workaround'=> '0',
 156       'wsrep_causal_reads'            => '0',
 157       'wsrep_notify_cmd'              => '',
 158       'wsrep_sst_method'              => 'rsync',
 159     }
 160   }
 161
 162   class { '::mysql::server':
 163     create_root_user   => false,
 164     create_root_my_cnf => false,
 165     config_file        => $mysql_config_file,
 166     override_options   => $mysqld_options,
 167     service_manage     => false,
 168     service_enabled    => false,
 169   }
 170
 171 }
 172
 173 if hiera('step') >= 2 {
 174
 175   # NOTE(gfidente): the following vars are needed on all nodes so they
 176   # need to stay out of pacemaker_master conditional
 177   $mongo_node_ips_with_port = suffix(hiera('mongo_node_ips'), ':27017')
 178   $mongodb_replset = hiera('mongodb::server::replset')
 179
 180   if $pacemaker_master {
 181
 182     # FIXME: we should not have to access tripleo::loadbalancer class
 183     # parameters here to configure pacemaker VIPs. The configuration
 184     # of pacemaker VIPs could move into puppet-tripleo or we should
 185     # make use of less specific hiera parameters here for the settings.
 186     pacemaker::resource::service { 'haproxy':
 187       clone_params => true,
 188     }
 189
 190     $control_vip = hiera('tripleo::loadbalancer::controller_virtual_ip')
 191     pacemaker::resource::ip { 'control_vip':
 192       ip_address => $control_vip,
 193     }
 194     pacemaker::constraint::base { 'control_vip-then-haproxy':
 195       constraint_type   => 'order',
 196       first_resource    => "ip-${control_vip}",
 197       second_resource   => 'haproxy-clone',
 198       first_action      => 'start',
 199       second_action     => 'start',
 200       constraint_params => 'kind=Optional',
 201       require => [Pacemaker::Resource::Service['haproxy'],
 202                   Pacemaker::Resource::Ip['control_vip']],
 203     }
 204     pacemaker::constraint::colocation { 'control_vip-with-haproxy':
 205       source  => "ip-${control_vip}",
 206       target  => 'haproxy-clone',
 207       score   => 'INFINITY',
 208       require => [Pacemaker::Resource::Service['haproxy'],
 209                   Pacemaker::Resource::Ip['control_vip']],
 210     }
 211
 212     $public_vip = hiera('tripleo::loadbalancer::public_virtual_ip')
 213     if $public_vip and $public_vip != $control_vip {
 214       pacemaker::resource::ip { 'public_vip':
 215         ip_address => $public_vip,
 216       }
 217       pacemaker::constraint::base { 'public_vip-then-haproxy':
 218         constraint_type   => 'order',
 219         first_resource    => "ip-${public_vip}",
 220         second_resource   => 'haproxy-clone',
 221         first_action      => 'start',
 222         second_action     => 'start',
 223         constraint_params => 'kind=Optional',
 224         require => [Pacemaker::Resource::Service['haproxy'],
 225                     Pacemaker::Resource::Ip['public_vip']],
 226       }
 227       pacemaker::constraint::colocation { 'public_vip-with-haproxy':
 228         source  => "ip-${public_vip}",
 229         target  => 'haproxy-clone',
 230         score   => 'INFINITY',
 231         require => [Pacemaker::Resource::Service['haproxy'],
 232                     Pacemaker::Resource::Ip['public_vip']],
 233       }
 234     }
 235
 236     $redis_vip = hiera('redis_vip')
 237     if $redis_vip and $redis_vip != $control_vip {
 238       pacemaker::resource::ip { 'redis_vip':
 239         ip_address => $redis_vip,
 240       }
 241       pacemaker::constraint::base { 'redis_vip-then-haproxy':
 242         constraint_type   => 'order',
 243         first_resource    => "ip-${redis_vip}",
 244         second_resource   => 'haproxy-clone',
 245         first_action      => 'start',
 246         second_action     => 'start',
 247         constraint_params => 'kind=Optional',
 248         require => [Pacemaker::Resource::Service['haproxy'],
 249                     Pacemaker::Resource::Ip['redis_vip']],
 250       }
 251       pacemaker::constraint::colocation { 'redis_vip-with-haproxy':
 252         source  => "ip-${redis_vip}",
 253         target  => 'haproxy-clone',
 254         score   => 'INFINITY',
 255         require => [Pacemaker::Resource::Service['haproxy'],
 256                     Pacemaker::Resource::Ip['redis_vip']],
 257       }
 258     }
 259
 260     $internal_api_vip = hiera('tripleo::loadbalancer::internal_api_virtual_ip')
 261     if $internal_api_vip and $internal_api_vip != $control_vip {
 262       pacemaker::resource::ip { 'internal_api_vip':
 263         ip_address => $internal_api_vip,
 264       }
 265       pacemaker::constraint::base { 'internal_api_vip-then-haproxy':
 266         constraint_type   => 'order',
 267         first_resource    => "ip-${internal_api_vip}",
 268         second_resource   => 'haproxy-clone',
 269         first_action      => 'start',
 270         second_action     => 'start',
 271         constraint_params => 'kind=Optional',
 272         require => [Pacemaker::Resource::Service['haproxy'],
 273                     Pacemaker::Resource::Ip['internal_api_vip']],
 274       }
 275       pacemaker::constraint::colocation { 'internal_api_vip-with-haproxy':
 276         source  => "ip-${internal_api_vip}",
 277         target  => 'haproxy-clone',
 278         score   => 'INFINITY',
 279         require => [Pacemaker::Resource::Service['haproxy'],
 280                     Pacemaker::Resource::Ip['internal_api_vip']],
 281       }
 282     }
 283
 284     $storage_vip = hiera('tripleo::loadbalancer::storage_virtual_ip')
 285     if $storage_vip and $storage_vip != $control_vip {
 286       pacemaker::resource::ip { 'storage_vip':
 287         ip_address => $storage_vip,
 288       }
 289       pacemaker::constraint::base { 'storage_vip-then-haproxy':
 290         constraint_type   => 'order',
 291         first_resource    => "ip-${storage_vip}",
 292         second_resource   => 'haproxy-clone',
 293         first_action      => 'start',
 294         second_action     => 'start',
 295         constraint_params => 'kind=Optional',
 296         require => [Pacemaker::Resource::Service['haproxy'],
 297                     Pacemaker::Resource::Ip['storage_vip']],
 298       }
 299       pacemaker::constraint::colocation { 'storage_vip-with-haproxy':
 300         source  => "ip-${storage_vip}",
 301         target  => 'haproxy-clone',
 302         score   => 'INFINITY',
 303         require => [Pacemaker::Resource::Service['haproxy'],
 304                     Pacemaker::Resource::Ip['storage_vip']],
 305       }
 306     }
 307
 308     $storage_mgmt_vip = hiera('tripleo::loadbalancer::storage_mgmt_virtual_ip')
 309     if $storage_mgmt_vip and $storage_mgmt_vip != $control_vip {
 310       pacemaker::resource::ip { 'storage_mgmt_vip':
 311         ip_address => $storage_mgmt_vip,
 312       }
 313       pacemaker::constraint::base { 'storage_mgmt_vip-then-haproxy':
 314         constraint_type   => 'order',
 315         first_resource    => "ip-${storage_mgmt_vip}",
 316         second_resource   => 'haproxy-clone',
 317         first_action      => 'start',
 318         second_action     => 'start',
 319         constraint_params => 'kind=Optional',
 320         require => [Pacemaker::Resource::Service['haproxy'],
 321                     Pacemaker::Resource::Ip['storage_mgmt_vip']],
 322       }
 323       pacemaker::constraint::colocation { 'storage_mgmt_vip-with-haproxy':
 324         source  => "ip-${storage_mgmt_vip}",
 325         target  => 'haproxy-clone',
 326         score   => 'INFINITY',
 327         require => [Pacemaker::Resource::Service['haproxy'],
 328                     Pacemaker::Resource::Ip['storage_mgmt_vip']],
 329       }
 330     }
 331
 332     pacemaker::resource::service { $::memcached::params::service_name :
 333       clone_params => true,
 334       require      => Class['::memcached'],
 335     }
 336
 337     pacemaker::resource::ocf { 'rabbitmq':
 338       ocf_agent_name  => 'heartbeat:rabbitmq-cluster',
 339       resource_params => 'set_policy=\'ha-all ^(?!amq\.).* {"ha-mode":"all"}\'',
 340       clone_params    => 'ordered=true interleave=true',
 341       require         => Class['::rabbitmq'],
 342     }
 343
 344     if downcase(hiera('ceilometer_backend')) == 'mongodb' {
 345       pacemaker::resource::service { $::mongodb::params::service_name :
 346         op_params    => 'start timeout=120s',
 347         clone_params => true,
 348         require      => Class['::mongodb::server'],
 349       }
 350       # NOTE (spredzy) : The replset can only be run
 351       # once all the nodes have joined the cluster.
 352       mongodb_conn_validator { $mongo_node_ips_with_port :
 353         timeout => '600',
 354         require => Pacemaker::Resource::Service[$::mongodb::params::service_name],
 355         before  => Mongodb_replset[$mongodb_replset],
 356       }
 357       mongodb_replset { $mongodb_replset :
 358         members => $mongo_node_ips_with_port,
 359       }
 360     }
 361
 362     pacemaker::resource::ocf { 'galera' :
 363       ocf_agent_name  => 'heartbeat:galera',
 364       op_params       => 'promote timeout=300s on-fail=block',
 365       master_params   => '',
 366       meta_params     => "master-max=${galera_nodes_count} ordered=true",
 367       resource_params => "additional_parameters='--open-files-limit=16384' enable_creation=true wsrep_cluster_address='gcomm://${galera_nodes}'",
 368       require         => Class['::mysql::server'],
 369       before          => Exec['galera-ready'],
 370     }
 371
 372     pacemaker::resource::ocf { 'redis':
 373       ocf_agent_name  => 'heartbeat:redis',
 374       master_params   => '',
 375       meta_params     => 'notify=true ordered=true interleave=true',
 376       resource_params => 'wait_last_known_master=true',
 377       require         => Class['::redis'],
 378     }
 379
 380   }
 381
 382   exec { 'galera-ready' :
 383     command     => '/usr/bin/clustercheck >/dev/null',
 384     timeout     => 30,
 385     tries       => 180,
 386     try_sleep   => 10,
 387     environment => ["AVAILABLE_WHEN_READONLY=0"],
 388     require     => File['/etc/sysconfig/clustercheck'],
 389   }
 390
 391   file { '/etc/sysconfig/clustercheck' :
 392     ensure  => file,
 393     content => "MYSQL_USERNAME=root\n
 394 MYSQL_PASSWORD=''\n
 395 MYSQL_HOST=localhost\n",
 396   }
 397
 398   xinetd::service { 'galera-monitor' :
 399     port           => '9200',
 400     server         => '/usr/bin/clustercheck',
 401     per_source     => 'UNLIMITED',
 402     log_on_success => '',
 403     log_on_failure => 'HOST',
 404     flags          => 'REUSE',
 405     service_type   => 'UNLISTED',
 406     user           => 'root',
 407     group          => 'root',
 408     require        => File['/etc/sysconfig/clustercheck'],
 409   }
 410
 411   # Create all the database schemas
 412   # Example DSN format: mysql://user:password@host/dbname
 413   if $sync_db {
 414     $allowed_hosts = ['%',hiera('mysql_bind_host')]
 415     $keystone_dsn = split(hiera('keystone::database_connection'), '[@:/?]')
 416     class { 'keystone::db::mysql':
 417       user          => $keystone_dsn[3],
 418       password      => $keystone_dsn[4],
 419       host          => $keystone_dsn[5],
 420       dbname        => $keystone_dsn[6],
 421       allowed_hosts => $allowed_hosts,
 422       require       => Exec['galera-ready'],
 423     }
 424     $glance_dsn = split(hiera('glance::api::database_connection'), '[@:/?]')
 425     class { 'glance::db::mysql':
 426       user          => $glance_dsn[3],
 427       password      => $glance_dsn[4],
 428       host          => $glance_dsn[5],
 429       dbname        => $glance_dsn[6],
 430       allowed_hosts => $allowed_hosts,
 431       require       => Exec['galera-ready'],
 432     }
 433     $nova_dsn = split(hiera('nova::database_connection'), '[@:/?]')
 434     class { 'nova::db::mysql':
 435       user          => $nova_dsn[3],
 436       password      => $nova_dsn[4],
 437       host          => $nova_dsn[5],
 438       dbname        => $nova_dsn[6],
 439       allowed_hosts => $allowed_hosts,
 440       require       => Exec['galera-ready'],
 441     }
 442     $neutron_dsn = split(hiera('neutron::server::database_connection'), '[@:/?]')
 443     class { 'neutron::db::mysql':
 444       user          => $neutron_dsn[3],
 445       password      => $neutron_dsn[4],
 446       host          => $neutron_dsn[5],
 447       dbname        => $neutron_dsn[6],
 448       allowed_hosts => $allowed_hosts,
 449       require       => Exec['galera-ready'],
 450     }
 451     $cinder_dsn = split(hiera('cinder::database_connection'), '[@:/?]')
 452     class { 'cinder::db::mysql':
 453       user          => $cinder_dsn[3],
 454       password      => $cinder_dsn[4],
 455       host          => $cinder_dsn[5],
 456       dbname        => $cinder_dsn[6],
 457       allowed_hosts => $allowed_hosts,
 458       require       => Exec['galera-ready'],
 459     }
 460     $heat_dsn = split(hiera('heat::database_connection'), '[@:/?]')
 461     class { 'heat::db::mysql':
 462       user          => $heat_dsn[3],
 463       password      => $heat_dsn[4],
 464       host          => $heat_dsn[5],
 465       dbname        => $heat_dsn[6],
 466       allowed_hosts => $allowed_hosts,
 467       require       => Exec['galera-ready'],
 468     }
 469     if downcase(hiera('ceilometer_backend')) == 'mysql' {
 470       $ceilometer_dsn = split(hiera('ceilometer_mysql_conn_string'), '[@:/?]')
 471       class { 'ceilometer::db::mysql':
 472         user          => $ceilometer_dsn[3],
 473         password      => $ceilometer_dsn[4],
 474         host          => $ceilometer_dsn[5],
 475         dbname        => $ceilometer_dsn[6],
 476         allowed_hosts => $allowed_hosts,
 477         require       => Exec['galera-ready'],
 478       }
 479     }
 480   }
 481
 482   # pre-install swift here so we can build rings
 483   include ::swift
 484
 485   # Ceph
 486   $cinder_enable_rbd_backend = hiera('cinder_enable_rbd_backend', false)
 487   $enable_ceph = $cinder_enable_rbd_backend
 488
 489   if $enable_ceph {
 490     class { 'ceph::profile::params':
 491       mon_initial_members => downcase(hiera('ceph_mon_initial_members'))
 492     }
 493     include ::ceph::profile::mon
 494   }
 495
 496   if str2bool(hiera('enable_ceph_storage', 'false')) {
 497     include ::ceph::profile::client
 498     include ::ceph::profile::osd
 499   }
 500
 501
 502 } #END STEP 2
 503
 504 if hiera('step') >= 3 {
 505
 506   class { '::keystone':
 507     sync_db => $sync_db,
 508     manage_service => false,
 509     enabled => false,
 510   }
 511
 512   #TODO: need a cleanup-keystone-tokens.sh solution here
 513   keystone_config {
 514     'ec2/driver': value => 'keystone.contrib.ec2.backends.sql.Ec2';
 515   }
 516   file { [ '/etc/keystone/ssl', '/etc/keystone/ssl/certs', '/etc/keystone/ssl/private' ]:
 517     ensure  => 'directory',
 518     owner   => 'keystone',
 519     group   => 'keystone',
 520     require => Package['keystone'],
 521   }
 522   file { '/etc/keystone/ssl/certs/signing_cert.pem':
 523     content => hiera('keystone_signing_certificate'),
 524     owner   => 'keystone',
 525     group   => 'keystone',
 526     notify  => Service['keystone'],
 527     require => File['/etc/keystone/ssl/certs'],
 528   }
 529   file { '/etc/keystone/ssl/private/signing_key.pem':
 530     content => hiera('keystone_signing_key'),
 531     owner   => 'keystone',
 532     group   => 'keystone',
 533     notify  => Service['keystone'],
 534     require => File['/etc/keystone/ssl/private'],
 535   }
 536   file { '/etc/keystone/ssl/certs/ca.pem':
 537     content => hiera('keystone_ca_certificate'),
 538     owner   => 'keystone',
 539     group   => 'keystone',
 540     notify  => Service['keystone'],
 541     require => File['/etc/keystone/ssl/certs'],
 542   }
 543
 544   $glance_backend = downcase(hiera('glance_backend', 'swift'))
 545   case $glance_backend {
 546       swift: { $backend_store = 'glance.store.swift.Store' }
 547       file: { $backend_store = 'glance.store.filesystem.Store' }
 548       rbd: { $backend_store = 'glance.store.rbd.Store' }
 549       default: { fail('Unrecognized glance_backend parameter.') }
 550   }
 551   $http_store = ['glance.store.http.Store']
 552   $glance_store = concat($http_store, $backend_store)
 553
 554   # TODO: notifications, scrubber, etc.
 555   include ::glance
 556   class { 'glance::api':
 557     known_stores => $glance_store,
 558     manage_service => false,
 559     enabled => false,
 560   }
 561   class { '::glance::registry' :
 562     sync_db => $sync_db,
 563     manage_service => false,
 564     enabled => false,
 565   }
 566   include join(['::glance::backend::', $glance_backend])
 567
 568   include ::nova
 569
 570   class { '::nova::api' :
 571     sync_db => $sync_db,
 572     manage_service => false,
 573     enabled => false,
 574   }
 575   class { '::nova::cert' :
 576     manage_service => false,
 577     enabled => false,
 578   }
 579   class { '::nova::conductor' :
 580     manage_service => false,
 581     enabled => false,
 582   }
 583   class { '::nova::consoleauth' :
 584     manage_service => false,
 585     enabled => false,
 586   }
 587   class { '::nova::vncproxy' :
 588     manage_service => false,
 589     enabled => false,
 590   }
 591   class { '::nova::scheduler' :
 592     manage_service => false,
 593     enabled => false,
 594   }
 595   include ::nova::network::neutron
 596
 597   # Neutron class definitions
 598   include ::neutron
 599   class { '::neutron::server' :
 600     sync_db => $sync_db,
 601     manage_service => false,
 602     enabled => false,
 603   }
 604   class { '::neutron::agents::dhcp' :
 605     manage_service => false,
 606     enabled => false,
 607   }
 608   class { '::neutron::agents::l3' :
 609     manage_service => false,
 610     enabled => false,
 611   }
 612   class { 'neutron::agents::metadata':
 613     manage_service => false,
 614     enabled => false,
 615   }
 616   file { '/etc/neutron/dnsmasq-neutron.conf':
 617     content => hiera('neutron_dnsmasq_options'),
 618     owner   => 'neutron',
 619     group   => 'neutron',
 620     notify  => Service['neutron-dhcp-service'],
 621     require => Package['neutron'],
 622   }
 623   class { 'neutron::plugins::ml2':
 624     flat_networks   => split(hiera('neutron_flat_networks'), ','),
 625     tenant_network_types => [hiera('neutron_tenant_network_type')],
 626   }
 627   class { 'neutron::agents::ml2::ovs':
 628     # manage_service   => false # not implemented
 629     enabled          => false,
 630     bridge_mappings  => split(hiera('neutron_bridge_mappings'), ','),
 631     tunnel_types     => split(hiera('neutron_tunnel_types'), ','),
 632   }
 633
 634   include ::cinder
 635   class { '::cinder::api':
 636     sync_db => $sync_db,
 637     manage_service => false,
 638     enabled => false,
 639   }
 640   class { '::cinder::scheduler' :
 641     manage_service => false,
 642     enabled => false,
 643   }
 644   class { '::cinder::volume' :
 645     manage_service => false,
 646     enabled => false,
 647   }
 648   include ::cinder::glance
 649   class {'cinder::setup_test_volume':
 650     size => join([hiera('cinder_lvm_loop_device_size'), 'M']),
 651   }
 652
 653   $cinder_enable_iscsi = hiera('cinder_enable_iscsi_backend', true)
 654   if $cinder_enable_iscsi {
 655     $cinder_iscsi_backend = 'tripleo_iscsi'
 656
 657     cinder::backend::iscsi { $cinder_iscsi_backend :
 658       iscsi_ip_address => hiera('cinder_iscsi_ip_address'),
 659       iscsi_helper     => hiera('cinder_iscsi_helper'),
 660     }
 661   }
 662
 663   if $enable_ceph {
 664
 665     Ceph_pool {
 666       pg_num  => hiera('ceph::profile::params::osd_pool_default_pg_num'),
 667       pgp_num => hiera('ceph::profile::params::osd_pool_default_pgp_num'),
 668       size    => hiera('ceph::profile::params::osd_pool_default_size'),
 669     }
 670
 671     $ceph_pools = hiera('ceph_pools')
 672     ceph::pool { $ceph_pools : }
 673   }
 674
 675   if $cinder_enable_rbd_backend {
 676     $cinder_rbd_backend = 'tripleo_ceph'
 677
 678     cinder_config {
 679       "${cinder_rbd_backend}/host": value => 'hostgroup';
 680     }
 681
 682     cinder::backend::rbd { $cinder_rbd_backend :
 683       rbd_pool        => 'volumes',
 684       rbd_user        => 'openstack',
 685       rbd_secret_uuid => hiera('ceph::profile::params::fsid'),
 686       require         => Ceph::Pool['volumes'],
 687     }
 688   }
 689
 690   if hiera('cinder_enable_netapp_backend', false) {
 691     $cinder_netapp_backend = hiera('cinder::backend::netapp::title')
 692
 693     cinder_config {
 694       "${cinder_netapp_backend}/host": value => 'hostgroup';
 695     }
 696
 697     if hiera('cinder_netapp_nfs_shares', undef) {
 698       $cinder_netapp_nfs_shares = split(hiera('cinder_netapp_nfs_shares', undef), ',')
 699     }
 700
 701     cinder::backend::netapp { $cinder_netapp_backend :
 702       nfs_shares => $cinder_netapp_nfs_shares,
 703     }
 704   }
 705
 706   $cinder_enabled_backends = delete_undef_values([$cinder_iscsi_backend, $cinder_rbd_backend, $cinder_netapp_backend])
 707   class { '::cinder::backends' :
 708     enabled_backends => $cinder_enabled_backends,
 709   }
 710
 711   # swift proxy
 712   class { '::swift::proxy' :
 713     manage_service => $non_pcmk_start,
 714     enabled => $non_pcmk_start,
 715   }
 716   include ::swift::proxy::proxy_logging
 717   include ::swift::proxy::healthcheck
 718   include ::swift::proxy::cache
 719   include ::swift::proxy::keystone
 720   include ::swift::proxy::authtoken
 721   include ::swift::proxy::staticweb
 722   include ::swift::proxy::ratelimit
 723   include ::swift::proxy::catch_errors
 724   include ::swift::proxy::tempurl
 725   include ::swift::proxy::formpost
 726
 727   # swift storage
 728   if str2bool(hiera('enable_swift_storage', 'true')) {
 729     class {'::swift::storage::all':
 730       mount_check => str2bool(hiera('swift_mount_check'))
 731     }
 732     class {'::swift::storage::account':
 733       manage_service => $non_pcmk_start,
 734       enabled => $non_pcmk_start,
 735     }
 736     class {'::swift::storage::container':
 737       manage_service => $non_pcmk_start,
 738       enabled => $non_pcmk_start,
 739     }
 740     class {'::swift::storage::object':
 741       manage_service => $non_pcmk_start,
 742       enabled => $non_pcmk_start,
 743     }
 744     if(!defined(File['/srv/node'])) {
 745       file { '/srv/node':
 746         ensure  => directory,
 747         owner   => 'swift',
 748         group   => 'swift',
 749         require => Package['openstack-swift'],
 750       }
 751     }
 752     $swift_components = ['account', 'container', 'object']
 753     swift::storage::filter::recon { $swift_components : }
 754     swift::storage::filter::healthcheck { $swift_components : }
 755   }
 756
 757   # Ceilometer
 758   $ceilometer_backend = downcase(hiera('ceilometer_backend'))
 759   case $ceilometer_backend {
 760     /mysql/ : {
 761       $ceilometer_database_connection = hiera('ceilometer_mysql_conn_string')
 762     }
 763     default : {
 764       $mongo_node_string = join($mongo_node_ips_with_port, ',')
 765       $ceilometer_database_connection = "mongodb://${mongo_node_string}/ceilometer?replicaSet=${mongodb_replset}"
 766     }
 767   }
 768   include ::ceilometer
 769   class { '::ceilometer::api' :
 770     manage_service => false,
 771     enabled => false,
 772   }
 773   class { '::ceilometer::agent::notification' :
 774     manage_service => false,
 775     enabled => false,
 776   }
 777   class { '::ceilometer::agent::central' :
 778     manage_service => false,
 779     enabled => false,
 780   }
 781   class { '::ceilometer::alarm::notifier' :
 782     manage_service => false,
 783     enabled => false,
 784   }
 785   class { '::ceilometer::alarm::evaluator' :
 786     manage_service => false,
 787     enabled => false,
 788   }
 789   class { '::ceilometer::collector' :
 790     manage_service => false,
 791     enabled => false,
 792   }
 793   include ::ceilometer::expirer
 794   class { '::ceilometer::db' :
 795     database_connection => $ceilometer_database_connection,
 796     sync_db             => $sync_db,
 797   }
 798   include ceilometer::agent::auth
 799
 800   Cron <| title == 'ceilometer-expirer' |> { command => "sleep $((\$(od -A n -t d -N 3 /dev/urandom) % 86400)) && ${::ceilometer::params::expirer_command}" }
 801
 802   # Heat
 803   class { '::heat' :
 804     sync_db => $sync_db,
 805   }
 806   class { '::heat::api' :
 807     manage_service => false,
 808     enabled => false,
 809   }
 810   class { '::heat::api_cfn' :
 811     manage_service => false,
 812     enabled => false,
 813   }
 814   class { '::heat::api_cloudwatch' :
 815     manage_service => false,
 816     enabled => false,
 817   }
 818   class { '::heat::engine' :
 819     manage_service => false,
 820     enabled => false,
 821   }
 822
 823   # httpd/apache and horizon
 824   # NOTE(gfidente): server-status can be consumed by the pacemaker resource agent
 825   include ::apache
 826   include ::apache::mod::status
 827   $vhost_params = {
 828     add_listen => false,
 829     priority   => 10,
 830   }
 831   class { 'horizon':
 832     cache_server_ip    => hiera('memcache_node_ips', '127.0.0.1'),
 833     vhost_extra_params => $vhost_params,
 834     server_aliases     => $::hostname,
 835   }
 836
 837   $snmpd_user = hiera('snmpd_readonly_user_name')
 838   snmp::snmpv3_user { $snmpd_user:
 839     authtype => 'MD5',
 840     authpass => hiera('snmpd_readonly_user_password'),
 841   }
 842   class { 'snmp':
 843     agentaddress => ['udp:161','udp6:[::1]:161'],
 844     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' ],
 845   }
 846
 847   hiera_include('controller_classes')
 848
 849 } #END STEP 3
 850
 851 if hiera('step') >= 4 {
 852   if $pacemaker_master {
 853
 854     # Keystone
 855     pacemaker::resource::service { $::keystone::params::service_name :
 856       clone_params => "interleave=true",
 857     }
 858
 859     # Cinder
 860     pacemaker::resource::service { $::cinder::params::api_service :
 861       clone_params => "interleave=true",
 862       require      => Pacemaker::Resource::Service[$::keystone::params::service_name],
 863     }
 864     pacemaker::resource::service { $::cinder::params::scheduler_service :
 865       clone_params => "interleave=true",
 866     }
 867     pacemaker::resource::service { $::cinder::params::volume_service : }
 868
 869     pacemaker::constraint::base { 'keystone-then-cinder-api-constraint':
 870       constraint_type => 'order',
 871       first_resource  => "${::keystone::params::service_name}-clone",
 872       second_resource => "${::cinder::params::api_service}-clone",
 873       first_action    => 'start',
 874       second_action   => 'start',
 875       require         => [Pacemaker::Resource::Service[$::cinder::params::api_service],
 876                           Pacemaker::Resource::Service[$::keystone::params::service_name]],
 877     }
 878     pacemaker::constraint::base { 'cinder-api-then-cinder-scheduler-constraint':
 879       constraint_type => "order",
 880       first_resource => "${::cinder::params::api_service}-clone",
 881       second_resource => "${::cinder::params::scheduler_service}-clone",
 882       first_action => "start",
 883       second_action => "start",
 884       require => [Pacemaker::Resource::Service[$::cinder::params::api_service],
 885                   Pacemaker::Resource::Service[$::cinder::params::scheduler_service]],
 886     }
 887     pacemaker::constraint::colocation { 'cinder-scheduler-with-cinder-api-colocation':
 888       source => "${::cinder::params::scheduler_service}-clone",
 889       target => "${::cinder::params::api_service}-clone",
 890       score => "INFINITY",
 891       require => [Pacemaker::Resource::Service[$::cinder::params::api_service],
 892                   Pacemaker::Resource::Service[$::cinder::params::scheduler_service]],
 893     }
 894     pacemaker::constraint::base { 'cinder-scheduler-then-cinder-volume-constraint':
 895       constraint_type => "order",
 896       first_resource => "${::cinder::params::scheduler_service}-clone",
 897       second_resource => "${::cinder::params::volume_service}",
 898       first_action => "start",
 899       second_action => "start",
 900       require => [Pacemaker::Resource::Service[$::cinder::params::scheduler_service],
 901                   Pacemaker::Resource::Service[$::cinder::params::volume_service]],
 902     }
 903     pacemaker::constraint::colocation { 'cinder-volume-with-cinder-scheduler-colocation':
 904       source => "${::cinder::params::volume_service}",
 905       target => "${::cinder::params::scheduler_service}-clone",
 906       score => "INFINITY",
 907       require => [Pacemaker::Resource::Service[$::cinder::params::scheduler_service],
 908                   Pacemaker::Resource::Service[$::cinder::params::volume_service]],
 909     }
 910
 911     # Glance
 912     pacemaker::resource::service { $::glance::params::registry_service_name :
 913       clone_params => "interleave=true",
 914       require      => Pacemaker::Resource::Service[$::keystone::params::service_name],
 915     }
 916     pacemaker::resource::service { $::glance::params::api_service_name :
 917       clone_params => "interleave=true",
 918     }
 919
 920     pacemaker::constraint::base { 'keystone-then-glance-registry-constraint':
 921       constraint_type => 'order',
 922       first_resource  => "${::keystone::params::service_name}-clone",
 923       second_resource => "${::glance::params::registry_service_name}-clone",
 924       first_action    => 'start',
 925       second_action   => 'start',
 926       require         => [Pacemaker::Resource::Service[$::glance::params::registry_service_name],
 927                           Pacemaker::Resource::Service[$::keystone::params::service_name]],
 928     }
 929     pacemaker::constraint::base { 'glance-registry-then-glance-api-constraint':
 930       constraint_type => "order",
 931       first_resource  => "${::glance::params::registry_service_name}-clone",
 932       second_resource => "${::glance::params::api_service_name}-clone",
 933       first_action    => "start",
 934       second_action   => "start",
 935       require => [Pacemaker::Resource::Service[$::glance::params::registry_service_name],
 936                   Pacemaker::Resource::Service[$::glance::params::api_service_name]],
 937     }
 938     pacemaker::constraint::colocation { 'glance-api-with-glance-registry-colocation':
 939       source  => "${::glance::params::api_service_name}-clone",
 940       target  => "${::glance::params::registry_service_name}-clone",
 941       score   => "INFINITY",
 942       require => [Pacemaker::Resource::Service[$::glance::params::registry_service_name],
 943                   Pacemaker::Resource::Service[$::glance::params::api_service_name]],
 944     }
 945
 946     # Neutron
 947     # NOTE(gfidente): Neutron will try to populate the database with some data
 948     # as soon as neutron-server is started; to avoid races we want to make this
 949     # happen only on one node, before normal Pacemaker initialization
 950     # https://bugzilla.redhat.com/show_bug.cgi?id=1233061
 951     exec { '/usr/bin/systemctl start neutron-server && /usr/bin/sleep 5' : } ->
 952     pacemaker::resource::service { $::neutron::params::server_service:
 953       op_params => "start timeout=90",
 954       clone_params   => "interleave=true",
 955       require => Pacemaker::Resource::Service[$::keystone::params::service_name]
 956     }
 957     pacemaker::resource::service { $::neutron::params::l3_agent_service:
 958       clone_params   => "interleave=true",
 959     }
 960     pacemaker::resource::service { $::neutron::params::dhcp_agent_service:
 961       clone_params   => "interleave=true",
 962     }
 963     pacemaker::resource::service { $::neutron::params::ovs_agent_service:
 964       clone_params => "interleave=true",
 965     }
 966     pacemaker::resource::service { $::neutron::params::metadata_agent_service:
 967       clone_params => "interleave=true",
 968     }
 969     pacemaker::resource::ocf { $::neutron::params::ovs_cleanup_service:
 970       ocf_agent_name => "neutron:OVSCleanup",
 971       clone_params => "interleave=true",
 972     }
 973     pacemaker::resource::ocf { 'neutron-netns-cleanup':
 974       ocf_agent_name => "neutron:NetnsCleanup",
 975       clone_params => "interleave=true",
 976     }
 977     pacemaker::resource::ocf { 'neutron-scale':
 978       ocf_agent_name => "neutron:NeutronScale",
 979       clone_params => "globally-unique=true clone-max=3 interleave=true",
 980     }
 981     pacemaker::constraint::base { 'keystone-to-neutron-server-constraint':
 982       constraint_type => "order",
 983       first_resource => "${::keystone::params::service_name}-clone",
 984       second_resource => "${::neutron::params::server_service}-clone",
 985       first_action => "start",
 986       second_action => "start",
 987       require => [Pacemaker::Resource::Service[$::keystone::params::service_name],
 988                   Pacemaker::Resource::Service[$::neutron::params::server_service]],
 989     }
 990     pacemaker::constraint::base { 'neutron-server-to-neutron-scale-constraint':
 991       constraint_type => "order",
 992       first_resource => "${::neutron::params::server_service}-clone",
 993       second_resource => "neutron-scale-clone",
 994       first_action => "start",
 995       second_action => "start",
 996       require => [Pacemaker::Resource::Service[$::neutron::params::server_service],
 997                   Pacemaker::Resource::Ocf['neutron-scale']],
 998     }
 999     pacemaker::constraint::base { 'neutron-scale-to-ovs-cleanup-constraint':
1000       constraint_type => "order",
1001       first_resource => "neutron-scale-clone",
1002       second_resource => "${::neutron::params::ovs_cleanup_service}-clone",
1003       first_action => "start",
1004       second_action => "start",
1005       require => [Pacemaker::Resource::Ocf['neutron-scale'],
1006                   Pacemaker::Resource::Ocf["${::neutron::params::ovs_cleanup_service}"]],
1007     }
1008     pacemaker::constraint::colocation { 'neutron-scale-to-ovs-cleanup-colocation':
1009       source => "${::neutron::params::ovs_cleanup_service}-clone",
1010       target => "neutron-scale-clone",
1011       score => "INFINITY",
1012       require => [Pacemaker::Resource::Ocf['neutron-scale'],
1013                   Pacemaker::Resource::Ocf["${::neutron::params::ovs_cleanup_service}"]],
1014     }
1015     pacemaker::constraint::base { 'neutron-ovs-cleanup-to-netns-cleanup-constraint':
1016       constraint_type => "order",
1017       first_resource => "${::neutron::params::ovs_cleanup_service}-clone",
1018       second_resource => "neutron-netns-cleanup-clone",
1019       first_action => "start",
1020       second_action => "start",
1021       require => [Pacemaker::Resource::Ocf["${::neutron::params::ovs_cleanup_service}"],
1022                   Pacemaker::Resource::Ocf['neutron-netns-cleanup']],
1023     }
1024     pacemaker::constraint::colocation { 'neutron-ovs-cleanup-to-netns-cleanup-colocation':
1025       source => "neutron-netns-cleanup-clone",
1026       target => "${::neutron::params::ovs_cleanup_service}-clone",
1027       score => "INFINITY",
1028       require => [Pacemaker::Resource::Ocf["${::neutron::params::ovs_cleanup_service}"],
1029                   Pacemaker::Resource::Ocf['neutron-netns-cleanup']],
1030     }
1031     pacemaker::constraint::base { 'neutron-netns-cleanup-to-openvswitch-agent-constraint':
1032       constraint_type => "order",
1033       first_resource => "neutron-netns-cleanup-clone",
1034       second_resource => "${::neutron::params::ovs_agent_service}-clone",
1035       first_action => "start",
1036       second_action => "start",
1037       require => [Pacemaker::Resource::Ocf["neutron-netns-cleanup"],
1038                   Pacemaker::Resource::Service["${::neutron::params::ovs_agent_service}"]],
1039     }
1040     pacemaker::constraint::colocation { 'neutron-netns-cleanup-to-openvswitch-agent-colocation':
1041       source => "${::neutron::params::ovs_agent_service}-clone",
1042       target => "neutron-netns-cleanup-clone",
1043       score => "INFINITY",
1044       require => [Pacemaker::Resource::Ocf["neutron-netns-cleanup"],
1045                   Pacemaker::Resource::Service["${::neutron::params::ovs_agent_service}"]],
1046     }
1047     pacemaker::constraint::base { 'neutron-openvswitch-agent-to-dhcp-agent-constraint':
1048       constraint_type => "order",
1049       first_resource => "${::neutron::params::ovs_agent_service}-clone",
1050       second_resource => "${::neutron::params::dhcp_agent_service}-clone",
1051       first_action => "start",
1052       second_action => "start",
1053       require => [Pacemaker::Resource::Service["${::neutron::params::ovs_agent_service}"],
1054                   Pacemaker::Resource::Service["${::neutron::params::dhcp_agent_service}"]],
1055
1056     }
1057     pacemaker::constraint::colocation { 'neutron-openvswitch-agent-to-dhcp-agent-colocation':
1058       source => "${::neutron::params::dhcp_agent_service}-clone",
1059       target => "${::neutron::params::ovs_agent_service}-clone",
1060       score => "INFINITY",
1061       require => [Pacemaker::Resource::Service["${::neutron::params::ovs_agent_service}"],
1062                   Pacemaker::Resource::Service["${::neutron::params::dhcp_agent_service}"]],
1063     }
1064     pacemaker::constraint::base { 'neutron-dhcp-agent-to-l3-agent-constraint':
1065       constraint_type => "order",
1066       first_resource => "${::neutron::params::dhcp_agent_service}-clone",
1067       second_resource => "${::neutron::params::l3_agent_service}-clone",
1068       first_action => "start",
1069       second_action => "start",
1070       require => [Pacemaker::Resource::Service["${::neutron::params::dhcp_agent_service}"],
1071                   Pacemaker::Resource::Service["${::neutron::params::l3_agent_service}"]]
1072     }
1073     pacemaker::constraint::colocation { 'neutron-dhcp-agent-to-l3-agent-colocation':
1074       source => "${::neutron::params::l3_agent_service}-clone",
1075       target => "${::neutron::params::dhcp_agent_service}-clone",
1076       score => "INFINITY",
1077       require => [Pacemaker::Resource::Service["${::neutron::params::dhcp_agent_service}"],
1078                   Pacemaker::Resource::Service["${::neutron::params::l3_agent_service}"]]
1079     }
1080     pacemaker::constraint::base { 'neutron-l3-agent-to-metadata-agent-constraint':
1081       constraint_type => "order",
1082       first_resource => "${::neutron::params::l3_agent_service}-clone",
1083       second_resource => "${::neutron::params::metadata_agent_service}-clone",
1084       first_action => "start",
1085       second_action => "start",
1086       require => [Pacemaker::Resource::Service["${::neutron::params::l3_agent_service}"],
1087                   Pacemaker::Resource::Service["${::neutron::params::metadata_agent_service}"]]
1088     }
1089     pacemaker::constraint::colocation { 'neutron-l3-agent-to-metadata-agent-colocation':
1090       source => "${::neutron::params::metadata_agent_service}-clone",
1091       target => "${::neutron::params::l3_agent_service}-clone",
1092       score => "INFINITY",
1093       require => [Pacemaker::Resource::Service["${::neutron::params::l3_agent_service}"],
1094                   Pacemaker::Resource::Service["${::neutron::params::metadata_agent_service}"]]
1095     }
1096
1097     # Nova
1098     pacemaker::resource::service { $::nova::params::api_service_name :
1099       clone_params    => "interleave=true",
1100       op_params       => "monitor start-delay=10s",
1101     }
1102     pacemaker::resource::service { $::nova::params::conductor_service_name :
1103       clone_params    => "interleave=true",
1104       op_params       => "monitor start-delay=10s",
1105     }
1106     pacemaker::resource::service { $::nova::params::consoleauth_service_name :
1107       clone_params    => "interleave=true",
1108       op_params       => "monitor start-delay=10s",
1109       require         => Pacemaker::Resource::Service[$::keystone::params::service_name],
1110     }
1111     pacemaker::resource::service { $::nova::params::vncproxy_service_name :
1112       clone_params    => "interleave=true",
1113       op_params       => "monitor start-delay=10s",
1114     }
1115     pacemaker::resource::service { $::nova::params::scheduler_service_name :
1116       clone_params    => "interleave=true",
1117       op_params       => "monitor start-delay=10s",
1118     }
1119
1120     pacemaker::constraint::base { 'keystone-then-nova-consoleauth-constraint':
1121       constraint_type => 'order',
1122       first_resource  => "${::keystone::params::service_name}-clone",
1123       second_resource => "${::nova::params::consoleauth_service_name}-clone",
1124       first_action    => 'start',
1125       second_action   => 'start',
1126       require         => [Pacemaker::Resource::Service[$::nova::params::consoleauth_service_name],
1127                           Pacemaker::Resource::Service[$::keystone::params::service_name]],
1128     }
1129     pacemaker::constraint::base { 'nova-consoleauth-then-nova-vncproxy-constraint':
1130       constraint_type => "order",
1131       first_resource  => "${::nova::params::consoleauth_service_name}-clone",
1132       second_resource => "${::nova::params::vncproxy_service_name}-clone",
1133       first_action    => "start",
1134       second_action   => "start",
1135       require => [Pacemaker::Resource::Service[$::nova::params::consoleauth_service_name],
1136                   Pacemaker::Resource::Service[$::nova::params::vncproxy_service_name]],
1137     }
1138     pacemaker::constraint::colocation { 'nova-vncproxy-with-nova-consoleauth-colocation':
1139       source => "${::nova::params::vncproxy_service_name}-clone",
1140       target => "${::nova::params::consoleauth_service_name}-clone",
1141       score => "INFINITY",
1142       require => [Pacemaker::Resource::Service[$::nova::params::consoleauth_service_name],
1143                   Pacemaker::Resource::Service[$::nova::params::vncproxy_service_name]],
1144     }
1145     # FIXME(gfidente): novncproxy will not start unless websockify is updated to 0.6
1146     # which is not the case for f20 nor f21; ucomment when it becomes available
1147     #pacemaker::constraint::base { 'nova-vncproxy-then-nova-api-constraint':
1148     #  constraint_type => "order",
1149     #  first_resource  => "${::nova::params::vncproxy_service_name}-clone",
1150     #  second_resource => "${::nova::params::api_service_name}-clone",
1151     #  first_action    => "start",
1152     #  second_action   => "start",
1153     #  require => [Pacemaker::Resource::Service[$::nova::params::vncproxy_service_name],
1154     #              Pacemaker::Resource::Service[$::nova::params::api_service_name]],
1155     #}
1156     #pacemaker::constraint::colocation { 'nova-api-with-nova-vncproxy-colocation':
1157     #  source => "${::nova::params::api_service_name}-clone",
1158     #  target => "${::nova::params::vncproxy_service_name}-clone",
1159     #  score => "INFINITY",
1160     #  require => [Pacemaker::Resource::Service[$::nova::params::vncproxy_service_name],
1161     #              Pacemaker::Resource::Service[$::nova::params::api_service_name]],
1162     #}
1163     pacemaker::constraint::base { 'nova-api-then-nova-scheduler-constraint':
1164       constraint_type => "order",
1165       first_resource  => "${::nova::params::api_service_name}-clone",
1166       second_resource => "${::nova::params::scheduler_service_name}-clone",
1167       first_action    => "start",
1168       second_action   => "start",
1169       require => [Pacemaker::Resource::Service[$::nova::params::api_service_name],
1170                   Pacemaker::Resource::Service[$::nova::params::scheduler_service_name]],
1171     }
1172     pacemaker::constraint::colocation { 'nova-scheduler-with-nova-api-colocation':
1173       source => "${::nova::params::scheduler_service_name}-clone",
1174       target => "${::nova::params::api_service_name}-clone",
1175       score => "INFINITY",
1176       require => [Pacemaker::Resource::Service[$::nova::params::api_service_name],
1177                   Pacemaker::Resource::Service[$::nova::params::scheduler_service_name]],
1178     }
1179     pacemaker::constraint::base { 'nova-scheduler-then-nova-conductor-constraint':
1180       constraint_type => "order",
1181       first_resource  => "${::nova::params::scheduler_service_name}-clone",
1182       second_resource => "${::nova::params::conductor_service_name}-clone",
1183       first_action    => "start",
1184       second_action   => "start",
1185       require => [Pacemaker::Resource::Service[$::nova::params::scheduler_service_name],
1186                   Pacemaker::Resource::Service[$::nova::params::conductor_service_name]],
1187     }
1188     pacemaker::constraint::colocation { 'nova-conductor-with-nova-scheduler-colocation':
1189       source => "${::nova::params::conductor_service_name}-clone",
1190       target => "${::nova::params::scheduler_service_name}-clone",
1191       score => "INFINITY",
1192       require => [Pacemaker::Resource::Service[$::nova::params::scheduler_service_name],
1193                   Pacemaker::Resource::Service[$::nova::params::conductor_service_name]],
1194     }
1195
1196     # Ceilometer
1197     pacemaker::resource::service { $::ceilometer::params::agent_central_service_name :
1198       clone_params => 'interleave=true',
1199       require      => [Pacemaker::Resource::Service[$::keystone::params::service_name],
1200                        Pacemaker::Resource::Service[$::mongodb::params::service_name]],
1201     }
1202     pacemaker::resource::service { $::ceilometer::params::collector_service_name :
1203       clone_params => 'interleave=true',
1204     }
1205     pacemaker::resource::service { $::ceilometer::params::api_service_name :
1206       clone_params => 'interleave=true',
1207     }
1208     pacemaker::resource::service { $::ceilometer::params::alarm_evaluator_service_name :
1209       clone_params => 'interleave=true',
1210     }
1211     pacemaker::resource::service { $::ceilometer::params::alarm_notifier_service_name :
1212       clone_params => 'interleave=true',
1213     }
1214     pacemaker::resource::service { $::ceilometer::params::agent_notification_service_name :
1215       clone_params => 'interleave=true',
1216     }
1217     pacemaker::resource::ocf { 'delay' :
1218       ocf_agent_name  => 'heartbeat:Delay',
1219       clone_params    => 'interleave=true',
1220       resource_params => 'startdelay=10',
1221     }
1222     pacemaker::constraint::base { 'keystone-then-ceilometer-central-constraint':
1223       constraint_type => 'order',
1224       first_resource  => "${::keystone::params::service_name}-clone",
1225       second_resource => "${::ceilometer::params::agent_central_service_name}-clone",
1226       first_action    => 'start',
1227       second_action   => 'start',
1228       require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
1229                           Pacemaker::Resource::Service[$::keystone::params::service_name]],
1230     }
1231     pacemaker::constraint::base { 'ceilometer-central-then-ceilometer-collector-constraint':
1232       constraint_type => 'order',
1233       first_resource  => "${::ceilometer::params::agent_central_service_name}-clone",
1234       second_resource => "${::ceilometer::params::collector_service_name}-clone",
1235       first_action    => 'start',
1236       second_action   => 'start',
1237       require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
1238                           Pacemaker::Resource::Service[$::ceilometer::params::collector_service_name]],
1239     }
1240     pacemaker::constraint::base { 'ceilometer-collector-then-ceilometer-api-constraint':
1241       constraint_type => 'order',
1242       first_resource  => "${::ceilometer::params::collector_service_name}-clone",
1243       second_resource => "${::ceilometer::params::api_service_name}-clone",
1244       first_action    => 'start',
1245       second_action   => 'start',
1246       require         => [Pacemaker::Resource::Service[$::ceilometer::params::collector_service_name],
1247                           Pacemaker::Resource::Service[$::ceilometer::params::api_service_name]],
1248     }
1249     pacemaker::constraint::colocation { 'ceilometer-api-with-ceilometer-collector-colocation':
1250       source  => "${::ceilometer::params::api_service_name}-clone",
1251       target  => "${::ceilometer::params::collector_service_name}-clone",
1252       score   => 'INFINITY',
1253       require => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
1254                   Pacemaker::Resource::Service[$::ceilometer::params::collector_service_name]],
1255     }
1256     pacemaker::constraint::base { 'ceilometer-api-then-ceilometer-delay-constraint':
1257       constraint_type => 'order',
1258       first_resource  => "${::ceilometer::params::api_service_name}-clone",
1259       second_resource => 'delay-clone',
1260       first_action    => 'start',
1261       second_action   => 'start',
1262       require         => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
1263                           Pacemaker::Resource::Ocf['delay']],
1264     }
1265     pacemaker::constraint::colocation { 'ceilometer-delay-with-ceilometer-api-colocation':
1266       source  => 'delay-clone',
1267       target  => "${::ceilometer::params::api_service_name}-clone",
1268       score   => 'INFINITY',
1269       require => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
1270                   Pacemaker::Resource::Ocf['delay']],
1271     }
1272     pacemaker::constraint::base { 'ceilometer-delay-then-ceilometer-alarm-evaluator-constraint':
1273       constraint_type => 'order',
1274       first_resource  => 'delay-clone',
1275       second_resource => "${::ceilometer::params::alarm_evaluator_service_name}-clone",
1276       first_action    => 'start',
1277       second_action   => 'start',
1278       require         => [Pacemaker::Resource::Service[$::ceilometer::params::alarm_evaluator_service_name],
1279                           Pacemaker::Resource::Ocf['delay']],
1280     }
1281     pacemaker::constraint::colocation { 'ceilometer-alarm-evaluator-with-ceilometer-delay-colocation':
1282       source  => "${::ceilometer::params::alarm_evaluator_service_name}-clone",
1283       target  => 'delay-clone',
1284       score   => 'INFINITY',
1285       require => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
1286                   Pacemaker::Resource::Ocf['delay']],
1287     }
1288     pacemaker::constraint::base { 'ceilometer-alarm-evaluator-then-ceilometer-alarm-notifier-constraint':
1289       constraint_type => 'order',
1290       first_resource  => "${::ceilometer::params::alarm_evaluator_service_name}-clone",
1291       second_resource => "${::ceilometer::params::alarm_notifier_service_name}-clone",
1292       first_action    => 'start',
1293       second_action   => 'start',
1294       require         => [Pacemaker::Resource::Service[$::ceilometer::params::alarm_evaluator_service_name],
1295                           Pacemaker::Resource::Service[$::ceilometer::params::alarm_notifier_service_name]],
1296     }
1297     pacemaker::constraint::colocation { 'ceilometer-alarm-notifier-with-ceilometer-alarm-evaluator-colocation':
1298       source  => "${::ceilometer::params::alarm_notifier_service_name}-clone",
1299       target  => "${::ceilometer::params::alarm_evaluator_service_name}-clone",
1300       score   => 'INFINITY',
1301       require => [Pacemaker::Resource::Service[$::ceilometer::params::alarm_evaluator_service_name],
1302                   Pacemaker::Resource::Service[$::ceilometer::params::alarm_notifier_service_name]],
1303     }
1304     pacemaker::constraint::base { 'ceilometer-alarm-notifier-then-ceilometer-notification-constraint':
1305       constraint_type => 'order',
1306       first_resource  => "${::ceilometer::params::alarm_notifier_service_name}-clone",
1307       second_resource => "${::ceilometer::params::agent_notification_service_name}-clone",
1308       first_action    => 'start',
1309       second_action   => 'start',
1310       require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_notification_service_name],
1311                           Pacemaker::Resource::Service[$::ceilometer::params::alarm_notifier_service_name]],
1312     }
1313     pacemaker::constraint::colocation { 'ceilometer-notification-with-ceilometer-alarm-notifier-colocation':
1314       source  => "${::ceilometer::params::agent_notification_service_name}-clone",
1315       target  => "${::ceilometer::params::alarm_notifier_service_name}-clone",
1316       score   => 'INFINITY',
1317       require => [Pacemaker::Resource::Service[$::ceilometer::params::agent_notification_service_name],
1318                   Pacemaker::Resource::Service[$::ceilometer::params::alarm_notifier_service_name]],
1319     }
1320     if downcase(hiera('ceilometer_backend')) == 'mongodb' {
1321       pacemaker::constraint::base { 'mongodb-then-ceilometer-central-constraint':
1322         constraint_type => 'order',
1323         first_resource  => "${::mongodb::params::service_name}-clone",
1324         second_resource => "${::ceilometer::params::agent_central_service_name}-clone",
1325         first_action    => 'start',
1326         second_action   => 'start',
1327         require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
1328                             Pacemaker::Resource::Service[$::mongodb::params::service_name]],
1329       }
1330     }
1331
1332     # Heat
1333     pacemaker::resource::service { $::heat::params::api_service_name :
1334       clone_params => 'interleave=true',
1335     }
1336     pacemaker::resource::service { $::heat::params::api_cloudwatch_service_name :
1337       clone_params => 'interleave=true',
1338     }
1339     pacemaker::resource::service { $::heat::params::api_cfn_service_name :
1340       clone_params => 'interleave=true',
1341     }
1342     pacemaker::resource::service { $::heat::params::engine_service_name :
1343       clone_params => 'interleave=true',
1344     }
1345     pacemaker::constraint::base { 'keystone-then-heat-api-constraint':
1346       constraint_type => 'order',
1347       first_resource  => "${::keystone::params::service_name}-clone",
1348       second_resource => "${::heat::params::api_service_name}-clone",
1349       first_action    => 'start',
1350       second_action   => 'start',
1351       require         => [Pacemaker::Resource::Service[$::heat::params::api_service_name],
1352                           Pacemaker::Resource::Service[$::keystone::params::service_name]],
1353     }
1354     pacemaker::constraint::base { 'heat-api-then-heat-api-cfn-constraint':
1355       constraint_type => 'order',
1356       first_resource  => "${::heat::params::api_service_name}-clone",
1357       second_resource => "${::heat::params::api_cfn_service_name}-clone",
1358       first_action    => 'start',
1359       second_action   => 'start',
1360       require => [Pacemaker::Resource::Service[$::heat::params::api_service_name],
1361                   Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name]],
1362     }
1363     pacemaker::constraint::colocation { 'heat-api-cfn-with-heat-api-colocation':
1364       source  => "${::heat::params::api_cfn_service_name}-clone",
1365       target  => "${::heat::params::api_service_name}-clone",
1366       score   => 'INFINITY',
1367       require => [Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name],
1368                   Pacemaker::Resource::Service[$::heat::params::api_service_name]],
1369     }
1370     pacemaker::constraint::base { 'heat-api-cfn-then-heat-api-cloudwatch-constraint':
1371       constraint_type => 'order',
1372       first_resource  => "${::heat::params::api_cfn_service_name}-clone",
1373       second_resource => "${::heat::params::api_cloudwatch_service_name}-clone",
1374       first_action    => 'start',
1375       second_action   => 'start',
1376       require => [Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name],
1377                   Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name]],
1378     }
1379     pacemaker::constraint::colocation { 'heat-api-cloudwatch-with-heat-api-cfn-colocation':
1380       source  => "${::heat::params::api_cloudwatch_service_name}-clone",
1381       target  => "${::heat::params::api_cfn_service_name}-clone",
1382       score   => 'INFINITY',
1383       require => [Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name],
1384                   Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name]],
1385     }
1386     pacemaker::constraint::base { 'heat-api-cloudwatch-then-heat-engine-constraint':
1387       constraint_type => 'order',
1388       first_resource  => "${::heat::params::api_cloudwatch_service_name}-clone",
1389       second_resource => "${::heat::params::engine_service_name}-clone",
1390       first_action    => 'start',
1391       second_action   => 'start',
1392       require => [Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name],
1393                   Pacemaker::Resource::Service[$::heat::params::engine_service_name]],
1394     }
1395     pacemaker::constraint::colocation { 'heat-engine-with-heat-api-cloudwatch-colocation':
1396       source  => "${::heat::params::engine_service_name}-clone",
1397       target  => "${::heat::params::api_cloudwatch_service_name}-clone",
1398       score   => 'INFINITY',
1399       require => [Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name],
1400                   Pacemaker::Resource::Service[$::heat::params::engine_service_name]],
1401     }
1402     pacemaker::constraint::base { 'ceilometer-notification-then-heat-api-constraint':
1403       constraint_type => 'order',
1404       first_resource  => "${::ceilometer::params::agent_notification_service_name}-clone",
1405       second_resource => "${::heat::params::api_service_name}-clone",
1406       first_action    => 'start',
1407       second_action   => 'start',
1408       require         => [Pacemaker::Resource::Service[$::heat::params::api_service_name],
1409                           Pacemaker::Resource::Service[$::ceilometer::params::agent_notification_service_name]],
1410     }
1411
1412     # Horizon
1413     pacemaker::resource::service { $::horizon::params::http_service:
1414         clone_params => "interleave=true",
1415     }
1416
1417
1418   }
1419
1420 } #END STEP 4