Merge pull request #4239 from sethalves/allowed-editors

Allowed editors domain setting

domain-server/resources/describe-settings.json

@@ -73,6 +73,20 @@
             "can_set": true
           }
         ]
+      },
+      {
+        "name": "allowed_editors",
+        "type": "table",
+        "label": "Allowed Editors",
+        "help": "List the High Fidelity names for people you want to be able lock or unlock entities in this domain.<br/>An empty list means everyone.",
+        "numbered": false,
+        "columns": [
+          {
+            "name": "username",
+            "label": "Username",
+            "can_set": true
+          }
+        ]
       }
     ]
   },
@@ -433,4 +447,4 @@
       }
     ]
   }
-]
+]

domain-server/src/DomainServer.cpp

@@ -41,6 +41,11 @@ int const DomainServer::EXIT_CODE_REBOOT = 234923;
 
 const QString ICE_SERVER_DEFAULT_HOSTNAME = "ice.highfidelity.io";
 
+
+const QString ALLOWED_USERS_SETTINGS_KEYPATH = "security.allowed_users";
+const QString ALLOWED_EDITORS_SETTINGS_KEYPATH = "security.allowed_editors";
+
+
 DomainServer::DomainServer(int argc, char* argv[]) :
     QCoreApplication(argc, argv),
     _httpManager(DOMAIN_SERVER_HTTP_PORT, QString("%1/resources/web/").arg(QCoreApplication::applicationDirPath()), this),
@@ -638,10 +643,16 @@ void DomainServer::handleConnectRequest(const QByteArray& packet, const HifiSock
             // we got a packetUUID we didn't recognize, just add the node
             nodeUUID = QUuid::createUuid();
         }
-        
 
-        SharedNodePointer newNode = DependencyManager::get<LimitedNodeList>()->addOrUpdateNode(nodeUUID, nodeType,
+        // if this user is in the editors list (or if the editors list is empty) set the user's node's canAdjustLocks to true
-                                                                                    publicSockAddr, localSockAddr);
+        const QVariant* allowedEditorsVariant =
+            valueForKeyPath(_settingsManager.getSettingsMap(), ALLOWED_EDITORS_SETTINGS_KEYPATH);
+        QStringList allowedEditors = allowedEditorsVariant ? allowedEditorsVariant->toStringList() : QStringList();
+        bool canAdjustLocks = allowedEditors.isEmpty() || allowedEditors.contains(username);
+
+        SharedNodePointer newNode =
+            DependencyManager::get<LimitedNodeList>()->addOrUpdateNode(nodeUUID, nodeType,
+                                                                       publicSockAddr, localSockAddr, canAdjustLocks);
         // when the newNode is created the linked data is also created
         // if this was a static assignment set the UUID, set the sendingSockAddr
         DomainServerNodeData* nodeData = reinterpret_cast<DomainServerNodeData*>(newNode->getLinkedData());
@@ -663,7 +674,6 @@ void DomainServer::handleConnectRequest(const QByteArray& packet, const HifiSock
     }
 }
 
