Merge "Fix Puppet Configuring NetApp Cinder Backend"
[apex-tripleo-heat-templates.git] / puppet / manifests / overcloud_controller_pacemaker.pp
index 6e911f7..d85ef55 100644 (file)
@@ -37,6 +37,8 @@ if $::hostname == downcase(hiera('bootstrap_nodeid')) {
   $sync_db = false
 }
 
+$enable_fencing = str2bool(hiera('enable_fencing', 'false')) and hiera('step') >= 5
+
 # When to start and enable services which haven't been Pacemakerized
 # FIXME: remove when we start all OpenStack services using Pacemaker
 # (occurences of this variable will be gradually replaced with false)
@@ -56,6 +58,7 @@ if hiera('step') >= 1 {
     controller_hosts       => $controller_node_ips,
     controller_hosts_names => $controller_node_names,
     manage_vip             => false,
+    mysql_clustercheck     => true,
     haproxy_service_manage => false,
   }
 
@@ -71,7 +74,13 @@ if hiera('step') >= 1 {
     setup_cluster   => $pacemaker_master,
   }
   class { '::pacemaker::stonith':
-    disable => true,
+    disable => !$enable_fencing,
+  }
+  if $enable_fencing {
+    include tripleo::fencing
+
+    # enable stonith after all fencing devices have been created
+    Class['tripleo::fencing'] -> Class['pacemaker::stonith']
   }
 
   # Only configure RabbitMQ in this step, don't start it yet to
