---

CAlarmServer.cpp

// Author:
//   Jason Venema
//   NSCL
//   Michigan State University
//   East Lansing, MI 48824-1321
//   mailto:venemaja@msu.edu
//
// Copyright
//   NSCL All rights reserved.
//
// See CAlarmServer.h for a description of this class.
//

#include <iostream.h>
#include <stdio.h>
#include <string.h>
#include <CAlarmServer.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>

extern gdbm_error gdbm_errno;           // errno for gdbm
extern int errno;                       // in case the server dies

CAlarmServer::CAlarmServer()
{
  // See if "daqalarm" is configured
  struct servent* pServ = getservbyname("daqalarm", "tcp");
  if(pServ) {
    Int_t nPort = pServ->s_port;
    char port[4];
    sprintf(port, "%d", nPort);
    m_sPort = string(port);
  }
  else {
    // default to 2702
    m_sPort = "2702";
  }

  GDBM_FILE DBFWriter;

  // We open these files so that they will be created. That way, we don't
  // have to worry about doing this later, during the actual fulfilling of
  // client requests.
  if(!(DBFWriter = gdbm_open(".alarmcount", 512, GDBM_WRCREAT, 
                             S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH, 0))) {
    string reason = "Attempting to open .alarmcount while ";
    reason += "constructing CAlarmServer";
    CGDBMException dbme(reason, gdbm_errno);
    throw dbme;
  }
  gdbm_close(DBFWriter);
  if(!(DBFWriter = gdbm_open(".alarmdb", 512, GDBM_WRCREAT,
                             S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH, 0))) {
    string reason = "Attempting to open .alarmcount while ";
    reason += "constructing CAlarmServer";
    CGDBMException dbme(reason, gdbm_errno);
    throw dbme;
  }

  // It is VERY important to close the gdbm file every time we are done writing
  // to it or reading from it, so that some cleanup operations may be performed
  gdbm_close(DBFWriter);
}

CAlarmServer::CAlarmServer(const CAlarmServer& aCAlarmServer)
{
  m_sExpId = aCAlarmServer.m_sExpId;
  m_sAlarmId = aCAlarmServer.m_sAlarmId;
}

