summaryrefslogtreecommitdiff
path: root/jarmon
diff options
context:
space:
mode:
Diffstat (limited to 'jarmon')
-rw-r--r--jarmon/jarmon.js88
-rw-r--r--jarmon/jarmon.test.js312
2 files changed, 374 insertions, 26 deletions
diff --git a/jarmon/jarmon.js b/jarmon/jarmon.js
index 44c4dad..406c4d1 100644
--- a/jarmon/jarmon.js
+++ b/jarmon/jarmon.js
@@ -27,6 +27,7 @@ if(typeof jarmon == 'undefined') {
var jarmon = {};
}
+
jarmon.downloadBinary = function(url) {
/**
* Download a binary file asynchronously using the jQuery.ajax function
@@ -141,31 +142,36 @@ jarmon.RrdQuery = function(rrd, unit) {
this.unit = unit;
};
-jarmon.RrdQuery.prototype.getData = function(startTime, endTime, dsId, cfName) {
+jarmon.RrdQuery.prototype.getData = function(startTimeJs, endTimeJs, dsId, cfName) {
/**
* Generate a Flot compatible data object containing rows between start and
* end time. The rows are taken from the first RRA whose data spans the
* requested time range.
*
* @method getData
- * @param startTime {Number} start timestamp
- * @param endTime {Number} end timestamp
+ * @param startTimeJs {Number} start timestamp in microseconds
+ * @param endTimeJs {Number} end timestamp in microseconds
* @param dsId {Variant} identifier of the RRD datasource (string or number)
* @param cfName {String} The name of an RRD consolidation function (CF)
* eg AVERAGE, MIN, MAX
* @return {Object} A Flot compatible data series
* eg label: '', data: [], unit: ''
**/
- var startTimestamp = startTime/1000;
+ if (startTimeJs >= endTimeJs) {
+ throw RangeError(
+ ['starttime must be less than endtime. ',
+ 'starttime: ', startTimeJs,
+ 'endtime: ', endTimeJs].join(''));
+ }
+
+ var startTime = startTimeJs/1000;
var lastUpdated = this.rrd.getLastUpdate();
- var endTimestamp = lastUpdated;
- if(endTime) {
- endTimestamp = endTime/1000;
- // If end time stamp is beyond the range of this rrd then reset it
- if(lastUpdated < endTimestamp) {
- endTimestamp = lastUpdated;
- }
+
+ // default endTime to the last updated time (quantized to rrd step boundry)
+ var endTime = lastUpdated - lastUpdated%this.rrd.getMinStep();
+ if(endTimeJs) {
+ endTime = endTimeJs/1000;
}
if(dsId == null) {
@@ -177,7 +183,7 @@ jarmon.RrdQuery.prototype.getData = function(startTime, endTime, dsId, cfName) {
cfName = 'AVERAGE';
}
- var rra, step, rraRowCount, firstUpdated;
+ var rra, step, rraRowCount, lastRowTime, firstRowTime;
for(var i=0; i<this.rrd.getNrRRAs(); i++) {
// Look through all RRAs looking for the most suitable
@@ -191,29 +197,53 @@ jarmon.RrdQuery.prototype.getData = function(startTime, endTime, dsId, cfName) {
step = rra.getStep();
rraRowCount = rra.getNrRows();
- firstUpdated = lastUpdated - (rraRowCount - 1) * step;
+ lastRowTime = lastUpdated-lastUpdated%step;
+ firstRowTime = lastRowTime - rraRowCount * step;
+
// We assume that the RRAs are listed in ascending order of time range,
// therefore the first RRA which contains the range minimum should give
// the highest resolution data for this range.
- if(firstUpdated <= startTimestamp) {
+ if(firstRowTime <= startTime) {
break;
}
}
// If we got to the end of the loop without ever defining step, it means
// that the CF check never succeded.
if(!step) {
- throw new Error('Unrecognised consolidation function: ' + cfName);
+ throw TypeError('Unrecognised consolidation function: ' + cfName);
}
- var startRow = rraRowCount - parseInt((lastUpdated - Math.max(startTimestamp, firstUpdated))/step) - 1;
- var endRow = rraRowCount - parseInt((lastUpdated - endTimestamp)/step) - 1;
-
var flotData = [];
- var timestamp = firstUpdated + (startRow - 1) * step;
var dsIndex = ds.getIdx();
- for (var i=startRow; i<=endRow; i++) {
- flotData.push([timestamp*1000.0, rra.getEl(i, dsIndex)]);
- timestamp += step;
+
+ var startRowTime = Math.max(firstRowTime, startTime - startTime%step);
+ var endRowTime = Math.min(lastRowTime, endTime - endTime%step);
+ // If RRD exists, but hasn't been updated then the start time might end up
+ // being higher than the end time (which is capped at the last row time of
+ // the chosen RRA, so cap startTime at endTime...if you see what I mean)
+ startRowTime = Math.min(startRowTime, endRowTime);
+
+ /*
+ console.log('FRT: ', new Date(firstRowTime*1000));
+ console.log('LRT: ', new Date(lastRowTime*1000));
+ console.log('SRT: ', new Date(startRowTime*1000));
+ console.log('ERT: ', new Date(endRowTime*1000));
+ console.log('DIFF: ', (lastRowTime - startRowTime) / step);
+ console.log('ROWS: ', rraRowCount);
+ */
+
+ var startRowIndex = rraRowCount - (lastRowTime - startRowTime) / step;
+ var endRowIndex = rraRowCount - (lastRowTime - endRowTime) / step;
+
+ //console.log('SRI: ', startRowIndex);
+ //console.log('ERI: ', endRowIndex);
+
+ var val;
+ var timestamp = startRowTime;
+ for(var i=startRowIndex; i<endRowIndex; i++) {
+ val = rra.getEl(i, dsIndex)
+ flotData.push([timestamp*1000.0, val]);
+ timestamp += step
}
// Now get the date of the earliest record in entire rrd file, ie that of
@@ -240,7 +270,7 @@ jarmon.RrdQuery.prototype.getData = function(startTime, endTime, dsId, cfName) {
jarmon.RrdQueryRemote = function(url, unit, downloader) {
this.url = url;
this.unit = unit;
- this.downloader = downloader;
+ this.downloader = downloader || jarmon.downloadBinary;
this.lastUpdate = 0;
this._download = null;
};
@@ -498,6 +528,9 @@ jarmon.Chart.prototype.draw = function() {
return MochiKit.Async.gatherResults(results)
.addCallback(
function(self, data) {
+ // Clear any previous error messages.
+ self.template.find('.error').empty().hide();
+
var i, label, disabled = [];
unit = '';
for(i=0; i<data.length; i++) {
@@ -514,7 +547,7 @@ jarmon.Chart.prototype.draw = function() {
}
}
- $.plot(self.template.find('.chart'), data, self.options);
+ $.plot(self.template.find('.chart').empty().show(), data, self.options);
var yaxisUnitLabel = $('<div>').text(self.siPrefix + unit)
.css({width: '100px',
@@ -533,7 +566,7 @@ jarmon.Chart.prototype.draw = function() {
// table is useful as it generates an optimum label element
// width which we can copy to the new divs + a little extra
// to accomodate the color box
- var legend = self.template.find('.graph-legend');
+ var legend = self.template.find('.graph-legend').show();
legend.empty();
self.template.find('.legendLabel')
.each(function(i, el) {
@@ -562,7 +595,10 @@ jarmon.Chart.prototype.draw = function() {
}, this)
.addErrback(
function(self, failure) {
- self.template.text('error: ' + failure.message);
+ self.template.find('.chart').empty().hide();
+ self.template.find('.graph-legend').empty().hide();
+ self.template.find('.error').text('error: ' + failure.message);
+
}, this)
.addBoth(
function(self, res) {
diff --git a/jarmon/jarmon.test.js b/jarmon/jarmon.test.js
new file mode 100644
index 0000000..c838023
--- /dev/null
+++ b/jarmon/jarmon.test.js
@@ -0,0 +1,312 @@
+/* Copyright (c) 2010 Richard Wall <richard (at) the-moon.net>
+ * See LICENSE for details.
+ *
+ * Unit tests for Jarmon
+ **/
+
+YUI({ logInclude: { TestRunner: true } }).use('console', 'test', function(Y) {
+ Y.Test.Runner.add(new Y.Test.Case({
+ name: "jarmon.downloadBinary",
+
+ test_urlNotFound: function () {
+ /**
+ * When url cannot be found, the deferred should errback with status
+ * 404.
+ **/
+ var d = new jarmon.downloadBinary('non-existent-file.html');
+ d.addBoth(
+ function(self, ret) {
+ self.resume(function() {
+ Y.Assert.isInstanceOf(Error, ret);
+ Y.Assert.areEqual(404, ret.message);
+ });
+ }, this);
+
+ this.wait();
+ },
+
+ test_urlFound: function () {
+ /**
+ * When url is found, the deferred should callback with an instance
+ * of javascriptrrd.BinaryFile
+ **/
+ var d = new jarmon.downloadBinary('testfile.bin');
+ d.addBoth(
+ function(self, ret) {
+ self.resume(function() {
+ Y.Assert.isInstanceOf(BinaryFile, ret);
+ Y.Assert.areEqual(String.fromCharCode(0), ret.getRawData());
+ });
+ }, this);
+
+ this.wait();
+ }
+
+ }));
+
+ var RRD_STEP = 10;
+ var RRD_DSNAME = 'speed';
+ var RRD_DSINDEX = 0;
+ var RRD_RRACOUNT = 2;
+ var RRD_RRAROWS = 12;
+ var RRD_STARTTIME = new Date('1 jan 1980 00:00:00').getTime();
+ var RRD_ENDTIME = new Date('1 jan 1980 00:02:00').getTime();
+
+ Y.Test.Runner.add(new Y.Test.Case({
+ name: "jarmon.RRDFile",
+
+ setUp: function() {
+ this.d = new jarmon.downloadBinary('build/test.rrd')
+ .addCallback(
+ function(self, binary) {
+ return new RRDFile(binary);
+ }, this)
+ .addErrback(
+ function(ret) {
+ console.log(ret);
+ });
+ },
+
+ test_getLastUpdate: function () {
+ /**
+ * The generated rrd file should have a lastupdate date of
+ * 1980-01-01 00:50:01
+ **/
+ this.d.addCallback(
+ function(self, rrd) {
+ self.resume(function() {
+ Y.Assert.areEqual(
+ RRD_ENDTIME/1000+1, rrd.getLastUpdate());
+ });
+ }, this);
+ this.wait();
+ },
+
+ test_getDSIndex: function () {
+ /**
+ * The generated rrd file should have a single DS whose name is
+ * 'speed'. A RangeError is thrown if the requested index or dsName
+ * doesnt exist.
+ **/
+ this.d.addCallback(
+ function(self, rrd) {
+ self.resume(function() {
+ Y.Assert.areEqual(RRD_DSNAME, rrd.getDS(0).getName());
+ Y.Assert.areEqual(
+ RRD_DSINDEX, rrd.getDS('speed').getIdx());
+ var error = null;
+ try {
+ rrd.getDS(RRD_DSINDEX+1);
+ } catch(e) {
+ error = e;
+ }
+ Y.assert(error instanceof RangeError);
+ });
+ }, this);
+ this.wait();
+ },
+
+ test_getNrRRAs: function () {
+ /**
+ * The generated rrd file should have a single RRA
+ **/
+ this.d.addCallback(
+ function(self, rrd) {
+ self.resume(function() {
+ Y.Assert.areEqual(RRD_RRACOUNT, rrd.getNrRRAs());
+ });
+ }, this);
+ this.wait();
+ },
+
+ test_getRRA: function () {
+ /**
+ * The generated rrd file should have a single RRA using AVERAGE
+ * consolidation, step=10, rows=6 and values 0-5
+ * rra.getEl throws a RangeError if asked for row which doesn't
+ * exist.
+ **/
+ this.d.addCallback(
+ function(self, rrd) {
+ self.resume(function() {
+ var rra = rrd.getRRA(0);
+ Y.Assert.areEqual('AVERAGE', rra.getCFName());
+ Y.Assert.areEqual(RRD_STEP, rra.getStep());
+ Y.Assert.areEqual(RRD_RRAROWS, rra.getNrRows());
+ for(var i=0; i<RRD_RRAROWS; i++) {
+ Y.Assert.areEqual(i, rra.getEl(i, RRD_DSINDEX));
+ }
+ var error = null
+ try {
+ rra.getEl(RRD_RRAROWS+1, 0);
+ } catch(e) {
+ error = e;
+ }
+ Y.assert(error instanceof RangeError);
+ });
+ }, this);
+ this.wait();
+ }
+ }));
+
+ Y.Test.Runner.add(new Y.Test.Case({
+ name: "jarmon.RrdQuery",
+
+ setUp: function() {
+ this.d = new jarmon.downloadBinary('build/test.rrd')
+ .addCallback(
+ function(self, binary) {
+ return new RRDFile(binary);
+ }, this)
+ .addErrback(
+ function(ret) {
+ console.log(ret);
+ });
+ },
+
+ test_getDataTimeRangeOverlapError: function () {
+ /**
+ * The starttime must be less than the endtime
+ **/
+ this.d.addCallback(
+ function(self, rrd) {
+ self.resume(function() {
+ var rq = new jarmon.RrdQuery(rrd, '');
+ var error = null;
+ try {
+ rq.getData(1, 0);
+ } catch(e) {
+ error = e;
+ }
+ Y.Assert.isInstanceOf(RangeError, error);
+ });
+ }, this);
+ this.wait();
+ },
+
+
+ test_getDataUnknownCfError: function () {
+ /**
+ * Error is raised if the rrd file doesn't contain an RRA with the
+ * requested consolidation function (CF)
+ **/
+ this.d.addCallback(
+ function(self, rrd) {
+ self.resume(function() {
+ var rq = new jarmon.RrdQuery(rrd, '');
+ var error = null;
+ try {
+ rq.getData(RRD_STARTTIME, RRD_ENDTIME, 0, 'FOO');
+ } catch(e) {
+ error = e;
+ }
+ Y.Assert.isInstanceOf(TypeError, error);
+ });
+ }, this);
+ this.wait();
+ },
+
+
+ test_getData: function () {
+ /**
+ * The generated rrd file should have values 0-9 at 300s intervals
+ * starting at 1980-01-01 00:00:00
+ * Result should include a data points with times > starttime and
+ * <= endTime
+ **/
+ this.d.addCallback(
+ function(self, rrd) {
+ self.resume(function() {
+ var rq = new jarmon.RrdQuery(rrd, '');
+
+ // We request data starting 1 STEP +1s after the RRD file
+ // first val and ending 1 STEP -1s before the RRD last val
+ // ie one step within the RRD file, but 1s away from the
+ // step boundary to test the quantisation of the
+ // requested time range.
+ var data = rq.getData(
+ RRD_STARTTIME + (RRD_STEP+1) * 1000,
+ RRD_ENDTIME - (RRD_STEP-1) * 1000);
+
+ // so we expect two less rows than the total rows in the
+ // file.
+ Y.Assert.areEqual(RRD_RRAROWS-2, data.data.length);
+
+ // The value of the first returned row should be the
+ // second value in the RRD file (starts at value 0)
+ Y.Assert.areEqual(1, data.data[0][1]);
+
+ // The value of the last returned row should be the
+ // 10 value in the RRD file (starts at value 0)
+ Y.Assert.areEqual(10, data.data[data.data.length-1][1]);
+
+ // The timestamp of the first returned row should be
+ // exactly one step after the start of the RRD file
+ Y.Assert.areEqual(
+ RRD_STARTTIME+RRD_STEP*1000, data.data[0][0]);
+
+ // RRD_ENDTIME is on a step boundary and is therfore
+ // actually the start time of a new row
+ // So when we ask for endTime = RRD_ENDTIME-STEP-1 we
+ // actually get data up to the 2nd to last RRD row.
+ Y.Assert.areEqual(
+ RRD_ENDTIME-RRD_STEP*1000*2,
+ data.data[data.data.length-1][0]);
+ });
+ }, this);
+ this.wait();
+ },
+
+ test_getDataUnknownValues: function () {
+ /**
+ * If the requested time range is outside the range of the RRD file
+ * we should not get any values back
+ **/
+ this.d.addCallback(
+ function(self, rrd) {
+ self.resume(function() {
+ var rq = new jarmon.RrdQuery(rrd, '');
+ var data = rq.getData(RRD_ENDTIME, RRD_ENDTIME+1000);
+ Y.Assert.areEqual(0, data.data.length);
+ });
+ }, this);
+ this.wait();
+ }
+
+ }));
+
+
+ Y.Test.Runner.add(new Y.Test.Case({
+ name: "jarmon.Chart",
+
+ test_draw: function () {
+ /**
+ * Test that a rendered chart has the correct dimensions, legend,
+ * axis, labels etc
+ **/
+ var $tpl = $('<div><div class="chart"></div></div>').appendTo($('body'));
+ var c = new jarmon.Chart($tpl, jarmon.Chart.BASE_OPTIONS);
+ //
+ c.options.xaxis.tzoffset = 0;
+ c.addData('speed', new jarmon.RrdQueryRemote('build/test.rrd', 'm/s'), true);
+ var d = c.setTimeRange(RRD_STARTTIME, RRD_ENDTIME);
+ d.addCallback(
+ function(self) {
+ self.resume(function() {
+ // TODO: write useful tests
+ });
+ }, this);
+ this.wait();
+ },
+ }));
+
+
+ //initialize the console
+ var yconsole = new Y.Console({
+ newestOnTop: false,
+ width:'600px',
+ height: '400px'
+ });
+ yconsole.render('#log');
+ Y.Test.Runner.run();
+});
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-17 22:51:19 +0000