76d12a0c84697bb4a3892bd81b9c9f7b46f0cdd1
[puppet_munin.git] / manifests / plugin.pp
1 # plugin.pp - configure a specific munin plugin
2 # Copyright (C) 2007 David Schmitt <david@schmitt.edv-bus.at>
3 # See LICENSE for the full license granted to you.
4 # adapted and improved by admin(at)immerda.ch
5
6
7 ### configpaths
8
9 class munin::plugin::scriptpaths {
10         case $operatingsystem {
11                 gentoo: {       
12             $script_path =  "/usr/libexec/munin/plugins"
13                         }
14                 debian: {               
15             $script_path =  "/usr/share/munin/plugins"
16                         }
17                 centos: {               
18             $script_path =  "/usr/share/munin/plugins"
19                         }
20                 default: {
21             $script_path =  "/usr/share/munin/plugins"
22                 }
23         }
24 }
25
26 ### defines
27
28 define munin::plugin (
29         $ensure = "present",
30         $script_path_in = '',
31         $config = '')
32 {
33
34     include munin::plugin::scriptpaths
35         $real_script_path = $script_path_in ? { '' => $munin::plugin::scriptpaths::script_path, default => $script_path_in }
36
37         $plugin_src = $ensure ? { "present" => $name, default => $ensure }
38         debug ( "munin_plugin: name=$name, ensure=$ensure, script_path=$munin::plugin::scriptpaths::script_path" )
39         $plugin = "/etc/munin/plugins/$name"
40         $plugin_conf = "/etc/munin/plugin-conf.d/$name.conf"
41         case $ensure {
42                 "absent": {
43                         debug ( "munin_plugin: suppressing $plugin" )
44                         file { $plugin: ensure => absent, } 
45                 }
46                 default: {
47                         debug ( "munin_plugin: making $plugin using src: $plugin_src" )
48             if $require {
49                 $real_require = [ $require, Package['munin-node'] ]
50             } else {
51                 $real_require = Package['munin-node']
52             }
53                         file { $plugin:
54                             ensure => "${real_script_path}/${plugin_src}",
55                                 require => $real_require,
56                                 notify => Service['munin-node'];
57                         }
58
59                 }
60         }
61         case $config {
62                 '': {
63                         debug("no config for $name")
64                         file { $plugin_conf: ensure => absent }
65                 }
66                 default: {
67                         case $ensure {
68                                 absent: {
69                                         debug("removing config for $name")
70                                         file { $plugin_conf: ensure => absent }
71                                 }
72                                 default: {
73                                         debug("creating $plugin_conf")
74                                         file { $plugin_conf:
75                                                 content => "[${name}]\n$config\n",
76                                                 mode => 0644, owner => root, group => 0,
77                                         }
78                     if $require {
79                         File[$plugin_conf]{
80                             require +> $require,
81                         }
82                     }
83                                 }
84                         }
85                 }
86         }
87 }
88
89 define munin::remoteplugin($ensure = "present", $source, $config = '') {
90         case $ensure {
91                 "absent": { munin::plugin{ $name: ensure => absent } }
92                 default: {
93                         file {
94                                 "/var/lib/puppet/modules/munin/plugins/${name}":
95                                         source => $source,
96                                         mode => 0755, owner => root, group => 0;
97                         }
98                         munin::plugin { $name:
99                                 ensure => $ensure,
100                                 config => $config,
101                                 script_path_in => "/var/lib/puppet/modules/munin/plugins",
102                         }
103                 }
104         }
105 }
106 define munin::plugin::deploy ($source = '', $ensure = 'present', $config = '') {
107     $plugin_src = $ensure ? { 
108         'present' => $name, 
109         'absent' => $name, 
110         default => $ensure 
111     }
112     $real_source = $source ? {
113         ''  =>  "munin/plugins/$plugin_src",
114         default => $source
115     }
116     include munin::plugin::scriptpaths
117         debug ( "munin_plugin_${name}: name=$name, source=$source, script_path=$munin::plugin::scriptpaths::script_path" )
118     file { "munin_plugin_${name}":
119             path => "$munin::plugin::scriptpaths::script_path/${name}",
120             source => "puppet://$server/$real_source",
121                         require => Package['munin-node'],
122             mode => 0755, owner => root, group => 0;
123     }
124     if $require {
125         File["munin_plugin_${name}"]{
126             require +> $require,
127         }
128         munin::plugin{$name: ensure => $ensure, config => $config, require => $require }
129     } else {
130         munin::plugin{$name: ensure => $ensure, config => $config }
131     }
132 }
133
134 ### clases for plugins
135
136 class munin::plugins::base {
137         case $operatingsystem {
138                 centos: {               
139                     file {
140                         [ "/etc/munin/plugins", "/etc/munin/plugin-conf.d" ]:
141                                 source => "puppet://$server/munin/empty",
142                                 ensure => directory, checksum => mtime,
143                                 recurse => true, purge => true, force => true, 
144                                 mode => 0755, owner => root, group => 0;
145                         "/etc/munin/plugin-conf.d/munin-node":
146                                 ensure => present, 
147                                 mode => 0644, owner => root, group => 0;
148                     }
149                 }
150
151                 default: {
152                     file {
153                         [ "/etc/munin/plugins", "/etc/munin/plugin-conf.d" ]:
154                                 source => "puppet://$server/munin/empty",
155                                 ensure => directory, checksum => mtime,
156                                 recurse => true, purge => true, force => true, 
157                                 mode => 0755, owner => root, group => 0,
158                                 notify => Service['munin-node'];
159                         "/etc/munin/plugin-conf.d/munin-node":
160                                 ensure => present, 
161                                 mode => 0644, owner => root, group => 0,
162                                 notify => Service['munin-node'],
163                 before => Package['munin-node'];
164                     }
165                 }
166         }
167     case $kernel {
168         linux: {
169             case $vserver {
170                 guest: { include munin::plugins::vserver }
171                 default: {
172                     include munin::plugins::linux
173                 }
174             }
175         }
176     }
177     case $virtual {
178         physical: { include munin::plugins::physical }
179         xen0: { include munin::plugins::dom0 }
180         xenu: { include munin::plugins::domU }
181     }
182 }
183
184 # handle if_ and if_err_ plugins
185 class munin::plugins::interfaces inherits munin::plugins::base {
186
187         $ifs = gsub(split($interfaces, " "), "(.+)", "if_\\1")
188         $if_errs = gsub(split($interfaces, " "), "(.+)", "if_err_\\1")
189         munin::plugin {
190                 $ifs: ensure => "if_";
191                 $if_errs: ensure => "if_err_";
192         }
193 }
194
195 class munin::plugins::linux inherits munin::plugins::base {
196
197         munin::plugin {
198                 [ df_abs, forks, memory, processes, cpu, df_inode, irqstats,
199                   netstat, open_files, swap, df, entropy, interrupts, load, open_inodes,
200                   vmstat
201                 ]:
202                         ensure => present;
203                 acpi: 
204                         ensure => $acpi_available;
205         }
206
207         include munin::plugins::interfaces
208 }
209
210 class munin::plugins::debian inherits munin::plugins::base {
211         munin::plugin { apt_all: ensure => present; }
212 }
213
214 class munin::plugins::vserver inherits munin::plugins::base {
215         munin::plugin {
216                 [ netstat, processes ]:
217                         ensure => present;
218         }
219 }
220
221 class munin::plugins::gentoo inherits munin::plugins::base {
222     munin::plugin::deploy { "gentoo_lastupdated": config => "user portage\nenv.logfile /var/log/emerge.log\nenv.tail        /usr/bin/tail\nenv.grep        /bin/grep"}
223 }
224
225 class munin::plugins::centos inherits munin::plugins::base {
226 }
227
228
229
230 class munin::plugins::dom0 inherits munin::plugins::physical {
231     munin::plugin::deploy { "xen": config => "user root"}
232     munin::plugin::deploy { "xen-cpu": config => "user root"}
233     munin::plugin::deploy { "xen_memory": config => "user root"}
234     munin::plugin::deploy { "xen_vbd": config => "user root"}
235     munin::plugin::deploy { "xen_traffic_all": config => "user root"}
236 }
237
238 class munin::plugins::physical inherits munin::plugins::base {
239      munin::plugin { iostat: }
240 }
241
242 class munin::plugins::muninhost inherits munin::plugins::base {
243     munin::plugin { munin_update: }
244     munin::plugin { munin_graph: }
245 }
246
247 class munin::plugins::domU inherits munin::plugins::base { }
248
249 class munin::plugins::djbdns inherits munin::plugins::base {
250     munin::plugin::deploy { "tinydns": }
251 }
252
253 class munin::plugins::apache inherits munin::plugins::base {
254     munin::plugin{ "apache_accesses": }
255     munin::plugin{ "apache_processes": }
256     munin::plugin{ "apache_volume": }
257     munin::plugin::deploy { "apache_activity": }
258 }
259
260 class munin::plugins::selinux inherits munin::plugins::base {
261     munin::plugin::deploy { "selinuxenforced": }
262     munin::plugin::deploy { "selinux_avcstats": }
263 }
264
265 class munin::plugins::squid inherits munin::plugins::base {
266     munin::plugin{ 'squid_cache': config => "user root\nenv.squidhost localhost\nenv.squidport 80"}
267     munin::plugin{ 'squid_icp': }
268     munin::plugin{ 'squid_requests': }
269     munin::plugin{ 'squid_traffic': }
270 }
271
272 class munin::plugins::postgres inherits munin::plugins::base {
273     munin::plugin::deploy { "pg_conn": }
274     munin::plugin::deploy { "pg__connections": ensure => 'absent' }
275     munin::plugin::deploy { "pg__locks": ensure => 'absent' }
276 }
277 class munin::plugins::nagios inherits munin::plugins::base {
278     munin::plugin::deploy {
279         nagios_hosts: config => 'user root';
280         nagios_svc: config => 'user root';
281         nagios_perf_hosts: ensure => nagios_perf_, config => 'user root';
282         nagios_perf_svc: ensure => nagios_perf_, config => 'user root';
283     }
284 }