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 include ::tripleo::packages
  22 include ::tripleo::firewall
  23
  24 if $::hostname == downcase(hiera('bootstrap_nodeid')) {
  25   $pacemaker_master = true
  26   $sync_db = true
  27 } else {
  28   $pacemaker_master = false
  29   $sync_db = false
  30 }
  31
  32 $enable_fencing = str2bool(hiera('enable_fencing', false)) and hiera('step') >= 5
  33 $enable_load_balancer = hiera('enable_load_balancer', true)
  34
  35 # When to start and enable services which haven't been Pacemakerized
  36 # FIXME: remove when we start all OpenStack services using Pacemaker
  37 # (occurences of this variable will be gradually replaced with false)
  38 $non_pcmk_start = hiera('step') >= 4
  39
  40 if hiera('step') >= 1 {
  41
  42   create_resources(kmod::load, hiera('kernel_modules'), {})
  43   create_resources(sysctl::value, hiera('sysctl_settings'), {})
  44   Exec <| tag == 'kmod::load' |>  -> Sysctl <| |>
  45
  46   include ::timezone
  47
  48   if count(hiera('ntp::servers')) > 0 {
  49     include ::ntp
  50   }
  51
  52   $controller_node_ips = split(hiera('controller_node_ips'), ',')
  53   $controller_node_names = split(downcase(hiera('controller_node_names')), ',')
  54   if $enable_load_balancer {
  55     class { '::tripleo::loadbalancer' :
  56       controller_hosts       => $controller_node_ips,
  57       controller_hosts_names => $controller_node_names,
  58       manage_vip             => false,
  59       mysql_clustercheck     => true,
  60       haproxy_service_manage => false,
  61     }
  62   }
  63
  64   $pacemaker_cluster_members = downcase(regsubst(hiera('controller_node_names'), ',', ' ', 'G'))
  65   $corosync_ipv6 = str2bool(hiera('corosync_ipv6', false))
  66   if $corosync_ipv6 {
  67     $cluster_setup_extras = { '--ipv6' => '' }
  68   } else {
  69     $cluster_setup_extras = {}
  70   }
  71   user { 'hacluster':
  72     ensure => present,
  73   } ->
  74   class { '::pacemaker':
  75     hacluster_pwd => hiera('hacluster_pwd'),
  76   } ->
  77   class { '::pacemaker::corosync':
  78     cluster_members      => $pacemaker_cluster_members,
  79     setup_cluster        => $pacemaker_master,
  80     cluster_setup_extras => $cluster_setup_extras,
  81   }
  82   class { '::pacemaker::stonith':
  83     disable => !$enable_fencing,
  84   }
  85   if $enable_fencing {
  86     include ::tripleo::fencing
  87
  88     # enable stonith after all fencing devices have been created
  89     Class['tripleo::fencing'] -> Class['pacemaker::stonith']
  90   }
  91
  92   # FIXME(gfidente): sets 200secs as default start timeout op
  93   # param; until we can use pcmk global defaults we'll still
  94   # need to add it to every resource which redefines op params
  95   Pacemaker::Resource::Service {
  96     op_params => 'start timeout=200s stop timeout=200s',
  97   }
  98
  99   # Only configure RabbitMQ in this step, don't start it yet to
 100   # avoid races where non-master nodes attempt to start without
 101   # config (eg. binding on 0.0.0.0)
 102   # The module ignores erlang_cookie if cluster_config is false
 103   class { '::rabbitmq':
 104     service_manage          => false,
 105     tcp_keepalive           => false,
 106     config_kernel_variables => hiera('rabbitmq_kernel_variables'),
 107     config_variables        => hiera('rabbitmq_config_variables'),
 108     environment_variables   => hiera('rabbitmq_environment'),
 109   } ->
 110   file { '/var/lib/rabbitmq/.erlang.cookie':
 111     ensure  => file,
 112     owner   => 'rabbitmq',
 113     group   => 'rabbitmq',
 114     mode    => '0400',
 115     content => hiera('rabbitmq::erlang_cookie'),
 116     replace => true,
 117   }
 118
 119   if downcase(hiera('ceilometer_backend')) == 'mongodb' {
 120     include ::mongodb::globals
 121     class { '::mongodb::server' :
 122       service_manage => false,
 123     }
 124   }
 125
 126   # Memcached
 127   class {'::memcached' :
 128     service_manage => false,
 129   }
 130
 131   # Redis
 132   class { '::redis' :
 133     service_manage => false,
 134     notify_service => false,
 135   }
 136
 137   # Galera
 138   if str2bool(hiera('enable_galera', true)) {
 139     $mysql_config_file = '/etc/my.cnf.d/galera.cnf'
 140   } else {
 141     $mysql_config_file = '/etc/my.cnf.d/server.cnf'
 142   }
 143   $galera_nodes = downcase(hiera('galera_node_names', $::hostname))
 144   $galera_nodes_count = count(split($galera_nodes, ','))
 145
 146   # FIXME: due to https://bugzilla.redhat.com/show_bug.cgi?id=1298671 we
 147   # set bind-address to a hostname instead of an ip address; to move Mysql
 148   # from internal_api on another network we'll have to customize both
 149   # MysqlNetwork and ControllerHostnameResolveNetwork in ServiceNetMap
 150   $mysql_bind_host = hiera('mysql_bind_host')
 151   $mysqld_options = {
 152     'mysqld' => {
 153       'skip-name-resolve'             => '1',
 154       'binlog_format'                 => 'ROW',
 155       'default-storage-engine'        => 'innodb',
 156       'innodb_autoinc_lock_mode'      => '2',
 157       'innodb_locks_unsafe_for_binlog'=> '1',
 158       'query_cache_size'              => '0',
 159       'query_cache_type'              => '0',
 160       'bind-address'                  => $::hostname,
 161       'max_connections'               => hiera('mysql_max_connections'),
 162       'open_files_limit'              => '-1',
 163       'wsrep_provider'                => '/usr/lib64/galera/libgalera_smm.so',
 164       'wsrep_cluster_name'            => 'galera_cluster',
 165       'wsrep_slave_threads'           => '1',
 166       'wsrep_certify_nonPK'           => '1',
 167       'wsrep_max_ws_rows'             => '131072',
 168       'wsrep_max_ws_size'             => '1073741824',
 169       'wsrep_debug'                   => '0',
 170       'wsrep_convert_LOCK_to_trx'     => '0',
 171       'wsrep_retry_autocommit'        => '1',
 172       'wsrep_auto_increment_control'  => '1',
 173       'wsrep_drupal_282555_workaround'=> '0',
 174       'wsrep_causal_reads'            => '0',
 175       'wsrep_sst_method'              => 'rsync',
 176       'wsrep_provider_options'        => "gmcast.listen_addr=tcp://[${mysql_bind_host}]:4567;",
 177     },
 178   }
 179
 180   class { '::mysql::server':
 181     create_root_user        => false,
 182     create_root_my_cnf      => false,
 183     config_file             => $mysql_config_file,
 184     override_options        => $mysqld_options,
 185     remove_default_accounts => $pacemaker_master,
 186     service_manage          => false,
 187     service_enabled         => false,
 188   }
 189
 190 }
 191
 192 if hiera('step') >= 2 {
 193
 194   # NOTE(gfidente): the following vars are needed on all nodes so they
 195   # need to stay out of pacemaker_master conditional
 196   $mongo_node_ips_with_port = suffix(hiera('mongo_node_ips'), ':27017')
 197   $mongodb_replset = hiera('mongodb::server::replset')
 198
 199   if $pacemaker_master {
 200
 201     if $enable_load_balancer {
 202
 203       include ::pacemaker::resource_defaults
 204
 205       # FIXME: we should not have to access tripleo::loadbalancer class
 206       # parameters here to configure pacemaker VIPs. The configuration
 207       # of pacemaker VIPs could move into puppet-tripleo or we should
 208       # make use of less specific hiera parameters here for the settings.
 209       pacemaker::resource::service { 'haproxy':
 210         clone_params => true,
 211       }
 212
 213       $control_vip = hiera('tripleo::loadbalancer::controller_virtual_ip')
 214       pacemaker::resource::ip { 'control_vip':
 215         ip_address => $control_vip,
 216       }
 217       pacemaker::constraint::base { 'control_vip-then-haproxy':
 218         constraint_type   => 'order',
 219         first_resource    => "ip-${control_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['control_vip']],
 226       }
 227       pacemaker::constraint::colocation { 'control_vip-with-haproxy':
 228         source  => "ip-${control_vip}",
 229         target  => 'haproxy-clone',
 230         score   => 'INFINITY',
 231         require => [Pacemaker::Resource::Service['haproxy'],
 232                     Pacemaker::Resource::Ip['control_vip']],
 233       }
 234
 235       $public_vip = hiera('tripleo::loadbalancer::public_virtual_ip')
 236       if $public_vip and $public_vip != $control_vip {
 237         pacemaker::resource::ip { 'public_vip':
 238           ip_address => $public_vip,
 239         }
 240         pacemaker::constraint::base { 'public_vip-then-haproxy':
 241           constraint_type   => 'order',
 242           first_resource    => "ip-${public_vip}",
 243           second_resource   => 'haproxy-clone',
 244           first_action      => 'start',
 245           second_action     => 'start',
 246           constraint_params => 'kind=Optional',
 247           require           => [Pacemaker::Resource::Service['haproxy'],
 248                                 Pacemaker::Resource::Ip['public_vip']],
 249         }
 250         pacemaker::constraint::colocation { 'public_vip-with-haproxy':
 251           source  => "ip-${public_vip}",
 252           target  => 'haproxy-clone',
 253           score   => 'INFINITY',
 254           require => [Pacemaker::Resource::Service['haproxy'],
 255                       Pacemaker::Resource::Ip['public_vip']],
 256         }
 257       }
 258
 259       $redis_vip = hiera('redis_vip')
 260       if $redis_vip and $redis_vip != $control_vip {
 261         pacemaker::resource::ip { 'redis_vip':
 262           ip_address => $redis_vip,
 263         }
 264         pacemaker::constraint::base { 'redis_vip-then-haproxy':
 265           constraint_type   => 'order',
 266           first_resource    => "ip-${redis_vip}",
 267           second_resource   => 'haproxy-clone',
 268           first_action      => 'start',
 269           second_action     => 'start',
 270           constraint_params => 'kind=Optional',
 271           require           => [Pacemaker::Resource::Service['haproxy'],
 272                                 Pacemaker::Resource::Ip['redis_vip']],
 273         }
 274         pacemaker::constraint::colocation { 'redis_vip-with-haproxy':
 275           source  => "ip-${redis_vip}",
 276           target  => 'haproxy-clone',
 277           score   => 'INFINITY',
 278           require => [Pacemaker::Resource::Service['haproxy'],
 279                       Pacemaker::Resource::Ip['redis_vip']],
 280         }
 281       }
 282
 283       $internal_api_vip = hiera('tripleo::loadbalancer::internal_api_virtual_ip')
 284       if $internal_api_vip and $internal_api_vip != $control_vip {
 285         pacemaker::resource::ip { 'internal_api_vip':
 286           ip_address => $internal_api_vip,
 287         }
 288         pacemaker::constraint::base { 'internal_api_vip-then-haproxy':
 289           constraint_type   => 'order',
 290           first_resource    => "ip-${internal_api_vip}",
 291           second_resource   => 'haproxy-clone',
 292           first_action      => 'start',
 293           second_action     => 'start',
 294           constraint_params => 'kind=Optional',
 295           require           => [Pacemaker::Resource::Service['haproxy'],
 296                                 Pacemaker::Resource::Ip['internal_api_vip']],
 297         }
 298         pacemaker::constraint::colocation { 'internal_api_vip-with-haproxy':
 299           source  => "ip-${internal_api_vip}",
 300           target  => 'haproxy-clone',
 301           score   => 'INFINITY',
 302           require => [Pacemaker::Resource::Service['haproxy'],
 303                       Pacemaker::Resource::Ip['internal_api_vip']],
 304         }
 305       }
 306
 307       $storage_vip = hiera('tripleo::loadbalancer::storage_virtual_ip')
 308       if $storage_vip and $storage_vip != $control_vip {
 309         pacemaker::resource::ip { 'storage_vip':
 310           ip_address => $storage_vip,
 311         }
 312         pacemaker::constraint::base { 'storage_vip-then-haproxy':
 313           constraint_type   => 'order',
 314           first_resource    => "ip-${storage_vip}",
 315           second_resource   => 'haproxy-clone',
 316           first_action      => 'start',
 317           second_action     => 'start',
 318           constraint_params => 'kind=Optional',
 319           require           => [Pacemaker::Resource::Service['haproxy'],
 320                                 Pacemaker::Resource::Ip['storage_vip']],
 321         }
 322         pacemaker::constraint::colocation { 'storage_vip-with-haproxy':
 323           source  => "ip-${storage_vip}",
 324           target  => 'haproxy-clone',
 325           score   => 'INFINITY',
 326           require => [Pacemaker::Resource::Service['haproxy'],
 327                       Pacemaker::Resource::Ip['storage_vip']],
 328         }
 329       }
 330
 331       $storage_mgmt_vip = hiera('tripleo::loadbalancer::storage_mgmt_virtual_ip')
 332       if $storage_mgmt_vip and $storage_mgmt_vip != $control_vip {
 333         pacemaker::resource::ip { 'storage_mgmt_vip':
 334           ip_address => $storage_mgmt_vip,
 335         }
 336         pacemaker::constraint::base { 'storage_mgmt_vip-then-haproxy':
 337           constraint_type   => 'order',
 338           first_resource    => "ip-${storage_mgmt_vip}",
 339           second_resource   => 'haproxy-clone',
 340           first_action      => 'start',
 341           second_action     => 'start',
 342           constraint_params => 'kind=Optional',
 343           require           => [Pacemaker::Resource::Service['haproxy'],
 344                                 Pacemaker::Resource::Ip['storage_mgmt_vip']],
 345         }
 346         pacemaker::constraint::colocation { 'storage_mgmt_vip-with-haproxy':
 347           source  => "ip-${storage_mgmt_vip}",
 348           target  => 'haproxy-clone',
 349           score   => 'INFINITY',
 350           require => [Pacemaker::Resource::Service['haproxy'],
 351                       Pacemaker::Resource::Ip['storage_mgmt_vip']],
 352         }
 353       }
 354
 355     }
 356
 357     pacemaker::resource::service { $::memcached::params::service_name :
 358       clone_params => 'interleave=true',
 359       require      => Class['::memcached'],
 360     }
 361
 362     pacemaker::resource::ocf { 'rabbitmq':
 363       ocf_agent_name  => 'heartbeat:rabbitmq-cluster',
 364       resource_params => 'set_policy=\'ha-all ^(?!amq\.).* {"ha-mode":"all"}\'',
 365       clone_params    => 'ordered=true interleave=true',
 366       meta_params     => 'notify=true',
 367       require         => Class['::rabbitmq'],
 368     }
 369
 370     if downcase(hiera('ceilometer_backend')) == 'mongodb' {
 371       pacemaker::resource::service { $::mongodb::params::service_name :
 372         op_params    => 'start timeout=370s stop timeout=200s',
 373         clone_params => true,
 374         require      => Class['::mongodb::server'],
 375       }
 376       # NOTE (spredzy) : The replset can only be run
 377       # once all the nodes have joined the cluster.
 378       mongodb_conn_validator { $mongo_node_ips_with_port :
 379         timeout => '600',
 380         require => Pacemaker::Resource::Service[$::mongodb::params::service_name],
 381         before  => Mongodb_replset[$mongodb_replset],
 382       }
 383       mongodb_replset { $mongodb_replset :
 384         members => $mongo_node_ips_with_port,
 385       }
 386     }
 387
 388     pacemaker::resource::ocf { 'galera' :
 389       ocf_agent_name  => 'heartbeat:galera',
 390       op_params       => 'promote timeout=300s on-fail=block',
 391       master_params   => '',
 392       meta_params     => "master-max=${galera_nodes_count} ordered=true",
 393       resource_params => "additional_parameters='--open-files-limit=16384' enable_creation=true wsrep_cluster_address='gcomm://${galera_nodes}'",
 394       require         => Class['::mysql::server'],
 395       before          => Exec['galera-ready'],
 396     }
 397
 398     pacemaker::resource::ocf { 'redis':
 399       ocf_agent_name  => 'heartbeat:redis',
 400       master_params   => '',
 401       meta_params     => 'notify=true ordered=true interleave=true',
 402       resource_params => 'wait_last_known_master=true',
 403       require         => Class['::redis'],
 404     }
 405
 406   }
 407
 408   exec { 'galera-ready' :
 409     command     => '/usr/bin/clustercheck >/dev/null',
 410     timeout     => 30,
 411     tries       => 180,
 412     try_sleep   => 10,
 413     environment => ['AVAILABLE_WHEN_READONLY=0'],
 414     require     => File['/etc/sysconfig/clustercheck'],
 415   }
 416
 417   file { '/etc/sysconfig/clustercheck' :
 418     ensure  => file,
 419     content => "MYSQL_USERNAME=root\n
 420 MYSQL_PASSWORD=''\n
 421 MYSQL_HOST=localhost\n",
 422   }
 423
 424   xinetd::service { 'galera-monitor' :
 425     port           => '9200',
 426     server         => '/usr/bin/clustercheck',
 427     per_source     => 'UNLIMITED',
 428     log_on_success => '',
 429     log_on_failure => 'HOST',
 430     flags          => 'REUSE',
 431     service_type   => 'UNLISTED',
 432     user           => 'root',
 433     group          => 'root',
 434     require        => File['/etc/sysconfig/clustercheck'],
 435   }
 436
 437   # Create all the database schemas
 438   if $sync_db {
 439     class { '::keystone::db::mysql':
 440       require => Exec['galera-ready'],
 441     }
 442     class { '::glance::db::mysql':
 443       require => Exec['galera-ready'],
 444     }
 445     class { '::nova::db::mysql':
 446       require => Exec['galera-ready'],
 447     }
 448     class { '::nova::db::mysql_api':
 449       require => Exec['galera-ready'],
 450     }
 451     class { '::neutron::db::mysql':
 452       require => Exec['galera-ready'],
 453     }
 454     class { '::cinder::db::mysql':
 455       require => Exec['galera-ready'],
 456     }
 457     class { '::heat::db::mysql':
 458       require => Exec['galera-ready'],
 459     }
 460
 461     if downcase(hiera('ceilometer_backend')) == 'mysql' {
 462       class { '::ceilometer::db::mysql':
 463         require => Exec['galera-ready'],
 464       }
 465     }
 466
 467     class { '::sahara::db::mysql':
 468       require       => Exec['galera-ready'],
 469     }
 470   }
 471
 472   # pre-install swift here so we can build rings
 473   include ::swift
 474
 475   # Ceph
 476   $enable_ceph = hiera('ceph_storage_count', 0) > 0 or hiera('enable_ceph_storage', false)
 477
 478   if $enable_ceph {
 479     class { '::ceph::profile::params':
 480       mon_initial_members => downcase(hiera('ceph_mon_initial_members')),
 481     }
 482     include ::ceph::conf
 483     include ::ceph::profile::mon
 484   }
 485
 486   if str2bool(hiera('enable_ceph_storage', false)) {
 487     if str2bool(hiera('ceph_osd_selinux_permissive', true)) {
 488       exec { 'set selinux to permissive on boot':
 489         command => "sed -ie 's/^SELINUX=.*/SELINUX=permissive/' /etc/selinux/config",
 490         onlyif  => "test -f /etc/selinux/config && ! grep '^SELINUX=permissive' /etc/selinux/config",
 491         path    => ['/usr/bin', '/usr/sbin'],
 492       }
 493
 494       exec { 'set selinux to permissive':
 495         command => 'setenforce 0',
 496         onlyif  => "which setenforce && getenforce | grep -i 'enforcing'",
 497         path    => ['/usr/bin', '/usr/sbin'],
 498       } -> Class['ceph::profile::osd']
 499     }
 500
 501     include ::ceph::conf
 502     include ::ceph::profile::osd
 503   }
 504
 505   if str2bool(hiera('enable_external_ceph', false)) {
 506     include ::ceph::conf
 507     include ::ceph::profile::client
 508   }
 509
 510
 511 } #END STEP 2
 512
 513 if hiera('step') >= 3 {
 514
 515   class { '::keystone':
 516     sync_db          => $sync_db,
 517     manage_service   => false,
 518     enabled          => false,
 519     enable_bootstrap => $pacemaker_master,
 520   }
 521   include ::keystone::config
 522
 523   #TODO: need a cleanup-keystone-tokens.sh solution here
 524
 525   file { [ '/etc/keystone/ssl', '/etc/keystone/ssl/certs', '/etc/keystone/ssl/private' ]:
 526     ensure  => 'directory',
 527     owner   => 'keystone',
 528     group   => 'keystone',
 529     require => Package['keystone'],
 530   }
 531   file { '/etc/keystone/ssl/certs/signing_cert.pem':
 532     content => hiera('keystone_signing_certificate'),
 533     owner   => 'keystone',
 534     group   => 'keystone',
 535     notify  => Service['keystone'],
 536     require => File['/etc/keystone/ssl/certs'],
 537   }
 538   file { '/etc/keystone/ssl/private/signing_key.pem':
 539     content => hiera('keystone_signing_key'),
 540     owner   => 'keystone',
 541     group   => 'keystone',
 542     notify  => Service['keystone'],
 543     require => File['/etc/keystone/ssl/private'],
 544   }
 545   file { '/etc/keystone/ssl/certs/ca.pem':
 546     content => hiera('keystone_ca_certificate'),
 547     owner   => 'keystone',
 548     group   => 'keystone',
 549     notify  => Service['keystone'],
 550     require => File['/etc/keystone/ssl/certs'],
 551   }
 552
 553   $glance_backend = downcase(hiera('glance_backend', 'swift'))
 554   case $glance_backend {
 555       'swift': { $backend_store = 'glance.store.swift.Store' }
 556       'file': { $backend_store = 'glance.store.filesystem.Store' }
 557       'rbd': { $backend_store = 'glance.store.rbd.Store' }
 558       default: { fail('Unrecognized glance_backend parameter.') }
 559   }
 560   $http_store = ['glance.store.http.Store']
 561   $glance_store = concat($http_store, $backend_store)
 562
 563   if $glance_backend == 'file' and hiera('glance_file_pcmk_manage', false) {
 564     $secontext = 'context="system_u:object_r:glance_var_lib_t:s0"'
 565     pacemaker::resource::filesystem { 'glance-fs':
 566       device       => hiera('glance_file_pcmk_device'),
 567       directory    => hiera('glance_file_pcmk_directory'),
 568       fstype       => hiera('glance_file_pcmk_fstype'),
 569       fsoptions    => join([$secontext, hiera('glance_file_pcmk_options', '')],','),
 570       clone_params => '',
 571     }
 572   }
 573
 574   # TODO: notifications, scrubber, etc.
 575   include ::glance
 576   include ::glance::config
 577   class { '::glance::api':
 578     known_stores   => $glance_store,
 579     manage_service => false,
 580     enabled        => false,
 581   }
 582   class { '::glance::registry' :
 583     sync_db        => $sync_db,
 584     manage_service => false,
 585     enabled        => false,
 586   }
 587   include join(['::glance::backend::', $glance_backend])
 588   $rabbit_port = hiera('rabbitmq::port')
 589   class { '::glance::notify::rabbitmq':
 590     rabbit_hosts => suffix(hiera('rabbit_node_ips'), ":${rabbit_port}"),
 591   }
 592
 593   class { '::nova' :
 594     memcached_servers => suffix(hiera('memcache_node_ips'), ':11211'),
 595   }
 596
 597   include ::nova::config
 598
 599   class { '::nova::api' :
 600     sync_db        => $sync_db,
 601     sync_db_api    => $sync_db,
 602     manage_service => false,
 603     enabled        => false,
 604   }
 605   class { '::nova::cert' :
 606     manage_service => false,
 607     enabled        => false,
 608   }
 609   class { '::nova::conductor' :
 610     manage_service => false,
 611     enabled        => false,
 612   }
 613   class { '::nova::consoleauth' :
 614     manage_service => false,
 615     enabled        => false,
 616   }
 617   class { '::nova::vncproxy' :
 618     manage_service => false,
 619     enabled        => false,
 620   }
 621   include ::nova::scheduler::filter
 622   class { '::nova::scheduler' :
 623     manage_service => false,
 624     enabled        => false,
 625   }
 626   include ::nova::network::neutron
 627
 628   if hiera('neutron::core_plugin') == 'midonet.neutron.plugin_v1.MidonetPluginV2' {
 629
 630     # TODO(devvesa) provide non-controller ips for these services
 631     $zookeeper_node_ips = hiera('neutron_api_node_ips')
 632     $cassandra_node_ips = hiera('neutron_api_node_ips')
 633
 634     # Run zookeeper in the controller if configured
 635     if hiera('enable_zookeeper_on_controller') {
 636       class {'::tripleo::cluster::zookeeper':
 637         zookeeper_server_ips => $zookeeper_node_ips,
 638         # TODO: create a 'bind' hiera key for zookeeper
 639         zookeeper_client_ip  => hiera('neutron::bind_host'),
 640         zookeeper_hostnames  => split(hiera('controller_node_names'), ',')
 641       }
 642     }
 643
 644     # Run cassandra in the controller if configured
 645     if hiera('enable_cassandra_on_controller') {
 646       class {'::tripleo::cluster::cassandra':
 647         cassandra_servers => $cassandra_node_ips,
 648         # TODO: create a 'bind' hiera key for cassandra
 649         cassandra_ip      => hiera('neutron::bind_host'),
 650       }
 651     }
 652
 653     class {'::tripleo::network::midonet::agent':
 654       zookeeper_servers => $zookeeper_node_ips,
 655       cassandra_seeds   => $cassandra_node_ips
 656     }
 657
 658     class {'::tripleo::network::midonet::api':
 659       zookeeper_servers    => $zookeeper_node_ips,
 660       vip                  => hiera('tripleo::loadbalancer::public_virtual_ip'),
 661       keystone_ip          => hiera('tripleo::loadbalancer::public_virtual_ip'),
 662       keystone_admin_token => hiera('keystone::admin_token'),
 663       # TODO: create a 'bind' hiera key for api
 664       bind_address         => hiera('neutron::bind_host'),
 665       admin_password       => hiera('admin_password')
 666     }
 667
 668     # Configure Neutron
 669     class {'::neutron':
 670       service_plugins => []
 671     }
 672
 673   }
 674   else {
 675     # Neutron class definitions
 676     include ::neutron
 677   }
 678
 679   include ::neutron::config
 680   class { '::neutron::server' :
 681     sync_db        => $sync_db,
 682     manage_service => false,
 683     enabled        => false,
 684   }
 685   include ::neutron::server::notifications
 686   if  hiera('neutron::core_plugin') == 'neutron.plugins.nuage.plugin.NuagePlugin' {
 687     include ::neutron::plugins::nuage
 688   }
 689   if  hiera('neutron::core_plugin') == 'neutron_plugin_contrail.plugins.opencontrail.contrail_plugin.NeutronPluginContrailCoreV2' {
 690     include ::neutron::plugins::opencontrail
 691   }
 692   if hiera('neutron::core_plugin') == 'midonet.neutron.plugin_v1.MidonetPluginV2' {
 693     class {'::neutron::plugins::midonet':
 694       midonet_api_ip    => hiera('tripleo::loadbalancer::public_virtual_ip'),
 695       keystone_tenant   => hiera('neutron::server::auth_tenant'),
 696       keystone_password => hiera('neutron::server::auth_password')
 697     }
 698   }
 699   if hiera('neutron::enable_dhcp_agent',true) {
 700     class { '::neutron::agents::dhcp' :
 701       manage_service => false,
 702       enabled        => false,
 703     }
 704     file { '/etc/neutron/dnsmasq-neutron.conf':
 705       content => hiera('neutron_dnsmasq_options'),
 706       owner   => 'neutron',
 707       group   => 'neutron',
 708       notify  => Service['neutron-dhcp-service'],
 709       require => Package['neutron'],
 710     }
 711   }
 712   if hiera('neutron::enable_l3_agent',true) {
 713     class { '::neutron::agents::l3' :
 714       manage_service => false,
 715       enabled        => false,
 716     }
 717   }
 718   if hiera('neutron::enable_metadata_agent',true) {
 719     class { '::neutron::agents::metadata':
 720       manage_service => false,
 721       enabled        => false,
 722     }
 723   }
 724   include ::neutron::plugins::ml2
 725   class { '::neutron::agents::ml2::ovs':
 726     manage_service => false,
 727     enabled        => false,
 728   }
 729
 730   if 'cisco_ucsm' in hiera('neutron::plugins::ml2::mechanism_drivers') {
 731     include ::neutron::plugins::ml2::cisco::ucsm
 732   }
 733   if 'cisco_nexus' in hiera('neutron::plugins::ml2::mechanism_drivers') {
 734     include ::neutron::plugins::ml2::cisco::nexus
 735     include ::neutron::plugins::ml2::cisco::type_nexus_vxlan
 736   }
 737   if 'cisco_n1kv' in hiera('neutron::plugins::ml2::mechanism_drivers') {
 738     include ::neutron::plugins::ml2::cisco::nexus1000v
 739
 740     class { '::neutron::agents::n1kv_vem':
 741       n1kv_source  => hiera('n1kv_vem_source', undef),
 742       n1kv_version => hiera('n1kv_vem_version', undef),
 743     }
 744
 745     class { '::n1k_vsm':
 746       n1kv_source  => hiera('n1kv_vsm_source', undef),
 747       n1kv_version => hiera('n1kv_vsm_version', undef),
 748     }
 749   }
 750
 751   if 'bsn_ml2' in hiera('neutron::plugins::ml2::mechanism_drivers') {
 752     include ::neutron::plugins::ml2::bigswitch::restproxy
 753     include ::neutron::agents::bigswitch
 754   }
 755   neutron_l3_agent_config {
 756     'DEFAULT/ovs_use_veth': value => hiera('neutron_ovs_use_veth', false);
 757   }
 758   neutron_dhcp_agent_config {
 759     'DEFAULT/ovs_use_veth': value => hiera('neutron_ovs_use_veth', false);
 760   }
 761   neutron_config {
 762     'DEFAULT/notification_driver': value => 'messaging';
 763   }
 764
 765   include ::cinder
 766   include ::cinder::config
 767   include ::tripleo::ssl::cinder_config
 768   class { '::cinder::api':
 769     sync_db        => $sync_db,
 770     manage_service => false,
 771     enabled        => false,
 772   }
 773   class { '::cinder::scheduler' :
 774     manage_service => false,
 775     enabled        => false,
 776   }
 777   class { '::cinder::volume' :
 778     manage_service => false,
 779     enabled        => false,
 780   }
 781   include ::cinder::glance
 782   include ::cinder::ceilometer
 783   class { '::cinder::setup_test_volume':
 784     size => join([hiera('cinder_lvm_loop_device_size'), 'M']),
 785   }
 786
 787   $cinder_enable_iscsi = hiera('cinder_enable_iscsi_backend', true)
 788   if $cinder_enable_iscsi {
 789     $cinder_iscsi_backend = 'tripleo_iscsi'
 790
 791     cinder::backend::iscsi { $cinder_iscsi_backend :
 792       iscsi_ip_address => hiera('cinder_iscsi_ip_address'),
 793       iscsi_helper     => hiera('cinder_iscsi_helper'),
 794     }
 795   }
 796
 797   if $enable_ceph {
 798
 799     $ceph_pools = hiera('ceph_pools')
 800     ceph::pool { $ceph_pools :
 801       pg_num  => hiera('ceph::profile::params::osd_pool_default_pg_num'),
 802       pgp_num => hiera('ceph::profile::params::osd_pool_default_pgp_num'),
 803       size    => hiera('ceph::profile::params::osd_pool_default_size'),
 804     }
 805
 806     $cinder_pool_requires = [Ceph::Pool[hiera('cinder_rbd_pool_name')]]
 807
 808   } else {
 809     $cinder_pool_requires = []
 810   }
 811
 812   if hiera('cinder_enable_rbd_backend', false) {
 813     $cinder_rbd_backend = 'tripleo_ceph'
 814
 815     cinder::backend::rbd { $cinder_rbd_backend :
 816       rbd_pool        => hiera('cinder_rbd_pool_name'),
 817       rbd_user        => hiera('ceph_client_user_name'),
 818       rbd_secret_uuid => hiera('ceph::profile::params::fsid'),
 819       require         => $cinder_pool_requires,
 820     }
 821   }
 822
 823   if hiera('cinder_enable_eqlx_backend', false) {
 824     $cinder_eqlx_backend = hiera('cinder::backend::eqlx::volume_backend_name')
 825
 826     cinder::backend::eqlx { $cinder_eqlx_backend :
 827       volume_backend_name => hiera('cinder::backend::eqlx::volume_backend_name', undef),
 828       san_ip              => hiera('cinder::backend::eqlx::san_ip', undef),
 829       san_login           => hiera('cinder::backend::eqlx::san_login', undef),
 830       san_password        => hiera('cinder::backend::eqlx::san_password', undef),
 831       san_thin_provision  => hiera('cinder::backend::eqlx::san_thin_provision', undef),
 832       eqlx_group_name     => hiera('cinder::backend::eqlx::eqlx_group_name', undef),
 833       eqlx_pool           => hiera('cinder::backend::eqlx::eqlx_pool', undef),
 834       eqlx_use_chap       => hiera('cinder::backend::eqlx::eqlx_use_chap', undef),
 835       eqlx_chap_login     => hiera('cinder::backend::eqlx::eqlx_chap_login', undef),
 836       eqlx_chap_password  => hiera('cinder::backend::eqlx::eqlx_san_password', undef),
 837     }
 838   }
 839
 840   if hiera('cinder_enable_dellsc_backend', false) {
 841     $cinder_dellsc_backend = hiera('cinder::backend::dellsc_iscsi::volume_backend_name')
 842
 843     cinder::backend::dellsc_iscsi{ $cinder_dellsc_backend :
 844       volume_backend_name   => hiera('cinder::backend::dellsc_iscsi::volume_backend_name', undef),
 845       san_ip                => hiera('cinder::backend::dellsc_iscsi::san_ip', undef),
 846       san_login             => hiera('cinder::backend::dellsc_iscsi::san_login', undef),
 847       san_password          => hiera('cinder::backend::dellsc_iscsi::san_password', undef),
 848       dell_sc_ssn           => hiera('cinder::backend::dellsc_iscsi::dell_sc_ssn', undef),
 849       iscsi_ip_address      => hiera('cinder::backend::dellsc_iscsi::iscsi_ip_address', undef),
 850       iscsi_port            => hiera('cinder::backend::dellsc_iscsi::iscsi_port', undef),
 851       dell_sc_api_port      => hiera('cinder::backend::dellsc_iscsi::dell_sc_api_port', undef),
 852       dell_sc_server_folder => hiera('cinder::backend::dellsc_iscsi::dell_sc_server_folder', undef),
 853       dell_sc_volume_folder => hiera('cinder::backend::dellsc_iscsi::dell_sc_volume_folder', undef),
 854     }
 855   }
 856
 857   if hiera('cinder_enable_netapp_backend', false) {
 858     $cinder_netapp_backend = hiera('cinder::backend::netapp::title')
 859
 860     if hiera('cinder::backend::netapp::nfs_shares', undef) {
 861       $cinder_netapp_nfs_shares = split(hiera('cinder::backend::netapp::nfs_shares', undef), ',')
 862     }
 863
 864     cinder::backend::netapp { $cinder_netapp_backend :
 865       netapp_login                 => hiera('cinder::backend::netapp::netapp_login', undef),
 866       netapp_password              => hiera('cinder::backend::netapp::netapp_password', undef),
 867       netapp_server_hostname       => hiera('cinder::backend::netapp::netapp_server_hostname', undef),
 868       netapp_server_port           => hiera('cinder::backend::netapp::netapp_server_port', undef),
 869       netapp_size_multiplier       => hiera('cinder::backend::netapp::netapp_size_multiplier', undef),
 870       netapp_storage_family        => hiera('cinder::backend::netapp::netapp_storage_family', undef),
 871       netapp_storage_protocol      => hiera('cinder::backend::netapp::netapp_storage_protocol', undef),
 872       netapp_transport_type        => hiera('cinder::backend::netapp::netapp_transport_type', undef),
 873       netapp_vfiler                => hiera('cinder::backend::netapp::netapp_vfiler', undef),
 874       netapp_volume_list           => hiera('cinder::backend::netapp::netapp_volume_list', undef),
 875       netapp_vserver               => hiera('cinder::backend::netapp::netapp_vserver', undef),
 876       netapp_partner_backend_name  => hiera('cinder::backend::netapp::netapp_partner_backend_name', undef),
 877       nfs_shares                   => $cinder_netapp_nfs_shares,
 878       nfs_shares_config            => hiera('cinder::backend::netapp::nfs_shares_config', undef),
 879       netapp_copyoffload_tool_path => hiera('cinder::backend::netapp::netapp_copyoffload_tool_path', undef),
 880       netapp_controller_ips        => hiera('cinder::backend::netapp::netapp_controller_ips', undef),
 881       netapp_sa_password           => hiera('cinder::backend::netapp::netapp_sa_password', undef),
 882       netapp_storage_pools         => hiera('cinder::backend::netapp::netapp_storage_pools', undef),
 883       netapp_eseries_host_type     => hiera('cinder::backend::netapp::netapp_eseries_host_type', undef),
 884       netapp_webservice_path       => hiera('cinder::backend::netapp::netapp_webservice_path', undef),
 885     }
 886   }
 887
 888   if hiera('cinder_enable_nfs_backend', false) {
 889     $cinder_nfs_backend = 'tripleo_nfs'
 890
 891     if str2bool($::selinux) {
 892       selboolean { 'virt_use_nfs':
 893         value      => on,
 894         persistent => true,
 895       } -> Package['nfs-utils']
 896     }
 897
 898     package { 'nfs-utils': } ->
 899     cinder::backend::nfs { $cinder_nfs_backend:
 900       nfs_servers       => hiera('cinder_nfs_servers'),
 901       nfs_mount_options => hiera('cinder_nfs_mount_options',''),
 902       nfs_shares_config => '/etc/cinder/shares-nfs.conf',
 903     }
 904   }
 905
 906   $cinder_enabled_backends = delete_undef_values([$cinder_iscsi_backend, $cinder_rbd_backend, $cinder_eqlx_backend, $cinder_dellsc_backend, $cinder_netapp_backend, $cinder_nfs_backend])
 907   class { '::cinder::backends' :
 908     enabled_backends => $cinder_enabled_backends,
 909   }
 910
 911   class { '::sahara':
 912     sync_db => $sync_db,
 913   }
 914   class { '::sahara::service::api':
 915     manage_service => false,
 916     enabled        => false,
 917   }
 918   class { '::sahara::service::engine':
 919     manage_service => false,
 920     enabled        => false,
 921   }
 922
 923   # swift proxy
 924   class { '::swift::proxy' :
 925     manage_service => $non_pcmk_start,
 926     enabled        => $non_pcmk_start,
 927   }
 928   include ::swift::proxy::proxy_logging
 929   include ::swift::proxy::healthcheck
 930   include ::swift::proxy::cache
 931   include ::swift::proxy::keystone
 932   include ::swift::proxy::authtoken
 933   include ::swift::proxy::staticweb
 934   include ::swift::proxy::ratelimit
 935   include ::swift::proxy::catch_errors
 936   include ::swift::proxy::tempurl
 937   include ::swift::proxy::formpost
 938
 939   # swift storage
 940   if str2bool(hiera('enable_swift_storage', true)) {
 941     class {'::swift::storage::all':
 942       mount_check => str2bool(hiera('swift_mount_check')),
 943     }
 944     class {'::swift::storage::account':
 945       manage_service => $non_pcmk_start,
 946       enabled        => $non_pcmk_start,
 947     }
 948     class {'::swift::storage::container':
 949       manage_service => $non_pcmk_start,
 950       enabled        => $non_pcmk_start,
 951     }
 952     class {'::swift::storage::object':
 953       manage_service => $non_pcmk_start,
 954       enabled        => $non_pcmk_start,
 955     }
 956     if(!defined(File['/srv/node'])) {
 957       file { '/srv/node':
 958         ensure  => directory,
 959         owner   => 'swift',
 960         group   => 'swift',
 961         require => Package['openstack-swift'],
 962       }
 963     }
 964     $swift_components = ['account', 'container', 'object']
 965     swift::storage::filter::recon { $swift_components : }
 966     swift::storage::filter::healthcheck { $swift_components : }
 967   }
 968
 969   # Ceilometer
 970   case downcase(hiera('ceilometer_backend')) {
 971     /mysql/: {
 972       $ceilometer_database_connection = hiera('ceilometer_mysql_conn_string')
 973     }
 974     default: {
 975       $mongo_node_string = join($mongo_node_ips_with_port, ',')
 976       $ceilometer_database_connection = "mongodb://${mongo_node_string}/ceilometer?replicaSet=${mongodb_replset}"
 977     }
 978   }
 979   include ::ceilometer
 980   include ::ceilometer::config
 981   class { '::ceilometer::api' :
 982     manage_service => false,
 983     enabled        => false,
 984   }
 985   class { '::ceilometer::agent::notification' :
 986     manage_service => false,
 987     enabled        => false,
 988   }
 989   class { '::ceilometer::agent::central' :
 990     manage_service => false,
 991     enabled        => false,
 992   }
 993   class { '::ceilometer::collector' :
 994     manage_service => false,
 995     enabled        => false,
 996   }
 997   include ::ceilometer::expirer
 998   class { '::ceilometer::db' :
 999     database_connection => $ceilometer_database_connection,
1000     sync_db             => $sync_db,
1001   }
1002   include ::ceilometer::agent::auth
1003
1004   Cron <| title == 'ceilometer-expirer' |> { command => "sleep $((\$(od -A n -t d -N 3 /dev/urandom) % 86400)) && ${::ceilometer::params::expirer_command}" }
1005
1006   # Heat
1007   include ::heat::config
1008   class { '::heat' :
1009     sync_db             => $sync_db,
1010     notification_driver => 'messaging',
1011   }
1012   class { '::heat::api' :
1013     manage_service => false,
1014     enabled        => false,
1015   }
1016   class { '::heat::api_cfn' :
1017     manage_service => false,
1018     enabled        => false,
1019   }
1020   class { '::heat::api_cloudwatch' :
1021     manage_service => false,
1022     enabled        => false,
1023   }
1024   class { '::heat::engine' :
1025     manage_service => false,
1026     enabled        => false,
1027   }
1028
1029   # httpd/apache and horizon
1030   # NOTE(gfidente): server-status can be consumed by the pacemaker resource agent
1031   class { '::apache' :
1032     service_enable => false,
1033     # service_manage => false, # <-- not supported with horizon&apache mod_wsgi?
1034   }
1035   include ::keystone::wsgi::apache
1036   include ::apache::mod::status
1037   if 'cisco_n1kv' in hiera('neutron::plugins::ml2::mechanism_drivers') {
1038     $_profile_support = 'cisco'
1039   } else {
1040     $_profile_support = 'None'
1041   }
1042   $neutron_options   = {'profile_support' => $_profile_support }
1043   class { '::horizon':
1044     cache_server_ip => hiera('memcache_node_ips', '127.0.0.1'),
1045     neutron_options => $neutron_options,
1046   }
1047
1048   # Aodh
1049   class { '::aodh' :
1050     database_connection => $ceilometer_database_connection,
1051   }
1052   include ::aodh::config
1053   include ::aodh::auth
1054   include ::aodh::client
1055   include ::aodh::wsgi::apache
1056   class { '::aodh::api':
1057     manage_service => false,
1058     enabled        => false,
1059     service_name   => 'httpd',
1060   }
1061   class { '::aodh::evaluator':
1062     manage_service => false,
1063     enabled        => false,
1064   }
1065   class { '::aodh::notifier':
1066     manage_service => false,
1067     enabled        => false,
1068   }
1069   class { '::aodh::listener':
1070     manage_service => false,
1071     enabled        => false,
1072   }
1073
1074   $snmpd_user = hiera('snmpd_readonly_user_name')
1075   snmp::snmpv3_user { $snmpd_user:
1076     authtype => 'MD5',
1077     authpass => hiera('snmpd_readonly_user_password'),
1078   }
1079   class { '::snmp':
1080     agentaddress => ['udp:161','udp6:[::1]:161'],
1081     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' ],
1082   }
1083
1084   hiera_include('controller_classes')
1085
1086 } #END STEP 3
1087
1088 if hiera('step') >= 4 {
1089   $keystone_enable_db_purge = hiera('keystone_enable_db_purge', true)
1090   $nova_enable_db_purge = hiera('nova_enable_db_purge', true)
1091   $cinder_enable_db_purge = hiera('cinder_enable_db_purge', true)
1092   $heat_enable_db_purge = hiera('heat_enable_db_purge', true)
1093
1094   if $keystone_enable_db_purge {
1095     include ::keystone::cron::token_flush
1096   }
1097   if $nova_enable_db_purge {
1098     include ::nova::cron::archive_deleted_rows
1099   }
1100   if $cinder_enable_db_purge {
1101     include ::cinder::cron::db_purge
1102   }
1103   if $heat_enable_db_purge {
1104     include ::heat::cron::purge_deleted
1105   }
1106
1107   if $pacemaker_master {
1108
1109     if $enable_load_balancer {
1110       pacemaker::constraint::base { 'haproxy-then-keystone-constraint':
1111         constraint_type => 'order',
1112         first_resource  => 'haproxy-clone',
1113         second_resource => "${::apache::params::service_name}-clone",
1114         first_action    => 'start',
1115         second_action   => 'start',
1116         require         => [Pacemaker::Resource::Service['haproxy'],
1117                             Pacemaker::Resource::Service[$::apache::params::service_name]],
1118       }
1119     }
1120     pacemaker::constraint::base { 'rabbitmq-then-keystone-constraint':
1121       constraint_type => 'order',
1122       first_resource  => 'rabbitmq-clone',
1123       second_resource => "${::apache::params::service_name}-clone",
1124       first_action    => 'start',
1125       second_action   => 'start',
1126       require         => [Pacemaker::Resource::Ocf['rabbitmq'],
1127                           Pacemaker::Resource::Service[$::apache::params::service_name]],
1128     }
1129     pacemaker::constraint::base { 'memcached-then-keystone-constraint':
1130       constraint_type => 'order',
1131       first_resource  => 'memcached-clone',
1132       second_resource => "${::apache::params::service_name}-clone",
1133       first_action    => 'start',
1134       second_action   => 'start',
1135       require         => [Pacemaker::Resource::Service['memcached'],
1136                           Pacemaker::Resource::Service[$::apache::params::service_name]],
1137     }
1138     pacemaker::constraint::base { 'galera-then-keystone-constraint':
1139       constraint_type => 'order',
1140       first_resource  => 'galera-master',
1141       second_resource => "${::apache::params::service_name}-clone",
1142       first_action    => 'promote',
1143       second_action   => 'start',
1144       require         => [Pacemaker::Resource::Ocf['galera'],
1145                           Pacemaker::Resource::Service[$::apache::params::service_name]],
1146     }
1147
1148     # Cinder
1149     pacemaker::resource::service { $::cinder::params::api_service :
1150       clone_params => 'interleave=true',
1151       require      => Pacemaker::Resource::Service[$::apache::params::service_name],
1152     }
1153     pacemaker::resource::service { $::cinder::params::scheduler_service :
1154       clone_params => 'interleave=true',
1155     }
1156     pacemaker::resource::service { $::cinder::params::volume_service : }
1157
1158     pacemaker::constraint::base { 'keystone-then-cinder-api-constraint':
1159       constraint_type => 'order',
1160       first_resource  => "${::apache::params::service_name}-clone",
1161       second_resource => "${::cinder::params::api_service}-clone",
1162       first_action    => 'start',
1163       second_action   => 'start',
1164       require         => [Pacemaker::Resource::Service[$::cinder::params::api_service],
1165                           Pacemaker::Resource::Service[$::apache::params::service_name]],
1166     }
1167     pacemaker::constraint::base { 'cinder-api-then-cinder-scheduler-constraint':
1168       constraint_type => 'order',
1169       first_resource  => "${::cinder::params::api_service}-clone",
1170       second_resource => "${::cinder::params::scheduler_service}-clone",
1171       first_action    => 'start',
1172       second_action   => 'start',
1173       require         => [Pacemaker::Resource::Service[$::cinder::params::api_service],
1174                           Pacemaker::Resource::Service[$::cinder::params::scheduler_service]],
1175     }
1176     pacemaker::constraint::colocation { 'cinder-scheduler-with-cinder-api-colocation':
1177       source  => "${::cinder::params::scheduler_service}-clone",
1178       target  => "${::cinder::params::api_service}-clone",
1179       score   => 'INFINITY',
1180       require => [Pacemaker::Resource::Service[$::cinder::params::api_service],
1181                   Pacemaker::Resource::Service[$::cinder::params::scheduler_service]],
1182     }
1183     pacemaker::constraint::base { 'cinder-scheduler-then-cinder-volume-constraint':
1184       constraint_type => 'order',
1185       first_resource  => "${::cinder::params::scheduler_service}-clone",
1186       second_resource => $::cinder::params::volume_service,
1187       first_action    => 'start',
1188       second_action   => 'start',
1189       require         => [Pacemaker::Resource::Service[$::cinder::params::scheduler_service],
1190                           Pacemaker::Resource::Service[$::cinder::params::volume_service]],
1191     }
1192     pacemaker::constraint::colocation { 'cinder-volume-with-cinder-scheduler-colocation':
1193       source  => $::cinder::params::volume_service,
1194       target  => "${::cinder::params::scheduler_service}-clone",
1195       score   => 'INFINITY',
1196       require => [Pacemaker::Resource::Service[$::cinder::params::scheduler_service],
1197                   Pacemaker::Resource::Service[$::cinder::params::volume_service]],
1198     }
1199
1200     # Sahara
1201     pacemaker::resource::service { $::sahara::params::api_service_name :
1202       clone_params => 'interleave=true',
1203       require      => Pacemaker::Resource::Service[$::apache::params::service_name],
1204     }
1205     pacemaker::resource::service { $::sahara::params::engine_service_name :
1206       clone_params => 'interleave=true',
1207     }
1208     pacemaker::constraint::base { 'keystone-then-sahara-api-constraint':
1209       constraint_type => 'order',
1210       first_resource  => "${::apache::params::service_name}-clone",
1211       second_resource => "${::sahara::params::api_service_name}-clone",
1212       first_action    => 'start',
1213       second_action   => 'start',
1214       require         => [Pacemaker::Resource::Service[$::sahara::params::api_service_name],
1215                           Pacemaker::Resource::Service[$::apache::params::service_name]],
1216     }
1217
1218     # Glance
1219     pacemaker::resource::service { $::glance::params::registry_service_name :
1220       clone_params => 'interleave=true',
1221       require      => Pacemaker::Resource::Service[$::apache::params::service_name],
1222     }
1223     pacemaker::resource::service { $::glance::params::api_service_name :
1224       clone_params => 'interleave=true',
1225     }
1226
1227     pacemaker::constraint::base { 'keystone-then-glance-registry-constraint':
1228       constraint_type => 'order',
1229       first_resource  => "${::apache::params::service_name}-clone",
1230       second_resource => "${::glance::params::registry_service_name}-clone",
1231       first_action    => 'start',
1232       second_action   => 'start',
1233       require         => [Pacemaker::Resource::Service[$::glance::params::registry_service_name],
1234                           Pacemaker::Resource::Service[$::apache::params::service_name]],
1235     }
1236     pacemaker::constraint::base { 'glance-registry-then-glance-api-constraint':
1237       constraint_type => 'order',
1238       first_resource  => "${::glance::params::registry_service_name}-clone",
1239       second_resource => "${::glance::params::api_service_name}-clone",
1240       first_action    => 'start',
1241       second_action   => 'start',
1242       require         => [Pacemaker::Resource::Service[$::glance::params::registry_service_name],
1243                           Pacemaker::Resource::Service[$::glance::params::api_service_name]],
1244     }
1245     pacemaker::constraint::colocation { 'glance-api-with-glance-registry-colocation':
1246       source  => "${::glance::params::api_service_name}-clone",
1247       target  => "${::glance::params::registry_service_name}-clone",
1248       score   => 'INFINITY',
1249       require => [Pacemaker::Resource::Service[$::glance::params::registry_service_name],
1250                   Pacemaker::Resource::Service[$::glance::params::api_service_name]],
1251     }
1252
1253     if hiera('step') == 4 {
1254       # Neutron
1255       # NOTE(gfidente): Neutron will try to populate the database with some data
1256       # as soon as neutron-server is started; to avoid races we want to make this
1257       # happen only on one node, before normal Pacemaker initialization
1258       # https://bugzilla.redhat.com/show_bug.cgi?id=1233061
1259       # NOTE(emilien): we need to run this Exec only at Step 4 otherwise this exec
1260       # will try to start the service while it's already started by Pacemaker
1261       # It would result to a deployment failure since systemd would return 1 to Puppet
1262       # and the overcloud would fail to deploy (6 would be returned).
1263       # This conditional prevents from a race condition during the deployment.
1264       # https://bugzilla.redhat.com/show_bug.cgi?id=1290582
1265       exec { 'neutron-server-systemd-start-sleep' :
1266         command => 'systemctl start neutron-server && /usr/bin/sleep 5',
1267         path    => '/usr/bin',
1268         unless  => '/sbin/pcs resource show neutron-server',
1269       } ->
1270       pacemaker::resource::service { $::neutron::params::server_service:
1271         clone_params => 'interleave=true',
1272         require      => Pacemaker::Resource::Service[$::apache::params::service_name]
1273       }
1274     } else {
1275       pacemaker::resource::service { $::neutron::params::server_service:
1276         clone_params => 'interleave=true',
1277         require      => Pacemaker::Resource::Service[$::apache::params::service_name]
1278       }
1279     }
1280     if hiera('neutron::enable_l3_agent', true) {
1281       pacemaker::resource::service { $::neutron::params::l3_agent_service:
1282         clone_params => 'interleave=true',
1283       }
1284     }
1285     if hiera('neutron::enable_dhcp_agent', true) {
1286       pacemaker::resource::service { $::neutron::params::dhcp_agent_service:
1287         clone_params => 'interleave=true',
1288       }
1289     }
1290     if hiera('neutron::enable_ovs_agent', true) {
1291       pacemaker::resource::service { $::neutron::params::ovs_agent_service:
1292         clone_params => 'interleave=true',
1293       }
1294     }
1295     if hiera('neutron::core_plugin') == 'midonet.neutron.plugin_v1.MidonetPluginV2' {
1296       pacemaker::resource::service {'tomcat':
1297         clone_params => 'interleave=true',
1298       }
1299     }
1300     if hiera('neutron::enable_metadata_agent', true) {
1301       pacemaker::resource::service { $::neutron::params::metadata_agent_service:
1302         clone_params => 'interleave=true',
1303       }
1304     }
1305     if hiera('neutron::enable_ovs_agent', true) {
1306       pacemaker::resource::ocf { $::neutron::params::ovs_cleanup_service:
1307         ocf_agent_name => 'neutron:OVSCleanup',
1308         clone_params   => 'interleave=true',
1309       }
1310       pacemaker::resource::ocf { 'neutron-netns-cleanup':
1311         ocf_agent_name => 'neutron:NetnsCleanup',
1312         clone_params   => 'interleave=true',
1313       }
1314
1315       # neutron - one chain ovs-cleanup-->netns-cleanup-->ovs-agent
1316       pacemaker::constraint::base { 'neutron-ovs-cleanup-to-netns-cleanup-constraint':
1317         constraint_type => 'order',
1318         first_resource  => "${::neutron::params::ovs_cleanup_service}-clone",
1319         second_resource => 'neutron-netns-cleanup-clone',
1320         first_action    => 'start',
1321         second_action   => 'start',
1322         require         => [Pacemaker::Resource::Ocf[$::neutron::params::ovs_cleanup_service],
1323                             Pacemaker::Resource::Ocf['neutron-netns-cleanup']],
1324       }
1325       pacemaker::constraint::colocation { 'neutron-ovs-cleanup-to-netns-cleanup-colocation':
1326         source  => 'neutron-netns-cleanup-clone',
1327         target  => "${::neutron::params::ovs_cleanup_service}-clone",
1328         score   => 'INFINITY',
1329         require => [Pacemaker::Resource::Ocf[$::neutron::params::ovs_cleanup_service],
1330                     Pacemaker::Resource::Ocf['neutron-netns-cleanup']],
1331       }
1332       pacemaker::constraint::base { 'neutron-netns-cleanup-to-openvswitch-agent-constraint':
1333         constraint_type => 'order',
1334         first_resource  => 'neutron-netns-cleanup-clone',
1335         second_resource => "${::neutron::params::ovs_agent_service}-clone",
1336         first_action    => 'start',
1337         second_action   => 'start',
1338         require         => [Pacemaker::Resource::Ocf['neutron-netns-cleanup'],
1339                             Pacemaker::Resource::Service[$::neutron::params::ovs_agent_service]],
1340       }
1341       pacemaker::constraint::colocation { 'neutron-netns-cleanup-to-openvswitch-agent-colocation':
1342         source  => "${::neutron::params::ovs_agent_service}-clone",
1343         target  => 'neutron-netns-cleanup-clone',
1344         score   => 'INFINITY',
1345         require => [Pacemaker::Resource::Ocf['neutron-netns-cleanup'],
1346                     Pacemaker::Resource::Service[$::neutron::params::ovs_agent_service]],
1347       }
1348     }
1349     pacemaker::constraint::base { 'keystone-to-neutron-server-constraint':
1350       constraint_type   => 'order',
1351       first_resource    => "${::apache::params::service_name}-clone",
1352         second_resource => "${::neutron::params::server_service}-clone",
1353         first_action    => 'start',
1354         second_action   => 'start',
1355         require         => [Pacemaker::Resource::Service[$::apache::params::service_name],
1356                             Pacemaker::Resource::Service[$::neutron::params::server_service]],
1357       }
1358     if hiera('neutron::enable_ovs_agent',true) {
1359       pacemaker::constraint::base { 'neutron-openvswitch-agent-to-dhcp-agent-constraint':
1360         constraint_type => 'order',
1361         first_resource  => "${::neutron::params::ovs_agent_service}-clone",
1362         second_resource => "${::neutron::params::dhcp_agent_service}-clone",
1363         first_action    => 'start',
1364         second_action   => 'start',
1365         require         => [Pacemaker::Resource::Service[$::neutron::params::ovs_agent_service],
1366                             Pacemaker::Resource::Service[$::neutron::params::dhcp_agent_service]],
1367       }
1368     }
1369     if hiera('neutron::enable_dhcp_agent',true) and hiera('neutron::enable_ovs_agent',true) {
1370       pacemaker::constraint::base { 'neutron-server-to-openvswitch-agent-constraint':
1371         constraint_type => 'order',
1372         first_resource  => "${::neutron::params::server_service}-clone",
1373         second_resource => "${::neutron::params::ovs_agent_service}-clone",
1374         first_action    => 'start',
1375         second_action   => 'start',
1376         require         => [Pacemaker::Resource::Service[$::neutron::params::server_service],
1377                             Pacemaker::Resource::Service[$::neutron::params::ovs_agent_service]],
1378     }
1379
1380       pacemaker::constraint::colocation { 'neutron-openvswitch-agent-to-dhcp-agent-colocation':
1381         source  => "${::neutron::params::dhcp_agent_service}-clone",
1382         target  => "${::neutron::params::ovs_agent_service}-clone",
1383         score   => 'INFINITY',
1384         require => [Pacemaker::Resource::Service[$::neutron::params::ovs_agent_service],
1385                     Pacemaker::Resource::Service[$::neutron::params::dhcp_agent_service]],
1386       }
1387     }
1388     if hiera('neutron::enable_dhcp_agent',true) and hiera('l3_agent_service',true) {
1389       pacemaker::constraint::base { 'neutron-dhcp-agent-to-l3-agent-constraint':
1390         constraint_type => 'order',
1391         first_resource  => "${::neutron::params::dhcp_agent_service}-clone",
1392         second_resource => "${::neutron::params::l3_agent_service}-clone",
1393         first_action    => 'start',
1394         second_action   => 'start',
1395         require         => [Pacemaker::Resource::Service[$::neutron::params::dhcp_agent_service],
1396                             Pacemaker::Resource::Service[$::neutron::params::l3_agent_service]]
1397       }
1398       pacemaker::constraint::colocation { 'neutron-dhcp-agent-to-l3-agent-colocation':
1399         source  => "${::neutron::params::l3_agent_service}-clone",
1400         target  => "${::neutron::params::dhcp_agent_service}-clone",
1401         score   => 'INFINITY',
1402         require => [Pacemaker::Resource::Service[$::neutron::params::dhcp_agent_service],
1403                     Pacemaker::Resource::Service[$::neutron::params::l3_agent_service]]
1404       }
1405     }
1406     if hiera('neutron::enable_l3_agent',true) and hiera('neutron::enable_metadata_agent',true) {
1407       pacemaker::constraint::base { 'neutron-l3-agent-to-metadata-agent-constraint':
1408         constraint_type => 'order',
1409         first_resource  => "${::neutron::params::l3_agent_service}-clone",
1410         second_resource => "${::neutron::params::metadata_agent_service}-clone",
1411         first_action    => 'start',
1412         second_action   => 'start',
1413         require         => [Pacemaker::Resource::Service[$::neutron::params::l3_agent_service],
1414                             Pacemaker::Resource::Service[$::neutron::params::metadata_agent_service]]
1415       }
1416       pacemaker::constraint::colocation { 'neutron-l3-agent-to-metadata-agent-colocation':
1417         source  => "${::neutron::params::metadata_agent_service}-clone",
1418         target  => "${::neutron::params::l3_agent_service}-clone",
1419         score   => 'INFINITY',
1420         require => [Pacemaker::Resource::Service[$::neutron::params::l3_agent_service],
1421                     Pacemaker::Resource::Service[$::neutron::params::metadata_agent_service]]
1422       }
1423     }
1424     if hiera('neutron::core_plugin') == 'midonet.neutron.plugin_v1.MidonetPluginV2' {
1425       #midonet-chain chain keystone-->neutron-server-->dhcp-->metadata->tomcat
1426       pacemaker::constraint::base { 'neutron-server-to-dhcp-agent-constraint':
1427         constraint_type => 'order',
1428         first_resource  => "${::neutron::params::server_service}-clone",
1429         second_resource => "${::neutron::params::dhcp_agent_service}-clone",
1430         first_action    => 'start',
1431         second_action   => 'start',
1432         require         => [Pacemaker::Resource::Service[$::neutron::params::server_service],
1433                             Pacemaker::Resource::Service[$::neutron::params::dhcp_agent_service]],
1434       }
1435       pacemaker::constraint::base { 'neutron-dhcp-agent-to-metadata-agent-constraint':
1436         constraint_type => 'order',
1437         first_resource  => "${::neutron::params::dhcp_agent_service}-clone",
1438         second_resource => "${::neutron::params::metadata_agent_service}-clone",
1439         first_action    => 'start',
1440         second_action   => 'start',
1441         require         => [Pacemaker::Resource::Service[$::neutron::params::dhcp_agent_service],
1442                             Pacemaker::Resource::Service[$::neutron::params::metadata_agent_service]],
1443       }
1444       pacemaker::constraint::base { 'neutron-metadata-agent-to-tomcat-constraint':
1445         constraint_type => 'order',
1446         first_resource  => "${::neutron::params::metadata_agent_service}-clone",
1447         second_resource => 'tomcat-clone',
1448         first_action    => 'start',
1449         second_action   => 'start',
1450         require         => [Pacemaker::Resource::Service[$::neutron::params::metadata_agent_service],
1451                             Pacemaker::Resource::Service['tomcat']],
1452       }
1453       pacemaker::constraint::colocation { 'neutron-dhcp-agent-to-metadata-agent-colocation':
1454         source  => "${::neutron::params::metadata_agent_service}-clone",
1455         target  => "${::neutron::params::dhcp_agent_service}-clone",
1456         score   => 'INFINITY',
1457         require => [Pacemaker::Resource::Service[$::neutron::params::dhcp_agent_service],
1458                     Pacemaker::Resource::Service[$::neutron::params::metadata_agent_service]],
1459       }
1460     }
1461
1462     # Nova
1463     pacemaker::resource::service { $::nova::params::api_service_name :
1464       clone_params => 'interleave=true',
1465     }
1466     pacemaker::resource::service { $::nova::params::conductor_service_name :
1467       clone_params => 'interleave=true',
1468     }
1469     pacemaker::resource::service { $::nova::params::consoleauth_service_name :
1470       clone_params => 'interleave=true',
1471       require      => Pacemaker::Resource::Service[$::apache::params::service_name],
1472     }
1473     pacemaker::resource::service { $::nova::params::vncproxy_service_name :
1474       clone_params => 'interleave=true',
1475     }
1476     pacemaker::resource::service { $::nova::params::scheduler_service_name :
1477       clone_params => 'interleave=true',
1478     }
1479
1480     pacemaker::constraint::base { 'keystone-then-nova-consoleauth-constraint':
1481       constraint_type => 'order',
1482       first_resource  => "${::apache::params::service_name}-clone",
1483       second_resource => "${::nova::params::consoleauth_service_name}-clone",
1484       first_action    => 'start',
1485       second_action   => 'start',
1486       require         => [Pacemaker::Resource::Service[$::nova::params::consoleauth_service_name],
1487                           Pacemaker::Resource::Service[$::apache::params::service_name]],
1488     }
1489     pacemaker::constraint::base { 'nova-consoleauth-then-nova-vncproxy-constraint':
1490       constraint_type => 'order',
1491       first_resource  => "${::nova::params::consoleauth_service_name}-clone",
1492       second_resource => "${::nova::params::vncproxy_service_name}-clone",
1493       first_action    => 'start',
1494       second_action   => 'start',
1495       require         => [Pacemaker::Resource::Service[$::nova::params::consoleauth_service_name],
1496                           Pacemaker::Resource::Service[$::nova::params::vncproxy_service_name]],
1497     }
1498     pacemaker::constraint::colocation { 'nova-vncproxy-with-nova-consoleauth-colocation':
1499       source  => "${::nova::params::vncproxy_service_name}-clone",
1500       target  => "${::nova::params::consoleauth_service_name}-clone",
1501       score   => 'INFINITY',
1502       require => [Pacemaker::Resource::Service[$::nova::params::consoleauth_service_name],
1503                   Pacemaker::Resource::Service[$::nova::params::vncproxy_service_name]],
1504     }
1505     pacemaker::constraint::base { 'nova-vncproxy-then-nova-api-constraint':
1506       constraint_type => 'order',
1507       first_resource  => "${::nova::params::vncproxy_service_name}-clone",
1508       second_resource => "${::nova::params::api_service_name}-clone",
1509       first_action    => 'start',
1510       second_action   => 'start',
1511       require         => [Pacemaker::Resource::Service[$::nova::params::vncproxy_service_name],
1512                           Pacemaker::Resource::Service[$::nova::params::api_service_name]],
1513     }
1514     pacemaker::constraint::colocation { 'nova-api-with-nova-vncproxy-colocation':
1515       source  => "${::nova::params::api_service_name}-clone",
1516       target  => "${::nova::params::vncproxy_service_name}-clone",
1517       score   => 'INFINITY',
1518       require => [Pacemaker::Resource::Service[$::nova::params::vncproxy_service_name],
1519                   Pacemaker::Resource::Service[$::nova::params::api_service_name]],
1520     }
1521     pacemaker::constraint::base { 'nova-api-then-nova-scheduler-constraint':
1522       constraint_type => 'order',
1523       first_resource  => "${::nova::params::api_service_name}-clone",
1524       second_resource => "${::nova::params::scheduler_service_name}-clone",
1525       first_action    => 'start',
1526       second_action   => 'start',
1527       require         => [Pacemaker::Resource::Service[$::nova::params::api_service_name],
1528                           Pacemaker::Resource::Service[$::nova::params::scheduler_service_name]],
1529     }
1530     pacemaker::constraint::colocation { 'nova-scheduler-with-nova-api-colocation':
1531       source  => "${::nova::params::scheduler_service_name}-clone",
1532       target  => "${::nova::params::api_service_name}-clone",
1533       score   => 'INFINITY',
1534       require => [Pacemaker::Resource::Service[$::nova::params::api_service_name],
1535                   Pacemaker::Resource::Service[$::nova::params::scheduler_service_name]],
1536     }
1537     pacemaker::constraint::base { 'nova-scheduler-then-nova-conductor-constraint':
1538       constraint_type => 'order',
1539       first_resource  => "${::nova::params::scheduler_service_name}-clone",
1540       second_resource => "${::nova::params::conductor_service_name}-clone",
1541       first_action    => 'start',
1542       second_action   => 'start',
1543       require         => [Pacemaker::Resource::Service[$::nova::params::scheduler_service_name],
1544                           Pacemaker::Resource::Service[$::nova::params::conductor_service_name]],
1545     }
1546     pacemaker::constraint::colocation { 'nova-conductor-with-nova-scheduler-colocation':
1547       source  => "${::nova::params::conductor_service_name}-clone",
1548       target  => "${::nova::params::scheduler_service_name}-clone",
1549       score   => 'INFINITY',
1550       require => [Pacemaker::Resource::Service[$::nova::params::scheduler_service_name],
1551                   Pacemaker::Resource::Service[$::nova::params::conductor_service_name]],
1552     }
1553
1554     # Ceilometer and Aodh
1555     case downcase(hiera('ceilometer_backend')) {
1556       /mysql/: {
1557         pacemaker::resource::service { $::ceilometer::params::agent_central_service_name :
1558           clone_params => 'interleave=true',
1559           require      => Pacemaker::Resource::Service[$::apache::params::service_name],
1560         }
1561       }
1562       default: {
1563         pacemaker::resource::service { $::ceilometer::params::agent_central_service_name :
1564           clone_params => 'interleave=true',
1565           require      => [Pacemaker::Resource::Service[$::apache::params::service_name],
1566           Pacemaker::Resource::Service[$::mongodb::params::service_name]],
1567         }
1568       }
1569     }
1570     pacemaker::resource::service { $::ceilometer::params::collector_service_name :
1571       clone_params => 'interleave=true',
1572     }
1573     pacemaker::resource::service { $::ceilometer::params::api_service_name :
1574       clone_params => 'interleave=true',
1575     }
1576     pacemaker::resource::service { $::ceilometer::params::agent_notification_service_name :
1577       clone_params => 'interleave=true',
1578     }
1579     pacemaker::resource::ocf { 'delay' :
1580       ocf_agent_name  => 'heartbeat:Delay',
1581       clone_params    => 'interleave=true',
1582       resource_params => 'startdelay=10',
1583     }
1584     # Fedora doesn't know `require-all` parameter for constraints yet
1585     if $::operatingsystem == 'Fedora' {
1586       $redis_ceilometer_constraint_params = undef
1587       $redis_aodh_constraint_params = undef
1588     } else {
1589       $redis_ceilometer_constraint_params = 'require-all=false'
1590       $redis_aodh_constraint_params = 'require-all=false'
1591     }
1592     pacemaker::constraint::base { 'redis-then-ceilometer-central-constraint':
1593       constraint_type   => 'order',
1594       first_resource    => 'redis-master',
1595       second_resource   => "${::ceilometer::params::agent_central_service_name}-clone",
1596       first_action      => 'promote',
1597       second_action     => 'start',
1598       constraint_params => $redis_ceilometer_constraint_params,
1599       require           => [Pacemaker::Resource::Ocf['redis'],
1600                             Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name]],
1601     }
1602     pacemaker::constraint::base { 'redis-then-aodh-evaluator-constraint':
1603       constraint_type   => 'order',
1604       first_resource    => 'redis-master',
1605       second_resource   => "${::aodh::params::evaluator_service_name}-clone",
1606       first_action      => 'promote',
1607       second_action     => 'start',
1608       constraint_params => $redis_aodh_constraint_params,
1609       require           => [Pacemaker::Resource::Ocf['redis'],
1610                             Pacemaker::Resource::Service[$::aodh::params::evaluator_service_name]],
1611     }
1612     pacemaker::constraint::base { 'keystone-then-ceilometer-central-constraint':
1613       constraint_type => 'order',
1614       first_resource  => "${::apache::params::service_name}-clone",
1615       second_resource => "${::ceilometer::params::agent_central_service_name}-clone",
1616       first_action    => 'start',
1617       second_action   => 'start',
1618       require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
1619                           Pacemaker::Resource::Service[$::apache::params::service_name]],
1620     }
1621     pacemaker::constraint::base { 'ceilometer-central-then-ceilometer-collector-constraint':
1622       constraint_type => 'order',
1623       first_resource  => "${::ceilometer::params::agent_central_service_name}-clone",
1624       second_resource => "${::ceilometer::params::collector_service_name}-clone",
1625       first_action    => 'start',
1626       second_action   => 'start',
1627       require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
1628                           Pacemaker::Resource::Service[$::ceilometer::params::collector_service_name]],
1629     }
1630     pacemaker::constraint::base { 'ceilometer-collector-then-ceilometer-api-constraint':
1631       constraint_type => 'order',
1632       first_resource  => "${::ceilometer::params::collector_service_name}-clone",
1633       second_resource => "${::ceilometer::params::api_service_name}-clone",
1634       first_action    => 'start',
1635       second_action   => 'start',
1636       require         => [Pacemaker::Resource::Service[$::ceilometer::params::collector_service_name],
1637                           Pacemaker::Resource::Service[$::ceilometer::params::api_service_name]],
1638     }
1639     pacemaker::constraint::colocation { 'ceilometer-api-with-ceilometer-collector-colocation':
1640       source  => "${::ceilometer::params::api_service_name}-clone",
1641       target  => "${::ceilometer::params::collector_service_name}-clone",
1642       score   => 'INFINITY',
1643       require => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
1644                   Pacemaker::Resource::Service[$::ceilometer::params::collector_service_name]],
1645     }
1646     pacemaker::constraint::base { 'ceilometer-api-then-ceilometer-delay-constraint':
1647       constraint_type => 'order',
1648       first_resource  => "${::ceilometer::params::api_service_name}-clone",
1649       second_resource => 'delay-clone',
1650       first_action    => 'start',
1651       second_action   => 'start',
1652       require         => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
1653                           Pacemaker::Resource::Ocf['delay']],
1654     }
1655     pacemaker::constraint::colocation { 'ceilometer-delay-with-ceilometer-api-colocation':
1656       source  => 'delay-clone',
1657       target  => "${::ceilometer::params::api_service_name}-clone",
1658       score   => 'INFINITY',
1659       require => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
1660                   Pacemaker::Resource::Ocf['delay']],
1661     }
1662     # Aodh
1663     pacemaker::resource::service { $::aodh::params::api_service_name :
1664       clone_params => 'interleave=true',
1665     }
1666     pacemaker::resource::service { $::aodh::params::evaluator_service_name :
1667       clone_params => 'interleave=true',
1668     }
1669     pacemaker::resource::service { $::aodh::params::notifier_service_name :
1670       clone_params => 'interleave=true',
1671     }
1672     pacemaker::resource::service { $::aodh::params::listener_service_name :
1673       clone_params => 'interleave=true',
1674     }
1675     pacemaker::constraint::base { 'keystone-then-aodh-api-constraint':
1676       constraint_type => 'order',
1677       first_resource  => "${::apache::params::service_name}-clone",
1678       second_resource => "${::aodh::params::api_service_name}-clone",
1679       first_action    => 'start',
1680       second_action   => 'start',
1681       require         => [Pacemaker::Resource::Service[$::aodh::params::api_service_name],
1682                           Pacemaker::Resource::Service[$::apache::params::service_name]],
1683     }
1684     pacemaker::constraint::base { 'aodh-delay-then-aodh-evaluator-constraint':
1685       constraint_type => 'order',
1686       first_resource  => 'delay-clone',
1687       second_resource => "${::aodh::params::evaluator_service_name}-clone",
1688       first_action    => 'start',
1689       second_action   => 'start',
1690       require         => [Pacemaker::Resource::Service[$::aodh::params::evaluator_service_name],
1691                           Pacemaker::Resource::Ocf['delay']],
1692     }
1693     pacemaker::constraint::colocation { 'aodh-evaluator-with-aodh-delay-colocation':
1694       source  => "${::aodh::params::evaluator_service_name}-clone",
1695       target  => 'delay-clone',
1696       score   => 'INFINITY',
1697       require => [Pacemaker::Resource::Service[$::horizon::params::http_service],
1698                   Pacemaker::Resource::Ocf['delay']],
1699     }
1700     pacemaker::constraint::base { 'aodh-evaluator-then-aodh-notifier-constraint':
1701       constraint_type => 'order',
1702       first_resource  => "${::aodh::params::evaluator_service_name}-clone",
1703       second_resource => "${::aodh::params::notifier_service_name}-clone",
1704       first_action    => 'start',
1705       second_action   => 'start',
1706       require         => [Pacemaker::Resource::Service[$::aodh::params::evaluator_service_name],
1707                           Pacemaker::Resource::Service[$::aodh::params::notifier_service_name]],
1708     }
1709     pacemaker::constraint::colocation { 'aodh-notifier-with-aodh-evaluator-colocation':
1710       source  => "${::aodh::params::notifier_service_name}-clone",
1711       target  => "${::aodh::params::evaluator_service_name}-clone",
1712       score   => 'INFINITY',
1713       require => [Pacemaker::Resource::Service[$::aodh::params::evaluator_service_name],
1714                   Pacemaker::Resource::Service[$::aodh::params::notifier_service_name]],
1715     }
1716     if downcase(hiera('ceilometer_backend')) == 'mongodb' {
1717       pacemaker::constraint::base { 'mongodb-then-ceilometer-central-constraint':
1718         constraint_type => 'order',
1719         first_resource  => "${::mongodb::params::service_name}-clone",
1720         second_resource => "${::ceilometer::params::agent_central_service_name}-clone",
1721         first_action    => 'start',
1722         second_action   => 'start',
1723         require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
1724                             Pacemaker::Resource::Service[$::mongodb::params::service_name]],
1725       }
1726     }
1727
1728     # Heat
1729     pacemaker::resource::service { $::heat::params::api_service_name :
1730       clone_params => 'interleave=true',
1731     }
1732     pacemaker::resource::service { $::heat::params::api_cloudwatch_service_name :
1733       clone_params => 'interleave=true',
1734     }
1735     pacemaker::resource::service { $::heat::params::api_cfn_service_name :
1736       clone_params => 'interleave=true',
1737     }
1738     pacemaker::resource::service { $::heat::params::engine_service_name :
1739       clone_params => 'interleave=true',
1740     }
1741     pacemaker::constraint::base { 'keystone-then-heat-api-constraint':
1742       constraint_type => 'order',
1743       first_resource  => "${::apache::params::service_name}-clone",
1744       second_resource => "${::heat::params::api_service_name}-clone",
1745       first_action    => 'start',
1746       second_action   => 'start',
1747       require         => [Pacemaker::Resource::Service[$::heat::params::api_service_name],
1748                           Pacemaker::Resource::Service[$::apache::params::service_name]],
1749     }
1750     pacemaker::constraint::base { 'heat-api-then-heat-api-cfn-constraint':
1751       constraint_type => 'order',
1752       first_resource  => "${::heat::params::api_service_name}-clone",
1753       second_resource => "${::heat::params::api_cfn_service_name}-clone",
1754       first_action    => 'start',
1755       second_action   => 'start',
1756       require         => [Pacemaker::Resource::Service[$::heat::params::api_service_name],
1757                           Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name]],
1758     }
1759     pacemaker::constraint::colocation { 'heat-api-cfn-with-heat-api-colocation':
1760       source  => "${::heat::params::api_cfn_service_name}-clone",
1761       target  => "${::heat::params::api_service_name}-clone",
1762       score   => 'INFINITY',
1763       require => [Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name],
1764                   Pacemaker::Resource::Service[$::heat::params::api_service_name]],
1765     }
1766     pacemaker::constraint::base { 'heat-api-cfn-then-heat-api-cloudwatch-constraint':
1767       constraint_type => 'order',
1768       first_resource  => "${::heat::params::api_cfn_service_name}-clone",
1769       second_resource => "${::heat::params::api_cloudwatch_service_name}-clone",
1770       first_action    => 'start',
1771       second_action   => 'start',
1772       require         => [Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name],
1773                           Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name]],
1774     }
1775     pacemaker::constraint::colocation { 'heat-api-cloudwatch-with-heat-api-cfn-colocation':
1776       source  => "${::heat::params::api_cloudwatch_service_name}-clone",
1777       target  => "${::heat::params::api_cfn_service_name}-clone",
1778       score   => 'INFINITY',
1779       require => [Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name],
1780                   Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name]],
1781     }
1782     pacemaker::constraint::base { 'heat-api-cloudwatch-then-heat-engine-constraint':
1783       constraint_type => 'order',
1784       first_resource  => "${::heat::params::api_cloudwatch_service_name}-clone",
1785       second_resource => "${::heat::params::engine_service_name}-clone",
1786       first_action    => 'start',
1787       second_action   => 'start',
1788       require         => [Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name],
1789                           Pacemaker::Resource::Service[$::heat::params::engine_service_name]],
1790     }
1791     pacemaker::constraint::colocation { 'heat-engine-with-heat-api-cloudwatch-colocation':
1792       source  => "${::heat::params::engine_service_name}-clone",
1793       target  => "${::heat::params::api_cloudwatch_service_name}-clone",
1794       score   => 'INFINITY',
1795       require => [Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name],
1796                   Pacemaker::Resource::Service[$::heat::params::engine_service_name]],
1797     }
1798     pacemaker::constraint::base { 'ceilometer-notification-then-heat-api-constraint':
1799       constraint_type => 'order',
1800       first_resource  => "${::ceilometer::params::agent_notification_service_name}-clone",
1801       second_resource => "${::heat::params::api_service_name}-clone",
1802       first_action    => 'start',
1803       second_action   => 'start',
1804       require         => [Pacemaker::Resource::Service[$::heat::params::api_service_name],
1805                           Pacemaker::Resource::Service[$::ceilometer::params::agent_notification_service_name]],
1806     }
1807
1808     # Horizon and Keystone
1809     pacemaker::resource::service { $::apache::params::service_name:
1810       clone_params     => 'interleave=true',
1811       verify_on_create => true,
1812       require          => [File['/etc/keystone/ssl/certs/ca.pem'],
1813       File['/etc/keystone/ssl/private/signing_key.pem'],
1814       File['/etc/keystone/ssl/certs/signing_cert.pem']],
1815     }
1816
1817     #VSM
1818     if 'cisco_n1kv' in hiera('neutron::plugins::ml2::mechanism_drivers') {
1819       pacemaker::resource::ocf { 'vsm-p' :
1820         ocf_agent_name  => 'heartbeat:VirtualDomain',
1821         resource_params => 'force_stop=true config=/var/spool/cisco/vsm/vsm_primary_deploy.xml',
1822         require         => Class['n1k_vsm'],
1823         meta_params     => 'resource-stickiness=INFINITY',
1824       }
1825       if str2bool(hiera('n1k_vsm::pacemaker_control', true)) {
1826         pacemaker::resource::ocf { 'vsm-s' :
1827           ocf_agent_name  => 'heartbeat:VirtualDomain',
1828           resource_params => 'force_stop=true config=/var/spool/cisco/vsm/vsm_secondary_deploy.xml',
1829           require         => Class['n1k_vsm'],
1830           meta_params     => 'resource-stickiness=INFINITY',
1831         }
1832         pacemaker::constraint::colocation { 'vsm-colocation-contraint':
1833           source  => 'vsm-p',
1834           target  => 'vsm-s',
1835           score   => '-INFINITY',
1836           require => [Pacemaker::Resource::Ocf['vsm-p'],
1837                       Pacemaker::Resource::Ocf['vsm-s']],
1838         }
1839       }
1840     }
1841
1842   }
1843
1844 } #END STEP 4
1845
1846 if hiera('step') >= 5 {
1847
1848   if $pacemaker_master {
1849
1850     class {'::keystone::roles::admin' :
1851       require => Pacemaker::Resource::Service[$::apache::params::service_name],
1852     } ->
1853     class {'::keystone::endpoint' :
1854       require => Pacemaker::Resource::Service[$::apache::params::service_name],
1855     }
1856   }
1857
1858 } #END STEP 5
1859
1860 $package_manifest_name = join(['/var/lib/tripleo/installed-packages/overcloud_controller_pacemaker', hiera('step')])
1861 package_manifest{$package_manifest_name: ensure => present}