-const QString ALLOWED_USERS_SETTINGS_KEYPATH = "security.allowed_users";
 
 bool DomainServer::shouldAllowConnectionFromNode(const QString& username,
                                                  const QByteArray& usernameSignature,
@@ -842,6 +852,7 @@ void DomainServer::sendDomainListToNode(const SharedNodePointer& node, const Hif
     // always send the node their own UUID back
     QDataStream broadcastDataStream(&broadcastPacket, QIODevice::Append);
     broadcastDataStream << node->getUUID();
+    broadcastDataStream << node->getCanAdjustLocks();
 
     int numBroadcastPacketLeadBytes = broadcastDataStream.device()->pos();
 

libraries/entities/src/EntityScriptingInterface.cpp

@@ -26,6 +26,13 @@ void EntityScriptingInterface::queueEntityMessage(PacketType packetType,
     getEntityPacketSender()->queueEditEntityMessage(packetType, entityID, properties);
 }
 
+
+bool EntityScriptingInterface::canAdjustLocks() {
+    auto nodeList = DependencyManager::get<NodeList>();
+    return nodeList->getThisNodeCanAdjustLocks();
+}
+
+
 EntityItemID EntityScriptingInterface::addEntity(const EntityItemProperties& properties) {
 
     // The application will keep track of creatorTokenID
@@ -108,7 +115,7 @@ EntityItemID EntityScriptingInterface::editEntity(EntityItemID entityID, const E
     // the actual id, because we can edit out local entities just with creatorTokenID
     if (_entityTree) {
         _entityTree->lockForWrite();
-        _entityTree->updateEntity(entityID, properties);
+        _entityTree->updateEntity(entityID, properties, canAdjustLocks());
         _entityTree->unlock();
     }
 

libraries/entities/src/EntityScriptingInterface.h

@@ -61,6 +61,10 @@ public:
     EntityTree* getEntityTree(EntityTree*) { return _entityTree; }
     
 public slots:
+
+    // returns true if the DomainServer will allow this Node/Avatar to make changes
+    Q_INVOKABLE bool canAdjustLocks();
+
     /// adds a model with the specific properties
     Q_INVOKABLE EntityItemID addEntity(const EntityItemProperties& properties);
 

libraries/entities/src/EntityTree.cpp

@@ -93,7 +93,7 @@ void EntityTree::postAddEntity(EntityItem* entity) {
     emit addingEntity(entity->getEntityItemID());
 }
 
-bool EntityTree::updateEntity(const EntityItemID& entityID, const EntityItemProperties& properties) {
+bool EntityTree::updateEntity(const EntityItemID& entityID, const EntityItemProperties& properties, bool allowLockChange) {
     EntityTreeElement* containingElement = getContainingElement(entityID);
     if (!containingElement) {
         qDebug() << "UNEXPECTED!!!!  EntityTree::updateEntity() entityID doesn't exist!!! entityID=" << entityID;
@@ -106,21 +106,27 @@ bool EntityTree::updateEntity(const EntityItemID& entityID, const EntityItemProp
         return false;
     }
 
-    return updateEntityWithElement(existingEntity, properties, containingElement);
+    return updateEntityWithElement(existingEntity, properties, containingElement, allowLockChange);
 }
 
-bool EntityTree::updateEntity(EntityItem* entity, const EntityItemProperties& properties) {
+bool EntityTree::updateEntity(EntityItem* entity, const EntityItemProperties& properties, bool allowLockChange) {
     EntityTreeElement* containingElement = getContainingElement(entity->getEntityItemID());
     if (!containingElement) {
         qDebug() << "UNEXPECTED!!!!  EntityTree::updateEntity() entity-->element lookup failed!!! entityID=" 
             << entity->getEntityItemID();
         return false;
     }
-    return updateEntityWithElement(entity, properties, containingElement);
+    return updateEntityWithElement(entity, properties, containingElement, allowLockChange);
 }
 
 bool EntityTree::updateEntityWithElement(EntityItem* entity, const EntityItemProperties& properties, 
-        EntityTreeElement* containingElement) {
+                                         EntityTreeElement* containingElement, bool allowLockChange) {
+
+    if (!allowLockChange && (entity->getLocked() != properties.getLocked())) {
+        qDebug() << "Refusing disallowed lock adjustment.";
+        return false;
+    }
+
     // enforce support for locked entities. If an entity is currently locked, then the only
     // property we allow you to change is the locked property.
     if (entity->getLocked()) {
@@ -586,7 +592,7 @@ int EntityTree::processEditPacketData(PacketType packetType, const unsigned char
                     
                     // if the EntityItem exists, then update it
                     if (existingEntity) {
-                        updateEntity(entityItemID, properties);
+                        updateEntity(entityItemID, properties, senderNode->getCanAdjustLocks());
                         existingEntity->markAsChangedOnServer();
                     } else {
                         qDebug() << "User attempted to edit an unknown entity. ID:" << entityItemID;

libraries/entities/src/EntityTree.h

@@ -86,10 +86,10 @@ public:
     EntityItem* addEntity(const EntityItemID& entityID, const EntityItemProperties& properties);
 
     // use this method if you only know the entityID
-    bool updateEntity(const EntityItemID& entityID, const EntityItemProperties& properties);
+    bool updateEntity(const EntityItemID& entityID, const EntityItemProperties& properties, bool allowLockChange);
 
     // use this method if you have a pointer to the entity (avoid an extra entity lookup)
-    bool updateEntity(EntityItem* entity, const EntityItemProperties& properties);
+    bool updateEntity(EntityItem* entity, const EntityItemProperties& properties, bool allowLockChange);
 
     void deleteEntity(const EntityItemID& entityID, bool force = false);
     void deleteEntities(QSet<EntityItemID> entityIDs, bool force = false);
@@ -162,7 +162,7 @@ private:
 
     void processRemovedEntities(const DeleteEntityOperator& theOperator);
     bool updateEntityWithElement(EntityItem* entity, const EntityItemProperties& properties, 
-            EntityTreeElement* containingElement);
+                                 EntityTreeElement* containingElement, bool allowLockChange);
     static bool findNearPointOperation(OctreeElement* element, void* extraData);
     static bool findInSphereOperation(OctreeElement* element, void* extraData);
     static bool findInCubeOperation(OctreeElement* element, void* extraData);

libraries/networking/src/LimitedNodeList.cpp

@@ -411,7 +411,8 @@ void LimitedNodeList::handleNodeKill(const SharedNodePointer& node) {
 }
 
 SharedNodePointer LimitedNodeList::addOrUpdateNode(const QUuid& uuid, NodeType_t nodeType,
-                                                   const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket) {
+                                                   const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket,
+                                                   bool canAdjustLocks) {
     NodeHash::const_iterator it = _nodeHash.find(uuid);
     
     if (it != _nodeHash.end()) {
@@ -419,11 +420,12 @@ SharedNodePointer LimitedNodeList::addOrUpdateNode(const QUuid& uuid, NodeType_t
         
         matchingNode->setPublicSocket(publicSocket);
         matchingNode->setLocalSocket(localSocket);
+        matchingNode->setCanAdjustLocks(canAdjustLocks);
         
         return matchingNode;
     } else {
         // we didn't have this node, so add them
-        Node* newNode = new Node(uuid, nodeType, publicSocket, localSocket);
+        Node* newNode = new Node(uuid, nodeType, publicSocket, localSocket, canAdjustLocks);
         SharedNodePointer newNodePointer(newNode);
         
         _nodeHash.insert(UUIDNodePair(newNode->getUUID(), newNodePointer));

libraries/networking/src/LimitedNodeList.h

@@ -76,6 +76,9 @@ class LimitedNodeList : public QObject, public Dependency {
 public:
     const QUuid& getSessionUUID() const { return _sessionUUID; }
     void setSessionUUID(const QUuid& sessionUUID);
+
+    bool getThisNodeCanAdjustLocks() { return _thisNodeCanAdjustLocks; }
+    void setThisNodeCanAdjustLocks(bool canAdjustLocks) { _thisNodeCanAdjustLocks = canAdjustLocks; }
     
     void rebindNodeSocket();
     QUdpSocket& getNodeSocket() { return _nodeSocket; }
@@ -106,7 +109,7 @@ public:
     SharedNodePointer sendingNodeForPacket(const QByteArray& packet);
     
     SharedNodePointer addOrUpdateNode(const QUuid& uuid, NodeType_t nodeType,
-                                      const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket);
+                                      const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket, bool canAdjustLocks);
     
     const HifiSockAddr& getLocalSockAddr() const { return _localSockAddr; }
     const HifiSockAddr& getSTUNSockAddr() const { return _stunSockAddr; }
@@ -201,6 +204,7 @@ protected:
     void handleNodeKill(const SharedNodePointer& node);
 
     QUuid _sessionUUID;
+    bool _thisNodeCanAdjustLocks;
     NodeHash _nodeHash;
     QReadWriteLock _nodeMutex;
     QUdpSocket _nodeSocket;

libraries/networking/src/Node.cpp

@@ -41,8 +41,9 @@ const QString& NodeType::getNodeTypeName(NodeType_t nodeType) {
     return matchedTypeName != TypeNameHash.end() ? matchedTypeName.value() : UNKNOWN_NodeType_t_NAME;
 }
 
-Node::Node(const QUuid& uuid, NodeType_t type, const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket) :
+Node::Node(const QUuid& uuid, NodeType_t type, const HifiSockAddr& publicSocket,
-	NetworkPeer(uuid, publicSocket, localSocket),
+           const HifiSockAddr& localSocket, bool canAdjustLocks) :
+    NetworkPeer(uuid, publicSocket, localSocket),
     _type(type),
     _activeSocket(NULL),
     _symmetricSocket(),
@@ -52,7 +53,8 @@ Node::Node(const QUuid& uuid, NodeType_t type, const HifiSockAddr& publicSocket,
     _pingMs(-1),  // "Uninitialized"
     _clockSkewUsec(0),
     _mutex(),
-    _clockSkewMovingPercentile(30, 0.8f)   // moving 80th percentile of 30 samples
+    _clockSkewMovingPercentile(30, 0.8f),   // moving 80th percentile of 30 samples
+    _canAdjustLocks(canAdjustLocks)
 {
     
 }
@@ -131,6 +133,7 @@ QDataStream& operator<<(QDataStream& out, const Node& node) {
     out << node._uuid;
     out << node._publicSocket;
     out << node._localSocket;
+    out << node._canAdjustLocks;
     
     return out;
 }
@@ -140,6 +143,7 @@ QDataStream& operator>>(QDataStream& in, Node& node) {
     in >> node._uuid;
     in >> node._publicSocket;
     in >> node._localSocket;
+    in >> node._canAdjustLocks;
     
     return in;
 }

libraries/networking/src/Node.h

@@ -45,7 +45,8 @@ namespace NodeType {
 class Node : public NetworkPeer {
     Q_OBJECT
 public:
-    Node(const QUuid& uuid, NodeType_t type, const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket);
+    Node(const QUuid& uuid, NodeType_t type,
+         const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket, bool canAdjustLocks);
     ~Node();
 
     bool operator==(const Node& otherNode) const { return _uuid == otherNode._uuid; }
@@ -76,6 +77,9 @@ public:
     virtual void setSymmetricSocket(const HifiSockAddr& symmetricSocket);
     
     const HifiSockAddr* getActiveSocket() const { return _activeSocket; }
+
+    void setCanAdjustLocks(bool canAdjustLocks) { _canAdjustLocks = canAdjustLocks; }
+    bool getCanAdjustLocks() { return _canAdjustLocks; }
     
     void activatePublicSocket();
     void activateLocalSocket();
@@ -101,6 +105,7 @@ private:
     int _clockSkewUsec;
     QMutex _mutex;
     MovingPercentile _clockSkewMovingPercentile;
+    bool _canAdjustLocks;
 };
 
 QDebug operator<<(QDebug debug, const Node &message);

libraries/networking/src/NodeList.cpp

@@ -370,13 +370,6 @@ int NodeList::processDomainServerList(const QByteArray& packet) {
 
     int readNodes = 0;
     
-    // setup variables to read into from QDataStream
-    qint8 nodeType;
-    
-    QUuid nodeUUID, connectionUUID;
-
-    HifiSockAddr nodePublicSocket;
-    HifiSockAddr nodeLocalSocket;
     
     QDataStream packetStream(packet);
     packetStream.skipRawData(numBytesForPacketHeader(packet));
@@ -385,10 +378,20 @@ int NodeList::processDomainServerList(const QByteArray& packet) {
     QUuid newUUID;
     packetStream >> newUUID;
     setSessionUUID(newUUID);
+
+    bool thisNodeCanAdjustLocks;
+    packetStream >> thisNodeCanAdjustLocks;
+    setThisNodeCanAdjustLocks(thisNodeCanAdjustLocks);
     
     // pull each node in the packet
     while(packetStream.device()->pos() < packet.size()) {
-        packetStream >> nodeType >> nodeUUID >> nodePublicSocket >> nodeLocalSocket;
+        // setup variables to read into from QDataStream
+        qint8 nodeType;
+        QUuid nodeUUID, connectionUUID;
+        HifiSockAddr nodePublicSocket, nodeLocalSocket;
+        bool canAdjustLocks;
+
+        packetStream >> nodeType >> nodeUUID >> nodePublicSocket >> nodeLocalSocket >> canAdjustLocks;
 
         // if the public socket address is 0 then it's reachable at the same IP
         // as the domain server
@@ -396,7 +399,7 @@ int NodeList::processDomainServerList(const QByteArray& packet) {
             nodePublicSocket.setAddress(_domainHandler.getIP());
         }
 
-        SharedNodePointer node = addOrUpdateNode(nodeUUID, nodeType, nodePublicSocket, nodeLocalSocket);
+        SharedNodePointer node = addOrUpdateNode(nodeUUID, nodeType, nodePublicSocket, nodeLocalSocket, canAdjustLocks);
         
         packetStream >> connectionUUID;
         node->setConnectionSecret(connectionUUID);

libraries/networking/src/PacketHeaders.cpp

@@ -64,7 +64,7 @@ PacketVersion versionForPacketType(PacketType type) {
             return 2;
         case PacketTypeDomainList:
         case PacketTypeDomainListRequest:
-            return 3;
+            return 4;
         case PacketTypeCreateAssignment:
         case PacketTypeRequestAssignment:
             return 2;

tests/octree/src/ModelTests.cpp

@@ -107,7 +107,7 @@ void EntityTests::entityTreeTests(bool verbose) {
 
         properties.setPosition(newPosition);
 
-        tree.updateEntity(entityID, properties);
+        tree.updateEntity(entityID, properties, true);
         
         float targetRadius = oneMeter * 2.0 / (float)TREE_SCALE; // in tree units
         const EntityItem* foundEntityByRadius = tree.findClosestEntity(positionNearOriginInTreeUnits, targetRadius);
@@ -147,7 +147,7 @@ void EntityTests::entityTreeTests(bool verbose) {
 
         properties.setPosition(newPosition);
 
-        tree.updateEntity(entityID, properties);
+        tree.updateEntity(entityID, properties, true);
         
         float targetRadius = oneMeter * 2.0 / (float)TREE_SCALE; // in tree units
         const EntityItem* foundEntityByRadius = tree.findClosestEntity(positionAtCenterInTreeUnits, targetRadius);