/* our version of 'et_start' */
int
ettStart()
{
objClass object = localobject;
ET_priv *etp = (ET_priv *) object->privated;
size_t hostlen = ET_FILENAME_LENGTH - 1;
char *ch;
struct timespec btime = {1, 0}; /* 1 sec */
int status, ntransferred = 0;
MYSQL *dbsock;
char tmp[1000], tmpp[1000];
printf("ettStart reached\n");
printf("\n0 etp->exit = %d\n\n",etp->exit);
/************************************/
/* default configuration parameters */
/************************************/
etp->nevents = 4000; /* total number of events */
etp->event_size = 500000; /* size of event in bytes */
etp->serverPort = 11111; /* server port number, unique for every ET system on the same machine */
/* will NOT use that value, will get free port and put it into database */
etp->udpPort = 0;
etp->deleteFile = 1;
etp->ngroups = 1;
etp->noDelay = 0;
etp->maxNumStations = 0;
etp->sendBufSize = 0;
etp->recvBufSize = 0;
etp->et_verbose = ET_DEBUG_NONE;
/***************************************************/
/* extract all necessary information from database */
/* connect to database */
dbsock = dbConnect(mysql_host, expid);
/* get 'from' info */
sprintf(tmp,"SELECT inputs FROM %s WHERE name='%s'",configname,object->name);
printf("MYSQL QUERY >%s<\n",tmp);
if(dbGetStr(dbsock, tmp, tmpp)==ET_ERROR)
{
printf("coda_ett: ERROR in mysql query >%s<\n",tmp);
}
else
{
printf("inputs >%s<\n",tmpp);
}
ch = strchr(tmpp,':'); /* get pointer to the location of ':' */
if(ch==NULL)
{
printf("wrong arguments in 'from' - exit\n");
exit(0);
}
ch[0] = '\0'; /* replace ':' by the end of string */
/* info from database looks like 'ET66:ctof1', so after parsing
'tmpp' contains 'ET66' and '(ch+1)' points to 'ctof1'; we are
not using 'ET66' names here, just 'ctof1' as hostname; 'et_from'
will be set using session name */
strcpy(etp->host_from,(ch+1));
/*sprintf(etp->et_from,"/tmp/et_sys_%s",session);*/
sprintf(etp->et_from,"/et/%s",session);
printf("host_from >%s<, et_from >%s<\n",etp->host_from,etp->et_from);
/* get 'to' info */
sprintf(tmp,"SELECT outputs FROM %s WHERE name='%s'",configname,object->name);
printf("MYSQL QUERY >%s<\n",tmp);
if(dbGetStr(dbsock, tmp, tmpp)==ET_ERROR)
{
printf("cannot get 'outputs' from table>%s< for the name>%s<\n",configname,object->name);
return(ET_ERROR);
}
else
{
printf("outputs >%s<\n",tmpp);
}
ch = strchr(tmpp,':'); /* get pointer to the location of ':' */
if(ch==NULL)
{
printf("wrong arguments in 'to' - exit\n");
exit(0);
}
ch[0] = '\0'; /* replace ':' by the end of string */
strcpy(etp->host_to,(ch+1));
/*sprintf(etp->et_to,"/tmp/et_sys_%s",session);*/
sprintf(etp->et_to,"/et/%s",session);
printf("host_to >%s<, et_to >%s<\n",etp->host_to,etp->et_to);
/* disconnect from database */
dbDisconnect(dbsock);
/* station 'from' */
strcpy(etp->station,"ETT");
/* init ET configuration will be used for both ET systems */
et_open_config_init(&etp->openconfig);
/*****************/
/* open 'from' ET */
/*****************/
et_open_config_sethost(etp->openconfig, etp->host_from);
et_open_config_gethost(etp->openconfig, ch);
printf("host_from >%s<\n",ch);
/*et_open_config_setport(openconfig, 12345);*/
/*sergey: increase tcp buffersize
{
int rBufSize;
int sBufSize;
int noDelay;
et_open_config_gettcp(openconfig, &rBufSize, &sBufSize, &noDelay);
printf("default rBufSize=%d, sBufSize=%d, noDelay=%d\n", rBufSize, sBufSize, noDelay);
rBufSize = 65000;
sBufSize = 65000;
noDelay = 0;
et_open_config_settcp(openconfig, rBufSize, sBufSize, noDelay);
et_open_config_gettcp(openconfig, &rBufSize, &sBufSize, &noDelay);
printf("ett: set rBufSize=%d, sBufSize=%d, noDelay=%d\n", rBufSize, sBufSize, noDelay);
}
*/
if(et_open(&etp->id_from, etp->et_from, etp->openconfig) != ET_OK)
{
printf("et_open 'from' problems\n");
exit(1);
}
/******************/
/* open 'to' ET */
/******************/
/*!!!!!!!!!!!!!!!! ET_HOST_ANYWHERE works, to_node does not !!!!!!!!*/
et_open_config_sethost(etp->openconfig, etp->host_to/*ET_HOST_ANYWHERE*/);
et_open_config_gethost(etp->openconfig, ch);
printf("host_to >%s<\n",ch);
/* Always use 'direct' connection: you can connect to any subnet,
but only one ET system allowed on remote machine */
et_open_config_setcast(etp->openconfig, ET_DIRECT);
/*sergey: increase tcp buffersize
{
int rBufSize;
int sBufSize;
int noDelay;
et_open_config_gettcp(openconfig, &rBufSize, &sBufSize, &noDelay);
printf("default rBufSize=%d, sBufSize=%d, noDelay=%d\n", rBufSize, sBufSize, noDelay);
rBufSize = 65000;
sBufSize = 65000;
noDelay = 0;
et_open_config_settcp(openconfig, rBufSize, sBufSize, noDelay);
et_open_config_gettcp(openconfig, &rBufSize, &sBufSize, &noDelay);
printf("ett: set rBufSize=%d, sBufSize=%d, noDelay=%d\n", rBufSize, sBufSize, noDelay);
}
*/
/*
{
et_open_config *config = (et_open_config *) openconfig;
printf("befor et_open: rBufSize=%d, sBufSize=%d, noDelay=%d\n",
config->tcpSendBufSize,config->tcpRecvBufSize,config->tcpNoDelay);
}
*/
if(et_open(&etp->id_to, etp->et_to, etp->openconfig) != ET_OK)
{
printf("et_open 'to' problems\n");
exit(1);
}
{
et_id *idto = (et_id *) etp->id_to;
printf("11111: idto->endian=0x%08x idto->systemendian=0x%08x\n",idto->endian,idto->systemendian);
}
printf("11\n");fflush(stdout);
/* destroy configuration */
et_open_config_destroy(etp->openconfig);
/* init station configuration */
et_station_config_init(&etp->sconfig);
et_station_config_setuser(etp->sconfig, ET_STATION_USER_MULTI);
et_station_config_setrestore(etp->sconfig, ET_STATION_RESTORE_OUT);
et_station_config_setprescale(etp->sconfig, 1);
et_station_config_setcue(etp->sconfig, 150);
printf("12\n");fflush(stdout);
/* ET system "all" mode */
et_station_config_setselect(etp->sconfig, ET_STATION_SELECT_ALL);
et_station_config_setblock(etp->sconfig, ET_STATION_BLOCKING);
/* ET system "on req" mode
et_station_config_setselect(etp->sconfig, ET_STATION_SELECT_ALL);
et_station_config_setblock(etp->sconfig, ET_STATION_NONBLOCKING);
*/
/* ET system "condition" mode
et_station_config_setselect(etp->sconfig, ET_STATION_SELECT_MATCH);
et_station_config_setblock(setp->config, ET_STATION_BLOCKING);
et_station_config_setselectwords(etp->sconfig, selections);
*/
/* new non-blocking "condition" mode
et_station_config_setselect(etp->sconfig, ET_STATION_SELECT_MATCH);
et_station_config_setblock(etp->sconfig, ET_STATION_NONBLOCKING);
et_station_config_setselectwords(etp->sconfig, selections);
*/
/* user's condition, blocking mode
et_station_config_setselect(etp->sconfig, ET_STATION_SELECT_USER);
et_station_config_setblock(etp->sconfig, ET_STATION_BLOCKING);
et_station_config_setselectwords(etp->sconfig, selections);
if (et_station_config_setfunction(etp->sconfig, "et_carls_function") == ET_ERROR) {
printf("%s: cannot set function\n", argv[0]);
exit(1);
}
if (et_station_config_setlib(etp->sconfig, "/home/timmer/cvs/coda/source/et/src/libet_user.so") == ET_ERROR) {
printf("%s: cannot set library\n", argv[0]);
exit(1);
}
*/
/* user's condition, nonblocking mode
et_station_config_setselect(etp->sconfig, ET_STATION_SELECT_USER);
et_station_config_setblock(etp->sconfig, ET_STATION_NONBLOCKING);
et_station_config_setselectwords(etp->sconfig, selections);
et_station_config_setfunction(etp->sconfig, "et_carls_function");
et_station_config_setlib(etp->sconfig, "/home/timmer/cvs/coda/source/et/src/libet_user.so");
*/
/* set debug level */
et_system_setdebug(etp->id_from, ET_DEBUG_INFO);
et_system_setdebug(etp->id_to, ET_DEBUG_INFO);
if ((status = et_station_create(etp->id_from, &etp->stat_from, etp->station, etp->sconfig)) < ET_OK)
{
if (status == ET_ERROR_EXISTS)
{
/* my_stat contains pointer to existing station */;
printf("station already exists, will attach to it\n");
/* get id and attach to existing station (must be created by 'et_start' */
if((status = et_station_name_to_id(etp->id_from, &etp->stat_from, etp->station)) < ET_OK)
{
printf("error in station_name_to_id\n");
exit(0);
}
}
else
{
printf("error in station creation\n");
exit(0);
}
}
et_station_config_destroy(etp->sconfig);
printf("13\n");fflush(stdout);
/* */
if (et_station_attach(etp->id_from, etp->stat_from, &etp->att_from) < 0)
{
printf("error in station attach\n");
exit(0);
}
printf("14\n");fflush(stdout);
if (et_station_attach(etp->id_to, ET_GRANDCENTRAL, &etp->att_to) < 0)
{
printf("error in station attach\n");
exit(0);
}
printf("15\n");fflush(stdout);
et_bridge_config_init(&etp->bconfig);
/*et_bridge_config_setfunc(etp->bconfig, et_bridge_CODAswap);*/
/* set timeouts - does not do anything ???
if (et_bridge_config_settimeoutfrom(etp->bconfig, btime) < 0)
{
printf("error et_bridge_config_settimeoutfrom\n");
exit(0);
}
if (et_bridge_config_settimeoutto(etp->bconfig, btime) < 0)
{
printf("error et_bridge_config_settimeoutto\n");
exit(0);
}
*/
printf("1 etp->exit = %d\n",etp->exit);
printf("1 etp->exit = %d\n",etp->exit);
printf("1 etp->exit = %d\n",etp->exit);
/* infinite loop */
status = ET_OK;
while((status == ET_OK) && (etp->exit == 0))
{
printf("-> status=%d etp->exit=%d\n",status,etp->exit);
status = et_events_bridge(etp->id_from, etp->id_to, etp->att_from, etp->att_to,
etp->bconfig, NUMEVENTS, &ntransferred);
}
printf("2 etp->exit = %d\n",etp->exit);
printf("2 etp->exit = %d\n",etp->exit);
printf("2 etp->exit = %d\n",etp->exit);
/* cleanup */
et_bridge_config_destroy(etp->bconfig);
et_forcedclose(etp->id_from);
et_forcedclose(etp->id_to);
etp->exit = 0;
return(ET_OK);
}
main(int argc,char **argv)
{
int *ev, len, i, j, status, numread, totalread=0, nevents_max, event_size, chunk;
int con[ET_STATION_SELECT_INTS];
et_event **pe;
et_openconfig openconfig;
et_statconfig sconfig;
et_att_id attach;
et_stat_id my_stat;
et_sys_id id;
sigset_t sigblock;
struct timespec timeout;
pthread_t tid;
BOSIOptr BIOstream;
char *ch;
char *str1 =
"OPEN UNIT=11 FILE='/scratch/boiarino/test.A00' WRITE RECL=32768 SPLITMB=2047 RAW SEQ NEW BINARY";
/*"OPEN UNIT=11 FILE='/work/clas/disk1/boiarino/test.A00' WRITE RECL=32768 SPLITMB=2047 RAW SEQ NEW BINARY";*/
if(argc != 3) {
printf("Usage: et2bos_test <et_filename> <station_name>\n");
exit(1);
}
timeout.tv_sec = 0;
timeout.tv_nsec = 1;
/* setup signal handling */
sigfillset(&sigblock);
/* block all signals */
status = pthread_sigmask(SIG_BLOCK, &sigblock, NULL);
if (status != 0) {
printf("et2bos: pthread_sigmask failure\n");
exit(1);
}
#ifdef sun
thr_setconcurrency(thr_getconcurrency() + 1);
#endif
/* spawn signal handling thread */
pthread_create(&tid, NULL, signal_thread, (void *)NULL);
restartLinux:
/* open ET system */
et_open_config_init(&openconfig);
et_open_config_setwait(openconfig, ET_OPEN_WAIT);
if (et_open(&id, argv[1], openconfig) != ET_OK) {
printf("et2bos: et_open problems\n");
exit(1);
}
et_open_config_destroy(openconfig);
/*
* Now that we have access to an ET system, find out how many
* events it has and what size they are. Then allocate an array
* of pointers to use for reading, writing, and modifying these events.
*/
if (et_system_getnumevents(id, &nevents_max) != ET_OK)
{
printf("et2bos: ET has died\n");
exit(1);
}
if (et_system_geteventsize(id, &event_size) != ET_OK)
{
printf("et2bos: ET has died\n");
exit(1);
}
if ( (pe = (et_event **) calloc(nevents_max, sizeof(et_event *))) == NULL)
{
printf("et2bos: cannot allocate memory\n");
exit(1);
}
et_station_config_init(&sconfig);
et_station_config_setuser(sconfig, ET_STATION_USER_MULTI);
et_station_config_setrestore(sconfig, ET_STATION_RESTORE_OUT);
et_station_config_setprescale(sconfig, 1);
/* old "all" mode */
et_station_config_setselect(sconfig, ET_STATION_SELECT_ALL);
et_station_config_setblock(sconfig, ET_STATION_BLOCKING);
et_station_config_setcue(sconfig, 150); /* if ET_STATION_NONBLOCKING */
/* set debug level */
et_system_setdebug(id, ET_DEBUG_INFO);
/* create station */
if ((status = et_station_create(id, &my_stat, argv[2], sconfig)) < 0)
{
if (status == ET_ERROR_EXISTS)
{
/* my_stat contains pointer to existing station */;
printf("et2bos: set ptr to the existing station\n");
}
else if (status == ET_ERROR_TOOMANY)
{
printf("et2bos: too many stations created\n");
goto error;
}
else
{
printf("et2bos: error in station creation\n");
goto error;
}
}
printf("et2bos: station ready\n");
if (et_station_attach(id, my_stat, &attach) < 0)
{
printf("et2bos: error in station attach\n");
goto error;
}
/* open FPACK file for writing */
/*if( (status = FParm(str1,&fd)) !=0)
{
printf("FParm status %d \n",status);
printf("command was >%s<\n",str1);
exit(1);
}*/
/* set file descriptor pointer */
BIOstream = (BOSIOptr)fd;
/* initialize BOS array */
bosInit(jw,NBCS);
while (et_alive(id))
{
/**************/
/* read data */
/**************/
/* example of single, timeout read */
/* status = et_event_get(&id, attach, &pe[0], ET_TIMED, &timeout); */
/* example of single, asynchronous read */
/* status = et_event_get(&id, attach, &pe[0], ET_ASYNC, NULL);*/
/* example of reading array of up to "chunk" events */
/* chunk = 500; */
/* numread = status = et_events_get(&id, attach, pe, ET_SLEEP, NULL, chunk, &numread);*/
chunk = 500;
status = et_events_get(id, attach, pe, ET_SLEEP, NULL, chunk, &numread);
if (status == ET_OK) {
;
}
else if (status == ET_ERROR_DEAD) {
printf("et2bos: ET system is dead\n");
goto end;
}
else if (status == ET_ERROR_TIMEOUT) {
printf("et2bos: got timeout\n");
goto end;
}
else if (status == ET_ERROR_EMPTY) {
printf("et2bos: no events\n");
goto end;
}
else if (status == ET_ERROR_BUSY) {
printf("et2bos: station is busy\n");
goto end;
}
else if (status == ET_ERROR_WAKEUP) {
printf("et2bos: someone told me to wake up\n");
goto end;
}
else if ((status == ET_ERROR_WRITE) || (status == ET_ERROR_READ)) {
printf("et2bos: socket communication error\n");
goto end;
}
else if (status != ET_OK) {
printf("et2bos: get error\n");
goto error;
}
/****************************************/
/* print data, write data to FPACK file */
/****************************************/
for (j=0; j<numread; j++)
{
et_event_getdata(pe[j], (void **) &ev);
/*
et_event_getlength(pe[j], &len);
printf("et2bos: recname=>%4.4s%4.4s<, run#=%d, event#=%d, reclen=%d\n",
(char *)&ev[3],(char *)&ev[4],ev[5],ev[6],ev[10]);
printf(" temp = %d, pri = %d, len = %d\n",
pe[j]->temp,et_event_getpriority(pe[j]),len);
et_event_getcontrol(pe[j], con);
for (i=0; i < ET_STATION_SELECT_INTS; i++)
{
printf("control[%d] = %d\n",i,con[i]);
}
*/
/* drop banks from previous event */
bosLdrop(jw, "E");
bosNgarbage(jw);
bosWgarbage(jw);
/* create banks in BOS array */
status = et2bos(ev, jw, "E");
if (status != 0)
{
printf ("et2bos_test: error %d in et2bos()\n",status);
exit(1);
}
/* call next if want to use ET record header; otherwise
record name will be "RUNEVENT" and other info from HEAD bank */
/*bosWriteRecord(fd,&ev[3],ev[5],ev[6],ev[8]);*/
/* write down BOS banks to file */
/*
status = bosWrite(fd, jw, "E");
if (status != 0)
{
printf ("et2bos_test: error %d in bosWrite()\n",status);
exit(1);
}
*/
}
/*********************/
/* return data to ET */
/*********************/
/* example of writing single event */
/* status = et_event_put(id, attach, pe[0]);*/
/* example of writing array of events */
status = et_events_put(id, attach, pe, numread);
if (status == ET_ERROR_DEAD) {
printf("et2bos: ET is dead\n");
goto end;
}
else if ((status == ET_ERROR_WRITE) || (status == ET_ERROR_READ)) {
printf("et2bos: socket communication error\n");
goto end;
}
else if (status != ET_OK) {
printf("et2bos: put error\n");
goto error;
}
totalread += numread;
end:
/* print something out after having read NUMEVENTS events */
if (totalread >= NUMEVENTS)
{
totalread = 0;
printf(" et2bos: %d events\n", NUMEVENTS);
}
/* if ET system is dead, wait here until it comes back */
while (!et_alive(id)) {
status = et_wait_for_alive(id);
if (status == ET_OK) {
int locality;
et_system_getlocality(id, &locality);
/* if Linux, re-establish connection to ET system since socket broken */
if (locality == ET_LOCAL_NOSHARE) {
printf("et2bos: try to reconnect Linux client\n");
et_forcedclose(id);
goto restartLinux;
}
}
}
} /* while(alive) */
error:
free(pe);
printf("et2bos: ERROR\n");
exit(0);
}
/* ET Initialization */
int
mon_et_initialize(void)
{
et_statconfig sconfig;
et_openconfig openconfig;
int status;
struct timespec timeout;
timeout.tv_sec = 2;
timeout.tv_nsec = 0;
/* Normally, initialization is done only once. However, if the ET
* system dies and is restarted, and we're running on a Linux or
* Linux-like operating system, then we need to re-initalize in
* order to reestablish the tcp connection for communication etc.
* Thus, we must undo some of the previous initialization before
* we do it again.
*/
if(et_init > 0)
{
/* unmap shared mem, detach attachment, close socket, free et_sys */
et_forcedclose(et_sys);
}
printf("mon_et_initialize: start ET stuff\n");
if(et_open_config_init(&openconfig) != ET_OK)
{
printf("ERROR: mon ET init: cannot allocate mem to open ET system\n");
return MON_ERROR;
}
et_open_config_setwait(openconfig, ET_OPEN_WAIT);
et_open_config_settimeout(openconfig, timeout);
if(et_open(&et_sys, et_name, openconfig) != ET_OK)
{
printf("ERROR: mon ET init: cannot open ET system\n");
return MON_ERROR;
}
et_open_config_destroy(openconfig);
/* set level of debug output */
et_system_setdebug(et_sys, ET_DEBUG_ERROR);
/* where am I relative to the ET system? */
et_system_getlocality(et_sys, &et_locality);
et_station_config_init(&sconfig);
et_station_config_setselect(sconfig, ET_STATION_SELECT_ALL);
et_station_config_setblock(sconfig, ET_STATION_BLOCKING);
et_station_config_setuser(sconfig, ET_STATION_USER_MULTI);
et_station_config_setrestore(sconfig, ET_STATION_RESTORE_OUT);
et_station_config_setprescale(sconfig,1);
if((status = et_station_create(et_sys, &et_statid, "TAPE", sconfig)) < 0)
{
if (status == ET_ERROR_EXISTS) {
printf("mon ET init: station exists, will attach\n");
}
else
{
et_close(et_sys);
et_station_config_destroy(sconfig);
printf("ERROR: mon ET init: cannot create ET station (status = %d)\n",
status);
return(MON_ERROR);
}
}
et_station_config_destroy(sconfig);
if (et_station_attach(et_sys, et_statid, &et_attach) != ET_OK) {
et_close(et_sys);
printf("ERROR: mon ET init: cannot attach to ET station\n");
return MON_ERROR;
}
et_init++;
et_reinit = 0;
printf("mon ET init: ET fully initialized\n");
return MON_OK;
}