diff --git a/manifests/dnfmodule.pp b/manifests/dnfmodule.pp
new file mode 100644
index 0000000..a1cb4b9
--- /dev/null
+++ b/manifests/dnfmodule.pp
@@ -0,0 +1,20 @@
+# @summary Manage the DNF module
+#
+# On EL8 and Fedora DNF can manage modules. This is a method of providing
+# multiple versions on the same OS. Only one DNF module can be active at the
+# same time.
+#
+# @api private
+class postgresql::dnfmodule (
+  String[1] $ensure = 'installed',
+  String[1] $module = 'postgresql',
+) {
+  package { 'postgresql dnf module':
+    ensure      => $ensure,
+    name        => $module,
+    enable_only => true,
+    provider    => 'dnfmodule',
+  }
+
+  Package['postgresql dnf module'] -> Package<|tag == 'puppetlabs-postgresql'|>
+}
diff --git a/manifests/globals.pp b/manifests/globals.pp
index b4d73a2..db39f1c 100644
--- a/manifests/globals.pp
+++ b/manifests/globals.pp
@@ -1,268 +1,279 @@
 # @summary Class for setting cross-class global overrides.
 #
 # @note
 #   Most server-specific defaults should be overridden in the postgresql::server class.
 #   This class should be used only if you are using a non-standard OS, or if you are changing elements that can only be changed here, such as version or manage_package_repo.
 #
 #
 # @param client_package_name  Overrides the default PostgreSQL client package name.
 # @param server_package_name Overrides the default PostgreSQL server package name.
 # @param contrib_package_name Overrides the default PostgreSQL contrib package name.
 # @param devel_package_name Overrides the default PostgreSQL devel package name.
 # @param java_package_name Overrides the default PostgreSQL java package name.
 # @param docs_package_name Overrides the default PostgreSQL docs package name.
 # @param perl_package_name Overrides the default PostgreSQL Perl package name.
 # @param plperl_package_name Overrides the default PostgreSQL PL/Perl package name.
 # @param plpython_package_name Overrides the default PostgreSQL PL/Python package name.
 # @param python_package_name Overrides the default PostgreSQL Python package name.
 # @param postgis_package_name Overrides the default PostgreSQL PostGIS package name.
 #
 # @param service_name Overrides the default PostgreSQL service name.
 # @param service_provider Overrides the default PostgreSQL service provider.
 # @param service_status Overrides the default status check command for your PostgreSQL service.
 # @param default_database Specifies the name of the default database to connect with.
 #
 # @param validcon_script_path Scipt path for the connection validation check.
 #
 # @param initdb_path Path to the initdb command.
 # @param createdb_path Deprecated. Path to the createdb command.
 # @param psql_path Sets the path to the psql command.
 # @param pg_hba_conf_path Specifies the path to your pg_hba.conf file.
 # @param pg_ident_conf_path Specifies the path to your pg_ident.conf file.
 # @param postgresql_conf_path Sets the path to your postgresql.conf file.
 # @param postgresql_conf_mode Sets the mode of your postgresql.conf file. Only relevant if manage_postgresql_conf_perms is true.
 # @param recovery_conf_path Path to your recovery.conf file.
 # @param default_connect_settings Default connection settings.
 #
 # @param pg_hba_conf_defaults Disables the defaults supplied with the module for pg_hba.conf if set to false.
 #
 # @param datadir
 #    Overrides the default PostgreSQL data directory for the target platform.
 #    Changing the datadir after installation causes the server to come to a full stop before making the change.
 #    For Red Hat systems, the data directory must be labeled appropriately for SELinux.
 #    On Ubuntu, you must explicitly set needs_initdb = true to allow Puppet to initialize the database in the new datadir (needs_initdb defaults to true on other systems).
 #    Warning! If datadir is changed from the default, Puppet does not manage purging of the original data directory, which causes it to fail if the data directory is changed back to the original
 #
 # @param confdir Overrides the default PostgreSQL configuration directory for the target platform.
 # @param bindir Overrides the default PostgreSQL binaries directory for the target platform.
 # @param xlogdir Overrides the default PostgreSQL xlog directory.
 # @param logdir Overrides the default PostgreSQL log directory.
 # @param log_line_prefix Overrides the default PostgreSQL log prefix.
 #
 # @param user Overrides the default PostgreSQL super user and owner of PostgreSQL related files in the file system.
 # @param group Overrides the default postgres user group to be used for related files in the file system.
 #
 # @param version The version of PostgreSQL to install and manage.
 # @param postgis_version Defines the version of PostGIS to install, if you install PostGIS.
 # @param repo_proxy Sets the proxy option for the official PostgreSQL yum-repositories only.
 #
 # @param repo_baseurl Sets the baseurl for the PostgreSQL repository. Useful if you host your own mirror of the repository.
 #
 # @param needs_initdb Explicitly calls the initdb operation after the server package is installed and before the PostgreSQL service is started.
 #
 # @param encoding
 #   Sets the default encoding for all databases created with this module.
 #   On certain operating systems, this is also used during the template1 initialization, so it becomes a default outside of the module as well.
 # @param locale
 #   Sets the default database locale for all databases created with this module.
 #   On certain operating systems, this is also used during the template1 initialization, so it becomes a default outside of the module as well.
 #   On Debian, you'll need to ensure that the 'locales-all' package is installed for full functionality of PostgreSQL.
 # @param data_checksums
 #   Use checksums on data pages to help detect corruption by the I/O system that would otherwise be silent.
 #   Warning: This option is used during initialization by initdb, and cannot be changed later.
 #
 # @param timezone Sets the default timezone of the postgresql server. The postgresql built-in default is taking the systems timezone information.
 #
 # @param manage_pg_hba_conf Allow Puppet to manage the pg_hba.conf file.
 # @param manage_pg_ident_conf Allow Puppet to manage the pg_ident.conf file.
 # @param manage_recovery_conf Allow Puppet to manage the recovery.conf file.
 # @param manage_postgresql_conf_perms
 #   Whether to manage the postgresql conf file permissions. This means owner,
 #   group and mode. Contents are not managed but should be managed through
 #   postgresql::server::config_entry.
 #
 # @param manage_datadir Set to false if you have file{ $datadir: } already defined
 # @param manage_logdir Set to false if you have file{ $logdir: } already defined
 # @param manage_xlogdir Set to false if you have file{ $xlogdir: } already defined
 #
 # @param manage_package_repo Sets up official PostgreSQL repositories on your host if set to true.
