char* printstrftime(long argc, const char **args){
struct rrd_time_value start_tv, end_tv;
char *parsetime_error = NULL;
char formatted[MAX_STRFTIME_SIZE];
struct tm *the_tm;
time_t start_tmp, end_tmp;
/* Make sure that we were given the right number of args */
if( argc != 4) {
rrd_set_error( "wrong number of args %d", argc);
return stralloc("");
}
/* Init start and end time */
parsetime("end-24h", &start_tv);
parsetime("now", &end_tv);
/* Parse the start and end times we were given */
if( (parsetime_error = parsetime( args[1], &start_tv))) {
rrd_set_error( "start time: %s", parsetime_error);
return stralloc("");
}
if( (parsetime_error = parsetime( args[2], &end_tv))) {
rrd_set_error( "end time: %s", parsetime_error);
return stralloc("");
}
if( proc_start_end( &start_tv, &end_tv, &start_tmp, &end_tmp) == -1) {
return stralloc("");
}
/* Do we do the start or end */
if( strcasecmp( args[0], "START") == 0) {
the_tm = localtime( &start_tmp);
}
else if( strcasecmp( args[0], "END") == 0) {
the_tm = localtime( &end_tmp);
}
else {
rrd_set_error( "start/end not found in '%s'", args[0]);
return stralloc("");
}
/* now format it */
if( strftime( formatted, MAX_STRFTIME_SIZE, args[3], the_tm)) {
return( stralloc( formatted));
}
else {
rrd_set_error( "strftime failed");
return stralloc("");
}
}
int main ( int ac, char **av )
{
static struct option long_options[] =
{
{"start", required_argument, 0, 's'},
{"end", required_argument, 0, 'e'},
{0,0,0,0}};
int option_index = 0;
int opt;
time_t start_tmp, end_tmp, Now = time(NULL);
char tim_b[200];
struct time_value start_tv, end_tv;
char *parsetime_error = NULL;
/* default values */
parsetime("end-24h", &start_tv);
parsetime("now", &end_tv);
if( ac < 2 )
{
printf( "usage: %s [--start|-s start] [--end|-e end]\n"
"\n"
"In plain English, this means that to time specification try\n"
"a single time specification (just like in the rrdtool create)\n"
"you can use the first form, while to try two of them at once\n"
"(just like in rrdtool graph or fetch) you need the seconf form\n",
av[0] );
exit(0);
}
printf( "The time now is: %s\n", ctime(&Now) );
while(1){
opt = getopt_long(ac, av, "s:e:", long_options, &option_index);
if (opt == EOF)
break;
switch(opt)
{
case 's':
strncpy( soption, optarg, BUF_LEN );
if ((parsetime_error = parsetime(optarg, &start_tv))) {
fprintf( stderr, "ERROR: start time: %s\n", parsetime_error );
exit(1);
}
break;
case 'e':
strncpy( eoption, optarg, BUF_LEN );
if ((parsetime_error = parsetime(optarg, &end_tv))) {
fprintf( stderr, "ERROR: end time: %s\n", parsetime_error );
exit(1);
}
break;
}
}
if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
printf("ERROR: %s\n",rrd_get_error());
rrd_clear_error();
exit(1);
}
strftime(tim_b,100,"%c %Z",localtime(&start_tmp));
if( *soption )
printf( "Start time was specified as: '%s',\n"
"for me this means: %s (or %ld sec since epoch)\n\n",
soption, tim_b, start_tmp );
else
printf( "Start time was not specified, default value will be used (end-24h)\n"
"for me this means: %s (or %ld sec since epoch)\n\n",
tim_b, start_tmp );
strftime(tim_b,100,"%c %Z",localtime(&end_tmp));
if( *eoption )
printf( "End time was specified as: '%s',\n"
"for me this means: %s (or %ld sec since epoch)\n",
eoption, tim_b, end_tmp );
else
printf( "End time was not specified, default value will be used (now)\n"
"for me this means: %s (or %ld sec since epoch)\n\n",
tim_b, end_tmp );
exit(0);
}
int
rrd_parse_def(char *line, unsigned int *eaten, graph_desc_t *gdp, image_desc_t *im) {
int i=0;
char command[7]; /* step, start, end, reduce */
char tmpstr[256];
struct rrd_time_value start_tv,end_tv;
time_t start_tmp=0,end_tmp=0;
char *parsetime_error=NULL;
start_tv.type = end_tv.type=ABSOLUTE_TIME;
start_tv.offset = end_tv.offset=0;
localtime_r(&gdp->start, &start_tv.tm);
localtime_r(&gdp->end, &end_tv.tm);
dprintf("- parsing '%s'\n",&line[*eaten]);
dprintf("- from line '%s'\n",line);
if (rrd_parse_vname(line,eaten,gdp,im)) return 1;
i=scan_for_col(&line[*eaten],254,gdp->rrd);
if (line[*eaten+i]!=':') {
rrd_set_error("Problems reading database name");
return 1;
}
(*eaten)+=++i;
dprintf("- using file '%s'\n",gdp->rrd);
i=0;
sscanf(&line[*eaten], DS_NAM_FMT ":%n", gdp->ds_nam,&i);
if (!i) {
rrd_set_error("Cannot parse DS in '%s'",line);
return 1;
}
(*eaten)+=i;
dprintf("- using DS '%s'\n",gdp->ds_nam);
if (rrd_parse_CF(line,eaten,gdp,&gdp->cf)) return 1;
gdp->cf_reduce = gdp->cf;
if (line[*eaten]=='\0') return 0;
while (1) {
dprintf("- optional parameter follows: %s\n", &line[*eaten]);
i=0;
sscanf(&line[*eaten], "%6[a-z]=%n", command, &i);
if (!i) {
rrd_set_error("Parse error in '%s'",line);
return 1;
}
(*eaten)+=i;
dprintf("- processing '%s'\n",command);
if (!strcmp("reduce",command)) {
if (rrd_parse_CF(line,eaten,gdp,&gdp->cf_reduce)) return 1;
if (line[*eaten] != '\0')
(*eaten)--;
} else if (!strcmp("step",command)) {
i=0;
sscanf(&line[*eaten],"%lu%n",&gdp->step,&i);
(*eaten)+=i;
dprintf("- using step %lu\n",gdp->step);
} else if (!strcmp("start",command)) {
i=scan_for_col(&line[*eaten],255,tmpstr);
(*eaten)+=i;
if ((parsetime_error = parsetime(tmpstr, &start_tv))) {
rrd_set_error( "start time: %s", parsetime_error );
return 1;
}
dprintf("- done parsing: '%s'\n",&line[*eaten]);
} else if (!strcmp("end",command)) {
i=scan_for_col(&line[*eaten],255,tmpstr);
(*eaten)+=i;
if ((parsetime_error = parsetime(tmpstr, &end_tv))) {
rrd_set_error( "end time: %s", parsetime_error );
return 1;
}
dprintf("- done parsing: '%s'\n",&line[*eaten]);
} else {
rrd_set_error("Parse error in '%s'",line);
return 1;
}
if (line[*eaten]=='\0') break;
if (line[*eaten]!=':') {
dprintf("- Expected to see end of string but got '%s'\n",\
&line[*eaten]);
rrd_set_error("Parse error in '%s'",line);
return 1;
}
(*eaten)++;
}
if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
/* error string is set in parsetime.c */
return 1;
}
if (start_tmp < 3600*24*365*10) {
rrd_set_error("the first entry to fetch should be "
"after 1980 (%ld)",start_tmp);
return 1;
}
if (end_tmp < start_tmp) {
rrd_set_error("start (%ld) should be less than end (%ld)",
start_tmp, end_tmp);
return 1;
}
gdp->start = start_tmp;
gdp->end = end_tmp;
dprintf("- start time %lu\n",gdp->start);
dprintf("- end time %lu\n",gdp->end);
return 0;
}
/* mostly rrd_graph(), just pushed a bit here and stretched a bit there */
int
rrd_xport(int argc, char **argv, int *xsize,
time_t *start,
time_t *end, /* which time frame do you want ?
* will be changed to represent reality */
unsigned long *step, /* which stepsize do you want?
* 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) /* two dimensional array containing the data */
{
image_desc_t im;
int i;
long long_tmp;
time_t start_tmp=0,end_tmp=0;
char symname[100];
long scancount;
struct rrd_time_value start_tv, end_tv;
char *parsetime_error = NULL;
parsetime("end-24h", &start_tv);
parsetime("now", &end_tv);
/* use the default values from rrd_graph.c */
im.xlab_user.minsec = -1;
im.xgif=0;
im.ygif=0;
im.xsize = 400;
im.ysize = 100;
im.step = 0;
im.ylegend[0] = '\0';
im.title[0] = '\0';
im.minval = DNAN;
im.maxval = DNAN;
im.interlaced = 0;
im.unitsexponent= 9999;
im.unitslength= 9;
im.extra_flags= 0;
im.rigid = 0;
im.imginfo = NULL;
im.lazy = 0;
im.logarithmic = 0;
im.ygridstep = DNAN;
im.draw_x_grid = 1;
im.draw_y_grid = 1;
im.base = 1000;
im.prt_c = 0;
im.gdes_c = 0;
im.gdes = NULL;
im.imgformat = IF_GIF; /* we default to GIF output */
while (1) {
static struct option long_options[] =
{
{"start", required_argument, 0, 's'},
{"end", required_argument, 0, 'e'},
{"maxrows", required_argument, 0, 'm'},
{"step", required_argument, 0, 261},
{0,0,0,0}
};
int option_index = 0;
int opt;
opt = getopt_long(argc, argv, "s:e:m:",
long_options, &option_index);
if (opt == EOF)
break;
switch(opt) {
case 261:
im.step = atoi(optarg);
break;
case 's':
if ((parsetime_error = parsetime(optarg, &start_tv))) {
rrd_set_error( "start time: %s", parsetime_error );
return -1;
}
break;
case 'e':
if ((parsetime_error = parsetime(optarg, &end_tv))) {
rrd_set_error( "end time: %s", parsetime_error );
return -1;
}
break;
case 'm':
long_tmp = atol(optarg);
if (long_tmp < 10) {
rrd_set_error("maxrows below 10 rows");
return -1;
}
im.xsize = long_tmp;
break;
case '?':
if (optopt != 0)
rrd_set_error("unknown option '%c'", optopt);
else
rrd_set_error("unknown option '%s'",argv[optind-1]);
return -1;
}
}
/*
if (optind >= argc) {
rrd_set_error("missing filename");
return -1;
}
*/
if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1) {
return -1;
}
if (start_tmp < 3600*24*365*10) {
rrd_set_error("the first entry to fetch should be after 1980 (%ld)",start_tmp);
return -1;
}
if (end_tmp < start_tmp) {
rrd_set_error("start (%ld) should be less than end (%ld)",
start_tmp, end_tmp);
return -1;
}
im.start = start_tmp;
im.end = end_tmp;
for(i=optind; i<argc; i++) {
int argstart=0;
int strstart=0;
char varname[30],*rpnex;
gdes_alloc(&im);
if(sscanf(argv[i],"%10[A-Z0-9]:%n",symname,&argstart)==1) {
if((im.gdes[im.gdes_c-1].gf=gf_conv(symname))==-1) {
im_free(&im);
rrd_set_error("unknown function '%s'",symname);
return -1;
}
} else {
rrd_set_error("can't parse '%s'",argv[i]);
im_free(&im);
return -1;
}
switch(im.gdes[im.gdes_c-1].gf) {
case GF_CDEF:
if((rpnex = malloc(strlen(&argv[i][argstart])*sizeof(char)))==NULL) {
rrd_set_error("malloc for CDEF");
return -1;
}
if(sscanf(
&argv[i][argstart],
DEF_NAM_FMT "=%[^: ]",
im.gdes[im.gdes_c-1].vname,
rpnex) != 2) {
im_free(&im);
free(rpnex);
rrd_set_error("can't parse CDEF '%s'",&argv[i][argstart]);
return -1;
}
/* checking for duplicate DEF CDEFS */
if(find_var(&im,im.gdes[im.gdes_c-1].vname) != -1) {
im_free(&im);
rrd_set_error("duplicate variable '%s'",
im.gdes[im.gdes_c-1].vname);
return -1;
}
if((im.gdes[im.gdes_c-1].rpnp = str2rpn(&im,rpnex))== NULL) {
rrd_set_error("invalid rpn expression '%s'", rpnex);
im_free(&im);
return -1;
}
free(rpnex);
break;
case GF_DEF:
if (sscanf(
&argv[i][argstart],
DEF_NAM_FMT "=%n",
im.gdes[im.gdes_c-1].vname,
&strstart)== 1 && strstart) { /* is the = did not match %n returns 0 */
if(sscanf(&argv[i][argstart
+strstart
+scan_for_col(&argv[i][argstart+strstart],
MAXPATH,im.gdes[im.gdes_c-1].rrd)],
":" DS_NAM_FMT ":" CF_NAM_FMT,
im.gdes[im.gdes_c-1].ds_nam,
symname) != 2) {
im_free(&im);
rrd_set_error("can't parse DEF '%s' -2",&argv[i][argstart]);
return -1;
}
} else {
im_free(&im);
rrd_set_error("can't parse DEF '%s'",&argv[i][argstart]);
return -1;
}
/* checking for duplicate DEF CDEFS */
if (find_var(&im,im.gdes[im.gdes_c-1].vname) != -1) {
im_free(&im);
rrd_set_error("duplicate variable '%s'",
im.gdes[im.gdes_c-1].vname);
return -1;
}
if((im.gdes[im.gdes_c-1].cf=cf_conv(symname))==-1) {
im_free(&im);
rrd_set_error("unknown cf '%s'",symname);
return -1;
}
break;
case GF_XPORT:
if((scancount=sscanf(
&argv[i][argstart],
"%29[^:]:%n",
varname,
&strstart))>=1) {
if(strstart <= 0) {
im.gdes[im.gdes_c-1].legend[0] = '\0';
} else {
scan_for_col(&argv[i][argstart+strstart],FMT_LEG_LEN,im.gdes[im.gdes_c-1].legend);
}
if((im.gdes[im.gdes_c-1].vidx=find_var(&im,varname))==-1) {
im_free(&im);
rrd_set_error("unknown variable '%s'",varname);
return -1;
}
} else {
im_free(&im);
rrd_set_error("can't parse '%s'",&argv[i][argstart]);
return -1;
}
break;
default:
break;
}
}
if (im.gdes_c == 0) {
rrd_set_error("can't make a graph without contents");
im_free(&im);
return(-1);
}
if (rrd_xport_fn(&im, start, end, step, col_cnt, legend_v, data) == -1) {
im_free(&im);
return -1;
}
im_free(&im);
return 0;
}
int
rrd_fetch(int argc,
char **argv,
time_t *start,
time_t *end, /* which time frame do you want ?
* will be changed to represent reality */
unsigned long *step, /* which stepsize do you want?
* will be changed to represent reality */
unsigned long *ds_cnt, /* number of data sources in file */
char ***ds_namv, /* names of data sources */
rrd_value_t **data) /* two dimensional array containing the data */
{
long step_tmp =1;
time_t start_tmp=0, end_tmp=0;
enum cf_en cf_idx;
struct rrd_time_value start_tv, end_tv;
char *parsetime_error = NULL;
optind = 0; opterr = 0; /* initialize getopt */
/* init start and end time */
parsetime("end-24h", &start_tv);
parsetime("now", &end_tv);
while (1){
static struct option long_options[] =
{
{"resolution", required_argument, 0, 'r'},
{"start", required_argument, 0, 's'},
{"end", required_argument, 0, 'e'},
{0,0,0,0}
};
int option_index = 0;
int opt;
opt = getopt_long(argc, argv, "r:s:e:",
long_options, &option_index);
if (opt == EOF)
break;
switch(opt) {
case 's':
if ((parsetime_error = parsetime(optarg, &start_tv))) {
rrd_set_error( "start time: %s", parsetime_error );
return -1;
}
break;
case 'e':
if ((parsetime_error = parsetime(optarg, &end_tv))) {
rrd_set_error( "end time: %s", parsetime_error );
return -1;
}
break;
case 'r':
step_tmp = atol(optarg);
break;
case '?':
rrd_set_error("unknown option '-%c'",optopt);
return(-1);
}
}
if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
return -1;
}
if (start_tmp < 3600*24*365*10){
rrd_set_error("the first entry to fetch should be after 1980");
return(-1);
}
if (end_tmp < start_tmp) {
rrd_set_error("start (%ld) should be less than end (%ld)", start_tmp, end_tmp);
return(-1);
}
*start = start_tmp;
*end = end_tmp;
if (step_tmp < 1) {
rrd_set_error("step must be >= 1 second");
return -1;
}
*step = step_tmp;
if (optind + 1 >= argc){
rrd_set_error("not enough arguments");
return -1;
}
if ((int)(cf_idx=cf_conv(argv[optind+1])) == -1 ){
return -1;
}
if (rrd_fetch_fn(argv[optind],cf_idx,start,end,step,ds_cnt,ds_namv,data) == -1)
return(-1);
return (0);
}
int
rrd_xport(int argc, char **argv, int UNUSED(*xsize),
time_t *start,
time_t *end, /* which time frame do you want ?
* will be changed to represent reality */
unsigned long *step, /* which stepsize do you want?
* 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) /* two dimensional array containing the data */
{
image_desc_t im;
time_t start_tmp=0,end_tmp=0;
struct rrd_time_value start_tv, end_tv;
char *parsetime_error = NULL;
optind = 0; opterr = 0; /* initialize getopt */
rrd_graph_init(&im);
parsetime("end-24h", &start_tv);
parsetime("now", &end_tv);
while (1){
static struct option long_options[] =
{
{"start", required_argument, 0, 's'},
{"end", required_argument, 0, 'e'},
{"maxrows", required_argument, 0, 'm'},
{"step", required_argument, 0, 261},
{0,0,0,0}
};
int option_index = 0;
int opt;
opt = getopt_long(argc, argv, "s:e:m:",
long_options, &option_index);
if (opt == EOF)
break;
switch(opt) {
case 261:
im.step = atoi(optarg);
break;
case 's':
if ((parsetime_error = parsetime(optarg, &start_tv))) {
rrd_set_error( "start time: %s", parsetime_error );
return -1;
}
break;
case 'e':
if ((parsetime_error = parsetime(optarg, &end_tv))) {
rrd_set_error( "end time: %s", parsetime_error );
return -1;
}
break;
case 'm':
im.xsize = atol(optarg);
if (im.xsize < 10) {
rrd_set_error("maxrows below 10 rows");
return -1;
}
break;
case '?':
rrd_set_error("unknown option '%c'", optopt);
return -1;
}
}
if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
return -1;
}
if (start_tmp < 3600*24*365*10){
rrd_set_error("the first entry to fetch should be after 1980 (%ld)",start_tmp);
return -1;
}
if (end_tmp < start_tmp) {
rrd_set_error("start (%ld) should be less than end (%ld)",
start_tmp, end_tmp);
return -1;
}
im.start = start_tmp;
im.end = end_tmp;
im.step = max((long)im.step, (im.end-im.start)/im.xsize);
rrd_graph_script(argc,argv,&im,0);
if (rrd_test_error()) {
im_free(&im);
return -1;
}
if (im.gdes_c == 0){
rrd_set_error("can't make a graph without contents");
im_free(&im);
return(-1);
}
if (rrd_xport_fn(&im, start, end, step, col_cnt, legend_v, data) == -1){
im_free(&im);
return -1;
}
im_free(&im);
return 0;
}
