diff --git a/manifests/package.pp b/manifests/package.pp
index 0bf8cd7..109d48a 100644
--- a/manifests/package.pp
+++ b/manifests/package.pp
@@ -1,193 +1,193 @@
 # This class exists to coordinate all software package management related
 # actions, functionality and logical units in a central place.
 #
 # It is not intended to be used directly by external resources like node
 # definitions or other modules.
 #
 # @example importing this class by other classes to use its functionality:
 #   class { 'elasticsearch::package': }
 #
 # @author Richard Pijnenburg <richard.pijnenburg@elasticsearch.com>
 # @author Tyler Langlois <tyler.langlois@elastic.co>
 #
 class elasticsearch::package {
 
   Exec {
     path      => [ '/bin', '/usr/bin', '/usr/local/bin' ],
     cwd       => '/',
     tries     => 3,
     try_sleep => 10,
   }
 
   if $elasticsearch::ensure == 'present' {
 
     if $elasticsearch::restart_package_change {
       Package['elasticsearch'] ~> Elasticsearch::Service <| |>
     }
     Package['elasticsearch'] ~> Exec['remove_plugin_dir']
 
     # Create directory to place the package file
     $package_dir = $elasticsearch::package_dir
     exec { 'create_package_dir_elasticsearch':
       cwd     => '/',
       path    => ['/usr/bin', '/bin'],
       command => "mkdir -p ${package_dir}",
       creates => $package_dir,
     }
 
     file { $package_dir:
       ensure  => 'directory',
       purge   => $elasticsearch::purge_package_dir,
       force   => $elasticsearch::purge_package_dir,
       backup  => false,
       require => Exec['create_package_dir_elasticsearch'],
     }
 
     # Check if we want to install a specific version or not
     if $elasticsearch::version == false {
 
       $package_ensure = $elasticsearch::autoupgrade ? {
         true  => 'latest',
         false => 'present',
       }
 
     } else {
 
       # install specific version
       $package_ensure = $elasticsearch::pkg_version
 
     }
 
     # action
     if ($elasticsearch::package_url != undef) {
 
       case $elasticsearch::package_provider {
         'package': { $before = Package['elasticsearch']  }
         default:   { fail("software provider \"${elasticsearch::package_provider}\".") }
       }
 
 
       $filename_array = split($elasticsearch::package_url, '/')
       $basefilename = $filename_array[-1]
 
       $source_array = split($elasticsearch::package_url, ':')
       $protocol_type = $source_array[0]
 
       $ext_array = split($basefilename, '\.')
       $ext = $ext_array[-1]
 
       $pkg_source = "${package_dir}/${basefilename}"
 
       case $protocol_type {
 
         'puppet': {
 
           file { $pkg_source:
             ensure  => file,
             source  => $elasticsearch::package_url,
             require => File[$package_dir],
             backup  => false,
             before  => $before,
           }
 
         }
         'ftp', 'https', 'http': {
 
           if $elasticsearch::proxy_url != undef {
             $exec_environment = [
               'use_proxy=yes',
               "http_proxy=${elasticsearch::proxy_url}",
               "https_proxy=${elasticsearch::proxy_url}",
             ]
           } else {
             $exec_environment = []
           }
 
           case $elasticsearch::download_tool {
             String: {
               $_download_command = if $elasticsearch::download_tool_verify_certificates {
                 $elasticsearch::download_tool
               } else {
                 $elasticsearch::download_tool_insecure
               }
 
               exec { 'download_package_elasticsearch':
                 command     => "${_download_command} ${pkg_source} ${elasticsearch::package_url} 2> /dev/null",
                 creates     => $pkg_source,
                 environment => $exec_environment,
                 timeout     => $elasticsearch::package_dl_timeout,
                 require     => File[$package_dir],
                 before      => $before,
               }
             }
             default: {
               fail("no \$elasticsearch::download_tool defined for ${facts['os']['family']}")
             }
           }
 
         }
         'file': {
 
           $source_path = $source_array[1]
           file { $pkg_source:
             ensure  => file,
             source  => $source_path,
             require => File[$package_dir],
             backup  => false,
             before  => $before,
           }
 
         }
         default: {
           fail("Protocol must be puppet, file, http, https, or ftp. You have given \"${protocol_type}\"")
         }
       }
 
       if ($elasticsearch::package_provider == 'package') {
 
         case $ext {
           'deb':   { Package { provider => 'dpkg', source => $pkg_source } }
           'rpm':   { Package { provider => 'rpm', source => $pkg_source } }
           default: { fail("Unknown file extention \"${ext}\".") }
         }
 
       }
 
     } else {
       if ($elasticsearch::manage_repo and $facts['os']['family'] == 'Debian') {
         Class['apt::update'] -> Package['elasticsearch']
       }
     }
 
   # Package removal
   } else {
 
     if ($facts['os']['family'] == 'Suse') {
       Package {
         provider  => 'rpm',
       }
       $package_ensure = 'absent'
     } else {
       $package_ensure = 'purged'
     }
 
   }
 
   if ($elasticsearch::package_provider == 'package') {
 
     package { 'elasticsearch':
       ensure => $package_ensure,
       name   => $elasticsearch::_package_name,
     }
 
     exec { 'remove_plugin_dir':
       refreshonly => true,
-      command     => "rm -rf ${elasticsearch::_plugindir}",
+      command     => "rm -rf ${::elasticsearch::_plugindir}",
     }
 
 
   } else {
     fail("\"${elasticsearch::package_provider}\" is not supported")
   }
 
 }
