mf::service::ELadministrator Class Reference

#include <ELadministrator.h>

Public Types
using	destination_collection_t = std::map< std::string, cet::propagate_const< std::unique_ptr< ELdestination >>>

Public Member Functions
void	log (ErrorObj &msg)
	ELadministrator (ELadministrator const &)=delete
ELadministrator &	operator= (ELadministrator const &)=delete
	ELadministrator (ELadministrator &&)=delete
ELadministrator &	operator= (ELadministrator &&)=delete
void	setApplication (std::string const &application)
void	setHighSeverity (ELseverityLevel const sev)
destination_collection_t const &	destinations () const
destination_collection_t &	destinations ()
bool	hasDestination (std::string const &) const
ELseverityLevel	checkSeverity ()
int	severityCount (ELseverityLevel sev) const
int	severityCount (ELseverityLevel from, ELseverityLevel to) const
void	resetSeverityCount (ELseverityLevel sev)
void	resetSeverityCount (ELseverityLevel from, ELseverityLevel to)
void	resetSeverityCount ()
void	finish ()
std::string const &	application () const
ELseverityLevel	abortThreshold () const
ELseverityLevel	exitThreshold () const
ELseverityLevel	highSeverity () const
std::string const &	hostname () const
std::string const &	hostaddr () const
long	pid () const
void	incrementSeverityCount (int const sev)
template<typename DEST >
std::enable_if_t< std::is_base_of< ELdestination, DEST >::value, ELdestination & >	attach (std::string const &outputId, std::unique_ptr< DEST > &&dest)

Private Member Functions
	ELadministrator (std::string const &applicationName)
void	updateMsg_ (ErrorObj &msg) const
template<typename F >
void	for_all_destinations (F f)

Private Attributes
std::array< int, ELseverityLevel::nLevels >	severityCounts_
ELseverityLevel	highSeverity_ {ELseverityLevel::ELsev_zeroSeverity}
std::string	hostname_ {}
std::string	hostaddr_ {}
std::string	application_ {}
long	pid_ {}
destination_collection_t	destinations_ {}

Detailed Description

Definition at line 32 of file ELadministrator.h.

Member Typedef Documentation

using mf::service::ELadministrator::destination_collection_t = std::map<std::string, cet::propagate_const<std::unique_ptr<ELdestination>>>

Definition at line 37 of file ELadministrator.h.

Constructor & Destructor Documentation

mf::service::ELadministrator::ELadministrator ( ELadministrator const &  )

delete

mf::service::ELadministrator::ELadministrator ( ELadministrator &&  )

delete

mf::service::ELadministrator::ELadministrator ( std::string const &  applicationName )

private

Definition at line 104 of file ELadministrator.cc.

{
  // hostname
  char hostname[1024];
  hostname_ = (gethostname(hostname, 1023) == 0) ? hostname : "Unkonwn Host";

  // host ip address
  hostent* host = nullptr;
  host = gethostbyname(hostname);

  if (host != nullptr) {
    // ip address from hostname if the entry exists in /etc/hosts
    char* ip = inet_ntoa(*(struct in_addr*)host->h_addr);
    hostaddr_ = ip;
  } else {
    // enumerate all network interfaces
    struct ifaddrs* ifAddrStruct = nullptr;
    struct ifaddrs* ifa = nullptr;
    void* tmpAddrPtr = nullptr;

    if (getifaddrs(&ifAddrStruct)) {
      // failed to get addr struct
      hostaddr_ = "127.0.0.1";
    } else {
      // iterate through all interfaces
      for (ifa = ifAddrStruct; ifa != nullptr; ifa = ifa->ifa_next) {
        if (ifa->ifa_addr->sa_family == AF_INET) {
          // a valid IPv4 addres
          tmpAddrPtr = &((struct sockaddr_in*)ifa->ifa_addr)->sin_addr;
          char addressBuffer[INET_ADDRSTRLEN];
          inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN);
          hostaddr_ = addressBuffer;
        } else if (ifa->ifa_addr->sa_family == AF_INET6) {
          // a valid IPv6 address
          tmpAddrPtr = &((struct sockaddr_in6*)ifa->ifa_addr)->sin6_addr;
          char addressBuffer[INET6_ADDRSTRLEN];
          inet_ntop(AF_INET6, tmpAddrPtr, addressBuffer, INET6_ADDRSTRLEN);
          hostaddr_ = addressBuffer;
        }

        // find first non-local address
        if (!hostaddr_.empty() && hostaddr_.compare("127.0.0.1") &&
            hostaddr_.compare("::1"))
          break;
      }

      if (hostaddr_.empty()) // failed to find anything
        hostaddr_ = "127.0.0.1";
    }
  }

  // process id
  pid_ = static_cast<long>(getpid());

  if (applicationName.empty()) {
    // get process name from '/proc/pid/cmdline'
    std::stringstream ss;
    ss << "//proc//" << pid_ << "//cmdline";
    std::ifstream procfile{ss.str().c_str()};

    std::string procinfo;

    if (procfile.is_open()) {
      procfile >> procinfo;
      procfile.close();
    }

    size_t end = procinfo.find('\0');
    size_t start = procinfo.find_last_of('/', end);

    application_ = procinfo.substr(start + 1, end - start - 1);
  } else {
    application_ = applicationName;
  }
} // ELadministrator()

