From 1317be2382c4aa0073f8047af76906a17145e6e5 Mon Sep 17 00:00:00 2001 From: Stephen Birarda Date: Mon, 25 Feb 2013 11:52:38 -0800 Subject: [PATCH 1/4] domain server only returns newest of types in SOLO_AGENT_TYPES_STRING --- domain/src/main.cpp | 36 +++++++++++++++++++++++++++++++----- shared/src/Agent.cpp | 3 +++ shared/src/Agent.h | 1 + shared/src/AgentList.cpp | 2 ++ shared/src/AgentList.h | 1 + 5 files changed, 38 insertions(+), 5 deletions(-) diff --git a/domain/src/main.cpp b/domain/src/main.cpp index 5f9b075c48..7dd89df557 100644 --- a/domain/src/main.cpp +++ b/domain/src/main.cpp @@ -27,6 +27,7 @@ #include #include #include +#include #include "AgentList.h" #include "SharedUtil.h" @@ -42,6 +43,15 @@ const int LOGOFF_CHECK_INTERVAL = 5000; int lastActiveCount = 0; AgentList agentList(DOMAIN_LISTEN_PORT); +unsigned char * addAgentToBroadcastPacket(unsigned char *currentPosition, Agent *agentToAdd) { + *currentPosition++ = agentToAdd->type; + + currentPosition += packSocket(currentPosition, agentToAdd->publicSocket); + currentPosition += packSocket(currentPosition, agentToAdd->localSocket); + + // return the new unsigned char * for broadcast packet + return currentPosition; +} int main(int argc, const char * argv[]) { @@ -60,6 +70,8 @@ int main(int argc, const char * argv[]) agentList.startSilentAgentRemovalThread(); + std::map newestSoloAgents; + while (true) { if (agentList.getAgentSocket()->receive((sockaddr *)&agentPublicAddress, packetData, &receivedBytes)) { agentType = packetData[0]; @@ -73,17 +85,31 @@ int main(int argc, const char * argv[]) for(std::vector::iterator agent = agentList.agents.begin(); agent != agentList.agents.end(); agent++) { if (DEBUG_TO_SELF || !agent->matches((sockaddr *)&agentPublicAddress, (sockaddr *)&agentLocalAddress, agentType)) { - *currentBufferPos++ = agent->type; - - currentBufferPos += packSocket(currentBufferPos, agent->publicSocket); - currentBufferPos += packSocket(currentBufferPos, agent->localSocket); + if (strchr(SOLO_AGENT_TYPES_STRING, (int) agent->type) == NULL) { + // this is an agent of which there can be multiple, just add them to the packet + currentBufferPos = addAgentToBroadcastPacket(currentBufferPos, &(*agent)); + } else { + std::cout << "We have a solo agent: " << &(*agent) << "\n"; + // solo agent, we need to only send newest + if (newestSoloAgents[agent->type] == NULL || + newestSoloAgents[agent->type]->firstRecvTimeUsecs < agent->firstRecvTimeUsecs) { + // we have to set the newer solo agent to add it to the broadcast later + newestSoloAgents[agent->type] = &(*agent); + } + } } else { // this is the agent, just update last receive to now agent->lastRecvTimeUsecs = usecTimestampNow(); } } - ; + for (std::map::iterator agentIterator = newestSoloAgents.begin(); + agentIterator != newestSoloAgents.end(); + agentIterator++) { + std::cout << "Newest agent: " << agentIterator->second << "\n"; + // this is the newest alive solo agent, add them to the packet + currentBufferPos = addAgentToBroadcastPacket(currentBufferPos, agentIterator->second); + } if ((packetBytesWithoutLeadingChar = (currentBufferPos - startPointer))) { agentList.getAgentSocket()->send((sockaddr *)&agentPublicAddress, broadcastPacket, packetBytesWithoutLeadingChar + 1); diff --git a/shared/src/Agent.cpp b/shared/src/Agent.cpp index 5b48033225..5790329c80 100644 --- a/shared/src/Agent.cpp +++ b/shared/src/Agent.cpp @@ -22,6 +22,8 @@ Agent::Agent(sockaddr *agentPublicSocket, sockaddr *agentLocalSocket, char agent memcpy(localSocket, agentLocalSocket, sizeof(sockaddr)); type = agentType; + + firstRecvTimeUsecs = usecTimestampNow(); lastRecvTimeUsecs = usecTimestampNow(); activeSocket = NULL; @@ -43,6 +45,7 @@ Agent::Agent(const Agent &otherAgent) { activeSocket = NULL; } + firstRecvTimeUsecs = otherAgent.firstRecvTimeUsecs; lastRecvTimeUsecs = otherAgent.lastRecvTimeUsecs; type = otherAgent.type; diff --git a/shared/src/Agent.h b/shared/src/Agent.h index efcebc3b05..90073a92b0 100644 --- a/shared/src/Agent.h +++ b/shared/src/Agent.h @@ -28,6 +28,7 @@ class Agent { char type; timeval pingStarted; int pingMsecs; + double firstRecvTimeUsecs; double lastRecvTimeUsecs; bool isSelf; AgentData *linkedData; diff --git a/shared/src/AgentList.cpp b/shared/src/AgentList.cpp index d068ab15fc..fdf4e430ff 100644 --- a/shared/src/AgentList.cpp +++ b/shared/src/AgentList.cpp @@ -11,6 +11,8 @@ #include #include "SharedUtil.h" +const char * SOLO_AGENT_TYPES_STRING = "M"; + bool stopAgentRemovalThread = false; pthread_mutex_t vectorChangeMutex = PTHREAD_MUTEX_INITIALIZER; diff --git a/shared/src/AgentList.h b/shared/src/AgentList.h index 399340b841..734d64da9e 100644 --- a/shared/src/AgentList.h +++ b/shared/src/AgentList.h @@ -16,6 +16,7 @@ const unsigned short AGENT_SOCKET_LISTEN_PORT = 40103; const int AGENT_SILENCE_THRESHOLD_USECS = 2 * 1000000; +extern const char *SOLO_AGENT_TYPES_STRINGg; class AgentList { public: From 4541a5fe7867ec5e1f58f776dddb9337b461b8f2 Mon Sep 17 00:00:00 2001 From: Stephen Birarda Date: Mon, 25 Feb 2013 12:24:42 -0800 Subject: [PATCH 2/4] AgentList returns agents vector and agentSocket by reference --- interface/src/main.cpp | 8 ++++---- shared/src/AgentList.cpp | 8 ++++++-- shared/src/AgentList.h | 15 +++++++++------ 3 files changed, 19 insertions(+), 12 deletions(-) diff --git a/interface/src/main.cpp b/interface/src/main.cpp index 44ed1b8ac9..9b3ad7a39f 100644 --- a/interface/src/main.cpp +++ b/interface/src/main.cpp @@ -223,7 +223,7 @@ void Timer(int extra) output[0] = 'I'; packSocket(output + 1, localAddress, htons(AGENT_SOCKET_LISTEN_PORT)); - agentList.getAgentSocket()->send(DOMAIN_IP, DOMAINSERVER_PORT, output, 7); + agentList.getAgentSocket().send(DOMAIN_IP, DOMAINSERVER_PORT, output, 7); // Ping the agents we can see agentList.pingAgents(); @@ -570,7 +570,7 @@ void display(void) if (display_field) field.render(); // Render heads of other agents - for(std::vector::iterator agent = agentList.agents.begin(); agent != agentList.agents.end(); agent++) { + for(std::vector::iterator agent = agentList.getAgents().begin(); agent != agentList.getAgents().end(); agent++) { if (agent->linkedData != NULL) { Head *agentHead = (Head *)agent->linkedData; glPushMatrix(); @@ -659,7 +659,7 @@ void display(void) // Draw number of nearby people always char agents[100]; - sprintf(agents, "Agents nearby: %ld\n", agentList.agents.size()); + sprintf(agents, "Agents nearby: %ld\n", agentList.getAgents().size()); drawtext(WIDTH-200,20, 0.10, 0, 1.0, 0, agents, 1, 1, 0); glPopMatrix(); @@ -744,7 +744,7 @@ void *networkReceive(void *args) char *incomingPacket = new char[MAX_PACKET_SIZE]; while (!stopNetworkReceiveThread) { - if (agentList.getAgentSocket()->receive(&senderAddress, incomingPacket, &bytesReceived)) { + if (agentList.getAgentSocket().receive(&senderAddress, incomingPacket, &bytesReceived)) { packetcount++; bytescount += bytesReceived; diff --git a/shared/src/AgentList.cpp b/shared/src/AgentList.cpp index fdf4e430ff..0a72c3065e 100644 --- a/shared/src/AgentList.cpp +++ b/shared/src/AgentList.cpp @@ -30,8 +30,12 @@ AgentList::~AgentList() { stopSilentAgentRemovalThread(); } -UDPSocket * AgentList::getAgentSocket() { - return &agentSocket; +std::vector& AgentList::getAgents() { + return agents; +} + +UDPSocket& AgentList::getAgentSocket() { + return agentSocket; } void AgentList::processAgentData(sockaddr *senderAddress, void *packetData, size_t dataBytes) { diff --git a/shared/src/AgentList.h b/shared/src/AgentList.h index 734d64da9e..2755058503 100644 --- a/shared/src/AgentList.h +++ b/shared/src/AgentList.h @@ -16,18 +16,19 @@ const unsigned short AGENT_SOCKET_LISTEN_PORT = 40103; const int AGENT_SILENCE_THRESHOLD_USECS = 2 * 1000000; -extern const char *SOLO_AGENT_TYPES_STRINGg; +extern const char *SOLO_AGENT_TYPES_STRING; class AgentList { public: AgentList(); AgentList(int socketListenPort); ~AgentList(); - std::vector agents; + void(*linkedDataCreateCallback)(Agent *); void(*audioMixerSocketUpdate)(in_addr_t, in_port_t); - - UDPSocket* getAgentSocket(); + + std::vector& getAgents(); + UDPSocket& getAgentSocket(); int updateList(unsigned char *packetData, size_t dataBytes); bool addOrUpdateAgent(sockaddr *publicSocket, sockaddr *localSocket, char agentType); @@ -38,11 +39,13 @@ class AgentList { void startSilentAgentRemovalThread(); void stopSilentAgentRemovalThread(); private: + UDPSocket agentSocket; + std::vector agents; + pthread_t removeSilentAgentsThread; + int indexOfMatchingAgent(sockaddr *senderAddress); void updateAgentWithData(sockaddr *senderAddress, void *packetData, size_t dataBytes); void handlePingReply(sockaddr *agentAddress); - UDPSocket agentSocket; - pthread_t removeSilentAgentsThread; }; #endif /* defined(__hifi__AgentList__) */ From d211eb6c84f5def959cab898524312441399aecb Mon Sep 17 00:00:00 2001 From: Stephen Birarda Date: Mon, 25 Feb 2013 12:51:52 -0800 Subject: [PATCH 3/4] use getters and setters for all member variables in AgentList and Agent --- domain/src/main.cpp | 22 ++++++------ interface/src/main.cpp | 10 +++--- shared/src/Agent.cpp | 75 ++++++++++++++++++++++++++++++++++++---- shared/src/Agent.h | 33 ++++++++++++------ shared/src/AgentList.cpp | 51 ++++++++++++--------------- 5 files changed, 129 insertions(+), 62 deletions(-) diff --git a/domain/src/main.cpp b/domain/src/main.cpp index 7dd89df557..424416ca6c 100644 --- a/domain/src/main.cpp +++ b/domain/src/main.cpp @@ -44,10 +44,10 @@ int lastActiveCount = 0; AgentList agentList(DOMAIN_LISTEN_PORT); unsigned char * addAgentToBroadcastPacket(unsigned char *currentPosition, Agent *agentToAdd) { - *currentPosition++ = agentToAdd->type; + *currentPosition++ = agentToAdd->getType(); - currentPosition += packSocket(currentPosition, agentToAdd->publicSocket); - currentPosition += packSocket(currentPosition, agentToAdd->localSocket); + currentPosition += packSocket(currentPosition, agentToAdd->getPublicSocket()); + currentPosition += packSocket(currentPosition, agentToAdd->getLocalSocket()); // return the new unsigned char * for broadcast packet return currentPosition; @@ -73,7 +73,7 @@ int main(int argc, const char * argv[]) std::map newestSoloAgents; while (true) { - if (agentList.getAgentSocket()->receive((sockaddr *)&agentPublicAddress, packetData, &receivedBytes)) { + if (agentList.getAgentSocket().receive((sockaddr *)&agentPublicAddress, packetData, &receivedBytes)) { agentType = packetData[0]; unpackSocket(&packetData[1], (sockaddr *)&agentLocalAddress); @@ -82,24 +82,24 @@ int main(int argc, const char * argv[]) currentBufferPos = broadcastPacket + 1; startPointer = currentBufferPos; - for(std::vector::iterator agent = agentList.agents.begin(); agent != agentList.agents.end(); agent++) { + for(std::vector::iterator agent = agentList.getAgents().begin(); agent != agentList.getAgents().end(); agent++) { if (DEBUG_TO_SELF || !agent->matches((sockaddr *)&agentPublicAddress, (sockaddr *)&agentLocalAddress, agentType)) { - if (strchr(SOLO_AGENT_TYPES_STRING, (int) agent->type) == NULL) { + if (strchr(SOLO_AGENT_TYPES_STRING, (int) agent->getType()) == NULL) { // this is an agent of which there can be multiple, just add them to the packet currentBufferPos = addAgentToBroadcastPacket(currentBufferPos, &(*agent)); } else { std::cout << "We have a solo agent: " << &(*agent) << "\n"; // solo agent, we need to only send newest - if (newestSoloAgents[agent->type] == NULL || - newestSoloAgents[agent->type]->firstRecvTimeUsecs < agent->firstRecvTimeUsecs) { + if (newestSoloAgents[agent->getType()] == NULL || + newestSoloAgents[agent->getType()]->getFirstRecvTimeUsecs() < agent->getFirstRecvTimeUsecs()) { // we have to set the newer solo agent to add it to the broadcast later - newestSoloAgents[agent->type] = &(*agent); + newestSoloAgents[agent->getType()] = &(*agent); } } } else { // this is the agent, just update last receive to now - agent->lastRecvTimeUsecs = usecTimestampNow(); + agent->setLastRecvTimeUsecs(usecTimestampNow()); } } @@ -112,7 +112,7 @@ int main(int argc, const char * argv[]) } if ((packetBytesWithoutLeadingChar = (currentBufferPos - startPointer))) { - agentList.getAgentSocket()->send((sockaddr *)&agentPublicAddress, broadcastPacket, packetBytesWithoutLeadingChar + 1); + agentList.getAgentSocket().send((sockaddr *)&agentPublicAddress, broadcastPacket, packetBytesWithoutLeadingChar + 1); } } } diff --git a/interface/src/main.cpp b/interface/src/main.cpp index 9b3ad7a39f..6d19004bfe 100644 --- a/interface/src/main.cpp +++ b/interface/src/main.cpp @@ -571,8 +571,8 @@ void display(void) // Render heads of other agents for(std::vector::iterator agent = agentList.getAgents().begin(); agent != agentList.getAgents().end(); agent++) { - if (agent->linkedData != NULL) { - Head *agentHead = (Head *)agent->linkedData; + if (agent->getLinkedData() != NULL) { + Head *agentHead = (Head *)agent->getLinkedData(); glPushMatrix(); glm::vec3 pos = agentHead->getPos(); glTranslatef(-pos.x, -pos.y, -pos.z); @@ -583,7 +583,7 @@ void display(void) if (!display_head) balls.render(); - // Render the world box + // Render the world box if (!display_head && stats_on) render_world_box(); // Render my own head @@ -851,8 +851,8 @@ void mouseoverFunc( int x, int y) } void attachNewHeadToAgent(Agent *newAgent) { - if (newAgent->linkedData == NULL) { - newAgent->linkedData = new Head(); + if (newAgent->getLinkedData() == NULL) { + newAgent->setLinkedData(new Head()); } } diff --git a/shared/src/Agent.cpp b/shared/src/Agent.cpp index 5790329c80..a635314b64 100644 --- a/shared/src/Agent.cpp +++ b/shared/src/Agent.cpp @@ -58,6 +58,75 @@ Agent& Agent::operator=(Agent otherAgent) { return *this; } +Agent::~Agent() { + delete publicSocket; + delete localSocket; + delete linkedData; +} + +char Agent::getType() { + return type; +} + +void Agent::setType(char newType) { + type = newType; +} + +double Agent::getFirstRecvTimeUsecs() { + return firstRecvTimeUsecs; +} + +void Agent::setFirstRecvTimeUsecs(double newTimeUsecs) { + firstRecvTimeUsecs = newTimeUsecs; +} + +double Agent::getLastRecvTimeUsecs() { + return lastRecvTimeUsecs; +} + +void Agent::setLastRecvTimeUsecs(double newTimeUsecs) { + lastRecvTimeUsecs = newTimeUsecs; +} + +sockaddr* Agent::getPublicSocket() { + return publicSocket; +} + +void Agent::setPublicSocket(sockaddr *newSocket) { + publicSocket = newSocket; +} + +sockaddr* Agent::getLocalSocket() { + return localSocket; +} + +void Agent::setLocalSocket(sockaddr *newSocket) { + publicSocket = newSocket; +} + +sockaddr* Agent::getActiveSocket() { + return activeSocket; +} + +void Agent::activateLocalSocket() { + activeSocket = localSocket; +} + +void Agent::activatePublicSocket() { + activeSocket = publicSocket; +} + + + +AgentData* Agent::getLinkedData() { + return linkedData; +} + +void Agent::setLinkedData(AgentData *newData) { + linkedData = newData; +} + + bool Agent::operator==(const Agent& otherAgent) { return matches(otherAgent.publicSocket, otherAgent.localSocket, otherAgent.type); } @@ -71,12 +140,6 @@ void Agent::swap(Agent &first, Agent &second) { swap(first.linkedData, second.linkedData); } -Agent::~Agent() { - delete publicSocket; - delete localSocket; - delete linkedData; -} - bool Agent::matches(sockaddr *otherPublicSocket, sockaddr *otherLocalSocket, char otherAgentType) { // checks if two agent objects are the same agent (same type + local + public address) return type == otherAgentType diff --git a/shared/src/Agent.h b/shared/src/Agent.h index 90073a92b0..dafbeb768f 100644 --- a/shared/src/Agent.h +++ b/shared/src/Agent.h @@ -18,24 +18,35 @@ class Agent { Agent(); Agent(sockaddr *agentPublicSocket, sockaddr *agentLocalSocket, char agentType); Agent(const Agent &otherAgent); + ~Agent(); Agent& operator=(Agent otherAgent); bool operator==(const Agent& otherAgent); - ~Agent(); - + bool matches(sockaddr *otherPublicSocket, sockaddr *otherLocalSocket, char otherAgentType); - - sockaddr *publicSocket, *localSocket, *activeSocket; - char type; - timeval pingStarted; - int pingMsecs; - double firstRecvTimeUsecs; - double lastRecvTimeUsecs; - bool isSelf; - AgentData *linkedData; + char getType(); + void setType(char newType); + double getFirstRecvTimeUsecs(); + void setFirstRecvTimeUsecs(double newTimeUsecs); + double getLastRecvTimeUsecs(); + void setLastRecvTimeUsecs(double newTimeUsecs); + sockaddr* getPublicSocket(); + void setPublicSocket(sockaddr *newSocket); + sockaddr* getLocalSocket(); + void setLocalSocket(sockaddr *newSocket); + sockaddr* getActiveSocket(); + void activatePublicSocket(); + void activateLocalSocket(); + AgentData* getLinkedData(); + void setLinkedData(AgentData *newData); friend std::ostream& operator<<(std::ostream& os, const Agent* agent); private: void swap(Agent &first, Agent &second); + sockaddr *publicSocket, *localSocket, *activeSocket; + char type; + double firstRecvTimeUsecs; + double lastRecvTimeUsecs; + AgentData *linkedData; }; std::ostream& operator<<(std::ostream& os, const Agent* agent); diff --git a/shared/src/AgentList.cpp b/shared/src/AgentList.cpp index 0a72c3065e..d1c4db24ce 100644 --- a/shared/src/AgentList.cpp +++ b/shared/src/AgentList.cpp @@ -75,22 +75,22 @@ void AgentList::updateAgentWithData(sockaddr *senderAddress, void *packetData, s if (agentIndex != -1) { Agent *matchingAgent = &agents[agentIndex]; - matchingAgent->lastRecvTimeUsecs = usecTimestampNow(); + matchingAgent->setLastRecvTimeUsecs(usecTimestampNow()); - if (matchingAgent->linkedData == NULL) { + if (matchingAgent->getLinkedData() == NULL) { if (linkedDataCreateCallback != NULL) { linkedDataCreateCallback(matchingAgent); } } - matchingAgent->linkedData->parseData(packetData, dataBytes); + matchingAgent->getLinkedData()->parseData(packetData, dataBytes); } } int AgentList::indexOfMatchingAgent(sockaddr *senderAddress) { for(std::vector::iterator agent = agents.begin(); agent != agents.end(); agent++) { - if (agent->activeSocket != NULL && socketMatch(agent->activeSocket, senderAddress)) { + if (agent->getActiveSocket() != NULL && socketMatch(agent->getActiveSocket(), senderAddress)) { return agent - agents.begin(); } } @@ -140,10 +140,10 @@ bool AgentList::addOrUpdateAgent(sockaddr *publicSocket, sockaddr *localSocket, if (socketMatch(publicSocket, localSocket)) { // likely debugging scenario with DS + agent on local network // set the agent active right away - newAgent.activeSocket = newAgent.localSocket; + newAgent.activatePublicSocket(); } - if (newAgent.type == 'M' && audioMixerSocketUpdate != NULL) { + if (newAgent.getType() == 'M' && audioMixerSocketUpdate != NULL) { // this is an audio mixer // for now that means we need to tell the audio class // to use the local socket information the domain server gave us @@ -160,10 +160,10 @@ bool AgentList::addOrUpdateAgent(sockaddr *publicSocket, sockaddr *localSocket, return true; } else { - if (agent->type == 'M') { + if (agent->getType() == 'M') { // until the Audio class also uses our agentList, we need to update // the lastRecvTimeUsecs for the audio mixer so it doesn't get killed and re-added continously - agent->lastRecvTimeUsecs = usecTimestampNow(); + agent->setLastRecvTimeUsecs(usecTimestampNow()); } // we had this agent already, do nothing for now @@ -175,9 +175,9 @@ void AgentList::broadcastToAgents(char *broadcastData, size_t dataBytes) { for(std::vector::iterator agent = agents.begin(); agent != agents.end(); agent++) { // for now assume we only want to send to other interface clients // until the Audio class uses the AgentList - if (agent->activeSocket != NULL && agent->type == 'I') { + if (agent->getActiveSocket() != NULL && agent->getType() == 'I') { // we know which socket is good for this agent, send there - agentSocket.send(agent->activeSocket, broadcastData, dataBytes); + agentSocket.send(agent->getActiveSocket(), broadcastData, dataBytes); } } } @@ -186,15 +186,15 @@ void AgentList::pingAgents() { char payload[] = "P"; for(std::vector::iterator agent = agents.begin(); agent != agents.end(); agent++) { - if (agent->type == 'I') { - if (agent->activeSocket != NULL) { + if (agent->getType() == 'I') { + if (agent->getActiveSocket() != NULL) { // we know which socket is good for this agent, send there - agentSocket.send(agent->activeSocket, payload, 1); + agentSocket.send(agent->getActiveSocket(), payload, 1); } else { // ping both of the sockets for the agent so we can figure out // which socket we can use - agentSocket.send(agent->publicSocket, payload, 1); - agentSocket.send(agent->localSocket, payload, 1); + agentSocket.send(agent->getPublicSocket(), payload, 1); + agentSocket.send(agent->getLocalSocket(), payload, 1); } } } @@ -203,19 +203,12 @@ void AgentList::pingAgents() { void AgentList::handlePingReply(sockaddr *agentAddress) { for(std::vector::iterator agent = agents.begin(); agent != agents.end(); agent++) { // check both the public and local addresses for each agent to see if we find a match - // prioritize the private address so that we prune erroneous local matches - sockaddr *matchedSocket = NULL; - - if (socketMatch(agent->publicSocket, agentAddress)) { - matchedSocket = agent->publicSocket; - } else if (socketMatch(agent->localSocket, agentAddress)) { - matchedSocket = agent->localSocket; - } - - if (matchedSocket != NULL) { - // matched agent, stop checking - // update the agent's ping - agent->activeSocket = matchedSocket; + // prioritize the private address so that we prune erroneous local matches + if (socketMatch(agent->getPublicSocket(), agentAddress)) { + agent->activatePublicSocket(); + break; + } else if (socketMatch(agent->getLocalSocket(), agentAddress)) { + agent->activateLocalSocket(); break; } } @@ -229,7 +222,7 @@ void *removeSilentAgents(void *args) { checkTimeUSecs = usecTimestampNow(); for(std::vector::iterator agent = agents->begin(); agent != agents->end();) { - if ((checkTimeUSecs - agent->lastRecvTimeUsecs) > AGENT_SILENCE_THRESHOLD_USECS) { + if ((checkTimeUSecs - agent->getLastRecvTimeUsecs()) > AGENT_SILENCE_THRESHOLD_USECS) { std::cout << "Killing agent " << &(*agent) << "\n"; pthread_mutex_lock(&vectorChangeMutex); agent = agents->erase(agent); From b6d255477b115f77c4b885313e35714dd3a43c06 Mon Sep 17 00:00:00 2001 From: Stephen Birarda Date: Mon, 25 Feb 2013 13:06:36 -0800 Subject: [PATCH 4/4] remove extraneous logging for Domain server solo agents --- domain/src/main.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/domain/src/main.cpp b/domain/src/main.cpp index 424416ca6c..7b6f75ad3f 100644 --- a/domain/src/main.cpp +++ b/domain/src/main.cpp @@ -89,7 +89,6 @@ int main(int argc, const char * argv[]) // this is an agent of which there can be multiple, just add them to the packet currentBufferPos = addAgentToBroadcastPacket(currentBufferPos, &(*agent)); } else { - std::cout << "We have a solo agent: " << &(*agent) << "\n"; // solo agent, we need to only send newest if (newestSoloAgents[agent->getType()] == NULL || newestSoloAgents[agent->getType()]->getFirstRecvTimeUsecs() < agent->getFirstRecvTimeUsecs()) { @@ -106,7 +105,6 @@ int main(int argc, const char * argv[]) for (std::map::iterator agentIterator = newestSoloAgents.begin(); agentIterator != newestSoloAgents.end(); agentIterator++) { - std::cout << "Newest agent: " << agentIterator->second << "\n"; // this is the newest alive solo agent, add them to the packet currentBufferPos = addAgentToBroadcastPacket(currentBufferPos, agentIterator->second); }