Merge master

Author: coleaeason

BedrockCommand.h

@@ -139,32 +139,3 @@ class BedrockCommand : public SQLiteCommand {
 
     static atomic<size_t> _commandCount;
 };
-
-#include <BedrockCommand.h>
-
-class checkedUniquePtr_BedrockCommand : public unique_ptr<BedrockCommand> {
-  public:
-
-    // Constructors.
-    checkedUniquePtr_BedrockCommand(unique_ptr<BedrockCommand>&& other) {
-        unique_ptr<BedrockCommand>::operator=(move(other));
-    }
-    checkedUniquePtr_BedrockCommand(BedrockCommand* other) : unique_ptr<BedrockCommand>(other) { }
-    checkedUniquePtr_BedrockCommand(nullptr_t np) : unique_ptr<BedrockCommand>(np) {}
-
-    // Copy by calling parent copy assignment operator.
-    checkedUniquePtr_BedrockCommand& operator=(unique_ptr<BedrockCommand>&& other) {
-        unique_ptr<BedrockCommand>::operator=(move(other));
-        return *this;
-    }
-
-    BedrockCommand* operator->() const {
-        if (get() == nullptr) {
-            STHROW_STACK("Dereferencing null pointer");
-        }
-        return get();
-    }
-};
-
-typedef checkedUniquePtr_BedrockCommand BedrockCommandPtr;
-

BedrockCommandQueue.cpp

@@ -1,15 +1,15 @@
 #include <BedrockCommandQueue.h>
 
