errand 0.7.0

data/.cvsignore

@@ -0,0 +1,5 @@
+Makefile
+test.png
+test.rrd
+mkmf.log
+pkg

data/.gitignore

@@ -0,0 +1,10 @@
+Makefile
+test.png
+test.rrd
+mkmf.log
+pkg
+*~
+*.gem
+*.o
+*.so
+errand.gemspec

data/AUTHORS

@@ -0,0 +1,18 @@
+Based on work of
+----------------
+Miles Egan <miles at caddr.com>
+
+
+RubyRRDtool authors + contributors
+----------------------------------
+David Bacher <drbacher at alum.mit.edu>
+Mark Probert <probertm at acm.org>  
+
+Eric Lindvall (http://github.com/eric)
+Michael Gebetsroither (http://github.com/gebi)
+schmurfy (http://github.com/schmurfy/)
+
+
+Errand is: 
+----------
+Lindsay Holmwood <lindsay@holmwood.id.au>

data/README.md

@@ -0,0 +1,94 @@
+Errand
+======
+
+Errand provides Ruby bindings for RRD functions (via librrd), and a clear
+API for interacting with RRDs. 
+
+Check under spec/ for usage examples. 
+
+Using
+=====
+
+To set up an RRD to work with (whether it exists or otherwise): 
+
+    @rrd = Errand.new(:filename => "data.rrd")
+
+To create an RRD:
+
+    @rrd.create(:sources => [
+                  {:name => "Counter", :type => :counter, :heartbeat => 1800, :min => 0, :max => 4294967295}],
+                :archives => [
+                  {:function => :average, :xff => 0.5, :steps => 1, :rows => 2400}])
+
+To update said RRD: 
+
+    @rrd.update(:sources => [{:name => "Counter", :value => 1}]
+
+To fetch that data: 
+
+    @rrd.fetch # <= {:start => Time, :end => Time, 
+                     :data => {"Counter" => [nil, nil, nil, 1]}
+
+Dependencies
+============
+
+**Errand** requires RRDtool version 1.2 or later. Some RRD functions such
+as rrddump are only available with the latest RRDtool.
+
+Installation is standard. If you've installed the gem, you should be ready
+to go. 
+
+Otherwise, simply run:
+
+    ruby extconf.rb
+    make
+    make install
+
+This should build a library named `rrd.so` in the current directory. If it 
+doesn't, please report bugs at [http://github.com/eric/rubyrrdtool/issues](http://github.com/eric/rubyrrdtool/issues)!
+
+Building gem
+============
+
+gem build errand.gemspec 
+
+Testing 
+=======
+
+Testing is done with RSpec. 
+
+To run tests: 
+
+   rake spec
+
+Todo
+====
+
+* Extend documentation with examples
+
+
+License
+=======
+
+(the MIT license)
+
+Copyright (c) 2006 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "errand"
+    gemspec.summary = "Ruby language binding for RRD tool version 1.2+"
+    gemspec.description = "Errand provides Ruby bindings for RRD functions (via librrd), and a concise DSL for interacting with RRDs."
+    gemspec.email = "lindsay@holmwood.id.au"
+    gemspec.homepage = "http://auxesis.github.com/errand"
+    gemspec.authors = ["Lindsay Holmwood"]
+    gemspec.extensions = ["extconf.rb"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+begin 
+  require 'spec/rake/spectask'
+  
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_opts = ["--options", "spec/spec.opts"]
+  end
+rescue LoadError
+  puts "RSpec not available. Install it with: gem install rspec"
+end
+  

data/VERSION

@@ -0,0 +1 @@
+0.7.0

data/extconf.rb

@@ -0,0 +1,30 @@
+# $Id: extconf.rb,v 1.4 2008/03/11 22:47:06 dbach Exp $
+
+require 'mkmf'
+
+# If there are build errors, be sure to say where your rrdtool lives:
+#
+# ruby ./extconf.rb --with-rrd-dir=/usr/local/rrdtool-1.2.12
+
+libpaths=%w(/lib /usr/lib /usr/local/lib /sw/lib /opt/local/lib)
+%w(art_lgpl_2 freetype png z).sort.reverse.each do |lib|
+	find_library(lib, nil, *libpaths)
+end
+
+dir_config("rrd")
+# rrd_first is only defined rrdtool >= 1.2.x
+have_library("rrd", "rrd_first")
+
+# rrd_dump_r has 2nd arg in rrdtool >= 1.2.14
+if try_link(<<EOF)
+#include <rrd.h>
+main()
+{
+  rrd_dump_r("/dev/null", NULL);
+}
+EOF
+    $CFLAGS += " -DHAVE_RRD_DUMP_R_2"
+end
+
+create_makefile("errand_backend")
+

data/lib/errand.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env ruby 
+
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+require 'errand_backend'
+
+class Errand
+  def initialize(opts={})
+    raise ArgumentError unless opts[:filename]
+    @filename = opts[:filename]
+    @backend = ::ErrandBackend
+  end
+
+  def dump(opts={})
+    output = opts[:filename] || ""
+    @backend.dump(@filename, output)
+  end
+
+  def last
+    @backend.last(@filename)
+  end
+
+  def fetch(opts={})
+    start  = (opts[:start] || Time.now.to_i - 3600).to_s
+    finish = (opts[:finish] || Time.now.to_i).to_s
+    function = opts[:function] ? opts[:function].to_s.upcase : "AVERAGE"
+
+    args = [@filename, "--start", start, "--end", finish, function]
+
+    data = @backend.fetch(*args)
+    start  = data[0]
+    finish = data[1]
+    labels = data[2]
+    values = data[3]
+    points = {}
+
+    # compose a saner representation of the data
+    labels.each_with_index do |label, index|
+      points[label] = []
+      values.each do |tuple|
+        value = tuple[index].nan? ? nil : tuple[index]
+        points[label] << value
+      end
+    end
+
+    {:start => start, :finish => finish, :data => points}
+  end
+
+  def create(opts={})
+    step  = (opts[:step] || 300).to_s
+    start = (opts[:start] || Time.now.to_i - 10).to_s
+
+    options = ["--step", step, "--start", start]
+
+    sources = opts[:sources].map { |source|
+      name      = source[:name]
+      type      = source[:type].to_s.upcase
+      heartbeat = source[:heartbeat]
+      min       = source[:min]
+      max       = source[:max]
+
+      ds = ["DS", name, type]
+      ds += [heartbeat, min, max] if heartbeat && min && max
+
+      ds.join(':')
+    }
+
+    archives = opts[:archives].map { |archive|
+      function = archive[:function].to_s.upcase
+      xff      = archive[:xff]
+      steps    = archive[:steps]
+      rows     = archive[:rows]
+
+      rra = ["RRA", function]
+      rra += [xff, steps, rows] if xff && steps && rows
+
+      rra.join(':')
+    }
+
+    args = options + sources + archives
+    @backend.create(@filename, *args) # * "flattens" the array
+
+    true
+  end
+
+  def update(opts={})
+    time_specified = opts[:sources].find { |source| source[:time] }
+    times = opts[:sources].map {|s| s[:time]}.sort.uniq if time_specified
+
+    sources = opts[:sources].map { |source|
+      source[:name]
+    }.join(':')
+
+    case 
+    when time_specified && times.size == 1
+      values = "#{times.first}:" + opts[:sources].map { |s|
+        s[:value]
+      }.join(':')
+
+      args = ["--template", sources, values]
+      @backend.update(@filename, *args)
+    when time_specified && times.size > 1
+      times.each do |t|
+        points = opts[:sources].find_all { |source| source[:time] == t }
+      
+        sources = points.map { |p|
+          p[:name]
+        }.join(':')
+
+        values = "#{t}:" + points.map { |p|
+          p[:value]
+        }.join(':')
+
+        args = ["--template", sources, values]
+        @backend.update(@filename, *args)
+      end
+
+    when !time_specified
+      values = "N:" + opts[:sources].map { |source|
+        source[:value]
+      }.join(':')
+
+      args = ["--template", sources, values]
+      @backend.update(@filename, *args)
+    end
+    
+    true
+  end
+
+  def info
+    @backend.info(@filename)
+  end
+
+  # ordered array of data sources as defined in rrd
+  def data_sources
+    self.info.keys.grep(/^ds\[/).map { |ds| ds[3..-1].split(']').first}.uniq                                                                                    
+  end
+
+end

data/lib/graph.rb

@@ -0,0 +1,75 @@
+#
+# ideas for a graphing DSL
+#
+
+module RRDtool
+
+  # Simple Ruby object to generate the RRD graph parameters
+  #
+  class Graph
+    
+    # Graph attributes can appear in any order
+    attr :image_file, :image_format
+    attr :title
+    attr :vertical_label
+    
+    attr :width, :height
+    attr :start, :duration, :step
+    attr :upper_limit, :lower_limit
+    
+    # LATER: there are lots of other RRDtool graph attributes
+    
+    def initialize
+      @graph_command = []
+    end
+
+    # 
+    # The graph commands must be preserved in order
+    #
+
+    # Create a DEF
+    def fetch(name, rrd_file, value, type)
+      # format: DEF:name=rrd_file:value:type
+      @graph_command << "DEF:#{name}=#{rrd_file}:#{value}:#{type}"
+    end
+    
+    # Create a CDEF
+    def compute(name, expr)
+      # format: CDEF:name=expr
+      @graph_command << "CDEF:#{name}=#{expr}"
+    end
+    
+    # Create GPRINT
+    def gprint(name, type, print_expr)
+      # format: GPRINTF:name:type:print_expr
+      @graph_command << "GPRINTF:#{name}:#{type}:#{print_expr}"    
+    end
+    
+    # Create a LINE(1,2,...)
+    def line(name, width, color, label)
+      # format: LINEwidth:name#color:label
+      @graph_command << "LINE#{width}:#{name}##{color}:#{label}"
+    end
+    
+    # Create a AREA
+    def area(name, color)
+      # format: AREA:name#color
+      @graph_command << "AREA:#{name}##{color}"
+    end
+    
+    # Create a STACK
+    def stack(name, color)
+      # format: STACK:name#color
+      @graph_command << "STACK:#{name}##{color}"
+    end
+
+    # Turn the graph definition into a real image
+    def publish
+      # LATER: add in the graph attributes -- 
+      # i.e., turn the graph attribute hash into an array of [ '--key', 'value', ...]
+      RRDtool.graph @graph_command
+    end
+
+  end
+
+end

data/rrd_info.h

@@ -0,0 +1,47 @@
+/* -*- C -*-
+ * file:   rrd_info.h
+ * date:   $Date: 2008/03/11 22:47:06 $
+ * init:   2005-07-26
+ * vers:   $Version$
+ * auth:   $Author: dbach $
+ * -----
+ * 
+ * Support file to add rrd_info() to rrd.h
+ * 
+ */
+#ifndef __RRD_INFO_H
+#define __RRD_INFO_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+/* 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;
+    rrd_info_type_t  type;
+    union infoval   value;
+    struct info_t   *next;
+} info_t;
+
+//info_t *rrd_info(int, char **);
+
+
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+#endif /* __RRD_INFO_H */

data/rrdtool_main.c

@@ -0,0 +1,260 @@
+/* $Id: rrdtool_main.c,v 1.1 2008/03/11 22:47:06 dbach Exp $
+ * Substantial penalty for early withdrawal.
+ */
+
+#include <unistd.h>
+#include <math.h>   /* for isnan */
+#include <ruby.h>
+#include <rrd.h>
+#include "rrd_info.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(STR2CSTR(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_errand_backend() 
+{
+    mRRD = rb_define_module("ErrandBackend");
+    rb_eRRDError = rb_define_class("ErrandError", 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/spec/errand_spec.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby 
+
+$: <<  File.expand_path(File.join(File.dirname(__FILE__), '..'))
+require 'lib/errand'
+require 'tmpdir'
+
+describe Errand do 
+
+  before(:all) do
+    @tmpdir = Dir.mktmpdir
+  end
+
+  before(:each) do 
+    @rrd = Errand.new(:filename => File.join(@tmpdir, 'test.rrd'))
+  end
+
+  it "should create data" do 
+
+    @rrd.create(:start => Time.now.to_i - 1, :step => 300, 
+                :sources => [ 
+                  {:name => "Counter", :type => :counter, :heartbeat => 1800, :min => 0, :max => 4294967295},
+                  {:name => "Total", :type => :derive, :heartbeat => 1800, :min => 0, :max => 'U'} ],
+                :archives => [
+                  {:function => :average, :xff => 0.5, :steps => 1, :rows => 2400}]).should be_true
+    
+    sources = @rrd.info.keys.grep(/^ds\[/).map { |ds| ds[3..-1].split(']').first}.uniq
+    sources.size.should == 2
+
+  end
+
+  it "should dump data" do
+    @rrd.create(:start => Time.now.to_i - 1, :step => 300, 
+                :sources => [ 
+                  {:name => "Counter", :type => :counter, :heartbeat => 1800, :min => 0, :max => 4294967295},
+                  {:name => "Total", :type => :derive, :heartbeat => 1800, :min => 0, :max => 'U'} ],
+                :archives => [
+                  {:function => :average, :xff => 0.5, :steps => 1, :rows => 2400}]).should be_true
+   
+    tmpfile = File.join(@tmpdir, 'test.out')
+    lambda {
+      @rrd.dump(:filename => tmpfile)
+      @rrd.dump # <= no args 
+    }.should_not raise_error
+  end
+
+  it "should update rrds" do 
+    @rrd.create(:start => Time.now.to_i - 1, :step => 1, 
+                :sources => [ 
+                  {:name => "Sum", :type => :gauge, :heartbeat => 1800, :min => 0, :max => 4294967295},
+                  {:name => "Total", :type => :gauge, :heartbeat => 1800, :min => 0, :max => 'U'} ],
+                :archives => [
+                  {:function => :average, :xff => 0.5, :steps => 1, :rows => 2400}]).should be_true
+
+    @rrd.update(:sources => [ 
+                  {:name => "Sum", :value => 1},
+                  {:name => "Total", :value => 30}]).should be_true
+
+    @rrd.fetch[:data].each_pair do |source, values|
+      values.compact.size.should > 0
+    end
+  end
+
+  it "should update with weird data" do 
+    time = Time.now.to_i - 300
+    @rrd.create(:start => time - 1, :step => 1, 
+                :sources => [ 
+                  {:name => "Sum", :type => :gauge, :heartbeat => 1800, :min => 0, :max => 4294967295},
+                  {:name => "Total", :type => :gauge, :heartbeat => 1800, :min => 0, :max => 'U'} ],
+                :archives => [
+                  {:function => :average, :xff => 0.5, :steps => 1, :rows => 2400}]).should be_true
+
+    updates = []
+    100.times do |i|
+      updates << {:name => "Sum", :time => time + i , :value => 1}
+      updates << {:name => "Total", :time => time + i * 4, :value => 30}
+    end
+    
+    @rrd.update(:sources => updates)
+    
+    @rrd.fetch[:data].each_pair do |source, values|
+      values.compact.size.should > 0
+    end
+  end
+
+  it "should fetch data" do
+    time = Time.now.to_i - 300
+    @rrd.create(:start => time - 1, :step => 1, 
+                :sources => [ 
+                  {:name => "Sum", :type => :gauge, :heartbeat => 1800, :min => 0, :max => 4294967295},
+                  {:name => "Total", :type => :gauge, :heartbeat => 1800, :min => 0, :max => 'U'} ],
+                :archives => [
+                  {:function => :average, :xff => 0.5, :steps => 1, :rows => 2400}]).should be_true
+
+    100.times do |i|
+      @rrd.update(:sources => [ 
+                    {:name => "Sum", :time => time + i, :value => 1},
+                    {:name => "Total", :time => time + i, :value => 30}]).should be_true
+    end
+
+    @rrd.fetch[:data].each_pair do |source, values|
+      values.compact.size.should > 0
+    end
+  end
+
+  it "should return timestamp of first value"
+  it "should return timestamp of last value"
+
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--color
+--format
+progress
+--diff

data/test/test_rrdtool.rb

@@ -0,0 +1,172 @@
+# Code Generated by ZenTest v. 3.2.0
+#                 classname: asrt / meth =  ratio%
+
+$:.unshift '..'
+
+require 'test/unit' unless defined? $ZENTEST and $ZENTEST
+require 'rrd'
+
+class TestRRDtool < Test::Unit::TestCase
+  def setup
+    @f = 'test.rrd'
+    @g = (File.basename @f, '.rrd') + '.png'
+    File.delete @f if File.exists? @f
+    File.delete @g if File.exists? @g
+    @r = RRDtool.new @f
+  end
+  
+  def teardown
+    File.delete @f if File.exists? @f
+    # note: leave the graph file around to check it by hand
+    @r = nil
+  end
+  
+  def create_file
+    @start = Time.now.to_i - 1
+    @step = 300
+    @r.create @step, @start, [ "DS:a:GAUGE:#{2*@step}:0:1", 
+      "DS:b:GAUGE:#{2*@step}:-10:10",
+      "RRA:AVERAGE:0.5:1:300", 
+      "RRA:LAST:0.5:1:10" ]
+  end
+  
+  def create_data
+    scale = 10
+    ts = Time.now.to_i + 1
+    while (ts < (@start.to_i + @step*300)) do
+      @r.update "a:b", ["#{ts}:#{rand()}:#{Math.sin(ts / @step / 10)}"]
+      ts += @step
+    end
+  end
+  
+  def test_create
+    create_file
+    assert File.readable?(@f)    
+  end
+
+  def test_dump
+    # RRDtool.dump is not defined for older versions of RRDtool
+    dump_file = "#{@f}.out"
+    create_file
+    create_data
+    if RRDtool.version < 1.2015 then
+      assert_raise NoMethodError do
+        @r.dump dump_file
+      end
+    else
+      @r.dump dump_file
+      assert File.readable? dump_file
+    end
+    # cleanup
+    File.delete dump_file if File.exists? dump_file
+  end
+
+  def test_fetch
+    assert_raise RRDtoolError do
+      @r.fetch ["AVERAGE"]
+    end
+    create_file
+    create_data
+    fary = @r.fetch ["AVERAGE"]
+    assert_not_nil fary
+    assert !fary.empty?
+    #assert_equals expected_data_points, fary[3]
+    # LATER: test rrd.fetch ["AVERAGE", "LAST"]
+  end
+
+  def test_first
+    # first and last should raise an exception without an RRD file
+    assert_raise RRDtoolError do
+      @r.first 0
+    end
+    create_file
+    (0..1).each do |i|
+      f = @r.first i
+      assert_not_nil f
+      assert f > 0
+    end
+    assert_raise RRDtoolError do
+      f2 = @r.first 2
+    end
+  end
+
+  def test_graph
+    create_file
+    create_data
+    RRDtool.graph(
+        [@g, "--title", " RubyRRD Demo", 
+        "--start", "#{@start} + 1 h",
+        "--end", "#{@start} + 1000 min",
+        "--interlace", 
+        "--imgformat", "PNG",
+        "--width=450",
+        "DEF:a=#{@f}:a:AVERAGE",
+        "DEF:b=#{@f}:b:AVERAGE",
+        "CDEF:line=TIME,2400,%,300,LT,a,UNKN,IF",
+        "AREA:b#00b6e4:beta",
+        "AREA:line#0022e9:alpha",
+        "LINE3:line#ff0000"])
+    assert File.exists?(@g)
+  end
+
+  def test_info
+    create_file
+    info = @r.info
+    assert_not_nil info
+    assert_equal info['filename'], @f
+    assert_equal info['step'], @step
+  end
+
+  def test_last
+    # first and last should raise an exception without an RRD file
+    assert_raise RRDtoolError do
+      @r.last
+    end
+    create_file
+    l = @r.last
+    assert l > 0
+    assert_equal @start, l
+    create_data
+    l = @r.last
+    assert l > @start
+  end
+
+  def test_resize
+    raise NotImplementedError, 'Need to write test_resize'
+  end
+
+  def test_restore
+    raise NotImplementedError, 'Need to write test_restore'
+  end
+
+  def test_rrdname
+    r = RRDtool.new 'foo'
+    assert_equal r.rrdname, 'foo'
+  end
+
+  def test_tune
+    raise NotImplementedError, 'Need to write test_tune'
+  end
+
+  def test_update
+    create_file
+    # first, test the simple update case (now)
+    @r.update "a:b", ["N:0:0"]
+    assert_in_delta Time.now.to_i, @r.last, 1
+    # next, create a bunch of data entries
+    create_data
+    l = @r.last
+    @r.update "a:b", ["#{l+1}:0:0", "#{l+2}:1:1"]
+    assert_equal @r.last, l+2
+  end
+
+  def test_version
+    v = RRDtool.version
+    assert_instance_of Float, v
+    assert_not_nil v
+  end
+
+  def test_xport
+    raise NotImplementedError, 'Need to write test_xport'
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: errand
+version: !ruby/object:Gem::Version 
+  version: 0.7.0
+platform: ruby
+authors: 
+- Lindsay Holmwood
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-22 00:00:00 +13:00
+default_executable: 
+dependencies: []
+
+description: Errand provides Ruby bindings for RRD functions (via librrd), and a concise DSL for interacting with RRDs.
+email: lindsay@holmwood.id.au
+executables: []
+
+extensions: 
+- extconf.rb
+extra_rdoc_files: 
+- README.md
+files: 
+- .cvsignore
+- .gitignore
+- AUTHORS
+- README.md
+- Rakefile
+- VERSION
+- extconf.rb
+- lib/errand.rb
+- lib/graph.rb
+- rrd_info.h
+- rrdtool_main.c
+- spec/errand_spec.rb
+- spec/spec.opts
+- test/test_rrdtool.rb
+has_rdoc: true
+homepage: http://auxesis.github.com/errand
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby language binding for RRD tool version 1.2+
+test_files: 
+- spec/errand_spec.rb
+- test/test_rrdtool.rb