add pending assignment purgatory for assignees

domain-server/src/DomainServer.cpp

@@ -35,6 +35,7 @@ DomainServer::DomainServer(int argc, char* argv[]) :
     _httpsManager(NULL),
     _allAssignments(),
     _unfulfilledAssignments(),
+    _pendingAssignedNodes(),
     _isUsingDTLS(false),
     _oauthProviderURL(),
     _oauthClientID(),
@@ -339,9 +340,9 @@ void DomainServer::handleConnectRequest(const QByteArray& packet, const HifiSock
     QUuid packetUUID = uuidFromPacketHeader(packet);
 
     // check if this connect request matches an assignment in the queue
-    bool isFulfilledOrUnfulfilledAssignment = _allAssignments.contains(packetUUID);
+    bool isAssignment = _pendingAssignedNodes.contains(packetUUID);
     SharedAssignmentPointer matchingQueuedAssignment = SharedAssignmentPointer();
-    if (isFulfilledOrUnfulfilledAssignment) {
+    if (isAssignment) {
         matchingQueuedAssignment = matchingQueuedAssignmentForCheckIn(packetUUID, nodeType);
     }
     
@@ -371,8 +372,8 @@ void DomainServer::handleConnectRequest(const QByteArray& packet, const HifiSock
         }
     }
         
-    if ((!isFulfilledOrUnfulfilledAssignment && !STATICALLY_ASSIGNED_NODES.contains(nodeType))
+    if ((!isAssignment && !STATICALLY_ASSIGNED_NODES.contains(nodeType))
-        || (isFulfilledOrUnfulfilledAssignment && matchingQueuedAssignment)) {
+        || (isAssignment && matchingQueuedAssignment)) {
         // this was either not a static assignment or it was and we had a matching one in the queue
         
         // create a new session UUID for this node
@@ -384,8 +385,8 @@ void DomainServer::handleConnectRequest(const QByteArray& packet, const HifiSock
         // if this was a static assignment set the UUID, set the sendingSockAddr
         DomainServerNodeData* nodeData = reinterpret_cast<DomainServerNodeData*>(newNode->getLinkedData());
         
-        if (isFulfilledOrUnfulfilledAssignment) {
+        if (isAssignment) {
-            nodeData->setAssignmentUUID(packetUUID);
+            nodeData->setAssignmentUUID(matchingQueuedAssignment->getUUID());
         }
         
         nodeData->setSendingSockAddr(senderSockAddr);
@@ -589,12 +590,21 @@ void DomainServer::readAvailableDatagrams() {
                 // give this assignment out, either the type matches or the requestor said they will take any
                 assignmentPacket.resize(numAssignmentPacketHeaderBytes);
                 
+                // setup a copy of this assignment that will have a unique UUID, for packaging purposes
+                Assignment uniqueAssignment(*assignmentToDeploy.data());
+                uniqueAssignment.setUUID(QUuid::createUuid());
+                
                 QDataStream assignmentStream(&assignmentPacket, QIODevice::Append);
                 
-                assignmentStream << *assignmentToDeploy.data();
+                assignmentStream << uniqueAssignment;
                 
                 nodeList->getNodeSocket().writeDatagram(assignmentPacket,
                                                         senderSockAddr.getAddress(), senderSockAddr.getPort());
+                
+                // add the information for that deployed assignment to the hash of pending assigned nodes
+                PendingAssignedNodeData* pendingNodeData = new PendingAssignedNodeData(assignmentToDeploy->getUUID(),
+                                                                                       requestAssignment.getWalletUUID());
+                _pendingAssignedNodes.insert(uniqueAssignment.getUUID(), pendingNodeData);
             } else {
                 if (requestAssignment.getType() != Assignment::AgentType
                     || noisyMessageTimer.elapsed() > NOISY_MESSAGE_INTERVAL_MSECS) {
@@ -1069,11 +1079,25 @@ void DomainServer::nodeKilled(SharedNodePointer node) {
 SharedAssignmentPointer DomainServer::matchingQueuedAssignmentForCheckIn(const QUuid& checkInUUID, NodeType_t nodeType) {
     QQueue<SharedAssignmentPointer>::iterator i = _unfulfilledAssignments.begin();
     
-    while (i != _unfulfilledAssignments.end()) {
+    PendingAssignedNodeData* pendingAssigneeData = _pendingAssignedNodes.take(checkInUUID);
-        if (i->data()->getType() == Assignment::typeForNodeType(nodeType) && i->data()->getUUID() == checkInUUID) {
+    
-            return _unfulfilledAssignments.takeAt(i - _unfulfilledAssignments.begin());
+    if (pendingAssigneeData) {
-        } else {
+        while (i != _unfulfilledAssignments.end()) {
-            ++i;
+            if (i->data()->getType() == Assignment::typeForNodeType(nodeType)
+                && i->data()->getUUID() == pendingAssigneeData->getAssignmentUUID()) {
+                // we have an unfulfilled assignment to return
+                qDebug() << "Assignment deployed with" << uuidStringWithoutCurlyBraces(checkInUUID)
+                    << "matches unfulfilled assignment"
+                    << uuidStringWithoutCurlyBraces(pendingAssigneeData->getAssignmentUUID());
+                
+                // first clear the pending assignee data
+                delete pendingAssigneeData;
+                
+                // return the matching assignment
+                return _unfulfilledAssignments.takeAt(i - _unfulfilledAssignments.begin());
+            } else {
+                ++i;
+            }
         }
     }
     

domain-server/src/DomainServer.h

@@ -24,6 +24,8 @@
 #include <HTTPSConnection.h>
 #include <LimitedNodeList.h>
 
+#include "PendingAssignedNodeData.h"
+
 typedef QSharedPointer<Assignment> SharedAssignmentPointer;
 
 class DomainServer : public QCoreApplication, public HTTPSRequestHandler {
@@ -85,6 +87,7 @@ private:
     
     QHash<QUuid, SharedAssignmentPointer> _allAssignments;
     QQueue<SharedAssignmentPointer> _unfulfilledAssignments;
+    QHash<QUuid, PendingAssignedNodeData*> _pendingAssignedNodes;
     
     QVariantMap _argumentVariantMap;
     

domain-server/src/PendingAssignedNodeData.cpp

@@ -0,0 +1,19 @@
+//
+//  PendingAssignedNodeData.cpp
+//  domain-server/src
+//
+//  Created by Stephen Birarda on 2014-05-20.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "PendingAssignedNodeData.h"
+
+PendingAssignedNodeData::PendingAssignedNodeData(const QUuid& assignmentUUID, const QUuid& walletUUID) :
+    _assignmentUUID(assignmentUUID),
+    _walletUUID(walletUUID)
+{
+    
+}

domain-server/src/PendingAssignedNodeData.h

@@ -0,0 +1,33 @@
+//
+//  PendingAssignedNodeData.h
+//  domain-server/src
+//
+//  Created by Stephen Birarda on 2014-05-20.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_PendingAssignedNodeData_h
+#define hifi_PendingAssignedNodeData_h
+
+#include <QtCore/QObject>
+#include <QtCore/QUuid>
+
+class PendingAssignedNodeData : public QObject {
+    Q_OBJECT
+public:
+    PendingAssignedNodeData(const QUuid& assignmentUUID, const QUuid& walletUUID);
+    
+    void setAssignmentUUID(const QUuid& assignmentUUID) { _assignmentUUID = assignmentUUID; }
+    const QUuid& getAssignmentUUID() const { return _assignmentUUID; }
+    
+    void setWalletUUID(const QUuid& walletUUID) { _walletUUID = walletUUID; }
+    const QUuid& getWalletUUID() const { return _walletUUID; }
+private:
+    QUuid _assignmentUUID;
+    QUuid _walletUUID;
+};
+
+#endif // hifi_PendingAssignedNodeData_h