Member Function Documentation

ELseverityLevel mf::service::ELadministrator::abortThreshold

(

)

const

std::string const & mf::service::ELadministrator::application ( ) const

inline

Definition at line 150 of file ELadministrator.h.

{
  return application_;
}

template<typename DEST >

std::enable_if_t<std::is_base_of<ELdestination, DEST>::value, ELdestination&> mf::service::ELadministrator::attach ( std::string const &  outputId, std::unique_ptr< DEST > &&  dest  )

inline

Definition at line 92 of file ELadministrator.h.

  {
    return *(destinations_[outputId] = std::move(dest));
    // If you don't like the above, an alternative is something equivalent to:
    //   return *destinations_.emplace(outputId, std::move(dest)).first->second;
  }

mf::ELseverityLevel mf::service::ELadministrator::checkSeverity

(

)

Definition at line 58 of file ELadministrator.cc.

{
  ELseverityLevel const retval{highSeverity_};
  highSeverity_ = ELzeroSeverity;
  return retval;
}

auto mf::service::ELadministrator::destinations ( ) const

inline

Definition at line 125 of file ELadministrator.h.

{
  return destinations_;
}

auto mf::service::ELadministrator::destinations ( )

inline

Definition at line 132 of file ELadministrator.h.

{
  return destinations_;
}

ELseverityLevel mf::service::ELadministrator::exitThreshold

(

)

const

void mf::service::ELadministrator::finish ( )

inline

Definition at line 168 of file ELadministrator.h.

{
  for_all_destinations([](auto& d) { d.finish(); });
}

template<typename F >

void mf::service::ELadministrator::for_all_destinations ( F  f )

inlineprivate

Definition at line 116 of file ELadministrator.h.

  {
    for (auto& pr : destinations_)
      f(*pr.second);
  }

bool mf::service::ELadministrator::hasDestination

(

std::string const &

name

)

const

Definition at line 52 of file ELadministrator.cc.

{
  return destinations_.find(name) != destinations_.end();
}

mf::ELseverityLevel mf::service::ELadministrator::highSeverity ( ) const

inline

Definition at line 162 of file ELadministrator.h.

{
  return highSeverity_;
}

std::string const & mf::service::ELadministrator::hostaddr ( ) const

inline

Definition at line 144 of file ELadministrator.h.

{
  return hostaddr_;
}

std::string const & mf::service::ELadministrator::hostname ( ) const

inline

Definition at line 138 of file ELadministrator.h.

{
  return hostname_;
}

void mf::service::ELadministrator::incrementSeverityCount ( int const  sev )

inline

Definition at line 83 of file ELadministrator.h.

  {
    ++severityCounts_[sev];
  }

void mf::service::ELadministrator::log

(

ErrorObj &

msg

)

Definition at line 19 of file ELadministrator.cc.

