librrd 0.1.2 → 0.2.0

data/CHANGES.md

@@ -1,8 +1,12 @@
 ChangeLog
 =========
 
+# 0.2.0
+* Add RRDtool 1.2 bindings.
+* Fix build on OpenBSD.
+
 # 0.1.2
-* Fix compilation on 1.9.2 by backporting a fix from the rrdtool svn. (r2132)
+* Fix compilation on 1.9.2 by backporting a fix from the RRDtool svn. (r2132)
 
 # 0.1.1
 * Remove wrong dependency from gemspec.

data/README.md

@@ -3,24 +3,22 @@ librrd
 
 # Description
 
-This gem includes the [rrdtool](http://www.mrtg.org/rrdtool/) Ruby bindings.
-It got created because it's difficult to get the rrdtool bindings if you don't
-use the Ruby distribution included in your package system.
+This gem includes the [RRDtool](http://www.mrtg.org/rrdtool/) Ruby bindings from
+the RRDtool sources. It should help people that are unable to use or don't have
+some kind of `librrd-ruby` operating system package.
 
 The `extconf.rb` tries to guess the librrd version installed on your system.
 If it doesn't work, please try to adjust the `ext/librrd/extconf.rb` file
 and submit a pull request or open an issue.
 
-The following systems have been tested.
+The following systems, RRDtool versions and Ruby versions  have been tested.
 
-* Ubuntu 10.04 LTS (librrd-1.3.8)
-
-The following Ruby versions have been tested with [RVM](http://rvm.beginrescueend.com/).
-
-* ruby 1.9.2p0
-* ruby 1.8.7p302
-* rubinius 1.1.0
-* ruby-enterpriseedition 1.8.7 2010.02
+* Ubuntu 10.04 LTS (RRDtool 1.3.8)
+  * Ruby 1.9.2p0, 1.8.7p302
+  * Rubinius 1.1.0
+  * ruby-enterpriseedition 1.8.7 2010.02
+* OpenBSD 4.8 (RRDtool 1.2.30)
+  * Ruby 1.9.2p0, 1.8.7p302
 
 # Installation
 
@@ -31,8 +29,9 @@ Make sure you have the development package of `librrd` installed.
 
 # Contribute
 
-Please test the gem on different systems and report success and/or failure.
-Open issues and/or submit pull requests with fixes.
+Please test the gem on different systems with different RRDtool versions
+and report success and/or failure. Open issues and/or submit pull
+requests with fixes.
 
 Thank you!
 
@@ -42,11 +41,11 @@ Thank you!
 
 # Maintainer
 
-Bernd Ahlers <bernd@tuneafish.de>
+Bernd Ahlers
 
 # Copyright
 
-Since the files have been taken from the [rrdtool](http://www.mrtg.org/rrdtool/)
+Since the files have been taken from the [RRDtool](http://www.mrtg.org/rrdtool/)
 sources, all files in this project are available under the
 [GNU General Public License](http://www.gnu.org/copyleft/gpl.html). See the
 COPYING and COPYRIGHT for details.

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/ext/librrd/1.2/main.c

@@ -0,0 +1,259 @@
+/* $Id: main.c 1212 2007-11-08 10:13:48Z oetiker $
+ * Substantial penalty for early withdrawal.
+ */
+
+#include <unistd.h>
+#include <ruby.h>
+#include <rrd.h>
+#include "rrd_tool.h"
+
+typedef struct string_arr_t {
+    int len;
+    char **strings;
+} string_arr;
+
+VALUE mRRD;
+VALUE rb_eRRDError;
+
+typedef int (*RRDFUNC)(int argc, char ** argv);
+#define RRD_CHECK_ERROR  \
+    if (rrd_test_error()) \
+      rb_raise(rb_eRRDError, rrd_get_error()); \
+    rrd_clear_error();
+
+string_arr string_arr_new(VALUE rb_strings)
+{
+    string_arr a;
+    char buf[64];
+    int i;
+   
+    Check_Type(rb_strings, T_ARRAY);
+    a.len = RARRAY_LEN(rb_strings) + 1;
+
+    a.strings = malloc(a.len * sizeof(char *));
+    a.strings[0] = "dummy";     /* first element is a dummy element */
+
+    for (i = 0; i < a.len - 1; i++) {
+        VALUE v = rb_ary_entry(rb_strings, i);
+        switch (TYPE(v)) {
+        case T_STRING:
+            a.strings[i + 1] = strdup(StringValuePtr(v));
+            break;
+        case T_FIXNUM:
+            snprintf(buf, 63, "%d", FIX2INT(v));
+            a.strings[i + 1] = strdup(buf);
+            break;
+        default:
+            rb_raise(rb_eTypeError, "invalid argument - %s, expected T_STRING or T_FIXNUM on index %d", rb_class2name(CLASS_OF(v)), i);
+            break;
+        }
+    }
+
+    return a;
+}
+
+void string_arr_delete(string_arr a)
+{
+    int i;
+
+    /* skip dummy first entry */
+    for (i = 1; i < a.len; i++) {
+        free(a.strings[i]);
+    }
+
+    free(a.strings);
+}
+
+void reset_rrd_state()
+{
+    optind = 0; 
+    opterr = 0;
+    rrd_clear_error();
+}
+
+VALUE rrd_call(RRDFUNC func, VALUE args)
+{
+    string_arr a;
+
+    a = string_arr_new(args);
+    reset_rrd_state();
+    func(a.len, a.strings);
+    string_arr_delete(a);
+
+    RRD_CHECK_ERROR
+
+    return Qnil;
+}
+
+VALUE rb_rrd_create(VALUE self, VALUE args)
+{
+    return rrd_call(rrd_create, args);
+}
+
+VALUE rb_rrd_dump(VALUE self, VALUE args)
+{
+    return rrd_call(rrd_dump, args);
+}
+
+VALUE rb_rrd_fetch(VALUE self, VALUE args)
+{
+    string_arr a;
+    unsigned long i, j, k, step, ds_cnt;
+    rrd_value_t *raw_data;
+    char **raw_names;
+    VALUE data, names, result;
+    time_t start, end;
+
+    a = string_arr_new(args);
+    reset_rrd_state();
+    rrd_fetch(a.len, a.strings, &start, &end, &step, &ds_cnt, &raw_names, &raw_data);
+    string_arr_delete(a);
+
+    RRD_CHECK_ERROR
+
+    names = rb_ary_new();
+    for (i = 0; i < ds_cnt; i++) {
+        rb_ary_push(names, rb_str_new2(raw_names[i]));
+        free(raw_names[i]);
+    }
+    free(raw_names);
+
+    k = 0;
+    data = rb_ary_new();
+    for (i = start; i <= end; i += step) {
+        VALUE line = rb_ary_new2(ds_cnt);
+        for (j = 0; j < ds_cnt; j++) {
+            rb_ary_store(line, j, rb_float_new(raw_data[k]));
+            k++;
+        }
+        rb_ary_push(data, line);
+    }
+    free(raw_data);
+   
+    result = rb_ary_new2(4);
+    rb_ary_store(result, 0, INT2NUM(start));
+    rb_ary_store(result, 1, INT2NUM(end));
+    rb_ary_store(result, 2, names);
+    rb_ary_store(result, 3, data);
+    return result;
+}
+
+VALUE rb_rrd_graph(VALUE self, VALUE args)
+{
+    string_arr a;
+    char **calcpr, **p;
+    VALUE result, print_results;
+    int xsize, ysize;
+    double ymin, ymax;
+
+    a = string_arr_new(args);
+    reset_rrd_state();
+    rrd_graph(a.len, a.strings, &calcpr, &xsize, &ysize, NULL, &ymin, &ymax);
+    string_arr_delete(a);
+
+    RRD_CHECK_ERROR
+
+    result = rb_ary_new2(3);
+    print_results = rb_ary_new();
+    p = calcpr;
+    for (p = calcpr; p && *p; p++) {
+        rb_ary_push(print_results, rb_str_new2(*p));
+        free(*p);
+    }
+    free(calcpr);
+    rb_ary_store(result, 0, print_results);
+    rb_ary_store(result, 1, INT2FIX(xsize));
+    rb_ary_store(result, 2, INT2FIX(ysize));
+    return result;
+}
+
+VALUE rb_rrd_info(VALUE self, VALUE args)
+{
+    string_arr a;
+    info_t *p, *data;
+    VALUE result;
+
+    a = string_arr_new(args);
+    data = rrd_info(a.len, a.strings);
+    string_arr_delete(a);
+
+    RRD_CHECK_ERROR
+
+    result = rb_hash_new();
+    while (data) {
+        VALUE key = rb_str_new2(data->key);
+        switch (data->type) {
+        case RD_I_VAL:
+            if (isnan(data->value.u_val)) {
+                rb_hash_aset(result, key, Qnil);
+            }
+            else {
+                rb_hash_aset(result, key, rb_float_new(data->value.u_val));
+            }
+            break;
+        case RD_I_CNT:
+            rb_hash_aset(result, key, INT2FIX(data->value.u_cnt));
+            break;
+        case RD_I_STR:
+            rb_hash_aset(result, key, rb_str_new2(data->value.u_str));
+            free(data->value.u_str);
+            break;
+        }
+        p = data;
+        data = data->next;
+        free(p);
+    }
+    return result;
+}
+
+VALUE rb_rrd_last(VALUE self, VALUE args)
+{
+    string_arr a;
+    time_t last;
+
+    a = string_arr_new(args);
+    reset_rrd_state();
+    last = rrd_last(a.len, a.strings);
+    string_arr_delete(a);
+
+    RRD_CHECK_ERROR
+
+    return rb_funcall(rb_cTime, rb_intern("at"), 1, INT2FIX(last));
+}
+
+VALUE rb_rrd_resize(VALUE self, VALUE args)
+{
+    return rrd_call(rrd_resize, args);
+}
+
+VALUE rb_rrd_restore(VALUE self, VALUE args)
+{
+    return rrd_call(rrd_restore, args);
+}
+
+VALUE rb_rrd_tune(VALUE self, VALUE args)
+{
+    return rrd_call(rrd_tune, args);
+}
+
+VALUE rb_rrd_update(VALUE self, VALUE args)
+{
+    return rrd_call(rrd_update, args);
+}
+
+void Init_RRD() 
+{
+    mRRD = rb_define_module("RRD");
+    rb_eRRDError = rb_define_class("RRDError", rb_eStandardError);
+
+    rb_define_module_function(mRRD, "create", rb_rrd_create, -2);
+    rb_define_module_function(mRRD, "dump", rb_rrd_dump, -2);
+    rb_define_module_function(mRRD, "fetch", rb_rrd_fetch, -2);
+    rb_define_module_function(mRRD, "graph", rb_rrd_graph, -2);
+    rb_define_module_function(mRRD, "last", rb_rrd_last, -2);
+    rb_define_module_function(mRRD, "resize", rb_rrd_resize, -2);
+    rb_define_module_function(mRRD, "restore", rb_rrd_restore, -2);
+    rb_define_module_function(mRRD, "tune", rb_rrd_tune, -2);
+    rb_define_module_function(mRRD, "update", rb_rrd_update, -2);
+    rb_define_module_function(mRRD, "info", rb_rrd_info, -2);
+}

data/ext/librrd/1.2/rrd_format.h

@@ -0,0 +1,398 @@
+/*****************************************************************************
+ * RRDtool 1.2.30  Copyright by Tobi Oetiker, 1997-2009
+ *****************************************************************************
+ * rrd_format.h  RRD Database Format header
+ *****************************************************************************/
+
+#ifndef _RRD_FORMAT_H
+#define _RRD_FORMAT_H
+
+#include "rrd.h"
+
+/*****************************************************************************
+ * put this in your /usr/lib/magic file (/etc/magic on HPUX)
+ *
+ *  # rrd database format
+ *  0       string          RRD\0           rrd file
+ *  >5      string          >\0             version '%s'
+ *
+ *****************************************************************************/
+
+#define RRD_COOKIE    "RRD"
+/* #define RRD_VERSION   "0002" */
+/* changed because microsecond precision requires another field */
+#define RRD_VERSION   "0003"
+#define FLOAT_COOKIE  8.642135E130
+
+#include "rrd_nan_inf.h"
+
+typedef union unival { 
+    unsigned long u_cnt; 
+    rrd_value_t   u_val;
+} unival;
+
+
+/****************************************************************************
+ * The RRD Database Structure
+ * ---------------------------
+ * 
+ * In oder to properly describe the database structure lets define a few
+ * new words:
+ *
+ * ds - Data Source (ds) providing input to the database. A Data Source (ds)
+ *       can be a traffic counter, a temperature, the number of users logged
+ *       into a system. The rrd database format can handle the input of
+ *       several Data Sources (ds) in a singe database.
+ *  
+ * dst - Data Source Type (dst). The Data Source Type (dst) defines the rules
+ *       applied to Build Primary Data Points from the input provided by the
+ *       data sources (ds).
+ *
+ * pdp - Primary Data Point (pdp). After the database has accepted the
+ *       input from the data sources (ds). It starts building Primary
+ *       Data Points (pdp) from the data. Primary Data Points (pdp)
+ *       are evenly spaced along the time axis (pdp_step). The values
+ *       of the Primary Data Points are calculated from the values of
+ *       the data source (ds) and the exact time these values were
+ *       provided by the data source (ds).
+ *
+ * pdp_st - PDP Start (pdp_st). The moments (pdp_st) in time where
+ *       these steps occur are defined by the moments where the
+ *       number of seconds since 1970-jan-1 modulo pdp_step equals
+ *       zero (pdp_st). 
+ *
+ * cf -  Consolidation Function (cf). An arbitrary Consolidation Function (cf)
+ *       (averaging, min, max) is applied to the primary data points (pdp) to
+ *       calculate the consolidated data point.
+ *
+ * cdp - Consolidated Data Point (cdp) is the long term storage format for data
+ *       in the rrd database. Consolidated Data Points represent one or
+ *       several primary data points collected along the time axis. The
+ *       Consolidated Data Points (cdp) are stored in Round Robin Archives
+ *       (rra).
+ *
+ * rra - Round Robin Archive (rra). This is the place where the
+ *       consolidated data points (cdp) get stored. The data is
+ *       organized in rows (row) and columns (col). The Round Robin
+ *       Archive got its name from the method data is stored in
+ *       there. An RRD database can contain several Round Robin
+ *       Archives. Each Round Robin Archive can have a different row
+ *       spacing along the time axis (pdp_cnt) and a different
+ *       consolidation function (cf) used to build its consolidated
+ *       data points (cdp).  
+ * 
+ * rra_st - RRA Start (rra_st). The moments (rra_st) in time where
+ *       Consolidated Data Points (cdp) are added to an rra are
+ *       defined by the moments where the number of seconds since
+ *       1970-jan-1 modulo pdp_cnt*pdp_step equals zero (rra_st).
+ *
+ * row - Row (row). A row represent all consolidated data points (cdp)
+ *       in a round robin archive who are of the same age.
+ *       
+ * col - Column (col). A column (col) represent all consolidated
+ *       data points (cdp) in a round robin archive (rra) who
+ *       originated from the same data source (ds).
+ *
+ */
+
+/****************************************************************************
+ * POS 1: stat_head_t                           static header of the database
+ ****************************************************************************/
+
+typedef struct stat_head_t {
+
+    /* Data Base Identification Section ***/
+    char             cookie[4];          /* RRD */
+    char             version[5];         /* version of the format */
+    double           float_cookie;       /* is it the correct double
+				  	  * representation ?  */
+
+    /* Data Base Structure Definition *****/
+    unsigned long    ds_cnt;             /* how many different ds provide
+					  * input to the rrd */
+    unsigned long    rra_cnt;            /* how many rras will be maintained
+					  * in the rrd */
+    unsigned long    pdp_step;           /* pdp interval in seconds */
+
+    unival           par[10];            /* global parameters ... unused
+					    at the moment */
+} stat_head_t;
+
+
+/****************************************************************************
+ * POS 2: ds_def_t  (* ds_cnt)                        Data Source definitions
+ ****************************************************************************/
+
+enum dst_en          { DST_COUNTER=0,     /* data source types available */
+                       DST_ABSOLUTE, 
+                       DST_GAUGE,
+                       DST_DERIVE,
+					   DST_CDEF};
+
+enum ds_param_en {   DS_mrhb_cnt=0,       /* minimum required heartbeat. A
+					   * data source must provide input at
+					   * least every ds_mrhb seconds,
+					   * otherwise it is regarded dead and
+					   * will be set to UNKNOWN */             
+	             DS_min_val,	  /* the processed input of a ds must */
+                     DS_max_val,      /* be between max_val and min_val
+					   * both can be set to UNKNOWN if you
+					   * do not care. Data outside the limits
+ 					   * set to UNKNOWN */
+                     DS_cdef = DS_mrhb_cnt}; /* pointer to encoded rpn
+					   * expression only applies to DST_CDEF */
+
+/* The magic number here is one less than DS_NAM_SIZE */
+#define DS_NAM_FMT    "%19[a-zA-Z0-9_-]"
+#define DS_NAM_SIZE   20
+
+#define DST_FMT    "%19[A-Z]"
+#define DST_SIZE   20
+
+typedef struct ds_def_t {
+    char             ds_nam[DS_NAM_SIZE]; /* Name of the data source (null terminated)*/
+    char             dst[DST_SIZE];       /* Type of data source (null terminated)*/
+    unival           par[10];             /* index of this array see ds_param_en */
+} ds_def_t;
+
+/****************************************************************************
+ * POS 3: rra_def_t ( *  rra_cnt)         one for each store to be maintained
+ ****************************************************************************/
+enum cf_en           { CF_AVERAGE=0,     /* data consolidation functions */ 
+                       CF_MINIMUM, 
+                       CF_MAXIMUM,
+                       CF_LAST,
+         	       CF_HWPREDICT, 
+					   /* An array of predictions using the seasonal 
+						* Holt-Winters algorithm. Requires an RRA of type
+						* CF_SEASONAL for this data source. */
+					   CF_SEASONAL,
+					   /* An array of seasonal effects. Requires an RRA of
+						* type CF_HWPREDICT for this data source. */
+					   CF_DEVPREDICT,
+					   /* An array of deviation predictions based upon
+						* smoothed seasonal deviations. Requires an RRA of
+						* type CF_DEVSEASONAL for this data source. */
+					   CF_DEVSEASONAL,
+					   /* An array of smoothed seasonal deviations. Requires
+						* an RRA of type CF_HWPREDICT for this data source.
+						* */
+					   CF_FAILURES};
+					   /* A binary array of failure indicators: 1 indicates
+						* that the number of violations in the prescribed
+						* window exceeded the prescribed threshold. */
+
+#define MAX_RRA_PAR_EN 10
+enum rra_par_en {   RRA_cdp_xff_val=0,  /* what part of the consolidated
+                     * datapoint must be known, to produce a
+					 * valid entry in the rra */
+					RRA_hw_alpha,
+					/* exponential smoothing parameter for the intercept in
+					 * the Holt-Winters prediction algorithm. */
+					RRA_hw_beta,
+					/* exponential smoothing parameter for the slope in
+					 * the Holt-Winters prediction algorithm. */
+					RRA_dependent_rra_idx,
+					/* For CF_HWPREDICT: index of the RRA with the seasonal 
+					 * effects of the Holt-Winters algorithm (of type
+					 * CF_SEASONAL).
+					 * For CF_DEVPREDICT: index of the RRA with the seasonal
+					 * deviation predictions (of type CF_DEVSEASONAL).
+					 * For CF_SEASONAL: index of the RRA with the Holt-Winters
+					 * intercept and slope coefficient (of type CF_HWPREDICT).
+					 * For CF_DEVSEASONAL: index of the RRA with the 
+					 * Holt-Winters prediction (of type CF_HWPREDICT).
+					 * For CF_FAILURES: index of the CF_DEVSEASONAL array.
+					 * */
+					RRA_seasonal_smooth_idx,
+					/* For CF_SEASONAL and CF_DEVSEASONAL:
+					 * an integer between 0 and row_count - 1 which
+					 * is index in the seasonal cycle for applying
+					 * the period smoother. */
+				    RRA_failure_threshold,
+					/* For CF_FAILURES, number of violations within the last
+					 * window required to mark a failure. */
+                    RRA_seasonal_gamma = RRA_hw_alpha,
+					/* exponential smoothing parameter for seasonal effects.
+					 * */
+                    RRA_delta_pos = RRA_hw_alpha,
+                    RRA_delta_neg = RRA_hw_beta,
+					/* confidence bound scaling parameters for the
+					 * the FAILURES RRA. */
+                    RRA_window_len = RRA_seasonal_smooth_idx};
+					/* For CF_FAILURES, the length of the window for measuring
+					 * failures. */
+		   	
+#define CF_NAM_FMT    "%19[A-Z]"
+#define CF_NAM_SIZE   20
+
+typedef struct rra_def_t {
+    char             cf_nam[CF_NAM_SIZE];/* consolidation function (null term) */
+    unsigned long    row_cnt;            /* number of entries in the store */
+    unsigned long    pdp_cnt;            /* how many primary data points are
+					  * required for a consolidated data
+					  * point?*/
+    unival           par[MAX_RRA_PAR_EN];            /* index see rra_param_en */
+
+} rra_def_t;
+
+
+/****************************************************************************
+ ****************************************************************************
+ ****************************************************************************
+ * LIVE PART OF THE HEADER. THIS WILL BE WRITTEN ON EVERY UPDATE         *
+ ****************************************************************************
+ ****************************************************************************
+ ****************************************************************************/
+/****************************************************************************
+ * POS 4: live_head_t                    
+ ****************************************************************************/
+
+typedef struct live_head_t {
+    time_t           last_up;            /* when was rrd last updated */
+    long	     last_up_usec;	 /* micro seconds part of the
+					    update timestamp. Always >= 0 */
+} live_head_t;
+
+
+/****************************************************************************
+ * POS 5: pdp_prep_t  (* ds_cnt)                     here we prepare the pdps 
+ ****************************************************************************/
+#define LAST_DS_LEN 30 /* DO NOT CHANGE THIS ... */
+
+enum pdp_par_en {   PDP_unkn_sec_cnt=0,  /* how many seconds of the current
+					  * pdp value is unknown data? */
+
+		    PDP_val};	         /* current value of the pdp.
+					    this depends on dst */
+
+typedef struct pdp_prep_t{    
+    char last_ds[LAST_DS_LEN];           /* the last reading from the data
+					  * source.  this is stored in ASCII
+					  * to cater for very large counters
+					  * we might encounter in connection
+					  * with SNMP. */
+    unival          scratch[10];         /* contents according to pdp_par_en */
+} pdp_prep_t;
+
+/* data is passed from pdp to cdp when seconds since epoch modulo pdp_step == 0
+   obviously the updates do not occur at these times only. Especially does the
+   format allow for updates to occur at different times for each data source.
+   The rules which makes this work is as follows:
+
+   * DS updates may only occur at ever increasing points in time
+   * When any DS update arrives after a cdp update time, the *previous*
+     update cycle gets executed. All pdps are transfered to cdps and the
+     cdps feed the rras where necessary. Only then the new DS value
+     is loaded into the PDP.                                                   */
+
+
+/****************************************************************************
+ * POS 6: cdp_prep_t (* rra_cnt * ds_cnt )      data prep area for cdp values
+ ****************************************************************************/
+#define MAX_CDP_PAR_EN 10
+#define MAX_CDP_FAILURES_IDX 8 
+/* max CDP scratch entries avail to record violations for a FAILURES RRA */
+#define MAX_FAILURES_WINDOW_LEN 28
+enum cdp_par_en {  CDP_val=0,          
+                   /* the base_interval is always an
+					* average */
+		           CDP_unkn_pdp_cnt,       
+				   /* how many unknown pdp were
+               	    * integrated. This and the cdp_xff
+					* will decide if this is going to
+					* be a UNKNOWN or a valid value */
+				   CDP_hw_intercept,
+				   /* Current intercept coefficient for the Holt-Winters
+					* prediction algorithm. */
+				   CDP_hw_last_intercept,
+				   /* Last iteration intercept coefficient for the Holt-Winters
+					* prediction algorihtm. */
+				   CDP_hw_slope,
+				   /* Current slope coefficient for the Holt-Winters
+					* prediction algorithm. */
+				   CDP_hw_last_slope,
+				   /* Last iteration slope coeffient. */
+				   CDP_null_count,
+				   /* Number of sequential Unknown (DNAN) values + 1 preceding
+				    * the current prediction.
+					* */
+				   CDP_last_null_count,
+				   /* Last iteration count of Unknown (DNAN) values. */
+				   CDP_primary_val = 8,
+				   /* optimization for bulk updates: the value of the first CDP
+					* value to be written in the bulk update. */
+				   CDP_secondary_val = 9,
+				   /* optimization for bulk updates: the value of subsequent
+					* CDP values to be written in the bulk update. */
+                   CDP_hw_seasonal = CDP_hw_intercept,
+                   /* Current seasonal coefficient for the Holt-Winters
+                    * prediction algorithm. This is stored in CDP prep to avoid
+                    * redundant seek operations. */
+                   CDP_hw_last_seasonal = CDP_hw_last_intercept,
+                   /* Last iteration seasonal coeffient. */
+                   CDP_seasonal_deviation = CDP_hw_intercept,
+                   CDP_last_seasonal_deviation = CDP_hw_last_intercept,
+                   CDP_init_seasonal = CDP_null_count};
+                   /* init_seasonal is a flag which when > 0, forces smoothing updates
+                    * to occur when rra_ptr.cur_row == 0 */
+
+typedef struct cdp_prep_t{
+    unival         scratch[MAX_CDP_PAR_EN];          
+										 /* contents according to cdp_par_en *
+                                          * init state should be NAN */
+
+} cdp_prep_t;
+
+/****************************************************************************
+ * POS 7: rra_ptr_t (* rra_cnt)       pointers to the current row in each rra
+ ****************************************************************************/
+
+typedef struct rra_ptr_t {
+    unsigned long    cur_row;            /* current row in the rra*/
+} rra_ptr_t;
+
+
+/****************************************************************************
+ ****************************************************************************
+ * One single struct to hold all the others. For convenience.
+ ****************************************************************************
+ ****************************************************************************/
+typedef struct rrd_t {
+    stat_head_t      *stat_head;          /* the static header */
+    ds_def_t         *ds_def;             /* list of data source definitions */
+    rra_def_t        *rra_def;            /* list of round robin archive def */
+    live_head_t      *live_head;
+    pdp_prep_t       *pdp_prep;           /* pdp data prep area */  
+    cdp_prep_t       *cdp_prep;           /* cdp prep area */
+    rra_ptr_t        *rra_ptr;            /* list of rra pointers */
+    rrd_value_t      *rrd_value;          /* list of rrd values */
+} rrd_t;
+
+/****************************************************************************
+ ****************************************************************************
+ * AFTER the header section we have the DATA STORAGE AREA it is made up from
+ * Consolidated Data Points organized in Round Robin Archives.
+ ****************************************************************************
+ ****************************************************************************
+
+ *RRA 0
+ (0,0) .................... ( ds_cnt -1 , 0)
+ .
+ . 
+ .
+ (0, row_cnt -1) ... (ds_cnt -1, row_cnt -1)
+
+ *RRA 1
+ *RRA 2
+
+ *RRA rra_cnt -1
+ 
+ ****************************************************************************/
+
+
+#endif
+
+
+
+

data/ext/librrd/1.2/rrd_getopt.h

@@ -0,0 +1,133 @@
+/* Declarations for getopt.
+   Copyright (C) 1989,90,91,92,93,94,96,97 Free Software Foundation, Inc.
+
+   This file is part of the GNU C Library.  Its master source is NOT part of
+   the C library, however.  The master source lives in /gd/gnu/lib.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef _GETOPT_H
+#define _GETOPT_H 1
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+extern char *optarg;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns -1, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+extern int optind;
+
+/* Callers store zero here to inhibit the error message `getopt' prints
+   for unrecognized options.  */
+
+extern int opterr;
+
+/* Set to an option character which was unrecognized.  */
+
+extern int optopt;
+
+/* Describe the long-named options requested by the application.
+   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+   of `struct option' terminated by an element containing a name which is
+   zero.
+
+   The field `has_arg' is:
+   no_argument		(or 0) if the option does not take an argument,
+   required_argument	(or 1) if the option requires an argument,
+   optional_argument 	(or 2) if the option takes an optional argument.
+
+   If the field `flag' is not NULL, it points to a variable that is set
+   to the value given in the field `val' when the option is found, but
+   left unchanged if the option is not found.
+
+   To have a long-named option do something other than set an `int' to
+   a compiled-in constant, such as set a value from `optarg', set the
+   option's `flag' field to zero and its `val' field to a nonzero
+   value (the equivalent single-letter option character, if there is
+   one).  For long options that have a zero `flag' field, `getopt'
+   returns the contents of the `val' field.  */
+
+struct option
+{
+#if defined (__STDC__) && __STDC__
+  const char *name;
+#else
+  char *name;
+#endif
+  /* has_arg can't be an enum because some compilers complain about
+     type mismatches in all the code that assumes it is an int.  */
+  int has_arg;
+  int *flag;
+  int val;
+};
+
+/* Names for the values of the `has_arg' field of `struct option'.  */
+
+#define	no_argument		0
+#define required_argument	1
+#define optional_argument	2
+
+#if defined (__STDC__) && __STDC__
+#ifdef __GNU_LIBRARY__
+/* Many other libraries have conflicting prototypes for getopt, with
+   differences in the consts, in stdlib.h.  To avoid compilation
+   errors, only prototype getopt for the GNU C library.  */
+extern int getopt (int argc, char *const *argv, const char *shortopts);
+#else /* not __GNU_LIBRARY__ */
+extern int getopt ();
+#endif /* __GNU_LIBRARY__ */
+extern int getopt_long (int argc, char *const *argv, const char *shortopts,
+		        const struct option *longopts, int *longind);
+extern int getopt_long_only (int argc, char *const *argv,
+			     const char *shortopts,
+		             const struct option *longopts, int *longind);
+
+/* Internal only.  Users should not call this directly.  */
+extern int _getopt_internal (int argc, char *const *argv,
+			     const char *shortopts,
+		             const struct option *longopts, int *longind,
+			     int long_only);
+#else /* not __STDC__ */
+extern int getopt ();
+extern int getopt_long ();
+extern int getopt_long_only ();
+
+extern int _getopt_internal ();
+#endif /* __STDC__ */
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif /* _GETOPT_H */

data/ext/librrd/1.2/rrd_nan_inf.h

@@ -0,0 +1,5 @@
+#define DNAN          set_to_DNAN()
+#define DINF          set_to_DINF()
+
+double set_to_DNAN(void);
+double set_to_DINF(void);

data/ext/librrd/1.2/rrd_tool.h

@@ -0,0 +1,182 @@
+/*****************************************************************************
+ * RRDtool 1.2.30  Copyright by Tobi Oetiker, 1997-2009
+ *****************************************************************************
+ * rrd_tool.h   Common Header File
+ *****************************************************************************/
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef _RRD_TOOL_H
+#define _RRD_TOOL_H
+
+#ifdef HAVE_CONFIG_H
+#include "../rrd_config.h"
+#elif defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
+#include "../win32/config.h"
+#endif
+
+#ifdef MUST_DISABLE_SIGFPE
+#include <signal.h>
+#endif
+
+#ifdef MUST_DISABLE_FPMASK
+#include <floatingpoint.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <ctype.h>
+
+#if HAVE_SYS_PARAM_H
+#  include <sys/param.h>
+#endif
+
+#ifndef MAXPATH
+#  define MAXPATH 1024
+#endif
+
+#if HAVE_MATH_H
+# include <math.h>
+#endif
+/* Sorry: don't know autoconf as well how to check the exist of
+   dirent.h ans sys/stat.h
+*/
+
+#if HAVE_DIRENT_H
+# include <dirent.h>
+# define NAMLEN(dirent) strlen((dirent)->d_name)
+#else
+# define dirent direct
+# define NAMLEN(dirent) (dirent)->d_namlen
+# if HAVE_SYS_NDIR_H
+#  include <sys/ndir.h>
+# endif
+# if HAVE_SYS_DIR_H
+#  include <sys/dir.h>
+# endif
+# if HAVE_NDIR_H
+#  include <ndir.h>
+# endif
+#endif
+
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#if HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+
+#if HAVE_STRINGS_H
+# include <strings.h>
+#endif
+
+#include "rrd.h"
+
+#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
+
+/* Win32 only includes */
+
+#include <float.h>        /* for _isnan  */
+#include <io.h>           /* for chdir   */
+#include <process.h>      /* for getpid  */
+
+#define random rand
+#define srandom srand
+
+struct tm* localtime_r(const time_t *timep, struct tm* result);
+char* ctime_r(const time_t *timep, char* result);
+struct tm* gmtime_r(const time_t *timep, struct tm* result);
+char *strtok_r(char *str, const char *sep, char **last);
+
+#else
+
+/* unix-only includes */
+#if !defined isnan && !defined HAVE_ISNAN
+int isnan(double value);
+#endif
+
+#endif
+
+/* local include files -- need to be after the system ones */
+#include "rrd_getopt.h"
+#include "rrd_format.h"
+
+#ifndef max
+#define max(a,b) ((a) > (b) ? (a) : (b))
+#endif
+
+#ifndef min
+#define min(a,b) ((a) < (b) ? (a) : (b))
+#endif                                                   
+
+#define DIM(x) (sizeof(x)/sizeof(x[0]))
+
+/* rrd info interface */
+enum info_type   { RD_I_VAL=0,
+	       RD_I_CNT,
+	       RD_I_STR, 
+		   RD_I_INT };
+
+typedef union infoval { 
+    unsigned long u_cnt; 
+    rrd_value_t   u_val;
+    char         *u_str;
+    int		  u_int;
+} infoval;
+
+typedef struct info_t {
+    char            *key;
+    enum info_type  type;
+    union infoval   value;
+    struct info_t   *next;
+} info_t;
+
+info_t *rrd_info(int, char **);
+int rrd_lastupdate(int argc, char **argv, time_t *last_update,
+                unsigned long *ds_cnt, char ***ds_namv, char ***last_ds);
+info_t *rrd_update_v(int, char **);
+char * sprintf_alloc(char *, ...);
+info_t *info_push(info_t *, char *, enum info_type, infoval);
+
+/* HELPER FUNCTIONS */
+
+int PngSize(FILE *, long *, long *);
+
+int rrd_create_fn(const char *file_name, rrd_t *rrd);
+int rrd_fetch_fn(const char *filename, enum cf_en cf_idx,
+		 time_t *start,time_t *end,
+		 unsigned long *step,
+		 unsigned long *ds_cnt,
+		 char        ***ds_namv,
+		 rrd_value_t **data);
+
+void rrd_free(rrd_t *rrd);
+void rrd_freemem(void *mem);
+void rrd_init(rrd_t *rrd);
+
+int rrd_open(const char *file_name, FILE **in_file, rrd_t *rrd, int rdwr);
+int readfile(const char *file, char **buffer, int skipfirst);
+
+#define RRD_READONLY    0
+#define RRD_READWRITE   1
+
+enum cf_en cf_conv(const char *string);
+enum dst_en dst_conv(char *string);
+long ds_match(rrd_t *rrd,char *ds_nam);
+double rrd_diff(char *a, char *b);
+
+    /* rrd_strerror is thread safe, but still it uses a global buffer
+       (but one per thread), thus subsequent calls within a single
+       thread overwrite the same buffer */
+const char *rrd_strerror(int err);
+
+#endif
+
+#ifdef  __cplusplus
+}
+#endif

data/ext/librrd/extconf.rb

@@ -1,5 +1,13 @@
 require 'mkmf'
 
+case RUBY_PLATFORM
+when /openbsd/i
+  puts "Using OpenBSD hacks"
+  $LDFLAGS += ' -L/usr/X11R6/lib'
+  find_library('z', nil)
+  find_library('freetype', nil)
+end
+
 dir_config("rrd")
 
 # Try to detect the librrd version.
@@ -7,8 +15,10 @@ dir_config("rrd")
 # or submit a pull request. Thanks!
 if have_library("rrd", "rrd_flushcached")
   src_prefix = '1.4'
-elsif have_library("rrd", "rrd_create")
+elsif have_type("rrd_info_t", "rrd.h") and have_library("rrd", "rrd_create")
   src_prefix = '1.3'
+elsif have_library("rrd", "rrd_create")
+  src_prefix = '1.2'
 else
   puts "Unsupported librrd version, abort."
   exit 1

data/librrd.gemspec

@@ -7,11 +7,11 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'librrd'
-  s.version           = '0.1.2'
-  s.date              = '2010-10-05'
+  s.version           = '0.2.0'
+  s.date              = '2010-10-06'
 
   s.summary     = "Ruby bindings for librrd"
-  s.description = "Ruby bindings for librrd. Extracted from the rrdtool source."
+  s.description = "Ruby bindings for librrd. Extracted from the RRDtool source."
 
   s.authors  = ["Bernd Ahlers"]
   s.email    = 'bernd@tuneafish.de'
@@ -33,6 +33,11 @@ Gem::Specification.new do |s|
     README.md
     Rakefile
     VERSION
+    ext/librrd/1.2/main.c
+    ext/librrd/1.2/rrd_format.h
+    ext/librrd/1.2/rrd_getopt.h
+    ext/librrd/1.2/rrd_nan_inf.h
+    ext/librrd/1.2/rrd_tool.h
     ext/librrd/1.3/main.c
     ext/librrd/1.4/main.c
     ext/librrd/extconf.rb

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: librrd
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
   - 2
-  version: 0.1.2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Bernd Ahlers
@@ -15,11 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-05 00:00:00 +02:00
+date: 2010-10-06 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
-description: Ruby bindings for librrd. Extracted from the rrdtool source.
+description: Ruby bindings for librrd. Extracted from the RRDtool source.
 email: bernd@tuneafish.de
 executables: []
 
@@ -35,6 +35,11 @@ files:
 - README.md
 - Rakefile
 - VERSION
+- ext/librrd/1.2/main.c
+- ext/librrd/1.2/rrd_format.h
+- ext/librrd/1.2/rrd_getopt.h
+- ext/librrd/1.2/rrd_nan_inf.h
+- ext/librrd/1.2/rrd_tool.h
 - ext/librrd/1.3/main.c
 - ext/librrd/1.4/main.c
 - ext/librrd/extconf.rb