/* Clear out vegas status buf */
void vegas_status_clear(struct vegas_status *s) {
int semval;
int retval;
retval = sem_getvalue(s->lock,&semval);
if (retval) {
vegas_error("vegas_status_clear", "sem_getvalue failed");
}
if (semval == 0) {
printf("Found vegas status semaphore locked in vegas_status_clear. releasing\n");
vegas_status_unlock(s);
}
/* Lock */
vegas_status_lock(s);
/* Zero bufer */
memset(s->buf, 0, VEGAS_STATUS_SIZE);
/* Fill first card w/ spaces */
memset(s->buf, ' ', VEGAS_STATUS_CARD);
/* add END */
strncpy(s->buf, "END", 3);
/* Unlock */
vegas_status_unlock(s);
}
int main(int argc, char *argv[]) {
int rv;
struct vegas_status s;
rv = vegas_status_attach(&s);
if (rv!=VEGAS_OK) {
fprintf(stderr, "Error connecting to shared mem.\n");
perror(NULL);
exit(1);
}
vegas_status_lock(&s);
/* Loop over cmd line to fill in params */
static struct option long_opts[] = {
{"key", 1, NULL, 'k'},
{"get", 1, NULL, 'g'},
{"string", 1, NULL, 's'},
{"float", 1, NULL, 'f'},
{"double", 1, NULL, 'd'},
{"int", 1, NULL, 'i'},
{"quiet", 0, NULL, 'q'},
{"clear", 0, NULL, 'C'},
{"del", 0, NULL, 'D'},
{0,0,0,0}
};
int opt,opti;
char *key=NULL;
float flttmp;
double dbltmp;
int inttmp;
int quiet=0, clear=0;
while ((opt=getopt_long(argc,argv,"k:g:s:f:d:i:qCD",long_opts,&opti))!=-1) {
switch (opt) {
case 'k':
key = optarg;
break;
case 'g':
hgetr8(s.buf, optarg, &dbltmp);
printf("%g\n", dbltmp);
break;
case 's':
if (key)
hputs(s.buf, key, optarg);
break;
case 'f':
flttmp = atof(optarg);
if (key)
hputr4(s.buf, key, flttmp);
break;
case 'd':
dbltmp = atof(optarg);
if (key)
hputr8(s.buf, key, dbltmp);
break;
case 'i':
inttmp = atoi(optarg);
if (key)
hputi4(s.buf, key, inttmp);
break;
case 'D':
if (key)
hdel(s.buf, key);
break;
case 'C':
clear=1;
break;
case 'q':
quiet=1;
break;
default:
break;
}
}
/* If not quiet, print out buffer */
if (!quiet) {
printf(s.buf); printf("\n");
}
vegas_status_unlock(&s);
if (clear)
vegas_status_clear(&s);
exit(0);
}
int main(int argc, char *argv[]) {
static struct option long_opts[] = {
{"help", 0, NULL, 'h'},
{0,0,0,0}
};
int opt, opti;
while ((opt=getopt_long(argc,argv,"h",long_opts,&opti))!=-1) {
switch (opt) {
default:
case 'h':
usage();
exit(0);
break;
}
}
/* Create FIFO */
int rv = mkfifo(vegas_DAQ_CONTROL, 0666);
if (rv!=0 && errno!=EEXIST) {
fprintf(stderr, "vegas_daq_server: Error creating control fifo\n");
perror("mkfifo");
exit(1);
}
/* Open command FIFO for read */
#define MAX_CMD_LEN 1024
char cmd[MAX_CMD_LEN];
int command_fifo;
command_fifo = open(vegas_DAQ_CONTROL, O_RDONLY | O_NONBLOCK);
if (command_fifo<0) {
fprintf(stderr, "vegas_daq_server: Error opening control fifo\n");
perror("open");
exit(1);
}
/* Attach to shared memory buffers */
struct vegas_status stat;
struct vegas_databuf *dbuf_net=NULL, *dbuf_pfb=NULL, *dbuf_acc=NULL;
rv = vegas_status_attach(&stat);
const int netbuf_id = 1;
const int pfbbuf_id = 2;
const int accbuf_id = 3;
if (rv!=VEGAS_OK) {
fprintf(stderr, "Error connecting to vegas_status\n");
exit(1);
}
dbuf_net = vegas_databuf_attach(netbuf_id);
if (dbuf_net==NULL) {
fprintf(stderr, "Error connecting to vegas_databuf (raw net)\n");
exit(1);
}
vegas_databuf_clear(dbuf_net);
dbuf_pfb = vegas_databuf_attach(pfbbuf_id);
if (dbuf_pfb==NULL) {
fprintf(stderr, "Error connecting to vegas_databuf (accum input)\n");
exit(1);
}
vegas_databuf_clear(dbuf_pfb);
dbuf_acc = vegas_databuf_attach(accbuf_id);
if (dbuf_acc==NULL) {
fprintf(stderr, "Error connecting to vegas_databuf (accum output)\n");
exit(1);
}
vegas_databuf_clear(dbuf_acc);
/* Thread setup */
#define MAX_THREAD 8
int i;
int nthread_cur = 0;
struct vegas_thread_args args[MAX_THREAD];
pthread_t thread_id[MAX_THREAD];
for (i=0; i<MAX_THREAD; i++) thread_id[i] = 0;
/* Print start time for logs */
time_t curtime = time(NULL);
char tmp[256];
printf("\nvegas_daq_server started at %s", ctime_r(&curtime,tmp));
fflush(stdout);
/* hmm.. keep this old signal stuff?? */
run=1;
srv_run=1;
signal(SIGINT, srv_cc);
signal(SIGTERM, srv_quit);
/* Loop over recv'd commands, process them */
int cmd_wait=1;
while (cmd_wait && srv_run) {
// Check to see if threads have exited, if so, stop them
if (check_thread_exit(args, nthread_cur)) {
run = 0;
stop_threads(args, thread_id, nthread_cur);
nthread_cur = 0;
}
// Heartbeat, status update
time_t curtime;
char timestr[32];
char *ctmp;
time(&curtime);
ctime_r(&curtime, timestr);
ctmp = strchr(timestr, '\n');
if (ctmp!=NULL) {
*ctmp = '\0';
}
else {
timestr[0]='\0';
}
vegas_status_lock(&stat);
hputs(stat.buf, "DAQPULSE", timestr);
hputs(stat.buf, "DAQSTATE", nthread_cur==0 ? "stopped" : "running");
vegas_status_unlock(&stat);
// Flush any status/error/etc for logfiles
fflush(stdout);
fflush(stderr);
// Wait for data on fifo
struct pollfd pfd;
pfd.fd = command_fifo;
pfd.events = POLLIN;
rv = poll(&pfd, 1, 1000);
if (rv==0) {
continue;
}
else if (rv<0) {
if (errno!=EINTR) perror("poll");
continue;
}
// If we got POLLHUP, it means the other side closed its
// connection. Close and reopen the FIFO to clear this
// condition. Is there a better/recommended way to do this?
if (pfd.revents==POLLHUP) {
close(command_fifo);
command_fifo = open(vegas_DAQ_CONTROL, O_RDONLY | O_NONBLOCK);
if (command_fifo<0) {
fprintf(stderr,
"vegas_daq_server: Error opening control fifo\n");
perror("open");
break;
}
continue;
}
// Read the command
memset(cmd, 0, MAX_CMD_LEN);
rv = read(command_fifo, cmd, MAX_CMD_LEN-1);
if (rv==0) {
continue;
}
else if (rv<0) {
if (errno==EAGAIN) {
continue;
}
else {
perror("read");
continue;
}
}
// Truncate at newline
// TODO: allow multiple commands in one read?
char *ptr = strchr(cmd, '\n');
if (ptr!=NULL) *ptr='\0';
// Process the command
if (strncasecmp(cmd,"QUIT",MAX_CMD_LEN)==0) {
// Exit program
printf("Exit\n");
run = 0;
stop_threads(args, thread_id, nthread_cur);
cmd_wait=0;
continue;
}
else if (strncasecmp(cmd,"START",MAX_CMD_LEN)==0 ||
strncasecmp(cmd,"MONITOR",MAX_CMD_LEN)==0) {
// Start observations
// TODO : decide how to behave if observations are running
printf("Start observations\n");
if (nthread_cur>0) {
printf(" observations already running!\n");
} else {
// Figure out which mode to start
char obs_mode[32];
if (strncasecmp(cmd,"START",MAX_CMD_LEN)==0) {
vegas_status_lock(&stat);
vegas_read_obs_mode(stat.buf, obs_mode);
vegas_status_unlock(&stat);
} else {
strncpy(obs_mode, cmd, 32);
}
printf(" obs_mode = %s\n", obs_mode);
// Clear out data bufs
vegas_databuf_clear(dbuf_net);
vegas_databuf_clear(dbuf_pfb);
vegas_databuf_clear(dbuf_acc);
// Do it
run = 1;
if (strncasecmp(obs_mode, "HBW", 4)==0) {
hputs(stat.buf, "BW_MODE", "high");
hputs(stat.buf, "SWVER", "1.4");
init_hbw_mode(args, &nthread_cur);
start_hbw_mode(args, thread_id);
} else if (strncasecmp(obs_mode, "LBW", 4)==0) {
hputs(stat.buf, "BW_MODE", "low");
hputs(stat.buf, "SWVER", "1.4");
init_lbw_mode(args, &nthread_cur);
start_lbw_mode(args, thread_id);
} else if (strncasecmp(obs_mode, "MONITOR", 8)==0) {
init_monitor_mode(args, &nthread_cur);
start_monitor_mode(args, thread_id);
} else {
printf(" unrecognized obs_mode!\n");
}
}
}
else if (strncasecmp(cmd,"STOP",MAX_CMD_LEN)==0) {
// Stop observations
printf("Stop observations\n");
run = 0;
stop_threads(args, thread_id, nthread_cur);
nthread_cur = 0;
}
else {
// Unknown command
printf("Unrecognized command '%s'\n", cmd);
}
}
/* Stop any running threads */
run = 0;
stop_threads(args, thread_id, nthread_cur);
if (command_fifo>0) close(command_fifo);
vegas_status_lock(&stat);
hputs(stat.buf, "DAQSTATE", "exiting");
vegas_status_unlock(&stat);
curtime = time(NULL);
printf("vegas_daq_server exiting cleanly at %s\n", ctime_r(&curtime,tmp));
fflush(stdout);
fflush(stderr);
/* TODO: remove FIFO */
exit(0);
}
