PingTarget.cpp

Go to the documentation of this file.

// PingTarget.cpp

#include "PingTarget.h"
#include <iomanip>
#include <math.h>
#include <float.h>
#include <sstream>
#include "format_system_time.h"
#include "fit_text.h"
#include "safe_assign.h"
#include "trim_spaces.h"
#include <iostream>
#include <fstream>
#include <sys/stat.h>


PingTarget::PingTarget(PingTargets& targets, const char* name, in_addr inetAddr, long id)
  : m_targets(targets)
{
  safe_assign(m_sName, name);
  m_inetAddr = inetAddr;
  m_lId = id;
  m_bResponseAdded = false;

  m_dCurrent = -1.0;
  m_lReceived = 0;
  m_lSkipped = 0;
  m_dMin = DBL_MAX;
  m_dMax = 0.0;
  m_dSum = 0.0;
  m_dSumSquares = 0.0;
}

const char* PingTarget::GetIpAddr() const
{
  return inet_ntoa(m_inetAddr);
}

USHORT PingTarget::MakeSequence(long sequence) const
{
  return m_targets.MakeSequence(m_lId, sequence);
}

void PingTarget::AddResponseTime(double ms)
{
  m_bResponseAdded = true;
  m_dCurrent = ms;
  if (ms > -1)
  {
    if (ms < m_dMin)
      m_dMin = ms;
    if (ms > m_dMax)
      m_dMax = ms;
    m_dSum += ms;
    m_dSumSquares += ms*ms;
    m_lReceived++;
  }
  else
  {
    m_lSkipped++;
  }
}

void PingTarget::ClearResponseFlag()
{
  m_bResponseAdded = false;
}

double PingTarget::GetMin() const
{
  if (m_lReceived > 0)
    return m_dMin;
  else
    return 0.0;
}

double PingTarget::GetMax() const
{
  if (m_lReceived > 0)
    return m_dMax;
  else
    return 0.0;
}

double PingTarget::GetAvg() const
{
  if (m_lReceived > 0)
  {
    double rec = m_lReceived;
    return m_dSum/rec;
  }
  else
    return 0.0;
}
double PingTarget::GetStdDev() const
{
  if (m_lReceived > 0)
  {
    double avg = GetAvg();
    double rec = m_lReceived;
    double stddev = sqrt(m_dSumSquares / rec - avg*avg);
    return stddev;
  }
  else
    return 0.0;
}

double PingTarget::GetSkippedPercent() const
{
  double total = m_lReceived+m_lSkipped;
  if (total > 0.0)
  {
    double skipped = m_lSkipped;
    return 100.0*skipped/total;
  }
  else
    return 0.0;
}

std::ostream& operator<<(std::ostream& os, const PingTarget& t)
{
  os.precision(6);
  os.unsetf(std::ios::showpoint | std::ios::fixed);
  os << t.GetName() << " (" << t.GetIpAddr() << ") id=" << t.GetId() << std::endl;
  os << "  responses=" << t.GetResponseCount();
  os << " skipped=" << t.GetSkipped();
  os << " (" <<  t.GetSkippedPercent() << "%)";
  os << std::endl;
  os << "  current=";
  if (t.GetCurrent() == -1.0)
    os << "(*)";
  else
    os << t.GetCurrent();
  os << " min=" << t.GetMin();
  os << " avg=" << t.GetAvg() << " max=" << t.GetMax();
  os << " stddev=" << t.GetStdDev();
  return os;
}


PingTargets::PingTargets()
{
  m_lIdBits = 6;
  m_lIdMax = (1 << m_lIdBits) -1;
  m_lSequenceBits = sizeof(USHORT)*8 - m_lIdBits;
  m_uIdMask = (USHORT)(m_lIdMax << m_lSequenceBits);
  m_uSeqMask = m_uIdMask ^ (USHORT)0xffff;
  m_lSequenceMax = m_uSeqMask;
  m_lMaxNameWidth = 0;
}

PingTargets::~PingTargets()
{
  for (const_iterator i = begin(); i != end(); ++i)
    delete *i;
  m_targets.clear();
}

