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