implement CSV, TSC, SSV with JSON and XML as "graphics" formats for rrdgraph -- Marti...

git-svn-id: svn://svn.oetiker.ch/rrdtool/trunk/program@2274 a5681a0c-68f1-0310-ab6d-d61299d08faa

diff --git a/doc/rrdgraph.pod b/doc/rrdgraph.pod
index 71a1e1dde1236d1512d7a7533aa42e69c9d50f08..f8aae34145d14e0822ee7bc2034932bb1deae46a 100644 (file)
--- a/doc/rrdgraph.pod
+++ b/doc/rrdgraph.pod
@@ -453,7 +453,7 @@ RRDtool graphs are composed of stair case curves by default. This is in line wit
 the way RRDtool calculates its data. Some people favor a more 'organic' look
 for their graphs even though it is not all that true.
 
-[B<-a>|B<--imgformat> B<PNG>|B<SVG>|B<EPS>|B<PDF>]
+[B<-a>|B<--imgformat> B<PNG>|B<SVG>|B<EPS>|B<PDF>|B<XML>|B<JSON>|B<CSV>|B<TSV>|B<SSV>]
 
 Image format for the generated graph. For the vector formats you can
 choose among the standard Postscript fonts Courier-Bold,
@@ -461,6 +461,10 @@ Courier-BoldOblique, Courier-Oblique, Courier, Helvetica-Bold,
 Helvetica-BoldOblique, Helvetica-Oblique, Helvetica, Symbol,
 Times-Bold, Times-BoldItalic, Times-Italic, Times-Roman, and ZapfDingbats.
 
+For Export type you can define XML, JSON, CSV (=comma separated values),
+TSV (=tab separated values), SSV (=semicolon separated values)
+(for comma/tab/semicolon separated values the time format by default is in the form of unix time. to change it to something else use: --x-grid MINUTE:10:HOUR:1:HOUR:4:0:"%Y-%m-%d %H:%M:%S")
+
 [B<-i>|B<--interlaced>]
 
 (this gets ignored in 1.3 for now!)

diff --git a/src/rrd_graph.c b/src/rrd_graph.c
index 8417291bc2f05a5691cc44a906215e609cccc81a..240e96f7cb48e673f61a51afd1ba2f8165190059 100644 (file)
--- a/src/rrd_graph.c
+++ b/src/rrd_graph.c
@@ -256,6 +256,11 @@ enum gfx_if_en if_conv(
     conv_if(SVG, IF_SVG);
     conv_if(EPS, IF_EPS);
     conv_if(PDF, IF_PDF);
+    conv_if(XML, IF_XML);
+    conv_if(CSV, IF_CSV);
+    conv_if(TSV, IF_TSV);
+    conv_if(SSV, IF_SSV);
+    conv_if(JSON, IF_JSON);
 
     return (enum gfx_if_en)(-1);
 }
@@ -3405,6 +3410,12 @@ int graph_paint(
         cairo_svg_surface_restrict_to_version
             (im->surface, CAIRO_SVG_VERSION_1_1);
         break;
+    case IF_XML:
+    case IF_CSV:
+    case IF_TSV:
+    case IF_SSV:
+    case IF_JSON:
+        break;
     };
     cairo_destroy(im->cr);
     im->cr = cairo_create(im->surface);