bool
CAlarmServer::operator()()
{
  CSocket* newSock;   // the new socket
  string client_ip;   // the client ip address
  pid_t child_pid;    // the pid of the child process
  if((child_pid = fork()) < 0) {
    // If we can't even fork a new process, we had better bail out!
    cerr << "Error while attempting to fork a new process." << endl;
    return 0;
  }

  // The parent will wait for the child to die, and restart it if need be...
  else if(child_pid > 0) {
    int x;
    wait(&x);
    cerr << "Exit status was " << x << endl;

    //If the exit status is SIGHUP, then someone asked us to shutdown
    if(x == SIGHUP) {
      cout << "Received hangup!" << endl;
      return 0;
    }

    // Otherwise, something happened that shouldn't have and we try
    // to restart the server.
    else {
      cerr << "Server dying!" << endl;
      perror(strerror(errno));
      return 1;
    }
  }

  // The child process will execute this part...
  else {
    try {
      CSocket sock;

      // The following code is so that the server can be restarted immediately
      // upon exiting, without having to wait for the OS to free up the address
      // space it was using.
      int fd = sock.getSocketFd();
      int state = 1;
      setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &state, sizeof(int));

      // Now we bind, listen and accept any requests
      sock.Bind(m_sPort);

      // BUGBUG Listen has a parameter nBacklog -- should we change it?
      // The value is defaulted to 5, meaning that the limit on the queue size
      // for incoming connections is 5. Additional connections are refused.
      sock.Listen();
      while(1) {
        newSock = sock.Accept(client_ip);

        // Get the id and reason of the experiment making the request
        void* pBuf = (void*)(new char[512]);

        // Block until some command comes through the socket
        int nB = newSock->Read(pBuf, 512);

        // Break that command down so we can process it
        char command[512];
        sprintf(command, "%s", (char*)pBuf);
        char* pCommand = command;
        char* temp;
        int reason;
        string fac, mess, date;
        temp = strsep(&pCommand, " ");
        m_sExpId = string(temp);  // set the experiment ID for this request
        temp = strsep(&pCommand, " ");
        reason = atoi(temp);      // this is why we're being called

        // Now we figure out what the request is all about
        switch(reason) {
        case LOG: {
          // Break the command up into the alarm information so it can
          // be logged to the logfile
          temp = strsep(&pCommand, " ");
          m_sAlarmId = string(temp);
          temp = strsep(&pCommand, "~");
          fac = string(temp);
          temp = strsep(&pCommand, "~");
          mess = string(temp);
          temp = strsep(&pCommand, "\n");
          date = string(temp);
          
          // Make sure the information is valid
          if(!(fac.size()) ||
             !(mess.size()) ||
             !(date.size())) {
            CAlarmServerException ase
              ("Attempting to parse log request in CAlarmServer::operator()",
               pCommand);
            throw ase;
          }

          // Let the Log() function take care of the rest
          Log(fac, mess, date);
          break;
        }
        case ACKNOWLEDGE:
        case DISMISS:     {

          // Break the command down further and get the alarm id to edit
          temp = strsep(&pCommand, " \n");
          int id = atoi(temp);
          char szBuf[20];
          sprintf(szBuf, "%d", id);
          m_sAlarmId = string(szBuf);

          // Let the EditAlarm() function do the rest
          EditAlarm(reason);
          break;
        }
        case UPDATE: {

          // We perform the update stuff here, because we need to use the
          // socket that is already opened to send update information to the
          // client.
          GDBM_FILE DBFReader;
          if(!(DBFReader = gdbm_open(".alarmdb", 512 ,GDBM_READER, 0, 0))) {
            string reason = "Attempting to open .alarmdb in ";
            reason += "CAlarmServer::Update()";
            CGDBMException dbme(reason, gdbm_errno);
            throw dbme;
          }
          string packet = "";  // this will be the final packet we send
          string sPiece;       // this is just a piece of the packet
          datum NextKey;
          datum ContentVal;

          // Start by retrieving the first key from the database
          datum KeyVal = gdbm_firstkey(DBFReader);
          while(KeyVal.dptr) {

            // Now we examine every key, and "build up" our packet with
            // each entry for this experiment
            NextKey = gdbm_nextkey(DBFReader, KeyVal);
            ContentVal = gdbm_fetch(DBFReader, KeyVal);
            sPiece = string(ContentVal.dptr);
            if(atoi(&(KeyVal.dptr)[0]) == atoi(m_sExpId.c_str())) {
              sPiece.resize(ContentVal.dsize);
              packet += string(sPiece);
              packet += "\n";
            }
            KeyVal = NextKey;
          }

          // This eof tells the caller that the packet is done. Now we
          // send it out!
          packet += "eof";
          newSock->Write((void*)packet.c_str(), packet.size());
          gdbm_close(DBFReader);
          break;
        }
        case INIT: {
          Init(newSock, &sock);
          break;
        }
        case CREATE: {
          CreateExperiment();
          break;
        }
        case HISTORY: {
          string sHistory = GetExperimentHistory();
          newSock->Write((void*)sHistory.c_str(), sHistory.size());
        }
        }
        
        // Perform some memory management here
        newSock->Shutdown();
        delete newSock;
        delete [] (char*)pBuf;
      }
    }
    catch (CException& e) {
      cerr << "Caught exception while attempting to listen on port " 
           << m_sPort << endl;
      cerr << "Reason was: " << e.ReasonText() << endl;
      cerr << e.WasDoing() << endl;
      exit(2);
    }
  }
}

