X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=puppet%2Fmanifests%2Fovercloud_controller_pacemaker.pp;h=d6d14a830eb1dbf5bd63d100d0a8fdae368b14cf;hb=7903fc743bd3e445ef48c2d08a4bd3115f825e0b;hp=b271114fd7ba6589b0c89a1974b97679463dea56;hpb=7d704fbd074cdeb2b381aab353ee1deaeb9ae736;p=apex-tripleo-heat-templates.git

diff --git a/puppet/manifests/overcloud_controller_pacemaker.pp b/puppet/manifests/overcloud_controller_pacemaker.pp
index b271114f..d6d14a83 100644
--- a/puppet/manifests/overcloud_controller_pacemaker.pp
+++ b/puppet/manifests/overcloud_controller_pacemaker.pp
@@ -23,9 +23,7 @@ Service <|
   tag == 'aodh-service' or
   tag == 'cinder-service' or
   tag == 'ceilometer-service' or
-  tag == 'glance-service' or
-  tag == 'heat-service' or
-  tag == 'keystone-service' or
+  tag == 'gnocchi-service' or
   tag == 'neutron-service' or
   tag == 'nova-service' or
   tag == 'sahara-service'
@@ -47,7 +45,7 @@ if $::hostname == downcase(hiera('bootstrap_nodeid')) {
   $sync_db = false
 }
 
-$enable_fencing = str2bool(hiera('enable_fencing', false)) and hiera('step') >= 6
+$enable_fencing = str2bool(hiera('enable_fencing', false)) and hiera('step') >= 5
 $enable_load_balancer = hiera('enable_load_balancer', true)
 
 # When to start and enable services which haven't been Pacemakerized
@@ -67,24 +65,12 @@ if hiera('step') >= 1 {
     include ::ntp
   }
 
