puppet/manifests/overcloud_controller_pacemaker.pp

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