自学教程：C++ rrd_clear_error函数代码示例

int update_rrd(char* file, long int last_up, data_t* dt){	if ( dt )	{		char data[256];		update_params[1] = file;		sprintf(data, "%ld:%u:%u:%u:%u:%u:%u",				last_up,				dt->bytes,				dt->ip_v4_bytes,				dt->not_ip_bytes,				dt->tcp_bytes,				dt->udp_bytes,				dt->other_bytes);		update_params[2] = data;		if (rrd_update(3, update_params))		{			fprintf(stderr, "rrd update failed: %s/n", rrd_get_error());			rrd_clear_error();		}		else				printf("%s updated!/n", file);		bzero(dt, sizeof(data_t));	}	else	    fprintf(stderr, "/nerror/n");	return 0;}

int create_rrd(char* file){	struct stat st;	if (file)	{				if (stat(file, &st))		{   /* stats fails*/			if (errno != ENOENT)			{ /* error occurred */				perror(file);				return -1;			}		}    /*  file exists  */		create_args[3] = file;		if (rrd_create(CREATE_ARGS, create_args))		{			fprintf(stderr, "unable to create file: %s/n", file);			fprintf(stderr, "%s/n", rrd_get_error());			rrd_clear_error();			return -1;		}		printf("file %s created/n", file);	}	return 0;}

char     *drawgraph(    long argc,    const char **args){    int       i, xsize, ysize;    double    ymin, ymax;    for (i = 0; i < argc; i++)        if (strcmp(args[i], "--imginfo") == 0 || strcmp(args[i], "-g") == 0)            break;    if (i == argc) {        args[argc++] = "--imginfo";        args[argc++] = "<IMG SRC=/"./%s/" WIDTH=/"%lu/" HEIGHT=/"%lu/">";    }    calfree();    if (rrd_graph        (argc + 1, (char **) args - 1, &calcpr, &xsize, &ysize, NULL, &ymin,         &ymax) != -1) {        return stralloc(calcpr[0]);    } else {        if (rrd_test_error()) {            const size_t len = strlen(rrd_get_error()) + DS_NAM_SIZE;            char *err = malloc(len);            snprintf(err, len, "[ERROR: %s]", rrd_get_error());            rrd_clear_error();            return err;        }    }    return NULL;}

static int rrd_common_call (lua_State *L, const char *cmd,			    RRD_FUNCTION rrd_function) {  char **argv;  int argc = lua_gettop(L) + 1;  if(ntop->getGlobals()->isShutdown()) return(CONST_LUA_PARAM_ERROR);  ntop->rrdLock(__FILE__, __LINE__);  rrd_clear_error();  argv = make_argv(cmd, L);  reset_rrd_state();  rrd_function(argc, argv);  free(argv);  if(rrd_test_error()) {    char *err =  rrd_get_error();    if(err != NULL) {      /*	IMPORTANT	It is important to unlock now as if luaL_error is called the	function returns and no unlock will take place      */      ntop->rrdUnlock(__FILE__, __LINE__);      luaL_error(L, err);    }  }  ntop->rrdUnlock(__FILE__, __LINE__);  return 0;}

/** * /brief Update RRD stats file * * /param[in] stats Stats data * /param[in] templ RRD template */void stats_update(stats_data *stats, std::string templ){	std::vector<std::string> argv;	/* Set RRD file */	argv.push_back("update");	argv.push_back(stats->file);	/* Set template */	argv.push_back("--template");	argv.push_back(templ);	/* Add counters */	argv.push_back(stats_counters_to_string(stats->last, stats->fields));	/* Create C style argv */	const char **c_argv = new const char*[argv.size()];	for (u_int16_t i = 0; i < argv.size(); ++i) {		c_argv[i] = argv[i].c_str();	}	/* Update database */	if (rrd_update(argv.size(), (char **) c_argv)) {		MSG_ERROR(msg_module, "RRD Insert Error: %s", rrd_get_error());		rrd_clear_error();	}	delete c_argv;}