diff --git a/manifests/plugin.pp b/manifests/plugin.pp
index 12b74a1..cb25516 100644
--- a/manifests/plugin.pp
+++ b/manifests/plugin.pp
@@ -1,152 +1,152 @@
 # This define allows you to install arbitrary Elasticsearch plugins
 # either by using the default repositories or by specifying an URL
 #
 # @example install from official repository
 #   elasticsearch::plugin {'mobz/elasticsearch-head': module_dir => 'head'}
 #
 # @example installation using a custom URL
 #   elasticsearch::plugin { 'elasticsearch-jetty':
 #    module_dir => 'elasticsearch-jetty',
 #    url        => 'https://oss-es-plugins.s3.amazonaws.com/elasticsearch-jetty/elasticsearch-jetty-0.90.0.zip',
 #   }
 #
 # @param ensure
 #   Whether the plugin will be installed or removed.
 #   Set to 'absent' to ensure a plugin is not installed
 #
 # @param configdir
 #   Path to the elasticsearch configuration directory (ES_PATH_CONF)
 #   to which the plugin should be installed.
 #
 # @param instances
 #   Specify all the instances related
 #
 # @param java_opts
 #   Array of Java options to be passed to `ES_JAVA_OPTS`
 #
 # @param java_home
 #   Path to JAVA_HOME, if Java is installed in a non-standard location.
 #
 # @param module_dir
 #   Directory name where the module has been installed
 #   This is automatically generated based on the module name
 #   Specify a value here to override the auto generated value
 #
 # @param proxy_host
 #   Proxy host to use when installing the plugin
 #
 # @param proxy_password
 #   Proxy auth password to use when installing the plugin
 #
 # @param proxy_port
 #   Proxy port to use when installing the plugin
 #
 # @param proxy_username
 #   Proxy auth username to use when installing the plugin
 #
 # @param source
 #   Specify the source of the plugin.
 #   This will copy over the plugin to the node and use it for installation.
 #   Useful for offline installation
 #
 # @param url
 #   Specify an URL where to download the plugin from.
 #
 # @author Richard Pijnenburg <richard.pijnenburg@elasticsearch.com>
 # @author Matteo Sessa <matteo.sessa@catchoftheday.com.au>
 # @author Dennis Konert <dkonert@gmail.com>
 # @author Tyler Langlois <tyler.langlois@elastic.co>
 #
 define elasticsearch::plugin (
   Enum['absent', 'present']      $ensure         = 'present',
   Stdlib::Absolutepath           $configdir      = $elasticsearch::configdir,
   Variant[String, Array[String]] $instances      = [],
   Array[String]                  $java_opts      = [],
   Optional[Stdlib::Absolutepath] $java_home      = undef,
   Optional[String]               $module_dir     = undef,
   Optional[String]               $proxy_host     = undef,
   Optional[String]               $proxy_password = undef,
   Optional[Integer[0, 65535]]    $proxy_port     = undef,
   Optional[String]               $proxy_username = undef,
   Optional[String]               $source         = undef,
   Optional[Stdlib::HTTPUrl]      $url            = undef,
 ) {
 
   include elasticsearch
 
   case $ensure {
     'present': {
       if empty($instances) and $elasticsearch::restart_plugin_change {
         fail('no $instances defined, even though `restart_plugin_change` is set!')
       }
 
       $_file_ensure = 'directory'
       $_file_before = []
     }
     'absent': {
       $_file_ensure = $ensure
       $_file_before = File[$elasticsearch::_plugindir]
     }
     default: { }
   }
 
   # set proxy by override or parse and use proxy_url from
   # elasticsearch::proxy_url or use no proxy at all
 
   if ($proxy_host != undef and $proxy_port != undef) {
     if ($proxy_username != undef and $proxy_password != undef) {
       $_proxy_auth = "${proxy_username}:${proxy_password}@"
     } else {
       $_proxy_auth = undef
     }
     $_proxy = "http://${_proxy_auth}${proxy_host}:${proxy_port}"
   } elsif ($elasticsearch::proxy_url != undef) {
     $_proxy = $elasticsearch::proxy_url
   } else {
     $_proxy = undef
   }
 
   if ($source != undef) {
 
     $filename_array = split($source, '/')
     $basefilename = $filename_array[-1]
 
     $file_source = "${elasticsearch::package_dir}/${basefilename}"
 
     file { $file_source:
       ensure => 'file',
       source => $source,
       before => Elasticsearch_plugin[$name],
     }
 
   } else {
     $file_source = undef
   }
 
   $_module_dir = es_plugin_name($module_dir, $name)
 
   elasticsearch_plugin { $name:
     ensure                     => $ensure,
     configdir                  => $configdir,
     elasticsearch_package_name => 'elasticsearch',
     java_opts                  => $java_opts,
     java_home                  => $java_home,
     source                     => $file_source,
     url                        => $url,
     proxy                      => $_proxy,
     plugin_dir                 => $::elasticsearch::_plugindir,
     plugin_path                => $module_dir,
   }
-  -> file { "${elasticsearch::_plugindir}/${_module_dir}":
+  -> file { "${::elasticsearch::_plugindir}/${_module_dir}":
     ensure  => $_file_ensure,
     mode    => 'o+Xr',
     recurse => true,
     before  => $_file_before,
   }
 
   if ! empty($instances) and $elasticsearch::restart_plugin_change {
     Elasticsearch_plugin[$name] {
       notify +> Elasticsearch::Instance[$instances],
     }
   }
 }