From 910e3379457143781e814d64ea8251a61e6675ef Mon Sep 17 00:00:00 2001 From: Sebastian Harl Date: Thu, 21 Aug 2008 10:45:43 +0200 Subject: [PATCH] perl plugin, Collectd.pm: Added support for flushing of specific identifiers. plugin_flush() now accepts three parameters, 'timeout', 'plugins' and 'identifiers'. The meaning of the former two did not change. 'identifiers' may be a string or an array of strings specifying identifiers that are to be passed along to the plugins' flush callbacks. This brings the Perl API in sync with the C API. plugin_flush_one() and plugin_flush_all() have been re-implemented in plain Perl and marked as deprecated. A new XSUB, Collectd::_plugin_flush, has been added which provides a small wrapper around the C implementation of plugin_flush(). Signed-off-by: Sebastian Harl Signed-off-by: Florian Forster --- bindings/perl/Collectd.pm | 65 +++++++++++++++++++++++++++++++++++++++++------ src/collectd-perl.pod | 21 +++++++++++---- src/perl.c | 63 ++++++++++++++++++++------------------------- 3 files changed, 101 insertions(+), 48 deletions(-) diff --git a/bindings/perl/Collectd.pm b/bindings/perl/Collectd.pm index afe92b2c..bfc30805 100644 --- a/bindings/perl/Collectd.pm +++ b/bindings/perl/Collectd.pm @@ -305,28 +305,77 @@ sub plugin_flush { my %args = @_; my $timeout = -1; + my @plugins = (); + my @ids = (); DEBUG ("Collectd::plugin_flush:" . (defined ($args{'timeout'}) ? " timeout = $args{'timeout'}" : "") - . (defined ($args{'plugins'}) ? " plugins = $args{'plugins'}" : "")); + . (defined ($args{'plugins'}) ? " plugins = $args{'plugins'}" : "") + . (defined ($args{'identifiers'}) + ? " identifiers = $args{'identifiers'}" : "")); if (defined ($args{'timeout'}) && ($args{'timeout'} > 0)) { $timeout = $args{'timeout'}; } - if (! defined $args{'plugins'}) { - plugin_flush_all ($timeout); + if (defined ($args{'plugins'})) { + if ("ARRAY" eq ref ($args{'plugins'})) { + @plugins = @{$args{'plugins'}}; + } + else { + @plugins = ($args{'plugins'}); + } } else { - if ("ARRAY" eq ref ($args{'plugins'})) { - foreach my $plugin (@{$args{'plugins'}}) { - plugin_flush_one ($timeout, $plugin); - } + @plugins = (undef); + } + + if (defined ($args{'identifiers'})) { + if ("ARRAY" eq ref ($args{'identifiers'})) { + @ids = @{$args{'identifiers'}}; } else { - plugin_flush_one ($timeout, $args{'plugins'}); + @ids = ($args{'identifiers'}); } } + else { + @ids = (undef); + } + + foreach my $plugin (@plugins) { + foreach my $id (@ids) { + _plugin_flush($plugin, $timeout, $id); + } + } +} + +sub plugin_flush_one { + my $timeout = shift; + my $name = shift; + + WARNING ("Collectd::plugin_flush_one is deprecated - " + . "use Collectd::plugin_flush instead."); + + if (! (defined ($timeout) && defined ($name))) { + ERROR ("Usage: Collectd::plugin_flush_one(timeout, name)"); + return; + } + + plugin_flush (plugins => $name, timeout => $timeout); +} + +sub plugin_flush_all { + my $timeout = shift; + + WARNING ("Collectd::plugin_flush_all is deprecated - " + . "use Collectd::plugin_flush instead."); + + if (! defined ($timeout)) { + ERROR ("Usage: Collectd::plugin_flush_all(timeout)"); + return; + } + + plugin_flush (timeout => $timeout); } 1; diff --git a/src/collectd-perl.pod b/src/collectd-perl.pod index b7ae9cac..6396bc8e 100644 --- a/src/collectd-perl.pod +++ b/src/collectd-perl.pod @@ -299,22 +299,33 @@ as the first argument to B. This syntax is still supported for backwards compatibility but has been deprecated and will be removed in some future version of collectd. -=item B ([B => I,] [B => I<...>]) +=item B ([B => I][, B => I<...>][, +B => I<...>]) -Flush one or more plugins. I is passed on to the registered -flush-callbacks. If omitted, C<-1> is used. If the I argument has -been specified, only named plugins will be flushed. The argument's value may -either be a string or a reference to an array of strings. +Flush one or more plugins. I and the specified I are +passed on to the registered flush-callbacks. If omitted, the timeout defaults +to C<-1>. The identifier defaults to the undefined value. If the I +argument has been specified, only named plugins will be flushed. The value of +the B and B arguments may either be a string or a +reference to an array of strings. =item B (I, I) This is identical to using "plugin_flush (timeout =E I, plugins =E I". +B: Starting with version 4.5 of collectd, B has been +deprecated and will be removed in some future version of collectd. Use +B instead. + =item B (I) This is identical to using "plugin_flush (timeout =E I)". +B: Starting with version 4.5 of collectd, B has been +deprecated and will be removed in some future version of collectd. Use +B instead. + =item B (I) Submits a I to the daemon which will then pass it to all diff --git a/src/perl.c b/src/perl.c index 268e1d14..e6bb25ef 100644 --- a/src/perl.c +++ b/src/perl.c @@ -84,8 +84,7 @@ void boot_DynaLoader (PerlInterpreter *, CV *); static XS (Collectd_plugin_register_ds); static XS (Collectd_plugin_unregister_ds); static XS (Collectd_plugin_dispatch_values); -static XS (Collectd_plugin_flush_one); -static XS (Collectd_plugin_flush_all); +static XS (Collectd__plugin_flush); static XS (Collectd_plugin_dispatch_notification); static XS (Collectd_plugin_log); static XS (Collectd_call_by_name); @@ -139,8 +138,7 @@ static struct { { "Collectd::plugin_register_data_set", Collectd_plugin_register_ds }, { "Collectd::plugin_unregister_data_set", Collectd_plugin_unregister_ds }, { "Collectd::plugin_dispatch_values", Collectd_plugin_dispatch_values }, - { "Collectd::plugin_flush_one", Collectd_plugin_flush_one }, - { "Collectd::plugin_flush_all", Collectd_plugin_flush_all }, + { "Collectd::_plugin_flush", Collectd__plugin_flush }, { "Collectd::plugin_dispatch_notification", Collectd_plugin_dispatch_notification }, { "Collectd::plugin_log", Collectd_plugin_log }, @@ -918,52 +916,47 @@ static XS (Collectd_plugin_dispatch_values) } /* static XS (Collectd_plugin_dispatch_values) */ /* - * Collectd::plugin_flush_one (timeout, name). + * Collectd::_plugin_flush (plugin, timeout, identifier). + * + * plugin: + * name of the plugin to flush * * timeout: * timeout to use when flushing the data * - * name: - * name of the plugin to flush + * identifier: + * data-set identifier to flush */ -static XS (Collectd_plugin_flush_one) +static XS (Collectd__plugin_flush) { + char *plugin = NULL; + int timeout = -1; + char *id = NULL; + dXSARGS; - if (2 != items) { - log_err ("Usage: Collectd::plugin_flush_one(timeout, name)"); + if (3 != items) { + log_err ("Usage: Collectd::_plugin_flush(plugin, timeout, id)"); XSRETURN_EMPTY; } - log_debug ("Collectd::plugin_flush_one: timeout = %i, name = \"%s\"", - (int)SvIV (ST (0)), SvPV_nolen (ST (1))); + if (SvOK (ST (0))) + plugin = SvPV_nolen (ST (0)); - if (0 == plugin_flush_one ((int)SvIV (ST (0)), SvPV_nolen (ST (1)))) - XSRETURN_YES; - else - XSRETURN_EMPTY; -} /* static XS (Collectd_plugin_flush_one) */ - -/* - * Collectd::plugin_flush_all (timeout). - * - * timeout: - * timeout to use when flushing the data - */ -static XS (Collectd_plugin_flush_all) -{ - dXSARGS; + if (SvOK (ST (1))) + timeout = (int)SvIV (ST (1)); - if (1 != items) { - log_err ("Usage: Collectd::plugin_flush_all(timeout)"); - XSRETURN_EMPTY; - } + if (SvOK (ST (2))) + id = SvPV_nolen (ST (2)); - log_debug ("Collectd::plugin_flush_all: timeout = %i", (int)SvIV (ST (0))); + log_debug ("Collectd::_plugin_flush: plugin = \"%s\", timeout = %i, " + "id = \"%s\"", plugin, timeout, id); - plugin_flush_all ((int)SvIV (ST (0))); - XSRETURN_YES; -} /* static XS (Collectd_plugin_flush_all) */ + if (0 == plugin_flush (plugin, timeout, id)) + XSRETURN_YES; + else + XSRETURN_EMPTY; +} /* static XS (Collectd__plugin_flush) */ /* * Collectd::plugin_dispatch_notification (notif). -- 2.11.0