static void
minstats(const expirestats *stp)
{
static unsigned lastnprods = 0;
if(pq != NULL && log_is_enabled_info)
{
off_t highwater = -1;
size_t maxregions = 0;
(void) pq_highwater(pq, &highwater, &maxregions);
log_info("> Queue usage (bytes):%8ld",
(long)highwater);
log_info("> (nregions):%8ld",
(long)maxregions);
}
if(stp->nprods != 0 && stp->nprods != lastnprods)
{
double elapsed = d_diff_timestamp(&stp->lasthit,
&stp->firsthit);
elapsed /= 3600;
log_notice("> Recycled %10.3f kb/hr (%10.3f prods per hour)",
((double)stp->nbytes)/(1024 * elapsed),
((double)stp->nprods)/elapsed
);
lastnprods = stp->nprods;
}
}
/*
* called at exit
*/
static void
cleanup(void)
{
log_notice("Exiting");
if (done) {
/*
* We are not in the interrupt context, so these can be performed
* safely.
*/
fl_closeAll();
if (pq)
(void)pq_close(pq);
if (!tvEqual(palt_last_insertion, TS_ZERO)) {
timestampt now;
(void)set_timestamp(&now);
log_notice("Behind by %g s",
d_diff_timestamp(&now, &palt_last_insertion));
if (stateWrite(&palt_last_insertion) < 0) {
log_error("Couldn't save insertion-time of last processed "
"data-product");
}
}
while (reap(-1, WNOHANG) > 0)
/*EMPTY*/;
}
if(shmid != -1) {
log_notice("Deleting shared segment.");
shmctl(shmid, IPC_RMID, NULL);
}
if(semid != -1) {
semctl(semid, 0, IPC_RMID);
}
log_fini();
}
static void
dump_stats(const expirestats *stp)
{
char cp[32];
sprint_timestampt(cp, sizeof(cp), &stp->starttime);
log_notice("> Up since: %s", cp);
if(pq != NULL)
{
off_t highwater = -1;
size_t maxregions = 0;
(void) pq_highwater(pq, &highwater, &maxregions);
log_notice("> Queue usage (bytes):%8ld",
(long)highwater);
log_notice("> (nregions):%8ld",
(long)maxregions);
}
if(stp->nprods != 0)
{
double elapsed = d_diff_timestamp(&stp->lasthit,
&stp->firsthit);
elapsed /= 3600;
log_notice("> nbytes recycle: %10u (%10.3f kb/hr)",
stp->nbytes, ((double)stp->nbytes)/(1024 * elapsed));
log_notice("> nprods deleted: %10u (%10.3f per hour)",
stp->nprods, ((double)stp->nprods)/elapsed);
sprint_timestampt(cp, sizeof(cp), &stp->firsthit);
log_notice("> First deleted: %s", cp);
sprint_timestampt(cp, sizeof(cp), &stp->lasthit);
log_notice("> Last deleted: %s", cp);
}
else
{
log_notice("> nprods deleted 0");
}
}
static void
test_regTime(void)
{
RegStatus status;
timestampt value;
status = reg_putTime("/fooTime_key", &TS_ENDT);
if (status) {
log_error("test_regTime(): Couldn't put time");
}
else {
CU_ASSERT_EQUAL(status, 0);
}
status = reg_putTime("/fooTime_key", &TS_ZERO);
if (status) {
log_error("test_regTime(): Couldn't replace time");
}
else {
CU_ASSERT_EQUAL(status, 0);
}
status = reg_getTime("/fooTime_key", &value);
if (status) {
log_error("test_regTime(): Couldn't get time");
}
else {
CU_ASSERT_EQUAL(status, 0);
CU_ASSERT_EQUAL(d_diff_timestamp(&value, &TS_ZERO), 0.0);
}
status = reg_getTime("/barTime_key", &value);
if (status && ENOENT != status) {
log_error("test_regTime(): Couldn't put second time");
}
else {
CU_ASSERT_EQUAL(status, ENOENT);
}
}
static int
expire(pqueue *epq, const unsigned interval, const double age)
{
int status = ENOERR;
static timestampt now;
static prod_class eclss;
static prod_spec spec;
timestampt ts;
timestampt cursor;
double diff = 0.;
double max_latency = 0.;
size_t nr;
if(eclss.psa.psa_val == 0)
{
/* first time */
eclss.from = TS_ZERO;
eclss.psa.psa_len = 1;
eclss.psa.psa_val = &spec;
spec.feedtype = ANY;
spec.pattern = ".*";
regcomp(&spec.rgx, spec.pattern, REG_EXTENDED|REG_NOSUB);
}
(void) set_timestamp(&now);
if(d_diff_timestamp(&now, &eclss.to) < interval + age)
{
/* only run this routine every interval seconds */
udebug("not yet");
return ENOERR;
}
/* else */
eclss.to = now;
eclss.to.tv_sec -= age;
if(ulogIsDebug())
{
char cp[64];
sprint_timestampt(cp, sizeof(cp), &eclss.to);
udebug("to %s", cp);
}
pq_cset(epq, &TS_ZERO);
while(exitIfDone(0) && !stats_req)
{
nr = 0;
status = pq_seqdel(epq, TV_GT, &eclss, 0, &nr, &ts);
switch(status) {
case ENOERR:
pq_ctimestamp(epq, &cursor);
diff = d_diff_timestamp(&cursor, &ts);
if(diff > max_latency)
{
max_latency = diff;
udebug("max_latency %.3f", max_latency);
}
if(nr == 0)
{
diff = d_diff_timestamp(&cursor, &eclss.to);
udebug("diff %.3f", diff);
if(diff > interval + max_latency)
{
udebug("heuristic depth break");
break;
}
}
continue; /* N.B., other cases break and return */
case PQUEUE_END:
udebug("expire: End of Queue");
break;
case EAGAIN:
case EACCES:
udebug("Hit a lock");
break;
#if defined(EDEADLOCK) && EDEADLOCK != EDEADLK
case EDEADLOCK:
#endif
case EDEADLK:
uerror("%s", strerror(status));
break;
default:
uerror("pq_seqdel failed: %s (errno = %d)",
strerror(status), status);
break;
}
break;
}
return status;
}
static void
test_regNode(void)
{
RegStatus status;
RegNode* testnode;
RegNode* subnode;
char* string;
const char* constString;
unsigned uint;
int boolean;
timestampt time;
signaturet defSig1 = {0};
signaturet defSig2 = {1};
signaturet sig;
status = reg_getNode("/test_node/subnode", &subnode, 1);
if (status) {
log_error("test_regNode(): Couldn't get subnode");
}
else {
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_PTR_NOT_NULL(subnode);
}
constString = reg_getNodeName(subnode);
CU_ASSERT_STRING_EQUAL(constString, "subnode");
constString = reg_getNodeAbsPath(subnode);
CU_ASSERT_STRING_EQUAL(constString, "/test_node/subnode");
status = reg_getNodeString(subnode, "string_key", &string);
if (status && ENOENT != status) {
log_error("test_regNode(): Couldn't verify non-existant subnode string");
}
else {
CU_ASSERT_EQUAL(status, ENOENT);
}
status = reg_putNodeString(subnode, "string_key", "string value");
if (0 != status) {
log_error("test_regNode(): Couldn't add subnode string");
}
else {
CU_ASSERT_EQUAL(status, 0);
}
status = reg_getNodeString(subnode, "string_key", &string);
if (status) {
log_error("test_regNode(): Couldn't get subnode string");
}
else {
CU_ASSERT_EQUAL(status, 0);
CU_ASSERT_STRING_EQUAL(string, "string value");
free(string);
}
status = reg_getNodeBool(subnode, "bool_key", &boolean);
if (status && ENOENT != status) {
log_error("test_regNode(): Couldn't verify non-existant subnode boolean");
}
else {
CU_ASSERT_EQUAL(status, ENOENT);
}
status = reg_putNodeBool(subnode, "bool_key", 1);
if (0 != status) {
log_error("test_regNode(): Couldn't put subnode boolean");
}
else {
CU_ASSERT_EQUAL(status, 0);
}
status = reg_getNodeBool(subnode, "bool_key", &boolean);
if (status) {
log_error("test_regNode(): Couldn't get subnode boolean");
}
else {
CU_ASSERT_EQUAL(status, 0);
CU_ASSERT_EQUAL(boolean, 1);
}
status = reg_getNodeUint(subnode, "uint_key", &uint);
if (status && ENOENT != status) {
log_error("test_regNode(): Couldn't verify non-existant subnode int");
}
else {
CU_ASSERT_EQUAL(status, ENOENT);
}
status = reg_putNodeUint(subnode, "uint_key", 5);
if (0 != status) {
log_error("test_regNode(): Couldn't put subnode int");
}
else {
CU_ASSERT_EQUAL(status, 0);
}
status = reg_getNodeUint(subnode, "uint_key", &uint);
if (status) {
log_error("test_regNode(): Couldn't get subnode int");
}
else {
CU_ASSERT_EQUAL(status, 0);
CU_ASSERT_EQUAL(uint, 5);
}
status = reg_getNodeTime(subnode, "time_key", &time);
if (status && ENOENT != status) {
log_error("test_regNode(): Couldn't verify non-existant subnode time");
}
else {
CU_ASSERT_EQUAL(status, ENOENT);
}
status = reg_putNodeTime(subnode, "time_key", &TS_ZERO);
if (0 != status) {
log_error("test_regNode(): Couldn't put subnode time");
}
else {
CU_ASSERT_EQUAL(status, 0);
}
status = reg_getNodeTime(subnode, "time_key", &time);
if (status) {
log_error("test_regNode(): Couldn't get subnode time");
}
else {
CU_ASSERT_EQUAL(status, 0);
CU_ASSERT_EQUAL(d_diff_timestamp(&time, &TS_ZERO), 0.0);
}
status = reg_getNodeSignature(subnode, "sig_key", &sig);
if (status && ENOENT != status) {
log_error("test_regNode(): Couldn't verify non-existant subnode sig");
}
else {
CU_ASSERT_EQUAL(status, ENOENT);
}
status = reg_putNodeSignature(subnode, "sig_key", defSig2);
if (0 != status) {
log_error("test_regNode(): Couldn't put subnode sig");
}
else {
CU_ASSERT_EQUAL(status, 0);
}
status = reg_getNodeSignature(subnode, "sig_key", &sig);
if (status) {
log_error("test_regNode(): Couldn't get subnode sig");
}
else {
CU_ASSERT_EQUAL(status, 0);
CU_ASSERT_EQUAL(memcmp(sig, defSig2, sizeof(signaturet)), 0);
}
status = reg_deleteNodeValue(subnode, "non-existant_key");
if (status && ENOENT != status) {
log_error("test_regNode(): Couldn't verify non-existant subnode value deletion");
}
else {
CU_ASSERT_EQUAL(status, ENOENT);
}
status = reg_deleteNodeValue(subnode, "string_key");
if (status) {
log_error("test_regNode(): Couldn't delete subnode value");
}
else {
CU_ASSERT_EQUAL(status, 0);
}
status = reg_getNodeString(subnode, "string_key", &string);
if (status && ENOENT != status) {
log_error("test_regNode(): Couldn't verify non-existant subnode string");
}
else {
CU_ASSERT_EQUAL(status, ENOENT);
}
status = reg_getNode("/test_node", &testnode, 1);
if (status) {
log_error("test_regNode(): Couldn't get subnode");
}
else {
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_PTR_NOT_NULL(testnode);
}
status = reg_flushNode(testnode);
if (status) {
log_error("test_regNode(): Couldn't flush node");
}
else {
CU_ASSERT_EQUAL(status, 0);
}
rn_free(testnode);
{
status = reg_getNode("/test_node2", &testnode, 1);
if (status) {
log_error("test_regNode(): Couldn't get temporary node");
}
else {
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_PTR_NOT_NULL(testnode);
}
status = reg_putNodeString(testnode, "string_key", "string value");
if (0 != status) {
log_error("test_regNode(): Couldn't add temporary node string");
}
else {
CU_ASSERT_EQUAL(status, 0);
}
status = reg_flushNode(testnode);
if (status) {
log_error("test_regNode(): Couldn't flush temporary node");
}
else {
CU_ASSERT_EQUAL(status, 0);
}
reg_deleteNode(testnode);
status = reg_flushNode(testnode);
if (status) {
log_error("test_regNode(): Couldn't delete temporary node");
}
else {
CU_ASSERT_EQUAL(status, 0);
}
rn_free(testnode);
status = reg_getNode("/test_node2", &testnode, 0);
if (status && ENOENT != status) {
log_error("test_regNode(): Couldn't verify temporary node deletion");
}
else {
CU_ASSERT_EQUAL(status, ENOENT);
}
}
}