PingTarget* PingTargets::AddTarget(const char* name)
{
  in_addr inetAddr;
  inetAddr.S_un.S_addr = inet_addr(name);
  if (inetAddr.S_un.S_addr == INADDR_NONE)
  {
    hostent* pHost = gethostbyname(name);
    if (pHost && pHost->h_addrtype == AF_INET)
      memcpy(&inetAddr, pHost->h_addr_list[0], pHost->h_length);
  }
  if (inetAddr.S_un.S_addr == INADDR_NONE)
  {
    std::cerr << "Unable to add target. Target " << name << " cannot be resolved." << std::endl;
    return NULL;
  }
  if ((long)m_targets.size() < m_lIdMax)
  {
    PingTarget* pTarget = new PingTarget(*this, name, inetAddr, (long)m_targets.size()+1);
    m_targets.push_back(pTarget);
    m_lMaxNameWidth = max(m_lMaxNameWidth, (long)pTarget->m_sName.size());
    return pTarget;
  }
  else
  {
    std::cerr << "Unable to add target: " << name << std::endl;
    std::cerr << "Maximum target count " << GetMaxTargets() << " would be exceeded." << std::endl;
  }
  return NULL;
}

bool PingTargets::AddTargets(std::istream& is)
{
  bool resolved = true;
  while (is && resolved)
  {
    std::string s;
    std::getline(is, s);
    s = trim_spaces(s.c_str());
    if (!s.empty())
    {
      if (!AddTarget(s.c_str()))
        resolved = false;
    }
  }
  return resolved;
}

bool PingTargets::AddTargets(const char* pszFilename)
{
  std::ifstream is(pszFilename);
  if (is.is_open())
  {
    return AddTargets(is);
  }
  else
  {
    std::cerr << "Unable to open file " << pszFilename << " for reading." << std::endl;
    return false;
  }
}

long PingTargets::GetMaxTargets() const
{
  return m_lIdMax;
}

PingTarget* PingTargets::Get(long id) const
{
  if (id > 0 && id <= (long)size())
    return m_targets[id-1];
  else
    return NULL;
}

bool PingTargets::AddResponse(long id, double ms)
{
  PingTarget* pTarget = Get(id);
  if (pTarget)
  {
    pTarget->AddResponseTime(ms);
    return true;
  }
  return false;
}

void PingTargets::ClearResponseFlags()
{
  for (iterator i = m_targets.begin(); i != m_targets.end(); ++i)
    (*i)->m_bResponseAdded = false;
}

void PingTargets::AddUnreachableResponses()
{
  for (iterator i = m_targets.begin(); i != m_targets.end(); ++i)
  {
    PingTarget& t = **i;
    if (!t.IsResponseAdded())
      t.AddResponseTime();
  }
}

long PingTargets::GetTargetId(USHORT sequence) const
{
  return sequence >> m_lSequenceBits;
}

long PingTargets::GetSequence(USHORT sequence) const
{
  return sequence & m_uSeqMask;
}

USHORT PingTargets::MakeSequence(long lId, long lSequence) const
{
  return (USHORT)((lId << m_lSequenceBits) + lSequence);
}

void PingTargets::PrintStatisticsHeader(std::ostream& os, long lConsoleWidth) const
{
  os << std::setfill(' ') << std::left;
  long lNameWidth = GetMaxNameWidth();
  if (lNameWidth > lConsoleWidth-7*8-1)
    lNameWidth = lConsoleWidth-7*8-1;
  os << std::right;
  os << std::setw(lNameWidth) << " ";
  os << std::setw(8) << "now";
  os << std::setw(8) << "minimum";
  os << std::setw(8) << "average";
  os << std::setw(8) << "maximum";
  os << std::setw(8) << "std.dev";
  os << std::setw(8) << "skipped";
  os << std::setw(8) << "skip%";
}

