diff --git a/src/bgp/SConscript b/src/bgp/SConscript index 9c6c354e2f9..01b740f3c63 100644 --- a/src/bgp/SConscript +++ b/src/bgp/SConscript @@ -65,6 +65,7 @@ libbgp = env.Library('bgp', 'bgp_show_route.cc', 'bgp_show_route_summary.cc', 'bgp_show_routing_instance.cc', + 'bgp_show_rtarget_group.cc', 'bgp_table.cc', 'bgp_update.cc', 'bgp_update_monitor.cc', diff --git a/src/bgp/bgp_peer.sandesh b/src/bgp/bgp_peer.sandesh index 188586fffbe..d303db368d4 100644 --- a/src/bgp/bgp_peer.sandesh +++ b/src/bgp/bgp_peer.sandesh @@ -262,6 +262,49 @@ request sandesh ShowRoutingInstanceSummaryReq { 1: string search_string; } +struct ShowRtGroupMemberTableList { + 1: string family; + 2: list tables; +} + +struct ShowRtGroupInfo { + 1: string rtarget (link="ShowRtGroupReq"); + 2: list import_members; + 3: list export_members; + 4: optional list peers_interested; + 5: optional list dep_route; +} + +response sandesh ShowRtGroupResp { + 1: list rtgroup_list; + 2: optional string next_batch (link="ShowRtGroupReqIterate", + link_title="next_batch"); +} + +request sandesh ShowRtGroupReq { + 1: string search_string; +} + +response sandesh ShowRtGroupSummaryResp { + 1: list rtgroup_list; + 2: optional string next_batch (link="ShowRtGroupSummaryReqIterate", + link_title="next_batch"); +} + +request sandesh ShowRtGroupSummaryReq { + 1: string search_string; +} + +response sandesh ShowRtGroupPeerResp { + 1: list rtgroup_list; + 2: optional string next_batch (link="ShowRtGroupPeerReqIterate", + link_title="next_batch"); +} + +request sandesh ShowRtGroupPeerReq { + 1: string search_string; +} + struct ShowEvpnTable { 1: string name (link="ShowRouteReq"); 2: u64 mac_routes; diff --git a/src/bgp/bgp_peer_internal.sandesh b/src/bgp/bgp_peer_internal.sandesh index 58773473b30..33610ea052f 100644 --- a/src/bgp/bgp_peer_internal.sandesh +++ b/src/bgp/bgp_peer_internal.sandesh @@ -50,6 +50,18 @@ request sandesh ShowRoutingInstanceSummaryReqIterate { 1: string iterate_info; } +request sandesh ShowRtGroupReqIterate { + 1: string iterate_info; +} + +request sandesh ShowRtGroupSummaryReqIterate { + 1: string iterate_info; +} + +request sandesh ShowRtGroupPeerReqIterate { + 1: string iterate_info; +} + request sandesh ShowEvpnTableReqIterate { 1: string iterate_info; } diff --git a/src/bgp/bgp_server.h b/src/bgp/bgp_server.h index 3f868f22e2d..6af03f9d13a 100644 --- a/src/bgp/bgp_server.h +++ b/src/bgp/bgp_server.h @@ -78,6 +78,9 @@ class BgpServer { return inst_mgr_.get(); } RTargetGroupMgr *rtarget_group_mgr() { return rtarget_group_mgr_.get(); } + const RTargetGroupMgr *rtarget_group_mgr() const { + return rtarget_group_mgr_.get(); + } BgpConditionListener *condition_listener(Address::Family family) { if (family == Address::INET) return inet_condition_listener_.get(); diff --git a/src/bgp/bgp_show_rtarget_group.cc b/src/bgp/bgp_show_rtarget_group.cc new file mode 100644 index 00000000000..7c7e61b0ba6 --- /dev/null +++ b/src/bgp/bgp_show_rtarget_group.cc @@ -0,0 +1,307 @@ +/* + * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved. + */ + +#include "bgp/bgp_show_handler.h" + +#include + +#include "bgp/bgp_peer_internal_types.h" +#include "bgp/bgp_peer_types.h" +#include "bgp/bgp_server.h" +#include "bgp/routing-instance/rtarget_group.h" +#include "bgp/routing-instance/rtarget_group_mgr.h" + +using std::string; +using std::vector; + +// +// Fill in information for list of rtarget groups. +// +// Allows regular, summary and peer introspect to share code. +// Assumes that search_string is the peer name if match_peer is true. +// +static bool FillRtGroupInfoList(const BgpSandeshContext *bsc, + bool summary, bool match_peer, uint32_t page_limit, uint32_t iter_limit, + const string &start_rtarget_str, const string &search_string, + vector *srtg_list, string *next_rtarget_str) { + RouteTarget rtarget; + + // Bail if start_rtarget_str is bad. + if (!start_rtarget_str.empty()) { + rtarget = RouteTarget::FromString(start_rtarget_str); + if (rtarget.IsNull()) + return true; + } + + // Bail if there's no peer specified when doing a peer introspect. + if (match_peer && search_string.empty()) + return true; + + const RTargetGroupMgr *rtgroup_mgr = bsc->bgp_server->rtarget_group_mgr(); + RTargetGroupMgr::const_iterator it = rtgroup_mgr->lower_bound(rtarget); + for (uint32_t iter_count = 0; it != rtgroup_mgr->end(); + ++it, ++iter_count) { + const RtGroup *rtgroup = it->second; + if (!match_peer && !search_string.empty() && + (rtgroup->ToString().find(search_string) == string::npos)) { + continue; + } + ShowRtGroupInfo srtg; + if (match_peer) { + if (!rtgroup->HasInterestedPeer(search_string)) + continue; + rtgroup->FillShowPeerInfo(&srtg); + } else if (summary) { + rtgroup->FillShowSummaryInfo(&srtg); + } else { + rtgroup->FillShowInfo(&srtg); + } + srtg_list->push_back(srtg); + if (srtg_list->size() >= page_limit) + break; + if (iter_count >= iter_limit) + break; + } + + // All done if we've looked at all rtarget groups. + if (it == rtgroup_mgr->end() || ++it == rtgroup_mgr->end()) + return true; + + // Return true if we've reached the page limit, false if we've reached the + // iteration limit. + bool done = srtg_list->size() >= page_limit; + *next_rtarget_str = it->second->ToString(); + return done; +} + +// +// Specialization of BgpShowHandler<>::CallbackCommon for regular introspect. +// +template <> +bool BgpShowHandler::CallbackCommon( + const BgpSandeshContext *bsc, Data *data) { + uint32_t page_limit = bsc->page_limit() ? bsc->page_limit() : kPageLimit; + uint32_t iter_limit = bsc->iter_limit() ? bsc->iter_limit() : kIterLimit; + string next_rtarget_str; + bool done = FillRtGroupInfoList(bsc, false, false, page_limit, iter_limit, + data->next_entry, data->search_string, &data->show_list, + &next_rtarget_str); + if (!next_rtarget_str.empty()) + SaveContextToData(next_rtarget_str, done, data); + return done; +} + +// +// Specialization of BgpShowHandler<>::FillShowList for regular introspect. +// +template <> +void BgpShowHandler::FillShowList( + ShowRtGroupResp *resp, + const vector &show_list) { + resp->set_rtgroup_list(show_list); +} + +// +// Specialization of BgpShowHandler<>::CallbackCommon for summary introspect. +// +template <> +bool BgpShowHandler::CallbackCommon( + const BgpSandeshContext *bsc, Data *data) { + uint32_t page_limit = bsc->page_limit() ? bsc->page_limit() : kPageLimit; + uint32_t iter_limit = bsc->iter_limit() ? bsc->iter_limit() : kIterLimit; + string next_rtarget_str; + bool done = FillRtGroupInfoList(bsc, true, false, page_limit, iter_limit, + data->next_entry, data->search_string, &data->show_list, + &next_rtarget_str); + if (!next_rtarget_str.empty()) + SaveContextToData(next_rtarget_str, done, data); + return done; +} + +// +// Specialization of BgpShowHandler<>::FillShowList for summary introspect. +// +template <> +void BgpShowHandler::FillShowList( + ShowRtGroupSummaryResp *resp, + const vector &show_list) { + resp->set_rtgroup_list(show_list); +} + +// +// Specialization of BgpShowHandler<>::CallbackCommon for peer introspect. +// +template <> +bool BgpShowHandler::CallbackCommon( + const BgpSandeshContext *bsc, Data *data) { + uint32_t page_limit = bsc->page_limit() ? bsc->page_limit() : kPageLimit; + uint32_t iter_limit = bsc->iter_limit() ? bsc->iter_limit() : kIterLimit; + string next_rtarget_str; + bool done = FillRtGroupInfoList(bsc, false, true, page_limit, iter_limit, + data->next_entry, data->search_string, &data->show_list, + &next_rtarget_str); + if (!next_rtarget_str.empty()) + SaveContextToData(next_rtarget_str, done, data); + return done; +} + +// +// Specialization of BgpShowHandler<>::FillShowList for peer introspect. +// +template <> +void BgpShowHandler::FillShowList( + ShowRtGroupPeerResp *resp, + const vector &show_list) { + resp->set_rtgroup_list(show_list); +} + +// +// Handler for ShowRtGroupReq. +// +void ShowRtGroupReq::HandleRequest() const { + RequestPipeline::PipeSpec ps(this); + RequestPipeline::StageSpec s1; + TaskScheduler *scheduler = TaskScheduler::GetInstance(); + + s1.taskId_ = scheduler->GetTaskId("bgp::RTFilter"); + s1.cbFn_ = boost::bind(&BgpShowHandler< + ShowRtGroupReq, + ShowRtGroupReqIterate, + ShowRtGroupResp, + ShowRtGroupInfo>::Callback, _1, _2, _3, _4, _5); + s1.allocFn_ = BgpShowHandler< + ShowRtGroupReq, + ShowRtGroupReqIterate, + ShowRtGroupResp, + ShowRtGroupInfo>::CreateData; + s1.instances_.push_back(0); + ps.stages_.push_back(s1); + RequestPipeline rp(ps); +} + +// +// Handler for ShowRtGroupReqIterate. +// +void ShowRtGroupReqIterate::HandleRequest() const { + RequestPipeline::PipeSpec ps(this); + RequestPipeline::StageSpec s1; + TaskScheduler *scheduler = TaskScheduler::GetInstance(); + + s1.taskId_ = scheduler->GetTaskId("bgp::RTFilter"); + s1.cbFn_ = boost::bind(&BgpShowHandler< + ShowRtGroupReq, + ShowRtGroupReqIterate, + ShowRtGroupResp, + ShowRtGroupInfo>::CallbackIterate, _1, _2, _3, _4, _5); + s1.allocFn_ = BgpShowHandler< + ShowRtGroupReq, + ShowRtGroupReqIterate, + ShowRtGroupResp, + ShowRtGroupInfo>::CreateData; + s1.instances_.push_back(0); + ps.stages_.push_back(s1); + RequestPipeline rp(ps); +} + +// +// Handler for ShowRtGroupSummaryReq. +// +void ShowRtGroupSummaryReq::HandleRequest() const { + RequestPipeline::PipeSpec ps(this); + RequestPipeline::StageSpec s1; + TaskScheduler *scheduler = TaskScheduler::GetInstance(); + + s1.taskId_ = scheduler->GetTaskId("bgp::RTFilter"); + s1.cbFn_ = boost::bind(&BgpShowHandler< + ShowRtGroupSummaryReq, + ShowRtGroupSummaryReqIterate, + ShowRtGroupSummaryResp, + ShowRtGroupInfo>::Callback, _1, _2, _3, _4, _5); + s1.allocFn_ = BgpShowHandler< + ShowRtGroupSummaryReq, + ShowRtGroupSummaryReqIterate, + ShowRtGroupSummaryResp, + ShowRtGroupInfo>::CreateData; + s1.instances_.push_back(0); + ps.stages_.push_back(s1); + RequestPipeline rp(ps); +} + +// +// Handler for ShowRtGroupSummaryReqIterate. +// +void ShowRtGroupSummaryReqIterate::HandleRequest() const { + RequestPipeline::PipeSpec ps(this); + RequestPipeline::StageSpec s1; + TaskScheduler *scheduler = TaskScheduler::GetInstance(); + + s1.taskId_ = scheduler->GetTaskId("bgp::RTFilter"); + s1.cbFn_ = boost::bind(&BgpShowHandler< + ShowRtGroupSummaryReq, + ShowRtGroupSummaryReqIterate, + ShowRtGroupSummaryResp, + ShowRtGroupInfo>::CallbackIterate, _1, _2, _3, _4, _5); + s1.allocFn_ = BgpShowHandler< + ShowRtGroupSummaryReq, + ShowRtGroupSummaryReqIterate, + ShowRtGroupSummaryResp, + ShowRtGroupInfo>::CreateData; + s1.instances_.push_back(0); + ps.stages_.push_back(s1); + RequestPipeline rp(ps); +} + +// +// Handler for ShowRtGroupPeerReq. +// +void ShowRtGroupPeerReq::HandleRequest() const { + RequestPipeline::PipeSpec ps(this); + RequestPipeline::StageSpec s1; + TaskScheduler *scheduler = TaskScheduler::GetInstance(); + + s1.taskId_ = scheduler->GetTaskId("bgp::RTFilter"); + s1.cbFn_ = boost::bind(&BgpShowHandler< + ShowRtGroupPeerReq, + ShowRtGroupPeerReqIterate, + ShowRtGroupPeerResp, + ShowRtGroupInfo>::Callback, _1, _2, _3, _4, _5); + s1.allocFn_ = BgpShowHandler< + ShowRtGroupPeerReq, + ShowRtGroupPeerReqIterate, + ShowRtGroupPeerResp, + ShowRtGroupInfo>::CreateData; + s1.instances_.push_back(0); + ps.stages_.push_back(s1); + RequestPipeline rp(ps); +} + +// +// Handler for ShowRtGroupPeerReqIterate. +// +void ShowRtGroupPeerReqIterate::HandleRequest() const { + RequestPipeline::PipeSpec ps(this); + RequestPipeline::StageSpec s1; + TaskScheduler *scheduler = TaskScheduler::GetInstance(); + + s1.taskId_ = scheduler->GetTaskId("bgp::RTFilter"); + s1.cbFn_ = boost::bind(&BgpShowHandler< + ShowRtGroupPeerReq, + ShowRtGroupPeerReqIterate, + ShowRtGroupPeerResp, + ShowRtGroupInfo>::CallbackIterate, _1, _2, _3, _4, _5); + s1.allocFn_ = BgpShowHandler< + ShowRtGroupPeerReq, + ShowRtGroupPeerReqIterate, + ShowRtGroupPeerResp, + ShowRtGroupInfo>::CreateData; + s1.instances_.push_back(0); + ps.stages_.push_back(s1); + RequestPipeline rp(ps); +} diff --git a/src/bgp/routing-instance/SConscript b/src/bgp/routing-instance/SConscript index 59e113aefc0..a87e220260e 100644 --- a/src/bgp/routing-instance/SConscript +++ b/src/bgp/routing-instance/SConscript @@ -16,7 +16,6 @@ env.Append(CPPPATH = [env['TOP'] + '/io']) SandeshGenFiles = env.SandeshGenCpp('routing_instance_analytics.sandesh') SandeshGenFiles += env.SandeshGenCpp('service_chaining.sandesh') SandeshGenFiles += env.SandeshGenCpp('static_route.sandesh') -SandeshGenFiles += env.SandeshGenCpp('rtarget_group.sandesh') SandeshGenSrcs = env.ExtractCpp(SandeshGenFiles) librouting_instance = env.Library('routing_instance', SandeshGenSrcs + diff --git a/src/bgp/routing-instance/routing_instance.cc b/src/bgp/routing-instance/routing_instance.cc index a7532a1b0cf..f2d4389856d 100644 --- a/src/bgp/routing-instance/routing_instance.cc +++ b/src/bgp/routing-instance/routing_instance.cc @@ -780,7 +780,7 @@ BgpTable *RoutingInstance::VpnTableCreate(Address::Family vpn_family) { AddTable(table); RTINSTANCE_LOG_TABLE(Create, this, table, SandeshLevel::SYS_DEBUG, RTINSTANCE_LOG_FLAG_ALL); - assert(server_->rtarget_group_mgr()->GetRtGroupMap().empty()); + assert(server_->rtarget_group_mgr()->empty()); RoutePathReplicator *replicator = server_->replicator(vpn_family); replicator->Initialize(); return table; diff --git a/src/bgp/routing-instance/rtarget_group.cc b/src/bgp/routing-instance/rtarget_group.cc index 4438ab12b8c..6c4b40ee1bb 100644 --- a/src/bgp/routing-instance/rtarget_group.cc +++ b/src/bgp/routing-instance/rtarget_group.cc @@ -7,8 +7,8 @@ #include #include +#include "bgp/bgp_peer_types.h" #include "bgp/bgp_route.h" -#include "bgp/routing-instance/rtarget_group_types.h" #include "bgp/rtarget/rtarget_route.h" using std::pair; @@ -174,9 +174,9 @@ bool RtGroup::HasInterestedPeer(const string &name) const { } void RtGroup::FillMemberTables(const RtGroupMembers &rt_members, - vector *member_list) const { + vector *member_list) const { BOOST_FOREACH(const RtGroupMembers::value_type &rt_tables, rt_members) { - MemberTableList member; + ShowRtGroupMemberTableList member; vector table_names; BOOST_FOREACH(BgpTable *table, rt_tables.second) { table_names.push_back(table->name()); @@ -205,12 +205,12 @@ void RtGroup::FillDependentRoutes(vector *rtlist) const { void RtGroup::FillShowInfoCommon(ShowRtGroupInfo *info, bool fill_peers, bool fill_routes) const { - info->set_rtarget(rt_.ToString()); + info->set_rtarget(ToString()); - vector import_members; + vector import_members; FillMemberTables(import_, &import_members); info->set_import_members(import_members); - vector export_members; + vector export_members; FillMemberTables(export_, &export_members); info->set_export_members(export_members); diff --git a/src/bgp/routing-instance/rtarget_group.h b/src/bgp/routing-instance/rtarget_group.h index 3bcf7cab1c9..f8ebc5683a3 100644 --- a/src/bgp/routing-instance/rtarget_group.h +++ b/src/bgp/routing-instance/rtarget_group.h @@ -15,7 +15,7 @@ class BgpRoute; class RTargetRoute; -class MemberTableList; +class ShowRtGroupMemberTableList; class ShowRtGroupInfo; class RtGroupInterestedPeerSet : public BitSet { @@ -65,6 +65,7 @@ class RtGroup { explicit RtGroup(const RouteTarget &rt); const RouteTarget &rt(); + std::string ToString() const { return rt_.ToString(); } bool MayDelete() const; const RtGroupMemberList GetImportTables(Address::Family family) const; @@ -95,7 +96,7 @@ class RtGroup { private: void FillMemberTables(const RtGroupMembers &rt_members, - std::vector *member_list) const; + std::vector *member_list) const; void FillInterestedPeers(std::vector *interested_peers) const; void FillDependentRoutes(std::vector *rtlist) const; void FillShowInfoCommon( diff --git a/src/bgp/routing-instance/rtarget_group.sandesh b/src/bgp/routing-instance/rtarget_group.sandesh deleted file mode 100644 index 58cbddeafde..00000000000 --- a/src/bgp/routing-instance/rtarget_group.sandesh +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved. - */ - -struct MemberTableList { - 1: string family; - 2: list tables; -} - -struct ShowRtGroupInfo { - 1: string rtarget (link="ShowRtGroupReq"); - 2: list import_members; - 3: list export_members; - 4: optional list peers_interested; - 5: optional list dep_route; -} - -response sandesh ShowRtGroupResp { - 1: list rtgroup_list; -} - -request sandesh ShowRtGroupReq { - 1: string rtarget; -} - -response sandesh ShowRtGroupPeerResp { - 1: list rtgroup_list; -} - -request sandesh ShowRtGroupPeerReq { - 1: string peer; -} - -response sandesh ShowRtGroupSummaryResp { - 1: list rtgroup_list; -} - -request sandesh ShowRtGroupSummaryReq { -} diff --git a/src/bgp/routing-instance/rtarget_group_mgr.cc b/src/bgp/routing-instance/rtarget_group_mgr.cc index fb21b2b9acf..4bfc5805a38 100644 --- a/src/bgp/routing-instance/rtarget_group_mgr.cc +++ b/src/bgp/routing-instance/rtarget_group_mgr.cc @@ -73,10 +73,6 @@ RTargetGroupMgr::RTargetGroupMgr(BgpServer *server) : server_(server), rtfilter_task_id_ = scheduler->GetTaskId("bgp::RTFilter"); } - process_queue_ = - new WorkQueue(rtfilter_task_id_, 0, - boost::bind(&RTargetGroupMgr::RequestHandler, this, _1)); - for (int i = 0; i < DB::PartitionCount(); i++) { rtarget_dep_triggers_.push_back(boost::shared_ptr(new TaskTrigger(boost::bind(&RTargetGroupMgr::ProcessRouteTargetList, @@ -85,114 +81,6 @@ RTargetGroupMgr::RTargetGroupMgr(BgpServer *server) : server_(server), } } -bool RTargetGroupMgr::RequestHandler(RtGroupMgrReq *req) { - CHECK_CONCURRENCY("bgp::RTFilter"); - - switch (req->type_) { - case RtGroupMgrReq::SHOW_RTGROUP: { - ShowRtGroupResp *snh_resp = - static_cast(req->snh_resp_); - std::vector rtgroup_info_list; - if (req->param_.empty()) { - for (RtGroupMap::const_iterator it = rtgroup_map_.begin(); - it != rtgroup_map_.end(); it++) { - ShowRtGroupInfo info; - const RtGroup *rtgroup = it->second; - rtgroup->FillShowInfo(&info); - rtgroup_info_list.push_back(info); - } - } else { - RouteTarget rtarget = RouteTarget::FromString(req->param_); - RtGroupMap::const_iterator it = rtgroup_map_.find(rtarget); - if (it != rtgroup_map_.end()) { - ShowRtGroupInfo info; - const RtGroup *rtgroup = it->second; - rtgroup->FillShowInfo(&info); - rtgroup_info_list.push_back(info); - } - } - - snh_resp->set_rtgroup_list(rtgroup_info_list); - snh_resp->Response(); - break; - } - case RtGroupMgrReq::SHOW_RTGROUP_PEER: { - ShowRtGroupPeerResp *snh_resp = - static_cast(req->snh_resp_); - std::vector rtgroup_info_list; - for (RtGroupMap::iterator it = rtgroup_map_.begin(); - it != rtgroup_map_.end(); it++) { - ShowRtGroupInfo info; - RtGroup *rtgroup = it->second; - if (!rtgroup->HasInterestedPeer(req->param_)) - continue; - rtgroup->FillShowPeerInfo(&info); - rtgroup_info_list.push_back(info); - } - - snh_resp->set_rtgroup_list(rtgroup_info_list); - snh_resp->Response(); - break; - } - case RtGroupMgrReq::SHOW_RTGROUP_SUMMARY: { - ShowRtGroupSummaryResp *snh_resp = - static_cast(req->snh_resp_); - std::vector rtgroup_info_list; - for (RtGroupMap::iterator it = rtgroup_map_.begin(); - it != rtgroup_map_.end(); it++) { - ShowRtGroupInfo info; - RtGroup *rtgroup = it->second; - rtgroup->FillShowSummaryInfo(&info); - rtgroup_info_list.push_back(info); - } - - snh_resp->set_rtgroup_list(rtgroup_info_list); - snh_resp->Response(); - break; - } - default: { - break; - } - } - - delete req; - return true; -} - -void RTargetGroupMgr::Enqueue(RtGroupMgrReq *req) { - process_queue_->Enqueue(req); -} - -void ShowRtGroupReq::HandleRequest() const { - BgpSandeshContext *bsc = static_cast(client_context()); - RTargetGroupMgr *mgr = bsc->bgp_server->rtarget_group_mgr(); - ShowRtGroupResp *resp = new ShowRtGroupResp; - resp->set_context(context()); - RtGroupMgrReq *req = - new RtGroupMgrReq(RtGroupMgrReq::SHOW_RTGROUP, resp, get_rtarget()); - mgr->Enqueue(req); -} - -void ShowRtGroupPeerReq::HandleRequest() const { - BgpSandeshContext *bsc = static_cast(client_context()); - RTargetGroupMgr *mgr = bsc->bgp_server->rtarget_group_mgr(); - ShowRtGroupPeerResp *resp = new ShowRtGroupPeerResp; - resp->set_context(context()); - RtGroupMgrReq *req = - new RtGroupMgrReq(RtGroupMgrReq::SHOW_RTGROUP_PEER, resp, get_peer()); - mgr->Enqueue(req); -} - -void ShowRtGroupSummaryReq::HandleRequest() const { - BgpSandeshContext *bsc = static_cast(client_context()); - RTargetGroupMgr *mgr = bsc->bgp_server->rtarget_group_mgr(); - ShowRtGroupSummaryResp *resp = new ShowRtGroupSummaryResp; - resp->set_context(context()); - RtGroupMgrReq *req = - new RtGroupMgrReq(RtGroupMgrReq::SHOW_RTGROUP_SUMMARY, resp); - mgr->Enqueue(req); -} - void RTargetGroupMgr::RTargetPeerSync(BgpTable *table, RTargetRoute *rt, DBTableBase::ListenerId id, RTargetState *dbstate, const RtGroup::InterestedPeerList *future) { @@ -464,7 +352,6 @@ bool RTargetGroupMgr::RTargetRouteNotify(DBTablePartBase *root, } RTargetGroupMgr::~RTargetGroupMgr() { - delete process_queue_; assert(rtgroup_map_.empty()); } diff --git a/src/bgp/routing-instance/rtarget_group_mgr.h b/src/bgp/routing-instance/rtarget_group_mgr.h index e048779c213..285f13dd38c 100644 --- a/src/bgp/routing-instance/rtarget_group_mgr.h +++ b/src/bgp/routing-instance/rtarget_group_mgr.h @@ -24,7 +24,6 @@ #include "bgp/bgp_route.h" #include "bgp/community.h" #include "bgp/routing-instance/rtarget_group.h" -#include "bgp/routing-instance/rtarget_group_types.h" #include "bgp/rtarget/rtarget_address.h" #include "db/db_table_partition.h" @@ -203,20 +202,22 @@ struct RtGroupMgrReq { class RTargetGroupMgr { public: typedef boost::ptr_map RtGroupMap; - typedef std::map RtGroupMgrTableStateList; - typedef std::set RTargetRouteTriggerList; - typedef std::set RouteTargetTriggerList; - typedef std::set RtGroupRemoveList; + typedef RtGroupMap::const_iterator const_iterator; explicit RTargetGroupMgr(BgpServer *server); virtual ~RTargetGroupMgr(); + bool empty() const { return rtgroup_map_.empty(); } + const_iterator begin() const { return rtgroup_map_.begin(); } + const_iterator end() const { return rtgroup_map_.end(); } + const_iterator lower_bound(const RouteTarget &rt) const { + return rtgroup_map_.lower_bound(rt); + } + // RtGroup RtGroup *GetRtGroup(const RouteTarget &rt); RtGroup *GetRtGroup(const ExtCommunity::ExtCommunityValue &comm); RtGroup *LocateRtGroup(const RouteTarget &rt); - RtGroupMap &GetRtGroupMap() { return rtgroup_map_; } void NotifyRtGroup(const RouteTarget &rt); void RemoveRtGroup(const RouteTarget &rt); @@ -236,6 +237,12 @@ class RTargetGroupMgr { friend class BgpXmppRTargetTest; friend class ReplicationTest; + typedef std::map RtGroupMgrTableStateList; + typedef std::set RTargetRouteTriggerList; + typedef std::set RouteTargetTriggerList; + typedef std::set RtGroupRemoveList; + void RTargetDepSync(DBTablePartBase *root, BgpRoute *rt, DBTableBase::ListenerId id, VpnRouteState *dbstate, const VpnRouteState::RTargetList *future); @@ -278,7 +285,6 @@ class RTargetGroupMgr { RTargetRouteTriggerList rtarget_route_list_; std::vector rtarget_trigger_lists_; RtGroupRemoveList rtgroup_remove_list_; - WorkQueue *process_queue_; LifetimeRef master_instance_delete_ref_; DISALLOW_COPY_AND_ASSIGN(RTargetGroupMgr); diff --git a/src/bgp/rtarget/rtarget_address.cc b/src/bgp/rtarget/rtarget_address.cc index ea1a2d4c525..06e0ef459ee 100644 --- a/src/bgp/rtarget/rtarget_address.cc +++ b/src/bgp/rtarget/rtarget_address.cc @@ -23,13 +23,14 @@ RouteTarget::RouteTarget(const bytes_type &data) { } const uint64_t RouteTarget::GetExtCommunityValue() const { - return get_value(data_.begin(), 8); + return get_value(data_.begin(), 8); } RouteTarget RouteTarget::FromString(const string &str, boost::system::error_code *errorp) { RouteTarget rt; uint8_t data[RouteTarget::kSize]; + // target:1:2 OR target:1.2.3.4:3 size_t pos = str.find(':'); if (pos == string::npos) { diff --git a/src/bgp/test/SConscript b/src/bgp/test/SConscript index 0387210c098..941d1d7bacd 100644 --- a/src/bgp/test/SConscript +++ b/src/bgp/test/SConscript @@ -250,6 +250,11 @@ bgp_show_routing_instance_test = env.UnitTest('bgp_show_routing_instance_test', env.Alias('src/bgp:bgp_show_routing_instance_test', bgp_show_routing_instance_test) +bgp_show_rtarget_group_test = env.UnitTest('bgp_show_rtarget_group_test', + ['bgp_show_rtarget_group_test.cc']) +env.Alias('src/bgp:bgp_show_rtarget_group_test', + bgp_show_rtarget_group_test) + bgp_stress_test = env.UnitTest('bgp_stress_test', ['bgp_stress_test.cc']) env.Alias('src/bgp:bgp_stress_test', bgp_stress_test) @@ -417,6 +422,7 @@ test_suite = [ bgp_show_neighbor_test, bgp_show_route_summary_test, bgp_show_routing_instance_test, + bgp_show_rtarget_group_test, bgp_stress_test, bgp_table_export_test, bgp_table_test, diff --git a/src/bgp/test/bgp_show_rtarget_group_test.cc b/src/bgp/test/bgp_show_rtarget_group_test.cc new file mode 100644 index 00000000000..ce743ea17d2 --- /dev/null +++ b/src/bgp/test/bgp_show_rtarget_group_test.cc @@ -0,0 +1,676 @@ +/* + * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved. + */ + +#include "base/test/task_test_util.h" +#include "bgp/bgp_config.h" +#include "bgp/bgp_factory.h" +#include "bgp/bgp_sandesh.h" +#include "bgp/bgp_session_manager.h" +#include "bgp/test/bgp_server_test_util.h" +#include "bgp/test/bgp_test_util.h" +#include "bgp/xmpp_message_builder.h" +#include "control-node/control_node.h" +#include "control-node/test/network_agent_mock.h" +#include "ifmap/ifmap_server_parser.h" +#include "ifmap/test/ifmap_test_util.h" +#include "io/test/event_manager_test.h" +#include "schema/bgp_schema_types.h" +#include "schema/vnc_cfg_types.h" +#include "testing/gunit.h" + +using std::cout; +using std::endl; +using std::string; +using std::vector; + +static const char *config_template = "\ +\ + \ + 192.168.0.1\ + 64512\ +
127.0.0.1
\ + %d\ + \ +\ +"; + +class BgpShowRtGroupTest : public ::testing::Test { +public: + void ValidateResponse(Sandesh *sandesh, + vector &result, const string &next_batch) { + const ShowRtGroupResp *resp = + dynamic_cast(sandesh); + TASK_UTIL_EXPECT_TRUE(resp != NULL); + TASK_UTIL_EXPECT_EQ(result.size(), resp->get_rtgroup_list().size()); + TASK_UTIL_EXPECT_EQ(next_batch, resp->get_next_batch()); + for (size_t i = 0; i < resp->get_rtgroup_list().size(); ++i) { + TASK_UTIL_EXPECT_EQ(result[i], + resp->get_rtgroup_list()[i].get_rtarget()); + cout << resp->get_rtgroup_list()[i].log() << endl; + } + validate_done_ = true; + } + +protected: + BgpShowRtGroupTest() + : thread_(&evm_), validate_done_(false) { + } + + virtual void SetUp() { + IFMapServerParser *parser = IFMapServerParser::GetInstance("schema"); + bgp_schema_ParserInit(parser); + vnc_cfg_ParserInit(parser); + + server_.reset(new BgpServerTest(&evm_, "X")); + server_->session_manager()->Initialize(0); + sandesh_context_.bgp_server = server_.get(); + Sandesh::set_client_context(&sandesh_context_); + + thread_.Start(); + Configure(); + task_util::WaitForIdle(); + } + + virtual void TearDown() { + server_->Shutdown(); + task_util::WaitForIdle(); + + IFMapCleanUp(); + task_util::WaitForIdle(); + + evm_.Shutdown(); + thread_.Join(); + task_util::WaitForIdle(); + } + + void IFMapCleanUp() { + IFMapServerParser::GetInstance("vnc_cfg")->MetadataClear("vnc_cfg"); + IFMapServerParser::GetInstance("schema")->MetadataClear("schema"); + } + + void Configure() { + char config[4096]; + snprintf(config, sizeof(config), config_template, + server_->session_manager()->GetPort()); + server_->Configure(config); + task_util::WaitForIdle(); + + TASK_UTIL_EXPECT_EQ(64512, server_->autonomous_system()); + TASK_UTIL_EXPECT_EQ(64512, server_->local_autonomous_system()); + + vector instance_names; + for (int idx = 1; idx <= 12; ++idx) { + string vn_name = string("vn") + integerToString(idx); + instance_names.push_back(vn_name); + } + NetworkConfig(instance_names); + VerifyNetworkConfig(instance_names); + } + + void NetworkConfig(const vector &instance_names) { + string netconf(bgp_util::NetworkConfigGenerate(instance_names)); + IFMapServerParser *parser = IFMapServerParser::GetInstance("schema"); + parser->Receive( + server_->config_db(), netconf.data(), netconf.length(), 0); + task_util::WaitForIdle(); + } + + void VerifyNetworkConfig(const vector &instance_names) { + RoutingInstanceMgr *rim = server_->routing_instance_mgr(); + int idx = 1; + for (vector::const_iterator iter = instance_names.begin(); + iter != instance_names.end(); ++iter, ++idx) { + TASK_UTIL_EXPECT_TRUE(rim->GetRoutingInstance(*iter) != NULL); + const RoutingInstance *rtinstance = rim->GetRoutingInstance(*iter); + TASK_UTIL_EXPECT_EQ(1, rtinstance->GetExportList().size()); + string rtarget_str = string("target:64496:") + integerToString(idx); + TASK_UTIL_EXPECT_EQ(rtarget_str, + rtinstance->GetExportList().begin()->ToString()); + } + } + + string GetRTargetName(int idx) { + string rtarget_name("target:64496:"); + rtarget_name += integerToString(idx); + return rtarget_name; + } + + void AddRTargetName(vector *rtarget_names, int idx) { + rtarget_names->push_back(GetRTargetName(idx)); + } + + EventManager evm_; + ServerThread thread_; + boost::scoped_ptr server_; + bool validate_done_; + BgpSandeshContext sandesh_context_; +}; + +// Parameterize the iteration limit. +class BgpShowRtGroupParamTest : + public BgpShowRtGroupTest, + public ::testing::WithParamInterface { +}; + +// +// Next rtarget = empty +// Page limit = 64 (default) +// Should return all rtargets. +// +TEST_P(BgpShowRtGroupParamTest, Request1) { + sandesh_context_.set_page_limit(0); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 1; idx <= 12; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReq *req = new ShowRtGroupReq; + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = empty +// Page limit = 12 (number of rtargets) +// Should return all rtargets. +// +TEST_P(BgpShowRtGroupParamTest, Request2) { + sandesh_context_.set_page_limit(12); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 1; idx <= 12; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReq *req = new ShowRtGroupReq; + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = empty +// Page limit = 4 +// Should return first 4 rtargets. +// +TEST_P(BgpShowRtGroupParamTest, Request3) { + sandesh_context_.set_page_limit(4); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 1; idx <= 4; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch = GetRTargetName(5) + "||"; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReq *req = new ShowRtGroupReq; + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = empty +// Page limit = 64 (default) +// Search string = "" +// Should return all rtargets. +// +TEST_P(BgpShowRtGroupParamTest, RequestWithSearch1) { + sandesh_context_.set_page_limit(0); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 1; idx <= 12; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReq *req = new ShowRtGroupReq; + req->set_search_string(""); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = empty +// Page limit = 64 (default) +// Search string = "64496" +// Should return all rtargets with "64496". +// +TEST_P(BgpShowRtGroupParamTest, RequestWithSearch2) { + sandesh_context_.set_page_limit(0); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 1; idx <= 12; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReq *req = new ShowRtGroupReq; + req->set_search_string("64496"); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = empty +// Page limit = 12 (number of matching rtargets) +// Search string = "64496" +// Should return all rtargets with "64496". +// +TEST_P(BgpShowRtGroupParamTest, RequestWithSearch3) { + sandesh_context_.set_page_limit(12); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 1; idx <= 12; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReq *req = new ShowRtGroupReq; + req->set_search_string("64496"); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = empty +// Page limit = 4 +// Search string = "64496" +// Should return first 4 rtargets with "64496". +// +TEST_P(BgpShowRtGroupParamTest, RequestWithSearch4) { + sandesh_context_.set_page_limit(4); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 1; idx <= 4; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch = GetRTargetName(5) + "||64496"; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReq *req = new ShowRtGroupReq; + req->set_search_string("64496"); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = empty +// Page limit = 64 (default) +// Search string = "xyz" +// Should return empty list. +// +TEST_P(BgpShowRtGroupParamTest, RequestWithSearch5) { + sandesh_context_.set_page_limit(0); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReq *req = new ShowRtGroupReq; + req->set_search_string("xyz"); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = empty +// Page limit = 64 (default) +// Search string = "target:64496:7" +// Should return 1 rtarget. +// +TEST_P(BgpShowRtGroupParamTest, RequestWithSearch6) { + sandesh_context_.set_page_limit(0); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + AddRTargetName(&rtargets, 7); + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReq *req = new ShowRtGroupReq; + req->set_search_string(GetRTargetName(7)); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = empty +// Page limit = 1 +// Search string = "target:64496:7" +// Should return 1 rtarget. +// +TEST_P(BgpShowRtGroupParamTest, RequestWithSearch7) { + sandesh_context_.set_page_limit(1); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + AddRTargetName(&rtargets, 7); + string next_batch = GetRTargetName(8) + "||" + GetRTargetName(7); + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReq *req = new ShowRtGroupReq; + req->set_search_string(GetRTargetName(7)); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = "target:64496:2" +// Page limit = 64 (default) +// Should return all rtargets including and after "target:64496:2" +// +TEST_P(BgpShowRtGroupParamTest, RequestIterate1) { + sandesh_context_.set_page_limit(0); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 2; idx <= 12; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReqIterate *req = new ShowRtGroupReqIterate; + req->set_iterate_info(GetRTargetName(2) + "||"); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = "target:64496:2" +// Page limit = 11 +// Should return all rtargets including and after "target:64496:2" +// +TEST_P(BgpShowRtGroupParamTest, RequestIterate2) { + sandesh_context_.set_page_limit(11); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 2; idx <= 12; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReqIterate *req = new ShowRtGroupReqIterate; + req->set_iterate_info(GetRTargetName(2) + "||"); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = "target:64496:2" +// Page limit = 4 +// Should return first 4 rtargets including and after "target:64496:2" +// +TEST_P(BgpShowRtGroupParamTest, RequestIterate3) { + sandesh_context_.set_page_limit(4); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 2; idx <= 5; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch = GetRTargetName(6) + "||"; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReqIterate *req = new ShowRtGroupReqIterate; + req->set_iterate_info(GetRTargetName(2) + "||"); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = empty +// Page limit = 4 +// Should return empty list. +// +TEST_P(BgpShowRtGroupParamTest, RequestIterate4) { + sandesh_context_.set_page_limit(4); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReqIterate *req = new ShowRtGroupReqIterate; + req->set_iterate_info(""); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = malformed +// Page limit = 4 +// Should return empty list. +// +TEST_P(BgpShowRtGroupParamTest, RequestIterate5) { + sandesh_context_.set_page_limit(4); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReqIterate *req = new ShowRtGroupReqIterate; + req->set_iterate_info(GetRTargetName(2)); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = malformed +// Page limit = 4 +// Should return empty list. +// +TEST_P(BgpShowRtGroupParamTest, RequestIterate6) { + sandesh_context_.set_page_limit(4); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReqIterate *req = new ShowRtGroupReqIterate; + req->set_iterate_info(GetRTargetName(2) + "|"); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = "target:64496:19" +// Page limit = 4 +// Should return empty list. +// +TEST_P(BgpShowRtGroupParamTest, RequestIterate7) { + sandesh_context_.set_page_limit(4); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReqIterate *req = new ShowRtGroupReqIterate; + req->set_iterate_info(GetRTargetName(19) + "|"); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = "target:64496:2" +// Page limit = 64 (default) +// Search string = "target:64496:1" +// Should return 3 matching rtargets including and after "target:64496:10" +// +TEST_P(BgpShowRtGroupParamTest, RequestIterateWithSearch1) { + sandesh_context_.set_page_limit(0); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 10; idx <= 12; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReqIterate *req = new ShowRtGroupReqIterate; + req->set_iterate_info(GetRTargetName(2) + "||" + GetRTargetName(1)); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = "target:64496:2" +// Page limit = 3 +// Search string = "target:64496:1" +// Should return 3 matching rtargets including and after "target:64496:10" +// +TEST_P(BgpShowRtGroupParamTest, RequestIterateWithSearch2) { + sandesh_context_.set_page_limit(3); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 10; idx <= 12; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReqIterate *req = new ShowRtGroupReqIterate; + req->set_iterate_info(GetRTargetName(2) + "||" + GetRTargetName(1)); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = "target:64496:2" +// Page limit = 2 +// Search string = "target:64496:1" +// Should return 2 matching rtargets including and after "target:64496:10" +// +TEST_P(BgpShowRtGroupParamTest, RequestIterateWithSearch3) { + sandesh_context_.set_page_limit(2); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + for (int idx = 10; idx <= 11; ++idx) { + AddRTargetName(&rtargets, idx); + } + string next_batch = GetRTargetName(12) + "||" + GetRTargetName(1); + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReqIterate *req = new ShowRtGroupReqIterate; + req->set_iterate_info(GetRTargetName(2) + "||" + GetRTargetName(1)); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// +// Next rtarget = "target:64496:2" +// Page limit = 4 +// Search string = "target:64496:19" +// Should return empty list. +// +TEST_P(BgpShowRtGroupParamTest, RequestIterateWithSearch4) { + sandesh_context_.set_page_limit(4); + sandesh_context_.set_iter_limit(GetParam()); + vector rtargets; + string next_batch; + Sandesh::set_response_callback(boost::bind( + &BgpShowRtGroupParamTest::ValidateResponse, this, + _1, rtargets, next_batch)); + validate_done_ = false; + ShowRtGroupReqIterate *req = new ShowRtGroupReqIterate; + req->set_iterate_info(GetRTargetName(2) + "||" + GetRTargetName(19)); + req->HandleRequest(); + req->Release(); + TASK_UTIL_EXPECT_TRUE(validate_done_); +} + +// Instantiate for each value of iteration limit from 0 through 9. +// Note that 0 implies the default iteration limit. +INSTANTIATE_TEST_CASE_P(Instance, BgpShowRtGroupParamTest, + ::testing::Range(0, 10)); + +class TestEnvironment : public ::testing::Environment { + virtual ~TestEnvironment() { } +}; + +static void SetUp() { + ControlNode::SetDefaultSchedulingPolicy(); + BgpServerTest::GlobalSetUp(); + BgpObjectFactory::Register( + boost::factory()); +} + +static void TearDown() { + task_util::WaitForIdle(); + TaskScheduler *scheduler = TaskScheduler::GetInstance(); + scheduler->Terminate(); +} + +int main(int argc, char **argv) { + bgp_log_test::init(); + ::testing::InitGoogleTest(&argc, argv); + ::testing::AddGlobalTestEnvironment(new TestEnvironment()); + SetUp(); + int result = RUN_ALL_TESTS(); + TearDown(); + return result; +} diff --git a/src/bgp/test/bgp_xmpp_rtarget_test.cc b/src/bgp/test/bgp_xmpp_rtarget_test.cc index dc516d96716..70c318e0481 100644 --- a/src/bgp/test/bgp_xmpp_rtarget_test.cc +++ b/src/bgp/test/bgp_xmpp_rtarget_test.cc @@ -907,8 +907,7 @@ class BgpXmppRTargetTest : public ::testing::Test { TASK_UTIL_EXPECT_EQ(result.size(), resp->get_rtgroup_list().size()); cout << "*****************************************************" << endl; int i = 0; - BOOST_FOREACH(const ShowRtGroupInfo &info, - resp->get_rtgroup_list()) { + BOOST_FOREACH(const ShowRtGroupInfo &info, resp->get_rtgroup_list()) { TASK_UTIL_EXPECT_EQ(info.get_rtarget(), result[i]); cout << info.log() << endl; i++; @@ -927,8 +926,7 @@ class BgpXmppRTargetTest : public ::testing::Test { TASK_UTIL_EXPECT_EQ(result.size(), resp->get_rtgroup_list().size()); cout << "*****************************************************" << endl; int i = 0; - BOOST_FOREACH(const ShowRtGroupInfo &info, - resp->get_rtgroup_list()) { + BOOST_FOREACH(const ShowRtGroupInfo &info, resp->get_rtgroup_list()) { TASK_UTIL_EXPECT_EQ(info.get_rtarget(), result[i]); cout << info.log() << endl; i++; @@ -963,7 +961,7 @@ class BgpXmppRTargetTest : public ::testing::Test { Sandesh::set_response_callback( boost::bind(ValidateRTGroupResponse, _1, result)); ShowRtGroupReq *req = new ShowRtGroupReq; - req->set_rtarget(rtarget); + req->set_search_string(rtarget); validate_done_ = 0; req->HandleRequest(); req->Release(); @@ -980,7 +978,7 @@ class BgpXmppRTargetTest : public ::testing::Test { Sandesh::set_response_callback( boost::bind(ValidateRTGroupPeerResponse, _1, result)); ShowRtGroupPeerReq *req = new ShowRtGroupPeerReq; - req->set_peer(peer); + req->set_search_string(peer); validate_done_ = 0; req->HandleRequest(); req->Release(); @@ -2136,6 +2134,7 @@ TEST_F(BgpXmppRTargetTest, HTTPIntrospect3) { const BgpPeer *peer_cn2 = FindMatchingPeer(mx_.get(), "CN2"); EXPECT_TRUE(peer_cn2 != NULL); VerifyRtGroupPeerSandesh(mx_.get(), peer_cn2->peer_basename(), result); + VerifyRtGroupPeerSandesh(mx_.get(), string(), vector()); VerifyRtGroupPeerSandesh(mx_.get(), "undefined", vector()); VerifyRtGroupPeerSandesh(cn1_.get(), "undefined", vector());