X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=puppet%2Fmanifests%2Fovercloud_controller.pp;h=b8b9540bbec37635457da48d72509748d708d22d;hb=1fca42264e0606f415b5bca45c10d9c4dae5074c;hp=ad10cd332afe5452d5a3f9ef4d9fec9af228f590;hpb=cf4d918cd923c228d37fc06ecadf2f48c80ef400;p=apex-tripleo-heat-templates.git

diff --git a/puppet/manifests/overcloud_controller.pp b/puppet/manifests/overcloud_controller.pp
index ad10cd33..34be39f3 100644
--- a/puppet/manifests/overcloud_controller.pp
+++ b/puppet/manifests/overcloud_controller.pp
@@ -13,47 +13,17 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-if !str2bool(hiera('enable_package_install', 'false')) {
-  case $::osfamily {
-    'RedHat': {
-      Package { provider => 'norpm' } # provided by tripleo-puppet
-    }
-    default: {
-      warning('enable_package_install option not supported.')
-    }
-  }
-}
+include ::tripleo::packages
 
 if hiera('step') >= 1 {
 
+  create_resources(sysctl::value, hiera('sysctl_settings'), {})
+
   $controller_node_ips = split(hiera('controller_node_ips'), ',')
-  $enable_pacemaker = str2bool(hiera('enable_pacemaker'))
-  $enable_keepalived = !$enable_pacemaker
 
   class { '::tripleo::loadbalancer' :
     controller_hosts => $controller_node_ips,
-  }
-
-  if $enable_pacemaker {
-    $pacemaker_cluster_members = regsubst(hiera('controller_node_ips'), ',', ' ', 'G')
-    if $::hostname == downcase(hiera('bootstrap_nodeid')) {
-      $pacemaker_master = true
-    } else {
-      $pacemaker_master = false
-    }
-    user { 'hacluster':
-     ensure => present,
-    } ->
-    class { '::pacemaker':
-      hacluster_pwd => hiera('hacluster_pwd'),
-    } ->
-    class { '::pacemaker::corosync':
-      cluster_members => $pacemaker_cluster_members,
-      setup_cluster   => $pacemaker_master,
-    }
-    class { '::pacemaker::stonith':
-      disable => true,
-    }
+    manage_vip       => true,
   }
 
 }
@@ -65,22 +35,24 @@ if hiera('step') >= 2 {
   }
 
   # MongoDB