void PingTargets::PrintStatistics(std::ostream& os, long lConsoleWidth) const
{
  long lNameWidth = GetMaxNameWidth();
  if (lNameWidth > lConsoleWidth-7*8-1)
    lNameWidth = lConsoleWidth-7*8-1;
  os.fill(' ');
  for (PingTargets::const_iterator i = begin(); i != end(); ++i)
  {
    if (i != begin())
      os << std::endl;
    const PingTarget& t = **i;
    os << std::left << std::setw(lNameWidth) << fit_text(t.GetName()) << std::right;
    os.precision(1);
    os.setf(std::ios::showpoint | std::ios::fixed);
    if (t.GetCurrent() == -1.0)
      os << std::setw(8) << "(*)";
    else
      os << std::setw(8) << t.GetCurrent();
    os << std::setw(8) << t.GetMin();
    os << std::setw(8) << t.GetAvg();
    os << std::setw(8) << t.GetMax();
    os << std::setw(8) << t.GetStdDev();
    os << std::setw(8) << t.GetSkipped();
    os << std::setw(8) << t.GetSkippedPercent();
  }
}

void PingTargets::PrintLogHeader(std::ostream& os) const
{
  os << std::left;
  os << "Time/Target";
  for (PingTargets::const_iterator i = begin(); i != end(); ++i)
  {
    const PingTarget& t = **i;
    os << "\t" << t.GetName();
  }
}

void PingTargets::PrintLogCurrent(std::ostream& os, const SYSTEMTIME& systemtime) const
{
  os << std::left;
  os << format_system_time(systemtime, format_system_time::show_seconds);
  os.precision(1);
  os.setf(std::ios::showpoint | std::ios::fixed);
  for (PingTargets::const_iterator i = begin(); i != end(); ++i)
  {
    const PingTarget& t = **i;
    os << "\t" << t.GetCurrent();
  }
}

bool PingTargets::PrintLogCurrent(const char* pszFilename, const SYSTEMTIME& systemtime,
  LOG_FILENAME_TYPE FilenameType, bool bNewFile) const
{
  std::ostringstream osName;
  char path_buffer[_MAX_PATH];
  char drive[_MAX_DRIVE];
  char dir[_MAX_DIR];
  char fname[_MAX_FNAME];
  char ext[_MAX_EXT];
  _splitpath(pszFilename, drive, dir, fname, ext);
  switch(FilenameType)
  {
  case LOG_FILENAME_PLAIN:
  default:
    osName << fname;
    break;
  case LOG_FILENAME_DAILY:
    osName << fname;
    osName << std::setw(4) << std::setfill('0') << systemtime.wYear;
    osName << std::setw(2) << std::setfill('0') << systemtime.wMonth;
    osName << std::setw(2) << std::setfill('0') << systemtime.wDay;
    break;
  case LOG_FILENAME_HOURLY:
    osName << fname;
    osName << std::setw(4) << std::setfill('0') << systemtime.wYear;
    osName << std::setw(2) << std::setfill('0') << systemtime.wMonth;
    osName << std::setw(2) << std::setfill('0') << systemtime.wDay;
    osName << "_";
    osName << std::setw(2) << std::setfill('0') << systemtime.wHour;
    break;
  }
  _makepath(path_buffer, drive, dir, osName.str().c_str(), ext);
  bool bFileExists = false;
  struct _stat st;
  if (_stat(path_buffer, &st) == 0 && st.st_size > 0)
    bFileExists = true;
  std::ofstream os;
  os.imbue(std::locale(""));
  if (bNewFile)
    os.open(path_buffer);
  else
    os.open(path_buffer, std::ios::app);
  if (!os.is_open())
  {
    std::cerr << "Unable to create or open log file " << path_buffer<< std::endl;
    return false;
  }
  if (bNewFile || !bFileExists)
  {
    PrintLogHeader(os);
    os << std::endl;
  }
  PrintLogCurrent(os, systemtime);
  os << std::endl;
  return true;
}

std::ostream& operator<<(std::ostream& os, const PingTargets& targets)
{
  for (PingTargets::const_iterator i = targets.begin(); i != targets.end(); ++i)
    os << **i << std::endl;
  return os;
}

---