@@ -4017,6 +4028,10 @@ int rrd_graph(
 ** - options parsing  now in rrd_graph_options()
 ** - script parsing   now in rrd_graph_script()
 */
+
+/* have no better idea where to put it - rrd.h does not work */
+int       rrd_graph_xport(image_desc_t *);
+
 rrd_info_t *rrd_graph_v(
     int argc,
     char **argv)
@@ -4068,6 +4083,10 @@ rrd_info_t *rrd_graph_v(
         return NULL;
     }
 
+    if (im.imgformat >= IF_XML) {
+      rrd_graph_xport(&im);
+   } else {
+
     /* Everything is now read and the actual work can start */
 
     if (graph_paint(&im) == -1) {
@@ -4075,7 +4094,7 @@ rrd_info_t *rrd_graph_v(
         im_free(&im);
         return NULL;
     }
-
+   }
 
     /* The image is generated and needs to be output.
      ** Also, if needed, print a line with information about the image.

diff --git a/src/rrd_graph.h b/src/rrd_graph.h
index 75a9439faeb0a6e0f3bf0244b5c5e6eea10fe0ed..790f1d922a580fef263f3a9883ed117d3f643598 100644 (file)
--- a/src/rrd_graph.h
+++ b/src/rrd_graph.h
@@ -92,7 +92,8 @@ enum text_prop_en {
 enum legend_pos{ NORTH = 0, WEST, SOUTH, EAST };
 enum legend_direction { TOP_DOWN = 0, BOTTOM_UP };
 
-enum gfx_if_en { IF_PNG = 0, IF_SVG, IF_EPS, IF_PDF };
+enum gfx_if_en { IF_PNG = 0, IF_SVG, IF_EPS, IF_PDF, 
+                IF_XML=128, IF_CSV=129, IF_TSV=130, IF_SSV=131, IF_JSON=132 };
 enum gfx_en { GFX_LINE = 0, GFX_AREA, GFX_TEXT };
 enum gfx_h_align_en { GFX_H_NULL = 0, GFX_H_LEFT, GFX_H_RIGHT, GFX_H_CENTER };
 enum gfx_v_align_en { GFX_V_NULL = 0, GFX_V_TOP, GFX_V_BOTTOM, GFX_V_CENTER };

diff --git a/src/rrd_xport.c b/src/rrd_xport.c
index 5ee0fdfb1daa51174bb3fc825293884bdbf0ef58..4a7b688b78c938a25c3f8c158773a6bc664582dd 100644 (file)
--- a/src/rrd_xport.c
+++ b/src/rrd_xport.c
@@ -36,8 +36,8 @@ int       rrd_xport_fn(
     unsigned long *,
     unsigned long *,
     char ***,
-    rrd_value_t **);
-
+    rrd_value_t **,
+    int);
 
 
 
@@ -173,7 +173,7 @@ int rrd_xport(
         if (status != 0) return status;
     }
 
-    if (rrd_xport_fn(&im, start, end, step, col_cnt, legend_v, data) == -1) {
+    if (rrd_xport_fn(&im, start, end, step, col_cnt, legend_v, data,0) == -1) {
         im_free(&im);
         return -1;
     }
@@ -193,7 +193,8 @@ int rrd_xport_fn(
                              * will be changed to represent reality */
     unsigned long *col_cnt, /* number of data columns in the result */
     char ***legend_v,   /* legend entries */
-    rrd_value_t **data)
+    rrd_value_t **data,
+    int dolines)
 {                       /* two dimensional array containing the data */
 
     int       i = 0, j = 0;
@@ -215,12 +216,17 @@ int rrd_xport_fn(
     if (data_calc(im) == -1)
         return -1;
 
-    /* how many xports? */
-    *col_cnt = 0;    
+    /* how many xports or lines/AREA/STACK ? */
+    *col_cnt = 0;
     for (i = 0; i < im->gdes_c; i++) {
         switch (im->gdes[i].gf) {
+        case GF_LINE:
+        case GF_AREA:
+        case GF_STACK:
+         (*col_cnt)+=dolines;
+         break;
         case GF_XPORT:
-            (*col_cnt)++;
+         (*col_cnt)++;
             break;
         default:
             break;
@@ -249,8 +255,23 @@ int rrd_xport_fn(
     step_list_ptr = step_list;
     j = 0;
     for (i = 0; i < im->gdes_c; i++) {
+      /* decide if we need to handle the output */
+        int handle=0;
         switch (im->gdes[i].gf) {
+        case GF_LINE:
+        case GF_AREA:
+        case GF_STACK:
+         handle=dolines;
+         break;
         case GF_XPORT:
+         handle=1;
+         break;
+       default:
+         handle=0;
+         break;
+       }
+       /* and now do the real work */
+       if (handle) {
             ref_list[xport_counter++] = i;
             *step_list_ptr = im->gdes[im->gdes[i].vidx].step;
             /* printf("%s:%lu\n",im->gdes[i].legend,*step_list_ptr); */
@@ -274,10 +295,7 @@ int rrd_xport_fn(
                 strcpy(legend_list[j++], im->gdes[i].legend);
             else
                 legend_list[j++][0] = '\0';
-            break;
-        default:
-            break;            
-        }
+       }
     }
     *step_list_ptr=0;    
     /* find a common step */
@@ -321,3 +339,209 @@ int rrd_xport_fn(
     return 0;
 
 }
+
+/* helper function for buffer handling */
+typedef struct stringbuffer_t {
+  size_t allocated;
+  size_t len;
+  unsigned char* data;
+  FILE *file;
+} stringbuffer_t;
+int addToBuffer(stringbuffer_t *,char*,size_t);
+
+int rrd_graph_xport(image_desc_t *);
+int rrd_xport_format_xml(stringbuffer_t *,image_desc_t*,time_t, time_t, unsigned long, unsigned long, char**, rrd_value_t*);
+int rrd_xport_format_json(stringbuffer_t *,image_desc_t*,time_t, time_t, unsigned long, unsigned long, char**, rrd_value_t*);
+int rrd_xport_format_sv(char,stringbuffer_t *,image_desc_t*,time_t, time_t, unsigned long, unsigned long, char**, rrd_value_t*);
+
+int rrd_graph_xport(image_desc_t *im) {
+  /* prepare the data for processing */
+  unsigned long col_cnt=0;
+  time_t start=im->start;
+  time_t end=im->end;
+  unsigned long step=im->step;
+  char **legend_v=NULL;
+  rrd_value_t *data=NULL;
+  /* initialize buffer */
+  stringbuffer_t buffer={0,0,NULL,NULL}; 
+  /* if we write a file, then open it */
+  if (strlen(im->graphfile)) {
+    buffer.file=fopen(im->graphfile,"w");
+  }
+
+  /* do the data processing */
+  if (rrd_xport_fn(im,&start,&end,&step,&col_cnt,&legend_v,&data,1)) { return -1;}
+
+  /* fill in some data */
+  rrd_infoval_t info;
+  info.u_cnt = im->start;
+  grinfo_push(im, sprintf_alloc("graph_start"), RD_I_CNT, info);
+  info.u_cnt = im->end;
+  grinfo_push(im, sprintf_alloc("graph_end"), RD_I_CNT, info);
+  info.u_cnt = im->step;
+  grinfo_push(im, sprintf_alloc("graph_step"), RD_I_CNT, info);
+
+
+  /* format it for output */
+  int r=0;
+  switch(im->imgformat) {
+  case IF_XML:
+    r=rrd_xport_format_xml(&buffer,im, start, end, step, col_cnt, legend_v, data);
+    break;
+  case IF_JSON:
+    r=rrd_xport_format_json(&buffer,im, start, end, step, col_cnt, legend_v, data);
+    break;
+  case IF_CSV:
+    r=rrd_xport_format_sv(',',&buffer,im, start, end, step, col_cnt, legend_v, data);
+    break;
+  case IF_TSV:
+    r=rrd_xport_format_sv('\t',&buffer,im, start, end, step, col_cnt, legend_v, data);
+    break;
+  case IF_SSV:
+    r=rrd_xport_format_sv(';',&buffer,im, start, end, step, col_cnt, legend_v, data);
+    break;
+  default:
+    break;
+  }
+  /* handle errors */
+  if (r) {
+    if (buffer.data) {free(buffer.data);}
+    return r;
+  }
+
+  /* now do the cleanup */
+  if (buffer.file) {
+    fclose(buffer.file); buffer.file=NULL; 
+    im->rendered_image_size=0;
+    im->rendered_image=NULL;
+  } else {
+    im->rendered_image_size=buffer.len;
+    im->rendered_image=buffer.data;    
+  }
+
+  /* and print stuff */
+  return print_calc(im);
+}
+
+int addToBuffer(stringbuffer_t * sb,char* data,size_t len) {
+  /* if len <= 0  we assume a string and calculate the length ourself */
+  if (len<=0) { len=strlen(data); }
+  /* if we have got a file, then take the shortcut */
+  if (sb->file) { 
+    sb->len+=len;
+    fwrite(data,len,1,sb->file); 
+    return 0; 
+  }
+  /* if buffer is 0, then initialize */
+  if (! sb->data) { 
+    /* make buffer a multiple of 8192 */
+    sb->allocated+=8192;
+    sb->allocated-=(sb->allocated%8192);    
+    /* and allocate it */
+    sb->data=malloc(sb->allocated); 
+    if (! sb->data) { 
+      rrd_set_error("malloc issue");
+      return 1;
+    }
+    /* and initialize the buffer */
+    sb->len=0;
+    sb->data[0]=0;
+  }
+  /* and figure out if we need to extend the buffer */
+  if (sb->len+len+1>=sb->allocated) {
+    /* add so many pages until we have a buffer big enough */
+    while(sb->len+len+1>=sb->allocated) {
+      sb->allocated+=8192;
+    }
+    /* try to resize it */
+    unsigned char* resized=(unsigned char*)realloc(sb->data,sb->allocated);
+    if (resized) {
+      sb->data=resized;
+    } else {
+      free(sb->data);
+      sb->data=NULL;
+      sb->allocated=0;
+      rrd_set_error("realloc issue");
+      return -1;
+    }
+  }
+  /* and finally add to the buffer */
+  memcpy(sb->data+sb->len,data,len);
+  sb->len+=len;
+  /* and 0 terminate it */
+  sb->data[sb->len]=0;
+  /* and return */
+  return 0;
+}
+
+int rrd_xport_format_sv(char sep, stringbuffer_t *buffer,image_desc_t *im,time_t start, time_t end, unsigned long step, unsigned long col_cnt, char **legend_v, rrd_value_t* data) {
+  /* define the time format */
+  char* timefmt=NULL;
+  /* unfortunatley we have to do it this way, 
+     as when no --x-graph argument is given,
+     then the xlab_user is not in a clean state (e.g. zero-filled) */
+  if (im->xlab_user.minsec!=-1) { timefmt=im->xlab_user.stst; }
+
+  /* row count */
+  unsigned long row_cnt=(end-start)/step;
+
+  /* estimate buffer size (to avoid multiple allocations) */
+  buffer->allocated=
+    1024 /* bytes of overhead /header/footer */
+    +(12+19*col_cnt) /* 12 bytes overhead/line plus 19 bytes per column*/
+    *(1+row_cnt) /* number of columns + 1 (for header) */
+    ;
+
+  /* now start writing the header*/
+  if (addToBuffer(buffer,"\"time\"",6)) { return 1; }
+  char buf[256];
+  for(unsigned long i=0;i<col_cnt;i++) {
+    /* strip leading spaces */
+    char *t=legend_v[i]; while (isspace(*t)) { t++;}
+    /* and print it */
+    snprintf(buf,255,"%c\"%s\"",sep,t);
+    if (addToBuffer(buffer,buf,0)) { return 1;}
+  }
+  if (addToBuffer(buffer,"\r\n",2)) { return 1; }
+  /* and now write the data */
+  rrd_value_t *ptr=data;
+  for(time_t ti=start+step;ti<end;ti+=step) {
+    /* write time */
+    if (timefmt) {
+      struct tm loc;
+      localtime_r(&ti,&loc);
+      strftime(buf,254,timefmt,&loc);
+    } else {
+      snprintf(buf,254,"%ul",ti);
+    }
+    if (addToBuffer(buffer,buf,0)) { return 1; }
+    /* write the columns */
+    for(unsigned long i=0;i<col_cnt;i++) {
+      /* get the value */
+      rrd_value_t v=*ptr;ptr++;
+      /* and print it */
+      if (isnan(v)) {
+       snprintf(buf,255,"%c\"NaN\"",sep);
+      } else {
+       snprintf(buf,255,"%c\"%0.10e\"",sep,v);
+      }
+      if (addToBuffer(buffer,buf,0)) { return 1;}
+    }
+    /* and add a newline */
+    if (addToBuffer(buffer,"\r\n",2)) { return 1; }
+  }
+
+  /* and return OK */
+  return 0;
+}
+
+int rrd_xport_format_xml(stringbuffer_t *buffer,image_desc_t *im,time_t start, time_t end, unsigned long step, unsigned long col_cnt, char **legend_v, rrd_value_t* data) {
+  addToBuffer(buffer,"xml not implemented",0);
+  return 0;
+}
+
+int rrd_xport_format_json(stringbuffer_t *buffer,image_desc_t *im,time_t start, time_t end, unsigned long step, unsigned long col_cnt, char **legend_v, rrd_value_t* data) {
+  addToBuffer(buffer,"JSON not implemented",0);
+  return 0;
+}
+