From: oetiker Date: Wed, 22 Feb 2012 06:44:28 +0000 (+0000) Subject: implement CSV, TSC, SSV with JSON and XML as "graphics" formats for rrdgraph -- Marti... X-Git-Url: https://git.tokkee.org/?a=commitdiff_plain;h=b19af459046d7ced9d3a617cb106e346d1d95a63;p=rrdtool.git implement CSV, TSC, SSV with JSON and XML as "graphics" formats for rrdgraph -- Martin Sperl 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 71a1e1d..f8aae34 100644 --- 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|B|B|B] +[B<-a>|B<--imgformat> B|B|B|B|B|B|B|B|B] 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 8417291..240e96f 100644 --- 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 75a9439..790f1d9 100644 --- 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 5ee0fdf..4a7b688 100644 --- 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