diff --git a/manifests/master.pp b/manifests/master.pp
index e1aeeca..734228c 100644
--- a/manifests/master.pp
+++ b/manifests/master.pp
@@ -1,135 +1,135 @@
 # munin::master - Define a munin master
 #
 # The munin master will install munin, and collect all exported munin
 # node definitions as files into /etc/munin/munin-conf.d/.
 #
 # Parameters:
 #
 # - node_definitions: A hash of node definitions used by
 #   create_resources to make static node definitions.
 #
 # - host_name: A host name for this munin master, matched with
 #   munin::node::mastername for collecting nodes. Defaults to $::fqdn
 #
 # - graph_strategy: 'cgi' (default) or 'cron'
 #   Controls if munin-graph graphs all services ('cron') or if graphing is done
 #   by munin-cgi-graph (which must configured seperatly)
 #
 # - html_strategy: 'cgi' (default) or 'cron'
 #   Controls if munin-html will recreate all html pages every run interval
 #   ('cron') or if html pages are generated by munin-cgi-graph (which must
 #   configured seperatly)
 #
 # - config_root: the root directory of the munin master configuration.
 #   Default: /etc/munin on most platforms.
 #
 # - collect_nodes: 'enabled' (default), 'disabled', 'mine' or
 #   'unclaimed'. 'enabled' makes the munin master collect all exported
 #   node_definitions. 'disabled' disables it. 'mine' makes the munin
 #   master collect nodes matching $munin::master::host_name, while
 #   'unclaimed' makes the munin master collect nodes not tagged with a
 #   host name.
 #
 # - dbdir: Path to the munin dbdir, where munin stores everything
 #
 # - htmldir: Path to where munin will generate HTML documents and
 #   graphs, used if graph_strategy is cron.
 #
 # - rundir: Path to directory munin uses for pid and lock files.
 #
 # - tls: 'enabled' or 'disabled' (default). Controls the use of TLS
 #   globally for master to node communications.
 #
 # - tls_certificate: Path to a file containing a TLS certificate. No
 #   default. Required if tls is enabled.
 #
 # - tls_private_key: Path to a file containing a TLS key. No default.
 #   Required if tls is enabled.
 #
 # - tls_verify_certificate: 'yes' (default) or 'no'.
 #
 # - extra_config: Extra lines of config to put in munin.conf.
 
 class munin::master (
   $node_definitions       = $munin::params::master::node_defintions,
   $graph_strategy         = $munin::params::master::graph_strategy,
   $html_strategy          = $munin::params::master::html_strategy,
   $config_root            = $munin::params::master::config_root,
   $collect_nodes          = $munin::params::master::collect_nodes,
   $dbdir                  = $munin::params::master::dbdir,
   $htmldir                = $munin::params::master::htmldir,
   $logdir                 = $munin::params::master::logdir,
   $rundir                 = $munin::params::master::rundir,
   $tls                    = $munin::params::master::tls,
   $tls_certificate        = $munin::params::master::tls_certificate,
   $tls_private_key        = $munin::params::master::tls_private_key,
   $tls_verify_certificate = $munin::params::master::tls_verify_certificate,
   $host_name              = $munin::params::master::host_name,
   $extra_config           = $munin::params::master::extra_config,
   ) inherits munin::params::master {
 
   if $node_definitions {
     validate_hash($node_definitions)
   }
   if $graph_strategy {
     validate_re($graph_strategy, [ '^cgi$', '^cron$' ])
   }
   if $html_strategy {
     validate_re($html_strategy, [ '^cgi$', '^cron$' ])
   }
   validate_re($collect_nodes, [ '^enabled$', '^disabled$', '^mine$',
                                 '^unclaimed$' ])
   validate_absolute_path($config_root)
 
   validate_re($tls, [ '^enabled$', '^disabled$' ])
 
   if $tls == 'enabled' {
     validate_re($tls_verify_certificate, [ '^yes$', '^no$' ])
     validate_absolute_path($tls_private_key)
     validate_absolute_path($tls_certificate)
   }
 
   if $host_name {
     validate_string($host_name)
-    if ! is_domain_name("${host_name}") {
+    if ! is_domain_name($host_name) {
       fail('host_name should be a valid domain name')
     }
   }
 
   validate_array($extra_config)
 
   # The munin package and configuration
   package { 'munin':
     ensure => latest,
   }
 
   File {
     owner   => 'root',
     group   => 'root',
     mode    => '0644',
     require => Package['munin'],
   }
 
   file { "${config_root}/munin.conf":
     content => template('munin/munin.conf.erb'),
   }
 
   file { "${config_root}/munin-conf.d":
     ensure  => directory,
     recurse => true,
     purge   => true,
     force   => true,
   }
 
   if $collect_nodes != 'disabled' {
-    class { 'munin::master::collect':
+    class { '::munin::master::collect':
       collect_nodes => $collect_nodes,
       host_name     => $host_name,
     }
   }
 
   # Create static node definitions
   if $node_definitions {
     create_resources(munin::master::node_definition, $node_definitions, {})
   }
 }
diff --git a/manifests/master/node_definition.pp b/manifests/master/node_definition.pp
index dbf4755..cc1d582 100644
--- a/manifests/master/node_definition.pp
+++ b/manifests/master/node_definition.pp
@@ -1,35 +1,35 @@
 # munin::master::node_definition - A node definition for the munin
 # master.
 #
 # - title: The title of the defined resource should be a munin FQN,
 #   ('hostname', 'group;hostname', 'group;subgroup;hostname'). If a
 #   group is not set, munin will by default use the domain of the node
 #   as a group.
 #
 # Parameters
 #
 # - address: The address of the munin node. A hostname, an IP address,
 #   or a ssh:// uri for munin-async node. Required.
 #
 # - mastername: The name of the munin master server which will collect
 #   the node definition.
 #
 # - config: An array of configuration lines to be added to the node
 #   definition. Default is an empty array.
 #
 define munin::master::node_definition (
   $address,
   $mastername='',
   $config=[],
 )
 {
   validate_string($address)
   validate_array($config)
 
   $filename=sprintf('/etc/munin/munin-conf.d/node.%s.conf',
                     regsubst($name, '[^[:alnum:]\.]', '_', 'IG'))
 
   file { $filename:
-    content => template('munin/master/node.definition.conf.erb')
+    content => template('munin/master/node.definition.conf.erb'),
   }
 }
diff --git a/manifests/node.pp b/manifests/node.pp
index cd929f4..5c91617 100644
--- a/manifests/node.pp
+++ b/manifests/node.pp
@@ -1,184 +1,184 @@
 # munin::node - Configure a munin node, and export configuration a
 # munin master can collect.
 #
 # Parameters:
 #
 # allow: List of IPv4 and IPv6 addresses and networks to allow to connect.
 #
 # config_root: Root directory for munin configuration.
 #
 # nodeconfig: List of lines to append to the munin node configuration.
 #
 # host_name: The host name munin node identifies as. Defaults to
 # the $::fqdn fact.
 #
 # log_dir: The log directory for the munin node process. Defaults
 # change according to osfamily, see munin::params::node for details.
 #
 # log_file: Appended to "log_dir". Defaults to "munin-node.log".
 #
 # log_destination: "file" or "syslog".  Defaults to "file".  If log_destination
 # is "syslog", the "log_file" and "log_dir" parameters are ignored, and the
 # "syslog_*" parameters are used if set.
 #
 # purge_configs: Removes all other munin plugins and munin plugin
 # configuration files.  Boolean, defaults to false.
 #
 # syslog_facility: Defaults to undef, which makes munin-node use the
 # perl Net::Server module default of "daemon". Possible values are any
 # syslog facility by number, or lowercase name.
 #
 # masterconfig: List of configuration lines to append to the munin
 # master node definitinon
 #
 # mastername: The name of the munin master server which will collect
 # the node definition.
 #
 # mastergroup: The group used on the master to construct a FQN for
 # this node. Defaults to "", which in turn makes munin master use the
 # domain. Note: changing this for a node also means you need to move
 # rrd files on the master, or graph history will be lost.
 #
 # plugins: A hash used by create_resources to create munin::plugin
 # instances.
 #
 # address: The address used in the munin master node definition.
 #
 # package_name: The name of the munin node package to install.
 #
 # service_name: The name of the munin node service.
 #
 # service_ensure: Defaults to "". If set to "running" or "stopped", it
 # is used as parameter "ensure" for the munin node service.
 #
 # export_node: "enabled" or "disabled". Defaults to "enabled".
 # Causes the node config to be exported to puppetmaster.
 #
 # file_group: The UNIX group name owning the configuration files,
 # log files, etc.
 #
 # timeout: Used to set the global plugin runtime timeout for this
 # node. Integer. Defaults to undef, which lets munin-node use its
 # default of 10 seconds.
 
 class munin::node (
   $address         = $munin::params::node::address,
   $allow           = $munin::params::node::allow,
   $config_root     = $munin::params::node::config_root,
   $host_name       = $munin::params::node::host_name,
   $log_dir         = $munin::params::node::log_dir,
   $log_file        = $munin::params::node::log_file,
   $masterconfig    = $munin::params::node::masterconfig,
   $mastergroup     = $munin::params::node::mastergroup,
   $mastername      = $munin::params::node::mastername,
   $nodeconfig      = $munin::params::node::nodeconfig,
   $package_name    = $munin::params::node::package_name,
   $plugins         = $munin::params::node::plugins,
   $purge_configs   = $munin::params::node::purge_configs,
   $service_ensure  = $munin::params::node::service_ensure,
   $service_name    = $munin::params::node::service_name,
   $export_node     = $munin::params::node::export_node,
   $file_group      = $munin::params::node::file_group,
   $log_destination = $munin::params::node::log_destination,
   $syslog_facility = $munin::params::node::syslog_facility,
   $timeout         = $munin::params::node::timeout,
 ) inherits munin::params::node {
 
   validate_array($allow)
   validate_array($nodeconfig)
   validate_array($masterconfig)
   if $mastergroup { validate_string($mastergroup) }
   if $mastername { validate_string($mastername) }
   validate_hash($plugins)
   validate_string($address)
   validate_absolute_path($config_root)
   validate_string($package_name)
   validate_string($service_name)
   if $service_ensure { validate_re($service_ensure, '^(running|stopped)$') }
   validate_re($export_node, '^(enabled|disabled)$')
   validate_absolute_path($log_dir)
   validate_re($log_destination, '^(?:file|syslog)$')
   validate_string($log_file)
   validate_string($file_group)
   validate_bool($purge_configs)
   if $timeout { validate_integer($timeout) }
 
   case $log_destination {
     'file': {
       $_log_file = "${log_dir}/${log_file}"
       validate_absolute_path($_log_file)
     }
     'syslog': {
       $_log_file = 'Sys::Syslog'
       if $syslog_facility {
         validate_string($syslog_facility)
         validate_re($syslog_facility,
                     '^(?:\d+|(?:kern|user|mail|daemon|auth|syslog|lpr|news|uucp|authpriv|ftp|cron|local[0-7]))$')
       }
     }
     default: {
       fail('log_destination is not set')
     }
   }
 
   if $mastergroup {
     $fqn = "${mastergroup};${host_name}"
   }
   else {
     $fqn = $host_name
   }
 
   if $service_ensure { $_service_ensure = $service_ensure }
   else { $_service_ensure = undef }
 
   # Defaults
   File {
     ensure => present,
     owner  => 'root',
     group  => $file_group,
     mode   => '0444',
   }
 
   package { $package_name:
     ensure => installed,
   }
 
   service { $service_name:
     ensure  => $_service_ensure,
     enable  => true,
     require => Package[$package_name],
   }
 
   file { "${config_root}/munin-node.conf":
     content => template('munin/munin-node.conf.erb'),
     require => Package[$package_name],
     notify  => Service[$service_name],
   }
 
   # Export a node definition to be collected by the munin master.
   # (Separated into its own class to prevent warnings about "missing
   # storeconfigs", even if $export_node is not enabled)
   if $export_node == 'enabled' {
-    class { 'munin::node::export':
+    class { '::munin::node::export':
       address      => $address,
       fqn          => $fqn,
       mastername   => $mastername,
       masterconfig => $masterconfig,
     }
   }
 
   # Generate plugin resources from hiera or class parameter.
   create_resources(munin::plugin, $plugins, {})
 
   # Purge unmanaged plugins and plugin configuration files.
   if $purge_configs {
     file { ["${config_root}/plugins", "${config_root}/plugin-conf.d" ]:
       ensure  => directory,
       recurse => true,
       purge   => true,
       require => Package[$package_name],
       notify  => Service[$service_name],
     }
   }
 
 }
diff --git a/manifests/params/master.pp b/manifests/params/master.pp
index b745b6a..d8b0ddf 100644
--- a/manifests/params/master.pp
+++ b/manifests/params/master.pp
@@ -1,34 +1,36 @@
+# Parameters for the munin::master class. Add support for new OS
+# families here.
 class munin::params::master {
   $message = "Unsupported osfamily ${::osfamily}"
 
   $graph_strategy           = 'cgi'
   $html_strategy            = 'cgi'
   $node_definitions         = ''
   $collect_nodes            = 'enabled'
   $dbdir                    = undef
   $htmldir                  = undef
   $logdir                   = undef
   $rundir                   = undef
   $tls                      = 'disabled'
   $tls_certificate          = undef
   $tls_private_key          = undef
   $tls_verify_certificate   = 'yes'
   $extra_config             = []
   $host_name                = $::fqdn
 
   case $::osfamily {
     'Debian',
     'RedHat': {
       $config_root = '/etc/munin'
     }
     'Solaris': {
       $config_root = '/opt/local/etc/munin'
     }
     'FreeBSD': {
       $config_root = '/usr/local/etc/munin'
     }
     default: {
       fail($message)
     }
   }
 }
diff --git a/manifests/params/node.pp b/manifests/params/node.pp
index f2ae4ca..08716a9 100644
--- a/manifests/params/node.pp
+++ b/manifests/params/node.pp
@@ -1,75 +1,77 @@
+# Parameters for the munin::node class. Add support for new OS
+# families here.
 class munin::params::node {
 
   $message = "Unsupported osfamily: ${::osfamily}"
 
   $address        = $::fqdn
   $host_name      = $::fqdn
   $allow          = []
   $masterconfig   = []
   $mastergroup    = undef
   $mastername     = undef
   $nodeconfig     = []
   $plugins        = {}
   $service_ensure = undef
   $export_node    = 'enabled'
   $log_file       = 'munin-node.log'
   $log_destination = 'file'
   $syslog_facility = undef
   $purge_configs   = false
   $timeout         = undef
 
   case $::osfamily {
     'RedHat': {
       $config_root  = '/etc/munin'
       $log_dir      = '/var/log/munin-node'
       $service_name = 'munin-node'
       $package_name = 'munin-node'
       $plugin_share_dir = '/usr/share/munin/plugins'
       $file_group   = 'root'
     }
     'Debian': {
       $config_root  = '/etc/munin'
       $log_dir      = '/var/log/munin'
       $service_name = 'munin-node'
       $package_name = 'munin-node'
       $plugin_share_dir = '/usr/share/munin/plugins'
       $file_group   = 'root'
     }
     'Solaris': {
       case $::operatingsystem {
         'SmartOS': {
           $config_root  = '/opt/local/etc/munin'
           $log_dir      = '/var/opt/log/munin'
           $service_name = 'smf:/munin-node'
           $package_name = 'munin-node'
           $plugin_share_dir = '/opt/local/share/munin/plugins'
           $file_group   = 'root'
         }
         default: {
           fail("Unsupported operatingsystem ${::operatingsystem} for osfamily ${::osfamily}")
         }
       }
     }
     'FreeBSD', 'DragonFly': {
       $config_root  = '/usr/local/etc/munin'
       $log_dir      = '/var/log/munin'
       $service_name = 'munin-node'
       $package_name = 'munin-node'
       $plugin_share_dir = '/usr/local/share/munin/plugins'
       $file_group   = 'wheel'
     }
     'OpenBSD': {
       $config_root  = '/etc/munin'
       $log_dir      = '/var/log/munin'
       $service_name = 'munin_node'
       $package_name = 'munin-node'
       $plugin_share_dir = '/usr/local/libexec/munin/plugins'
       $file_group   = 'wheel'
     }
     default: {
       fail($message)
     }
   }
 }
 
 
diff --git a/manifests/plugin.pp b/manifests/plugin.pp
index 9d8a90b..1b5b66e 100644
--- a/manifests/plugin.pp
+++ b/manifests/plugin.pp
@@ -1,92 +1,92 @@
 # munin::plugin
 #
 # Parameters:
 #
 # - ensure: "link", "present", "absent" or "". Default is "". The
 #   ensure parameter is mandatory for installing a plugin.
 # - source: when ensure => present, source file
 # - target: when ensure => link, link target.  If target is an
 #   absolute path (starts with "/") it is used directly.  If target is
 #   a relative path, $munin::node::plugin_share_dir is prepended.
 # - config: array of lines for munin plugin config
 # - config_label: label for munin plugin config
 
 define munin::plugin (
     $ensure='',
     $source=undef,
     $target='',
     $config=undef,
     $config_label=undef,
 )
 {
 
-    include munin::node
+    include ::munin::node
 
     $plugin_share_dir=$munin::node::plugin_share_dir
     validate_absolute_path($plugin_share_dir)
 
     File {
         require => Package[$munin::node::package_name],
         notify  => Service[$munin::node::service_name],
     }
 
     validate_re($ensure, '^(|link|present|absent)$')
     case $ensure {
         'present': {
             $handle_plugin = true
             $plugin_ensure = 'present'
         }
         'absent': {
             $handle_plugin = true
             $plugin_ensure = 'absent'
         }
         'link': {
             $handle_plugin = true
             $plugin_ensure = 'link'
             case $target {
                 '': {
                     $plugin_target = "${munin::node::plugin_share_dir}/${title}"
                 }
                 /^\//: {
                     $plugin_target = $target
                 }
                 default: {
                     $plugin_target = "${munin::node::plugin_share_dir}/${target}"
                 }
             }
             validate_absolute_path($plugin_target)
         }
         default: {
             $handle_plugin = false
         }
     }
 
     if $config {
         $config_ensure = $ensure ? {
-            absent  => absent,
+            'absent'=> absent,
             default => present,
         }
     }
     else {
         $config_ensure = absent
     }
 
 
     if $handle_plugin {
         # Install the plugin
         file {"${munin::node::config_root}/plugins/${name}":
             ensure => $plugin_ensure,
             source => $source,
             target => $plugin_target,
             mode   => '0755',
         }
     }
 
     # Config
 
     file{ "${munin::node::config_root}/plugin-conf.d/${name}.conf":
       ensure  => $config_ensure,
       content => template('munin/plugin_conf.erb'),
     }
 
 }