-  $controller_node_ips = split(hiera('controller_node_ips'), ',')
-  $controller_node_names = split(downcase(hiera('controller_node_names')), ',')
-  if $enable_load_balancer {
-    class { '::tripleo::loadbalancer' :
-      controller_hosts       => $controller_node_ips,
-      controller_hosts_names => $controller_node_names,
-      manage_vip             => false,
-      mysql_clustercheck     => true,
-      haproxy_service_manage => false,
-    }
-  }
-
   $pacemaker_cluster_members = downcase(regsubst(hiera('controller_node_names'), ',', ' ', 'G'))
   $corosync_ipv6 = str2bool(hiera('corosync_ipv6', false))
   if $corosync_ipv6 {
-    $cluster_setup_extras = { '--ipv6' => '' }
+    $cluster_setup_extras = { '--token' => hiera('corosync_token_timeout', 1000), '--ipv6' => '' }
   } else {
-    $cluster_setup_extras = {}
+    $cluster_setup_extras = { '--token' => hiera('corosync_token_timeout', 1000) }
   }
   class { '::pacemaker':
     hacluster_pwd => hiera('hacluster_pwd'),
@@ -100,6 +86,10 @@ if hiera('step') >= 1 {
   if $enable_fencing {
     include ::tripleo::fencing
 
+    # enable stonith after all Pacemaker resources have been created
+    Pcmk_resource<||> -> Class['tripleo::fencing']
+    Pcmk_constraint<||> -> Class['tripleo::fencing']
+    Exec <| tag == 'pacemaker_constraint' |> -> Class['tripleo::fencing']
     # enable stonith after all fencing devices have been created
     Class['tripleo::fencing'] -> Class['pacemaker::stonith']
   }
@@ -111,35 +101,6 @@ if hiera('step') >= 1 {
     op_params => 'start timeout=200s stop timeout=200s',
   }
 
-  # Only configure RabbitMQ in this step, don't start it yet to
-  # avoid races where non-master nodes attempt to start without
-  # config (eg. binding on 0.0.0.0)
-  # The module ignores erlang_cookie if cluster_config is false
-  $rabbit_ipv6 = str2bool(hiera('rabbit_ipv6', false))
-  if $rabbit_ipv6 {
-      $rabbit_env = merge(hiera('rabbitmq_environment'), {
-        'RABBITMQ_SERVER_START_ARGS' => '"-proto_dist inet6_tcp"'
-      })
-  } else {
-    $rabbit_env = hiera('rabbitmq_environment')
-  }
-
-  class { '::rabbitmq':
-    service_manage          => false,
-    tcp_keepalive           => false,
-    config_kernel_variables => hiera('rabbitmq_kernel_variables'),
-    config_variables        => hiera('rabbitmq_config_variables'),
-    environment_variables   => $rabbit_env,
-  } ->
-  file { '/var/lib/rabbitmq/.erlang.cookie':
-    ensure  => file,
-    owner   => 'rabbitmq',
-    group   => 'rabbitmq',
-    mode    => '0400',
-    content => hiera('rabbitmq::erlang_cookie'),
-    replace => true,
-  }
-
   if downcase(hiera('ceilometer_backend')) == 'mongodb' {
     include ::mongodb::globals
     include ::mongodb::client
@@ -148,11 +109,6 @@ if hiera('step') >= 1 {
     }
   }
 
-  # Memcached
-  class {'::memcached' :
-    service_manage => false,
-  }
-
   # Redis
   class { '::redis' :
     service_manage => false,
@@ -185,8 +141,10 @@ if hiera('step') >= 1 {
       'bind-address'                  => $::hostname,
       'max_connections'               => hiera('mysql_max_connections'),
       'open_files_limit'              => '-1',
+      'wsrep_on'                      => 'ON',
       'wsrep_provider'                => '/usr/lib64/galera/libgalera_smm.so',
       'wsrep_cluster_name'            => 'galera_cluster',
+      'wsrep_cluster_address'         => "gcomm://${galera_nodes}",
       'wsrep_slave_threads'           => '1',
       'wsrep_certify_nonPK'           => '1',
       'wsrep_max_ws_rows'             => '131072',
@@ -234,214 +192,12 @@ if hiera('step') >= 2 {
 
   if $pacemaker_master {
 
-    if $enable_load_balancer {
-
-      include ::pacemaker::resource_defaults
-
-      # Create an openstack-core dummy resource. See RHBZ 1290121
-      pacemaker::resource::ocf { 'openstack-core':
-        ocf_agent_name => 'heartbeat:Dummy',
-        clone_params   => true,
-      }
-      # FIXME: we should not have to access tripleo::loadbalancer class
-      # parameters here to configure pacemaker VIPs. The configuration
-      # of pacemaker VIPs could move into puppet-tripleo or we should
-      # make use of less specific hiera parameters here for the settings.
-      pacemaker::resource::service { 'haproxy':
-        clone_params => true,
-      }
-
-      $control_vip = hiera('tripleo::loadbalancer::controller_virtual_ip')
-      if is_ipv6_address($control_vip) {
-        $control_vip_netmask = '64'
-      } else {
-        $control_vip_netmask = '32'
-      }
-      pacemaker::resource::ip { 'control_vip':
-        ip_address   => $control_vip,
-        cidr_netmask => $control_vip_netmask,
-      }
-      pacemaker::constraint::base { 'control_vip-then-haproxy':
-        constraint_type   => 'order',
-        first_resource    => "ip-${control_vip}",
-        second_resource   => 'haproxy-clone',
-        first_action      => 'start',
-        second_action     => 'start',
-        constraint_params => 'kind=Optional',
-        require           => [Pacemaker::Resource::Service['haproxy'],
-                              Pacemaker::Resource::Ip['control_vip']],
-      }
-      pacemaker::constraint::colocation { 'control_vip-with-haproxy':
-        source  => "ip-${control_vip}",
-        target  => 'haproxy-clone',
-        score   => 'INFINITY',
-        require => [Pacemaker::Resource::Service['haproxy'],
-                    Pacemaker::Resource::Ip['control_vip']],
-      }
-
-      $public_vip = hiera('tripleo::loadbalancer::public_virtual_ip')
-      if is_ipv6_address($public_vip) {
-        $public_vip_netmask = '64'
-      } else {
-        $public_vip_netmask = '32'
-      }
-      if $public_vip and $public_vip != $control_vip {
-        pacemaker::resource::ip { 'public_vip':
-          ip_address   => $public_vip,
-          cidr_netmask => $public_vip_netmask,
-        }
-        pacemaker::constraint::base { 'public_vip-then-haproxy':
-          constraint_type   => 'order',
-          first_resource    => "ip-${public_vip}",
-          second_resource   => 'haproxy-clone',
-          first_action      => 'start',
-          second_action     => 'start',
-          constraint_params => 'kind=Optional',
-          require           => [Pacemaker::Resource::Service['haproxy'],
-                                Pacemaker::Resource::Ip['public_vip']],
-        }
-        pacemaker::constraint::colocation { 'public_vip-with-haproxy':
-          source  => "ip-${public_vip}",
-          target  => 'haproxy-clone',
-          score   => 'INFINITY',
-          require => [Pacemaker::Resource::Service['haproxy'],
-                      Pacemaker::Resource::Ip['public_vip']],
-        }
-      }
-
-      $redis_vip = hiera('redis_vip')
-      if is_ipv6_address($redis_vip) {
-        $redis_vip_netmask = '64'
-      } else {
-        $redis_vip_netmask = '32'
-      }
-      if $redis_vip and $redis_vip != $control_vip {
-        pacemaker::resource::ip { 'redis_vip':
-          ip_address   => $redis_vip,
-          cidr_netmask => $redis_vip_netmask,
-        }
-        pacemaker::constraint::base { 'redis_vip-then-haproxy':
-          constraint_type   => 'order',
-          first_resource    => "ip-${redis_vip}",
-          second_resource   => 'haproxy-clone',
-          first_action      => 'start',
-          second_action     => 'start',
-          constraint_params => 'kind=Optional',
-          require           => [Pacemaker::Resource::Service['haproxy'],
-                                Pacemaker::Resource::Ip['redis_vip']],
-        }
-        pacemaker::constraint::colocation { 'redis_vip-with-haproxy':
-          source  => "ip-${redis_vip}",
-          target  => 'haproxy-clone',
-          score   => 'INFINITY',
-          require => [Pacemaker::Resource::Service['haproxy'],
-                      Pacemaker::Resource::Ip['redis_vip']],
-        }
-      }
-
-      $internal_api_vip = hiera('tripleo::loadbalancer::internal_api_virtual_ip')
-      if is_ipv6_address($internal_api_vip) {
-        $internal_api_vip_netmask = '64'
-      } else {
-        $internal_api_vip_netmask = '32'
-      }
-      if $internal_api_vip and $internal_api_vip != $control_vip {
-        pacemaker::resource::ip { 'internal_api_vip':
-          ip_address   => $internal_api_vip,
-          cidr_netmask => $internal_api_vip_netmask,
-        }
-        pacemaker::constraint::base { 'internal_api_vip-then-haproxy':
-          constraint_type   => 'order',
-          first_resource    => "ip-${internal_api_vip}",
-          second_resource   => 'haproxy-clone',
-          first_action      => 'start',
-          second_action     => 'start',
-          constraint_params => 'kind=Optional',
-          require           => [Pacemaker::Resource::Service['haproxy'],
-                                Pacemaker::Resource::Ip['internal_api_vip']],
-        }
-        pacemaker::constraint::colocation { 'internal_api_vip-with-haproxy':
-          source  => "ip-${internal_api_vip}",
-          target  => 'haproxy-clone',
-          score   => 'INFINITY',
-          require => [Pacemaker::Resource::Service['haproxy'],
-                      Pacemaker::Resource::Ip['internal_api_vip']],
-        }
-      }
-
-      $storage_vip = hiera('tripleo::loadbalancer::storage_virtual_ip')
-      if is_ipv6_address($storage_vip) {
-        $storage_vip_netmask = '64'
-      } else {
-        $storage_vip_netmask = '32'
-      }
-      if $storage_vip and $storage_vip != $control_vip {
-        pacemaker::resource::ip { 'storage_vip':
-          ip_address   => $storage_vip,
-          cidr_netmask => $storage_vip_netmask,
-        }
-        pacemaker::constraint::base { 'storage_vip-then-haproxy':
-          constraint_type   => 'order',
-          first_resource    => "ip-${storage_vip}",
-          second_resource   => 'haproxy-clone',
-          first_action      => 'start',
-          second_action     => 'start',
-          constraint_params => 'kind=Optional',
-          require           => [Pacemaker::Resource::Service['haproxy'],
-                                Pacemaker::Resource::Ip['storage_vip']],
-        }
-        pacemaker::constraint::colocation { 'storage_vip-with-haproxy':
-          source  => "ip-${storage_vip}",
-          target  => 'haproxy-clone',
-          score   => 'INFINITY',
-          require => [Pacemaker::Resource::Service['haproxy'],
-                      Pacemaker::Resource::Ip['storage_vip']],
-        }
-      }
-
-      $storage_mgmt_vip = hiera('tripleo::loadbalancer::storage_mgmt_virtual_ip')
-      if is_ipv6_address($storage_mgmt_vip) {
-        $storage_mgmt_vip_netmask = '64'
-      } else {
-        $storage_mgmt_vip_netmask = '32'
-      }
-      if $storage_mgmt_vip and $storage_mgmt_vip != $control_vip {
-        pacemaker::resource::ip { 'storage_mgmt_vip':
-          ip_address   => $storage_mgmt_vip,
-          cidr_netmask => $storage_mgmt_vip_netmask,
-        }
-        pacemaker::constraint::base { 'storage_mgmt_vip-then-haproxy':
-          constraint_type   => 'order',
-          first_resource    => "ip-${storage_mgmt_vip}",
-          second_resource   => 'haproxy-clone',
-          first_action      => 'start',
-          second_action     => 'start',
-          constraint_params => 'kind=Optional',
-          require           => [Pacemaker::Resource::Service['haproxy'],
-                                Pacemaker::Resource::Ip['storage_mgmt_vip']],
-        }
-        pacemaker::constraint::colocation { 'storage_mgmt_vip-with-haproxy':
-          source  => "ip-${storage_mgmt_vip}",
-          target  => 'haproxy-clone',
-          score   => 'INFINITY',
-          require => [Pacemaker::Resource::Service['haproxy'],
-                      Pacemaker::Resource::Ip['storage_mgmt_vip']],
-        }
-      }
+    include ::pacemaker::resource_defaults
 
-    }
-
-    pacemaker::resource::service { $::memcached::params::service_name :
-      clone_params => 'interleave=true',
-      require      => Class['::memcached'],
-    }
-
-    pacemaker::resource::ocf { 'rabbitmq':
-      ocf_agent_name  => 'heartbeat:rabbitmq-cluster',
-      resource_params => 'set_policy=\'ha-all ^(?!amq\.).* {"ha-mode":"all"}\'',
-      clone_params    => 'ordered=true interleave=true',
-      meta_params     => 'notify=true',
-      require         => Class['::rabbitmq'],
+    # Create an openstack-core dummy resource. See RHBZ 1290121
+    pacemaker::resource::ocf { 'openstack-core':
+      ocf_agent_name => 'heartbeat:Dummy',
+      clone_params   => true,
     }
 
     if downcase(hiera('ceilometer_backend')) == 'mongodb' {
@@ -481,6 +237,16 @@ if hiera('step') >= 2 {
     }
 
   }
+  $mysql_root_password = hiera('mysql::server::root_password')
+  $mysql_clustercheck_password = hiera('mysql_clustercheck_password')
+  # This step is to create a sysconfig clustercheck file with the root user and empty password
+  # on the first install only (because later on the clustercheck db user will be used)
+  # We are using exec and not file in order to not have duplicate definition errors in puppet
+  # when we later set the the file to contain the clustercheck data
+  exec { 'create-root-sysconfig-clustercheck':
+    command => "/bin/echo 'MYSQL_USERNAME=root\nMYSQL_PASSWORD=\'\'\nMYSQL_HOST=localhost\n' > /etc/sysconfig/clustercheck",
+    unless  => '/bin/test -e /etc/sysconfig/clustercheck && grep -q clustercheck /etc/sysconfig/clustercheck',
+  }
 
   exec { 'galera-ready' :
     command     => '/usr/bin/clustercheck >/dev/null',
@@ -488,14 +254,7 @@ if hiera('step') >= 2 {
     tries       => 180,
     try_sleep   => 10,
     environment => ['AVAILABLE_WHEN_READONLY=0'],
-    require     => File['/etc/sysconfig/clustercheck'],
-  }
-
-  file { '/etc/sysconfig/clustercheck' :
-    ensure  => file,
-    content => "MYSQL_USERNAME=root\n
-MYSQL_PASSWORD=''\n
-MYSQL_HOST=localhost\n",
+    require     => Exec['create-root-sysconfig-clustercheck'],
   }
 
   xinetd::service { 'galera-monitor' :
@@ -508,17 +267,28 @@ MYSQL_HOST=localhost\n",
     service_type   => 'UNLISTED',
     user           => 'root',
     group          => 'root',
-    require        => File['/etc/sysconfig/clustercheck'],
+    require        => Exec['create-root-sysconfig-clustercheck'],
+  }
+  # We add a clustercheck db user and we will switch /etc/sysconfig/clustercheck
+  # to it in a later step. We do this only on one node as it will replicate on
+  # the other members. We also make sure that the permissions are the minimum necessary
+  if $pacemaker_master {
+    mysql_user { 'clustercheck@localhost':
+      ensure        => 'present',
+      password_hash => mysql_password($mysql_clustercheck_password),
+      require       => Exec['galera-ready'],
+    }
+    mysql_grant { 'clustercheck@localhost/*.*':
+      ensure     => 'present',
+      options    => ['GRANT'],
+      privileges => ['PROCESS'],
+      table      => '*.*',
+      user       => 'clustercheck@localhost',
+    }
   }
 
   # Create all the database schemas
   if $sync_db {
-    class { '::keystone::db::mysql':
-      require => Exec['galera-ready'],
-    }
-    class { '::glance::db::mysql':
-      require => Exec['galera-ready'],
-    }
     class { '::nova::db::mysql':
       require => Exec['galera-ready'],
     }
@@ -531,9 +301,6 @@ MYSQL_HOST=localhost\n",
     class { '::cinder::db::mysql':
       require => Exec['galera-ready'],
     }
-    class { '::heat::db::mysql':
-      require => Exec['galera-ready'],
-    }
 
     if downcase(hiera('ceilometer_backend')) == 'mysql' {
       class { '::ceilometer::db::mysql':
@@ -541,14 +308,16 @@ MYSQL_HOST=localhost\n",
       }
     }
 
+    if downcase(hiera('gnocchi_indexer_backend')) == 'mysql' {
+      class { '::gnocchi::db::mysql':
+        require => Exec['galera-ready'],
+      }
+    }
     class { '::sahara::db::mysql':
       require       => Exec['galera-ready'],
     }
   }
 
-  # pre-install swift here so we can build rings
-  include ::swift
-
   # Ceph
   $enable_ceph = hiera('ceph_storage_count', 0) > 0 or hiera('enable_ceph_storage', false)
 
@@ -602,82 +371,18 @@ MYSQL_HOST=localhost\n",
 
 } #END STEP 2
 
-if hiera('step') >= 4 {
-
-  class { '::keystone':
-    sync_db          => $sync_db,
-    manage_service   => false,
-    enabled          => false,
-    enable_bootstrap => $pacemaker_master,
-  }
-  include ::keystone::config
-
-  #TODO: need a cleanup-keystone-tokens.sh solution here
-
-  file { [ '/etc/keystone/ssl', '/etc/keystone/ssl/certs', '/etc/keystone/ssl/private' ]:
-    ensure  => 'directory',
-    owner   => 'keystone',
-    group   => 'keystone',
-    require => Package['keystone'],
-  }
-  file { '/etc/keystone/ssl/certs/signing_cert.pem':
-    content => hiera('keystone_signing_certificate'),
-    owner   => 'keystone',
-    group   => 'keystone',
-    notify  => Service['keystone'],
-    require => File['/etc/keystone/ssl/certs'],
-  }
-  file { '/etc/keystone/ssl/private/signing_key.pem':
-    content => hiera('keystone_signing_key'),
-    owner   => 'keystone',
-    group   => 'keystone',
-    notify  => Service['keystone'],
-    require => File['/etc/keystone/ssl/private'],
-  }
-  file { '/etc/keystone/ssl/certs/ca.pem':
-    content => hiera('keystone_ca_certificate'),
-    owner   => 'keystone',
-    group   => 'keystone',
-    notify  => Service['keystone'],
-    require => File['/etc/keystone/ssl/certs'],
-  }
-
-  $glance_backend = downcase(hiera('glance_backend', 'swift'))
-  case $glance_backend {
-      'swift': { $backend_store = 'glance.store.swift.Store' }
-      'file': { $backend_store = 'glance.store.filesystem.Store' }
-      'rbd': { $backend_store = 'glance.store.rbd.Store' }
-      default: { fail('Unrecognized glance_backend parameter.') }
-  }
-  $http_store = ['glance.store.http.Store']
-  $glance_store = concat($http_store, $backend_store)
-
-  if $glance_backend == 'file' and hiera('glance_file_pcmk_manage', false) {
-    $secontext = 'context="system_u:object_r:glance_var_lib_t:s0"'
-    pacemaker::resource::filesystem { 'glance-fs':
-      device       => hiera('glance_file_pcmk_device'),
-      directory    => hiera('glance_file_pcmk_directory'),
-      fstype       => hiera('glance_file_pcmk_fstype'),
-      fsoptions    => join([$secontext, hiera('glance_file_pcmk_options', '')],','),
-      clone_params => '',
-    }
-  }
-
-  # TODO: notifications, scrubber, etc.
-  include ::glance
-  include ::glance::config
-  class { '::glance::api':
-    known_stores   => $glance_store,
-    manage_service => false,
-    enabled        => false,
-  }
-  class { '::glance::registry' :
-    sync_db        => $sync_db,
-    manage_service => false,
-    enabled        => false,
+if hiera('step') >= 4 or ( hiera('step') >= 3 and $sync_db ) {
+  # At this stage we are guaranteed that the clustercheck db user exists
+  # so we switch the resource agent to use it.
+  file { '/etc/sysconfig/clustercheck' :
+    ensure  => file,
+    mode    => '0600',
+    owner   => 'root',
+    group   => 'root',
+    content => "MYSQL_USERNAME=clustercheck\n
+MYSQL_PASSWORD='${mysql_clustercheck_password}'\n
+MYSQL_HOST=localhost\n",
   }
-  include ::glance::notify::rabbitmq
-  include join(['::glance::backend::', $glance_backend])
 
   $nova_ipv6 = hiera('nova::use_ipv6', false)
   if $nova_ipv6 {
@@ -753,8 +458,8 @@ if hiera('step') >= 4 {
 
     class {'::tripleo::network::midonet::api':
       zookeeper_servers    => $zookeeper_node_ips,
-      vip                  => hiera('tripleo::loadbalancer::public_virtual_ip'),
-      keystone_ip          => hiera('tripleo::loadbalancer::public_virtual_ip'),
+      vip                  => hiera('public_virtual_ip'),
+      keystone_ip          => hiera('public_virtual_ip'),
       keystone_admin_token => hiera('keystone::admin_token'),
       # TODO: create a 'bind' hiera key for api
       bind_address         => hiera('neutron::bind_host'),
@@ -787,34 +492,17 @@ if hiera('step') >= 4 {
   }
   if hiera('neutron::core_plugin') == 'midonet.neutron.plugin_v1.MidonetPluginV2' {
     class {'::neutron::plugins::midonet':
-      midonet_api_ip    => hiera('tripleo::loadbalancer::public_virtual_ip'),
+      midonet_api_ip    => hiera('public_virtual_ip'),
       keystone_tenant   => hiera('neutron::server::auth_tenant'),
-      keystone_password => hiera('neutron::server::auth_password')
-    }
-  }
-  if hiera('neutron::enable_dhcp_agent',true) {
-    class { '::neutron::agents::dhcp' :
-      manage_service => false,
-      enabled        => false,
-    }
-    file { '/etc/neutron/dnsmasq-neutron.conf':
-      content => hiera('neutron_dnsmasq_options'),
-      owner   => 'neutron',
-      group   => 'neutron',
-      notify  => Service['neutron-dhcp-service'],
-      require => Package['neutron'],
+      keystone_password => hiera('neutron::server::password')
     }
   }
-  if hiera('neutron::enable_l3_agent',true) {
-    class { '::neutron::agents::l3' :
-      manage_service => false,
-      enabled        => false,
-    }
-  }
-  if hiera('neutron::enable_metadata_agent',true) {
-    class { '::neutron::agents::metadata':
-      manage_service => false,
-      enabled        => false,
+  if hiera('neutron::core_plugin') == 'networking_plumgrid.neutron.plugins.plugin.NeutronPluginPLUMgridV2' {
+    class { '::neutron::plugins::plumgrid' :
+      connection                   => hiera('neutron::server::database_connection'),
+      controller_priv_host         => hiera('keystone_admin_api_vip'),
+      admin_password               => hiera('admin_password'),
+      metadata_proxy_shared_secret => hiera('nova::api::neutron_metadata_proxy_shared_secret'),
     }
   }
   include ::neutron::plugins::ml2
@@ -848,19 +536,9 @@ if hiera('step') >= 4 {
     include ::neutron::plugins::ml2::bigswitch::restproxy
     include ::neutron::agents::bigswitch
   }
-  neutron_l3_agent_config {
-    'DEFAULT/ovs_use_veth': value => hiera('neutron_ovs_use_veth', false);
-  }
-  neutron_dhcp_agent_config {
-    'DEFAULT/ovs_use_veth': value => hiera('neutron_ovs_use_veth', false);
-  }
-  neutron_config {
-    'DEFAULT/notification_driver': value => 'messaging';
-  }
 
   include ::cinder
   include ::cinder::config
-  include ::tripleo::ssl::cinder_config
   class { '::cinder::api':
     sync_db        => $sync_db,
     manage_service => false,
@@ -909,6 +587,7 @@ if hiera('step') >= 4 {
     $cinder_rbd_backend = 'tripleo_ceph'
 
     cinder::backend::rbd { $cinder_rbd_backend :
+      backend_host    => hiera('cinder::host'),
       rbd_pool        => hiera('cinder_rbd_pool_name'),
       rbd_user        => hiera('ceph_client_user_name'),
       rbd_secret_uuid => hiera('ceph::profile::params::fsid'),
@@ -1016,22 +695,6 @@ if hiera('step') >= 4 {
     enabled        => false,
   }
 
-  # swift proxy
-  class { '::swift::proxy' :
-    manage_service => $non_pcmk_start,
-    enabled        => $non_pcmk_start,
-  }
-  include ::swift::proxy::proxy_logging
-  include ::swift::proxy::healthcheck
-  include ::swift::proxy::cache
-  include ::swift::proxy::keystone
-  include ::swift::proxy::authtoken
-  include ::swift::proxy::staticweb
-  include ::swift::proxy::ratelimit
-  include ::swift::proxy::catch_errors
-  include ::swift::proxy::tempurl
-  include ::swift::proxy::formpost
-
   # swift storage
   if str2bool(hiera('enable_swift_storage', true)) {
     class {'::swift::storage::all':
@@ -1096,39 +759,17 @@ if hiera('step') >= 4 {
     sync_db             => $sync_db,
   }
   include ::ceilometer::agent::auth
+  include ::ceilometer::dispatcher::gnocchi
 
   Cron <| title == 'ceilometer-expirer' |> { command => "sleep $((\$(od -A n -t d -N 3 /dev/urandom) % 86400)) && ${::ceilometer::params::expirer_command}" }
 
-  # Heat
-  include ::heat::config
-  class { '::heat' :
-    sync_db             => $sync_db,
-    notification_driver => 'messaging',
-  }
-  class { '::heat::api' :
-    manage_service => false,
-    enabled        => false,
-  }
-  class { '::heat::api_cfn' :
-    manage_service => false,
-    enabled        => false,
-  }
-  class { '::heat::api_cloudwatch' :
-    manage_service => false,
-    enabled        => false,
-  }
-  class { '::heat::engine' :
-    manage_service => false,
-    enabled        => false,
-  }
-
   # httpd/apache and horizon
   # NOTE(gfidente): server-status can be consumed by the pacemaker resource agent
   class { '::apache' :
     service_enable => false,
     # service_manage => false, # <-- not supported with horizon&apache mod_wsgi?
   }
-  include ::keystone::wsgi::apache
+  include ::apache::mod::remoteip
   include ::apache::mod::status
   if 'cisco_n1kv' in hiera('neutron::plugins::ml2::mechanism_drivers') {
     $_profile_support = 'cisco'
@@ -1175,6 +816,40 @@ if hiera('step') >= 4 {
     enabled        => false,
   }
 
+  # Gnocchi
+  $gnocchi_database_connection = hiera('gnocchi_mysql_conn_string')
+  include ::gnocchi::client
+  if $sync_db {
+    include ::gnocchi::db::sync
+  }
+  include ::gnocchi::storage
+  $gnocchi_backend = downcase(hiera('gnocchi_backend', 'swift'))
+  case $gnocchi_backend {
+      'swift': { include ::gnocchi::storage::swift }
+      'file': { include ::gnocchi::storage::file }
+      'rbd': { include ::gnocchi::storage::ceph }
+      default: { fail('Unrecognized gnocchi_backend parameter.') }
+  }
+  class { '::gnocchi':
+    database_connection => $gnocchi_database_connection,
+  }
+  class { '::gnocchi::api' :
+    manage_service => false,
+    enabled        => false,
+    service_name   => 'httpd',
+  }
+  class { '::gnocchi::wsgi::apache' :
+    ssl => false,
+  }
+  class { '::gnocchi::metricd' :
+    manage_service => false,
+    enabled        => false,
+  }
+  class { '::gnocchi::statsd' :
+    manage_service => false,
+    enabled        => false,
+  }
+
   $snmpd_user = hiera('snmpd_readonly_user_name')
   snmp::snmpv3_user { $snmpd_user:
     authtype => 'MD5',
@@ -1190,38 +865,41 @@ if hiera('step') >= 4 {
 } #END STEP 4
 
 if hiera('step') >= 5 {
-  $keystone_enable_db_purge = hiera('keystone_enable_db_purge', true)
+  # We now make sure that the root db password is set to a random one
+  # At first installation /root/.my.cnf will be empty and we connect without a root
+  # password. On second runs or updates /root/.my.cnf will already be populated
+  # with proper credentials. This step happens on every node because this sql
+  # statement does not automatically replicate across nodes.
+  exec { 'galera-set-root-password':
+    command => "/bin/touch /root/.my.cnf && /bin/echo \"UPDATE mysql.user SET Password = PASSWORD('${mysql_root_password}') WHERE user = 'root'; flush privileges;\" | /bin/mysql --defaults-extra-file=/root/.my.cnf -u root",
+  }
+  file { '/root/.my.cnf' :
+    ensure  => file,
+    mode    => '0600',
+    owner   => 'root',
+    group   => 'root',
+    content => "[client]
+user=root
+password=\"${mysql_root_password}\"
+
+[mysql]
+user=root
+password=\"${mysql_root_password}\"",
+    require => Exec['galera-set-root-password'],
+  }
+
   $nova_enable_db_purge = hiera('nova_enable_db_purge', true)
   $cinder_enable_db_purge = hiera('cinder_enable_db_purge', true)
-  $heat_enable_db_purge = hiera('heat_enable_db_purge', true)
 
-  if $keystone_enable_db_purge {
-    include ::keystone::cron::token_flush
-  }
   if $nova_enable_db_purge {
     include ::nova::cron::archive_deleted_rows
   }
   if $cinder_enable_db_purge {
     include ::cinder::cron::db_purge
   }
-  if $heat_enable_db_purge {
-    include ::heat::cron::purge_deleted
-  }
 
   if $pacemaker_master {
 
-    if $enable_load_balancer {
-      pacemaker::constraint::base { 'haproxy-then-keystone-constraint':
-        constraint_type => 'order',
-        first_resource  => 'haproxy-clone',
-        second_resource => 'openstack-core-clone',
-        first_action    => 'start',
-        second_action   => 'start',
-        require         => [Pacemaker::Resource::Service['haproxy'],
-                            Pacemaker::Resource::Ocf['openstack-core']],
-      }
-    }
-
     pacemaker::constraint::base { 'openstack-core-then-httpd-constraint':
       constraint_type => 'order',
       first_resource  => 'openstack-core-clone',
@@ -1231,24 +909,6 @@ if hiera('step') >= 5 {
       require         => [Pacemaker::Resource::Service[$::apache::params::service_name],
                           Pacemaker::Resource::Ocf['openstack-core']],
     }
-    pacemaker::constraint::base { 'rabbitmq-then-keystone-constraint':
-      constraint_type => 'order',
-      first_resource  => 'rabbitmq-clone',
-      second_resource => 'openstack-core-clone',
-      first_action    => 'start',
-      second_action   => 'start',
-      require         => [Pacemaker::Resource::Ocf['rabbitmq'],
-                          Pacemaker::Resource::Ocf['openstack-core']],
-    }
-    pacemaker::constraint::base { 'memcached-then-openstack-core-constraint':
-      constraint_type => 'order',
-      first_resource  => 'memcached-clone',
-      second_resource => 'openstack-core-clone',
-      first_action    => 'start',
-      second_action   => 'start',
-      require         => [Pacemaker::Resource::Service['memcached'],
-                          Pacemaker::Resource::Ocf['openstack-core']],
-    }
     pacemaker::constraint::base { 'galera-then-openstack-core-constraint':
       constraint_type => 'order',
       first_resource  => 'galera-master',
@@ -1328,79 +988,16 @@ if hiera('step') >= 5 {
       require         => [Pacemaker::Resource::Service[$::sahara::params::api_service_name],
                           Pacemaker::Resource::Ocf['openstack-core']],
     }
-
-    # Glance
-    pacemaker::resource::service { $::glance::params::registry_service_name :
-      clone_params => 'interleave=true',
-      require      => Pacemaker::Resource::Ocf['openstack-core'],
-    }
-    pacemaker::resource::service { $::glance::params::api_service_name :
-      clone_params => 'interleave=true',
-    }
-
-    pacemaker::constraint::base { 'keystone-then-glance-registry-constraint':
+    pacemaker::constraint::base { 'sahara-api-then-sahara-engine-constraint':
       constraint_type => 'order',
-      first_resource  => 'openstack-core-clone',
-      second_resource => "${::glance::params::registry_service_name}-clone",
+      first_resource  => "${::sahara::params::api_service_name}-clone",
+      second_resource => "${::sahara::params::engine_service_name}-clone",
       first_action    => 'start',
       second_action   => 'start',
-      require         => [Pacemaker::Resource::Service[$::glance::params::registry_service_name],
-                          Pacemaker::Resource::Ocf['openstack-core']],
-    }
-    pacemaker::constraint::base { 'glance-registry-then-glance-api-constraint':
-      constraint_type => 'order',
-      first_resource  => "${::glance::params::registry_service_name}-clone",
-      second_resource => "${::glance::params::api_service_name}-clone",
-      first_action    => 'start',
-      second_action   => 'start',
-      require         => [Pacemaker::Resource::Service[$::glance::params::registry_service_name],
-                          Pacemaker::Resource::Service[$::glance::params::api_service_name]],
-    }
-    pacemaker::constraint::colocation { 'glance-api-with-glance-registry-colocation':
-      source  => "${::glance::params::api_service_name}-clone",
-      target  => "${::glance::params::registry_service_name}-clone",
-      score   => 'INFINITY',
-      require => [Pacemaker::Resource::Service[$::glance::params::registry_service_name],
-                  Pacemaker::Resource::Service[$::glance::params::api_service_name]],
-    }
-
-    if hiera('step') == 5 {
-      # Neutron
-      # NOTE(gfidente): Neutron will try to populate the database with some data
-      # as soon as neutron-server is started; to avoid races we want to make this
-      # happen only on one node, before normal Pacemaker initialization
-      # https://bugzilla.redhat.com/show_bug.cgi?id=1233061
-      # NOTE(emilien): we need to run this Exec only at Step 4 otherwise this exec
-      # will try to start the service while it's already started by Pacemaker
-      # It would result to a deployment failure since systemd would return 1 to Puppet
-      # and the overcloud would fail to deploy (6 would be returned).
-      # This conditional prevents from a race condition during the deployment.
-      # https://bugzilla.redhat.com/show_bug.cgi?id=1290582
-      exec { 'neutron-server-systemd-start-sleep' :
-        command => 'systemctl start neutron-server && /usr/bin/sleep 5',
-        path    => '/usr/bin',
-        unless  => '/sbin/pcs resource show neutron-server',
-      } ->
-      pacemaker::resource::service { $::neutron::params::server_service:
-        clone_params => 'interleave=true',
-        require      => Pacemaker::Resource::Ocf['openstack-core']
-      }
-    } else {
-      pacemaker::resource::service { $::neutron::params::server_service:
-        clone_params => 'interleave=true',
-        require      => Pacemaker::Resource::Ocf['openstack-core']
-      }
-    }
-    if hiera('neutron::enable_l3_agent', true) {
-      pacemaker::resource::service { $::neutron::params::l3_agent_service:
-        clone_params => 'interleave=true',
-      }
-    }
-    if hiera('neutron::enable_dhcp_agent', true) {
-      pacemaker::resource::service { $::neutron::params::dhcp_agent_service:
-        clone_params => 'interleave=true',
-      }
+      require         => [Pacemaker::Resource::Service[$::sahara::params::api_service_name],
+                          Pacemaker::Resource::Service[$::sahara::params::engine_service_name]],
     }
+
     if hiera('neutron::enable_ovs_agent', true) {
       pacemaker::resource::service { $::neutron::params::ovs_agent_service:
         clone_params => 'interleave=true',
@@ -1411,11 +1008,6 @@ if hiera('step') >= 5 {
         clone_params => 'interleave=true',
       }
     }
-    if hiera('neutron::enable_metadata_agent', true) {
-      pacemaker::resource::service { $::neutron::params::metadata_agent_service:
-        clone_params => 'interleave=true',
-      }
-    }
     if hiera('neutron::enable_ovs_agent', true) {
       pacemaker::resource::ocf { $::neutron::params::ovs_cleanup_service:
         ocf_agent_name => 'neutron:OVSCleanup',
@@ -1460,81 +1052,6 @@ if hiera('step') >= 5 {
                     Pacemaker::Resource::Service[$::neutron::params::ovs_agent_service]],
       }
     }
-    pacemaker::constraint::base { 'keystone-to-neutron-server-constraint':
-      constraint_type => 'order',
-      first_resource  => 'openstack-core-clone',
-      second_resource => "${::neutron::params::server_service}-clone",
-      first_action    => 'start',
-      second_action   => 'start',
-      require         => [Pacemaker::Resource::Ocf['openstack-core'],
-                          Pacemaker::Resource::Service[$::neutron::params::server_service]],
-    }
-    if hiera('neutron::enable_ovs_agent',true) {
-      pacemaker::constraint::base { 'neutron-openvswitch-agent-to-dhcp-agent-constraint':
-        constraint_type => 'order',
-        first_resource  => "${::neutron::params::ovs_agent_service}-clone",
-        second_resource => "${::neutron::params::dhcp_agent_service}-clone",
-        first_action    => 'start',
-        second_action   => 'start',
-        require         => [Pacemaker::Resource::Service[$::neutron::params::ovs_agent_service],
-                            Pacemaker::Resource::Service[$::neutron::params::dhcp_agent_service]],
-      }
-    }
-    if hiera('neutron::enable_dhcp_agent',true) and hiera('neutron::enable_ovs_agent',true) {
-      pacemaker::constraint::base { 'neutron-server-to-openvswitch-agent-constraint':
-        constraint_type => 'order',
-        first_resource  => "${::neutron::params::server_service}-clone",
-        second_resource => "${::neutron::params::ovs_agent_service}-clone",
-        first_action    => 'start',
-        second_action   => 'start',
-        require         => [Pacemaker::Resource::Service[$::neutron::params::server_service],
-                            Pacemaker::Resource::Service[$::neutron::params::ovs_agent_service]],
-    }
-
-      pacemaker::constraint::colocation { 'neutron-openvswitch-agent-to-dhcp-agent-colocation':
-        source  => "${::neutron::params::dhcp_agent_service}-clone",
-        target  => "${::neutron::params::ovs_agent_service}-clone",
-        score   => 'INFINITY',
-        require => [Pacemaker::Resource::Service[$::neutron::params::ovs_agent_service],
-                    Pacemaker::Resource::Service[$::neutron::params::dhcp_agent_service]],
-      }
-    }
-    if hiera('neutron::enable_dhcp_agent',true) and hiera('l3_agent_service',true) {
-      pacemaker::constraint::base { 'neutron-dhcp-agent-to-l3-agent-constraint':
-        constraint_type => 'order',
-        first_resource  => "${::neutron::params::dhcp_agent_service}-clone",
-        second_resource => "${::neutron::params::l3_agent_service}-clone",
-        first_action    => 'start',
-        second_action   => 'start',
-        require         => [Pacemaker::Resource::Service[$::neutron::params::dhcp_agent_service],
-                            Pacemaker::Resource::Service[$::neutron::params::l3_agent_service]]
-      }
-      pacemaker::constraint::colocation { 'neutron-dhcp-agent-to-l3-agent-colocation':
-        source  => "${::neutron::params::l3_agent_service}-clone",
-        target  => "${::neutron::params::dhcp_agent_service}-clone",
-        score   => 'INFINITY',
-        require => [Pacemaker::Resource::Service[$::neutron::params::dhcp_agent_service],
-                    Pacemaker::Resource::Service[$::neutron::params::l3_agent_service]]
-      }
-    }
-    if hiera('neutron::enable_l3_agent',true) and hiera('neutron::enable_metadata_agent',true) {
-      pacemaker::constraint::base { 'neutron-l3-agent-to-metadata-agent-constraint':
-        constraint_type => 'order',
-        first_resource  => "${::neutron::params::l3_agent_service}-clone",
-        second_resource => "${::neutron::params::metadata_agent_service}-clone",
-        first_action    => 'start',
-        second_action   => 'start',
-        require         => [Pacemaker::Resource::Service[$::neutron::params::l3_agent_service],
-                            Pacemaker::Resource::Service[$::neutron::params::metadata_agent_service]]
-      }
-      pacemaker::constraint::colocation { 'neutron-l3-agent-to-metadata-agent-colocation':
-        source  => "${::neutron::params::metadata_agent_service}-clone",
-        target  => "${::neutron::params::l3_agent_service}-clone",
-        score   => 'INFINITY',
-        require => [Pacemaker::Resource::Service[$::neutron::params::l3_agent_service],
-                    Pacemaker::Resource::Service[$::neutron::params::metadata_agent_service]]
-      }
-    }
     if hiera('neutron::core_plugin') == 'midonet.neutron.plugin_v1.MidonetPluginV2' {
       #midonet-chain chain keystone-->neutron-server-->dhcp-->metadata->tomcat
       pacemaker::constraint::base { 'neutron-server-to-dhcp-agent-constraint':
@@ -1690,11 +1207,6 @@ if hiera('step') >= 5 {
     pacemaker::resource::service { $::ceilometer::params::agent_notification_service_name :
       clone_params => 'interleave=true',
     }
-    pacemaker::resource::ocf { 'delay' :
-      ocf_agent_name  => 'heartbeat:Delay',
-      clone_params    => 'interleave=true',
-      resource_params => 'startdelay=10',
-    }
     # Fedora doesn't know `require-all` parameter for constraints yet
     if $::operatingsystem == 'Fedora' {
       $redis_ceilometer_constraint_params = undef
@@ -1732,6 +1244,15 @@ if hiera('step') >= 5 {
       require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
                           Pacemaker::Resource::Ocf['openstack-core']],
     }
+    pacemaker::constraint::base { 'keystone-then-ceilometer-notification-constraint':
+      constraint_type => 'order',
+      first_resource  => 'openstack-core-clone',
+      second_resource => "${::ceilometer::params::agent_notification_service_name}-clone",
+      first_action    => 'start',
+      second_action   => 'start',
+      require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
+                          Pacemaker::Resource::Ocf['openstack-core']],
+    }
     pacemaker::constraint::base { 'ceilometer-central-then-ceilometer-collector-constraint':
       constraint_type => 'order',
       first_resource  => "${::ceilometer::params::agent_central_service_name}-clone",
@@ -1757,22 +1278,6 @@ if hiera('step') >= 5 {
       require => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
                   Pacemaker::Resource::Service[$::ceilometer::params::collector_service_name]],
     }
-    pacemaker::constraint::base { 'ceilometer-api-then-ceilometer-delay-constraint':
-      constraint_type => 'order',
-      first_resource  => "${::ceilometer::params::api_service_name}-clone",
-      second_resource => 'delay-clone',
-      first_action    => 'start',
-      second_action   => 'start',
-      require         => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
-                          Pacemaker::Resource::Ocf['delay']],
-    }
-    pacemaker::constraint::colocation { 'ceilometer-delay-with-ceilometer-api-colocation':
-      source  => 'delay-clone',
-      target  => "${::ceilometer::params::api_service_name}-clone",
-      score   => 'INFINITY',
-      require => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
-                  Pacemaker::Resource::Ocf['delay']],
-    }
     # Aodh
     pacemaker::resource::service { $::aodh::params::evaluator_service_name :
       clone_params => 'interleave=true',
@@ -1783,22 +1288,6 @@ if hiera('step') >= 5 {
     pacemaker::resource::service { $::aodh::params::listener_service_name :
       clone_params => 'interleave=true',
     }
-    pacemaker::constraint::base { 'aodh-delay-then-aodh-evaluator-constraint':
-      constraint_type => 'order',
-      first_resource  => 'delay-clone',
-      second_resource => "${::aodh::params::evaluator_service_name}-clone",
-      first_action    => 'start',
-      second_action   => 'start',
-      require         => [Pacemaker::Resource::Service[$::aodh::params::evaluator_service_name],
-                          Pacemaker::Resource::Ocf['delay']],
-    }
-    pacemaker::constraint::colocation { 'aodh-evaluator-with-aodh-delay-colocation':
-      source  => "${::aodh::params::evaluator_service_name}-clone",
-      target  => 'delay-clone',
-      score   => 'INFINITY',
-      require => [Pacemaker::Resource::Service[$::aodh::params::evaluator_service_name],
-                  Pacemaker::Resource::Ocf['delay']],
-    }
     pacemaker::constraint::base { 'aodh-evaluator-then-aodh-notifier-constraint':
       constraint_type => 'order',
       first_resource  => "${::aodh::params::evaluator_service_name}-clone",
@@ -1815,6 +1304,15 @@ if hiera('step') >= 5 {
       require => [Pacemaker::Resource::Service[$::aodh::params::evaluator_service_name],
                   Pacemaker::Resource::Service[$::aodh::params::notifier_service_name]],
     }
+    pacemaker::constraint::base { 'aodh-evaluator-then-aodh-listener-constraint':
+      constraint_type => 'order',
+      first_resource  => "${::aodh::params::evaluator_service_name}-clone",
+      second_resource => "${::aodh::params::listener_service_name}-clone",
+      first_action    => 'start',
+      second_action   => 'start',
+      require         => [Pacemaker::Resource::Service[$::aodh::params::evaluator_service_name],
+                          Pacemaker::Resource::Service[$::aodh::params::listener_service_name]],
+    }
     pacemaker::constraint::colocation { 'aodh-listener-with-aodh-evaluator-colocation':
       source  => "${::aodh::params::listener_service_name}-clone",
       target  => "${::aodh::params::evaluator_service_name}-clone",
@@ -1834,84 +1332,28 @@ if hiera('step') >= 5 {
       }
     }
 
-    # Heat
-    pacemaker::resource::service { $::heat::params::api_service_name :
-      clone_params => 'interleave=true',
-    }
-    pacemaker::resource::service { $::heat::params::api_cloudwatch_service_name :
-      clone_params => 'interleave=true',
-    }
-    pacemaker::resource::service { $::heat::params::api_cfn_service_name :
+    # gnocchi
+    pacemaker::resource::service { $::gnocchi::params::metricd_service_name :
       clone_params => 'interleave=true',
     }
-    pacemaker::resource::service { $::heat::params::engine_service_name :
+    pacemaker::resource::service { $::gnocchi::params::statsd_service_name :
       clone_params => 'interleave=true',
     }
-    pacemaker::constraint::base { 'keystone-then-heat-api-constraint':
+    pacemaker::constraint::base { 'gnocchi-metricd-then-gnocchi-statsd-constraint':
       constraint_type => 'order',
-      first_resource  => 'openstack-core-clone',
-      second_resource => "${::heat::params::api_service_name}-clone",
+      first_resource  => "${::gnocchi::params::metricd_service_name}-clone",
+      second_resource => "${::gnocchi::params::statsd_service_name}-clone",
       first_action    => 'start',
       second_action   => 'start',
-      require         => [Pacemaker::Resource::Service[$::heat::params::api_service_name],
-                          Pacemaker::Resource::Ocf['openstack-core']],
+      require         => [Pacemaker::Resource::Service[$::gnocchi::params::metricd_service_name],
+                          Pacemaker::Resource::Service[$::gnocchi::params::statsd_service_name]],
     }
-    pacemaker::constraint::base { 'heat-api-then-heat-api-cfn-constraint':
-      constraint_type => 'order',
-      first_resource  => "${::heat::params::api_service_name}-clone",
-      second_resource => "${::heat::params::api_cfn_service_name}-clone",
-      first_action    => 'start',
-      second_action   => 'start',
-      require         => [Pacemaker::Resource::Service[$::heat::params::api_service_name],
-                          Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name]],
-    }
-    pacemaker::constraint::colocation { 'heat-api-cfn-with-heat-api-colocation':
-      source  => "${::heat::params::api_cfn_service_name}-clone",
-      target  => "${::heat::params::api_service_name}-clone",
+    pacemaker::constraint::colocation { 'gnocchi-statsd-with-metricd-colocation':
+      source  => "${::gnocchi::params::statsd_service_name}-clone",
+      target  => "${::gnocchi::params::metricd_service_name}-clone",
       score   => 'INFINITY',
-      require => [Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name],
-                  Pacemaker::Resource::Service[$::heat::params::api_service_name]],
-    }
-    pacemaker::constraint::base { 'heat-api-cfn-then-heat-api-cloudwatch-constraint':
-      constraint_type => 'order',
-      first_resource  => "${::heat::params::api_cfn_service_name}-clone",
-      second_resource => "${::heat::params::api_cloudwatch_service_name}-clone",
-      first_action    => 'start',
-      second_action   => 'start',
-      require         => [Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name],
-                          Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name]],
-    }
-    pacemaker::constraint::colocation { 'heat-api-cloudwatch-with-heat-api-cfn-colocation':
-      source  => "${::heat::params::api_cloudwatch_service_name}-clone",
-      target  => "${::heat::params::api_cfn_service_name}-clone",
-      score   => 'INFINITY',
-      require => [Pacemaker::Resource::Service[$::heat::params::api_cfn_service_name],
-                  Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name]],
-    }
-    pacemaker::constraint::base { 'heat-api-cloudwatch-then-heat-engine-constraint':
-      constraint_type => 'order',
-      first_resource  => "${::heat::params::api_cloudwatch_service_name}-clone",
-      second_resource => "${::heat::params::engine_service_name}-clone",
-      first_action    => 'start',
-      second_action   => 'start',
-      require         => [Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name],
-                          Pacemaker::Resource::Service[$::heat::params::engine_service_name]],
-    }
-    pacemaker::constraint::colocation { 'heat-engine-with-heat-api-cloudwatch-colocation':
-      source  => "${::heat::params::engine_service_name}-clone",
-      target  => "${::heat::params::api_cloudwatch_service_name}-clone",
-      score   => 'INFINITY',
-      require => [Pacemaker::Resource::Service[$::heat::params::api_cloudwatch_service_name],
-                  Pacemaker::Resource::Service[$::heat::params::engine_service_name]],
-    }
-    pacemaker::constraint::base { 'ceilometer-notification-then-heat-api-constraint':
-      constraint_type => 'order',
-      first_resource  => "${::ceilometer::params::agent_notification_service_name}-clone",
-      second_resource => "${::heat::params::api_service_name}-clone",
-      first_action    => 'start',
-      second_action   => 'start',
-      require         => [Pacemaker::Resource::Service[$::heat::params::api_service_name],
-                          Pacemaker::Resource::Service[$::ceilometer::params::agent_notification_service_name]],
+      require => [Pacemaker::Resource::Service[$::gnocchi::params::metricd_service_name],
+                  Pacemaker::Resource::Service[$::gnocchi::params::statsd_service_name]],
     }
 
     # Horizon and Keystone
@@ -1952,29 +1394,5 @@ if hiera('step') >= 5 {
 
 } #END STEP 5
 
-if hiera('step') >= 6 {
-
-  if $pacemaker_master {
-
-    class {'::keystone::roles::admin' :
-      require => Pacemaker::Resource::Service[$::apache::params::service_name],
-    } ->
-    class {'::keystone::endpoint' :
-      require => Pacemaker::Resource::Service[$::apache::params::service_name],
-    }
-    include ::heat::keystone::domain
-    Class['::keystone::roles::admin'] -> Class['::heat::keystone::domain']
-
-  } else {
-    # On non-master controller we don't need to create Keystone resources again
-    class { '::heat::keystone::domain':
-      manage_domain => false,
-      manage_user   => false,
-      manage_role   => false,
-    }
-  }
-
-} #END STEP 6
-
 $package_manifest_name = join(['/var/lib/tripleo/installed-packages/overcloud_controller_pacemaker', hiera('step')])
 package_manifest{$package_manifest_name: ensure => present}