refactored cql recount leases plus minor changes

src/bin/perfdhcp/command_options.cc

@@ -370,9 +370,8 @@ CommandOptions::initialize(int argc, char** argv, bool print_cmd_line) {
             break;
 
         case 'W':
-            // 'm' for moratorium
             exit_wait_time_ = nonNegativeInteger("value of exist wait time: "
-                                                  "-m<value> must not be a "
+                                                  "-W<value> must not be a "
                                                   "negative integer");
             break;
 
@@ -989,7 +988,7 @@ CommandOptions::usage() const {
         "         [-n<num-request>] [-p<test-period>] [-d<drop-time>]\n"
         "         [-D<max-drop>] [-l<local-addr|interface>] [-P<preload>]\n"
         "         [-a<aggressivity>] [-L<local-port>] [-s<seed>] [-i] [-B]\n"
-        "         [-m<late-exit-delay>]\n"
+        "         [-W<late-exit-delay>]\n"
         "         [-c] [-1] [-M<mac-list-file>] [-T<template-file>]\n"
         "         [-X<xid-offset>] [-O<random-offset] [-E<time-offset>]\n"
         "         [-S<srvid-offset>] [-I<ip-offset>] [-x<diagnostic-selector>]\n"

src/lib/config/base_command_mgr.cc

@@ -172,7 +172,7 @@ BaseCommandMgr::handleCommand(const std::string& cmd_name,
 }
 
 isc::data::ConstElementPtr
-BaseCommandMgr::listCommandsHandler(const std::string& name,
+BaseCommandMgr::listCommandsHandler(const std::string& /* name */,
                                     const isc::data::ConstElementPtr& ) {
     using namespace isc::data;
     ElementPtr commands = Element::createList();

src/lib/dhcpsrv/benchmarks/benchmarks.dox

@@ -23,7 +23,7 @@ $ make
 The benchmarks are built in @b src/lib/dhcpsrv/benchmarks directory.
 Note that the benchmarks are backend-specific, so please make sure you
 enable the backends you want to measure (See --with-mysql,
---with-pgsql --with-cql parameters for configure). Once the
+--with-pgsql, --with-cql parameters for configure). Once the
 benchmark is built, you can run specific benchmarks. Make sure you
 have the environment ready for use, i.e. the actual database backend
 is set up, the DB or keyspace is created. The setup is the same as for

src/lib/dhcpsrv/cql_host_data_source.cc

@@ -898,10 +898,10 @@ CqlHostExchange::retrieve() {
     asiolink::IOAddress ipv4_reservation =
         asiolink::IOAddress(static_cast<uint32_t>(host_ipv4_address_));
 
-    Host* host = new Host(host_identifier.data(), host_identifier.size(),
+    HostPtr host(new Host(host_identifier.data(), host_identifier.size(),
                           host_identifier_type, ipv4_subnet_id, ipv6_subnet_id,
                           ipv4_reservation, hostname_,
-                          host_ipv4_client_classes_, host_ipv6_client_classes_);
+                          host_ipv4_client_classes_, host_ipv6_client_classes_));
     host->setHostId(id);
 
     const IPv6Resrv reservation = retrieveReservation();
@@ -1702,7 +1702,7 @@ CqlHostDataSourceImpl::getHostCollection(StatementTag statement_tag,
     // Form HostPtr objects.
     HostCollection host_collection;
     for (boost::any& host : collection) {
-        host_collection.push_back(HostPtr(boost::any_cast<Host*>(host)));
+        host_collection.push_back(boost::any_cast<HostPtr>(host));
     }
 
     // Merge the denormalized table entries that belong to the same host

src/lib/dhcpsrv/cql_lease_mgr.cc

@@ -1437,19 +1437,19 @@ CqlLease6Exchange::getExpiredLeases(const size_t &max_leases,
 /// This class provides the functionality such as results storage and row
 /// fetching common to fulfilling the statistical lease data query.
 ///
-class CqlLeaseStatsQuery : public LeaseStatsQuery {
+class CqlLeaseStatsQuery : public LeaseStatsQuery, public CqlExchange {
 public:
     /// @brief Constructor
     ///
     /// @param conn An open connection to the database housing the lease data
     /// @param statement The lease data SQL prepared statement tag to execute
     /// @param fetch_type Indicates whether or not lease_type should be
     /// fetched from the result set (should be true for v6)
-    CqlLeaseStatsQuery(CqlConnection& conn, StatementTag& statement,
-                         const bool fetch_type)
-        : conn_(conn), statement_(statement), fetch_type_(fetch_type),
+    CqlLeaseStatsQuery(CqlConnection& connection, StatementTag& statement,
+                       const bool fetch_type)
+        : connection_(connection), statement_(statement), fetch_type_(fetch_type),
           cummulative_rows_(), next_row_(cummulative_rows_.begin()),
-          subnet_id_(0), lease_type_(0), lease_state_(0) {
+          subnet_id_(0), lease_type_(0), state_(0) {
     }
 
     /// @brief Destructor
@@ -1463,35 +1463,6 @@ class CqlLeaseStatsQuery : public LeaseStatsQuery {
     /// first row of the aggregate results.
     void start();
 
-    /// @brief Executes protocol specific lease query SELECT statement
-    ///
-    /// Currently we do not have a good way for Cassandra to roll up the
-    /// lease counts per subnet, type, and state as we do the other back
-    /// ends.  This method executes the select statement which returns
-    /// a result set containing a row of data for every lease:
-    /// -v4 - subnet-id, lease-state
-    /// -v6 - subnet-id, lease-type, lease-state
-    ///
-    /// It then iterates over this result set, aggregating the data into a
-    /// a map of LeaseStatRows.
-    ///
-    /// If we didn't have to roll up the raw lease data first, we could
-    /// have derived this class from CqlExchange and used it's executeSelect
-    /// (from which this method borrows heavily). However, that would mean
-    /// copying all the raw lease  data into a collection returned by
-    /// executeSelect and then aggregating that into cummulative rows.
-    /// The way we are now we go turn the raw lease data directly into the
-    /// cummulative row map.
-    ///
-    /// @param connection connection used to communicate with the Cassandra
-    /// database
-    /// @param where_values array of bound objects used to filter the results
-    /// @param statement_tag prepared statement being executed
-    ///
-    /// @throw DbOperationError
-    void executeSelect(const CqlConnection& connection, const AnyArray& data,
-                       StatementTag statement_tag);
-
     /// @brief Fetches the next row in the result set
     ///
     /// Once the internal result set has been populated by invoking the
@@ -1515,6 +1486,15 @@ class CqlLeaseStatsQuery : public LeaseStatsQuery {
     virtual void
     createBindForSelect(AnyArray& data, StatementTag statement_tag = NULL);
 
+    /// @brief Copy received data into the derived class' object.
+    ///
+    /// Copies information about the entity to be retrieved into a holistic
+    /// object. Called in @ref executeSelect(). Not implemented for base class
+    /// CqlExchange. To be implemented in derived classes.
+    ///
+    /// @return a pointer to the object retrieved.
+    virtual boost::any retrieve();
+
     /// @brief Statement tags definitions
     /// @{
     // Return recalculated lease4 lease statistics
@@ -1527,28 +1507,29 @@ class CqlLeaseStatsQuery : public LeaseStatsQuery {
     static StatementMap tagged_statements_;
 
 private:
-    /// @brief Database connection to use to execute the query
-    CqlConnection& conn_;
+    /// @brief Database connection
+    const CqlConnection &connection_;
 
     /// @brief The query's prepared statement tag
     StatementTag statement_;
 
     /// @brief Indicates if query supplies lease type
     bool fetch_type_;
 
-
     /// @brief map containing the aggregated lease counts
     std::map<LeaseStatsRow, int> cummulative_rows_;
 
     /// @brief cursor pointing to the next row to read in aggregate map
     std::map<LeaseStatsRow, int>::iterator next_row_;
 
-    /// @brief bind variable for retrieving subnet-id from a result set row
-    int subnet_id_;
-    /// @brief bind variable for retrieving lease-type from a result set row
-    int lease_type_;
-    /// @brief bind variable for retrieving lease-state from a result set row
-    int lease_state_;
+    /// @brief Subnet identifier
+    cass_int32_t subnet_id_;
+
+    /// @brief Lease type (NA, TA or PD)
+    cass_int32_t lease_type_;
+
+    /// @brief Lease state
+    cass_int32_t state_;
 };
 
 constexpr StatementTag CqlLeaseStatsQuery::RECOUNT_LEASE4_STATS;
@@ -1578,7 +1559,20 @@ CqlLeaseStatsQuery::start() {
 
     // This gets a collection of data for ALL leases, and
     // then rolls them up into cummulative_rows_
-    executeSelect(conn_, data, statement_);
+    AnyArray collection = executeSelect(connection_, data, statement_);
+
+    // Form LeaseStatsRowPtr objects.
+    LeaseStatsCollection stats_collection;
+    for (boost::any& stats : collection) {
+        LeaseStatsRowPtr data(boost::any_cast<LeaseStatsRowPtr>(stats));
+        stats_collection.push_back(data);
+        auto cum_row = cummulative_rows_.find(*data);
+        if (cum_row != cummulative_rows_.end()) {
+            cummulative_rows_[*data] = cum_row->second + 1;
+        } else {
+            cummulative_rows_.insert(std::make_pair(*data, 1));
+        }
+    }
 
     // Set our row iterator to the beginning
     next_row_ = cummulative_rows_.begin();
@@ -1605,118 +1599,29 @@ CqlLeaseStatsQuery::getNextRow(LeaseStatsRow& row) {
 }
 
 void
-CqlLeaseStatsQuery::createBindForSelect(AnyArray& data, StatementTag) {
-    data.clear();
-    data.add(&subnet_id_);
-    if (fetch_type_) {
-        data.add(&lease_type_);
-    }
+CqlLeaseStatsQuery::createBindForSelect(AnyArray& data, StatementTag statement_tag) {
 
-    data.add(&lease_state_);
-}
+    // Start with a fresh array.
+    data.clear();
 
-void
-CqlLeaseStatsQuery::executeSelect(const CqlConnection& connection, const AnyArray& data,
-                                  StatementTag statement_tag)  {
-    CassError rc;
-    CassStatement* statement = NULL;
-    CassFuture* future = NULL;
-    AnyArray local_data = data;
-
-    // Find the query statement first.
-    StatementMap::const_iterator it = connection.statements_.find(statement_tag);
-    if (it == connection.statements_.end()) {
-        isc_throw(DbOperationError,
-                  "CqlLeastStatsQuery::executeSelect(): Statement "
-                      << statement_tag << "has not been prepared.");
-    }
+    // subnet_id: int
+    data.add(&subnet_id_);
 
-    // Bind the data before the query is executed.
-    CqlTaggedStatement tagged_statement = it->second;
-    if (tagged_statement.is_raw_) {
-        // The entire query is the first element in data.
-        std::string* query = boost::any_cast<std::string*>(local_data.back());
-        local_data.pop_back();
-        statement = cass_statement_new(query->c_str(), local_data.size());
+    // lease_type: int
+    if (statement_tag == CqlLeaseStatsQuery::RECOUNT_LEASE6_STATS) {
+        data.add(&lease_type_);
     } else {
-        statement = cass_prepared_bind(tagged_statement.prepared_statement_);
-        if (!statement) {
-            isc_throw(DbOperationError,
-                      "CqlLeaseStatsQuery::executeSelect(): unable to bind statement "
-                          << tagged_statement.name_);
-        }
-    }
-
-    // Set specific level of consistency if we're told to do so.
-    if (connection.force_consistency_) {
-        rc = cass_statement_set_consistency(statement, connection.consistency_);
-        if (rc != CASS_OK) {
-            cass_statement_free(statement);
-            isc_throw(DbOperationError,
-                      "CqlLeaseStatsQuery::executeSelect(): unable to set statement "
-                      "consistency for statement "
-                          << tagged_statement.name_
-                          << ", Cassandra error code: " << cass_error_desc(rc));
-        }
-    }
-
-    CqlCommon::bindData(local_data, statement);
-
-    // Everything's ready. Call the actual statement.
-    future = cass_session_execute(connection.session_, statement);
-    if (!future) {
-        cass_statement_free(statement);
-        isc_throw(DbOperationError,
-                  "CqlLeaseStatsQuery::executeSelect(): no CassFuture for statement "
-                      << tagged_statement.name_);
+        lease_type_ = Lease::TYPE_NA; // lease type is always NA for v4
     }
 
-    // Wait for the statement execution to complete.
-    cass_future_wait(future);
-    const std::string error = connection.checkFutureError(
-        "CqlLeaseStatsQuery::executeSelect(): cass_session_execute() != CASS_OK",
-        future, statement_tag);
-    rc = cass_future_error_code(future);
-    if (rc != CASS_OK) {
-        cass_future_free(future);
-        cass_statement_free(statement);
-        isc_throw(DbOperationError, error);
-    }
-
-    // Get column values.
-    const CassResult* result_collection = cass_future_get_result(future);
-
-    // lease type is always NA for v4
-    if (!fetch_type_)  {
-        lease_type_ = Lease::TYPE_NA;
-    }
-
-    // Since we're currently forced to pull data for all leases, we
-    // iterate over them, aggregating them into cummulative LeaseStatsRows
-    AnyArray return_values;
-    CassIterator* rows = cass_iterator_from_result(result_collection);
-    while (cass_iterator_next(rows)) {
-        const CassRow* row = cass_iterator_get_row(rows);
-        createBindForSelect(return_values, statement_tag);
-        CqlCommon::getData(row, return_values);
-
-        LeaseStatsRow raw_row(subnet_id_, static_cast<Lease::Type>(lease_type_),
-                              lease_state_, 1);
-
-        auto cum_row = cummulative_rows_.find(raw_row);
-        if (cum_row != cummulative_rows_.end()) {
-            cummulative_rows_[raw_row] = cum_row->second + 1;
-        } else {
-            cummulative_rows_.insert(std::make_pair(raw_row, 1));
-        }
-    }
+    // state: int
+    data.add(&state_);
+}
 
-    // Free resources.
-    cass_iterator_free(rows);
-    cass_result_free(result_collection);
-    cass_future_free(future);
-    cass_statement_free(statement);
-    return;
+boost::any
+CqlLeaseStatsQuery::retrieve() {
+    return (LeaseStatsRowPtr(new LeaseStatsRow(subnet_id_,
+            static_cast<Lease::Type>(lease_type_), state_, 1)));
 }
 
 CqlLeaseMgr::CqlLeaseMgr(const DatabaseConnection::ParameterMap &parameters)

src/lib/dhcpsrv/lease_mgr.h

@@ -114,7 +114,7 @@ struct LeaseStatsRow {
 
         if (subnet_id_ == rhs.subnet_id_ &&
             lease_type_ == rhs.lease_type_ &&
-            lease_state_ < rhs.lease_state_) {      
+            lease_state_ < rhs.lease_state_) {
                 return (true);
         }
 
@@ -166,6 +166,9 @@ typedef boost::shared_ptr<LeaseStatsQuery> LeaseStatsQueryPtr;
 /// @brief Defines a pointer to a LeaseStatsRow.
 typedef boost::shared_ptr<LeaseStatsRow> LeaseStatsRowPtr;
 
+/// @brief Collection of the @c LeaseStatsRow objects.
+typedef std::vector<LeaseStatsRowPtr> LeaseStatsCollection;
+
 /// @brief Abstract Lease Manager
 ///
 /// This is an abstract API for lease database backends. It provides unified