- filecount
Count the number of files in directories.
+ - gmond
+ Receive multicast traffic from Ganglia instances.
+
- hddtemp
Harddisk temperatures using hddtempd.
- processes
Process counts: Number of running, sleeping, zombie, ... processes.
+ - protocols
+ Counts various aspects of network protocols such as IP, TCP, UDP, etc.
+
- rrdcached
RRDtool caching daemon (RRDcacheD) statistics.
- teamspeak2
TeamSpeak2 server statistics.
+ - ted
+ Plugin to read values from `The Energy Detective' (TED).
+
- thermal
Linux ACPI thermal zone information.
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/Collectd.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Java API to internal functions of collectd.
+ *
+ * All functions in this class are {@code static}. You don't need to create an
+ * object of this class (in fact, you can't). Just call these functions
+ * directly.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ */
+public class Collectd
+{
+
+ /**
+ * Constant for severity (log level) "error".
+ *
+ * @see CollectdLogInterface
+ */
+ public static final int LOG_ERR = 3;
+
+ /**
+ * Constant for severity (log level) "warning".
+ *
+ * @see CollectdLogInterface
+ */
+ public static final int LOG_WARNING = 4;
+
+ /**
+ * Constant for severity (log level) "notice".
+ *
+ * @see CollectdLogInterface
+ */
+ public static final int LOG_NOTICE = 5;
+
+ /**
+ * Constant for severity (log level) "info".
+ *
+ * @see CollectdLogInterface
+ */
+ public static final int LOG_INFO = 6;
+
+ /**
+ * Constant for severity (log level) "debug".
+ *
+ * @see CollectdLogInterface
+ */
+ public static final int LOG_DEBUG = 7;
+
+ /**
+ * Return value of match methods: No match.
+ *
+ * This is one of two valid return values from match callbacks, indicating
+ * that the passed {@link DataSet} and {@link ValueList} did not match.
+ *
+ * Do not use the numeric value directly, it is subject to change without
+ * notice!
+ *
+ * @see CollectdMatchInterface
+ */
+ public static final int FC_MATCH_NO_MATCH = 0;
+
+ /**
+ * Return value of match methods: Match.
+ *
+ * This is one of two valid return values from match callbacks, indicating
+ * that the passed {@link DataSet} and {@link ValueList} did match.
+ *
+ * Do not use the numeric value directly, it is subject to change without
+ * notice!
+ *
+ * @see CollectdMatchInterface
+ */
+ public static final int FC_MATCH_MATCHES = 1;
+
+ /**
+ * Return value of target methods: Continue.
+ *
+ * This is one of three valid return values from target callbacks, indicating
+ * that processing of the {@link ValueList} should continue.
+ *
+ * Do not use the numeric value directly, it is subject to change without
+ * notice!
+ *
+ * @see CollectdTargetInterface
+ */
+ public static final int FC_TARGET_CONTINUE = 0;
+
+ /**
+ * Return value of target methods: Stop.
+ *
+ * This is one of three valid return values from target callbacks, indicating
+ * that processing of the {@link ValueList} should stop immediately.
+ *
+ * Do not use the numeric value directly, it is subject to change without
+ * notice!
+ *
+ * @see CollectdTargetInterface
+ */
+ public static final int FC_TARGET_STOP = 1;
+
+ /**
+ * Return value of target methods: Return.
+ *
+ * This is one of three valid return values from target callbacks, indicating
+ * that processing of the current chain should be stopped and processing of
+ * the {@link ValueList} should continue in the calling chain.
+ *
+ * Do not use the numeric value directly, it is subject to change without
+ * notice!
+ *
+ * @see CollectdTargetInterface
+ */
+ public static final int FC_TARGET_RETURN = 2;
+
+ /**
+ * Java representation of collectd/src/plugin.h:plugin_register_config
+ *
+ * @return Zero when successful, non-zero otherwise.
+ * @see CollectdConfigInterface
+ */
+ native public static int registerConfig (String name,
+ CollectdConfigInterface object);
+
+ /**
+ * Java representation of collectd/src/plugin.h:plugin_register_init
+ *
+ * @return Zero when successful, non-zero otherwise.
+ * @see CollectdInitInterface
+ */
+ native public static int registerInit (String name,
+ CollectdInitInterface object);
+
+ /**
+ * Java representation of collectd/src/plugin.h:plugin_register_read
+ *
+ * @return Zero when successful, non-zero otherwise.
+ * @see CollectdReadInterface
+ */
+ native public static int registerRead (String name,
+ CollectdReadInterface object);
+
+ /**
+ * Java representation of collectd/src/plugin.h:plugin_register_write
+ *
+ * @return Zero when successful, non-zero otherwise.
+ * @see CollectdWriteInterface
+ */
+ native public static int registerWrite (String name,
+ CollectdWriteInterface object);
+
+ /**
+ * Java representation of collectd/src/plugin.h:plugin_register_flush
+ *
+ * @return Zero when successful, non-zero otherwise.
+ * @see CollectdFlushInterface
+ */
+ native public static int registerFlush (String name,
+ CollectdFlushInterface object);
+
+ /**
+ * Java representation of collectd/src/plugin.h:plugin_register_shutdown
+ *
+ * @return Zero when successful, non-zero otherwise.
+ * @see CollectdShutdownInterface
+ */
+ native public static int registerShutdown (String name,
+ CollectdShutdownInterface object);
+
+ /**
+ * Java representation of collectd/src/plugin.h:plugin_register_log
+ *
+ * @return Zero when successful, non-zero otherwise.
+ * @see CollectdLogInterface
+ */
+ native public static int registerLog (String name,
+ CollectdLogInterface object);
+
+ /**
+ * Java representation of collectd/src/plugin.h:plugin_register_notification
+ *
+ * @return Zero when successful, non-zero otherwise.
+ * @see CollectdNotificationInterface
+ */
+ native public static int registerNotification (String name,
+ CollectdNotificationInterface object);
+
+ /**
+ * Java representation of collectd/src/filter_chain.h:fc_register_match
+ *
+ * @return Zero when successful, non-zero otherwise.
+ * @see CollectdMatchFactoryInterface
+ */
+ native public static int registerMatch (String name,
+ CollectdMatchFactoryInterface object);
+
+ /**
+ * Java representation of collectd/src/filter_chain.h:fc_register_target
+ *
+ * @return Zero when successful, non-zero otherwise.
+ * @see CollectdTargetFactoryInterface
+ */
+ native public static int registerTarget (String name,
+ CollectdTargetFactoryInterface object);
+
+ /**
+ * Java representation of collectd/src/plugin.h:plugin_dispatch_values
+ *
+ * @return Zero when successful, non-zero otherwise.
+ */
+ native public static int dispatchValues (ValueList vl);
+
+ /**
+ * Java representation of collectd/src/plugin.h:plugin_dispatch_notification
+ *
+ * @return Zero when successful, non-zero otherwise.
+ */
+ native public static int dispatchNotification (Notification n);
+
+ /**
+ * Java representation of collectd/src/plugin.h:plugin_get_ds
+ *
+ * @return The appropriate {@link DataSet} object or {@code null} if no such
+ * type is registered.
+ */
+ native public static DataSet getDS (String type);
+
+ /**
+ * Java representation of collectd/src/plugin.h:plugin_log
+ */
+ native private static void log (int severity, String message);
+
+ /**
+ * Prints an error message.
+ */
+ public static void logError (String message)
+ {
+ log (LOG_ERR, message);
+ } /* void logError */
+
+ /**
+ * Prints a warning message.
+ */
+ public static void logWarning (String message)
+ {
+ log (LOG_WARNING, message);
+ } /* void logWarning */
+
+ /**
+ * Prints a notice.
+ */
+ public static void logNotice (String message)
+ {
+ log (LOG_NOTICE, message);
+ } /* void logNotice */
+
+ /**
+ * Prints an info message.
+ */
+ public static void logInfo (String message)
+ {
+ log (LOG_INFO, message);
+ } /* void logInfo */
+
+ /**
+ * Prints a debug message.
+ */
+ public static void logDebug (String message)
+ {
+ log (LOG_DEBUG, message);
+ } /* void logDebug */
+} /* class Collectd */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/CollectdConfigInterface.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a config method.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ * @see Collectd#registerConfig(String, CollectdConfigInterface)
+ */
+public interface CollectdConfigInterface
+{
+ public int config (OConfigItem ci);
+}
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/CollectdFlushInterface.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a flush method.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ * @see Collectd#registerFlush
+ */
+public interface CollectdFlushInterface
+{
+ public int flush (int timeout, String identifier);
+}
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/CollectdInitInterface.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing an init method.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ * @see Collectd#registerInit
+ */
+public interface CollectdInitInterface
+{
+ public int init ();
+}
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/CollectdLogInterface.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a log method.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ * @see Collectd#registerLog
+ */
+public interface CollectdLogInterface
+{
+ public void log (int severity, String message);
+}
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/CollectdMatchFactoryInterface.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a "match factory".
+ *
+ * Objects implementing this interface are used to create objects implementing
+ * the CollectdMatchInterface interface.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ * @see CollectdMatchInterface
+ * @see Collectd#registerMatch
+ */
+public interface CollectdMatchFactoryInterface
+{
+ /**
+ * Create a new "match" object.
+ *
+ * This method uses the configuration provided as argument to create a
+ * new object which must implement the {@link CollectdMatchInterface}
+ * interface.
+ *
+ * This function corresponds to the <code>create</code> member of the
+ * <code>src/filter_chain.h:match_proc_t</code> struct.
+ *
+ * @return New {@link CollectdMatchInterface} object.
+ */
+ public CollectdMatchInterface createMatch (OConfigItem ci);
+}
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/CollectdMatchInterface.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a match method.
+ *
+ * These objects are instantiated using objects which implement the
+ * CollectdMatchFactoryInterface interface. They are not instantiated by the
+ * daemon directly!
+ *
+ * @author Florian Forster <octo at verplant.org>
+ * @see CollectdMatchFactoryInterface
+ * @see Collectd#registerMatch
+ */
+public interface CollectdMatchInterface
+{
+ /**
+ * Callback method for matches.
+ *
+ * This method is called to decide whether or not a given ValueList
+ * matches or not. How this is determined is the is the main part of
+ * this function.
+ *
+ * @return One of {@link Collectd#FC_MATCH_NO_MATCH} and {@link Collectd#FC_MATCH_MATCHES}.
+ * @see CollectdMatchFactoryInterface
+ */
+ public int match (DataSet ds, ValueList vl);
+} /* public interface CollectdMatchInterface */
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/CollectdNotificationInterface.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a notification method.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ * @see Collectd#registerNotification
+ */
+public interface CollectdNotificationInterface
+{
+ public int notification (Notification n);
+}
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/CollectdReadInterface.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a read method.
+ *
+ * Objects implementing this interface can be registered with the daemon. Their
+ * read method is then called periodically to acquire and submit values.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ * @see Collectd#registerRead
+ */
+public interface CollectdReadInterface
+{
+ /**
+ * Callback method for read plugins.
+ *
+ * This method is called once every few seconds (depends on the
+ * configuration of the daemon). It is supposed to gather values in
+ * some way and submit them to the daemon using
+ * {@link Collectd#dispatchValues}.
+ *
+ * @return zero when successful, non-zero when an error occurred.
+ * @see Collectd#dispatchValues
+ */
+ public int read ();
+}
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/CollectdShutdownInterface.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a shutdown method.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ * @see Collectd#registerShutdown
+ */
+public interface CollectdShutdownInterface
+{
+ public int shutdown ();
+}
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/CollectdTargetFactoryInterface.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a "target factory".
+ *
+ * Objects implementing this interface are used to create objects implementing
+ * the CollectdTargetInterface interface.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ * @see CollectdTargetInterface
+ * @see Collectd#registerTarget
+ */
+public interface CollectdTargetFactoryInterface
+{
+ /**
+ * Create a new "target" object.
+ *
+ * This method uses the configuration provided as argument to create a
+ * new object which must implement the {@link CollectdTargetInterface}
+ * interface.
+ *
+ * This function corresponds to the {@code create} member of the
+ * {@code src/filter_chain.h:target_proc_t} struct.
+ *
+ * @return New {@link CollectdTargetInterface} object.
+ */
+ public CollectdTargetInterface createTarget (OConfigItem ci);
+}
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/CollectdTargetInterface.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a target method.
+ *
+ * These objects are instantiated using objects which implement the
+ * CollectdTargetFactoryInterface interface. They are not instantiated by the
+ * daemon directly!
+ *
+ * @author Florian Forster <octo at verplant.org>
+ * @see CollectdTargetFactoryInterface
+ * @see Collectd#registerTarget
+ */
+public interface CollectdTargetInterface
+{
+ /**
+ * Callback method for targets.
+ *
+ * This method is called to perform some action on the given ValueList.
+ * What precisely is done depends entirely on the implementing class.
+ *
+ * @return One of: {@link Collectd#FC_TARGET_CONTINUE},
+ * {@link Collectd#FC_TARGET_STOP}, {@link Collectd#FC_TARGET_RETURN}
+ * @see CollectdTargetFactoryInterface
+ */
+ public int invoke (DataSet ds, ValueList vl);
+} /* public interface CollectdTargetInterface */
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/CollectdWriteInterface.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Interface for objects implementing a write method.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ * @see Collectd#registerWrite
+ */
+public interface CollectdWriteInterface
+{
+ public int write (ValueList vl);
+}
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/OConfigItem.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+import java.util.List;
+import java.util.ArrayList;
+
+/**
+ * Java representation of collectd/src/plugin.h:data_set_t structure.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ */
+public class DataSet
+{
+ private String _type;
+ private List<DataSource> _ds;
+
+ private DataSet ()
+ {
+ this._type = null;
+ this._ds = new ArrayList<DataSource> ();
+ }
+
+ public DataSet (String type)
+ {
+ this._type = type;
+ this._ds = new ArrayList<DataSource> ();
+ }
+
+ public DataSet (String type, DataSource dsrc)
+ {
+ this._type = type;
+ this._ds = new ArrayList<DataSource> ();
+ this._ds.add (dsrc);
+ }
+
+ public DataSet (String type, List<DataSource> ds)
+ {
+ this._type = type;
+ this._ds = ds;
+ }
+
+ public void setType (String type)
+ {
+ this._type = type;
+ }
+
+ public String getType ()
+ {
+ return (this._type);
+ }
+
+ public void addDataSource (DataSource dsrc)
+ {
+ this._ds.add (dsrc);
+ }
+
+ public List<DataSource> getDataSources ()
+ {
+ return (this._ds);
+ }
+
+ public String toString ()
+ {
+ StringBuffer sb = new StringBuffer ();
+ int i;
+
+ sb.append (this._type);
+ for (i = 0; i < this._ds.size (); i++)
+ {
+ if (i == 0)
+ sb.append ("\t");
+ else
+ sb.append (", ");
+ sb.append (this._ds.get (i).toString ());
+ }
+
+ return (sb.toString ());
+ }
+
+ static public DataSet parseDataSet (String str)
+ {
+ DataSet ds = new DataSet ();
+ String[] fields;
+ int i;
+
+ str = str.trim();
+ if (str.length() == 0) {
+ return (null);
+ }
+ if (str.charAt(0) == '#') {
+ return (null);
+ }
+
+ fields = str.split ("\\s+");
+ if (fields.length < 2)
+ return (null);
+
+ ds._type = fields[0];
+
+ for (i = 1; i < fields.length; i++) {
+ DataSource dsrc;
+
+ dsrc = DataSource.parseDataSource (fields[i]);
+ if (dsrc == null)
+ break;
+
+ ds._ds.add (dsrc);
+ }
+
+ if (i < fields.length)
+ return (null);
+
+ return (ds);
+ } /* DataSet parseDataSet */
+} /* class DataSet */
+
+/* vim: set sw=4 sts=4 et : */
--- /dev/null
+/*
+ * jcollectd
+ * Copyright (C) 2009 Hyperic, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package org.collectd.api;
+
+/**
+ * Java representation of collectd/src/plugin.h:data_source_t structure.
+ */
+public class DataSource {
+ public static final int TYPE_COUNTER = 0;
+ public static final int TYPE_GAUGE = 1;
+
+ static final String COUNTER = "COUNTER";
+ static final String GAUGE = "GAUGE";
+
+ static final String NAN = "U";
+ private static final String[] TYPES = { COUNTER, GAUGE };
+
+ String _name;
+ int _type;
+ double _min;
+ double _max;
+
+ public DataSource (String name, int type, double min, double max) {
+ this._name = name;
+ this._type = TYPE_GAUGE;
+ if (type == TYPE_COUNTER)
+ this._type = TYPE_COUNTER;
+ this._min = min;
+ this._max = max;
+ }
+
+ /* Needed in parseDataSource below. Other code should use the above
+ * constructor or `parseDataSource'. */
+ private DataSource () {
+ this._type = TYPE_GAUGE;
+ }
+
+ public String getName() {
+ return _name;
+ }
+
+ public void setName(String name) {
+ _name = name;
+ }
+
+ public int getType() {
+ return _type;
+ }
+
+ public void setType(int type) {
+ _type = type;
+ }
+
+ public double getMin() {
+ return _min;
+ }
+
+ public void setMin(double min) {
+ _min = min;
+ }
+
+ public double getMax() {
+ return _max;
+ }
+
+ public void setMax(double max) {
+ _max = max;
+ }
+
+ static double toDouble(String val) {
+ if (val.equals(NAN)) {
+ return Double.NaN;
+ }
+ else {
+ return Double.parseDouble(val);
+ }
+ }
+
+ private String asString(double val) {
+ if (Double.isNaN(val)) {
+ return NAN;
+ }
+ else {
+ return String.valueOf(val);
+ }
+ }
+
+ public String toString() {
+ StringBuffer sb = new StringBuffer();
+ final char DLM = ':';
+ sb.append(_name).append(DLM);
+ sb.append(TYPES[_type]).append(DLM);
+ sb.append(asString(_min)).append(DLM);
+ sb.append(asString(_max));
+ return sb.toString();
+ }
+
+ static public DataSource parseDataSource (String str)
+ {
+ String[] fields;
+ int str_len = str.length ();
+ DataSource dsrc = new DataSource ();
+
+ /* Ignore trailing commas. This makes it easier for parsing code. */
+ if (str.charAt (str_len - 1) == ',') {
+ str = str.substring (0, str_len - 1);
+ }
+
+ fields = str.split(":");
+ if (fields.length != 4)
+ return (null);
+
+ dsrc._name = fields[0];
+
+ if (fields[1].equals (DataSource.GAUGE)) {
+ dsrc._type = TYPE_GAUGE;
+ }
+ else {
+ dsrc._type = TYPE_COUNTER;
+ }
+
+ dsrc._min = toDouble (fields[2]);
+ dsrc._max = toDouble (fields[3]);
+
+ return (dsrc);
+ } /* DataSource parseDataSource */
+}
+
+/* vim: set sw=4 sts=4 et : */
--- /dev/null
+/*
+ * jcollectd
+ * Copyright (C) 2009 Hyperic, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package org.collectd.api;
+
+/**
+ * Java representation of collectd/src/plugin.h:notfication_t structure.
+ */
+public class Notification extends PluginData {
+ public static final int FAILURE = 1;
+ public static final int WARNING = 2;
+ public static final int OKAY = 4;
+
+ public static String[] SEVERITY = {
+ "FAILURE",
+ "WARNING",
+ "OKAY",
+ "UNKNOWN"
+ };
+
+ private int _severity;
+ private String _message;
+
+ public Notification () {
+ _severity = 0;
+ _message = "Initial notification message";
+ }
+
+ public Notification (PluginData pd) {
+ super (pd);
+ _severity = 0;
+ _message = "Initial notification message";
+ }
+
+ public void setSeverity (int severity) {
+ if ((severity == FAILURE)
+ || (severity == WARNING)
+ || (severity == OKAY))
+ this._severity = severity;
+ }
+
+ public int getSeverity() {
+ return _severity;
+ }
+
+ public String getSeverityString() {
+ switch (_severity) {
+ case FAILURE:
+ return SEVERITY[0];
+ case WARNING:
+ return SEVERITY[1];
+ case OKAY:
+ return SEVERITY[2];
+ default:
+ return SEVERITY[3];
+ }
+ }
+
+ public void setMessage (String message) {
+ this._message = message;
+ }
+
+ public String getMessage() {
+ return _message;
+ }
+
+ public String toString() {
+ StringBuffer sb = new StringBuffer(super.toString());
+ sb.append(" [").append(getSeverityString()).append("] ");
+ sb.append(_message);
+ return sb.toString();
+ }
+}
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/OConfigItem.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+import java.util.List;
+import java.util.ArrayList;
+
+/**
+ * Java representation of collectd/src/liboconfig/oconfig.h:oconfig_item_t structure.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ */
+public class OConfigItem
+{
+ private String _key = null;
+ private List<OConfigValue> _values = new ArrayList<OConfigValue> ();
+ private List<OConfigItem> _children = new ArrayList<OConfigItem> ();
+
+ public OConfigItem (String key)
+ {
+ _key = key;
+ } /* OConfigItem (String key) */
+
+ public String getKey ()
+ {
+ return (_key);
+ } /* String getKey () */
+
+ public void addValue (OConfigValue cv)
+ {
+ _values.add (cv);
+ } /* void addValue (OConfigValue cv) */
+
+ public void addValue (String s)
+ {
+ _values.add (new OConfigValue (s));
+ } /* void addValue (String s) */
+
+ public void addValue (Number n)
+ {
+ _values.add (new OConfigValue (n));
+ } /* void addValue (String s) */
+
+ public void addValue (boolean b)
+ {
+ _values.add (new OConfigValue (b));
+ } /* void addValue (String s) */
+
+ public List<OConfigValue> getValues ()
+ {
+ return (_values);
+ } /* List<OConfigValue> getValues () */
+
+ public void addChild (OConfigItem ci)
+ {
+ _children.add (ci);
+ } /* void addChild (OConfigItem ci) */
+
+ public List<OConfigItem> getChildren ()
+ {
+ return (_children);
+ } /* List<OConfigItem> getChildren () */
+
+ public String toString ()
+ {
+ return (new String ("{ key: " + _key + "; "
+ + "values: " + _values.toString () + "; "
+ + "children: " + _children.toString () + "; }"));
+ } /* String toString () */
+} /* class OConfigItem */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
--- /dev/null
+/*
+ * collectd/java - org/collectd/api/OConfigValue.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.api;
+
+/**
+ * Java representation of collectd/src/liboconfig/oconfig.h:oconfig_value_t structure.
+ *
+ * @author Florian Forster <octo at verplant.org>
+ */
+public class OConfigValue
+{
+ public static final int OCONFIG_TYPE_STRING = 0;
+ public static final int OCONFIG_TYPE_NUMBER = 1;
+ public static final int OCONFIG_TYPE_BOOLEAN = 2;
+
+ private int _type;
+ private String _value_string;
+ private Number _value_number;
+ private boolean _value_boolean;
+
+ public OConfigValue (String s)
+ {
+ _type = OCONFIG_TYPE_STRING;
+ _value_string = s;
+ _value_number = null;
+ _value_boolean = false;
+ } /* OConfigValue (String s) */
+
+ public OConfigValue (Number n)
+ {
+ _type = OCONFIG_TYPE_NUMBER;
+ _value_string = null;
+ _value_number = n;
+ _value_boolean = false;
+ } /* OConfigValue (String s) */
+
+ public OConfigValue (boolean b)
+ {
+ _type = OCONFIG_TYPE_BOOLEAN;
+ _value_string = null;
+ _value_number = null;
+ _value_boolean = b;
+ } /* OConfigValue (String s) */
+
+ public int getType ()
+ {
+ return (_type);
+ } /* int getType */
+
+ public String getString ()
+ {
+ return (_value_string);
+ } /* String getString */
+
+ public Number getNumber ()
+ {
+ return (_value_number);
+ } /* String getString */
+
+ public boolean getBoolean ()
+ {
+ return (_value_boolean);
+ } /* String getString */
+
+ public String toString ()
+ {
+ if (_type == OCONFIG_TYPE_STRING)
+ return (_value_string);
+ else if (_type == OCONFIG_TYPE_NUMBER)
+ return (_value_number.toString ());
+ else if (_type == OCONFIG_TYPE_BOOLEAN)
+ return (Boolean.toString (_value_boolean));
+ return (null);
+ } /* String toString () */
+} /* class OConfigValue */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
--- /dev/null
+/*
+ * jcollectd
+ * Copyright (C) 2009 Hyperic, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package org.collectd.api;
+
+import java.util.Date;
+
+/**
+ * Shared members of value_list_t and notification_t structures.
+ */
+public class PluginData {
+
+ protected long _time = 0;
+ protected String _host;
+ protected String _plugin;
+ protected String _pluginInstance = "";
+ protected String _type = "";
+ protected String _typeInstance = "";
+
+ public PluginData() {
+
+ }
+
+ public PluginData(PluginData pd) {
+ _time = pd._time;
+ _host = pd._host;
+ _plugin = pd._plugin;
+ _pluginInstance = pd._pluginInstance;
+ _type = pd._type;
+ _typeInstance = pd._typeInstance;
+ }
+
+ public long getTime() {
+ return _time;
+ }
+
+ public void setTime(long time) {
+ _time = time;
+ }
+
+ public String getHost() {
+ return _host;
+ }
+
+ public void setHost(String host) {
+ _host = host;
+ }
+
+ public String getPlugin() {
+ return _plugin;
+ }
+
+ public void setPlugin(String plugin) {
+ _plugin = plugin;
+ }
+
+ public String getPluginInstance() {
+ return _pluginInstance;
+ }
+
+ public void setPluginInstance(String pluginInstance) {
+ _pluginInstance = pluginInstance;
+ }
+
+ public String getType() {
+ return _type;
+ }
+
+ public void setType(String type) {
+ _type = type;
+ }
+
+ public String getTypeInstance() {
+ return _typeInstance;
+ }
+
+ public void setTypeInstance(String typeInstance) {
+ _typeInstance = typeInstance;
+ }
+
+ public boolean defined(String val) {
+ return (val != null) && (val.length() > 0);
+ }
+
+ public String getSource() {
+ final char DLM = '/';
+ StringBuffer sb = new StringBuffer();
+ if (defined(_host)) {
+ sb.append(_host);
+ }
+ if (defined(_plugin)) {
+ sb.append(DLM).append(_plugin);
+ }
+ if (defined(_pluginInstance)) {
+ sb.append(DLM).append(_pluginInstance);
+ }
+ if (defined(_type)) {
+ sb.append(DLM).append(_type);
+ }
+ if (defined(_typeInstance)) {
+ sb.append(DLM).append(_typeInstance);
+ }
+ return sb.toString();
+ }
+
+ public String toString() {
+ StringBuffer sb = new StringBuffer();
+ sb.append('[').append(new Date(_time)).append("] ");
+ sb.append(getSource());
+ return sb.toString();
+ }
+}
--- /dev/null
+/*
+ * jcollectd
+ * Copyright (C) 2009 Hyperic, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package org.collectd.api;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Java representation of collectd/src/plugin.h:value_list_t structure.
+ */
+public class ValueList extends PluginData {
+
+ private List<Number> _values = new ArrayList<Number>();
+ private DataSet _ds;
+
+ private long _interval = 0;
+
+ public ValueList() {
+
+ }
+
+ public ValueList(PluginData pd) {
+ super(pd);
+ }
+
+ public ValueList(ValueList vl) {
+ this((PluginData)vl);
+ _interval = vl._interval;
+ _values.addAll(vl.getValues());
+ _ds = vl._ds;
+ }
+
+ public List<Number> getValues() {
+ return _values;
+ }
+
+ public void setValues(List<Number> values) {
+ _values = values;
+ }
+
+ public void addValue(Number value) {
+ _values.add(value);
+ }
+
+ /* Used by the network parsing code */
+ public void clearValues () {
+ _values.clear ();
+ }
+
+ /**
+ * @deprecated Use {@link #getDataSet()} instead.
+ */
+ public List<DataSource> getDataSource() {
+ if (_ds == null)
+ return null;
+ return _ds.getDataSources ();
+ }
+
+ public DataSet getDataSet () {
+ return _ds;
+ }
+
+ public void setDataSet (DataSet ds) {
+ _ds = ds;
+ }
+
+ /**
+ * @deprecated Use {@link #setDataSet(DataSet)} instead.
+ */
+ public void setDataSource(List<DataSource> dsrc) {
+ _ds = new DataSet (_type, dsrc);
+ }
+
+ public long getInterval() {
+ return _interval;
+ }
+
+ public void setInterval(long interval) {
+ _interval = interval;
+ }
+
+ public String toString() {
+ StringBuffer sb = new StringBuffer(super.toString());
+ sb.append("=[");
+ List<DataSource> ds = getDataSource();
+ int size = _values.size();
+ for (int i=0; i<size; i++) {
+ Number val = _values.get(i);
+ String name;
+ if (ds == null) {
+ name = "unknown" + i;
+ }
+ else {
+ name = ds.get(i).getName();
+ }
+ sb.append(name).append('=').append(val);
+ if (i < size-1) {
+ sb.append(',');
+ }
+ }
+ sb.append("]");
+ return sb.toString();
+ }
+}
+
+/* vim: set sw=4 sts=4 et : */
--- /dev/null
+/*
+ * collectd/java - org/collectd/java/JMXMemory.java
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ */
+
+package org.collectd.java;
+
+import java.util.List;
+import java.util.Date;
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryUsage;
+import java.lang.management.MemoryMXBean;
+
+import javax.management.MBeanServerConnection;
+import javax.management.remote.JMXConnector;
+import javax.management.remote.JMXConnectorFactory;
+import javax.management.remote.JMXServiceURL;
+
+import org.collectd.api.Collectd;
+import org.collectd.api.DataSet;
+import org.collectd.api.ValueList;
+import org.collectd.api.Notification;
+import org.collectd.api.OConfigItem;
+
+import org.collectd.api.CollectdConfigInterface;
+import org.collectd.api.CollectdInitInterface;
+import org.collectd.api.CollectdReadInterface;
+import org.collectd.api.CollectdShutdownInterface;
+
+import org.collectd.api.OConfigValue;
+import org.collectd.api.OConfigItem;
+
+public class JMXMemory implements CollectdConfigInterface, /* {{{ */
+ CollectdInitInterface,
+ CollectdReadInterface,
+ CollectdShutdownInterface
+{
+ private String _jmx_service_url = null;
+ private MemoryMXBean _mbean = null;
+
+ public JMXMemory ()
+ {
+ Collectd.registerConfig ("JMXMemory", this);
+ Collectd.registerInit ("JMXMemory", this);
+ Collectd.registerRead ("JMXMemory", this);
+ Collectd.registerShutdown ("JMXMemory", this);
+ }
+
+ private void submit (String plugin_instance, MemoryUsage usage) /* {{{ */
+ {
+ ValueList vl;
+
+ long mem_init;
+ long mem_used;
+ long mem_committed;
+ long mem_max;
+
+ mem_init = usage.getInit ();
+ mem_used = usage.getUsed ();
+ mem_committed = usage.getCommitted ();
+ mem_max = usage.getMax ();
+
+ Collectd.logDebug ("JMXMemory plugin: plugin_instance = " + plugin_instance + "; "
+ + "mem_init = " + mem_init + "; "
+ + "mem_used = " + mem_used + "; "
+ + "mem_committed = " + mem_committed + "; "
+ + "mem_max = " + mem_max + ";");
+
+ vl = new ValueList ();
+
+ vl.setHost ("localhost");
+ vl.setPlugin ("JMXMemory");
+ vl.setPluginInstance (plugin_instance);
+ vl.setType ("memory");
+
+ if (mem_init >= 0)
+ {
+ vl.addValue (mem_init);
+ vl.setTypeInstance ("init");
+ Collectd.dispatchValues (vl);
+ vl.clearValues ();
+ }
+
+ if (mem_used >= 0)
+ {
+ vl.addValue (mem_used);
+ vl.setTypeInstance ("used");
+ Collectd.dispatchValues (vl);
+ vl.clearValues ();
+ }
+
+ if (mem_committed >= 0)
+ {
+ vl.addValue (mem_committed);
+ vl.setTypeInstance ("committed");
+ Collectd.dispatchValues (vl);
+ vl.clearValues ();
+ }
+
+ if (mem_max >= 0)
+ {
+ vl.addValue (mem_max);
+ vl.setTypeInstance ("max");
+ Collectd.dispatchValues (vl);
+ vl.clearValues ();
+ }
+ } /* }}} void submit */
+
+ private int configServiceURL (OConfigItem ci) /* {{{ */
+ {
+ List<OConfigValue> values;
+ OConfigValue cv;
+
+ values = ci.getValues ();
+ if (values.size () != 1)
+ {
+ Collectd.logError ("JMXMemory plugin: The JMXServiceURL option needs "
+ + "exactly one string argument.");
+ return (-1);
+ }
+
+ cv = values.get (0);
+ if (cv.getType () != OConfigValue.OCONFIG_TYPE_STRING)
+ {
+ Collectd.logError ("JMXMemory plugin: The JMXServiceURL option needs "
+ + "exactly one string argument.");
+ return (-1);
+ }
+
+ _jmx_service_url = cv.getString ();
+ return (0);
+ } /* }}} int configServiceURL */
+
+ public int config (OConfigItem ci) /* {{{ */
+ {
+ List<OConfigItem> children;
+ int i;
+
+ Collectd.logDebug ("JMXMemory plugin: config: ci = " + ci + ";");
+
+ children = ci.getChildren ();
+ for (i = 0; i < children.size (); i++)
+ {
+ OConfigItem child;
+ String key;
+
+ child = children.get (i);
+ key = child.getKey ();
+ if (key.equalsIgnoreCase ("JMXServiceURL"))
+ {
+ configServiceURL (child);
+ }
+ else
+ {
+ Collectd.logError ("JMXMemory plugin: Unknown config option: " + key);
+ }
+ }
+
+ return (0);
+ } /* }}} int config */
+
+ public int init () /* {{{ */
+ {
+ JMXServiceURL service_url;
+ JMXConnector connector;
+ MBeanServerConnection connection;
+
+ if (_jmx_service_url == null)
+ {
+ Collectd.logError ("JMXMemory: _jmx_service_url == null");
+ return (-1);
+ }
+
+ try
+ {
+ service_url = new JMXServiceURL (_jmx_service_url);
+ connector = JMXConnectorFactory.connect (service_url);
+ connection = connector.getMBeanServerConnection ();
+ _mbean = ManagementFactory.newPlatformMXBeanProxy (connection,
+ ManagementFactory.MEMORY_MXBEAN_NAME,
+ MemoryMXBean.class);
+ }
+ catch (Exception e)
+ {
+ Collectd.logError ("JMXMemory: Creating MBean failed: " + e);
+ return (-1);
+ }
+
+ return (0);
+ } /* }}} int init */
+
+ public int read () /* {{{ */
+ {
+ if (_mbean == null)
+ {
+ Collectd.logError ("JMXMemory: _mbean == null");
+ return (-1);
+ }
+
+ submit ("heap", _mbean.getHeapMemoryUsage ());
+ submit ("non_heap", _mbean.getNonHeapMemoryUsage ());
+
+ return (0);
+ } /* }}} int read */
+
+ public int shutdown () /* {{{ */
+ {
+ System.out.print ("org.collectd.java.JMXMemory.Shutdown ();\n");
+ _jmx_service_url = null;
+ _mbean = null;
+ return (0);
+ } /* }}} int shutdown */
+} /* }}} class JMXMemory */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
&& rm -f src/libping/config.h.in \
&& rm -f src/libping/Makefile \
&& rm -f src/libping/Makefile.in \
-&& rm -f src/libping/stamp-h2
+&& rm -f src/libping/stamp-h2 \
+&& rm -f -r src/libcollectdclient/.libs \
+&& rm -f src/libcollectdclient/*.o \
+&& rm -f src/libcollectdclient/*.la \
+&& rm -f src/libcollectdclient/*.lo
AM_CONDITIONAL(BUILD_WITH_LIBESMTP, test "x$with_libesmtp" = "xyes")
# }}}
+# --with-libganglia {{{
+AC_ARG_WITH(libganglia, [AS_HELP_STRING([--with-libganglia@<:@=PREFIX@:>@], [Path to libganglia.])],
+[
+ if test -f "$withval" && test -x "$withval"
+ then
+ with_libganglia_config="$withval"
+ with_libganglia="yes"
+ else if test -f "$withval/bin/ganglia-config" && test -x "$withval/bin/ganglia-config"
+ then
+ with_libganglia_config="$withval/bin/ganglia-config"
+ with_libganglia="yes"
+ else if test -d "$withval"
+ then
+ GANGLIA_CPPFLAGS="-I$withval/include"
+ GANGLIA_LDFLAGS="-L$withval/lib"
+ with_libganglia="yes"
+ else
+ with_libganglia_config="ganglia-config"
+ with_libganglia="$withval"
+ fi; fi; fi
+],
+[
+ with_libganglia_config="ganglia-config"
+ with_libganglia="yes"
+])
+
+if test "x$with_libganglia" = "xyes" && test "x$with_libganglia_config" != "x"
+then
+ if test "x$GANGLIA_CPPFLAGS" = "x"
+ then
+ GANGLIA_CPPFLAGS=`"$with_libganglia_config" --cflags 2>/dev/null`
+ fi
+
+ if test "x$GANGLIA_LDFLAGS" = "x"
+ then
+ GANGLIA_LDFLAGS=`"$with_libganglia_config" --ldflags 2>/dev/null`
+ fi
+
+ if test "x$GANGLIA_LIBS" = "x"
+ then
+ GANGLIA_LIBS=`"$with_libganglia_config" --libs 2>/dev/null`
+ fi
+fi
+
+SAVE_CPPFLAGS="$CPPFLAGS"
+SAVE_LDFLAGS="$LDFLAGS"
+CPPFLAGS="$CPPFLAGS $GANGLIA_CPPFLAGS"
+LDFLAGS="$LDFLAGS $GANGLIA_LDFLAGS"
+
+if test "x$with_libganglia" = "xyes"
+then
+ AC_CHECK_HEADERS(gm_protocol.h,
+ [
+ AC_DEFINE(HAVE_GM_PROTOCOL_H, 1,
+ [Define to 1 if you have the <gm_protocol.h> header file.])
+ ], [with_libganglia="no (gm_protocol.h not found)"])
+fi
+
+if test "x$with_libganglia" = "xyes"
+then
+ AC_CHECK_LIB(ganglia, xdr_Ganglia_value_msg,
+ [
+ AC_DEFINE(HAVE_LIBGANGLIA, 1,
+ [Define to 1 if you have the ganglia library (-lganglia).])
+ ], [with_libganglia="no (symbol xdr_Ganglia_value_msg not found)"])
+fi
+
+CPPFLAGS="$SAVE_CPPFLAGS"
+LDFLAGS="$SAVE_LDFLAGS"
+
+AC_SUBST(GANGLIA_CPPFLAGS)
+AC_SUBST(GANGLIA_LDFLAGS)
+AC_SUBST(GANGLIA_LIBS)
+AM_CONDITIONAL(BUILD_WITH_LIBGANGLIA, test "x$with_libganglia" = "xyes")
+# }}}
+
+# --with-libgcrypt {{{
+GCRYPT_CPPFLAGS="$GCRYPT_CPPFLAGS"
+GCRYPT_LDFLAGS="$GCRYPT_LDFLAGS"
+GCRYPT_LIBS="$GCRYPT_LIBS"
+AC_ARG_WITH(libgcrypt, [AS_HELP_STRING([--with-libgcrypt@<:@=PREFIX@:>@], [Path to libgcrypt.])],
+[
+ if test -f "$withval" && test -x "$withval"
+ then
+ with_libgcrypt_config="$withval"
+ with_libgcrypt="yes"
+ else if test -f "$withval/bin/gcrypt-config" && test -x "$withval/bin/gcrypt-config"
+ then
+ with_libgcrypt_config="$withval/bin/gcrypt-config"
+ with_libgcrypt="yes"
+ else if test -d "$withval"
+ then
+ GCRYPT_CPPFLAGS="$GCRYPT_CPPFLAGS -I$withval/include"
+ GCRYPT_LDFLAGS="$GCRYPT_LDFLAGS -L$withval/lib"
+ with_libgcrypt="yes"
+ else
+ with_libgcrypt_config="gcrypt-config"
+ with_libgcrypt="$withval"
+ fi; fi; fi
+],
+[
+ with_libgcrypt_config="libgcrypt-config"
+ with_libgcrypt="yes"
+])
+
+if test "x$with_libgcrypt" = "xyes" && test "x$with_libgcrypt_config" != "x"
+then
+ if test "x$GCRYPT_CPPFLAGS" = "x"
+ then
+ GCRYPT_CPPFLAGS=`"$with_libgcrypt_config" --cflags 2>/dev/null`
+ fi
+
+ if test "x$GCRYPT_LDFLAGS" = "x"
+ then
+ gcrypt_exec_prefix=`"$with_libgcrypt_config" --exec-prefix 2>/dev/null`
+ GCRYPT_LDFLAGS="-L$gcrypt_exec_prefix/lib"
+ fi
+
+ if test "x$GCRYPT_LIBS" = "x"
+ then
+ GCRYPT_LIBS=`"$with_libgcrypt_config" --libs 2>/dev/null`
+ fi
+fi
+
+SAVE_CPPFLAGS="$CPPFLAGS"
+SAVE_LDFLAGS="$LDFLAGS"
+CPPFLAGS="$CPPFLAGS $GCRYPT_CPPFLAGS"
+LDFLAGS="$LDFLAGS $GCRYPT_LDFLAGS"
+
+if test "x$with_libgcrypt" = "xyes"
+then
+ if test "x$GCRYPT_CPPFLAGS" != "x"
+ then
+ AC_MSG_NOTICE([gcrypt CPPFLAGS: $GCRYPT_CPPFLAGS])
+ fi
+ AC_CHECK_HEADERS(gcrypt.h,
+ [with_libgcrypt="yes"],
+ [with_libgcrypt="no (gcrypt.h not found)"])
+fi
+
+if test "x$with_libgcrypt" = "xyes"
+then
+ if test "x$GCRYPT_LDFLAGS" != "x"
+ then
+ AC_MSG_NOTICE([gcrypt LDFLAGS: $GCRYPT_LDFLAGS])
+ fi
+ AC_CHECK_LIB(gcrypt, gcry_md_hash_buffer,
+ [with_libgcrypt="yes"],
+ [with_libgcrypt="no (symbol gcry_md_hash_buffer not found)"])
+fi
+
+CPPFLAGS="$SAVE_CPPFLAGS"
+LDFLAGS="$SAVE_LDFLAGS"
+
+AC_SUBST(GCRYPT_CPPFLAGS)
+AC_SUBST(GCRYPT_LDFLAGS)
+AC_SUBST(GCRYPT_LIBS)
+AM_CONDITIONAL(BUILD_WITH_LIBGCRYPT, test "x$with_libgcrypt" = "xyes")
+# }}}
+
# --with-libiptc {{{
with_own_libiptc="no"
AC_ARG_WITH(libiptc, [AS_HELP_STRING([--with-libiptc@<:@=PREFIX@:>@], [Path to libiptc.])],
fi
# }}}
+# --with-java {{{
+with_java_home="$JAVA_HOME"
+with_java_vmtype="client"
+with_java_cflags=""
+with_java_libs=""
+AC_ARG_WITH(java, [AS_HELP_STRING([--with-java@<:@=PREFIX@:>@], [Path to Java home.])],
+[
+ if test "x$withval" = "xno"
+ then
+ with_java="no"
+ else if test "x$withval" = "xyes"
+ then
+ with_java="yes"
+ else
+ with_java_home="$withval"
+ with_java="yes"
+ fi; fi
+],
+[with_java="yes"])
+if test "x$with_java" = "xyes"
+then
+ if test -d "$with_java_home"
+ then
+ if test -d "$with_java_home/include"
+ then
+ JAVA_CPPFLAGS="$JAVA_CPPFLAGS -I$with_java_home/include"
+ else
+ JAVA_CPPFLAGS="$JAVA_CPPFLAGS -I$with_java_home"
+ fi
+
+ if test -d "$with_java_home/lib"
+ then
+ JAVA_LDFLAGS="$JAVA_LDFLAGS -L$with_java_home/lib"
+ else
+ JAVA_LDFLAGS="$JAVA_LDFLAGS -L$with_java_home"
+ fi
+ else if test "x$with_java_home" != "x"
+ then
+ AC_MSG_WARN([JAVA_HOME: No such directory: $with_java_home])
+ fi; fi
+fi
+
+if test "x$JAVA_CPPFLAGS" != "x"
+then
+ AC_MSG_NOTICE([Building with JAVA_CPPFLAGS set to: $JAVA_CPPFLAGS])
+fi
+if test "x$JAVA_CFLAGS" != "x"
+then
+ AC_MSG_NOTICE([Building with JAVA_CFLAGS set to: $JAVA_CFLAGS])
+fi
+if test "x$JAVA_LDFLAGS" != "x"
+then
+ AC_MSG_NOTICE([Building with JAVA_LDFLAGS set to: $JAVA_LDFLAGS])
+fi
+
+SAVE_CPPFLAGS="$CPPFLAGS"
+SAVE_CFLAGS="$CFLAGS"
+SAVE_LDFLAGS="$LDFLAGS"
+CPPFLAGS="$CPPFLAGS $JAVA_CPPFLAGS"
+CFLAGS="$CFLAGS $JAVA_CFLAGS"
+LDFLAGS="$LDFLAGS $JAVA_LDFLAGS"
+
+if test "x$with_java" = "xyes"
+then
+ AC_CHECK_HEADERS(jni.h, [], [with_java="no (jni.h not found)"])
+fi
+if test "x$with_java" = "xyes"
+then
+ AC_CHECK_LIB(jvm, JNI_CreateJavaVM,
+ [with_java="yes"],
+ [with_java="no (libjvm not found)"],
+ [$JAVA_LIBS])
+fi
+if test "x$with_java" = "xyes"
+then
+ JAVA_LIBS="$JAVA_LIBS -ljvm"
+ AC_MSG_NOTICE([Building with JAVA_LIBS set to: $JAVA_LIBS])
+fi
+
+CPPFLAGS="$SAVE_CPPFLAGS"
+CFLAGS="$SAVE_CFLAGS"
+LDFLAGS="$SAVE_LDFLAGS"
+
+AC_SUBST(JAVA_CPPFLAGS)
+AC_SUBST(JAVA_CFLAGS)
+AC_SUBST(JAVA_LDFLAGS)
+AC_SUBST(JAVA_LIBS)
+AM_CONDITIONAL(BUILD_WITH_JAVA, test "x$with_java" = "xyes")
+# }}}
+
+# --with-libmemcached {{{
+with_libmemcached_cppflags=""
+with_libmemcached_ldflags=""
+AC_ARG_WITH(libmemcached, [AS_HELP_STRING([--with-libmemcached@<:@=PREFIX@:>@], [Path to libmemcached.])],
+[
+ if test "x$withval" != "xno" && test "x$withval" != "xyes"
+ then
+ with_libmemcached_cppflags="-I$withval/include"
+ with_libmemcached_ldflags="-L$withval/lib"
+ with_libmemcached="yes"
+ else
+ with_libmemcached="$withval"
+ fi
+],
+[
+ with_libmemcached="yes"
+])
+if test "x$with_libmemcached" = "xyes"
+then
+ SAVE_CPPFLAGS="$CPPFLAGS"
+ CPPFLAGS="$CPPFLAGS $with_libmemcached_cppflags"
+
+ AC_CHECK_HEADERS(libmemcached/memcached.h, [with_libmemcached="yes"], [with_libmemcached="no (libmemcached/memcached.h not found)"])
+
+ CPPFLAGS="$SAVE_CPPFLAGS"
+fi
+if test "x$with_libmemcached" = "xyes"
+then
+ SAVE_CPPFLAGS="$CPPFLAGS"
+ SAVE_LDFLAGS="$LDFLAGS"
+ CPPFLAGS="$CPPFLAGS $with_libmemcached_cppflags"
+ LDFLAGS="$LDFLAGS $with_libmemcached_ldflags"
+
+ AC_CHECK_LIB(memcached, memcached_create, [with_libmemcached="yes"], [with_libmemcached="no (Symbol 'memcached_create' not found)"])
+
+ CPPFLAGS="$SAVE_CPPFLAGS"
+ LDFLAGS="$SAVE_LDFLAGS"
+fi
+if test "x$with_libmemcached" = "xyes"
+then
+ BUILD_WITH_LIBMEMCACHED_CPPFLAGS="$with_libmemcached_cppflags"
+ BUILD_WITH_LIBMEMCACHED_LDFLAGS="$with_libmemcached_ldflags"
+ BUILD_WITH_LIBMEMCACHED_LIBS="-lmemcached"
+ AC_SUBST(BUILD_WITH_LIBMEMCACHED_CPPFLAGS)
+ AC_SUBST(BUILD_WITH_LIBMEMCACHED_LDFLAGS)
+ AC_SUBST(BUILD_WITH_LIBMEMCACHED_LIBS)
+ AC_DEFINE(HAVE_LIBMEMCACHED, 1, [Define if libmemcached is present and usable.])
+fi
+AM_CONDITIONAL(BUILD_WITH_LIBMEMCACHED, test "x$with_libmemcached" = "xyes")
+# }}}
+
# --with-libmysql {{{
with_mysql_config="mysql_config"
with_mysql_cflags=""
# }}}
# --with-liboping {{{
-with_own_liboping="no"
-liboping_LDFLAGS="$LDFLAGS"
-liboping_CPPFLAGS="$CPPFLAGS"
AC_ARG_WITH(liboping, [AS_HELP_STRING([--with-liboping@<:@=PREFIX@:>@], [Path to liboping.])],
[
- if test "x$withval" != "xno" && test "x$withval" != "xyes"
+ if test "x$withval" = "xyes"
+ then
+ with_liboping="yes"
+ else if test "x$withval" = "xno"
+ then
+ with_liboping="no"
+ else
+ with_liboping="yes"
+ LIBOPING_CPPFLAGS="$LIBOPING_CPPFLAGS -I$withval/include"
+ LIBOPING_LDFLAGS="$LIBOPING_LDFLAGS -L$withval/lib"
+ fi; fi
+],
+[with_liboping="yes"])
+
+SAVE_CPPFLAGS="$CPPFLAGS"
+SAVE_LDFLAGS="$LDFLAGS"
+
+CPPFLAGS="$CPPFLAGS $LIBOPING_CPPFLAGS"
+LDFLAGS="$LDFLAGS $LIBOPING_LDFLAGS"
+
+if test "x$with_liboping" = "xyes"
+then
+ if test "x$LIBOPING_CPPFLAGS" != "x"
then
- if test -d "$withval/lib"
- then
- liboping_LDFLAGS="$LDFLAGS -L$withval/lib"
- fi
- if test -d "$withval/include"
- then
- liboping_CPPFLAGS="$CPPFLAGS -I$withval/include"
- fi
+ AC_MSG_NOTICE([liboping CPPFLAGS: $LIBOPING_CPPFLAGS])
fi
- if test "x$withval" = "xno"
- then
- with_liboping="no"
- with_own_liboping="no"
- else if test "x$withval" = "xyes"
+ AC_CHECK_HEADERS(oping.h,
+ [with_liboping="yes"],
+ [with_liboping="no ('oping.h' not found)"])
+fi
+if test "x$with_liboping" = "xyes"
+then
+ if test "x$LIBOPING_LDFLAGS" != "x"
then
- with_liboping="yes"
- fi; fi
-],
-[
- with_liboping="yes"
-])
+ AC_MSG_NOTICE([liboping LDFLAGS: $LIBOPING_LDFLAGS])
+ fi
+ AC_CHECK_LIB(oping, ping_construct,
+ [with_liboping="yes"],
+ [with_liboping="no (symbol 'ping_construct' not found)"])
+fi
+
+CPPFLAGS="$SAVE_CPPFLAGS"
+LDFLAGS="$SAVE_LDFLAGS"
if test "x$with_liboping" = "xyes"
then
- save_LDFLAGS="$LDFLAGS"
- save_CPPFLAGS="$CPPFLAGS"
- LDFLAGS="$liboping_LDFLAGS"
- CPPFLAGS="$liboping_CPPFLAGS"
- AC_CHECK_LIB(oping, ping_construct,
- [
- with_liboping="yes"
- with_own_liboping="no"
- ],
- [
- with_liboping="yes"
- with_own_liboping="yes"
- LDFLAGS="$save_LDFLAGS"
- CPPFLAGS="$save_CPPFLAGS"
- ])
+ BUILD_WITH_LIBOPING_CPPFLAGS="$LIBOPING_CPPFLAGS"
+ BUILD_WITH_LIBOPING_LDFLAGS="$LIBOPING_LDFLAGS"
+ AC_SUBST(BUILD_WITH_LIBOPING_CPPFLAGS)
+ AC_SUBST(BUILD_WITH_LIBOPING_LDFLAGS)
fi
AM_CONDITIONAL(BUILD_WITH_LIBOPING, test "x$with_liboping" = "xyes")
-AM_CONDITIONAL(BUILD_WITH_OWN_LIBOPING, test "x$with_own_liboping" = "xyes")
# }}}
# --with-oracle {{{
[with_libpq="yes"],
[with_libpq="no (symbol 'PQconnectdb' not found)"])
+ AC_CHECK_LIB(pq, PQserverVersion,
+ [with_libpq="yes"],
+ [with_libpq="no (symbol 'PQserverVersion' not found)"])
+
LDFLAGS="$SAVE_LDFLAGS"
fi
if test "x$with_libpq" = "xyes"
plugin_nfs="no"
plugin_perl="no"
plugin_processes="no"
+plugin_protocols="no"
plugin_serial="no"
plugin_swap="no"
plugin_tape="no"
plugin_tcpconns="no"
+plugin_ted="no"
plugin_thermal="no"
plugin_users="no"
+plugin_uptime="no"
plugin_vmem="no"
plugin_vserver="no"
plugin_wireless="no"
plugin_memory="yes"
plugin_nfs="yes"
plugin_processes="yes"
+ plugin_protocols="yes"
plugin_serial="yes"
plugin_swap="yes"
plugin_tcpconns="yes"
plugin_thermal="yes"
+ plugin_uptime="yes"
plugin_vmem="yes"
plugin_vserver="yes"
plugin_wireless="yes"
fi
# Solaris
+if test "x$with_kstat" = "xyes"
+then
+ plugin_uptime="yes"
+fi
+
if test "x$with_devinfo$with_kstat" = "xyesyes"
then
plugin_cpu="yes"
then
plugin_cpu="yes"
plugin_swap="yes"
+ plugin_uptime="yes"
fi
if test "x$have_sysctlbyname" = "xyes"
then
if test "x$have_termios_h" = "xyes"
then
plugin_multimeter="yes"
+ plugin_ted="yes"
fi
if test "x$have_thread_info" = "xyes"
AC_PLUGIN([entropy], [$plugin_entropy], [Entropy statistics])
AC_PLUGIN([exec], [yes], [Execution of external programs])
AC_PLUGIN([filecount], [yes], [Count files in directories])
+AC_PLUGIN([gmond], [$with_libganglia], [Ganglia plugin])
AC_PLUGIN([hddtemp], [yes], [Query hddtempd])
AC_PLUGIN([interface], [$plugin_interface], [Interface traffic statistics])
AC_PLUGIN([ipmi], [$plugin_ipmi], [IPMI sensor statistics])
AC_PLUGIN([iptables], [$with_libiptc], [IPTables rule counters])
AC_PLUGIN([ipvs], [$plugin_ipvs], [IPVS connection statistics])
AC_PLUGIN([irq], [$plugin_irq], [IRQ statistics])
+AC_PLUGIN([java], [$with_java], [Embed the Java Virtual Machine])
AC_PLUGIN([libvirt], [$plugin_libvirt], [Virtual machine statistics])
AC_PLUGIN([load], [$plugin_load], [System load])
AC_PLUGIN([logfile], [yes], [File logging plugin])
AC_PLUGIN([match_timediff], [yes], [The timediff match])
AC_PLUGIN([match_value], [yes], [The value match])
AC_PLUGIN([mbmon], [yes], [Query mbmond])
+AC_PLUGIN([memcachec], [$with_libmemcached], [memcachec statistics])
AC_PLUGIN([memcached], [yes], [memcached statistics])
AC_PLUGIN([memory], [$plugin_memory], [Memory usage])
AC_PLUGIN([multimeter], [$plugin_multimeter], [Read multimeter values])
AC_PLUGIN([postgresql], [$with_libpq], [PostgreSQL database statistics])
AC_PLUGIN([powerdns], [yes], [PowerDNS statistics])
AC_PLUGIN([processes], [$plugin_processes], [Process statistics])
+AC_PLUGIN([protocols], [$plugin_protocols], [Protocol (IP, TCP, ...) statistics])
AC_PLUGIN([rrdcached], [$librrd_rrdc_update], [RRDTool output plugin])
AC_PLUGIN([rrdtool], [$with_librrd], [RRDTool output plugin])
AC_PLUGIN([sensors], [$with_libsensors], [lm_sensors statistics])
AC_PLUGIN([snmp], [$with_libnetsnmp], [SNMP querying plugin])
AC_PLUGIN([swap], [$plugin_swap], [Swap usage statistics])
AC_PLUGIN([syslog], [$have_syslog], [Syslog logging plugin])
+AC_PLUGIN([table], [yes], [Parsing of tabular data])
AC_PLUGIN([tail], [yes], [Parsing of logfiles])
AC_PLUGIN([tape], [$plugin_tape], [Tape drive statistics])
AC_PLUGIN([target_notification], [yes], [The notification target])
AC_PLUGIN([target_set], [yes], [The set target])
AC_PLUGIN([tcpconns], [$plugin_tcpconns], [TCP connection statistics])
AC_PLUGIN([teamspeak2], [yes], [TeamSpeak2 server statistics])
+AC_PLUGIN([ted], [$plugin_ted], [Read The Energy Detective values])
AC_PLUGIN([thermal], [$plugin_thermal], [Linux ACPI thermal zone statistics])
AC_PLUGIN([unixsock], [yes], [Unixsock communication plugin])
+AC_PLUGIN([uptime], [$plugin_uptime], [Uptime statistics])
AC_PLUGIN([users], [$plugin_users], [User statistics])
AC_PLUGIN([uuid], [yes], [UUID as hostname plugin])
AC_PLUGIN([vmem], [$plugin_vmem], [Virtual memory statistics])
AC_PLUGIN([wireless], [$plugin_wireless], [Wireless statistics])
AC_PLUGIN([xmms], [$with_libxmms], [XMMS statistics])
+dnl Default configuration file
+# Load either syslog or logfile
+LOAD_PLUGIN_SYSLOG=""
+LOAD_PLUGIN_LOGFILE=""
+
+AC_MSG_CHECKING([which default log plugin to load])
+default_log_plugin="none"
+if test "x$enable_syslog" = "xyes"
+then
+ default_log_plugin="syslog"
+else
+ LOAD_PLUGIN_SYSLOG="##"
+fi
+
+if test "x$enable_logfile" = "xyes"
+then
+ if test "x$default_log_plugin" = "xnone"
+ then
+ default_log_plugin="logfile"
+ else
+ LOAD_PLUGIN_LOGFILE="#"
+ fi
+else
+ LOAD_PLUGIN_LOGFILE="##"
+fi
+AC_MSG_RESULT([$default_log_plugin])
+
+AC_SUBST(LOAD_PLUGIN_SYSLOG)
+AC_SUBST(LOAD_PLUGIN_LOGFILE)
+
+DEFAULT_LOG_LEVEL="info"
+if test "x$enable_debug" = "xyes"
+then
+ DEFAULT_LOG_LEVEL="debug"
+fi
+AC_SUBST(DEFAULT_LOG_LEVEL)
+
+# Load only one of rrdtool, network, csv in the default config.
+LOAD_PLUGIN_RRDTOOL=""
+LOAD_PLUGIN_NETWORK=""
+LOAD_PLUGIN_CSV=""
+
+AC_MSG_CHECKING([which default write plugin to load])
+default_write_plugin="none"
+if test "x$enable_rrdtool" = "xyes"
+then
+ default_write_plugin="rrdtool"
+else
+ LOAD_PLUGIN_RRDTOOL="##"
+fi
+
+if test "x$enable_network" = "xyes"
+then
+ if test "x$default_write_plugin" = "xnone"
+ then
+ default_write_plugin="network"
+ else
+ LOAD_PLUGIN_NETWORK="#"
+ fi
+else
+ LOAD_PLUGIN_NETWORK="##"
+fi
+
+if test "x$enable_csv" = "xyes"
+then
+ if test "x$default_write_plugin" = "xnone"
+ then
+ default_write_plugin="csv"
+ else
+ LOAD_PLUGIN_CSV="#"
+ fi
+else
+ LOAD_PLUGIN_CSV="##"
+fi
+AC_MSG_RESULT([$default_write_plugin])
+
+AC_SUBST(LOAD_PLUGIN_RRDTOOL)
+AC_SUBST(LOAD_PLUGIN_NETWORK)
+AC_SUBST(LOAD_PLUGIN_CSV)
+
dnl ip_vs.h
if test "x$ac_system" = "xLinux" \
&& test "x$have_net_ip_vs_h$have_ip_vs_h" = "xnono"
AC_CONFIG_FILES(src/libcollectdclient/lcc_features.h)
-AC_OUTPUT(Makefile src/Makefile src/collectd.conf src/libiptc/Makefile src/libcollectdclient/Makefile src/libcollectdclient/libcollectdclient.pc src/liboconfig/Makefile src/liboping/Makefile bindings/Makefile)
+AC_OUTPUT(Makefile src/Makefile src/collectd.conf src/libiptc/Makefile src/libcollectdclient/Makefile src/libcollectdclient/libcollectdclient.pc src/liboconfig/Makefile bindings/Makefile)
if test "x$with_librrd" = "xyes" \
&& test "x$librrd_threadsafe" != "xyes"
with_librrd="yes (warning: librrd is not thread-safe)"
fi
-if test "x$with_liboping" = "xyes" \
- && test "x$with_own_liboping" = "xyes"
-then
- with_liboping="yes (shipped version)"
-fi
-
if test "x$with_libiptc" = "xyes" -a "x$with_own_libiptc" = "xyes"
then
with_libiptc="yes (shipped version)"
libesmtp . . . . . . $with_libesmtp
libiokit . . . . . . $with_libiokit
libiptc . . . . . . . $with_libiptc
+ libjvm . . . . . . . $with_java
libkstat . . . . . . $with_kstat
libkvm . . . . . . . $with_libkvm
libmysql . . . . . . $with_libmysql
entropy . . . . . . . $enable_entropy
exec . . . . . . . . $enable_exec
filecount . . . . . . $enable_filecount
+ gmond . . . . . . . . $enable_gmond
hddtemp . . . . . . . $enable_hddtemp
interface . . . . . . $enable_interface
ipmi . . . . . . . . $enable_ipmi
iptables . . . . . . $enable_iptables
ipvs . . . . . . . . $enable_ipvs
irq . . . . . . . . . $enable_irq
+ java . . . . . . . . $enable_java
libvirt . . . . . . . $enable_libvirt
load . . . . . . . . $enable_load
logfile . . . . . . . $enable_logfile
match_timediff . . . $enable_match_timediff
match_value . . . . . $enable_match_value
mbmon . . . . . . . . $enable_mbmon
+ memcachec . . . . . . $enable_memcachec
memcached . . . . . . $enable_memcached
memory . . . . . . . $enable_memory
multimeter . . . . . $enable_multimeter
postgresql . . . . . $enable_postgresql
powerdns . . . . . . $enable_powerdns
processes . . . . . . $enable_processes
+ protocols . . . . . . $enable_protocols
rrdcached . . . . . . $enable_rrdcached
rrdtool . . . . . . . $enable_rrdtool
sensors . . . . . . . $enable_sensors
snmp . . . . . . . . $enable_snmp
swap . . . . . . . . $enable_swap
syslog . . . . . . . $enable_syslog
+ table . . . . . . . . $enable_table
tail . . . . . . . . $enable_tail
tape . . . . . . . . $enable_tape
target_notification . $enable_target_notification
target_set . . . . . $enable_target_set
tcpconns . . . . . . $enable_tcpconns
teamspeak2 . . . . . $enable_teamspeak2
+ ted . . . . . . . . . $enable_ted
thermal . . . . . . . $enable_thermal
unixsock . . . . . . $enable_unixsock
+ uptime . . . . . . . $enable_uptime
users . . . . . . . . $enable_users
uuid . . . . . . . . $enable_uuid
vmem . . . . . . . . $enable_vmem
--- /dev/null
+#-*- coding: ISO-8859-1 -*-
+# collect.py: the python collectd-unixsock module.
+#
+# Requires collectd to be configured with the unixsock plugin, like so:
+#
+# LoadPlugin unixsock
+# <Plugin unixsock>
+# SocketFile "/var/run/collectd-unixsock"
+# SocketPerms "0775"
+# </Plugin>
+#
+# Copyright (C) 2008 Clay Loveless <clay@killersoft.com>
+#
+# This software is provided 'as-is', without any express or implied
+# warranty. In no event will the author be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+# claim that you wrote the original software. If you use this software
+# in a product, an acknowledgment in the product documentation would be
+# appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+# misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+
+import socket, string
+
+class Collect(object):
+
+ def __init__(self, path='/var/run/collectd-unixsock'):
+ self._sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+ self._path = path
+ self._sock.connect(self._path)
+
+ def list(self):
+ numvalues = self._cmd('LISTVAL')
+ lines = []
+ if numvalues:
+ lines = self._readlines(numvalues)
+ return lines
+
+ def get(self, val, flush=True):
+ numvalues = self._cmd('GETVAL "' + val + '"')
+ lines = []
+ if numvalues:
+ lines = self._readlines(numvalues)
+ if flush:
+ self._cmd('FLUSH identifier="' + val + '"')
+ return lines
+
+ def _cmd(self, c):
+ self._sock.send(c + "\n")
+ stat = string.split(self._readline())
+ status = int(stat[0])
+ if status:
+ return status
+ return False
+
+ '''
+ _readline and _readlines methods borrowed from the _fileobject class
+ in sockets.py, tweaked a little bit for use in the collectd context.
+ '''
+ def _readline(self):
+ data = ''
+ buf = []
+ recv = self._sock.recv
+ while data != "\n":
+ data = recv(1)
+ if not data:
+ break
+ if data != "\n":
+ buf.append(data)
+ return ''.join(buf)
+
+ def _readlines(self, sizehint=0):
+ total = 0
+ list = []
+ while True:
+ line = self._readline()
+ if not line:
+ break
+ list.append(line)
+ total = len(list)
+ if sizehint and total >= sizehint:
+ break
+ return list
+
+ def __del__(self):
+ self._sock.close()
+
+
+
+if __name__ == '__main__':
+
+ '''
+ Example usage:
+ Collect values from socket and dump to STDOUT.
+ '''
+
+ c = Collect('/var/run/collectd-unixsock')
+ list = c.list()
+
+ for val in list:
+ stamp, key = string.split(val)
+ glines = c.get(key)
+ print stamp + ' ' + key + ' ' + ', '.join(glines)
+
<Type mysql_commands>
Module GenericStacked
DataSources value
- RRDTitle "MySQL commands"
+ RRDTitle "MySQL commands ({plugin_instance})"
RRDVerticalLabel "Invocations"
RRDFormat "%6.2lf"
<Type mysql_handler>
Module GenericStacked
DataSources value
- RRDTitle "MySQL handler"
+ RRDTitle "MySQL handler ({plugin_instance})"
RRDVerticalLabel "Invocations"
RRDFormat "%6.2lf"
DSName commit commit
DataSources rx tx
DSName rx RX
DSName tx TX
- RRDTitle "MySQL Traffic"
+ RRDTitle "MySQL Traffic ({plugin_instance})"
RRDVerticalLabel "Bits per second"
RRDFormat "%5.1lf%s"
Scale 8
if BUILD_WITH_OWN_LIBOCONFIG
SUBDIRS += liboconfig
endif
-if BUILD_WITH_OWN_LIBOPING
-SUBDIRS += liboping
-endif
if COMPILER_IS_GCC
AM_CFLAGS = -Wall -Werror
utils_avltree.c utils_avltree.h \
utils_cache.c utils_cache.h \
utils_complain.c utils_complain.h \
+ utils_heap.c utils_heap.h \
utils_ignorelist.c utils_ignorelist.h \
utils_llist.c utils_llist.h \
utils_parse_option.c utils_parse_option.h \
collectdmon_CPPFLAGS = $(AM_CPPFLAGS)
collectd_nagios_SOURCES = collectd-nagios.c
-collectd_nagios_LDFLAGS =
+collectd_nagios_LDADD =
if BUILD_WITH_LIBSOCKET
-collectd_nagios_LDFLAGS += -lsocket
+collectd_nagios_LDADD += -lsocket
endif
-collectd_nagios_LDADD = libcollectdclient/libcollectdclient.la
+collectd_nagios_LDADD += libcollectdclient/libcollectdclient.la
collectd_nagios_DEPENDENCIES = libcollectdclient/libcollectdclient.la
pkglib_LTLIBRARIES =
pkglib_LTLIBRARIES += apcups.la
apcups_la_SOURCES = apcups.c
apcups_la_LDFLAGS = -module -avoid-version
+apcups_la_LIBADD =
if BUILD_WITH_LIBSOCKET
-apcups_la_LDFLAGS += -lsocket
+apcups_la_LIBADD += -lsocket
endif
collectd_LDADD += "-dlopen" apcups.la
collectd_DEPENDENCIES += apcups.la
if BUILD_PLUGIN_APPLE_SENSORS
pkglib_LTLIBRARIES += apple_sensors.la
apple_sensors_la_SOURCES = apple_sensors.c
-apple_sensors_la_LDFLAGS = -module -avoid-version -lIOKit
+apple_sensors_la_LDFLAGS = -module -avoid-version
+apple_sensors_la_LIBADD = -lIOKit
collectd_LDADD += "-dlopen" apple_sensors.la
collectd_DEPENDENCIES += apple_sensors.la
endif
pkglib_LTLIBRARIES += battery.la
battery_la_SOURCES = battery.c
battery_la_LDFLAGS = -module -avoid-version
+battery_la_LIBADD =
if BUILD_WITH_LIBIOKIT
-battery_la_LDFLAGS += -lIOKit
+battery_la_LIBADD += -lIOKit
endif
collectd_LDADD += "-dlopen" battery.la
collectd_DEPENDENCIES += battery.la
cpu_la_LDFLAGS = -module -avoid-version
cpu_la_LIBADD =
if BUILD_WITH_LIBKSTAT
-cpu_la_LDFLAGS += -lkstat
+cpu_la_LIBADD += -lkstat
endif
if BUILD_WITH_LIBDEVINFO
-cpu_la_LDFLAGS += -ldevinfo
+cpu_la_LIBADD += -ldevinfo
endif
if BUILD_WITH_LIBSTATGRAB
cpu_la_CFLAGS += $(BUILD_WITH_LIBSTATGRAB_CFLAGS)
disk_la_LDFLAGS = -module -avoid-version
disk_la_LIBADD =
if BUILD_WITH_LIBKSTAT
-disk_la_LDFLAGS += -lkstat
+disk_la_LIBADD += -lkstat
endif
if BUILD_WITH_LIBDEVINFO
-disk_la_LDFLAGS += -ldevinfo
+disk_la_LIBADD += -ldevinfo
endif
if BUILD_WITH_LIBIOKIT
-disk_la_LDFLAGS += -lIOKit
+disk_la_LIBADD += -lIOKit
endif
if BUILD_WITH_LIBSTATGRAB
disk_la_CFLAGS += $(BUILD_WITH_LIBSTATGRAB_CFLAGS)
if BUILD_PLUGIN_DNS
pkglib_LTLIBRARIES += dns.la
dns_la_SOURCES = dns.c utils_dns.c utils_dns.h
-dns_la_LDFLAGS = -module -avoid-version -lpcap -lpthread
+dns_la_LDFLAGS = -module -avoid-version
+dns_la_LIBADD = -lpcap -lpthread
collectd_LDADD += "-dlopen" dns.la
collectd_DEPENDENCIES += dns.la
endif
pkglib_LTLIBRARIES += email.la
email_la_SOURCES = email.c
email_la_LDFLAGS = -module -avoid-version
-if BUILD_WITH_LIBPTHREAD
-email_la_LDFLAGS += -lpthread
-endif
+email_la_LIBADD = -lpthread
collectd_LDADD += "-dlopen" email.la
collectd_DEPENDENCIES += email.la
endif
utils_cmd_putnotif.c utils_cmd_putnotif.h \
utils_cmd_putval.c utils_cmd_putval.h
exec_la_LDFLAGS = -module -avoid-version
-if BUILD_WITH_LIBPTHREAD
-exec_la_LDFLAGS += -lpthread
-endif
+exec_la_LIBADD = -lpthread
collectd_LDADD += "-dlopen" exec.la
collectd_DEPENDENCIES += exec.la
endif
collectd_DEPENDENCIES += filecount.la
endif
+if BUILD_PLUGIN_GMOND
+pkglib_LTLIBRARIES += gmond.la
+gmond_la_SOURCES = gmond.c
+gmond_la_CPPFLAGS = $(AM_CPPFLAGS) $(GANGLIA_CPPFLAGS)
+gmond_la_LDFLAGS = -module -avoid-version $(GANGLIA_LDFLAGS)
+gmond_la_LIBADD = $(GANGLIA_LIBS)
+collectd_LDADD += "-dlopen" gmond.la
+collectd_DEPENDENCIES += gmond.la
+endif
+
if BUILD_PLUGIN_HDDTEMP
pkglib_LTLIBRARIES += hddtemp.la
hddtemp_la_SOURCES = hddtemp.c
hddtemp_la_LDFLAGS = -module -avoid-version
+hddtemp_la_LIBADD =
if BUILD_WITH_LIBSOCKET
-hddtemp_la_LDFLAGS += -lsocket
+hddtemp_la_LIBADD += -lsocket
endif
collectd_LDADD += "-dlopen" hddtemp.la
collectd_DEPENDENCIES += hddtemp.la
interface_la_LIBADD += $(BUILD_WITH_LIBSTATGRAB_LDFLAGS)
else
if BUILD_WITH_LIBKSTAT
-interface_la_LDFLAGS += -lkstat
+interface_la_LIBADD += -lkstat
endif
if BUILD_WITH_LIBDEVINFO
-interface_la_LDFLAGS += -ldevinfo
+interface_la_LIBADD += -ldevinfo
endif # BUILD_WITH_LIBDEVINFO
endif # !BUILD_WITH_LIBSTATGRAB
endif # BUILD_PLUGIN_INTERFACE
iptables_la_LIBADD = libiptc/libiptc.la
iptables_la_DEPENDENCIES = libiptc/libiptc.la
else
-iptables_la_LDFLAGS += -liptc
+iptables_la_LIBADD = -liptc
endif
collectd_LDADD += "-dlopen" iptables.la
collectd_DEPENDENCIES += iptables.la
collectd_DEPENDENCIES += irq.la
endif
+if BUILD_PLUGIN_JAVA
+pkglib_LTLIBRARIES += java.la
+java_la_SOURCES = java.c
+java_la_CPPFLAGS = $(AM_CPPFLAGS) $(JAVA_CPPFLAGS)
+java_la_CFLAGS = $(AM_CFLAGS) $(JAVA_CFLAGS)
+java_la_LDFLAGS = -module -avoid-version $(JAVA_LDFLAGS)
+java_la_LIBADD = $(JAVA_LIBS)
+collectd_LDADD += "-dlopen" java.la
+collectd_DEPENDENCIES += java.la
+endif
+
if BUILD_PLUGIN_LIBVIRT
pkglib_LTLIBRARIES += libvirt.la
libvirt_la_SOURCES = libvirt.c
pkglib_LTLIBRARIES += mbmon.la
mbmon_la_SOURCES = mbmon.c
mbmon_la_LDFLAGS = -module -avoid-version
+mbmon_la_LIBADD =
if BUILD_WITH_LIBSOCKET
-mbmon_la_LDFLAGS += -lsocket
+mbmon_la_LIBADD += -lsocket
endif
collectd_LDADD += "-dlopen" mbmon.la
collectd_DEPENDENCIES += mbmon.la
endif
+if BUILD_PLUGIN_MEMCACHEC
+pkglib_LTLIBRARIES += memcachec.la
+memcachec_la_SOURCES = memcachec.c
+memcachec_la_LDFLAGS = -module -avoid-version $(BUILD_WITH_LIBMEMCACHED_LDFLAGS)
+memcachec_la_CPPFLAGS = $(BUILD_WITH_LIBMEMCACHED_CPPFLAGS)
+memcachec_la_LIBADD = $(BUILD_WITH_LIBMEMCACHED_LIBS)
+collectd_LDADD += "-dlopen" memcachec.la
+collectd_DEPENDENCIES += memcachec.la
+endif
+
if BUILD_PLUGIN_MEMCACHED
pkglib_LTLIBRARIES += memcached.la
memcached_la_SOURCES = memcached.c
memcached_la_LDFLAGS = -module -avoid-version
memcached_la_LIBADD =
if BUILD_WITH_LIBSOCKET
-memcached_la_LDFLAGS += -lsocket
+memcached_la_LIBADD += -lsocket
endif
collectd_LDADD += "-dlopen" memcached.la
collectd_DEPENDENCIES += memcached.la
if BUILD_PLUGIN_NETWORK
pkglib_LTLIBRARIES += network.la
network_la_SOURCES = network.c network.h
+network_la_CPPFLAGS = $(AM_CPPFLAGS)
network_la_LDFLAGS = -module -avoid-version
+network_la_LIBADD = -lpthread
if BUILD_WITH_LIBSOCKET
-network_la_LDFLAGS += -lsocket
+network_la_LIBADD += -lsocket
endif
-if BUILD_WITH_LIBPTHREAD
-network_la_LDFLAGS += -lpthread
+if BUILD_WITH_LIBGCRYPT
+network_la_CPPFLAGS += $(GCRYPT_CPPFLAGS)
+network_la_LDFLAGS += $(GCRYPT_LDFLAGS)
+network_la_LIBADD += $(GCRYPT_LIBS)
endif
collectd_LDADD += "-dlopen" network.la
collectd_DEPENDENCIES += network.la
pkglib_LTLIBRARIES += notify_desktop.la
notify_desktop_la_SOURCES = notify_desktop.c
notify_desktop_la_CFLAGS = $(AM_CFLAGS) $(LIBNOTIFY_CFLAGS)
-notify_desktop_la_LDFLAGS = -module -avoid-version $(LIBNOTIFY_LIBS)
+notify_desktop_la_LDFLAGS = -module -avoid-version
+notify_desktop_la_LIBADD = $(LIBNOTIFY_LIBS)
collectd_LDADD += "-dlopen" notify_desktop.la
collectd_DEPENDENCIES += notify_desktop.la
endif
if BUILD_PLUGIN_NOTIFY_EMAIL
pkglib_LTLIBRARIES += notify_email.la
notify_email_la_SOURCES = notify_email.c
-notify_email_la_LDFLAGS = -L/usr/local/lib -lesmtp -lssl -lcrypto -pthread -module -avoid-version
+notify_email_la_LDFLAGS = -module -avoid-version
+notify_email_la_LIBADD = -lesmtp -lssl -lcrypto -lpthread -ldl
collectd_LDADD += "-dlopen" notify_email.la
collectd_DEPENDENCIES += notify_email.la
endif
pkglib_LTLIBRARIES += ntpd.la
ntpd_la_SOURCES = ntpd.c
ntpd_la_LDFLAGS = -module -avoid-version
+ntpd_la_LIBADD =
if BUILD_WITH_LIBSOCKET
-ntpd_la_LDFLAGS += -lsocket
+ntpd_la_LIBADD += -lsocket
endif
collectd_LDADD += "-dlopen" ntpd.la
collectd_DEPENDENCIES += ntpd.la
pkglib_LTLIBRARIES += nut.la
nut_la_SOURCES = nut.c
nut_la_CFLAGS = $(AM_CFLAGS) $(BUILD_WITH_LIBUPSCLIENT_CFLAGS)
-nut_la_LDFLAGS = -module -avoid-version -lpthread $(BUILD_WITH_LIBUPSCLIENT_LIBS)
+nut_la_LDFLAGS = -module -avoid-version
+nut_la_LIBADD = -lpthread $(BUILD_WITH_LIBUPSCLIENT_LIBS)
collectd_LDADD += "-dlopen" nut.la
collectd_DEPENDENCIES += nut.la
endif
if BUILD_PLUGIN_PING
pkglib_LTLIBRARIES += ping.la
ping_la_SOURCES = ping.c
-ping_la_LDFLAGS = -module -avoid-version
-if BUILD_WITH_OWN_LIBOPING
-ping_la_LIBADD = liboping/liboping.la
-ping_la_DEPENDENCIES = liboping/liboping.la
-else
-ping_la_LDFLAGS += -loping
-endif
+ping_la_CPPFLAGS = $(AM_CPPFLAGS) $(BUILD_WITH_LIBOPING_CPPFLAGS)
+ping_la_LDFLAGS = -module -avoid-version $(BUILD_WITH_LIBOPING_LDFLAGS)
+ping_la_LIBADD = -loping
collectd_LDADD += "-dlopen" ping.la
collectd_DEPENDENCIES += ping.la
endif
utils_db_query.c utils_db_query.h
postgresql_la_CPPFLAGS = $(AM_CPPFLAGS) $(BUILD_WITH_LIBPQ_CPPFLAGS)
postgresql_la_LDFLAGS = -module -avoid-version \
- $(BUILD_WITH_LIBPQ_LDFLAGS) -lpq
+ $(BUILD_WITH_LIBPQ_LDFLAGS)
+postgresql_la_LIBADD = -lpq
collectd_LDADD += "-dlopen" postgresql.la
collectd_DEPENDENCIES += postgresql.la
endif
endif
endif
+if BUILD_PLUGIN_PROTOCOLS
+pkglib_LTLIBRARIES += protocols.la
+protocols_la_SOURCES = protocols.c
+protocols_la_LDFLAGS = -module -avoid-version
+collectd_LDADD += "-dlopen" protocols.la
+collectd_DEPENDENCIES += protocols.la
+endif
+
if BUILD_PLUGIN_RRDCACHED
pkglib_LTLIBRARIES += rrdcached.la
rrdcached_la_SOURCES = rrdcached.c utils_rrdcreate.c utils_rrdcreate.h
pkglib_LTLIBRARIES += sensors.la
sensors_la_SOURCES = sensors.c
sensors_la_CFLAGS = $(AM_CFLAGS) $(BUILD_WITH_LIBSENSORS_CFLAGS)
-sensors_la_LDFLAGS = -module -avoid-version $(BUILD_WITH_LIBSENSORS_LDFLAGS)
-sensors_la_LIBADD = -lsensors
+sensors_la_LDFLAGS = -module -avoid-version
+sensors_la_LIBADD = $(BUILD_WITH_LIBSENSORS_LDFLAGS)
collectd_LDADD += "-dlopen" sensors.la
collectd_DEPENDENCIES += sensors.la
endif
collectd_DEPENDENCIES += syslog.la
endif
+if BUILD_PLUGIN_TABLE
+pkglib_LTLIBRARIES += table.la
+table_la_SOURCES = table.c
+table_la_LDFLAGS = -module -avoid-version
+collectd_LDADD += "-dlopen" table.la
+collectd_DEPENDENCIES += table.la
+endif
+
if BUILD_PLUGIN_TAIL
pkglib_LTLIBRARIES += tail.la
tail_la_SOURCES = tail.c
if BUILD_PLUGIN_TAPE
pkglib_LTLIBRARIES += tape.la
tape_la_SOURCES = tape.c
-tape_la_LDFLAGS = -module -avoid-version -lkstat -ldevinfo
+tape_la_LDFLAGS = -module -avoid-version
+tape_la_LIBADD = -lkstat -ldevinfo
collectd_LDADD += "-dlopen" tape.la
collectd_DEPENDENCIES += tape.la
endif
collectd_DEPENDENCIES += teamspeak2.la
endif
+if BUILD_PLUGIN_TED
+pkglib_LTLIBRARIES += ted.la
+ted_la_SOURCES = ted.c
+ted_la_LDFLAGS = -module -avoid-version
+collectd_LDADD += "-dlopen" ted.la
+collectd_DEPENDENCIES += ted.la
+endif
+
if BUILD_PLUGIN_THERMAL
pkglib_LTLIBRARIES += thermal.la
thermal_la_SOURCES = thermal.c
utils_cmd_listval.h utils_cmd_listval.c \
utils_cmd_putval.h utils_cmd_putval.c \
utils_cmd_putnotif.h utils_cmd_putnotif.c
-unixsock_la_LDFLAGS = -module -avoid-version -lpthread
+unixsock_la_LDFLAGS = -module -avoid-version
+unixsock_la_LIBADD = -lpthread
collectd_LDADD += "-dlopen" unixsock.la
collectd_DEPENDENCIES += unixsock.la
endif
+if BUILD_PLUGIN_UPTIME
+pkglib_LTLIBRARIES += uptime.la
+uptime_la_SOURCES = uptime.c
+uptime_la_CFLAGS = $(AM_CFLAGS)
+uptime_la_LDFLAGS = -module -avoid-version
+uptime_la_LIBADD =
+if BUILD_WITH_LIBKSTAT
+uptime_la_LIBADD += -lkstat
+endif
+collectd_LDADD += "-dlopen" uptime.la
+collectd_DEPENDENCIES += uptime.la
+endif
+
if BUILD_PLUGIN_USERS
pkglib_LTLIBRARIES += users.la
users_la_SOURCES = users.c
pkglib_LTLIBRARIES += xmms.la
xmms_la_SOURCES = xmms.c
xmms_la_CFLAGS = $(AM_CFLAGS) $(BUILD_WITH_LIBXMMS_CFLAGS)
-xmms_la_LDFLAGS = -module -avoid-version $(BUILD_WITH_LIBXMMS_LIBS)
+xmms_la_LDFLAGS = -module -avoid-version
+xmms_la_LIBADD = $(BUILD_WITH_LIBXMMS_LIBS)
collectd_LDADD += "-dlopen" xmms.la
collectd_DEPENDENCIES += xmms.la
endif
-dist_man_MANS = collectd.1 collectd-nagios.1 collectd.conf.5 \
- collectd-email.5 collectd-exec.5 collectd-perl.5 \
- collectd-snmp.5 collectd-unixsock.5 collectdmon.1 \
+dist_man_MANS = collectd.1 \
+ collectd.conf.5 \
+ collectd-email.5 \
+ collectd-exec.5 \
+ collectd-java.5
+ collectdmon.1 \
+ collectd-nagios.1 \
+ collectd-perl.5 \
+ collectd-snmp.5 \
+ collectd-unixsock.5 \
types.db.5
#collectd_1_SOURCES = collectd.pod
EXTRA_DIST = types.db
-EXTRA_DIST += collectd-email.pod collectd-exec.pod collectd-nagios.pod \
- collectd-perl.pod collectd-snmp.pod collectd-unixsock.pod \
- collectd.conf.pod collectd.pod collectdmon.pod types.db.pod \
- postgresql_default.conf
+EXTRA_DIST += collectd.conf.pod \
+ collectd-email.pod \
+ collectd-exec.pod \
+ collectd-java.pod \
+ collectdmon.pod \
+ collectd-nagios.pod \
+ collectd-perl.pod \
+ collectd.pod \
+ collectd-snmp.pod \
+ collectd-unixsock.pod \
+ postgresql_default.conf \
+ types.db.pod
.pod.1:
pod2man --release=$(VERSION) --center=$(PACKAGE) $< \
STATIC_ARRAY_SIZE (memsummary_translation_table);
/* }}} */
-static void remove_special (char *buffer, size_t buffer_size) /* {{{ */
-{
- size_t i;
-
- for (i = 0; i < buffer_size; i++)
- {
- if (buffer[i] == 0)
- return;
- if ((!isalnum ((int) buffer[i])) && (buffer[i] != '-'))
- buffer[i] = '_';
- }
-} /* }}} void remove_special */
-
static void submit (time_t ts, const char *plugin_instance, /* {{{ */
const char *type, const char *type_instance, value_t value)
{
if (plugin_instance) {
sstrncpy(vl.plugin_instance, plugin_instance,
sizeof(vl.plugin_instance));
- remove_special (vl.plugin_instance, sizeof (vl.plugin_instance));
+ replace_special (vl.plugin_instance, sizeof (vl.plugin_instance));
}
sstrncpy(vl.type, type, sizeof(vl.type));
if (type_instance) {
sstrncpy(vl.type_instance, type_instance,
sizeof(vl.type_instance));
- remove_special (vl.plugin_instance, sizeof (vl.plugin_instance));
+ replace_special (vl.plugin_instance, sizeof (vl.plugin_instance));
}
plugin_dispatch_values(&vl);
} /* }}} void submit */
--- /dev/null
+=head1 NAME
+
+collectd-java - Documentation of collectd's "java plugin"
+
+=head1 SYNOPSIS
+
+ LoadPlugin "java"
+ <Plugin "java">
+ JVMArg "-verbose:jni"
+ JVMArg "-Djava.class.path=/opt/collectd/lib/collectd/bindings/java"
+
+ LoadPlugin "org.collectd.java.Foobar"
+ <Plugin "org.collectd.java.Foobar">
+ # To be parsed by the plugin
+ </Plugin>
+ </Plugin>
+
+=head1 DESCRIPTION
+
+The I<Java> plugin embeds a I<Java Virtual Machine> (JVM) into I<collectd> and
+provides a Java interface to part of collectd's API. This makes it possible to
+write additions to the daemon in Java.
+
+This plugin is similar in nature to, but shares no code with, the I<Perl>
+plugin by Sebastian Harl, see L<collectd-perl(5)> for details.
+
+=head1 CONFIGURATION
+
+A short outline of this plugin's configuration can be seen in L<"SYNOPSIS">
+above. For a complete list of all configuration options and their semantics
+please read L<collectd.conf(5)/Plugin C<java>>.
+
+=head1 OVERVIEW
+
+When writing additions for collectd in Java, the underlying C base is mostly
+hidden from you. All complex data types are converted to their Java counterparts
+before they're passed to your functions. These Java classes reside in the
+I<org.collectd.api> namespace.
+
+The I<Java> plugin will create one object of each class configured with the
+B<LoadPlugin> option. The constructor of this class can then register "callback
+methods", i.E<nbsp>e. methods that will be called by the daemon when
+appropriate.
+
+The available classes are:
+
+=over 4
+
+=item B<org.collectd.api.Collectd>
+
+All API functions exported to Java are implemented as static functions of this
+class. See L<"EXPORTED API FUNCTIONS"> below.
+
+=item B<org.collectd.api.OConfigValue>
+
+Corresponds to C<oconfig_value_t>, defined in F<src/liboconfig/oconfig.h>.
+
+=item B<org.collectd.api.OConfigItem>
+
+Corresponds to C<oconfig_item_t>, defined in F<src/liboconfig/oconfig.h>.
+
+=item B<org.collectd.api.DataSource>
+
+Corresponds to C<data_source_t>, defined in F<src/plugin.h>.
+
+=item B<org.collectd.api.DataSet>
+
+Corresponds to C<data_set_t>, defined in F<src/plugin.h>.
+
+=item B<org.collectd.api.ValueList>
+
+Corresponds to C<value_list_t>, defined in F<src/plugin.h>.
+
+=item B<org.collectd.api.Notification>
+
+Corresponds to C<notification_t>, defined in F<src/plugin.h>.
+
+=back
+
+In the remainder of this document, we'll use the short form of these names, for
+example B<ValueList>. In order to be able to use these abbreviated names, you
+need to B<import> the classes.
+
+=head1 EXPORTED API FUNCTIONS
+
+All collectd API functions that are available to Java plugins are implemented
+as I<publicE<nbsp>static> functions of the B<Collectd> class. This makes
+calling these functions pretty straight forward. For example, to send an error
+message to the daemon, you'd do something like this:
+
+ Collectd.logError ("That wasn't chicken!");
+
+The following are the currently exported functions.
+
+=head2 registerConfig
+
+Signature: I<int> B<registerConfig> (I<String> name,
+I<CollectdConfigInterface> object);
+
+Registers the B<config> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"config callback"> below.
+
+=head2 registerInit
+
+Signature: I<int> B<registerInit> (I<String> name,
+I<CollectdInitInterface> object);
+
+Registers the B<init> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"init callback"> below.
+
+=head2 registerRead
+
+Signature: I<int> B<registerRead> (I<String> name,
+I<CollectdReadInterface> object)
+
+Registers the B<read> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"read callback"> below.
+
+=head2 registerWrite
+
+Signature: I<int> B<registerWrite> (I<String> name,
+I<CollectdWriteInterface> object)
+
+Registers the B<write> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"write callback"> below.
+
+=head2 registerFlush
+
+Signature: I<int> B<registerFlush> (I<String> name,
+I<CollectdFlushInterface> object)
+
+Registers the B<flush> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"flush callback"> below.
+
+=head2 registerShutdown
+
+Signature: I<int> B<registerShutdown> (I<String> name,
+I<CollectdShutdownInterface> object);
+
+Registers the B<shutdown> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"shutdown callback"> below.
+
+=head2 registerLog
+
+Signature: I<int> B<registerLog> (I<String> name,
+I<CollectdLogInterface> object);
+
+Registers the B<log> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"log callback"> below.
+
+=head2 registerNotification
+
+Signature: I<int> B<registerNotification> (I<String> name,
+I<CollectdNotificationInterface> object);
+
+Registers the B<notification> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"notification callback"> below.
+
+=head2 registerMatch
+
+Signature: I<int> B<registerMatch> (I<String> name,
+I<CollectdMatchFactoryInterface> object);
+
+Registers the B<createMatch> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"match callback"> below.
+
+=head2 registerTarget
+
+Signature: I<int> B<registerTarget> (I<String> name,
+I<CollectdTargetFactoryInterface> object);
+
+Registers the B<createTarget> function of I<object> with the daemon.
+
+Returns zero upon success and non-zero when an error occurred.
+
+See L<"target callback"> below.
+
+=head2 dispatchValues
+
+Signature: I<int> B<dispatchValues> (I<ValueList>)
+
+Passes the values represented by the B<ValueList> object to the
+C<plugin_dispatch_values> function of the daemon. The "data set" (or list of
+"data sources") associated with the object are ignored, because
+C<plugin_dispatch_values> will automatically lookup the required data set. It
+is therefore absolutely okay to leave this blank.
+
+Returns zero upon success or non-zero upon failure.
+
+=head2 getDS
+
+Signature: I<DataSet> B<getDS> (I<String>)
+
+Returns the appropriate I<type> or B<null> if the type is not defined.
+
+=head2 logError
+
+Signature: I<void> B<logError> (I<String>)
+
+Sends a log message with severity B<ERROR> to the daemon.
+
+=head2 logWarning
+
+Signature: I<void> B<logWarning> (I<String>)
+
+Sends a log message with severity B<WARNING> to the daemon.
+
+=head2 logNotice
+
+Signature: I<void> B<logNotice> (I<String>)
+
+Sends a log message with severity B<NOTICE> to the daemon.
+
+=head2 logInfo
+
+Signature: I<void> B<logInfo> (I<String>)
+
+Sends a log message with severity B<INFO> to the daemon.
+
+=head2 logDebug
+
+Signature: I<void> B<logDebug> (I<String>)
+
+Sends a log message with severity B<DEBUG> to the daemon.
+
+=head1 REGISTERING CALLBACKS
+
+When starting up, collectd creates an object of each configured class. The
+constructor of this class should then register "callbacks" with the daemon,
+using the appropriate static functions in B<Collectd>,
+see L<"EXPORTED API FUNCTIONS"> above. To register a callback, the object being
+passed to one of the register functions must implement an appropriate
+interface, which are all in the B<org.collectd.api> namespace.
+
+A constructor may register any number of these callbacks, even none. An object
+without callback methods is never actively called by collectd, but may still
+call the exported API functions. One could, for example, start a new thread in
+the constructor and dispatch (submit to the daemon) values asynchronously,
+whenever one is available.
+
+Each callback method is now explained in more detail:
+
+=head2 config callback
+
+Interface: B<org.collectd.api.CollectdConfigInterface>
+
+Signature: I<int> B<config> (I<OConfigItem> ci)
+
+This method is passed a B<OConfigItem> object, if both, method and
+configuration, are available. B<OConfigItem> is the root of a tree representing
+the configuration for this plugin. The root itself is the representation of the
+B<E<lt>PluginE<nbsp>/E<gt>> block, so in next to all cases the children of the
+root are the first interesting objects.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and the plugin will be disabled entirely.
+
+See L<"registerConfig"> above.
+
+=head2 init callback
+
+Interface: B<org.collectd.api.CollectdInitInterface>
+
+Signature: I<int> B<init> ()
+
+This method is called after the configuration has been handled. It is
+supposed to set up the plugin. e.E<nbsp>g. start threads, open connections, or
+check if can do anything useful at all.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and the plugin will be disabled entirely.
+
+See L<"registerInit"> above.
+
+=head2 read callback
+
+Interface: B<org.collectd.api.CollectdReadInterface>
+
+Signature: I<int> B<read> ()
+
+This method is called periodically and is supposed to gather statistics in
+whatever fashion. These statistics are represented as a B<ValueList> object and
+sent to the daemon using L<dispatchValues|"dispatchValues">.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and cause an appropriate message to be logged.
+Currently, returning non-zero does not have any other effects. In particular,
+Java "read"-methods are not suspended for increasing intervals like C
+"read"-functions.
+
+See L<"registerRead"> above.
+
+=head2 write callback
+
+Interface: B<org.collectd.api.CollectdWriteInterface>
+
+Signature: I<int> B<write> (I<ValueList> vl)
+
+This method is called whenever a value is dispatched to the daemon. The
+corresponding C "write"-functions are passed a C<data_set_t>, so they can
+decide which values are absolute values (gauge) and which are counter values.
+To get the corresponding C<ListE<lt>DataSourceE<gt>>, call the B<getDataSource>
+method of the B<ValueList> object.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and cause an appropriate message to be logged.
+
+See L<"registerWrite"> above.
+
+=head2 flush callback
+
+Interface: B<org.collectd.api.CollectdFlushInterface>
+
+Signature: I<int> B<flush> (I<int> timeout, I<String> identifier)
+
+This method is called when the daemon received a flush command. This can either
+be done using the C<USR1> signal (see L<collectd(1)>) or using the I<unixsock>
+plugin (see L<collectd-unixsock(5)>).
+
+If I<timeout> is greater than zero, only values older than this number of
+seconds should be flushed. To signal that all values should be flushed
+regardless of age, this argument is set to a negative number.
+
+The I<identifier> specifies which value should be flushed. If it is not
+possible to flush one specific value, flush all values. To signal that all
+values should be flushed, this argument is set to I<null>.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and cause an appropriate message to be logged.
+
+See L<"registerFlush"> above.
+
+=head2 shutdown callback
+
+Interface: B<org.collectd.api.CollectdShutdownInterface>
+
+Signature: I<int> B<shutdown> ()
+
+This method is called when the daemon is shutting down. You should not rely on
+the destructor to clean up behind the object but use this function instead.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and cause an appropriate message to be logged.
+
+See L<"registerShutdown"> above.
+
+=head2 log callback
+
+Interface: B<org.collectd.api.CollectdLogInterface>
+
+Signature: I<void> B<log> (I<int> severity, I<String> message)
+
+This callback can be used to receive log messages from the daemon.
+
+The argument I<severity> is one of:
+
+=over 4
+
+=item *
+
+org.collectd.api.Collectd.LOG_ERR
+
+=item *
+
+org.collectd.api.Collectd.LOG_WARNING
+
+=item *
+
+org.collectd.api.Collectd.LOG_NOTICE
+
+=item *
+
+org.collectd.api.Collectd.LOG_INFO
+
+=item *
+
+org.collectd.api.Collectd.LOG_DEBUG
+
+=back
+
+The function does not return any value.
+
+See L<"registerLog"> above.
+
+=head2 notification callback
+
+Interface: B<org.collectd.api.CollectdNotificationInterface>
+
+Signature: I<int> B<notification> (I<Notification> n)
+
+This callback can be used to receive notifications from the daemon.
+
+To signal success, this method has to return zero. Anything else will be
+considered an error condition and cause an appropriate message to be logged.
+
+See L<"registerNotification"> above.
+
+=head2 match callback
+
+The match (and target, see L<"target callback"> below) callbacks work a bit
+different from the other callbacks above: You don't register a match callback
+with the daemon directly, but you register a function which, when called,
+creates an appropriate object. The object creating the "match" objects is
+called "match factory".
+
+See L<"registerMatch"> above.
+
+=head3 Factory object
+
+Interface: B<org.collectd.api.CollectdMatchFactoryInterface>
+
+Signature: I<CollectdMatchInterface> B<createMatch>
+(I<OConfigItem> ci);
+
+Called by the daemon to create "match" objects.
+
+Returns: A new object which implements the B<CollectdMatchInterface> interface.
+
+=head3 Match object
+
+Interface: B<org.collectd.api.CollectdMatchInterface>
+
+Signature: I<int> B<match> (I<DataSet> ds, I<ValueList> vl);
+
+Called when processing a chain to determine whether or not a I<ValueList>
+matches. How values are matches is up to the implementing class.
+
+Has to return one of:
+
+=over 4
+
+=item *
+
+B<Collectd.FC_MATCH_NO_MATCH>
+
+=item *
+
+B<Collectd.FC_MATCH_MATCHES>
+
+=back
+
+=head2 target callback
+
+The target (and match, see L<"match callback"> above) callbacks work a bit
+different from the other callbacks above: You don't register a target callback
+with the daemon directly, but you register a function which, when called,
+creates an appropriate object. The object creating the "target" objects is
+called "target factory".
+
+See L<"registerTarget"> above.
+
+=head3 Factory object
+
+Interface: B<org.collectd.api.CollectdTargetFactoryInterface>
+
+Signature: I<CollectdTargetInterface> B<createTarget>
+(I<OConfigItem> ci);
+
+Called by the daemon to create "target" objects.
+
+Returns: A new object which implements the B<CollectdTargetInterface>
+interface.
+
+=head3 Target object
+
+Interface: B<org.collectd.api.CollectdTargetInterface>
+
+Signature: I<int> B<invoke> (I<DataSet> ds, I<ValueList> vl);
+
+Called when processing a chain to perform some action. The action performed is
+up to the implementing class.
+
+Has to return one of:
+
+=over 4
+
+=item *
+
+B<Collectd.FC_TARGET_CONTINUE>
+
+=item *
+
+B<Collectd.FC_TARGET_STOP>
+
+=item *
+
+B<Collectd.FC_TARGET_RETURN>
+
+=back
+
+=head1 EXAMPLE
+
+This short example demonstrates how to register a read callback with the
+daemon:
+
+ import org.collectd.api.Collectd;
+ import org.collectd.api.ValueList;
+
+ import org.collectd.api.CollectdReadInterface;
+
+ public class Foobar implements CollectdReadInterface
+ {
+ public Foobar ()
+ {
+ Collectd.registerRead ("Foobar", this);
+ }
+
+ public int read ()
+ {
+ ValueList vl;
+
+ /* Do something... */
+
+ Collectd.dispatchValues (vl);
+ }
+ }
+
+=head1 SEE ALSO
+
+L<collectd(1)>,
+L<collectd.conf(5)>,
+L<collectd-perl(5)>,
+L<types.db(5)>
+
+=head1 AUTHOR
+
+Florian Forster E<lt>octoE<nbsp>atE<nbsp>verplant.orgE<gt>
+
file which are automatically registered with collectd - see L<types.db(5)> for
a description of the format of this file.
+B<Note>: Using B<plugin_register> to register a data-set is deprecated. Add
+the new type to a custom L<types.db(5)> file instead. This functionality might
+be removed in a future version of collectd.
+
If the I<type> argument is any of the other types (B<TYPE_INIT>, B<TYPE_READ>,
...) then I<data> is expected to be a function name. If the name is not
prefixed with the plugin's package name collectd will add it automatically.
=item B<Interval> I<Seconds>
-Collect data from this host every I<Seconds> seconds. This value needs to be a
-multiple of the global B<Interval> setting and, if it is not, will be rounded
-B<down> to one and a warning is logged in this case. So if your global
-B<Interval> is set to I<10> and you configure I<25> here, it's rounded down to
-I<20>. By default the global B<Interval> setting will be used.
-
-This option is meant for devices with not much CPU power, e.E<nbsp>g. network
-equipment such as switches, embedded devices, rack monitoring systems and so
-on. Since the B<Step> of generated RRD files depends on this setting it's
-wise to select a reasonable value once and never change it.
+Collect data from this host every I<Seconds> seconds. This option is meant for
+devices with not much CPU power, e.E<nbsp>g. network equipment such as
+switches, embedded devices, rack monitoring systems and so on. Since the
+B<Step> of generated RRD files depends on this setting it's wise to select a
+reasonable value once and never change it.
=back
# http://collectd.org/
#
+##############################################################################
+# Global #
+#----------------------------------------------------------------------------#
+# Global settings for the daemon. #
+##############################################################################
+
#Hostname "localhost"
FQDNLookup true
#BaseDir "@prefix@/var/lib/@PACKAGE_NAME@"
#Interval 10
#ReadThreads 5
-@BUILD_PLUGIN_LOGFILE_TRUE@LoadPlugin logfile
-@BUILD_PLUGIN_SYSLOG_TRUE@LoadPlugin syslog
+##############################################################################
+# Logging #
+#----------------------------------------------------------------------------#
+# Plugins which provide logging functions should be loaded first, so log #
+# messages generated when loading or configuring other plugins can be #
+# accessed. #
+##############################################################################
+
+@LOAD_PLUGIN_SYSLOG@LoadPlugin syslog
+@LOAD_PLUGIN_LOGFILE@LoadPlugin logfile
#<Plugin logfile>
-# LogLevel info
+# LogLevel @DEFAULT_LOG_LEVEL@
# File STDOUT
# Timestamp true
#</Plugin>
#<Plugin syslog>
-# LogLevel info
-#</Plugin>
-
-@BUILD_PLUGIN_APACHE_TRUE@LoadPlugin apache
-@BUILD_PLUGIN_APCUPS_TRUE@LoadPlugin apcups
-@BUILD_PLUGIN_APPLE_SENSORS_TRUE@LoadPlugin apple_sensors
-@BUILD_PLUGIN_ASCENT_TRUE@LoadPlugin ascent
-@BUILD_PLUGIN_BATTERY_TRUE@LoadPlugin battery
-@BUILD_PLUGIN_BIND_TRUE@LoadPlugin bind
-@BUILD_PLUGIN_CPU_TRUE@LoadPlugin cpu
-@BUILD_PLUGIN_CPUFREQ_TRUE@LoadPlugin cpufreq
-@BUILD_PLUGIN_CSV_TRUE@LoadPlugin csv
-@BUILD_PLUGIN_CURL_TRUE@LoadPlugin curl
-@BUILD_PLUGIN_DBI_TRUE@LoadPlugin dbi
-@BUILD_PLUGIN_DF_TRUE@LoadPlugin df
-@BUILD_PLUGIN_DISK_TRUE@LoadPlugin disk
-@BUILD_PLUGIN_DNS_TRUE@LoadPlugin dns
-@BUILD_PLUGIN_EMAIL_TRUE@LoadPlugin email
-@BUILD_PLUGIN_ENTROPY_TRUE@LoadPlugin entropy
-@BUILD_PLUGIN_EXEC_TRUE@LoadPlugin exec
-@BUILD_PLUGIN_FILECOUNT_TRUE@LoadPlugin filecount
-@BUILD_PLUGIN_HDDTEMP_TRUE@LoadPlugin hddtemp
-@BUILD_PLUGIN_INTERFACE_TRUE@LoadPlugin interface
-@BUILD_PLUGIN_IPTABLES_TRUE@LoadPlugin iptables
-@BUILD_PLUGIN_IPMI_TRUE@LoadPlugin ipmi
-@BUILD_PLUGIN_IPVS_TRUE@LoadPlugin ipvs
-@BUILD_PLUGIN_IRQ_TRUE@LoadPlugin irq
-@BUILD_PLUGIN_LIBVIRT_TRUE@LoadPlugin libvirt
-@BUILD_PLUGIN_LOAD_TRUE@LoadPlugin load
-@BUILD_PLUGIN_MBMON_TRUE@LoadPlugin mbmon
-@BUILD_PLUGIN_MEMCACHED_TRUE@LoadPlugin memcached
-@BUILD_PLUGIN_MEMORY_TRUE@LoadPlugin memory
-@BUILD_PLUGIN_MULTIMETER_TRUE@LoadPlugin multimeter
-@BUILD_PLUGIN_MYSQL_TRUE@LoadPlugin mysql
-@BUILD_PLUGIN_NETLINK_TRUE@LoadPlugin netlink
-@BUILD_PLUGIN_NETWORK_TRUE@LoadPlugin network
-@BUILD_PLUGIN_NFS_TRUE@LoadPlugin nfs
-@BUILD_PLUGIN_NGINX_TRUE@LoadPlugin nginx
-@BUILD_PLUGIN_NOTIFY_DESKTOP_TRUE@LoadPlugin notify_desktop
-@BUILD_PLUGIN_NOTIFY_EMAIL_TRUE@LoadPlugin notify_email
-@BUILD_PLUGIN_NTPD_TRUE@LoadPlugin ntpd
-@BUILD_PLUGIN_NUT_TRUE@LoadPlugin nut
-@BUILD_PLUGIN_ONEWIRE_TRUE@LoadPlugin onewire
-@BUILD_PLUGIN_OPENVPN_TRUE@LoadPlugin openvpn
-@BUILD_PLUGIN_ORACLE_TRUE@LoadPlugin oracle
-@BUILD_PLUGIN_PERL_TRUE@LoadPlugin perl
-@BUILD_PLUGIN_PING_TRUE@LoadPlugin ping
-@BUILD_PLUGIN_POSTGRESQL_TRUE@LoadPlugin postgresql
-@BUILD_PLUGIN_POWERDNS_TRUE@LoadPlugin powerdns
-@BUILD_PLUGIN_PROCESSES_TRUE@LoadPlugin processes
-@BUILD_PLUGIN_RRDCACHED_TRUE@LoadPlugin rrdcached
-@BUILD_PLUGIN_RRDTOOL_TRUE@LoadPlugin rrdtool
-@BUILD_PLUGIN_SENSORS_TRUE@LoadPlugin sensors
-@BUILD_PLUGIN_SERIAL_TRUE@LoadPlugin serial
-@BUILD_PLUGIN_SNMP_TRUE@LoadPlugin snmp
-@BUILD_PLUGIN_SWAP_TRUE@LoadPlugin swap
-@BUILD_PLUGIN_TAIL_TRUE@LoadPlugin tail
-@BUILD_PLUGIN_TAPE_TRUE@LoadPlugin tape
-@BUILD_PLUGIN_TCPCONNS_TRUE@LoadPlugin tcpconns
-@BUILD_PLUGIN_TEAMSPEAK2_TRUE@LoadPlugin teamspeak2
-@BUILD_PLUGIN_THERMAL_TRUE@LoadPlugin thermal
-@BUILD_PLUGIN_UNIXSOCK_TRUE@LoadPlugin unixsock
-@BUILD_PLUGIN_USERS_TRUE@LoadPlugin users
-#LoadPlugin uuid
-@BUILD_PLUGIN_VMEM_TRUE@LoadPlugin vmem
-@BUILD_PLUGIN_VSERVER_TRUE@LoadPlugin vserver
-@BUILD_PLUGIN_WIRELESS_TRUE@LoadPlugin wireless
-@BUILD_PLUGIN_XMMS_TRUE@LoadPlugin xmms
+# LogLevel @DEFAULT_LOG_LEVEL@
+#</Plugin>
+
+##############################################################################
+# LoadPlugin section #
+#----------------------------------------------------------------------------#
+# Lines beginning with a single `#' belong to plugins which have been built #
+# but are disabled by default. #
+# #
+# Lines begnning with `##' belong to plugins which have not been built due #
+# to missing dependencies or because they have been deactivated explicitly. #
+##############################################################################
+
+#@BUILD_PLUGIN_APACHE_TRUE@LoadPlugin apache
+#@BUILD_PLUGIN_APCUPS_TRUE@LoadPlugin apcups
+#@BUILD_PLUGIN_APPLE_SENSORS_TRUE@LoadPlugin apple_sensors
+#@BUILD_PLUGIN_ASCENT_TRUE@LoadPlugin ascent
+#@BUILD_PLUGIN_BATTERY_TRUE@LoadPlugin battery
+#@BUILD_PLUGIN_BIND_TRUE@LoadPlugin bind
+@BUILD_PLUGIN_CPU_TRUE@@BUILD_PLUGIN_CPU_TRUE@LoadPlugin cpu
+#@BUILD_PLUGIN_CPUFREQ_TRUE@LoadPlugin cpufreq
+@LOAD_PLUGIN_CSV@LoadPlugin csv
+#@BUILD_PLUGIN_CURL_TRUE@LoadPlugin curl
+#@BUILD_PLUGIN_DBI_TRUE@LoadPlugin dbi
+#@BUILD_PLUGIN_DF_TRUE@LoadPlugin df
+#@BUILD_PLUGIN_DISK_TRUE@LoadPlugin disk
+#@BUILD_PLUGIN_DNS_TRUE@LoadPlugin dns
+#@BUILD_PLUGIN_EMAIL_TRUE@LoadPlugin email
+#@BUILD_PLUGIN_ENTROPY_TRUE@LoadPlugin entropy
+#@BUILD_PLUGIN_EXEC_TRUE@LoadPlugin exec
+#@BUILD_PLUGIN_FILECOUNT_TRUE@LoadPlugin filecount
+#@BUILD_PLUGIN_GMOND_TRUE@LoadPlugin gmond
+#@BUILD_PLUGIN_HDDTEMP_TRUE@LoadPlugin hddtemp
+@BUILD_PLUGIN_INTERFACE_TRUE@@BUILD_PLUGIN_INTERFACE_TRUE@LoadPlugin interface
+#@BUILD_PLUGIN_IPTABLES_TRUE@LoadPlugin iptables
+#@BUILD_PLUGIN_IPMI_TRUE@LoadPlugin ipmi
+#@BUILD_PLUGIN_IPVS_TRUE@LoadPlugin ipvs
+#@BUILD_PLUGIN_IRQ_TRUE@LoadPlugin irq
+#@BUILD_PLUGIN_JAVA_TRUE@LoadPlugin java
+#@BUILD_PLUGIN_LIBVIRT_TRUE@LoadPlugin libvirt
+@BUILD_PLUGIN_LOAD_TRUE@@BUILD_PLUGIN_LOAD_TRUE@LoadPlugin load
+#@BUILD_PLUGIN_MBMON_TRUE@LoadPlugin mbmon
+#@BUILD_PLUGIN_MEMCACHED_TRUE@LoadPlugin memcached
+@BUILD_PLUGIN_MEMORY_TRUE@@BUILD_PLUGIN_MEMORY_TRUE@LoadPlugin memory
+#@BUILD_PLUGIN_MULTIMETER_TRUE@LoadPlugin multimeter
+#@BUILD_PLUGIN_MYSQL_TRUE@LoadPlugin mysql
+#@BUILD_PLUGIN_NETLINK_TRUE@LoadPlugin netlink
+@LOAD_PLUGIN_NETWORK@LoadPlugin network
+#@BUILD_PLUGIN_NFS_TRUE@LoadPlugin nfs
+#@BUILD_PLUGIN_NGINX_TRUE@LoadPlugin nginx
+#@BUILD_PLUGIN_NOTIFY_DESKTOP_TRUE@LoadPlugin notify_desktop
+#@BUILD_PLUGIN_NOTIFY_EMAIL_TRUE@LoadPlugin notify_email
+#@BUILD_PLUGIN_NTPD_TRUE@LoadPlugin ntpd
+#@BUILD_PLUGIN_NUT_TRUE@LoadPlugin nut
+#@BUILD_PLUGIN_ONEWIRE_TRUE@LoadPlugin onewire
+#@BUILD_PLUGIN_OPENVPN_TRUE@LoadPlugin openvpn
+#@BUILD_PLUGIN_ORACLE_TRUE@LoadPlugin oracle
+#@BUILD_PLUGIN_PERL_TRUE@LoadPlugin perl
+#@BUILD_PLUGIN_PING_TRUE@LoadPlugin ping
+#@BUILD_PLUGIN_POSTGRESQL_TRUE@LoadPlugin postgresql
+#@BUILD_PLUGIN_POWERDNS_TRUE@LoadPlugin powerdns
+#@BUILD_PLUGIN_PROCESSES_TRUE@LoadPlugin processes
+#@BUILD_PLUGIN_PROTOCOLS_TRUE@LoadPlugin protocols
+#@BUILD_PLUGIN_RRDCACHED_TRUE@LoadPlugin rrdcached
+@LOAD_PLUGIN_RRDTOOL@LoadPlugin rrdtool
+#@BUILD_PLUGIN_SENSORS_TRUE@LoadPlugin sensors
+#@BUILD_PLUGIN_SERIAL_TRUE@LoadPlugin serial
+#@BUILD_PLUGIN_SNMP_TRUE@LoadPlugin snmp
+#@BUILD_PLUGIN_SWAP_TRUE@LoadPlugin swap
+#@BUILD_PLUGIN_TAIL_TRUE@LoadPlugin tail
+#@BUILD_PLUGIN_TAPE_TRUE@LoadPlugin tape
+#@BUILD_PLUGIN_TCPCONNS_TRUE@LoadPlugin tcpconns
+#@BUILD_PLUGIN_TEAMSPEAK2_TRUE@LoadPlugin teamspeak2
+#@BUILD_PLUGIN_THERMAL_TRUE@LoadPlugin thermal
+#@BUILD_PLUGIN_UNIXSOCK_TRUE@LoadPlugin unixsock
+#@BUILD_PLUGIN_UPTIME_TRUE@LoadPlugin uptime
+#@BUILD_PLUGIN_USERS_TRUE@LoadPlugin users
+#@BUILD_PLUGIN_UUID_TRUE@LoadPlugin uuid
+#@BUILD_PLUGIN_VMEM_TRUE@LoadPlugin vmem
+#@BUILD_PLUGIN_VSERVER_TRUE@LoadPlugin vserver
+#@BUILD_PLUGIN_WIRELESS_TRUE@LoadPlugin wireless
+#@BUILD_PLUGIN_XMMS_TRUE@LoadPlugin xmms
+
+##############################################################################
+# Plugin configuration #
+#----------------------------------------------------------------------------#
+# In this section configuration stubs for each plugin are provided. A desc- #
+# ription of those options is available in the collectd.conf(5) manual page. #
+##############################################################################
#<Plugin apache>
# URL "http://localhost/status?auto"
# </Directory>
#</Plugin>
-@BUILD_PLUGIN_HDDTEMP_TRUE@<Plugin hddtemp>
-# Host "127.0.0.1"
-# Port "7634"
-@BUILD_PLUGIN_HDDTEMP_TRUE@ TranslateDevicename false
-@BUILD_PLUGIN_HDDTEMP_TRUE@</Plugin>
+#<Plugin "gmond">
+# MCReceiveFrom "239.2.11.71" "8649"
+# <Metric "swap_total">
+# Type "swap"
+# TypeInstance "total"
+# DataSource "value"
+# </Metric>
+# <Metric "swap_free">
+# Type "swap"
+# TypeInstance "free"
+# DataSource "value"
+# </Metric>
+#</Plugin>
+
+#<Plugin hddtemp>
+# Host "127.0.0.1"
+# Port "7634"
+#
+# #----------------------------------------------------------------#
+# # `TranslateDevicename' enabled backwards compatibility behavior #
+# # and is enabled by default. Setting this option to `false' is #
+# # highly recommended. #
+# #----------------------------------------------------------------#
+# TranslateDevicename false
+#</Plugin>
#<Plugin interface>
# Interface "eth0"
# IgnoreSelected true
#</Plugin>
+#<Plugin "java">
+# JVMArg "-verbose:jni"
+# JVMArg "-Djava.class.path=/opt/collectd/lib/collectd/bindings/java"
+#
+# LoadPlugin "org.collectd.java.Foobar"
+# <Plugin "org.collectd.java.Foobar">
+# # To be parsed by the plugin
+# </Plugin>
+#</Plugin>
+
#<Plugin libvirt>
# Connection "xen:///"
# RefreshInterval 60
#</Plugin>
#<Plugin mysql>
-# Host "database.serv.er"
-# User "db_user"
-# Password "secret"
-# Database "db_name"
+# <Database db_name>
+# Host "database.serv.er"
+# User "db_user"
+# Password "secret"
+# Database "db_name"
+# MasterStats true
+# </Database>
+#
+# <Database db_name2>
+# Host "localhost"
+# Socket "/var/run/mysql/mysqld.sock"
+# SlaveStats true
+# SlaveNotifications true
+# </Database>
#</Plugin>
#<Plugin netlink>
# IgnoreSelected false
#</Plugin>
-# Server "ff18::efc0:4a42" "25826"
-# Server "239.192.74.66" "25826"
+
@LOAD_PLUGIN_NETWORK@<Plugin network>
+@LOAD_PLUGIN_NETWORK@ Server "ff18::efc0:4a42" "25826"
+@LOAD_PLUGIN_NETWORK@ Server "239.192.74.66" "25826"
# Listen "ff18::efc0:4a42" "25826"
# Listen "239.192.74.66" "25826"
# TimeToLive "128"
# Forward false
# CacheFlush 1800
-#</Plugin>
+@LOAD_PLUGIN_NETWORK@</Plugin>
#<Plugin nginx>
# URL "http://localhost/status?auto"
# Process "name"
#</Plugin>
+#<Plugin protocols>
+# Value "/^Tcp:/"
+# IgnoreSelected false
+#</Plugin>
+
#<Plugin rrdcached>
# DaemonAddress "unix:/tmp/rrdcached.sock"
# DataDir "@prefix@/var/lib/@PACKAGE_NAME@/rrd"
# Instance "IF-MIB::ifDescr"
# Values "IF-MIB::ifInOctets" "IF-MIB::ifOutOctets"
# </Data>
-#
+#
# <Host "some.switch.mydomain.org">
# Address "192.168.0.2"
# Version 1
# Verbose false
#</Plugin>
-# * * * * * * * * * * * * *
-# * FILTER CONFIGURATION *
-# * * * * * * * * * * * * *
-
-# The following configures collectd's filtering mechanism. Before changing
-# anything in this section, please read the `FILTER CONFIGURATION' section in
-# the collectd.conf(5) manual page.
+##############################################################################
+# Filter configuration #
+#----------------------------------------------------------------------------#
+# The following configures collectd's filtering mechanism. Before changing #
+# anything in this section, please read the `FILTER CONFIGURATION' section #
+# in the collectd.conf(5) manual page. #
+##############################################################################
# Load required matches:
#@BUILD_PLUGIN_MATCH_REGEX_TRUE@LoadPlugin match_regex
#@BUILD_PLUGIN_TARGET_NOTIFICATION_TRUE@LoadPlugin target_notification
#@BUILD_PLUGIN_TARGET_REPLACE_TRUE@LoadPlugin target_replace
#@BUILD_PLUGIN_TARGET_SET_TRUE@LoadPlugin target_set
-
-# The following block demonstrates the default behavior if no filtering is
-# configured at all: All values will be sent to all available write plugins.
+
+#----------------------------------------------------------------------------#
+# The following block demonstrates the default behavior if no filtering is #
+# configured at all: All values will be sent to all available write plugins. #
+#----------------------------------------------------------------------------#
#<Chain "Main">
# Target "write"
Specifies the columns whose values will be used to create the "type-instance"
for each row. If you specify more than one column, the value of all columns
-will be join together with the dashes I<("-")> as separation character.
+will be joined together with dashes I<("-")> as separation characters.
The plugin itself does not check whether or not all built instances are
different. It's your responsibility to assure that each is unique. This is
=back
+=head2 Plugin C<gmond>
+
+The I<gmond> plugin received the multicast traffic sent by B<gmond>, the
+statistics collection daemon of Ganglia. Mappings for the standard "metrics"
+are built-in, custom mappings may be added via B<Metric> blocks, see below.
+
+Synopsis:
+
+ <Plugin "gmond">
+ MCReceiveFrom "239.2.11.71" "8649"
+ <Metric "swap_total">
+ Type "swap"
+ TypeInstance "total"
+ DataSource "value"
+ </Metric>
+ <Metric "swap_free">
+ Type "swap"
+ TypeInstance "free"
+ DataSource "value"
+ </Metric>
+ </Plugin>
+
+The following metrics are built-in:
+
+=over 4
+
+=item *
+
+load_one, load_five, load_fifteen
+
+=item *
+
+cpu_user, cpu_system, cpu_idle, cpu_nice, cpu_wio
+
+=item *
+
+mem_free, mem_shared, mem_buffers, mem_cached, mem_total
+
+=item *
+
+bytes_in, bytes_out
+
+=item *
+
+pkts_in, pkts_out
+
+=back
+
+Available configuration options:
+
+=over 4
+
+=item B<MCReceiveFrom> I<MCGroup> [I<Port>]
+
+Sets sets the multicast group and UDP port to which to subscribe.
+
+Default: B<239.2.11.71>E<nbsp>/E<nbsp>B<8649>
+
+=item E<lt>B<Metric> I<Name>E<gt>
+
+These blocks add a new metric conversion to the internal table. I<Name>, the
+string argument to the B<Metric> block, is the metric name as used by Ganglia.
+
+=over 4
+
+=item B<Type> I<Type>
+
+Type to map this metric to. Required.
+
+=item B<TypeInstance> I<Instance>
+
+Type-instance to use. Optional.
+
+=item B<DataSource> I<Name>
+
+Data source to map this metric to. If the configured type has exactly one data
+source, this is optional. Otherwise the option is required.
+
+=back
+
+=back
+
=head2 Plugin C<hddtemp>
To get values from B<hddtemp> collectd connects to B<localhost> (127.0.0.1),
=back
+=head2 Plugin C<java>
+
+The I<Java> plugin makes it possible to write extensions for collectd in Java.
+This section only discusses the syntax and semantic of the configuration
+options. For more in-depth information on the I<Java> plugin, please read
+L<collectd-java(5)>.
+
+Synopsis:
+
+ <Plugin "java">
+ JVMArg "-verbose:jni"
+ JVMArg "-Djava.class.path=/opt/collectd/lib/collectd/bindings/java"
+ LoadPlugin "org.collectd.java.Foobar"
+ <Plugin "org.collectd.java.Foobar">
+ # To be parsed by the plugin
+ </Plugin>
+ </Plugin>
+
+Available configuration options:
+
+=over 4
+
+=item B<JVMArg> I<Argument>
+
+Argument that is to be passed to the I<Java Virtual Machine> (JVM). This works
+exactly the way the arguments to the I<java> binary on the command line work.
+Execute C<javaE<nbsp>--help> for details.
+
+Please note that B<all> these options must appear B<before> (i.E<nbsp>e. above)
+any other options! When another option is found, the JVM will be started and
+later options will have to be ignored!
+
+=item B<LoadPlugin> I<JavaClass>
+
+Instantiates a new I<JavaClass> object. The constructor of this object very
+likely then registers one or more callback methods with the server.
+
+See L<collectd-java(5)> for details.
+
+When the first such option is found, the virtual machine (JVM) is created. This
+means that all B<JVMArg> options must appear before (i.E<nbsp>e. above) all
+B<LoadPlugin> options!
+
+=item B<Plugin> I<Name>
+
+The entire block is passed to the Java plugin as an
+I<org.collectd.api.OConfigItem> object.
+
+For this to work, the plugin has to register a configuration callback first,
+see L<collectd-java(5)/"config callback">. This means, that the B<Plugin> block
+must appear after the appropriate B<LoadPlugin> block. Also note, that I<Name>
+depends on the (Java) plugin registering the callback and is completely
+independent from the I<JavaClass> argument passed to B<LoadPlugin>.
+
+=back
+
=head2 Plugin C<libvirt>
This plugin allows CPU, disk and network load to be collected for virtualized
=head2 Plugin C<mysql>
-The C<mysql plugin> requires B<mysqlclient> to be installed. It connects to the
-database when started and keeps the connection up as long as possible. When the
-connection is interrupted for whatever reason it will try to re-connect. The
-plugin will complaint loudly in case anything goes wrong.
+The C<mysql plugin> requires B<mysqlclient> to be installed. It connects to
+one or more databases when started and keeps the connection up as long as
+possible. When the connection is interrupted for whatever reason it will try
+to re-connect. The plugin will complaint loudly in case anything goes wrong.
+
+This plugin issues the MySQL C<SHOW STATUS> / C<SHOW GLOBAL STATUS> command
+and collects information about MySQL network traffic, executed statements,
+requests, the query cache and threads by evaluating the
+C<Bytes_{received,sent}>, C<Com_*>, C<Handler_*>, C<Qcache_*> and C<Threads_*>
+return values. Please refer to the B<MySQL reference manual>, I<5.1.6. Server
+Status Variables> for an explanation of these values.
+
+Optionally, master and slave statistics may be collected in a MySQL
+replication setup. In that case, information about the synchronization state
+of the nodes are collected by evaluating the C<Position> return value of the
+C<SHOW MASTER STATUS> command and the C<Seconds_Behind_Master>,
+C<Read_Master_Log_Pos> and C<Exec_Master_Log_Pos> return values of the
+C<SHOW SLAVE STATUS> command. See the B<MySQL reference manual>,
+I<12.5.5.21 SHOW MASTER STATUS Syntax> and
+I<12.5.5.31 SHOW SLAVE STATUS Syntax> for details.
-This plugin issues the MySQL C<SHOW STATUS> command and collects information
-about MySQL network traffic, executed statements, requests, the query cache
-and threads by evaluating the C<Bytes_{received,sent}>, C<Com_*>,
-C<Handler_*>, C<Qcache_*> and C<Threads_*> return values. Please refer to the
-B<MySQL reference manual>, I<5.1.6. Server Status Variables> for an
-explanation of these values.
+Synopsis:
-Use the following options to configure the plugin:
+ <Plugin mysql>
+ <Database foo>
+ Host "hostname"
+ User "username"
+ Password "password"
+ Port "3306"
+ MasterStats true
+ </Database>
+
+ <Database bar>
+ Host "localhost"
+ Socket "/var/run/mysql/mysqld.sock"
+ SlaveStats true
+ SlaveNotifications true
+ </Database>
+ </Plugin>
+
+A B<Database> block defines one connection to a MySQL database. It accepts a
+single argument which specifies the name of the database. None of the other
+options are required. MySQL will use default values as documented in the
+section "mysql_real_connect()" in the B<MySQL reference manual>.
=over 4
Otherwise, use the B<Port> option above. See the documentation for the
C<mysql_real_connect> function for details.
+=item B<MasterStats> I<true|false>
+
+=item B<SlaveStats> I<true|false>
+
+Enable the collection of master / slave statistics in a replication setup.
+
+=item B<SlaveNotifications> I<true|false>
+
+If enabled, the plugin sends a notification if the replication slave I/O and /
+or SQL threads are not running.
+
=back
=head2 Plugin C<netlink>
using a numeric port number or a service name. If the argument is omitted the
default port B<25826> is assumed.
+Both, B<Server> and B<Listen> can be used as block, too, to provide
+configuration options for this socket only. For example:
+
+ <Plugin "network">
+ <Server "my.server.tld">
+ SecurityLevel "sign"
+ Secret "ohl0eQue"
+ </Server>
+ </Plugin>
+
+The following options are understood within B<E<lt>ServerE<gt>> and
+B<E<lt>ListenE<gt>> blocks:
+
+=over 4
+
+=item B<SecurityLevel> B<Encrypt>|B<Sign>|B<None>
+
+Set the security you require for network communication. When the security level
+has been set to B<Encrypt>, data sent over the network will be encrypted using
+I<AES-256> and only encrypted data will be accepted when receiving. When set to
+B<Sign>, transmitted data is signed using I<SHA-256> and only signed and
+encrypted data is accepted when receiving. When set to B<None>, data is sent
+without any security and all data is accepted when receiving.
+
+This feature is only available if the I<network> plugin was linked with
+I<libgcrypt>.
+
+=item B<Secret> I<Secret>
+
+Sets a shared secret for this socket. All security levels except B<None>
+require this setting. For B<None> this setting is only required if you want to
+be able to decrypt encrypted data (B<SecurityLevel> is set to B<Encrypt> on the
+client).
+
+This feature is only available if the I<network> plugin was linked with
+I<libgcrypt>.
+
+=back
+
=item B<TimeToLive> I<1-255>
Set the time-to-live of sent packets. This applies to all, unicast and
B<Sensor> is inverted: All selected interfaces are ignored and all other
interfaces are collected.
+=item B<Interval> I<Seconds>
+
+Sets the interval in which all sensors should be read. If not specified, the
+global B<Interval> setting is used.
+
=back
B<EXPERIMENTAL!> The C<onewire> plugin is experimental, because it doesn't yet
=head2 Plugin C<ping>
+The I<Ping> plugin starts a new thread which sends ICMP "ping" packets to the
+configured hosts periodically and measures the network latency. Whenever the
+C<read> function of the plugin is called, it submits the average latency, the
+standard deviation and the drop rate for each host.
+
+Available configuration options:
+
=over 4
=item B<Host> I<IP-address>
Host to ping periodically. This option may be repeated several times to ping
multiple hosts.
+=item B<Interval> I<Seconds>
+
+Sets the interval in which to send ICMP echo packets to the configured hosts.
+This is B<not> the interval in which statistics are queries from the plugin but
+the interval in which the hosts are "pinged". Therefore, the setting here
+should be smaller than or equal to the global B<Interval> setting. Fractional
+times, such as "1.24" are allowed.
+
+Default: B<1.0>
+
+=item B<Timeout> I<Seconds>
+
+Time to wait for a response from the host to which an ICMP packet had been
+sent. If a reply was not received after I<Seconds> seconds, the host is assumed
+to be down or the packet to be dropped. This setting must be smaller than the
+B<Interval> setting above for the plugin to work correctly. Fractional
+arguments are accepted.
+
+Default: B<0.9>
+
=item B<TTL> I<0-255>
Sets the Time-To-Live of generated ICMP packets.
=back
+=head2 Plugin C<protocols>
+
+Collects a lot of information about various network protocols, such as I<IP>,
+I<TCP>, I<UDP>, etc.
+
+Available configuration options:
+
+=over 4
+
+=item B<Value> I<Selector>
+
+Selects whether or not to select a specific value. The string being matched is
+of the form "I<Protocol>:I<ValueName>", where I<Protocol> will be used as the
+plugin instance and I<ValueName> will be used as type instance. An example of
+the string being used would be C<Tcp:RetransSegs>.
+
+You can use regular expressions to match a large number of values with just one
+configuration option. To select all "extended" I<TCP> values, you could use the
+following statement:
+
+ Value "/^TcpExt:/"
+
+Whether only matched values are selected or all matched values are ignored
+depends on the B<IgnoreSelected>. By default, only matched values are selected.
+If no value is configured at all, all values will be selected.
+
+=item B<IgnoreSelected> B<true>|B<false>
+
+If set to B<true>, inverts the selection made by B<Value>, i.E<nbsp>e. all
+matching values will be ignored.
+
+=back
+
=head2 Plugin C<rrdcached>
The C<rrdcached> plugin uses the RRDTool accelerator daemon, L<rrdcached(1)>,
=back
+=head2 Plugin C<table>
+
+The C<table plugin> provides generic means to parse tabular data and dispatch
+user specified values. Values are selected based on column numbers. For
+example, this plugin may be used to get values from the Linux L<proc(5)>
+filesystem or CSV (comma separated values) files.
+
+ <Plugin table>
+ <Table "/proc/slabinfo">
+ Instance "slabinfo"
+ Separator " "
+ <Result>
+ Type gauge
+ InstancePrefix "active_objs"
+ InstancesFrom 0
+ ValuesFrom 1
+ </Result>
+ <Result>
+ Type gauge
+ InstancePrefix "objperslab"
+ InstancesFrom 0
+ ValuesFrom 4
+ </Result>
+ </Table>
+ </Plugin>
+
+The configuration consists of one or more B<Table> blocks, each of which
+configures one file to parse. Within each B<Table> block, there are one or
+more B<Result> blocks, which configure which data to select and how to
+interpret it.
+
+The following options are available inside a B<Table> block:
+
+=over 4
+
+=item B<Instance> I<instance>
+
+If specified, I<instance> is used as the plugin instance. So, in the above
+example, the plugin name C<table-slabinfo> would be used. If omitted, the
+filename of the table is used instead, with all special characters replaced
+with an underscore (C<_>).
+
+=item B<Separator> I<string>
+
+Any character of I<string> is interpreted as a delimiter between the different
+columns of the table. A sequence of two or more contiguous delimiters in the
+table is considered to be a single delimiter, i.E<nbsp>e. there cannot be any
+empty columns. The plugin uses the L<strtok_r(3)> function to parse the lines
+of a table - see its documentation for more details. This option is mandatory.
+
+A horizontal tab, newline and carriage return may be specified by C<\\t>,
+C<\\n> and C<\\r> respectively. Please note that the double backslashes are
+required because of collectd's config parsing.
+
+=back
+
+The following options are available inside a B<Result> block:
+
+=over 4
+
+=item B<Type> I<type>
+
+Sets the type used to dispatch the values to the daemon. Detailed information
+about types and their configuration can be found in L<types.db(5)>. This
+option is mandatory.
+
+=item B<InstancePrefix> I<prefix>
+
+If specified, prepend I<prefix> to the type instance. If omitted, only the
+B<InstancesFrom> option is considered for the type instance.
+
+=item B<InstancesFrom> I<column0> [I<column1> ...]
+
+If specified, the content of the given columns (identified by the column
+number starting at zero) will be used to create the type instance for each
+row. Multiple values (and the instance prefix) will be joined together with
+dashes (I<->) as separation character. If omitted, only the B<InstancePrefix>
+option is considered for the type instance.
+
+The plugin itself does not check whether or not all built instances are
+different. It’s your responsibility to assure that each is unique. This is
+especially true, if you do not specify B<InstancesFrom>: B<You> have to make
+sure that the table only contains one row.
+
+If neither B<InstancePrefix> nor B<InstancesFrom> is given, the type instance
+will be empty.
+
+=item B<ValuesFrom> I<column0> [I<column1> ...]
+
+Specifies the columns (identified by the column numbers starting at zero)
+whose content is used as the actual data for the data sets that are dispatched
+to the daemon. How many such columns you need is determined by the B<Type>
+setting above. If you specify too many or not enough columns, the plugin will
+complain about that and no data will be submitted to the daemon. The plugin
+uses L<strtoll(3)> and L<strtod(3)> to parse counter and gauge values
+respectively, so anything supported by those functions is supported by the
+plugin as well. This option is mandatory.
+
+=back
+
=head2 Plugin C<tail>
-The C<tail plugin> plugins follows logfiles, just like L<tail(1)> does, parses
+The C<tail plugin> follows logfiles, just like L<tail(1)> does, parses
each line and dispatches found values. What is matched can be configured by the
user using (extended) regular expressions, as described in L<regex(7)>.
=back
+=head2 Plugin C<ted>
+
+The I<TED> plugin connects to a device of "The Energy Detective", a device to
+measure power consumption. These devices are usually connected to a serial
+(RS232) or USB port. The plugin opens a configured device and tries to read the
+current energy readings. For more information on TED, visit
+L<http://www.theenergydetective.com/>.
+
+Available configuration options:
+
+=over 4
+
+=item B<Device> I<Path>
+
+Path to the device on which TED is connected. collectd will need read and write
+permissions on that file.
+
+Default: B</dev/ttyUSB0>
+
+=item B<Retries> I<Num>
+
+Apparently reading from TED is not that reliable. You can therefore configure a
+number of retries here. You only configure the I<retries> here, to if you
+specify zero, one reading will be performed (but no retries if that fails); if
+you specify three, a maximum of four readings are performed. Negative values
+are illegal.
+
+Default: B<0>
+
+=back
+
=head2 Plugin C<tcpconns>
The C<tcpconns plugin> counts the number of currently established TCP
break;
}
- return (i);
+ return ((int) i);
}
int strjoin (char *dst, size_t dst_len,
return (ret);
} /* int strsubstitute */
+int strunescape (char *buf, size_t buf_len)
+{
+ size_t i;
+
+ for (i = 0; (i < buf_len) && (buf[i] != '\0'); ++i)
+ {
+ if (buf[i] != '\\')
+ continue;
+
+ if ((i >= buf_len) || (buf[i + 1] == '\0')) {
+ ERROR ("string unescape: backslash found at end of string.");
+ return (-1);
+ }
+
+ switch (buf[i + 1]) {
+ case 't':
+ buf[i] = '\t';
+ break;
+ case 'n':
+ buf[i] = '\n';
+ break;
+ case 'r':
+ buf[i] = '\r';
+ break;
+ default:
+ buf[i] = buf[i + 1];
+ break;
+ }
+
+ memmove (buf + i + 1, buf + i + 2, buf_len - i - 2);
+ }
+ return (0);
+} /* int strunescape */
+
int escape_slashes (char *buf, int buf_len)
{
int i;
return (0);
} /* int escape_slashes */
+void replace_special (char *buffer, size_t buffer_size)
+{
+ size_t i;
+
+ for (i = 0; i < buffer_size; i++)
+ {
+ if (buffer[i] == 0)
+ return;
+ if ((!isalnum ((int) buffer[i])) && (buffer[i] != '-'))
+ buffer[i] = '_';
+ }
+} /* void replace_special */
+
int timeval_cmp (struct timeval tv0, struct timeval tv1, struct timeval *delta)
{
struct timeval *larger;
return (0);
} /* int parse_identifier */
+int parse_value (const char *value, value_t *ret_value, const data_source_t ds)
+{
+ char *endptr = NULL;
+
+ if (DS_TYPE_COUNTER == ds.type)
+ ret_value->counter = (counter_t)strtoll (value, &endptr, 0);
+ else if (DS_TYPE_GAUGE == ds.type)
+ ret_value->gauge = (gauge_t)strtod (value, &endptr);
+ else {
+ ERROR ("parse_value: Invalid data source \"%s\" "
+ "(type = %i).", ds.name, ds.type);
+ return -1;
+ }
+
+ if (value == endptr) {
+ ERROR ("parse_value: Failed to parse string as number: %s.", value);
+ return -1;
+ }
+ else if ((NULL != endptr) && ('\0' != *endptr))
+ WARNING ("parse_value: Ignoring trailing garbage after number: %s.",
+ endptr);
+ return 0;
+} /* int parse_value */
+
int parse_values (char *buffer, value_list_t *vl, const data_set_t *ds)
{
int i;
}
else
{
- if (strcmp ("U", ptr) == 0)
+ if ((strcmp ("U", ptr) == 0) && (ds->ds[i].type == DS_TYPE_GAUGE))
vl->values[i].gauge = NAN;
- else if (ds->ds[i].type == DS_TYPE_COUNTER)
- vl->values[i].counter = atoll (ptr);
- else if (ds->ds[i].type == DS_TYPE_GAUGE)
- vl->values[i].gauge = atof (ptr);
+ else if (0 != parse_value (ptr, &vl->values[i], ds->ds[i]))
+ return -1;
}
i++;
*
* DESCRIPTION
* Splits a string into parts and stores pointers to the parts in `fields'.
- * The characters split at are ` ' (space) and "\t" (tab).
+ * The characters split at are: " ", "\t", "\r", and "\n".
*
* PARAMETERS
* `string' String to split. This string will be modified. `fields' will
*/
int escape_slashes (char *buf, int buf_len);
+/*
+ * NAME
+ * replace_special
+ *
+ * DESCRIPTION
+ * Replaces any special characters (anything that's not alpha-numeric or a
+ * dash) with an underscore.
+ *
+ * E.g. "foo$bar&" would become "foo_bar_".
+ *
+ * PARAMETERS
+ * `buffer' String to be handled.
+ * `buffer_size' Length of the string. The function returns after
+ * encountering a null-byte or reading this many bytes.
+ */
+void replace_special (char *buffer, size_t buffer_size);
+
int strsubstitute (char *str, char c_from, char c_to);
/*
* NAME
+ * strunescape
+ *
+ * DESCRIPTION
+ * Replaces any escaped characters in a string with the appropriate special
+ * characters. The following escaped characters are recognized:
+ *
+ * \t -> <tab>
+ * \n -> <newline>
+ * \r -> <carriage return>
+ *
+ * For all other escacped characters only the backslash will be removed.
+ *
+ * PARAMETERS
+ * `buf' String to be unescaped.
+ * `buf_len' Length of the string, including the terminating null-byte.
+ *
+ * RETURN VALUE
+ * Returns zero upon success, a value less than zero else.
+ */
+int strunescape (char *buf, size_t buf_len);
+
+/*
+ * NAME
* timeval_cmp
*
* DESCRIPTION
(tv).tv_usec = (tv).tv_usec % 1000000; \
} while (0)
+/* make sure tv_sec stores less than a second */
+#define NORMALIZE_TIMESPEC(tv) \
+ do { \
+ (tv).tv_sec += (tv).tv_nsec / 1000000000; \
+ (tv).tv_nsec = (tv).tv_nsec % 1000000000; \
+ } while (0)
+
int check_create_dir (const char *file_orig);
#ifdef HAVE_LIBKSTAT
int parse_identifier (char *str, char **ret_host,
char **ret_plugin, char **ret_plugin_instance,
char **ret_type, char **ret_type_instance);
+int parse_value (const char *value, value_t *ret_value, const data_source_t ds);
int parse_values (char *buffer, value_list_t *vl, const data_set_t *ds);
#if !HAVE_GETPWNAM_R
free (key);
free (value);
- DEBUG ("return (%i)", ret);
+ DEBUG ("cf_dispatch: return (%i)", ret);
return (ret);
} /* int cf_dispatch */
return (0);
} /* int csv_config */
-static int csv_write (const data_set_t *ds, const value_list_t *vl)
+static int csv_write (const data_set_t *ds, const value_list_t *vl,
+ user_data_t __attribute__((unused)) *user_data)
{
struct stat statbuf;
char filename[512];
{
plugin_register_config ("csv", csv_config,
config_keys, config_keys_num);
- plugin_register_write ("csv", csv_write);
+ plugin_register_write ("csv", csv_write, /* user_data = */ NULL);
} /* void module_register */
return (0);
} /* int exec_read }}} */
-static int exec_notification (const notification_t *n)
+static int exec_notification (const notification_t *n,
+ user_data_t __attribute__((unused)) *user_data)
{
program_list_t *pl;
program_list_and_notification_t *pln;
} /* for (pl) */
return (0);
-} /* int exec_notification */
+} /* }}} int exec_notification */
static int exec_shutdown (void) /* {{{ */
{
plugin_register_complex_config ("exec", exec_config);
plugin_register_init ("exec", exec_init);
plugin_register_read ("exec", exec_read);
- plugin_register_notification ("exec", exec_notification);
+ plugin_register_notification ("exec", exec_notification,
+ /* user_data = */ NULL);
plugin_register_shutdown ("exec", exec_shutdown);
} /* void module_register */
--- /dev/null
+/**
+ * collectd - src/gmond.c
+ * Copyright (C) 2005-2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ **/
+
+#include "collectd.h"
+#include "plugin.h"
+#include "common.h"
+#include "configfile.h"
+#include "utils_avltree.h"
+
+#if HAVE_PTHREAD_H
+# include <pthread.h>
+#endif
+#if HAVE_SYS_SOCKET_H
+# include <sys/socket.h>
+#endif
+#if HAVE_NETDB_H
+# include <netdb.h>
+#endif
+#if HAVE_NETINET_IN_H
+# include <netinet/in.h>
+#endif
+#if HAVE_ARPA_INET_H
+# include <arpa/inet.h>
+#endif
+#if HAVE_POLL_H
+# include <poll.h>
+#endif
+
+#include <gm_protocol.h>
+
+#ifndef IPV6_ADD_MEMBERSHIP
+# ifdef IPV6_JOIN_GROUP
+# define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
+# else
+# error "Neither IP_ADD_MEMBERSHIP nor IPV6_JOIN_GROUP is defined"
+# endif
+#endif /* !IP_ADD_MEMBERSHIP */
+
+#ifdef GANGLIA_MAX_MESSAGE_LEN
+# define BUFF_SIZE GANGLIA_MAX_MESSAGE_LEN
+#else
+# define BUFF_SIZE 1400
+#endif
+
+struct socket_entry_s
+{
+ int fd;
+ struct sockaddr_storage addr;
+ socklen_t addrlen;
+};
+typedef struct socket_entry_s socket_entry_t;
+
+struct staging_entry_s
+{
+ char key[2 * DATA_MAX_NAME_LEN];
+ value_list_t vl;
+ int flags;
+};
+typedef struct staging_entry_s staging_entry_t;
+
+struct metric_map_s
+{
+ char *ganglia_name;
+ char *type;
+ char *type_instance;
+ char *ds_name;
+ int ds_type;
+ int ds_index;
+};
+typedef struct metric_map_s metric_map_t;
+
+#define MC_RECEIVE_GROUP_DEFAULT "239.2.11.71"
+static char *mc_receive_group = NULL;
+#define MC_RECEIVE_PORT_DEFAULT "8649"
+static char *mc_receive_port = NULL;
+
+static struct pollfd *mc_receive_sockets = NULL;
+static size_t mc_receive_sockets_num = 0;
+
+static socket_entry_t *mc_send_sockets = NULL;
+static size_t mc_send_sockets_num = 0;
+static pthread_mutex_t mc_send_sockets_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static int mc_receive_thread_loop = 0;
+static int mc_receive_thread_running = 0;
+static pthread_t mc_receive_thread_id;
+
+static metric_map_t metric_map_default[] =
+{ /*---------------+-------------+-----------+-------------+------+-----*
+ * ganglia_name ! type ! type_inst ! data_source ! type ! idx *
+ *---------------+-------------+-----------+-------------+------+-----*/
+ { "load_one", "load", "", "shortterm", -1, -1 },
+ { "load_five", "load", "", "midterm", -1, -1 },
+ { "load_fifteen", "load", "", "longterm", -1, -1 },
+ { "cpu_user", "cpu", "user", "value", -1, -1 },
+ { "cpu_system", "cpu", "system", "value", -1, -1 },
+ { "cpu_idle", "cpu", "idle", "value", -1, -1 },
+ { "cpu_nice", "cpu", "nice", "value", -1, -1 },
+ { "cpu_wio", "cpu", "wait", "value", -1, -1 },
+ { "mem_free", "memory", "free", "value", -1, -1 },
+ { "mem_shared", "memory", "shared", "value", -1, -1 },
+ { "mem_buffers", "memory", "buffered", "value", -1, -1 },
+ { "mem_cached", "memory", "cached", "value", -1, -1 },
+ { "mem_total", "memory", "total", "value", -1, -1 },
+ { "bytes_in", "if_octets", "", "rx", -1, -1 },
+ { "bytes_out", "if_octets", "", "tx", -1, -1 },
+ { "pkts_in", "if_packets", "", "rx", -1, -1 },
+ { "pkts_out", "if_packets", "", "tx", -1, -1 }
+};
+static size_t metric_map_len_default = STATIC_ARRAY_SIZE (metric_map_default);
+
+static metric_map_t *metric_map = NULL;
+static size_t metric_map_len = 0;
+
+static c_avl_tree_t *staging_tree;
+static pthread_mutex_t staging_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static metric_map_t *metric_lookup (const char *key) /* {{{ */
+{
+ metric_map_t *map;
+ size_t map_len;
+ size_t i;
+
+ /* Search the user-supplied table first.. */
+ map = metric_map;
+ map_len = metric_map_len;
+ for (i = 0; i < map_len; i++)
+ if (strcmp (map[i].ganglia_name, key) == 0)
+ break;
+
+ /* .. and fall back to the built-in table if nothing is found. */
+ if (i >= map_len)
+ {
+ map = metric_map_default;
+ map_len = metric_map_len_default;
+
+ for (i = 0; i < map_len; i++)
+ if (strcmp (map[i].ganglia_name, key) == 0)
+ break;
+ }
+
+ if (i >= map_len)
+ return (NULL);
+
+ /* Look up the DS type and ds_index. */
+ if ((map[i].ds_type < 0) || (map[i].ds_index < 0)) /* {{{ */
+ {
+ const data_set_t *ds;
+
+ ds = plugin_get_ds (map[i].type);
+ if (ds == NULL)
+ {
+ WARNING ("gmond plugin: Type not defined: %s", map[i].type);
+ return (NULL);
+ }
+
+ if ((map[i].ds_name == NULL) && (ds->ds_num != 1))
+ {
+ WARNING ("gmond plugin: No data source name defined for metric %s, "
+ "but type %s has more than one data source.",
+ map[i].ganglia_name, map[i].type);
+ return (NULL);
+ }
+
+ if (map[i].ds_name == NULL)
+ {
+ map[i].ds_index = 0;
+ }
+ else
+ {
+ int j;
+
+ for (j = 0; j < ds->ds_num; j++)
+ if (strcasecmp (ds->ds[j].name, map[i].ds_name) == 0)
+ break;
+
+ if (j >= ds->ds_num)
+ {
+ WARNING ("gmond plugin: There is no data source "
+ "named `%s' in type `%s'.",
+ map[i].ds_name, ds->type);
+ return (NULL);
+ }
+ map[i].ds_index = j;
+ }
+
+ map[i].ds_type = ds->ds[map[i].ds_index].type;
+ } /* }}} if ((map[i].ds_type < 0) || (map[i].ds_index < 0)) */
+
+ return (map + i);
+} /* }}} metric_map_t *metric_lookup */
+
+static int create_sockets (socket_entry_t **ret_sockets, /* {{{ */
+ size_t *ret_sockets_num,
+ const char *node, const char *service, int listen)
+{
+ struct addrinfo ai_hints;
+ struct addrinfo *ai_list;
+ struct addrinfo *ai_ptr;
+ int ai_return;
+
+ socket_entry_t *sockets;
+ size_t sockets_num;
+
+ int status;
+
+ sockets = *ret_sockets;
+ sockets_num = *ret_sockets_num;
+
+ memset (&ai_hints, 0, sizeof (ai_hints));
+ ai_hints.ai_flags = 0;
+#ifdef AI_PASSIVE
+ ai_hints.ai_flags |= AI_PASSIVE;
+#endif
+#ifdef AI_ADDRCONFIG
+ ai_hints.ai_flags |= AI_ADDRCONFIG;
+#endif
+ ai_hints.ai_family = AF_UNSPEC;
+ ai_hints.ai_socktype = SOCK_DGRAM;
+ ai_hints.ai_protocol = IPPROTO_UDP;
+
+ ai_return = getaddrinfo (node, service, &ai_hints, &ai_list);
+ if (ai_return != 0)
+ {
+ char errbuf[1024];
+ ERROR ("gmond plugin: getaddrinfo (%s, %s) failed: %s",
+ (node == NULL) ? "(null)" : node,
+ (service == NULL) ? "(null)" : service,
+ (ai_return == EAI_SYSTEM)
+ ? sstrerror (errno, errbuf, sizeof (errbuf))
+ : gai_strerror (ai_return));
+ return (-1);
+ }
+
+ for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) /* {{{ */
+ {
+ socket_entry_t *tmp;
+
+ tmp = realloc (sockets, (sockets_num + 1) * sizeof (*sockets));
+ if (tmp == NULL)
+ {
+ ERROR ("gmond plugin: realloc failed.");
+ continue;
+ }
+ sockets = tmp;
+
+ sockets[sockets_num].fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype,
+ ai_ptr->ai_protocol);
+ if (sockets[sockets_num].fd < 0)
+ {
+ char errbuf[1024];
+ ERROR ("gmond plugin: socket failed: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ continue;
+ }
+
+ assert (sizeof (sockets[sockets_num].addr) >= ai_ptr->ai_addrlen);
+ memcpy (&sockets[sockets_num].addr, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
+ sockets[sockets_num].addrlen = ai_ptr->ai_addrlen;
+
+ /* Sending socket: Open only one socket and don't bind it. */
+ if (listen == 0)
+ {
+ sockets_num++;
+ break;
+ }
+ else
+ {
+ int yes = 1;
+
+ setsockopt (sockets[sockets_num].fd, SOL_SOCKET, SO_REUSEADDR,
+ (void *) &yes, sizeof (yes));
+ }
+
+ status = bind (sockets[sockets_num].fd, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
+ if (status != 0)
+ {
+ char errbuf[1024];
+ ERROR ("gmond plugin: bind failed: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ close (sockets[sockets_num].fd);
+ continue;
+ }
+
+ if (ai_ptr->ai_family == AF_INET)
+ {
+ struct sockaddr_in *addr;
+ struct ip_mreq mreq;
+ int loop;
+
+ addr = (struct sockaddr_in *) ai_ptr->ai_addr;
+
+ if (!IN_MULTICAST (ntohl (addr->sin_addr.s_addr)))
+ {
+ sockets_num++;
+ continue;
+ }
+
+ loop = 1;
+ setsockopt (sockets[sockets_num].fd, IPPROTO_IP, IP_MULTICAST_LOOP,
+ (void *) &loop, sizeof (loop));
+
+ memset (&mreq, 0, sizeof (mreq));
+ mreq.imr_multiaddr.s_addr = addr->sin_addr.s_addr;
+ mreq.imr_interface.s_addr = htonl (INADDR_ANY);
+ setsockopt (sockets[sockets_num].fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
+ (void *) &mreq, sizeof (mreq));
+ } /* if (ai_ptr->ai_family == AF_INET) */
+ else if (ai_ptr->ai_family == AF_INET6)
+ {
+ struct sockaddr_in6 *addr;
+ struct ipv6_mreq mreq;
+ int loop;
+
+ addr = (struct sockaddr_in6 *) ai_ptr->ai_addr;
+
+ if (!IN6_IS_ADDR_MULTICAST (&addr->sin6_addr))
+ {
+ sockets_num++;
+ continue;
+ }
+
+ loop = 1;
+ setsockopt (sockets[sockets_num].fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
+ (void *) &loop, sizeof (loop));
+
+ memset (&mreq, 0, sizeof (mreq));
+ memcpy (&mreq.ipv6mr_multiaddr,
+ &addr->sin6_addr, sizeof (addr->sin6_addr));
+ mreq.ipv6mr_interface = 0; /* any */
+ setsockopt (sockets[sockets_num].fd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP,
+ (void *) &mreq, sizeof (mreq));
+ } /* if (ai_ptr->ai_family == AF_INET6) */
+
+ sockets_num++;
+ } /* }}} for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) */
+
+ freeaddrinfo (ai_list);
+
+ if ((*ret_sockets_num) >= sockets_num)
+ return (-1);
+
+ *ret_sockets = sockets;
+ *ret_sockets_num = sockets_num;
+ return (0);
+} /* }}} int create_sockets */
+
+static int request_meta_data (const char *host, const char *name) /* {{{ */
+{
+ Ganglia_metadata_msg msg;
+ char buffer[BUFF_SIZE];
+ unsigned int buffer_size;
+ XDR xdr;
+ size_t i;
+
+ memset (&msg, 0, sizeof (msg));
+
+ msg.id = gmetadata_request;
+ msg.Ganglia_metadata_msg_u.grequest.metric_id.host = strdup (host);
+ msg.Ganglia_metadata_msg_u.grequest.metric_id.name = strdup (name);
+
+ if ((msg.Ganglia_metadata_msg_u.grequest.metric_id.host == NULL)
+ || (msg.Ganglia_metadata_msg_u.grequest.metric_id.name == NULL))
+ {
+ sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.host);
+ sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.name);
+ return (-1);
+ }
+
+ memset (buffer, 0, sizeof (buffer));
+ xdrmem_create (&xdr, buffer, sizeof (buffer), XDR_ENCODE);
+
+ if (!xdr_Ganglia_metadata_msg (&xdr, &msg))
+ {
+ sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.host);
+ sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.name);
+ return (-1);
+ }
+
+ buffer_size = xdr_getpos (&xdr);
+
+ DEBUG ("gmond plugin: Requesting meta data for %s/%s.",
+ host, name);
+
+ pthread_mutex_lock (&mc_send_sockets_lock);
+ for (i = 0; i < mc_send_sockets_num; i++)
+ sendto (mc_send_sockets[i].fd, buffer, (size_t) buffer_size,
+ /* flags = */ 0,
+ (struct sockaddr *) &mc_send_sockets[i].addr,
+ mc_send_sockets[i].addrlen);
+ pthread_mutex_unlock (&mc_send_sockets_lock);
+
+ sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.host);
+ sfree (msg.Ganglia_metadata_msg_u.grequest.metric_id.name);
+ return (0);
+} /* }}} int request_meta_data */
+
+static staging_entry_t *staging_entry_get (const char *host, /* {{{ */
+ const char *name,
+ const char *type, const char *type_instance,
+ int values_len)
+{
+ char key[2 * DATA_MAX_NAME_LEN];
+ staging_entry_t *se;
+ int status;
+
+ if (staging_tree == NULL)
+ return (NULL);
+
+ ssnprintf (key, sizeof (key), "%s/%s/%s", host, type,
+ (type_instance != NULL) ? type_instance : "");
+
+ se = NULL;
+ status = c_avl_get (staging_tree, key, (void *) &se);
+ if (status == 0)
+ return (se);
+
+ /* insert new entry */
+ se = (staging_entry_t *) malloc (sizeof (*se));
+ if (se == NULL)
+ return (NULL);
+ memset (se, 0, sizeof (*se));
+
+ sstrncpy (se->key, key, sizeof (se->key));
+ se->flags = 0;
+
+ se->vl.values = (value_t *) calloc (values_len, sizeof (*se->vl.values));
+ if (se->vl.values == NULL)
+ {
+ sfree (se);
+ return (NULL);
+ }
+ se->vl.values_len = values_len;
+
+ se->vl.time = 0;
+ se->vl.interval = 0;
+ sstrncpy (se->vl.host, host, sizeof (se->vl.host));
+ sstrncpy (se->vl.plugin, "gmond", sizeof (se->vl.plugin));
+ sstrncpy (se->vl.type, type, sizeof (se->vl.type));
+ if (type_instance != NULL)
+ sstrncpy (se->vl.type_instance, type_instance,
+ sizeof (se->vl.type_instance));
+
+ status = c_avl_insert (staging_tree, se->key, se);
+ if (status != 0)
+ {
+ ERROR ("gmond plugin: c_avl_insert failed.");
+ sfree (se->vl.values);
+ sfree (se);
+ return (NULL);
+ }
+
+ return (se);
+} /* }}} staging_entry_t *staging_entry_get */
+
+static int staging_entry_submit (const char *host, const char *name, /* {{{ */
+ staging_entry_t *se)
+{
+ value_list_t vl;
+ value_t values[se->vl.values_len];
+
+ if (se->vl.interval == 0)
+ {
+ /* No meta data has been received for this metric yet. */
+ se->flags = 0;
+ pthread_mutex_unlock (&staging_lock);
+ request_meta_data (host, name);
+ return (0);
+ }
+
+ se->flags = 0;
+
+ memcpy (values, se->vl.values, sizeof (values));
+ memcpy (&vl, &se->vl, sizeof (vl));
+
+ /* Unlock before calling `plugin_dispatch_values'.. */
+ pthread_mutex_unlock (&staging_lock);
+
+ vl.values = values;
+
+ plugin_dispatch_values (&vl);
+
+ return (0);
+} /* }}} int staging_entry_submit */
+
+static int staging_entry_update (const char *host, const char *name, /* {{{ */
+ const char *type, const char *type_instance,
+ int ds_index, int ds_type, value_t value)
+{
+ const data_set_t *ds;
+ staging_entry_t *se;
+
+ ds = plugin_get_ds (type);
+ if (ds == NULL)
+ {
+ ERROR ("gmond plugin: Looking up type %s failed.", type);
+ return (-1);
+ }
+
+ if (ds->ds_num <= ds_index)
+ {
+ ERROR ("gmond plugin: Invalid index %i: %s has only %i data source(s).",
+ ds_index, ds->type, ds->ds_num);
+ return (-1);
+ }
+
+ pthread_mutex_lock (&staging_lock);
+
+ se = staging_entry_get (host, name, type, type_instance, ds->ds_num);
+ if (se == NULL)
+ {
+ pthread_mutex_unlock (&staging_lock);
+ ERROR ("gmond plugin: staging_entry_get failed.");
+ return (-1);
+ }
+ if (se->vl.values_len != ds->ds_num)
+ {
+ pthread_mutex_unlock (&staging_lock);
+ return (-1);
+ }
+
+ if (ds_type == DS_TYPE_COUNTER)
+ se->vl.values[ds_index].counter += value.counter;
+ else if (ds_type == DS_TYPE_GAUGE)
+ se->vl.values[ds_index].gauge = value.gauge;
+ se->flags |= (0x01 << ds_index);
+
+ /* Check if all values have been set and submit if so. */
+ if (se->flags == ((0x01 << se->vl.values_len) - 1))
+ {
+ /* `staging_lock' is unlocked in `staging_entry_submit'. */
+ staging_entry_submit (host, name, se);
+ }
+ else
+ {
+ pthread_mutex_unlock (&staging_lock);
+ }
+
+ return (0);
+} /* }}} int staging_entry_update */
+
+static int mc_handle_value_msg (Ganglia_value_msg *msg) /* {{{ */
+{
+ const char *host;
+ const char *name;
+ metric_map_t *map;
+
+ value_t value_counter;
+ value_t value_gauge;
+
+ /* Fill in `host', `name', `value_counter', and `value_gauge' according to
+ * the value type, or return with an error. */
+ switch (msg->id) /* {{{ */
+ {
+ case gmetric_uint:
+ {
+ Ganglia_gmetric_uint msg_uint;
+
+ msg_uint = msg->Ganglia_value_msg_u.gu_int;
+
+ host = msg_uint.metric_id.host;
+ name = msg_uint.metric_id.name;
+ value_counter.counter = (counter_t) msg_uint.ui;
+ value_gauge.gauge = (gauge_t) msg_uint.ui;
+ break;
+ }
+
+ case gmetric_string:
+ {
+ Ganglia_gmetric_string msg_string;
+ char *endptr;
+
+ msg_string = msg->Ganglia_value_msg_u.gstr;
+
+ host = msg_string.metric_id.host;
+ name = msg_string.metric_id.name;
+
+ endptr = NULL;
+ errno = 0;
+ value_counter.counter = (counter_t) strtoll (msg_string.str,
+ &endptr, /* base = */ 0);
+ if ((endptr == msg_string.str) || (errno != 0))
+ value_counter.counter = -1;
+
+ endptr = NULL;
+ errno = 0;
+ value_gauge.gauge = (gauge_t) strtod (msg_string.str, &endptr);
+ if ((endptr == msg_string.str) || (errno != 0))
+ value_gauge.gauge = NAN;
+
+ break;
+ }
+
+ case gmetric_float:
+ {
+ Ganglia_gmetric_float msg_float;
+
+ msg_float = msg->Ganglia_value_msg_u.gf;
+
+ host = msg_float.metric_id.host;
+ name = msg_float.metric_id.name;
+ value_counter.counter = (counter_t) msg_float.f;
+ value_gauge.gauge = (gauge_t) msg_float.f;
+ break;
+ }
+
+ case gmetric_double:
+ {
+ Ganglia_gmetric_double msg_double;
+
+ msg_double = msg->Ganglia_value_msg_u.gd;
+
+ host = msg_double.metric_id.host;
+ name = msg_double.metric_id.name;
+ value_counter.counter = (counter_t) msg_double.d;
+ value_gauge.gauge = (gauge_t) msg_double.d;
+ break;
+ }
+ default:
+ DEBUG ("gmond plugin: Value type not handled: %i", msg->id);
+ return (-1);
+ } /* }}} switch (msg->id) */
+
+ assert (host != NULL);
+ assert (name != NULL);
+
+ map = metric_lookup (name);
+ if (map != NULL)
+ return (staging_entry_update (host, name,
+ map->type, map->type_instance,
+ map->ds_index, map->ds_type,
+ (map->ds_type == DS_TYPE_COUNTER) ? value_counter : value_gauge));
+
+ DEBUG ("gmond plugin: Cannot find a translation for %s.", name);
+ return (-1);
+} /* }}} int mc_handle_value_msg */
+
+static int mc_handle_metadata_msg (Ganglia_metadata_msg *msg) /* {{{ */
+{
+ switch (msg->id)
+ {
+ case gmetadata_full:
+ {
+ Ganglia_metadatadef msg_meta;
+ staging_entry_t *se;
+ const data_set_t *ds;
+ metric_map_t *map;
+
+ msg_meta = msg->Ganglia_metadata_msg_u.gfull;
+
+ if (msg_meta.metric.tmax <= 0)
+ return (-1);
+
+ map = metric_lookup (msg_meta.metric_id.name);
+ if (map == NULL)
+ {
+ DEBUG ("gmond plugin: Not handling meta data %s.",
+ msg_meta.metric_id.name);
+ return (0);
+ }
+
+ ds = plugin_get_ds (map->type);
+ if (ds == NULL)
+ {
+ WARNING ("gmond plugin: Could not find data set %s.", map->type);
+ return (-1);
+ }
+
+ DEBUG ("gmond plugin: Received meta data for %s/%s.",
+ msg_meta.metric_id.host, msg_meta.metric_id.name);
+
+ pthread_mutex_lock (&staging_lock);
+ se = staging_entry_get (msg_meta.metric_id.host,
+ msg_meta.metric_id.name,
+ map->type, map->type_instance,
+ ds->ds_num);
+ if (se != NULL)
+ se->vl.interval = (int) msg_meta.metric.tmax;
+ pthread_mutex_unlock (&staging_lock);
+
+ if (se == NULL)
+ {
+ ERROR ("gmond plugin: staging_entry_get failed.");
+ return (-1);
+ }
+
+ break;
+ }
+
+ default:
+ {
+ return (-1);
+ }
+ }
+
+ return (0);
+} /* }}} int mc_handle_metadata_msg */
+
+static int mc_handle_metric (void *buffer, size_t buffer_size) /* {{{ */
+{
+ XDR xdr;
+ Ganglia_msg_formats format;
+
+ xdrmem_create (&xdr, buffer, buffer_size, XDR_DECODE);
+
+ xdr_Ganglia_msg_formats (&xdr, &format);
+ xdr_setpos (&xdr, 0);
+
+ switch (format)
+ {
+ case gmetric_ushort:
+ case gmetric_short:
+ case gmetric_int:
+ case gmetric_uint:
+ case gmetric_string:
+ case gmetric_float:
+ case gmetric_double:
+ {
+ Ganglia_value_msg msg;
+
+ memset (&msg, 0, sizeof (msg));
+ if (xdr_Ganglia_value_msg (&xdr, &msg))
+ mc_handle_value_msg (&msg);
+ break;
+ }
+
+ case gmetadata_full:
+ case gmetadata_request:
+ {
+ Ganglia_metadata_msg msg;
+ memset (&msg, 0, sizeof (msg));
+ if (xdr_Ganglia_metadata_msg (&xdr, &msg))
+ mc_handle_metadata_msg (&msg);
+ break;
+ }
+
+ default:
+ DEBUG ("gmond plugin: Unknown format: %i", format);
+ return (-1);
+ } /* switch (format) */
+
+
+ return (0);
+} /* }}} int mc_handle_metric */
+
+static int mc_handle_socket (struct pollfd *p) /* {{{ */
+{
+ char buffer[BUFF_SIZE];
+ ssize_t buffer_size;
+
+ if ((p->revents & (POLLIN | POLLPRI)) == 0)
+ {
+ p->revents = 0;
+ return (-1);
+ }
+
+ buffer_size = recv (p->fd, buffer, sizeof (buffer), /* flags = */ 0);
+ if (buffer_size <= 0)
+ {
+ char errbuf[1024];
+ ERROR ("gmond plugin: recv failed: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ p->revents = 0;
+ return (-1);
+ }
+
+ mc_handle_metric (buffer, (size_t) buffer_size);
+ return (0);
+} /* }}} int mc_handle_socket */
+
+static void *mc_receive_thread (void *arg) /* {{{ */
+{
+ socket_entry_t *mc_receive_socket_entries;
+ int status;
+ size_t i;
+
+ mc_receive_socket_entries = NULL;
+ status = create_sockets (&mc_receive_socket_entries, &mc_receive_sockets_num,
+ (mc_receive_group != NULL) ? mc_receive_group : MC_RECEIVE_GROUP_DEFAULT,
+ (mc_receive_port != NULL) ? mc_receive_port : MC_RECEIVE_PORT_DEFAULT,
+ /* listen = */ 1);
+ if (status != 0)
+ {
+ ERROR ("gmond plugin: create_sockets failed.");
+ return ((void *) -1);
+ }
+
+ mc_receive_sockets = (struct pollfd *) calloc (mc_receive_sockets_num,
+ sizeof (*mc_receive_sockets));
+ if (mc_receive_sockets == NULL)
+ {
+ ERROR ("gmond plugin: calloc failed.");
+ for (i = 0; i < mc_receive_sockets_num; i++)
+ close (mc_receive_socket_entries[i].fd);
+ free (mc_receive_socket_entries);
+ mc_receive_socket_entries = NULL;
+ mc_receive_sockets_num = 0;
+ return ((void *) -1);
+ }
+
+ for (i = 0; i < mc_receive_sockets_num; i++)
+ {
+ mc_receive_sockets[i].fd = mc_receive_socket_entries[i].fd;
+ mc_receive_sockets[i].events = POLLIN | POLLPRI;
+ mc_receive_sockets[i].revents = 0;
+ }
+
+ while (mc_receive_thread_loop != 0)
+ {
+ status = poll (mc_receive_sockets, mc_receive_sockets_num, -1);
+ if (status <= 0)
+ {
+ char errbuf[1024];
+ if (errno == EINTR)
+ continue;
+ ERROR ("gmond plugin: poll failed: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ break;
+ }
+
+ for (i = 0; i < mc_receive_sockets_num; i++)
+ {
+ if (mc_receive_sockets[i].revents != 0)
+ mc_handle_socket (mc_receive_sockets + i);
+ }
+ } /* while (mc_receive_thread_loop != 0) */
+
+ return ((void *) 0);
+} /* }}} void *mc_receive_thread */
+
+static int mc_receive_thread_start (void) /* {{{ */
+{
+ int status;
+
+ if (mc_receive_thread_running != 0)
+ return (-1);
+
+ mc_receive_thread_loop = 1;
+
+ status = pthread_create (&mc_receive_thread_id, /* attr = */ NULL,
+ mc_receive_thread, /* args = */ NULL);
+ if (status != 0)
+ {
+ ERROR ("gmond plugin: Starting receive thread failed.");
+ mc_receive_thread_loop = 0;
+ return (-1);
+ }
+
+ mc_receive_thread_running = 1;
+ return (0);
+} /* }}} int start_receive_thread */
+
+static int mc_receive_thread_stop (void) /* {{{ */
+{
+ if (mc_receive_thread_running == 0)
+ return (-1);
+
+ mc_receive_thread_loop = 0;
+
+ INFO ("gmond plugin: Stopping receive thread.");
+ pthread_kill (mc_receive_thread_id, SIGTERM);
+ pthread_join (mc_receive_thread_id, /* return value = */ NULL);
+ memset (&mc_receive_thread_id, 0, sizeof (mc_receive_thread_id));
+
+ mc_receive_thread_running = 0;
+
+ return (0);
+} /* }}} int mc_receive_thread_stop */
+
+/*
+ * Config:
+ *
+ * <Plugin gmond>
+ * MCReceiveFrom "239.2.11.71" "8649"
+ * <Metric "load_one">
+ * Type "load"
+ * [TypeInstance "foo"]
+ * [DataSource "bar"]
+ * </Metric>
+ * </Plugin>
+ */
+static int gmond_config_set_string (oconfig_item_t *ci, char **str) /* {{{ */
+{
+ char *tmp;
+
+ if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("gmond plugin: The `%s' option needs "
+ "exactly one string argument.", ci->key);
+ return (-1);
+ }
+
+ tmp = strdup (ci->values[0].value.string);
+ if (tmp == NULL)
+ {
+ ERROR ("gmond plugin: strdup failed.");
+ return (-1);
+ }
+
+ sfree (*str);
+ *str = tmp;
+ return (0);
+} /* }}} int gmond_config_set_string */
+
+static int gmond_config_add_metric (oconfig_item_t *ci) /* {{{ */
+{
+ metric_map_t *map;
+ int i;
+
+ if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("gmond plugin: `Metric' blocks need "
+ "exactly one string argument.");
+ return (-1);
+ }
+
+ map = realloc (metric_map, (metric_map_len + 1) * sizeof (*metric_map));
+ if (map == NULL)
+ {
+ ERROR ("gmond plugin: realloc failed.");
+ return (-1);
+ }
+ metric_map = map;
+ map = metric_map + metric_map_len;
+
+ memset (map, 0, sizeof (*map));
+ map->type = NULL;
+ map->type_instance = NULL;
+ map->ds_name = NULL;
+ map->ds_type = -1;
+ map->ds_index = -1;
+
+ map->ganglia_name = strdup (ci->values[0].value.string);
+ if (map->ganglia_name == NULL)
+ {
+ ERROR ("gmond plugin: strdup failed.");
+ return (-1);
+ }
+
+ for (i = 0; i < ci->children_num; i++)
+ {
+ oconfig_item_t *child = ci->children + i;
+ if (strcasecmp ("Type", child->key) == 0)
+ gmond_config_set_string (child, &map->type);
+ else if (strcasecmp ("TypeInstance", child->key) == 0)
+ gmond_config_set_string (child, &map->type_instance);
+ else if (strcasecmp ("DataSource", child->key) == 0)
+ gmond_config_set_string (child, &map->ds_name);
+ else
+ {
+ WARNING ("gmond plugin: Unknown configuration option `%s' ignored.",
+ child->key);
+ }
+ }
+
+ if (map->type == NULL)
+ {
+ ERROR ("gmond plugin: No type is set for metric %s.",
+ map->ganglia_name);
+ sfree (map->ganglia_name);
+ sfree (map->type_instance);
+ return (-1);
+ }
+
+ metric_map_len++;
+ return (0);
+} /* }}} int gmond_config_add_metric */
+
+static int gmond_config_set_address (oconfig_item_t *ci, /* {{{ */
+ char **ret_addr, char **ret_port)
+{
+ char *addr;
+ char *port;
+
+ if ((ci->values_num != 1) && (ci->values_num != 2))
+ {
+ WARNING ("gmond plugin: The `%s' config option needs "
+ "one or two string arguments.",
+ ci->key);
+ return (-1);
+ }
+ if ((ci->values[0].type != OCONFIG_TYPE_STRING)
+ || ((ci->values_num == 2)
+ && (ci->values[1].type != OCONFIG_TYPE_STRING)))
+ {
+ WARNING ("gmond plugin: The `%s' config option needs "
+ "one or two string arguments.",
+ ci->key);
+ return (-1);
+ }
+
+ addr = strdup (ci->values[0].value.string);
+ if (ci->values_num == 2)
+ port = strdup (ci->values[1].value.string);
+ else
+ port = NULL;
+
+ if ((addr == NULL) || ((ci->values_num == 2) && (port == NULL)))
+ {
+ ERROR ("gmond plugin: strdup failed.");
+ sfree (addr);
+ sfree (port);
+ return (-1);
+ }
+
+ sfree (*ret_addr);
+ sfree (*ret_port);
+
+ *ret_addr = addr;
+ *ret_port = port;
+
+ return (0);
+} /* }}} int gmond_config_set_address */
+
+static int gmond_config (oconfig_item_t *ci) /* {{{ */
+{
+ int i;
+
+ for (i = 0; i < ci->children_num; i++)
+ {
+ oconfig_item_t *child = ci->children + i;
+ if (strcasecmp ("MCReceiveFrom", child->key) == 0)
+ gmond_config_set_address (child, &mc_receive_group, &mc_receive_port);
+ else if (strcasecmp ("Metric", child->key) == 0)
+ gmond_config_add_metric (child);
+ else
+ {
+ WARNING ("gmond plugin: Unknown configuration option `%s' ignored.",
+ child->key);
+ }
+ }
+
+ return (0);
+} /* }}} int gmond_config */
+
+static int gmond_init (void) /* {{{ */
+{
+ create_sockets (&mc_send_sockets, &mc_send_sockets_num,
+ (mc_receive_group != NULL) ? mc_receive_group : MC_RECEIVE_GROUP_DEFAULT,
+ (mc_receive_port != NULL) ? mc_receive_port : MC_RECEIVE_PORT_DEFAULT,
+ /* listen = */ 0);
+
+ staging_tree = c_avl_create ((void *) strcmp);
+ if (staging_tree == NULL)
+ {
+ ERROR ("gmond plugin: c_avl_create failed.");
+ return (-1);
+ }
+
+ mc_receive_thread_start ();
+
+ return (0);
+} /* }}} int gmond_init */
+
+static int gmond_shutdown (void) /* {{{ */
+{
+ size_t i;
+
+ mc_receive_thread_stop ();
+
+ pthread_mutex_lock (&mc_send_sockets_lock);
+ for (i = 0; i < mc_send_sockets_num; i++)
+ {
+ close (mc_send_sockets[i].fd);
+ mc_send_sockets[i].fd = -1;
+ }
+ sfree (mc_send_sockets);
+ mc_send_sockets_num = 0;
+ pthread_mutex_unlock (&mc_send_sockets_lock);
+
+
+ return (0);
+} /* }}} int gmond_shutdown */
+
+void module_register (void)
+{
+ plugin_register_complex_config ("gmond", gmond_config);
+ plugin_register_init ("gmond", gmond_init);
+ plugin_register_shutdown ("gmond", gmond_shutdown);
+}
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
--- /dev/null
+/**
+ * collectd - src/java.c
+ * Copyright (C) 2009 Florian octo Forster
+ * Copyright (C) 2008 Justo Alonso Achaques
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ * Justo Alonso Achaques <justo.alonso at gmail.com>
+ **/
+
+#include "collectd.h"
+#include "plugin.h"
+#include "common.h"
+#include "filter_chain.h"
+
+#include <pthread.h>
+#include <jni.h>
+
+#if !defined(JNI_VERSION_1_2)
+# error "Need JNI 1.2 compatible interface!"
+#endif
+
+/*
+ * Types
+ */
+struct cjni_jvm_env_s /* {{{ */
+{
+ JNIEnv *jvm_env;
+ int reference_counter;
+};
+typedef struct cjni_jvm_env_s cjni_jvm_env_t;
+/* }}} */
+
+struct java_plugin_class_s /* {{{ */
+{
+ char *name;
+ jclass class;
+ jobject object;
+};
+typedef struct java_plugin_class_s java_plugin_class_t;
+/* }}} */
+
+#define CB_TYPE_CONFIG 1
+#define CB_TYPE_INIT 2
+#define CB_TYPE_READ 3
+#define CB_TYPE_WRITE 4
+#define CB_TYPE_FLUSH 5
+#define CB_TYPE_SHUTDOWN 6
+#define CB_TYPE_LOG 7
+#define CB_TYPE_NOTIFICATION 8
+#define CB_TYPE_MATCH 9
+#define CB_TYPE_TARGET 10
+struct cjni_callback_info_s /* {{{ */
+{
+ char *name;
+ int type;
+ jclass class;
+ jobject object;
+ jmethodID method;
+};
+typedef struct cjni_callback_info_s cjni_callback_info_t;
+/* }}} */
+
+/*
+ * Global variables
+ */
+static JavaVM *jvm = NULL;
+static pthread_key_t jvm_env_key;
+
+/* Configuration options for the JVM. */
+static char **jvm_argv = NULL;
+static size_t jvm_argc = 0;
+
+/* List of class names to load */
+static java_plugin_class_t *java_classes_list = NULL;
+static size_t java_classes_list_len;
+
+/* List of config, init, and shutdown callbacks. */
+static cjni_callback_info_t *java_callbacks = NULL;
+static size_t java_callbacks_num = 0;
+static pthread_mutex_t java_callbacks_lock = PTHREAD_MUTEX_INITIALIZER;
+
+/*
+ * Prototypes
+ *
+ * Mostly functions that are needed by the Java interface (``native'')
+ * functions.
+ */
+static void cjni_callback_info_destroy (void *arg);
+static cjni_callback_info_t *cjni_callback_info_create (JNIEnv *jvm_env,
+ jobject o_name, jobject o_callback, int type);
+static int cjni_callback_register (JNIEnv *jvm_env, jobject o_name,
+ jobject o_callback, int type);
+static int cjni_read (user_data_t *user_data);
+static int cjni_write (const data_set_t *ds, const value_list_t *vl,
+ user_data_t *ud);
+static int cjni_flush (int timeout, const char *identifier, user_data_t *ud);
+static void cjni_log (int severity, const char *message, user_data_t *ud);
+static int cjni_notification (const notification_t *n, user_data_t *ud);
+
+/* Create, destroy, and match/invoke functions, used by both, matches AND
+ * targets. */
+static int cjni_match_target_create (const oconfig_item_t *ci, void **user_data);
+static int cjni_match_target_destroy (void **user_data);
+static int cjni_match_target_invoke (const data_set_t *ds, value_list_t *vl,
+ notification_meta_t **meta, void **user_data);
+
+/*
+ * C to Java conversion functions
+ */
+static int ctoj_string (JNIEnv *jvm_env, /* {{{ */
+ const char *string,
+ jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+ jmethodID m_set;
+ jstring o_string;
+
+ /* Create a java.lang.String */
+ o_string = (*jvm_env)->NewStringUTF (jvm_env,
+ (string != NULL) ? string : "");
+ if (o_string == NULL)
+ {
+ ERROR ("java plugin: ctoj_string: NewStringUTF failed.");
+ return (-1);
+ }
+
+ /* Search for the `void setFoo (String s)' method. */
+ m_set = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+ method_name, "(Ljava/lang/String;)V");
+ if (m_set == NULL)
+ {
+ ERROR ("java plugin: ctoj_string: Cannot find method `void %s (String)'.",
+ method_name);
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_string);
+ return (-1);
+ }
+
+ /* Call the method. */
+ (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_set, o_string);
+
+ /* Decrease reference counter on the java.lang.String object. */
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_string);
+
+ return (0);
+} /* }}} int ctoj_string */
+
+static int ctoj_int (JNIEnv *jvm_env, /* {{{ */
+ jint value,
+ jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+ jmethodID m_set;
+
+ /* Search for the `void setFoo (int i)' method. */
+ m_set = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+ method_name, "(I)V");
+ if (m_set == NULL)
+ {
+ ERROR ("java plugin: ctoj_int: Cannot find method `void %s (int)'.",
+ method_name);
+ return (-1);
+ }
+
+ (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_set, value);
+
+ return (0);
+} /* }}} int ctoj_int */
+
+static int ctoj_long (JNIEnv *jvm_env, /* {{{ */
+ jlong value,
+ jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+ jmethodID m_set;
+
+ /* Search for the `void setFoo (long l)' method. */
+ m_set = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+ method_name, "(J)V");
+ if (m_set == NULL)
+ {
+ ERROR ("java plugin: ctoj_long: Cannot find method `void %s (long)'.",
+ method_name);
+ return (-1);
+ }
+
+ (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_set, value);
+
+ return (0);
+} /* }}} int ctoj_long */
+
+static int ctoj_double (JNIEnv *jvm_env, /* {{{ */
+ jdouble value,
+ jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+ jmethodID m_set;
+
+ /* Search for the `void setFoo (double d)' method. */
+ m_set = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+ method_name, "(D)V");
+ if (m_set == NULL)
+ {
+ ERROR ("java plugin: ctoj_double: Cannot find method `void %s (double)'.",
+ method_name);
+ return (-1);
+ }
+
+ (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_set, value);
+
+ return (0);
+} /* }}} int ctoj_double */
+
+/* Convert a jlong to a java.lang.Number */
+static jobject ctoj_jlong_to_number (JNIEnv *jvm_env, jlong value) /* {{{ */
+{
+ jclass c_long;
+ jmethodID m_long_constructor;
+
+ /* Look up the java.lang.Long class */
+ c_long = (*jvm_env)->FindClass (jvm_env, "java.lang.Long");
+ if (c_long == NULL)
+ {
+ ERROR ("java plugin: ctoj_jlong_to_number: Looking up the "
+ "java.lang.Long class failed.");
+ return (NULL);
+ }
+
+ m_long_constructor = (*jvm_env)->GetMethodID (jvm_env,
+ c_long, "<init>", "(J)V");
+ if (m_long_constructor == NULL)
+ {
+ ERROR ("java plugin: ctoj_jlong_to_number: Looking up the "
+ "`Long (long)' constructor failed.");
+ return (NULL);
+ }
+
+ return ((*jvm_env)->NewObject (jvm_env,
+ c_long, m_long_constructor, value));
+} /* }}} jobject ctoj_jlong_to_number */
+
+/* Convert a jdouble to a java.lang.Number */
+static jobject ctoj_jdouble_to_number (JNIEnv *jvm_env, jdouble value) /* {{{ */
+{
+ jclass c_double;
+ jmethodID m_double_constructor;
+
+ /* Look up the java.lang.Long class */
+ c_double = (*jvm_env)->FindClass (jvm_env, "java.lang.Double");
+ if (c_double == NULL)
+ {
+ ERROR ("java plugin: ctoj_jdouble_to_number: Looking up the "
+ "java.lang.Double class failed.");
+ return (NULL);
+ }
+
+ m_double_constructor = (*jvm_env)->GetMethodID (jvm_env,
+ c_double, "<init>", "(D)V");
+ if (m_double_constructor == NULL)
+ {
+ ERROR ("java plugin: ctoj_jdouble_to_number: Looking up the "
+ "`Double (double)' constructor failed.");
+ return (NULL);
+ }
+
+ return ((*jvm_env)->NewObject (jvm_env,
+ c_double, m_double_constructor, value));
+} /* }}} jobject ctoj_jdouble_to_number */
+
+/* Convert a value_t to a java.lang.Number */
+static jobject ctoj_value_to_number (JNIEnv *jvm_env, /* {{{ */
+ value_t value, int ds_type)
+{
+ if (ds_type == DS_TYPE_COUNTER)
+ return (ctoj_jlong_to_number (jvm_env, (jlong) value.counter));
+ else if (ds_type == DS_TYPE_GAUGE)
+ return (ctoj_jdouble_to_number (jvm_env, (jdouble) value.gauge));
+ else
+ return (NULL);
+} /* }}} jobject ctoj_value_to_number */
+
+/* Convert a data_source_t to a org/collectd/api/DataSource */
+static jobject ctoj_data_source (JNIEnv *jvm_env, /* {{{ */
+ const data_source_t *dsrc)
+{
+ jclass c_datasource;
+ jmethodID m_datasource_constructor;
+ jobject o_datasource;
+ int status;
+
+ /* Look up the DataSource class */
+ c_datasource = (*jvm_env)->FindClass (jvm_env,
+ "org/collectd/api/DataSource");
+ if (c_datasource == NULL)
+ {
+ ERROR ("java plugin: ctoj_data_source: "
+ "FindClass (org/collectd/api/DataSource) failed.");
+ return (NULL);
+ }
+
+ /* Lookup the `ValueList ()' constructor. */
+ m_datasource_constructor = (*jvm_env)->GetMethodID (jvm_env, c_datasource,
+ "<init>", "()V");
+ if (m_datasource_constructor == NULL)
+ {
+ ERROR ("java plugin: ctoj_data_source: Cannot find the "
+ "`DataSource ()' constructor.");
+ return (NULL);
+ }
+
+ /* Create a new instance. */
+ o_datasource = (*jvm_env)->NewObject (jvm_env, c_datasource,
+ m_datasource_constructor);
+ if (o_datasource == NULL)
+ {
+ ERROR ("java plugin: ctoj_data_source: "
+ "Creating a new DataSource instance failed.");
+ return (NULL);
+ }
+
+ /* Set name via `void setName (String name)' */
+ status = ctoj_string (jvm_env, dsrc->name,
+ c_datasource, o_datasource, "setName");
+ if (status != 0)
+ {
+ ERROR ("java plugin: ctoj_data_source: "
+ "ctoj_string (setName) failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
+ return (NULL);
+ }
+
+ /* Set type via `void setType (int type)' */
+ status = ctoj_int (jvm_env, dsrc->type,
+ c_datasource, o_datasource, "setType");
+ if (status != 0)
+ {
+ ERROR ("java plugin: ctoj_data_source: "
+ "ctoj_int (setType) failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
+ return (NULL);
+ }
+
+ /* Set min via `void setMin (double min)' */
+ status = ctoj_double (jvm_env, dsrc->min,
+ c_datasource, o_datasource, "setMin");
+ if (status != 0)
+ {
+ ERROR ("java plugin: ctoj_data_source: "
+ "ctoj_double (setMin) failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
+ return (NULL);
+ }
+
+ /* Set max via `void setMax (double max)' */
+ status = ctoj_double (jvm_env, dsrc->max,
+ c_datasource, o_datasource, "setMax");
+ if (status != 0)
+ {
+ ERROR ("java plugin: ctoj_data_source: "
+ "ctoj_double (setMax) failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
+ return (NULL);
+ }
+
+ return (o_datasource);
+} /* }}} jobject ctoj_data_source */
+
+/* Convert a oconfig_value_t to a org/collectd/api/OConfigValue */
+static jobject ctoj_oconfig_value (JNIEnv *jvm_env, /* {{{ */
+ oconfig_value_t ocvalue)
+{
+ jclass c_ocvalue;
+ jmethodID m_ocvalue_constructor;
+ jobject o_argument;
+ jobject o_ocvalue;
+
+ m_ocvalue_constructor = NULL;
+ o_argument = NULL;
+
+ c_ocvalue = (*jvm_env)->FindClass (jvm_env,
+ "org/collectd/api/OConfigValue");
+ if (c_ocvalue == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_value: "
+ "FindClass (org/collectd/api/OConfigValue) failed.");
+ return (NULL);
+ }
+
+ if (ocvalue.type == OCONFIG_TYPE_BOOLEAN)
+ {
+ jboolean tmp_boolean;
+
+ tmp_boolean = (ocvalue.value.boolean == 0) ? JNI_FALSE : JNI_TRUE;
+
+ m_ocvalue_constructor = (*jvm_env)->GetMethodID (jvm_env, c_ocvalue,
+ "<init>", "(Z)V");
+ if (m_ocvalue_constructor == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_value: Cannot find the "
+ "`OConfigValue (boolean)' constructor.");
+ return (NULL);
+ }
+
+ return ((*jvm_env)->NewObject (jvm_env,
+ c_ocvalue, m_ocvalue_constructor, tmp_boolean));
+ } /* if (ocvalue.type == OCONFIG_TYPE_BOOLEAN) */
+ else if (ocvalue.type == OCONFIG_TYPE_STRING)
+ {
+ m_ocvalue_constructor = (*jvm_env)->GetMethodID (jvm_env, c_ocvalue,
+ "<init>", "(Ljava/lang/String;)V");
+ if (m_ocvalue_constructor == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_value: Cannot find the "
+ "`OConfigValue (String)' constructor.");
+ return (NULL);
+ }
+
+ o_argument = (*jvm_env)->NewStringUTF (jvm_env, ocvalue.value.string);
+ if (o_argument == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_value: "
+ "Creating a String object failed.");
+ return (NULL);
+ }
+ }
+ else if (ocvalue.type == OCONFIG_TYPE_NUMBER)
+ {
+ m_ocvalue_constructor = (*jvm_env)->GetMethodID (jvm_env, c_ocvalue,
+ "<init>", "(Ljava/lang/Number;)V");
+ if (m_ocvalue_constructor == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_value: Cannot find the "
+ "`OConfigValue (Number)' constructor.");
+ return (NULL);
+ }
+
+ o_argument = ctoj_jdouble_to_number (jvm_env,
+ (jdouble) ocvalue.value.number);
+ if (o_argument == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_value: "
+ "Creating a Number object failed.");
+ return (NULL);
+ }
+ }
+ else
+ {
+ return (NULL);
+ }
+
+ assert (m_ocvalue_constructor != NULL);
+ assert (o_argument != NULL);
+
+ o_ocvalue = (*jvm_env)->NewObject (jvm_env,
+ c_ocvalue, m_ocvalue_constructor, o_argument);
+ if (o_ocvalue == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_value: "
+ "Creating an OConfigValue object failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_argument);
+ return (NULL);
+ }
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_argument);
+ return (o_ocvalue);
+} /* }}} jobject ctoj_oconfig_value */
+
+/* Convert a oconfig_item_t to a org/collectd/api/OConfigItem */
+static jobject ctoj_oconfig_item (JNIEnv *jvm_env, /* {{{ */
+ const oconfig_item_t *ci)
+{
+ jclass c_ocitem;
+ jmethodID m_ocitem_constructor;
+ jmethodID m_addvalue;
+ jmethodID m_addchild;
+ jobject o_key;
+ jobject o_ocitem;
+ int i;
+
+ c_ocitem = (*jvm_env)->FindClass (jvm_env, "org/collectd/api/OConfigItem");
+ if (c_ocitem == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_item: "
+ "FindClass (org/collectd/api/OConfigItem) failed.");
+ return (NULL);
+ }
+
+ /* Get the required methods: m_ocitem_constructor, m_addvalue, and m_addchild
+ * {{{ */
+ m_ocitem_constructor = (*jvm_env)->GetMethodID (jvm_env, c_ocitem,
+ "<init>", "(Ljava/lang/String;)V");
+ if (m_ocitem_constructor == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_item: Cannot find the "
+ "`OConfigItem (String)' constructor.");
+ return (NULL);
+ }
+
+ m_addvalue = (*jvm_env)->GetMethodID (jvm_env, c_ocitem,
+ "addValue", "(Lorg/collectd/api/OConfigValue;)V");
+ if (m_addvalue == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_item: Cannot find the "
+ "`addValue (OConfigValue)' method.");
+ return (NULL);
+ }
+
+ m_addchild = (*jvm_env)->GetMethodID (jvm_env, c_ocitem,
+ "addChild", "(Lorg/collectd/api/OConfigItem;)V");
+ if (m_addchild == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_item: Cannot find the "
+ "`addChild (OConfigItem)' method.");
+ return (NULL);
+ }
+ /* }}} */
+
+ /* Create a String object with the key.
+ * Needed for calling the constructor. */
+ o_key = (*jvm_env)->NewStringUTF (jvm_env, ci->key);
+ if (o_key == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_item: "
+ "Creating String object failed.");
+ return (NULL);
+ }
+
+ /* Create an OConfigItem object */
+ o_ocitem = (*jvm_env)->NewObject (jvm_env,
+ c_ocitem, m_ocitem_constructor, o_key);
+ if (o_ocitem == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_item: "
+ "Creating an OConfigItem object failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_key);
+ return (NULL);
+ }
+
+ /* We don't need the String object any longer.. */
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_key);
+
+ /* Call OConfigItem.addValue for each value */
+ for (i = 0; i < ci->values_num; i++) /* {{{ */
+ {
+ jobject o_value;
+
+ o_value = ctoj_oconfig_value (jvm_env, ci->values[i]);
+ if (o_value == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_item: "
+ "Creating an OConfigValue object failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_ocitem);
+ return (NULL);
+ }
+
+ (*jvm_env)->CallVoidMethod (jvm_env, o_ocitem, m_addvalue, o_value);
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_value);
+ } /* }}} for (i = 0; i < ci->values_num; i++) */
+
+ /* Call OConfigItem.addChild for each child */
+ for (i = 0; i < ci->children_num; i++) /* {{{ */
+ {
+ jobject o_child;
+
+ o_child = ctoj_oconfig_item (jvm_env, ci->children + i);
+ if (o_child == NULL)
+ {
+ ERROR ("java plugin: ctoj_oconfig_item: "
+ "Creating an OConfigItem object failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_ocitem);
+ return (NULL);
+ }
+
+ (*jvm_env)->CallVoidMethod (jvm_env, o_ocitem, m_addchild, o_child);
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_child);
+ } /* }}} for (i = 0; i < ci->children_num; i++) */
+
+ return (o_ocitem);
+} /* }}} jobject ctoj_oconfig_item */
+
+/* Convert a data_set_t to a org/collectd/api/DataSet */
+static jobject ctoj_data_set (JNIEnv *jvm_env, const data_set_t *ds) /* {{{ */
+{
+ jclass c_dataset;
+ jmethodID m_constructor;
+ jmethodID m_add;
+ jobject o_type;
+ jobject o_dataset;
+ int i;
+
+ /* Look up the org/collectd/api/DataSet class */
+ c_dataset = (*jvm_env)->FindClass (jvm_env, "org/collectd/api/DataSet");
+ if (c_dataset == NULL)
+ {
+ ERROR ("java plugin: ctoj_data_set: Looking up the "
+ "org/collectd/api/DataSet class failed.");
+ return (NULL);
+ }
+
+ /* Search for the `DataSet (String type)' constructor. */
+ m_constructor = (*jvm_env)->GetMethodID (jvm_env,
+ c_dataset, "<init>", "(Ljava.lang.String;)V");
+ if (m_constructor == NULL)
+ {
+ ERROR ("java plugin: ctoj_data_set: Looking up the "
+ "`DataSet (String)' constructor failed.");
+ return (NULL);
+ }
+
+ /* Search for the `void addDataSource (DataSource)' method. */
+ m_add = (*jvm_env)->GetMethodID (jvm_env,
+ c_dataset, "addDataSource", "(Lorg/collectd/api/DataSource;)V");
+ if (m_add == NULL)
+ {
+ ERROR ("java plugin: ctoj_data_set: Looking up the "
+ "`addDataSource (DataSource)' method failed.");
+ return (NULL);
+ }
+
+ o_type = (*jvm_env)->NewStringUTF (jvm_env, ds->type);
+ if (o_type == NULL)
+ {
+ ERROR ("java plugin: ctoj_data_set: Creating a String object failed.");
+ return (NULL);
+ }
+
+ o_dataset = (*jvm_env)->NewObject (jvm_env,
+ c_dataset, m_constructor, o_type);
+ if (o_dataset == NULL)
+ {
+ ERROR ("java plugin: ctoj_data_set: Creating a DataSet object failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_type);
+ return (NULL);
+ }
+
+ /* Decrease reference counter on the java.lang.String object. */
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_type);
+
+ for (i = 0; i < ds->ds_num; i++)
+ {
+ jobject o_datasource;
+
+ o_datasource = ctoj_data_source (jvm_env, ds->ds + i);
+ if (o_datasource == NULL)
+ {
+ ERROR ("java plugin: ctoj_data_set: ctoj_data_source (%s.%s) failed",
+ ds->type, ds->ds[i].name);
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_dataset);
+ return (NULL);
+ }
+
+ (*jvm_env)->CallVoidMethod (jvm_env, o_dataset, m_add, o_datasource);
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_datasource);
+ } /* for (i = 0; i < ds->ds_num; i++) */
+
+ return (o_dataset);
+} /* }}} jobject ctoj_data_set */
+
+static int ctoj_value_list_add_value (JNIEnv *jvm_env, /* {{{ */
+ value_t value, int ds_type,
+ jclass class_ptr, jobject object_ptr)
+{
+ jmethodID m_addvalue;
+ jobject o_number;
+
+ m_addvalue = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+ "addValue", "(Ljava/lang/Number;)V");
+ if (m_addvalue == NULL)
+ {
+ ERROR ("java plugin: ctoj_value_list_add_value: "
+ "Cannot find method `void addValue (Number)'.");
+ return (-1);
+ }
+
+ o_number = ctoj_value_to_number (jvm_env, value, ds_type);
+ if (o_number == NULL)
+ {
+ ERROR ("java plugin: ctoj_value_list_add_value: "
+ "ctoj_value_to_number failed.");
+ return (-1);
+ }
+
+ (*jvm_env)->CallVoidMethod (jvm_env, object_ptr, m_addvalue, o_number);
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_number);
+
+ return (0);
+} /* }}} int ctoj_value_list_add_value */
+
+static int ctoj_value_list_add_data_set (JNIEnv *jvm_env, /* {{{ */
+ jclass c_valuelist, jobject o_valuelist, const data_set_t *ds)
+{
+ jmethodID m_setdataset;
+ jobject o_dataset;
+
+ /* Look for the `void setDataSource (List<DataSource> ds)' method. */
+ m_setdataset = (*jvm_env)->GetMethodID (jvm_env, c_valuelist,
+ "setDataSet", "(Lorg/collectd/api/DataSet;)V");
+ if (m_setdataset == NULL)
+ {
+ ERROR ("java plugin: ctoj_value_list_add_data_set: "
+ "Cannot find the `void setDataSet (DataSet)' method.");
+ return (-1);
+ }
+
+ /* Create a DataSet object. */
+ o_dataset = ctoj_data_set (jvm_env, ds);
+ if (o_dataset == NULL)
+ {
+ ERROR ("java plugin: ctoj_value_list_add_data_set: "
+ "ctoj_data_set (%s) failed.", ds->type);
+ return (-1);
+ }
+
+ /* Actually call the method. */
+ (*jvm_env)->CallVoidMethod (jvm_env,
+ o_valuelist, m_setdataset, o_dataset);
+
+ /* Decrease reference counter on the List<DataSource> object. */
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_dataset);
+
+ return (0);
+} /* }}} int ctoj_value_list_add_data_set */
+
+/* Convert a value_list_t (and data_set_t) to a org/collectd/api/ValueList */
+static jobject ctoj_value_list (JNIEnv *jvm_env, /* {{{ */
+ const data_set_t *ds, const value_list_t *vl)
+{
+ jclass c_valuelist;
+ jmethodID m_valuelist_constructor;
+ jobject o_valuelist;
+ int status;
+ int i;
+
+ /* First, create a new ValueList instance..
+ * Look up the class.. */
+ c_valuelist = (*jvm_env)->FindClass (jvm_env,
+ "org/collectd/api/ValueList");
+ if (c_valuelist == NULL)
+ {
+ ERROR ("java plugin: ctoj_value_list: "
+ "FindClass (org/collectd/api/ValueList) failed.");
+ return (NULL);
+ }
+
+ /* Lookup the `ValueList ()' constructor. */
+ m_valuelist_constructor = (*jvm_env)->GetMethodID (jvm_env, c_valuelist,
+ "<init>", "()V");
+ if (m_valuelist_constructor == NULL)
+ {
+ ERROR ("java plugin: ctoj_value_list: Cannot find the "
+ "`ValueList ()' constructor.");
+ return (NULL);
+ }
+
+ /* Create a new instance. */
+ o_valuelist = (*jvm_env)->NewObject (jvm_env, c_valuelist,
+ m_valuelist_constructor);
+ if (o_valuelist == NULL)
+ {
+ ERROR ("java plugin: ctoj_value_list: Creating a new ValueList instance "
+ "failed.");
+ return (NULL);
+ }
+
+ status = ctoj_value_list_add_data_set (jvm_env,
+ c_valuelist, o_valuelist, ds);
+ if (status != 0)
+ {
+ ERROR ("java plugin: ctoj_value_list: "
+ "ctoj_value_list_add_data_set failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist);
+ return (NULL);
+ }
+
+ /* Set the strings.. */
+#define SET_STRING(str,method_name) do { \
+ status = ctoj_string (jvm_env, str, \
+ c_valuelist, o_valuelist, method_name); \
+ if (status != 0) { \
+ ERROR ("java plugin: ctoj_value_list: ctoj_string (%s) failed.", \
+ method_name); \
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist); \
+ return (NULL); \
+ } } while (0)
+
+ SET_STRING (vl->host, "setHost");
+ SET_STRING (vl->plugin, "setPlugin");
+ SET_STRING (vl->plugin_instance, "setPluginInstance");
+ SET_STRING (vl->type, "setType");
+ SET_STRING (vl->type_instance, "setTypeInstance");
+
+#undef SET_STRING
+
+ /* Set the `time' member. Java stores time in milliseconds. */
+ status = ctoj_long (jvm_env, ((jlong) vl->time) * ((jlong) 1000),
+ c_valuelist, o_valuelist, "setTime");
+ if (status != 0)
+ {
+ ERROR ("java plugin: ctoj_value_list: ctoj_long (setTime) failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist);
+ return (NULL);
+ }
+
+ /* Set the `interval' member.. */
+ status = ctoj_long (jvm_env, (jlong) vl->interval,
+ c_valuelist, o_valuelist, "setInterval");
+ if (status != 0)
+ {
+ ERROR ("java plugin: ctoj_value_list: ctoj_long (setInterval) failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist);
+ return (NULL);
+ }
+
+ for (i = 0; i < vl->values_len; i++)
+ {
+ status = ctoj_value_list_add_value (jvm_env, vl->values[i], ds->ds[i].type,
+ c_valuelist, o_valuelist);
+ if (status != 0)
+ {
+ ERROR ("java plugin: ctoj_value_list: "
+ "ctoj_value_list_add_value failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_valuelist);
+ return (NULL);
+ }
+ }
+
+ return (o_valuelist);
+} /* }}} jobject ctoj_value_list */
+
+/* Convert a notification_t to a org/collectd/api/Notification */
+static jobject ctoj_notification (JNIEnv *jvm_env, /* {{{ */
+ const notification_t *n)
+{
+ jclass c_notification;
+ jmethodID m_constructor;
+ jobject o_notification;
+ int status;
+
+ /* First, create a new Notification instance..
+ * Look up the class.. */
+ c_notification = (*jvm_env)->FindClass (jvm_env,
+ "org/collectd/api/Notification");
+ if (c_notification == NULL)
+ {
+ ERROR ("java plugin: ctoj_notification: "
+ "FindClass (org/collectd/api/Notification) failed.");
+ return (NULL);
+ }
+
+ /* Lookup the `Notification ()' constructor. */
+ m_constructor = (*jvm_env)->GetMethodID (jvm_env, c_notification,
+ "<init>", "()V");
+ if (m_constructor == NULL)
+ {
+ ERROR ("java plugin: ctoj_notification: Cannot find the "
+ "`Notification ()' constructor.");
+ return (NULL);
+ }
+
+ /* Create a new instance. */
+ o_notification = (*jvm_env)->NewObject (jvm_env, c_notification,
+ m_constructor);
+ if (o_notification == NULL)
+ {
+ ERROR ("java plugin: ctoj_notification: Creating a new Notification "
+ "instance failed.");
+ return (NULL);
+ }
+
+ /* Set the strings.. */
+#define SET_STRING(str,method_name) do { \
+ status = ctoj_string (jvm_env, str, \
+ c_notification, o_notification, method_name); \
+ if (status != 0) { \
+ ERROR ("java plugin: ctoj_notification: ctoj_string (%s) failed.", \
+ method_name); \
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_notification); \
+ return (NULL); \
+ } } while (0)
+
+ SET_STRING (n->host, "setHost");
+ SET_STRING (n->plugin, "setPlugin");
+ SET_STRING (n->plugin_instance, "setPluginInstance");
+ SET_STRING (n->type, "setType");
+ SET_STRING (n->type_instance, "setTypeInstance");
+ SET_STRING (n->message, "setMessage");
+
+#undef SET_STRING
+
+ /* Set the `time' member. Java stores time in milliseconds. */
+ status = ctoj_long (jvm_env, ((jlong) n->time) * ((jlong) 1000),
+ c_notification, o_notification, "setTime");
+ if (status != 0)
+ {
+ ERROR ("java plugin: ctoj_notification: ctoj_long (setTime) failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_notification);
+ return (NULL);
+ }
+
+ /* Set the `interval' member.. */
+ status = ctoj_int (jvm_env, (jint) n->severity,
+ c_notification, o_notification, "setSeverity");
+ if (status != 0)
+ {
+ ERROR ("java plugin: ctoj_notification: ctoj_int (setSeverity) failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_notification);
+ return (NULL);
+ }
+
+ return (o_notification);
+} /* }}} jobject ctoj_notification */
+
+/*
+ * Java to C conversion functions
+ */
+/* Call a `String <method> ()' method. */
+static int jtoc_string (JNIEnv *jvm_env, /* {{{ */
+ char *buffer, size_t buffer_size, int empty_okay,
+ jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+ jmethodID method_id;
+ jobject string_obj;
+ const char *c_str;
+
+ method_id = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+ method_name, "()Ljava/lang/String;");
+ if (method_id == NULL)
+ {
+ ERROR ("java plugin: jtoc_string: Cannot find method `String %s ()'.",
+ method_name);
+ return (-1);
+ }
+
+ string_obj = (*jvm_env)->CallObjectMethod (jvm_env, object_ptr, method_id);
+ if ((string_obj == NULL) && (empty_okay == 0))
+ {
+ ERROR ("java plugin: jtoc_string: CallObjectMethod (%s) failed.",
+ method_name);
+ return (-1);
+ }
+ else if ((string_obj == NULL) && (empty_okay != 0))
+ {
+ memset (buffer, 0, buffer_size);
+ return (0);
+ }
+
+ c_str = (*jvm_env)->GetStringUTFChars (jvm_env, string_obj, 0);
+ if (c_str == NULL)
+ {
+ ERROR ("java plugin: jtoc_string: GetStringUTFChars failed.");
+ (*jvm_env)->DeleteLocalRef (jvm_env, string_obj);
+ return (-1);
+ }
+
+ sstrncpy (buffer, c_str, buffer_size);
+
+ (*jvm_env)->ReleaseStringUTFChars (jvm_env, string_obj, c_str);
+ (*jvm_env)->DeleteLocalRef (jvm_env, string_obj);
+
+ return (0);
+} /* }}} int jtoc_string */
+
+/* Call an `int <method> ()' method. */
+static int jtoc_int (JNIEnv *jvm_env, /* {{{ */
+ jint *ret_value,
+ jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+ jmethodID method_id;
+
+ method_id = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+ method_name, "()I");
+ if (method_id == NULL)
+ {
+ ERROR ("java plugin: jtoc_int: Cannot find method `int %s ()'.",
+ method_name);
+ return (-1);
+ }
+
+ *ret_value = (*jvm_env)->CallIntMethod (jvm_env, object_ptr, method_id);
+
+ return (0);
+} /* }}} int jtoc_int */
+
+/* Call a `long <method> ()' method. */
+static int jtoc_long (JNIEnv *jvm_env, /* {{{ */
+ jlong *ret_value,
+ jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+ jmethodID method_id;
+
+ method_id = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+ method_name, "()J");
+ if (method_id == NULL)
+ {
+ ERROR ("java plugin: jtoc_long: Cannot find method `long %s ()'.",
+ method_name);
+ return (-1);
+ }
+
+ *ret_value = (*jvm_env)->CallLongMethod (jvm_env, object_ptr, method_id);
+
+ return (0);
+} /* }}} int jtoc_long */
+
+/* Call a `double <method> ()' method. */
+static int jtoc_double (JNIEnv *jvm_env, /* {{{ */
+ jdouble *ret_value,
+ jclass class_ptr, jobject object_ptr, const char *method_name)
+{
+ jmethodID method_id;
+
+ method_id = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+ method_name, "()D");
+ if (method_id == NULL)
+ {
+ ERROR ("java plugin: jtoc_double: Cannot find method `double %s ()'.",
+ method_name);
+ return (-1);
+ }
+
+ *ret_value = (*jvm_env)->CallDoubleMethod (jvm_env, object_ptr, method_id);
+
+ return (0);
+} /* }}} int jtoc_double */
+
+static int jtoc_value (JNIEnv *jvm_env, /* {{{ */
+ value_t *ret_value, int ds_type, jobject object_ptr)
+{
+ jclass class_ptr;
+ int status;
+
+ class_ptr = (*jvm_env)->GetObjectClass (jvm_env, object_ptr);
+
+ if (ds_type == DS_TYPE_COUNTER)
+ {
+ jlong tmp_long;
+
+ status = jtoc_long (jvm_env, &tmp_long,
+ class_ptr, object_ptr, "longValue");
+ if (status != 0)
+ {
+ ERROR ("java plugin: jtoc_value: "
+ "jtoc_long failed.");
+ return (-1);
+ }
+ (*ret_value).counter = (counter_t) tmp_long;
+ }
+ else
+ {
+ jdouble tmp_double;
+
+ status = jtoc_double (jvm_env, &tmp_double,
+ class_ptr, object_ptr, "doubleValue");
+ if (status != 0)
+ {
+ ERROR ("java plugin: jtoc_value: "
+ "jtoc_double failed.");
+ return (-1);
+ }
+ (*ret_value).gauge = (gauge_t) tmp_double;
+ }
+
+ return (0);
+} /* }}} int jtoc_value */
+
+/* Read a List<Number>, convert it to `value_t' and add it to the given
+ * `value_list_t'. */
+static int jtoc_values_array (JNIEnv *jvm_env, /* {{{ */
+ const data_set_t *ds, value_list_t *vl,
+ jclass class_ptr, jobject object_ptr)
+{
+ jmethodID m_getvalues;
+ jmethodID m_toarray;
+ jobject o_list;
+ jobjectArray o_number_array;
+
+ value_t *values;
+ int values_num;
+ int i;
+
+ values_num = ds->ds_num;
+
+ values = NULL;
+ o_number_array = NULL;
+ o_list = NULL;
+
+#define BAIL_OUT(status) \
+ free (values); \
+ if (o_number_array != NULL) \
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_number_array); \
+ if (o_list != NULL) \
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_list); \
+ return (status);
+
+ /* Call: List<Number> ValueList.getValues () */
+ m_getvalues = (*jvm_env)->GetMethodID (jvm_env, class_ptr,
+ "getValues", "()Ljava/util/List;");
+ if (m_getvalues == NULL)
+ {
+ ERROR ("java plugin: jtoc_values_array: "
+ "Cannot find method `List getValues ()'.");
+ BAIL_OUT (-1);
+ }
+
+ o_list = (*jvm_env)->CallObjectMethod (jvm_env, object_ptr, m_getvalues);
+ if (o_list == NULL)
+ {
+ ERROR ("java plugin: jtoc_values_array: "
+ "CallObjectMethod (getValues) failed.");
+ BAIL_OUT (-1);
+ }
+
+ /* Call: Number[] List.toArray () */
+ m_toarray = (*jvm_env)->GetMethodID (jvm_env,
+ (*jvm_env)->GetObjectClass (jvm_env, o_list),
+ "toArray", "()[Ljava/lang/Object;");
+ if (m_toarray == NULL)
+ {
+ ERROR ("java plugin: jtoc_values_array: "
+ "Cannot find method `Object[] toArray ()'.");
+ BAIL_OUT (-1);
+ }
+
+ o_number_array = (*jvm_env)->CallObjectMethod (jvm_env, o_list, m_toarray);
+ if (o_number_array == NULL)
+ {
+ ERROR ("java plugin: jtoc_values_array: "
+ "CallObjectMethod (toArray) failed.");
+ BAIL_OUT (-1);
+ }
+
+ values = (value_t *) calloc (values_num, sizeof (value_t));
+ if (values == NULL)
+ {
+ ERROR ("java plugin: jtoc_values_array: calloc failed.");
+ BAIL_OUT (-1);
+ }
+
+ for (i = 0; i < values_num; i++)
+ {
+ jobject o_number;
+ int status;
+
+ o_number = (*jvm_env)->GetObjectArrayElement (jvm_env,
+ o_number_array, (jsize) i);
+ if (o_number == NULL)
+ {
+ ERROR ("java plugin: jtoc_values_array: "
+ "GetObjectArrayElement (%i) failed.", i);
+ BAIL_OUT (-1);
+ }
+
+ status = jtoc_value (jvm_env, values + i, ds->ds[i].type, o_number);
+ if (status != 0)
+ {
+ ERROR ("java plugin: jtoc_values_array: "
+ "jtoc_value (%i) failed.", i);
+ BAIL_OUT (-1);
+ }
+ } /* for (i = 0; i < values_num; i++) */
+
+ vl->values = values;
+ vl->values_len = values_num;
+
+#undef BAIL_OUT
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_number_array);
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_list);
+ return (0);
+} /* }}} int jtoc_values_array */
+
+/* Convert a org/collectd/api/ValueList to a value_list_t. */
+static int jtoc_value_list (JNIEnv *jvm_env, value_list_t *vl, /* {{{ */
+ jobject object_ptr)
+{
+ jclass class_ptr;
+ int status;
+ jlong tmp_long;
+ const data_set_t *ds;
+
+ class_ptr = (*jvm_env)->GetObjectClass (jvm_env, object_ptr);
+ if (class_ptr == NULL)
+ {
+ ERROR ("java plugin: jtoc_value_list: GetObjectClass failed.");
+ return (-1);
+ }
+
+ /* eo == empty okay */
+#define SET_STRING(buffer,method, eo) do { \
+ status = jtoc_string (jvm_env, buffer, sizeof (buffer), eo, \
+ class_ptr, object_ptr, method); \
+ if (status != 0) { \
+ ERROR ("java plugin: jtoc_value_list: jtoc_string (%s) failed.", \
+ method); \
+ return (-1); \
+ } } while (0)
+
+ SET_STRING(vl->type, "getType", /* empty = */ 0);
+
+ ds = plugin_get_ds (vl->type);
+ if (ds == NULL)
+ {
+ ERROR ("java plugin: jtoc_value_list: Data-set `%s' is not defined. "
+ "Please consult the types.db(5) manpage for mor information.",
+ vl->type);
+ return (-1);
+ }
+
+ SET_STRING(vl->host, "getHost", /* empty = */ 0);
+ SET_STRING(vl->plugin, "getPlugin", /* empty = */ 0);
+ SET_STRING(vl->plugin_instance, "getPluginInstance", /* empty = */ 1);
+ SET_STRING(vl->type_instance, "getTypeInstance", /* empty = */ 1);
+
+#undef SET_STRING
+
+ status = jtoc_long (jvm_env, &tmp_long, class_ptr, object_ptr, "getTime");
+ if (status != 0)
+ {
+ ERROR ("java plugin: jtoc_value_list: jtoc_long (getTime) failed.");
+ return (-1);
+ }
+ /* Java measures time in milliseconds. */
+ vl->time = (time_t) (tmp_long / ((jlong) 1000));
+
+ status = jtoc_long (jvm_env, &tmp_long,
+ class_ptr, object_ptr, "getInterval");
+ if (status != 0)
+ {
+ ERROR ("java plugin: jtoc_value_list: jtoc_long (getInterval) failed.");
+ return (-1);
+ }
+ vl->interval = (int) tmp_long;
+
+ status = jtoc_values_array (jvm_env, ds, vl, class_ptr, object_ptr);
+ if (status != 0)
+ {
+ ERROR ("java plugin: jtoc_value_list: jtoc_values_array failed.");
+ return (-1);
+ }
+
+ return (0);
+} /* }}} int jtoc_value_list */
+
+/* Convert a org/collectd/api/Notification to a notification_t. */
+static int jtoc_notification (JNIEnv *jvm_env, notification_t *n, /* {{{ */
+ jobject object_ptr)
+{
+ jclass class_ptr;
+ int status;
+ jlong tmp_long;
+ jint tmp_int;
+
+ class_ptr = (*jvm_env)->GetObjectClass (jvm_env, object_ptr);
+ if (class_ptr == NULL)
+ {
+ ERROR ("java plugin: jtoc_notification: GetObjectClass failed.");
+ return (-1);
+ }
+
+ /* eo == empty okay */
+#define SET_STRING(buffer,method, eo) do { \
+ status = jtoc_string (jvm_env, buffer, sizeof (buffer), eo, \
+ class_ptr, object_ptr, method); \
+ if (status != 0) { \
+ ERROR ("java plugin: jtoc_notification: jtoc_string (%s) failed.", \
+ method); \
+ return (-1); \
+ } } while (0)
+
+ SET_STRING (n->host, "getHost", /* empty = */ 1);
+ SET_STRING (n->plugin, "getPlugin", /* empty = */ 1);
+ SET_STRING (n->plugin_instance, "getPluginInstance", /* empty = */ 1);
+ SET_STRING (n->type, "getType", /* empty = */ 1);
+ SET_STRING (n->type_instance, "getTypeInstance", /* empty = */ 1);
+ SET_STRING (n->message, "getMessage", /* empty = */ 0);
+
+#undef SET_STRING
+
+ status = jtoc_long (jvm_env, &tmp_long, class_ptr, object_ptr, "getTime");
+ if (status != 0)
+ {
+ ERROR ("java plugin: jtoc_notification: jtoc_long (getTime) failed.");
+ return (-1);
+ }
+ /* Java measures time in milliseconds. */
+ n->time = (time_t) (tmp_long / ((jlong) 1000));
+
+ status = jtoc_int (jvm_env, &tmp_int,
+ class_ptr, object_ptr, "getSeverity");
+ if (status != 0)
+ {
+ ERROR ("java plugin: jtoc_notification: jtoc_int (getSeverity) failed.");
+ return (-1);
+ }
+ n->severity = (int) tmp_int;
+
+ return (0);
+} /* }}} int jtoc_notification */
+/*
+ * Functions accessible from Java
+ */
+static jint JNICALL cjni_api_dispatch_values (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject java_vl)
+{
+ value_list_t vl = VALUE_LIST_INIT;
+ int status;
+
+ DEBUG ("cjni_api_dispatch_values: java_vl = %p;", (void *) java_vl);
+
+ status = jtoc_value_list (jvm_env, &vl, java_vl);
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_api_dispatch_values: jtoc_value_list failed.");
+ return (-1);
+ }
+
+ status = plugin_dispatch_values (&vl);
+
+ sfree (vl.values);
+
+ return (status);
+} /* }}} jint cjni_api_dispatch_values */
+
+static jint JNICALL cjni_api_dispatch_notification (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_notification)
+{
+ notification_t n;
+ int status;
+
+ memset (&n, 0, sizeof (n));
+ n.meta = NULL;
+
+ status = jtoc_notification (jvm_env, &n, o_notification);
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_api_dispatch_notification: jtoc_notification failed.");
+ return (-1);
+ }
+
+ status = plugin_dispatch_notification (&n);
+
+ return (status);
+} /* }}} jint cjni_api_dispatch_notification */
+
+static jobject JNICALL cjni_api_get_ds (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_string_type)
+{
+ const char *ds_name;
+ const data_set_t *ds;
+ jobject o_dataset;
+
+ ds_name = (*jvm_env)->GetStringUTFChars (jvm_env, o_string_type, 0);
+ if (ds_name == NULL)
+ {
+ ERROR ("java plugin: cjni_api_get_ds: GetStringUTFChars failed.");
+ return (NULL);
+ }
+
+ ds = plugin_get_ds (ds_name);
+ DEBUG ("java plugin: cjni_api_get_ds: "
+ "plugin_get_ds (%s) = %p;", ds_name, (void *) ds);
+
+ (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_string_type, ds_name);
+
+ if (ds == NULL)
+ return (NULL);
+
+ o_dataset = ctoj_data_set (jvm_env, ds);
+ return (o_dataset);
+} /* }}} jint cjni_api_get_ds */
+
+static jint JNICALL cjni_api_register_config (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_name, jobject o_config)
+{
+ return (cjni_callback_register (jvm_env, o_name, o_config, CB_TYPE_CONFIG));
+} /* }}} jint cjni_api_register_config */
+
+static jint JNICALL cjni_api_register_init (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_name, jobject o_config)
+{
+ return (cjni_callback_register (jvm_env, o_name, o_config, CB_TYPE_INIT));
+} /* }}} jint cjni_api_register_init */
+
+static jint JNICALL cjni_api_register_read (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_name, jobject o_read)
+{
+ user_data_t ud;
+ cjni_callback_info_t *cbi;
+
+ cbi = cjni_callback_info_create (jvm_env, o_name, o_read, CB_TYPE_READ);
+ if (cbi == NULL)
+ return (-1);
+
+ DEBUG ("java plugin: Registering new read callback: %s", cbi->name);
+
+ memset (&ud, 0, sizeof (ud));
+ ud.data = (void *) cbi;
+ ud.free_func = cjni_callback_info_destroy;
+
+ plugin_register_complex_read (cbi->name, cjni_read,
+ /* interval = */ NULL, &ud);
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_read);
+
+ return (0);
+} /* }}} jint cjni_api_register_read */
+
+static jint JNICALL cjni_api_register_write (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_name, jobject o_write)
+{
+ user_data_t ud;
+ cjni_callback_info_t *cbi;
+
+ cbi = cjni_callback_info_create (jvm_env, o_name, o_write, CB_TYPE_WRITE);
+ if (cbi == NULL)
+ return (-1);
+
+ DEBUG ("java plugin: Registering new write callback: %s", cbi->name);
+
+ memset (&ud, 0, sizeof (ud));
+ ud.data = (void *) cbi;
+ ud.free_func = cjni_callback_info_destroy;
+
+ plugin_register_write (cbi->name, cjni_write, &ud);
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_write);
+
+ return (0);
+} /* }}} jint cjni_api_register_write */
+
+static jint JNICALL cjni_api_register_flush (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_name, jobject o_flush)
+{
+ user_data_t ud;
+ cjni_callback_info_t *cbi;
+
+ cbi = cjni_callback_info_create (jvm_env, o_name, o_flush, CB_TYPE_FLUSH);
+ if (cbi == NULL)
+ return (-1);
+
+ DEBUG ("java plugin: Registering new flush callback: %s", cbi->name);
+
+ memset (&ud, 0, sizeof (ud));
+ ud.data = (void *) cbi;
+ ud.free_func = cjni_callback_info_destroy;
+
+ plugin_register_flush (cbi->name, cjni_flush, &ud);
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_flush);
+
+ return (0);
+} /* }}} jint cjni_api_register_flush */
+
+static jint JNICALL cjni_api_register_shutdown (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_name, jobject o_shutdown)
+{
+ return (cjni_callback_register (jvm_env, o_name, o_shutdown,
+ CB_TYPE_SHUTDOWN));
+} /* }}} jint cjni_api_register_shutdown */
+
+static jint JNICALL cjni_api_register_log (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_name, jobject o_log)
+{
+ user_data_t ud;
+ cjni_callback_info_t *cbi;
+
+ cbi = cjni_callback_info_create (jvm_env, o_name, o_log, CB_TYPE_LOG);
+ if (cbi == NULL)
+ return (-1);
+
+ DEBUG ("java plugin: Registering new log callback: %s", cbi->name);
+
+ memset (&ud, 0, sizeof (ud));
+ ud.data = (void *) cbi;
+ ud.free_func = cjni_callback_info_destroy;
+
+ plugin_register_log (cbi->name, cjni_log, &ud);
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_log);
+
+ return (0);
+} /* }}} jint cjni_api_register_log */
+
+static jint JNICALL cjni_api_register_notification (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_name, jobject o_notification)
+{
+ user_data_t ud;
+ cjni_callback_info_t *cbi;
+
+ cbi = cjni_callback_info_create (jvm_env, o_name, o_notification,
+ CB_TYPE_NOTIFICATION);
+ if (cbi == NULL)
+ return (-1);
+
+ DEBUG ("java plugin: Registering new notification callback: %s", cbi->name);
+
+ memset (&ud, 0, sizeof (ud));
+ ud.data = (void *) cbi;
+ ud.free_func = cjni_callback_info_destroy;
+
+ plugin_register_notification (cbi->name, cjni_notification, &ud);
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_notification);
+
+ return (0);
+} /* }}} jint cjni_api_register_notification */
+
+static jint JNICALL cjni_api_register_match_target (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_name, jobject o_match, int type)
+{
+ int status;
+ const char *c_name;
+
+ c_name = (*jvm_env)->GetStringUTFChars (jvm_env, o_name, 0);
+ if (c_name == NULL)
+ {
+ ERROR ("java plugin: cjni_api_register_match_target: "
+ "GetStringUTFChars failed.");
+ return (-1);
+ }
+
+ status = cjni_callback_register (jvm_env, o_name, o_match, type);
+ if (status != 0)
+ {
+ (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+ return (-1);
+ }
+
+ if (type == CB_TYPE_MATCH)
+ {
+ match_proc_t m_proc;
+
+ memset (&m_proc, 0, sizeof (m_proc));
+ m_proc.create = cjni_match_target_create;
+ m_proc.destroy = cjni_match_target_destroy;
+ m_proc.match = (void *) cjni_match_target_invoke;
+
+ status = fc_register_match (c_name, m_proc);
+ }
+ else if (type == CB_TYPE_TARGET)
+ {
+ target_proc_t t_proc;
+
+ memset (&t_proc, 0, sizeof (t_proc));
+ t_proc.create = cjni_match_target_create;
+ t_proc.destroy = cjni_match_target_destroy;
+ t_proc.invoke = cjni_match_target_invoke;
+
+ status = fc_register_target (c_name, t_proc);
+ }
+ else
+ {
+ ERROR ("java plugin: cjni_api_register_match_target: "
+ "Don't know whether to create a match or a target.");
+ (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+ return (-1);
+ }
+
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_api_register_match_target: "
+ "%s failed.",
+ (type == CB_TYPE_MATCH) ? "fc_register_match" : "fc_register_target");
+ (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+ return (-1);
+ }
+
+ (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+
+ return (0);
+} /* }}} jint cjni_api_register_match_target */
+
+static jint JNICALL cjni_api_register_match (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_name, jobject o_match)
+{
+ return (cjni_api_register_match_target (jvm_env, this, o_name, o_match,
+ CB_TYPE_MATCH));
+} /* }}} jint cjni_api_register_match */
+
+static jint JNICALL cjni_api_register_target (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jobject o_name, jobject o_target)
+{
+ return (cjni_api_register_match_target (jvm_env, this, o_name, o_target,
+ CB_TYPE_TARGET));
+} /* }}} jint cjni_api_register_target */
+
+static void JNICALL cjni_api_log (JNIEnv *jvm_env, /* {{{ */
+ jobject this, jint severity, jobject o_message)
+{
+ const char *c_str;
+
+ c_str = (*jvm_env)->GetStringUTFChars (jvm_env, o_message, 0);
+ if (c_str == NULL)
+ {
+ ERROR ("java plugin: cjni_api_log: GetStringUTFChars failed.");
+ return;
+ }
+
+ if (severity < LOG_ERR)
+ severity = LOG_ERR;
+ if (severity > LOG_DEBUG)
+ severity = LOG_DEBUG;
+
+ plugin_log (severity, "%s", c_str);
+
+ (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_message, c_str);
+} /* }}} void cjni_api_log */
+
+/* List of ``native'' functions, i. e. C-functions that can be called from
+ * Java. */
+static JNINativeMethod jni_api_functions[] = /* {{{ */
+{
+ { "dispatchValues",
+ "(Lorg/collectd/api/ValueList;)I",
+ cjni_api_dispatch_values },
+
+ { "dispatchNotification",
+ "(Lorg/collectd/api/Notification;)I",
+ cjni_api_dispatch_notification },
+
+ { "getDS",
+ "(Ljava/lang/String;)Lorg/collectd/api/DataSet;",
+ cjni_api_get_ds },
+
+ { "registerConfig",
+ "(Ljava/lang/String;Lorg/collectd/api/CollectdConfigInterface;)I",
+ cjni_api_register_config },
+
+ { "registerInit",
+ "(Ljava/lang/String;Lorg/collectd/api/CollectdInitInterface;)I",
+ cjni_api_register_init },
+
+ { "registerRead",
+ "(Ljava/lang/String;Lorg/collectd/api/CollectdReadInterface;)I",
+ cjni_api_register_read },
+
+ { "registerWrite",
+ "(Ljava/lang/String;Lorg/collectd/api/CollectdWriteInterface;)I",
+ cjni_api_register_write },
+
+ { "registerFlush",
+ "(Ljava/lang/String;Lorg/collectd/api/CollectdFlushInterface;)I",
+ cjni_api_register_flush },
+
+ { "registerShutdown",
+ "(Ljava/lang/String;Lorg/collectd/api/CollectdShutdownInterface;)I",
+ cjni_api_register_shutdown },
+
+ { "registerLog",
+ "(Ljava/lang/String;Lorg/collectd/api/CollectdLogInterface;)I",
+ cjni_api_register_log },
+
+ { "registerNotification",
+ "(Ljava/lang/String;Lorg/collectd/api/CollectdNotificationInterface;)I",
+ cjni_api_register_notification },
+
+ { "registerMatch",
+ "(Ljava/lang/String;Lorg/collectd/api/CollectdMatchFactoryInterface;)I",
+ cjni_api_register_match },
+
+ { "registerTarget",
+ "(Ljava/lang/String;Lorg/collectd/api/CollectdTargetFactoryInterface;)I",
+ cjni_api_register_target },
+
+ { "log",
+ "(ILjava/lang/String;)V",
+ cjni_api_log },
+};
+static size_t jni_api_functions_num = sizeof (jni_api_functions)
+ / sizeof (jni_api_functions[0]);
+/* }}} */
+
+/*
+ * Functions
+ */
+/* Allocate a `cjni_callback_info_t' given the type and objects necessary for
+ * all registration functions. */
+static cjni_callback_info_t *cjni_callback_info_create (JNIEnv *jvm_env, /* {{{ */
+ jobject o_name, jobject o_callback, int type)
+{
+ const char *c_name;
+ cjni_callback_info_t *cbi;
+ const char *method_name;
+ const char *method_signature;
+
+ switch (type)
+ {
+ case CB_TYPE_CONFIG:
+ method_name = "config";
+ method_signature = "(Lorg/collectd/api/OConfigItem;)I";
+ break;
+
+ case CB_TYPE_INIT:
+ method_name = "init";
+ method_signature = "()I";
+ break;
+
+ case CB_TYPE_READ:
+ method_name = "read";
+ method_signature = "()I";
+ break;
+
+ case CB_TYPE_WRITE:
+ method_name = "write";
+ method_signature = "(Lorg/collectd/api/ValueList;)I";
+ break;
+
+ case CB_TYPE_FLUSH:
+ method_name = "flush";
+ method_signature = "(ILjava/lang/String;)I";
+ break;
+
+ case CB_TYPE_SHUTDOWN:
+ method_name = "shutdown";
+ method_signature = "()I";
+ break;
+
+ case CB_TYPE_LOG:
+ method_name = "log";
+ method_signature = "(ILjava/lang/String;)V";
+ break;
+
+ case CB_TYPE_NOTIFICATION:
+ method_name = "notification";
+ method_signature = "(Lorg/collectd/api/Notification;)I";
+ break;
+
+ case CB_TYPE_MATCH:
+ method_name = "createMatch";
+ method_signature = "(Lorg/collectd/api/OConfigItem;)"
+ "Lorg/collectd/api/CollectdMatchInterface;";
+ break;
+
+ case CB_TYPE_TARGET:
+ method_name = "createTarget";
+ method_signature = "(Lorg/collectd/api/OConfigItem;)"
+ "Lorg/collectd/api/CollectdTargetInterface;";
+ break;
+
+ default:
+ ERROR ("java plugin: cjni_callback_info_create: Unknown type: %#x",
+ type);
+ return (NULL);
+ }
+
+ c_name = (*jvm_env)->GetStringUTFChars (jvm_env, o_name, 0);
+ if (c_name == NULL)
+ {
+ ERROR ("java plugin: cjni_callback_info_create: "
+ "GetStringUTFChars failed.");
+ return (NULL);
+ }
+
+ cbi = (cjni_callback_info_t *) malloc (sizeof (*cbi));
+ if (cbi == NULL)
+ {
+ ERROR ("java plugin: cjni_callback_info_create: malloc failed.");
+ (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+ return (NULL);
+ }
+ memset (cbi, 0, sizeof (*cbi));
+ cbi->type = type;
+
+ cbi->name = strdup (c_name);
+ if (cbi->name == NULL)
+ {
+ pthread_mutex_unlock (&java_callbacks_lock);
+ ERROR ("java plugin: cjni_callback_info_create: strdup failed.");
+ (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+ return (NULL);
+ }
+
+ (*jvm_env)->ReleaseStringUTFChars (jvm_env, o_name, c_name);
+
+ cbi->object = (*jvm_env)->NewGlobalRef (jvm_env, o_callback);
+ if (cbi->object == NULL)
+ {
+ ERROR ("java plugin: cjni_callback_info_create: NewGlobalRef failed.");
+ free (cbi);
+ return (NULL);
+ }
+
+ cbi->class = (*jvm_env)->GetObjectClass (jvm_env, cbi->object);
+ if (cbi->class == NULL)
+ {
+ ERROR ("java plugin: cjni_callback_info_create: GetObjectClass failed.");
+ free (cbi);
+ return (NULL);
+ }
+
+ cbi->method = (*jvm_env)->GetMethodID (jvm_env, cbi->class,
+ method_name, method_signature);
+ if (cbi->method == NULL)
+ {
+ ERROR ("java plugin: cjni_callback_info_create: "
+ "Cannot find the `%s' method with signature `%s'.",
+ method_name, method_signature);
+ free (cbi);
+ return (NULL);
+ }
+
+ return (cbi);
+} /* }}} cjni_callback_info_t cjni_callback_info_create */
+
+/* Allocate a `cjni_callback_info_t' via `cjni_callback_info_create' and add it
+ * to the global `java_callbacks' variable. This is used for `config', `init',
+ * and `shutdown' callbacks. */
+static int cjni_callback_register (JNIEnv *jvm_env, /* {{{ */
+ jobject o_name, jobject o_callback, int type)
+{
+ cjni_callback_info_t *cbi;
+ cjni_callback_info_t *tmp;
+#if COLLECT_DEBUG
+ const char *type_str;
+#endif
+
+ cbi = cjni_callback_info_create (jvm_env, o_name, o_callback, type);
+ if (cbi == NULL)
+ return (-1);
+
+#if COLLECT_DEBUG
+ switch (type)
+ {
+ case CB_TYPE_CONFIG:
+ type_str = "config";
+ break;
+
+ case CB_TYPE_INIT:
+ type_str = "init";
+ break;
+
+ case CB_TYPE_SHUTDOWN:
+ type_str = "shutdown";
+ break;
+
+ case CB_TYPE_MATCH:
+ type_str = "match";
+ break;
+
+ case CB_TYPE_TARGET:
+ type_str = "target";
+ break;
+
+ default:
+ type_str = "<unknown>";
+ }
+ DEBUG ("java plugin: Registering new %s callback: %s",
+ type_str, cbi->name);
+#endif
+
+ pthread_mutex_lock (&java_callbacks_lock);
+
+ tmp = (cjni_callback_info_t *) realloc (java_callbacks,
+ (java_callbacks_num + 1) * sizeof (*java_callbacks));
+ if (tmp == NULL)
+ {
+ pthread_mutex_unlock (&java_callbacks_lock);
+ ERROR ("java plugin: cjni_callback_register: realloc failed.");
+
+ (*jvm_env)->DeleteGlobalRef (jvm_env, cbi->object);
+ free (cbi);
+
+ return (-1);
+ }
+ java_callbacks = tmp;
+ java_callbacks[java_callbacks_num] = *cbi;
+ java_callbacks_num++;
+
+ pthread_mutex_unlock (&java_callbacks_lock);
+
+ free (cbi);
+ return (0);
+} /* }}} int cjni_callback_register */
+
+/* Callback for `pthread_key_create'. It frees the data contained in
+ * `jvm_env_key' and prints a warning if the reference counter is not zero. */
+static void cjni_jvm_env_destroy (void *args) /* {{{ */
+{
+ cjni_jvm_env_t *cjni_env;
+
+ if (args == NULL)
+ return;
+
+ cjni_env = (cjni_jvm_env_t *) args;
+
+ if (cjni_env->reference_counter > 0)
+ {
+ ERROR ("java plugin: cjni_jvm_env_destroy: "
+ "cjni_env->reference_counter = %i;", cjni_env->reference_counter);
+ }
+
+ if (cjni_env->jvm_env != NULL)
+ {
+ ERROR ("java plugin: cjni_jvm_env_destroy: cjni_env->jvm_env = %p;",
+ (void *) cjni_env->jvm_env);
+ }
+
+ /* The pointer is allocated in `cjni_thread_attach' */
+ free (cjni_env);
+} /* }}} void cjni_jvm_env_destroy */
+
+/* Register ``native'' functions with the JVM. Native functions are C-functions
+ * that can be called by Java code. */
+static int cjni_init_native (JNIEnv *jvm_env) /* {{{ */
+{
+ jclass api_class_ptr;
+ int status;
+
+ api_class_ptr = (*jvm_env)->FindClass (jvm_env, "org/collectd/api/Collectd");
+ if (api_class_ptr == NULL)
+ {
+ ERROR ("cjni_init_native: Cannot find API class `org/collectd/api/Collectd'.");
+ return (-1);
+ }
+
+ status = (*jvm_env)->RegisterNatives (jvm_env, api_class_ptr,
+ jni_api_functions, (jint) jni_api_functions_num);
+ if (status != 0)
+ {
+ ERROR ("cjni_init_native: RegisterNatives failed with status %i.", status);
+ return (-1);
+ }
+
+ return (0);
+} /* }}} int cjni_init_native */
+
+/* Create the JVM. This is called when the first thread tries to access the JVM
+ * via cjni_thread_attach. */
+static int cjni_create_jvm (void) /* {{{ */
+{
+ JNIEnv *jvm_env;
+ JavaVMInitArgs vm_args;
+ JavaVMOption vm_options[jvm_argc];
+
+ int status;
+ size_t i;
+
+ if (jvm != NULL)
+ return (0);
+
+ status = pthread_key_create (&jvm_env_key, cjni_jvm_env_destroy);
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_create_jvm: pthread_key_create failed "
+ "with status %i.", status);
+ return (-1);
+ }
+
+ jvm_env = NULL;
+
+ memset (&vm_args, 0, sizeof (vm_args));
+ vm_args.version = JNI_VERSION_1_2;
+ vm_args.options = vm_options;
+ vm_args.nOptions = (jint) jvm_argc;
+
+ for (i = 0; i < jvm_argc; i++)
+ {
+ DEBUG ("java plugin: cjni_create_jvm: jvm_argv[%zu] = %s",
+ i, jvm_argv[i]);
+ vm_args.options[i].optionString = jvm_argv[i];
+ }
+
+ status = JNI_CreateJavaVM (&jvm, (void *) &jvm_env, (void *) &vm_args);
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_create_jvm: "
+ "JNI_CreateJavaVM failed with status %i.",
+ status);
+ return (-1);
+ }
+ assert (jvm != NULL);
+ assert (jvm_env != NULL);
+
+ /* Call RegisterNatives */
+ status = cjni_init_native (jvm_env);
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_create_jvm: cjni_init_native failed.");
+ return (-1);
+ }
+
+ DEBUG ("java plugin: The JVM has been created.");
+ return (0);
+} /* }}} int cjni_create_jvm */
+
+/* Increase the reference counter to the JVM for this thread. If it was zero,
+ * attach the JVM first. */
+static JNIEnv *cjni_thread_attach (void) /* {{{ */
+{
+ cjni_jvm_env_t *cjni_env;
+ JNIEnv *jvm_env;
+
+ /* If we're the first thread to access the JVM, we'll have to create it
+ * first.. */
+ if (jvm == NULL)
+ {
+ int status;
+
+ status = cjni_create_jvm ();
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_thread_attach: cjni_create_jvm failed.");
+ return (NULL);
+ }
+ }
+ assert (jvm != NULL);
+
+ cjni_env = pthread_getspecific (jvm_env_key);
+ if (cjni_env == NULL)
+ {
+ /* This pointer is free'd in `cjni_jvm_env_destroy'. */
+ cjni_env = (cjni_jvm_env_t *) malloc (sizeof (*cjni_env));
+ if (cjni_env == NULL)
+ {
+ ERROR ("java plugin: cjni_thread_attach: malloc failed.");
+ return (NULL);
+ }
+ memset (cjni_env, 0, sizeof (*cjni_env));
+ cjni_env->reference_counter = 0;
+ cjni_env->jvm_env = NULL;
+
+ pthread_setspecific (jvm_env_key, cjni_env);
+ }
+
+ if (cjni_env->reference_counter > 0)
+ {
+ cjni_env->reference_counter++;
+ jvm_env = cjni_env->jvm_env;
+ }
+ else
+ {
+ int status;
+ JavaVMAttachArgs args;
+
+ assert (cjni_env->jvm_env == NULL);
+
+ memset (&args, 0, sizeof (args));
+ args.version = JNI_VERSION_1_2;
+
+ status = (*jvm)->AttachCurrentThread (jvm, (void *) &jvm_env, (void *) &args);
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_thread_attach: AttachCurrentThread failed "
+ "with status %i.", status);
+ return (NULL);
+ }
+
+ cjni_env->reference_counter = 1;
+ cjni_env->jvm_env = jvm_env;
+ }
+
+ DEBUG ("java plugin: cjni_thread_attach: cjni_env->reference_counter = %i",
+ cjni_env->reference_counter);
+ assert (jvm_env != NULL);
+ return (jvm_env);
+} /* }}} JNIEnv *cjni_thread_attach */
+
+/* Decrease the reference counter of this thread. If it reaches zero, detach
+ * from the JVM. */
+static int cjni_thread_detach (void) /* {{{ */
+{
+ cjni_jvm_env_t *cjni_env;
+ int status;
+
+ cjni_env = pthread_getspecific (jvm_env_key);
+ if (cjni_env == NULL)
+ {
+ ERROR ("java plugin: cjni_thread_detach: pthread_getspecific failed.");
+ return (-1);
+ }
+
+ assert (cjni_env->reference_counter > 0);
+ assert (cjni_env->jvm_env != NULL);
+
+ cjni_env->reference_counter--;
+ DEBUG ("java plugin: cjni_thread_detach: cjni_env->reference_counter = %i",
+ cjni_env->reference_counter);
+
+ if (cjni_env->reference_counter > 0)
+ return (0);
+
+ status = (*jvm)->DetachCurrentThread (jvm);
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_thread_detach: DetachCurrentThread failed "
+ "with status %i.", status);
+ }
+
+ cjni_env->reference_counter = 0;
+ cjni_env->jvm_env = NULL;
+
+ return (0);
+} /* }}} JNIEnv *cjni_thread_attach */
+
+static int cjni_config_add_jvm_arg (oconfig_item_t *ci) /* {{{ */
+{
+ char **tmp;
+
+ if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("java plugin: `JVMArg' needs exactly one string argument.");
+ return (-1);
+ }
+
+ if (jvm != NULL)
+ {
+ ERROR ("java plugin: All `JVMArg' options MUST appear before all "
+ "`LoadPlugin' options! The JVM is already started and I have to "
+ "ignore this argument: %s",
+ ci->values[0].value.string);
+ return (-1);
+ }
+
+ tmp = (char **) realloc (jvm_argv, sizeof (char *) * (jvm_argc + 1));
+ if (tmp == NULL)
+ {
+ ERROR ("java plugin: realloc failed.");
+ return (-1);
+ }
+ jvm_argv = tmp;
+
+ jvm_argv[jvm_argc] = strdup (ci->values[0].value.string);
+ if (jvm_argv[jvm_argc] == NULL)
+ {
+ ERROR ("java plugin: strdup failed.");
+ return (-1);
+ }
+ jvm_argc++;
+
+ return (0);
+} /* }}} int cjni_config_add_jvm_arg */
+
+static int cjni_config_load_plugin (oconfig_item_t *ci) /* {{{ */
+{
+ JNIEnv *jvm_env;
+ java_plugin_class_t *class;
+ jmethodID constructor_id;
+ jobject tmp_object;
+
+ if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("java plugin: `LoadPlugin' needs exactly one string argument.");
+ return (-1);
+ }
+
+ jvm_env = cjni_thread_attach ();
+ if (jvm_env == NULL)
+ return (-1);
+
+ class = (java_plugin_class_t *) realloc (java_classes_list,
+ (java_classes_list_len + 1) * sizeof (*java_classes_list));
+ if (class == NULL)
+ {
+ ERROR ("java plugin: realloc failed.");
+ cjni_thread_detach ();
+ return (-1);
+ }
+ java_classes_list = class;
+ class = java_classes_list + java_classes_list_len;
+
+ memset (class, 0, sizeof (*class));
+ class->name = strdup (ci->values[0].value.string);
+ if (class->name == NULL)
+ {
+ ERROR ("java plugin: strdup failed.");
+ cjni_thread_detach ();
+ return (-1);
+ }
+ class->class = NULL;
+ class->object = NULL;
+
+ DEBUG ("java plugin: Loading class %s", class->name);
+
+ class->class = (*jvm_env)->FindClass (jvm_env, class->name);
+ if (class->class == NULL)
+ {
+ ERROR ("java plugin: cjni_config_load_plugin: FindClass (%s) failed.",
+ class->name);
+ cjni_thread_detach ();
+ free (class->name);
+ return (-1);
+ }
+
+ constructor_id = (*jvm_env)->GetMethodID (jvm_env, class->class,
+ "<init>", "()V");
+ if (constructor_id == NULL)
+ {
+ ERROR ("java plugin: cjni_config_load_plugin: "
+ "Could not find the constructor for `%s'.",
+ class->name);
+ cjni_thread_detach ();
+ free (class->name);
+ return (-1);
+ }
+
+ tmp_object = (*jvm_env)->NewObject (jvm_env, class->class,
+ constructor_id);
+ if (tmp_object != NULL)
+ class->object = (*jvm_env)->NewGlobalRef (jvm_env, tmp_object);
+ else
+ class->object = NULL;
+ if (class->object == NULL)
+ {
+ ERROR ("java plugin: cjni_config_load_plugin: "
+ "Could create a new `%s' object.",
+ class->name);
+ cjni_thread_detach ();
+ free (class->name);
+ return (-1);
+ }
+
+ cjni_thread_detach ();
+
+ java_classes_list_len++;
+
+ return (0);
+} /* }}} int cjni_config_load_plugin */
+
+static int cjni_config_plugin_block (oconfig_item_t *ci) /* {{{ */
+{
+ JNIEnv *jvm_env;
+ cjni_callback_info_t *cbi;
+ jobject o_ocitem;
+ const char *name;
+ int status;
+ size_t i;
+
+ jclass class;
+ jmethodID method;
+
+ if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("java plugin: `Plugin' blocks "
+ "need exactly one string argument.");
+ return (-1);
+ }
+
+ name = ci->values[0].value.string;
+
+ cbi = NULL;
+ for (i = 0; i < java_callbacks_num; i++)
+ {
+ if (java_callbacks[i].type != CB_TYPE_CONFIG)
+ continue;
+
+ if (strcmp (name, java_callbacks[i].name) != 0)
+ continue;
+
+ cbi = java_callbacks + i;
+ break;
+ }
+
+ if (cbi == NULL)
+ {
+ NOTICE ("java plugin: Configuration block for `%s' found, but no such "
+ "configuration callback has been registered. Please make sure, the "
+ "`LoadPlugin' lines precede the `Plugin' blocks.",
+ name);
+ return (0);
+ }
+
+ DEBUG ("java plugin: Configuring %s", name);
+
+ jvm_env = cjni_thread_attach ();
+ if (jvm_env == NULL)
+ return (-1);
+
+ o_ocitem = ctoj_oconfig_item (jvm_env, ci);
+ if (o_ocitem == NULL)
+ {
+ ERROR ("java plugin: cjni_config_plugin_block: ctoj_oconfig_item failed.");
+ cjni_thread_detach ();
+ return (-1);
+ }
+
+ class = (*jvm_env)->GetObjectClass (jvm_env, cbi->object);
+ method = (*jvm_env)->GetMethodID (jvm_env, class,
+ "config", "(Lorg/collectd/api/OConfigItem;)I");
+
+ status = (*jvm_env)->CallIntMethod (jvm_env,
+ cbi->object, method, o_ocitem);
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_ocitem);
+ cjni_thread_detach ();
+ return (0);
+} /* }}} int cjni_config_plugin_block */
+
+static int cjni_config (oconfig_item_t *ci) /* {{{ */
+{
+ int success;
+ int errors;
+ int status;
+ int i;
+
+ success = 0;
+ errors = 0;
+
+ for (i = 0; i < ci->children_num; i++)
+ {
+ oconfig_item_t *child = ci->children + i;
+
+ if (strcasecmp ("JVMArg", child->key) == 0)
+ {
+ status = cjni_config_add_jvm_arg (child);
+ if (status == 0)
+ success++;
+ else
+ errors++;
+ }
+ else if (strcasecmp ("LoadPlugin", child->key) == 0)
+ {
+ status = cjni_config_load_plugin (child);
+ if (status == 0)
+ success++;
+ else
+ errors++;
+ }
+ else if (strcasecmp ("Plugin", child->key) == 0)
+ {
+ status = cjni_config_plugin_block (child);
+ if (status == 0)
+ success++;
+ else
+ errors++;
+ }
+ else
+ {
+ WARNING ("java plugin: Option `%s' not allowed here.", child->key);
+ errors++;
+ }
+ }
+
+ DEBUG ("java plugin: jvm_argc = %zu;", jvm_argc);
+ DEBUG ("java plugin: java_classes_list_len = %zu;", java_classes_list_len);
+
+ if ((success == 0) && (errors > 0))
+ {
+ ERROR ("java plugin: All statements failed.");
+ return (-1);
+ }
+
+ return (0);
+} /* }}} int cjni_config */
+
+/* Free the data contained in the `user_data_t' pointer passed to `cjni_read'
+ * and `cjni_write'. In particular, delete the global reference to the Java
+ * object. */
+static void cjni_callback_info_destroy (void *arg) /* {{{ */
+{
+ JNIEnv *jvm_env;
+ cjni_callback_info_t *cbi;
+
+ DEBUG ("java plugin: cjni_callback_info_destroy (arg = %p);", arg);
+
+ cbi = (cjni_callback_info_t *) arg;
+
+ /* This condition can occurr when shutting down. */
+ if (jvm == NULL)
+ {
+ sfree (cbi);
+ return;
+ }
+
+ if (arg == NULL)
+ return;
+
+ jvm_env = cjni_thread_attach ();
+ if (jvm_env == NULL)
+ {
+ ERROR ("java plugin: cjni_callback_info_destroy: cjni_thread_attach failed.");
+ return;
+ }
+
+ (*jvm_env)->DeleteGlobalRef (jvm_env, cbi->object);
+
+ cbi->method = NULL;
+ cbi->object = NULL;
+ cbi->class = NULL;
+ free (cbi);
+
+ cjni_thread_detach ();
+} /* }}} void cjni_callback_info_destroy */
+
+/* Call the CB_TYPE_READ callback pointed to by the `user_data_t' pointer. */
+static int cjni_read (user_data_t *ud) /* {{{ */
+{
+ JNIEnv *jvm_env;
+ cjni_callback_info_t *cbi;
+ int status;
+ int ret_status;
+
+ if (jvm == NULL)
+ {
+ ERROR ("java plugin: cjni_read: jvm == NULL");
+ return (-1);
+ }
+
+ if ((ud == NULL) || (ud->data == NULL))
+ {
+ ERROR ("java plugin: cjni_read: Invalid user data.");
+ return (-1);
+ }
+
+ jvm_env = cjni_thread_attach ();
+ if (jvm_env == NULL)
+ return (-1);
+
+ cbi = (cjni_callback_info_t *) ud->data;
+
+ ret_status = (*jvm_env)->CallIntMethod (jvm_env, cbi->object,
+ cbi->method);
+
+ status = cjni_thread_detach ();
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_read: cjni_thread_detach failed.");
+ return (-1);
+ }
+
+ return (ret_status);
+} /* }}} int cjni_read */
+
+/* Call the CB_TYPE_WRITE callback pointed to by the `user_data_t' pointer. */
+static int cjni_write (const data_set_t *ds, const value_list_t *vl, /* {{{ */
+ user_data_t *ud)
+{
+ JNIEnv *jvm_env;
+ cjni_callback_info_t *cbi;
+ jobject vl_java;
+ int status;
+ int ret_status;
+
+ if (jvm == NULL)
+ {
+ ERROR ("java plugin: cjni_write: jvm == NULL");
+ return (-1);
+ }
+
+ if ((ud == NULL) || (ud->data == NULL))
+ {
+ ERROR ("java plugin: cjni_write: Invalid user data.");
+ return (-1);
+ }
+
+ jvm_env = cjni_thread_attach ();
+ if (jvm_env == NULL)
+ return (-1);
+
+ cbi = (cjni_callback_info_t *) ud->data;
+
+ vl_java = ctoj_value_list (jvm_env, ds, vl);
+ if (vl_java == NULL)
+ {
+ ERROR ("java plugin: cjni_write: ctoj_value_list failed.");
+ return (-1);
+ }
+
+ ret_status = (*jvm_env)->CallIntMethod (jvm_env,
+ cbi->object, cbi->method, vl_java);
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, vl_java);
+
+ status = cjni_thread_detach ();
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_write: cjni_thread_detach failed.");
+ return (-1);
+ }
+
+ return (ret_status);
+} /* }}} int cjni_write */
+
+/* Call the CB_TYPE_FLUSH callback pointed to by the `user_data_t' pointer. */
+static int cjni_flush (int timeout, const char *identifier, /* {{{ */
+ user_data_t *ud)
+{
+ JNIEnv *jvm_env;
+ cjni_callback_info_t *cbi;
+ jobject o_identifier;
+ int status;
+ int ret_status;
+
+ if (jvm == NULL)
+ {
+ ERROR ("java plugin: cjni_flush: jvm == NULL");
+ return (-1);
+ }
+
+ if ((ud == NULL) || (ud->data == NULL))
+ {
+ ERROR ("java plugin: cjni_flush: Invalid user data.");
+ return (-1);
+ }
+
+ jvm_env = cjni_thread_attach ();
+ if (jvm_env == NULL)
+ return (-1);
+
+ cbi = (cjni_callback_info_t *) ud->data;
+
+ o_identifier = NULL;
+ if (identifier != NULL)
+ {
+ o_identifier = (*jvm_env)->NewStringUTF (jvm_env, identifier);
+ if (o_identifier == NULL)
+ {
+ ERROR ("java plugin: cjni_flush: NewStringUTF failed.");
+ return (-1);
+ }
+ }
+
+ ret_status = (*jvm_env)->CallIntMethod (jvm_env,
+ cbi->object, cbi->method, (jint) timeout, o_identifier);
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_identifier);
+
+ status = cjni_thread_detach ();
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_flush: cjni_thread_detach failed.");
+ return (-1);
+ }
+
+ return (ret_status);
+} /* }}} int cjni_flush */
+
+/* Call the CB_TYPE_LOG callback pointed to by the `user_data_t' pointer. */
+static void cjni_log (int severity, const char *message, /* {{{ */
+ user_data_t *ud)
+{
+ JNIEnv *jvm_env;
+ cjni_callback_info_t *cbi;
+ jobject o_message;
+
+ if (jvm == NULL)
+ return;
+
+ if ((ud == NULL) || (ud->data == NULL))
+ return;
+
+ jvm_env = cjni_thread_attach ();
+ if (jvm_env == NULL)
+ return;
+
+ cbi = (cjni_callback_info_t *) ud->data;
+
+ o_message = (*jvm_env)->NewStringUTF (jvm_env, message);
+ if (o_message == NULL)
+ return;
+
+ (*jvm_env)->CallVoidMethod (jvm_env,
+ cbi->object, cbi->method, (jint) severity, o_message);
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_message);
+
+ cjni_thread_detach ();
+} /* }}} void cjni_log */
+
+/* Call the CB_TYPE_NOTIFICATION callback pointed to by the `user_data_t'
+ * pointer. */
+static int cjni_notification (const notification_t *n, /* {{{ */
+ user_data_t *ud)
+{
+ JNIEnv *jvm_env;
+ cjni_callback_info_t *cbi;
+ jobject o_notification;
+ int status;
+ int ret_status;
+
+ if (jvm == NULL)
+ {
+ ERROR ("java plugin: cjni_read: jvm == NULL");
+ return (-1);
+ }
+
+ if ((ud == NULL) || (ud->data == NULL))
+ {
+ ERROR ("java plugin: cjni_read: Invalid user data.");
+ return (-1);
+ }
+
+ jvm_env = cjni_thread_attach ();
+ if (jvm_env == NULL)
+ return (-1);
+
+ cbi = (cjni_callback_info_t *) ud->data;
+
+ o_notification = ctoj_notification (jvm_env, n);
+ if (o_notification == NULL)
+ {
+ ERROR ("java plugin: cjni_notification: ctoj_notification failed.");
+ return (-1);
+ }
+
+ ret_status = (*jvm_env)->CallIntMethod (jvm_env,
+ cbi->object, cbi->method, o_notification);
+
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_notification);
+
+ status = cjni_thread_detach ();
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_read: cjni_thread_detach failed.");
+ return (-1);
+ }
+
+ return (ret_status);
+} /* }}} int cjni_notification */
+
+/* Callbacks for matches implemented in Java */
+static int cjni_match_target_create (const oconfig_item_t *ci, /* {{{ */
+ void **user_data)
+{
+ JNIEnv *jvm_env;
+ cjni_callback_info_t *cbi_ret;
+ cjni_callback_info_t *cbi_factory;
+ const char *name;
+ jobject o_ci;
+ jobject o_tmp;
+ int type;
+ size_t i;
+
+ cbi_ret = NULL;
+ o_ci = NULL;
+ jvm_env = NULL;
+
+#define BAIL_OUT(status) \
+ if (cbi_ret != NULL) { \
+ free (cbi_ret->name); \
+ if ((jvm_env != NULL) && (cbi_ret->object != NULL)) \
+ (*jvm_env)->DeleteLocalRef (jvm_env, cbi_ret->object); \
+ } \
+ free (cbi_ret); \
+ if (jvm_env != NULL) { \
+ if (o_ci != NULL) \
+ (*jvm_env)->DeleteLocalRef (jvm_env, o_ci); \
+ cjni_thread_detach (); \
+ } \
+ return (status)
+
+ if (jvm == NULL)
+ {
+ ERROR ("java plugin: cjni_read: jvm == NULL");
+ BAIL_OUT (-1);
+ }
+
+ jvm_env = cjni_thread_attach ();
+ if (jvm_env == NULL)
+ {
+ BAIL_OUT (-1);
+ }
+
+ /* Find out whether to create a match or a target. */
+ if (strcasecmp ("Match", ci->key) == 0)
+ type = CB_TYPE_MATCH;
+ else if (strcasecmp ("Target", ci->key) == 0)
+ type = CB_TYPE_TARGET;
+ else
+ {
+ ERROR ("java plugin: cjni_match_target_create: Can't figure out whether "
+ "to create a match or a target.");
+ BAIL_OUT (-1);
+ }
+
+ /* This is the name of the match we should create. */
+ name = ci->values[0].value.string;
+
+ /* Lets see if we have a matching factory here.. */
+ cbi_factory = NULL;
+ for (i = 0; i < java_callbacks_num; i++)
+ {
+ if (java_callbacks[i].type != type)
+ continue;
+
+ if (strcmp (name, java_callbacks[i].name) != 0)
+ continue;
+
+ cbi_factory = java_callbacks + i;
+ break;
+ }
+
+ /* Nope, no factory for that name.. */
+ if (cbi_factory == NULL)
+ {
+ ERROR ("java plugin: cjni_match_target_create: "
+ "No such match factory registered: %s",
+ name);
+ BAIL_OUT (-1);
+ }
+
+ /* We convert `ci' to its Java equivalent.. */
+ o_ci = ctoj_oconfig_item (jvm_env, ci);
+ if (o_ci == NULL)
+ {
+ ERROR ("java plugin: cjni_match_target_create: "
+ "ctoj_oconfig_item failed.");
+ BAIL_OUT (-1);
+ }
+
+ /* Allocate a new callback info structure. This is going to be our user_data
+ * pointer. */
+ cbi_ret = (cjni_callback_info_t *) malloc (sizeof (*cbi_ret));
+ if (cbi_ret == NULL)
+ {
+ ERROR ("java plugin: cjni_match_target_create: malloc failed.");
+ BAIL_OUT (-1);
+ }
+ memset (cbi_ret, 0, sizeof (*cbi_ret));
+ cbi_ret->object = NULL;
+ cbi_ret->type = type;
+
+ /* Lets fill the callback info structure.. First, the name: */
+ cbi_ret->name = strdup (name);
+ if (cbi_ret->name == NULL)
+ {
+ ERROR ("java plugin: cjni_match_target_create: strdup failed.");
+ BAIL_OUT (-1);
+ }
+
+ /* Then call the factory method so it creates a new object for us. */
+ o_tmp = (*jvm_env)->CallObjectMethod (jvm_env,
+ cbi_factory->object, cbi_factory->method, o_ci);
+ if (o_tmp == NULL)
+ {
+ ERROR ("java plugin: cjni_match_target_create: CallObjectMethod failed.");
+ BAIL_OUT (-1);
+ }
+
+ cbi_ret->object = (*jvm_env)->NewGlobalRef (jvm_env, o_tmp);
+ if (o_tmp == NULL)
+ {
+ ERROR ("java plugin: cjni_match_target_create: NewGlobalRef failed.");
+ BAIL_OUT (-1);
+ }
+
+ /* This is the class of the match. It is possibly different from the class of
+ * the match-factory! */
+ cbi_ret->class = (*jvm_env)->GetObjectClass (jvm_env, cbi_ret->object);
+ if (cbi_ret->class == NULL)
+ {
+ ERROR ("java plugin: cjni_match_target_create: GetObjectClass failed.");
+ BAIL_OUT (-1);
+ }
+
+ /* Lookup the `int match (DataSet, ValueList)' method. */
+ cbi_ret->method = (*jvm_env)->GetMethodID (jvm_env, cbi_ret->class,
+ /* method name = */ (type == CB_TYPE_MATCH) ? "match" : "invoke",
+ "(Lorg/collectd/api/DataSet;Lorg/collectd/api/ValueList;)I");
+ if (cbi_ret->method == NULL)
+ {
+ ERROR ("java plugin: cjni_match_target_create: GetMethodID failed.");
+ BAIL_OUT (-1);
+ }
+
+ /* Return the newly created match via the user_data pointer. */
+ *user_data = (void *) cbi_ret;
+
+ cjni_thread_detach ();
+
+ DEBUG ("java plugin: cjni_match_target_create: "
+ "Successfully created a `%s' %s.",
+ cbi_ret->name, (type == CB_TYPE_MATCH) ? "match" : "target");
+
+ /* Success! */
+ return (0);
+#undef BAIL_OUT
+} /* }}} int cjni_match_target_create */
+
+static int cjni_match_target_destroy (void **user_data) /* {{{ */
+{
+ cjni_callback_info_destroy (*user_data);
+ *user_data = NULL;
+
+ return (0);
+} /* }}} int cjni_match_target_destroy */
+
+static int cjni_match_target_invoke (const data_set_t *ds, /* {{{ */
+ value_list_t *vl, notification_meta_t **meta, void **user_data)
+{
+ JNIEnv *jvm_env;
+ cjni_callback_info_t *cbi;
+ jobject o_vl;
+ jobject o_ds;
+ int ret_status;
+ int status;
+
+ if (jvm == NULL)
+ {
+ ERROR ("java plugin: cjni_match_target_invoke: jvm == NULL");
+ return (-1);
+ }
+
+ jvm_env = cjni_thread_attach ();
+ if (jvm_env == NULL)
+ return (-1);
+
+ cbi = (cjni_callback_info_t *) *user_data;
+
+ o_vl = ctoj_value_list (jvm_env, ds, vl);
+ if (o_vl == NULL)
+ {
+ ERROR ("java plugin: cjni_match_target_invoke: ctoj_value_list failed.");
+ cjni_thread_detach ();
+ return (-1);
+ }
+
+ o_ds = ctoj_data_set (jvm_env, ds);
+ if (o_ds == NULL)
+ {
+ ERROR ("java plugin: cjni_match_target_invoke: ctoj_value_list failed.");
+ cjni_thread_detach ();
+ return (-1);
+ }
+
+ ret_status = (*jvm_env)->CallIntMethod (jvm_env, cbi->object, cbi->method,
+ o_ds, o_vl);
+
+ DEBUG ("java plugin: cjni_match_target_invoke: Method returned %i.", ret_status);
+
+ /* If we're executing a target, copy the `ValueList' back to our
+ * `value_list_t'. */
+ if (cbi->type == CB_TYPE_TARGET)
+ {
+ value_list_t new_vl;
+
+ memset (&new_vl, 0, sizeof (new_vl));
+ status = jtoc_value_list (jvm_env, &new_vl, o_vl);
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_match_target_invoke: "
+ "jtoc_value_list failed.");
+ }
+ else /* if (status == 0) */
+ {
+ /* plugin_dispatch_values assures that this is dynamically allocated
+ * memory. */
+ sfree (vl->values);
+
+ /* This will replace the vl->values pointer to a new, dynamically
+ * allocated piece of memory. */
+ memcpy (vl, &new_vl, sizeof (*vl));
+ }
+ } /* if (cbi->type == CB_TYPE_TARGET) */
+
+ status = cjni_thread_detach ();
+ if (status != 0)
+ ERROR ("java plugin: cjni_read: cjni_thread_detach failed.");
+
+ return (ret_status);
+} /* }}} int cjni_match_target_invoke */
+
+/* Iterate over `java_callbacks' and call all CB_TYPE_INIT callbacks. */
+static int cjni_init_plugins (JNIEnv *jvm_env) /* {{{ */
+{
+ int status;
+ size_t i;
+
+ for (i = 0; i < java_callbacks_num; i++)
+ {
+ if (java_callbacks[i].type != CB_TYPE_INIT)
+ continue;
+
+ DEBUG ("java plugin: Initializing %s", java_callbacks[i].name);
+
+ status = (*jvm_env)->CallIntMethod (jvm_env,
+ java_callbacks[i].object, java_callbacks[i].method);
+ if (status != 0)
+ {
+ ERROR ("java plugin: Initializing `%s' failed with status %i. "
+ "Removing read function.",
+ java_callbacks[i].name, status);
+ plugin_unregister_read (java_callbacks[i].name);
+ }
+ }
+
+ return (0);
+} /* }}} int cjni_init_plugins */
+
+/* Iterate over `java_callbacks' and call all CB_TYPE_SHUTDOWN callbacks. */
+static int cjni_shutdown_plugins (JNIEnv *jvm_env) /* {{{ */
+{
+ int status;
+ size_t i;
+
+ for (i = 0; i < java_callbacks_num; i++)
+ {
+ if (java_callbacks[i].type != CB_TYPE_SHUTDOWN)
+ continue;
+
+ DEBUG ("java plugin: Shutting down %s", java_callbacks[i].name);
+
+ status = (*jvm_env)->CallIntMethod (jvm_env,
+ java_callbacks[i].object, java_callbacks[i].method);
+ if (status != 0)
+ {
+ ERROR ("java plugin: Shutting down `%s' failed with status %i. ",
+ java_callbacks[i].name, status);
+ }
+ }
+
+ return (0);
+} /* }}} int cjni_shutdown_plugins */
+
+
+static int cjni_shutdown (void) /* {{{ */
+{
+ JNIEnv *jvm_env;
+ JavaVMAttachArgs args;
+ int status;
+ size_t i;
+
+ if (jvm == NULL)
+ return (0);
+
+ jvm_env = NULL;
+ memset (&args, 0, sizeof (args));
+ args.version = JNI_VERSION_1_2;
+
+ status = (*jvm)->AttachCurrentThread (jvm, (void *) &jvm_env, &args);
+ if (status != 0)
+ {
+ ERROR ("java plugin: cjni_shutdown: AttachCurrentThread failed with status %i.",
+ status);
+ return (-1);
+ }
+
+ /* Execute all the shutdown functions registered by plugins. */
+ cjni_shutdown_plugins (jvm_env);
+
+ /* Release all the global references to callback functions */
+ for (i = 0; i < java_callbacks_num; i++)
+ {
+ if (java_callbacks[i].object != NULL)
+ {
+ (*jvm_env)->DeleteGlobalRef (jvm_env, java_callbacks[i].object);
+ java_callbacks[i].object = NULL;
+ }
+ sfree (java_callbacks[i].name);
+ }
+ java_callbacks_num = 0;
+ sfree (java_callbacks);
+
+ /* Release all the global references to directly loaded classes. */
+ for (i = 0; i < java_classes_list_len; i++)
+ {
+ if (java_classes_list[i].object != NULL)
+ {
+ (*jvm_env)->DeleteGlobalRef (jvm_env, java_classes_list[i].object);
+ java_classes_list[i].object = NULL;
+ }
+ sfree (java_classes_list[i].name);
+ }
+ java_classes_list_len = 0;
+ sfree (java_classes_list);
+
+ /* Destroy the JVM */
+ DEBUG ("java plugin: Destroying the JVM.");
+ (*jvm)->DestroyJavaVM (jvm);
+ jvm = NULL;
+ jvm_env = NULL;
+
+ pthread_key_delete (jvm_env_key);
+
+ /* Free the JVM argument list */
+ for (i = 0; i < jvm_argc; i++)
+ sfree (jvm_argv[i]);
+ jvm_argc = 0;
+ sfree (jvm_argv);
+
+ return (0);
+} /* }}} int cjni_shutdown */
+
+/* Initialization: Create a JVM, load all configured classes and call their
+ * `config' and `init' callback methods. */
+static int cjni_init (void) /* {{{ */
+{
+ JNIEnv *jvm_env;
+
+ if (jvm == NULL)
+ {
+ ERROR ("java plugin: cjni_init: jvm == NULL");
+ return (-1);
+ }
+
+ jvm_env = cjni_thread_attach ();
+ if (jvm_env == NULL)
+ return (-1);
+
+ cjni_init_plugins (jvm_env);
+
+ cjni_thread_detach ();
+ return (0);
+} /* }}} int cjni_init */
+
+void module_register (void)
+{
+ plugin_register_complex_config ("java", cjni_config);
+ plugin_register_init ("java", cjni_init);
+ plugin_register_shutdown ("java", cjni_shutdown);
+} /* void module_register (void) */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
return (ret);
} /* oconfig_item_t *oconfig_parse_file */
+oconfig_item_t *oconfig_clone (const oconfig_item_t *ci_orig)
+{
+ oconfig_item_t *ci_copy;
+
+ ci_copy = (oconfig_item_t *) malloc (sizeof (*ci_copy));
+ if (ci_copy == NULL)
+ {
+ fprintf (stderr, "malloc failed.\n");
+ return (NULL);
+ }
+ memset (ci_copy, 0, sizeof (*ci_copy));
+ ci_copy->values = NULL;
+ ci_copy->parent = NULL;
+ ci_copy->children = NULL;
+
+ ci_copy->key = strdup (ci_orig->key);
+ if (ci_copy->key == NULL)
+ {
+ fprintf (stderr, "strdup failed.\n");
+ free (ci_copy);
+ return (NULL);
+ }
+
+ if (ci_orig->values_num > 0) /* {{{ */
+ {
+ int i;
+
+ ci_copy->values = (oconfig_value_t *) calloc (ci_orig->values_num,
+ sizeof (*ci_copy->values));
+ if (ci_copy->values == NULL)
+ {
+ fprintf (stderr, "calloc failed.\n");
+ free (ci_copy->key);
+ free (ci_copy);
+ return (NULL);
+ }
+ ci_copy->values_num = ci_orig->values_num;
+
+ for (i = 0; i < ci_copy->values_num; i++)
+ {
+ ci_copy->values[i].type = ci_orig->values[i].type;
+ if (ci_copy->values[i].type == OCONFIG_TYPE_STRING)
+ {
+ ci_copy->values[i].value.string
+ = strdup (ci_orig->values[i].value.string);
+ if (ci_copy->values[i].value.string == NULL)
+ {
+ fprintf (stderr, "strdup failed.\n");
+ oconfig_free (ci_copy);
+ return (NULL);
+ }
+ }
+ else /* ci_copy->values[i].type != OCONFIG_TYPE_STRING) */
+ {
+ ci_copy->values[i].value = ci_orig->values[i].value;
+ }
+ }
+ } /* }}} if (ci_orig->values_num > 0) */
+
+ if (ci_orig->children_num > 0) /* {{{ */
+ {
+ int i;
+
+ ci_copy->children = (oconfig_item_t *) calloc (ci_orig->children_num,
+ sizeof (*ci_copy->children));
+ if (ci_copy->children == NULL)
+ {
+ fprintf (stderr, "calloc failed.\n");
+ oconfig_free (ci_copy);
+ return (NULL);
+ }
+ ci_copy->children_num = ci_orig->children_num;
+
+ for (i = 0; i < ci_copy->children_num; i++)
+ {
+ oconfig_item_t *child;
+
+ child = oconfig_clone (ci_orig->children + i);
+ if (child == NULL)
+ {
+ oconfig_free (ci_copy);
+ return (NULL);
+ }
+ child->parent = ci_copy;
+ ci_copy->children[i] = *child;
+ free (child);
+ } /* for (i = 0; i < ci_copy->children_num; i++) */
+ } /* }}} if (ci_orig->children_num > 0) */
+
+ return (ci_copy);
+} /* oconfig_item_t *oconfig_clone */
+
void oconfig_free (oconfig_item_t *ci)
{
int i;
}
/*
- * vim:shiftwidth=2:tabstop=8:softtabstop=2
+ * vim:shiftwidth=2:tabstop=8:softtabstop=2:fdm=marker
*/
/**
* oconfig - src/oconfig.h
- * Copyright (C) 2006,2007 Florian octo Forster <octo at verplant.org>
+ * Copyright (C) 2006-2009 Florian octo Forster <octo at verplant.org>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
oconfig_item_t *oconfig_parse_fh (FILE *fh);
oconfig_item_t *oconfig_parse_file (const char *file);
+oconfig_item_t *oconfig_clone (const oconfig_item_t *ci);
+
void oconfig_free (oconfig_item_t *ci);
/*
+++ /dev/null
- GNU GENERAL PUBLIC LICENSE
- Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
- Preamble
-
- The licenses for most software are designed to take away your
-freedom to share and change it. By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users. This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it. (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.) You can apply it to
-your programs, too.
-
- When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
- To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
- For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have. You must make sure that they, too, receive or can get the
-source code. And you must show them these terms so they know their
-rights.
-
- We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
- Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software. If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
- Finally, any free program is threatened constantly by software
-patents. We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary. To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
- The precise terms and conditions for copying, distribution and
-modification follow.
-\f
- GNU GENERAL PUBLIC LICENSE
- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
- 0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License. The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language. (Hereinafter, translation is included without limitation in
-the term "modification".) Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope. The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
- 1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
- 2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
- a) You must cause the modified files to carry prominent notices
- stating that you changed the files and the date of any change.
-
- b) You must cause any work that you distribute or publish, that in
- whole or in part contains or is derived from the Program or any
- part thereof, to be licensed as a whole at no charge to all third
- parties under the terms of this License.
-
- c) If the modified program normally reads commands interactively
- when run, you must cause it, when started running for such
- interactive use in the most ordinary way, to print or display an
- announcement including an appropriate copyright notice and a
- notice that there is no warranty (or else, saying that you provide
- a warranty) and that users may redistribute the program under
- these conditions, and telling the user how to view a copy of this
- License. (Exception: if the Program itself is interactive but
- does not normally print such an announcement, your work based on
- the Program is not required to print an announcement.)
-\f
-These requirements apply to the modified work as a whole. If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works. But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
- 3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
- a) Accompany it with the complete corresponding machine-readable
- source code, which must be distributed under the terms of Sections
- 1 and 2 above on a medium customarily used for software interchange; or,
-
- b) Accompany it with a written offer, valid for at least three
- years, to give any third party, for a charge no more than your
- cost of physically performing source distribution, a complete
- machine-readable copy of the corresponding source code, to be
- distributed under the terms of Sections 1 and 2 above on a medium
- customarily used for software interchange; or,
-
- c) Accompany it with the information you received as to the offer
- to distribute corresponding source code. (This alternative is
- allowed only for noncommercial distribution and only if you
- received the program in object code or executable form with such
- an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it. For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable. However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-\f
- 4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License. Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
- 5. You are not required to accept this License, since you have not
-signed it. However, nothing else grants you permission to modify or
-distribute the Program or its derivative works. These actions are
-prohibited by law if you do not accept this License. Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
- 6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions. You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
- 7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all. For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices. Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-\f
- 8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded. In such case, this License incorporates
-the limitation as if written in the body of this License.
-
- 9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time. Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation. If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
- 10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission. For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this. Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
- NO WARRANTY
-
- 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
- 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
- END OF TERMS AND CONDITIONS
-\f
- How to Apply These Terms to Your New Programs
-
- If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
- To do so, attach the following notices to the program. It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
- <one line to give the program's name and a brief idea of what it does.>
- Copyright (C) <year> <name of author>
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
- Gnomovision version 69, Copyright (C) year name of author
- Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
- This is free software, and you are welcome to redistribute it
- under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License. Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary. Here is a sample; alter the names:
-
- Yoyodyne, Inc., hereby disclaims all copyright interest in the program
- `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
- <signature of Ty Coon>, 1 April 1989
- Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs. If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library. If this is what you want to do, use the GNU Library General
-Public License instead of this License.
+++ /dev/null
-2006-06-05, Version 0.2.2
- * The `oping' application didn't exit if no hosts could be resolved.
- This release fixes it's behavior.
-
-2006-06-01, Version 0.2.1
- * Fix the behavior for non GNU-Linux systems. liboping tried to
- `bind(2)' to the raw-socket it uses to send ICMP packets. Apparently
- (decided by majority vote ;) this is not the right thing to do.
- GNU/Linux never complained about it, but works find without the bind.
- Other operating systems don't work at all with the bind.
- * Build fixes for non-GNU/Linux platforms: Mac OS X doesn't define
- `size_t' as `unsigned int' and therefore needs casting and FreeBSD
- needs to have `sys/types.h' included before `netinet/*.h'
-
-2006-05-29, Version 0.2.0
- * It's now possible to set the data to be send to the remote host and
- to get the data received from the host.
- * The `oping' binary now calculates the standard deviation. Also, it
- displays the number of byes that were received and other output
- changes.
- * Hosts are now returned in the same order as they were added by
- `ping_host_add'. This is not guaranteed, but makes `oping' prettier.
-
-2006-05-12, Version 0.1.1
- * A bug in the library has been fixed: When the sequence got higher
- than 2^16 the counter in the packets wrapped around, but the
- internal counter didn't, causing the library to ignore all further
- ICMP packets. This affected both, ICMPv4 and ICMPv6.
-
-2006-05-08, Version 0.1.0
- * Initial release.
+++ /dev/null
-AUTOMAKE_OPTIONS = foreign no-dependencies
-
-if COMPILER_IS_GCC
-AM_CFLAGS = -Wall -Werror
-endif
-
-EXTRA_DIST = AUTHORS COPYING ChangeLog README
-
-noinst_LTLIBRARIES = liboping.la
-
-#liboping_la_CFLAGS =
-liboping_la_LDFLAGS = -version-info 0:3:0
-if BUILD_WITH_LIBSOCKET
-liboping_la_LDFLAGS += -lsocket
-endif
-liboping_la_SOURCES = liboping.c oping.h
+++ /dev/null
- liboping - Library to ping IPv4 and IPv6 hosts in parallel
-============================================================
-http://verplant.org/liboping/
-
-About
------
-
- liboping was inspired by ping, libping and fping: It differs from these
- existing solutions in that it can `ping' multiple hosts in parallel using
- IPv4 or IPv6 transparently. Other design principles were an object oriented
- interface, simplicity and extensibility.
-
-
-Features
---------
-
- * Support for multiple hosts.
-
- * Support for IPv4 and IPv6.
-
- * Object oriented interface.
-
-
-Author
-------
-
- Florian octo Forster <octo at verplant.org>
-
+++ /dev/null
-/**
- * Object oriented C module to send ICMP and ICMPv6 `echo's.
- * Copyright (C) 2006 Florian octo Forster <octo at verplant.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#if HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#if STDC_HEADERS
-# include <stdlib.h>
-# include <stdio.h>
-# include <string.h>
-# include <errno.h>
-# include <assert.h>
-#else
-# error "You don't have the standard C99 header files installed"
-#endif /* STDC_HEADERS */
-
-#if HAVE_UNISTD_H
-# include <unistd.h>
-#endif
-
-#if HAVE_FCNTL_H
-# include <fcntl.h>
-#endif
-#if HAVE_SYS_TYPES_H
-# include <sys/types.h>
-#endif
-#if HAVE_SYS_STAT_H
-# include <sys/stat.h>
-#endif
-
-#if TIME_WITH_SYS_TIME
-# include <sys/time.h>
-# include <time.h>
-#else
-# if HAVE_SYS_TIME_H
-# include <sys/time.h>
-# else
-# include <time.h>
-# endif
-#endif
-
-#if HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-#if HAVE_NETDB_H
-# include <netdb.h>
-#endif
-
-#if HAVE_NETINET_IN_SYSTM_H
-# include <netinet/in_systm.h>
-#endif
-#if HAVE_NETINET_IN_H
-# include <netinet/in.h>
-#endif
-#if HAVE_NETINET_IP_H
-# include <netinet/ip.h>
-#endif
-#if HAVE_NETINET_IP_ICMP_H
-# include <netinet/ip_icmp.h>
-#endif
-#ifdef HAVE_NETINET_IP_VAR_H
-# include <netinet/ip_var.h>
-#endif
-#if HAVE_NETINET_IP6_H
-# include <netinet/ip6.h>
-#endif
-#if HAVE_NETINET_ICMP6_H
-# include <netinet/icmp6.h>
-#endif
-
-#include "oping.h"
-
-#if WITH_DEBUG
-# define dprintf(...) printf ("%s[%4i]: %-20s: ", __FILE__, __LINE__, __FUNCTION__); printf (__VA_ARGS__)
-#else
-# define dprintf(...) /**/
-#endif
-
-#define PING_ERRMSG_LEN 256
-
-struct pinghost
-{
- char *hostname;
- struct sockaddr_storage *addr;
- socklen_t addrlen;
- int addrfamily;
- int fd;
- int ident;
- int sequence;
- struct timeval *timer;
- double latency;
- char *data;
-
- void *context;
-
- struct pinghost *next;
-};
-
-struct pingobj
-{
- double timeout;
- int ttl;
- int addrfamily;
- char *data;
-
- char errmsg[PING_ERRMSG_LEN];
-
- pinghost_t *head;
-};
-
-/*
- * private (static) functions
- */
-static void ping_set_error (pingobj_t *obj, const char *function,
- const char *message)
-{
- snprintf (obj->errmsg, PING_ERRMSG_LEN, "%s: %s", function, message);
- obj->errmsg[PING_ERRMSG_LEN - 1] = '\0';
-}
-
-static int ping_timeval_add (struct timeval *tv1, struct timeval *tv2,
- struct timeval *res)
-{
- res->tv_sec = tv1->tv_sec + tv2->tv_sec;
- res->tv_usec = tv1->tv_usec + tv2->tv_usec;
-
- while (res->tv_usec > 1000000)
- {
- res->tv_usec -= 1000000;
- res->tv_sec++;
- }
-
- return (0);
-}
-
-static int ping_timeval_sub (struct timeval *tv1, struct timeval *tv2,
- struct timeval *res)
-{
-
- if ((tv1->tv_sec < tv2->tv_sec)
- || ((tv1->tv_sec == tv2->tv_sec)
- && (tv1->tv_usec < tv2->tv_usec)))
- return (-1);
-
- res->tv_sec = tv1->tv_sec - tv2->tv_sec;
- res->tv_usec = tv1->tv_usec - tv2->tv_usec;
-
- assert ((res->tv_sec > 0) || ((res->tv_sec == 0) && (res->tv_usec > 0)));
-
- while (res->tv_usec < 0)
- {
- res->tv_usec += 1000000;
- res->tv_sec--;
- }
-
- return (0);
-}
-
-static uint16_t ping_icmp4_checksum (char *buf, size_t len)
-{
- uint32_t sum = 0;
- uint16_t ret = 0;
-
- uint16_t *ptr;
-
- for (ptr = (uint16_t *) buf; len > 1; ptr++, len -= 2)
- sum += *ptr;
-
- if (len == 1)
- {
- *(char *) &ret = *(char *) ptr;
- sum += ret;
- }
-
- /* Do this twice to get all possible carries.. */
- sum = (sum >> 16) + (sum & 0xFFFF);
- sum = (sum >> 16) + (sum & 0xFFFF);
-
- ret = ~sum;
-
- return (ret);
-}
-
-static pinghost_t *ping_receive_ipv4 (pinghost_t *ph, char *buffer, size_t buffer_len)
-{
- struct ip *ip_hdr;
- struct icmp *icmp_hdr;
-
- size_t ip_hdr_len;
-
- uint16_t recv_checksum;
- uint16_t calc_checksum;
-
- uint16_t ident;
- uint16_t seq;
-
- pinghost_t *ptr;
-
- if (buffer_len < sizeof (struct ip))
- return (NULL);
-
- ip_hdr = (struct ip *) buffer;
- ip_hdr_len = ip_hdr->ip_hl << 2;
-
- if (buffer_len < ip_hdr_len)
- return (NULL);
-
- buffer += ip_hdr_len;
- buffer_len -= ip_hdr_len;
-
- if (buffer_len < sizeof (struct icmp))
- return (NULL);
-
- icmp_hdr = (struct icmp *) buffer;
- buffer += sizeof (struct icmp);
- buffer_len -= sizeof (struct icmp);
-
- if (icmp_hdr->icmp_type != ICMP_ECHOREPLY)
- {
- dprintf ("Unexpected ICMP type: %i\n", icmp_hdr->icmp_type);
- return (NULL);
- }
-
- recv_checksum = icmp_hdr->icmp_cksum;
- icmp_hdr->icmp_cksum = 0;
- calc_checksum = ping_icmp4_checksum ((char *) icmp_hdr,
- sizeof (struct icmp) + buffer_len);
-
- if (recv_checksum != calc_checksum)
- {
- dprintf ("Checksum missmatch: Got 0x%04x, calculated 0x%04x\n",
- recv_checksum, calc_checksum);
- return (NULL);
- }
-
- ident = ntohs (icmp_hdr->icmp_id);
- seq = ntohs (icmp_hdr->icmp_seq);
-
- for (ptr = ph; ptr != NULL; ptr = ptr->next)
- {
- dprintf ("hostname = %s, ident = 0x%04x, seq = %i\n",
- ptr->hostname, ptr->ident, ((ptr->sequence - 1) & 0xFFFF));
-
- if (ptr->addrfamily != AF_INET)
- continue;
-
- if (!timerisset (ptr->timer))
- continue;
-
- if (ptr->ident != ident)
- continue;
-
- if (((ptr->sequence - 1) & 0xFFFF) != seq)
- continue;
-
- dprintf ("Match found: hostname = %s, ident = 0x%04x, seq = %i\n",
- ptr->hostname, ident, seq);
-
- break;
- }
-
- if (ptr == NULL)
- {
- dprintf ("No match found for ident = 0x%04x, seq = %i\n",
- ident, seq);
- }
-
- return (ptr);
-}
-
-static pinghost_t *ping_receive_ipv6 (pinghost_t *ph, char *buffer, size_t buffer_len)
-{
- struct icmp6_hdr *icmp_hdr;
-
- uint16_t ident;
- uint16_t seq;
-
- pinghost_t *ptr;
-
- if (buffer_len < sizeof (struct icmp6_hdr))
- return (NULL);
-
- icmp_hdr = (struct icmp6_hdr *) buffer;
- buffer += sizeof (struct icmp);
- buffer_len -= sizeof (struct icmp);
-
- if (icmp_hdr->icmp6_type != ICMP6_ECHO_REPLY)
- {
- dprintf ("Unexpected ICMP type: %02x\n", icmp_hdr->icmp6_type);
- return (NULL);
- }
-
- if (icmp_hdr->icmp6_code != 0)
- {
- dprintf ("Unexpected ICMP code: %02x\n", icmp_hdr->icmp6_code);
- return (NULL);
- }
-
- ident = ntohs (icmp_hdr->icmp6_id);
- seq = ntohs (icmp_hdr->icmp6_seq);
-
- for (ptr = ph; ptr != NULL; ptr = ptr->next)
- {
- dprintf ("hostname = %s, ident = 0x%04x, seq = %i\n",
- ptr->hostname, ptr->ident, ((ptr->sequence - 1) & 0xFFFF));
-
- if (ptr->addrfamily != AF_INET6)
- continue;
-
- if (!timerisset (ptr->timer))
- continue;
-
- if (ptr->ident != ident)
- continue;
-
- if (((ptr->sequence - 1) & 0xFFFF) != seq)
- continue;
-
- dprintf ("Match found: hostname = %s, ident = 0x%04x, seq = %i\n",
- ptr->hostname, ident, seq);
-
- break;
- }
-
- if (ptr == NULL)
- {
- dprintf ("No match found for ident = 0x%04x, seq = %i\n",
- ident, seq);
- }
-
- return (ptr);
-}
-
-static int ping_receive_one (int fd, pinghost_t *ph, struct timeval *now)
-{
- char buffer[4096];
- size_t buffer_len;
-
- struct timeval diff;
-
- pinghost_t *host = NULL;
-
- struct sockaddr_storage sa;
- socklen_t sa_len;
-
- sa_len = sizeof (sa);
-
- buffer_len = recvfrom (fd, buffer, sizeof (buffer), 0,
- (struct sockaddr *) &sa, &sa_len);
- if (buffer_len == -1)
- {
- dprintf ("recvfrom: %s\n", strerror (errno));
- return (-1);
- }
-
- dprintf ("Read %u bytes from fd = %i\n", (unsigned int) buffer_len, fd);
-
- if (sa.ss_family == AF_INET)
- {
- if ((host = ping_receive_ipv4 (ph, buffer, buffer_len)) == NULL)
- return (-1);
- }
- else if (sa.ss_family == AF_INET6)
- {
- if ((host = ping_receive_ipv6 (ph, buffer, buffer_len)) == NULL)
- return (-1);
- }
-
- dprintf ("rcvd: %12i.%06i\n",
- (int) now->tv_sec,
- (int) now->tv_usec);
- dprintf ("sent: %12i.%06i\n",
- (int) host->timer->tv_sec,
- (int) host->timer->tv_usec);
-
- if (ping_timeval_sub (now, host->timer, &diff) < 0)
- {
- timerclear (host->timer);
- return (-1);
- }
-
- dprintf ("diff: %12i.%06i\n",
- (int) diff.tv_sec,
- (int) diff.tv_usec);
-
- host->latency = ((double) diff.tv_usec) / 1000.0;
- host->latency += ((double) diff.tv_sec) * 1000.0;
-
- timerclear (host->timer);
-
- return (0);
-}
-
-static int ping_receive_all (pingobj_t *obj)
-{
- fd_set readfds;
- int num_readfds;
- int max_readfds;
-
- pinghost_t *ph;
- pinghost_t *ptr;
-
- struct timeval endtime;
- struct timeval nowtime;
- struct timeval timeout;
- int status;
-
- int ret;
-
- ph = obj->head;
- ret = 0;
-
- for (ptr = ph; ptr != NULL; ptr = ptr->next)
- ptr->latency = -1.0;
-
- if (gettimeofday (&nowtime, NULL) == -1)
- {
- ping_set_error (obj, "gettimeofday", strerror (errno));
- return (-1);
- }
-
- /* Set up timeout */
- timeout.tv_sec = (time_t) obj->timeout;
- timeout.tv_usec = (suseconds_t) (1000000 * (obj->timeout - ((double) timeout.tv_sec)));
-
- dprintf ("Set timeout to %i.%06i seconds\n",
- (int) timeout.tv_sec,
- (int) timeout.tv_usec);
-
- ping_timeval_add (&nowtime, &timeout, &endtime);
-
- while (1)
- {
- FD_ZERO (&readfds);
- num_readfds = 0;
- max_readfds = -1;
-
- for (ptr = ph; ptr != NULL; ptr = ptr->next)
- {
- if (!timerisset (ptr->timer))
- continue;
-
- FD_SET (ptr->fd, &readfds);
- num_readfds++;
-
- if (max_readfds < ptr->fd)
- max_readfds = ptr->fd;
- }
-
- if (num_readfds == 0)
- break;
-
- if (gettimeofday (&nowtime, NULL) == -1)
- {
- ping_set_error (obj, "gettimeofday", strerror (errno));
- return (-1);
- }
-
- if (ping_timeval_sub (&endtime, &nowtime, &timeout) == -1)
- break;
-
- dprintf ("Waiting on %i sockets for %i.%06i seconds\n", num_readfds,
- (int) timeout.tv_sec,
- (int) timeout.tv_usec);
-
- status = select (max_readfds + 1, &readfds, NULL, NULL, &timeout);
-
- if (gettimeofday (&nowtime, NULL) == -1)
- {
- ping_set_error (obj, "gettimeofday", strerror (errno));
- return (-1);
- }
-
- if ((status == -1) && (errno == EINTR))
- {
- dprintf ("select was interrupted by signal..\n");
- continue;
- }
- else if (status < 0)
- {
- dprintf ("select: %s\n", strerror (errno));
- break;
- }
- else if (status == 0)
- {
- dprintf ("select timed out\n");
- break;
- }
-
- for (ptr = ph; ptr != NULL; ptr = ptr->next)
- {
- if (FD_ISSET (ptr->fd, &readfds))
- if (ping_receive_one (ptr->fd, ph, &nowtime) == 0)
- ret++;
- }
- } /* while (1) */
-
- return (ret);
-}
-
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Sending functions: *
- * *
- * ping_send_all *
- * +-> ping_send_one_ipv4 *
- * `-> ping_send_one_ipv6 *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-static ssize_t ping_sendto (pingobj_t *obj, pinghost_t *ph,
- const void *buf, size_t buflen)
-{
- ssize_t ret;
-
- if (gettimeofday (ph->timer, NULL) == -1)
- {
- timerclear (ph->timer);
- return (-1);
- }
-
- ret = sendto (ph->fd, buf, buflen, 0,
- (struct sockaddr *) ph->addr, ph->addrlen);
-
- if (ret < 0)
- {
-#if defined(EHOSTUNREACH)
- if (errno == EHOSTUNREACH)
- return (0);
-#endif
-#if defined(ENETUNREACH)
- if (errno == ENETUNREACH)
- return (0);
-#endif
- ping_set_error (obj, "sendto", strerror (errno));
- }
-
- return (ret);
-}
-
-static int ping_send_one_ipv4 (pingobj_t *obj, pinghost_t *ph)
-{
- struct icmp *icmp4;
- int status;
-
- char buf[4096];
- int buflen;
-
- char *data;
- int datalen;
-
- dprintf ("ph->hostname = %s\n", ph->hostname);
-
- memset (buf, '\0', sizeof (buf));
- icmp4 = (struct icmp *) buf;
- data = (char *) (icmp4 + 1);
-
- icmp4->icmp_type = ICMP_ECHO;
- icmp4->icmp_code = 0;
- icmp4->icmp_cksum = 0;
- icmp4->icmp_id = htons (ph->ident);
- icmp4->icmp_seq = htons (ph->sequence);
-
- buflen = 4096 - sizeof (struct icmp);
- strncpy (data, ph->data, buflen);
- datalen = strlen (data);
-
- buflen = datalen + sizeof (struct icmp);
-
- icmp4->icmp_cksum = ping_icmp4_checksum (buf, buflen);
-
- dprintf ("Sending ICMPv4 package with ID 0x%04x\n", ph->ident);
-
- status = ping_sendto (obj, ph, buf, buflen);
- if (status < 0)
- {
- perror ("ping_sendto");
- return (-1);
- }
-
- dprintf ("sendto: status = %i\n", status);
-
- return (0);
-}
-
-static int ping_send_one_ipv6 (pingobj_t *obj, pinghost_t *ph)
-{
- struct icmp6_hdr *icmp6;
- int status;
-
- char buf[4096];
- int buflen;
-
- char *data;
- int datalen;
-
- dprintf ("ph->hostname = %s\n", ph->hostname);
-
- memset (buf, '\0', sizeof (buf));
- icmp6 = (struct icmp6_hdr *) buf;
- data = (char *) (icmp6 + 1);
-
- icmp6->icmp6_type = ICMP6_ECHO_REQUEST;
- icmp6->icmp6_code = 0;
- /* The checksum will be calculated by the TCP/IP stack. */
- /* FIXME */
- icmp6->icmp6_cksum = 0;
- icmp6->icmp6_id = htons (ph->ident);
- icmp6->icmp6_seq = htons (ph->sequence);
-
- buflen = 4096 - sizeof (struct icmp6_hdr);
- strncpy (data, ph->data, buflen);
- datalen = strlen (data);
-
- buflen = datalen + sizeof (struct icmp6_hdr);
-
- dprintf ("Sending ICMPv6 package with ID 0x%04x\n", ph->ident);
-
- status = ping_sendto (obj, ph, buf, buflen);
- if (status < 0)
- {
- perror ("ping_sendto");
- return (-1);
- }
-
- dprintf ("sendto: status = %i\n", status);
-
- return (0);
-}
-
-static int ping_send_all (pingobj_t *obj)
-{
- pinghost_t *ph;
- pinghost_t *ptr;
-
- int ret;
-
- ret = 0;
- ph = obj->head;
-
- for (ptr = ph; ptr != NULL; ptr = ptr->next)
- {
- /* start timer.. The GNU `ping6' starts the timer before
- * sending the packet, so I will do that too */
- if (gettimeofday (ptr->timer, NULL) == -1)
- {
- dprintf ("gettimeofday: %s\n", strerror (errno));
- timerclear (ptr->timer);
- ret--;
- continue;
- }
- else
- {
- dprintf ("timer set for hostname = %s\n", ptr->hostname);
- }
-
- if (ptr->addrfamily == AF_INET6)
- {
- dprintf ("Sending ICMPv6 echo request to `%s'\n", ptr->hostname);
- if (ping_send_one_ipv6 (obj, ptr) != 0)
- {
- timerclear (ptr->timer);
- ret--;
- continue;
- }
- }
- else if (ptr->addrfamily == AF_INET)
- {
- dprintf ("Sending ICMPv4 echo request to `%s'\n", ptr->hostname);
- if (ping_send_one_ipv4 (obj, ptr) != 0)
- {
- timerclear (ptr->timer);
- ret--;
- continue;
- }
- }
- else /* this should not happen */
- {
- dprintf ("Unknown address family: %i\n", ptr->addrfamily);
- timerclear (ptr->timer);
- ret--;
- continue;
- }
-
- ptr->sequence++;
- }
-
- return (ret);
-}
-
-/*
- * Set the TTL of a socket protocol independently.
- */
-static int ping_set_ttl (pinghost_t *ph, int ttl)
-{
- int ret = -2;
-
- if (ph->addrfamily == AF_INET)
- {
- ret = setsockopt (ph->fd, IPPROTO_IP, IP_TTL, &ttl, sizeof (ttl));
- }
- else if (ph->addrfamily == AF_INET6)
- {
- ret = setsockopt (ph->fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof (ttl));
- }
-
- return (ret);
-}
-
-static int ping_get_ident (void)
-{
- int fd;
- static int did_seed = 0;
-
- int retval;
-
- if (did_seed == 0)
- {
- if ((fd = open ("/dev/urandom", O_RDONLY)) != -1)
- {
- unsigned int seed;
-
- if (read (fd, &seed, sizeof (seed)) != -1)
- {
- did_seed = 1;
- dprintf ("Random seed: %i\n", seed);
- srandom (seed);
- }
-
- close (fd);
- }
- else
- {
- dprintf ("open (/dev/urandom): %s\n", strerror (errno));
- }
- }
-
- retval = (int) random ();
-
- dprintf ("Random number: %i\n", retval);
-
- return (retval);
-}
-
-static pinghost_t *ping_alloc (void)
-{
- pinghost_t *ph;
- size_t ph_size;
-
- ph_size = sizeof (pinghost_t)
- + sizeof (struct sockaddr_storage)
- + sizeof (struct timeval);
-
- ph = (pinghost_t *) malloc (ph_size);
- if (ph == NULL)
- return (NULL);
-
- memset (ph, '\0', ph_size);
-
- ph->timer = (struct timeval *) (ph + 1);
- ph->addr = (struct sockaddr_storage *) (ph->timer + 1);
-
- ph->addrlen = sizeof (struct sockaddr_storage);
- ph->latency = -1.0;
- ph->ident = ping_get_ident () & 0xFFFF;
-
- return (ph);
-}
-
-static void ping_free (pinghost_t *ph)
-{
- if (ph->hostname != NULL)
- free (ph->hostname);
-
- if (ph->data != NULL)
- free (ph->data);
-
- free (ph);
-}
-
-/*
- * public methods
- */
-const char *ping_get_error (pingobj_t *obj)
-{
- return (obj->errmsg);
-}
-
-pingobj_t *ping_construct (void)
-{
- pingobj_t *obj;
-
- if ((obj = (pingobj_t *) malloc (sizeof (pingobj_t))) == NULL)
- return (NULL);
- memset (obj, '\0', sizeof (pingobj_t));
-
- obj->timeout = PING_DEF_TIMEOUT;
- obj->ttl = PING_DEF_TTL;
- obj->addrfamily = PING_DEF_AF;
- obj->data = strdup (PING_DEF_DATA);
-
- return (obj);
-}
-
-void ping_destroy (pingobj_t *obj)
-{
- pinghost_t *current;
- pinghost_t *next;
-
- current = obj->head;
- next = NULL;
-
- while (current != NULL)
- {
- next = current->next;
- ping_free (current);
- current = next;
- }
-
- if (obj->data != NULL)
- free (obj->data);
-
- free (obj);
-
- return;
-}
-
-int ping_setopt (pingobj_t *obj, int option, void *value)
-{
- int ret = 0;
-
- switch (option)
- {
- case PING_OPT_TIMEOUT:
- obj->timeout = *((double *) value);
- if (obj->timeout < 0.0)
- {
- obj->timeout = PING_DEF_TIMEOUT;
- ret = -1;
- }
- break;
-
- case PING_OPT_TTL:
- obj->ttl = *((int *) value);
- if ((obj->ttl < 1) || (obj->ttl > 255))
- {
- obj->ttl = PING_DEF_TTL;
- ret = -1;
- }
- break;
-
- case PING_OPT_AF:
- obj->addrfamily = *((int *) value);
- if ((obj->addrfamily != AF_UNSPEC)
- && (obj->addrfamily != AF_INET)
- && (obj->addrfamily != AF_INET6))
- {
- obj->addrfamily = PING_DEF_AF;
- ret = -1;
- }
- break;
-
- case PING_OPT_DATA:
- if (obj->data != NULL)
- {
- free (obj->data);
- obj->data = NULL;
- }
- obj->data = strdup ((const char *) value);
- break;
-
- default:
- ret = -2;
- } /* switch (option) */
-
- return (ret);
-} /* int ping_setopt */
-
-
-int ping_send (pingobj_t *obj)
-{
- int ret;
-
- if (ping_send_all (obj) < 0)
- return (-1);
-
- if ((ret = ping_receive_all (obj)) < 0)
- return (-2);
-
- return (ret);
-}
-
-static pinghost_t *ping_host_search (pinghost_t *ph, const char *host)
-{
- while (ph != NULL)
- {
- if (strcasecmp (ph->hostname, host) == 0)
- break;
-
- ph = ph->next;
- }
-
- return (ph);
-}
-
-int ping_host_add (pingobj_t *obj, const char *host)
-{
- pinghost_t *ph;
-
- struct addrinfo ai_hints;
- struct addrinfo *ai_list, *ai_ptr;
- int ai_return;
-
- dprintf ("host = %s\n", host);
-
- if (ping_host_search (obj->head, host) != NULL)
- return (0);
-
- memset (&ai_hints, '\0', sizeof (ai_hints));
- ai_hints.ai_flags = 0;
-#ifdef AI_ADDRCONFIG
- ai_hints.ai_flags |= AI_ADDRCONFIG;
-#endif
- ai_hints.ai_family = obj->addrfamily;
- ai_hints.ai_socktype = SOCK_RAW;
-
- if ((ph = ping_alloc ()) == NULL)
- {
- dprintf ("Out of memory!\n");
- return (-1);
- }
-
- if ((ph->hostname = strdup (host)) == NULL)
- {
- dprintf ("Out of memory!\n");
- ping_set_error (obj, "strdup", strerror (errno));
- ping_free (ph);
- return (-1);
- }
-
- /* obj->data is not garuanteed to be != NULL */
- if ((ph->data = strdup (obj->data == NULL ? PING_DEF_DATA : obj->data)) == NULL)
- {
- dprintf ("Out of memory!\n");
- ping_set_error (obj, "strdup", strerror (errno));
- ping_free (ph);
- return (-1);
- }
-
- if ((ai_return = getaddrinfo (host, NULL, &ai_hints, &ai_list)) != 0)
- {
- dprintf ("getaddrinfo failed\n");
- ping_set_error (obj, "getaddrinfo",
- (ai_return == EAI_SYSTEM)
- ? strerror (errno)
- : gai_strerror (ai_return));
- ping_free (ph);
- return (-1);
- }
-
- if (ai_list == NULL)
- ping_set_error (obj, "getaddrinfo", "No hosts returned");
-
- for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
- {
- ph->fd = -1;
-
- if (ai_ptr->ai_family == AF_INET)
- {
- ai_ptr->ai_socktype = SOCK_RAW;
- ai_ptr->ai_protocol = IPPROTO_ICMP;
- }
- else if (ai_ptr->ai_family == AF_INET6)
- {
- ai_ptr->ai_socktype = SOCK_RAW;
- ai_ptr->ai_protocol = IPPROTO_ICMPV6;
- }
- else
- {
- char errmsg[PING_ERRMSG_LEN];
-
- snprintf (errmsg, PING_ERRMSG_LEN, "Unknown `ai_family': %i", ai_ptr->ai_family);
- errmsg[PING_ERRMSG_LEN - 1] = '\0';
-
- dprintf (errmsg);
- ping_set_error (obj, "getaddrinfo", errmsg);
- continue;
- }
-
- /* TODO: Move this to a static function `ping_open_socket' and
- * call it whenever the socket dies. */
- ph->fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
- if (ph->fd == -1)
- {
- dprintf ("socket: %s\n", strerror (errno));
- ping_set_error (obj, "socket", strerror (errno));
- continue;
- }
-
-/*
- * The majority vote of operating systems has decided that you don't need to
- * bind here. This code should be reactivated to bind to a specific address,
- * though. See the `-I' option of `ping(1)' (GNU). -octo
- */
-#if 0
- if (bind (ph->fd, (struct sockaddr *) &sockaddr, sockaddr_len) == -1)
- {
- dprintf ("bind: %s\n", strerror (errno));
- ping_set_error (obj, "bind", strerror (errno));
- close (ph->fd);
- ph->fd = -1;
- continue;
- }
-#endif
-
- assert (sizeof (struct sockaddr_storage) >= ai_ptr->ai_addrlen);
- memset (ph->addr, '\0', sizeof (struct sockaddr_storage));
- memcpy (ph->addr, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
- ph->addrlen = ai_ptr->ai_addrlen;
- ph->addrfamily = ai_ptr->ai_family;
-
- break;
- }
-
- freeaddrinfo (ai_list);
-
- if (ph->fd < 0)
- {
- free (ph->hostname);
- free (ph);
- return (-1);
- }
-
- /*
- * Adding in the front is much easier, but then the iterator will
- * return the host that was added last as first host. That's just not
- * nice. -octo
- */
- if (obj->head == NULL)
- {
- obj->head = ph;
- }
- else
- {
- pinghost_t *hptr;
-
- hptr = obj->head;
- while (hptr->next != NULL)
- hptr = hptr->next;
-
- assert ((hptr != NULL) && (hptr->next == NULL));
- hptr->next = ph;
- }
-
- ping_set_ttl (ph, obj->ttl);
-
- return (0);
-}
-
-int ping_host_remove (pingobj_t *obj, const char *host)
-{
- pinghost_t *pre, *cur;
-
- pre = NULL;
- cur = obj->head;
-
- while (cur != NULL)
- {
- if (strcasecmp (host, cur->hostname))
- break;
-
- pre = cur;
- cur = cur->next;
- }
-
- if (cur == NULL)
- {
- ping_set_error (obj, "ping_host_remove", "Host not found");
- return (-1);
- }
-
- if (pre == NULL)
- obj->head = cur->next;
- else
- pre->next = cur->next;
-
- if (cur->fd >= 0)
- close (cur->fd);
-
- ping_free (cur);
-
- return (0);
-}
-
-pingobj_iter_t *ping_iterator_get (pingobj_t *obj)
-{
- return ((pingobj_iter_t *) obj->head);
-}
-
-pingobj_iter_t *ping_iterator_next (pingobj_iter_t *iter)
-{
- return ((pingobj_iter_t *) iter->next);
-}
-
-int ping_iterator_get_info (pingobj_iter_t *iter, int info,
- void *buffer, size_t *buffer_len)
-{
- int ret = EINVAL;
-
- size_t orig_buffer_len = *buffer_len;
-
- switch (info)
- {
- case PING_INFO_HOSTNAME:
- ret = ENOMEM;
- *buffer_len = strlen (iter->hostname);
- if (orig_buffer_len <= *buffer_len)
- break;
- /* Since (orig_buffer_len > *buffer_len) `strncpy'
- * will copy `*buffer_len' and pad the rest of
- * `buffer' with null-bytes */
- strncpy (buffer, iter->hostname, orig_buffer_len);
- ret = 0;
- break;
-
- case PING_INFO_ADDRESS:
- ret = getnameinfo ((struct sockaddr *) iter->addr,
- iter->addrlen,
- (char *) buffer,
- *buffer_len,
- NULL, 0,
- NI_NUMERICHOST);
- if (ret != 0)
- {
- if ((ret == EAI_MEMORY)
-#ifdef EAI_OVERFLOW
- || (ret == EAI_OVERFLOW)
-#endif
- )
- ret = ENOMEM;
- else if (ret == EAI_SYSTEM)
- /* XXX: Not thread-safe! */
- ret = errno;
- else
- ret = EINVAL;
- }
- break;
-
- case PING_INFO_FAMILY:
- ret = ENOMEM;
- *buffer_len = sizeof (int);
- if (orig_buffer_len < sizeof (int))
- break;
- *((int *) buffer) = iter->addrfamily;
- ret = 0;
- break;
-
- case PING_INFO_LATENCY:
- ret = ENOMEM;
- *buffer_len = sizeof (double);
- if (orig_buffer_len < sizeof (double))
- break;
- *((double *) buffer) = iter->latency;
- ret = 0;
- break;
-
- case PING_INFO_SEQUENCE:
- ret = ENOMEM;
- *buffer_len = sizeof (unsigned int);
- if (orig_buffer_len < sizeof (unsigned int))
- break;
- *((unsigned int *) buffer) = (unsigned int) iter->sequence;
- ret = 0;
- break;
-
- case PING_INFO_IDENT:
- ret = ENOMEM;
- *buffer_len = sizeof (uint16_t);
- if (orig_buffer_len < sizeof (uint16_t))
- break;
- *((uint16_t *) buffer) = (uint16_t) iter->ident;
- ret = 0;
- break;
-
- case PING_INFO_DATA:
- ret = ENOMEM;
- *buffer_len = strlen (iter->data);
- if (orig_buffer_len < *buffer_len)
- break;
- strncpy ((char *) buffer, iter->data, orig_buffer_len);
- ret = 0;
- break;
- }
-
- return (ret);
-}
-
-void *ping_iterator_get_context (pingobj_iter_t *iter)
-{
- return (iter->context);
-}
-
-void ping_iterator_set_context (pingobj_iter_t *iter, void *context)
-{
- iter->context = context;
-}
+++ /dev/null
-/**
- * Object oriented C module to send ICMP and ICMPv6 `echo's.
- * Copyright (C) 2006 Florian octo Forster <octo at verplant.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef OCTO_PING_H
-#define OCTO_PING_H 1
-
-#if HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#if HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
-#if HAVE_UNISTD_H
-# include <unistd.h>
-#endif
-#if HAVE_SYS_SOCKET_H
-# include <sys/socket.h>
-#endif
-
-/*
- * Type definitions
- */
-struct pinghost;
-typedef struct pinghost pinghost_t;
-
-typedef pinghost_t pingobj_iter_t;
-
-struct pingobj;
-typedef struct pingobj pingobj_t;
-
-#define PING_OPT_TIMEOUT 0x01
-#define PING_OPT_TTL 0x02
-#define PING_OPT_AF 0x04
-#define PING_OPT_DATA 0x08
-
-#define PING_DEF_TIMEOUT 1.0
-#define PING_DEF_TTL 255
-#define PING_DEF_AF AF_UNSPEC
-#define PING_DEF_DATA "Florian Forster <octo@verplant.org> http://verplant.org/"
-
-/*
- * Method definitions
- */
-pingobj_t *ping_construct (void);
-void ping_destroy (pingobj_t *obj);
-
-int ping_setopt (pingobj_t *obj, int option, void *value);
-
-int ping_send (pingobj_t *obj);
-
-int ping_host_add (pingobj_t *obj, const char *host);
-int ping_host_remove (pingobj_t *obj, const char *host);
-
-pingobj_iter_t *ping_iterator_get (pingobj_t *obj);
-pingobj_iter_t *ping_iterator_next (pingobj_iter_t *iter);
-
-#define PING_INFO_HOSTNAME 1
-#define PING_INFO_ADDRESS 2
-#define PING_INFO_FAMILY 3
-#define PING_INFO_LATENCY 4
-#define PING_INFO_SEQUENCE 5
-#define PING_INFO_IDENT 6
-#define PING_INFO_DATA 7
-int ping_iterator_get_info (pingobj_iter_t *iter, int info,
- void *buffer, size_t *buffer_len);
-
-const char *ping_get_error (pingobj_t *obj);
-
-void *ping_iterator_get_context (pingobj_iter_t *iter);
-void ping_iterator_set_context (pingobj_iter_t *iter, void *context);
-
-#endif /* OCTO_PING_H */
return;
} /* void logfile_print */
-static void logfile_log (int severity, const char *msg)
+static void logfile_log (int severity, const char *msg,
+ user_data_t __attribute__((unused)) *user_data)
{
if (severity > log_level)
return;
logfile_print (msg, time (NULL));
} /* void logfile_log (int, const char *) */
-static int logfile_notification (const notification_t *n)
+static int logfile_notification (const notification_t *n,
+ user_data_t __attribute__((unused)) *user_data)
{
char buf[1024] = "";
char *buf_ptr = buf;
buf[sizeof (buf) - 1] = '\0';
- logfile_print (buf, n->time);
+ logfile_print (buf,
+ (n->time > 0) ? n->time : time (NULL));
return (0);
} /* int logfile_notification */
{
plugin_register_config ("logfile", logfile_config,
config_keys, config_keys_num);
- plugin_register_log ("logfile", logfile_log);
- plugin_register_notification ("logfile", logfile_notification);
+ plugin_register_log ("logfile", logfile_log, /* user_data = */ NULL);
+ plugin_register_notification ("logfile", logfile_notification,
+ /* user_data = */ NULL);
} /* void module_register (void) */
/* vim: set sw=4 ts=4 tw=78 noexpandtab : */
--- /dev/null
+/**
+ * collectd - src/memcachec.c
+ * Copyright (C) 2009 Doug MacEachern
+ * Copyright (C) 2006-2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Doug MacEachern <Doug.MacEachern at hyperic.com>
+ * Florian octo Forster <octo at verplant.org>
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+#include "configfile.h"
+#include "utils_match.h"
+
+#include <libmemcached/memcached.h>
+
+/*
+ * Data types
+ */
+struct web_match_s;
+typedef struct web_match_s web_match_t;
+struct web_match_s /* {{{ */
+{
+ char *regex;
+ int dstype;
+ char *type;
+ char *instance;
+
+ cu_match_t *match;
+
+ web_match_t *next;
+}; /* }}} */
+
+struct web_page_s;
+typedef struct web_page_s web_page_t;
+struct web_page_s /* {{{ */
+{
+ char *instance;
+
+ char *server;
+ char *key;
+
+ memcached_st *memc;
+ char *buffer;
+
+ web_match_t *matches;
+
+ web_page_t *next;
+}; /* }}} */
+
+/*
+ * Global variables;
+ */
+static web_page_t *pages_g = NULL;
+
+/*
+ * Private functions
+ */
+static void cmc_web_match_free (web_match_t *wm) /* {{{ */
+{
+ if (wm == NULL)
+ return;
+
+ sfree (wm->regex);
+ sfree (wm->type);
+ sfree (wm->instance);
+ match_destroy (wm->match);
+ cmc_web_match_free (wm->next);
+ sfree (wm);
+} /* }}} void cmc_web_match_free */
+
+static void cmc_web_page_free (web_page_t *wp) /* {{{ */
+{
+ if (wp == NULL)
+ return;
+
+ if (wp->memc != NULL)
+ memcached_free(wp->memc);
+ wp->memc = NULL;
+
+ sfree (wp->instance);
+ sfree (wp->server);
+ sfree (wp->key);
+ sfree (wp->buffer);
+
+ cmc_web_match_free (wp->matches);
+ cmc_web_page_free (wp->next);
+ sfree (wp);
+} /* }}} void cmc_web_page_free */
+
+static int cmc_page_init_memc (web_page_t *wp) /* {{{ */
+{
+ memcached_server_st *server;
+
+ wp->memc = memcached_create(NULL);
+ if (wp->memc == NULL)
+ {
+ ERROR ("memcachec plugin: memcached_create failed.");
+ return (-1);
+ }
+
+ server = memcached_servers_parse (wp->server);
+ memcached_server_push (wp->memc, server);
+ memcached_server_list_free (server);
+
+ return (0);
+} /* }}} int cmc_page_init_memc */
+
+static int cmc_config_add_string (const char *name, char **dest, /* {{{ */
+ oconfig_item_t *ci)
+{
+ if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("memcachec plugin: `%s' needs exactly one string argument.", name);
+ return (-1);
+ }
+
+ sfree (*dest);
+ *dest = strdup (ci->values[0].value.string);
+ if (*dest == NULL)
+ return (-1);
+
+ return (0);
+} /* }}} int cmc_config_add_string */
+
+static int cmc_config_add_match_dstype (int *dstype_ret, /* {{{ */
+ oconfig_item_t *ci)
+{
+ int dstype;
+
+ if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("memcachec plugin: `DSType' needs exactly one string argument.");
+ return (-1);
+ }
+
+ if (strncasecmp ("Gauge", ci->values[0].value.string,
+ strlen ("Gauge")) == 0)
+ {
+ dstype = UTILS_MATCH_DS_TYPE_GAUGE;
+ if (strcasecmp ("GaugeAverage", ci->values[0].value.string) == 0)
+ dstype |= UTILS_MATCH_CF_GAUGE_AVERAGE;
+ else if (strcasecmp ("GaugeMin", ci->values[0].value.string) == 0)
+ dstype |= UTILS_MATCH_CF_GAUGE_MIN;
+ else if (strcasecmp ("GaugeMax", ci->values[0].value.string) == 0)
+ dstype |= UTILS_MATCH_CF_GAUGE_MAX;
+ else if (strcasecmp ("GaugeLast", ci->values[0].value.string) == 0)
+ dstype |= UTILS_MATCH_CF_GAUGE_LAST;
+ else
+ dstype = 0;
+ }
+ else if (strncasecmp ("Counter", ci->values[0].value.string,
+ strlen ("Counter")) == 0)
+ {
+ dstype = UTILS_MATCH_DS_TYPE_COUNTER;
+ if (strcasecmp ("CounterSet", ci->values[0].value.string) == 0)
+ dstype |= UTILS_MATCH_CF_COUNTER_SET;
+ else if (strcasecmp ("CounterAdd", ci->values[0].value.string) == 0)
+ dstype |= UTILS_MATCH_CF_COUNTER_ADD;
+ else if (strcasecmp ("CounterInc", ci->values[0].value.string) == 0)
+ dstype |= UTILS_MATCH_CF_COUNTER_INC;
+ else
+ dstype = 0;
+ }
+ else
+ {
+ dstype = 0;
+ }
+
+ if (dstype == 0)
+ {
+ WARNING ("memcachec plugin: `%s' is not a valid argument to `DSType'.",
+ ci->values[0].value.string);
+ return (-1);
+ }
+
+ *dstype_ret = dstype;
+ return (0);
+} /* }}} int cmc_config_add_match_dstype */
+
+static int cmc_config_add_match (web_page_t *page, /* {{{ */
+ oconfig_item_t *ci)
+{
+ web_match_t *match;
+ int status;
+ int i;
+
+ if (ci->values_num != 0)
+ {
+ WARNING ("memcachec plugin: Ignoring arguments for the `Match' block.");
+ }
+
+ match = (web_match_t *) malloc (sizeof (*match));
+ if (match == NULL)
+ {
+ ERROR ("memcachec plugin: malloc failed.");
+ return (-1);
+ }
+ memset (match, 0, sizeof (*match));
+
+ status = 0;
+ for (i = 0; i < ci->children_num; i++)
+ {
+ oconfig_item_t *child = ci->children + i;
+
+ if (strcasecmp ("Regex", child->key) == 0)
+ status = cmc_config_add_string ("Regex", &match->regex, child);
+ else if (strcasecmp ("DSType", child->key) == 0)
+ status = cmc_config_add_match_dstype (&match->dstype, child);
+ else if (strcasecmp ("Type", child->key) == 0)
+ status = cmc_config_add_string ("Type", &match->type, child);
+ else if (strcasecmp ("Instance", child->key) == 0)
+ status = cmc_config_add_string ("Instance", &match->instance, child);
+ else
+ {
+ WARNING ("memcachec plugin: Option `%s' not allowed here.", child->key);
+ status = -1;
+ }
+
+ if (status != 0)
+ break;
+ } /* for (i = 0; i < ci->children_num; i++) */
+
+ while (status == 0)
+ {
+ if (match->regex == NULL)
+ {
+ WARNING ("memcachec plugin: `Regex' missing in `Match' block.");
+ status = -1;
+ }
+
+ if (match->type == NULL)
+ {
+ WARNING ("memcachec plugin: `Type' missing in `Match' block.");
+ status = -1;
+ }
+
+ if (match->dstype == 0)
+ {
+ WARNING ("memcachec plugin: `DSType' missing in `Match' block.");
+ status = -1;
+ }
+
+ break;
+ } /* while (status == 0) */
+
+ if (status != 0)
+ return (status);
+
+ match->match = match_create_simple (match->regex, match->dstype);
+ if (match->match == NULL)
+ {
+ ERROR ("memcachec plugin: tail_match_add_match_simple failed.");
+ cmc_web_match_free (match);
+ return (-1);
+ }
+ else
+ {
+ web_match_t *prev;
+
+ prev = page->matches;
+ while ((prev != NULL) && (prev->next != NULL))
+ prev = prev->next;
+
+ if (prev == NULL)
+ page->matches = match;
+ else
+ prev->next = match;
+ }
+
+ return (0);
+} /* }}} int cmc_config_add_match */
+
+static int cmc_config_add_page (oconfig_item_t *ci) /* {{{ */
+{
+ web_page_t *page;
+ int status;
+ int i;
+
+ if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("memcachec plugin: `Page' blocks need exactly one string argument.");
+ return (-1);
+ }
+
+ page = (web_page_t *) malloc (sizeof (*page));
+ if (page == NULL)
+ {
+ ERROR ("memcachec plugin: malloc failed.");
+ return (-1);
+ }
+ memset (page, 0, sizeof (*page));
+ page->server = NULL;
+ page->key = NULL;
+
+ page->instance = strdup (ci->values[0].value.string);
+ if (page->instance == NULL)
+ {
+ ERROR ("memcachec plugin: strdup failed.");
+ sfree (page);
+ return (-1);
+ }
+
+ /* Process all children */
+ status = 0;
+ for (i = 0; i < ci->children_num; i++)
+ {
+ oconfig_item_t *child = ci->children + i;
+
+ if (strcasecmp ("Server", child->key) == 0)
+ status = cmc_config_add_string ("Server", &page->server, child);
+ if (strcasecmp ("Key", child->key) == 0)
+ status = cmc_config_add_string ("Key", &page->key, child);
+ else if (strcasecmp ("Match", child->key) == 0)
+ /* Be liberal with failing matches => don't set `status'. */
+ cmc_config_add_match (page, child);
+ else
+ {
+ WARNING ("memcachec plugin: Option `%s' not allowed here.", child->key);
+ status = -1;
+ }
+
+ if (status != 0)
+ break;
+ } /* for (i = 0; i < ci->children_num; i++) */
+
+ /* Additionial sanity checks and libCURL initialization. */
+ while (status == 0)
+ {
+ if (page->server == NULL)
+ {
+ WARNING ("memcachec plugin: `Server' missing in `Page' block.");
+ status = -1;
+ }
+
+ if (page->key == NULL)
+ {
+ WARNING ("memcachec plugin: `Key' missing in `Page' block.");
+ status = -1;
+ }
+
+ if (page->matches == NULL)
+ {
+ assert (page->instance != NULL);
+ WARNING ("memcachec plugin: No (valid) `Match' block "
+ "within `Page' block `%s'.", page->instance);
+ status = -1;
+ }
+
+ if (status == 0)
+ status = cmc_page_init_memc (page);
+
+ break;
+ } /* while (status == 0) */
+
+ if (status != 0)
+ {
+ cmc_web_page_free (page);
+ return (status);
+ }
+
+ /* Add the new page to the linked list */
+ if (pages_g == NULL)
+ pages_g = page;
+ else
+ {
+ web_page_t *prev;
+
+ prev = pages_g;
+ while ((prev != NULL) && (prev->next != NULL))
+ prev = prev->next;
+ prev->next = page;
+ }
+
+ return (0);
+} /* }}} int cmc_config_add_page */
+
+static int cmc_config (oconfig_item_t *ci) /* {{{ */
+{
+ int success;
+ int errors;
+ int status;
+ int i;
+
+ success = 0;
+ errors = 0;
+
+ for (i = 0; i < ci->children_num; i++)
+ {
+ oconfig_item_t *child = ci->children + i;
+
+ if (strcasecmp ("Page", child->key) == 0)
+ {
+ status = cmc_config_add_page (child);
+ if (status == 0)
+ success++;
+ else
+ errors++;
+ }
+ else
+ {
+ WARNING ("memcachec plugin: Option `%s' not allowed here.", child->key);
+ errors++;
+ }
+ }
+
+ if ((success == 0) && (errors > 0))
+ {
+ ERROR ("memcachec plugin: All statements failed.");
+ return (-1);
+ }
+
+ return (0);
+} /* }}} int cmc_config */
+
+static int cmc_init (void) /* {{{ */
+{
+ if (pages_g == NULL)
+ {
+ INFO ("memcachec plugin: No pages have been defined.");
+ return (-1);
+ }
+ return (0);
+} /* }}} int cmc_init */
+
+static void cmc_submit (const web_page_t *wp, const web_match_t *wm, /* {{{ */
+ const cu_match_value_t *mv)
+{
+ value_t values[1];
+ value_list_t vl = VALUE_LIST_INIT;
+
+ values[0] = mv->value;
+
+ vl.values = values;
+ vl.values_len = 1;
+ vl.time = time (NULL);
+ sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+ sstrncpy (vl.plugin, "memcachec", sizeof (vl.plugin));
+ sstrncpy (vl.plugin_instance, wp->instance, sizeof (vl.plugin_instance));
+ sstrncpy (vl.type, wm->type, sizeof (vl.type));
+ sstrncpy (vl.type_instance, wm->instance, sizeof (vl.type_instance));
+
+ plugin_dispatch_values (&vl);
+} /* }}} void cmc_submit */
+
+static int cmc_read_page (web_page_t *wp) /* {{{ */
+{
+ web_match_t *wm;
+ memcached_return rc;
+ size_t string_length;
+ uint32_t flags;
+ int status;
+
+ if (wp->memc == NULL)
+ return (-1);
+
+ wp->buffer = memcached_get (wp->memc, wp->key, strlen (wp->key),
+ &string_length, &flags, &rc);
+ if (rc != MEMCACHED_SUCCESS)
+ {
+ ERROR ("memcachec plugin: memcached_get failed: %s",
+ memcached_strerror (wp->memc, rc));
+ return (-1);
+ }
+
+ for (wm = wp->matches; wm != NULL; wm = wm->next)
+ {
+ cu_match_value_t *mv;
+
+ status = match_apply (wm->match, wp->buffer);
+ if (status != 0)
+ {
+ WARNING ("memcachec plugin: match_apply failed.");
+ continue;
+ }
+
+ mv = match_get_user_data (wm->match);
+ if (mv == NULL)
+ {
+ WARNING ("memcachec plugin: match_get_user_data returned NULL.");
+ continue;
+ }
+
+ cmc_submit (wp, wm, mv);
+ } /* for (wm = wp->matches; wm != NULL; wm = wm->next) */
+
+ sfree (wp->buffer);
+
+ return (0);
+} /* }}} int cmc_read_page */
+
+static int cmc_read (void) /* {{{ */
+{
+ web_page_t *wp;
+
+ for (wp = pages_g; wp != NULL; wp = wp->next)
+ cmc_read_page (wp);
+
+ return (0);
+} /* }}} int cmc_read */
+
+static int cmc_shutdown (void) /* {{{ */
+{
+ cmc_web_page_free (pages_g);
+ pages_g = NULL;
+
+ return (0);
+} /* }}} int cmc_shutdown */
+
+void module_register (void)
+{
+ plugin_register_complex_config ("memcachec", cmc_config);
+ plugin_register_init ("memcachec", cmc_init);
+ plugin_register_read ("memcachec", cmc_read);
+ plugin_register_shutdown ("memcachec", cmc_shutdown);
+} /* void module_register */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
/**
* collectd - src/mysql.c
- * Copyright (C) 2006,2007 Florian octo Forster
+ * Copyright (C) 2006-2009 Florian octo Forster
+ * Copyright (C) 2009 Doug MacEachern
+ * Copyright (C) 2009 Sebastian tokkee Harl
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
*
* Authors:
* Florian octo Forster <octo at verplant.org>
+ * Mirko Buffoni <briareos at eswat.org>
+ * Doug MacEachern <dougm at hyperic.com>
+ * Sebastian tokkee Harl <sh at tokkee.org>
**/
#include "collectd.h"
/* TODO: Understand `Select_*' and possibly do that stuff as well.. */
-static const char *config_keys[] =
+struct mysql_database_s /* {{{ */
{
- "Host",
- "User",
- "Password",
- "Database",
- "Port",
- "Socket",
- NULL
+ /* instance == NULL => legacy mode */
+ char *instance;
+ char *host;
+ char *user;
+ char *pass;
+ char *database;
+ char *socket;
+ int port;
+
+ int master_stats;
+ int slave_stats;
+
+ int slave_notif;
+ int slave_io_running;
+ int slave_sql_running;
+
+ MYSQL *con;
+ int state;
};
-static int config_keys_num = 6;
+typedef struct mysql_database_s mysql_database_t; /* }}} */
-static char *host = "localhost";
-static char *user;
-static char *pass;
-static char *db = NULL;
-static char *socket = NULL;
-static int port = 0;
+static int mysql_read (user_data_t *ud);
-static MYSQL *getconnection (void)
+static void mysql_database_free (void *arg) /* {{{ */
{
- static MYSQL *con;
- static int state;
+ mysql_database_t *db;
- static int wait_for = 0;
- static int wait_increase = 60;
+ DEBUG ("mysql plugin: mysql_database_free (arg = %p);", arg);
- if (state != 0)
+ db = (mysql_database_t *) arg;
+
+ if (db == NULL)
+ return;
+
+ if (db->con != NULL)
+ mysql_close (db->con);
+
+ sfree (db->host);
+ sfree (db->user);
+ sfree (db->pass);
+ sfree (db->socket);
+ sfree (db->instance);
+ sfree (db->database);
+ sfree (db);
+} /* }}} void mysql_database_free */
+
+/* Configuration handling functions {{{
+ *
+ * <Plugin mysql>
+ * <Database "plugin_instance1">
+ * Host "localhost"
+ * Port 22000
+ * ...
+ * </Database>
+ * </Plugin>
+ */
+
+static int mysql_config_set_string (char **ret_string, /* {{{ */
+ oconfig_item_t *ci)
+{
+ char *string;
+
+ if ((ci->values_num != 1)
+ || (ci->values[0].type != OCONFIG_TYPE_STRING))
{
- int err;
- if ((err = mysql_ping (con)) != 0)
+ WARNING ("mysql plugin: The `%s' config option "
+ "needs exactly one string argument.", ci->key);
+ return (-1);
+ }
+
+ string = strdup (ci->values[0].value.string);
+ if (string == NULL)
+ {
+ ERROR ("mysql plugin: strdup failed.");
+ return (-1);
+ }
+
+ if (*ret_string != NULL)
+ free (*ret_string);
+ *ret_string = string;
+
+ return (0);
+} /* }}} int mysql_config_set_string */
+
+static int mysql_config_set_int (int *ret_int, /* {{{ */
+ oconfig_item_t *ci)
+{
+ if ((ci->values_num != 1)
+ || (ci->values[0].type != OCONFIG_TYPE_NUMBER))
+ {
+ WARNING ("mysql plugin: The `%s' config option "
+ "needs exactly one string argument.", ci->key);
+ return (-1);
+ }
+
+ *ret_int = ci->values[0].value.number;
+
+ return (0);
+} /* }}} int mysql_config_set_int */
+
+static int mysql_config_set_boolean (int *ret_boolean, /* {{{ */
+ oconfig_item_t *ci)
+{
+ int status = 0;
+
+ if (ci->values_num != 1)
+ status = -1;
+
+ if (status == 0)
+ {
+ if (ci->values[0].type == OCONFIG_TYPE_BOOLEAN)
+ *ret_boolean = ci->values[0].value.boolean;
+ else if (ci->values[0].type == OCONFIG_TYPE_STRING)
{
- WARNING ("mysql_ping failed: %s", mysql_error (con));
- state = 0;
+ if (IS_TRUE (ci->values[0].value.string))
+ *ret_boolean = 1;
+ else if (IS_FALSE (ci->values[0].value.string))
+ *ret_boolean = 0;
+ else
+ status = -1;
}
else
+ status = -1;
+ }
+
+ if (status != 0)
+ {
+ WARNING ("mysql plugin: The `%s' config option "
+ "needs exactly one boolean argument.", ci->key);
+ return (-1);
+ }
+ return (0);
+} /* }}} mysql_config_set_boolean */
+
+static int mysql_config (oconfig_item_t *ci) /* {{{ */
+{
+ mysql_database_t *db;
+ int plugin_block;
+ int status = 0;
+ int i;
+
+ if ((ci->values_num != 1)
+ || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("mysql plugin: The `Database' block "
+ "needs exactly one string argument.");
+ return (-1);
+ }
+
+ db = (mysql_database_t *) malloc (sizeof (*db));
+ if (db == NULL)
+ {
+ ERROR ("mysql plugin: malloc failed.");
+ return (-1);
+ }
+ memset (db, 0, sizeof (*db));
+
+ /* initialize all the pointers */
+ db->host = NULL;
+ db->user = NULL;
+ db->pass = NULL;
+ db->database = NULL;
+ db->socket = NULL;
+ db->con = NULL;
+
+ /* trigger a notification, if it's not running */
+ db->slave_io_running = 1;
+ db->slave_sql_running = 1;
+
+ plugin_block = 1;
+ if (strcasecmp ("Plugin", ci->key) == 0)
+ {
+ db->instance = NULL;
+ }
+ else if (strcasecmp ("Database", ci->key) == 0)
+ {
+ plugin_block = 0;
+ status = mysql_config_set_string (&db->instance, ci);
+ if (status != 0)
{
- state = 1;
- return (con);
+ sfree (db);
+ return (status);
}
+ assert (db->instance != NULL);
+ }
+ else
+ {
+ ERROR ("mysql plugin: mysql_config: "
+ "Invalid key: %s", ci->key);
+ return (-1);
}
- if (wait_for > 0)
+ /* Fill the `mysql_database_t' structure.. */
+ for (i = 0; i < ci->children_num; i++)
{
- wait_for -= interval_g;
- return (NULL);
+ oconfig_item_t *child = ci->children + i;
+
+ if (strcasecmp ("Host", child->key) == 0)
+ status = mysql_config_set_string (&db->host, child);
+ else if (strcasecmp ("User", child->key) == 0)
+ status = mysql_config_set_string (&db->user, child);
+ else if (strcasecmp ("Password", child->key) == 0)
+ status = mysql_config_set_string (&db->pass, child);
+ else if (strcasecmp ("Port", child->key) == 0)
+ status = mysql_config_set_int (&db->port, child);
+ else if (strcasecmp ("Socket", child->key) == 0)
+ status = mysql_config_set_string (&db->socket, child);
+ /* Check if we're currently handling the `Plugin' block. If so,
+ * handle `Database' _blocks_, too. */
+ else if ((plugin_block != 0)
+ && (strcasecmp ("Database", child->key) == 0)
+ && (child->children != NULL))
+ {
+ /* If `plugin_block > 1', there has been at least one
+ * `Database' block */
+ plugin_block++;
+ status = mysql_config (child);
+ }
+ /* Now handle ordinary `Database' options (without children) */
+ else if ((strcasecmp ("Database", child->key) == 0)
+ && (child->children == NULL))
+ status = mysql_config_set_string (&db->database, child);
+ else if (strcasecmp ("MasterStats", child->key) == 0)
+ status = mysql_config_set_boolean (&db->master_stats, child);
+ else if (strcasecmp ("SlaveStats", child->key) == 0)
+ status = mysql_config_set_boolean (&db->slave_stats, child);
+ else if (strcasecmp ("SlaveNotifications", child->key) == 0)
+ status = mysql_config_set_boolean (&db->slave_notif, child);
+ else
+ {
+ WARNING ("mysql plugin: Option `%s' not allowed here.", child->key);
+ status = -1;
+ }
+
+ if (status != 0)
+ break;
}
- wait_for = wait_increase;
- wait_increase *= 2;
- if (wait_increase > 86400)
- wait_increase = 86400;
+ /* Check if there were any `Database' blocks. */
+ if (plugin_block > 1)
+ {
+ /* There were connection blocks. Don't use any legacy stuff. */
+ if ((db->host != NULL)
+ || (db->user != NULL)
+ || (db->pass != NULL)
+ || (db->database != NULL)
+ || (db->socket != NULL)
+ || (db->port != 0))
+ {
+ WARNING ("mysql plugin: At least one <Database> "
+ "block has been found. The legacy "
+ "configuration will be ignored.");
+ }
+ mysql_database_free (db);
+ return (0);
+ }
+ else if (plugin_block != 0)
+ {
+ WARNING ("mysql plugin: You're using the legacy "
+ "configuration options. Please consider "
+ "updating your configuration!");
+ }
+
+ /* Check that all necessary options have been given. */
+ while (status == 0)
+ {
+ /* Zero is allowed and automatically handled by
+ * `mysql_real_connect'. */
+ if ((db->port < 0) || (db->port > 65535))
+ {
+ ERROR ("mysql plugin: Database %s: Port number out "
+ "of range: %i",
+ (db->instance != NULL)
+ ? db->instance
+ : "<legacy>",
+ db->port);
+ status = -1;
+ }
+ break;
+ } /* while (status == 0) */
+
+ /* If all went well, register this database for reading */
+ if (status == 0)
+ {
+ user_data_t ud;
+ char cb_name[DATA_MAX_NAME_LEN];
- if ((con = mysql_init (con)) == NULL)
+ DEBUG ("mysql plugin: Registering new read callback: %s",
+ (db->database != NULL) ? db->database : "<default>");
+
+ memset (&ud, 0, sizeof (ud));
+ ud.data = (void *) db;
+ ud.free_func = mysql_database_free;
+
+ if (db->database != NULL)
+ ssnprintf (cb_name, sizeof (cb_name), "mysql-%s",
+ db->database);
+ else
+ sstrncpy (cb_name, "mysql", sizeof (cb_name));
+
+ plugin_register_complex_read (cb_name, mysql_read,
+ /* interval = */ NULL, &ud);
+ }
+ else
+ {
+ mysql_database_free (db);
+ return (-1);
+ }
+
+ return (0);
+} /* }}} int mysql_config */
+
+/* }}} End of configuration handling functions */
+
+static MYSQL *getconnection (mysql_database_t *db)
+{
+ if (db->state != 0)
{
- ERROR ("mysql_init failed: %s", mysql_error (con));
- state = 0;
+ int err;
+ if ((err = mysql_ping (db->con)) != 0)
+ {
+ WARNING ("mysql_ping failed: %s", mysql_error (db->con));
+ db->state = 0;
+ }
+ else
+ {
+ db->state = 1;
+ return (db->con);
+ }
+ }
+
+ if ((db->con = mysql_init (db->con)) == NULL)
+ {
+ ERROR ("mysql_init failed: %s", mysql_error (db->con));
+ db->state = 0;
return (NULL);
}
- if (mysql_real_connect (con, host, user, pass, db, port, socket, 0) == NULL)
+ if (mysql_real_connect (db->con, db->host, db->user, db->pass,
+ db->database, db->port, db->socket, 0) == NULL)
{
- ERROR ("mysql_real_connect failed: %s", mysql_error (con));
- state = 0;
+ ERROR ("mysql plugin: Failed to connect to database %s "
+ "at server %s: %s",
+ (db->database != NULL) ? db->database : "<none>",
+ (db->host != NULL) ? db->host : "localhost",
+ mysql_error (db->con));
+ db->state = 0;
return (NULL);
}
else
{
- state = 1;
- wait_for = 0;
- wait_increase = 60;
- return (con);
+ INFO ("mysql plugin: Sucessfully connected to database %s "
+ "at server %s (server version: %s, protocol version: %d)",
+ (db->database != NULL) ? db->database : "<none>",
+ mysql_get_host_info (db->con),
+ mysql_get_server_info (db->con),
+ mysql_get_proto_info (db->con));
+ db->state = 1;
+ return (db->con);
}
-} /* static MYSQL *getconnection (void) */
+} /* static MYSQL *getconnection (mysql_database_t *db) */
-static int config (const char *key, const char *value)
+static void set_host (mysql_database_t *db, char *buf, size_t buflen)
{
- if (strcasecmp (key, "host") == 0)
- return ((host = strdup (value)) == NULL ? 1 : 0);
- else if (strcasecmp (key, "user") == 0)
- return ((user = strdup (value)) == NULL ? 1 : 0);
- else if (strcasecmp (key, "password") == 0)
- return ((pass = strdup (value)) == NULL ? 1 : 0);
- else if (strcasecmp (key, "database") == 0)
- return ((db = strdup (value)) == NULL ? 1 : 0);
- else if (strcasecmp (key, "socket") == 0)
- return ((socket = strdup (value)) == NULL ? 1 : 0);
- else if (strcasecmp (key, "port") == 0)
+ /* XXX legacy mode - use hostname_g */
+ if (db->instance == NULL)
+ sstrncpy (buf, hostname_g, buflen);
+ else
{
- char *endptr = NULL;
- int temp;
-
- errno = 0;
- temp = strtol (value, &endptr, 0);
- if ((errno != 0) || (value == endptr))
- {
- ERROR ("mysql plugin: Invalid \"Port\" argument: %s",
- value);
- port = 0;
- return (1);
- }
- else if ((temp < 0) || (temp >= 65535))
- {
- ERROR ("mysql plugin: Port number out of range: %i",
- temp);
- port = 0;
- return (1);
- }
-
- port = temp;
- return (0);
+ if ((db->host == NULL)
+ || (strcmp ("", db->host) == 0)
+ || (strcmp ("localhost", db->host) == 0))
+ sstrncpy (buf, hostname_g, buflen);
+ else
+ sstrncpy (buf, db->host, buflen);
}
+}
+
+static void set_plugin_instance (mysql_database_t *db,
+ char *buf, size_t buflen)
+{
+ /* XXX legacy mode - no plugin_instance */
+ if (db->instance == NULL)
+ sstrncpy (buf, "", buflen);
else
- return (-1);
-} /* int config */
+ sstrncpy (buf, db->instance, buflen);
+}
-static void counter_submit (const char *type, const char *type_instance,
- counter_t value)
+static void submit (const char *type, const char *type_instance,
+ value_t *values, size_t values_len, mysql_database_t *db)
{
- value_t values[1];
value_list_t vl = VALUE_LIST_INIT;
- values[0].counter = value;
+ vl.values = values;
+ vl.values_len = values_len;
+
+ set_host (db, vl.host, sizeof (vl.host));
- vl.values = values;
- vl.values_len = 1;
- sstrncpy (vl.host, hostname_g, sizeof (vl.host));
sstrncpy (vl.plugin, "mysql", sizeof (vl.plugin));
+ set_plugin_instance (db, vl.plugin_instance, sizeof (vl.plugin_instance));
+
sstrncpy (vl.type, type, sizeof (vl.type));
- sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
+ if (type_instance != NULL)
+ sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
plugin_dispatch_values (&vl);
+} /* submit */
+
+static void counter_submit (const char *type, const char *type_instance,
+ counter_t value, mysql_database_t *db)
+{
+ value_t values[1];
+
+ values[0].counter = value;
+ submit (type, type_instance, values, STATIC_ARRAY_SIZE (values), db);
} /* void counter_submit */
+static void gauge_submit (const char *type, const char *type_instance,
+ gauge_t value, mysql_database_t *db)
+{
+ value_t values[1];
+
+ values[0].gauge = value;
+ submit (type, type_instance, values, STATIC_ARRAY_SIZE (values), db);
+} /* void gauge_submit */
+
static void qcache_submit (counter_t hits, counter_t inserts,
counter_t not_cached, counter_t lowmem_prunes,
- gauge_t queries_in_cache)
+ gauge_t queries_in_cache, mysql_database_t *db)
{
value_t values[5];
- value_list_t vl = VALUE_LIST_INIT;
values[0].counter = hits;
values[1].counter = inserts;
values[3].counter = lowmem_prunes;
values[4].gauge = queries_in_cache;
- vl.values = values;
- vl.values_len = 5;
- sstrncpy (vl.host, hostname_g, sizeof (vl.host));
- sstrncpy (vl.plugin, "mysql", sizeof (vl.plugin));
- sstrncpy (vl.type, "mysql_qcache", sizeof (vl.type));
-
- plugin_dispatch_values (&vl);
+ submit ("mysql_qcache", NULL, values, STATIC_ARRAY_SIZE (values), db);
} /* void qcache_submit */
static void threads_submit (gauge_t running, gauge_t connected, gauge_t cached,
- counter_t created)
+ counter_t created, mysql_database_t *db)
{
value_t values[4];
- value_list_t vl = VALUE_LIST_INIT;
values[0].gauge = running;
values[1].gauge = connected;
values[2].gauge = cached;
values[3].counter = created;
- vl.values = values;
- vl.values_len = 4;
- sstrncpy (vl.host, hostname_g, sizeof (vl.host));
- sstrncpy (vl.plugin, "mysql", sizeof (vl.plugin));
- sstrncpy (vl.type, "mysql_threads", sizeof (vl.type));
-
- plugin_dispatch_values (&vl);
+ submit ("mysql_threads", NULL, values, STATIC_ARRAY_SIZE (values), db);
} /* void threads_submit */
-static void traffic_submit (counter_t rx, counter_t tx)
+static void traffic_submit (counter_t rx, counter_t tx, mysql_database_t *db)
{
value_t values[2];
- value_list_t vl = VALUE_LIST_INIT;
values[0].counter = rx;
values[1].counter = tx;
- vl.values = values;
- vl.values_len = 2;
- sstrncpy (vl.host, hostname_g, sizeof (vl.host));
- sstrncpy (vl.plugin, "mysql", sizeof (vl.plugin));
- sstrncpy (vl.type, "mysql_octets", sizeof (vl.type));
-
- plugin_dispatch_values (&vl);
+ submit ("mysql_octets", NULL, values, STATIC_ARRAY_SIZE (values), db);
} /* void traffic_submit */
-static int mysql_read (void)
+static MYSQL_RES *exec_query (MYSQL *con, const char *query)
+{
+ MYSQL_RES *res;
+
+ int query_len = strlen (query);
+
+ if (mysql_real_query (con, query, query_len))
+ {
+ ERROR ("mysql plugin: Failed to execute query: %s",
+ mysql_error (con));
+ INFO ("mysql plugin: SQL query was: %s", query);
+ return (NULL);
+ }
+
+ res = mysql_store_result (con);
+ if (res == NULL)
+ {
+ ERROR ("mysql plugin: Failed to store query result: %s",
+ mysql_error (con));
+ INFO ("mysql plugin: SQL query was: %s", query);
+ return (NULL);
+ }
+
+ return (res);
+} /* exec_query */
+
+static int mysql_read_master_stats (mysql_database_t *db, MYSQL *con)
{
+ MYSQL_RES *res;
+ MYSQL_ROW row;
+
+ char *query;
+ int field_num;
+ unsigned long long position;
+
+ query = "SHOW MASTER STATUS";
+
+ res = exec_query (con, query);
+ if (res == NULL)
+ return (-1);
+
+ row = mysql_fetch_row (res);
+ if (row == NULL)
+ {
+ ERROR ("mysql plugin: Failed to get master statistics: "
+ "`%s' did not return any rows.", query);
+ return (-1);
+ }
+
+ field_num = mysql_num_fields (res);
+ if (field_num < 2)
+ {
+ ERROR ("mysql plugin: Failed to get master statistics: "
+ "`%s' returned less than two columns.", query);
+ return (-1);
+ }
+
+ position = atoll (row[1]);
+ counter_submit ("mysql_log_position", "master-bin", position, db);
+
+ row = mysql_fetch_row (res);
+ if (row != NULL)
+ WARNING ("mysql plugin: `%s' returned more than one row - "
+ "ignoring further results.", query);
+
+ mysql_free_result (res);
+
+ return (0);
+} /* mysql_read_master_stats */
+
+static int mysql_read_slave_stats (mysql_database_t *db, MYSQL *con)
+{
+ MYSQL_RES *res;
+ MYSQL_ROW row;
+
+ char *query;
+ int field_num;
+
+ /* WTF? libmysqlclient does not seem to provide any means to
+ * translate a column name to a column index ... :-/ */
+ const int READ_MASTER_LOG_POS_IDX = 6;
+ const int SLAVE_IO_RUNNING_IDX = 10;
+ const int SLAVE_SQL_RUNNING_IDX = 11;
+ const int EXEC_MASTER_LOG_POS_IDX = 21;
+ const int SECONDS_BEHIND_MASTER_IDX = 32;
+
+ query = "SHOW SLAVE STATUS";
+
+ res = exec_query (con, query);
+ if (res == NULL)
+ return (-1);
+
+ row = mysql_fetch_row (res);
+ if (row == NULL)
+ {
+ ERROR ("mysql plugin: Failed to get slave statistics: "
+ "`%s' did not return any rows.", query);
+ return (-1);
+ }
+
+ field_num = mysql_num_fields (res);
+ if (field_num < 33)
+ {
+ ERROR ("mysql plugin: Failed to get slave statistics: "
+ "`%s' returned less than 33 columns.", query);
+ return (-1);
+ }
+
+ if (db->slave_stats)
+ {
+ unsigned long long counter;
+ double gauge;
+
+ counter = atoll (row[READ_MASTER_LOG_POS_IDX]);
+ counter_submit ("mysql_log_position", "slave-read", counter, db);
+
+ counter = atoll (row[EXEC_MASTER_LOG_POS_IDX]);
+ counter_submit ("mysql_log_position", "slave-exec", counter, db);
+
+ if (row[SECONDS_BEHIND_MASTER_IDX] != NULL)
+ {
+ gauge = atof (row[SECONDS_BEHIND_MASTER_IDX]);
+ gauge_submit ("time_offset", NULL, gauge, db);
+ }
+ }
+
+ if (db->slave_notif)
+ {
+ notification_t n = { 0, time (NULL), "", "",
+ "mysql", "", "time_offset", "", NULL };
+
+ char *io, *sql;
+
+ io = row[SLAVE_IO_RUNNING_IDX];
+ sql = row[SLAVE_SQL_RUNNING_IDX];
+
+ set_host (db, n.host, sizeof (n.host));
+ set_plugin_instance (db,
+ n.plugin_instance, sizeof (n.plugin_instance));
+
+ if (((io == NULL) || (strcasecmp (io, "yes") != 0))
+ && (db->slave_io_running))
+ {
+ n.severity = NOTIF_WARNING;
+ ssnprintf (n.message, sizeof (n.message),
+ "slave I/O thread not started or not connected to master");
+ plugin_dispatch_notification (&n);
+ db->slave_io_running = 0;
+ }
+ else if (((io != NULL) && (strcasecmp (io, "yes") == 0))
+ && (! db->slave_io_running))
+ {
+ n.severity = NOTIF_OKAY;
+ ssnprintf (n.message, sizeof (n.message),
+ "slave I/O thread started and connected to master");
+ plugin_dispatch_notification (&n);
+ db->slave_io_running = 1;
+ }
+
+ if (((sql == NULL) || (strcasecmp (sql, "yes") != 0))
+ && (db->slave_sql_running))
+ {
+ n.severity = NOTIF_WARNING;
+ ssnprintf (n.message, sizeof (n.message),
+ "slave SQL thread not started");
+ plugin_dispatch_notification (&n);
+ db->slave_sql_running = 0;
+ }
+ else if (((sql != NULL) && (strcasecmp (sql, "yes") == 0))
+ && (! db->slave_sql_running))
+ {
+ n.severity = NOTIF_OKAY;
+ ssnprintf (n.message, sizeof (n.message),
+ "slave SQL thread started");
+ plugin_dispatch_notification (&n);
+ db->slave_sql_running = 0;
+ }
+ }
+
+ row = mysql_fetch_row (res);
+ if (row != NULL)
+ WARNING ("mysql plugin: `%s' returned more than one row - "
+ "ignoring further results.", query);
+
+ mysql_free_result (res);
+
+ return (0);
+} /* mysql_read_slave_stats */
+
+static int mysql_read (user_data_t *ud)
+{
+ mysql_database_t *db;
MYSQL *con;
MYSQL_RES *res;
MYSQL_ROW row;
char *query;
- int query_len;
int field_num;
unsigned long long qcache_hits = 0ULL;
unsigned long long traffic_incoming = 0ULL;
unsigned long long traffic_outgoing = 0ULL;
+ if ((ud == NULL) || (ud->data == NULL))
+ {
+ ERROR ("mysql plugin: mysql_database_read: Invalid user data.");
+ return (-1);
+ }
+
+ db = (mysql_database_t *) ud->data;
+
/* An error message will have been printed in this case */
- if ((con = getconnection ()) == NULL)
+ if ((con = getconnection (db)) == NULL)
return (-1);
query = "SHOW STATUS";
if (mysql_get_server_version (con) >= 50002)
query = "SHOW GLOBAL STATUS";
- query_len = strlen (query);
-
- if (mysql_real_query (con, query, query_len))
- {
- ERROR ("mysql_real_query failed: %s\n",
- mysql_error (con));
- return (-1);
- }
-
- if ((res = mysql_store_result (con)) == NULL)
- {
- ERROR ("mysql_store_result failed: %s\n",
- mysql_error (con));
+ res = exec_query (con, query);
+ if (res == NULL)
return (-1);
- }
field_num = mysql_num_fields (res);
while ((row = mysql_fetch_row (res)))
/* Ignore `prepared statements' */
if (strncmp (key, "Com_stmt_", 9) != 0)
- counter_submit ("mysql_commands", key + 4, val);
+ counter_submit ("mysql_commands", key + 4, val, db);
}
else if (strncmp (key, "Handler_", 8) == 0)
{
if (val == 0ULL)
continue;
- counter_submit ("mysql_handler", key + 8, val);
+ counter_submit ("mysql_handler", key + 8, val, db);
}
else if (strncmp (key, "Qcache_", 7) == 0)
{
|| (qcache_not_cached != 0ULL)
|| (qcache_lowmem_prunes != 0ULL))
qcache_submit (qcache_hits, qcache_inserts, qcache_not_cached,
- qcache_lowmem_prunes, qcache_queries_in_cache);
+ qcache_lowmem_prunes, qcache_queries_in_cache, db);
if (threads_created != 0ULL)
threads_submit (threads_running, threads_connected,
- threads_cached, threads_created);
+ threads_cached, threads_created, db);
+
+ traffic_submit (traffic_incoming, traffic_outgoing, db);
- traffic_submit (traffic_incoming, traffic_outgoing);
+ if (db->master_stats)
+ mysql_read_master_stats (db, con);
- /* mysql_close (con); */
+ if ((db->slave_stats) || (db->slave_notif))
+ mysql_read_slave_stats (db, con);
return (0);
} /* int mysql_read */
void module_register (void)
{
- plugin_register_config ("mysql", config, config_keys, config_keys_num);
- plugin_register_read ("mysql", mysql_read);
+ plugin_register_complex_config ("mysql", mysql_config);
} /* void module_register */
/**
* collectd - src/network.c
- * Copyright (C) 2005-2008 Florian octo Forster
+ * Copyright (C) 2005-2009 Florian octo Forster
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
# include <poll.h>
#endif
+#if HAVE_GCRYPT_H
+# include <gcrypt.h>
+#endif
+
/* 1500 - 40 - 8 = Ethernet packet - IPv6 header - UDP header */
/* #define BUFF_SIZE 1452 */
# endif
#endif /* !IP_ADD_MEMBERSHIP */
+/* Buffer size to allocate. */
#define BUFF_SIZE 1024
/*
+ * Maximum size required for encryption / signing:
+ * Type/length: 4
+ * Hash/orig length: 32
+ * Padding (up to): 16
+ * --------------------
+ * 52
+ */
+#define BUFF_SIG_SIZE 52
+
+/*
* Private data types
*/
typedef struct sockent
int fd;
struct sockaddr_storage *addr;
socklen_t addrlen;
+
+#define SECURITY_LEVEL_NONE 0
+#if HAVE_GCRYPT_H
+# define SECURITY_LEVEL_SIGN 1
+# define SECURITY_LEVEL_ENCRYPT 2
+ int security_level;
+ char *shared_secret;
+ gcry_cipher_hd_t cypher;
+#endif /* HAVE_GCRYPT_H */
+
struct sockent *next;
} sockent_t;
};
typedef struct part_values_s part_values_t;
+struct part_signature_sha256_s
+{
+ part_header_t head;
+ char hash[32];
+};
+typedef struct part_signature_sha256_s part_signature_sha256_t;
+
+struct part_encryption_aes256_s
+{
+ part_header_t head;
+ uint16_t orig_length;
+ uint16_t random;
+ char hash[28];
+};
+typedef struct part_encryption_aes256_s part_encryption_aes256_t;
+
struct receive_list_entry_s
{
char data[BUFF_SIZE];
int data_len;
+ int fd;
struct receive_list_entry_s *next;
};
typedef struct receive_list_entry_s receive_list_entry_t;
/*
* Private variables
*/
-static const char *config_keys[] =
-{
- "CacheFlush",
- "Listen",
- "Server",
- "TimeToLive",
- "Forward"
-};
-static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
-
static int network_config_ttl = 0;
static int network_config_forward = 0;
static pthread_mutex_t receive_list_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t receive_list_cond = PTHREAD_COND_INITIALIZER;
-static struct pollfd *listen_sockets = NULL;
-static int listen_sockets_num = 0;
-
-static int listen_loop = 0;
-static pthread_t receive_thread_id = 0;
-static pthread_t dispatch_thread_id = 0;
-
-static char send_buffer[BUFF_SIZE];
-static char *send_buffer_ptr;
-static int send_buffer_fill;
-static value_list_t send_buffer_vl = VALUE_LIST_STATIC;
-static pthread_mutex_t send_buffer_lock = PTHREAD_MUTEX_INITIALIZER;
-
-static c_avl_tree_t *cache_tree = NULL;
+static sockent_t *listen_sockets = NULL;
+static struct pollfd *listen_sockets_pollfd = NULL;
+static int listen_sockets_num = 0;
+
+/* The receive and dispatch threads will run as long as `listen_loop' is set to
+ * zero. */
+static int listen_loop = 0;
+static int receive_thread_running = 0;
+static pthread_t receive_thread_id;
+static int dispatch_thread_running = 0;
+static pthread_t dispatch_thread_id;
+
+/* Buffer in which to-be-sent network packets are constructed. */
+static char send_buffer[BUFF_SIZE];
+static char *send_buffer_ptr;
+static int send_buffer_fill;
+static value_list_t send_buffer_vl = VALUE_LIST_STATIC;
+static pthread_mutex_t send_buffer_lock = PTHREAD_MUTEX_INITIALIZER;
+
+/* In this cache we store all the values we received, so we can send out only
+ * those values which were *not* received via the network plugin, too. This is
+ * used for the `Forward false' option. */
+static c_avl_tree_t *cache_tree = NULL;
static pthread_mutex_t cache_lock = PTHREAD_MUTEX_INITIALIZER;
static time_t cache_flush_last = 0;
static int cache_flush_interval = 1800;
pthread_mutex_unlock (&cache_lock);
- DEBUG ("network plugin: cache_check: key = %s; time = %i; retval = %i",
- key, (int) vl->time, retval);
-
return (retval);
} /* int cache_check */
return (0);
} /* int parse_part_string */
-static int parse_packet (void *buffer, int buffer_len)
+#if HAVE_GCRYPT_H
+static int parse_part_sign_sha256 (sockent_t *se, /* {{{ */
+ void **ret_buffer, int *ret_buffer_len)
+{
+ char *buffer = *ret_buffer;
+ size_t buffer_len = (size_t) *ret_buffer_len;
+
+ part_signature_sha256_t ps_received;
+ part_signature_sha256_t ps_expected;
+
+ if (se->shared_secret == NULL)
+ {
+ NOTICE ("network plugin: Received signed network packet but can't verify "
+ "it because no shared secret has been configured. Will accept it.");
+ return (0);
+ }
+
+ if (buffer_len < sizeof (ps_received))
+ return (-ENOMEM);
+
+ memcpy (&ps_received, buffer, sizeof (ps_received));
+
+ memset (&ps_expected, 0, sizeof (ps_expected));
+ ps_expected.head.type = htons (TYPE_SIGN_SHA256);
+ ps_expected.head.length = htons (sizeof (ps_expected));
+ sstrncpy (ps_expected.hash, se->shared_secret, sizeof (ps_expected.hash));
+ memcpy (buffer, &ps_expected, sizeof (ps_expected));
+
+ gcry_md_hash_buffer (GCRY_MD_SHA256, ps_expected.hash, buffer, buffer_len);
+
+ *ret_buffer += sizeof (ps_received);
+
+ if (memcmp (ps_received.hash, ps_expected.hash,
+ sizeof (ps_received.hash)) == 0)
+ return (0);
+ else /* hashes do not match. */
+ return (1);
+} /* }}} int parse_part_sign_sha256 */
+/* #endif HAVE_GCRYPT_H */
+
+#else /* if !HAVE_GCRYPT_H */
+static int parse_part_sign_sha256 (sockent_t *se, /* {{{ */
+ void **ret_buffer, int *ret_buffer_len)
+{
+ INFO ("network plugin: Received signed packet, but the network "
+ "plugin was not linked with libgcrypt, so I cannot "
+ "verify the signature. The packet will be accepted.");
+ return (0);
+} /* }}} int parse_part_sign_sha256 */
+#endif /* !HAVE_GCRYPT_H */
+
+#if HAVE_GCRYPT_H
+static int parse_part_encr_aes256 (sockent_t *se, /* {{{ */
+ void **ret_buffer, int *ret_buffer_len)
+{
+ char *buffer = *ret_buffer;
+ int buffer_len = *ret_buffer_len;
+ int orig_buffer_len;
+ part_encryption_aes256_t pea;
+ char hash[28];
+ gcry_error_t err;
+
+ if (se->cypher == NULL)
+ {
+ NOTICE ("network plugin: Unable to decrypt packet, because no cypher "
+ "instance is present.");
+ return (-1);
+ }
+
+ /* Decrypt the packet in-place */
+ err = gcry_cipher_decrypt (se->cypher,
+ buffer + sizeof (pea.head), buffer_len - sizeof (pea.head),
+ /* in = */ NULL, /* in len = */ 0);
+ gcry_cipher_reset (se->cypher);
+ if (err != 0)
+ {
+ ERROR ("network plugin: gcry_cipher_decrypt returned: %s",
+ gcry_strerror (err));
+ return (-1);
+ }
+
+ /* Copy the header information to `pea' */
+ memcpy (&pea, buffer, sizeof (pea));
+ buffer += sizeof (pea);
+ buffer_len -= sizeof (pea);
+
+ /* Check sanity of the original length */
+ orig_buffer_len = ntohs (pea.orig_length);
+ if (orig_buffer_len > buffer_len)
+ {
+ ERROR ("network plugin: Decryption failed: Invalid original length.");
+ return (-1);
+ }
+
+ /* Check hash sum */
+ memset (hash, 0, sizeof (hash));
+ gcry_md_hash_buffer (GCRY_MD_SHA224, hash, buffer, orig_buffer_len);
+
+ if (memcmp (hash, pea.hash, sizeof (hash)) != 0)
+ {
+ ERROR ("network plugin: Decryption failed: Checksum mismatch.");
+ return (-1);
+ }
+
+ /* Update return values */
+ *ret_buffer = buffer;
+ *ret_buffer_len = orig_buffer_len;
+
+ return (0);
+} /* }}} int parse_part_encr_aes256 */
+/* #endif HAVE_GCRYPT_H */
+
+#else /* if !HAVE_GCRYPT_H */
+static int parse_part_encr_aes256 (sockent_t *se, /* {{{ */
+ void **ret_buffer, int *ret_buffer_len)
+{
+ INFO ("network plugin: Received encrypted packet, but the network "
+ "plugin was not linked with libgcrypt, so I cannot "
+ "decrypt it. The packet will be discarded.");
+ return (-1);
+} /* }}} int parse_part_encr_aes256 */
+#endif /* !HAVE_GCRYPT_H */
+
+static int parse_packet (receive_list_entry_t *rle) /* {{{ */
{
int status;
+ void *buffer;
+ int buffer_len;
+ sockent_t *se;
+
value_list_t vl = VALUE_LIST_INIT;
notification_t n;
- DEBUG ("network plugin: parse_packet: buffer = %p; buffer_len = %i;",
- buffer, buffer_len);
+ int packet_was_encrypted = 0;
+ int packet_was_signed = 0;
+#if HAVE_GCRYPT_H
+ int printed_ignore_warning = 0;
+#endif /* HAVE_GCRYPT_H */
+
+ buffer = rle->data;
+ buffer_len = rle->data_len;
+
+ /* Look for the correct `sockent_t' */
+ se = listen_sockets;
+ while ((se != NULL) && (se->fd != rle->fd))
+ se = se->next;
+
+ if (se == NULL)
+ {
+ ERROR ("network plugin: Got packet from FD %i, but can't "
+ "find an appropriate socket entry.",
+ rle->fd);
+ return (-1);
+ }
memset (&vl, '\0', sizeof (vl));
memset (&n, '\0', sizeof (n));
if (pkg_length < (2 * sizeof (uint16_t)))
break;
- if (pkg_type == TYPE_VALUES)
+ if (pkg_type == TYPE_ENCR_AES256)
+ {
+ status = parse_part_encr_aes256 (se, &buffer, &buffer_len);
+ if (status != 0)
+ {
+ ERROR ("network plugin: Decrypting AES256 "
+ "part failed "
+ "with status %i.", status);
+ break;
+ }
+ else
+ {
+ packet_was_encrypted = 1;
+ }
+ }
+#if HAVE_GCRYPT_H
+ else if ((se->security_level == SECURITY_LEVEL_ENCRYPT)
+ && (packet_was_encrypted == 0))
+ {
+ if (printed_ignore_warning == 0)
+ {
+ INFO ("network plugin: Unencrypted packet or "
+ "part has been ignored.");
+ printed_ignore_warning = 1;
+ }
+ buffer = ((char *) buffer) + pkg_length;
+ continue;
+ }
+#endif /* HAVE_GCRYPT_H */
+ else if (pkg_type == TYPE_SIGN_SHA256)
+ {
+ status = parse_part_sign_sha256 (se, &buffer, &buffer_len);
+ if (status < 0)
+ {
+ ERROR ("network plugin: Verifying SHA-256 "
+ "signature failed "
+ "with status %i.", status);
+ break;
+ }
+ else if (status > 0)
+ {
+ ERROR ("network plugin: Ignoring packet with "
+ "invalid SHA-256 signature.");
+ break;
+ }
+ else
+ {
+ packet_was_signed = 1;
+ }
+ }
+#if HAVE_GCRYPT_H
+ else if ((se->security_level == SECURITY_LEVEL_SIGN)
+ && (packet_was_encrypted == 0)
+ && (packet_was_signed == 0))
+ {
+ if (printed_ignore_warning == 0)
+ {
+ INFO ("network plugin: Unsigned packet or "
+ "part has been ignored.");
+ printed_ignore_warning = 1;
+ }
+ buffer = ((char *) buffer) + pkg_length;
+ continue;
+ }
+#endif /* HAVE_GCRYPT_H */
+ else if (pkg_type == TYPE_VALUES)
{
status = parse_part_values (&buffer, &buffer_len,
&vl.values, &vl.values_len);
} /* while (buffer_len > sizeof (part_header_t)) */
return (status);
-} /* int parse_packet */
+} /* }}} int parse_packet */
-static void free_sockent (sockent_t *se)
+static void free_sockent (sockent_t *se) /* {{{ */
{
sockent_t *next;
while (se != NULL)
{
next = se->next;
+
+#if HAVE_GCRYPT_H
+ if (se->cypher != NULL)
+ {
+ gcry_cipher_close (se->cypher);
+ se->cypher = NULL;
+ }
+ free (se->shared_secret);
+#endif /* HAVE_GCRYPT_H */
+
free (se->addr);
free (se);
+
se = next;
}
-} /* void free_sockent */
+} /* }}} void free_sockent */
/*
* int network_set_ttl
return (0);
} /* int network_set_ttl */
+#if HAVE_GCRYPT_H
+static int network_set_encryption (sockent_t *se, /* {{{ */
+ const char *shared_secret)
+{
+ char hash[32];
+ gcry_error_t err;
+
+ se->shared_secret = sstrdup (shared_secret);
+
+ /*
+ * We use CBC *without* an initialization vector: The cipher is reset after
+ * each packet and we would have to re-set the IV each time. The first
+ * encrypted block will contain the SHA-224 checksum anyway, so this should
+ * be quite unpredictable. Also, there's a 2 byte field in the header that's
+ * being filled with random numbers. So we only use CBC so the blocks
+ * *within* one packet are chained.
+ */
+ err = gcry_cipher_open (&se->cypher,
+ GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC, /* flags = */ 0);
+ if (err != 0)
+ {
+ ERROR ("network plugin: gcry_cipher_open returned: %s",
+ gcry_strerror (err));
+ return (-1);
+ }
+
+ assert (se->shared_secret != NULL);
+ gcry_md_hash_buffer (GCRY_MD_SHA256, hash,
+ se->shared_secret, strlen (se->shared_secret));
+
+ err = gcry_cipher_setkey (se->cypher, hash, sizeof (hash));
+ if (err != 0)
+ {
+ DEBUG ("network plugin: gcry_cipher_setkey returned: %s",
+ gcry_strerror (err));
+ gcry_cipher_close (se->cypher);
+ se->cypher = NULL;
+ return (-1);
+ }
+
+ return (0);
+} /* }}} int network_set_encryption */
+#endif /* HAVE_GCRYPT_H */
+
static int network_bind_socket (const sockent_t *se, const struct addrinfo *ai)
{
int loop = 0;
return (0);
} /* int network_bind_socket */
-static sockent_t *network_create_socket (const char *node,
+#define CREATE_SOCKET_FLAGS_LISTEN 0x0001
+static sockent_t *network_create_socket (const char *node, /* {{{ */
const char *service,
- int listen)
+ const char *shared_secret,
+ int security_level,
+ int flags)
{
struct addrinfo ai_hints;
struct addrinfo *ai_list, *ai_ptr;
for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next)
{
sockent_t *se;
+ int status;
if ((se = (sockent_t *) malloc (sizeof (sockent_t))) == NULL)
{
continue;
}
- if (listen != 0)
+ if ((flags & CREATE_SOCKET_FLAGS_LISTEN) != 0)
{
- if (network_bind_socket (se, ai_ptr) != 0)
+ status = network_bind_socket (se, ai_ptr);
+ if (status != 0)
{
close (se->fd);
free (se->addr);
continue;
}
}
- else /* listen == 0 */
+ else /* sending socket */
{
network_set_ttl (se, ai_ptr);
}
+#if HAVE_GCRYPT_H
+ se->security_level = security_level;
+ se->shared_secret = NULL;
+ se->cypher = NULL;
+ if (shared_secret != NULL)
+ {
+ status = network_set_encryption (se, shared_secret);
+ if ((status != 0) && (security_level <= SECURITY_LEVEL_SIGN))
+ {
+ WARNING ("network plugin: Starting cryptograp"
+ "hic subsystem failed. Since "
+ "security level `Sign' or "
+ "`None' is configured I will "
+ "continue.");
+ }
+ else if (status != 0)
+ {
+ ERROR ("network plugin: Starting cryptograp"
+ "hic subsystem failed. "
+ "Because the security level "
+ "is set to `Encrypt' I will "
+ "not continue!");
+ close (se->fd);
+ free (se->addr);
+ free (se);
+ continue;
+ }
+ } /* if (shared_secret != NULL) */
+#else
+ /* Make compiler happy */
+ security_level = 0;
+ shared_secret = NULL;
+#endif /* HAVE_GCRYPT_H */
+
if (se_tail == NULL)
{
se_head = se;
}
/* We don't open more than one write-socket per node/service pair.. */
- if (listen == 0)
+ if ((flags & CREATE_SOCKET_FLAGS_LISTEN) == 0)
break;
}
freeaddrinfo (ai_list);
return (se_head);
-} /* sockent_t *network_create_socket */
+} /* }}} sockent_t *network_create_socket */
-static sockent_t *network_create_default_socket (int listen)
+static sockent_t *network_create_default_socket (int flags) /* {{{ */
{
sockent_t *se_ptr = NULL;
sockent_t *se_head = NULL;
sockent_t *se_tail = NULL;
- se_ptr = network_create_socket (NET_DEFAULT_V6_ADDR,
- NET_DEFAULT_PORT, listen);
+ se_ptr = network_create_socket (NET_DEFAULT_V6_ADDR, NET_DEFAULT_PORT,
+ /* shared secret = */ NULL, SECURITY_LEVEL_NONE,
+ flags);
/* Don't send to the same machine in IPv6 and IPv4 if both are available. */
- if ((listen == 0) && (se_ptr != NULL))
+ if (((flags & CREATE_SOCKET_FLAGS_LISTEN) == 0) && (se_ptr != NULL))
return (se_ptr);
if (se_ptr != NULL)
se_tail = se_tail->next;
}
- se_ptr = network_create_socket (NET_DEFAULT_V4_ADDR, NET_DEFAULT_PORT, listen);
+ se_ptr = network_create_socket (NET_DEFAULT_V4_ADDR, NET_DEFAULT_PORT,
+ /* shared secret = */ NULL, SECURITY_LEVEL_NONE,
+ flags);
if (se_tail == NULL)
return (se_ptr);
se_tail->next = se_ptr;
return (se_head);
-} /* sockent_t *network_create_default_socket */
+} /* }}} sockent_t *network_create_default_socket */
-static int network_add_listen_socket (const char *node, const char *service)
+static int network_add_listen_socket (const char *node, /* {{{ */
+ const char *service, const char *shared_secret, int security_level)
{
sockent_t *se;
sockent_t *se_ptr;
int se_num = 0;
+ int flags;
+
+ flags = CREATE_SOCKET_FLAGS_LISTEN;
+
if (service == NULL)
service = NET_DEFAULT_PORT;
if (node == NULL)
- se = network_create_default_socket (1 /* listen == true */);
+ se = network_create_default_socket (flags);
else
- se = network_create_socket (node, service, 1 /* listen == true */);
+ se = network_create_socket (node, service,
+ shared_secret, security_level, flags);
if (se == NULL)
return (-1);
for (se_ptr = se; se_ptr != NULL; se_ptr = se_ptr->next)
se_num++;
- listen_sockets = (struct pollfd *) realloc (listen_sockets,
+ listen_sockets_pollfd = realloc (listen_sockets_pollfd,
(listen_sockets_num + se_num)
* sizeof (struct pollfd));
for (se_ptr = se; se_ptr != NULL; se_ptr = se_ptr->next)
{
- listen_sockets[listen_sockets_num].fd = se_ptr->fd;
- listen_sockets[listen_sockets_num].events = POLLIN | POLLPRI;
- listen_sockets[listen_sockets_num].revents = 0;
+ listen_sockets_pollfd[listen_sockets_num].fd = se_ptr->fd;
+ listen_sockets_pollfd[listen_sockets_num].events = POLLIN | POLLPRI;
+ listen_sockets_pollfd[listen_sockets_num].revents = 0;
listen_sockets_num++;
} /* for (se) */
- free_sockent (se);
+ se_ptr = listen_sockets;
+ while ((se_ptr != NULL) && (se_ptr->next != NULL))
+ se_ptr = se_ptr->next;
+
+ if (se_ptr == NULL)
+ listen_sockets = se;
+ else
+ se_ptr->next = se;
+
return (0);
-} /* int network_add_listen_socket */
+} /* }}} int network_add_listen_socket */
-static int network_add_sending_socket (const char *node, const char *service)
+static int network_add_sending_socket (const char *node, /* {{{ */
+ const char *service, const char *shared_secret, int security_level)
{
sockent_t *se;
sockent_t *se_ptr;
service = NET_DEFAULT_PORT;
if (node == NULL)
- se = network_create_default_socket (0 /* listen == false */);
+ se = network_create_default_socket (/* flags = */ 0);
else
- se = network_create_socket (node, service, 0 /* listen == false */);
+ se = network_create_socket (node, service,
+ shared_secret, security_level,
+ /* flags = */ 0);
if (se == NULL)
return (-1);
se_ptr->next = se;
return (0);
-} /* int network_get_listen_socket */
+} /* }}} int network_add_sending_socket */
static void *dispatch_thread (void __attribute__((unused)) *arg)
{
if (ent == NULL)
break;
- parse_packet (ent->data, ent->data_len);
+ parse_packet (ent);
sfree (ent);
} /* while (42) */
return (NULL);
-} /* void *receive_thread */
+} /* void *dispatch_thread */
static int network_receive (void)
{
receive_list_entry_t *private_list_tail;
if (listen_sockets_num == 0)
- network_add_listen_socket (NULL, NULL);
+ network_add_listen_socket (/* node = */ NULL,
+ /* service = */ NULL,
+ /* shared secret = */ NULL,
+ /* encryption = */ 0);
if (listen_sockets_num == 0)
{
while (listen_loop == 0)
{
- status = poll (listen_sockets, listen_sockets_num, -1);
+ status = poll (listen_sockets_pollfd, listen_sockets_num, -1);
if (status <= 0)
{
{
receive_list_entry_t *ent;
- if ((listen_sockets[i].revents & (POLLIN | POLLPRI)) == 0)
+ if ((listen_sockets_pollfd[i].revents
+ & (POLLIN | POLLPRI)) == 0)
continue;
status--;
- buffer_len = recv (listen_sockets[i].fd,
+ buffer_len = recv (listen_sockets_pollfd[i].fd,
buffer, sizeof (buffer),
0 /* no flags */);
if (buffer_len < 0)
return (-1);
}
+ /* TODO: Possible performance enhancement: Do not free
+ * these entries in the dispatch thread but put them in
+ * another list, so we don't have to allocate more and
+ * more of these structures. */
ent = malloc (sizeof (receive_list_entry_t));
if (ent == NULL)
{
return (-1);
}
memset (ent, 0, sizeof (receive_list_entry_t));
+ ent->fd = listen_sockets_pollfd[i].fd;
ent->next = NULL;
/* Hopefully this be optimized out by the compiler. It
pthread_cond_signal (&receive_list_cond);
pthread_mutex_unlock (&receive_list_lock);
}
- } /* for (listen_sockets) */
+ } /* for (listen_sockets_pollfd) */
} /* while (listen_loop == 0) */
/* Make sure everything is dispatched before exiting. */
}
return (0);
-}
+} /* int network_receive */
static void *receive_thread (void __attribute__((unused)) *arg)
{
return (network_receive () ? (void *) 1 : (void *) 0);
} /* void *receive_thread */
-static void network_send_buffer (const char *buffer, int buffer_len)
+static void network_init_buffer (void)
{
- sockent_t *se;
- int status;
+ memset (send_buffer, 0, sizeof (send_buffer));
+ send_buffer_ptr = send_buffer;
+ send_buffer_fill = 0;
- DEBUG ("network plugin: network_send_buffer: buffer_len = %i", buffer_len);
+ memset (&send_buffer_vl, 0, sizeof (send_buffer_vl));
+} /* int network_init_buffer */
- for (se = sending_sockets; se != NULL; se = se->next)
+static void networt_send_buffer_plain (const sockent_t *se, /* {{{ */
+ const char *buffer, size_t buffer_size)
+{
+ int status;
+
+ while (42)
{
- while (42)
+ status = sendto (se->fd, buffer, buffer_size, 0 /* no flags */,
+ (struct sockaddr *) se->addr, se->addrlen);
+ if (status < 0)
{
- status = sendto (se->fd, buffer, buffer_len, 0 /* no flags */,
- (struct sockaddr *) se->addr, se->addrlen);
- if (status < 0)
- {
- char errbuf[1024];
- if (errno == EINTR)
- continue;
- ERROR ("network plugin: sendto failed: %s",
- sstrerror (errno, errbuf,
- sizeof (errbuf)));
- break;
- }
-
+ char errbuf[1024];
+ if (errno == EINTR)
+ continue;
+ ERROR ("network plugin: sendto failed: %s",
+ sstrerror (errno, errbuf,
+ sizeof (errbuf)));
break;
- } /* while (42) */
- } /* for (sending_sockets) */
-} /* void network_send_buffer */
+ }
+
+ break;
+ } /* while (42) */
+} /* }}} void networt_send_buffer_plain */
+
+#if HAVE_GCRYPT_H
+static void networt_send_buffer_signed (const sockent_t *se, /* {{{ */
+ const char *in_buffer, size_t in_buffer_size)
+{
+ part_signature_sha256_t ps;
+ char buffer[sizeof (ps) + in_buffer_size];
+ char hash[sizeof (ps.hash)];
+
+ /* Initialize the `ps' structure. */
+ memset (&ps, 0, sizeof (ps));
+ ps.head.type = htons (TYPE_SIGN_SHA256);
+ ps.head.length = htons ((uint16_t) sizeof (ps));
+ sstrncpy (ps.hash, se->shared_secret, sizeof (ps.hash));
+
+ /* Prepend the signature. */
+ memcpy (buffer, &ps, sizeof (ps));
+ memcpy (buffer + sizeof (ps), in_buffer, in_buffer_size);
+
+ /* Calculate the hash value. */
+ gcry_md_hash_buffer (GCRY_MD_SHA256, hash, buffer, sizeof (buffer));
+
+ /* Copy the hash value into the buffer. */
+ memcpy (ps.hash, hash, sizeof (ps.hash));
+ memcpy (buffer, &ps, sizeof (ps));
+
+ networt_send_buffer_plain (se, buffer, sizeof (buffer));
+} /* }}} void networt_send_buffer_signed */
+
+static void networt_send_buffer_encrypted (const sockent_t *se, /* {{{ */
+ const char *in_buffer, size_t in_buffer_size)
+{
+ part_encryption_aes256_t pea;
+ char buffer[sizeof (pea) + in_buffer_size + 16];
+ size_t buffer_size;
+ gcry_error_t err;
+
+ /* Round to the next multiple of 16, because AES has a block size of 128 bit.
+ * the first four bytes of `pea' are not encrypted and must be subtracted. */
+ buffer_size = (sizeof (pea) + in_buffer_size + 15 - sizeof (pea.head)) / 16;
+ buffer_size = buffer_size * 16;
+ buffer_size += sizeof (pea.head);
+
+ DEBUG ("network plugin: networt_send_buffer_encrypted: "
+ "buffer_size = %zu;", buffer_size);
+
+ /* Initialize the header fields */
+ memset (&pea, 0, sizeof (pea));
+ pea.head.type = htons (TYPE_ENCR_AES256);
+ pea.head.length = htons ((uint16_t) buffer_size);
+ pea.orig_length = htons ((uint16_t) in_buffer_size);
+
+ /* Fill the extra field with random values. Some entropy in the encrypted
+ * data is usually not a bad thing, I hope. */
+ gcry_randomize (&pea.random, sizeof (pea.random), GCRY_STRONG_RANDOM);
+
+ /* Create hash of the payload */
+ gcry_md_hash_buffer (GCRY_MD_SHA224, pea.hash, in_buffer, in_buffer_size);
+
+ /* Initialize the buffer */
+ memset (buffer, 0, sizeof (buffer));
+ memcpy (buffer, &pea, sizeof (pea));
+ memcpy (buffer + sizeof (pea), in_buffer, in_buffer_size);
+
+ /* Encrypt the buffer in-place */
+ err = gcry_cipher_encrypt (se->cypher,
+ buffer + sizeof (pea.head), buffer_size - sizeof (pea.head),
+ /* in = */ NULL, /* in len = */ 0);
+ gcry_cipher_reset (se->cypher);
+ if (err != 0)
+ {
+ ERROR ("network plugin: gcry_cipher_encrypt returned: %s",
+ gcry_strerror (err));
+ return;
+ }
+
+ /* Send it out without further modifications */
+ networt_send_buffer_plain (se, buffer, buffer_size);
+} /* }}} void networt_send_buffer_encrypted */
+#endif /* HAVE_GCRYPT_H */
+
+static void network_send_buffer (char *buffer, size_t buffer_len) /* {{{ */
+{
+ sockent_t *se;
-static int add_to_buffer (char *buffer, int buffer_size,
+ DEBUG ("network plugin: network_send_buffer: buffer_len = %zu", buffer_len);
+
+ for (se = sending_sockets; se != NULL; se = se->next)
+ {
+#if HAVE_GCRYPT_H
+ if (se->security_level == SECURITY_LEVEL_ENCRYPT)
+ networt_send_buffer_encrypted (se, buffer, buffer_len);
+ else if (se->security_level == SECURITY_LEVEL_SIGN)
+ networt_send_buffer_signed (se, buffer, buffer_len);
+ else /* if (se->security_level == SECURITY_LEVEL_NONE) */
+#endif /* HAVE_GCRYPT_H */
+ networt_send_buffer_plain (se, buffer, buffer_len);
+ } /* for (sending_sockets) */
+} /* }}} void network_send_buffer */
+
+static int add_to_buffer (char *buffer, int buffer_size, /* {{{ */
value_list_t *vl_def,
const data_set_t *ds, const value_list_t *vl)
{
return (-1);
return (buffer - buffer_orig);
-} /* int add_to_buffer */
+} /* }}} int add_to_buffer */
static void flush_buffer (void)
{
DEBUG ("network plugin: flush_buffer: send_buffer_fill = %i",
send_buffer_fill);
- network_send_buffer (send_buffer, send_buffer_fill);
- send_buffer_ptr = send_buffer;
- send_buffer_fill = 0;
- memset (&send_buffer_vl, 0, sizeof (send_buffer_vl));
+ network_send_buffer (send_buffer, (size_t) send_buffer_fill);
+ network_init_buffer ();
}
-static int network_write (const data_set_t *ds, const value_list_t *vl)
+static int network_write (const data_set_t *ds, const value_list_t *vl,
+ user_data_t __attribute__((unused)) *user_data)
{
int status;
pthread_mutex_lock (&send_buffer_lock);
status = add_to_buffer (send_buffer_ptr,
- sizeof (send_buffer) - send_buffer_fill,
+ sizeof (send_buffer) - (send_buffer_fill + BUFF_SIG_SIZE),
&send_buffer_vl,
ds, vl);
if (status >= 0)
flush_buffer ();
status = add_to_buffer (send_buffer_ptr,
- sizeof (send_buffer) - send_buffer_fill,
+ sizeof (send_buffer) - (send_buffer_fill + BUFF_SIG_SIZE),
&send_buffer_vl,
ds, vl);
return ((status < 0) ? -1 : 0);
} /* int network_write */
-static int network_config (const char *key, const char *val)
+static int network_config_set_boolean (const oconfig_item_t *ci, /* {{{ */
+ int *retval)
{
- char *node;
- char *service;
+ if ((ci->values_num != 1)
+ || ((ci->values[0].type != OCONFIG_TYPE_BOOLEAN)
+ && (ci->values[0].type != OCONFIG_TYPE_STRING)))
+ {
+ ERROR ("network plugin: The `%s' config option needs "
+ "exactly one boolean argument.", ci->key);
+ return (-1);
+ }
- char *fields[3];
- int fields_num;
+ if (ci->values[0].type == OCONFIG_TYPE_BOOLEAN)
+ {
+ if (ci->values[0].value.boolean)
+ *retval = 1;
+ else
+ *retval = 0;
+ }
+ else
+ {
+ char *str = ci->values[0].value.string;
+
+ if ((strcasecmp ("true", str) == 0)
+ || (strcasecmp ("yes", str) == 0)
+ || (strcasecmp ("on", str) == 0))
+ *retval = 1;
+ else if ((strcasecmp ("false", str) == 0)
+ || (strcasecmp ("no", str) == 0)
+ || (strcasecmp ("off", str) == 0))
+ *retval = 0;
+ else
+ {
+ ERROR ("network plugin: Cannot parse string value `%s' of the `%s' "
+ "option as boolean value.",
+ str, ci->key);
+ return (-1);
+ }
+ }
- if ((strcasecmp ("Listen", key) == 0)
- || (strcasecmp ("Server", key) == 0))
- {
- char *val_cpy = strdup (val);
- if (val_cpy == NULL)
- return (1);
+ return (0);
+} /* }}} int network_config_set_boolean */
- service = NET_DEFAULT_PORT;
- fields_num = strsplit (val_cpy, fields, 3);
- if ((fields_num != 1)
- && (fields_num != 2))
- {
- sfree (val_cpy);
- return (1);
- }
- else if (fields_num == 2)
- {
- if ((service = strchr (fields[1], '.')) != NULL)
- *service = '\0';
- service = fields[1];
- }
- node = fields[0];
+static int network_config_set_ttl (const oconfig_item_t *ci) /* {{{ */
+{
+ int tmp;
+ if ((ci->values_num != 1)
+ || (ci->values[0].type != OCONFIG_TYPE_NUMBER))
+ {
+ WARNING ("network plugin: The `TimeToLive' config option needs exactly "
+ "one numeric argument.");
+ return (-1);
+ }
- if (strcasecmp ("Listen", key) == 0)
- network_add_listen_socket (node, service);
- else
- network_add_sending_socket (node, service);
+ tmp = (int) ci->values[0].value.number;
+ if ((tmp > 0) && (tmp <= 255))
+ network_config_ttl = tmp;
- sfree (val_cpy);
- }
- else if (strcasecmp ("TimeToLive", key) == 0)
- {
- int tmp = atoi (val);
- if ((tmp > 0) && (tmp < 256))
- network_config_ttl = tmp;
- else
- return (1);
- }
- else if (strcasecmp ("Forward", key) == 0)
- {
- if ((strcasecmp ("true", val) == 0)
- || (strcasecmp ("yes", val) == 0)
- || (strcasecmp ("on", val) == 0))
- network_config_forward = 1;
- else
- network_config_forward = 0;
- }
- else if (strcasecmp ("CacheFlush", key) == 0)
- {
- int tmp = atoi (val);
- if (tmp > 0)
- cache_flush_interval = tmp;
- else return (1);
- }
- else
- {
- return (-1);
- }
- return (0);
-} /* int network_config */
+ return (0);
+} /* }}} int network_config_set_ttl */
+
+#if HAVE_GCRYPT_H
+static int network_config_set_security_level (oconfig_item_t *ci, /* {{{ */
+ int *retval)
+{
+ char *str;
+ if ((ci->values_num != 1)
+ || (ci->values[0].type != OCONFIG_TYPE_STRING))
+ {
+ WARNING ("network plugin: The `SecurityLevel' config option needs exactly "
+ "one string argument.");
+ return (-1);
+ }
+
+ str = ci->values[0].value.string;
+ if (strcasecmp ("Encrypt", str) == 0)
+ *retval = SECURITY_LEVEL_ENCRYPT;
+ else if (strcasecmp ("Sign", str) == 0)
+ *retval = SECURITY_LEVEL_SIGN;
+ else if (strcasecmp ("None", str) == 0)
+ *retval = SECURITY_LEVEL_NONE;
+ else
+ {
+ WARNING ("network plugin: Unknown security level: %s.", str);
+ return (-1);
+ }
+
+ return (0);
+} /* }}} int network_config_set_security_level */
+#endif /* HAVE_GCRYPT_H */
+
+static int network_config_listen_server (const oconfig_item_t *ci) /* {{{ */
+{
+ char *node;
+ char *service;
+ char *shared_secret = NULL;
+ int security_level = SECURITY_LEVEL_NONE;
+ int i;
+
+ if ((ci->values_num < 1) || (ci->values_num > 2)
+ || (ci->values[0].type != OCONFIG_TYPE_STRING)
+ || ((ci->values_num > 1) && (ci->values[1].type != OCONFIG_TYPE_STRING)))
+ {
+ ERROR ("network plugin: The `%s' config option needs "
+ "one or two string arguments.", ci->key);
+ return (-1);
+ }
+
+ node = ci->values[0].value.string;
+ if (ci->values_num >= 2)
+ service = ci->values[1].value.string;
+ else
+ service = NULL;
+
+ for (i = 0; i < ci->children_num; i++)
+ {
+ oconfig_item_t *child = ci->children + i;
+
+#if HAVE_GCRYPT_H
+ if (strcasecmp ("Secret", child->key) == 0)
+ {
+ if ((child->values_num == 1)
+ && (child->values[0].type == OCONFIG_TYPE_STRING))
+ shared_secret = child->values[0].value.string;
+ else
+ ERROR ("network plugin: The `Secret' option needs exactly one string "
+ "argument.");
+ }
+ else if (strcasecmp ("SecurityLevel", child->key) == 0)
+ network_config_set_security_level (child, &security_level);
+ else
+#endif /* HAVE_GCRYPT_H */
+ {
+ WARNING ("network plugin: Option `%s' is not allowed here.",
+ child->key);
+ }
+ }
+
+ if ((security_level > SECURITY_LEVEL_NONE) && (shared_secret == NULL))
+ {
+ ERROR ("network plugin: A security level higher than `none' was "
+ "requested, but no shared key was given. Cowardly refusing to open "
+ "this socket!");
+ return (-1);
+ }
+
+ if (strcasecmp ("Listen", ci->key) == 0)
+ network_add_listen_socket (node, service, shared_secret, security_level);
+ else
+ network_add_sending_socket (node, service, shared_secret, security_level);
+
+ return (0);
+} /* }}} int network_config_listen_server */
+
+static int network_config_set_cache_flush (const oconfig_item_t *ci) /* {{{ */
+{
+ int tmp;
+ if ((ci->values_num != 1)
+ || (ci->values[0].type != OCONFIG_TYPE_NUMBER))
+ {
+ WARNING ("network plugin: The `CacheFlush' config option needs exactly "
+ "one numeric argument.");
+ return (-1);
+ }
-static int network_notification (const notification_t *n)
+ tmp = (int) ci->values[0].value.number;
+ if (tmp > 0)
+ network_config_ttl = tmp;
+
+ return (0);
+} /* }}} int network_config_set_cache_flush */
+
+static int network_config (oconfig_item_t *ci) /* {{{ */
+{
+ int i;
+
+ for (i = 0; i < ci->children_num; i++)
+ {
+ oconfig_item_t *child = ci->children + i;
+
+ if ((strcasecmp ("Listen", child->key) == 0)
+ || (strcasecmp ("Server", child->key) == 0))
+ network_config_listen_server (child);
+ else if (strcasecmp ("TimeToLive", child->key) == 0)
+ network_config_set_ttl (child);
+ else if (strcasecmp ("Forward", child->key) == 0)
+ network_config_set_boolean (child, &network_config_forward);
+ else if (strcasecmp ("CacheFlush", child->key) == 0)
+ network_config_set_cache_flush (child);
+ else
+ {
+ WARNING ("network plugin: Option `%s' is not allowed here.",
+ child->key);
+ }
+ }
+
+ return (0);
+} /* }}} int network_config */
+
+static int network_notification (const notification_t *n,
+ user_data_t __attribute__((unused)) *user_data)
{
char buffer[BUFF_SIZE];
char *buffer_ptr = buffer;
listen_loop++;
/* Kill the listening thread */
- if (receive_thread_id != (pthread_t) 0)
+ if (receive_thread_running != 0)
{
+ INFO ("network plugin: Stopping receive thread.");
pthread_kill (receive_thread_id, SIGTERM);
pthread_join (receive_thread_id, NULL /* no return value */);
- receive_thread_id = (pthread_t) 0;
+ memset (&receive_thread_id, 0, sizeof (receive_thread_id));
+ receive_thread_running = 0;
}
/* Shutdown the dispatching thread */
- if (dispatch_thread_id != (pthread_t) 0)
+ if (dispatch_thread_running != 0)
+ {
+ INFO ("network plugin: Stopping dispatch thread.");
+ pthread_mutex_lock (&receive_list_lock);
pthread_cond_broadcast (&receive_list_cond);
+ pthread_mutex_unlock (&receive_list_lock);
+ pthread_join (dispatch_thread_id, /* ret = */ NULL);
+ dispatch_thread_running = 0;
+ }
+
+ free_sockent (listen_sockets);
if (send_buffer_fill > 0)
flush_buffer ();
plugin_register_shutdown ("network", network_shutdown);
- send_buffer_ptr = send_buffer;
- send_buffer_fill = 0;
- memset (&send_buffer_vl, 0, sizeof (send_buffer_vl));
+ network_init_buffer ();
cache_tree = c_avl_create ((int (*) (const void *, const void *)) strcmp);
cache_flush_last = time (NULL);
/* setup socket(s) and so on */
if (sending_sockets != NULL)
{
- plugin_register_write ("network", network_write);
- plugin_register_notification ("network", network_notification);
+ plugin_register_write ("network", network_write,
+ /* user_data = */ NULL);
+ plugin_register_notification ("network", network_notification,
+ /* user_data = */ NULL);
}
- if ((listen_sockets_num != 0) && (receive_thread_id == 0))
+ /* If no threads need to be started, return here. */
+ if ((listen_sockets_num == 0)
+ || ((dispatch_thread_running != 0)
+ && (receive_thread_running != 0)))
+ return (0);
+
+ if (dispatch_thread_running == 0)
{
int status;
-
status = pthread_create (&dispatch_thread_id,
NULL /* no attributes */,
dispatch_thread,
sstrerror (errno, errbuf,
sizeof (errbuf)));
}
+ else
+ {
+ dispatch_thread_running = 1;
+ }
+ }
+ if (receive_thread_running == 0)
+ {
+ int status;
status = pthread_create (&receive_thread_id,
NULL /* no attributes */,
receive_thread,
sstrerror (errno, errbuf,
sizeof (errbuf)));
}
+ else
+ {
+ receive_thread_running = 1;
+ }
}
+
return (0);
} /* int network_init */
* there, good. If not, well, then there is nothing to flush.. -octo
*/
static int network_flush (int timeout,
- const char __attribute__((unused)) *identifier)
+ const char __attribute__((unused)) *identifier,
+ user_data_t __attribute__((unused)) *user_data)
{
pthread_mutex_lock (&send_buffer_lock);
void module_register (void)
{
- plugin_register_config ("network", network_config,
- config_keys, config_keys_num);
+ plugin_register_complex_config ("network", network_config);
plugin_register_init ("network", network_init);
- plugin_register_flush ("network", network_flush);
+ plugin_register_flush ("network", network_flush,
+ /* user_data = */ NULL);
} /* void module_register */
+
+/* vim: set fdm=marker : */
#define TYPE_MESSAGE 0x0100
#define TYPE_SEVERITY 0x0101
+#define TYPE_SIGN_SHA256 0x0200
+#define TYPE_ENCR_AES256 0x0210
+
#endif /* NETWORK_H */
return 0;
} /* c_notify_config */
-static int c_notify (const notification_t *n)
+static int c_notify (const notification_t *n,
+ user_data_t __attribute__((unused)) *user_data)
{
NotifyNotification *notification = NULL;
NotifyUrgency urgency = NOTIFY_URGENCY_LOW;
free (spec_version);
}
- plugin_register_notification ("notify_desktop", c_notify);
+ plugin_register_notification ("notify_desktop", c_notify,
+ /* user_data = */ NULL);
plugin_register_shutdown ("notify_desktop", c_notify_shutdown);
return 0;
} /* c_notify_init */
return 0;
} /* int notify_email_config (const char *, const char *) */
-static int notify_email_notification (const notification_t *n)
+static int notify_email_notification (const notification_t *n,
+ user_data_t __attribute__((unused)) *user_data)
{
smtp_recipient_t recipient;
plugin_register_shutdown ("notify_email", notify_email_shutdown);
plugin_register_config ("notify_email", notify_email_config,
config_keys, config_keys_num);
- plugin_register_notification ("notify_email", notify_email_notification);
+ plugin_register_notification ("notify_email", notify_email_notification,
+ /* user_data = */ NULL);
} /* void module_register (void) */
/* vim: set sw=2 sts=2 ts=8 et : */
static int ow_family_features_num = STATIC_ARRAY_SIZE (ow_family_features);
static char *device_g = NULL;
+static int ow_interval = 0;
static const char *config_keys[] =
{
"Device",
"IgnoreSelected",
"Sensor",
+ "Interval"
};
static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
sfree (device_g);
device_g = temp;
}
- else
+ else if (strcasecmp ("Interval", key) == 0)
{
- return (-1);
+ int tmp;
+ tmp = atoi (value);
+ if (tmp > 0)
+ ow_interval = tmp;
+ else
+ ERROR ("onewire plugin: Invalid `Interval' setting: %s", value);
}
-
- return (0);
-}
-
-static int cow_init (void)
-{
- int status;
-
- if (device_g == NULL)
+ else
{
- ERROR ("onewire plugin: cow_init: No device configured.");
return (-1);
}
- status = (int) OW_init (device_g);
- if (status != 0)
- {
- ERROR ("onewire plugin: OW_init(%s) failed: %i.", device_g, status);
- return (1);
- }
-
return (0);
-} /* int cow_init */
+}
static int cow_read_values (const char *path, const char *name,
const ow_family_features_t *family_info)
return (0);
} /* int cow_read_bus */
-static int cow_read (void)
+static int cow_read (user_data_t *ud __attribute__((unused)))
{
return (cow_read_bus ("/"));
} /* int cow_read */
return (0);
} /* int cow_shutdown */
+static int cow_init (void)
+{
+ int status;
+ struct timespec cb_interval;
+
+ if (device_g == NULL)
+ {
+ ERROR ("onewire plugin: cow_init: No device configured.");
+ return (-1);
+ }
+
+ status = (int) OW_init (device_g);
+ if (status != 0)
+ {
+ ERROR ("onewire plugin: OW_init(%s) failed: %i.", device_g, status);
+ return (1);
+ }
+
+ memset (&cb_interval, 0, sizeof (cb_interval));
+ if (ow_interval > 0)
+ cb_interval.tv_sec = (time_t) ow_interval;
+
+ plugin_register_complex_read ("onewire", cow_read,
+ &cb_interval, /* user data = */ NULL);
+ plugin_register_shutdown ("onewire", cow_shutdown);
+
+ return (0);
+} /* int cow_init */
+
void module_register (void)
{
plugin_register_init ("onewire", cow_init);
- plugin_register_read ("onewire", cow_read);
- plugin_register_shutdown ("onewire", cow_shutdown);
plugin_register_config ("onewire", cow_load_config,
config_keys, config_keys_num);
}
dXSARGS;
+ log_warn ("Using plugin_register() to register new data-sets is "
+ "deprecated - add new entries to a custom types.db instead.");
+
if (2 != items) {
log_err ("Usage: Collectd::plugin_register_data_set(type, dataset)");
XSRETURN_EMPTY;
return pplugin_call_all (aTHX_ PLUGIN_READ);
} /* static int perl_read (void) */
-static int perl_write (const data_set_t *ds, const value_list_t *vl)
+static int perl_write (const data_set_t *ds, const value_list_t *vl,
+ user_data_t __attribute__((unused)) *user_data)
{
dTHX;
return pplugin_call_all (aTHX_ PLUGIN_WRITE, ds, vl);
} /* static int perl_write (const data_set_t *, const value_list_t *) */
-static void perl_log (int level, const char *msg)
+static void perl_log (int level, const char *msg,
+ user_data_t __attribute__((unused)) *user_data)
{
dTHX;
return;
} /* static void perl_log (int, const char *) */
-static int perl_notify (const notification_t *notif)
+static int perl_notify (const notification_t *notif,
+ user_data_t __attribute__((unused)) *user_data)
{
dTHX;
return pplugin_call_all (aTHX_ PLUGIN_NOTIF, notif);
} /* static int perl_notify (const notification_t *) */
-static int perl_flush (int timeout, const char *identifier)
+static int perl_flush (int timeout, const char *identifier,
+ user_data_t __attribute__((unused)) *user_data)
{
dTHX;
perl_run (aTHX);
- plugin_register_log ("perl", perl_log);
- plugin_register_notification ("perl", perl_notify);
+ plugin_register_log ("perl", perl_log, /* user_data = */ NULL);
+ plugin_register_notification ("perl", perl_notify,
+ /* user_data = */ NULL);
plugin_register_init ("perl", perl_init);
plugin_register_read ("perl", perl_read);
- plugin_register_write ("perl", perl_write);
- plugin_register_flush ("perl", perl_flush);
+ plugin_register_write ("perl", perl_write, /* user_data = */ NULL);
+ plugin_register_flush ("perl", perl_flush, /* user_data = */ NULL);
plugin_register_shutdown ("perl", perl_shutdown);
return 0;
} /* static int init_pi (const char **, const int) */
/**
* collectd - src/ping.c
- * Copyright (C) 2005,2006 Florian octo Forster
+ * Copyright (C) 2005-2009 Florian octo Forster
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
#include "plugin.h"
#include "configfile.h"
+#include <pthread.h>
#include <netinet/in.h>
-#include "liboping/oping.h"
+#if HAVE_NETDB_H
+# include <netdb.h> /* NI_MAXHOST */
+#endif
+
+#include <oping.h>
+
+#ifndef NI_MAXHOST
+# define NI_MAXHOST 1025
+#endif
/*
* Private data types
*/
struct hostlist_s
{
- char *host;
- int wait_time;
- int wait_left;
- struct hostlist_s *next;
+ char *host;
+
+ uint32_t pkg_sent;
+ uint32_t pkg_recv;
+
+ double latency_total;
+ double latency_squared;
+
+ struct hostlist_s *next;
};
typedef struct hostlist_s hostlist_t;
/*
* Private variables
*/
-static pingobj_t *pingobj = NULL;
-static hostlist_t *hosts = NULL;
+static hostlist_t *hostlist_head = NULL;
+
+static int ping_ttl = PING_DEF_TTL;
+static double ping_interval = 1.0;
+static double ping_timeout = 0.9;
+
+static int ping_thread_loop = 0;
+static int ping_thread_error = 0;
+static pthread_t ping_thread_id;
+static pthread_mutex_t ping_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t ping_cond = PTHREAD_COND_INITIALIZER;
static const char *config_keys[] =
{
- "Host",
- "TTL",
- NULL
+ "Host",
+ "TTL",
+ "Interval",
+ "Timeout"
};
-static int config_keys_num = 2;
+static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
/*
* Private functions
*/
-static void add_hosts (void)
+/* Assure that `ts->tv_nsec' is in the range 0 .. 999999999 */
+static void time_normalize (struct timespec *ts) /* {{{ */
+{
+ while (ts->tv_nsec < 0)
+ {
+ if (ts->tv_sec == 0)
+ {
+ ts->tv_nsec = 0;
+ return;
+ }
+
+ ts->tv_sec -= 1;
+ ts->tv_nsec += 1000000000;
+ }
+
+ while (ts->tv_nsec >= 1000000000)
+ {
+ ts->tv_sec += 1;
+ ts->tv_nsec -= 1000000000;
+ }
+} /* }}} void time_normalize */
+
+/* Add `ts_int' to `tv_begin' and store the result in `ts_dest'. If the result
+ * is larger than `tv_end', copy `tv_end' to `ts_dest' instead. */
+static void time_calc (struct timespec *ts_dest, /* {{{ */
+ const struct timespec *ts_int,
+ const struct timeval *tv_begin,
+ const struct timeval *tv_end)
+{
+ ts_dest->tv_sec = tv_begin->tv_sec + ts_int->tv_sec;
+ ts_dest->tv_nsec = (tv_begin->tv_usec * 1000) + ts_int->tv_nsec;
+ time_normalize (ts_dest);
+
+ /* Assure that `(begin + interval) > end'.
+ * This may seem overly complicated, but `tv_sec' is of type `time_t'
+ * which may be `unsigned. *sigh* */
+ if ((tv_end->tv_sec > ts_dest->tv_sec)
+ || ((tv_end->tv_sec == ts_dest->tv_sec)
+ && ((tv_end->tv_usec * 1000) > ts_dest->tv_nsec)))
+ {
+ ts_dest->tv_sec = tv_end->tv_sec;
+ ts_dest->tv_nsec = 1000 * tv_end->tv_usec;
+ }
+
+ time_normalize (ts_dest);
+} /* }}} void time_calc */
+
+static void *ping_thread (void *arg) /* {{{ */
{
- hostlist_t *hl_this;
- hostlist_t *hl_prev;
-
- hl_this = hosts;
- hl_prev = NULL;
- while (hl_this != NULL)
- {
- DEBUG ("ping plugin: host = %s, wait_left = %i, "
- "wait_time = %i, next = %p",
- hl_this->host, hl_this->wait_left,
- hl_this->wait_time, (void *) hl_this->next);
-
- if (hl_this->wait_left <= 0)
- {
- if (ping_host_add (pingobj, hl_this->host) == 0)
- {
- DEBUG ("ping plugin: Successfully added host %s", hl_this->host);
- /* Remove the host from the linked list */
- if (hl_prev != NULL)
- hl_prev->next = hl_this->next;
- else
- hosts = hl_this->next;
- free (hl_this->host);
- free (hl_this);
- hl_this = (hl_prev != NULL) ? hl_prev : hosts;
- }
- else
- {
- WARNING ("ping plugin: Failed adding host "
- "`%s': %s", hl_this->host,
- ping_get_error (pingobj));
- hl_this->wait_left = hl_this->wait_time;
- hl_this->wait_time *= 2;
- if (hl_this->wait_time > 86400)
- hl_this->wait_time = 86400;
- }
- }
- else
- {
- hl_this->wait_left -= interval_g;
- }
-
- if (hl_this != NULL)
- {
- hl_prev = hl_this;
- hl_this = hl_this->next;
- }
- }
-} /* void add_hosts */
-
-static int ping_init (void)
+ static pingobj_t *pingobj = NULL;
+
+ struct timeval tv_begin;
+ struct timeval tv_end;
+ struct timespec ts_wait;
+ struct timespec ts_int;
+
+ hostlist_t *hl;
+ int status;
+
+ pthread_mutex_lock (&ping_lock);
+
+ pingobj = ping_construct ();
+ if (pingobj == NULL)
+ {
+ ERROR ("ping plugin: ping_construct failed.");
+ ping_thread_error = 1;
+ pthread_mutex_unlock (&ping_lock);
+ return ((void *) -1);
+ }
+
+ ping_setopt (pingobj, PING_OPT_TIMEOUT, (void *) &ping_timeout);
+ ping_setopt (pingobj, PING_OPT_TTL, (void *) &ping_ttl);
+
+ /* Add all the hosts to the ping object. */
+ status = 0;
+ for (hl = hostlist_head; hl != NULL; hl = hl->next)
+ {
+ int tmp_status;
+ tmp_status = ping_host_add (pingobj, hl->host);
+ if (tmp_status != 0)
+ WARNING ("ping plugin: ping_host_add (%s) failed.", hl->host);
+ else
+ status++;
+ }
+
+ if (status == 0)
+ {
+ ERROR ("ping plugin: No host could be added to ping object. Giving up.");
+ ping_thread_error = 1;
+ pthread_mutex_unlock (&ping_lock);
+ return ((void *) -1);
+ }
+
+ /* Set up `ts_int' */
+ {
+ double temp_sec;
+ double temp_nsec;
+
+ temp_nsec = modf (ping_interval, &temp_sec);
+ ts_int.tv_sec = (time_t) temp_sec;
+ ts_int.tv_nsec = (long) (temp_nsec * 1000000000L);
+ }
+
+ while (ping_thread_loop > 0)
+ {
+ pingobj_iter_t *iter;
+ int status;
+
+ if (gettimeofday (&tv_begin, NULL) < 0)
+ {
+ ERROR ("ping plugin: gettimeofday failed");
+ ping_thread_error = 1;
+ break;
+ }
+
+ pthread_mutex_unlock (&ping_lock);
+
+ status = ping_send (pingobj);
+ if (status < 0)
+ {
+ ERROR ("ping plugin: ping_send failed: %s", ping_get_error (pingobj));
+ pthread_mutex_lock (&ping_lock);
+ ping_thread_error = 1;
+ break;
+ }
+
+ pthread_mutex_lock (&ping_lock);
+
+ if (ping_thread_loop <= 0)
+ break;
+
+ for (iter = ping_iterator_get (pingobj);
+ iter != NULL;
+ iter = ping_iterator_next (iter))
+ { /* {{{ */
+ char userhost[NI_MAXHOST];
+ double latency;
+ size_t param_size;
+
+ param_size = sizeof (userhost);
+ status = ping_iterator_get_info (iter,
+#ifdef PING_INFO_USERNAME
+ PING_INFO_USERNAME,
+#else
+ PING_INFO_HOSTNAME,
+#endif
+ userhost, ¶m_size);
+ if (status != 0)
+ {
+ WARNING ("ping plugin: ping_iterator_get_info failed: %s",
+ ping_get_error (pingobj));
+ continue;
+ }
+
+ for (hl = hostlist_head; hl != NULL; hl = hl->next)
+ if (strcmp (userhost, hl->host) == 0)
+ break;
+
+ if (hl == NULL)
+ {
+ WARNING ("ping plugin: Cannot find host %s.", userhost);
+ continue;
+ }
+
+ param_size = sizeof (latency);
+ status = ping_iterator_get_info (iter, PING_INFO_LATENCY,
+ (void *) &latency, ¶m_size);
+ if (status != 0)
+ {
+ WARNING ("ping plugin: ping_iterator_get_info failed: %s",
+ ping_get_error (pingobj));
+ continue;
+ }
+
+ hl->pkg_sent++;
+ if (latency >= 0.0)
+ {
+ hl->pkg_recv++;
+ hl->latency_total += latency;
+ hl->latency_squared += (latency * latency);
+ }
+ } /* }}} for (iter) */
+
+ if (gettimeofday (&tv_end, NULL) < 0)
+ {
+ ERROR ("ping plugin: gettimeofday failed");
+ ping_thread_error = 1;
+ break;
+ }
+
+ /* Calculate the absolute time until which to wait and store it in
+ * `ts_wait'. */
+ time_calc (&ts_wait, &ts_int, &tv_begin, &tv_end);
+
+ status = pthread_cond_timedwait (&ping_cond, &ping_lock, &ts_wait);
+ if (ping_thread_loop <= 0)
+ break;
+ } /* while (ping_thread_loop > 0) */
+
+ pthread_mutex_unlock (&ping_lock);
+ ping_destroy (pingobj);
+
+ return ((void *) 0);
+} /* }}} void *ping_thread */
+
+static int start_thread (void) /* {{{ */
{
- if (pingobj == NULL)
- return (-1);
+ int status;
+
+ pthread_mutex_lock (&ping_lock);
+
+ if (ping_thread_loop != 0)
+ {
+ pthread_mutex_unlock (&ping_lock);
+ return (-1);
+ }
+
+ ping_thread_loop = 1;
+ ping_thread_error = 0;
+ status = pthread_create (&ping_thread_id, /* attr = */ NULL,
+ ping_thread, /* arg = */ (void *) 0);
+ if (status != 0)
+ {
+ ping_thread_loop = 0;
+ ERROR ("ping plugin: Starting thread failed.");
+ pthread_mutex_unlock (&ping_lock);
+ return (-1);
+ }
+
+ pthread_mutex_unlock (&ping_lock);
+ return (0);
+} /* }}} int start_thread */
+
+static int stop_thread (void) /* {{{ */
+{
+ int status;
+
+ pthread_mutex_lock (&ping_lock);
+
+ if (ping_thread_loop == 0)
+ {
+ pthread_mutex_unlock (&ping_lock);
+ return (-1);
+ }
- if (hosts != NULL)
- add_hosts ();
+ ping_thread_loop = 0;
+ pthread_cond_broadcast (&ping_cond);
+ pthread_mutex_unlock (&ping_lock);
- return (0);
-} /* int ping_init */
+ status = pthread_join (ping_thread_id, /* return = */ NULL);
+ if (status != 0)
+ {
+ ERROR ("ping plugin: Stopping thread failed.");
+ status = -1;
+ }
-static int ping_config (const char *key, const char *value)
+ memset (&ping_thread_id, 0, sizeof (ping_thread_id));
+ ping_thread_error = 0;
+
+ return (status);
+} /* }}} int stop_thread */
+
+static int ping_init (void) /* {{{ */
+{
+ if (hostlist_head == NULL)
+ {
+ NOTICE ("ping plugin: No hosts have been configured.");
+ return (-1);
+ }
+
+ if (ping_timeout > ping_interval)
+ {
+ ping_timeout = 0.9 * ping_interval;
+ WARNING ("ping plugin: Timeout is greater than interval. "
+ "Will use a timeout of %gs.", ping_timeout);
+ }
+
+ if (start_thread () != 0)
+ return (-1);
+
+ return (0);
+} /* }}} int ping_init */
+
+static int ping_config (const char *key, const char *value) /* {{{ */
{
- if (pingobj == NULL)
- {
- if ((pingobj = ping_construct ()) == NULL)
- {
- ERROR ("ping plugin: `ping_construct' failed.");
- return (1);
- }
- }
-
- if (strcasecmp (key, "host") == 0)
- {
- hostlist_t *hl;
- char *host;
-
- if ((hl = (hostlist_t *) malloc (sizeof (hostlist_t))) == NULL)
- {
- char errbuf[1024];
- ERROR ("ping plugin: malloc failed: %s",
- sstrerror (errno, errbuf,
- sizeof (errbuf)));
- return (1);
- }
- if ((host = strdup (value)) == NULL)
- {
- char errbuf[1024];
- free (hl);
- ERROR ("ping plugin: strdup failed: %s",
- sstrerror (errno, errbuf,
- sizeof (errbuf)));
- return (1);
- }
-
- hl->host = host;
- hl->wait_time = 2 * interval_g;
- hl->wait_left = 0;
- hl->next = hosts;
- hosts = hl;
- }
- else if (strcasecmp (key, "ttl") == 0)
- {
- int ttl = atoi (value);
- if (ping_setopt (pingobj, PING_OPT_TTL, (void *) &ttl))
- {
- WARNING ("ping: liboping did not accept the TTL value %i", ttl);
- return (1);
- }
- }
- else
- {
- return (-1);
- }
-
- return (0);
-}
-
-static void ping_submit (char *host, double latency)
+ if (strcasecmp (key, "Host") == 0)
+ {
+ hostlist_t *hl;
+ char *host;
+
+ hl = (hostlist_t *) malloc (sizeof (hostlist_t));
+ if (hl == NULL)
+ {
+ char errbuf[1024];
+ ERROR ("ping plugin: malloc failed: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (1);
+ }
+
+ host = strdup (value);
+ if (host == NULL)
+ {
+ char errbuf[1024];
+ sfree (hl);
+ ERROR ("ping plugin: strdup failed: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (1);
+ }
+
+ hl->host = host;
+ hl->pkg_sent = 0;
+ hl->pkg_recv = 0;
+ hl->latency_total = 0.0;
+ hl->latency_squared = 0.0;
+ hl->next = hostlist_head;
+ hostlist_head = hl;
+ }
+ else if (strcasecmp (key, "TTL") == 0)
+ {
+ int ttl = atoi (value);
+ if ((ttl > 0) && (ttl <= 255))
+ ping_ttl = ttl;
+ else
+ WARNING ("ping plugin: Ignoring invalid TTL %i.", ttl);
+ }
+ else if (strcasecmp (key, "Interval") == 0)
+ {
+ double tmp;
+
+ tmp = atof (value);
+ if (tmp > 0.0)
+ ping_interval = tmp;
+ else
+ WARNING ("ping plugin: Ignoring invalid interval %g (%s)",
+ tmp, value);
+ }
+ else if (strcasecmp (key, "Timeout") == 0)
+ {
+ double tmp;
+
+ tmp = atof (value);
+ if (tmp > 0.0)
+ ping_timeout = tmp;
+ else
+ WARNING ("ping plugin: Ignoring invalid timeout %g (%s)",
+ tmp, value);
+ }
+ else
+ {
+ return (-1);
+ }
+
+ return (0);
+} /* }}} int ping_config */
+
+static void submit (const char *host, const char *type, /* {{{ */
+ gauge_t value)
{
- value_t values[1];
- value_list_t vl = VALUE_LIST_INIT;
+ value_t values[1];
+ value_list_t vl = VALUE_LIST_INIT;
- values[0].gauge = latency;
+ values[0].gauge = value;
- vl.values = values;
- vl.values_len = 1;
- sstrncpy (vl.host, hostname_g, sizeof (vl.host));
- sstrncpy (vl.plugin, "ping", sizeof (vl.plugin));
- sstrncpy (vl.plugin_instance, "", sizeof (vl.plugin_instance));
- sstrncpy (vl.type_instance, host, sizeof (vl.type_instance));
- sstrncpy (vl.type, "ping", sizeof (vl.type));
+ vl.values = values;
+ vl.values_len = 1;
+ sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+ sstrncpy (vl.plugin, "ping", sizeof (vl.plugin));
+ sstrncpy (vl.plugin_instance, "", sizeof (vl.plugin_instance));
+ sstrncpy (vl.type_instance, host, sizeof (vl.type_instance));
+ sstrncpy (vl.type, type, sizeof (vl.type));
- plugin_dispatch_values (&vl);
-}
+ plugin_dispatch_values (&vl);
+} /* }}} void ping_submit */
-static int ping_read (void)
+static int ping_read (void) /* {{{ */
{
- pingobj_iter_t *iter;
-
- char host[512];
- double latency;
- size_t buf_len;
- int number_of_hosts;
-
- if (pingobj == NULL)
- return (-1);
-
- if (hosts != NULL)
- add_hosts ();
-
- if (ping_send (pingobj) < 0)
- {
- ERROR ("ping plugin: `ping_send' failed: %s",
- ping_get_error (pingobj));
- return (-1);
- }
-
- number_of_hosts = 0;
- for (iter = ping_iterator_get (pingobj);
- iter != NULL;
- iter = ping_iterator_next (iter))
- {
- buf_len = sizeof (host);
- if (ping_iterator_get_info (iter, PING_INFO_HOSTNAME,
- host, &buf_len))
- {
- WARNING ("ping plugin: ping_iterator_get_info "
- "(PING_INFO_HOSTNAME) failed.");
- continue;
- }
-
- buf_len = sizeof (latency);
- if (ping_iterator_get_info (iter, PING_INFO_LATENCY,
- &latency, &buf_len))
- {
- WARNING ("ping plugin: ping_iterator_get_info (%s, "
- "PING_INFO_LATENCY) failed.", host);
- continue;
- }
-
- DEBUG ("ping plugin: host = %s, latency = %f", host, latency);
- ping_submit (host, latency);
- number_of_hosts++;
- }
-
- if ((number_of_hosts == 0) && (getuid () != 0))
- {
- ERROR ("ping plugin: All hosts failed. Try starting collectd as root.");
- }
-
- return (number_of_hosts == 0 ? -1 : 0);
-} /* int ping_read */
+ hostlist_t *hl;
+
+ if (ping_thread_error != 0)
+ {
+ ERROR ("ping plugin: The ping thread had a problem. Restarting it.");
+
+ stop_thread ();
+
+ for (hl = hostlist_head; hl != NULL; hl = hl->next)
+ {
+ hl->pkg_sent = 0;
+ hl->pkg_recv = 0;
+ hl->latency_total = 0.0;
+ hl->latency_squared = 0.0;
+ }
+
+ start_thread ();
+
+ return (-1);
+ } /* if (ping_thread_error != 0) */
+
+ for (hl = hostlist_head; hl != NULL; hl = hl->next) /* {{{ */
+ {
+ uint32_t pkg_sent;
+ uint32_t pkg_recv;
+ double latency_total;
+ double latency_squared;
+
+ double latency_average;
+ double latency_stddev;
+
+ double droprate;
+
+ /* Locking here works, because the structure of the linked list is only
+ * changed during configure and shutdown. */
+ pthread_mutex_lock (&ping_lock);
+
+ pkg_sent = hl->pkg_sent;
+ pkg_recv = hl->pkg_recv;
+ latency_total = hl->latency_total;
+ latency_squared = hl->latency_squared;
+
+ hl->pkg_sent = 0;
+ hl->pkg_recv = 0;
+ hl->latency_total = 0.0;
+ hl->latency_squared = 0.0;
+
+ pthread_mutex_unlock (&ping_lock);
+
+ /* This e. g. happens when starting up. */
+ if (pkg_sent == 0)
+ {
+ DEBUG ("ping plugin: No packages for host %s have been sent.",
+ hl->host);
+ continue;
+ }
+
+ /* Calculate average. Beware of division by zero. */
+ if (pkg_recv == 0)
+ latency_average = NAN;
+ else
+ latency_average = latency_total / ((double) pkg_recv);
+
+ /* Calculate standard deviation. Beware even more of division by zero. */
+ if (pkg_recv == 0)
+ latency_stddev = NAN;
+ else if (pkg_recv == 1)
+ latency_stddev = 0.0;
+ else
+ latency_stddev = sqrt (((((double) pkg_recv) * latency_squared)
+ - (latency_total * latency_total))
+ / ((double) (pkg_recv * (pkg_recv - 1))));
+
+ /* Calculate drop rate. */
+ droprate = ((double) (pkg_sent - pkg_recv)) / ((double) pkg_sent);
+
+ submit (hl->host, "ping", latency_average);
+ submit (hl->host, "ping_stddev", latency_stddev);
+ submit (hl->host, "ping_droprate", droprate);
+ } /* }}} for (hl = hostlist_head; hl != NULL; hl = hl->next) */
+
+ return (0);
+} /* }}} int ping_read */
+
+static int ping_shutdown (void) /* {{{ */
+{
+ hostlist_t *hl;
+
+ INFO ("ping plugin: Shutting down thread.");
+ if (stop_thread () < 0)
+ return (-1);
+
+ hl = hostlist_head;
+ while (hl != NULL)
+ {
+ hostlist_t *hl_next;
+
+ hl_next = hl->next;
+
+ sfree (hl->host);
+ sfree (hl);
+
+ hl = hl_next;
+ }
+
+ return (0);
+} /* }}} int ping_shutdown */
void module_register (void)
{
- plugin_register_config ("ping", ping_config,
- config_keys, config_keys_num);
- plugin_register_init ("ping", ping_init);
- plugin_register_read ("ping", ping_read);
+ plugin_register_config ("ping", ping_config,
+ config_keys, config_keys_num);
+ plugin_register_init ("ping", ping_init);
+ plugin_register_read ("ping", ping_read);
+ plugin_register_shutdown ("ping", ping_shutdown);
} /* void module_register */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
#include "configfile.h"
#include "utils_avltree.h"
#include "utils_llist.h"
+#include "utils_heap.h"
#include "utils_cache.h"
#include "utils_threshold.h"
#include "filter_chain.h"
/*
* Private structures
*/
+struct callback_func_s
+{
+ void *cf_callback;
+ user_data_t cf_udata;
+};
+typedef struct callback_func_s callback_func_t;
+
+#define RF_SIMPLE 0
+#define RF_COMPLEX 1
struct read_func_s
{
- int wait_time;
- int wait_left;
- int (*callback) (void);
- enum { DONE = 0, TODO = 1, ACTIVE = 2 } needs_read;
+ /* `read_func_t' "inherits" from `callback_func_t'.
+ * The `rf_super' member MUST be the first one in this structure! */
+#define rf_callback rf_super.cf_callback
+#define rf_udata rf_super.cf_udata
+ callback_func_t rf_super;
+ char rf_name[DATA_MAX_NAME_LEN];
+ int rf_type;
+ struct timespec rf_interval;
+ struct timespec rf_effective_interval;
+ struct timespec rf_next_read;
};
typedef struct read_func_s read_func_t;
* Private variables
*/
static llist_t *list_init;
-static llist_t *list_read;
static llist_t *list_write;
static llist_t *list_flush;
static llist_t *list_shutdown;
static char *plugindir = NULL;
+static c_heap_t *read_heap = NULL;
static int read_loop = 1;
static pthread_mutex_t read_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t read_cond = PTHREAD_COND_INITIALIZER;
return (plugindir);
}
-static int register_callback (llist_t **list, const char *name, void *callback)
+static void destroy_callback (callback_func_t *cf) /* {{{ */
+{
+ if (cf == NULL)
+ return;
+
+ if ((cf->cf_udata.data != NULL) && (cf->cf_udata.free_func != NULL))
+ {
+ cf->cf_udata.free_func (cf->cf_udata.data);
+ cf->cf_udata.data = NULL;
+ cf->cf_udata.free_func = NULL;
+ }
+ sfree (cf);
+} /* }}} void destroy_callback */
+
+static void destroy_all_callbacks (llist_t **list) /* {{{ */
+{
+ llentry_t *le;
+
+ if (*list == NULL)
+ return;
+
+ le = llist_head (*list);
+ while (le != NULL)
+ {
+ llentry_t *le_next;
+
+ le_next = le->next;
+
+ sfree (le->key);
+ destroy_callback (le->value);
+ le->value = NULL;
+
+ le = le_next;
+ }
+
+ llist_destroy (*list);
+ *list = NULL;
+} /* }}} void destroy_all_callbacks */
+
+static void destroy_read_heap (void) /* {{{ */
+{
+ if (read_heap == NULL)
+ return;
+
+ while (42)
+ {
+ callback_func_t *cf;
+
+ cf = c_head_get_root (read_heap);
+ if (cf == NULL)
+ break;
+
+ destroy_callback (cf);
+ }
+
+ c_heap_destroy (read_heap);
+ read_heap = NULL;
+} /* }}} void destroy_read_heap */
+
+static int register_callback (llist_t **list, /* {{{ */
+ const char *name, callback_func_t *cf)
{
llentry_t *le;
char *key;
- if ((*list == NULL)
- && ((*list = llist_create ()) == NULL))
+ if (*list == NULL)
+ {
+ *list = llist_create ();
+ if (*list == NULL)
+ {
+ ERROR ("plugin: create_register_callback: "
+ "llist_create failed.");
+ destroy_callback (cf);
+ return (-1);
+ }
+ }
+
+ key = strdup (name);
+ if (key == NULL)
+ {
+ ERROR ("plugin: create_register_callback: strdup failed.");
+ destroy_callback (cf);
return (-1);
+ }
le = llist_search (*list, name);
if (le == NULL)
{
- key = strdup (name);
- if (key == NULL)
- return (-1);
-
- le = llentry_create (key, callback);
+ le = llentry_create (key, cf);
if (le == NULL)
{
+ ERROR ("plugin: create_register_callback: "
+ "llentry_create failed.");
free (key);
+ destroy_callback (cf);
return (-1);
}
}
else
{
- le->value = callback;
+ callback_func_t *old_cf;
+
+ old_cf = le->value;
+ le->value = cf;
+
+ destroy_callback (old_cf);
+ sfree (key);
}
return (0);
-} /* int register_callback */
+} /* }}} int register_callback */
-static int plugin_unregister (llist_t *list, const char *name)
+static int create_register_callback (llist_t **list, /* {{{ */
+ const char *name, void *callback, user_data_t *ud)
+{
+ callback_func_t *cf;
+
+ cf = (callback_func_t *) malloc (sizeof (*cf));
+ if (cf == NULL)
+ {
+ ERROR ("plugin: create_register_callback: malloc failed.");
+ return (-1);
+ }
+ memset (cf, 0, sizeof (*cf));
+
+ cf->cf_callback = callback;
+ if (ud == NULL)
+ {
+ cf->cf_udata.data = NULL;
+ cf->cf_udata.free_func = NULL;
+ }
+ else
+ {
+ cf->cf_udata = *ud;
+ }
+
+ return (register_callback (list, name, cf));
+} /* }}} int create_register_callback */
+
+static int plugin_unregister (llist_t *list, const char *name) /* {{{ */
{
llentry_t *e;
- e = llist_search (list, name);
+ if (list == NULL)
+ return (-1);
+ e = llist_search (list, name);
if (e == NULL)
return (-1);
llist_remove (list, e);
- free (e->key);
+
+ sfree (e->key);
+ destroy_callback (e->value);
+
llentry_destroy (e);
return (0);
-} /* int plugin_unregister */
+} /* }}} int plugin_unregister */
/*
* (Try to) load the shared object `file'. Won't complain if it isn't a shared
static void *plugin_read_thread (void __attribute__((unused)) *args)
{
- llentry_t *le;
- read_func_t *rf;
- int status;
- int done;
-
- pthread_mutex_lock (&read_lock);
-
while (read_loop != 0)
{
- le = llist_head (list_read);
- done = 0;
+ read_func_t *rf;
+ struct timeval now;
+ int status;
- while ((read_loop != 0) && (le != NULL))
+ /* Get the read function that needs to be read next. */
+ rf = c_head_get_root (read_heap);
+ if (rf == NULL)
{
- rf = (read_func_t *) le->value;
+ struct timespec abstime;
- if (rf->needs_read != TODO)
- {
- le = le->next;
- continue;
- }
+ gettimeofday (&now, /* timezone = */ NULL);
- /* We will do this read function */
- rf->needs_read = ACTIVE;
+ abstime.tv_sec = now.tv_sec + interval_g;
+ abstime.tv_nsec = 1000 * now.tv_usec;
- DEBUG ("[thread #%5lu] plugin: plugin_read_thread: Handling %s",
- (unsigned long int) pthread_self (), le->key);
+ pthread_mutex_lock (&read_lock);
+ pthread_cond_timedwait (&read_cond, &read_lock,
+ &abstime);
pthread_mutex_unlock (&read_lock);
+ continue;
+ }
- status = rf->callback ();
- done++;
+ if ((rf->rf_interval.tv_sec == 0) && (rf->rf_interval.tv_nsec == 0))
+ {
+ gettimeofday (&now, /* timezone = */ NULL);
- if (status != 0)
- {
- if (rf->wait_time < interval_g)
- rf->wait_time = interval_g;
- rf->wait_left = rf->wait_time;
- rf->wait_time = rf->wait_time * 2;
- if (rf->wait_time > 86400)
- rf->wait_time = 86400;
-
- NOTICE ("read-function of plugin `%s' "
- "failed. Will suspend it for %i "
- "seconds.", le->key, rf->wait_left);
- }
- else
+ rf->rf_interval.tv_sec = interval_g;
+ rf->rf_interval.tv_nsec = 0;
+
+ rf->rf_effective_interval = rf->rf_interval;
+
+ rf->rf_next_read.tv_sec = now.tv_sec;
+ rf->rf_next_read.tv_nsec = 1000 * now.tv_usec;
+ }
+
+ /* sleep until this entry is due,
+ * using pthread_cond_timedwait */
+ pthread_mutex_lock (&read_lock);
+ pthread_cond_timedwait (&read_cond, &read_lock,
+ &rf->rf_next_read);
+ pthread_mutex_unlock (&read_lock);
+
+ /* Check if we're supposed to stop.. This may have interrupted
+ * the sleep, too. */
+ if (read_loop == 0)
+ {
+ /* Insert `rf' again, so it can be free'd correctly */
+ c_heap_insert (read_heap, rf);
+ break;
+ }
+
+ DEBUG ("plugin_read_thread: Handling `%s'.", rf->rf_name);
+
+ if (rf->rf_type == RF_SIMPLE)
+ {
+ int (*callback) (void);
+
+ callback = rf->rf_callback;
+ status = (*callback) ();
+ }
+ else
+ {
+ plugin_read_cb callback;
+
+ callback = rf->rf_callback;
+ status = (*callback) (&rf->rf_udata);
+ }
+
+ /* If the function signals failure, we will increase the
+ * intervals in which it will be called. */
+ if (status != 0)
+ {
+ rf->rf_effective_interval.tv_sec *= 2;
+ rf->rf_effective_interval.tv_nsec *= 2;
+ NORMALIZE_TIMESPEC (rf->rf_effective_interval);
+
+ if (rf->rf_effective_interval.tv_sec >= 86400)
{
- rf->wait_left = 0;
- rf->wait_time = interval_g;
+ rf->rf_effective_interval.tv_sec = 86400;
+ rf->rf_effective_interval.tv_nsec = 0;
}
- pthread_mutex_lock (&read_lock);
-
- rf->needs_read = DONE;
- le = le->next;
- } /* while (le != NULL) */
+ NOTICE ("read-function of plugin `%s' failed. "
+ "Will suspend it for %i seconds.",
+ rf->rf_name,
+ (int) rf->rf_effective_interval.tv_sec);
+ }
+ else
+ {
+ /* Success: Restore the interval, if it was changed. */
+ rf->rf_effective_interval = rf->rf_interval;
+ }
- if ((read_loop != 0) && (done == 0))
+ /* update the ``next read due'' field */
+ gettimeofday (&now, /* timezone = */ NULL);
+
+ DEBUG ("plugin_read_thread: Effective interval of the "
+ "%s plugin is %i.%09i.",
+ rf->rf_name,
+ (int) rf->rf_effective_interval.tv_sec,
+ (int) rf->rf_effective_interval.tv_nsec);
+
+ /* Calculate the next (absolute) time at which this function
+ * should be called. */
+ rf->rf_next_read.tv_sec = rf->rf_next_read.tv_sec
+ + rf->rf_effective_interval.tv_sec;
+ rf->rf_next_read.tv_nsec = rf->rf_next_read.tv_nsec
+ + rf->rf_effective_interval.tv_nsec;
+ NORMALIZE_TIMESPEC (rf->rf_next_read);
+
+ /* Check, if `rf_next_read' is in the past. */
+ if ((rf->rf_next_read.tv_sec < now.tv_sec)
+ || ((rf->rf_next_read.tv_sec == now.tv_sec)
+ && (rf->rf_next_read.tv_nsec < (1000 * now.tv_usec))))
{
- DEBUG ("[thread #%5lu] plugin: plugin_read_thread: Waiting on read_cond.",
- (unsigned long int) pthread_self ());
- pthread_cond_wait (&read_cond, &read_lock);
+ /* `rf_next_read' is in the past. Insert `now'
+ * so this value doesn't trail off into the
+ * past too much. */
+ rf->rf_next_read.tv_sec = now.tv_sec;
+ rf->rf_next_read.tv_nsec = 1000 * now.tv_usec;
}
- } /* while (read_loop) */
- pthread_mutex_unlock (&read_lock);
+ DEBUG ("plugin_read_thread: Next read of the %s plugin at %i.%09i.",
+ rf->rf_name,
+ (int) rf->rf_next_read.tv_sec,
+ (int) rf->rf_next_read.tv_nsec);
+
+ /* Re-insert this read function into the heap again. */
+ c_heap_insert (read_heap, rf);
+ } /* while (read_loop) */
pthread_exit (NULL);
return ((void *) 0);
} /* void *plugin_read_thread */
-static void start_threads (int num)
+static void start_read_threads (int num)
{
int i;
read_threads = (pthread_t *) calloc (num, sizeof (pthread_t));
if (read_threads == NULL)
{
- ERROR ("plugin: start_threads: calloc failed.");
+ ERROR ("plugin: start_read_threads: calloc failed.");
return;
}
}
else
{
- ERROR ("plugin: start_threads: pthread_create failed.");
+ ERROR ("plugin: start_read_threads: pthread_create failed.");
return;
}
} /* for (i) */
-} /* void start_threads */
+} /* void start_read_threads */
-static void stop_threads (void)
+static void stop_read_threads (void)
{
int i;
if (read_threads == NULL)
return;
+ INFO ("collectd: Stopping %i read threads.", read_threads_num);
+
pthread_mutex_lock (&read_lock);
read_loop = 0;
- DEBUG ("plugin: stop_threads: Signalling `read_cond'");
+ DEBUG ("plugin: stop_read_threads: Signalling `read_cond'");
pthread_cond_broadcast (&read_cond);
pthread_mutex_unlock (&read_lock);
{
if (pthread_join (read_threads[i], NULL) != 0)
{
- ERROR ("plugin: stop_threads: pthread_join failed.");
+ ERROR ("plugin: stop_read_threads: pthread_join failed.");
}
read_threads[i] = (pthread_t) 0;
}
sfree (read_threads);
read_threads_num = 0;
-} /* void stop_threads */
+} /* void stop_read_threads */
/*
* Public functions
int plugin_register_init (const char *name,
int (*callback) (void))
{
- return (register_callback (&list_init, name, (void *) callback));
+ return (create_register_callback (&list_init, name, (void *) callback,
+ /* user_data = */ NULL));
} /* plugin_register_init */
+static int plugin_compare_read_func (const void *arg0, const void *arg1)
+{
+ const read_func_t *rf0;
+ const read_func_t *rf1;
+
+ rf0 = arg0;
+ rf1 = arg1;
+
+ if (rf0->rf_next_read.tv_sec < rf1->rf_next_read.tv_sec)
+ return (-1);
+ else if (rf0->rf_next_read.tv_sec > rf1->rf_next_read.tv_sec)
+ return (1);
+ else if (rf0->rf_next_read.tv_nsec < rf1->rf_next_read.tv_nsec)
+ return (-1);
+ else if (rf0->rf_next_read.tv_nsec > rf1->rf_next_read.tv_nsec)
+ return (1);
+ else
+ return (0);
+} /* int plugin_compare_read_func */
+
int plugin_register_read (const char *name,
int (*callback) (void))
{
read_func_t *rf;
+ if (read_heap == NULL)
+ {
+ read_heap = c_heap_create (plugin_compare_read_func);
+ if (read_heap == NULL)
+ {
+ ERROR ("plugin_register_read: "
+ "c_heap_create failed.");
+ return (-1);
+ }
+ }
+
rf = (read_func_t *) malloc (sizeof (read_func_t));
if (rf == NULL)
{
return (-1);
}
- memset (rf, '\0', sizeof (read_func_t));
- rf->wait_time = interval_g;
- rf->wait_left = 0;
- rf->callback = callback;
- rf->needs_read = DONE;
-
- return (register_callback (&list_read, name, (void *) rf));
+ memset (rf, 0, sizeof (read_func_t));
+ rf->rf_callback = (void *) callback;
+ rf->rf_udata.data = NULL;
+ rf->rf_udata.free_func = NULL;
+ sstrncpy (rf->rf_name, name, sizeof (rf->rf_name));
+ rf->rf_type = RF_SIMPLE;
+ rf->rf_interval.tv_sec = 0;
+ rf->rf_interval.tv_nsec = 0;
+ rf->rf_effective_interval = rf->rf_interval;
+
+ return (c_heap_insert (read_heap, rf));
} /* int plugin_register_read */
+int plugin_register_complex_read (const char *name,
+ plugin_read_cb callback,
+ const struct timespec *interval,
+ user_data_t *user_data)
+{
+ read_func_t *rf;
+
+ if (read_heap == NULL)
+ {
+ read_heap = c_heap_create (plugin_compare_read_func);
+ if (read_heap == NULL)
+ {
+ ERROR ("plugin_register_read: c_heap_create failed.");
+ return (-1);
+ }
+ }
+
+ rf = (read_func_t *) malloc (sizeof (read_func_t));
+ if (rf == NULL)
+ {
+ ERROR ("plugin_register_complex_read: malloc failed.");
+ return (-1);
+ }
+
+ memset (rf, 0, sizeof (read_func_t));
+ rf->rf_callback = (void *) callback;
+ sstrncpy (rf->rf_name, name, sizeof (rf->rf_name));
+ rf->rf_type = RF_COMPLEX;
+ if (interval != NULL)
+ {
+ rf->rf_interval = *interval;
+ }
+ rf->rf_effective_interval = rf->rf_interval;
+
+ /* Set user data */
+ if (user_data == NULL)
+ {
+ rf->rf_udata.data = NULL;
+ rf->rf_udata.free_func = NULL;
+ }
+ else
+ {
+ rf->rf_udata = *user_data;
+ }
+
+ return (c_heap_insert (read_heap, rf));
+} /* int plugin_register_complex_read */
+
int plugin_register_write (const char *name,
- int (*callback) (const data_set_t *ds, const value_list_t *vl))
+ plugin_write_cb callback, user_data_t *ud)
{
- return (register_callback (&list_write, name, (void *) callback));
+ return (create_register_callback (&list_write, name,
+ (void *) callback, ud));
} /* int plugin_register_write */
int plugin_register_flush (const char *name,
- int (*callback) (const int timeout, const char *identifier))
+ plugin_flush_cb callback, user_data_t *ud)
{
- return (register_callback (&list_flush, name, (void *) callback));
+ return (create_register_callback (&list_flush, name,
+ (void *) callback, ud));
} /* int plugin_register_flush */
int plugin_register_shutdown (char *name,
int (*callback) (void))
{
- return (register_callback (&list_shutdown, name, (void *) callback));
+ return (create_register_callback (&list_shutdown, name,
+ (void *) callback, /* user_data = */ NULL));
} /* int plugin_register_shutdown */
int plugin_register_data_set (const data_set_t *ds)
return (c_avl_insert (data_sets, (void *) ds_copy->type, (void *) ds_copy));
} /* int plugin_register_data_set */
-int plugin_register_log (char *name,
- void (*callback) (int priority, const char *msg))
+int plugin_register_log (const char *name,
+ plugin_log_cb callback, user_data_t *ud)
{
- return (register_callback (&list_log, name, (void *) callback));
+ return (create_register_callback (&list_log, name,
+ (void *) callback, ud));
} /* int plugin_register_log */
int plugin_register_notification (const char *name,
- int (*callback) (const notification_t *notif))
+ plugin_notification_cb callback, user_data_t *ud)
{
- return (register_callback (&list_notification, name, (void *) callback));
+ return (create_register_callback (&list_notification, name,
+ (void *) callback, ud));
} /* int plugin_register_log */
int plugin_unregister_config (const char *name)
int plugin_unregister_read (const char *name)
{
- llentry_t *e;
-
- e = llist_search (list_read, name);
-
- if (e == NULL)
- return (-1);
-
- llist_remove (list_read, e);
- free (e->value);
- free (e->key);
- llentry_destroy (e);
-
- return (0);
+ /* TODO: Implement removal of a specific key from the heap. */
+ assert (0);
+ return (-1);
}
int plugin_unregister_write (const char *name)
void plugin_init_all (void)
{
const char *chain_name;
- int (*callback) (void);
llentry_t *le;
int status;
post_cache_chain = fc_chain_get_by_name (chain_name);
- if ((list_init == NULL) && (list_read == NULL))
+ if ((list_init == NULL) && (read_heap == NULL))
return;
/* Calling all init callbacks before checking if read callbacks
le = llist_head (list_init);
while (le != NULL)
{
- callback = (int (*) (void)) le->value;
+ callback_func_t *cf;
+ plugin_init_cb callback;
+
+ cf = le->value;
+ callback = cf->cf_callback;
status = (*callback) ();
if (status != 0)
}
/* Start read-threads */
- if (list_read != NULL)
+ if (read_heap != NULL)
{
const char *rt;
int num;
rt = global_option_get ("ReadThreads");
num = atoi (rt);
if (num != -1)
- start_threads ((num > 0) ? num : 5);
+ start_read_threads ((num > 0) ? num : 5);
}
} /* void plugin_init_all */
+/* TODO: Rename this function. */
void plugin_read_all (void)
{
- llentry_t *le;
- read_func_t *rf;
-
uc_check_timeout ();
- if (list_read == NULL)
- return;
-
- pthread_mutex_lock (&read_lock);
-
- le = llist_head (list_read);
- while (le != NULL)
- {
- rf = (read_func_t *) le->value;
-
- if (rf->needs_read != DONE)
- {
- le = le->next;
- continue;
- }
-
- if (rf->wait_left > 0)
- rf->wait_left -= interval_g;
-
- if (rf->wait_left <= 0)
- {
- rf->needs_read = TODO;
- }
-
- le = le->next;
- }
-
- DEBUG ("plugin: plugin_read_all: Signalling `read_cond'");
- pthread_cond_broadcast (&read_cond);
- pthread_mutex_unlock (&read_lock);
+ return;
} /* void plugin_read_all */
/* Read function called when the `-T' command line argument is given. */
int plugin_read_all_once (void)
{
- llentry_t *le;
- read_func_t *rf;
int status;
int return_status = 0;
- if (list_read == NULL)
+ if (read_heap == NULL)
{
NOTICE ("No read-functions are registered.");
return (0);
}
- for (le = llist_head (list_read);
- le != NULL;
- le = le->next)
+ while (42)
{
- rf = (read_func_t *) le->value;
- status = rf->callback ();
+ read_func_t *rf;
+
+ rf = c_head_get_root (read_heap);
+ if (rf == NULL)
+ break;
+
+ if (rf->rf_type == RF_SIMPLE)
+ {
+ int (*callback) (void);
+
+ callback = rf->rf_callback;
+ status = (*callback) ();
+ }
+ else
+ {
+ plugin_read_cb callback;
+
+ callback = rf->rf_callback;
+ status = (*callback) (&rf->rf_udata);
+ }
+
if (status != 0)
{
NOTICE ("read-function of plugin `%s' failed.",
- le->key);
+ rf->rf_name);
return_status = -1;
}
+
+ destroy_callback ((void *) rf);
}
return (return_status);
int plugin_write (const char *plugin, /* {{{ */
const data_set_t *ds, const value_list_t *vl)
{
- int (*callback) (const data_set_t *ds, const value_list_t *vl);
llentry_t *le;
int status;
le = llist_head (list_write);
while (le != NULL)
{
- callback = le->value;
- status = (*callback) (ds, vl);
+ callback_func_t *cf = le->value;
+ plugin_write_cb callback;
+
+ DEBUG ("plugin: plugin_write: Writing values via %s.", le->key);
+ callback = cf->cf_callback;
+ status = (*callback) (ds, vl, &cf->cf_udata);
if (status != 0)
failure++;
else
}
else /* plugin != NULL */
{
+ callback_func_t *cf;
+ plugin_write_cb callback;
+
le = llist_head (list_write);
while (le != NULL)
{
if (le == NULL)
return (ENOENT);
- callback = le->value;
- status = (*callback) (ds, vl);
+ cf = le->value;
+
+ DEBUG ("plugin: plugin_write: Writing values via %s.", le->key);
+ callback = cf->cf_callback;
+ status = (*callback) (ds, vl, &cf->cf_udata);
}
return (status);
int plugin_flush (const char *plugin, int timeout, const char *identifier)
{
- int (*callback) (int timeout, const char *identifier);
llentry_t *le;
if (list_flush == NULL)
le = llist_head (list_flush);
while (le != NULL)
{
+ callback_func_t *cf;
+ plugin_flush_cb callback;
+
if ((plugin != NULL)
&& (strcmp (plugin, le->key) != 0))
{
continue;
}
- callback = (int (*) (int, const char *)) le->value;
- (*callback) (timeout, identifier);
+ cf = le->value;
+ callback = cf->cf_callback;
+
+ (*callback) (timeout, identifier, &cf->cf_udata);
le = le->next;
}
void plugin_shutdown_all (void)
{
- int (*callback) (void);
llentry_t *le;
- stop_threads ();
+ stop_read_threads ();
- if (list_shutdown == NULL)
- return;
+ destroy_all_callbacks (&list_init);
+ destroy_read_heap ();
+
+ plugin_flush (/* plugin = */ NULL, /* timeout = */ -1,
+ /* identifier = */ NULL);
+
+ le = NULL;
+ if (list_shutdown != NULL)
+ le = llist_head (list_shutdown);
- le = llist_head (list_shutdown);
while (le != NULL)
{
- callback = (int (*) (void)) le->value;
+ callback_func_t *cf;
+ plugin_shutdown_cb callback;
+
+ cf = le->value;
+ callback = cf->cf_callback;
/* Advance the pointer before calling the callback allows
* shutdown functions to unregister themselves. If done the
(*callback) ();
}
+
+ destroy_all_callbacks (&list_write);
+ destroy_all_callbacks (&list_flush);
+ destroy_all_callbacks (&list_notification);
+ destroy_all_callbacks (&list_shutdown);
+ destroy_all_callbacks (&list_log);
} /* void plugin_shutdown_all */
int plugin_dispatch_values (value_list_t *vl)
if (vl->time == 0)
vl->time = time (NULL);
+ if (vl->interval <= 0)
+ vl->interval = interval_g;
+
DEBUG ("plugin_dispatch_values: time = %u; interval = %i; "
"host = %s; "
"plugin = %s; plugin_instance = %s; "
int plugin_dispatch_notification (const notification_t *notif)
{
- int (*callback) (const notification_t *);
llentry_t *le;
/* Possible TODO: Add flap detection here */
le = llist_head (list_notification);
while (le != NULL)
{
- callback = (int (*) (const notification_t *)) le->value;
- (*callback) (notif);
+ callback_func_t *cf;
+ plugin_notification_cb callback;
+ int status;
+
+ cf = le->value;
+ callback = cf->cf_callback;
+ status = (*callback) (notif, &cf->cf_udata);
+ if (status != 0)
+ {
+ WARNING ("plugin_dispatch_notification: Notification "
+ "callback %s returned %i.",
+ le->key, status);
+ }
le = le->next;
}
{
char msg[1024];
va_list ap;
-
- void (*callback) (int, const char *);
llentry_t *le;
if (list_log == NULL)
le = llist_head (list_log);
while (le != NULL)
{
- callback = (void (*) (int, const char *)) le->value;
- (*callback) (level, msg);
+ callback_func_t *cf;
+ plugin_log_cb callback;
+
+ cf = le->value;
+ callback = cf->cf_callback;
+
+ (*callback) (level, msg, &cf->cf_udata);
le = le->next;
}
return (0);
} /* int plugin_notification_meta_free */
+
+/* vim: set sw=8 ts=8 noet fdm=marker : */
notification_meta_t *meta;
} notification_t;
+struct user_data_s
+{
+ void *data;
+ void (*free_func) (void *);
+};
+typedef struct user_data_s user_data_t;
+
+/*
+ * Callback types
+ */
+typedef int (*plugin_init_cb) (void);
+typedef int (*plugin_read_cb) (user_data_t *);
+typedef int (*plugin_write_cb) (const data_set_t *, const value_list_t *,
+ user_data_t *);
+typedef int (*plugin_flush_cb) (int timeout, const char *identifier,
+ user_data_t *);
+typedef void (*plugin_log_cb) (int severity, const char *message,
+ user_data_t *);
+typedef int (*plugin_shutdown_cb) (void);
+typedef int (*plugin_notification_cb) (const notification_t *,
+ user_data_t *);
+
/*
* NAME
* plugin_set_dir
int plugin_register_complex_config (const char *type,
int (*callback) (oconfig_item_t *));
int plugin_register_init (const char *name,
- int (*callback) (void));
+ plugin_init_cb callback);
int plugin_register_read (const char *name,
int (*callback) (void));
+int plugin_register_complex_read (const char *name,
+ plugin_read_cb callback,
+ const struct timespec *interval,
+ user_data_t *user_data);
int plugin_register_write (const char *name,
- int (*callback) (const data_set_t *ds, const value_list_t *vl));
+ plugin_write_cb callback, user_data_t *user_data);
int plugin_register_flush (const char *name,
- int (*callback) (const int timeout, const char *identifier));
+ plugin_flush_cb callback, user_data_t *user_data);
int plugin_register_shutdown (char *name,
- int (*callback) (void));
+ plugin_shutdown_cb callback);
int plugin_register_data_set (const data_set_t *ds);
-int plugin_register_log (char *name,
- void (*callback) (int, const char *));
+int plugin_register_log (const char *name,
+ plugin_log_cb callback, user_data_t *user_data);
int plugin_register_notification (const char *name,
- int (*callback) (const notification_t *notif));
+ plugin_notification_cb callback, user_data_t *user_data);
int plugin_unregister_config (const char *name);
int plugin_unregister_complex_config (const char *name);
int plugin_unregister_init (const char *name);
int plugin_unregister_read (const char *name);
+int plugin_unregister_complex_read (const char *name, void **user_data);
int plugin_unregister_write (const char *name);
int plugin_unregister_flush (const char *name);
int plugin_unregister_shutdown (const char *name);
return;
}
- if (ds->ds[0].type == DS_TYPE_GAUGE)
+ if (0 != parse_value (value, &values[0], ds->ds[0]))
{
- char *endptr = NULL;
-
- values[0].gauge = strtod (value, &endptr);
-
- if (endptr == value)
- {
- ERROR ("powerdns plugin: Cannot convert `%s' "
- "to a floating point number.", value);
- return;
- }
- }
- else
- {
- char *endptr = NULL;
-
- values[0].counter = strtoll (value, &endptr, 0);
- if (endptr == value)
- {
- ERROR ("powerdns plugin: Cannot convert `%s' "
- "to an integer number.", value);
- return;
- }
+ ERROR ("powerdns plugin: Cannot convert `%s' "
+ "to a number.", value);
+ return;
}
vl.values = values;
--- /dev/null
+/**
+ * collectd - src/protocols.c
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+#include "utils_ignorelist.h"
+
+#if !KERNEL_LINUX
+# error "No applicable input method."
+#endif
+
+#define SNMP_FILE "/proc/net/snmp"
+#define NETSTAT_FILE "/proc/net/netstat"
+
+/*
+ * Global variables
+ */
+static const char *config_keys[] =
+{
+ "Value",
+ "IgnoreSelected",
+};
+static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
+
+static ignorelist_t *values_list = NULL;
+
+/*
+ * Functions
+ */
+static void submit (const char *protocol_name,
+ const char *str_key, const char *str_value)
+{
+ value_t values[1];
+ value_list_t vl = VALUE_LIST_INIT;
+
+ char *tmp_ptr;
+
+ errno = 0;
+ tmp_ptr = NULL;
+ values[0].counter = (counter_t) strtoll (str_value, &tmp_ptr,
+ /* base = */ 0);
+ if ((errno != 0) || (tmp_ptr == str_value))
+ {
+ ERROR ("protocols plugin: Parsing string as integer failed: %s",
+ str_value);
+ return;
+ }
+
+ vl.values = values;
+ vl.values_len = 1;
+ sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+ sstrncpy (vl.plugin, "protocols", sizeof (vl.plugin));
+ sstrncpy (vl.plugin_instance, protocol_name, sizeof (vl.plugin_instance));
+ sstrncpy (vl.type, "protocol_counter", sizeof (vl.type));
+ sstrncpy (vl.type_instance, str_key, sizeof (vl.type_instance));
+
+ plugin_dispatch_values (&vl);
+} /* void submit */
+
+static int read_file (const char *path)
+{
+ FILE *fh;
+ char key_buffer[4096];
+ char value_buffer[4096];
+ char *key_ptr;
+ char *value_ptr;
+ char *key_fields[256];
+ char *value_fields[256];
+ int key_fields_num;
+ int value_fields_num;
+ int status;
+ int i;
+
+ fh = fopen (path, "r");
+ if (fh == NULL)
+ {
+ ERROR ("protocols plugin: fopen (%s) failed: %s.",
+ path, sstrerror (errno, key_buffer, sizeof (key_buffer)));
+ return (-1);
+ }
+
+ status = -1;
+ while (42)
+ {
+ clearerr (fh);
+ key_ptr = fgets (key_buffer, sizeof (key_buffer), fh);
+ if (key_ptr == NULL)
+ {
+ if (feof (fh) != 0)
+ {
+ status = 0;
+ break;
+ }
+ else if (ferror (fh) != 0)
+ {
+ ERROR ("protocols plugin: Reading from %s failed.", path);
+ break;
+ }
+ else
+ {
+ ERROR ("protocols plugin: fgets failed for an unknown reason.");
+ break;
+ }
+ } /* if (key_ptr == NULL) */
+
+ value_ptr = fgets (value_buffer, sizeof (value_buffer), fh);
+ if (value_ptr == NULL)
+ {
+ ERROR ("protocols plugin: read_file (%s): Could not read values line.",
+ path);
+ break;
+ }
+
+ key_ptr = strchr (key_buffer, ':');
+ if (key_ptr == NULL)
+ {
+ ERROR ("protocols plugin: Could not find protocol name in keys line.");
+ break;
+ }
+ *key_ptr = 0;
+ key_ptr++;
+
+ value_ptr = strchr (value_buffer, ':');
+ if (value_ptr == NULL)
+ {
+ ERROR ("protocols plugin: Could not find protocol name "
+ "in values line.");
+ break;
+ }
+ *value_ptr = 0;
+ value_ptr++;
+
+ if (strcmp (key_buffer, value_buffer) != 0)
+ {
+ ERROR ("protocols plugin: Protocol names in keys and values lines "
+ "don't match: `%s' vs. `%s'.",
+ key_buffer, value_buffer);
+ break;
+ }
+
+
+ key_fields_num = strsplit (key_ptr,
+ key_fields, STATIC_ARRAY_SIZE (key_fields));
+ value_fields_num = strsplit (value_ptr,
+ value_fields, STATIC_ARRAY_SIZE (value_fields));
+
+ if (key_fields_num != value_fields_num)
+ {
+ ERROR ("protocols plugin: Number of fields in keys and values lines "
+ "dont match: %i vs %i.",
+ key_fields_num, value_fields_num);
+ break;
+ }
+
+ for (i = 0; i < key_fields_num; i++)
+ {
+ if (values_list != NULL)
+ {
+ char match_name[2 * DATA_MAX_NAME_LEN];
+
+ ssnprintf (match_name, sizeof (match_name), "%s:%s",
+ key_buffer, key_fields[i]);
+
+ if (ignorelist_match (values_list, match_name))
+ continue;
+ } /* if (values_list != NULL) */
+
+ submit (key_buffer, key_fields[i], value_fields[i]);
+ } /* for (i = 0; i < key_fields_num; i++) */
+ } /* while (42) */
+
+ fclose (fh);
+
+ return (status);
+} /* int read_file */
+
+static int protocols_read (void)
+{
+ int status;
+ int success = 0;
+
+ status = read_file (SNMP_FILE);
+ if (status == 0)
+ success++;
+
+ status = read_file (NETSTAT_FILE);
+ if (status == 0)
+ success++;
+
+ if (success == 0)
+ return (-1);
+
+ return (0);
+} /* int protocols_read */
+
+static int protocols_config (const char *key, const char *value)
+{
+ if (values_list == NULL)
+ values_list = ignorelist_create (/* invert = */ 1);
+
+ if (strcasecmp (key, "Value") == 0)
+ {
+ ignorelist_add (values_list, value);
+ }
+ else if (strcasecmp (key, "IgnoreSelected") == 0)
+ {
+ int invert = 1;
+ if ((strcasecmp (value, "True") == 0)
+ || (strcasecmp (value, "Yes") == 0)
+ || (strcasecmp (value, "On") == 0))
+ invert = 0;
+ ignorelist_set_invert (values_list, invert);
+ }
+ else
+ {
+ return (-1);
+ }
+
+ return (0);
+} /* int protocols_config */
+
+void module_register (void)
+{
+ plugin_register_config ("protocols", protocols_config,
+ config_keys, config_keys_num);
+ plugin_register_read ("protocols", protocols_read);
+} /* void module_register */
+
+/* vim: set sw=2 sts=2 et : */
return (0);
} /* int rc_init */
-static int rc_write (const data_set_t *ds, const value_list_t *vl)
+static int rc_write (const data_set_t *ds, const value_list_t *vl,
+ user_data_t __attribute__((unused)) *user_data)
{
char filename[512];
char values[512];
plugin_register_config ("rrdcached", rc_config,
config_keys, config_keys_num);
plugin_register_init ("rrdcached", rc_init);
- plugin_register_write ("rrdcached", rc_write);
+ plugin_register_write ("rrdcached", rc_write, /* user_data = */ NULL);
plugin_register_shutdown ("rrdcached", rc_shutdown);
} /* void module_register */
static rrd_queue_t *queue_tail = NULL;
static rrd_queue_t *flushq_head = NULL;
static rrd_queue_t *flushq_tail = NULL;
-static pthread_t queue_thread = 0;
+static pthread_t queue_thread;
+static int queue_thread_running = 1;
static pthread_mutex_t queue_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t queue_cond = PTHREAD_COND_INITIALIZER;
/* Write the values to the RRD-file */
srrd_update (queue_entry->filename, NULL,
values_num, (const char **)values);
- DEBUG ("rrdtool plugin: queue thread: Wrote %i values to %s",
- values_num, queue_entry->filename);
+ DEBUG ("rrdtool plugin: queue thread: Wrote %i value%s to %s",
+ values_num, (values_num == 1) ? "" : "s",
+ queue_entry->filename);
for (i = 0; i < values_num; i++)
{
return (0);
} /* int rrd_compare_numeric */
-static int rrd_write (const data_set_t *ds, const value_list_t *vl)
+static int rrd_write (const data_set_t *ds, const value_list_t *vl,
+ user_data_t __attribute__((unused)) *user_data)
{
struct stat statbuf;
char filename[512];
return (status);
} /* int rrd_write */
-static int rrd_flush (int timeout, const char *identifier)
+static int rrd_flush (int timeout, const char *identifier,
+ user_data_t __attribute__((unused)) *user_data)
{
pthread_mutex_lock (&cache_lock);
pthread_cond_signal (&queue_cond);
pthread_mutex_unlock (&queue_lock);
+ if ((queue_thread_running != 0)
+ && ((queue_head != NULL) || (flushq_head != NULL)))
+ {
+ INFO ("rrdtool plugin: Shutting down the queue thread. "
+ "This may take a while.");
+ }
+ else if (queue_thread_running != 0)
+ {
+ INFO ("rrdtool plugin: Shutting down the queue thread.");
+ }
+
/* Wait for all the values to be written to disk before returning. */
- if (queue_thread != 0)
+ if (queue_thread_running != 0)
{
pthread_join (queue_thread, NULL);
- queue_thread = 0;
+ memset (&queue_thread, 0, sizeof (queue_thread));
+ queue_thread_running = 0;
DEBUG ("rrdtool plugin: queue_thread exited.");
}
+ /* TODO: Maybe it'd be a good idea to free the cache here.. */
+
return (0);
} /* int rrd_shutdown */
pthread_mutex_unlock (&cache_lock);
- status = pthread_create (&queue_thread, NULL, rrd_queue_thread, NULL);
+ status = pthread_create (&queue_thread, /* attr = */ NULL,
+ rrd_queue_thread, /* args = */ NULL);
if (status != 0)
{
ERROR ("rrdtool plugin: Cannot create queue-thread.");
return (-1);
}
+ queue_thread_running = 1;
DEBUG ("rrdtool plugin: rrd_init: datadir = %s; stepsize = %i;"
" heartbeat = %i; rrarows = %i; xff = %lf;",
plugin_register_config ("rrdtool", rrd_config,
config_keys, config_keys_num);
plugin_register_init ("rrdtool", rrd_init);
- plugin_register_write ("rrdtool", rrd_write);
- plugin_register_flush ("rrdtool", rrd_flush);
+ plugin_register_write ("rrdtool", rrd_write, /* user_data = */ NULL);
+ plugin_register_flush ("rrdtool", rrd_flush, /* user_data = */ NULL);
plugin_register_shutdown ("rrdtool", rrd_shutdown);
}
void *sess_handle;
c_complain_t complaint;
uint32_t interval;
- time_t next_update;
data_definition_t **data_list;
int data_list_len;
- enum /******************************************************/
- { /* This host.. */
- STATE_IDLE, /* - just sits there until `next_update < interval_g' */
- STATE_WAIT, /* - waits to be queried. */
- STATE_BUSY /* - is currently being queried. */
- } state; /******************************************************/
- struct host_definition_s *next;
};
typedef struct host_definition_s host_definition_t;
/*
* Private variables
*/
-static int do_shutdown = 0;
-
-pthread_t *threads = NULL;
-int threads_num = 0;
-
static data_definition_t *data_head = NULL;
-static host_definition_t *host_head = NULL;
-static pthread_mutex_t host_lock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t host_cond = PTHREAD_COND_INITIALIZER;
+/*
+ * Prototypes
+ */
+static int csnmp_read_host (user_data_t *ud);
/*
* Private functions
*/
+static void csnmp_host_close_session (host_definition_t *host) /* {{{ */
+{
+ if (host->sess_handle == NULL)
+ return;
+
+ snmp_sess_close (host->sess_handle);
+ host->sess_handle = NULL;
+} /* }}} void csnmp_host_close_session */
+
+static void csnmp_host_definition_destroy (void *arg) /* {{{ */
+{
+ host_definition_t *hd;
+
+ hd = arg;
+
+ if (hd == NULL)
+ return;
+
+ if (hd->name != NULL)
+ {
+ DEBUG ("snmp plugin: Destroying host definition for host `%s'.",
+ hd->name);
+ }
+
+ csnmp_host_close_session (hd);
+
+ sfree (hd->name);
+ sfree (hd->address);
+ sfree (hd->community);
+ sfree (hd->data_list);
+
+ sfree (hd);
+} /* }}} void csnmp_host_definition_destroy */
+
/* Many functions to handle the configuration. {{{ */
/* First there are many functions which do configuration stuff. It's a big
* bloated and messy, I'm afraid. */
int status = 0;
int i;
+ /* Registration stuff. */
+ char cb_name[DATA_MAX_NAME_LEN];
+ user_data_t cb_data;
+ struct timespec cb_interval;
+
if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
{
WARNING ("snmp plugin: `Host' needs exactly one string argument.");
hd->sess_handle = NULL;
hd->interval = 0;
- hd->next_update = 0;
- hd->state = STATE_IDLE;
for (i = 0; i < ci->children_num; i++)
{
if (status != 0)
{
- sfree (hd->name);
- sfree (hd);
+ csnmp_host_definition_destroy (hd);
return (-1);
}
DEBUG ("snmp plugin: hd = { name = %s, address = %s, community = %s, version = %i }",
hd->name, hd->address, hd->community, hd->version);
- if (host_head == NULL)
- host_head = hd;
- else
+ ssnprintf (cb_name, sizeof (cb_name), "snmp-%s", hd->name);
+
+ memset (&cb_data, 0, sizeof (cb_data));
+ cb_data.data = hd;
+ cb_data.free_func = csnmp_host_definition_destroy;
+
+ memset (&cb_interval, 0, sizeof (cb_interval));
+ if (hd->interval != 0)
+ cb_interval.tv_sec = (time_t) hd->interval;
+
+ status = plugin_register_complex_read (cb_name, csnmp_read_host,
+ /* interval = */ &cb_interval, /* user_data = */ &cb_data);
+ if (status != 0)
{
- host_definition_t *last;
- last = host_head;
- while (last->next != NULL)
- last = last->next;
- last->next = hd;
+ ERROR ("snmp plugin: Registering complex read function failed.");
+ csnmp_host_definition_destroy (hd);
+ return (-1);
}
return (0);
/* }}} End of the config stuff. Now the interesting part begins */
-static void csnmp_host_close_session (host_definition_t *host)
-{
- if (host->sess_handle == NULL)
- return;
-
- snmp_sess_close (host->sess_handle);
- host->sess_handle = NULL;
-} /* void csnmp_host_close_session */
-
static void csnmp_host_open_session (host_definition_t *host)
{
struct snmp_session sess;
return (0);
} /* int csnmp_read_value */
-static int csnmp_read_host (host_definition_t *host)
+static int csnmp_read_host (user_data_t *ud)
{
- int i;
+ host_definition_t *host;
time_t time_start;
time_t time_end;
+ int status;
+ int success;
+ int i;
+
+ host = ud->data;
+
+ if (host->interval == 0)
+ host->interval = interval_g;
time_start = time (NULL);
DEBUG ("snmp plugin: csnmp_read_host (%s) started at %u;", host->name,
if (host->sess_handle == NULL)
return (-1);
+ success = 0;
for (i = 0; i < host->data_list_len; i++)
{
data_definition_t *data = host->data_list[i];
if (data->is_table)
- csnmp_read_table (host, data);
+ status = csnmp_read_table (host, data);
else
- csnmp_read_value (host, data);
+ status = csnmp_read_value (host, data);
+
+ if (status == 0)
+ success++;
}
time_end = time (NULL);
(unsigned int) time_end);
if ((uint32_t) (time_end - time_start) > host->interval)
{
- WARNING ("snmp plugin: Host `%s' should be queried every %i seconds, "
- "but reading all values takes %u seconds.",
+ WARNING ("snmp plugin: Host `%s' should be queried every %"PRIu32
+ " seconds, but reading all values takes %u seconds.",
host->name, host->interval, (unsigned int) (time_end - time_start));
}
+ if (success == 0)
+ return (-1);
+
return (0);
} /* int csnmp_read_host */
-static void *csnmp_read_thread (void __attribute__((unused)) *data)
-{
- host_definition_t *host;
-
- pthread_mutex_lock (&host_lock);
- while (do_shutdown == 0)
- {
- pthread_cond_wait (&host_cond, &host_lock);
-
- for (host = host_head; host != NULL; host = host->next)
- {
- if (do_shutdown != 0)
- break;
- if (host->state != STATE_WAIT)
- continue;
-
- host->state = STATE_BUSY;
- pthread_mutex_unlock (&host_lock);
- csnmp_read_host (host);
- pthread_mutex_lock (&host_lock);
- host->state = STATE_IDLE;
- } /* for (host) */
- } /* while (do_shutdown == 0) */
- pthread_mutex_unlock (&host_lock);
-
- pthread_exit ((void *) 0);
- return ((void *) 0);
-} /* void *csnmp_read_thread */
-
static int csnmp_init (void)
{
- host_definition_t *host;
- int i;
-
- if (host_head == NULL)
- {
- NOTICE ("snmp plugin: No host has been defined.");
- return (-1);
- }
-
call_snmp_init_once ();
- threads_num = 0;
- for (host = host_head; host != NULL; host = host->next)
- {
- threads_num++;
- /* We need to initialize `interval' here, because `interval_g' isn't
- * initialized during `configure'. */
- host->next_update = time (NULL);
- if (host->interval == 0)
- {
- host->interval = interval_g;
- }
- else if (host->interval < (uint32_t) interval_g)
- {
- host->interval = interval_g;
- WARNING ("snmp plugin: Data for host `%s' will be collected every %i seconds.",
- host->name, host->interval);
- }
-
- csnmp_host_open_session (host);
- } /* for (host) */
-
- /* Now start the reading threads */
- if (threads_num > 3)
- {
- threads_num = 3 + ((threads_num - 3) / 10);
- if (threads_num > 10)
- threads_num = 10;
- }
-
- threads = (pthread_t *) malloc (threads_num * sizeof (pthread_t));
- if (threads == NULL)
- {
- ERROR ("snmp plugin: malloc failed.");
- return (-1);
- }
- memset (threads, '\0', threads_num * sizeof (pthread_t));
-
- for (i = 0; i < threads_num; i++)
- pthread_create (threads + i, NULL, csnmp_read_thread, (void *) 0);
-
return (0);
} /* int csnmp_init */
-static int csnmp_read (void)
-{
- host_definition_t *host;
- time_t now;
-
- if (host_head == NULL)
- {
- INFO ("snmp plugin: No hosts configured.");
- return (-1);
- }
-
- now = time (NULL);
-
- pthread_mutex_lock (&host_lock);
- for (host = host_head; host != NULL; host = host->next)
- {
- if (host->state != STATE_IDLE)
- continue;
-
- /* Skip this host if the next or a later iteration will be sufficient. */
- if (host->next_update >= (now + interval_g))
- continue;
-
- host->state = STATE_WAIT;
- host->next_update = now + host->interval;
- } /* for (host) */
-
- pthread_cond_broadcast (&host_cond);
- pthread_mutex_unlock (&host_lock);
-
- return (0);
-} /* int csnmp_read */
-
static int csnmp_shutdown (void)
{
- host_definition_t *host_this;
- host_definition_t *host_next;
-
data_definition_t *data_this;
data_definition_t *data_next;
- int i;
-
- pthread_mutex_lock (&host_lock);
- do_shutdown = 1;
- pthread_cond_broadcast (&host_cond);
- pthread_mutex_unlock (&host_lock);
-
- for (i = 0; i < threads_num; i++)
- pthread_join (threads[i], NULL);
-
- /* Now that all the threads have exited, let's free all the global variables.
- * This isn't really neccessary, I guess, but I think it's good stile to do
- * so anyway. */
- host_this = host_head;
- host_head = NULL;
- while (host_this != NULL)
- {
- host_next = host_this->next;
-
- csnmp_host_close_session (host_this);
-
- sfree (host_this->name);
- sfree (host_this->address);
- sfree (host_this->community);
- sfree (host_this->data_list);
- sfree (host_this);
-
- host_this = host_next;
- }
+ /* When we get here, the read threads have been stopped and all the
+ * `host_definition_t' will be freed. */
+ DEBUG ("snmp plugin: Destroying all data definitions.");
data_this = data_head;
data_head = NULL;
{
plugin_register_complex_config ("snmp", csnmp_config);
plugin_register_init ("snmp", csnmp_init);
- plugin_register_read ("snmp", csnmp_read);
plugin_register_shutdown ("snmp", csnmp_shutdown);
} /* void module_register */
return (0);
} /* int sl_config */
-static void sl_log (int severity, const char *msg)
+static void sl_log (int severity, const char *msg,
+ user_data_t __attribute__((unused)) *user_data)
{
if (severity > log_level)
return;
openlog ("collectd", LOG_CONS | LOG_PID, LOG_DAEMON);
plugin_register_config ("syslog", sl_config, config_keys, config_keys_num);
- plugin_register_log ("syslog", sl_log);
+ plugin_register_log ("syslog", sl_log, /* user_data = */ NULL);
plugin_register_shutdown ("syslog", sl_shutdown);
} /* void module_register(void) */
--- /dev/null
+/**
+ * collectd - src/table.c
+ * Copyright (C) 2009 Sebastian Harl
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Sebastian Harl <sh at tokkee.org>
+ **/
+
+/*
+ * This module provides generic means to parse and dispatch tabular data.
+ */
+
+#include "collectd.h"
+#include "common.h"
+
+#include "configfile.h"
+#include "plugin.h"
+
+#define log_err(...) ERROR ("table plugin: " __VA_ARGS__)
+#define log_warn(...) WARNING ("table plugin: " __VA_ARGS__)
+
+/*
+ * private data types
+ */
+
+typedef struct {
+ char *type;
+ char *instance_prefix;
+ int *instances;
+ size_t instances_num;
+ int *values;
+ size_t values_num;
+
+ const data_set_t *ds;
+} tbl_result_t;
+
+typedef struct {
+ char *file;
+ char *sep;
+ char *instance;
+
+ tbl_result_t *results;
+ size_t results_num;
+
+ size_t max_colnum;
+} tbl_t;
+
+static void tbl_result_setup (tbl_result_t *res)
+{
+ res->type = NULL;
+
+ res->instance_prefix = NULL;
+ res->instances = NULL;
+ res->instances_num = 0;
+
+ res->values = NULL;
+ res->values_num = 0;
+
+ res->ds = NULL;
+} /* tbl_result_setup */
+
+static void tbl_result_clear (tbl_result_t *res)
+{
+ sfree (res->type);
+
+ sfree (res->instance_prefix);
+ sfree (res->instances);
+ res->instances_num = 0;
+
+ sfree (res->values);
+ res->values_num = 0;
+
+ res->ds = NULL;
+} /* tbl_result_clear */
+
+static void tbl_setup (tbl_t *tbl, char *file)
+{
+ tbl->file = sstrdup (file);
+ tbl->sep = NULL;
+ tbl->instance = NULL;
+
+ tbl->results = NULL;
+ tbl->results_num = 0;
+
+ tbl->max_colnum = 0;
+} /* tbl_setup */
+
+static void tbl_clear (tbl_t *tbl)
+{
+ size_t i;
+
+ sfree (tbl->file);
+ sfree (tbl->sep);
+ sfree (tbl->instance);
+
+ for (i = 0; i < tbl->results_num; ++i)
+ tbl_result_clear (tbl->results + i);
+ sfree (tbl->results);
+ tbl->results_num = 0;
+
+ tbl->max_colnum = 0;
+} /* tbl_clear */
+
+static tbl_t *tables;
+static size_t tables_num;
+
+/*
+ * configuration handling
+ */
+
+static int tbl_config_set_s (char *name, char **var, oconfig_item_t *ci)
+{
+ if ((1 != ci->values_num)
+ || (OCONFIG_TYPE_STRING != ci->values[0].type)) {
+ log_err ("\"%s\" expects a single string argument.", name);
+ return 1;
+ }
+
+ sfree (*var);
+ *var = sstrdup (ci->values[0].value.string);
+ return 0;
+} /* tbl_config_set_separator */
+
+static int tbl_config_append_array_i (char *name, int **var, size_t *len,
+ oconfig_item_t *ci)
+{
+ int *tmp;
+
+ size_t i;
+
+ if (1 > ci->values_num) {
+ log_err ("\"%s\" expects at least one argument.", name);
+ return 1;
+ }
+
+ for (i = 0; i < ci->values_num; ++i) {
+ if (OCONFIG_TYPE_NUMBER != ci->values[i].type) {
+ log_err ("\"%s\" expects numerical arguments only.", name);
+ return 1;
+ }
+ }
+
+ *len += ci->values_num;
+ tmp = (int *)realloc (*var, *len * sizeof (**var));
+ if (NULL == tmp) {
+ char errbuf[1024];
+ log_err ("realloc failed: %s.",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return -1;
+ }
+
+ *var = tmp;
+
+ for (i = *len - ci->values_num; i < *len; ++i)
+ (*var)[i] = (int)ci->values[i].value.number;
+ return 0;
+} /* tbl_config_append_array_s */
+
+static int tbl_config_result (tbl_t *tbl, oconfig_item_t *ci)
+{
+ tbl_result_t *res;
+
+ int status = 0;
+ size_t i;
+
+ if (0 != ci->values_num) {
+ log_err ("<Result> does not expect any arguments.");
+ return 1;
+ }
+
+ res = (tbl_result_t *)realloc (tbl->results,
+ (tbl->results_num + 1) * sizeof (*tbl->results));
+ if (NULL == tbl) {
+ char errbuf[1024];
+ log_err ("realloc failed: %s.",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return -1;
+ }
+
+ tbl->results = res;
+ ++tbl->results_num;
+
+ res = tbl->results + tbl->results_num - 1;
+ tbl_result_setup (res);
+
+ for (i = 0; i < ci->children_num; ++i) {
+ oconfig_item_t *c = ci->children + i;
+
+ if (0 == strcasecmp (c->key, "Type"))
+ tbl_config_set_s (c->key, &res->type, c);
+ else if (0 == strcasecmp (c->key, "InstancePrefix"))
+ tbl_config_set_s (c->key, &res->instance_prefix, c);
+ else if (0 == strcasecmp (c->key, "InstancesFrom"))
+ tbl_config_append_array_i (c->key,
+ &res->instances, &res->instances_num, c);
+ else if (0 == strcasecmp (c->key, "ValuesFrom"))
+ tbl_config_append_array_i (c->key,
+ &res->values, &res->values_num, c);
+ else
+ log_warn ("Ignoring unknown config key \"%s\" "
+ " in <Result>.", c->key);
+ }
+
+ if (NULL == res->type) {
+ log_err ("No \"Type\" option specified for <Result> "
+ "in table \"%s\".", tbl->file);
+ status = 1;
+ }
+
+ if (NULL == res->values) {
+ log_err ("No \"ValuesFrom\" option specified for <Result> "
+ "in table \"%s\".", tbl->file);
+ status = 1;
+ }
+
+ if (0 != status) {
+ tbl_result_clear (res);
+ --tbl->results_num;
+ return status;
+ }
+ return 0;
+} /* tbl_config_result */
+
+static int tbl_config_table (oconfig_item_t *ci)
+{
+ tbl_t *tbl;
+
+ int status = 0;
+ size_t i;
+
+ if ((1 != ci->values_num)
+ || (OCONFIG_TYPE_STRING != ci->values[0].type)) {
+ log_err ("<Table> expects a single string argument.");
+ return 1;
+ }
+
+ tbl = (tbl_t *)realloc (tables, (tables_num + 1) * sizeof (*tables));
+ if (NULL == tbl) {
+ char errbuf[1024];
+ log_err ("realloc failed: %s.",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return -1;
+ }
+
+ tables = tbl;
+ ++tables_num;
+
+ tbl = tables + tables_num - 1;
+ tbl_setup (tbl, ci->values[0].value.string);
+
+ for (i = 0; i < ci->children_num; ++i) {
+ oconfig_item_t *c = ci->children + i;
+
+ if (0 == strcasecmp (c->key, "Separator"))
+ tbl_config_set_s (c->key, &tbl->sep, c);
+ else if (0 == strcasecmp (c->key, "Instance"))
+ tbl_config_set_s (c->key, &tbl->instance, c);
+ else if (0 == strcasecmp (c->key, "Result"))
+ tbl_config_result (tbl, c);
+ else
+ log_warn ("Ignoring unknown config key \"%s\" "
+ "in <Table %s>.", c->key, tbl->file);
+ }
+
+ if (NULL == tbl->sep) {
+ log_err ("Table \"%s\" does not specify any separator.", tbl->file);
+ status = 1;
+ }
+ strunescape (tbl->sep, strlen (tbl->sep) + 1);
+
+ if (NULL == tbl->instance) {
+ tbl->instance = sstrdup (tbl->file);
+ replace_special (tbl->instance, strlen (tbl->instance));
+ }
+
+ if (NULL == tbl->results) {
+ log_err ("Table \"%s\" does not specify any (valid) results.",
+ tbl->file);
+ status = 1;
+ }
+
+ if (0 != status) {
+ tbl_clear (tbl);
+ --tables_num;
+ return status;
+ }
+
+ for (i = 0; i < tbl->results_num; ++i) {
+ tbl_result_t *res = tbl->results + i;
+ size_t j;
+
+ for (j = 0; j < res->instances_num; ++j)
+ if (res->instances[j] > tbl->max_colnum)
+ tbl->max_colnum = res->instances[j];
+
+ for (j = 0; j < res->values_num; ++j)
+ if (res->values[j] > tbl->max_colnum)
+ tbl->max_colnum = res->values[j];
+ }
+ return 0;
+} /* tbl_config_table */
+
+static int tbl_config (oconfig_item_t *ci)
+{
+ size_t i;
+
+ for (i = 0; i < ci->children_num; ++i) {
+ oconfig_item_t *c = ci->children + i;
+
+ if (0 == strcasecmp (c->key, "Table"))
+ tbl_config_table (c);
+ else
+ log_warn ("Ignoring unknown config key \"%s\".", c->key);
+ }
+ return 0;
+} /* tbl_config */
+
+/*
+ * result handling
+ */
+
+static int tbl_prepare (tbl_t *tbl)
+{
+ size_t i;
+
+ for (i = 0; i < tbl->results_num; ++i) {
+ tbl_result_t *res = tbl->results + i;
+
+ res->ds = plugin_get_ds (res->type);
+ if (NULL == res->ds) {
+ log_err ("Unknown type \"%s\". See types.db(5) for details.",
+ res->type);
+ return -1;
+ }
+
+ if (res->values_num != (size_t)res->ds->ds_num) {
+ log_err ("Invalid type \"%s\". Expected %zu data source%s, "
+ "got %i.", res->type, res->values_num,
+ (1 == res->values_num) ? "" : "s",
+ res->ds->ds_num);
+ return -1;
+ }
+ }
+ return 0;
+} /* tbl_prepare */
+
+static int tbl_finish (tbl_t *tbl)
+{
+ size_t i;
+
+ for (i = 0; i < tbl->results_num; ++i)
+ tbl->results[i].ds = NULL;
+ return 0;
+} /* tbl_finish */
+
+static int tbl_result_dispatch (tbl_t *tbl, tbl_result_t *res,
+ char **fields, size_t fields_num)
+{
+ value_list_t vl = VALUE_LIST_INIT;
+ value_t values[res->values_num];
+
+ size_t i;
+
+ assert (NULL != res->ds);
+ assert (res->values_num == res->ds->ds_num);
+
+ for (i = 0; i < res->values_num; ++i) {
+ char *value;
+
+ assert (res->values[i] < fields_num);
+ value = fields[res->values[i]];
+
+ if (0 != parse_value (value, &values[i], res->ds->ds[i]))
+ return -1;
+ }
+
+ vl.values = values;
+ vl.values_len = STATIC_ARRAY_SIZE (values);
+
+ sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+ sstrncpy (vl.plugin, "table", sizeof (vl.plugin));
+ sstrncpy (vl.plugin_instance, tbl->instance, sizeof (vl.plugin_instance));
+ sstrncpy (vl.type, res->type, sizeof (vl.type));
+
+ if (0 == res->instances_num) {
+ if (NULL != res->instance_prefix)
+ sstrncpy (vl.type_instance, res->instance_prefix,
+ sizeof (vl.type_instance));
+ }
+ else {
+ char *instances[res->instances_num];
+ char instances_str[DATA_MAX_NAME_LEN];
+
+ for (i = 0; i < res->instances_num; ++i) {
+ assert (res->instances[i] < fields_num);
+ instances[i] = fields[res->instances[i]];
+ }
+
+ strjoin (instances_str, sizeof (instances_str),
+ instances, STATIC_ARRAY_SIZE (instances), "-");
+ instances_str[sizeof (instances_str) - 1] = '\0';
+
+ vl.type_instance[sizeof (vl.type_instance) - 1] = '\0';
+ if (NULL == res->instance_prefix)
+ strncpy (vl.type_instance, instances_str,
+ sizeof (vl.type_instance));
+ else
+ snprintf (vl.type_instance, sizeof (vl.type_instance),
+ "%s-%s", res->instance_prefix, instances_str);
+
+ if ('\0' != vl.type_instance[sizeof (vl.type_instance) - 1]) {
+ vl.type_instance[sizeof (vl.type_instance) - 1] = '\0';
+ log_warn ("Truncated type instance: %s.", vl.type_instance);
+ }
+ }
+
+ plugin_dispatch_values (&vl);
+ return 0;
+} /* tbl_result_dispatch */
+
+static int tbl_parse_line (tbl_t *tbl, char *line, size_t len)
+{
+ char *fields[tbl->max_colnum + 1];
+ char *ptr, *saveptr;
+
+ size_t i;
+
+ i = 0;
+ ptr = line;
+ saveptr = NULL;
+ while (NULL != (fields[i] = strtok_r (ptr, tbl->sep, &saveptr))) {
+ ptr = NULL;
+ ++i;
+
+ if (i > tbl->max_colnum)
+ break;
+ }
+
+ if (i <= tbl->max_colnum) {
+ log_err ("Not enough columns in line "
+ "(expected at least %zu, got %zu).",
+ tbl->max_colnum + 1, i);
+ return -1;
+ }
+
+ for (i = 0; i < tbl->results_num; ++i)
+ if (0 != tbl_result_dispatch (tbl, tbl->results + i,
+ fields, STATIC_ARRAY_SIZE (fields))) {
+ log_err ("Failed to dispatch result.");
+ continue;
+ }
+ return 0;
+} /* tbl_parse_line */
+
+static int tbl_read_table (tbl_t *tbl)
+{
+ FILE *fh;
+ char buf[4096];
+
+ fh = fopen (tbl->file, "r");
+ if (NULL == fh) {
+ char errbuf[1024];
+ log_err ("Failed to open file \"%s\": %s.", tbl->file,
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return -1;
+ }
+
+ buf[sizeof (buf) - 1] = '\0';
+ while (NULL != fgets (buf, sizeof (buf), fh)) {
+ if ('\0' != buf[sizeof (buf) - 1]) {
+ buf[sizeof (buf) - 1] = '\0';
+ log_err ("Table %s: Truncated line: %s", tbl->file, buf);
+ }
+
+ if (0 != tbl_parse_line (tbl, buf, sizeof (buf))) {
+ log_err ("Table %s: Failed to parse line: %s", tbl->file, buf);
+ continue;
+ }
+ }
+
+ if (0 != ferror (fh)) {
+ char errbuf[1024];
+ log_err ("Failed to read from file \"%s\": %s.", tbl->file,
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ fclose (fh);
+ return -1;
+ }
+
+ fclose (fh);
+ return 0;
+} /* tbl_read_table */
+
+/*
+ * collectd callbacks
+ */
+
+static int tbl_read (void)
+{
+ int status = -1;
+ size_t i;
+
+ if (0 == tables_num)
+ return 0;
+
+ for (i = 0; i < tables_num; ++i) {
+ tbl_t *tbl = tables + i;
+
+ if (0 != tbl_prepare (tbl)) {
+ log_err ("Failed to prepare and parse table \"%s\".", tbl->file);
+ continue;
+ }
+
+ if (0 == tbl_read_table (tbl))
+ status = 0;
+
+ tbl_finish (tbl);
+ }
+ return status;
+} /* tbl_read */
+
+static int tbl_shutdown (void)
+{
+ size_t i;
+
+ for (i = 0; i < tables_num; ++i)
+ tbl_clear (&tables[i]);
+ sfree (tables);
+ return 0;
+} /* tbl_shutdown */
+
+static int tbl_init (void)
+{
+ if (0 == tables_num)
+ return 0;
+
+ plugin_register_read ("table", tbl_read);
+ plugin_register_shutdown ("table", tbl_shutdown);
+ return 0;
+} /* tbl_init */
+
+void module_register (void)
+{
+ plugin_register_complex_config ("table", tbl_config);
+ plugin_register_init ("table", tbl_init);
+} /* module_register */
+
+/* vim: set sw=4 ts=4 tw=78 noexpandtab : */
--- /dev/null
+/**
+ * collectd - src/ted.c
+ * Copyright (C) 2009 Eric Reed
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Eric Reed <ericr at reedhome.net>
+ *
+ * This is a collectd module for The Energy Detective: A low-cost whole
+ * house energy monitoring system. For more information on TED, see
+ * http://theenergydetective.com
+ *
+ * This module was not created by Energy, Inc. nor is it supported by
+ * them in any way. It was created using information from two sources:
+ * David Satterfield's TED module for Misterhouse, and Micah Dowty's TED
+ * Python Module.
+ *
+ * This has only tested with the model 1001 RDU, with
+ * firmware version 9.01U. The USB port is uses the very common FTDI
+ * USB-to-serial chip, so the RDU will show up as a serial device on
+ * Windows, Mac OS, or Linux.
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+#include "configfile.h"
+
+#if HAVE_TERMIOS_H && HAVE_SYS_IOCTL_H && HAVE_MATH_H
+# include <termios.h>
+# include <sys/ioctl.h>
+# include <math.h>
+#else
+# error "No applicable input method."
+#endif
+
+#define EXPECTED_PACKAGE_LENGTH 278
+#define ESCAPE 0x10
+#define PKT_BEGIN 0x04
+#define PKT_END 0x03
+
+#define DEFAULT_DEVICE "/dev/ttyUSB0"
+
+static char *conf_device = NULL;
+static int conf_retries = 0;
+
+static int fd = -1;
+
+static const char *config_keys[] =
+{
+ "Device",
+ "Retries"
+};
+static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
+
+static int ted_read_value(double *ret_power, double *ret_voltage)
+{
+ unsigned char receive_buffer[300];
+ unsigned char package_buffer[300];
+ char pkt_request[1] = {0xAA};
+ int package_buffer_pos;
+
+ fd_set input;
+ struct timeval timeout;
+
+ int end_flag;
+ int escape_flag;
+
+ int status;
+
+ assert (fd >= 0);
+
+ /* Initialize the input set*/
+ FD_ZERO (&input);
+ FD_SET (fd, &input);
+
+ /* Initialize timeout structure, set to 2 seconds */
+ memset (&timeout, 0, sizeof (timeout));
+ timeout.tv_sec = 2;
+ timeout.tv_usec = 0;
+
+ /* clear out anything in the buffer */
+ tcflush (fd, TCIFLUSH);
+
+ status = write (fd, pkt_request, sizeof(pkt_request));
+ if (status <= 0)
+ {
+ ERROR ("ted plugin: swrite failed.");
+ return (-1);
+ }
+
+ /* Loop until we find the end of the package */
+ end_flag = 0;
+ escape_flag = 0;
+ package_buffer_pos = 0;
+ while (end_flag == 0)
+ {
+ ssize_t receive_buffer_length;
+ ssize_t i;
+
+ /* check for timeout or input error*/
+ status = select (fd + 1, &input, NULL, NULL, &timeout);
+ if (status == 0) /* Timeout */
+ {
+ WARNING ("ted plugin: Timeout while waiting for file descriptor "
+ "to become ready.");
+ return (-1);
+ }
+ else if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
+ {
+ /* Some signal or something. Start over.. */
+ continue;
+ }
+ else if (status < 0)
+ {
+ char errbuf[1024];
+ ERROR ("ted plugin: select failed: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (-1);
+ }
+
+ receive_buffer_length = read (fd, receive_buffer, sizeof (receive_buffer));
+ if (receive_buffer_length < 0)
+ {
+ char errbuf[1024];
+ if ((errno == EAGAIN) || (errno == EINTR))
+ continue;
+ ERROR ("ted plugin: read(2) failed: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (-1);
+ }
+ else if (receive_buffer_length == 0)
+ {
+ /* Should we close the FD in this case? */
+ WARNING ("ted plugin: Received EOF from file descriptor.");
+ return (-1);
+ }
+ else if (receive_buffer_length > sizeof (receive_buffer))
+ {
+ ERROR ("ted plugin: read(2) returned invalid value %zi.",
+ receive_buffer_length);
+ return (-1);
+ }
+
+ /*
+ * packet filter loop
+ *
+ * Handle escape sequences in `receive_buffer' and put the
+ * result in `package_buffer'.
+ */
+ /* We need to see the begin sequence first. When we receive `ESCAPE
+ * PKT_BEGIN', we set `package_buffer_pos' to zero to signal that
+ * the beginning of the package has been found. */
+
+ escape_flag = 0;
+ for (i = 0; i < receive_buffer_length; i++)
+ {
+ /* Check if previous byte was the escape byte. */
+ if (escape_flag == 1)
+ {
+ escape_flag = 0;
+ /* escape escape = single escape */
+ if ((receive_buffer[i] == ESCAPE)
+ && (package_buffer_pos >= 0))
+ {
+ package_buffer[package_buffer_pos] = ESCAPE;
+ package_buffer_pos++;
+ }
+ else if (receive_buffer[i] == PKT_BEGIN)
+ {
+ package_buffer_pos = 0;
+ }
+ else if (receive_buffer[i] == PKT_END)
+ {
+ end_flag = 1;
+ break;
+ }
+ else
+ {
+ DEBUG ("ted plugin: Unknown escaped byte: %#x",
+ (unsigned int) receive_buffer[i]);
+ }
+ }
+ else if (receive_buffer[i] == ESCAPE)
+ {
+ escape_flag = 1;
+ }
+ /* if we are in a package add byte to buffer
+ * otherwise throw away */
+ else if (package_buffer_pos >= 0)
+ {
+ package_buffer[package_buffer_pos] = receive_buffer[i];
+ package_buffer_pos++;
+ }
+ } /* for (i = 0; i < receive_buffer_length; i++) */
+ } /* while (end_flag == 0) */
+
+ /* Check for errors inside the loop. */
+ if ((end_flag == 0) || (package_buffer_pos != EXPECTED_PACKAGE_LENGTH))
+ return (-1);
+
+ /*
+ * Power is at positions 247 and 248 (LSB first) in [10kW].
+ * Voltage is at positions 251 and 252 (LSB first) in [.1V].
+ *
+ * Power is in 10 Watt steps
+ * Voltage is in volts
+ */
+ *ret_power = 10.0 * (double) ((((int) package_buffer[248]) * 256)
+ + ((int) package_buffer[247]));
+ *ret_voltage = 0.1 * (double) ((((int) package_buffer[252]) * 256)
+ + ((int) package_buffer[251]));
+
+ /* success */
+ return (0);
+} /* int ted_read_value */
+
+static int ted_open_device (void)
+{
+ const char *dev;
+ struct termios options;
+
+ if (fd >= 0)
+ return (0);
+
+ dev = DEFAULT_DEVICE;
+ if (conf_device != NULL)
+ dev = conf_device;
+
+ fd = open (dev, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK);
+ if (fd < 0)
+ {
+ ERROR ("ted plugin: Unable to open device %s.", dev);
+ return (-1);
+ }
+
+ /* Get the current options for the port... */
+ tcgetattr(fd, &options);
+ options.c_cflag = B19200 | CS8 | CSTOPB | CREAD | CLOCAL;
+ options.c_iflag = IGNBRK | IGNPAR;
+ options.c_oflag = 0;
+ options.c_lflag = 0;
+ options.c_cc[VTIME] = 20;
+ options.c_cc[VMIN] = 250;
+
+ /* Set the new options for the port... */
+ tcflush(fd, TCIFLUSH);
+ tcsetattr(fd, TCSANOW, &options);
+
+ INFO ("ted plugin: Successfully opened %s.", dev);
+ return (0);
+} /* int ted_open_device */
+
+static void ted_submit (char *type, double value)
+{
+ value_t values[1];
+ value_list_t vl = VALUE_LIST_INIT;
+
+ values[0].gauge = value;
+
+ vl.time = time (NULL);
+ vl.values = values;
+ vl.values_len = 1;
+ sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+ sstrncpy (vl.plugin, "ted", sizeof (vl.plugin));
+ sstrncpy (vl.type, type, sizeof (vl.type));
+
+ plugin_dispatch_values (&vl);
+}
+
+static int ted_config (const char *key, const char *value)
+{
+ if (strcasecmp ("Device", key) == 0)
+ {
+ sfree (conf_device);
+ conf_device = sstrdup (value);
+ }
+ else if (strcasecmp ("Retries", key) == 0)
+ {
+ int tmp;
+
+ tmp = atoi (value);
+ if (tmp < 0)
+ {
+ WARNING ("ted plugin: Invalid retry count: %i", tmp);
+ return (1);
+ }
+ conf_retries = tmp;
+ }
+ else
+ {
+ ERROR ("ted plugin: Unknown config option: %s", key);
+ return (-1);
+ }
+
+ return (0);
+} /* int ted_config */
+
+static int ted_read (void)
+{
+ double power;
+ double voltage;
+ int status;
+ int i;
+
+ status = ted_open_device ();
+ if (status != 0)
+ return (-1);
+
+ power = NAN;
+ voltage = NAN;
+ for (i = 0; i <= conf_retries; i++)
+ {
+ status = ted_read_value (&power, &voltage);
+ if (status == 0)
+ break;
+ }
+
+ if (status != 0)
+ return (-1);
+
+ ted_submit ("power", power);
+ ted_submit ("voltage", voltage);
+
+ return (0);
+} /* int ted_read */
+
+static int ted_shutdown (void)
+{
+ if (fd >= 0)
+ {
+ close (fd);
+ fd = -1;
+ }
+
+ return (0);
+} /* int ted_shutdown */
+
+void module_register (void)
+{
+ plugin_register_config ("ted", ted_config,
+ config_keys, config_keys_num);
+ plugin_register_read ("ted", ted_read);
+ plugin_register_shutdown ("ted", ted_shutdown);
+} /* void module_register */
+
+/* vim: set sw=4 et : */
multimeter value:GAUGE:U:U
mysql_commands value:COUNTER:0:U
mysql_handler value:COUNTER:0:U
+mysql_log_position value:COUNTER:0:4294967295
mysql_octets rx:COUNTER:0:4294967295, tx:COUNTER:0:4294967295
mysql_qcache hits:COUNTER:0:U, inserts:COUNTER:0:U, not_cached:COUNTER:0:U, lowmem_prunes:COUNTER:0:U, queries_in_cache:GAUGE:0:U
mysql_threads running:GAUGE:0:U, connected:GAUGE:0:U, cached:GAUGE:0:U, created:COUNTER:0:U
pg_scan value:COUNTER:0:U
pg_xact value:COUNTER:0:U
ping ping:GAUGE:0:65535
+ping_droprate value:GAUGE:0:100
+ping_stddev value:GAUGE:0:65535
players value:GAUGE:0:1000000
power value:GAUGE:0:U
+protocol_counter value:COUNTER:0:U
ps_count processes:GAUGE:0:1000000, threads:GAUGE:0:1000000
ps_cputime user:COUNTER:0:16000000, syst:COUNTER:0:16000000
ps_pagefaults minflt:COUNTER:0:9223372036854775807, majflt:COUNTER:0:9223372036854775807
time_dispersion seconds:GAUGE:-1000000:1000000
timeleft timeleft:GAUGE:0:3600
time_offset seconds:GAUGE:-1000000:1000000
+uptime value:GAUGE:0:4294967295
users users:GAUGE:0:65535
virt_cpu_total ns:COUNTER:0:256000000000
virt_vcpu ns:COUNTER:0:1000000000
TypesDB "/opt/collectd/share/collectd/types.db"
TypesDB "/opt/collectd/etc/types.db.custom"
+B<Note>: Make sure to make this file available on all systems if you're
+sending values over the network.
+
=head1 SEE ALSO
L<collectd(1)>,
--- /dev/null
+/**
+ * collectd - src/uptime.c
+ * Copyright (C) 2009 Marco Chiappero
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; only version 2 of the License is applicable.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Marco Chiappero <marco at absence.it>
+ **/
+
+#include "collectd.h"
+#include "common.h"
+#include "plugin.h"
+
+#if KERNEL_LINUX
+# define UPTIME_FILE "/proc/uptime"
+/* No need for includes, using /proc filesystem, Linux only. */
+/* #endif KERNEL_LINUX */
+
+#elif HAVE_LIBKSTAT
+/* Using kstats chain to retrieve the boot time, this applies to:
+ * - Solaris / OpenSolaris
+ */
+/* #endif HAVE_LIBKSTAT */
+
+#elif HAVE_SYS_SYSCTL_H
+# include <sys/sysctl.h>
+/* Using sysctl interface to retrieve the boot time, this applies to:
+ * - *BSD
+ * - Darwin / OS X
+ */
+/* #endif HAVE_SYS_SYSCTL_H */
+
+#else
+# error "No applicable input method."
+#endif
+
+/*
+ * Global variables
+ */
+#if KERNEL_LINUX
+/* global variables not needed */
+/* #endif KERNEL_LINUX */
+
+#elif HAVE_LIBKSTAT
+static time_t boottime;
+extern kstat_ctl_t *kc;
+/* #endif HAVE_LIBKSTAT */
+
+#elif HAVE_SYS_SYSCTL_H
+static time_t boottime;
+#endif
+
+static void uptime_submit (gauge_t uptime)
+{
+ value_t values[1];
+ value_list_t vl = VALUE_LIST_INIT;
+
+ values[0].gauge = uptime;
+
+ vl.values = values;
+ vl.values_len = 1;
+
+ sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+ sstrncpy (vl.plugin, "uptime", sizeof (vl.plugin));
+ sstrncpy (vl.type, "uptime", sizeof (vl.type));
+
+ plugin_dispatch_values (&vl);
+}
+
+#if !defined(KERNEL_LINUX) || !KERNEL_LINUX
+static int uptime_init (void)
+{
+/* NOTE
+
+ On unix systems other than Linux there is no /proc filesystem which
+ calculates the uptime every time we call a read for the /proc/uptime
+ file, the only information available is the boot time (in unix time,
+ since epoch). Hence there is no need to read, every time the
+ plugin_read is called, a value that won't change: this is a right
+ task for the uptime_init function. However, since uptime_init is run
+ only once, if the function fails in retrieving the boot time, the
+ plugin is unregistered and there is no chance to try again later.
+ Nevertheless, this is very unlikely to happen.
+ */
+
+# if HAVE_LIBKSTAT
+ kstat_t *ksp;
+ kstat_named_t *knp;
+
+ ksp = NULL;
+ knp = NULL;
+
+ /* kstats chain already opened by update_kstat (using *kc), let's verify everything went fine. */
+ if (kc == NULL)
+ {
+ ERROR ("uptime plugin: kstat chain control structure not available.");
+ return (-1);
+ }
+
+ ksp = kstat_lookup (kc, "unix", 0, "system_misc");
+ if (ksp == NULL)
+ {
+ ERROR ("uptime plugin: Cannot find unix:0:system_misc kstat.");
+ return (-1);
+ }
+
+ if (kstat_read (kc, ksp, NULL) < 0)
+ {
+ ERROR ("uptime plugin: kstat_read failed.");
+ return (-1);
+ }
+
+ knp = (kstat_named_t *) kstat_data_lookup (ksp, "boot_time");
+ if (knp == NULL)
+ {
+ ERROR ("uptime plugin: kstat_data_lookup (boot_time) failed.");
+ return (-1);
+ }
+
+ boottime = (time_t) knp->value.ui32;
+/* #endif HAVE_LIBKSTAT */
+
+# elif HAVE_SYS_SYSCTL_H
+ struct timeval boottv;
+ size_t boottv_len;
+ int status;
+
+ int mib[2];
+
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_BOOTTIME;
+
+ memset (&boottv, 0, sizeof (boottv));
+ boottv_len = sizeof (boottv);
+
+ status = sysctl (mib, STATIC_ARRAY_SIZE (mib), &boottv, &boottv_len,
+ /* new_value = */ NULL, /* new_length = */ 0);
+ if (status != 0)
+ {
+ char errbuf[1024];
+ ERROR ("uptime plugin: No value read from sysctl interface: %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (-1);
+ }
+
+ boottime = boottv.tv_sec;
+ if (boottime == 0)
+ {
+ ERROR ("uptime plugin: sysctl(3) returned success, "
+ "but `boottime' is zero!");
+ return (-1);
+ }
+#endif /* HAVE_SYS_SYSCTL_H */
+
+ return (0);
+
+}
+#endif /* !KERNEL_LINUX */
+
+static int uptime_read (void)
+{
+ gauge_t uptime;
+
+#if KERNEL_LINUX
+ FILE *fh;
+
+ fh = fopen (UPTIME_FILE, "r");
+
+ if (fh == NULL)
+ {
+ char errbuf[1024];
+ ERROR ("uptime plugin: Cannot open "UPTIME_FILE": %s",
+ sstrerror (errno, errbuf, sizeof (errbuf)));
+ return (-1);
+ }
+
+ if ( fscanf (fh, "%lf", &uptime) < 1 )
+ {
+ WARNING ("uptime plugin: No value read from "UPTIME_FILE);
+ fclose (fh);
+ return (-1);
+ }
+
+ fclose (fh);
+/* #endif KERNEL_LINUX */
+
+#elif HAVE_LIBKSTAT || HAVE_SYS_SYSCTL_H
+ time_t elapsed;
+
+ elapsed = time (NULL) - boottime;
+
+ uptime = (gauge_t) elapsed;
+#endif /* HAVE_LIBKSTAT || HAVE_SYS_SYSCTL_H */
+
+ uptime_submit (uptime);
+
+ return (0);
+}
+
+void module_register (void)
+{
+#if !defined(KERNEL_LINUX) || !KERNEL_LINUX
+ plugin_register_init ("uptime", uptime_init);
+#endif
+ plugin_register_read ("uptime", uptime_read);
+} /* void module_register */
/**
* collectd - src/utils_cms_putval.c
- * Copyright (C) 2007,2008 Florian octo Forster
+ * Copyright (C) 2007-2009 Florian octo Forster
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
return -1; \
}
-static int parse_value (const data_set_t *ds, value_list_t *vl,
+static int dispatch_values (const data_set_t *ds, value_list_t *vl,
FILE *fh, char *buffer)
{
char *dummy;
break;
}
- if (strcmp (ptr, "U") == 0)
+ if ((strcmp (ptr, "U") == 0) && (ds->ds[i].type == DS_TYPE_GAUGE))
vl->values[i].gauge = NAN;
- else if (ds->ds[i].type == DS_TYPE_COUNTER)
- vl->values[i].counter = atoll (ptr);
- else if (ds->ds[i].type == DS_TYPE_GAUGE)
- vl->values[i].gauge = atof (ptr);
+ else if (0 != parse_value (ptr, &vl->values[i], ds->ds[i]))
+ {
+ print_to_socket (fh, "-1 Failed to parse value `%s'.\n", ptr);
+ return (-1);
+ }
i++;
} /* while (strtok_r) */
{
char identifier[128];
FORMAT_VL (identifier, sizeof (identifier), vl, ds);
- ERROR ("cmd putval: parse_value: "
+ ERROR ("cmd putval: dispatch_values: "
"Number of values incorrect: "
"Got %i, expected %i. Identifier is `%s'.",
i, vl->values_len, identifier);
plugin_dispatch_values (vl);
return (0);
-} /* int parse_value */
+} /* int dispatch_values */
static int set_option (value_list_t *vl, const char *key, const char *value)
{
}
assert (string != NULL);
- status = parse_value (ds, &vl, fh, string);
+ status = dispatch_values (ds, &vl, fh, string);
if (status != 0)
{
/* An error has already been printed. */
{
value_list_t vl = VALUE_LIST_INIT;
value_t value;
- char *endptr;
+ char *value_str;
assert (r->legacy_mode == 1);
assert (r->ds != NULL);
vl.values = &value;
vl.values_len = 1;
- endptr = NULL;
- errno = 0;
- if (r->ds->ds[0].type == DS_TYPE_COUNTER)
- vl.values[0].counter = (counter_t) strtoll (column_values[r->legacy_position],
- &endptr, /* base = */ 0);
- else if (r->ds->ds[0].type == DS_TYPE_GAUGE)
- vl.values[0].gauge = (gauge_t) strtod (column_values[r->legacy_position],
- &endptr);
- else
- errno = EINVAL;
-
- if ((endptr == column_values[r->legacy_position]) || (errno != 0))
+ value_str = column_values[r->legacy_position];
+ if (0 != parse_value (value_str, &vl.values[0], r->ds->ds[0]))
{
- WARNING ("db query utils: udb_result_submit: Parsing `%s' as %s failed.",
- column_values[r->legacy_position],
+ ERROR ("db query utils: udb_legacy_result_handle_result: "
+ "Parsing `%s' as %s failed.", value_str,
(r->ds->ds[0].type == DS_TYPE_COUNTER) ? "counter" : "gauge");
- vl.values[0].gauge = NAN;
+ errno = EINVAL;
+ return (-1);
}
sstrncpy (vl.host, q->host, sizeof (vl.host));
/*
* Result private functions
*/
-static void udb_result_submit (udb_result_t *r, udb_query_t *q) /* {{{ */
+static int udb_result_submit (udb_result_t *r, udb_query_t *q) /* {{{ */
{
value_list_t vl = VALUE_LIST_INIT;
size_t i;
if (vl.values == NULL)
{
ERROR ("db query utils: malloc failed.");
- return;
+ return (-1);
}
vl.values_len = r->ds->ds_num;
for (i = 0; i < r->values_num; i++)
{
- char *endptr;
-
- endptr = NULL;
- errno = 0;
- if (r->ds->ds[i].type == DS_TYPE_COUNTER)
- vl.values[i].counter = (counter_t) strtoll (r->values_buffer[i],
- &endptr, /* base = */ 0);
- else if (r->ds->ds[i].type == DS_TYPE_GAUGE)
- vl.values[i].gauge = (gauge_t) strtod (r->values_buffer[i], &endptr);
- else
- errno = EINVAL;
+ char *value_str = r->values_buffer[i];
- if ((endptr == r->values_buffer[i]) || (errno != 0))
+ if (0 != parse_value (value_str, &vl.values[i], r->ds->ds[i]))
{
- WARNING ("db query utils: udb_result_submit: Parsing `%s' as %s failed.",
- r->values_buffer[i],
+ ERROR ("db query utils: udb_result_submit: Parsing `%s' as %s failed.",
+ value_str,
(r->ds->ds[i].type == DS_TYPE_COUNTER) ? "counter" : "gauge");
- vl.values[i].gauge = NAN;
+ errno = EINVAL;
+ return (-1);
}
}
plugin_dispatch_values (&vl);
sfree (vl.values);
+ return (0);
} /* }}} void udb_result_submit */
static void udb_result_finish_result (udb_result_t *r) /* {{{ */
for (i = 0; i < r->values_num; i++)
r->values_buffer[i] = column_values[r->values_pos[i]];
- udb_result_submit (r, q);
-
- return (0);
+ return udb_result_submit (r, q);
} /* }}} int udb_result_handle_result */
static int udb_result_prepare_result (udb_result_t *r, /* {{{ */
--- /dev/null
+/**
+ * collectd - src/utils_heap.c
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ **/
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <pthread.h>
+
+#include "utils_heap.h"
+
+struct c_heap_s
+{
+ pthread_mutex_t lock;
+ int (*compare) (const void *, const void *);
+
+ void **list;
+ size_t list_len; /* # entries used */
+ size_t list_size; /* # entries allocated */
+};
+
+enum reheap_direction
+{
+ DIR_UP,
+ DIR_DOWN
+};
+
+static void reheap (c_heap_t *h, size_t root, enum reheap_direction dir)
+{
+ size_t left;
+ size_t right;
+ size_t min;
+ int status;
+
+ /* Calculate the positions of the children */
+ left = (2 * root) + 1;
+ if (left >= h->list_len)
+ left = 0;
+
+ right = (2 * root) + 2;
+ if (right >= h->list_len)
+ right = 0;
+
+ /* Check which one of the children is smaller. */
+ if ((left == 0) && (right == 0))
+ return;
+ else if (left == 0)
+ min = right;
+ else if (right == 0)
+ min = left;
+ else
+ {
+ status = h->compare (h->list[left], h->list[right]);
+ if (status > 0)
+ min = right;
+ else
+ min = left;
+ }
+
+ status = h->compare (h->list[root], h->list[min]);
+ if (status <= 0)
+ {
+ /* We didn't need to change anything, so the rest of the tree should be
+ * okay now. */
+ return;
+ }
+ else /* if (status > 0) */
+ {
+ void *tmp;
+
+ tmp = h->list[root];
+ h->list[root] = h->list[min];
+ h->list[min] = tmp;
+ }
+
+ if ((dir == DIR_UP) && (root == 0))
+ return;
+
+ if (dir == DIR_UP)
+ reheap (h, root / 2, dir);
+ else if (dir == DIR_DOWN)
+ reheap (h, min, dir);
+} /* void reheap */
+
+c_heap_t *c_heap_create (int (*compare) (const void *, const void *))
+{
+ c_heap_t *h;
+
+ if (compare == NULL)
+ return (NULL);
+
+ h = malloc (sizeof (*h));
+ if (h == NULL)
+ return (NULL);
+
+ memset (h, 0, sizeof (*h));
+ pthread_mutex_init (&h->lock, /* attr = */ NULL);
+ h->compare = compare;
+
+ h->list = NULL;
+ h->list_len = 0;
+ h->list_size = 0;
+
+ return (h);
+} /* c_heap_t *c_heap_create */
+
+void c_heap_destroy (c_heap_t *h)
+{
+ if (h == NULL)
+ return;
+
+ h->list_len = 0;
+ h->list_size = 0;
+ free (h->list);
+ h->list = NULL;
+
+ pthread_mutex_destroy (&h->lock);
+
+ free (h);
+} /* void c_heap_destroy */
+
+int c_heap_insert (c_heap_t *h, void *ptr)
+{
+ if ((h == NULL) || (ptr == NULL))
+ return (-EINVAL);
+
+ pthread_mutex_lock (&h->lock);
+
+ assert (h->list_len <= h->list_size);
+ if (h->list_len == h->list_size)
+ {
+ void **tmp;
+
+ tmp = realloc (h->list, (h->list_size + 16) * sizeof (*h->list));
+ if (tmp == NULL)
+ {
+ pthread_mutex_unlock (&h->lock);
+ return (-ENOMEM);
+ }
+
+ h->list = tmp;
+ h->list_size += 16;
+ }
+
+ /* Insert the new node as a leaf. */
+ h->list[h->list_len] = ptr;
+ h->list_len++;
+
+ /* Reorganize the heap from bottom up. */
+ reheap (h, /* parent of this node = */ (h->list_len - 1) / 2, DIR_UP);
+
+ pthread_mutex_unlock (&h->lock);
+ return (0);
+} /* int c_heap_insert */
+
+void *c_head_get_root (c_heap_t *h)
+{
+ void *ret = NULL;
+
+ if (h == NULL)
+ return (NULL);
+
+ pthread_mutex_lock (&h->lock);
+
+ if (h->list_len == 0)
+ {
+ pthread_mutex_unlock (&h->lock);
+ return (NULL);
+ }
+ else if (h->list_len == 1)
+ {
+ ret = h->list[0];
+ h->list[0] = NULL;
+ h->list_len = 0;
+ }
+ else /* if (h->list_len > 1) */
+ {
+ ret = h->list[0];
+ h->list[0] = h->list[h->list_len - 1];
+ h->list[h->list_len - 1] = NULL;
+ h->list_len--;
+
+ reheap (h, /* root = */ 0, DIR_DOWN);
+ }
+
+ /* free some memory */
+ if ((h->list_len + 32) < h->list_size)
+ {
+ void **tmp;
+
+ tmp = realloc (h->list, (h->list_len + 16) * sizeof (*h->list));
+ if (tmp != NULL)
+ {
+ h->list = tmp;
+ h->list_size = h->list_len + 16;
+ }
+ }
+
+ pthread_mutex_unlock (&h->lock);
+
+ return (ret);
+} /* void *c_head_get_root */
+
+/* vim: set sw=2 sts=2 et fdm=marker : */
--- /dev/null
+/**
+ * collectd - src/utils_heap.h
+ * Copyright (C) 2009 Florian octo Forster
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Authors:
+ * Florian octo Forster <octo at verplant.org>
+ **/
+
+#ifndef UTILS_HEAP_H
+#define UTILS_HEAP_H 1
+
+struct c_heap_s;
+typedef struct c_heap_s c_heap_t;
+
+/*
+ * NAME
+ * c_heap_create
+ *
+ * DESCRIPTION
+ * Allocates a new heap.
+ *
+ * PARAMETERS
+ * `compare' The function-pointer `compare' is used to compare two keys. It
+ * has to return less than zero if it's first argument is smaller
+ * then the second argument, more than zero if the first argument
+ * is bigger than the second argument and zero if they are equal.
+ * If your keys are char-pointers, you can use the `strcmp'
+ * function from the libc here.
+ *
+ * RETURN VALUE
+ * A c_heap_t-pointer upon success or NULL upon failure.
+ */
+c_heap_t *c_heap_create (int (*compare) (const void *, const void *));
+
+/*
+ * NAME
+ * c_heap_destroy
+ *
+ * DESCRIPTION
+ * Deallocates a heap. Stored value- and key-pointer are lost, but of course
+ * not freed.
+ */
+void c_heap_destroy (c_heap_t *h);
+
+/*
+ * NAME
+ * c_heap_insert
+ *
+ * DESCRIPTION
+ * Stores the key-value-pair in the heap pointed to by `h'.
+ *
+ * PARAMETERS
+ * `h' Heap to store the data in.
+ * `ptr' Value to be stored. This is typically a pointer to a data
+ * structure. The data structure is of course *not* copied and may
+ * not be free'd before the pointer has been removed from the heap
+ * again.
+ *
+ * RETURN VALUE
+ * Zero upon success, non-zero otherwise. It's less than zero if an error
+ * occurred or greater than zero if the key is already stored in the tree.
+ */
+int c_heap_insert (c_heap_t *h, void *ptr);
+
+/*
+ * NAME
+ * c_head_get_root
+ *
+ * DESCRIPTION
+ * Removes the value at the root of the heap and returns both, key and value.
+ *
+ * PARAMETERS
+ * `h' Heap to remove key-value-pair from.
+ *
+ * RETURN VALUE
+ * The pointer passed to `c_heap_insert' or NULL if there are no more
+ * elements in the heap (or an error occurred).
+ */
+void *c_head_get_root (c_heap_t *h);
+
+#endif /* UTILS_HEAP_H */
+/* vim: set sw=2 sts=2 et : */
projects / collectd.git / commitdiff