int perform_sensor_update_katcp(struct katcp_dispatch *d, void *data) { struct katcp_shared *s; unsigned int i, j, count; struct katcp_flat *fx; struct katcp_group *gx; struct katcl_parse *px; s = d->d_shared; if(s == NULL){ return -1; } if(s->s_changes <= 0){ log_message_katcp(d, KATCP_LEVEL_WARN, NULL, "logic problem: scheduled device update, but nothing requires updating"); return -1; } px = create_referenced_parse_katcl(); if(px == NULL){ return -1; } add_string_parse_katcl(px, KATCP_FLAG_FIRST | KATCP_FLAG_STRING, KATCP_DEVICE_CHANGED_INFORM); add_string_parse_katcl(px, KATCP_FLAG_LAST | KATCP_FLAG_STRING, "sensor-list"); count = 0; for(j = 0; j < s->s_members; j++){ gx = s->s_groups[j]; for(i = 0; i < gx->g_count; i++){ fx = is_ready_flat_katcp(d, gx->g_flats[i]); if(fx){ if((fx->f_stale & KATCP_STALE_MASK_SENSOR) == KATCP_STALE_SENSOR_STALE){ fx->f_stale = KATCP_STALE_SENSOR_NAIVE; if((fx->f_flags & KATCP_FLAT_TOCLIENT) && (fx->f_flags & KATCP_FLAT_SEESKATCP)){ /* TODO: shouldn't we use the fancy queue infrastructure ? */ append_parse_katcl(fx->f_line, px); count++; } } } } } log_message_katcp(d, KATCP_LEVEL_DEBUG, NULL, "notified %u clients of %u sensor %s", count, s->s_changes, (s->s_changes == 1) ? "change" : "changes"); destroy_parse_katcl(px); s->s_changes = 0; return 0; }
struct katcl_parse *make_sensor_katcp(struct katcp_dispatch *d, char *name, struct katcp_vrbl *vx, char *prefix) { struct katcl_parse *px; #ifdef DEBUG fprintf(stderr, "sensor: triggering sensor change logic on sensor %s\n", name); #endif px = create_referenced_parse_katcl(); if(px == NULL){ return NULL; } if(add_string_parse_katcl(px, KATCP_FLAG_FIRST | KATCP_FLAG_STRING, prefix) < 0){ destroy_parse_katcl(px); return NULL; } if(add_partial_sensor_katcp(d, px, name, KATCP_FLAG_LAST, vx) < 0){ destroy_parse_katcl(px); return NULL; } return px; }
int append_string_katcl(struct katcl_line *l, int flags, char *buffer) { struct katcl_parse *p; int result; p = before_append_katcl(l, flags); if(p == NULL){ return -1; } result = add_string_parse_katcl(p, flags, buffer); return after_append_katcl(l, flags, result); }
int add_partial_sensor_katcp(struct katcp_dispatch *d, struct katcl_parse *px, char *name, int flags, struct katcp_vrbl *vx) { int results[5]; struct katcp_vrbl_payload *py; unsigned int r; int i, sum; char *ptr; if((px == NULL) || (vx == NULL)){ return -1; } if(name){ ptr = name; } else if(vx->v_name){ ptr = vx->v_name; } else { ptr = "unnamed"; } r = 0; py = find_payload_katcp(d, vx, KATCP_VRC_SENSOR_TIME); if(py){ results[r++] = add_payload_vrbl_katcp(d, px, 0, vx, py); } else { results[r++] = add_timestamp_parse_katcl(px, flags & KATCP_FLAG_FIRST, NULL); } results[r++] = add_string_parse_katcl(px, KATCP_FLAG_STRING, "1"); results[r++] = add_string_parse_katcl(px, KATCP_FLAG_STRING, ptr); py = find_payload_katcp(d, vx, KATCP_VRC_SENSOR_STATUS); if(py){ results[r++] = add_payload_vrbl_katcp(d, px, 0, vx, py); } else { results[r++] = add_string_parse_katcl(px, KATCP_FLAG_STRING, "unknown"); } py = find_payload_katcp(d, vx, KATCP_VRC_SENSOR_VALUE); if(py){ results[r++] = add_payload_vrbl_katcp(d, px, flags & KATCP_FLAG_LAST, vx, py); } else { results[r++] = add_string_parse_katcl(px, KATCP_FLAG_STRING | (flags & KATCP_FLAG_LAST), "unset"); } sum = 0; for(i = 0; i < r; i++){ if(results[i] < 0){ sum = (-1); i = r; } else { sum += results[i]; } } if(sum <= 0){ return (-1); } return sum; }
int main(int argc, char **argv) { struct set *ss; struct remote *rx; struct katcl_parse *px; struct katcl_line *k; struct timeval delta, start, stop; fd_set fsr, fsw; char *app, *parm, *cmd, *copy, *ptr, *servers, *extra, *label; int i, j, c, fd, mfd, count; int verbose, result, status, info, timeout, flags, show, munge, once; int xmit, code; unsigned int len; servers = getenv("KATCP_SERVER"); if(servers == NULL){ servers = "localhost:7147"; } once = 1; munge = 0; info = 1; verbose = 1; i = j = 1; app = argv[0]; timeout = 0; k = NULL; show = 1; parm = NULL; extra = NULL; label = KCPPAR_NAME; count = 0; px = NULL; k = create_katcl(STDOUT_FILENO); if(k == NULL){ fprintf(stderr, "%s: unable to create katcp message logic\n", app); return 4; } ss = create_set(); if(ss == NULL){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to set up command set data structures"); return 4; } xmit = (-1); while (i < argc) { if (argv[i][0] == '-') { c = argv[i][j]; switch (c) { case 'h' : usage(app); return 0; case 'i' : info = 1 - info; j++; break; case 'm' : munge = 1; j++; break; case 'n' : show = 0; j++; break; case 'q' : verbose = 0; j++; break; case 'x' : xmit = 0; j++; break; case 'l' : case 's' : case 't' : j++; if (argv[i][j] == '\0') { j = 0; i++; } if (i >= argc) { sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "argument needs a parameter"); return 2; } switch(c){ case 'l' : label = argv[i] + j; break; case 's' : servers = argv[i] + j; break; case 't' : timeout = atoi(argv[i] + j); break; } i++; j = 1; break; case 'v' : verbose++; j++; break; case '-' : j++; break; case '\0': j = 1; i++; break; default: sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unknown option -%c", argv[i][j]); return 2; } } else { copy = NULL; if(xmit < 0){ /* WARNING: this could make error detection worse */ xmit = 0; } if(xmit == 0){ px = create_referenced_parse_katcl(); if(px == NULL){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to create parse instance for <%s ...>", argv[i]); return 4; } switch(argv[i][0]){ case KATCP_REQUEST : case KATCP_REPLY : case KATCP_INFORM : ptr = argv[i]; break; default : copy = malloc(strlen(argv[i]) + 1); if(copy == NULL){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to allocate temporary storage for %s", argv[i]); return 4; } copy[0] = KATCP_REQUEST; strcpy(copy + 1, argv[i]); ptr = copy; break; } flags = KATCP_FLAG_FIRST; } else { ptr = argv[i]; flags = 0; } i++; j = 1; if((i >= argc) || (argv[i][0] == '-')){ flags |= KATCP_FLAG_LAST; } if(add_string_parse_katcl(px, flags, ptr) < 0){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to add parameter %s", ptr); return 4; } if(flags & KATCP_FLAG_LAST){ #ifdef DEBUG fprintf(stderr, "par: loading command for servers %s\n", servers); #endif if(load_parse_set(ss, servers, px) < 0){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to load command into server set %s", servers); return 4; } destroy_parse_katcl(px); px = NULL; } if(copy){ free(copy); copy = NULL; } xmit++; } } if(timeout == 0){ timeout = 5000 * ss->s_count; } gettimeofday(&start, NULL); delta.tv_sec = timeout / 1000; delta.tv_usec = (timeout % 1000) * 1000; add_time_katcp(&stop, &start, &delta); if(activate_remotes(ss, k) < 0){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to initiate connections to remote servers"); return 3; } for(ss->s_finished = 0; ss->s_finished < ss->s_count;){ mfd = 0; FD_ZERO(&fsr); FD_ZERO(&fsw); if(k){ if(flushing_katcl(k)){ mfd = fileno_katcl(k); FD_SET(mfd, &fsw); } } for(i = 0; i < ss->s_count; i++){ rx = ss->s_vector[i]; if(rx->r_line){ fd = fileno_katcl(rx->r_line); if(fd > mfd){ mfd = fd; } } else { fd = (-1); /* WARNING: live dangerously */ } switch(rx->r_state){ case RX_SETUP : FD_SET(fd, &fsw); break; case RX_UP : if(flushing_katcl(rx->r_line)){ /* only write data if we have some */ FD_SET(fd, &fsw); } FD_SET(fd, &fsr); break; /* case RX_OK : */ /* case RX_FAIL : */ /* case RX_BAD : */ default : break; } } gettimeofday(&start, NULL); sub_time_katcp(&delta, &stop, &start); result = select(mfd + 1, &fsr, &fsw, NULL, &delta); switch(result){ case -1 : switch(errno){ case EAGAIN : case EINTR : continue; /* WARNING */ default : sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "select failed: %s", strerror(errno)); return 4; } break; case 0 : sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "requests timed out after %dms", timeout); /* could terminate cleanly here, but ... */ return 3; } if(k){ fd = fileno_katcl(k); if(FD_ISSET(fd, &fsw)){ write_katcl(k); /* WARNING: ignores write failures - unable to do much about it */ } } for(i = 0; i < ss->s_count; i++){ rx = ss->s_vector[i]; if(rx->r_line){ fd = fileno_katcl(rx->r_line); } else { fd = (-1); /* WARNING: live dangerously, will cause select to core dump if logic is incorrect */ } switch(rx->r_state){ case RX_SETUP : if(FD_ISSET(fd, &fsw)){ len = sizeof(int); result = getsockopt(fd, SOL_SOCKET, SO_ERROR, &code, &len); if(result == 0){ switch(code){ case 0 : if(verbose){ log_message_katcl(k, KATCP_LEVEL_DEBUG, label, "async connect to %s succeeded", rx->r_name); } if(next_request(rx) < 0){ log_message_katcl(k, KATCP_LEVEL_ERROR, label, "failed to load request for destination %s", rx->r_name); update_state(ss, rx, RX_BAD); } else { update_state(ss, rx, RX_UP); } break; case EINPROGRESS : log_message_katcl(k, KATCP_LEVEL_WARN, label, "saw an in progress despite write set being ready on job %s", rx->r_name); break; default : log_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to connect to %s: %s", rx->r_name, strerror(code)); update_state(ss, rx, RX_BAD); break; } } } break; case RX_UP : if(FD_ISSET(fd, &fsw)){ /* flushing things */ result = write_katcl(rx->r_line); if(result < 0){ log_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to write to %s: %s", rx->r_name, strerror(error_katcl(rx->r_line))); update_state(ss, rx, RX_BAD); } } if(FD_ISSET(fd, &fsr)){ /* get things */ result = read_katcl(rx->r_line); if(result){ if(result < 0){ log_message_katcl(k, KATCP_LEVEL_ERROR, label, "read from %s failed: %s", rx->r_name, strerror(error_katcl(rx->r_line))); } else { log_message_katcl(k, KATCP_LEVEL_WARN, label, "%s disconnected", rx->r_name); } } } while(have_katcl(rx->r_line) > 0){ /* compute */ cmd = arg_string_katcl(rx->r_line, 0); if(cmd){ #ifdef DEBUG fprintf(stderr, "reading message <%s ...>\n", cmd); #endif switch(cmd[0]){ case KATCP_INFORM : if(info){ if(show == 0){ if(!strcmp(KATCP_VERSION_CONNECT_INFORM, cmd)){ break; } if(!strcmp(KATCP_VERSION_INFORM, cmd)){ break; } if(!strcmp(KATCP_BUILD_STATE_INFORM, cmd)){ break; } } relay_katcl(rx->r_line, k); } break; case KATCP_REPLY : switch(cmd[1]){ case ' ' : case '\n' : case '\r' : case '\t' : case '\\' : case '\0' : log_message_katcl(k, KATCP_LEVEL_ERROR, label, "unreasonable response message from %s", rx->r_name); update_state(ss, rx, RX_BAD); break; default : ptr = cmd + 1; if(strcmp(ptr, rx->r_match)){ log_message_katcl(k, KATCP_LEVEL_ERROR, label, "downstream %s returned response %s which was never requested", rx->r_name, ptr); update_state(ss, rx, RX_BAD); } else { parm = arg_string_katcl(rx->r_line, 1); if(parm){ if(strcmp(parm, KATCP_OK) == 0){ count++; if(munge){ log_message_katcl(k, KATCP_LEVEL_INFO, label, "%s %s ok", rx->r_name, ptr); } if(verbose > 1){ log_message_katcl(k, KATCP_LEVEL_TRACE, label, "request %s to %s returned ok", ptr, rx->r_name); } result = next_request(rx); if(result){ if(result < 0){ sync_message_katcl(k, KATCP_LEVEL_ERROR, label, "unable to queue request %s to %s", ptr, rx->r_name); update_state(ss, rx, RX_BAD); } else { update_state(ss, rx, RX_OK); } } } else { if(munge){ extra = arg_string_katcl(rx->r_line, 2); log_message_katcl(k, KATCP_LEVEL_ERROR, label, "%s %s %s (%s)", rx->r_name, ptr, parm, extra ? extra : "no extra information"); } if(verbose > 0){ log_message_katcl(k, KATCP_LEVEL_ERROR, label, "downstream %s unable to process %s with status %s (%s)", rx->r_name, cmd, parm, extra ? extra : "no extra information"); } update_state(ss, rx, RX_FAIL); } } else { log_message_katcl(k, KATCP_LEVEL_ERROR, label, "response %s without status from %s", cmd, rx->r_name); update_state(ss, rx, RX_FAIL); } } break; } break; case KATCP_REQUEST : log_message_katcl(k, KATCP_LEVEL_WARN, label, "encountered unanswerable request %s", cmd); update_state(ss, rx, RX_BAD); break; default : if(once){ log_message_katcl(k, KATCP_LEVEL_WARN, label, "read malformed message %s from %s", cmd, rx->r_name); once = 1; } break; } } } break; /* case RX_OK : */ /* case RX_FAIL : */ /* case RX_BAD : */ default : break; } } } status = ss->s_status; destroy_set(ss); if(verbose){ if(status > 0){ log_message_katcl(k, KATCP_LEVEL_WARN, label, "command sequence failed after operation %d", count); } else { if(count > 0){ log_message_katcl(k, KATCP_LEVEL_INFO, label, "%d operations ok", count); } else { log_message_katcl(k, KATCP_LEVEL_INFO, label, "did nothing successfully"); } } } /* flush, allows us to get away with deferring writes to stdout */ while(write_katcl(k) == 0); destroy_katcl(k, 0); return status; }
int main(int argc, char **argv) { #define BUFFER 64 char buffer[BUFFER]; char *level, *app, *server, *output; int run, fd, i, j, c, verbose, attempts, detach, result, truncate, flags; struct katcl_parse *p; struct katcl_line *ls, *lo; struct sigaction sa; time_t now; struct tm *local; i = j = 1; app = argv[0]; verbose = 0; attempts = 2; detach = 0; truncate = 0; server = getenv("KATCP_SERVER"); if(server == NULL){ server = "localhost"; } output = NULL; level = NULL; flags = 0; /* placate -Wall */ while (i < argc) { if (argv[i][0] == '-') { c = argv[i][j]; switch (c) { case 'h' : usage(app); return EX_OK; case 'v' : verbose++; j++; break; case 'd' : detach = 1; j++; break; case 'f' : detach = 0; j++; break; case 't' : truncate = 1; j++; break; case 'q' : verbose = 0; j++; break; case 'l' : case 'o' : case 'a' : case 's' : j++; if (argv[i][j] == '\0') { j = 0; i++; } if (i >= argc) { fprintf(stderr, "%s: usage: argument needs a parameter\n", app); return EX_USAGE; } switch(c){ case 'l' : level = argv[i] + j; break; case 'o' : output = argv[i] + j; break; case 'a' : attempts = atoi(argv[i] + j); break; case 's' : server = argv[i] + j; break; } i++; j = 1; break; case '-' : j++; break; case '\0': j = 1; i++; break; default: fprintf(stderr, "%s: usage: unknown option -%c\n", app, argv[i][j]); return EX_USAGE; } } else { if(output){ fprintf(stderr, "%s: usage: unexpected extra argument %s (can only save to one file)\n", app, argv[i]); return EX_USAGE; } output = argv[i]; i++; } } if(detach){ if(fork_parent() < 0){ fprintf(stderr, "%s: unable to detach process\n", app); return EX_OSERR; } } sa.sa_handler = handle_signal; #if 0 sa.sa_flags = SA_RESTART; #endif sa.sa_flags = 0; sigemptyset(&(sa.sa_mask)); sigaction(SIGHUP, &sa, NULL); sigaction(SIGUSR1, &sa, NULL); sigaction(SIGUSR2, &sa, NULL); if(server == NULL){ server = "localhost:7147"; } if(level){ log_changed = 1; log_level = log_to_code_katcl(level); if(log_level < 0){ fprintf(stderr, "%s: usage: invalid initial log priority %s\n", app, level); return EX_USAGE; } } if(output == NULL){ if(detach == 1){ fprintf(stderr, "%s: usage: need a filename as target\n", app); return EX_USAGE; } fd = STDOUT_FILENO; } else { flags = O_CREAT | O_WRONLY; if(truncate == 0){ flags |= O_APPEND; } fd = open(output, flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH); if(fd < 0){ fprintf(stderr, "%s: unable to open file %s: %s\n", app, output, strerror(errno)); return EX_OSERR; } } lo = create_katcl(fd); if(lo == NULL){ fprintf(stderr, "%s: unable to allocate log state\n", app); return EX_OSERR; } /**********************/ while((attempts-- > 0) && ((fd = net_connect(server, 0, 0)) < 0)){ sleep(1); } if(attempts <= 0){ sync_message_katcl(lo, KATCP_LEVEL_FATAL, NAME, "unable to connect to %s", server); return EX_UNAVAILABLE; } ls = create_katcl(fd); if(ls == NULL){ sync_message_katcl(lo, KATCP_LEVEL_FATAL, NAME, "unable to allocate parser state"); return EX_OSERR; } if(detach){ fclose(stderr); } time(&now); local = localtime(&now); strftime(buffer, BUFFER - 1, "%Y-%m-%dT%H:%M:%S", local); sync_message_katcl(lo, KATCP_LEVEL_INFO, NAME, "monitor start for %s at %s", server, buffer); for(run = 1; run > 0;){ if(log_reload > 0){ if(output){ fd = open(output, flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH); if(fd >= 0){ exchange_katcl(lo, fd); } } log_reload = 0; } /* WARNING: will only run after the next message - may have to interrupt syscall to get past this */ if(log_changed > 0){ level = log_to_string_katcl(log_level); if(level){ p = create_parse_katcl(); if(p){ add_string_parse_katcl(p, KATCP_FLAG_STRING | KATCP_FLAG_FIRST, "?log-level"); add_string_parse_katcl(p, KATCP_FLAG_STRING | KATCP_FLAG_LAST, level); append_parse_katcl(lo, p); /* dodgy refcount dealings: p is created with refcount = 0, so can only do write at end, otherwise may end up being deallocated */ append_parse_katcl(ls, p); write_katcl(ls); } } else { sync_message_katcl(lo, KATCP_LEVEL_ERROR, NAME, "invalid log priority number %d", level); } log_changed = 0; } result = read_katcl(ls); if(result < 0){ sync_message_katcl(lo, KATCP_LEVEL_FATAL, NAME, "read from network failed: %s", strerror(errno)); return EX_OSERR; } if(result == 1){ run = 0; } while(have_katcl(ls)){ p = ready_katcl(ls); if(p){ append_parse_katcl(lo, p); } } write_katcl(lo); } return EX_OK; #undef BUFFER }