merged with immerda

3 files changed, 239 insertions, 142 deletions

diff --git a/manifests/client.pp b/manifests/client.pp
index 4c75757..df9ab06 100644
--- a/manifests/client.pp
+++ b/manifests/client.pp
@@ -13,9 +13,9 @@ class munin::client {
 	}
 
     case $operatingsystem {
+        openbsd: { include munin::client::openbsd }
         darwin: { include munin::client::darwin }
-        debian: { include munin::client::debian }
-        ubuntu: { include munin::client::ubuntu }
+        debian,ubuntu: { include munin::client::debian }
         centos: { include munin::client::centos }
         gentoo: { include munin::client::gentoo }
         default: { include munin::client::base }
@@ -61,34 +61,73 @@ define munin::register_snmp(
 }
 
 class munin::client::base {
-	package { "munin-node": ensure => installed }
-	service { "munin-node":
-		ensure => running, 
+    service { 'munin-node':
+        ensure => running, 
         enable => true,
         hasstatus => true,
         hasrestart => true,
-        require => Package[munin-node],
-	}
-	file {"/etc/munin/":
-			ensure => directory,
-			mode => 0755, owner => root, group => 0;
+    }
+    file {'/etc/munin/':
+        ensure => directory,
+        mode => 0755, owner => root, group => 0;
     }
     $real_munin_allow = $munin_allow ? {
         '' => '127.0.0.1',
         default => $munin_allow
     }
-    file {"/etc/munin/munin-node.conf":
-			content => template("munin/munin-node.conf.$operatingsystem"),
-			# this has to be installed before the package, so the postinst can
-			# boot the munin-node without failure!
-			before => Package["munin-node"],
-            notify => Service['munin-node'],
-			mode => 0644, owner => root, group => 0,
+    file {'/etc/munin/munin-node.conf':
+	    content => template("munin/munin-node.conf.$operatingsystem"),
+        notify => Service['munin-node'],
+		mode => 0644, owner => root, group => 0,
 	}
 	munin::register { $fqdn: }
 	include munin::plugins::base
 }
 
+# currently we install munin on openbsd by targz
+# :(
+class munin::client::openbsd inherits munin::client::base {
+    file{'/usr/src/munin_openbsd.tar.gz':
+        source => "puppet://$server/munin/openbsd/package/munin_openbsd.tar.gz",
+        owner => root, group => 0, mode => 0600;
+    }
+    package{ [ 'p5-Compress-Zlib', 'p5-Crypt-SSLeay', 'p5-HTML-Parser', 
+                'p5-HTML-Tagset', 'p5-HTTP-GHTTP', 'p5-LWP-UserAgent-Determined',
+                'p5-Net-SSLeay', 'p5-Net-Server', 'p5-URI', 'p5-libwww', 'pcre', 'curl' ]:
+        ensure => installed,
+        before => File['/var/run/munin'],
+    }
+    exec{'extract_openbsd':
+        command => 'cd /;tar xzf /usr/src/munin_openbsd.tar.gz',
+        unless => 'test -d /opt/munin',
+        require => File['/usr/src/munin_openbsd.tar.gz'],
+    }
+    file{[ '/var/run/munin', '/var/log/munin' ]:
+        ensure => directory,
+        require => Exec['extract_openbsd'],
+        owner => root, group  => 0, mode => 0755;
+    }
+    openbsd::add_to_rc_local{'munin-node':
+        binary => '/opt/munin/sbin/munin-node',
+        require => File['/var/run/munin'],
+    }
+    Service['munin-node']{
+        restart => '/bin/kill -HUP `/bin/cat /var/run/munin/munin-node.pid`',
+        stop => '/bin/kill `/bin/cat /var/run/munin/munin-node.pid`',
+        start => '/opt/munin/sbin/munin-node',
+        hasstatus => false,
+        hasrestart => false,
+        require => [ File['/var/run/munin'], File['/var/log/munin'] ],
+    }
+
+    cron{'clean_munin_logfile':
+        command => 'rm /var/log/munin/munin-node.log; kill -HUP `cat /var/run/munin/munin-node.pid`',
+        minute => 0,
+        hour => 2,
+        weekday => 0,
+    }
+}
+
 class munin::client::darwin {
 	file { "/usr/share/snmp/snmpd.conf": 
 		mode => 744,
@@ -111,7 +150,19 @@ class munin::client::darwin {
 	munin::register_snmp { $fqdn: }
 }
 
-class munin::client::debian inherits munin::client::base {
+class munin::client::package inherits munin::client::base {
+	package { 'munin-node': ensure => installed }
+    Service['munin-node']{
+        require => Package[munin-node],
+    }
+    File['/etc/munin/munin-node.conf']{
+    	# this has to be installed before the package, so the postinst can
+    	# boot the munin-node without failure!
+	    before => Package['munin-node'],
+    }
+}
+
+class munin::client::debian inherits munin::client::package {
     # the plugin will need that
 	package { "iproute": ensure => installed }
 
@@ -127,9 +178,7 @@ class munin::client::debian inherits munin::client::base {
 	include munin::plugins::debian
 }
 
-class munin::client::ubuntu inherits munin::client::debian {}
-
-class munin::client::gentoo inherits munin::client::base {
+class munin::client::gentoo inherits munin::client::package {
     Package['munin-node'] {
         name => 'munin',
         category => 'net-analyzer',
@@ -139,6 +188,6 @@ class munin::client::gentoo inherits munin::client::base {
 	include munin::plugins::gentoo
 }
 
-class munin::client::centos inherits munin::client::base {
+class munin::client::centos inherits munin::client::package {
 	include munin::plugins::centos
 }
diff --git a/manifests/host.pp b/manifests/host.pp
index fdaa255..21cf7df 100644
--- a/manifests/host.pp
+++ b/manifests/host.pp
@@ -34,6 +34,12 @@ class munin::host
     case $operatingsystem {
         centos: { include munin::host::cgi }
     }
+
+  # from time to time we cleanup hanging munin-runs
+  file{'/etc/cron.d/munin_kill':
+    content => "4,34 * * * * root if $(ps ax | grep -v grep | grep -q munin-run); then killall munin-run; fi\n",
+    owner => root, group => 0, mode => 0644;
+  }
 }
 
 class munin::host::cgi {
diff --git a/manifests/plugin.pp b/manifests/plugin.pp
index bb02e46..8d739a8 100644
--- a/manifests/plugin.pp
+++ b/manifests/plugin.pp
@@ -7,124 +7,125 @@
 ### configpaths
 
 class munin::plugin::scriptpaths {
-	case $operatingsystem {
-		gentoo: {	
-            $script_path =  "/usr/libexec/munin/plugins"
-			}
-		debian: {		
-            $script_path =  "/usr/share/munin/plugins"
-			}
-		centos: {		
-            $script_path =  "/usr/share/munin/plugins"
-			}
-		default: {
-            $script_path =  "/usr/share/munin/plugins"
-		}
-	}
+    case $operatingsystem {
+    	gentoo: { $script_path =  "/usr/libexec/munin/plugins" }
+    	debian: { $script_path =  "/usr/share/munin/plugins" }
+    	centos: { $script_path =  "/usr/share/munin/plugins" }
+    	openbsd: { $script_path =  "/opt/munin/lib/plugins/" }
+    	default: { $script_path =  "/usr/share/munin/plugins" }
+    }
 }
 
 ### defines
 
 define munin::plugin (
-	$ensure = "present",
-	$script_path_in = '',
-	$config = '')
+    $ensure = "present",
+    $script_path_in = '',
+    $config = '')
 {
 
     include munin::plugin::scriptpaths
-	$real_script_path = $script_path_in ? { '' => $munin::plugin::scriptpaths::script_path, default => $script_path_in }
-
-	$plugin_src = $ensure ? { "present" => $name, default => $ensure }
-	debug ( "munin_plugin: name=$name, ensure=$ensure, script_path=$munin::plugin::scriptpaths::script_path" )
-	$plugin = "/etc/munin/plugins/$name"
-	$plugin_conf = "/etc/munin/plugin-conf.d/$name.conf"
-	case $ensure {
-		"absent": {
-			debug ( "munin_plugin: suppressing $plugin" )
-			file { $plugin: ensure => absent, } 
-		}
-		default: {
-			debug ( "munin_plugin: making $plugin using src: $plugin_src" )
+    $real_script_path = $script_path_in ? { '' => $munin::plugin::scriptpaths::script_path, default => $script_path_in }
+
+    $plugin_src = $ensure ? { "present" => $name, default => $ensure }
+    $plugin = "/etc/munin/plugins/$name"
+    $plugin_conf = "/etc/munin/plugin-conf.d/$name.conf"
+    case $ensure {
+    	"absent": {
+    		file { $plugin: ensure => absent, }
+    	}
+    	default: {
+            case $kernel {
+                openbsd: { $basic_require = File['/var/run/munin'] }
+                default: { $basic_require = Package['munin-node'] }
+            }
             if $require {
-                $real_require = [ $require, Package['munin-node'] ]
+                $real_require = [ $require, $basic_require ]
             } else {
-                $real_require = Package['munin-node']
+                $real_require = $basic_require
             }
-			file { $plugin:
-			    ensure => "${real_script_path}/${plugin_src}",
-				require => $real_require,
-				notify => Service['munin-node'];
-			}
-
-		}
-	}
-	case $config {
-		'': {
-			debug("no config for $name")
-			file { $plugin_conf: ensure => absent }
-		}
-		default: {
-			case $ensure {
-				absent: {
-					debug("removing config for $name")
-					file { $plugin_conf: ensure => absent }
-				}
-				default: {
-					debug("creating $plugin_conf")
-					file { $plugin_conf:
-						content => "[${name}]\n$config\n",
-						mode => 0644, owner => root, group => 0,
-					}
+    		file { $plugin:
+    		    ensure => "${real_script_path}/${plugin_src}",
+    			require => $real_require,
+    			notify => Service['munin-node'];
+    		}
+
+    	}
+    }
+    case $config {
+    	'': {
+    		file { $plugin_conf: ensure => absent }
+    	}
+    	default: {
+    		case $ensure {
+    			absent: {
+    				file { $plugin_conf: ensure => absent }
+    			}
+    			default: {
+    				file { $plugin_conf:
+    					content => "[${name}]\n$config\n",
+    					mode => 0644, owner => root, group => 0,
+    				}
                     if $require {
                         File[$plugin_conf]{
                             require +> $require,
                         }
                     }
-				}
-			}
-		}
-	}
+    			}
+    		}
+    	}
+    }
 }
 
 define munin::remoteplugin($ensure = "present", $source, $config = '') {
-	case $ensure {
-		"absent": { munin::plugin{ $name: ensure => absent } }
-		default: {
-			file {
-				"/var/lib/puppet/modules/munin/plugins/${name}":
-					source => $source,
-					mode => 0755, owner => root, group => 0;
-			}
-			munin::plugin { $name:
-				ensure => $ensure,
-				config => $config,
-				script_path_in => "/var/lib/puppet/modules/munin/plugins",
-			}
-		}
-	}
+    case $ensure {
+    	"absent": { munin::plugin{ $name: ensure => absent } }
+    	default: {
+    		file {
+    			"/var/lib/puppet/modules/munin/plugins/${name}":
+    				source => $source,
+    				mode => 0755, owner => root, group => 0;
+    		}
+    		munin::plugin { $name:
+    			ensure => $ensure,
+    			config => $config,
+    			script_path_in => "/var/lib/puppet/modules/munin/plugins",
+    		}
+    	}
+    }
 }
 define munin::plugin::deploy ($source = '', $ensure = 'present', $config = '') {
-    $plugin_src = $ensure ? { 
-        'present' => $name, 
-        'absent' => $name, 
-        default => $ensure 
+    $plugin_src = $ensure ? {
+        'present' => $name,
+        'absent' => $name,
+        default => $ensure
     }
     $real_source = $source ? {
         ''  =>  "munin/plugins/$plugin_src",
         default => $source
     }
     include munin::plugin::scriptpaths
-	debug ( "munin_plugin_${name}: name=$name, source=$source, script_path=$munin::plugin::scriptpaths::script_path" )
     file { "munin_plugin_${name}":
             path => "$munin::plugin::scriptpaths::script_path/${name}",
             source => "puppet://$server/$real_source",
-			require => Package['munin-node'],
             mode => 0755, owner => root, group => 0;
     }
+
+    case $kernel {
+        openbsd: { $basic_require = File['/var/run/munin'] }
+        default: { $basic_require = Package['munin-node'] }
+    }
     if $require {
         File["munin_plugin_${name}"]{
-            require +> $require,
+            require => [ $basic_require, $require ],
         }
+    } else {
+        File["munin_plugin_${name}"]{
+            require => $basic_require,
+        }
+    }
+    # register the plugin
+    if $require {
         munin::plugin{$name: ensure => $ensure, config => $config, require => $require }
     } else {
         munin::plugin{$name: ensure => $ensure, config => $config }
@@ -135,23 +136,40 @@ define munin::plugin::deploy ($source = '', $ensure = 'present', $config = '') {
 
 class munin::plugins::base {
     file {
-	    [ "/etc/munin/plugins", "/etc/munin/plugin-conf.d" ]:
-	        source => "puppet://$server/common/empty",
+        [ '/etc/munin/plugins', '/etc/munin/plugin-conf.d' ]:
+            source => "puppet://$server/common/empty",
             ignore => [ '\.ignore', 'snmp_*' ],
-			ensure => directory, checksum => mtime,
-			recurse => true, purge => true, force => true, 
-			mode => 0755, owner => root, group => 0,
-			notify => Service['munin-node'];
-		"/etc/munin/plugin-conf.d/munin-node":
-			ensure => present, 
-			mode => 0644, owner => root, group => 0,
-			notify => Service['munin-node'],
-            before => Package['munin-node'];
-	}
-
-    munin::plugin {'uptime': ensure => present, }
+            ensure => directory, checksum => mtime,
+            recurse => true, purge => true, force => true,
+            mode => 0755, owner => root, group => 0,
+            notify => Service['munin-node'];
+        '/etc/munin/plugin-conf.d/munin-node':
+            ensure => present,
+            mode => 0644, owner => root, group => 0,
+            notify => Service['munin-node'],
+    }
+
+    munin::plugin {
+        [ df, cpu, interrupts, load, memory, netstat, open_files,
+            processes, swap, uptime, users, vmstat
+        ]:
+            ensure => present,
+    }
+    include munin::plugins::interfaces
 
     case $kernel {
+        openbsd: {
+            File['/etc/munin/plugin-conf.d/munin-node']{
+                before => File['/var/run/munin'],
+            }
+        }
+        default: {
+            File['/etc/munin/plugin-conf.d/munin-node']{
+                before => Package['munin-node'],
+            }
+        }
+    }
+    case $kernel {
         linux: {
             case $vserver {
                 guest: { include munin::plugins::vserver }
@@ -171,38 +189,60 @@ class munin::plugins::base {
 # handle if_ and if_err_ plugins
 class munin::plugins::interfaces inherits munin::plugins::base {
 
-	$ifs = gsub(split($interfaces, " |,"), "(.+)", "if_\\1")
-	$if_errs = gsub(split($interfaces, " |,"), "(.+)", "if_err_\\1")
-	munin::plugin {
-		$ifs: ensure => "if_";
-		$if_errs: ensure => "if_err_";
-	}
+    $ifs = gsub(split($interfaces, " |,"), "(.+)", "if_\\1")
+    munin::plugin {
+    $ifs: ensure => "if_";
+    }
+    case $operatingsystem {
+        openbsd: {
+            $if_errs = gsub(split($interfaces, " |,"), "(.+)", "if_errcoll_\\1")
+    	      munin::plugin{
+            $if_errs: ensure => "if_errcoll_";
+          }
+        }
+        default: {
+            $if_errs = gsub(split($interfaces, " |,"), "(.+)", "if_err_\\1")
+    	      munin::plugin{
+    	        $if_errs: ensure => "if_err_";
+          }
+        }
+    }
 }
 
 class munin::plugins::linux inherits munin::plugins::base {
+    munin::plugin {
+    	[ df_abs, forks, df_inode, irqstats, entropy, open_inodes ]:
+    		ensure => present;
+    	acpi:
+    		ensure => $acpi_available;
+    }
 
-	munin::plugin {
-		[ df_abs, forks, memory, processes, cpu, df_inode, irqstats,
-		  netstat, open_files, swap, df, entropy, interrupts, load, open_inodes,
-		  vmstat
-		]:
-			ensure => present;
-		acpi: 
-			ensure => $acpi_available;
-	}
-
-	include munin::plugins::interfaces
+    include munin::plugins::interfaces
 }
 
 class munin::plugins::debian inherits munin::plugins::base {
-	munin::plugin { apt_all: ensure => present; }
+    munin::plugin { apt_all: ensure => present; }
+}
+
+class munin::plugins::openbsd inherits munin::plugins::base {
+    munin::plugin {
+        [ df, cpu, interrupts, load, memory, netstat, open_files,
+            processes, swap, users, vmstat
+        ]:
+            ensure => present,
+    }
+    munin::plugin {
+        [ memory_pools, memory_types ]:
+            ensure => present,
+    }
+
 }
 
 class munin::plugins::vserver inherits munin::plugins::base {
-	munin::plugin {
-		[ netstat, processes ]:
-			ensure => present;
-	}
+    munin::plugin {
+    	[ netstat, processes ]:
+    		ensure => present;
+    }
 }
 
 class munin::plugins::gentoo inherits munin::plugins::base {
@@ -223,7 +263,9 @@ class munin::plugins::dom0 inherits munin::plugins::physical {
 }
 
 class munin::plugins::physical inherits munin::plugins::base {
-     munin::plugin { iostat: }
+    case $kernel {
+        linux: { munin::plugin { iostat: } }
+    }
 }
 
 class munin::plugins::muninhost inherits munin::plugins::base {