void
CAlarmServer::Log(string& srFacility, string& srMessage, string& srDate)
{
  // First we create key and content values to store in the database.
  // The content consists of the alarm information, the key is of the
  // form "m_sExpId.m_sAlarmId" 
  string key = m_sExpId + "." + m_sAlarmId;
  string content = "ALARMID: ";
  content += m_sAlarmId;
  content += " FACILITY: ";
  content += srFacility;
  content += " STATUS: n ";
  content += "MESSAGE: ";
  content += srMessage;
  content += " DATE: ";
  content += srDate;

  // Items of type "datum" are stored in a gdbm database. A datum
  // consists of two fields: char* dptr and int dsize.
  datum key_value,
    content_value;
  key_value.dptr = (char*)(key.c_str());
  key_value.dsize = strlen(key.c_str());
  content_value.dptr = (char*)(content.c_str());
  content_value.dsize = strlen(content.c_str());

  // We can only allow one writer to open the file with write access
  // at a time.  We need to write the information to log it.
  GDBM_FILE DBFWriter;
  
  // There may be problems opening the database file
  if(!(DBFWriter = gdbm_open(".alarmdb", 0, GDBM_WRCREAT, 
                             S_IRUSR | S_IWUSR | S_IRGRP | 
                             S_IROTH, 0))) {
    string reason = "Attempting to open .alarmdb in CAlarmServer::Log()";
    CGDBMException dbme(reason, gdbm_errno);
    throw dbme;
  }

  // Need to make sure that the information was successfully stored
  if(gdbm_store(DBFWriter, key_value, content_value, GDBM_INSERT)) {
    string reason = "Attemping to store in .alarmdb in CAlarmServer::Log()";
    CGDBMException dbme(reason, gdbm_errno);
    throw dbme;
    gdbm_close(DBFWriter);
  }

  // A gdbm_open **needs** to be accompanied by a gdbm_close, in
  // order for gdbm to "tidy up" the database file entries.
  gdbm_close(DBFWriter);
  
  // Now we need to increment the number of alarms this experiment
  // has in the .alarmcount file
  GDBM_FILE DBFReader;
  if(!(DBFReader = gdbm_open
       (".alarmcount", 512, GDBM_READER, 644, 0))) {
    string reason = "Attempting to open .alarmcount in CAlarmServer::Log()";
    CGDBMException dbme(reason, gdbm_errno);
    throw dbme;
  }

  // So we create a key and see if it already exists in the database
  datum Key;
  Key.dptr = const_cast<char*>(m_sExpId.c_str());
  Key.dsize = strlen(m_sExpId.c_str());
  
  // We check to see if the experiment has any alarms logged yet.
  int KeyExists = gdbm_exists(DBFReader, Key);
  
  // There are some alarms logged for this experiment, so we need
  // to update the current entry...
  datum NewContent;
  if(KeyExists) {
    datum ContentValue = gdbm_fetch(DBFReader, Key);
    int nOldCount = atoi(ContentValue.dptr);
    char NewCount[5];
    sprintf(NewCount, "%d", ++nOldCount);
    NewContent.dptr = NewCount;
    NewContent.dsize = strlen(NewCount);
  }
  
  // or, there haven't been any alarms logged here yet, so we simply
  // create a new entry
  else {
    char NewCount[1];
    sprintf(NewCount, "%d", 1);
    NewContent.dptr = NewCount;
    NewContent.dsize = strlen(NewCount);
  }
  gdbm_close(DBFReader);
  
  // Now we need to open a new writer to write the new entry
  if(!(DBFWriter = gdbm_open(".alarmcount", 0, GDBM_WRCREAT,
                             S_IRUSR | S_IWUSR | S_IRGRP |
                             S_IROTH, 0))) {
    string reason = "Attempting to open .alarmcount in CAlarmServer::Log()";
    CGDBMException dbme(reason, gdbm_errno);
    throw dbme;
  }
  
  // We tell gdbm to replace the old entry with the new one
  // with the flag GDBM_REPLACE
  int ret = gdbm_store(DBFWriter, Key, NewContent, GDBM_REPLACE);
  gdbm_close(DBFWriter);
  if(ret) {
    string reason = "Attempting to store new alarm count in ";
    reason += ".alarmcount while in CAlarmServer::Log()";
    CGDBMException dbme(reason, gdbm_errno);
    throw dbme;
  }
}

void
CAlarmServer::EditAlarm(Int_t nReason)
{
  GDBM_FILE DBFReader;
  GDBM_FILE DBFWriter;
  
  // First open the database for reading and find the key for this
  // alarm and experiment
  if(!(DBFReader = gdbm_open(".alarmdb", 512, GDBM_READER, 644, 0))) {
    string why = "Attempting to open .alarmdb in CAlarmServer::EditAlarm()";
    CGDBMException dbme(why, gdbm_errno);
    throw dbme;
  }
  datum Key;
  string sKey = m_sExpId + "." + m_sAlarmId;
  Key.dptr = const_cast<char*>(sKey.c_str());
  Key.dsize = strlen(sKey.c_str());
  datum ContentValue = gdbm_fetch(DBFReader, Key);
  
  // Pull out the alarm data
  if(!ContentValue.dptr) {
    string why = "Attempting to fetch data from .alarmdb in ";
    why += "CAlarmServer::EditAlarm()";
    CGDBMException dbme(why, gdbm_errno);
    throw dbme;
  }
  gdbm_close(DBFReader);
  
  // Get ready to change the datum by opening up for writing
  if(!(DBFWriter = gdbm_open(".alarmdb", 0, GDBM_WRCREAT,
                             S_IRUSR | S_IWUSR | S_IRGRP |
                             S_IROTH, 0))) {
    string why = "Attempting to open .alarmdb in CAlarmServer::EditAlarm()";
    CGDBMException dbme(why, gdbm_errno);
    throw dbme;
  }
  
  // We will rebuild the content string based on the old content
  // and the new status
  string sNewContent = "";
  char* token;
  
  // Now we rebuild the content string with the new STATUS field
  // Note that there are two cases, one for Acknowledge and one for Dismiss
  if(nReason == ACKNOWLEDGE) {
    while(token = strsep(&ContentValue.dptr, " ")) {
      string tok = string(token);
      if(tok == "STATUS:") {
        sNewContent += tok;
        sNewContent += " ";
        token = strsep(&ContentValue.dptr, " ");
        tok = string(token);
        if(tok == "n")
          sNewContent += "a";
        else
          sNewContent += tok;
      }
      else {
        sNewContent += tok;
      }
      sNewContent += " ";
    }
  }

  // This is for a Dismissal request
  else if(nReason == DISMISS) {
    while(token = strsep(&ContentValue.dptr, " ")) {
      string tok = string(token);
      if(tok == "STATUS:") {
        sNewContent += tok;
        sNewContent += " ";
        token = strsep(&ContentValue.dptr, " ");
        tok = string(token);
        if(tok == "a")
          sNewContent += "d";
        else
          sNewContent += tok;
      }
      else {
        sNewContent += tok;
      }
      sNewContent += " ";
    }
  }
  
  // Create the new content datum
  sNewContent.resize(ContentValue.dsize);
  datum NewContent;
  NewContent.dptr = const_cast<char*>(sNewContent.c_str());
  NewContent.dsize = sNewContent.length();
  
  // Instruct gdbm_store to replace the entry with the same key,
  // since it is the old entry
  int ret = gdbm_store(DBFWriter, Key, NewContent, GDBM_REPLACE);
  if(ret) {
    gdbm_close(DBFWriter);
    string why = "Attempting to store acknowledgement in .alarmdb ";
    why += "in CAlarmServer::EditAlarm()";
    CGDBMException dbme(why, gdbm_errno);
    throw dbme;
  }

  // Don't forget how important it is to close this file!
  gdbm_close(DBFWriter);
}

