Prometheus UT for rddrop

- passing the right cookie, ensuring cookie's msb is preserved
- waiting for the flows and stats state to be setup so that prom metric gets created

Mock policy stats mgr to be added

Signed-off-by: Gautam Venkataramanan <gautam.chennai@gmail.com>
Change-Id: I5ace2a2c3b33ec3412ea159a3a790f758ec4d6cb

Author: gautvenk

agent-ovs/ovs/include/ContractStatsManager.h

@@ -123,6 +123,8 @@ class ContractStatsManager : public PolicyStatsManager {
 
     void updatePolicyStatsDropCounters(const std::string& rdURI,
                                        PolicyDropCounters_t& counters);
+
+    friend class ContractStatsManagerFixture;
 };
 
 } /* namespace opflexagent */

agent-ovs/ovs/test/ContractStatsManager_test.cpp

@@ -52,30 +52,39 @@ class ContractStatsManagerFixture : public PolicyStatsManagerFixture {
 
 public:
     ContractStatsManagerFixture() : PolicyStatsManagerFixture(),
+                                    intFlowManager(agent, switchManager, idGen,
+                                                   ctZoneManager, tunnelEpManager),
                                     contractStatsManager(&agent, idGen,
                                                          switchManager, 10),
                                     policyManager(agent.getPolicyManager()) {
+        switchManager.setMaxFlowTables(IntFlowManager::NUM_FLOW_TABLES);
+        intFlowManager.start();
         createObjects();
         createPolicyObjects();
         idGen.initNamespace("l24classifierRule");
         idGen.initNamespace("routingDomain");
         switchManager.setMaxFlowTables(IntFlowManager::NUM_FLOW_TABLES);
     }
     virtual ~ContractStatsManagerFixture() {
+        intFlowManager.stop();
         stop();
     }
     void verifyRoutingDomainDropStats(shared_ptr<RoutingDomain> rd,
                                       uint32_t packet_count,
                                       uint32_t byte_count);
+    void waitForRdDropEntry(void);
 #ifdef HAVE_PROMETHEUS_SUPPORT
     virtual void verifyPromMetrics(shared_ptr<L24Classifier> classifier,
                             uint32_t pkts,
                             uint32_t bytes,
                             bool isTx=false) override;
+    void verifyRdDropPromMetrics(uint32_t pkts, uint32_t bytes);
 #endif
+    IntFlowManager  intFlowManager;
     ContractStatsManager contractStatsManager;
     PolicyManager& policyManager;
 private:
+    bool checkNewFlowMapSize(size_t pol_table_size);
 };
 
 #ifdef HAVE_PROMETHEUS_SUPPORT
@@ -103,6 +112,23 @@ verifyPromMetrics (shared_ptr<L24Classifier> classifier,
     pos = output.find(s_bytes);
     BOOST_CHECK_NE(pos, std::string::npos);
 }
+
+void ContractStatsManagerFixture::
+verifyRdDropPromMetrics (uint32_t pkts,
+                         uint32_t bytes)
+{
+    const std::string& s_pkts = "opflex_policy_drop_packets{routing_domain=\"tenant0:rd0\"} "\
+                                + boost::lexical_cast<std::string>(pkts) + ".000000";
+    const std::string& s_bytes = "opflex_policy_drop_bytes{routing_domain=\"tenant0:rd0\"} "\
+                                 + boost::lexical_cast<std::string>(bytes) + ".000000";
+
+    const std::string& output = BaseFixture::getOutputFromCommand(cmd);
+    size_t pos = std::string::npos;
+    pos = output.find(s_pkts);
+    BOOST_CHECK_NE(pos, std::string::npos);
+    pos = output.find(s_bytes);
+    BOOST_CHECK_NE(pos, std::string::npos);
+}
 #endif
 
 void ContractStatsManagerFixture::
