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,
 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 { 'neutron-server-start-wait-stop' :
 952       command   => "systemctl start neutron-server && \
 953                     sleep 5s && \
 954                     systemctl stop neutron-server",
 955       path      => ["/usr/bin", "/usr/sbin"],
 956     } ->
 957     pacemaker::resource::service { $::neutron::params::server_service:
 958       op_params => "start timeout=90",
 959       clone_params   => "interleave=true",
 960       require => Pacemaker::Resource::Service[$::keystone::params::service_name]
 961     }
 962     pacemaker::resource::service { $::neutron::params::l3_agent_service:
 963       clone_params   => "interleave=true",
 964     }
 965     pacemaker::resource::service { $::neutron::params::dhcp_agent_service:
 966       clone_params   => "interleave=true",
 967     }
 968     pacemaker::resource::service { $::neutron::params::ovs_agent_service:
 969       clone_params => "interleave=true",
 970     }
 971     pacemaker::resource::service { $::neutron::params::metadata_agent_service:
 972       clone_params => "interleave=true",
 973     }
 974     pacemaker::resource::ocf { $::neutron::params::ovs_cleanup_service:
 975       ocf_agent_name => "neutron:OVSCleanup",
 976       clone_params => "interleave=true",
 977     }
 978     pacemaker::resource::ocf { 'neutron-netns-cleanup':
 979       ocf_agent_name => "neutron:NetnsCleanup",
 980       clone_params => "interleave=true",
 981     }
 982     pacemaker::resource::ocf { 'neutron-scale':
 983       ocf_agent_name => "neutron:NeutronScale",
 984       clone_params => "globally-unique=true clone-max=3 interleave=true",
 985     }
 986     pacemaker::constraint::base { 'keystone-to-neutron-server-constraint':
 987       constraint_type => "order",
 988       first_resource => "${::keystone::params::service_name}-clone",
 989       second_resource => "${::neutron::params::server_service}-clone",
 990       first_action => "start",
 991       second_action => "start",
 992       require => [Pacemaker::Resource::Service[$::keystone::params::service_name],
 993                   Pacemaker::Resource::Service[$::neutron::params::server_service]],
 994     }
 995     pacemaker::constraint::base { 'neutron-server-to-neutron-scale-constraint':
 996       constraint_type => "order",
 997       first_resource => "${::neutron::params::server_service}-clone",
 998       second_resource => "neutron-scale-clone",
 999       first_action => "start",
1000       second_action => "start",
1001       require => [Pacemaker::Resource::Service[$::neutron::params::server_service],
1002                   Pacemaker::Resource::Ocf['neutron-scale']],
1003     }
1004     pacemaker::constraint::base { 'neutron-scale-to-ovs-cleanup-constraint':
1005       constraint_type => "order",
1006       first_resource => "neutron-scale-clone",
1007       second_resource => "${::neutron::params::ovs_cleanup_service}-clone",
1008       first_action => "start",
1009       second_action => "start",
1010       require => [Pacemaker::Resource::Ocf['neutron-scale'],
1011                   Pacemaker::Resource::Ocf["${::neutron::params::ovs_cleanup_service}"]],
1012     }
1013     pacemaker::constraint::colocation { 'neutron-scale-to-ovs-cleanup-colocation':
1014       source => "${::neutron::params::ovs_cleanup_service}-clone",
1015       target => "neutron-scale-clone",
1016       score => "INFINITY",
1017       require => [Pacemaker::Resource::Ocf['neutron-scale'],
1018                   Pacemaker::Resource::Ocf["${::neutron::params::ovs_cleanup_service}"]],
1019     }
1020     pacemaker::constraint::base { 'neutron-ovs-cleanup-to-netns-cleanup-constraint':
1021       constraint_type => "order",
1022       first_resource => "${::neutron::params::ovs_cleanup_service}-clone",
1023       second_resource => "neutron-netns-cleanup-clone",
1024       first_action => "start",
1025       second_action => "start",
1026       require => [Pacemaker::Resource::Ocf["${::neutron::params::ovs_cleanup_service}"],
1027                   Pacemaker::Resource::Ocf['neutron-netns-cleanup']],
1028     }
1029     pacemaker::constraint::colocation { 'neutron-ovs-cleanup-to-netns-cleanup-colocation':
1030       source => "neutron-netns-cleanup-clone",
1031       target => "${::neutron::params::ovs_cleanup_service}-clone",
1032       score => "INFINITY",
1033       require => [Pacemaker::Resource::Ocf["${::neutron::params::ovs_cleanup_service}"],
1034                   Pacemaker::Resource::Ocf['neutron-netns-cleanup']],
1035     }
1036     pacemaker::constraint::base { 'neutron-netns-cleanup-to-openvswitch-agent-constraint':
1037       constraint_type => "order",
1038       first_resource => "neutron-netns-cleanup-clone",
1039       second_resource => "${::neutron::params::ovs_agent_service}-clone",
1040       first_action => "start",
1041       second_action => "start",
1042       require => [Pacemaker::Resource::Ocf["neutron-netns-cleanup"],
1043                   Pacemaker::Resource::Service["${::neutron::params::ovs_agent_service}"]],
1044     }
1045     pacemaker::constraint::colocation { 'neutron-netns-cleanup-to-openvswitch-agent-colocation':
1046       source => "${::neutron::params::ovs_agent_service}-clone",
1047       target => "neutron-netns-cleanup-clone",
1048       score => "INFINITY",
1049       require => [Pacemaker::Resource::Ocf["neutron-netns-cleanup"],
1050                   Pacemaker::Resource::Service["${::neutron::params::ovs_agent_service}"]],
1051     }
1052     pacemaker::constraint::base { 'neutron-openvswitch-agent-to-dhcp-agent-constraint':
1053       constraint_type => "order",
1054       first_resource => "${::neutron::params::ovs_agent_service}-clone",
1055       second_resource => "${::neutron::params::dhcp_agent_service}-clone",
1056       first_action => "start",
1057       second_action => "start",
1058       require => [Pacemaker::Resource::Service["${::neutron::params::ovs_agent_service}"],
1059                   Pacemaker::Resource::Service["${::neutron::params::dhcp_agent_service}"]],
1060
1061     }
1062     pacemaker::constraint::colocation { 'neutron-openvswitch-agent-to-dhcp-agent-colocation':
1063       source => "${::neutron::params::dhcp_agent_service}-clone",
1064       target => "${::neutron::params::ovs_agent_service}-clone",
1065       score => "INFINITY",
1066       require => [Pacemaker::Resource::Service["${::neutron::params::ovs_agent_service}"],
1067                   Pacemaker::Resource::Service["${::neutron::params::dhcp_agent_service}"]],
1068     }
1069     pacemaker::constraint::base { 'neutron-dhcp-agent-to-l3-agent-constraint':
1070       constraint_type => "order",
1071       first_resource => "${::neutron::params::dhcp_agent_service}-clone",
1072       second_resource => "${::neutron::params::l3_agent_service}-clone",
1073       first_action => "start",
1074       second_action => "start",
1075       require => [Pacemaker::Resource::Service["${::neutron::params::dhcp_agent_service}"],
1076                   Pacemaker::Resource::Service["${::neutron::params::l3_agent_service}"]]
1077     }
1078     pacemaker::constraint::colocation { 'neutron-dhcp-agent-to-l3-agent-colocation':
1079       source => "${::neutron::params::l3_agent_service}-clone",
1080       target => "${::neutron::params::dhcp_agent_service}-clone",
1081       score => "INFINITY",
1082       require => [Pacemaker::Resource::Service["${::neutron::params::dhcp_agent_service}"],
1083                   Pacemaker::Resource::Service["${::neutron::params::l3_agent_service}"]]
1084     }
1085     pacemaker::constraint::base { 'neutron-l3-agent-to-metadata-agent-constraint':
1086       constraint_type => "order",
1087       first_resource => "${::neutron::params::l3_agent_service}-clone",
1088       second_resource => "${::neutron::params::metadata_agent_service}-clone",
1089       first_action => "start",
1090       second_action => "start",
1091       require => [Pacemaker::Resource::Service["${::neutron::params::l3_agent_service}"],
1092                   Pacemaker::Resource::Service["${::neutron::params::metadata_agent_service}"]]
1093     }
1094     pacemaker::constraint::colocation { 'neutron-l3-agent-to-metadata-agent-colocation':
1095       source => "${::neutron::params::metadata_agent_service}-clone",
1096       target => "${::neutron::params::l3_agent_service}-clone",
1097       score => "INFINITY",
1098       require => [Pacemaker::Resource::Service["${::neutron::params::l3_agent_service}"],
1099                   Pacemaker::Resource::Service["${::neutron::params::metadata_agent_service}"]]
1100     }
1101
1102     # Nova
1103     pacemaker::resource::service { $::nova::params::api_service_name :
1104       clone_params    => "interleave=true",
1105       op_params       => "monitor start-delay=10s",
1106     }
1107     pacemaker::resource::service { $::nova::params::conductor_service_name :
1108       clone_params    => "interleave=true",
1109       op_params       => "monitor start-delay=10s",
1110     }
1111     pacemaker::resource::service { $::nova::params::consoleauth_service_name :
1112       clone_params    => "interleave=true",
1113       op_params       => "monitor start-delay=10s",
1114       require         => Pacemaker::Resource::Service[$::keystone::params::service_name],
1115     }
1116     pacemaker::resource::service { $::nova::params::vncproxy_service_name :
1117       clone_params    => "interleave=true",
1118       op_params       => "monitor start-delay=10s",
1119     }
1120     pacemaker::resource::service { $::nova::params::scheduler_service_name :
1121       clone_params    => "interleave=true",
1122       op_params       => "monitor start-delay=10s",
1123     }
1124
1125     pacemaker::constraint::base { 'keystone-then-nova-consoleauth-constraint':
1126       constraint_type => 'order',
1127       first_resource  => "${::keystone::params::service_name}-clone",
1128       second_resource => "${::nova::params::consoleauth_service_name}-clone",
1129       first_action    => 'start',
1130       second_action   => 'start',
1131       require         => [Pacemaker::Resource::Service[$::nova::params::consoleauth_service_name],
1132                           Pacemaker::Resource::Service[$::keystone::params::service_name]],
1133     }
1134     pacemaker::constraint::base { 'nova-consoleauth-then-nova-vncproxy-constraint':
1135       constraint_type => "order",
1136       first_resource  => "${::nova::params::consoleauth_service_name}-clone",
1137       second_resource => "${::nova::params::vncproxy_service_name}-clone",
1138       first_action    => "start",
1139       second_action   => "start",
1140       require => [Pacemaker::Resource::Service[$::nova::params::consoleauth_service_name],
1141                   Pacemaker::Resource::Service[$::nova::params::vncproxy_service_name]],
1142     }
1143     pacemaker::constraint::colocation { 'nova-vncproxy-with-nova-consoleauth-colocation':
1144       source => "${::nova::params::vncproxy_service_name}-clone",
1145       target => "${::nova::params::consoleauth_service_name}-clone",
1146       score => "INFINITY",
1147       require => [Pacemaker::Resource::Service[$::nova::params::consoleauth_service_name],
1148                   Pacemaker::Resource::Service[$::nova::params::vncproxy_service_name]],
1149     }
1150     # FIXME(gfidente): novncproxy will not start unless websockify is updated to 0.6
1151     # which is not the case for f20 nor f21; ucomment when it becomes available
1152     #pacemaker::constraint::base { 'nova-vncproxy-then-nova-api-constraint':
1153     #  constraint_type => "order",
1154     #  first_resource  => "${::nova::params::vncproxy_service_name}-clone",
1155     #  second_resource => "${::nova::params::api_service_name}-clone",
1156     #  first_action    => "start",
1157     #  second_action   => "start",
1158     #  require => [Pacemaker::Resource::Service[$::nova::params::vncproxy_service_name],
1159     #              Pacemaker::Resource::Service[$::nova::params::api_service_name]],
1160     #}
1161     #pacemaker::constraint::colocation { 'nova-api-with-nova-vncproxy-colocation':
1162     #  source => "${::nova::params::api_service_name}-clone",
1163     #  target => "${::nova::params::vncproxy_service_name}-clone",
1164     #  score => "INFINITY",
1165     #  require => [Pacemaker::Resource::Service[$::nova::params::vncproxy_service_name],
1166     #              Pacemaker::Resource::Service[$::nova::params::api_service_name]],
1167     #}
1168     pacemaker::constraint::base { 'nova-api-then-nova-scheduler-constraint':
1169       constraint_type => "order",
1170       first_resource  => "${::nova::params::api_service_name}-clone",
1171       second_resource => "${::nova::params::scheduler_service_name}-clone",
1172       first_action    => "start",
1173       second_action   => "start",
1174       require => [Pacemaker::Resource::Service[$::nova::params::api_service_name],
1175                   Pacemaker::Resource::Service[$::nova::params::scheduler_service_name]],
1176     }
1177     pacemaker::constraint::colocation { 'nova-scheduler-with-nova-api-colocation':
1178       source => "${::nova::params::scheduler_service_name}-clone",
1179       target => "${::nova::params::api_service_name}-clone",
1180       score => "INFINITY",
1181       require => [Pacemaker::Resource::Service[$::nova::params::api_service_name],
1182                   Pacemaker::Resource::Service[$::nova::params::scheduler_service_name]],
1183     }
1184     pacemaker::constraint::base { 'nova-scheduler-then-nova-conductor-constraint':
1185       constraint_type => "order",
1186       first_resource  => "${::nova::params::scheduler_service_name}-clone",
1187       second_resource => "${::nova::params::conductor_service_name}-clone",
1188       first_action    => "start",
1189       second_action   => "start",
1190       require => [Pacemaker::Resource::Service[$::nova::params::scheduler_service_name],
1191                   Pacemaker::Resource::Service[$::nova::params::conductor_service_name]],
1192     }
1193     pacemaker::constraint::colocation { 'nova-conductor-with-nova-scheduler-colocation':
1194       source => "${::nova::params::conductor_service_name}-clone",
1195       target => "${::nova::params::scheduler_service_name}-clone",
1196       score => "INFINITY",
1197       require => [Pacemaker::Resource::Service[$::nova::params::scheduler_service_name],
1198                   Pacemaker::Resource::Service[$::nova::params::conductor_service_name]],
1199     }
1200
1201     # Ceilometer
1202     pacemaker::resource::service { $::ceilometer::params::agent_central_service_name :
1203       clone_params => 'interleave=true',
1204       require      => [Pacemaker::Resource::Service[$::keystone::params::service_name],
1205                        Pacemaker::Resource::Service[$::mongodb::params::service_name]],
1206     }
1207     pacemaker::resource::service { $::ceilometer::params::collector_service_name :
1208       clone_params => 'interleave=true',
1209     }
1210     pacemaker::resource::service { $::ceilometer::params::api_service_name :
1211       clone_params => 'interleave=true',
1212     }
1213     pacemaker::resource::service { $::ceilometer::params::alarm_evaluator_service_name :
1214       clone_params => 'interleave=true',
1215     }
1216     pacemaker::resource::service { $::ceilometer::params::alarm_notifier_service_name :
1217       clone_params => 'interleave=true',
1218     }
1219     pacemaker::resource::service { $::ceilometer::params::agent_notification_service_name :
1220       clone_params => 'interleave=true',
1221     }
1222     pacemaker::resource::ocf { 'delay' :
1223       ocf_agent_name  => 'heartbeat:Delay',
1224       clone_params    => 'interleave=true',
1225       resource_params => 'startdelay=10',
1226     }
1227     pacemaker::constraint::base { 'keystone-then-ceilometer-central-constraint':
1228       constraint_type => 'order',
1229       first_resource  => "${::keystone::params::service_name}-clone",
1230       second_resource => "${::ceilometer::params::agent_central_service_name}-clone",
1231       first_action    => 'start',
1232       second_action   => 'start',
1233       require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
1234                           Pacemaker::Resource::Service[$::keystone::params::service_name]],
1235     }
1236     pacemaker::constraint::base { 'ceilometer-central-then-ceilometer-collector-constraint':
1237       constraint_type => 'order',
1238       first_resource  => "${::ceilometer::params::agent_central_service_name}-clone",
1239       second_resource => "${::ceilometer::params::collector_service_name}-clone",
1240       first_action    => 'start',
1241       second_action   => 'start',
1242       require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
1243                           Pacemaker::Resource::Service[$::ceilometer::params::collector_service_name]],
1244     }
1245     pacemaker::constraint::base { 'ceilometer-collector-then-ceilometer-api-constraint':
1246       constraint_type => 'order',
1247       first_resource  => "${::ceilometer::params::collector_service_name}-clone",
1248       second_resource => "${::ceilometer::params::api_service_name}-clone",
1249       first_action    => 'start',
1250       second_action   => 'start',
1251       require         => [Pacemaker::Resource::Service[$::ceilometer::params::collector_service_name],
1252                           Pacemaker::Resource::Service[$::ceilometer::params::api_service_name]],
1253     }
1254     pacemaker::constraint::colocation { 'ceilometer-api-with-ceilometer-collector-colocation':
1255       source  => "${::ceilometer::params::api_service_name}-clone",
1256       target  => "${::ceilometer::params::collector_service_name}-clone",
1257       score   => 'INFINITY',
1258       require => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
1259                   Pacemaker::Resource::Service[$::ceilometer::params::collector_service_name]],
1260     }
1261     pacemaker::constraint::base { 'ceilometer-api-then-ceilometer-delay-constraint':
1262       constraint_type => 'order',
1263       first_resource  => "${::ceilometer::params::api_service_name}-clone",
1264       second_resource => 'delay-clone',
1265       first_action    => 'start',
1266       second_action   => 'start',
1267       require         => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
1268                           Pacemaker::Resource::Ocf['delay']],
1269     }
1270     pacemaker::constraint::colocation { 'ceilometer-delay-with-ceilometer-api-colocation':
1271       source  => 'delay-clone',
1272       target  => "${::ceilometer::params::api_service_name}-clone",
1273       score   => 'INFINITY',
1274       require => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
1275                   Pacemaker::Resource::Ocf['delay']],
1276     }
1277     pacemaker::constraint::base { 'ceilometer-delay-then-ceilometer-alarm-evaluator-constraint':
1278       constraint_type => 'order',
1279       first_resource  => 'delay-clone',
1280       second_resource => "${::ceilometer::params::alarm_evaluator_service_name}-clone",
1281       first_action    => 'start',
1282       second_action   => 'start',
1283       require         => [Pacemaker::Resource::Service[$::ceilometer::params::alarm_evaluator_service_name],
1284                           Pacemaker::Resource::Ocf['delay']],
1285     }
1286     pacemaker::constraint::colocation { 'ceilometer-alarm-evaluator-with-ceilometer-delay-colocation':
1287       source  => "${::ceilometer::params::alarm_evaluator_service_name}-clone",
1288       target  => 'delay-clone',
1289       score   => 'INFINITY',
1290       require => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
1291                   Pacemaker::Resource::Ocf['delay']],
1292     }
1293     pacemaker::constraint::base { 'ceilometer-alarm-evaluator-then-ceilometer-alarm-notifier-constraint':
1294       constraint_type => 'order',
1295       first_resource  => "${::ceilometer::params::alarm_evaluator_service_name}-clone",
1296       second_resource => "${::ceilometer::params::alarm_notifier_service_name}-clone",
1297       first_action    => 'start',
1298       second_action   => 'start',
1299       require         => [Pacemaker::Resource::Service[$::ceilometer::params::alarm_evaluator_service_name],
1300                           Pacemaker::Resource::Service[$::ceilometer::params::alarm_notifier_service_name]],
1301     }
1302     pacemaker::constraint::colocation { 'ceilometer-alarm-notifier-with-ceilometer-alarm-evaluator-colocation':
1303       source  => "${::ceilometer::params::alarm_notifier_service_name}-clone",
1304       target  => "${::ceilometer::params::alarm_evaluator_service_name}-clone",
1305       score   => 'INFINITY',
1306       require => [Pacemaker::Resource::Service[$::ceilometer::params::alarm_evaluator_service_name],
1307                   Pacemaker::Resource::Service[$::ceilometer::params::alarm_notifier_service_name]],
1308     }
1309     pacemaker::constraint::base { 'ceilometer-alarm-notifier-then-ceilometer-notification-constraint':
1310       constraint_type => 'order',
1311       first_resource  => "${::ceilometer::params::alarm_notifier_service_name}-clone",
1312       second_resource => "${::ceilometer::params::agent_notification_service_name}-clone",
1313       first_action    => 'start',
1314       second_action   => 'start',
1315       require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_notification_service_name],
1316                           Pacemaker::Resource::Service[$::ceilometer::params::alarm_notifier_service_name]],
1317     }
1318     pacemaker::constraint::colocation { 'ceilometer-notification-with-ceilometer-alarm-notifier-colocation':
1319       source  => "${::ceilometer::params::agent_notification_service_name}-clone",
1320       target  => "${::ceilometer::params::alarm_notifier_service_name}-clone",
1321       score   => 'INFINITY',
1322       require => [Pacemaker::Resource::Service[$::ceilometer::params::agent_notification_service_name],
1323                   Pacemaker::Resource::Service[$::ceilometer::params::alarm_notifier_service_name]],
1324     }
1325     if downcase(hiera('ceilometer_backend')) == 'mongodb' {
1326       pacemaker::constraint::base { 'mongodb-then-ceilometer-central-constraint':
1327         constraint_type => 'order',
1328         first_resource  => "${::mongodb::params::service_name}-clone",
1329         second_resource => "${::ceilometer::params::agent_central_service_name}-clone",
1330         first_action    => 'start',
1331         second_action   => 'start',
1332         require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
1333                             Pacemaker::Resource::Service[$::mongodb::params::service_name]],
1334       }
1335     }
1336
1337     # Heat
1338     pacemaker::resource::service { $::heat::params::api_service_name :
1339       clone_params => 'interleave=true',
1340     }
1341     pacemaker::resource::service { $::heat::params::api_cloudwatch_service_name :
1342       clone_params => 'interleave=true',
1343     }
1344     pacemaker::resource::service { $::heat::params::api_cfn_service_name :
1345       clone_params => 'interleave=true',
1346     }
1347     pacemaker::resource::service { $::heat::params::engine_service_name :
1348       clone_params => 'interleave=true',
1349     }
1350     pacemaker::constraint::base { 'keystone-then-heat-api-constraint':
1351       constraint_type => 'order',
1352       first_resource  => "${::keystone::params::service_name}-clone",
1353       second_resource => "${::heat::params::api_service_name}-clone",
1354       first_action    => 'start',
1355       second_action   => 'start',
1356       require         => [Pacemaker::Resource::Service[$::heat::params::api_service_name],
1357                           Pacemaker::Resource::Service[$::keystone::params::service_name]],
1358     }
1359     pacemaker::constraint::base { 'heat-api-then-heat-api-cfn-constraint':
1360       constraint_type => 'order',
1361       first_resource  => "${::heat::params::api_service_name}-clone",
1362       second_resource => "${::heat::params::api_cfn_service_name}-clone",
1363       first_action    => 'start',
1364       second_action   => 'start',
1365       require => [Pacemaker::Resource::Service[$::heat::params::api_service_name],
1366                   Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name]],
1367     }
1368     pacemaker::constraint::colocation { 'heat-api-cfn-with-heat-api-colocation':
1369       source  => "${::heat::params::api_cfn_service_name}-clone",
1370       target  => "${::heat::params::api_service_name}-clone",
1371       score   => 'INFINITY',
1372       require => [Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name],
1373                   Pacemaker::Resource::Service[$::heat::params::api_service_name]],
1374     }
1375     pacemaker::constraint::base { 'heat-api-cfn-then-heat-api-cloudwatch-constraint':
1376       constraint_type => 'order',
1377       first_resource  => "${::heat::params::api_cfn_service_name}-clone",
1378       second_resource => "${::heat::params::api_cloudwatch_service_name}-clone",
1379       first_action    => 'start',
1380       second_action   => 'start',
1381       require => [Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name],
1382                   Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name]],
1383     }
1384     pacemaker::constraint::colocation { 'heat-api-cloudwatch-with-heat-api-cfn-colocation':
1385       source  => "${::heat::params::api_cloudwatch_service_name}-clone",
1386       target  => "${::heat::params::api_cfn_service_name}-clone",
1387       score   => 'INFINITY',
1388       require => [Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name],
1389                   Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name]],
1390     }
1391     pacemaker::constraint::base { 'heat-api-cloudwatch-then-heat-engine-constraint':
1392       constraint_type => 'order',
1393       first_resource  => "${::heat::params::api_cloudwatch_service_name}-clone",
1394       second_resource => "${::heat::params::engine_service_name}-clone",
1395       first_action    => 'start',
1396       second_action   => 'start',
1397       require => [Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name],
1398                   Pacemaker::Resource::Service[$::heat::params::engine_service_name]],
1399     }
1400     pacemaker::constraint::colocation { 'heat-engine-with-heat-api-cloudwatch-colocation':
1401       source  => "${::heat::params::engine_service_name}-clone",
1402       target  => "${::heat::params::api_cloudwatch_service_name}-clone",
1403       score   => 'INFINITY',
1404       require => [Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name],
1405                   Pacemaker::Resource::Service[$::heat::params::engine_service_name]],
1406     }
1407     pacemaker::constraint::base { 'ceilometer-notification-then-heat-api-constraint':
1408       constraint_type => 'order',
1409       first_resource  => "${::ceilometer::params::agent_notification_service_name}-clone",
1410       second_resource => "${::heat::params::api_service_name}-clone",
1411       first_action    => 'start',
1412       second_action   => 'start',
1413       require         => [Pacemaker::Resource::Service[$::heat::params::api_service_name],
1414                           Pacemaker::Resource::Service[$::ceilometer::params::agent_notification_service_name]],
1415     }
1416
1417     # Horizon
1418     pacemaker::resource::service { $::horizon::params::http_service:
1419         clone_params => "interleave=true",
1420     }
1421
1422
1423   }
1424
1425 } #END STEP 4