void
CAlarmServer::Init(CSocket* newSock, CSocket* sock)
{
  // We open a reader to get the initial alarm count 
  // for this experiment
  GDBM_FILE DBFReader;
  if(!(DBFReader = gdbm_open(".alarmcount", 512, GDBM_READER, 0, 0))) {
    string reason = "Attempting to open .alarmcount in CAlarmServer::Init()";
    CGDBMException dbme(reason, gdbm_errno);
    throw dbme;
  }
  datum Key;
  Key.dptr = const_cast<char*>(m_sExpId.c_str());
  Key.dsize = strlen(m_sExpId.c_str());

  // Attempt to fetch the alarm count from the database
  datum ContentValue = gdbm_fetch(DBFReader, Key);
  gdbm_close(DBFReader);

  // If there is no count, then this is a new experiment, and its alarm
  // count is set to zero.
  if(!ContentValue.dptr) {
    datum NewContent;
    char content[4];
    sprintf(content, "%d", 0);
    NewContent.dptr = content;
    NewContent.dsize = strlen(content);
    ContentValue = NewContent;
  }

  // Now we will write the alarm count to the socket and send it
  // off to the alarm displayer to find out if the user really wants
  // us to create this new experiment
  int nB = newSock->Write((void*)ContentValue.dptr, ContentValue.dsize);
}

void
CAlarmServer::CreateExperiment() 
{
  GDBM_FILE DBFWriter;
  if(!(DBFWriter = gdbm_open(".alarmcount", 0, GDBM_WRCREAT,
                             S_IRUSR | S_IWUSR | S_IRGRP |
                             S_IROTH, 0))) {
    string reason = "Trying to open .alarmcount in CAlarmServer::Init()";
    CGDBMException dbme(reason, gdbm_errno);
    throw dbme;
  }
  datum Key;
  Key.dptr  = const_cast<char*>(m_sExpId.c_str());
  Key.dsize = strlen(m_sExpId.c_str());
  datum NewContent;
  char content[4];
  sprintf(content, "%d", 0);
  NewContent.dptr = content;
  NewContent.dsize = strlen(content);

  gdbm_store(DBFWriter, Key, NewContent, GDBM_REPLACE);
  gdbm_close(DBFWriter);
}

string
CAlarmServer::GetExperimentHistory()
{
  GDBM_FILE DBFReader;
  if(!(DBFReader = gdbm_open(".alarmdb", 512, GDBM_READER, 0, 0))) {
    string reason = "Trying to open .alarmcount in CAlarmServer::Init()";
    CGDBMException dbme(reason, gdbm_errno);
    throw dbme;
  }
  string packet = "";  // this will be the final packet we send
  string sPiece;       // this is just a piece of the packet
  datum NextKey;
  datum ContentVal;
  
  // Start by retrieving the first key from the database
  datum KeyVal = gdbm_firstkey(DBFReader);
  while(KeyVal.dptr) {
    
    // Now we examine every key, and "build up" our packet with
    // each entry for this experiment
    NextKey = gdbm_nextkey(DBFReader, KeyVal);
    ContentVal = gdbm_fetch(DBFReader, KeyVal);
    sPiece = string(ContentVal.dptr);
    if(atoi(&(KeyVal.dptr)[0]) == atoi(m_sExpId.c_str())) {
      sPiece.resize(ContentVal.dsize);
      packet += string(sPiece);
      packet += "\n";
    }
    KeyVal = NextKey;
  }
  packet += "eof";
  gdbm_close(DBFReader);
  return packet;
}

---