@@ -131,7 +140,7 @@ if hiera('step') >= 1 {
       'query_cache_size'              => '0',
       'query_cache_type'              => '0',
       'bind-address'                  => hiera('mysql_bind_host'),
-      'max_connections'               => '1024',
+      'max_connections'               => hiera('mysql_max_connections'),
       'open_files_limit'              => '-1',
       'wsrep_provider'                => '/usr/lib64/galera/libgalera_smm.so',
       'wsrep_cluster_name'            => 'galera_cluster',
@@ -174,13 +183,78 @@ if hiera('step') >= 2 {
     # 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')
     pacemaker::resource::ip { 'control_vip':
       ip_address => $control_vip,
     }
+    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')
-    pacemaker::resource::ip { 'public_vip':
-      ip_address => $public_vip,
+    if $public_vip and $public_vip != $control_vip {
+      pacemaker::resource::ip { 'public_vip':
+        ip_address => $public_vip,
+      }
+      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 $redis_vip and $redis_vip != $control_vip {
+      pacemaker::resource::ip { 'redis_vip':
+        ip_address => $redis_vip,
+      }
+      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')
@@ -188,6 +262,23 @@ if hiera('step') >= 2 {
       pacemaker::resource::ip { 'internal_api_vip':
         ip_address => $internal_api_vip,
       }
+      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')
@@ -195,6 +286,23 @@ if hiera('step') >= 2 {
       pacemaker::resource::ip { 'storage_vip':
         ip_address => $storage_vip,
       }
+      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')
@@ -202,11 +310,25 @@ if hiera('step') >= 2 {
       pacemaker::resource::ip { 'storage_mgmt_vip':
         ip_address => $storage_mgmt_vip,
       }
+      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']],
+      }
     }
 
-    pacemaker::resource::service { 'haproxy':
-      clone_params => true,
-    }
     pacemaker::resource::service { $::memcached::params::service_name :
       clone_params => true,
       require      => Class['::memcached'],
@@ -228,6 +350,7 @@ if hiera('step') >= 2 {
       # NOTE (spredzy) : The replset can only be run
       # once all the nodes have joined the cluster.
       mongodb_conn_validator { $mongo_node_ips_with_port :
+        timeout => '600',
         require => Pacemaker::Resource::Service[$::mongodb::params::service_name],
         before  => Mongodb_replset[$mongodb_replset],
       }
@@ -253,28 +376,6 @@ if hiera('step') >= 2 {
       resource_params => 'wait_last_known_master=true',
       require         => Class['::redis'],
     }
-    $redis_vip = hiera('redis_vip')
-    if $redis_vip and $redis_vip != $control_vip {
-        pacemaker::resource::ip { 'vip-redis':
-          ip_address => $redis_vip,
-        }
-    }
-    pacemaker::constraint::base { 'redis-master-then-vip-redis':
-      constraint_type => 'order',
-      first_resource  => 'redis-master',
-      second_resource => "ip-${redis_vip}",
-      first_action    => 'promote',
-      second_action   => 'start',
-      require => [Pacemaker::Resource::Ocf['redis'],
-                  Pacemaker::Resource::Ip['vip-redis']],
-    }
-    pacemaker::constraint::colocation { 'vip-redis-with-redis-master':
-      source  => "ip-${redis_vip}",
-      target  => 'redis-master',
-      score   => 'INFINITY',
-      require => [Pacemaker::Resource::Ocf['redis'],
-                  Pacemaker::Resource::Ip['vip-redis']],
-    }
 
   }
 
@@ -442,16 +543,18 @@ if hiera('step') >= 3 {
 
   $glance_backend = downcase(hiera('glance_backend', 'swift'))
   case $glance_backend {
-      swift: { $glance_store = 'glance.store.swift.Store' }
-      file: { $glance_store = 'glance.store.filesystem.Store' }
-      rbd: { $glance_store = 'glance.store.rbd.Store' }
+      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)
 
   # TODO: notifications, scrubber, etc.
   include ::glance
   class { 'glance::api':
-    known_stores => [$glance_store],
+    known_stores => $glance_store,
     manage_service => false,
     enabled => false,
   }
@@ -522,7 +625,7 @@ if hiera('step') >= 3 {
     tenant_network_types => [hiera('neutron_tenant_network_type')],
   }
   class { 'neutron::agents::ml2::ovs':
-    # manage_service   => false # not implemented
+    manage_service   => false,
     enabled          => false,
     bridge_mappings  => split(hiera('neutron_bridge_mappings'), ','),
     tunnel_types     => split(hiera('neutron_tunnel_types'), ','),
@@ -591,12 +694,31 @@ if hiera('step') >= 3 {
       "${cinder_netapp_backend}/host": value => 'hostgroup';
     }
 
-    if hiera('cinder_netapp_nfs_shares', undef) {
-      $cinder_netapp_nfs_shares = split(hiera('cinder_netapp_nfs_shares', undef), ',')
+    if hiera('cinder::backend::netapp::nfs_shares', undef) {
+      $cinder_netapp_nfs_shares = split(hiera('cinder::backend::netapp::nfs_shares', undef), ',')
     }
 
     cinder::backend::netapp { $cinder_netapp_backend :
-      nfs_shares => $cinder_netapp_nfs_shares,
+      netapp_login                 => hiera('cinder::backend::netapp::netapp_login', undef),
+      netapp_password              => hiera('cinder::backend::netapp::netapp_password', undef),
+      netapp_server_hostname       => hiera('cinder::backend::netapp::netapp_server_hostname', undef),
+      netapp_server_port           => hiera('cinder::backend::netapp::netapp_server_port', undef),
+      netapp_size_multiplier       => hiera('cinder::backend::netapp::netapp_size_multiplier', undef),
+      netapp_storage_family        => hiera('cinder::backend::netapp::netapp_storage_family', undef),
+      netapp_storage_protocol      => hiera('cinder::backend::netapp::netapp_storage_protocol', undef),
+      netapp_transport_type        => hiera('cinder::backend::netapp::netapp_transport_type', undef),
+      netapp_vfiler                => hiera('cinder::backend::netapp::netapp_vfiler', undef),
+      netapp_volume_list           => hiera('cinder::backend::netapp::netapp_volume_list', undef),
+      netapp_vserver               => hiera('cinder::backend::netapp::netapp_vserver', undef),
+      netapp_partner_backend_name  => hiera('cinder::backend::netapp::netapp_partner_backend_name', undef),
+      nfs_shares                   => $cinder_netapp_nfs_shares,
+      nfs_shares_config            => hiera('cinder::backend::netapp::nfs_shares_config', undef),
+      netapp_copyoffload_tool_path => hiera('cinder::backend::netapp::netapp_copyoffload_tool_path', undef),
+      netapp_controller_ips        => hiera('cinder::backend::netapp::netapp_controller_ips', undef),
+      netapp_sa_password           => hiera('cinder::backend::netapp::netapp_sa_password', undef),
+      netapp_storage_pools         => hiera('cinder::backend::netapp::netapp_storage_pools', undef),
+      netapp_eseries_host_type     => hiera('cinder::backend::netapp::netapp_eseries_host_type', undef),
+      netapp_webservice_path       => hiera('cinder::backend::netapp::netapp_webservice_path', undef),
     }
   }
 
@@ -616,7 +738,6 @@ if hiera('step') >= 3 {
   include ::swift::proxy::keystone
   include ::swift::proxy::authtoken
   include ::swift::proxy::staticweb
-  include ::swift::proxy::ceilometer
   include ::swift::proxy::ratelimit
   include ::swift::proxy::catch_errors
   include ::swift::proxy::tempurl
@@ -742,6 +863,8 @@ if hiera('step') >= 3 {
     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' ],
   }
 
+  hiera_include('controller_classes')
+
 } #END STEP 3
 
 if hiera('step') >= 4 {
@@ -840,6 +963,11 @@ if hiera('step') >= 4 {
     }
 
     # 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
+    exec { '/usr/bin/systemctl start neutron-server && /usr/bin/sleep 5' : } ->
     pacemaker::resource::service { $::neutron::params::server_service:
       op_params => "start timeout=90",
       clone_params   => "interleave=true",
@@ -865,10 +993,6 @@ if hiera('step') >= 4 {
       ocf_agent_name => "neutron:NetnsCleanup",
       clone_params => "interleave=true",
     }
-    pacemaker::resource::ocf { 'neutron-scale':
-      ocf_agent_name => "neutron:NeutronScale",
-      clone_params => "globally-unique=true clone-max=3 interleave=true",
-    }
     pacemaker::constraint::base { 'keystone-to-neutron-server-constraint':
       constraint_type => "order",
       first_resource => "${::keystone::params::service_name}-clone",
@@ -878,29 +1002,13 @@ if hiera('step') >= 4 {
       require => [Pacemaker::Resource::Service[$::keystone::params::service_name],
                   Pacemaker::Resource::Service[$::neutron::params::server_service]],
     }
-    pacemaker::constraint::base { 'neutron-server-to-neutron-scale-constraint':
+    pacemaker::constraint::base { 'neutron-server-to-neutron-ovs-cleanup-constraint':
       constraint_type => "order",
       first_resource => "${::neutron::params::server_service}-clone",
-      second_resource => "neutron-scale-clone",
-      first_action => "start",
-      second_action => "start",
-      require => [Pacemaker::Resource::Service[$::neutron::params::server_service],
-                  Pacemaker::Resource::Ocf['neutron-scale']],
-    }
-    pacemaker::constraint::base { 'neutron-scale-to-ovs-cleanup-constraint':
-      constraint_type => "order",
-      first_resource => "neutron-scale-clone",
       second_resource => "${::neutron::params::ovs_cleanup_service}-clone",
       first_action => "start",
       second_action => "start",
-      require => [Pacemaker::Resource::Ocf['neutron-scale'],
-                  Pacemaker::Resource::Ocf["${::neutron::params::ovs_cleanup_service}"]],
-    }
-    pacemaker::constraint::colocation { 'neutron-scale-to-ovs-cleanup-colocation':
-      source => "${::neutron::params::ovs_cleanup_service}-clone",
-      target => "neutron-scale-clone",
-      score => "INFINITY",
-      require => [Pacemaker::Resource::Ocf['neutron-scale'],
+      require => [Pacemaker::Resource::Service[$::neutron::params::server_service],
                   Pacemaker::Resource::Ocf["${::neutron::params::ovs_cleanup_service}"]],
     }
     pacemaker::constraint::base { 'neutron-ovs-cleanup-to-netns-cleanup-constraint':
@@ -1219,15 +1327,6 @@ if hiera('step') >= 4 {
                             Pacemaker::Resource::Service[$::mongodb::params::service_name]],
       }
     }
-    pacemaker::constraint::base { 'vip-redis-then-ceilometer-central':
-      constraint_type => 'order',
-      first_resource  => "ip-${redis_vip}",
-      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::Ip['vip-redis']],
-    }
 
     # Heat
     pacemaker::resource::service { $::heat::params::api_service_name :