int
photoproc(struct tstat *tasks, int *taskslen)
{
static int setup;
static pmID pmids[TASK_NMETRICS];
static pmDesc descs[TASK_NMETRICS];
pmResult *result;
char **insts;
int *pids, count, i;
if (!setup)
{
setup_metrics(procmetrics, pmids, descs, TASK_NMETRICS);
setup = 1;
}
fetch_metrics("task", TASK_NMETRICS, pmids, &result);
/* extract external process names (insts) */
count = get_instances("task", TASK_GEN_NAME, descs, &pids, &insts);
if (count > *taskslen)
{
size_t size;
int ents = (*taskslen + PROCCHUNK);
if (count > ents)
ents = count;
size = ents * sizeof(struct tstat);
tasks = (struct tstat *)realloc(tasks, size);
ptrverify(tasks, "photoproc [%ld]\n", (long)size);
*taskslen = ents;
}
for (i=0; i < count; i++)
{
if (pmDebug & DBG_TRACE_APPL0)
fprintf(stderr, "%s: updating process %d: %s\n",
pmProgname, pids[i], insts[i]);
update_task(&tasks[i], pids[i], insts[i], result, descs);
}
if (pmDebug & DBG_TRACE_APPL0)
fprintf(stderr, "%s: done %d processes\n", pmProgname, count);
pmFreeResult(result);
free(insts);
free(pids);
return count;
}
bool
AirspaceWarningManager::update(const AIRCRAFT_STATE& state,
const bool circling)
{
bool changed = false;
// save old state
for (AirspaceWarningList::iterator it = m_warnings.begin();
it != m_warnings.end(); ++it)
it->save_state();
// check from strongest to weakest alerts
update_inside(state);
update_glide(state);
if (circling)
update_filter(state);
update_task(state);
// action changes
for (AirspaceWarningList::iterator it = m_warnings.begin();
it != m_warnings.end(); ) {
if (it->warning_live(config.AcknowledgementTime)) {
if (it->changed_state())
changed = true;
it++;
} else {
if (!it->trivial()) {
//changed = true; // was downgraded to eliminate
}
it = m_warnings.erase(it);
}
}
// sort by importance, most severe top
m_warnings.sort();
return changed;
}
void load_config(char *conffn)
{
static void *configfiles = NULL;
tasklist_t *twalk, *curtask = NULL;
FILE *fd;
strbuffer_t *inbuf;
char *p;
char myhostname[256];
/* First check if there were no modifications at all */
if (configfiles) {
if (!stackfmodified(configfiles)){
dbgprintf("No files modified, skipping reload of %s\n", conffn);
return;
}
else {
stackfclist(&configfiles);
configfiles = NULL;
}
}
errprintf("Loading tasklist configuration from %s\n", conffn);
if (gethostname(myhostname, sizeof(myhostname)) != 0) {
errprintf("Cannot get the local hostname, using 'localhost' (error: %s)\n", strerror(errno));
strcpy(myhostname, "localhost");
}
/* The cfload flag: -1=delete task, 0=old task unchanged, 1=new/changed task */
for (twalk = taskhead; (twalk); twalk = twalk->next) {
twalk->cfload = -1;
twalk->group = NULL;
}
fd = stackfopen(conffn, "r", &configfiles);
if (fd == NULL) {
errprintf("Cannot open configuration file %s: %s\n", conffn, strerror(errno));
return;
}
inbuf = newstrbuffer(0);
while (stackfgets(inbuf, NULL)) {
sanitize_input(inbuf, 1, 0); if (STRBUFLEN(inbuf) == 0) continue;
p = STRBUF(inbuf);
if (*p == '[') {
/* New task */
char *endp;
if (curtask) {
update_task(curtask);
curtask = NULL;
}
p++; endp = strchr(p, ']');
if (endp == NULL) continue;
*endp = '\0';
curtask = (tasklist_t *)calloc(1, sizeof(tasklist_t));
curtask->key = strdup(p);
}
else if (curtask && (strncasecmp(p, "CMD ", 4) == 0)) {
p += 3;
p += strspn(p, " \t");
curtask->cmd = strdup(p);
}
else if (strncasecmp(p, "GROUP ", 6) == 0) {
/* Note: GROUP can be used by itself to define a group, or inside a task definition */
char *groupname;
int maxuse;
grouplist_t *gwalk;
p += 6;
p += strspn(p, " \t");
groupname = p;
p += strcspn(p, " \t");
if (isdigit((int) *p)) maxuse = atoi(p); else maxuse = 1;
/* Find or create the grouplist entry */
for (gwalk = grouphead; (gwalk && (strcmp(gwalk->groupname, groupname))); gwalk = gwalk->next);
if (gwalk == NULL) {
gwalk = (grouplist_t *)malloc(sizeof(grouplist_t));
gwalk->groupname = strdup(groupname);
gwalk->maxuse = maxuse;
gwalk->currentuse = 0;
gwalk->next = grouphead;
grouphead = gwalk;
}
if (curtask) curtask->group = gwalk;
}
else if (curtask && (strncasecmp(p, "INTERVAL ", 9) == 0)) {
char *tspec;
p += 9;
curtask->interval = atoi(p);
tspec = p + strspn(p, "0123456789");
switch (*tspec) {
case 'm': curtask->interval *= 60; break; /* Minutes */
case 'h': curtask->interval *= 3600; break; /* Hours */
case 'd': curtask->interval *= 86400; break; /* Days */
}
}
else if (curtask && (strncasecmp(p, "CRONDATE ", 9) == 0)) {
p+= 9;
curtask->cronstr = strdup(p);
curtask->crondate = parse_cron_time(curtask->cronstr);
if (!curtask->crondate) {
errprintf("Can't parse cron date: %s->%s", curtask->key, curtask->cronstr);
curtask->disabled = 1;
}
curtask->interval = -1; /* disable interval */
}
else if (curtask && (strncasecmp(p, "MAXTIME ", 8) == 0)) {
char *tspec;
p += 8;
curtask->maxruntime = atoi(p);
tspec = p + strspn(p, "0123456789");
switch (*tspec) {
case 'm': curtask->maxruntime *= 60; break; /* Minutes */
case 'h': curtask->maxruntime *= 3600; break; /* Hours */
case 'd': curtask->maxruntime *= 86400; break; /* Days */
}
}
else if (curtask && (strncasecmp(p, "LOGFILE ", 8) == 0)) {
p += 7;
p += strspn(p, " \t");
curtask->logfile = strdup(p);
}
else if (curtask && (strncasecmp(p, "NEEDS ", 6) == 0)) {
p += 6;
p += strspn(p, " \t");
for (twalk = taskhead; (twalk && strcmp(twalk->key, p)); twalk = twalk->next);
if (twalk) {
curtask->depends = twalk;
}
else {
errprintf("Configuration error, unknown dependency %s->%s", curtask->key, p);
}
}
else if (curtask && (strncasecmp(p, "ENVFILE ", 8) == 0)) {
p += 7;
p += strspn(p, " \t");
curtask->envfile = strdup(p);
}
else if (curtask && (strncasecmp(p, "ENVAREA ", 8) == 0)) {
p += 7;
p += strspn(p, " \t");
curtask->envarea = strdup(p);
}
else if (curtask && (strcasecmp(p, "DISABLED") == 0)) {
curtask->disabled = 1;
}
else if (curtask && (strncasecmp(p, "ONHOST ", 7) == 0)) {
regex_t cpattern;
int status;
p += 7;
p += strspn(p, " \t");
curtask->onhostptn = strdup(p);
/* Match the hostname against the pattern; if it doesnt match then disable the task */
status = regcomp(&cpattern, curtask->onhostptn, REG_EXTENDED|REG_ICASE|REG_NOSUB);
if (status == 0) {
status = regexec(&cpattern, myhostname, 0, NULL, 0);
if (status == REG_NOMATCH) curtask->disabled = 1;
}
else {
errprintf("ONHOST pattern '%s' is invalid\n", p);
}
}
}
if (curtask) update_task(curtask);
stackfclose(fd);
freestrbuffer(inbuf);
/* Running tasks that have been deleted or changed are killed off now. */
for (twalk = taskhead; (twalk); twalk = twalk->next) {
switch (twalk->cfload) {
case -1:
/* Kill the task, if active */
if (twalk->pid) {
dbgprintf("Killing task %s PID %d\n", twalk->key, (int)twalk->pid);
twalk->beingkilled = 1;
kill(twalk->pid, SIGTERM);
}
/* And prepare to free this tasklist entry */
xfree(twalk->key);
xfree(twalk->cmd);
if (twalk->logfile) xfree(twalk->logfile);
if (twalk->envfile) xfree(twalk->envfile);
if (twalk->envarea) xfree(twalk->envarea);
if (twalk->onhostptn) xfree(twalk->onhostptn);
if (twalk->cronstr) xfree(twalk->cronstr);
if (twalk->crondate) crondatefree(twalk->crondate);
break;
case 0:
/* Do nothing */
break;
case 1:
/* Bounce the task, if it is active */
if (twalk->pid) {
dbgprintf("Killing task %s PID %d\n", twalk->key, (int)twalk->pid);
twalk->beingkilled = 1;
kill(twalk->pid, SIGTERM);
}
break;
}
}
/* First clean out dead tasks at the start of the list */
while (taskhead && (taskhead->cfload == -1)) {
tasklist_t *tmp;
tmp = taskhead;
taskhead = taskhead->next;
xfree(tmp);
}
/* Then unlink and free those inside the list */
twalk = taskhead;
while (twalk && twalk->next) {
tasklist_t *tmp;
if (twalk->next->cfload == -1) {
tmp = twalk->next;
twalk->next = tmp->next;
xfree(tmp);
}
else twalk = twalk->next;
}
if (taskhead == NULL)
tasktail = NULL;
else {
tasktail = taskhead;
while (tasktail->next) tasktail = tasktail->next;
}
/* Make sure group usage counts are correct (groups can change) */
for (twalk = taskhead; (twalk); twalk = twalk->next) {
if (twalk->group) twalk->group->currentuse = 0;
}
for (twalk = taskhead; (twalk); twalk = twalk->next) {
if (twalk->group && twalk->pid) twalk->group->currentuse++;
}
}
void Engine::run_one_frame() {
TaskId update = task_manager.add(update_task(), INVALID_ID, pthread_self());
TaskId render = task_manager.add(render_task(), update, pthread_self());
task_manager.wait(update);
}
