int
QmcContext::traverse(const char *name, QStringList &list)
{
int sts;
theStringList = &list;
theStringList->clear();
if ((sts = pmUseContext(my.context)) < 0)
return sts;
sts = pmTraversePMNS(name, QmcContext::dometric);
if (pmDebug & DBG_TRACE_PMC) {
QTextStream cerr(stderr);
if (sts >= 0) {
cerr << "QmcContext::traverse: Found " << list.size()
<< " names from " << name << endl;
}
else
cerr << "QmcContext::traverse: Failed: " << pmErrStr(sts)
<< endl;
}
return sts;
}
static void *
func1(void *arg)
{
int sts;
int i;
char msgbuf[PM_MAXERRMSGLEN];
for (i = 0; i < ITER; i++) {
nmetric = 0;
sts = pmTraversePMNS("", dometric);
if (sts >= 0)
printf("traverse: found %d metrics, sts %d\n", nmetric, sts);
else {
/*
* expect 0 metrics and PM_ERR_NOPMNS if the pmTraversePMNS
* gets in between the pmUnloadPMNS and the pmLoadPMNS in the
* other thread
*/
if (nmetric > 0 || sts != PM_ERR_NOPMNS)
printf("traverse: found %d metrics, sts %s\n", nmetric, pmErrStr_r(sts, msgbuf, PM_MAXERRMSGLEN));
else {
/*
* nmetric == 0 && sts == PM_ERR_NOPMNS, so try again ...
* won't loop forever because eventually func2() will
* finish
*/
i--;
}
}
}
pthread_exit(NULL);
}
static int
traverse(const char *str, double scale)
{
pmMetricSpec *theMetric;
char *msg;
int sts = 0;
sts = pmParseMetricSpec((char *)str, 0, (char *)0, &theMetric, &msg);
if (sts < 0) {
pmprintf("%s: Error: Unable to parse metric spec:\n%s\n",
pmProgname, msg);
free(msg);
return sts;
}
// If the metric has instances, then it cannot be traversed
if (theMetric->ninst) {
QmcMetric *metric = group->addMetric(theMetric, scale);
if (metric->status() >= 0) {
checkUnits(metric);
metrics.append(metric);
numValues += metric->numValues();
}
else
sts = -1;
}
else {
if (theMetric->isarch == 0)
doMetricType = PM_CONTEXT_HOST;
else if (theMetric->isarch == 1)
doMetricType = PM_CONTEXT_ARCHIVE;
else if (theMetric->isarch == 2)
doMetricType = PM_CONTEXT_LOCAL;
else {
pmprintf("%s: Error: invalid metric source (%d): %s\n",
pmProgname, theMetric->isarch, theMetric->metric);
sts = -1;
}
doMetricSource = theMetric->source;
if (sts >= 0)
sts = group->use(doMetricType, doMetricSource);
if (sts >= 0) {
doMetricScale = scale;
sts = pmTraversePMNS(theMetric->metric, dometric);
if (sts >= 0 && doMetricFlag == false)
sts = -1;
else if (sts < 0) {
pmprintf("%s: Error: %s: %s\n",
pmProgname, theMetric->metric, pmErrStr(sts));
}
}
}
free(theMetric);
return sts;
}
ZBX_METRIC *zbx_module_item_list()
{
int sts;
ZBX_METRIC *mptr;
static ZBX_METRIC empty[] = { {NULL} };
/* Add PCP metrics to the Zabbix metric set. */
sts = pmTraversePMNS(ZBX_PCP_METRIC_BASE, zbx_module_pcp_add_metric);
if (sts < 0 || !metric_count) { free(metrics); return empty; }
/* Finalize the Zabbix set. */
mptr = metrics;
metrics = (ZBX_METRIC *)realloc(mptr, (metric_count + 1) * sizeof(ZBX_METRIC));
if (metrics == NULL) { free(mptr); return empty; }
metrics[metric_count].key = NULL;
return metrics;
}
int
main(int argc, char *argv[])
{
int c;
int sts;
char *rawfile = NULL;
int i;
int ctxid;
int first = 1;
int dflag = 0;
int iflag = 0;
int Lflag = 0;
int lflag = 0;
int Mflag = 0;
int mflag = 0;
int tflag = 0;
int vflag = 0;
int mode = PM_MODE_FORW;
__pmContext *ctxp;
pmResult *raw_result;
pmResult *skel_result = NULL;
pmResult *result;
struct timeval done;
while ((c = pmGetOptions(argc, argv, &opts)) != EOF) {
switch (c) {
case 'a': /* dump everything */
dflag = iflag = lflag = mflag = sflag = tflag = 1;
break;
case 'd': /* dump pmDesc structures */
dflag = 1;
break;
case 'i': /* dump instance domains */
iflag = 1;
break;
case 'L': /* dump label, verbose */
Lflag = 1;
lflag = 1;
break;
case 'l': /* dump label */
lflag = 1;
break;
case 'm': /* dump metrics in log */
mflag = 1;
break;
case 'M': /* report <mark> records */
Mflag = 1;
break;
case 'r': /* read log in reverse chornological order */
mode = PM_MODE_BACK;
break;
case 's': /* report data size in log */
sflag = 1;
break;
case 't': /* dump temporal index */
tflag = 1;
break;
case 'v': /* verbose, dump in raw format */
vflag = 1;
rawfile = opts.optarg;
break;
case 'x': /* report Ddd Mmm DD <timestamp> YYYY */
/* -xx reports numeric timeval also */
xflag++;
break;
}
}
if (opts.errors ||
(vflag && opts.optind != argc) ||
(!vflag && opts.optind > argc - 1 && !opts.narchives)) {
pmUsageMessage(&opts);
exit(1);
}
if (vflag) {
FILE *f;
if ((f = fopen(rawfile, "r")) == NULL) {
fprintf(stderr, "%s: Cannot open \"%s\": %s\n", pmProgname, rawfile, osstrerror());
exit(1);
}
printf("Raw dump of physical archive file \"%s\" ...\n", rawfile);
rawdump(f);
exit(0);
}
if (dflag + iflag + lflag + mflag + tflag == 0)
mflag = 1; /* default */
/* delay option end processing until now that we have the archive name */
if (opts.narchives == 0)
__pmAddOptArchive(&opts, argv[opts.optind++]);
opts.flags &= ~PM_OPTFLAG_DONE;
__pmEndOptions(&opts);
if ((sts = ctxid = pmNewContext(PM_CONTEXT_ARCHIVE, opts.archives[0])) < 0) {
fprintf(stderr, "%s: Cannot open archive \"%s\": %s\n",
pmProgname, opts.archives[0], pmErrStr(sts));
exit(1);
}
/* complete TZ and time window option (origin) setup */
if (pmGetContextOptions(ctxid, &opts)) {
pmflush();
exit(1);
}
numpmid = argc - opts.optind;
if (numpmid) {
numpmid = 0;
pmid = NULL;
for (i = 0; opts.optind < argc; i++, opts.optind++) {
numpmid++;
pmid = (pmID *)realloc(pmid, numpmid * sizeof(pmID));
if ((sts = pmLookupName(1, &argv[opts.optind], &pmid[numpmid-1])) < 0) {
if (sts == PM_ERR_NONLEAF) {
numpmid--;
if ((sts = pmTraversePMNS(argv[opts.optind], dometric)) < 0)
fprintf(stderr, "%s: pmTraversePMNS(%s): %s\n",
pmProgname, argv[opts.optind], pmErrStr(sts));
}
else
fprintf(stderr, "%s: pmLookupName(%s): %s\n",
pmProgname, argv[opts.optind], pmErrStr(sts));
if (sts < 0)
numpmid--;
}
}
if (numpmid == 0) {
fprintf(stderr, "No metric names can be translated, dump abandoned\n");
exit(1);
}
}
if ((sts = pmGetArchiveLabel(&label)) < 0) {
fprintf(stderr, "%s: Cannot get archive label record: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
if (numpmid > 0) {
/*
* setup dummy pmResult
*/
skel_result = (pmResult *)malloc(sizeof(pmResult)+(numpmid-1)*sizeof(pmValueSet *));
if (skel_result == NULL) {
fprintf(stderr, "%s: malloc(skel_result): %s\n", pmProgname, osstrerror());
exit(1);
}
}
/*
* Note: ctxp->c_lock remains locked throughout ... __pmHandleToPtr()
* is only called once, and a single context is used throughout
* ... so there is no PM_UNLOCK(ctxp->c_lock) anywhere in the
* pmdumplog code.
* This works because ctxp->c_lock is a recursive lock and
* pmdumplog is single-threaded.
*/
if ((ctxp = __pmHandleToPtr(ctxid)) == NULL) {
fprintf(stderr, "%s: botch: __pmHandleToPtr(%d) returns NULL!\n",
pmProgname, ctxid);
exit(1);
}
pmSetMode(mode, &opts.start, 0);
if (lflag)
dumpLabel(Lflag);
if (dflag)
dumpDesc(ctxp);
if (iflag)
dumpInDom(ctxp);
if (tflag)
dumpTI(ctxp);
if (mflag) {
if (mode == PM_MODE_FORW) {
if (opts.start_optarg != NULL || opts.finish_optarg != NULL) {
/* -S or -T */
sts = pmSetMode(mode, &opts.start, 0);
done = opts.finish;
}
else {
/* read the whole archive */
done.tv_sec = 0;
done.tv_usec = 0;
sts = pmSetMode(mode, &done, 0);
done.tv_sec = INT_MAX;
}
}
else {
if (opts.start_optarg != NULL || opts.finish_optarg != NULL) {
/* -S or -T */
done.tv_sec = INT_MAX;
done.tv_usec = 0;
sts = pmSetMode(mode, &done, 0);
done = opts.start;
}
else {
/* read the whole archive backwards */
done.tv_sec = INT_MAX;
done.tv_usec = 0;
sts = pmSetMode(mode, &done, 0);
done.tv_sec = 0;
}
}
if (sts < 0) {
fprintf(stderr, "%s: pmSetMode: %s\n", pmProgname, pmErrStr(sts));
exit(1);
}
sts = 0;
for ( ; ; ) {
sts = __pmLogFetch(ctxp, 0, NULL, &raw_result);
if (sts < 0)
break;
if (numpmid == 0 || (raw_result->numpmid == 0 && Mflag)) {
/*
* want 'em all or <mark> record ...
*/
result = raw_result;
}
else if (numpmid > 0) {
/*
* cherry pick from raw_result if pmid matches one
* of interest
*/
int picked = 0;
int j;
skel_result->timestamp = raw_result->timestamp;
for (j = 0; j < numpmid; j++)
skel_result->vset[j] = NULL;
for (i = 0; i < raw_result->numpmid; i++) {
for (j = 0; j < numpmid; j++) {
if (pmid[j] == raw_result->vset[i]->pmid) {
skel_result->vset[j] = raw_result->vset[i];
picked++;
break;
}
}
}
if (picked == 0) {
/* no metrics of interest, skip this record */
pmFreeResult(raw_result);
continue;
}
skel_result->numpmid = picked;
if (picked != numpmid) {
/* did not find 'em all ... shuffle time */
int j;
i = 0;
for (j = 0; j < numpmid; j++) {
if (skel_result->vset[j] != NULL)
skel_result->vset[i++] = skel_result->vset[j];
}
}
result = skel_result;
}
else {
/* not interesting */
pmFreeResult(raw_result);
continue;
}
if (first && mode == PM_MODE_BACK) {
first = 0;
printf("\nLog finished at %24.24s - dump in reverse order\n",
pmCtime(&result->timestamp.tv_sec, timebuf));
}
if ((mode == PM_MODE_FORW && tvcmp(result->timestamp, done) > 0) ||
(mode == PM_MODE_BACK && tvcmp(result->timestamp, done) < 0)) {
sts = PM_ERR_EOL;
break;
}
putchar('\n');
dump_result(result);
pmFreeResult(raw_result);
}
if (sts != PM_ERR_EOL) {
fprintf(stderr, "%s: pmFetch: %s\n", pmProgname, pmErrStr(sts));
exit(1);
}
}
exit(0);
}
int
main(int argc, char **argv)
{
int sts;
char *msg;
pmResult *irp; /* input pmResult */
pmResult *orp; /* output pmResult */
__pmPDU *pb; /* pdu buffer */
struct timeval unused;
unsigned long peek_offset;
/* process cmd line args */
if (parseargs(argc, argv) < 0) {
pmUsageMessage(&opts);
exit(1);
}
/* input archive name is argv[opts.optind] */
/* output archive name is argv[argc-1]) */
/* output archive */
oname = argv[argc-1];
/* input archive */
iname = argv[opts.optind];
/*
* This is the interp mode context
*/
if ((ictx_a = pmNewContext(PM_CONTEXT_ARCHIVE, iname)) < 0) {
fprintf(stderr, "%s: Error: cannot open archive \"%s\" (ctx_a): %s\n",
pmProgname, iname, pmErrStr(ictx_a));
exit(1);
}
if ((sts = pmGetArchiveLabel(&ilabel)) < 0) {
fprintf(stderr, "%s: Error: cannot get archive label record (%s): %s\n", pmProgname, iname, pmErrStr(sts));
exit(1);
}
/* start time */
logstart_tval.tv_sec = ilabel.ll_start.tv_sec;
logstart_tval.tv_usec = ilabel.ll_start.tv_usec;
/* end time */
if ((sts = pmGetArchiveEnd(&logend_tval)) < 0) {
fprintf(stderr, "%s: Error: cannot get end of archive (%s): %s\n",
pmProgname, iname, pmErrStr(sts));
exit(1);
}
if (zarg) {
/* use TZ from metrics source (input-archive) */
if ((sts = pmNewZone(ilabel.ll_tz)) < 0) {
fprintf(stderr, "%s: Cannot set context timezone: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
printf("Note: timezone set to local timezone of host \"%s\" from archive\n\n", ilabel.ll_hostname);
}
else if (tz != NULL) {
/* use TZ as specified by user */
if ((sts = pmNewZone(tz)) < 0) {
fprintf(stderr, "%s: Cannot set timezone to \"%s\": %s\n",
pmProgname, tz, pmErrStr(sts));
exit(1);
}
printf("Note: timezone set to \"TZ=%s\"\n\n", tz);
}
else {
char *tz;
tz = __pmTimezone();
/* use TZ from local host */
if ((sts = pmNewZone(tz)) < 0) {
fprintf(stderr, "%s: Cannot set local host's timezone: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
}
/* set winstart and winend timevals */
sts = pmParseTimeWindow(Sarg, Targ, Aarg, Oarg,
&logstart_tval, &logend_tval,
&winstart_tval, &winend_tval, &unused, &msg);
if (sts < 0) {
fprintf(stderr, "%s: Invalid time window specified: %s\n",
pmProgname, msg);
exit(1);
}
#if PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL0) {
char buf[26];
pmCtime((const time_t *)&winstart_tval.tv_sec, buf);
fprintf(stderr, "Start time: %s", buf);
pmCtime((const time_t *)&winend_tval.tv_sec, buf);
fprintf(stderr, "End time: %s", buf);
}
#endif
if ((sts = pmSetMode(PM_MODE_INTERP | PM_XTB_SET(PM_TIME_SEC),
&winstart_tval, (int)targ)) < 0) {
fprintf(stderr, "%s: pmSetMode(PM_MODE_INTERP ...) failed: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
/* create output log - must be done before writing label */
if ((sts = __pmLogCreate("", oname, PM_LOG_VERS02, &logctl)) < 0) {
fprintf(stderr, "%s: Error: __pmLogCreate: %s\n",
pmProgname, pmErrStr(sts));
exit(1);
}
/* This must be done after log is created:
* - checks that archive version, host, and timezone are ok
* - set archive version, host, and timezone of output archive
* - set start time
* - write labels
*/
newlabel();
current.tv_sec = logctl.l_label.ill_start.tv_sec = winstart_tval.tv_sec;
current.tv_usec = logctl.l_label.ill_start.tv_usec = winstart_tval.tv_usec;
/* write label record */
writelabel();
/*
* Supress any automatic label creation in libpcp at the first
* pmResult write.
*/
logctl.l_state = PM_LOG_STATE_INIT;
/*
* Traverse the PMNS to get all the metrics and their metadata
*/
if ((sts = pmTraversePMNS ("", dometric)) < 0) {
fprintf(stderr, "%s: Error traversing namespace ... %s\n",
pmProgname, pmErrStr(sts));
goto cleanup;
}
/*
* All the initial metadata has been generated, add timestamp
*/
fflush(logctl.l_mdfp);
__pmLogPutIndex(&logctl, ¤t);
written = 0;
/*
* main loop
*/
while (sarg == -1 || written < sarg) {
/*
* do stuff
*/
if ((sts = pmUseContext(ictx_a)) < 0) {
fprintf(stderr, "%s: Error: cannot use context (%s): %s\n",
pmProgname, iname, pmErrStr(sts));
goto cleanup;
}
if ((sts = pmFetch(numpmid, pmidlist, &irp)) < 0) {
if (sts == PM_ERR_EOL)
break;
fprintf(stderr,
"%s: Error: pmFetch failed: %s\n", pmProgname, pmErrStr(sts));
exit(1);
}
if (irp->timestamp.tv_sec > winend_tval.tv_sec ||
(irp->timestamp.tv_sec == winend_tval.tv_sec &&
irp->timestamp.tv_usec > winend_tval.tv_usec)) {
/* past end time as per -T */
break;
}
#if PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2) {
fprintf(stderr, "input record ...\n");
__pmDumpResult(stderr, irp);
}
#endif
/*
* traverse the interval, looking at every archive record ...
* we are particularly interested in:
* - metric-values that are interpolated but not present in
* this interval
* - counter wraps
* - mark records
*/
doscan(&irp->timestamp);
if ((sts = pmUseContext(ictx_a)) < 0) {
fprintf(stderr, "%s: Error: cannot use context (%s): %s\n",
pmProgname, iname, pmErrStr(sts));
goto cleanup;
}
orp = rewrite(irp);
#if PCP_DEBUG
if (pmDebug & DBG_TRACE_APPL2) {
if (orp == NULL)
fprintf(stderr, "output record ... none!\n");
else {
fprintf(stderr, "output record ...\n");
__pmDumpResult(stderr, orp);
}
}
#endif
if (orp == NULL)
goto next;
/*
* convert log record to a PDU, and enforce V2 encoding semantics,
* then write it out
*/
sts = __pmEncodeResult(PDU_OVERRIDE2, orp, &pb);
if (sts < 0) {
fprintf(stderr, "%s: Error: __pmEncodeResult: %s\n",
pmProgname, pmErrStr(sts));
goto cleanup;
}
/* switch volumes if required */
if (varg > 0) {
if (written > 0 && (written % varg) == 0) {
__pmTimeval next_stamp;
next_stamp.tv_sec = irp->timestamp.tv_sec;
next_stamp.tv_usec = irp->timestamp.tv_usec;
newvolume(oname, &next_stamp);
}
}
/*
* Even without a -v option, we may need to switch volumes
* if the data file exceeds 2^31-1 bytes
*/
peek_offset = ftell(logctl.l_mfp);
peek_offset += ((__pmPDUHdr *)pb)->len - sizeof(__pmPDUHdr) + 2*sizeof(int);
if (peek_offset > 0x7fffffff) {
__pmTimeval next_stamp;
next_stamp.tv_sec = irp->timestamp.tv_sec;
next_stamp.tv_usec = irp->timestamp.tv_usec;
newvolume(oname, &next_stamp);
}
current.tv_sec = orp->timestamp.tv_sec;
current.tv_usec = orp->timestamp.tv_usec;
doindom(orp);
/* write out log record */
sts = __pmLogPutResult2(&logctl, pb);
__pmUnpinPDUBuf(pb);
if (sts < 0) {
fprintf(stderr, "%s: Error: __pmLogPutResult2: log data: %s\n",
pmProgname, pmErrStr(sts));
goto cleanup;
}
written++;
rewrite_free();
next:
pmFreeResult(irp);
}
/* write the last time stamp */
fflush(logctl.l_mfp);
fflush(logctl.l_mdfp);
__pmLogPutIndex(&logctl, ¤t);
exit(exit_status);
cleanup:
{
char fname[MAXNAMELEN];
fprintf(stderr, "Archive \"%s\" not created.\n", oname);
snprintf(fname, sizeof(fname), "%s.0", oname);
unlink(fname);
snprintf(fname, sizeof(fname), "%s.meta", oname);
unlink(fname);
snprintf(fname, sizeof(fname), "%s.index", oname);
unlink(fname);
exit(1);
}
}
int
main(int argc, char **argv)
{
int sts;
int c;
int help = 0;
int oneline = 0;
char *pmnsfile = PM_NS_DEFAULT;
int errflag = 0;
int aflag = 0;
int eflag = 0;
int allpmid = 0;
int allindom = 0;
char *filename;
char *tp;
char *name;
int id;
int next_type;
char *endnum;
__pmSetProgname(argv[0]);
while ((c = getopt(argc, argv, "D:eHin:Opv:?")) != EOF) {
switch (c) {
case 'D': /* debug flag */
sts = __pmParseDebug(optarg);
if (sts < 0) {
fprintf(stderr, "%s: unrecognized debug flag specification (%s)\n",
pmProgname, optarg);
errflag++;
}
else
pmDebug |= sts;
break;
case 'e': /* help text exists? */
eflag = 1;
break;
case 'H': /* help text */
help = 1;
break;
case 'i':
aflag++;
allindom = 1;
break;
case 'n': /* alternative namespace file */
pmnsfile = optarg;
break;
case 'O': /* oneline text */
oneline = 1;
break;
case 'p':
aflag++;
allpmid = 1;
break;
case 'v': /* version 2 only these days */
version = (int)strtol(optarg, &endnum, 10);
if (*endnum != '\0') {
fprintf(stderr, "%s: -v requires numeric argument\n", pmProgname);
errflag++;
}
if (version != 2) {
fprintf(stderr
,"%s: deprecated option - only version 2 is supported\n"
, pmProgname);
errflag++;
}
break;
case '?':
default:
errflag++;
break;
}
}
if (optind == argc) {
fprintf(stderr, "%s: missing helpfile argument\n\n", pmProgname);
errflag = 1;
}
if (aflag && optind < argc-1) {
fprintf(stderr, "%s: metricname arguments cannot be used with -i or -p\n\n",
pmProgname);
errflag = 1;
}
if (aflag == 0 && optind == argc-1 && oneline+help != 0) {
fprintf(stderr, "%s: -O or -H require metricname arguments or -i or -p\n\n",
pmProgname);
errflag = 1;
}
if (eflag && (allpmid || allindom)) {
fprintf(stderr, "%s: -e cannot be used with -i or -p\n\n",
pmProgname);
errflag = 1;
}
if (errflag || optind >= argc) {
fprintf(stderr,
"Usage: %s helpfile\n"
" %s [options] helpfile [metricname ...]\n"
"\n"
"Options:\n"
" -e exists check, only report metrics with no help text\n"
" -H display verbose help text\n"
" -i process all the instance domains\n"
" -n pmnsfile use an alternative PMNS\n"
" -O display the one line help summary\n"
" -p process all the metrics (PMIDs)\n"
" -v version deprecated (only version 2 format supported)\n"
"\n"
"No options implies silently check internal integrity of the helpfile.\n",
pmProgname, pmProgname);
exit(1);
}
filename = argv[optind++];
if ((handle = pmdaOpenHelp(filename)) < 0) {
fprintf(stderr, "pmdaOpenHelp: failed to open \"%s\": ", filename);
if (handle == -EINVAL)
fprintf(stderr, "Bad format, not version %d PCP help text\n", version);
else
fprintf(stderr, "%s\n", pmErrStr(handle));
exit(1);
}
if ((sts = pmLoadASCIINameSpace(pmnsfile, 1)) < 0) {
fprintf(stderr, "pmLoadASCIINameSpace(%s, 1): %s\n", pmnsfile, pmErrStr(sts));
exit(1);
}
if (help + oneline == 0 && (optind < argc || aflag))
/* if metric names, -p or -i => -O is default */
oneline = 1;
if (optind == argc && aflag == 0)
/* no metric names, process all entries */
aflag = 1;
if (eflag) {
if (optind == argc) {
sts = pmTraversePMNS("", dometric);
if (sts < 0) {
fprintf(stderr, "Error: pmTraversePMNS(\"\", ...): %s\n", pmErrStr(sts));
}
}
else {
for ( ; optind < argc; optind++) {
sts = pmTraversePMNS(argv[optind], dometric);
if (sts < 0)
fprintf(stderr, "Error: pmTraversePMNS(\"%s\", ...): %s\n", argv[optind], pmErrStr(sts));
}
}
exit(0);
}
while (optind < argc || aflag) {
if (aflag) {
if (next(&id, &next_type) == 0)
break;
#ifdef PCP_DEBUG
if ((pmDebug & DBG_TRACE_APPL0) && allindom+allpmid == 0)
fprintf(stderr, "next_type=%d id=0x%x\n", next_type, id);
#endif
if (next_type == 2) {
if (!allindom)
continue;
printf("\nInDom %s:", pmInDomStr((pmInDom)id));
}
else {
char **names;
if (!allpmid)
continue;
printf("\nPMID %s", pmIDStr((pmID)id));
sts = pmNameAll(id, &names);
if (sts > 0) {
printf(" ");
__pmPrintMetricNames(stdout, sts, names, " or ");
free(names);
}
putchar(':');
}
}
else {
next_type = 1;
name = argv[optind++];
if ((sts = pmLookupName(1, &name, (pmID *)&id)) < 0) {
printf("\n%s: %s\n", name, pmErrStr(sts));
continue;
}
if (id == PM_ID_NULL) {
printf("\n%s: unknown metric\n", name);
continue;
}
printf("\nPMID %s %s:", pmIDStr((pmID)id), name);
}
if (oneline) {
if (next_type == 1)
tp = pmdaGetHelp(handle, (pmID)id, PM_TEXT_ONELINE);
else
tp = pmdaGetInDomHelp(handle, (pmInDom)id, PM_TEXT_ONELINE);
if (tp != NULL)
printf(" %s", tp);
putchar('\n');
}
if (help) {
if (next_type == 1)
tp = pmdaGetHelp(handle, (pmID)id, PM_TEXT_HELP);
else
tp = pmdaGetInDomHelp(handle, (pmInDom)id, PM_TEXT_HELP);
if (tp != NULL && *tp)
printf("%s\n", tp);
}
}
return 0;
}
int
main(int argc, char **argv)
{
int a, c;
int sts;
int exitsts = 0;
char *source;
char *endnum;
while ((c = pmGetOptions(argc, argv, &opts)) != EOF) {
switch (c) {
case 'b': /* batchsize */
batchsize = (int)strtol(opts.optarg, &endnum, 10);
if (*endnum != '\0') {
pmprintf("%s: -b requires numeric argument\n", pmProgname);
opts.errors++;
}
break;
case 'c': /* derived metrics config file */
sts = pmLoadDerivedConfig(opts.optarg);
if (sts < 0) {
fprintf(stderr, "%s: derived configuration(s) error: %s\n", pmProgname, pmErrStr(sts));
/* errors are not necessarily fatal ... */
}
break;
case 'd':
p_desc = 1;
need_context = 1;
need_pmid = 1;
break;
case 'F':
p_force = p_value = 1;
need_context = 1;
need_pmid = 1;
break;
case 'f':
p_value = 1;
need_context = 1;
need_pmid = 1;
break;
case 'M':
p_fullmid = 1;
p_mid = 1;
need_pmid = 1;
break;
case 'm':
p_mid = 1;
need_pmid = 1;
break;
case 't':
p_oneline = 1;
need_context = 1;
need_pmid = 1;
break;
case 'T':
p_help = 1;
need_context = 1;
need_pmid = 1;
break;
case 'v':
verify = 1;
need_context = 1;
need_pmid = 1;
break;
case 'x':
events = p_value = 1;
need_context = 1;
need_pmid = 1;
break;
}
}
if (opts.errors) {
pmUsageMessage(&opts);
exit(1);
}
if (opts.context)
need_context = 1;
if (opts.context == PM_CONTEXT_ARCHIVE)
/*
* for archives, one metric per batch and start at beginning of
* archive for each batch so metric will be found if it is in
* the archive
*/
batchsize = 1;
if (verify)
p_desc = p_mid = p_fullmid = p_help = p_oneline = p_value = p_force = 0;
if ((namelist = (char **)malloc(batchsize * sizeof(char *))) == NULL) {
fprintf(stderr, "%s: namelist malloc: %s\n", pmProgname, osstrerror());
exit(1);
}
if ((pmidlist = (pmID *)malloc(batchsize * sizeof(pmID))) == NULL) {
fprintf(stderr, "%s: pmidlist malloc: %s\n", pmProgname, osstrerror());
exit(1);
}
if (!opts.nsflag)
need_context = 1; /* for distributed PMNS as no PMNS file given */
if (need_context) {
int ctxid;
if (opts.context == PM_CONTEXT_ARCHIVE)
source = opts.archives[0];
else if (opts.context == PM_CONTEXT_HOST)
source = opts.hosts[0];
else if (opts.context == PM_CONTEXT_LOCAL)
source = NULL;
else {
opts.context = PM_CONTEXT_HOST;
source = "local:";
}
if ((sts = pmNewContext(opts.context, source)) < 0) {
if (opts.context == PM_CONTEXT_HOST)
fprintf(stderr, "%s: Cannot connect to PMCD on host \"%s\": %s\n",
pmProgname, source, pmErrStr(sts));
else if (opts.context == PM_CONTEXT_LOCAL)
fprintf(stderr, "%s: Cannot make standalone connection on localhost: %s\n",
pmProgname, pmErrStr(sts));
else
fprintf(stderr, "%s: Cannot open archive \"%s\": %s\n",
pmProgname, source, pmErrStr(sts));
exit(1);
}
ctxid = sts;
if (opts.context == PM_CONTEXT_ARCHIVE) {
pmTrimNameSpace();
/* complete TZ and time window option (origin) setup */
if (pmGetContextOptions(ctxid, &opts)) {
pmflush();
exit(1);
}
}
}
if (opts.optind >= argc) {
sts = pmTraversePMNS("", dometric);
if (sts < 0) {
fprintf(stderr, "Error: %s\n", pmErrStr(sts));
exitsts = 1;
}
}
else {
for (a = opts.optind; a < argc; a++) {
sts = pmTraversePMNS(argv[a], dometric);
if (sts < 0) {
fprintf(stderr, "Error: %s: %s\n", argv[a], pmErrStr(sts));
exitsts = 1;
}
}
}
report();
exit(exitsts);
}
