Merge pull request #1088 from birarda/assignment

add a DELETE method to civetweb to delete assignment by UUID

domain-server/src/DomainServer.cpp

@@ -46,79 +46,121 @@ int DomainServer::civetwebRequestHandler(struct mg_connection *connection) {
     const struct mg_request_info* ri = mg_get_request_info(connection);
     
     const char RESPONSE_200[] = "HTTP/1.0 200 OK\r\n\r\n";
+    const char RESPONSE_400[] = "HTTP/1.0 400 Bad Request\r\n\r\n";
     
-    if (strcmp(ri->uri, "/assignment") == 0 && strcmp(ri->request_method, "POST") == 0) {
+    const char URI_ASSIGNMENT[] = "/assignment";
-        // return a 200
+    const char URI_NODE[] = "/node";
-        mg_printf(connection, "%s", RESPONSE_200);
-        // upload the file
-        mg_upload(connection, "/tmp");
     
-        return 1;
+    if (strcmp(ri->request_method, "GET") == 0) {
-    } else if (strcmp(ri->uri, "/assignments.json") == 0) {
+        if (strcmp(ri->uri, "/assignments.json") == 0) {
-        // user is asking for json list of assignments
+            // user is asking for json list of assignments
             
-        // start with a 200 response
+            // start with a 200 response
-        mg_printf(connection, "%s", RESPONSE_200);
+            mg_printf(connection, "%s", RESPONSE_200);
             
-        // setup the JSON
+            // setup the JSON
-        QJsonObject assignmentJSON;
+            QJsonObject assignmentJSON;
             
-        QJsonObject assignedNodesJSON;
+            QJsonObject assignedNodesJSON;
             
-        // enumerate the NodeList to find the assigned nodes
+            // enumerate the NodeList to find the assigned nodes
-        NodeList* nodeList = NodeList::getInstance();
+            NodeList* nodeList = NodeList::getInstance();
             
-        const char ASSIGNMENT_JSON_UUID_KEY[] = "UUID";
+            const char ASSIGNMENT_JSON_UUID_KEY[] = "UUID";
             
-        for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
+            for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
-            if (node->getLinkedData()) {
+                if (node->getLinkedData()) {
-                // this is a node with assignment
+                    // this is a node with assignment
-                QJsonObject assignedNodeJSON;
+                    QJsonObject assignedNodeJSON;
                     
-                // add the assignment UUID
+                    // add the assignment UUID
-                QString assignmentUUID = uuidStringWithoutCurlyBraces(((Assignment*) node->getLinkedData())->getUUID());
+                    QString assignmentUUID = uuidStringWithoutCurlyBraces(((Assignment*) node->getLinkedData())->getUUID());
-                assignedNodeJSON[ASSIGNMENT_JSON_UUID_KEY] = assignmentUUID;
+                    assignedNodeJSON[ASSIGNMENT_JSON_UUID_KEY] = assignmentUUID;
                     
-                // add the node socket information
+                    // add the node socket information
-                assignedNodeJSON["public"] = jsonForSocket(node->getPublicSocket());
+                    assignedNodeJSON["public"] = jsonForSocket(node->getPublicSocket());
-                assignedNodeJSON["local"] = jsonForSocket(node->getLocalSocket());
+                    assignedNodeJSON["local"] = jsonForSocket(node->getLocalSocket());
                     
-                // re-format the type name so it matches the target name
+                    // re-format the type name so it matches the target name
-                QString nodeTypeName(node->getTypeName());
+                    QString nodeTypeName(node->getTypeName());
-                nodeTypeName = nodeTypeName.toLower();
+                    nodeTypeName = nodeTypeName.toLower();
-                nodeTypeName.replace(' ', '-');
+                    nodeTypeName.replace(' ', '-');
                     
-                assignedNodesJSON[nodeTypeName] = assignedNodeJSON;
+                    assignedNodesJSON[nodeTypeName] = assignedNodeJSON;
+                }
+            }
+            
+            assignmentJSON["fulfilled"] = assignedNodesJSON;
+            
+            QJsonObject queuedAssignmentsJSON;
+            
+            // add the queued but unfilled assignments to the json
+            std::deque<Assignment*>::iterator assignment = domainServerInstance->_assignmentQueue.begin();
+            
+            while (assignment != domainServerInstance->_assignmentQueue.end()) {
+                QJsonObject queuedAssignmentJSON;
+                
+                QString uuidString = uuidStringWithoutCurlyBraces((*assignment)->getUUID());
+                queuedAssignmentJSON[ASSIGNMENT_JSON_UUID_KEY] = uuidString;
+                
+                // add this queued assignment to the JSON
+                queuedAssignmentsJSON[(*assignment)->getTypeName()] = queuedAssignmentJSON;
+                
+                // push forward the iterator to check the next assignment
+                assignment++;
+            }
+            
+            assignmentJSON["queued"] = queuedAssignmentsJSON;
+            
+            // print out the created JSON
+            QJsonDocument assignmentDocument(assignmentJSON);
+            mg_printf(connection, "%s", assignmentDocument.toJson().constData());
+            
+            // we've processed this request
+            return 1;
+        }
+        
+        // not processed, pass to document root
+        return 0;
+    } else if (strcmp(ri->request_method, "POST") == 0) {
+        if (strcmp(ri->uri, URI_ASSIGNMENT) == 0) {
+            // return a 200
+            mg_printf(connection, "%s", RESPONSE_200);
+            // upload the file
+            mg_upload(connection, "/tmp");
+            
+            return 1;
+        }
+        
+        return 0;
+    } else if (strcmp(ri->request_method, "DELETE") == 0) {
+        // this is a DELETE request
+        
+        // check if it is for an assignment
+        if (memcmp(ri->uri, URI_NODE, strlen(URI_NODE)) == 0) {
+            // pull the UUID from the url
+            QUuid deleteUUID = QUuid(QString(ri->uri + strlen(URI_NODE) + sizeof('/')));
+            
+            if (!deleteUUID.isNull()) {
+                Node *nodeToKill = NodeList::getInstance()->nodeWithUUID(deleteUUID);
+                
+                if (nodeToKill) {
+                    // start with a 200 response
+                    mg_printf(connection, "%s", RESPONSE_200);
+                    
+                    // we have a valid UUID and node - kill the node that has this assignment
+                    NodeList::getInstance()->killNode(nodeToKill);
+                    
+                    // successfully processed request
+                    return 1;
+                }
             }
         }
         
-        assignmentJSON["fulfilled"] = assignedNodesJSON;
+        // request not processed - bad request
+        mg_printf(connection, "%s", RESPONSE_400);
         
-        QJsonObject queuedAssignmentsJSON;
+        // this was processed by civetweb
-        
-        // add the queued but unfilled assignments to the json
-        std::deque<Assignment*>::iterator assignment = domainServerInstance->_assignmentQueue.begin();
-        
-        while (assignment != domainServerInstance->_assignmentQueue.end()) {
-            QJsonObject queuedAssignmentJSON;
-            
-            QString uuidString = uuidStringWithoutCurlyBraces((*assignment)->getUUID());
-            queuedAssignmentJSON[ASSIGNMENT_JSON_UUID_KEY] = uuidString;
-            
-            // add this queued assignment to the JSON
-            queuedAssignmentsJSON[(*assignment)->getTypeName()] = queuedAssignmentJSON;
-            
-            // push forward the iterator to check the next assignment
-            assignment++;
-        }
-        
-        assignmentJSON["queued"] = queuedAssignmentsJSON;
-        
-        // print out the created JSON
-        QJsonDocument assignmentDocument(assignmentJSON);
-        mg_printf(connection, "%s", assignmentDocument.toJson().constData());
-        
-        // we've processed this request
         return 1;
     } else {
         // have mongoose process this request from the document_root
@@ -160,6 +202,27 @@ void DomainServer::civetwebUploadHandler(struct mg_connection *connection, const
     domainServerInstance->_assignmentQueueMutex.unlock();
 }
 
+void DomainServer::addReleasedAssignmentBackToQueue(Assignment* releasedAssignment) {
+    qDebug() << "Adding assignment" << *releasedAssignment << " back to queue.\n";
+    
+    // find this assignment in the static file
+    for (int i = 0; i < MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS; i++) {
+        if (_staticAssignments[i].getUUID() == releasedAssignment->getUUID()) {
+            // reset the UUID on the static assignment
+            _staticAssignments[i].resetUUID();
+            
+            // put this assignment back in the queue so it goes out
+            _assignmentQueueMutex.lock();
+            _assignmentQueue.push_back(&_staticAssignments[i]);
+            _assignmentQueueMutex.unlock();
+            
+        } else if (_staticAssignments[i].getUUID().isNull()) {
+            // we are at the blank part of the static assignments - break out
+            break;
+        }
+    }
+}
+
 void DomainServer::nodeAdded(Node* node) {
     
 }
@@ -169,26 +232,8 @@ void DomainServer::nodeKilled(Node* node) {
     if (node->getLinkedData()) {
         Assignment* nodeAssignment =  (Assignment*) node->getLinkedData();
         
-        qDebug() << "Adding assignment" << *nodeAssignment << " back to queue.\n";
+        addReleasedAssignmentBackToQueue(nodeAssignment);
-        
-        // find this assignment in the static file
-        for (int i = 0; i < MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS; i++) {
-            if (_staticAssignments[i].getUUID() == nodeAssignment->getUUID()) {
-                // reset the UUID on the static assignment
-                _staticAssignments[i].resetUUID();
-                
-                // put this assignment back in the queue so it goes out
-                _assignmentQueueMutex.lock();
-                _assignmentQueue.push_back(&_staticAssignments[i]);
-                _assignmentQueueMutex.unlock();
-                
-            } else if (_staticAssignments[i].getUUID().isNull()) {
-                // we are at the blank part of the static assignments - break out
-                break;
-            }
-        }
     }
-    
 }
 
 unsigned char* DomainServer::addNodeToBroadcastPacket(unsigned char* currentPosition, Node* nodeToAdd) {

domain-server/src/DomainServer.h

@@ -47,6 +47,7 @@ private:
     void removeAssignmentFromQueue(Assignment* removableAssignment);
     bool checkInWithUUIDMatchesExistingNode(sockaddr* nodePublicSocket, sockaddr* nodeLocalSocket, const QUuid& checkInUUI);
     void possiblyAddStaticAssignmentsBackToQueueAfterRestart(timeval* startTime);
+    void addReleasedAssignmentBackToQueue(Assignment* releasedAssignment);
     
     void cleanup();
     

libraries/shared/src/NodeList.cpp

@@ -715,6 +715,22 @@ Node* NodeList::soloNodeOfType(char nodeType) {
     return NULL;
 }
 
+void NodeList::killNode(Node* node, bool mustLockNode) {
+    if (mustLockNode) {
+        node->lock();
+    }
+    
+    qDebug() << "Killed " << *node << "\n";
+    
+    notifyHooksOfKilledNode(&*node);
+    
+    node->setAlive(false);
+    
+    if (mustLockNode) {
+        node->unlock();
+    }
+}
+
 void* removeSilentNodes(void *args) {
     NodeList* nodeList = (NodeList*) args;
     uint64_t checkTimeUsecs = 0;
@@ -728,12 +744,8 @@ void* removeSilentNodes(void *args) {
             node->lock();
             
             if ((usecTimestampNow() - node->getLastHeardMicrostamp()) > NODE_SILENCE_THRESHOLD_USECS) {
-
+                // kill this node, don't lock - we already did it
-                qDebug() << "Killed " << *node << "\n";
+                nodeList->killNode(&(*node), false);
-                
-                nodeList->notifyHooksOfKilledNode(&*node);
-                
-                node->setAlive(false);
             }
             
             node->unlock();

libraries/shared/src/NodeList.h

@@ -113,6 +113,7 @@ public:
     Node* nodeWithUUID(const QUuid& nodeUUID);
     
     Node* addOrUpdateNode(const QUuid& uuid, char nodeType, sockaddr* publicSocket, sockaddr* localSocket);
+    void killNode(Node* node, bool mustLockNode = true);
     
     void processNodeData(sockaddr *senderAddress, unsigned char *packetData, size_t dataBytes);
     void processBulkNodeData(sockaddr *senderAddress, unsigned char *packetData, int numTotalBytes);