straight to audio mixer

since we can get the canKick there too.  (doh)

assignment-client/src/audio/AudioMixer.cpp

@@ -96,6 +96,7 @@ AudioMixer::AudioMixer(ReceivedMessage& message) :
     packetReceiver.registerListener(PacketType::KillAvatar, this, "handleKillAvatarPacket");
     packetReceiver.registerListener(PacketType::NodeMuteRequest, this, "handleNodeMuteRequestPacket");
     
+    nodeList->addNodeTypeToInterestSet(NodeType::DomainServer);
     connect(nodeList.data(), &NodeList::nodeKilled, this, &AudioMixer::handleNodeKilled);
 }
 
@@ -603,7 +604,7 @@ void AudioMixer::handleNodeKilled(SharedNodePointer killedNode) {
 void AudioMixer::handleNodeMuteRequestPacket(QSharedPointer<ReceivedMessage> packet, SharedNodePointer sendingNode) {
     auto nodeList = DependencyManager::get<NodeList>();
     QUuid nodeUUID = QUuid::fromRfc4122(packet->readWithoutCopy(NUM_BYTES_RFC4122_UUID));
-
+    if (sendingNode->getCanKick()) {
         auto node = nodeList->nodeWithUUID(nodeUUID);
         if (node) {
             // we need to set a flag so we send them the appropriate packet to mute them
@@ -613,6 +614,9 @@ void AudioMixer::handleNodeMuteRequestPacket(QSharedPointer<ReceivedMessage> pac
         } else {
             qWarning() << "Node mute packet received for unknown node " << uuidStringWithoutCurlyBraces(nodeUUID);
         }
+    } else {
+        qWarning() << "Node mute packet received from node that cannot mute, ignoring";
+    }
 }
 
 void AudioMixer::handleKillAvatarPacket(QSharedPointer<ReceivedMessage> packet, SharedNodePointer sendingNode) {

domain-server/src/DomainServer.cpp

@@ -498,7 +498,6 @@ void DomainServer::setupNodeListAndAssignments() {
     // NodeList won't be available to the settings manager when it is created, so call registerListener here
     packetReceiver.registerListener(PacketType::DomainSettingsRequest, &_settingsManager, "processSettingsRequestPacket");
     packetReceiver.registerListener(PacketType::NodeKickRequest, &_settingsManager, "processNodeKickRequestPacket");
-    packetReceiver.registerListener(PacketType::NodeMuteRequest, &_settingsManager, "processNodeMuteRequestPacket");
 
     // register the gatekeeper for the packets it needs to receive
     packetReceiver.registerListener(PacketType::DomainConnectRequest, &_gatekeeper, "processConnectRequestPacket");

domain-server/src/DomainServerSettingsManager.cpp

@@ -634,39 +634,6 @@ bool DomainServerSettingsManager::ensurePermissionsForGroupRanks() {
     return changed;
 }
 
-void DomainServerSettingsManager::processNodeMuteRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode) {
-    if (sendingNode->getCanKick()) {
-        QUuid nodeUUID = QUuid::fromRfc4122(message->readWithoutCopy(NUM_BYTES_RFC4122_UUID));
-
-        if (!nodeUUID.isNull() && nodeUUID != sendingNode->getUUID()) {
-            // make sure we actually have a node with this UUID
-            auto limitedNodeList = DependencyManager::get<LimitedNodeList>();
-
-            auto matchingNode = limitedNodeList->nodeWithUUID(nodeUUID);
-
-            if (matchingNode) {
-                // send this along to the audio mixer       
-                auto limitedNodeList = DependencyManager::get<LimitedNodeList>();
-                auto audioMixer = limitedNodeList->soloNodeOfType(NodeType::AudioMixer);
-                if (audioMixer) {
-                    auto packet = NLPacket::create(PacketType::NodeMuteRequest, NUM_BYTES_RFC4122_UUID, true);
-                    packet->write(nodeUUID.toRfc4122());
-                    limitedNodeList->sendPacket(std::move(packet), *audioMixer);
-                } else {
-                    qWarning() << "Couldn't find an audio mixer, cannot process node mute request";
-                }
-            } else {
-                qWarning() << "Node mute request received for unknown node. Refusing to process.";
-            }
-        } else {
-            qWarning() << "Node kick request received for invalid node ID or from node being kicked. Refusing to process.";
-        }
-    } else {
-        qWarning() << "Refusing to process a kick packet from node" << uuidStringWithoutCurlyBraces(sendingNode->getUUID())
-        << "that does not have kick permissions.";
-    }
-}
-
 void DomainServerSettingsManager::processNodeKickRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode) {
     // before we do any processing on this packet make sure it comes from a node that is allowed to kick
     if (sendingNode->getCanKick()) {

domain-server/src/DomainServerSettingsManager.h

@@ -105,7 +105,6 @@ public slots:
 private slots:
     void processSettingsRequestPacket(QSharedPointer<ReceivedMessage> message);
     void processNodeKickRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);
-    void processNodeMuteRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode);
 
 private:
     QStringList _argumentList;

libraries/networking/src/NodeList.cpp

@@ -820,15 +820,20 @@ void NodeList::muteNodeBySessionID(const QUuid& nodeID) {
     // cannot mute yourself, or nobody
     if (!nodeID.isNull() && _sessionUUID != nodeID ) {
         if (getThisNodeCanKick()) {
+            auto audioMixer = soloNodeOfType(NodeType::AudioMixer);
+            if (audioMixer) {
                 // setup the packet
-            auto kickPacket = NLPacket::create(PacketType::NodeMuteRequest, NUM_BYTES_RFC4122_UUID, true);
+                auto mutePacket = NLPacket::create(PacketType::NodeMuteRequest, NUM_BYTES_RFC4122_UUID, true);
 
                 // write the node ID to the packet
-            kickPacket->write(nodeID.toRfc4122());
+                mutePacket->write(nodeID.toRfc4122());
 
                 qDebug() << "Sending packet to mute node" << uuidStringWithoutCurlyBraces(nodeID);
             
-            sendPacket(std::move(kickPacket), _domainHandler.getSockAddr());
+                sendPacket(std::move(mutePacket), *audioMixer);
+            } else {
+                qWarning() << "Couldn't find audio mixer to send node mute request";
+            }
         } else {
             qWarning() << "You do not have permissions to mute in this domain."
                 << "Request to mute node" << uuidStringWithoutCurlyBraces(nodeID) << "will not be sent";