+# @param manage_dnf_module
+#   Manage the DNF module. This only makes sense on distributions that use DNF
+#   package manager, such as EL8 or Fedora. It also requires Puppet 5.5.20+ or
+#   Puppet 6.15.0+ since they ship the dnfmodule provider.
 # @param module_workdir Specifies working directory under which the psql command should be executed. May need to specify if '/tmp' is on volume mounted with noexec option.
 #
 #
 class postgresql::globals (
   $client_package_name                             = undef,
   $server_package_name                             = undef,
   $contrib_package_name                            = undef,
   $devel_package_name                              = undef,
   $java_package_name                               = undef,
   $docs_package_name                               = undef,
   $perl_package_name                               = undef,
   $plperl_package_name                             = undef,
   $plpython_package_name                           = undef,
   $python_package_name                             = undef,
   $postgis_package_name                            = undef,
 
   $service_name                                    = undef,
   $service_provider                                = undef,
   $service_status                                  = undef,
   $default_database                                = undef,
 
   $validcon_script_path                            = undef,
 
   $initdb_path                                     = undef,
   $createdb_path                                   = undef,
   $psql_path                                       = undef,
   $pg_hba_conf_path                                = undef,
   $pg_ident_conf_path                              = undef,
   $postgresql_conf_path                            = undef,
   Optional[Stdlib::Filemode] $postgresql_conf_mode = undef,
   $recovery_conf_path                              = undef,
   $default_connect_settings                        = {},
 
   $pg_hba_conf_defaults                            = undef,
 
   $datadir                                         = undef,
   $confdir                                         = undef,
   $bindir                                          = undef,
   $xlogdir                                         = undef,
   $logdir                                          = undef,
   $log_line_prefix                                 = undef,
   $manage_datadir                                  = undef,
   $manage_logdir                                   = undef,
   $manage_xlogdir                                  = undef,
 
   $user                                            = undef,
   $group                                           = undef,
 
   $version                                         = undef,
   $postgis_version                                 = undef,
   $repo_proxy                                      = undef,
   $repo_baseurl                                    = undef,
 
   $needs_initdb                                    = undef,
 
   $encoding                                        = undef,
   $locale                                          = undef,
   $data_checksums                                  = undef,
   $timezone                                        = undef,
 
   $manage_pg_hba_conf                              = undef,
   $manage_pg_ident_conf                            = undef,
   $manage_recovery_conf                            = undef,
   $manage_postgresql_conf_perms                    = undef,
   $manage_selinux                                  = undef,
 
   $manage_package_repo                             = undef,
+  Boolean $manage_dnf_module                       = false,
   $module_workdir                                  = undef,
 ) {
   # We are determining this here, because it is needed by the package repo
   # class.
   $default_version = $facts['os']['family'] ? {
     /^(RedHat|Linux)/ => $facts['os']['name'] ? {
       'Fedora' => $facts['os']['release']['major'] ? {
         /^(32|33)$/    => '12',
         /^(31)$/       => '11.6',
         /^(30)$/       => '11.2',
         /^(29)$/       => '10.6',
         /^(28)$/       => '10.4',
         /^(26|27)$/    => '9.6',
         /^(24|25)$/    => '9.5',
         /^(22|23)$/    => '9.4',
         /^(21)$/       => '9.3',
         /^(18|19|20)$/ => '9.2',
         /^(17)$/       => '9.1',
         default        => undef,
       },
       'Amazon' => '9.2',
       default => $facts['os']['release']['major'] ? {
         '8'     => '10',
         '7'     => '9.2',
         '6'     => '8.4',
         '5'     => '8.1',
         default => undef,
       },
     },
     'Debian' => $facts['os']['name'] ? {
       'Debian' => $facts['os']['release']['major'] ? {
         '6'     => '8.4',
         '7'     => '9.1',
         '8'     => '9.4',
         '9'     => '9.6',
         '10'    => '11',
         default => undef,
       },
       'Ubuntu' => $facts['os']['release']['major'] ? {
         /^(10.04|10.10|11.04)$/ => '8.4',
         /^(11.10|12.04|12.10|13.04|13.10)$/ => '9.1',
         /^(14.04)$/ => '9.3',
         /^(14.10|15.04|15.10)$/ => '9.4',
         /^(16.04|16.10)$/ => '9.5',
         /^(17.04|17.10)$/ => '9.6',
         /^(18.04)$/ => '10',
         /^(20.04)$/ => '12',
         default => undef,
       },
       default => undef,
     },
     'Archlinux' => '9.2',
     'Gentoo' => '9.5',
     'FreeBSD' => '12',
     'OpenBSD' => $facts['os']['release']['full'] ? {
       /5\.6/ => '9.3',
       /5\.[7-9]/ => '9.4',
       /6\.[0-9]/ => '9.5',
     },
     'Suse' => $facts['os']['name'] ? {
       'SLES' => $facts['os']['release']['full'] ? {
         /11\.[0-3]/ => '91',
         /11\.4/     => '94',
         /12\.0/     => '93',
         /12\.[1-3]/ => '94',
         /12\.[4-5]/ => '10',
         /15\.[0-9]/     => '10',
         default     => '96',
       },
       'OpenSuSE' => $facts['os']['release']['full'] ? {
         /42\.[1-2]/ => '94',
         default     => '96',
       },
       default => undef,
     },
     default => undef,
   }
   $globals_version = pick($version, $default_version, 'unknown')
   if($globals_version == 'unknown') {
     fail('No preferred version defined or automatically detected.')
   }
 
   $default_postgis_version = $globals_version ? {
     '8.1'   => '1.3.6',
     '8.4'   => '2.0',
     '9.0'   => '2.1',
     '9.1'   => '2.1',
     '91'    => '2.1',
     '9.2'   => '2.3',
     '9.3'   => '2.3',
     '93'    => '2.3',
     '9.4'   => '2.3',
     '9.5'   => '2.3',
     '9.6'   => '2.3',
     '10'    => '2.4',
     '11'    => '3.0',
     '12'    => '3.0',
     default => undef,
   }
   $globals_postgis_version = $postgis_version ? {
     undef   => $default_postgis_version,
     default => $postgis_version,
   }
 
   # Setup of the repo only makes sense globally, so we are doing this here.
   if($manage_package_repo) {
     class { 'postgresql::repo':
       version => $globals_version,
       proxy   => $repo_proxy,
       baseurl => $repo_baseurl,
     }
   }
+
+  if $manage_dnf_module {
+    class { 'postgresql::dnfmodule':
+      ensure => $globals_version,
+    }
+  }
 }
