bogus_beammon.c

Go to the documentation of this file.

#include <stdio.h>
/* #include <getopt.h> seems to be part of <unistd.h> */
#include <unistd.h>
/* stdlib.h:  malloc and atoi */
#include <stdlib.h>
/* string.h: strrchr */
#include <string.h>

#include "OnlineUtil/msgLogLib/msgLog.h"
#include "OnlineUtil/rototalk.h"

/* timeval, gettimeofday */
#include <time.h>
#include <sys/time.h>

#include "OnlineUtil/rawBlockIds.h"
#include "OnlineUtil/rdChecksum.h"
#include "OnlineUtil/rotoMessages.h"

/* forward declarations */
int send_bogus_stuff(long* buffer, int bsize, int mxrec);
int config_autosave(const char* config);
int config_compress(const char* config);
int config_basketsize(const char* config);
long build_beammon_blockid(int major);

/* (default) maximum buffer size for raw records (in bytes) */
#define MAXBUFFER 8388608

/*
 *=========================================================================
 * main(int argc, char **argv)
 * 
 * Purpose:
 *    Generate and send a series of fake DCS records to the Rotorooter
 *
 *   usage: bogus_dcs -i<hostname> -b<buffer size> 
 *           -w<whoami> -p<port #> 
 *           -c"autosave_configstring" 
 *           -C"compress_configstring" 
 *           -B"basketsize_configstring" 
 *
 *     -i: hostname where rotorooter is running
 *     -b: buffer size to use
 *     -c: autosave config    "streamName,nrec,nsec[;streamName,nrec,nsec]" 
 *     -C: compression config "streamName,level[;streamName,level]"
 *     -B: basketsize config "streamName,size[;streamName,size]"
 *            both -c,-C,-B use "*" as streamName to set all legal streams
 *     -w: DCP or DCS or BeamMon
 *     -p: port number rotorooter is listening on
 *     -v: how verbose to be
 *     -n: maximum number of records from each file
 *     -h: print this message
 *
 * Return Value:
 *    non-zero indicates there was an error
 *=========================================================================
 */
