Merge "horizon/keystone api should use internal_api NW"

[apex-tripleo-heat-templates.git] / puppet / manifests / overcloud_controller_pacemaker.pp

diff --git a/puppet/manifests/overcloud_controller_pacemaker.pp b/puppet/manifests/overcloud_controller_pacemaker.pp
index 240a669..e30cda8 100644 (file)
--- a/puppet/manifests/overcloud_controller_pacemaker.pp
+++ b/puppet/manifests/overcloud_controller_pacemaker.pp
@@ -192,11 +192,12 @@ if hiera('step') >= 2 {
       }
       # NOTE (spredzy) : The replset can only be run
       # once all the nodes have joined the cluster.
-      $mongo_node_ips = split(hiera('mongo_node_ips'), ',')
+      $mongo_node_ips = hiera('mongo_node_ips')
       $mongo_node_ips_with_port = suffix($mongo_node_ips, ':27017')
       $mongo_node_string = join($mongo_node_ips_with_port, ',')
       $mongodb_replset = hiera('mongodb::server::replset')
       $mongodb_cluster_ready_command = join(suffix(prefix($mongo_node_ips, '/bin/nc -w1 '), ' 27017 < /dev/null'), ' && ')
+      $mongodb_pacemaker_resource = Pacemaker::Resource::Service[$::mongodb::params::service_name]
       exec { 'mongodb-ready' :
         command   => $mongodb_cluster_ready_command,
         timeout   => 30,
@@ -221,7 +222,7 @@ if hiera('step') >= 2 {
   }
 
   # Redis
-  $redis_node_ips = split(hiera('redis_node_ips'), ',')
+  $redis_node_ips = hiera('redis_node_ips')
   $redis_master_hostname = downcase(hiera('bootstrap_nodeid'))
 
   if $redis_master_hostname == $::hostname {
@@ -616,28 +617,28 @@ if hiera('step') >= 3 {
   }
   include ::ceilometer
   class { '::ceilometer::api' :
-    manage_service => $non_pcmk_start,
-    enabled => $non_pcmk_start,
+    manage_service => false,
+    enabled => false,
   }
   class { '::ceilometer::agent::notification' :
-    manage_service => $non_pcmk_start,
-    enabled => $non_pcmk_start,
+    manage_service => false,
+    enabled => false,
   }
   class { '::ceilometer::agent::central' :
-    manage_service => $non_pcmk_start,
-    enabled => $non_pcmk_start,
+    manage_service => false,
+    enabled => false,
   }
   class { '::ceilometer::alarm::notifier' :
-    manage_service => $non_pcmk_start,
-    enabled => $non_pcmk_start,
+    manage_service => false,
+    enabled => false,
   }
   class { '::ceilometer::alarm::evaluator' :
-    manage_service => $non_pcmk_start,
-    enabled => $non_pcmk_start,
+    manage_service => false,
+    enabled => false,
   }
   class { '::ceilometer::collector' :
-    manage_service => $non_pcmk_start,
-    enabled => $non_pcmk_start,
+    manage_service => false,
+    enabled => false,
   }
   include ::ceilometer::expirer
   class { '::ceilometer::db' :
@@ -655,26 +656,26 @@ if hiera('step') >= 3 {
     sync_db => $sync_db,
   }
   class { '::heat::api' :
-    manage_service => $non_pcmk_start,
-    enabled => $non_pcmk_start,
+    manage_service => false,
+    enabled => false,
   }
   class { '::heat::api_cfn' :
-    manage_service => $non_pcmk_start,
-    enabled => $non_pcmk_start,
+    manage_service => false,
+    enabled => false,
   }
   class { '::heat::api_cloudwatch' :
-    manage_service => $non_pcmk_start,
-    enabled => $non_pcmk_start,
+    manage_service => false,
+    enabled => false,
   }
   class { '::heat::engine' :
-    manage_service => $non_pcmk_start,
-    enabled => $non_pcmk_start,
+    manage_service => false,
+    enabled => false,
   }
 
   # Horizon
   $vhost_params = { add_listen => false }
   class { 'horizon':
-    cache_server_ip    => split(hiera('memcache_node_ips', '127.0.0.1'), ','),
+    cache_server_ip    => hiera('memcache_node_ips', '127.0.0.1'),
     vhost_extra_params => $vhost_params,
   }
 
@@ -1030,6 +1031,213 @@ if hiera('step') >= 4 {
                   Pacemaker::Resource::Service[$::nova::params::conductor_service_name]],
     }
 
+    # Ceilometer
+    pacemaker::resource::service { $::ceilometer::params::agent_central_service_name :
+      clone_params => 'interleave=true',
+      require      => [Pacemaker::Resource::Service[$::keystone::params::service_name],
+                       $mongodb_pacemaker_resource],
+    }
+    pacemaker::resource::service { $::ceilometer::params::collector_service_name :
+      clone_params => 'interleave=true',
+    }
+    pacemaker::resource::service { $::ceilometer::params::api_service_name :
+      clone_params => 'interleave=true',
+    }
+    pacemaker::resource::service { $::ceilometer::params::alarm_evaluator_service_name :
+      clone_params => 'interleave=true',
+    }
+    pacemaker::resource::service { $::ceilometer::params::alarm_notifier_service_name :
+      clone_params => 'interleave=true',
+    }
+    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',
+    }
+    pacemaker::constraint::base { 'ceilometer-central-then-ceilometer-collector-constraint':
+      constraint_type => 'order',
+      first_resource  => "${::ceilometer::params::agent_central_service_name}-clone",
+      second_resource => "${::ceilometer::params::collector_service_name}-clone",
+      first_action    => 'start',
+      second_action   => 'start',
+      require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
+                          Pacemaker::Resource::Service[$::ceilometer::params::collector_service_name]],
+    }
+    pacemaker::constraint::base { 'ceilometer-collector-then-ceilometer-api-constraint':
+      constraint_type => 'order',
+      first_resource  => "${::ceilometer::params::collector_service_name}-clone",
+      second_resource => "${::ceilometer::params::api_service_name}-clone",
+      first_action    => 'start',
+      second_action   => 'start',
+      require         => [Pacemaker::Resource::Service[$::ceilometer::params::collector_service_name],
+                          Pacemaker::Resource::Service[$::ceilometer::params::api_service_name]],
+    }
+    pacemaker::constraint::colocation { 'ceilometer-api-with-ceilometer-collector-colocation':
+      source  => "${::ceilometer::params::api_service_name}-clone",
+      target  => "${::ceilometer::params::collector_service_name}-clone",
+      score   => 'INFINITY',
+      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']],
+    }
+    pacemaker::constraint::base { 'ceilometer-delay-then-ceilometer-alarm-evaluator-constraint':
+      constraint_type => 'order',
+      first_resource  => 'delay-clone',
+      second_resource => "${::ceilometer::params::alarm_evaluator_service_name}-clone",
+      first_action    => 'start',
+      second_action   => 'start',
+      require         => [Pacemaker::Resource::Service[$::ceilometer::params::alarm_evaluator_service_name],
+                          Pacemaker::Resource::Ocf['delay']],
+    }
+    pacemaker::constraint::colocation { 'ceilometer-alarm-evaluator-with-ceilometer-delay-colocation':
+      source  => "${::ceilometer::params::alarm_evaluator_service_name}-clone",
+      target  => 'delay-clone',
+      score   => 'INFINITY',
+      require => [Pacemaker::Resource::Service[$::ceilometer::params::api_service_name],
+                  Pacemaker::Resource::Ocf['delay']],
+    }
+    pacemaker::constraint::base { 'ceilometer-alarm-evaluator-then-ceilometer-alarm-notifier-constraint':
+      constraint_type => 'order',
+      first_resource  => "${::ceilometer::params::alarm_evaluator_service_name}-clone",
+      second_resource => "${::ceilometer::params::alarm_notifier_service_name}-clone",
+      first_action    => 'start',
+      second_action   => 'start',
+      require         => [Pacemaker::Resource::Service[$::ceilometer::params::alarm_evaluator_service_name],
+                          Pacemaker::Resource::Service[$::ceilometer::params::alarm_notifier_service_name]],
+    }
+    pacemaker::constraint::colocation { 'ceilometer-alarm-notifier-with-ceilometer-alarm-evaluator-colocation':
+      source  => "${::ceilometer::params::alarm_notifier_service_name}-clone",
+      target  => "${::ceilometer::params::alarm_evaluator_service_name}-clone",
+      score   => 'INFINITY',
+      require => [Pacemaker::Resource::Service[$::ceilometer::params::alarm_evaluator_service_name],
+                  Pacemaker::Resource::Service[$::ceilometer::params::alarm_notifier_service_name]],
+    }
+    pacemaker::constraint::base { 'ceilometer-alarm-notifier-then-ceilometer-notification-constraint':
+      constraint_type => 'order',
+      first_resource  => "${::ceilometer::params::alarm_notifier_service_name}-clone",
+      second_resource => "${::ceilometer::params::agent_notification_service_name}-clone",
+      first_action    => 'start',
+      second_action   => 'start',
+      require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_notification_service_name],
+                          Pacemaker::Resource::Service[$::ceilometer::params::alarm_notifier_service_name]],
+    }
+    pacemaker::constraint::colocation { 'ceilometer-notification-with-ceilometer-alarm-notifier-colocation':
+      source  => "${::ceilometer::params::agent_notification_service_name}-clone",
+      target  => "${::ceilometer::params::alarm_notifier_service_name}-clone",
+      score   => 'INFINITY',
+      require => [Pacemaker::Resource::Service[$::ceilometer::params::agent_notification_service_name],
+                  Pacemaker::Resource::Service[$::ceilometer::params::alarm_notifier_service_name]],
+    }
+    if downcase(hiera('ceilometer_backend')) == 'mongodb' {
+      pacemaker::constraint::base { 'mongodb-then-ceilometer-central-constraint':
+        constraint_type => 'order',
+        first_resource  => "${::mongodb::params::service_name}-clone",
+        second_resource => "${::ceilometer::params::agent_central_service_name}-clone",
+        first_action    => 'start',
+        second_action   => 'start',
+        require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
+                            Pacemaker::Resource::Service[$::mongodb::params::service_name]],
+      }
+    }
+    pacemaker::constraint::base { 'keystone-then-ceilometer-central-constraint':
+      constraint_type => 'order',
+      first_resource  => "${::keystone::params::service_name}-clone",
+      second_resource => "${::ceilometer::params::agent_central_service_name}-clone",
+      first_action    => 'start',
+      second_action   => 'start',
+      require         => [Pacemaker::Resource::Service[$::ceilometer::params::agent_central_service_name],
+                          Pacemaker::Resource::Service[$::keystone::params::service_name]],
+    }
+
+    # 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 :
+      clone_params => 'interleave=true',
+    }
+    pacemaker::resource::service { $::heat::params::engine_service_name :
+      clone_params => 'interleave=true',
+    }
+    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",
+      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]],
+    }
+
   }
 
 } #END STEP 4