void temperhum_rrd_update(char *fname, time_t tv_sec, struct sht1x_readings readings) {	char update[4096];	char buf[512];	const char *args[1];	args[0] = update;	snprintf(update, 4096, "%llu", (unsigned long long)tv_sec);	if (isnan(readings.temperature_celsius))		strcat(update, ":U");	else {		snprintf(buf, 512, ":%.2f", readings.temperature_celsius);		strcat(update, buf);	}	if (isnan(readings.relative_humidity))		strcat(update, ":U");	else {		snprintf(buf, 512, ":%.2f", readings.relative_humidity);		strcat(update, buf);	}	if (isnan(readings.dew_point))		strcat(update, ":U");	else {		snprintf(buf, 512, ":%.2f", readings.dew_point);		strcat(update, buf);	}	rrd_clear_error();	if (rrd_update_r(fname, "tc:rh:dp", 1, args) != 0)		fprintf(stderr, "%s: (%s) %s/n", fname, args[0], rrd_get_error());}

char     *printtimelast(    long argc,    const char **args){    time_t    last;    struct tm tm_last;    char     *buf;    if (argc == 2) {        buf = malloc(255);        if (buf == NULL) {            return stralloc("[ERROR: allocating strftime buffer]");        };        /* not raising argc in step with args - 1 since the last argument           will be used below for strftime  */        last = rrd_last(argc, (char **) args - 1);        if (rrd_test_error()) {            const size_t len = strlen(rrd_get_error()) + DS_NAM_SIZE;            char *err = malloc(len);            snprintf(err, len, "[ERROR: %s]", rrd_get_error());            rrd_clear_error();            return err;        }        tm_last = *localtime(&last);        strftime(buf, 254, args[1], &tm_last);        return buf;    }    return stralloc("[ERROR: expected <RRD::TIME::LAST file.rrd strftime-format>]");}

/* convenience function; if there is a daemon specified, or if we can * detect one from the environment, then flush the file.  Otherwise, no-op */int rrdc_flush_if_daemon (const char *opt_daemon, const char *filename) /* {{{ */{  int status = 0;  rrdc_connect(opt_daemon);  if (rrdc_is_connected(opt_daemon))  {    rrd_clear_error();    status = rrdc_flush (filename);    if (status != 0 && !rrd_test_error())    {      if (status > 0)      {        rrd_set_error("rrdc_flush (%s) failed: %s",                      filename, rrd_strerror(status));      }      else if (status < 0)      {        rrd_set_error("rrdc_flush (%s) failed with status %i.",                      filename, status);      }    }  } /* if (rrdc_is_connected(..)) */  return status;} /* }}} int rrdc_flush_if_daemon */

char* printtimelast(long argc, const char **args) {  time_t last;  struct tm tm_last;  char *buf;  if ( argc == 2 ) {    buf = malloc(255);    if (buf == NULL){		return stralloc("[ERROR: allocating strftime buffer]");    };    last = rrd_last(argc+1, (char **) args-1);     if (rrd_test_error()) {      char *err = malloc((strlen(rrd_get_error())+DS_NAM_SIZE)*sizeof(char));      sprintf(err, "[ERROR: %s]",rrd_get_error());      rrd_clear_error();      return err;    }    tm_last = *localtime(&last);    strftime(buf,254,args[1],&tm_last);    return buf;  }  if ( argc < 2 ) {    return stralloc("[ERROR: too few arguments for RRD::TIME::LAST]");  }  return stralloc("[ERROR: not enough arguments for RRD::TIME::LAST]");}

