14#include <boost/noncopyable.hpp> 
   15#include <boost/shared_ptr.hpp> 
   16#include <boost/multi_index_container.hpp> 
   17#include <boost/multi_index/ordered_index.hpp> 
   18#include <boost/multi_index/sequenced_index.hpp> 
   19#include <boost/multi_index/global_fun.hpp> 
   20#include <boost/multi_index/mem_fun.hpp> 
   21#include <boost/date_time/posix_time/posix_time.hpp> 
   89        return (this_counter);
 
 
 
  161        return(packet->getTransid() & 1023);
 
 
  233    typedef boost::multi_index_container<
 
  237        boost::multi_index::indexed_by<
 
  240            boost::multi_index::sequenced<>,
 
  245            boost::multi_index::ordered_non_unique<
 
  249                boost::multi_index::global_fun<
 
  264    typedef typename PktList::template nth_index<1>::type
 
  267    typedef typename PktListTransidHashIndex::const_iterator
 
  270    typedef typename std::queue<PktListTransidHashIterator>
 
  282                  const double drop_time,
 
  283                  const bool archive_enabled,
 
  284                  const boost::posix_time::ptime boot_time);
 
  296        static_cast<void>(sent_packets_.template 
get<0>().push_back(packet));
 
 
  310        static_cast<void>(rcvd_packets_.push_back(packet));
 
 
  366        if (rcvd_packets_num_  == 0) {
 
  369        return(sum_delay_ / rcvd_packets_num_);
 
 
  383        if (rcvd_packets_num_ == 0) {
 
  386        return(sqrt(sum_delay_squared_ / rcvd_packets_num_ -
 
 
  420        if (unordered_lookups_ == 0) {
 
  423        return(
static_cast<double>(unordered_lookup_size_sum_) /
 
  424               static_cast<double>(unordered_lookups_));
 
 
  516        double drops_ratio = 100.0 * 
static_cast<double>(drops) / 
static_cast<double>(sent);
 
  518        cout << 
"sent packets: " << sent << endl
 
  520             << 
"drops: " << drops << endl
 
  521             << 
"drops ratio: " << drops_ratio << 
" %" << endl
 
 
  537        auto flags(cout.flags());
 
  539            cout << fixed << setprecision(3)
 
  540                 << 
"min delay: " << 
getMinDelay() * 1e3 << 
" ms" << endl
 
  541                 << 
"avg delay: " << 
getAvgDelay() * 1e3 << 
" ms" << endl
 
  542                 << 
"max delay: " << 
getMaxDelay() * 1e3 << 
" ms" << endl
 
  548            cout << 
"min delay: n/a" << endl
 
  549                 << 
"avg delay: n/a" << endl
 
  550                 << 
"max delay: n/a" << endl
 
  551                 << 
"std deviation: n/a" << endl
 
  552                 << 
"collected packets: 0" << endl;
 
 
  571        return(std::make_tuple(sent_packets_.begin(), sent_packets_.end()));
 
 
  606        if (archive_enabled_) {
 
  613            static_cast<void>(archived_packets_.push_back(*it));
 
  617        return(sent_packets_.template 
get<0>().erase(it));
 
  646    bool archive_enabled_;
 
  658    double sum_delay_squared_;     
 
  670    uint64_t unordered_lookup_size_sum_;
 
  672    uint64_t unordered_lookups_;   
 
  674    uint64_t ordered_lookups_;     
 
  677    uint64_t sent_packets_num_;    
 
  678    uint64_t rcvd_packets_num_;    
 
  680    uint64_t non_unique_addr_num_; 
 
  682    uint64_t rejected_leases_num_; 
 
  684    boost::posix_time::ptime boot_time_; 
 
 
  737                          const double drop_time = -1) {
 
  738        if (exchanges_.find(xchg_type) != exchanges_.end()) {
 
  741        exchanges_[xchg_type] =
 
 
  759        return (exchanges_.find(xchg_type) != exchanges_.end());
 
 
  770                          const std::string& long_name) {
 
  771        if (custom_counters_.find(short_name) != custom_counters_.end()) {
 
  773                      "Custom counter " << short_name << 
" already added.");
 
  775        custom_counters_[short_name] =
 
 
  783        for (
auto const& it : exchanges_) {
 
  784            if (it.second->getDroppedPacketsNum() > 0) {
 
 
  800        if (it == custom_counters_.end()) {
 
  802                      "Custom counter " << counter_key << 
"does not exist");
 
 
  815                                          const uint64_t value = 1) {
 
 
  834        xchg_stats->appendSent(packet);
 
 
  854        dhcp::PktPtr sent_packet = xchg_stats->matchPackets(packet);
 
  857            xchg_stats->updateDelays(sent_packet, packet);
 
  858            if (archive_enabled_) {
 
  859                xchg_stats->appendRcvd(packet);
 
 
  875        return(xchg_stats->getMinDelay());
 
 
  888        return(xchg_stats->getMaxDelay());
 
 
  899        return(xchg_stats->getAvgDelay());
 
 
  910        return(xchg_stats->getStdDevDelay());
 
 
  923        return(xchg_stats->getOrphans());
 
 
  937        return(xchg_stats->getAvgUnorderedLookupSetSize());
 
 
  952        return(xchg_stats->getUnorderedLookups());
 
 
  968        return(xchg_stats->getOrderedLookups());
 
 
  981        return(xchg_stats->getSentPacketsNum());
 
 
  994        return(xchg_stats->getRcvdPacketsNum());
 
 
 1007        return(xchg_stats->getDroppedPacketsNum());
 
 
 1022        return(xchg_stats->getCollectedNum());
 
 
 1035        return(xchg_stats->getRejLeasesNum());
 
 
 1044        xchg_stats->updateRejLeases();
 
 
 1053        xchg_stats->updateNonUniqueAddr();
 
 
 1066        return(xchg_stats->getNonUniqueAddrNum());
 
 
 1077        using namespace boost::posix_time;
 
 1078        time_period test_period(boot_time_,
 
 1079                                microsec_clock::universal_time());
 
 
 1097        if (exchanges_.empty()) {
 
 1099                      "no exchange type added for tracking");
 
 1101        for (
auto const& it : exchanges_) {
 
 1103            std::cout << 
"***Statistics for: " << it.first
 
 1104                      << 
"***" << std::endl;
 
 1105            xchg_stats->printMainStats();
 
 1106            std::cout << std::endl;
 
 1107            xchg_stats->printRTTStats();
 
 1108            std::cout << std::endl;
 
 
 1122        std::ostringstream stream_sent;
 
 1123        std::ostringstream stream_rcvd;
 
 1124        std::ostringstream stream_drops;
 
 1125        std::ostringstream stream_reject;
 
 1126        std::string sep(
"");
 
 1128        for (
auto const& it : exchanges_) {
 
 1138            stream_sent << sep << it.second->getSentPacketsNum();
 
 1139            stream_rcvd << sep << it.second->getRcvdPacketsNum();
 
 1140            stream_drops << sep << it.second->getDroppedPacketsNum();
 
 1141            stream_reject << sep << it.second->getRejLeasesNum();
 
 1145            std::cout << stream_sent.str()
 
 1146                      << clean_sep << stream_rcvd.str()
 
 1147                      << clean_sep << stream_drops.str()
 
 1148                      << clean_sep << stream_reject.str()
 
 1152            std::cout << 
"sent: " << stream_sent.str()
 
 1153                      << 
"; received: " << stream_rcvd.str()
 
 1154                      << 
"; drops: " << stream_drops.str()
 
 1155                      << 
"; rejected: " << stream_reject.str()
 
 
 1172        if (exchanges_.empty()) {
 
 1174                      "no exchange type added for tracking");
 
 1176        for (
auto const& it : exchanges_) {
 
 1178            std::cout << 
"***Timestamps for packets: " 
 1180                      << 
"***" << std::endl;
 
 1181            xchg_stats->printTimestamps();
 
 1182            std::cout << std::endl;
 
 
 1196        if (custom_counters_.empty()) {
 
 1199        for (
auto const& it : custom_counters_) {
 
 1201            std::cout << counter->getName() << 
": " << counter->getValue()
 
 
 1206    std::tuple<typename ExchangeStats::PktListIterator, typename ExchangeStats::PktListIterator>
 
 1209        std::tuple<typename ExchangeStats::PktListIterator, typename ExchangeStats::PktListIterator> sent_packets_its =
 
 1210                xchg_stats->getSentPackets();
 
 1211        return (sent_packets_its);
 
 
 1225        if (it == exchanges_.end()) {
 
 1243    bool archive_enabled_;
 
 1245    boost::posix_time::ptime boot_time_; 
 
 
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
This is a base class for exceptions thrown from the DNS library module.
A generic exception that is thrown if a function is called in a prohibited way.
const CustomCounter & operator+=(int val)
const CustomCounter & operator++(int)
Increment operator.
const CustomCounter & operator++()
Increment operator.
const std::string & getName() const
Return counter name.
CustomCounter(const std::string &name)
Constructor.
uint64_t getValue() const
Return counter value.
std::tuple< PktListIterator, PktListIterator > getSentPackets()
PktList::iterator PktListIterator
Packet list iterator for sequential access to elements.
double getAvgUnorderedLookupSetSize() const
Return average unordered lookup set size.
static int malformed_pkts_
void updateRejLeases()
Increase number of rejected leases.
void printMainStats() const
Print main statistics for packet exchange.
static uint32_t hashTransid(const dhcp::PktPtr &packet)
Hash transaction id of the packet.
PktListTransidHashIndex::const_iterator PktListTransidHashIterator
Packet list iterator to access packets using transaction id hash.
std::queue< PktListTransidHashIterator > PktListRemovalQueue
Packet list iterator queue for removal.
uint64_t getDroppedPacketsNum() const
Return number of dropped packets.
double getAvgDelay() const
Return average packet delay.
uint64_t getUnorderedLookups() const
Return number of unordered sent packets lookups.
uint64_t getOrphans() const
Return number of orphan packets.
std::string receivedLeases() const
Return the list of received leases in CSV format as string.
uint64_t getRcvdPacketsNum() const
Return total number of received packets.
void appendSent(const dhcp::PktPtr &packet)
Add new packet to list of sent packets.
uint64_t getCollectedNum() const
Return number of garbage collected packets.
uint64_t getSentPacketsNum() const
Return total number of sent packets.
ExchangeStats(const ExchangeType xchg_type, const double drop_time, const bool archive_enabled, const boost::posix_time::ptime boot_time)
Constructor.
double getStdDevDelay() const
Return standard deviation of packet delay.
void updateNonUniqueAddr()
Increase number of non unique addresses.
void appendRcvd(const dhcp::PktPtr &packet)
Add new packet to list of received packets.
uint64_t getOrderedLookups() const
Return number of ordered sent packets lookups.
double getMinDelay() const
Return minimum delay between sent and received packet.
PktList::template nth_index< 1 >::type PktListTransidHashIndex
Packet list index to search packets using transaction id hash.
void printLeases() const
Print the list of received leases.
boost::multi_index_container< dhcp::PktPtr, boost::multi_index::indexed_by< boost::multi_index::sequenced<>, boost::multi_index::ordered_non_unique< boost::multi_index::global_fun< const dhcp::PktPtr &, uint32_t, &ExchangeStats::hashTransid > > > > PktList
List of packets (sent or received).
void printTimestamps()
Print timestamps for sent and received packets.
void printRTTStats() const
Print round trip time packets statistics.
dhcp::PktPtr matchPackets(const dhcp::PktPtr &rcvd_packet)
Match received packet with the corresponding sent packet.
uint64_t getRejLeasesNum() const
Return total number of rejected leases.
uint64_t getNonUniqueAddrNum() const
Return total number of non unique addresses.
double getMaxDelay() const
Return maximum delay between sent and received packet.
void updateDelays(const dhcp::PktPtr &sent_packet, const dhcp::PktPtr &rcvd_packet)
Update delay counters.
void addCustomCounter(const std::string &short_name, const std::string &long_name)
Add named custom uint64 counter.
std::tuple< typename ExchangeStats::PktListIterator, typename ExchangeStats::PktListIterator > getSentPackets(const ExchangeType xchg_type) const
void updateRejLeases(const ExchangeType xchg_type)
Increase total number of rejected leases.
void printStats() const
Print statistics counters for all exchange types.
void printLeases() const
Delegate to all exchanges to print their leases.
double getAvgDelay(const ExchangeType xchg_type) const
Return average packet delay.
void printCustomCounters() const
Print names and values of custom counters.
uint64_t getDroppedPacketsNum(const ExchangeType xchg_type) const
Return total number of dropped packets.
const CustomCounter & incrementCounter(const std::string &counter_key, const uint64_t value=1)
Increment specified counter.
void printTimestamps() const
Print timestamps of all packets.
double getAvgUnorderedLookupSetSize(const ExchangeType xchg_type) const
Return average unordered lookup set size.
void updateNonUniqueAddrNum(const ExchangeType xchg_type)
Increase total number of non unique addresses.
CustomCounterPtr getCounter(const std::string &counter_key)
Return specified counter.
uint64_t getRcvdPacketsNum(const ExchangeType xchg_type) const
Return total number of received packets.
uint64_t getSentPacketsNum(const ExchangeType xchg_type) const
Return total number of sent packets.
uint64_t getCollectedNum(const ExchangeType xchg_type) const
Return number of garbage collected packets.
bool hasExchangeStats(const ExchangeType xchg_type) const
Check if the exchange type has been specified.
StatsMgr(CommandOptions &options)
Constructor.
void printIntermediateStats(bool clean_report, std::string clean_sep) const
Print intermediate statistics.
boost::posix_time::time_period getTestPeriod() const
Get time period since the start of test.
uint64_t getOrphans(const ExchangeType xchg_type) const
Return number of orphan packets.
bool droppedPackets() const
Check if any packet drops occurred.
void passSentPacket(const ExchangeType xchg_type, const dhcp::PktPtr &packet)
Adds new packet to the sent packets list.
dhcp::PktPtr passRcvdPacket(const ExchangeType xchg_type, const dhcp::PktPtr &packet)
Add new received packet and match with sent packet.
double getMinDelay(const ExchangeType xchg_type) const
Return minimum delay between sent and received packet.
double getMaxDelay(const ExchangeType xchg_type) const
Return maximum delay between sent and received packet.
uint64_t getOrderedLookups(const ExchangeType xchg_type) const
Return number of ordered sent packets lookups.
uint64_t getRejLeasesNum(const ExchangeType xchg_type) const
Return total number of rejected leases.
void addExchangeStats(const ExchangeType xchg_type, const double drop_time=-1)
Specify new exchange type.
uint64_t getNonUniqueAddrNum(const ExchangeType xchg_type) const
Return total number of non unique addresses.
uint64_t getUnorderedLookups(const ExchangeType xchg_type) const
Return number of unordered sent packets lookups.
double getStdDevDelay(const ExchangeType xchg_type) const
Return standard deviation of packet delay.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
int get(CalloutHandle &handle)
The gss-tsig-get command.
boost::shared_ptr< isc::dhcp::Pkt > PktPtr
A pointer to either Pkt4 or Pkt6 packet.
ExchangesMap::const_iterator ExchangesMapIterator
Iterator pointing to ExchangesMap.
boost::shared_ptr< StatsMgr > StatsMgrPtr
Pointer to Statistics Manager;.
CustomCountersMap::const_iterator CustomCountersMapIterator
Iterator for CustomCountersMap.
std::map< ExchangeType, ExchangeStatsPtr > ExchangesMap
Map containing all specified exchange types.
boost::shared_ptr< ExchangeStats > ExchangeStatsPtr
Pointer to ExchangeStats.
int dhcpVersion(ExchangeType const exchange_type)
Get the DHCP version that fits the exchange type.
ExchangeType
DHCP packet exchange types.
@ SA
DHCPv6 SOLICIT-ADVERTISE.
@ RNA
DHCPv4 REQUEST-ACK (renewal)
@ RL
DHCPv6 RELEASE-REPLY.
@ DO
DHCPv4 DISCOVER-OFFER.
@ RR
DHCPv6 REQUEST-REPLY.
std::map< std::string, CustomCounterPtr > CustomCountersMap
Map containing custom counters.
boost::shared_ptr< CustomCounter > CustomCounterPtr
std::ostream & operator<<(std::ostream &os, ExchangeType xchg_type)
Return name of the exchange.
Defines the logger used by the top-level component of kea-lfc.