diff --git a/manifests/params.pp b/manifests/params.pp
index de3eccf..f557b27 100644
--- a/manifests/params.pp
+++ b/manifests/params.pp
@@ -1,362 +1,362 @@
 # @api private
 class postgresql::params inherits postgresql::globals {
   $version                      = $postgresql::globals::globals_version
   $postgis_version              = $postgresql::globals::globals_postgis_version
   $listen_addresses             = undef
   $port                         = 5432
   $log_line_prefix              = undef
   $ip_mask_deny_postgres_user   = '0.0.0.0/0'
   $ip_mask_allow_all_users      = '127.0.0.1/32'
   $ipv4acls                     = []
   $ipv6acls                     = []
   $encoding                     = $postgresql::globals::encoding
   $locale                       = $postgresql::globals::locale
   $data_checksums               = $postgresql::globals::data_checksums
   $timezone                     = $postgresql::globals::timezone
   $service_ensure               = 'running'
   $service_enable               = true
   $service_manage               = true
   $service_restart_on_change    = true
   $service_provider             = $postgresql::globals::service_provider
   $manage_pg_hba_conf           = pick($manage_pg_hba_conf, true)
   $manage_pg_ident_conf         = pick($manage_pg_ident_conf, true)
   $manage_recovery_conf         = pick($manage_recovery_conf, false)
   $manage_postgresql_conf_perms = pick($manage_postgresql_conf_perms, true)
   $manage_selinux               = pick($manage_selinux, false)
   $package_ensure               = 'present'
   $module_workdir               = pick($module_workdir,'/tmp')
   $password_encryption          = undef
   $extra_systemd_config         = ''
   $manage_datadir               = true
   $manage_logdir                = true
   $manage_xlogdir               = true
 
   # Amazon Linux's OS Family is 'Linux', operating system 'Amazon'.
   case $facts['os']['family'] {
     'RedHat', 'Linux': {
       $link_pg_config     = true
       $user               = pick($user, 'postgres')
       $group              = pick($group, 'postgres')
       $needs_initdb       = pick($needs_initdb, true)
       $version_parts      = split($version, '[.]')
       $package_version    = "${version_parts[0]}${version_parts[1]}"
 
-      if $version == $postgresql::globals::default_version and $facts['os']['name'] != 'Amazon' {
+      if $version == $postgresql::globals::default_version and $facts['os']['name'] != 'Amazon' or $postgresql::globals::manage_dnf_module {
         $client_package_name    = pick($client_package_name, 'postgresql')
         $server_package_name    = pick($server_package_name, 'postgresql-server')
         $contrib_package_name   = pick($contrib_package_name,'postgresql-contrib')
         $devel_package_name     = pick($devel_package_name, 'postgresql-devel')
         $java_package_name      = pick($java_package_name, 'postgresql-jdbc')
         $docs_package_name      = pick($docs_package_name, 'postgresql-docs')
         $plperl_package_name    = pick($plperl_package_name, 'postgresql-plperl')
         $plpython_package_name  = pick($plpython_package_name, 'postgresql-plpython')
         $service_name           = pick($service_name, 'postgresql')
         $bindir                 = pick($bindir, '/usr/bin')
         $datadir                = $facts['os']['name'] ? {
           'Amazon' => pick($datadir, "/var/lib/pgsql${package_version}/data"),
           default  => pick($datadir, '/var/lib/pgsql/data'),
         }
         $confdir                = pick($confdir, $datadir)
       } else {
         $client_package_name    = pick($client_package_name, "postgresql${package_version}")
         $server_package_name    = pick($server_package_name, "postgresql${package_version}-server")
         $contrib_package_name   = pick($contrib_package_name,"postgresql${package_version}-contrib")
         $devel_package_name     = pick($devel_package_name, "postgresql${package_version}-devel")
         $java_package_name      = pick($java_package_name, "postgresql${package_version}-jdbc")
         $docs_package_name      = pick($docs_package_name, "postgresql${package_version}-docs")
         $plperl_package_name    = pick($plperl_package_name, "postgresql${package_version}-plperl")
         $plpython_package_name  = pick($plpython_package_name, "postgresql${package_version}-plpython")
         $service_name           = $facts['os']['name'] ? {
           'Amazon' => pick($service_name, "postgresql${version_parts[0]}${version_parts[1]}"),
           default  => pick($service_name, "postgresql-${version}"),
         }
         $bindir                 = $facts['os']['name'] ? {
           'Amazon' => pick($bindir, '/usr/bin'),
           default  => pick($bindir, "/usr/pgsql-${version}/bin"),
         }
         $datadir                = $facts['os']['name'] ? {
           'Amazon' => pick($datadir, "/var/lib/pgsql${package_version}/data"),
           default  => pick($datadir, "/var/lib/pgsql/${version}/data"),
         }
         $confdir                = pick($confdir, $datadir)
         $postgresql_conf_mode   = pick($postgresql_conf_mode, '0600')
       }
 
       case $facts['os']['name'] {
         'Amazon': {
           $service_reload = "service ${service_name} reload"
           $service_status = "service ${service_name} status"
         }
 
         # RHEL 5 uses SysV init, RHEL 6 uses upstart.  RHEL 7 and 8 both use systemd.
         'RedHat', 'CentOS', 'Scientific', 'OracleLinux': {
           if $facts['os']['release']['major'] in ['7', '8'] {
             $service_reload = "systemctl reload ${service_name}"
             $service_status = "systemctl status ${service_name}"
           } else {
             $service_reload = "service ${service_name} reload"
             $service_status = "service ${service_name} status"
           }
         }
 
         # Default will catch Fedora which uses systemd
         default: {
           $service_reload = "systemctl reload ${service_name}"
           $service_status = "systemctl status ${service_name}"
         }
       }
 
       $psql_path           = pick($psql_path, "${bindir}/psql")
 
       $perl_package_name   = pick($perl_package_name, 'perl-DBD-Pg')
       $python_package_name = pick($python_package_name, 'python-psycopg2')
 
       if $postgresql::globals::postgis_package_name {
         $postgis_package_name = $postgresql::globals::postgis_package_name
       } elsif $facts['os']['release']['major'] == '5' {
         $postgis_package_name = 'postgis'
       } elsif $postgis_version and versioncmp($postgis_version, '2') < 0 {
         $postgis_package_name = "postgis${package_version}"
       } else {
         $postgis_package_name = "postgis2_${package_version}"
       }
     }
 
     'Archlinux': {
       $link_pg_config     = true
       $needs_initdb       = pick($needs_initdb, true)
       $user               = pick($user, 'postgres')
       $group              = pick($group, 'postgres')
 
       # Archlinux doesn't have a client-package but has a libs package which
       # pulls in postgresql server
       $client_package_name    = pick($client_package_name, 'postgresql')
       $server_package_name    = pick($server_package_name, 'postgresql-libs')
       $java_package_name      = pick($java_package_name, 'postgresql-jdbc')
       # Archlinux doesn't have develop packages
       $devel_package_name     = pick($devel_package_name, 'postgresql-devel')
       # Archlinux does have postgresql-contrib but it isn't maintained
       $contrib_package_name   = pick($contrib_package_name,'undef')
       # Archlinux postgresql package provides plperl
       $plperl_package_name    = pick($plperl_package_name, 'undef')
       $plpython_package_name  = pick($plpython_package_name, 'undef')
       $service_name           = pick($service_name, 'postgresql')
       $bindir                 = pick($bindir, '/usr/bin')
       $datadir                = pick($datadir, '/var/lib/postgres/data')
       $confdir                = pick($confdir, $datadir)
       $psql_path              = pick($psql_path, "${bindir}/psql")
 
       $service_status         = $service_status
       $service_reload         = "systemctl reload ${service_name}"
       $python_package_name    = pick($python_package_name, 'python-psycopg2')
       # Archlinux does not have a perl::DBD::Pg package
       $perl_package_name      = pick($perl_package_name, 'undef')
     }
 
     'Debian': {
       $link_pg_config     = false
       $user               = pick($user, 'postgres')
       $group              = pick($group, 'postgres')
 
       if $postgresql::globals::manage_package_repo == true {
         $needs_initdb = pick($needs_initdb, true)
         $service_name = pick($service_name, 'postgresql')
       } else {
         $needs_initdb = pick($needs_initdb, false)
         $service_name = $facts['os']['name'] ? {
           'Debian' => pick($service_name, 'postgresql'),
           'Ubuntu' => $::lsbmajdistrelease ? {
             /^10/ => pick($service_name, "postgresql-${version}"),
             default => pick($service_name, 'postgresql'),
           },
           default => undef
         }
       }
 
       $client_package_name    = pick($client_package_name, "postgresql-client-${version}")
       $server_package_name    = pick($server_package_name, "postgresql-${version}")
       if $facts['os']['name'] == 'Debian' and $facts['os']['release']['major'] == '10' and $postgresql::globals::manage_package_repo != true {
         $contrib_package_name = pick($contrib_package_name, 'postgresql-contrib')
       } else {
         $contrib_package_name = pick($contrib_package_name, "postgresql-contrib-${version}")
       }
       if $postgis_version and versioncmp($postgis_version, '2') < 0 {
         $postgis_package_name = pick($postgis_package_name, "postgresql-${version}-postgis")
       } elsif $postgis_version and versioncmp($postgis_version, '3') >= 0 {
         $postgis_package_name = pick($postgis_package_name, "postgresql-${version}-postgis-3")
       } else {
         $postgis_package_name = pick($postgis_package_name, "postgresql-${version}-postgis-${postgis_version}")
       }
       $devel_package_name     = pick($devel_package_name, 'libpq-dev')
       $java_package_name = $facts['os']['name'] ? {
         'Debian' => $facts['os']['release']['major'] ? {
           '6'     => pick($java_package_name, 'libpg-java'),
           default => pick($java_package_name, 'libpostgresql-jdbc-java'),
         },
         default  => pick($java_package_name, 'libpostgresql-jdbc-java'),
       }
       $perl_package_name      = pick($perl_package_name, 'libdbd-pg-perl')
       $plperl_package_name    = pick($plperl_package_name, "postgresql-plperl-${version}")
       $plpython_package_name  = pick($plpython_package_name, "postgresql-plpython-${version}")
       $python_package_name    = pick($python_package_name, 'python-psycopg2')
 
       $bindir                 = pick($bindir, "/usr/lib/postgresql/${version}/bin")
       $datadir                = pick($datadir, "/var/lib/postgresql/${version}/main")
       $confdir                = pick($confdir, "/etc/postgresql/${version}/main")
       if $facts['os']['name'] == 'Debian' and versioncmp($facts['os']['release']['major'], '8') >= 0 {
         # Jessie uses systemd
         $service_status = pick($service_status, "/usr/sbin/service ${service_name}@*-main status")
       } elsif $facts['os']['name'] == 'Ubuntu' and versioncmp($facts['os']['release']['major'], '15.04') >= 0 {
         # Ubuntu releases since vivid use systemd
         $service_status = pick($service_status, "/usr/sbin/service ${service_name} status")
       } else {
         $service_status = pick($service_status, "/etc/init.d/${service_name} status | /bin/egrep -q 'Running clusters: .+|online'")
       }
       $service_reload         = "service ${service_name} reload"
       $psql_path              = pick($psql_path, '/usr/bin/psql')
       $postgresql_conf_mode   = pick($postgresql_conf_mode, '0644')
     }
 
     'Gentoo': {
       $user                = pick($user, 'postgres')
       $group               = pick($group, 'postgres')
 
       $client_package_name  = pick($client_package_name, 'UNSET')
       $server_package_name  = pick($server_package_name, 'postgresql')
       $contrib_package_name = pick_default($contrib_package_name, undef)
       $devel_package_name   = pick_default($devel_package_name, undef)
       $java_package_name    = pick($java_package_name, 'jdbc-postgresql')
       $perl_package_name    = pick($perl_package_name, 'DBD-Pg')
       $plperl_package_name  = undef
       $python_package_name  = pick($python_package_name, 'psycopg')
 
       $service_name         = pick($service_name, "postgresql-${version}")
       $bindir               = pick($bindir, "/usr/lib/postgresql-${version}/bin")
       $datadir              = pick($datadir, "/var/lib/postgresql/${version}_data")
       $confdir              = pick($confdir, "/etc/postgresql-${version}")
       $service_status       = pick($service_status, "systemctl status ${service_name}")
       $service_reload       = "systemctl reload ${service_name}"
       $psql_path            = pick($psql_path, "${bindir}/psql")
 
       $needs_initdb         = pick($needs_initdb, true)
     }
 
     'FreeBSD': {
       case $version {
         '94', '95': {
           $user                 = pick($user, 'pgsql')
           $group                = pick($group, 'pgsql')
           $datadir              = pick($datadir, '/usr/local/pgsql/data')
         }
         default: {
           $user                 = pick($user, 'postgres')
           $group                = pick($group, 'postgres')
           $datadir              = pick($datadir, "/var/db/postgres/data${version}")
         }
       }
 
       $link_pg_config       = true
       $client_package_name  = pick($client_package_name, "databases/postgresql${version}-client")
       $server_package_name  = pick($server_package_name, "databases/postgresql${version}-server")
       $contrib_package_name = pick($contrib_package_name, "databases/postgresql${version}-contrib")
       $devel_package_name   = pick($devel_package_name, 'databases/postgresql-libpqxx3')
       $java_package_name    = pick($java_package_name, 'databases/postgresql-jdbc')
       $perl_package_name    = pick($plperl_package_name, 'databases/p5-DBD-Pg')
       $plperl_package_name  = pick($plperl_package_name, "databases/postgresql${version}-plperl")
       $python_package_name  = pick($python_package_name, 'databases/py-psycopg2')
 
       $service_name         = pick($service_name, 'postgresql')
       $bindir               = pick($bindir, '/usr/local/bin')
       $confdir              = pick($confdir, $datadir)
       $service_status       = pick($service_status, "/usr/local/etc/rc.d/${service_name} onestatus")
       $service_reload       = "service ${service_name} reload"
       $psql_path            = pick($psql_path, "${bindir}/psql")
 
       $needs_initdb         = pick($needs_initdb, true)
     }
 
     'OpenBSD': {
       $user                = pick($user, '_postgresql')
       $group               = pick($group, '_postgresql')
 
       $client_package_name  = pick($client_package_name, 'postgresql-client')
       $server_package_name  = pick($server_package_name, 'postgresql-server')
       $contrib_package_name = pick($contrib_package_name, 'postgresql-contrib')
       $devel_package_name   = pick($devel_package_name, 'postgresql-client')
       $java_package_name    = pick($java_package_name, 'postgresql-jdbc')
       $perl_package_name    = pick($perl_package_name, 'databases/p5-DBD-Pg')
       $plperl_package_name  = undef
       $python_package_name  = pick($python_package_name, 'py-psycopg2')
 
       $service_name         = pick($service_name, 'postgresql')
       $bindir               = pick($bindir, '/usr/local/bin')
       $datadir              = pick($datadir, '/var/postgresql/data')
       $confdir              = pick($confdir, $datadir)
       $service_status       = pick($service_status, "/etc/rc.d/${service_name} check")
       $service_reload       = "/etc/rc.d/${service_name} reload"
       $psql_path            = pick($psql_path, "${bindir}/psql")
 
       $needs_initdb         = pick($needs_initdb, true)
     }
 
     'Suse': {
       $link_pg_config       = true
       $user                 = pick($user, 'postgres')
       $group                = pick($group, 'postgres')
 
       $client_package_name  = pick($client_package_name, "postgresql${version}")
       $server_package_name  = pick($server_package_name, "postgresql${version}-server")
       $contrib_package_name = pick($contrib_package_name, "postgresql${version}-contrib")
       $devel_package_name   = pick($devel_package_name, "postgresql${version}-devel")
       $java_package_name    = pick($java_package_name, "postgresql${version}-jdbc")
       $perl_package_name    = pick($plperl_package_name, 'perl-DBD-Pg')
       $plperl_package_name  = pick($plperl_package_name, "postgresql${version}-plperl")
       $python_package_name  = pick($python_package_name, 'python-psycopg2')
 
       $service_name         = pick($service_name, 'postgresql')
       $bindir               = pick($bindir, "/usr/lib/postgresql${version}/bin")
       $datadir              = pick($datadir, '/var/lib/pgsql/data')
       $confdir              = pick($confdir, $datadir)
       if $facts['os']['name'] == 'SLES' and versioncmp($facts['os']['release']['full'], '11.4') <= 0 {
         $service_status     = pick($service_status, "/etc/init.d/${service_name} status")
         $service_reload     = "/etc/init.d/${service_name} reload"
       } else {
         $service_status     = pick($service_status, "systemctl status ${service_name}")
         $service_reload     = "systemctl reload ${service_name}"
       }
       $psql_path            = pick($psql_path, "${bindir}/psql")
 
       $needs_initdb         = pick($needs_initdb, true)
     }
 
     default: {
       $link_pg_config       = true
       $psql_path            = pick($psql_path, "${bindir}/psql")
 
       # Since we can't determine defaults on our own, we rely on users setting
       # parameters with the postgresql::globals class. Here we are checking
       # that the mandatory minimum is set for the module to operate.
       $err_prefix = "Module ${module_name} does not provide defaults for osfamily: ${facts['os']['family']} operatingsystem: ${facts['os']['name']}; please specify a value for ${module_name}::globals::"
       if ($needs_initdb == undef) { fail("${err_prefix}needs_initdb") }
       if ($service_name == undef) { fail("${err_prefix}service_name") }
       if ($client_package_name == undef) { fail("${err_prefix}client_package_name") }
       if ($server_package_name == undef) { fail("${err_prefix}server_package_name") }
       if ($bindir == undef) { fail("${err_prefix}bindir") }
       if ($datadir == undef) { fail("${err_prefix}datadir") }
       if ($confdir == undef) { fail("${err_prefix}confdir") }
     }
   }
 
   if($data_checksums and versioncmp($version, '9.3') < 0) {
     fail('data_checksums require version 9.3 or greater')
   }
 
   $validcon_script_path = pick($validcon_script_path, '/usr/local/bin/validate_postgresql_connection.sh')
   $initdb_path          = pick($initdb_path, "${bindir}/initdb")
   $pg_hba_conf_path     = pick($pg_hba_conf_path, "${confdir}/pg_hba.conf")
   $pg_hba_conf_defaults = pick($pg_hba_conf_defaults, true)
   $pg_ident_conf_path   = pick($pg_ident_conf_path, "${confdir}/pg_ident.conf")
   $postgresql_conf_path = pick($postgresql_conf_path, "${confdir}/postgresql.conf")
   $recovery_conf_path   = pick($recovery_conf_path, "${datadir}/recovery.conf")
   $default_database     = pick($default_database, 'postgres')
 }
diff --git a/spec/unit/classes/client_spec.rb b/spec/unit/classes/client_spec.rb
index 5ee4dbc..a01311f 100644
--- a/spec/unit/classes/client_spec.rb
+++ b/spec/unit/classes/client_spec.rb
@@ -1,57 +1,69 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
 
 describe 'postgresql::client', type: :class do
   let :facts do
     {
       os: {
         family: 'Debian',
         name: 'Debian',
         release: { 'full' => '8.0', 'major' => '8' },
       },
     }
   end
 
   describe 'with parameters' do
     let :params do
       {
         validcon_script_path: '/opt/bin/my-validate-con.sh',
         package_ensure: 'absent',
         package_name: 'mypackage',
         file_ensure: 'file',
       }
     end
 
     it 'modifies package' do
       is_expected.to contain_package('postgresql-client').with(ensure: 'absent',
                                                                name: 'mypackage',
                                                                tag: 'puppetlabs-postgresql')
     end
 
     it 'has specified validate connexion' do
       is_expected.to contain_file('/opt/bin/my-validate-con.sh').with(ensure: 'file',
                                                                       owner: 0,
                                                                       group: 0,
                                                                       mode: '0755')
     end
   end
 
   describe 'with no parameters' do
     it 'creates package with postgresql tag' do
       is_expected.to contain_package('postgresql-client').with(tag: 'puppetlabs-postgresql')
     end
   end
 
+  describe 'with manage_dnf_module true' do
+    let(:pre_condition) do
+      <<-PUPPET
+      class { 'postgresql::globals':
+        manage_dnf_module => true,
+      }
+      PUPPET
+    end
+
+    it { is_expected.to contain_package('postgresql dnf module').that_comes_before('Package[postgresql-client]') }
+  end
+
   describe 'with client package name explicitly set undef' do
     let :params do
       {
         package_name: 'UNSET',
       }
     end
 
     it 'does not manage postgresql-client package' do
       is_expected.not_to contain_package('postgresql-client')
     end
   end
 end
diff --git a/spec/unit/classes/server_spec.rb b/spec/unit/classes/server_spec.rb
index 29240ed..a44c96f 100644
--- a/spec/unit/classes/server_spec.rb
+++ b/spec/unit/classes/server_spec.rb
@@ -1,248 +1,289 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
 
 describe 'postgresql::server', type: :class do
   let :facts do
     {
       os: {
         family: 'Debian',
         name: 'Debian',
         release: {
           full: '8.0',
           major: '8',
         },
         distro: { 'codename' => 'jessie' },
       },
       osfamily: 'Debian',
       lsbdistid: 'Debian',
       lsbdistcodename: 'jessie',
       kernel: 'Linux',
       id: 'root',
       path: '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',
     }
   end
 
   describe 'with no parameters' do
     it { is_expected.to contain_class('postgresql::params') }
     it { is_expected.to contain_class('postgresql::server') }
     it { is_expected.to contain_file('/var/lib/postgresql/9.4/main') }
     it {
       is_expected.to contain_exec('postgresql_reload').with('command' => 'service postgresql reload')
     }
     it 'validates connection' do
       is_expected.to contain_postgresql_conn_validator('validate_service_is_running')
     end
   end
 
+  describe 'with manage_dnf_module true' do
+    let(:facts) do
+      {
+        os: {
+          family: 'RedHat',
+          name: 'RedHat',
+          release: { 'full' => '8.3', 'major' => '8' },
+          selinux: {
+            enabled: true,
+          }
+        },
+        osfamily: 'RedHat',
+      }
+    end
+
+    let(:pre_condition) do
+      <<-PUPPET
+      class { 'postgresql::globals':
+        manage_dnf_module => true,
+      }
+      PUPPET
+    end
+
+    it { is_expected.to contain_package('postgresql dnf module').with_ensure('10').that_comes_before('Package[postgresql-server]') }
+    it { is_expected.to contain_package('postgresql-server').with_name('postgresql-server') }
+
+    describe 'with version set' do
+      let(:pre_condition) do
+        <<-PUPPET
+        class { 'postgresql::globals':
+          manage_dnf_module => true,
+          version           => '12',
+        }
+        PUPPET
+      end
+
+      it { is_expected.to contain_package('postgresql dnf module').with_ensure('12').that_comes_before('Package[postgresql-server]') }
+      it { is_expected.to contain_package('postgresql-server').with_name('postgresql-server') }
+    end
+  end
+
   describe 'service_ensure => running' do
     let(:params) do
       {
         service_ensure: 'running',
         postgres_password: 'new-p@s$word-to-set',
       }
     end
 
     it { is_expected.to contain_class('postgresql::params') }
     it { is_expected.to contain_class('postgresql::server') }
     it { is_expected.to contain_class('postgresql::server::passwd') }
     it 'validates connection' do
       is_expected.to contain_postgresql_conn_validator('validate_service_is_running')
     end
     it 'sets postgres password' do
       is_expected.to contain_exec('set_postgres_postgrespw').with('command' => '/usr/bin/psql -c "ALTER ROLE \"postgres\" PASSWORD ${NEWPASSWD_ESCAPED}"',
                                                                   'user'        => 'postgres',
                                                                   'environment' => ['PGPASSWORD=new-p@s$word-to-set', 'PGPORT=5432', 'NEWPASSWD_ESCAPED=$$new-p@s$word-to-set$$'],
                                                                   'unless' => "/usr/bin/psql -h localhost -p 5432 -c 'select 1' > /dev/null")
     end
   end
 
   describe 'service_ensure => true' do
     let(:params) do
       {
         service_ensure: true,
         postgres_password: 'new-p@s$word-to-set',
       }
     end
 
     it { is_expected.to contain_class('postgresql::params') }
     it { is_expected.to contain_class('postgresql::server') }
     it { is_expected.to contain_class('postgresql::server::passwd') }
     it 'validates connection' do
       is_expected.to contain_postgresql_conn_validator('validate_service_is_running')
     end
     it 'sets postgres password' do
       is_expected.to contain_exec('set_postgres_postgrespw').with('command' => '/usr/bin/psql -c "ALTER ROLE \"postgres\" PASSWORD ${NEWPASSWD_ESCAPED}"',
                                                                   'user'        => 'postgres',
                                                                   'environment' => ['PGPASSWORD=new-p@s$word-to-set', 'PGPORT=5432', 'NEWPASSWD_ESCAPED=$$new-p@s$word-to-set$$'],
                                                                   'unless' => "/usr/bin/psql -h localhost -p 5432 -c 'select 1' > /dev/null")
     end
   end
 
   describe 'service_ensure => stopped' do
     let(:params) { { service_ensure: 'stopped' } }
 
     it { is_expected.to contain_class('postgresql::params') }
     it { is_expected.to contain_class('postgresql::server') }
     it 'shouldnt validate connection' do
       is_expected.not_to contain_postgresql_conn_validator('validate_service_is_running')
     end
   end
 
   describe 'service_restart_on_change => false' do
     let(:params) { { service_restart_on_change: false } }
 
     it { is_expected.to contain_class('postgresql::params') }
     it { is_expected.to contain_class('postgresql::server') }
     it {
       is_expected.not_to contain_Postgresql_conf('data_directory').that_notifies('Class[postgresql::server::service]')
     }
     it 'validates connection' do
       is_expected.to contain_postgresql_conn_validator('validate_service_is_running')
     end
   end
 
   describe 'service_restart_on_change => true' do
     let(:params) { { service_restart_on_change: true } }
 
     it { is_expected.to contain_class('postgresql::params') }
     it { is_expected.to contain_class('postgresql::server') }
     it {
       is_expected.to contain_Postgresql_conf('data_directory').that_notifies('Class[postgresql::server::service]')
     }
     it 'validates connection' do
       is_expected.to contain_postgresql_conn_validator('validate_service_is_running')
     end
   end
 
   describe 'service_reload => /bin/true' do
     let(:params) { { service_reload: '/bin/true' } }
 
     it { is_expected.to contain_class('postgresql::params') }
     it { is_expected.to contain_class('postgresql::server') }
     it {
       is_expected.to contain_exec('postgresql_reload').with('command' => '/bin/true')
     }
     it 'validates connection' do
       is_expected.to contain_postgresql_conn_validator('validate_service_is_running')
     end
   end
 
   describe 'service_manage => true' do
     let(:params) { { service_manage: true } }
 
     it { is_expected.to contain_service('postgresqld') }
   end
 
   describe 'service_manage => false' do
     let(:params) { { service_manage: false } }
 
     it { is_expected.not_to contain_service('postgresqld') }
     it 'shouldnt validate connection' do
       is_expected.not_to contain_postgresql_conn_validator('validate_service_is_running')
     end
   end
 
   describe 'package_ensure => absent' do
     let(:params) do
       {
         package_ensure: 'absent',
       }
     end
 
     it 'removes the package' do
       is_expected.to contain_package('postgresql-server').with(ensure: 'purged')
     end
 
     it 'stills enable the service' do
       is_expected.to contain_service('postgresqld').with(ensure: 'running')
     end
   end
 
   describe 'needs_initdb => true' do
     let(:params) do
       {
         needs_initdb: true,
       }
     end
 
     it 'contains proper initdb exec' do
       is_expected.to contain_exec('postgresql_initdb')
     end
   end
 
   describe 'postgresql_version' do
     let(:pre_condition) do
       <<-EOS
       class { 'postgresql::globals':
         manage_package_repo => true,
         version             => '99.5',
         before              => Class['postgresql::server'],
       }
       EOS
     end
 
     it 'contains the correct package version' do
       is_expected.to contain_class('postgresql::repo').with_version('99.5')
       is_expected.to contain_file('/var/lib/postgresql/99.5/main') # FIXME: be more precise
       is_expected.to contain_concat('/etc/postgresql/99.5/main/pg_hba.conf') # FIXME: be more precise
       is_expected.to contain_concat('/etc/postgresql/99.5/main/pg_ident.conf') # FIXME: be more precise
     end
   end
 
   describe 'additional roles' do
     let(:params) do
       {
         roles: {
           username: { createdb: true },
         },
       }
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__role('username').with_createdb(true) }
   end
 
   describe 'additional config_entries' do
     let(:params) do
       {
         config_entries: {
           fsync: 'off',
           checkpoint_segments: '20',
           remove_me: :undef,
         },
       }
     end
 
     it { is_expected.to compile.with_all_deps }
     it { is_expected.to contain_postgresql__server__config_entry('fsync').with_value('off').with_ensure('present') }
     it { is_expected.to contain_postgresql__server__config_entry('checkpoint_segments').with_value('20').with_ensure('present') }
     it { is_expected.to contain_postgresql__server__config_entry('remove_me').with_value(nil).with_ensure('absent') }
   end
 
   describe 'additional pg_hba_rules' do
     let(:params) do
       {
         pg_hba_rules: {
           from_remote_host: {
             type: 'host',
             database: 'mydb',
             user: 'myuser',
             auth_method: 'md5',
             address: '192.0.2.100',
           },
         },
       }
     end
 
     it { is_expected.to compile.with_all_deps }
     it do
       is_expected.to contain_postgresql__server__pg_hba_rule('from_remote_host')
         .with_type('host')
         .with_database('mydb')
         .with_user('myuser')
         .with_auth_method('md5')
         .with_address('192.0.2.100')
     end
   end
 end