Refactor: remove return value for reserve/release

The functions may only fail with invalid input to the
functions and if that happens an exception is thrown

Change-Id: Ie36b0888205281e4a0207fe1ff6ea0283a98f0b3
Reviewed-on: http://review.couchbase.org/c/kv_engine/+/143490
Tested-by: Build Bot <[email protected]>
Reviewed-by: Dave Rigby <[email protected]>

Author: trondn

auditd/tests/testauditd.cc

@@ -93,10 +93,10 @@ class AuditMockServerCookieApi : public ServerCookieIface {
         throw std::runtime_error("Not implemented");
     }
 
-    ENGINE_ERROR_CODE reserve(gsl::not_null<const void*> cookie) override {
+    void reserve(gsl::not_null<const void*> cookie) override {
         throw std::runtime_error("Not implemented");
     }
-    ENGINE_ERROR_CODE release(gsl::not_null<const void*> cookie) override {
+    void release(gsl::not_null<const void*> cookie) override {
         throw std::runtime_error("Not implemented");
     }
     void set_priority(gsl::not_null<const void*> cookie,

daemon/server_api.cc

@@ -191,12 +191,11 @@ struct ServerCookieApi : public ServerCookieIface {
         ::scheduleDcpStep(getCookie(cookie));
     }
 
-    ENGINE_ERROR_CODE reserve(gsl::not_null<const void*> void_cookie) override {
+    void reserve(gsl::not_null<const void*> void_cookie) override {
         getCookie(void_cookie).incrementRefcount();
-        return ENGINE_SUCCESS;
     }
 
-    ENGINE_ERROR_CODE release(gsl::not_null<const void*> void_cookie) override {
+    void release(gsl::not_null<const void*> void_cookie) override {
         auto& cookie = getCookie(void_cookie);
         auto& connection = cookie.getConnection();
         auto& thr = connection.getThread();
@@ -216,8 +215,6 @@ struct ServerCookieApi : public ServerCookieIface {
         if (thr.notification.push(&connection)) {
             notify_thread(thr);
         }
-
-        return ENGINE_SUCCESS;
     }
 
     void set_priority(gsl::not_null<const void*> cookie,

engines/ep/src/ep_engine.cc

@@ -1934,16 +1934,14 @@ EventuallyPersistentEngine::EventuallyPersistentEngine(
     serverApi = getServerApiFunc();
 }
 
-ENGINE_ERROR_CODE EventuallyPersistentEngine::reserveCookie(const void *cookie)
-{
+void EventuallyPersistentEngine::reserveCookie(const void* cookie) {
     NonBucketAllocationGuard guard;
-    return serverApi->cookie->reserve(cookie);
+    serverApi->cookie->reserve(cookie);
 }
 
-ENGINE_ERROR_CODE EventuallyPersistentEngine::releaseCookie(const void *cookie)
-{
+void EventuallyPersistentEngine::releaseCookie(const void* cookie) {
     NonBucketAllocationGuard guard;
-    return serverApi->cookie->release(cookie);
+    serverApi->cookie->release(cookie);
 }
 
 void EventuallyPersistentEngine::setDcpConnHandler(
@@ -6196,12 +6194,7 @@ ENGINE_ERROR_CODE EventuallyPersistentEngine::dcpOpen(
     }
 
     // Success creating dcp object which has stored the cookie, now reserve it.
-    if (reserveCookie(cookie) != ENGINE_SUCCESS) {
-        EP_LOG_WARN(
-                "Cannot create DCP connection because cookie "
-                "cannot be reserved");
-        return ENGINE_DISCONNECT;
-    }
+    reserveCookie(cookie);
     setDcpConnHandler(cookie, handler);
 
     return ENGINE_SUCCESS;

engines/ep/src/ep_engine.h

@@ -532,8 +532,8 @@ class EventuallyPersistentEngine : public EngineIface, public DcpIface {
     void notifyIOComplete(const void* cookie, ENGINE_ERROR_CODE status);
     void scheduleDcpStep(gsl::not_null<const void*> cookie);
 
-    ENGINE_ERROR_CODE reserveCookie(const void *cookie);
-    ENGINE_ERROR_CODE releaseCookie(const void *cookie);
+    void reserveCookie(const void* cookie);
+    void releaseCookie(const void* cookie);
 
     void setDcpConnHandler(const void* cookie, DcpConnHandlerIface* handler);
     DcpConnHandlerIface* getDcpConnHandler(const void* cookie);

engines/ep/tests/module_tests/dcp_test.cc

@@ -123,11 +123,11 @@ class WrappedServerCookieIface : public ServerCookieIface {
     void scheduleDcpStep(gsl::not_null<const void*> cookie) override {
         wrapped->scheduleDcpStep(cookie);
     }
-    ENGINE_ERROR_CODE reserve(gsl::not_null<const void*> cookie) override {
-        return wrapped->reserve(cookie);
+    void reserve(gsl::not_null<const void*> cookie) override {
+        wrapped->reserve(cookie);
     }
-    ENGINE_ERROR_CODE release(gsl::not_null<const void*> cookie) override {
-        return wrapped->release(cookie);
+    void release(gsl::not_null<const void*> cookie) override {
+        wrapped->release(cookie);
     }
     void set_priority(gsl::not_null<const void*> cookie,
                       ConnectionPriority priority) override {

include/memcached/server_cookie_iface.h

@@ -170,14 +170,14 @@ struct ServerCookieIface {
      * future use. (The core guarantees it will not invalidate the
      * memory until the cookie is invalidated by calling release())
      */
-    virtual ENGINE_ERROR_CODE reserve(gsl::not_null<const void*> cookie) = 0;
+    virtual void reserve(gsl::not_null<const void*> cookie) = 0;
 
     /**
      * Notify the core that we're releasing the reference to the
      * The engine is not allowed to use the cookie (the core may invalidate
      * the memory)
      */
-    virtual ENGINE_ERROR_CODE release(gsl::not_null<const void*> cookie) = 0;
+    virtual void release(gsl::not_null<const void*> cookie) = 0;
 
     /**
      * Set the priority for this connection

programs/engine_testapp/mock_server.cc

@@ -294,23 +294,22 @@ struct MockServerCookieApi : public ServerCookieIface {
         session_ctr--;
     }
 
-    ENGINE_ERROR_CODE reserve(gsl::not_null<const void*> cookie) override {
+    void reserve(gsl::not_null<const void*> cookie) override {
         std::lock_guard<std::mutex> guard(mock_server_cookie_mutex);
         auto* c = cookie_to_mock_cookie(cookie.get());
         c->references++;
-        return ENGINE_SUCCESS;
     }
 
-    ENGINE_ERROR_CODE release(gsl::not_null<const void*> cookie) override {
+    void release(gsl::not_null<const void*> cookie) override {
         std::lock_guard<std::mutex> guard(mock_server_cookie_mutex);
         auto* c = cookie_to_mock_cookie(cookie.get());
 
         const int new_rc = --c->references;
         if (new_rc == 0) {
             delete c;
         }
-        return ENGINE_SUCCESS;
     }
+
     void set_priority(gsl::not_null<const void*> cookie,
                       ConnectionPriority) override {
         (void)cookie_to_mock_cookie(cookie.get()); // validate cookie