Merge "Disable faster polling of TCP flows" into R3.0

src/vnsw/agent/contrail-vrouter-agent.conf

@@ -131,9 +131,6 @@ log_local=1
 
 # Number of Index state-machine events to log
 # index_sm_log_count=0
-
-# Number of seconds within which TCP flows should be visited atleast once.
-# tcp_flow_scan_interval=15
 [METADATA]
 # Shared secret for metadata proxy service (Optional)
 # metadata_proxy_secret=contrail

src/vnsw/agent/init/agent_param.cc

@@ -534,10 +534,6 @@ void AgentParam::ParseFlows() {
                                     "FLOWS.index_sm_log_count")) {
         flow_index_sm_log_count_ = Agent::kDefaultFlowIndexSmLogCount;
     }
-    if (!GetValueFromTree<uint16_t>(tcp_flow_scan_interval_,
-                                    "FLOWS.tcp_flow_scan_interval")) {
-        tcp_flow_scan_interval_ = kTcpFlowScanInterval;
-    }
 
 }
 
@@ -780,8 +776,6 @@ void AgentParam::ParseFlowArguments
                           "FLOWS.max_vm_linklocal_flows");
     GetOptValue<uint16_t>(var_map, flow_index_sm_log_count_,
                           "FLOWS.index_sm_log_count");
-    GetOptValue<uint16_t>(var_map, tcp_flow_scan_interval_,
-                          "FLOWS.tcp_flow_scan_interval");
 }
 
 void AgentParam::ParseHeadlessModeArguments