-void BedrockCommandQueue::startTiming(BedrockCommandPtr& command) {
+void BedrockCommandQueue::startTiming(unique_ptr<BedrockCommand>& command) {
     command->startTiming(BedrockCommand::QUEUE_WORKER);
 }
 
-void BedrockCommandQueue::stopTiming(BedrockCommandPtr& command) {
+void BedrockCommandQueue::stopTiming(unique_ptr<BedrockCommand>& command) {
     command->stopTiming(BedrockCommand::QUEUE_WORKER);
 }
 
 BedrockCommandQueue::BedrockCommandQueue() :
-  SScheduledPriorityQueue<BedrockCommandPtr>(function<void(BedrockCommandPtr&)>(startTiming), function<void(BedrockCommandPtr&)>(stopTiming))
+  SScheduledPriorityQueue<unique_ptr<BedrockCommand>>(function<void(unique_ptr<BedrockCommand>&)>(startTiming), function<void(unique_ptr<BedrockCommand>&)>(stopTiming))
 { }
 
 list<string> BedrockCommandQueue::getRequestMethodLines() {
@@ -64,9 +64,9 @@ void BedrockCommandQueue::abandonFutureCommands(int msInFuture) {
     }
 }
 
-void BedrockCommandQueue::push(BedrockCommandPtr&& command) {
+void BedrockCommandQueue::push(unique_ptr<BedrockCommand>&& command) {
     BedrockCommand::Priority priority = command->priority;
     uint64_t executionTime = command->request.calcU64("commandExecuteTime");
     uint64_t timeout = command->timeout();
-    SScheduledPriorityQueue<BedrockCommandPtr>::push(move(command), priority, executionTime, timeout);
+    SScheduledPriorityQueue<unique_ptr<BedrockCommand>>::push(move(command), priority, executionTime, timeout);
 }

BedrockCommandQueue.h

@@ -3,13 +3,13 @@
 #include <libstuff/SScheduledPriorityQueue.h>
 #include "BedrockCommand.h"
 
-class BedrockCommandQueue : public SScheduledPriorityQueue<BedrockCommandPtr> {
+class BedrockCommandQueue : public SScheduledPriorityQueue<unique_ptr<BedrockCommand>> {
   public:
     BedrockCommandQueue();
 
     // Functions to start and stop timing on the commands when they're inserted/removed from the queue.
-    static void startTiming(BedrockCommandPtr& command);
-    static void stopTiming(BedrockCommandPtr& command);
+    static void startTiming(unique_ptr<BedrockCommand>& command);
+    static void stopTiming(unique_ptr<BedrockCommand>& command);
 
     // Returns a list of all the method lines for all the requests currently queued. This function exists for state
     // reporting, and is called by BedrockServer when we receive a `Status` command.
@@ -19,5 +19,5 @@ class BedrockCommandQueue : public SScheduledPriorityQueue<BedrockCommandPtr> {
     void abandonFutureCommands(int msInFuture);
 
     // Add an item to the queue. The queue takes ownership of the item and the caller's copy is invalidated.
-    void push(BedrockCommandPtr&& command);
+    void push(unique_ptr<BedrockCommand>&& command);
 };

BedrockCore.cpp

@@ -29,7 +29,7 @@ class AutoScopeRewrite {
     bool (*_handler)(int, const char*, string&);
 };
 
-uint64_t BedrockCore::_getRemainingTime(const BedrockCommandPtr& command) {
+uint64_t BedrockCore::_getRemainingTime(const unique_ptr<BedrockCommand>& command) {
     int64_t timeout = command->timeout();
     int64_t now = STimeNow();
 
@@ -53,7 +53,7 @@ uint64_t BedrockCore::_getRemainingTime(const BedrockCommandPtr& command) {
     return min(processTimeout, adjustedTimeout);
 }
 
-bool BedrockCore::isTimedOut(BedrockCommandPtr& command) {
+bool BedrockCore::isTimedOut(unique_ptr<BedrockCommand>& command) {
     try {
         _getRemainingTime(command);
     } catch (const SException& e) {
@@ -65,7 +65,7 @@ bool BedrockCore::isTimedOut(BedrockCommandPtr& command) {
     return false;
 }
 
-bool BedrockCore::peekCommand(BedrockCommandPtr& command) {
+bool BedrockCore::peekCommand(unique_ptr<BedrockCommand>& command) {
     AutoTimer timer(command, BedrockCommand::PEEK);
     // Convenience references to commonly used properties.
     SData& request = command->request;
@@ -177,7 +177,7 @@ bool BedrockCore::peekCommand(BedrockCommandPtr& command) {
     return true;
 }
 
-bool BedrockCore::processCommand(BedrockCommandPtr& command) {
+bool BedrockCore::processCommand(unique_ptr<BedrockCommand>& command) {
     AutoTimer timer(command, BedrockCommand::PROCESS);
 
     // Convenience references to commonly used properties.
@@ -278,7 +278,7 @@ bool BedrockCore::processCommand(BedrockCommandPtr& command) {
     return needsCommit;
 }
 
-void BedrockCore::_handleCommandException(BedrockCommandPtr& command, const SException& e) {
+void BedrockCore::_handleCommandException(unique_ptr<BedrockCommand>& command, const SException& e) {
     const string& msg = "Error processing command '" + command->request.methodLine + "' (" + e.what() + "), ignoring.";
     if (SContains(e.what(), "_ALERT_")) {
         SALERT(msg);

BedrockCore.h

@@ -10,21 +10,21 @@ class BedrockCore : public SQLiteCore {
     // Automatic timing class that records an entry corresponding to its lifespan.
     class AutoTimer {
       public:
-        AutoTimer(BedrockCommandPtr& command, BedrockCommand::TIMING_INFO type) :
+        AutoTimer(unique_ptr<BedrockCommand>& command, BedrockCommand::TIMING_INFO type) :
         _command(command), _type(type), _start(STimeNow()) { }
         ~AutoTimer() {
             _command->timingInfo.emplace_back(make_tuple(_type, _start, STimeNow()));
         }
       private:
-        BedrockCommandPtr& _command;
+        unique_ptr<BedrockCommand>& _command;
         BedrockCommand::TIMING_INFO _type;
         uint64_t _start;
     };
 
     // Checks if a command has already timed out. Like `peekCommand` without doing any work. Returns `true` and sets
     // the same command state as `peekCommand` would if the command has timed out. Returns `false` and does nothing if
     // the command hasn't timed out.
-    bool isTimedOut(BedrockCommandPtr& command);
+    bool isTimedOut(unique_ptr<BedrockCommand>& command);
 
     // Peek lets you pre-process a command. It will be called on each command before `process` is called on the same
     // command, and it *may be called multiple times*. Preventing duplicate actions on calling peek multiple times is
@@ -33,7 +33,7 @@ class BedrockCore : public SQLiteCore {
     // should be considered an error to modify the DB from inside `peek`.
     // Returns a boolean value of `true` if the command is complete and its `response` field can be returned to the
     // caller. Returns `false` if the command will need to be passed to `process` to complete handling the command.
-    bool peekCommand(BedrockCommandPtr& command);
+    bool peekCommand(unique_ptr<BedrockCommand>& command);
 
     // Process is the follow-up to `peek` if `peek` was insufficient to handle the command. It will only ever be called
     // on the leader node, and should always be able to resolve the command completely. When a command is passed to
@@ -45,7 +45,7 @@ class BedrockCore : public SQLiteCore {
     // replicate the transaction to follower nodes. Upon being returned `true`, the caller will attempt to perform a
     // `COMMIT` and replicate the transaction to follower nodes. It's allowable for this `COMMIT` to fail, in which case
     // this command *will be passed to process again in the future to retry*.
-    bool processCommand(BedrockCommandPtr& command);
+    bool processCommand(unique_ptr<BedrockCommand>& command);
 
   private:
     // When called in the context of handling an exception, returns the demangled (if possible) name of the exception.
@@ -54,8 +54,8 @@ class BedrockCore : public SQLiteCore {
     // Gets the amount of time remaining until this command times out. This is the difference between the command's
     // 'timeout' value (or the default timeout, if not set) and the time the command was initially scheduled to run. If
     // this time is already expired, this throws `555 Timeout`
-    uint64_t _getRemainingTime(const BedrockCommandPtr& command);
+    uint64_t _getRemainingTime(const unique_ptr<BedrockCommand>& command);
 
-    void _handleCommandException(BedrockCommandPtr& command, const SException& e);
+    void _handleCommandException(unique_ptr<BedrockCommand>& command, const SException& e);
     const BedrockServer& _server;
 };

BedrockServer.cpp

@@ -26,7 +26,7 @@ void BedrockServer::acceptCommand(SQLiteCommand&& command, bool isNew) {
         }
         SALERT("Blacklisting command (now have " << totalCount << " blacklisted commands): " << request.serialize());
     } else {
-        BedrockCommandPtr newCommand = make_unique<BedrockCommand>(move(command));
+        unique_ptr<BedrockCommand> newCommand = make_unique<BedrockCommand>(move(command));
         if (SIEquals(newCommand->request.methodLine, "BROADCAST_COMMAND")) {
             SData newRequest;
             newRequest.deserialize(newCommand->request.content);
@@ -193,7 +193,7 @@ void BedrockServer::sync(const SData& args,
 
     // Now we jump into our main command processing loop.
     uint64_t nextActivity = STimeNow();
-    BedrockCommandPtr command(nullptr);
+    unique_ptr<BedrockCommand> command(nullptr);
     bool committingCommand = false;
 
     // We hold a lock here around all operations on `syncNode`, because `SQLiteNode` isn't thread-safe, but we need
@@ -400,7 +400,7 @@ void BedrockServer::sync(const SData& args,
             try {
                 while (true) {
                     // Reset this to blank. This releases the existing command and allows it to get cleaned up.
-                    command = BedrockCommandPtr(nullptr);
+                    command = unique_ptr<BedrockCommand>(nullptr);
                     command = syncNodeQueuedCommands.pop();
                     if (command->initiatingClientID) {
                         // This one came from a local client, so we can save it for later.
@@ -471,7 +471,7 @@ void BedrockServer::sync(const SData& args,
             // If there are any completed commands to respond to, we'll do that first.
             try {
                 while (true) {
-                    BedrockCommandPtr completedCommand = server._completedCommands.pop();
+                    unique_ptr<BedrockCommand> completedCommand = server._completedCommands.pop();
                     SAUTOPREFIX(completedCommand->request);
                     SASSERT(completedCommand->complete);
                     SASSERT(completedCommand->initiatingPeerID);
@@ -488,7 +488,7 @@ void BedrockServer::sync(const SData& args,
             }
 
             // Reset this to blank. This releases the existing command and allows it to get cleaned up.
-            command = BedrockCommandPtr(nullptr);
+            command = unique_ptr<BedrockCommand>(nullptr);
 
             // Get the next sync node command to work on.
             command = syncNodeQueuedCommands.pop();
@@ -684,7 +684,7 @@ void BedrockServer::worker(const SData& args,
     BedrockCore core(db, server);
 
     // Command to work on. This default command is replaced when we find work to do.
-    BedrockCommandPtr command(nullptr);
+    unique_ptr<BedrockCommand> command(nullptr);
 
     // Which command queue do we use? The blockingCommit thread special and does blocking commits from the blocking queue.
     BedrockCommandQueue& commandQueue = threadId ? server._commandQueue : server._blockingCommandQueue;
@@ -699,7 +699,7 @@ void BedrockServer::worker(const SData& args,
             });
 
             // Reset this to blank. This releases the existing command and allows it to get cleaned up.
-            command = BedrockCommandPtr(nullptr);
+            command = unique_ptr<BedrockCommand>(nullptr);
 
             // And get another one.
             command = commandQueue.get(1000000);
@@ -1061,7 +1061,7 @@ void BedrockServer::worker(const SData& args,
     }
 }
 
-bool BedrockServer::_handleIfStatusOrControlCommand(BedrockCommandPtr& command) {
+bool BedrockServer::_handleIfStatusOrControlCommand(unique_ptr<BedrockCommand>& command) {
     if (_isStatusCommand(command)) {
         _status(command);
         _reply(command);
@@ -1081,7 +1081,7 @@ bool BedrockServer::_handleIfStatusOrControlCommand(BedrockCommandPtr& command)
     return false;
 }
 
-bool BedrockServer::_wouldCrash(const BedrockCommandPtr& command) {
+bool BedrockServer::_wouldCrash(const unique_ptr<BedrockCommand>& command) {
     // Get a shared lock so that all the workers can look at this map simultaneously.
     shared_lock<decltype(_crashCommandMutex)> lock(_crashCommandMutex);
 
@@ -1516,7 +1516,7 @@ void BedrockServer::postPoll(fd_map& fdm, uint64_t& nextActivity) {
                     }
 
                     // Create a command.
-                    BedrockCommandPtr command = make_unique<BedrockCommand>(request);
+                    unique_ptr<BedrockCommand> command = make_unique<BedrockCommand>(request);
 
                     // Get the source ip of the command.
                     char *ip = inet_ntoa(s->addr.sin_addr);
@@ -1622,7 +1622,7 @@ void BedrockServer::postPoll(fd_map& fdm, uint64_t& nextActivity) {
     }
 }
 
-void BedrockServer::_reply(BedrockCommandPtr& command) {
+void BedrockServer::_reply(unique_ptr<BedrockCommand>& command) {
     SAUTOLOCK(_socketIDMutex);
 
     // Finalize timing info even for commands we won't respond to (this makes this data available in logs).
@@ -1707,7 +1707,7 @@ void BedrockServer::suppressCommandPort(const string& reason, bool suppress, boo
     }
 }
 
-bool BedrockServer::_isStatusCommand(const BedrockCommandPtr& command) {
+bool BedrockServer::_isStatusCommand(const unique_ptr<BedrockCommand>& command) {
     if (SIEquals(command->request.methodLine, STATUS_IS_SLAVE)          ||
         SIEquals(command->request.methodLine, STATUS_IS_FOLLOWER)       ||
         SIEquals(command->request.methodLine, STATUS_HANDLING_COMMANDS) ||
@@ -1759,7 +1759,7 @@ bool BedrockServer::isDetached() {
     return _detach && _syncThreadComplete;
 }
 
-void BedrockServer::_status(BedrockCommandPtr& command) {
+void BedrockServer::_status(unique_ptr<BedrockCommand>& command) {
     SData& request  = command->request;
     SData& response = command->response;
 
@@ -1917,7 +1917,7 @@ void BedrockServer::_status(BedrockCommandPtr& command) {
     }
 }
 
-bool BedrockServer::_isControlCommand(const BedrockCommandPtr& command) {
+bool BedrockServer::_isControlCommand(const unique_ptr<BedrockCommand>& command) {
     if (SIEquals(command->request.methodLine, "BeginBackup")            ||
         SIEquals(command->request.methodLine, "SuppressCommandPort")    ||
         SIEquals(command->request.methodLine, "ClearCommandPort")       ||
@@ -1933,7 +1933,7 @@ bool BedrockServer::_isControlCommand(const BedrockCommandPtr& command) {
     return false;
 }
 
-void BedrockServer::_control(BedrockCommandPtr& command) {
+void BedrockServer::_control(unique_ptr<BedrockCommand>& command) {
     SData& response = command->response;
     response.methodLine = "200 OK";
     if (SIEquals(command->request.methodLine, "BeginBackup")) {
@@ -2078,7 +2078,7 @@ bool BedrockServer::shouldBackup() {
     return _shouldBackup;
 }
 
-SData BedrockServer::_generateCrashMessage(const BedrockCommandPtr& command) {
+SData BedrockServer::_generateCrashMessage(const unique_ptr<BedrockCommand>& command) {
     SData message("CRASH_COMMAND");
     SData subMessage(command->request.methodLine);
     for (auto& pair : command->crashIdentifyingValues) {
@@ -2106,7 +2106,7 @@ void BedrockServer::onNodeLogin(SQLiteNode::Peer* peer)
             SALERT("Sending crash command " << p.first << " to node " << peer->name << " on login");
             SData command(p.first);
             command.nameValueMap = table;
-            BedrockCommandPtr cmd = make_unique<BedrockCommand>(command);
+            unique_ptr<BedrockCommand> cmd = make_unique<BedrockCommand>(command);
             for (const auto& fields : command.nameValueMap) {
                 cmd->crashIdentifyingValues.insert(fields.first);
             }
@@ -2118,7 +2118,7 @@ void BedrockServer::onNodeLogin(SQLiteNode::Peer* peer)
     }
 }
 
-void BedrockServer::_finishPeerCommand(BedrockCommandPtr& command) {
+void BedrockServer::_finishPeerCommand(unique_ptr<BedrockCommand>& command) {
     // See if we're supposed to forget this command (because the follower is not listening for a response).
     auto it = command->request.nameValueMap.find("Connection");
     bool forget = it != command->request.nameValueMap.end() && SIEquals(it->second, "forget");
@@ -2150,7 +2150,7 @@ void BedrockServer::_acceptSockets() {
     }
 }
 
-void BedrockServer::waitForHTTPS(BedrockCommandPtr&& command) {
+void BedrockServer::waitForHTTPS(unique_ptr<BedrockCommand>&& command) {
     lock_guard<mutex> lock(_httpsCommandMutex);
 
     // Un-uniquify the unique_ptr. I don't love this, but it works better with the code we've already got.
@@ -2187,7 +2187,7 @@ int BedrockServer::finishWaitingForHTTPS(list<SHTTPSManager::Transaction*>& comp
             // I guess it's still here! Is it done?
             if (commandPtr->areHttpsRequestsComplete()) {
                 // If so, add it back to the main queue, erase its entry in _outstandingHTTPSCommands, and delete it.
-                _commandQueue.push(BedrockCommandPtr(commandPtr));
+                _commandQueue.push(unique_ptr<BedrockCommand>(commandPtr));
                 _outstandingHTTPSCommands.erase(commandPtrIt);
                 commandsCompleted++;
             }