int main(int argc, char **argv)
{

   /* this is C ... all declarations must come first */
   const char* iphost = "localhost";
   const char* default_producer = "BeamMon";   /* default producer */
   const int   default_port     = 9013;        /* default BeamMon port */
   const char* producer = default_producer;
   const char* autosave_config = 0;
   const char* compress_config = 0;
   const char* basketsize_config = 0;
   int port = default_port;
   int whoami = MINOS_ROOTER_BEAMMON;
   int bsize = MAXBUFFER;
   long* buffer = 0;
   int nerr = 0;
   int mxrec = 1000;  /* no input file, so limit how much stuff to send */
   int nodelay_flag = 1;  /* on by default */
   int echoMsgLog = 0;
   int copt;

   /*
    * parse the options and filenames
    * -i and -p take args
    */
   while ((copt = getopt(argc, argv, "i:b:c:C:B:w:p:ev:n:D:h")) != EOF) {
      switch (copt) {
      case 'i':  /* internet host */
         iphost = optarg;
         break;
      case 'b':  /* buffer size */
         bsize = atoi(optarg);
         break;
      case 'c':  /* autosave config string */
         autosave_config = optarg;
         break;
      case 'C':  /* compression config string */
         compress_config = optarg;
         break;
      case 'B':  /* basketsize config string */
         basketsize_config = optarg;
         break;
      case 'w':  /* whoami:  DCP, DCS, other */
         producer = optarg;
         break;
      case 'p':  /* port # */
         port = atoi(optarg);
         break;
      case 'e':  /* msgLog messages to stdout as well */
         echoMsgLog = 1;
         break;
      case 'v':  /* verbosity */
         roto_verbose = atoi(optarg);
         break;
      case 'n':  /* maximum number of records */
         mxrec = atoi(optarg);
         break;
      case 'D':  /* set nodelay_flag? */
         nodelay_flag = atoi(optarg);
         break;
      case 'h':  /* help */
         printf(" usage: %s -i<hostname> -b<buffer size> -w<whoami> -p<port #> <filenames..>\n", argv[0]);
         printf("   -i: hostname where rotorooter is running\n");
         printf("   -b: buffer size to use\n");
         printf("   -w: DCP, DCS or BeamMon\n");
         printf("   -p: port number rotorooter is listening on\n");
         printf("   -v: how verbose to be\n");
         printf("   -c: autosave config \"streamName,nrec,nsec[;streamName,nrec,nsec]\"\n");
         printf("   -C: compression config \"streamName,level[;streamName,level]\"\n");
         printf("   -B: basketsize config \"streamName,size[;streamName,size]\"\n");

         printf("   -n: maximum number of records from each file\n");

         printf("   -h: print this message\n");
         exit(1);
      default:
         printf(" unrecognized option '%c' ignored\n",(char)optopt);
         break;
      }
   }

   msgLogInit(argv[0]);
   msgLogNodeIdSet(whoami);
   msgLogLocalEchoSet(echoMsgLog);
   logNotice("starting %s",argv[0]);

   /* allocate a buffer to use */
   buffer = (long*) malloc(bsize);
   if (!buffer) {
      printf("failed to allocate buffer of size %d\n",bsize);
      exit(1);
   }
   if (roto_verbose>1) printf("allocated buffer of size %d\n",bsize);

   /* open a connection to the Rotorooter */
   if (0 == strcmp(producer,default_producer) && 
       port == default_port) {
      /* standard connection */
      if (roto_verbose>1) 
         printf("connect via roto_open_BeamMon_connection\n");
      nerr += roto_open_BeamMon_connection(iphost);
   } else {
      /* non-standard connection requested (either producer or port) */
      if (0 == strcmp(producer,"DCP")) {
         whoami  = MINOS_ROOTER_DCP;
      }
      else if (0 == strcmp(producer,"DCS")) {
         whoami = MINOS_ROOTER_DCS;
      }
      else if (0 == strcmp(producer,"BeamMon")) {
         whoami = MINOS_ROOTER_BEAMMON;
      }
      else 
         whoami = MINOS_ROOTER_UNIDENTIFIED_CLIENT;

      if (roto_verbose>1) 
         printf("connect via roto_open_connection: port %d, whoami %s (0x%2.2x)\n",port,producer,whoami);
      nerr += roto_open_connection(iphost,port,whoami);
   }
   if (nerr) exit(nerr);
   
   nerr += roto_set_connection_nodelay(nodelay_flag);

   if (autosave_config) nerr += config_autosave(autosave_config);
   if (compress_config) nerr += config_compress(compress_config);
   if (basketsize_config) nerr += config_basketsize(basketsize_config);

   nerr += send_bogus_stuff(buffer,bsize,mxrec);

   /* close the connection */
   nerr += roto_close_connection();

   /* set my buffer free */
   free(buffer);

   logNotice("stopping %s",argv[0]);
   msgLogCleanup();

   exit(nerr);
}

/*
 *=========================================================================
 * send_bogus_stuff(long* buffer, int bsize, int mxrec) 
 * 
 * Purpose:
 *    Send a series of bogus BeamMon records to the rotorooter
 *
 * Arguments:
 *    buffer:  ptr to pre-allocated buffer
 *    bsize:   buffer size
 *    mxrec:   maximum number of records to send (0=all)
 *
 * Return Value:
 *    non-zero indicates there was an error
 *=========================================================================
 */
