From 729493034916093d4269c98345a7c06b18440048 Mon Sep 17 00:00:00 2001 From: Nipa Kumar Date: Tue, 7 Jul 2015 14:22:04 -0700 Subject: [PATCH] 1) Remove stale Xmpp Servers i.e the ones different from the list returned from Discovery Servers only if DOWN. (Note: Responses from discovery server are not applied if the current XMPP connection is UP) 2) Remove checkum code in discovery client library so all responses from Discovery Server are delivered to the end client. 3) Add introspect to show the responses from Discovery Server and currently connected Xmpp servers for both control-node and dns. Change-Id: I80c9a8446ef94db73db36144109e80b2432a07fd Closes-Bug:1471002 Closes-Bug:1396807 --- src/discovery/client/discovery_client.cc | 8 +- src/vnsw/agent/cmn/agent.h | 50 +++++++ src/vnsw/agent/controller/controller.sandesh | 41 +++++- src/vnsw/agent/controller/controller_init.cc | 81 ++++++----- .../agent/controller/controller_sandesh.cc | 133 ++++++++++++++++-- 5 files changed, 265 insertions(+), 48 deletions(-) diff --git a/src/discovery/client/discovery_client.cc b/src/discovery/client/discovery_client.cc index ef57342ea8d..b895d9290ed 100644 --- a/src/discovery/client/discovery_client.cc +++ b/src/discovery/client/discovery_client.cc @@ -644,7 +644,7 @@ void DiscoveryServiceClient::SubscribeResponseHandler(std::string &xmls, hdr->sub_rcvd_++; hdr->attempts_ = 0; - if ((hdr->chksum_ == gen_chksum) || (ds_response.size() == 0)) { + if (ds_response.size() == 0) { //Restart Subscribe Timer hdr->StartSubscribeTimer(ttl); DISCOVERY_CLIENT_TRACE(DiscoveryClientMsg, "SubscribeResponseHandler", @@ -656,8 +656,10 @@ void DiscoveryServiceClient::SubscribeResponseHandler(std::string &xmls, return; //No change in message, ignore } - DISCOVERY_CLIENT_TRACE(DiscoveryClientMsg, "SubscribeResponseHandler", - serviceName, xmls); + if (hdr->chksum_ != gen_chksum) { + DISCOVERY_CLIENT_TRACE(DiscoveryClientMsg, "SubscribeResponseHandler", + serviceName, xmls); + } // Update connection info ConnectionState::GetInstance()->Update(ConnectionType::DISCOVERY, serviceName, ConnectionStatus::UP, ds_endpoint_, diff --git a/src/vnsw/agent/cmn/agent.h b/src/vnsw/agent/cmn/agent.h index 42fd2f37a2c..8db1564fde2 100644 --- a/src/vnsw/agent/cmn/agent.h +++ b/src/vnsw/agent/cmn/agent.h @@ -391,6 +391,50 @@ class Agent { // TODO: Should they be moved under controller/dns/cfg? + // Discovery Control-Node Server Response + const std::string &controller_ifmap_discovery_xmpp_server(uint8_t idx) const { + return xs_disc_addr_[idx]; + } + void set_controller_ifmap_discovery_xmpp_server(const std::string &addr, uint8_t idx) { + xs_disc_addr_[idx] = addr; + } + const uint32_t controller_ifmap_discovery_xmpp_port(uint8_t idx) const { + return xs_disc_port_[idx]; + } + void set_controller_ifmap_discovery_xmpp_port(uint32_t port, uint8_t idx) { + xs_disc_port_[idx] = port; + } + void reset_controller_ifmap_discovery_xmpp_servers() { + uint8_t count = 0; + while (count < MAX_XMPP_SERVERS) { + xs_disc_addr_[count].clear(); + xs_disc_port_[count] = 0; + count++; + } + } + + // Discovery Dns Server Response + const std::string &dns_discovery_server(uint8_t idx) const { + return dns_disc_addr_[idx]; + } + void set_dns_discovery_server(const std::string &addr, uint8_t idx) { + dns_disc_addr_[idx] = addr; + } + const uint32_t dns_discovery_port(uint8_t idx) const { + return dns_disc_port_[idx]; + } + void set_dns_discovery_port(uint32_t port, uint8_t idx) { + dns_disc_port_[idx] = port; + } + void reset_dns_discovery_servers() { + uint8_t count = 0; + while (count < MAX_XMPP_SERVERS) { + dns_disc_addr_[count].clear(); + dns_disc_port_[count] = 0; + count++; + } + } + // Common XMPP Client for control-node and config clients const std::string &controller_ifmap_xmpp_server(uint8_t idx) const { return xs_addr_[idx]; @@ -967,6 +1011,12 @@ class Agent { int8_t xs_dns_idx_; std::string dns_addr_[MAX_XMPP_SERVERS]; uint32_t dns_port_[MAX_XMPP_SERVERS]; + // Discovery Responses + std::string xs_disc_addr_[MAX_XMPP_SERVERS]; + uint32_t xs_disc_port_[MAX_XMPP_SERVERS]; + std::string dns_disc_addr_[MAX_XMPP_SERVERS]; + uint32_t dns_disc_port_[MAX_XMPP_SERVERS]; + // Discovery std::string dss_addr_; uint32_t dss_port_; int dss_xs_instances_; diff --git a/src/vnsw/agent/controller/controller.sandesh b/src/vnsw/agent/controller/controller.sandesh index c69c2320409..d94afbbf3d7 100644 --- a/src/vnsw/agent/controller/controller.sandesh +++ b/src/vnsw/agent/controller/controller.sandesh @@ -21,7 +21,25 @@ struct AgentXmppData { 9: string flap_time; 10: ControllerProtoStats rx_proto_stats; 11: ControllerProtoStats tx_proto_stats; - 12: string xmpp_auth_enabled; +} + +struct AgentXmppDnsData { + 1: string dns_controller_ip; + 2: string state; + 3: string last_state; + 4: string last_event; + 5: string last_state_at; + 6: u32 flap_count; + 7: string flap_time; + 8: ControllerProtoStats rx_proto_stats; + 9: ControllerProtoStats tx_proto_stats; +} + +struct AgentDiscoveryXmppConnections { + 1: string agent_controller_ip; + 2: u32 agent_controller_port; + 3: string discovery_controller_ip; + 4: u32 discovery_controller_port; } traceobject sandesh AgentXmppTrace { @@ -101,3 +119,24 @@ request sandesh AgentXmppConnectionStatusReq { response sandesh AgentXmppConnectionStatus { 1: listpeer; } + +request sandesh AgentDnsXmppConnectionStatusReq { +} + +response sandesh AgentDnsXmppConnectionStatus { + 1: listpeer; +} + +request sandesh AgentDiscoveryXmppConnectionsRequest { +} + +response sandesh AgentDiscoveryXmppConnectionsResponse { + 1: listxmppc; +} + +request sandesh AgentDiscoveryDnsXmppConnectionsRequest { +} + +response sandesh AgentDiscoveryDnsXmppConnectionsResponse { + 1: listxmppc; +} diff --git a/src/vnsw/agent/controller/controller_init.cc b/src/vnsw/agent/controller/controller_init.cc index 3c585647823..32e349bef5e 100644 --- a/src/vnsw/agent/controller/controller_init.cc +++ b/src/vnsw/agent/controller/controller_init.cc @@ -309,31 +309,30 @@ void VNController::DeleteConnectionInfo(const std::string &addr, bool is_dns) void VNController::DisConnectControllerIfmapServer(uint8_t idx) { - DeleteConnectionInfo(agent_->controller_ifmap_xmpp_server(idx), - false); - - // Managed Delete of XmppClient object, which deletes the - // dependent XmppClientConnection object and - // scoped XmppChannel object - XmppClient *xc = agent_->controller_ifmap_xmpp_client(idx); - xc->UnRegisterConnectionEvent(xmps::BGP); - xc->Shutdown(); // ManagedDelete - agent_->set_controller_ifmap_xmpp_client(NULL, idx); - - //cleanup AgentXmppChannel - agent_->ResetAgentMcastLabelRange(idx); + DeleteConnectionInfo(agent_->controller_ifmap_xmpp_server(idx), false); + + // Managed Delete of XmppClient object, which deletes the + // dependent XmppClientConnection object and + // scoped XmppChannel object + XmppClient *xc = agent_->controller_ifmap_xmpp_client(idx); + xc->UnRegisterConnectionEvent(xmps::BGP); + xc->Shutdown(); // ManagedDelete + agent_->set_controller_ifmap_xmpp_client(NULL, idx); + + //cleanup AgentXmppChannel + agent_->ResetAgentMcastLabelRange(idx); DeleteAgentXmppChannel(agent_->controller_xmpp_channel(idx)); - agent_->set_controller_xmpp_channel(NULL, idx); + agent_->set_controller_xmpp_channel(NULL, idx); - //cleanup AgentIfmapXmppChannel + //cleanup AgentIfmapXmppChannel delete agent_->ifmap_xmpp_channel(idx); - agent_->set_ifmap_xmpp_channel(NULL, idx); + agent_->set_ifmap_xmpp_channel(NULL, idx); - agent_->controller_ifmap_xmpp_init(idx)->Reset(); - delete agent_->controller_ifmap_xmpp_init(idx); - agent_->set_controller_ifmap_xmpp_init(NULL, idx); + agent_->controller_ifmap_xmpp_init(idx)->Reset(); + delete agent_->controller_ifmap_xmpp_init(idx); + agent_->set_controller_ifmap_xmpp_init(NULL, idx); - agent_->reset_controller_ifmap_xmpp_server(idx); + agent_->reset_controller_ifmap_xmpp_server(idx); } bool VNController::AgentXmppServerExists(const std::string &server_ip, @@ -359,12 +358,17 @@ void VNController::ApplyDiscoveryXmppServices(std::vector resp) { bool VNController::ApplyDiscoveryXmppServicesInternal(std::vector resp) { std::vector::iterator iter; int8_t count = -1; + agent_->reset_controller_ifmap_discovery_xmpp_servers(); for (iter = resp.begin(); iter != resp.end(); iter++) { DSResponse dr = *iter; count ++; CONTROLLER_TRACE(DiscoveryConnection, "XMPP Discovery Server Response", count, dr.ep.address().to_string(), integerToString(dr.ep.port())); + agent_->set_controller_ifmap_discovery_xmpp_server( + dr.ep.address().to_string(), count); + agent_->set_controller_ifmap_discovery_xmpp_port( + dr.ep.port(), count); AgentXmppChannel *chnl = FindAgentXmppChannel(dr.ep.address().to_string()); if (chnl) { @@ -424,17 +428,21 @@ bool VNController::ApplyDiscoveryXmppServicesInternal(std::vector re } } - /* Remove stale Servers */ + /* Remove stale Servers if DOWN */ for (uint8_t idx = 0; idx < MAX_XMPP_SERVERS; idx++) { if (agent_->controller_xmpp_channel(idx) != NULL) { if (!AgentXmppServerExists( - agent_->controller_ifmap_xmpp_server(idx), resp)) { + agent_->controller_ifmap_xmpp_server(idx), resp)) { - CONTROLLER_TRACE(DiscoveryConnection, "Cleanup Older Xmpp ", - idx, agent_->controller_ifmap_xmpp_server(idx), ""); - DisConnectControllerIfmapServer(idx); - agent_->reset_controller_ifmap_xmpp_server(idx); + if (agent_->controller_xmpp_channel(idx)->GetXmppChannel()-> + GetPeerState() == xmps::NOT_READY) { + + CONTROLLER_TRACE(DiscoveryConnection, "Cleanup Older Xmpp ", + idx, agent_->controller_ifmap_xmpp_server(idx), ""); + DisConnectControllerIfmapServer(idx); + agent_->reset_controller_ifmap_xmpp_server(idx); + } } } } @@ -487,12 +495,15 @@ void VNController::ApplyDiscoveryDnsXmppServices(std::vector resp) { std::vector::iterator iter; int8_t count = -1; + agent_->reset_dns_discovery_servers(); for (iter = resp.begin(); iter != resp.end(); iter++) { DSResponse dr = *iter; count++; CONTROLLER_TRACE(DiscoveryConnection, "DNS Discovery Server Response", count, dr.ep.address().to_string(), integerToString(dr.ep.port())); + agent_->set_dns_discovery_server(dr.ep.address().to_string(), count); + agent_->set_dns_discovery_port(dr.ep.port(), count); AgentDnsXmppChannel *chnl = FindAgentDnsXmppChannel(dr.ep.address().to_string()); if (chnl) { @@ -550,17 +561,21 @@ void VNController::ApplyDiscoveryDnsXmppServices(std::vector resp) { } } - /* Remove stale Servers */ + /* Remove stale Servers if DOWN*/ for (uint8_t idx = 0; idx < MAX_XMPP_SERVERS; idx++) { if (agent_->dns_xmpp_channel(idx) != NULL) { - if (AgentXmppServerExists( - agent_->dns_server(idx), resp)) { + if (!AgentXmppServerExists( + agent_->dns_server(idx), resp)) { + + if (agent_->dns_xmpp_channel(idx)->GetXmppChannel()-> + GetPeerState() == xmps::NOT_READY) { - CONTROLLER_TRACE(DiscoveryConnection, "Cleanup Older Dns Xmpp", - idx, agent_->dns_server(idx), ""); - DisConnectDnsServer(idx); - agent_->reset_dns_server(idx); + CONTROLLER_TRACE(DiscoveryConnection, "Cleanup Older Dns Xmpp", + idx, agent_->dns_server(idx), ""); + DisConnectDnsServer(idx); + agent_->reset_dns_server(idx); + } } } } diff --git a/src/vnsw/agent/controller/controller_sandesh.cc b/src/vnsw/agent/controller/controller_sandesh.cc index 3a1295c38d0..66468e02e10 100644 --- a/src/vnsw/agent/controller/controller_sandesh.cc +++ b/src/vnsw/agent/controller/controller_sandesh.cc @@ -7,10 +7,7 @@ #include #include #include -#include - -const char *ControllerSandesh::kAuthTypeNil = "NIL"; -const char *ControllerSandesh::kAuthTypeTls = "TLS"; +#include void AgentXmppConnectionStatusReq::HandleRequest() const { uint8_t count = 0; @@ -35,18 +32,13 @@ void AgentXmppConnectionStatusReq::HandleRequest() const { data.set_mcast_controller("No"); } - if (Agent::GetInstance()->ifmap_active_xmpp_server().compare(Agent::GetInstance()->controller_ifmap_xmpp_server(count)) == 0) { + if (Agent::GetInstance()->ifmap_active_xmpp_server().compare + (Agent::GetInstance()->controller_ifmap_xmpp_server(count)) == 0) { data.set_cfg_controller("Yes"); } else { data.set_cfg_controller("No"); } - if (Agent::GetInstance()->params()->xmpp_auth_enabled()) { - data.set_xmpp_auth_enabled(ControllerSandesh::kAuthTypeTls); - } else { - data.set_xmpp_auth_enabled(ControllerSandesh::kAuthTypeNil); - } - data.set_last_state(xc->LastStateName()); data.set_last_event(xc->LastEvent()); data.set_last_state_at(xc->LastStateChangeAt()); @@ -79,3 +71,122 @@ void AgentXmppConnectionStatusReq::HandleRequest() const { resp->set_more(false); resp->Response(); } + +void AgentDnsXmppConnectionStatusReq::HandleRequest() const { + uint8_t dns_count = 0; + + AgentDnsXmppConnectionStatus *resp = new AgentDnsXmppConnectionStatus(); + while (dns_count < MAX_XMPP_SERVERS) { + if (!Agent::GetInstance()->dns_server(dns_count).empty()) { + + AgentXmppDnsData data; + data.set_dns_controller_ip(Agent::GetInstance()->dns_server(dns_count)); + + AgentDnsXmppChannel *ch = Agent::GetInstance()->dns_xmpp_channel(dns_count); + if (ch) { + XmppChannel *xc = ch->GetXmppChannel(); + if (xc->GetPeerState() == xmps::READY) { + data.set_state("Established"); + } else { + data.set_state("Down"); + } + + data.set_last_state(xc->LastStateName()); + data.set_last_event(xc->LastEvent()); + data.set_last_state_at(xc->LastStateChangeAt()); + data.set_flap_count(xc->FlapCount()); + data.set_flap_time(xc->LastFlap()); + + ControllerProtoStats rx_proto_stats; + rx_proto_stats.open = xc->rx_open(); + rx_proto_stats.keepalive = xc->rx_keepalive(); + rx_proto_stats.update = xc->rx_update(); + rx_proto_stats.close = xc->rx_close(); + + ControllerProtoStats tx_proto_stats; + tx_proto_stats.open = xc->tx_open(); + tx_proto_stats.keepalive = xc->tx_keepalive(); + tx_proto_stats.update = xc->tx_update(); + tx_proto_stats.close = xc->tx_close(); + + data.set_rx_proto_stats(rx_proto_stats); + data.set_tx_proto_stats(tx_proto_stats); + } + + std::vector &list = + const_cast&>(resp->get_peer()); + list.push_back(data); + } + dns_count++; + } + resp->set_context(context()); + resp->set_more(false); + resp->Response(); +} + +void AgentDiscoveryXmppConnectionsRequest::HandleRequest() const { + uint8_t count = 0; + AgentDiscoveryXmppConnectionsResponse *resp = + new AgentDiscoveryXmppConnectionsResponse(); + + while (count < MAX_XMPP_SERVERS) { + + AgentDiscoveryXmppConnections data; + if (!Agent::GetInstance()->controller_ifmap_xmpp_server(count).empty()) { + data.set_agent_controller_ip( + Agent::GetInstance()->controller_ifmap_xmpp_server(count)); + data.set_agent_controller_port( + Agent::GetInstance()->controller_ifmap_xmpp_port(count)); + } + if (!Agent::GetInstance()-> + controller_ifmap_discovery_xmpp_server(count).empty()) { + data.set_discovery_controller_ip(Agent::GetInstance()-> + controller_ifmap_discovery_xmpp_server(count)); + data.set_discovery_controller_port(Agent::GetInstance()-> + controller_ifmap_discovery_xmpp_port(count)); + } + + std::vector &list = + const_cast&>(resp->get_xmppc()); + list.push_back(data); + + count++; + } + + resp->set_context(context()); + resp->set_more(false); + resp->Response(); +} + +void AgentDiscoveryDnsXmppConnectionsRequest::HandleRequest() const { + uint8_t dns_count = 0; + AgentDiscoveryDnsXmppConnectionsResponse *resp = + new AgentDiscoveryDnsXmppConnectionsResponse(); + + while (dns_count < MAX_XMPP_SERVERS) { + + AgentDiscoveryXmppConnections data; + if (!Agent::GetInstance()->dns_server(dns_count).empty()) { + data.set_agent_controller_ip( + Agent::GetInstance()->dns_server(dns_count)); + data.set_agent_controller_port( + Agent::GetInstance()->dns_server_port(dns_count)); + } + if (!Agent::GetInstance()->dns_discovery_server(dns_count).empty()) { + data.set_discovery_controller_ip( + Agent::GetInstance()->dns_discovery_server(dns_count)); + data.set_discovery_controller_port( + Agent::GetInstance()->dns_discovery_port(dns_count)); + } + + std::vector &list = + const_cast&>(resp->get_xmppc()); + list.push_back(data); + + dns_count++; + } + + resp->set_context(context()); + resp->set_more(false); + resp->Response(); +}