Refactor mongos handling

manifests/globals.pp

@@ -3,17 +3,11 @@
 class mongodb::globals (
   $server_package_name   = undef,
   $client_package_name   = undef,
-  $mongos_package_name   = undef,
 
   $mongod_service_manage = undef,
   $service_enable        = undef,
   $service_ensure        = undef,
   $service_name          = undef,
-  $mongos_service_manage = undef,
-  $mongos_service_enable = undef,
-  $mongos_service_ensure = undef,
-  $mongos_service_status = undef,
-  $mongos_service_name   = undef,
   $service_provider      = undef,
   $service_status        = undef,
 

manifests/mongos.pp

@@ -1,32 +1,31 @@
 # This installs a Mongo Shard daemon. See README.md for more details.
 class mongodb::mongos (
-  Variant[Boolean, String] $ensure                          = $mongodb::params::mongos_ensure,
-  Stdlib::Absolutepath $config                              = $mongodb::params::mongos_config,
-  $config_content                                           = undef,
-  $config_template                                          = undef,
-  $configdb                                                 = $mongodb::params::mongos_configdb,
-  Optional[Hash] $config_data                               = $mongodb::params::config_data,
-  Boolean $service_manage                                   = $mongodb::params::mongos_service_manage,
-  Optional[String] $service_provider                        = undef,
-  Optional[String] $service_name                            = $mongodb::params::mongos_service_name,
-  Boolean $service_enable                                   = $mongodb::params::mongos_service_enable,
-  Enum['stopped','running'] $service_ensure                 = $mongodb::params::mongos_service_ensure,
-  Optional[Enum['stopped','running']] $service_status       = $mongodb::params::mongos_service_status,
-  Variant[Boolean, String] $package_ensure                  = $mongodb::params::package_ensure_mongos,
-  String $package_name                                      = $mongodb::params::mongos_package_name,
-  Optional[Stdlib::Absolutepath] $unixsocketprefix          = $mongodb::params::mongos_unixsocketprefix,
-  Optional[Stdlib::Absolutepath] $pidfilepath               = $mongodb::params::mongos_pidfilepath,
-  Optional[Variant[Boolean, Stdlib::Absolutepath]] $logpath = $mongodb::params::mongos_logpath,
-  Optional[Boolean] $fork                                   = $mongodb::params::mongos_fork,
-  Optional[Array[Stdlib::Compat::Ip_address]] $bind_ip      = undef,
-  Optional[Integer[1, 65535]] $port                         = undef,
-  Boolean $restart                                          = $mongodb::params::mongos_restart,
-) inherits mongodb::params {
+  Stdlib::Absolutepath $config                              = $mongodb::mongos::params::config,
+  Optional[String[1]] $config_content                       = $mongodb::mongos::params::config_content,
+  Optional[String[1]] $config_template                      = $mongodb::mongos::params::config_template,
+  Variant[String[1], Array[String[1]]] $configdb            = $mongodb::mongos::params::configdb,
+  Optional[Hash] $config_data                               = $mongodb::mongos::params::config_data,
+  Boolean $service_manage                                   = $mongodb::mongos::params::service_manage,
+  Optional[String] $service_provider                        = $mongodb::mongos::params::service_provider,
+  Optional[String] $service_name                            = $mongodb::mongos::params::service_name,
+  Boolean $service_enable                                   = $mongodb::mongos::params::service_enable,
+  Stdlib::Ensure::Service $service_ensure                   = $mongodb::mongos::params::service_ensure,
+  Optional[String] $service_status                          = $mongodb::mongos::params::service_status,
+  Variant[Boolean, String] $package_ensure                  = $mongodb::mongos::params::package_ensure,
+  String $package_name                                      = $mongodb::mongos::params::package_name,
+  Optional[Stdlib::Absolutepath] $unixsocketprefix          = $mongodb::mongos::params::unixsocketprefix,
+  Optional[Stdlib::Absolutepath] $pidfilepath               = $mongodb::mongos::params::pidfilepath,
+  Optional[Variant[Boolean, Stdlib::Absolutepath]] $logpath = $mongodb::mongos::params::logpath,
+  Optional[Boolean] $fork                                   = $mongodb::mongos::params::fork,
+  Optional[Array[Stdlib::IP::Address]] $bind_ip             = $mongodb::mongos::params::bind_ip,
+  Optional[Stdlib::Port] $port                              = $mongodb::mongos::params::port,
+  Boolean $restart                                          = $mongodb::mongos::params::restart,
+) inherits mongodb::mongos::params {
   contain mongodb::mongos::install
   contain mongodb::mongos::config
   contain mongodb::mongos::service
 
-  if ($ensure == 'present' or $ensure == true) {
+  unless $package_ensure in ['absent', 'purged'] {
     Class['mongodb::mongos::install'] -> Class['mongodb::mongos::config']
 
     if $restart {

manifests/mongos/config.pp

@@ -1,50 +1,59 @@
 # PRIVATE CLASS: do not call directly
 class mongodb::mongos::config (
-  $ensure          = $mongodb::mongos::ensure,
-  $config          = $mongodb::mongos::config,
-  $config_content  = $mongodb::mongos::config_content,
-  $config_template = $mongodb::mongos::config_template,
-  $configdb        = $mongodb::mongos::configdb,
-  $config_data     = $mongodb::mongos::config_data,
-  $service_manage  = $mongodb::mongos::service_manage,
+  $package_ensure   = $mongodb::mongos::package_ensure,
+  $config           = $mongodb::mongos::config,
+  $config_content   = $mongodb::mongos::config_content,
+  $config_template  = $mongodb::mongos::config_template,
+  $service_manage   = $mongodb::mongos::service_manage,
+  # Used in the template
+  $configdb         = $mongodb::mongos::configdb,
+  $bind_ip          = $mongodb::mongos::bind_ip,
+  $port             = $mongodb::mongos::port,
+  $fork             = $mongodb::mongos::fork,
+  $pidfilepath      = $mongodb::mongos::pidfilepath,
+  $logpath          = $mongodb::mongos::logpath,
+  $unixsocketprefix = $mongodb::mongos::unixsocketprefix,
+  $config_data      = $mongodb::mongos::config_data,
 ) {
+  if $package_ensure == 'purged' {
+    $ensure = 'absent'
+  } else {
+    $ensure = 'file'
+  }
 
-  if ($ensure == 'present' or $ensure == true) {
-
-    #Pick which config content to use
-    if $config_content {
-      $config_content_real = $config_content
-    } else {
-      # Template has $config_data hash available
-      $config_content_real = template(pick($config_template, 'mongodb/mongodb-shard.conf.erb'))
-    }
+  #Pick which config content to use
+  if $config_content {
+    $config_content_real = $config_content
+  } else {
+    # Template has $config_data hash available
+    $config_content_real = template(pick($config_template, 'mongodb/mongodb-shard.conf.erb'))
+  }
 
-    file { $config:
-      content => $config_content_real,
-      owner   => 'root',
-      group   => 'root',
-      mode    => '0644',
-    }
+  file { $config:
+    ensure  => $ensure,
+    content => $config_content_real,
+    owner   => 'root',
+    group   => 'root',
+    mode    => '0644',
+  }
 
-    if $service_manage {
-      if $facts['os']['family'] == 'RedHat' {
-        file { '/etc/sysconfig/mongos' :
-          ensure  => file,
-          owner   => 'root',
-          group   => 'root',
-          mode    => '0644',
-          content => "OPTIONS=\"--quiet -f ${config}\"\n",
-        }
-      } elsif $facts['os']['family'] == 'Debian' {
-        file { '/etc/init.d/mongos' :
-          ensure  => file,
-          content => template('mongodb/mongos/Debian/mongos.erb'),
-          owner   => 'root',
-          group   => 'root',
-          mode    => '0755',
-        }
+  if $service_manage {
+    if $facts['os']['family'] == 'RedHat' {
+      file { '/etc/sysconfig/mongos' :
+        ensure  => $ensure,
+        owner   => 'root',
+        group   => 'root',
+        mode    => '0644',
+        content => "OPTIONS=\"--quiet -f ${config}\"\n",
+      }
+    } elsif $facts['os']['family'] == 'Debian' {
+      file { '/etc/init.d/mongos' :
+        ensure  => $ensure,
+        content => template('mongodb/mongos/Debian/mongos.erb'),
+        owner   => 'root',
+        group   => 'root',
+        mode    => '0755',
       }
     }
   }
-
 }

manifests/mongos/install.pp

@@ -1,30 +1,12 @@
 # PRIVATE CLASS: do not call directly
 class mongodb::mongos::install (
-  $package_ensure           = $mongodb::mongos::package_ensure,
-  $package_name             = $mongodb::mongos::package_name,
+  $package_ensure = $mongodb::mongos::package_ensure,
+  $package_name   = $mongodb::mongos::package_name,
 ) {
 
-  case $package_ensure {
-    true:     {
-      $my_package_ensure = 'present'
-    }
-    false:    {
-      $my_package_ensure = 'absent'
-    }
-    'absent': {
-      $my_package_ensure = 'absent'
-    }
-    'purged': {
-      $my_package_ensure = 'purged'
-    }
-    default:  {
-      $my_package_ensure = $package_ensure
-    }
-  }
-
-  if !defined(Package[$package_name]) {
+  unless defined(Package[$package_name]) {
     package { 'mongodb_mongos':
-      ensure => $my_package_ensure,
+      ensure => $package_ensure,
       name   => $package_name,
     }
   }

manifests/mongos/params.pp

@@ -0,0 +1,65 @@
+# PRIVATE CLASS: do not use directly
+class mongodb::mongos::params inherits mongodb::globals {
+  if $mongodb::globals::use_enterprise_repo {
+    $edition = 'enterprise'
+  } else {
+    $edition = 'org'
+  }
+
+  $manage_package = pick($mongodb::globals::manage_package, $mongodb::globals::manage_package_repo, false)
+
+  $version = $mongodb::globals::version
+
+  $package_ensure = pick($version, 'present')
+  if $manage_package {
+    $package_name = "mongodb-${edition}-mongos"
+  } else {
+    $package_name = 'mongodb-server'
+  }
+
+  $config_content = undef
+  $config_template = undef
+
+  $config_data = undef
+  $configdb    = '127.0.0.1:27019'
+  $bind_ip     = undef
+  $port        = undef
+  $restart     = true
+
+  $service_name   = 'mongos'
+  $service_manage = true
+  $service_enable = true
+  $service_ensure = 'running'
+  $service_status = undef
+
+  # Amazon Linux's OS Family is 'Linux', operating system 'Amazon'.
+  case $::osfamily {
+    'RedHat', 'Linux', 'Suse': {
+      if $manage_package {
+        $config           = '/etc/mongodb-shard.conf'
+        $pidfilepath      = undef
+        $unixsocketprefix = undef
+        $logpath          = undef
+        $fork             = undef
+      } else {
+        # RedHat/CentOS doesn't come with a prepacked mongodb
+        # so we assume that you are using EPEL repository.
+        $config           = '/etc/mongos.conf'
+        $pidfilepath      = '/var/run/mongodb/mongos.pid'
+        $unixsocketprefix = '/var/run/mongodb'
+        $logpath          = '/var/log/mongodb/mongos.log'
+        $fork             = true
+      }
+    }
+    'Debian': {
+      $config           = '/etc/mongodb-shard.conf'
+      $pidfilepath      = undef
+      $unixsocketprefix = undef
+      $logpath          = undef
+      $fork             = undef
+    }
+    default: {
+      fail("Osfamily ${::osfamily} is not supported")
+    }
+  }
+}

manifests/mongos/service.pp

@@ -1,5 +1,6 @@
 # PRIVATE CLASS: do not call directly
 class mongodb::mongos::service (
+  $package_ensure   = $mongodb::mongos::package_ensure,
   $service_manage   = $mongodb::mongos::service_manage,
   $service_name     = $mongodb::mongos::service_name,
   $service_enable   = $mongodb::mongos::service_enable,
@@ -10,32 +11,32 @@
   $port             = $mongodb::mongos::port,
 ) {
 
-  $service_ensure_real = $service_ensure ? {
-    'absent'  => false,
-    'purged'  => false,
-    'stopped' => false,
-    default   => true
+  if $package_ensure in ['absent', 'purged'] {
+    $real_service_ensure = 'stopped'
+    $real_service_enable = false
+  } else {
+    $real_service_ensure = $service_ensure
+    $real_service_enable = $service_enable
   }
 
   if $bind_ip == '0.0.0.0' {
-    $bind_ip_real = '127.0.0.1'
+    $connect_ip = '127.0.0.1'
   } else {
-    $bind_ip_real = $bind_ip
+    $connect_ip = $bind_ip
   }
 
   if $service_manage {
     service { 'mongos':
-      ensure    => $service_ensure_real,
-      name      => $service_name,
-      enable    => $service_enable,
-      provider  => $service_provider,
-      hasstatus => true,
-      status    => $service_status,
+      ensure   => $real_service_ensure,
+      name     => $service_name,
+      enable   => $real_service_enable,
+      provider => $service_provider,
+      status   => $service_status,
     }
 
-    if $service_ensure_real {
+    if $service_ensure == 'running' {
       mongodb_conn_validator { 'mongos':
-        server  => $bind_ip_real,
+        server  => $connect_ip,
         port    => pick($port, 27017),
         timeout => '240',
         require => Service['mongos'],