int send_bogus_stuff(long* buffer, int bsize, int mxrec) 
{

   int   nRecords=0;
   int   nbytes;
   int   nextra, j;
   const float nextra_max = 100.0;
   int   blktype;
   unsigned int spillcnt = 0;

   int nerr = 0;

   struct timeval now;
   gettimeofday(&now,0);

   nerr += roto_open_beammonfile(now.tv_sec,now.tv_usec*1000);
   if (nerr) {
      printf("Rotorooter failed to open output file\n");
      return 1;
   }

   while (1) {
      if (mxrec>0 && nRecords==mxrec) break;
      nRecords++;
      /* fill a BeamMon record */
      /*
       * 0 BeamMonHeaderBlock size
       * 1                checksum
       * 2                blockid
       * 3                sec
       * 4                ns
       * 5                spillcnt
       * 6 {In|OutOf}SpillBeamMonBlock size
       * 7                         checksum
       * 8                         blockid
       * 9..                       <stuff>
       */
      /* see Linux "man -s 3 rand" on why whe do this */
      nextra = 1+(int) (nextra_max*rand()/(RAND_MAX+1.0));
      nbytes = (9+nextra)*sizeof(int);
      if (nbytes>bsize) {
        nbytes = bsize;
        nextra = nbytes/sizeof(int) - 9;
      }
      blktype = kMdBlockBeamMonPayload;

      buffer[0] = 6; /* BeamMonHeaderBlock size */
      /* skip checksum */
      buffer[2] = build_beammon_blockid(kMdBlockBeamMonHeader);
      gettimeofday(&now,0);
      buffer[3] = now.tv_sec;
      buffer[4] = now.tv_usec*1000;
      buffer[5] = ++spillcnt;
      /* now fill in checksum */
      buffer[1] = rdxsum_calc(buffer+0,1);

      buffer[6] = 3 + nextra; /* {In|OutOf}SpillBeamMonBlock size */
      /* skip checksum */
      buffer[8] = build_beammon_blockid(blktype);
      /* fill in some arbitrary stuff */
      for (j=0; j<nextra; ++j) buffer[j+9] = rand();
      /* now fill in checksum */
      buffer[7] = rdxsum_calc(buffer+6,1);
                                 
      /* send the record */
      nerr += roto_send_record(buffer,nbytes);
   }

   nerr += roto_close_beammonfile();
   return nerr;
}

/*
 *=========================================================================
 * config_autosave(const char* config)
 * 
 * Purpose:
 *    Send autosave config to the rotorooter, parsed from string
 *
 * Arguments:
 *    config:  configuration string of form:
 *             "streamName,nrec,nsec[;streamName,nrec,nsec]"
 *             use "*" as streamName to set all legal streams
 * 
 * Return Value:
 *    non-zero indicates there was an error
 *=========================================================================
 */
int config_autosave(const char* config)
{
   int nerr = 0;
   int len = strlen(config);
   char *wcopy = (char*)malloc(len+1);  /* a writable copy of config string */
   char stream[1024];
   const char *p1;
   char *p2;
   char achar;
   int nrec,nsec, nitems;

   /* make a copy, replacing all the commas with blanks*/
   p1 = config; p2 = wcopy;
   while (p2 < wcopy+len) {
      achar = *p1;
      if (achar != ',') *p2 = achar;
      else              *p2 = ' ';
      p1++; p2++;
   }

   p2 = wcopy;
   while (p2  < wcopy+len) {
      nitems = sscanf(p2,"%s %d %d",stream,&nrec,&nsec);
      if (nitems != 3) {
         logInfo("config_autosave: only %d items from \"%s\"\n",nitems,p2);
         nerr += rototalk_err_badconfig;
      }
      else 
         nerr += roto_send_autosave_config(stream,nrec,nsec);

      p2 = strchr(p2,';'); /* move to the semicolon         */
      if (!p2) break;      /* in case of no final semicolon */
      p2++;                /* start just beyond semicolon   */
   }


   free(wcopy);  /* return the allocated space */
   wcopy = 0;

   return nerr;
}

/*
 *=========================================================================
 * config_compress(const char* config)
 * 
 * Purpose:
 *    Send compression config to the rotorooter, parsed from string
 *
 * Arguments:
 *    config:  configuration string of form:
 *             "streamName,level[;streamName,level]"
 *             use "*" as streamName to set all legal streams
 * 
 * Return Value:
 *    non-zero indicates there was an error
 *=========================================================================
 */