@@ -1237,7 +1231,6 @@ AgentParam::AgentParam(bool enable_flow_options,
         agent_stats_interval_(kAgentStatsInterval),
         flow_stats_interval_(kFlowStatsInterval),
         vrouter_stats_interval_(kVrouterStatsInterval),
-        tcp_flow_scan_interval_(kTcpFlowScanInterval),
         vmware_physical_port_(""), test_mode_(false), debug_(false), tree_(),
         vgw_config_table_(new VirtualGatewayConfigTable() ),
         headless_mode_(false), dhcp_relay_mode_(false),

src/vnsw/agent/init/agent_param.h

@@ -19,7 +19,6 @@ class AgentParam  {
     static const uint32_t kAgentStatsInterval = (30 * 1000); // time in millisecs
     static const uint32_t kFlowStatsInterval = (1000); // time in milliseconds
     static const uint32_t kVrouterStatsInterval = (30 * 1000); //time-millisecs
-    static const uint16_t kTcpFlowScanInterval = 15; // time in seconds
     typedef std::vector<Ip4Address> AddressList;
 
     // Agent mode we are running in
@@ -168,7 +167,6 @@ class AgentParam  {
     int agent_stats_interval() const { return agent_stats_interval_; }
     int flow_stats_interval() const { return flow_stats_interval_; }
     int vrouter_stats_interval() const { return vrouter_stats_interval_; }
-    uint16_t tcp_flow_scan_interval() const { return tcp_flow_scan_interval_; }
     void set_agent_stats_interval(int val) { agent_stats_interval_ = val; }
     void set_flow_stats_interval(int val) { flow_stats_interval_ = val; }
     void set_vrouter_stats_interval(int val) { vrouter_stats_interval_ = val; }
@@ -430,7 +428,6 @@ class AgentParam  {
     int agent_stats_interval_;
     int flow_stats_interval_;
     int vrouter_stats_interval_;
-    uint16_t tcp_flow_scan_interval_;
     std::string vmware_physical_port_;
     bool test_mode_;
     bool debug_;

src/vnsw/agent/pkt/pkt.sandesh

@@ -371,8 +371,6 @@ traceobject sandesh FlowRouteUpdate {
 response sandesh FlowAgeTimeResp {
    1: u32 old_age_time;
    2: u32 new_age_time;
-   3: u32 old_tcp_age_time;
-   4: u32 new_tcp_age_time;
 }
 
 /**

src/vnsw/agent/pkt/pkt_sandesh_flow.cc

@@ -428,31 +428,20 @@ void FlowAgeTimeReq::HandleRequest() const {
 
     FlowStatsCollector *collector =
         agent->flow_stats_manager()->default_flow_stats_collector();
-    FlowStatsCollector *tcp_col =
-        agent->flow_stats_manager()->tcp_flow_stats_collector();
 
     FlowAgeTimeResp *resp = new FlowAgeTimeResp();
-    if (collector) {
-        resp->set_old_age_time(collector->flow_age_time_intvl_in_secs());
-
-        if (age_time && age_time != resp->get_old_age_time()) {
-            collector->UpdateFlowAgeTimeInSecs(age_time);
-            resp->set_new_age_time(age_time);
-        } else {
-            resp->set_new_age_time(resp->get_old_age_time());
-        }
+    if (collector == NULL) {
+        goto done;
     }
-    if (tcp_col) {
-        resp->set_old_tcp_age_time(tcp_col->flow_age_time_intvl_in_secs());
+    resp->set_old_age_time(collector->flow_age_time_intvl_in_secs());
 
-        if (age_time && age_time != resp->get_old_age_time() &&
-            !tcp_col->user_configured()) {
-            tcp_col->UpdateFlowAgeTimeInSecs(age_time);
-            resp->set_new_tcp_age_time(age_time);
-        } else {
-            resp->set_new_tcp_age_time(resp->get_old_tcp_age_time());
-        }
+    if (age_time && age_time != resp->get_old_age_time()) {
+        collector->UpdateFlowAgeTimeInSecs(age_time);
+        resp->set_new_age_time(age_time);
+    } else {
+        resp->set_new_age_time(resp->get_old_age_time());
     }
+done:
     resp->set_context(context());
     resp->set_more(false);
     resp->Response();

src/vnsw/agent/test/test_util.cc

@@ -3299,12 +3299,8 @@ bool FlowStatsMatch(const string &vrf_name, const char *sip,
     if (fe == NULL) {
         return false;
     }
-    FlowStatsCollector *fec = NULL;
-    if (proto == IPPROTO_TCP) {
-        fec = agent->flow_stats_manager()->tcp_flow_stats_collector();
-    } else {
-        fec = agent->flow_stats_manager()->default_flow_stats_collector();
-    }
+    FlowStatsCollector *fec = 
+        agent->flow_stats_manager()->default_flow_stats_collector();
     FlowExportInfo *info = fec->FindFlowExportInfo(fe);
     if (info) {
         LOG(DEBUG, " bytes " << info->bytes() << " pkts " << info->packets());

src/vnsw/agent/uve/test/test_interface_uve.cc

@@ -96,11 +96,6 @@ class InterfaceUveTest : public ::testing::Test {
             (agent_->flow_stats_manager()->default_flow_stats_collector());
         f->ClearList();
         EXPECT_EQ(0U, f->ingress_flow_log_list().size());
-
-        f = static_cast<FlowStatsCollectorTest *>
-            (agent_->flow_stats_manager()->tcp_flow_stats_collector());
-        f->ClearList();
-        EXPECT_EQ(0U, f->ingress_flow_log_list().size());
     }
 
     void InterfaceSetup() {

src/vnsw/agent/uve/test/test_stats_mock.cc

@@ -496,24 +496,22 @@ TEST_F(StatsTestMock, FlowStatsOverflow_AgeTest) {
                            default_flow_stats_collector()->flow_age_time_intvl();
 
     //Set the flow age time to 1000 microsecond
-    agent->flow_stats_manager()->tcp_flow_stats_collector()->
+    agent->flow_stats_manager()->default_flow_stats_collector()->
         UpdateFlowAgeTime(tmp_age_time);
 
     usleep(tmp_age_time + 10);
-    util_.EnqueueFlowStatsCollectorTask();
+    client->EnqueueFlowAge();
     client->WaitForIdle();
     WAIT_FOR(100, 10000, (flow_proto_->FlowCount() == 0U));
 
     //Restore flow aging time
-    agent->flow_stats_manager()->tcp_flow_stats_collector()->
+    agent->flow_stats_manager()->default_flow_stats_collector()->
         UpdateFlowAgeTime(bkp_age_time);
 }
 
 TEST_F(StatsTestMock, FlowStatsTest_tcp_flags) {
     hash_id = 1;
 
-    FlowStatsCollector *fs = agent_->flow_stats_manager()->
-                                 tcp_flow_stats_collector();
     VrfEntry *vrf = Agent::GetInstance()->vrf_table()->FindVrfFromName("vrf5");
     //Flow creation using TCP packet
     TxTcpPacketUtil(flow0->id(), "1.1.1.1", "1.1.1.2",
@@ -526,8 +524,8 @@ TEST_F(StatsTestMock, FlowStatsTest_tcp_flags) {
     EXPECT_TRUE(f2 != NULL);
     FlowEntry *f2_rev = f2->reverse_flow_entry();
     EXPECT_TRUE(f2_rev != NULL);
-    FlowExportInfo *info = fs->FindFlowExportInfo(f2);
-    FlowExportInfo *rinfo = fs->FindFlowExportInfo(f2_rev);
+    FlowExportInfo *info = col_->FindFlowExportInfo(f2);
+    FlowExportInfo *rinfo = col_->FindFlowExportInfo(f2_rev);
     EXPECT_TRUE(info != NULL);
     EXPECT_TRUE(rinfo != NULL);
 
@@ -548,8 +546,8 @@ TEST_F(StatsTestMock, FlowStatsTest_tcp_flags) {
     util_.EnqueueFlowStatsCollectorTask();
     client->WaitForIdle(10);
 
-    info = fs->FindFlowExportInfo(f2);
-    rinfo = fs->FindFlowExportInfo(f2_rev);
+    info = col_->FindFlowExportInfo(f2);
+    rinfo = col_->FindFlowExportInfo(f2_rev);
     EXPECT_TRUE(info != NULL);
     EXPECT_TRUE(rinfo != NULL);
     //Verify flow TCP flags
@@ -564,8 +562,8 @@ TEST_F(StatsTestMock, FlowStatsTest_tcp_flags) {
     util_.EnqueueFlowStatsCollectorTask();
     client->WaitForIdle(10);
 
-    info = fs->FindFlowExportInfo(f2);
-    rinfo = fs->FindFlowExportInfo(f2_rev);
+    info = col_->FindFlowExportInfo(f2);
+    rinfo = col_->FindFlowExportInfo(f2_rev);
     EXPECT_TRUE(info != NULL);
     EXPECT_TRUE(rinfo != NULL);
     //Verify the updated flow TCP flags

src/vnsw/agent/uve/test/test_uve_util.h

@@ -95,8 +95,6 @@ class FlowStatsCollectorTask : public Task {
     virtual bool Run() {
         Agent::GetInstance()->flow_stats_manager()->
             default_flow_stats_collector()->Run();
-        Agent::GetInstance()->flow_stats_manager()->
-            tcp_flow_stats_collector()->Run();
     }
     std::string Description() const { return "FlowStatsCollectorTask"; }
 };

src/vnsw/agent/uve/test/test_vm_uve.cc

@@ -90,11 +90,6 @@ class UveVmUveTest : public ::testing::Test {
             (agent_->flow_stats_manager()->default_flow_stats_collector());
         f->ClearList();
         EXPECT_EQ(0U, f->ingress_flow_log_list().size());
-
-        f = static_cast<FlowStatsCollectorTest *>
-            (agent_->flow_stats_manager()->tcp_flow_stats_collector());
-        f->ClearList();
-        EXPECT_EQ(0U, f->ingress_flow_log_list().size());
     }
 
     void FlowSetUp() {

src/vnsw/agent/vrouter/flow_stats/flow_stats_collector.cc

@@ -82,19 +82,14 @@ void FlowStatsCollector::Shutdown() {
 // Get the time (in msec) in which one scan of flow-table is to be done
 uint64_t FlowStatsCollector::GetScanTime() {
     uint64_t scan_time_millisec;
-    /* Use Age Time itself as scan-time for non-tcp flows */
-    if (flow_aging_key_.proto == IPPROTO_TCP) {
-        /* Convert from seconds to milliseconds */
-        scan_time_millisec = agent_uve_->agent()->params()->
-            tcp_flow_scan_interval() * 1000;
-    } else {
-        // Convert aging-time configured in micro-sec to millisecond
-        scan_time_millisec = flow_age_time_intvl_ / 1000;
+    /* Use Age Time itself as scan-time for flows */
 
-        // Compute time in which we must scan the complete table to honor the
-        // kFlowScanTime
-        scan_time_millisec = (scan_time_millisec * kFlowScanTime) / 100;
-    }
+    // Convert aging-time configured in micro-sec to millisecond
+    scan_time_millisec = flow_age_time_intvl_ / 1000;
+
+    // Compute time in which we must scan the complete table to honor the
+    // kFlowScanTime
+    scan_time_millisec = (scan_time_millisec * kFlowScanTime) / 100;
 
     //  Enforce min value on scan-time. Aging timer run at kFlowStatsInterval
     if (scan_time_millisec < kFlowStatsInterval) {

src/vnsw/agent/vrouter/flow_stats/flow_stats_collector.h

@@ -109,8 +109,6 @@ class FlowStatsCollector : public StatsCollector {
     bool deleted() const {
         return deleted_;
     }
-    bool user_configured() const { return user_configured_; }
-    void set_user_configured(bool value) { user_configured_ = value; }
     const FlowAgingTableKey& flow_aging_key() const {
         return flow_aging_key_;
     }
@@ -213,7 +211,6 @@ class FlowStatsCollector : public StatsCollector {
     FlowAgingTableKey flow_aging_key_;
     uint32_t instance_id_;
     FlowStatsManager *flow_stats_manager_;
-    bool user_configured_;
     DISALLOW_COPY_AND_ASSIGN(FlowStatsCollector);
 };
 #endif //vnsw_agent_flow_stats_collector_h

src/vnsw/agent/vrouter/flow_stats/flow_stats_manager.cc

@@ -121,7 +121,6 @@ void FlowStatsManager::AddReqHandler(boost::shared_ptr<FlowStatsCollectorReq>
         it->second->set_flow_age_time_intvl(
                 1000000L * (uint64_t)req->flow_cache_timeout);
         it->second->set_deleted(false);
-        it->second->set_user_configured(req->user_configured);
         return;
     }
 
@@ -140,7 +139,6 @@ void FlowStatsManager::AddReqHandler(boost::shared_ptr<FlowStatsCollectorReq>
     if (req->key.port == 0) {
         protocol_list_[req->key.proto] = aging_table.get();
     }
-    aging_table->set_user_configured(req->user_configured);
 }
 
 void FlowStatsManager::DeleteReqHandler(boost::shared_ptr<FlowStatsCollectorReq>
@@ -179,34 +177,23 @@ void FlowStatsManager::FreeReqHandler(boost::shared_ptr<FlowStatsCollectorReq>
 }
 
 void FlowStatsManager::Add(const FlowAgingTableKey &key,
-                           uint64_t flow_stats_interval,
-                           uint64_t flow_cache_timeout, bool user_configured) {
+                          uint64_t flow_stats_interval,
+                          uint64_t flow_cache_timeout) {
     boost::shared_ptr<FlowStatsCollectorReq>
         req(new FlowStatsCollectorReq(
                     FlowStatsCollectorReq::ADD_FLOW_STATS_COLLECTOR,
-                    key, flow_stats_interval, flow_cache_timeout,
-                    user_configured));
+                    key, flow_stats_interval, flow_cache_timeout));
     request_queue_.Enqueue(req);
 }
 
 void FlowStatsManager::Delete(const FlowAgingTableKey &key) {
     if (key.proto == kCatchAllProto) {
         return;
     }
-    boost::shared_ptr<FlowStatsCollectorReq> req;
-    if (key.proto == IPPROTO_TCP && key.port == 0) {
-        /* We should never delete flow-stats-collector with (IPPROTO_TCP, 0)
-         * key as it is implicitly added. If user has overwritten that and later
-         * sent delete request, we should only change the aging time back to
-         * default value. This is done by enqueuing ADD request */
-        req.reset(new FlowStatsCollectorReq(
-                    FlowStatsCollectorReq::ADD_FLOW_STATS_COLLECTOR,
-                    key, agent_->params()->flow_stats_interval(),
-                    agent_->params()->flow_cache_timeout(), false));
-    } else {
-        req.reset(new FlowStatsCollectorReq(
-                    FlowStatsCollectorReq::DELETE_FLOW_STATS_COLLECTOR, key));
-    }
+    boost::shared_ptr<FlowStatsCollectorReq>
+        req(new FlowStatsCollectorReq(
+                    FlowStatsCollectorReq::DELETE_FLOW_STATS_COLLECTOR,
+                    key));
     request_queue_.Enqueue(req);
 }
 
@@ -325,18 +312,15 @@ void FlowStatsManager::FlowStatsReqHandler(Agent *agent,
     } else {
         agent->flow_stats_manager()->Add(
                 FlowAgingTableKey(protocol, port), 
-                agent->params()->flow_stats_interval(), timeout, true);
+                agent->params()->flow_stats_interval(), timeout);
     }
 }
 
 void FlowStatsManager::Init(uint64_t flow_stats_interval,
                            uint64_t flow_cache_timeout) {
     agent_->set_flow_stats_req_handler(&(FlowStatsManager::FlowStatsReqHandler));
     Add(FlowAgingTableKey(kCatchAllProto, 0),
-        flow_stats_interval,
-        flow_cache_timeout, false);
-    Add(FlowAgingTableKey(IPPROTO_TCP, 0), flow_stats_interval,
-        flow_cache_timeout, false);
+        flow_stats_interval, flow_cache_timeout);
     timer_->Start(FlowThresoldUpdateTime,
                   boost::bind(&FlowStatsManager::UpdateFlowThreshold, this));
 }
@@ -377,7 +361,7 @@ void ShowAgingConfig::HandleRequest() const {
 void AddAgingConfig::HandleRequest() const {
     FlowStatsManager *fam = Agent::GetInstance()->flow_stats_manager();
     fam->Add(FlowAgingTableKey(get_protocol(), get_port()),
-                               get_stats_interval(), get_cache_timeout(), true);
+                               get_stats_interval(), get_cache_timeout());
     SandeshResponse *resp = new FlowStatsCfgResp();
     resp->set_context(context());
     resp->Response();

src/vnsw/agent/vrouter/flow_stats/flow_stats_manager.h

@@ -44,10 +44,9 @@ struct FlowStatsCollectorReq {
     };
 
     FlowStatsCollectorReq(Event ev, const FlowAgingTableKey &k,
-                          uint64_t interval, uint64_t timeout,
-                          bool user_cfgd) :
+                          uint64_t interval, uint64_t timeout) :
         event(ev), key(k), flow_stats_interval(interval),
-        flow_cache_timeout(timeout), user_configured(user_cfgd) {}
+        flow_cache_timeout(timeout) {}
 
     FlowStatsCollectorReq(Event ev, const FlowAgingTableKey &k):
         event(ev), key(k) {}
@@ -56,7 +55,6 @@ struct FlowStatsCollectorReq {
     FlowAgingTableKey key;
     uint64_t flow_stats_interval;
     uint64_t flow_cache_timeout;
-    bool user_configured;
 };
 
 class FlowStatsManager {
@@ -79,14 +77,11 @@ class FlowStatsManager {
     FlowStatsCollector* default_flow_stats_collector() {
         return default_flow_stats_collector_.get();
     }
-    FlowStatsCollector* tcp_flow_stats_collector() {
-        return protocol_list_[IPPROTO_TCP];
-    }
 
     //Add protocol + port based flow aging table
     void Add(const FlowAgingTableKey &key,
              uint64_t flow_stats_interval,
-             uint64_t flow_cache_timeout, bool user_configured);
+             uint64_t flow_cache_timeout);
     void Delete(const FlowAgingTableKey &key);
     void Free(const FlowAgingTableKey &key);