mariadb-columnstore-engine/dbcon/execplan/sessionmonitor.cpp

/* Copyright (C) 2014 InfiniDB, Inc.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; version 2 of
   the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
   MA 02110-1301, USA. */

/*****************************************************************************
 * $Id: sessionmonitor.cpp 9210 2013-01-21 14:10:42Z rdempsey $
 *
 ****************************************************************************/

using namespace std;

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <time.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>

#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>
#include <ios>
#include <vector>

#include "calpontsystemcatalog.h"
#include "sessionmonitor.h"
#include "configcpp.h"

#include "vendordmlstatement.h"
#include "calpontdmlpackage.h"
#include "calpontdmlfactory.h"
using namespace dmlpackage;

#include "bytestream.h"
#include "messagequeue.h"
using namespace messageqcpp;

using namespace BRM;

#include "installdir.h"

namespace execplan
{
SessionMonitor::SessionMonitor()
{
  config::Config* conf;
  int madeSems;
  string stmp;

  fuid = getuid();
  conf = config::Config::makeConfig();

  try
  {
    stmp = conf->getConfig("SessionManager", "MaxConcurrentTransactions");
  }
  catch (exception& e)
  {
    cout << e.what() << endl;
    stmp.empty();
  }

  int tmp = static_cast<int>(config::Config::fromText(stmp));

  if (tmp <= 0)
    fMaxTxns = 1000;
  else
    fMaxTxns = tmp;

  stmp.clear();

  try
  {
    stmp = conf->getConfig("SessionMonitor", "SharedMemoryTmpFile");
  }
  catch (exception& e)
  {
    cout << e.what() << endl;
    stmp.empty();
  }

  // Instantiate/delete a SessionManager to make sure it's shared memory segments are present.
  SessionManager* mgr = new SessionManager();
  delete mgr;

  if (stmp != "")
    fSegmentFilename = strdup(stmp.c_str());
  else
  {
    string tmpdir = "/var/lib/columnstore/CalpontSessionMonitorShm";

    fSegmentFilename = strdup(tmpdir);
  }

  try
  {
    madeSems = getSems();
    fHaveSemaphores = true;
  }
  catch (...)
  {
    fHaveSemaphores = false;
  }

  stmp.clear();

  try
  {
    stmp = conf->getConfig("SessionMonitor", "TransactionAgeLimit");
  }
  catch (exception& e)
  {
    cerr << e.what() << endl;
    stmp.empty();
  }

  tmp = static_cast<int>(config::Config::fromText(stmp));

  if (tmp <= 0)
    fAgeLimit = fDefaultAgeLimit;
  else
    fAgeLimit = tmp;

  fIsAttached = false;
  getSharedData();
  unlock();
  fCurrentSegment = NULL;
  fPrevSegment.activeTxns = NULL;

  if (haveSharedMemory())
    copyCurrentSegment();

  if (haveSemaphores())
    copyPreviousSegment();
}

SessionMonitor::SessionMonitor(const SessionMonitor& sm)
{
}

SessionMonitor::~SessionMonitor()
{
  saveAsMonitorData(segmentFilename());

  if (fSessionManagerData != NULL)
  {
    lock();
    detachSegment();
    unlock();
  }

  // delete [] fCurrentSegment;
  // delete [] fSessionMonitorData.activeTxns;
  // delete [] fPrevSegment.activeTxns;
}

void SessionMonitor::detachSegment()
{
  // delete [] fSessionManagerData;

  fIsAttached = false;
}

// returns 1 if it attached to pre-existing semaphores, else it throws exception.
int SessionMonitor::getSems()
{
  return 1;
}

void SessionMonitor::lock()
{
}

void SessionMonitor::unlock()
{
}

void SessionMonitor::printTxns(const MonSIDTIDEntry& txn) const
{
  cout << "sessionid " << txn.sessionid << " txnid " << txn.txnid.id << " valid "
       << (txn.txnid.valid == true ? "TRUE" : "FALSE") << " time_t " << txn.txnid.firstrecord << " tdiff "
       << time(NULL) - txn.txnid.firstrecord << " ctime " << ctime(&txn.txnid.firstrecord);
}

#ifdef SM_DEBUG
void SessionMonitor::printTxns(const SessionManager::SIDTIDEntry& txn) const
{
  cout << "sessionid " << txn.sessionid << " txnid " << txn.txnid.id << " valid "
       << (txn.txnid.valid == true ? "TRUE" : "FALSE") << endl;
}

void SessionMonitor::printMonitorData(const int len) const
{
  MonSIDTIDEntry* txns = fPrevSegment.activeTxns;

  cout << "Monitor txnCount " << fPrevSegment.txnCount << " verID " << fPrevSegment.verID << endl;

  for (int idx = 0; txns && idx < len; idx++)
  {
    printTxns(txns[idx]);
  }

  cout << "==" << endl;
}

void SessionMonitor::printSegment(const SessionManagerData_t* seg, const int len) const
{
  if (seg == NULL)
  {
    cerr << "No SessionManagerData" << endl;
    return;
  }

  cout << "Manager txnCount " << seg->txnCount << " verID " << seg->verID << endl;

  for (int idx = 0; idx < len; idx++)
  {
    printTxns(seg->activeTxns[idx]);
  }
}
#endif

void SessionMonitor::getSharedData()
{
  int len;

  fSessionManagerData = reinterpret_cast<SessionManagerData_t*>(sm.getShmContents(len));

  if (fSessionManagerData == NULL)
  {
    cerr << "SessionMonitor::getSharedData(): getShmContents() failed" << endl;
    throw runtime_error("SessionMonitor::getSharedData(): getShmContents() failed.  Check the error log.");
  }

  fIsAttached = true;
}

void SessionMonitor::initSegment(SessionMonitorData_t* seg)
{
  if (!seg)
    return;

  seg->txnCount = 0;
  seg->verID = 0;
  int size = maxTxns() * sizeof(MonSIDTIDEntry_t);

  if (seg->activeTxns)
    memset(seg->activeTxns, 0, size);
}

void SessionMonitor::initSegment(SessionManagerData_t* seg)
{
  if (!seg)
    return;

  int size = maxTxns() * sizeof(SIDTIDEntry_t);
  seg->txnCount = 0;
  seg->verID = 0;
  memset(seg->activeTxns, 0, size);
}

void SessionMonitor::copyPreviousSegment()
{
  try
  {
    bool loadSuccessful = readMonitorDataFromFile(segmentFilename());

    if (!loadSuccessful)
    {
      saveAsMonitorData(segmentFilename());
      readMonitorDataFromFile(segmentFilename());
    }
  }
  catch (...)
  {
    saveAsMonitorData(segmentFilename());
    readMonitorDataFromFile(segmentFilename());
  }
}

bool SessionMonitor::readMonitorDataFromFile(const std::string filename)
{
  int err = 0;
  uint32_t headerSize = 2 * sizeof(int);
  char* data = reinterpret_cast<char*>(&fPrevSegment);
  int fd = open(filename.c_str(), O_RDONLY);

  if (fd < 0)
  {
    perror("SessionMonitor::readMonitorDataFromFile(): open");
    return false;
  }

  err = read(fd, data, headerSize);

  if (err < 0)
  {
    if (errno != EINTR)
    {
      perror("SessionMonitor::readMonitorDataFromFile(): read");
    }
  }
  else if (err == 0)
  {
    close(fd);
    return false;
  }

  int dataSize = maxTxns() * sizeof(MonSIDTIDEntry_t);
  delete[] fPrevSegment.activeTxns;

  fPrevSegment.activeTxns = new MonSIDTIDEntry[maxTxns()];
  data = reinterpret_cast<char*>(fPrevSegment.activeTxns);
  memset(data, 0, sizeof(MonSIDTIDEntry) * maxTxns());
  err = read(fd, data, dataSize);

  if (err < 0)
  {
    if (errno != EINTR)
    {
      perror("SessionMonitor::readMonitorDataFromFile(): read");
    }
  }
  else if (err == 0)
  {
    close(fd);
    perror("SessionMonitor::readMonitorDataFromFile(): read 0");
    return false;
  }

  close(fd);

  return true;
}

void SessionMonitor::saveAsMonitorData(const std::string)
{
  int fd;
  int err = 0;
  char* data = reinterpret_cast<char*>(&fSessionMonitorData);

  if (!fSessionMonitorData.activeTxns)
  {
    fSessionMonitorData.activeTxns = new MonSIDTIDEntry[maxTxns()];
  }

  initSegment(&fSessionMonitorData);

  // get the most recent SessionManagerData
  copyCurrentSegment();
  fSessionMonitorData.txnCount = fCurrentSegment->txnCount;
  fSessionMonitorData.verID = fCurrentSegment->verID;

  for (int idx = 0; idx < maxTxns(); idx++)
  {
    // is this a new txns or previously existing
    MonSIDTIDEntry* monitor = &fSessionMonitorData.activeTxns[idx];
    MonSIDTIDEntry* prevMonitor = (fPrevSegment.activeTxns ? &fPrevSegment.activeTxns[idx] : NULL);
    SIDTIDEntry* manager = &fCurrentSegment->activeTxns[idx];

    if (prevMonitor)
    {
      if (!isEqualSIDTID(*manager, *prevMonitor))
      {
        monitor->txnid.firstrecord = time(NULL);
      }
      else if (isEqualSIDTID(*manager, *prevMonitor) && isUsed(*prevMonitor))
      {
        if (prevMonitor && prevMonitor->txnid.firstrecord == 0)
          monitor->txnid.firstrecord = time(NULL);
        else
          monitor->txnid.firstrecord = prevMonitor->txnid.firstrecord;
      }
      else if (manager->txnid.valid == false && monitor->txnid.id == manager->txnid.id)
        monitor->txnid.firstrecord = 0;
    }
    else
    {
      if (manager->txnid.valid && manager->txnid.id)
      {
        monitor->txnid.firstrecord = time(NULL);
      }
      else
        monitor->txnid.firstrecord = 0;
    }

    monitor->sessionid = manager->sessionid;
    monitor->txnid.id = manager->txnid.id;
    monitor->txnid.valid = manager->txnid.valid;
  }

  // Always write to a new empty file
  fd = open(segmentFilename(), O_WRONLY | O_CREAT | O_TRUNC, 0666);

  if (fd < 0)
  {
    perror("SessionMonitor::saveAsMonitorData(): open");
    throw ios_base::failure("SessionMonitor::saveAsMonitorData(): open failed.	Check the error log.");
  }

  int headerSize = 2 * (sizeof(int));
  err = write(fd, data, headerSize);

  if (err < 0)
  {
    if (errno != EINTR)
      perror("SessionMonitor::saveAsMonitorData(): write");
  }

  int dataSize = maxTxns() * sizeof(MonSIDTIDEntry);
  data = reinterpret_cast<char*>(fSessionMonitorData.activeTxns);
  err = write(fd, data, dataSize);

  if (err < 0)
  {
    if (errno != EINTR)
      perror("SessionMonitor::saveAsMonitorData(): write");
  }

  close(fd);
}

void SessionMonitor::copyCurrentSegment()
{
  const int cpsize = 4 * sizeof(int) + 2 * sizeof(boost::interprocess::interprocess_semaphore) +
                     maxTxns() * sizeof(SIDTIDEntry);

  delete[] reinterpret_cast<char*>(fCurrentSegment);

  fCurrentSegment = reinterpret_cast<SessionManagerData_t*>(new char[cpsize]);
  lock();
  memcpy(fCurrentSegment, fSessionManagerData, cpsize);
  unlock();
}

bool SessionMonitor::isUsed(const MonSIDTIDEntry& e) const
{
  if (e.sessionid == 0 && e.txnid.id == 0 && e.txnid.valid == false && e.txnid.firstrecord == 0)
    return false;

  return true;
}

bool SessionMonitor::isUsedSIDTID(const SIDTIDEntry& e) const
{
  if (e.sessionid == 0 && e.txnid.id == 0 && e.txnid.valid == false)
    return false;

  return true;
}

bool SessionMonitor::isStaleSIDTID(const SIDTIDEntry& a, const MonSIDTIDEntry& b) const
{
  if (b.txnid.valid && isEqualSIDTID(a, b) && b.txnid.firstrecord &&
      (time(NULL) - b.txnid.firstrecord) > fAgeLimit)
    return true;

  return false;
}

bool SessionMonitor::isEqualSIDTID(const SIDTIDEntry& a, const MonSIDTIDEntry& b) const
{
  if (a.sessionid == b.sessionid && a.txnid.id == b.txnid.id && a.txnid.valid == b.txnid.valid)
    return true;

  return false;
}

vector<SessionMonitor::MonSIDTIDEntry_t*> SessionMonitor::timedOutTxns()
{
  vector<MonSIDTIDEntry_t*> txnsVec;

  copyCurrentSegment();

  if (fCurrentSegment && fPrevSegment.activeTxns != NULL)
  {
    for (int idx = 0; fCurrentSegment->activeTxns && fPrevSegment.activeTxns && idx < maxTxns(); idx++)
    {
      if (isUsedSIDTID(fCurrentSegment->activeTxns[idx]) &&
          isStaleSIDTID(fCurrentSegment->activeTxns[idx], fPrevSegment.activeTxns[idx]))
      {
        txnsVec.push_back(&fPrevSegment.activeTxns[idx]);
      }
    }

    sort(txnsVec.begin(), txnsVec.end(), lessMonSIDTIDEntry());
  }

  return txnsVec;
}

const int SessionMonitor::txnCount() const
{
  return fSessionMonitorData.txnCount;
}

}  // namespace execplan