int config_compress(const char* config)
{
   int nerr = 0;
   int len = strlen(config);
   char *wcopy = (char*)malloc(len+1);  /* a writable copy of config string */
   char stream[1024];
   const char *p1;
   char *p2;
   char achar;
   int level, nitems;

   /* make a copy, replacing all the commas with blanks*/
   p1 = config; p2 = wcopy;
   while (p2 < wcopy+len) {
      achar = *p1;
      if (achar != ',') *p2 = achar;
      else              *p2 = ' ';
      p1++; p2++;
   }

   p2 = wcopy;
   while (p2  < wcopy+len) {
      nitems = sscanf(p2,"%s %d",stream,&level);
      if (nitems != 2) {
         logInfo("config_compress: only %d items from \"%s\"\n",nitems,p2);
         nerr += rototalk_err_badconfig;
      }
      else 
         nerr += roto_send_compress_config(stream,level);

      p2 = strchr(p2,';'); /* move to the semicolon         */
      if (!p2) break;      /* in case of no final semicolon */
      p2++;                /* start just beyond semicolon   */
   }


   free(wcopy);  /* return the allocated space */
   wcopy = 0;

   return nerr;
}

/*
 *=========================================================================
 * config_basketsize(const char* config)
 * 
 * Purpose:
 *    Send basketsize config to the rotorooter, parsed from string
 *
 * Arguments:
 *    config:  configuration string of form:
 *             "streamName,bsize[;streamName,bsize]"
 *             use "*" as streamName to set all legal streams
 * 
 * Return Value:
 *    non-zero indicates there was an error
 *=========================================================================
 */
int config_basketsize(const char* config)
{
   int nerr = 0;
   int len = strlen(config);
   char *wcopy = (char*)malloc(len+1);  /* a writable copy of config string */
   char stream[1024];
   const char *p1;
   char *p2;
   char achar;
   int bsize, nitems;

   /* make a copy, replacing all the commas with blanks*/
   p1 = config; p2 = wcopy;
   while (p2 < wcopy+len) {
      achar = *p1;
      if (achar != ',') *p2 = achar;
      else              *p2 = ' ';
      p1++; p2++;
   }

   p2 = wcopy;
   while (p2  < wcopy+len) {
      nitems = sscanf(p2,"%s %d",stream,&bsize);
      if (nitems != 2) {
         logInfo("config_basketsize: only %d items from \"%s\"\n",nitems,p2);
         nerr += rototalk_err_badconfig;
      }
      else 
         nerr += roto_send_basketsize_config(stream,bsize);

      p2 = strchr(p2,';'); /* move to the semicolon         */
      if (!p2) break;      /* in case of no final semicolon */
      p2++;                /* start just beyond semicolon   */
   }


   free(wcopy);  /* return the allocated space */
   wcopy = 0;

   return nerr;
}

/*
 *=========================================================================
 * long build_beammon_blockid(int major)
 * 
 * Purpose:
 *    Generate a block id  (force DCS, bogus simflag)
 *
 * Arguments:
 *    major    : major block id
 * 
 * Return Value:
 *    non-zero indicates there was an error
 *=========================================================================
 */
long build_beammon_blockid(int major)
{
   const long  shiftRawBlkIdMinor    =  0;
   const long  shiftRawBlkIdMajor    =  8;
   const long  shiftRawBlkIdDetector = 25;
   const long  shiftRawBlkIdCSimFlag = 28;
   
   const long  maskRawBlkIdMinor     = 0x000000ff;
   const long  maskRawBlkIdMajor     = 0x00ffff00;
   const long  maskRawBlkIdIsDCS     = 0x01000000;
   const long  maskRawBlkIdDetector  = 0x0e000000;
   const long  maskRawBlkIdCSimFlag  = 0x30000000;

   int cmptSimFlag = 1;  /* compact simflag for DaqFakeData */
   int isDCS = 1;
   int minor = 0;
   int detector = 0;

   return
      ((cmptSimFlag << shiftRawBlkIdCSimFlag) & maskRawBlkIdCSimFlag) |
      ((   detector << shiftRawBlkIdDetector) & maskRawBlkIdDetector) |
      ((isDCS) ? maskRawBlkIdIsDCS : 0)                               |
      ((         major << shiftRawBlkIdMajor) & maskRawBlkIdMajor)    |
      ((         minor << shiftRawBlkIdMinor) & maskRawBlkIdMinor);

}

---