diff --git a/manifests/config.pp b/manifests/config.pp
index 5e2fa00..2fec21c 100644
--- a/manifests/config.pp
+++ b/manifests/config.pp
@@ -1,69 +1,69 @@
 # @summary This class provides configuration for Redis.
 # @api private
 class redis::config {
 
   File {
     owner  => $redis::config_owner,
     group  => $redis::config_group,
     mode   => $redis::config_file_mode,
   }
 
   file { $redis::config_dir:
     ensure => directory,
     mode   => $redis::config_dir_mode,
   }
 
   file {$redis::log_dir:
     ensure => directory,
     group  => $redis::service_group,
     mode   => $redis::log_dir_mode,
     owner  => $redis::service_user,
   }
 
   file {$redis::workdir:
     ensure => directory,
     group  => $redis::service_group,
     mode   => $redis::workdir_mode,
     owner  => $redis::service_user,
   }
 
   if $redis::default_install {
     redis::instance {'default':
       pid_file            => $redis::pid_file,
       log_file            => $redis::log_file,
       manage_service_file => $redis::manage_service_file,
       unixsocket          => $redis::unixsocket,
       workdir             => $redis::workdir,
     }
   }
 
   if $redis::ulimit {
     contain redis::ulimit
   }
 
-  $service_provider_lookup = pick(getvar('service_provider'), false)
+  $service_provider_lookup = fact('service_provider')
 
-  unless $facts['osfamily'] == 'Debian' or $service_provider_lookup == 'systemd' {
+  unless $facts['os']['family'] == 'Debian' or $service_provider_lookup == 'systemd' {
     file { '/var/run/redis':
       ensure => 'directory',
       owner  => $redis::config_owner,
       group  => $redis::config_group,
       mode   => '0755',
     }
   }
 
   # Adjust /etc/default/redis-server on Debian systems
-  case $::osfamily {
+  case $facts['os']['family'] {
     'Debian': {
       file { '/etc/default/redis-server':
-        ensure => present,
+        ensure => file,
         group  => $redis::config_group,
         mode   => $redis::config_file_mode,
         owner  => $redis::config_owner,
       }
     }
 
     default: {
     }
   }
 }
diff --git a/manifests/instance.pp b/manifests/instance.pp
index 3c8255e..8333477 100644
--- a/manifests/instance.pp
+++ b/manifests/instance.pp
@@ -1,410 +1,410 @@
 # This is an defined type to allow the configuration of
 # multiple redis instances on one machine without conflicts
 #
 # @summary Allows the configuration of multiple redis configurations on one machine
 #
 # @example
 #   redis::instance {'6380':
 #     port => 6380,
 #   }
 #
 # @param activerehashing
 #   Enable/disable active rehashing.
 # @param aof_load_truncated
 #   Enable/disable loading truncated AOF file
 # @param aof_rewrite_incremental_fsync
 #   Enable/disable fsync for AOF file
 # @param appendfilename
 #   The name of the append only file
 # @param appendfsync
 #   Adjust fsync mode. Valid options: always, everysec, no.
 # @param appendonly
 #   Enable/disable appendonly mode.
 # @param auto_aof_rewrite_min_size
 #   Adjust minimum size for auto-aof-rewrite.
 # @param auto_aof_rewrite_percentage
 #   Adjust percentatge for auto-aof-rewrite.
 # @param bind
 #   Configure which IP address(es) to listen on. To bind on all interfaces, use an empty array.
 # @param config_dir
 #   Directory containing the configuration files.
 # @param config_dir_mode
 #   Adjust mode for directory containing configuration files.
 # @param config_file_orig
 #   The location and name of a config file that provides the source
 # @param config_file
 #   Adjust main configuration file.
 # @param config_file_mode
 #   Adjust permissions for configuration files.
 # @param config_group
 #   Adjust filesystem group for config files.
 # @param config_owner
 #   Adjust filesystem owner for config files.
 # @param conf_template
 #   Define which template to use.
 # @param daemonize
 #   Have Redis run as a daemon.
 # @param databases
 #   Set the number of databases.
 # @param dbfilename
 #   The filename where to dump the DB
 # @param extra_config_file
 #   Optional extra config file to include
 # @param hash_max_ziplist_entries
 #   Set max ziplist entries for hashes.
 # @param hash_max_ziplist_value
 #   Set max ziplist values for hashes.
 # @param hll_sparse_max_bytes
 #   HyperLogLog sparse representation bytes limit
 # @param hz
 #   Set redis background tasks frequency
 # @param latency_monitor_threshold
 #   Latency monitoring threshold in milliseconds
 # @param list_max_ziplist_entries
 #   Set max ziplist entries for lists.
 # @param list_max_ziplist_value
 #   Set max ziplist values for lists.
 # @param log_dir
 #   Specify directory where to write log entries.
 # @param log_dir_mode
 #   Adjust mode for directory containing log files.
 # @param log_file
 #   Specify file where to write log entries.
 # @param log_level
 #   Specify the server verbosity level.
 # @param masterauth
 #   If the master is password protected (using the "requirepass" configuration
 # @param maxclients
 #   Set the max number of connected clients at the same time.
 # @param maxmemory
 #   Don't use more memory than the specified amount of bytes.
 # @param maxmemory_policy
 #   How Redis will select what to remove when maxmemory is reached.
 # @param maxmemory_samples
 #   Select as well the sample size to check.
 # @param min_slaves_max_lag
 #   The lag in seconds
 # @param min_slaves_to_write
 #   Minimum number of slaves to be in "online" state
 # @param no_appendfsync_on_rewrite
 #   If you have latency problems turn this to 'true'. Otherwise leave it as
 # @param notify_keyspace_events
 #   Which events to notify Pub/Sub clients about events happening
 # @param pid_file
 #   Where to store the pid.
 # @param port
 #   Configure which port to listen on.
 # @param protected_mode
 #   Whether protected mode is enabled or not.  Only applicable when no bind is set.
 # @param rdbcompression
 #   Enable/disable compression of string objects using LZF when dumping.
 # @param repl_backlog_size
 #   The replication backlog size
 # @param repl_backlog_ttl
 #   The number of seconds to elapse before freeing backlog buffer
 # @param repl_disable_tcp_nodelay
 #   Enable/disable TCP_NODELAY on the slave socket after SYNC
 # @param repl_ping_slave_period
 #   Slaves send PINGs to server in a predefined interval. It's possible
 # @param repl_timeout
 #   Set the replication timeout for:
 # @param requirepass
 #   Require clients to issue AUTH <PASSWORD> before processing any other
 #   commands.
 # @param save_db_to_disk
 #   Set if save db to disk.
 # @param save_db_to_disk_interval
 #   save the dataset every N seconds if there are at least M changes in the dataset
 # @param service_enable
 #   Enable/disable daemon at boot.
 # @param service_ensure
 #   Specify if the server should be running.
 # @param service_group
 #   Specify which group to run as.
 # @param service_hasrestart
 #   Does the init script support restart?
 # @param service_hasstatus
 #   Does the init script support status?
 # @param service_user
 #   Specify which user to run as.
 # @param set_max_intset_entries
 #   The following configuration setting sets the limit in the size of the set
 #   in order to use this special memory saving encoding.
 # @param slave_priority
 #   The priority number for slave promotion by Sentinel
 # @param slave_read_only
 #   You can configure a slave instance to accept writes or not.
 # @param slave_serve_stale_data
 #   When a slave loses its connection with the master, or when the replication
 #   is still in progress, the slave can act in two different ways:
 #   1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
 #      still reply to client requests, possibly with out of date data, or the
 #      data set may just be empty if this is the first synchronization.
 #   2) if slave-serve-stale-data is set to 'no' the slave will reply with
 #      an error "SYNC with master in progress" to all the kind of commands
 #      but to INFO and SLAVEOF.
 # @param slaveof
 #   Use slaveof to make a Redis instance a copy of another Redis server.
 # @param slowlog_log_slower_than
 #   Tells Redis what is the execution time, in microseconds, to exceed in order
 #   for the command to get logged.
 # @param slowlog_max_len
 #   Tells Redis what is the length to exceed in order for the command
 #   to get logged.
 # @param stop_writes_on_bgsave_error
 #   If false then Redis will continue to work as usual even if there
 #   are problems with disk, permissions, and so forth.
 # @param syslog_enabled
 #   Enable/disable logging to the system logger.
 # @param syslog_facility
 #   Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
 # @param tcp_backlog
 #   Sets the TCP backlog
 # @param tcp_keepalive
 #   TCP keepalive.
 # @param timeout
 #   Close the connection after a client is idle for N seconds (0 to disable).
 # @param ulimit
 #   Limit the use of system-wide resources.
 # @param unixsocket
 #   Define unix socket path
 # @param unixsocketperm
 #   Define unix socket file permissions
 # @param workdir
 #   The DB will be written inside this directory, with the filename specified
 #   above using the 'dbfilename' configuration directive.
 # @param workdir_mode
 #   Adjust mode for data directory.
 # @param zset_max_ziplist_entries
 #   Set max entries for sorted sets.
 # @param zset_max_ziplist_value
 #   Set max values for sorted sets.
 # @param cluster_enabled
 #   Enables redis 3.0 cluster functionality
 # @param cluster_config_file
 #   Config file for saving cluster nodes configuration. This file is never
 #   touched by humans.  Only set if cluster_enabled is true
 # @param cluster_node_timeout
 #   Node timeout. Only set if cluster_enabled is true
 # @param cluster_slave_validity_factor
 #   Control variable to disable promoting slave in case of disconnection from
 #   master Only set if cluster_enabled is true
 # @param cluster_require_full_coverage
 #   If false Redis Cluster will server queries even if requests about a subset
 #   of keys can be processed Only set if cluster_enabled is true
 # @param cluster_migration_barrier
 #   Minimum number of slaves master will remain connected with, for another
 #   slave to migrate to a  master which is no longer covered by any slave Only
 #   set if cluster_enabled is true
 define redis::instance (
   Boolean $activerehashing                                       = $redis::activerehashing,
   Boolean $aof_load_truncated                                    = $redis::aof_load_truncated,
   Boolean $aof_rewrite_incremental_fsync                         = $redis::aof_rewrite_incremental_fsync,
   String[1] $appendfilename                                      = $redis::appendfilename,
   Enum['no', 'always', 'everysec'] $appendfsync                  = $redis::appendfsync,
   Boolean $appendonly                                            = $redis::appendonly,
   String[1] $auto_aof_rewrite_min_size                           = $redis::auto_aof_rewrite_min_size,
   Integer[0] $auto_aof_rewrite_percentage                        = $redis::auto_aof_rewrite_percentage,
   Variant[Stdlib::IP::Address, Array[Stdlib::IP::Address]] $bind = $redis::bind,
   String[1] $output_buffer_limit_slave                           = $redis::output_buffer_limit_slave,
   String[1] $output_buffer_limit_pubsub                          = $redis::output_buffer_limit_pubsub,
   String[1] $conf_template                                       = $redis::conf_template,
   Stdlib::Absolutepath $config_dir                               = $redis::config_dir,
   Stdlib::Filemode $config_dir_mode                              = $redis::config_dir_mode,
   Stdlib::Absolutepath $config_file                              = $redis::config_file,
   Stdlib::Filemode $config_file_mode                             = $redis::config_file_mode,
   Stdlib::Absolutepath $config_file_orig                         = $redis::config_file_orig,
   String[1] $config_group                                        = $redis::config_group,
   String[1] $config_owner                                        = $redis::config_owner,
   Boolean $daemonize                                             = $redis::daemonize,
   Integer[1] $databases                                          = $redis::databases,
   Variant[String[1], Boolean] $dbfilename                        = $redis::dbfilename,
   Optional[String] $extra_config_file                            = $redis::extra_config_file,
   Integer[0] $hash_max_ziplist_entries                           = $redis::hash_max_ziplist_entries,
   Integer[0] $hash_max_ziplist_value                             = $redis::hash_max_ziplist_value,
   Integer[0] $hll_sparse_max_bytes                               = $redis::hll_sparse_max_bytes,
   Integer[1, 500] $hz                                            = $redis::hz,
   Integer[0] $latency_monitor_threshold                          = $redis::latency_monitor_threshold,
   Integer[0] $list_max_ziplist_entries                           = $redis::list_max_ziplist_entries,
   Integer[0] $list_max_ziplist_value                             = $redis::list_max_ziplist_value,
   Stdlib::Absolutepath $log_dir                                  = $redis::log_dir,
   Stdlib::Filemode $log_dir_mode                                 = $redis::log_dir_mode,
   Redis::LogLevel $log_level                                     = $redis::log_level,
   String[1] $minimum_version                                     = $redis::minimum_version,
   Optional[String[1]] $masterauth                                = $redis::masterauth,
   Integer[1] $maxclients                                         = $redis::maxclients,
   $maxmemory                                                     = $redis::maxmemory,
   $maxmemory_policy                                              = $redis::maxmemory_policy,
   $maxmemory_samples                                             = $redis::maxmemory_samples,
   Integer[0] $min_slaves_max_lag                                 = $redis::min_slaves_max_lag,
   Integer[0] $min_slaves_to_write                                = $redis::min_slaves_to_write,
   Boolean $no_appendfsync_on_rewrite                             = $redis::no_appendfsync_on_rewrite,
   Optional[String[1]] $notify_keyspace_events                    = $redis::notify_keyspace_events,
   Boolean $managed_by_cluster_manager                            = $redis::managed_by_cluster_manager,
   String[1] $package_ensure                                      = $redis::package_ensure,
   Stdlib::Port $port                                             = $redis::port,
   Boolean $protected_mode                                        = $redis::protected_mode,
   Boolean $rdbcompression                                        = $redis::rdbcompression,
   String[1] $repl_backlog_size                                   = $redis::repl_backlog_size,
   Integer[0] $repl_backlog_ttl                                   = $redis::repl_backlog_ttl,
   Boolean $repl_disable_tcp_nodelay                              = $redis::repl_disable_tcp_nodelay,
   Integer[1] $repl_ping_slave_period                             = $redis::repl_ping_slave_period,
   Integer[1] $repl_timeout                                       = $redis::repl_timeout,
   Optional[String] $requirepass                                  = $redis::requirepass,
   Boolean $save_db_to_disk                                       = $redis::save_db_to_disk,
   Hash $save_db_to_disk_interval                                 = $redis::save_db_to_disk_interval,
   String[1] $service_user                                        = $redis::service_user,
   Integer[0] $set_max_intset_entries                             = $redis::set_max_intset_entries,
   Integer[0] $slave_priority                                     = $redis::slave_priority,
   Boolean $slave_read_only                                       = $redis::slave_read_only,
   Boolean $slave_serve_stale_data                                = $redis::slave_serve_stale_data,
   Optional[String[1]] $slaveof                                   = $redis::slaveof,
   Integer[0] $slowlog_log_slower_than                            = $redis::slowlog_log_slower_than,
   Integer[0] $slowlog_max_len                                    = $redis::slowlog_max_len,
   Boolean $stop_writes_on_bgsave_error                           = $redis::stop_writes_on_bgsave_error,
   Boolean $syslog_enabled                                        = $redis::syslog_enabled,
   Optional[String[1]] $syslog_facility                           = $redis::syslog_facility,
   Integer[0] $tcp_backlog                                        = $redis::tcp_backlog,
   Integer[0] $tcp_keepalive                                      = $redis::tcp_keepalive,
   Integer[0] $timeout                                            = $redis::timeout,
   Stdlib::Filemode $unixsocketperm                               = $redis::unixsocketperm,
   Integer[0] $ulimit                                             = $redis::ulimit,
   Stdlib::Filemode $workdir_mode                                 = $redis::workdir_mode,
   Integer[0] $zset_max_ziplist_entries                           = $redis::zset_max_ziplist_entries,
   Integer[0] $zset_max_ziplist_value                             = $redis::zset_max_ziplist_value,
   Boolean $cluster_enabled                                       = $redis::cluster_enabled,
   String[1] $cluster_config_file                                 = $redis::cluster_config_file,
   Integer[1] $cluster_node_timeout                               = $redis::cluster_node_timeout,
   Integer[0] $cluster_slave_validity_factor                      = $redis::cluster_slave_validity_factor,
   Boolean $cluster_require_full_coverage                         = $redis::cluster_require_full_coverage,
   Integer[0] $cluster_migration_barrier                          = $redis::cluster_migration_barrier,
   Stdlib::Ensure::Service $service_ensure                        = $redis::service_ensure,
   Boolean $service_enable                                        = $redis::service_enable,
   String[1] $service_group                                       = $redis::service_group,
   Boolean $service_hasrestart                                    = $redis::service_hasrestart,
   Boolean $service_hasstatus                                     = $redis::service_hasstatus,
   # Defaults for redis::instance
   Boolean $manage_service_file                                   = true,
   Optional[Stdlib::Absolutepath] $log_file                       = undef,
   Stdlib::Absolutepath $pid_file                                 = "/var/run/redis/redis-server-${name}.pid",
   Stdlib::Absolutepath $unixsocket                               = "/var/run/redis/redis-server-${name}.sock",
   Stdlib::Absolutepath $workdir                                  = "${redis::workdir}/redis-server-${name}",
 ) {
 
   if $title == 'default' {
     $redis_server_name    = $redis::service_name
     $redis_file_name_orig = $config_file_orig
     $redis_file_name      = $config_file
   } else {
     $redis_server_name    = "redis-server-${name}"
     $redis_file_name_orig = sprintf('%s/%s.%s', dirname($config_file_orig), $redis_server_name, 'conf.puppet')
     $redis_file_name      = sprintf('%s/%s.%s', dirname($config_file), $redis_server_name, 'conf')
   }
 
   if $log_dir != $redis::log_dir {
     file { $log_dir:
       ensure => directory,
       group  => $service_group,
       mode   => $log_dir_mode,
       owner  => $service_user,
     }
   }
 
   $_real_log_file = $log_file ? {
     undef   => "${log_dir}/redis-server-${name}.log",
     default => $log_file,
   }
 
   if $workdir != $redis::workdir {
     file { $workdir:
       ensure => directory,
       group  => $service_group,
       mode   => $workdir_mode,
       owner  => $service_user,
     }
   }
 
   if $manage_service_file {
     $service_provider_lookup = pick(getvar('service_provider'), false)
 
     if $service_provider_lookup == 'systemd' {
 
       file { "/etc/systemd/system/${redis_server_name}.service":
         ensure  => file,
         owner   => 'root',
         group   => 'root',
         mode    => '0644',
         content => template('redis/service_templates/redis.service.erb'),
       }
       ~> Exec['systemd-reload-redis']
 
       if $title != 'default' {
         service { $redis_server_name:
           ensure     => $service_ensure,
           enable     => $service_enable,
           hasrestart => $service_hasrestart,
           hasstatus  => $service_hasstatus,
           subscribe  => [
             File["/etc/systemd/system/${redis_server_name}.service"],
             Exec["cp -p ${redis_file_name_orig} ${redis_file_name}"],
           ],
         }
       }
 
     } else {
 
       file { "/etc/init.d/${redis_server_name}":
         ensure  => file,
         mode    => '0755',
-        content => template("redis/service_templates/redis.${::osfamily}.erb"),
+        content => template("redis/service_templates/redis.${facts['os']['family']}.erb"),
       }
 
       if $title != 'default' {
         service { $redis_server_name:
           ensure     => $service_ensure,
           enable     => $service_enable,
           hasrestart => $service_hasrestart,
           hasstatus  => $service_hasstatus,
           subscribe  => [
             File["/etc/init.d/${redis_server_name}"],
             Exec["cp -p ${redis_file_name_orig} ${redis_file_name}"],
           ],
         }
       }
     }
   }
 
   File {
     owner  => $config_owner,
     group  => $config_group,
     mode   => $config_file_mode,
   }
 
   file {$redis_file_name_orig:
     ensure  => file,
   }
 
   exec {"cp -p ${redis_file_name_orig} ${redis_file_name}":
     path        => '/usr/bin:/bin',
     subscribe   => File[$redis_file_name_orig],
     refreshonly => true,
   }
 
   $bind_arr = [$bind].flatten
 
   if $package_ensure =~ /^([0-9]+:)?[0-9]+\.[0-9]/ {
     if ':' in $package_ensure {
       $_redis_version_real = split($package_ensure, ':')
       $redis_version_real = $_redis_version_real[1]
     } else {
       $redis_version_real = $package_ensure
     }
   } else {
     $redis_version_real = pick(getvar('redis_server_version'), $minimum_version)
   }
 
   $supports_protected_mode = !$redis_version_real or versioncmp($redis_version_real, '3.2.0') >= 0
 
   File[$redis_file_name_orig] { content => template($conf_template) }
 
 }
diff --git a/manifests/params.pp b/manifests/params.pp
index 8a584b5..691d006 100644
--- a/manifests/params.pp
+++ b/manifests/params.pp
@@ -1,143 +1,143 @@
 # @summary This class provides a number of parameters.
 # @api private
 class redis::params {
-  case $::osfamily {
+  case $facts['os']['family'] {
     'Debian': {
       $config_dir                = '/etc/redis'
       $config_dir_mode           = '0755'
       $config_file               = '/etc/redis/redis.conf'
       $config_file_orig          = '/etc/redis/redis.conf.puppet'
 
       $config_owner              = 'redis'
       $log_dir_mode              = '0755'
       $package_name              = 'redis-server'
       $pid_file                  = '/var/run/redis/redis-server.pid'
       $sentinel_config_file      = '/etc/redis/sentinel.conf'
       $sentinel_config_file_orig = '/etc/redis/redis-sentinel.conf.puppet'
       $sentinel_daemonize        = true
       $sentinel_init_script      = '/etc/init.d/redis-sentinel'
       $sentinel_package_name     = 'redis-sentinel'
       $service_group             = 'redis'
       $service_name              = 'redis-server'
       $ppa_repo                  = 'ppa:chris-lea/redis-server'
       $workdir                   = '/var/lib/redis'
 
       case $facts['os']['name'] {
         'Ubuntu': {
           $config_group = 'redis'
           $minimum_version = $facts['os']['release']['major'] ? {
             '16.04' => '3.0.5',
             default => '4.0.9',
           }
         }
         default: {
           $config_group              = 'root'
           $minimum_version           = '3.2.5'
         }
       }
 
     }
 
     'RedHat': {
       $config_dir                = '/etc/redis'
       $config_dir_mode           = '0755'
       $config_file               = '/etc/redis.conf'
       $config_file_orig          = '/etc/redis.conf.puppet'
       $config_group              = 'root'
       $config_owner              = 'redis'
       $log_dir_mode              = '0755'
       $package_name              = 'redis'
       $pid_file                  = '/var/run/redis/redis.pid'
       $sentinel_config_file      = '/etc/redis-sentinel.conf'
       $sentinel_config_file_orig = '/etc/redis-sentinel.conf.puppet'
       $sentinel_daemonize        = false
       $sentinel_init_script      = undef
       $sentinel_package_name     = 'redis'
       $service_name              = 'redis'
       $ppa_repo                  = undef
       $workdir                   = '/var/lib/redis'
 
       # EPEL 6 and newer have 3.2 so we can assume all EL is 3.2+
       $minimum_version           = '3.2.10'
 
       $service_group = $facts['os']['release']['major'] ? {
         '6'     => 'root',
         default => 'redis',
       }
     }
 
     'FreeBSD': {
       $config_dir                = '/usr/local/etc/redis'
       $config_dir_mode           = '0755'
       $config_file               = '/usr/local/etc/redis.conf'
       $config_file_orig          = '/usr/local/etc/redis.conf.puppet'
       $config_group              = 'wheel'
       $config_owner              = 'redis'
       $log_dir_mode              = '0755'
       $package_name              = 'redis'
       $pid_file                  = '/var/run/redis/redis.pid'
       $sentinel_config_file      = '/usr/local/etc/redis-sentinel.conf'
       $sentinel_config_file_orig = '/usr/local/etc/redis-sentinel.conf.puppet'
       $sentinel_daemonize        = true
       $sentinel_init_script      = undef
       $sentinel_package_name     = 'redis'
       $service_group             = 'redis'
       $service_name              = 'redis'
       $ppa_repo                  = undef
       $workdir                   = '/var/db/redis'
 
       # pkg version
       $minimum_version           = '3.2.4'
     }
 
     'Suse': {
       $config_dir                = '/etc/redis'
       $config_dir_mode           = '0750'
       $config_file               = '/etc/redis/redis-server.conf'
       $config_group              = 'redis'
       $config_owner              = 'redis'
       $log_dir_mode              = '0750'
       $package_name              = 'redis'
       $pid_file                  = '/var/run/redis/redis-server.pid'
       $sentinel_config_file      = '/etc/redis/redis-sentinel.conf'
       $sentinel_config_file_orig = '/etc/redis/redis-sentinel.conf.puppet'
       $sentinel_daemonize        = true
       $sentinel_init_script      = undef
       $sentinel_package_name     = 'redis'
       $service_group             = 'redis'
       $service_name              = 'redis'
       $ppa_repo                  = undef
       $workdir                   = '/var/lib/redis'
 
       # suse package version
       $minimum_version           = '3.0.5'
     }
 
     'Archlinux': {
       $config_dir                = '/etc/redis'
       $config_dir_mode           = '0755'
       $config_file               = '/etc/redis/redis.conf'
       $config_file_orig          = '/etc/redis/redis.conf.puppet'
       $config_group              = 'root'
       $config_owner              = 'root'
       $log_dir_mode              = '0755'
       $package_name              = 'redis'
       $pid_file                  = '/var/run/redis.pid'
       $sentinel_config_file      = '/etc/redis/redis-sentinel.conf'
       $sentinel_config_file_orig = '/etc/redis/redis-sentinel.conf.puppet'
       $sentinel_daemonize        = true
       $sentinel_init_script      = undef
       $sentinel_package_name     = 'redis'
       $service_group             = 'redis'
       $service_name              = 'redis'
       $ppa_repo                  = undef
       $workdir                   = '/var/lib/redis'
 
       # pkg version
       $minimum_version           = '3.2.4'
     }
     default: {
-      fail "Operating system ${::operatingsystem} is not supported yet."
+      fail "Operating system ${facts['os']['name']} is not supported yet."
     }
   }
 }
diff --git a/manifests/sentinel.pp b/manifests/sentinel.pp
index 2424d05..182df24 100644
--- a/manifests/sentinel.pp
+++ b/manifests/sentinel.pp
@@ -1,191 +1,191 @@
 # @summary Install redis-sentinel
 #
 # @param auth_pass
 #   The password to use to authenticate with the master and slaves.
 #
 # @param config_file
 #   The location and name of the sentinel config file.
 #
 # @param config_file_orig
 #   The location and name of a config file that provides the source
 #   of the sentinel config file. Two different files are needed
 #   because sentinel itself writes to its own config file and we do
 #   not want override that when puppet is run unless there are
 #   changes from the manifests.
 #
 # @param config_file_mode
 #   Permissions of config file.
 #
 # @param conf_template
 #   Define which template to use.
 #
 # @param daemonize
 #   Have Redis sentinel run as a daemon.
 #
 # @param down_after
 #   Number of milliseconds the master (or any attached slave or sentinel)
 #   should be unreachable (as in, not acceptable reply to PING, continuously,
 #   for the specified period) in order to consider it in S_DOWN state.
 #
 # @param failover_timeout
 #   Specify the failover timeout in milliseconds.
 #
 # @param init_script
 #   Specifiy the init script that will be created for sentinel.
 #
 # @param log_file
 #   Specify where to write log entries.
 #
 # @param log_level
 #   Specify how much we should log.
 #
 # @param master_name
 #   Specify the name of the master redis server.
 #   The valid charset is A-z 0-9 and the three characters ".-_".
 #
 # @param redis_host
 #   Specify the bound host of the master redis server.
 #
 # @param redis_port
 #   Specify the port of the master redis server.
 #
 # @param package_name
 #   The name of the package that installs sentinel.
 #
 # @param package_ensure
 #   Do we ensure this package.
 #
 # @param parallel_sync
 #   How many slaves can be reconfigured at the same time to use a
 #   new master after a failover.
 #
 # @param pid_file
 #   If sentinel is daemonized it will write its pid at this location.
 #
 # @param quorum
 #   Number of sentinels that must agree that a master is down to
 #   signal sdown state.
 #
 # @param sentinel_bind
 #   Allow optional sentinel server ip binding.  Can help overcome
 #   issues arising from protect-mode added Redis 3.2
 #
 # @param sentinel_port
 #   The port of sentinel server.
 #
 # @param service_group
 #   The group of the config file.
 #
 # @param service_name
 #   The name of the service (for puppet to manage).
 #
 # @param service_user
 #   The owner of the config file.
 #
 # @param service_enable
 #   Enable the service at boot time.
 #
 # @param working_dir
 #   The directory into which sentinel will change to avoid mount
 #   conflicts.
 #
 # @param notification_script
 #   Path to the notification script
 #
 # @param client_reconfig_script
 #   Path to the client-reconfig script
 #
 # @example Basic inclusion
 #   include redis::sentinel
 #
 # @example Configuring options
 #   class {'redis::sentinel':
 #     down_after => 80000,
 #     log_file   => '/var/log/redis/sentinel.log',
 #   }
 #
 class redis::sentinel (
   Optional[String[1]] $auth_pass = undef,
   Stdlib::Absolutepath $config_file = $redis::params::sentinel_config_file,
   Stdlib::Absolutepath $config_file_orig = $redis::params::sentinel_config_file_orig,
   Stdlib::Filemode $config_file_mode = '0644',
   String[1] $conf_template = 'redis/redis-sentinel.conf.erb',
   Boolean $daemonize = $redis::params::sentinel_daemonize,
   Integer[1] $down_after = 30000,
   Integer[1] $failover_timeout = 180000,
   Optional[Stdlib::Absolutepath] $init_script = $redis::params::sentinel_init_script,
   String[1] $init_template = 'redis/redis-sentinel.init.erb',
   Redis::LogLevel $log_level = 'notice',
   Stdlib::Absolutepath $log_file = '/var/log/redis/redis.log',
   String[1] $master_name  = 'mymaster',
   Stdlib::Host $redis_host = '127.0.0.1',
   Stdlib::Port $redis_port = 6379,
   String[1] $package_name = $redis::params::sentinel_package_name,
   String[1] $package_ensure = 'present',
   Integer[0] $parallel_sync = 1,
   Stdlib::Absolutepath $pid_file = '/var/run/redis/redis-sentinel.pid',
   Integer[1] $quorum = 2,
   Variant[Undef, Stdlib::IP::Address, Array[Stdlib::IP::Address]] $sentinel_bind = undef,
   Stdlib::Port $sentinel_port = 26379,
   String[1] $service_group = $redis::params::service_group,
   String[1] $service_name = 'redis-sentinel',
   Stdlib::Ensure::Service $service_ensure = 'running',
   Boolean $service_enable = true,
   String[1] $service_user = 'redis',
   Stdlib::Absolutepath $working_dir = '/tmp',
   Optional[Stdlib::Absolutepath] $notification_script = undef,
   Optional[Stdlib::Absolutepath] $client_reconfig_script = undef,
 ) inherits redis::params {
 
   require 'redis'
 
-  if $facts['osfamily'] == 'Debian' {
+  if $facts['os']['family'] == 'Debian' {
     package { $package_name:
       ensure => $package_ensure,
       before => File[$config_file_orig],
     }
 
     if $init_script {
       Package[$package_name] -> File[$init_script]
     }
   }
 
   file { $config_file_orig:
     ensure  => file,
     owner   => $service_user,
     group   => $service_group,
     mode    => $config_file_mode,
     content => template($conf_template),
   }
 
   exec { "cp -p ${config_file_orig} ${config_file}":
     path        => '/usr/bin:/bin',
     subscribe   => File[$config_file_orig],
     notify      => Service[$service_name],
     refreshonly => true,
   }
 
   if $init_script {
 
     file { $init_script:
       ensure  => file,
       owner   => 'root',
       group   => 'root',
       mode    => '0755',
       content => template($init_template),
     }
 
     exec { '/usr/sbin/update-rc.d redis-sentinel defaults':
       subscribe   => File[$init_script],
       refreshonly => true,
       notify      => Service[$service_name],
     }
 
   }
 
   service { $service_name:
     ensure => $service_ensure,
     enable => $service_enable,
   }
 
 }
diff --git a/manifests/ulimit.pp b/manifests/ulimit.pp
index e85eb5c..dc48da9 100644
--- a/manifests/ulimit.pp
+++ b/manifests/ulimit.pp
@@ -1,75 +1,75 @@
 # Redis class for configuring ulimit
 # Used to DRY up the config class, and
 # move the logic for ulimit changes all
 # into one place.
 #
 # Parameters are not required as it's a
 # private class only referencable from
 # the redis module, where the variables
 # would already be defined
 #
 # @example
 #   contain redis::ulimit
 #
 # @author - Peter Souter
 #
 # @api private
 class redis::ulimit {
   assert_private('The redis::ulimit class is only to be called from the redis::config class')
 
   $service_provider_lookup = pick(getvar('service_provider'), false)
 
   if $redis::managed_by_cluster_manager {
     file { '/etc/security/limits.d/redis.conf':
       ensure  => 'file',
       owner   => 'root',
       group   => 'root',
       mode    => '0644',
       content => "redis soft nofile ${redis::ulimit}\nredis hard nofile ${redis::ulimit}\n",
     }
   }
   if $service_provider_lookup == 'systemd' {
     file { "/etc/systemd/system/${redis::service_name}.service.d/":
       ensure                  => 'directory',
       owner                   => 'root',
       group                   => 'root',
       selinux_ignore_defaults => true,
     }
 
     file { "/etc/systemd/system/${redis::service_name}.service.d/limit.conf":
       ensure => file,
       owner  => 'root',
       group  => 'root',
       mode   => '0444',
     }
     augeas { 'Systemd redis ulimit' :
       incl    => "/etc/systemd/system/${redis::service_name}.service.d/limit.conf",
       lens    => 'Systemd.lns',
       changes => [
         "defnode nofile Service/LimitNOFILE \"\"",
         "set \$nofile/value \"${redis::ulimit}\"",
       ],
       notify  => [
         Exec['systemd-reload-redis'],
       ],
     }
   } else {
-    case $facts['osfamily'] {
+    case $facts['os']['family'] {
       'Debian': {
         augeas { 'redis ulimit':
           context => '/files/etc/default/redis-server',
           changes => "set ULIMIT ${redis::ulimit}",
         }
       }
       'RedHat': {
         augeas { 'redis ulimit':
           context => '/files/etc/sysconfig/redis',
           changes => "set ULIMIT ${redis::ulimit}",
         }
       }
       default: {
-        warning("Not sure how to set ULIMIT on non-systemd OSFamily ${facts['osfamily']}, PR's welcome")
+        warning("Not sure how to set ULIMIT on non-systemd OSFamily ${facts['os']['family']}, PR's welcome")
       }
     }
   }
 }
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 94d503c..2376c94 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,82 +1,107 @@
+RSpec.configure do |c|
+  c.mock_with :mocha
+end
+
 require 'puppetlabs_spec_helper/module_spec_helper'
 require 'rspec-puppet-facts'
 include RspecPuppetFacts
 
 def manifest_vars
   vars = {}
 
   case facts[:osfamily].to_s
   when 'RedHat'
     vars[:package_name] = 'redis'
     vars[:service_name] = 'redis'
     vars[:config_file] = '/etc/redis.conf'
     vars[:config_file_orig] = '/etc/redis.conf.puppet'
     vars[:ppa_repo] = nil
   when 'FreeBSD',
     vars[:package_name] = 'redis'
     vars[:service_name] = 'redis'
     vars[:config_file] = '/usr/local/etc/redis.conf'
     vars[:config_file_orig] = '/usr/local/etc/redis.conf.puppet'
     vars[:ppa_repo] = nil
   when 'Debian'
     vars[:package_name] = 'redis-server'
     vars[:service_name] = 'redis-server'
     vars[:config_file] = '/etc/redis/redis.conf'
     vars[:config_file_orig] = '/etc/redis/redis.conf.puppet'
     vars[:ppa_repo] = 'ppa:chris-lea/redis-server'
   when 'Archlinux'
     vars[:package_name] = 'redis'
     vars[:service_name] = 'redis'
     vars[:config_file] = '/etc/redis/redis.conf'
     vars[:config_file_orig] = '/etc/redis/redis.conf.puppet'
     vars[:ppa_repo] = nil
   end
 
   vars
 end
 
 def redis_service_name(service_name: 'default')
   case service_name.to_s
   when 'default'
     manifest_vars[:service_name]
   else
     "#{manifest_vars[:service_name]}-#{service_name}"
   end
 end
 
 def redis_service_file(service_name: redis_service_name, service_provider: nil)
   case service_provider.to_s
   when 'systemd'
     "/etc/systemd/system/#{service_name}.service"
   else
     "/etc/init.d/#{service_name}"
   end
 end
 
+if ENV['DEBUG']
+  Puppet::Util::Log.level = :debug
+  Puppet::Util::Log.newdestination(:console)
+end
+
 add_custom_fact :service_provider, (lambda do |_os, facts|
   case facts[:osfamily].downcase
   when 'archlinux'
     'systemd'
   when 'darwin'
     'launchd'
   when 'debian'
     'systemd'
   when 'freebsd'
     'freebsd'
   when 'gentoo'
     'openrc'
   when 'openbsd'
     'openbsd'
   when 'redhat'
     facts[:operatingsystemrelease].to_i >= 7 ? 'systemd' : 'redhat'
   when 'suse'
     facts[:operatingsystemmajrelease].to_i >= 12 ? 'systemd' : 'redhat'
   when 'windows'
     'windows'
   else
     'init'
   end
 end)
 
-# Include code coverage report for all our specs
-at_exit { RSpec::Puppet::Coverage.report! }
+RSpec.configure do |c|
+  # getting the correct facter version is tricky. We use facterdb as a source to mock facts
+  # see https://github.com/camptocamp/facterdb
+  # people might provide a specific facter version. In that case we use it.
+  # Otherwise we need to match the correct facter version to the used puppet version.
+  # as of 2019-10-31, puppet 5 ships facter 3.11 and puppet 6 ships facter 3.14
+  # https://puppet.com/docs/puppet/5.5/about_agent.html
+  c.default_facter_version = if ENV['FACTERDB_FACTS_VERSION']
+                               ENV['FACTERDB_FACTS_VERSION']
+                             else
+                               Gem::Dependency.new('', ENV['PUPPET_VERSION']).match?('', '5') ? '3.11.0' : '3.14.0'
+                             end
+
+  # Coverage generation
+  c.after(:suite) do
+    RSpec::Puppet::Coverage.report!
+  end
+end