@@ -115,21 +141,26 @@ verifyRoutingDomainDropStats(shared_ptr<RoutingDomain> rd,
 
     auto uuid =
         boost::lexical_cast<string>(contractStatsManager.getAgentUUID());
+    WAIT_FOR_DO_ONFAIL(su.get()->resolveGbpeRoutingDomainDropCounter(uuid,
+                                    contractStatsManager.getCurrDropGenId(),
+                                    rd->getURI().toString()),
+                                    500,, LOG(ERROR) << "Obj not resolved";);
     optional<shared_ptr<RoutingDomainDropCounter> > myCounter =
         su.get()->resolveGbpeRoutingDomainDropCounter(uuid,
                                                       contractStatsManager
                                                       .getCurrDropGenId(),
                                                       rd->getURI().toString());
-    if (myCounter) {
-        BOOST_CHECK_EQUAL(myCounter.get()->getPackets().get(),
-                          packet_count);
-        BOOST_CHECK_EQUAL(myCounter.get()->getBytes().get(),
-                          byte_count);
-    }
+    BOOST_CHECK(myCounter);
+    BOOST_CHECK_EQUAL(myCounter.get()->getPackets().get(), packet_count);
+    BOOST_CHECK_EQUAL(myCounter.get()->getBytes().get(), byte_count);
+
+#ifdef HAVE_PROMETHEUS_SUPPORT
+    verifyRdDropPromMetrics(packet_count, byte_count);
+#endif
 }
 
 struct ofpbuf *makeFlowStatReplyMessage(MockConnection *pConn,
-                                        uint32_t priority, uint32_t cookie,
+                                        uint32_t priority, uint64_t cookie,
                                         uint32_t packet_count,
                                         uint32_t byte_count,
                                         uint32_t reg0, uint32_t reg2,
@@ -159,7 +190,7 @@ struct ofpbuf *makeFlowStatReplyMessage(MockConnection *pConn,
         bzero(fs, sizeof(struct ofputil_flow_stats));
         fs->table_id = IntFlowManager::POL_TABLE_ID;
         fs->priority = priority;
-        fs->cookie = ovs_htonll((uint64_t)cookie);
+        fs->cookie = cookie;
         fs->packet_count = packet_count;
         fs->byte_count = byte_count;
         fs->flags = OFPUTIL_FF_SEND_FLOW_REM;
@@ -179,6 +210,44 @@ struct ofpbuf *makeFlowStatReplyMessage(MockConnection *pConn,
 
 }
 
+bool ContractStatsManagerFixture::checkNewFlowMapSize (size_t pol_table_size)
+{
+    // Call on_timer function to process the flow entries received from
+    // switchManager.
+    boost::system::error_code ec;
+    ec = make_error_code(boost::system::errc::success);
+    contractStatsManager.on_timer(ec);
+
+    std::lock_guard<std::mutex> lock(contractStatsManager.pstatMtx);
+    if (contractStatsManager.contractState.newFlowCounterMap.size() == pol_table_size)
+        return true;
+
+    return false;
+}
+
+// Wait for IntFlowManager to create rddrop flow and stats tables to get initialized
+void ContractStatsManagerFixture::waitForRdDropEntry (void)
+{
+    // 1 table-drop static entry in POL table with stats enabled
+    WAIT_FOR_DO_ONFAIL(checkNewFlowMapSize(1),
+                       500,,
+                       LOG(ERROR) << "##### flow state not fully setup ####";);
+
+    intFlowManager.domainUpdated(RoutingDomain::CLASS_ID, rd0->getURI());
+
+    // 1 entry is installed in policy table per VRF for collecting rddrop stats
+    WAIT_FOR_DO_ONFAIL(checkNewFlowMapSize(2),
+                       500,,
+                       LOG(ERROR) << "##### flow state not fully setup ####";);
+
+    // rdid for this rd should have been allocated
+    WAIT_FOR_DO_ONFAIL(
+            (idGen.getIdNoAlloc(IntFlowManager::getIdNamespace(RoutingDomain::CLASS_ID),
+                           rd0->getURI().toString()) != (uint32_t)-1),
+                        500,,
+                        LOG(ERROR) << "rdId not yet alloc'd for rd0");
+}
+
 BOOST_AUTO_TEST_SUITE(ContractStatsManager_test)
 
 BOOST_FIXTURE_TEST_CASE(testFlowMatchStats, ContractStatsManagerFixture) {
@@ -209,21 +278,25 @@ BOOST_FIXTURE_TEST_CASE(testRdDropStats, ContractStatsManagerFixture) {
     contractStatsManager.registerConnection(&integrationPortConn);
     contractStatsManager.start();
     LOG(DEBUG) << "### rddrop stats start";
+    waitForRdDropEntry();
 
     // get rdId
     uint32_t rdId =
-        idGen.getId(IntFlowManager::getIdNamespace(RoutingDomain::CLASS_ID),
-                    rd0->getURI().toString());
+        idGen.getIdNoAlloc(IntFlowManager::getIdNamespace(RoutingDomain::CLASS_ID),
+                           rd0->getURI().toString());
     uint32_t priority = 1;
     uint32_t packet_count = 39;
     uint32_t byte_count = 6994;
 
     /* create  per RD flow drop stats  */
     struct ofpbuf *res_msg = makeFlowStatReplyMessage(&integrationPortConn,
-                                                      priority, 0,
+                                                      priority,
+                                                      flow::cookie::RD_POL_DROP_FLOW,
                                                       packet_count, byte_count,
                                                       0, 0, rdId);
     BOOST_REQUIRE(res_msg!=0);
+    ofp_header *msgHdr = (ofp_header *)res_msg->data;
+    contractStatsManager.testInjectTxnId(msgHdr->xid);
 
     contractStatsManager.Handle(&integrationPortConn,
                                 OFPTYPE_FLOW_STATS_REPLY, res_msg);