Merge pull request #10669 from huffman/feat/replicants-upstream

node isUpstream

assignment-client/src/audio/AudioMixer.cpp

@@ -122,6 +122,7 @@ void AudioMixer::queueReplicatedAudioPacket(QSharedPointer<ReceivedMessage> mess
 
     auto node = nodeList->addOrUpdateNode(nodeID, NodeType::Agent,
                                           message->getSenderSockAddr(), message->getSenderSockAddr());
+    node->setIsUpstream(true);
     node->setIsMirror(true);
     node->setLastHeardMicrostamp(usecTimestampNow());
 

assignment-client/src/audio/AudioMixerSlave.cpp

@@ -74,6 +74,10 @@ void AudioMixerSlave::mix(const SharedNodePointer& node) {
         return;
     }
 
+    if (node->isUpstream()) {
+        return;
+    }
+
     // check that the stream is valid
     auto avatarStream = data->getAvatarAudioStream();
     if (avatarStream == nullptr) {

domain-server/src/DomainServer.cpp

@@ -2211,6 +2211,11 @@ void DomainServer::refreshStaticAssignmentAndAddToQueue(SharedAssignmentPointer&
 }
 
 void DomainServer::nodeAdded(SharedNodePointer node) {
+    // TODO Check to see if node is in list of replicated nodes
+    if (node->getType() == NodeType::Agent) {
+        node->setIsReplicated(true);
+    }
+
     // we don't use updateNodeWithData, so add the DomainServerNodeData to the node here
     node->setLinkedData(std::unique_ptr<DomainServerNodeData> { new DomainServerNodeData() });
 }

libraries/networking/src/LimitedNodeList.cpp

@@ -569,6 +569,7 @@ void LimitedNodeList::handleNodeKill(const SharedNodePointer& node) {
 SharedNodePointer LimitedNodeList::addOrUpdateNode(const QUuid& uuid, NodeType_t nodeType,
                                                    const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket,
                                                    const NodePermissions& permissions,
+                                                   bool isReplicated,
                                                    const QUuid& connectionSecret) {
     QReadLocker readLocker(&_nodeMutex);
     NodeHash::const_iterator it = _nodeHash.find(uuid);
@@ -580,11 +581,12 @@ SharedNodePointer LimitedNodeList::addOrUpdateNode(const QUuid& uuid, NodeType_t
         matchingNode->setLocalSocket(localSocket);
         matchingNode->setPermissions(permissions);
         matchingNode->setConnectionSecret(connectionSecret);
+        matchingNode->setIsReplicated(isReplicated);
 
         return matchingNode;
     } else {
         // we didn't have this node, so add them
-        Node* newNode = new Node(uuid, nodeType, publicSocket, localSocket, permissions, connectionSecret);
+        Node* newNode = new Node(uuid, nodeType, publicSocket, localSocket, permissions, isReplicated, connectionSecret);
 
         if (nodeType == NodeType::AudioMixer) {
             LimitedNodeList::flagTimeForConnectionStep(LimitedNodeList::AddedAudioMixer);

libraries/networking/src/LimitedNodeList.h

@@ -146,7 +146,7 @@ public:
     SharedNodePointer addOrUpdateNode(const QUuid& uuid, NodeType_t nodeType,
                                       const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket,
                                       const NodePermissions& permissions = DEFAULT_AGENT_PERMISSIONS,
-                                      const QUuid& connectionSecret = QUuid());
+                                      bool isReplicated = false, const QUuid& connectionSecret = QUuid());
 
     static bool parseSTUNResponse(udt::BasePacket* packet, QHostAddress& newPublicAddress, uint16_t& newPublicPort);
     bool hasCompletedInitialSTUN() const { return _hasCompletedInitialSTUN; }

libraries/networking/src/Node.cpp

@@ -51,11 +51,12 @@ const QString& NodeType::getNodeTypeName(NodeType_t nodeType) {
 }
 
 Node::Node(const QUuid& uuid, NodeType_t type, const HifiSockAddr& publicSocket,
-           const HifiSockAddr& localSocket, const NodePermissions& permissions, const QUuid& connectionSecret,
+           const HifiSockAddr& localSocket, const NodePermissions& permissions, bool isReplicated,
-           QObject* parent) :
+           const QUuid& connectionSecret, QObject* parent) :
     NetworkPeer(uuid, publicSocket, localSocket, parent),
     _type(type),
     _connectionSecret(connectionSecret),
+    _isReplicated(isReplicated),
     _pingMs(-1),  // "Uninitialized"
     _clockSkewUsec(0),
     _mutex(),
@@ -135,6 +136,7 @@ QDataStream& operator<<(QDataStream& out, const Node& node) {
     out << node._publicSocket;
     out << node._localSocket;
     out << node._permissions;
+    out << node._isReplicated;
     return out;
 }
 
@@ -144,6 +146,7 @@ QDataStream& operator>>(QDataStream& in, Node& node) {
     in >> node._publicSocket;
     in >> node._localSocket;
     in >> node._permissions;
+    in >> node._isReplicated;
     return in;
 }
 

libraries/networking/src/Node.h

@@ -39,7 +39,7 @@ class Node : public NetworkPeer {
 public:
     Node(const QUuid& uuid, NodeType_t type,
          const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket,
-         const NodePermissions& permissions, const QUuid& connectionSecret = QUuid(),
+         const NodePermissions& permissions, bool isReplicated, const QUuid& connectionSecret = QUuid(),
          QObject* parent = nullptr);
 
     bool operator==(const Node& otherNode) const { return _uuid == otherNode._uuid; }
@@ -48,6 +48,12 @@ public:
     char getType() const { return _type; }
     void setType(char type);
 
+    bool isReplicated() const { return _isReplicated; }
+    void setIsReplicated(bool isReplicated) { _isReplicated = isReplicated; }
+
+    bool isUpstream() const { return _isUpstream; }
+    void setIsUpstream(bool isUpstream) { _isUpstream = isUpstream; }
+
     const QUuid& getConnectionSecret() const { return _connectionSecret; }
     void setConnectionSecret(const QUuid& connectionSecret) { _connectionSecret = connectionSecret; }
 
@@ -92,11 +98,13 @@ private:
 
     QUuid _connectionSecret;
     std::unique_ptr<NodeData> _linkedData;
+    bool _isReplicated { false };
     int _pingMs;
     qint64 _clockSkewUsec;
     QMutex _mutex;
     MovingPercentile _clockSkewMovingPercentile;
     NodePermissions _permissions;
+    bool _isUpstream { false };
     tbb::concurrent_unordered_set<QUuid, UUIDHasher> _ignoredNodeIDSet;
     mutable QReadWriteLock _ignoredNodeIDSetLock;
 

libraries/networking/src/NodeList.cpp

@@ -654,8 +654,9 @@ void NodeList::parseNodeFromPacketStream(QDataStream& packetStream) {
     QUuid nodeUUID, connectionUUID;
     HifiSockAddr nodePublicSocket, nodeLocalSocket;
     NodePermissions permissions;
+    bool isReplicated;
 
-    packetStream >> nodeType >> nodeUUID >> nodePublicSocket >> nodeLocalSocket >> permissions;
+    packetStream >> nodeType >> nodeUUID >> nodePublicSocket >> nodeLocalSocket >> permissions >> isReplicated;
 
     // if the public socket address is 0 then it's reachable at the same IP
     // as the domain server
@@ -666,7 +667,7 @@ void NodeList::parseNodeFromPacketStream(QDataStream& packetStream) {
     packetStream >> connectionUUID;
 
     SharedNodePointer node = addOrUpdateNode(nodeUUID, nodeType, nodePublicSocket,
-                                             nodeLocalSocket, permissions, connectionUUID);
+                                             nodeLocalSocket, permissions, isReplicated, connectionUUID);
 }
 
 void NodeList::sendAssignment(Assignment& assignment) {