{
  auto const severity = msg.xid().severity();
  updateMsg_(msg);
  int const lev = severity.getLevel();
  ++severityCounts_[lev];
  if (severity > highSeverity_)
    highSeverity_ = severity;

  if (destinations_.empty()) {
    std::cerr
      << "\nERROR LOGGED WITHOUT DESTINATION!\n"
      << "Attaching destination \"cerr\" to ELadministrator by default\n\n";
    destinations_.emplace(
      "cerr",
      std::make_unique<ELostreamOutput>(default_destinations_config(),
                                        cet::ostream_handle{std::cerr}));
  }

  for_all_destinations([&msg](auto& d) { d.log(msg); });
}

ELadministrator& mf::service::ELadministrator::operator= ( ELadministrator const &  )

delete

ELadministrator& mf::service::ELadministrator::operator= ( ELadministrator &&  )

delete

long mf::service::ELadministrator::pid ( ) const

inline

Definition at line 156 of file ELadministrator.h.

{
  return pid_;
}

void mf::service::ELadministrator::resetSeverityCount

(

ELseverityLevel

sev

)

Definition at line 85 of file ELadministrator.cc.

{
  severityCounts_[sev.getLevel()] = 0;
}

void mf::service::ELadministrator::resetSeverityCount	(	ELseverityLevel	from,
		ELseverityLevel	to
	)

Definition at line 91 of file ELadministrator.cc.

{
  for (int k = from.getLevel(); k <= to.getLevel(); ++k)
    severityCounts_[k] = 0;
}

void mf::service::ELadministrator::resetSeverityCount

(

)

Definition at line 99 of file ELadministrator.cc.

{
  resetSeverityCount(ELzeroSeverity, ELhighestSeverity);
}

void mf::service::ELadministrator::setApplication

(

std::string const &

application

)

Definition at line 46 of file ELadministrator.cc.

{
  application_ = application;
}

void mf::service::ELadministrator::setHighSeverity ( ELseverityLevel const  sev )

inline

Definition at line 51 of file ELadministrator.h.

  {
    highSeverity_ = sev;
  }

int mf::service::ELadministrator::severityCount

(

ELseverityLevel

sev

)

const

Definition at line 66 of file ELadministrator.cc.

{
  return severityCounts_[sev.getLevel()];
}

int mf::service::ELadministrator::severityCount	(	ELseverityLevel	from,
		ELseverityLevel	to
	)		const

Definition at line 72 of file ELadministrator.cc.

{
  int k = from.getLevel();
  int sum = severityCounts_[k];

  while (++k <= to.getLevel())
    sum += severityCounts_[k];

  return sum;
}

void mf::service::ELadministrator::updateMsg_ ( ErrorObj &  msg ) const

private

Definition at line 182 of file ELadministrator.cc.

{
  auto const& xid = msg.xid();
  if (xid.hostname().empty()) {
    msg.setHostName(hostname());
  }
  if (xid.hostaddr().empty()) {
    msg.setHostAddr(hostaddr());
  }
  if (xid.application().empty()) {
    msg.setApplication(application());
  }
  if (xid.pid() == 0) {
    msg.setPID(pid());
  }
}

Member Data Documentation

std::string mf::service::ELadministrator::application_ {}

private

Definition at line 109 of file ELadministrator.h.

destination_collection_t mf::service::ELadministrator::destinations_ {}

private

Definition at line 112 of file ELadministrator.h.

ELseverityLevel mf::service::ELadministrator::highSeverity_ {ELseverityLevel::ELsev_zeroSeverity}

private

Definition at line 104 of file ELadministrator.h.

std::string mf::service::ELadministrator::hostaddr_ {}

private

Definition at line 108 of file ELadministrator.h.

std::string mf::service::ELadministrator::hostname_ {}

private

Definition at line 107 of file ELadministrator.h.

long mf::service::ELadministrator::pid_ {}

private

Definition at line 110 of file ELadministrator.h.

std::array<int, ELseverityLevel::nLevels> mf::service::ELadministrator::severityCounts_

private

Initial value:

{
    {0}}

Definition at line 102 of file ELadministrator.h.

---

The documentation for this class was generated from the following files:

• messagefacility/messagefacility/MessageService/ELadministrator.h
• messagefacility/messagefacility/MessageService/ELadministrator.cc