voidrrdtool_create_command (const char *name, const char *what){  // rrd_create needs the time of the first entry, so it  // called at the time of the first update; therefore, we  // need to backup the original rrd entry -- in order not   // overwrite the update command contained in rrd.cmd    rrd_struct temp_rrd = rrd;  if (RRD_DEBUG)    fprintf (fp_stderr, "rrdtool: create(%s,%s)/n", name, what);#ifdef RRD_TREE  sprintf (temp_rrd.file, "%s/%s", rrd.conf.path, name, what);  struct stat fbuf;  if (!((stat (temp_rrd.file, &fbuf) == 0) && S_ISDIR (fbuf.st_mode)))    {      mkdir (temp_rrd.file, 0775);      if (debug > 1)	fprintf (fp_stderr, "RRDtool database path <%s> created/n",		 temp_rrd.file);    }  sprintf (temp_rrd.file, "%s/%s/%s.rrd", rrd.conf.path, name, what);#else  sprintf (temp_rrd.file, "%s/%s.%s.rrd", rrd.conf.path, name, what);#endif  rrd.time_update = (unsigned long) current_time.tv_sec;  if (stat (temp_rrd.file, &temp_rrd.fbuf) == 0)    {      if (debug > 1)	fprintf (fp_stderr, "rrdtool: skip create <%s> ... already existent/n",		 temp_rrd.file);      return;			/* already called ? */    }  /* MTRG-like behavior for on-line usage */  sprintf (temp_rrd.cmd,        "create %s --step %lu --start %ld DS:%s:GAUGE:%lu:U:U %s %s %s %s",        temp_rrd.file, (unsigned long) (GLOBALS.Max_Time_Step / 1000000),        (long) rrd.time_update - 10, name, (unsigned long) (GLOBALS.Max_Time_Step / 500000),	   RRA_DAILY, RRA_WEEKLY, RRA_MONTHLY, RRA_YEARLY);  if (debug > 1)    fprintf (fp_stderr, "rrdtool: rrd_create('%s')/n", temp_rrd.cmd);  optind = 0;  opterr = 0;  rrdtool_str2argv (temp_rrd.cmd);  rrd_create (rrd.argc, rrd.argv);  if (rrd_test_error ())    {      fprintf (fp_stderr, "rrdtool: create command:/n%s/n", temp_rrd.cmd);      fprintf (fp_stderr, "rrdtool: create error!/n%s/n", rrd_get_error ());      if (temp_rrd.fatal)	exit (1);      rrd_clear_error ();    }}

static void throwException(JNIEnv *env, char *exception, char *msg) {  int rc = (*env)->ThrowNew(env, (*env)->FindClass(env, exception), msg);  if(rc < 0)  /* couldn't find exception class */    (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/Exception"), msg);  rrd_clear_error();}

int main(int argc, char *argv[]){    char *rrdargs[] = {        "rrdgraph",        "bbgen.png",        "-s", "e - 48d",        "--title", "bbgen runtime last 48 days",        "-w576",        "-v", "Seconds",        "-a", "PNG",        "DEF:rt=bbgen.rrd:runtime:AVERAGE",        "AREA:rt#00CCCC:Run Time",        "COMMENT: Timestamp",        NULL    };    char **calcpr=NULL;    int pcount, result, xsize, ysize;    double ymin, ymax;    for (pcount = 0; (rrdargs[pcount]); pcount++);    rrd_clear_error();#ifdef RRDTOOL12    result = rrd_graph(pcount, rrdargs, &calcpr, &xsize, &ysize, NULL, &ymin, &ymax);#else    result = rrd_graph(pcount, rrdargs, &calcpr, &xsize, &ysize);#endif    return 0;}

static intRRD_update( char *rrd, const char *sum, const char *num, unsigned int process_time ){    char *argv[3];    int   argc = 3;    char val[128];    /* If we are a host RRD, we "sum" over only one host. */    if (num)        sprintf(val, "%d:%s:%s", process_time, sum, num);    else        sprintf(val, "%d:%s", process_time, sum);    argv[0] = "dummy";    argv[1] = rrd;    argv[2] = val;    pthread_mutex_lock( &rrd_mutex );    optind=0;    opterr=0;    rrd_clear_error();    rrd_update(argc, argv);    if(rrd_test_error())    {        err_msg("RRD_update (%s): %s", rrd, rrd_get_error());        pthread_mutex_unlock( &rrd_mutex );        return 0;    }    /* debug_msg("Updated rrd %s with value %s", rrd, val); */    pthread_mutex_unlock( &rrd_mutex );    return 0;}

void reset_rrd_state(    ){    optind = 0;    opterr = 0;    rrd_clear_error();}

static int srrd_create(const char *filename, /* {{{ */                       unsigned long pdp_step, time_t last_up, int argc,                       const char **argv) {  int status;  char *filename_copy;  if ((filename == NULL) || (argv == NULL))    return -EINVAL;  /* Some versions of librrd don't have the `const' qualifier for the first   * argument, so we have to copy the pointer here to avoid warnings. It sucks,   * but what else can we do? :(  -octo */  filename_copy = strdup(filename);  if (filename_copy == NULL) {    ERROR("srrd_create: strdup failed.");    return -ENOMEM;  }  optind = 0; /* bug in librrd? */  rrd_clear_error();  status = rrd_create_r(filename_copy, pdp_step, last_up, argc, (void *)argv);  if (status != 0) {    P_WARNING("srrd_create: rrd_create_r (%s) failed: %s", filename,              rrd_get_error());  }  sfree(filename_copy);  return status;} /* }}} int srrd_create */

/**  * @brief  创建RRD数据库 * @param   rrd_file     rrd数据库路径 * @param   summary 标志位是否summary * @param   step    步长 * @return  成功返回0，失败返回-1 */int c_rrd_handler::RRD_create(const char *rrd_file, bool summary, unsigned int step){    /* Warning: RRD_create will overwrite a RRD if it already exists */    int  argc = 0;    const char *argv[128] = {NULL};    const char *data_source_type = "GAUGE";    int  heartbeat = 30;    char sstep[16] = {'/0'};    char sstart[64] = {'/0'};    char ssum[64] = {'/0'};    char snum[64] = {'/0'};    /* Our heartbeat is twice the step interval. */    heartbeat = 2 * step;    argv[argc++] = "dummy";    argv[argc++] = rrd_file;    argv[argc++] = "--step";    sprintf(sstep, "%u", step);    argv[argc++] = sstep;    argv[argc++] = "--start";    sprintf(sstart, "%lu", time(NULL) - 1);    argv[argc++] = sstart;    sprintf(ssum, "DS:sum:%s:%d:U:U", data_source_type, heartbeat);    argv[argc++] = ssum;    if(summary)    {        sprintf(snum, "DS:num:%s:%d:U:U", data_source_type, heartbeat);        argv[argc++] = snum;    }    if (g_is_switch_rrd)    {        GEN_SWITCH_RRA(argc, argv);    }    else    {        GEN_SERVER_RRA(argc, argv);    }    optind = 0;    optopt = 0;    opterr = 0;    optarg = NULL;    rrd_clear_error();    rrd_create(argc, (char**)argv);    if(rrd_test_error())    {        ERROR_LOG("RRD_create error: %s", rrd_get_error());        return -1;    }    DEBUG_LOG("CREATE RRD[%s]", rrd_file);    return 0;}

void * call_rrd_update(void*arg){	char buffer [2000];	int i = 0;	time_t t;	srand((unsigned) time(&t));		/* Set Cpu and I/O low priority 	struct sched_param sc_par;	sc_par.sched_priority = 0;	pthread_setschedparam(pthread_self(), SCHED_OTHER, &sc_par);	setpriority(PRIO_PROCESS, 0, 19);	syscall(SYS_ioprio_set,1, 0,  (2<< 13)| 7);*/	/* Open pipe as a stream */	FILE * buffer_pipe = fdopen(command_pipe[0], "r");	rrd_clear_error ();	/* Infinite loop on pipe */	while(1){		usleep(10000);		fgets(buffer,2000,buffer_pipe);		/* Replace /n with /0 */		buffer[strlen(buffer)-1]= '/0';		/* Execute update */		rrdtool_str2argv(buffer);		optind = 0; 		opterr = 0;		rrd_update (rrd.argc, rrd.argv);		//if (i++%1000 == 0)printf("RRD/n"); 			/* Check errors */		if (rrd_test_error ())		{			fprintf (fp_stderr, "rrdtool: update command:/n'%s'/n", buffer);			fprintf (fp_stderr, "rrdtool: update error!/n%s/n", rrd_get_error ());			if (rrd.fatal)				exit (1);			rrd_clear_error ();		}			}	return NULL;}

/* *  Handles the GET requests by getting RRD to graph and sending the result * as an HTTP response. */static ngx_int_t ngx_http_rrd_show_graph(ngx_http_request_t *r){    ngx_log_t* log = r->connection->log;    ngx_http_rrd_loc_conf_t *rrd_conf;    rrd_conf = ngx_http_get_module_loc_conf(r, ngx_http_rrd_module);    /* Prepare args for rrdgraph */    int rrd_argc = -1;    char** rrd_arg = ngx_http_rrd_create_graph_arg(&rrd_argc, r,                                                   rrd_conf->db_name_cstyle);    if (NULL == rrd_arg) {        return NGX_HTTP_INTERNAL_SERVER_ERROR;    }    rrd_clear_error();    rrd_info_t* const rrd_graph_info = rrd_graph_v(rrd_argc, rrd_arg);    ngx_log_debug(NGX_LOG_DEBUG_HTTP, log, 0,                  "rrd_graph (%s, %s, %s, %s) returned %p.",                  rrd_arg[0], rrd_arg[1], rrd_arg[2], rrd_arg[3],                  rrd_graph_info);    if (NULL == rrd_graph_info) {        ngx_http_rrd_free_graph_arg(r->pool, rrd_argc, rrd_arg);        return ngx_http_rrd_outprintf(r, NGX_HTTP_INTERNAL_SERVER_ERROR,                            "Error graphing DB %s: %s", rrd_conf->db_name_cstyle,                            rrd_get_error());    }    rrd_info_t* it;    u_char* image_data = NULL;    size_t image_size = 0;    for(it = rrd_graph_info; NULL == image_data && it != NULL; it = it->next) {        if (it->key != NULL            && ngx_strncmp(it->key, "image", sizeof("image")) == 0) {            image_data = it->value.u_blo.ptr;            image_size = it->value.u_blo.size;        }    }    if (NULL == image_data) {        ngx_http_rrd_free_graph_arg(r->pool, rrd_argc, rrd_arg);        rrd_info_free(rrd_graph_info);        return ngx_http_rrd_outprintf(r, NGX_HTTP_INTERNAL_SERVER_ERROR,                            "No image returned graphing DB %s.",                            rrd_conf->db_name_cstyle);    }    ngx_chain_t* out_chain = ngx_http_rrd_get_picture_outchain(r->pool,                                                      image_data, image_size);    if (NULL == out_chain) {        ngx_http_rrd_free_graph_arg(r->pool, rrd_argc, rrd_arg);        rrd_info_free(rrd_graph_info);        return ngx_http_rrd_outprintf(r, NGX_HTTP_INTERNAL_SERVER_ERROR,                            "Problem returning image for DB %s.",                            rrd_conf->db_name_cstyle);    }    ngx_http_rrd_free_graph_arg(r->pool, rrd_argc, rrd_arg);    rrd_info_free(rrd_graph_info);    return ngx_http_rrd_png_file_200(r, out_chain);}

int rrdc_connect (const char *addr) /* {{{ */{  int status = 0;  if (addr == NULL) {    addr = getenv (ENV_RRDCACHED_ADDRESS);  }  if (addr == NULL || strcmp(addr,"") == 0 ) {    addr = NULL;    return 0;     }  pthread_mutex_lock(&lock);  if (sd >= 0 && sd_path != NULL && strcmp(addr, sd_path) == 0)  {    /* connection to the same daemon; use cached connection */    pthread_mutex_unlock (&lock);    return (0);  }  else  {    close_connection();  }  rrd_clear_error ();  if (strncmp ("unix:", addr, strlen ("unix:")) == 0)    status = rrdc_connect_unix (addr + strlen ("unix:"));  else if (addr[0] == '/')    status = rrdc_connect_unix (addr);  else    status = rrdc_connect_network(addr);  if (status == 0 && sd >= 0)    sd_path = strdup(addr);  else  {    char *err = rrd_test_error () ? rrd_get_error () : "Internal error";    /* err points the string that gets written to by rrd_set_error(), thus we     * cannot pass it to that function */    err = strdup (err);    rrd_set_error("Unable to connect to rrdcached: %s",                  (status < 0)                  ? (err ? err : "Internal error")                  : rrd_strerror (status));    if (err != NULL)      free (err);  }  pthread_mutex_unlock (&lock);  return (status);} /* }}} int rrdc_connect */

/* #endif HAVE_THREADSAFE_LIBRRD */#else /* !HAVE_THREADSAFE_LIBRRD */static int srrd_create (const char *filename, /* {{{ */                        unsigned long pdp_step, time_t last_up,                        int argc, const char **argv){    int status;    int new_argc;    char **new_argv;    char pdp_step_str[16];    char last_up_str[16];    new_argc = 6 + argc;    new_argv = (char **) malloc ((new_argc + 1) * sizeof (char *));    if (new_argv == NULL)    {        ERROR ("rrdtool plugin: malloc failed.");        return (-1);    }    if (last_up == 0)        last_up = time (NULL) - 10;    ssnprintf (pdp_step_str, sizeof (pdp_step_str), "%lu", pdp_step);    ssnprintf (last_up_str, sizeof (last_up_str), "%u", (unsigned int) last_up);    new_argv[0] = "create";    new_argv[1] = (void *) filename;    new_argv[2] = "-s";    new_argv[3] = pdp_step_str;    new_argv[4] = "-b";    new_argv[5] = last_up_str;    memcpy (new_argv + 6, argv, argc * sizeof (char *));    new_argv[new_argc] = NULL;    pthread_mutex_lock (&librrd_lock);    optind = 0; /* bug in librrd? */    rrd_clear_error ();    status = rrd_create (new_argc, new_argv);    pthread_mutex_unlock (&librrd_lock);    if (status != 0)    {        WARNING ("rrdtool plugin: rrd_create (%s) failed: %s",                 filename, rrd_get_error ());    }    sfree (new_argv);    return (status);} /* }}} int srrd_create */

int main(    int argc,    char **argv){    char *name=basename(argv[0]);    rrd_info_t *info;    if (!strcmp(name, "rrdcreate")) {        rrd_create(argc, argv);    }    else if (!strcmp(name, "rrdinfo")) {         info=rrd_info(argc, argv);         rrd_info_print(info);         rrd_info_free(info);    }    else {        rrd_update(argc, argv);    }    if (rrd_test_error()) {         printf("RRDtool " PACKAGE_VERSION               "  Copyright by Tobi Oetiker, 1997-2010/n/n");        if (!strcmp(name, "rrdcreate")) {            printf("Usage: rrdcreate <filename>/n"                   "/t/t/t[--start|-b start time]/n"                   "/t/t/t[--step|-s step]/n"                   "/t/t/t[--no-overwrite]/n"                   "/t/t/t[DS:ds-name:DST:dst arguments]/n"                   "/t/t/t[RRA:CF:cf arguments]/n/n");       }       else if (!strcmp(name, "rrdinfo")) {           printf("Usage: rrdinfo <filename>/n");       }       else {            printf("Usage: rrdupdate <filename>/n"                   "/t/t/t[--template|-t ds-name[:ds-name]...]/n"                   "/t/t/t[--skip-past-updates]/n"                   "/t/t/ttime|N:value[:value...]/n/n"                   "/t/t/[email
C++ rrd_get_error函数代码示例
C++ rr3_ftr函数代码示例