diff --git a/manifests/init.pp b/manifests/init.pp
index 4ea193d..cd386c3 100644
--- a/manifests/init.pp
+++ b/manifests/init.pp
@@ -1,144 +1,143 @@
 # == Class: memcached
 #
 # Manage memcached
 #
 # == Parameters
 # [* syslog *]
 # Boolean.
 # If true will pipe output to /bin/logger, sends to syslog.
 #
 class memcached (
   Enum['present', 'latest', 'absent'] $package_ensure                                        = 'present',
   Boolean $service_manage                                                                    = true,
-  Optional[Stdlib::Absolutepath] $logfile                                                    = $::memcached::params::logfile,
+  Optional[Stdlib::Absolutepath] $logfile                                                    = $memcached::params::logfile,
   Boolean $logstdout                                                                         = false,
   Boolean $syslog                                                                            = false,
   Optional[Stdlib::Absolutepath] $pidfile                                                    = '/var/run/memcached.pid',
   Boolean $manage_firewall                                                                   = false,
   $max_memory                                                                                = '95%',
   Optional[Variant[Integer, String]] $max_item_size                                          = undef,
   Optional[Variant[Integer, String]] $min_item_size                                          = undef,
   Optional[Variant[Integer, String]] $factor                                                 = undef,
   Boolean $lock_memory                                                                       = false,
   Optional[Variant[Stdlib::Compat::Ip_address,Array[Stdlib::Compat::Ip_address]]] $listen_ip = '127.0.0.1',
   Integer $tcp_port                                                                          = 11211,
   Integer $udp_port                                                                          = 11211,
-  String $user                                                                               = $::memcached::params::user,
+  String $user                                                                               = $memcached::params::user,
   Integer $max_connections                                                                   = 8192,
   Optional[String] $verbosity                                                                = undef,
   Optional[String] $unix_socket                                                              = undef,
   String $unix_socket_mask                                                                   = '0755',
   Boolean $install_dev                                                                       = false,
-  Variant[String,Integer] $processorcount                                                    = $::processorcount,
+  Variant[String,Integer] $processorcount                                                    = $facts['processors']['count'],
   Boolean $service_restart                                                                   = true,
   Boolean $auto_removal                                                                      = false,
   Boolean $use_sasl                                                                          = false,
   Boolean $use_tls                                                                           = false,
   Optional[Stdlib::Absolutepath] $tls_cert_chain                                             = undef,
   Optional[Stdlib::Absolutepath] $tls_key                                                    = undef,
   Optional[Stdlib::Absolutepath] $tls_ca_cert                                                = undef,
   Optional[Integer] $tls_verify_mode                                                         = 1,
-  Boolean $use_registry                                                                      = $::memcached::params::use_registry,
+  Boolean $use_registry                                                                      = $memcached::params::use_registry,
   String $registry_key                                                                       = 'HKLM\System\CurrentControlSet\services\memcached\ImagePath',
   Boolean $large_mem_pages                                                                   = false,
-  Boolean $use_svcprop                                                                       = $::memcached::params::use_svcprop,
+  Boolean $use_svcprop                                                                       = $memcached::params::use_svcprop,
   String $svcprop_fmri                                                                       = 'memcached:default',
   String $svcprop_key                                                                        = 'memcached/options',
   Optional[Array[String]] $extended_opts                                                     = undef,
-  String $config_tmpl                                                                        = $::memcached::params::config_tmpl,
+  String $config_tmpl                                                                        = $memcached::params::config_tmpl,
   Boolean $disable_cachedump                                                                 = false
 ) inherits memcached::params {
-
   # Logging to syslog and file are mutually exclusive
   # Fail if both options are defined
   if $syslog and str2bool($logfile) {
     fail 'Define either syslog or logfile as logging destinations but not both.'
   }
 
   if $use_tls {
     if $tls_cert_chain == undef or $tls_key == undef {
       fail 'tls_cert_chain and tls_key should be set when use_tls is true.'
     }
   }
 
   if $package_ensure == 'absent' {
     $service_ensure = 'stopped'
     $service_enable = false
   } else {
     $service_ensure = 'running'
     $service_enable = true
   }
 
   # Handle if $listen_ip is not an array
-  $real_listen_ip = [ $listen_ip ]
+  $real_listen_ip = [$listen_ip]
 
   package { $memcached::params::package_name:
     ensure   => $package_ensure,
     provider => $memcached::params::package_provider,
   }
 
   if $install_dev {
     package { $memcached::params::dev_package_name:
       ensure  => $package_ensure,
       require => Package[$memcached::params::package_name],
     }
   }
 
   if $manage_firewall {
     firewall { "100_tcp_${tcp_port}_for_memcached":
       dport  => $tcp_port,
       proto  => 'tcp',
       action => 'accept',
     }
 
     firewall { "100_udp_${udp_port}_for_memcached":
       dport  => $udp_port,
       proto  => 'udp',
       action => 'accept',
     }
   }
 
   if $service_restart and $service_manage {
     $service_notify_real = Service[$memcached::params::service_name]
   } else {
     $service_notify_real = undef
   }
 
   if ( $memcached::params::config_file ) {
     file { $memcached::params::config_file:
       owner   => 'root',
       group   => 0,
       mode    => '0644',
       content => template($config_tmpl),
       require => Package[$memcached::params::package_name],
       notify  => $service_notify_real,
     }
   }
 
   if $service_manage {
     service { $memcached::params::service_name:
       ensure     => $service_ensure,
       enable     => $service_enable,
       hasrestart => true,
       hasstatus  => $memcached::params::service_hasstatus,
     }
   }
 
   if $use_registry {
-    registry_value{ $registry_key:
+    registry_value { $registry_key:
       ensure => 'present',
       type   => 'string',
       data   => template($config_tmpl),
       notify => $service_notify_real,
     }
   }
 
   if $use_svcprop {
     svcprop { $svcprop_key:
       fmri     => $svcprop_fmri,
       property => $svcprop_key,
       value    => template($memcached::params::config_tmpl),
       notify   => $service_notify_real,
     }
   }
 }
diff --git a/manifests/params.pp b/manifests/params.pp
index 2182dee..05aeab2 100644
--- a/manifests/params.pp
+++ b/manifests/params.pp
@@ -1,91 +1,91 @@
 # == Class: memcached::params
 #
 class memcached::params {
-  case $::osfamily {
+  case $facts['os']['family'] {
     'Debian': {
       $package_name      = 'memcached'
       $package_provider  = undef
       $service_name      = 'memcached'
       $service_hasstatus = false
       $dev_package_name  = 'libmemcached-dev'
       $config_file       = '/etc/memcached.conf'
       $config_tmpl       = "${module_name}/memcached.conf.erb"
       $user              = 'nobody'
       $logfile           = '/var/log/memcached.log'
       $use_registry      = false
       $use_svcprop       = false
     }
     /RedHat|Suse/: {
       $package_name      = 'memcached'
       $package_provider  = undef
       $service_name      = 'memcached'
       $service_hasstatus = true
       $dev_package_name  = 'libmemcached-devel'
       $config_file       = '/etc/sysconfig/memcached'
       $config_tmpl       = "${module_name}/memcached_sysconfig.erb"
       $user              = 'memcached'
       $logfile           = '/var/log/memcached.log'
       $use_registry      = false
       $use_svcprop       = false
     }
     /windows/: {
       $package_name      = 'memcached'
       $package_provider  = 'chocolatey'
       $service_name      = 'memcached'
       $service_hasstatus = true
       $dev_package_name  = 'libmemcached-devel'
       $config_file       = undef
       $config_tmpl       = "${module_name}/memcached_windows.erb"
       $user              = 'BUILTIN\Administrators'
       $logfile           = undef
       $use_registry      = true
       $use_svcprop       = false
     }
     'Solaris': {
       $package_name      = 'memcached'
       $package_provider  = undef
       $service_name      = 'memcached'
       $service_hasstatus = false
       $dev_package_name  = 'libmemcached'
       $config_file       = undef
       $config_tmpl       = "${module_name}/memcached_svcprop.erb"
       $user              = 'nobody'
       $logfile           = '/var/log/memcached.log'
       $use_registry      = false
       $use_svcprop       = true
     }
     'FreeBSD': {
       $package_name      = 'memcached'
       $package_provider  = undef
       $service_name      = 'memcached'
       $service_hasstatus = false
       $dev_package_name  = 'libmemcached'
       $config_file       = '/etc/rc.conf.d/memcached'
       $config_tmpl       = "${module_name}/memcached_freebsd_rcconf.erb"
       $user              = 'nobody'
       $logfile           = '/var/log/memcached.log'
       $use_registry      = false
       $use_svcprop       = false
     }
     default: {
-      case $::operatingsystem {
+      case $facts['os']['name'] {
         'Amazon': {
           $package_name      = 'memcached'
           $package_provider  = undef
           $service_name      = 'memcached'
           $service_hasstatus = true
           $dev_package_name  = 'libmemcached-devel'
           $config_file       = '/etc/sysconfig/memcached'
           $config_tmpl       = "${module_name}/memcached_sysconfig.erb"
           $user              = 'memcached'
           $logfile           = '/var/log/memcached.log'
           $use_registry      = false
           $use_svcprop       = false
         }
         default: {
-          fail("Unsupported platform: ${::osfamily}/${::operatingsystem}")
+          fail("Unsupported platform: ${facts['os']['family']}/${facts['os']['name']}")
         }
       }
     }
   }
 }