-  include ::mongodb::globals
-  include ::mongodb::server
-  $mongo_node_ips = split(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')
-  $ceilometer_mongodb_conn_string = "mongodb://${mongo_node_string}/ceilometer?replicaSet=${mongodb_replset}"
-  if downcase(hiera('bootstrap_nodeid')) == $::hostname {
-    mongodb_replset { $mongodb_replset :
-      members => $mongo_node_ips_with_port,
+  if downcase(hiera('ceilometer_backend')) == 'mongodb' {
+    include ::mongodb::globals
+
+    include ::mongodb::server
+    $mongo_node_ips_with_port = suffix(hiera('mongo_node_ips'), ':27017')
+    $mongo_node_string = join($mongo_node_ips_with_port, ',')
+
+    $mongodb_replset = hiera('mongodb::server::replset')
+    $ceilometer_mongodb_conn_string = "mongodb://${mongo_node_string}/ceilometer?replicaSet=${mongodb_replset}"
+    if downcase(hiera('bootstrap_nodeid')) == $::hostname {
+      mongodb_replset { $mongodb_replset :
+        members => $mongo_node_ips_with_port,
+      }
     }
   }
 
   # 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 {
@@ -95,127 +67,100 @@ if hiera('step') >= 2 {
   if count($redis_node_ips) > 1 {
     Class['::tripleo::redis_notification'] -> Service['redis-sentinel']
     include ::redis::sentinel
-    class {'::tripleo::redis_notification' :
-      haproxy_monitor_ip => hiera('tripleo::loadbalancer::controller_virtual_ip'),
-    }
+    include ::tripleo::redis_notification
   }
 
-  if str2bool(hiera('enable_galera', 'true')) {
+  if str2bool(hiera('enable_galera', true)) {
     $mysql_config_file = '/etc/my.cnf.d/galera.cnf'
   } else {
     $mysql_config_file = '/etc/my.cnf.d/server.cnf'
   }
   # TODO Galara
-  class { 'mysql::server':
-    config_file => $mysql_config_file,
-    override_options => {
+  class { '::mysql::server':
+    config_file             => $mysql_config_file,
+    override_options        => {
       'mysqld' => {
-        'bind-address' => hiera('controller_host')
-      }
-    }
+        'bind-address'     => hiera('mysql_bind_host'),
+        'max_connections'  => hiera('mysql_max_connections'),
+        'open_files_limit' => '-1',
+      },
+    },
+    remove_default_accounts => true,
   }
 
   # FIXME: this should only occur on the bootstrap host (ditto for db syncs)
   # Create all the database schemas
-  # Example DSN format: mysql://user:password@host/dbname
-  $allowed_hosts = ['%',hiera('controller_host')]
-  $keystone_dsn = split(hiera('keystone::database_connection'), '[@:/?]')
-  class { 'keystone::db::mysql':
-    user          => $keystone_dsn[3],
-    password      => $keystone_dsn[4],
-    host          => $keystone_dsn[5],
-    dbname        => $keystone_dsn[6],
-    allowed_hosts => $allowed_hosts,
-  }
-  $glance_dsn = split(hiera('glance::api::database_connection'), '[@:/?]')
-  class { 'glance::db::mysql':
-    user          => $glance_dsn[3],
-    password      => $glance_dsn[4],
-    host          => $glance_dsn[5],
-    dbname        => $glance_dsn[6],
-    allowed_hosts => $allowed_hosts,
-  }
-  $nova_dsn = split(hiera('nova::database_connection'), '[@:/?]')
-  class { 'nova::db::mysql':
-    user          => $nova_dsn[3],
-    password      => $nova_dsn[4],
-    host          => $nova_dsn[5],
-    dbname        => $nova_dsn[6],
-    allowed_hosts => $allowed_hosts,
-  }
-  $neutron_dsn = split(hiera('neutron::server::database_connection'), '[@:/?]')
-  class { 'neutron::db::mysql':
-    user          => $neutron_dsn[3],
-    password      => $neutron_dsn[4],
-    host          => $neutron_dsn[5],
-    dbname        => $neutron_dsn[6],
-    allowed_hosts => $allowed_hosts,
-  }
-  $cinder_dsn = split(hiera('cinder::database_connection'), '[@:/?]')
-  class { 'cinder::db::mysql':
-    user          => $cinder_dsn[3],
-    password      => $cinder_dsn[4],
-    host          => $cinder_dsn[5],
-    dbname        => $cinder_dsn[6],
-    allowed_hosts => $allowed_hosts,
-  }
-  $heat_dsn = split(hiera('heat::database_connection'), '[@:/?]')
-  class { 'heat::db::mysql':
-    user          => $heat_dsn[3],
-    password      => $heat_dsn[4],
-    host          => $heat_dsn[5],
-    dbname        => $heat_dsn[6],
-    allowed_hosts => $allowed_hosts,
-  }
-
-  $rabbit_nodes = split(downcase(hiera('rabbit_node_names', $::hostname)), ',')
-  if count($rabbit_nodes) > 1 {
-    $rabbit_cluster = true
-  }
-  else {
-    $rabbit_cluster = false
+  include ::keystone::db::mysql
+  include ::glance::db::mysql
+  include ::nova::db::mysql
+  include ::neutron::db::mysql
+  include ::cinder::db::mysql
+  include ::heat::db::mysql
+  if downcase(hiera('ceilometer_backend')) == 'mysql' {
+    include ::ceilometer::db::mysql
   }
-  class { 'rabbitmq':
-    config_cluster   => $rabbit_cluster,
-    cluster_nodes    => $rabbit_nodes,
-    node_ip_address  => hiera('controller_host'),
-  }
-  if $rabbit_cluster {
+
+  $rabbit_nodes = hiera('rabbit_node_ips')
+  if count($rabbit_nodes) > 1 {
+    class { '::rabbitmq':
+      config_cluster          => true,
+      cluster_nodes           => $rabbit_nodes,
+      tcp_keepalive           => false,
+      config_kernel_variables => hiera('rabbitmq_kernel_variables'),
+      config_variables        => hiera('rabbitmq_config_variables'),
+      environment_variables   => hiera('rabbitmq_environment'),
+    }
     rabbitmq_policy { 'ha-all@/':
       pattern    => '^(?!amq\.).*',
       definition => {
-        'ha-mode'      => 'all',
-        'ha-sync-mode' => 'automatic',
+        'ha-mode' => 'all',
       },
     }
-  }
-  rabbitmq_vhost { '/':
-    provider => 'rabbitmqctl',
+  } else {
+    include ::rabbitmq
   }
 
   # pre-install swift here so we can build rings
   include ::swift
 
-  $cinder_enable_rbd_backend = hiera('cinder_enable_rbd_backend', false)
-  $enable_ceph = $cinder_enable_rbd_backend
+  $enable_ceph = hiera('ceph_storage_count', 0) > 0
 
   if $enable_ceph {
-    class { 'ceph::profile::params':
-      mon_initial_members => downcase(hiera('ceph_mon_initial_members'))
+    class { '::ceph::profile::params':
+      mon_initial_members => downcase(hiera('ceph_mon_initial_members')),
     }
     include ::ceph::profile::mon
   }
 
-  if str2bool(hiera('enable_ceph_storage', 'false')) {
-    include ::ceph::profile::client
+  if str2bool(hiera('enable_ceph_storage', false)) {
+    if str2bool(hiera('ceph_osd_selinux_permissive', true)) {
+      exec { 'set selinux to permissive on boot':
+        command => "sed -ie 's/^SELINUX=.*/SELINUX=permissive/' /etc/selinux/config",
+        onlyif  => "test -f /etc/selinux/config && ! grep '^SELINUX=permissive' /etc/selinux/config",
+        path    => ['/usr/bin', '/usr/sbin'],
+      }
+
+      exec { 'set selinux to permissive':
+        command => 'setenforce 0',
+        onlyif  => "which setenforce && getenforce | grep -i 'enforcing'",
+        path    => ['/usr/bin', '/usr/sbin'],
+      } -> Class['ceph::profile::osd']
+    }
+
     include ::ceph::profile::osd
   }
 
+  if str2bool(hiera('enable_external_ceph', false)) {
+    include ::ceph::profile::client
+  }
+
 } #END STEP 2
 
 if hiera('step') >= 3 {
 
   include ::keystone
+  include ::keystone::roles::admin
+  include ::keystone::endpoint
 
   #TODO: need a cleanup-keystone-tokens.sh solution here
   keystone_config {
@@ -249,16 +194,28 @@ if hiera('step') >= 3 {
     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)
+
   # TODO: notifications, scrubber, etc.
   include ::glance
-  include ::glance::api
+  class { '::glance::api':
+    known_stores => $glance_store,
+  }
   include ::glance::registry
-  include ::glance::backend::swift
+  include join(['::glance::backend::', $glance_backend])
 
-  class { 'nova':
-    glance_api_servers     => join([hiera('glance_protocol'), '://', hiera('controller_virtual_ip'), ':', hiera('glance_port')]),
+  class { '::nova' :
+    memcached_servers => suffix(hiera('memcache_node_ips'), ':11211'),
   }
-
+  include ::nova::config
   include ::nova::api
   include ::nova::cert
   include ::nova::conductor
@@ -266,11 +223,13 @@ if hiera('step') >= 3 {
   include ::nova::network::neutron
   include ::nova::vncproxy
   include ::nova::scheduler
+  include ::nova::scheduler::filter
 
   include ::neutron
   include ::neutron::server
-  include ::neutron::agents::dhcp
   include ::neutron::agents::l3
+  include ::neutron::agents::dhcp
+  include ::neutron::agents::metadata
 
   file { '/etc/neutron/dnsmasq-neutron.conf':
     content => hiera('neutron_dnsmasq_options'),
@@ -280,19 +239,46 @@ if hiera('step') >= 3 {
     require => Package['neutron'],
   }
 
-  class { 'neutron::plugins::ml2':
+  class { '::neutron::plugins::ml2':
     flat_networks        => split(hiera('neutron_flat_networks'), ','),
     tenant_network_types => [hiera('neutron_tenant_network_type')],
-    type_drivers         => [hiera('neutron_tenant_network_type')],
+    mechanism_drivers    => [hiera('neutron_mechanism_drivers')],
+  }
+  class { '::neutron::agents::ml2::ovs':
+    bridge_mappings => split(hiera('neutron_bridge_mappings'), ','),
+    tunnel_types    => split(hiera('neutron_tunnel_types'), ','),
   }
+  if 'cisco_n1kv' in hiera('neutron_mechanism_drivers') {
+    include ::neutron::plugins::ml2::cisco::nexus1000v
 
-  class { 'neutron::agents::ml2::ovs':
-    bridge_mappings  => split(hiera('neutron_bridge_mappings'), ','),
-    tunnel_types     => split(hiera('neutron_tunnel_types'), ','),
+    class { '::neutron::agents::n1kv_vem':
+      n1kv_source  => hiera('n1kv_vem_source', undef),
+      n1kv_version => hiera('n1kv_vem_version', undef),
+    }
+
+    class { '::n1k_vsm':
+      n1kv_source       => hiera('n1kv_vsm_source', undef),
+      n1kv_version      => hiera('n1kv_vsm_version', undef),
+      pacemaker_control => false,
+    }
+  }
+
+  if 'cisco_ucsm' in hiera('neutron_mechanism_drivers') {
+    include ::neutron::plugins::ml2::cisco::ucsm
+  }
+  if 'cisco_nexus' in hiera('neutron_mechanism_drivers') {
+    include ::neutron::plugins::ml2::cisco::nexus
+    include ::neutron::plugins::ml2::cisco::type_nexus_vxlan
   }
 
-  class { 'neutron::agents::metadata':
-    auth_url => join(['http://', hiera('controller_virtual_ip'), ':35357/v2.0']),
+  if hiera('neutron_enable_bigswitch_ml2', false) {
+    include ::neutron::plugins::ml2::bigswitch::restproxy
+  }
+  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);
   }
 
   Service['neutron-server'] -> Service['neutron-dhcp-service']
@@ -305,7 +291,7 @@ if hiera('step') >= 3 {
   include ::cinder::glance
   include ::cinder::scheduler
   include ::cinder::volume
-  class {'cinder::setup_test_volume':
+  class { '::cinder::setup_test_volume':
     size => join([hiera('cinder_lvm_loop_device_size'), 'M']),
   }
 
@@ -329,24 +315,78 @@ if hiera('step') >= 3 {
 
     $ceph_pools = hiera('ceph_pools')
     ceph::pool { $ceph_pools : }
+
+    $cinder_pool_requires = [Ceph::Pool[hiera('cinder_rbd_pool_name')]]
+
+  } else {
+    $cinder_pool_requires = []
   }
 
-  if $cinder_enable_rbd_backend {
+  if hiera('cinder_enable_rbd_backend', false) {
     $cinder_rbd_backend = 'tripleo_ceph'
 
+    cinder::backend::rbd { $cinder_rbd_backend :
+      rbd_pool        => hiera('cinder_rbd_pool_name'),
+      rbd_user        => hiera('ceph_client_user_name'),
+      rbd_secret_uuid => hiera('ceph::profile::params::fsid'),
+      require         => $cinder_pool_requires,
+    }
+  }
+
+  if hiera('cinder_enable_netapp_backend', false) {
+    $cinder_netapp_backend = hiera('cinder::backend::netapp::title')
+
     cinder_config {
-      "${cinder_rbd_backend}/host": value => 'hostgroup';
+      "${cinder_netapp_backend}/host": value => 'hostgroup';
     }
 
-    cinder::backend::rbd { $cinder_rbd_backend :
-      rbd_pool        => 'volumes',
-      rbd_user        => 'openstack',
-      rbd_secret_uuid => hiera('ceph::profile::params::fsid'),
-      require         => Ceph::Pool['volumes'],
+    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 :
+      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),
     }
   }
 
-  $cinder_enabled_backends = delete_undef_values([$cinder_iscsi_backend, $cinder_rbd_backend])
+  if hiera('cinder_enable_nfs_backend', false) {
+    $cinder_nfs_backend = 'tripleo_nfs'
+
+    if str2bool($::selinux) {
+      selboolean { 'virt_use_nfs':
+        value      => on,
+        persistent => true,
+      } -> Package['nfs-utils']
+    }
+
+    package {'nfs-utils': } ->
+    cinder::backend::nfs { $cinder_nfs_backend :
+      nfs_servers       => hiera('cinder_nfs_servers'),
+      nfs_mount_options => hiera('cinder_nfs_mount_options',''),
+      nfs_shares_config => '/etc/cinder/shares-nfs.conf',
+    }
+  }
+
+  $cinder_enabled_backends = delete_undef_values([$cinder_iscsi_backend, $cinder_rbd_backend, $cinder_netapp_backend, $cinder_nfs_backend])
   class { '::cinder::backends' :
     enabled_backends => $cinder_enabled_backends,
   }
@@ -360,16 +400,15 @@ 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
   include ::swift::proxy::formpost
 
   # swift storage
-  if str2bool(hiera('enable_swift_storage', 'true')) {
-    class {'swift::storage::all':
-      mount_check => str2bool(hiera('swift_mount_check'))
+  if str2bool(hiera('enable_swift_storage', true)) {
+    class { '::swift::storage::all':
+      mount_check => str2bool(hiera('swift_mount_check')),
     }
     if(!defined(File['/srv/node'])) {
       file { '/srv/node':
@@ -385,7 +424,17 @@ if hiera('step') >= 3 {
   }
 
   # Ceilometer
+  $ceilometer_backend = downcase(hiera('ceilometer_backend'))
+  case $ceilometer_backend {
+    /mysql/ : {
+      $ceilometer_database_connection = hiera('ceilometer_mysql_conn_string')
+    }
+    default : {
+      $ceilometer_database_connection = $ceilometer_mongodb_conn_string
+    }
+  }
   include ::ceilometer
+  include ::ceilometer::config
   include ::ceilometer::api
   include ::ceilometer::agent::notification
   include ::ceilometer::agent::central
@@ -393,11 +442,9 @@ if hiera('step') >= 3 {
   include ::ceilometer::alarm::evaluator
   include ::ceilometer::expirer
   include ::ceilometer::collector
+  include ::ceilometer::agent::auth
   class { '::ceilometer::db' :
-    database_connection => $ceilometer_mongodb_conn_string,
-  }
-  class { 'ceilometer::agent::auth':
-    auth_url => join(['http://', hiera('controller_virtual_ip'), ':5000/v2.0']),
+    database_connection => $ceilometer_database_connection,
   }
 
   Cron <| title == 'ceilometer-expirer' |> { command => "sleep $((\$(od -A n -t d -N 3 /dev/urandom) % 86400)) && ${::ceilometer::params::expirer_command}" }
@@ -410,10 +457,16 @@ if hiera('step') >= 3 {
   include ::heat::engine
 
   # Horizon
-  $vhost_params = { add_listen => false }
-  class { 'horizon':
-    cache_server_ip    => split(hiera('memcache_node_ips', '127.0.0.1'), ','),
-    vhost_extra_params => $vhost_params,
+  if 'cisco_n1kv' in hiera('neutron_mechanism_drivers') {
+    $_profile_support = 'cisco'
+  } else {
+    $_profile_support = 'None'
+  }
+  $neutron_options   = {'profile_support' => $_profile_support }
+
+  class { '::horizon':
+    cache_server_ip => hiera('memcache_node_ips', '127.0.0.1'),
+    neutron_options => $neutron_options,
   }
 
   $snmpd_user = hiera('snmpd_readonly_user_name')
@@ -421,9 +474,18 @@ if hiera('step') >= 3 {
     authtype => 'MD5',
     authpass => hiera('snmpd_readonly_user_password'),
   }
-  class { 'snmp':
+  class { '::snmp':
     agentaddress => ['udp:161','udp6:[::1]:161'],
     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 {
+  include ::keystone::cron::token_flush
+} #END STEP 4
+
+$package_manifest_name = join(['/var/lib/tripleo/installed-packages/overcloud_controller', hiera('step')])
+package_manifest{$package_manifest_name: ensure => present}