Remove return type for lookup/removeAsync

Summary: As title. We have only one possible return value.

Reviewed By: therealgymmy

Differential Revision: D40962097

fbshipit-source-id: 6895984d3d9c34d58f0ed12526da0e4b02202c58

Author: haowu14

cachelib/allocator/nvmcache/NvmCache-inl.h

@@ -182,14 +182,11 @@ typename NvmCache<C>::WriteHandle NvmCache<C>::find(HashedKey hk) {
   XDCHECK(ctx);
   auto guard = folly::makeGuard([hk, this]() { removeFromFillMap(hk); });
 
-  auto status = navyCache_->lookupAsync(
+  navyCache_->lookupAsync(
       HashedKey::precomputed(ctx->getKey(), hk.keyHash()),
       [this, ctx](navy::Status s, HashedKey k, navy::Buffer v) {
         this->onGetComplete(*ctx, s, k, v.view());
       });
-
-  XDCHECK_EQ(status, navy::Status::Ok);
-
   guard.dismiss();
   return hdl;
 }
@@ -257,17 +254,14 @@ typename NvmCache<C>::WriteHandle NvmCache<C>::peek(folly::StringPiece key) {
 
   // no need for fill lock or inspecting the state of other concurrent
   // operations since we only want to check the state for debugging purposes.
-  auto status = navyCache_->lookupAsync(
+  navyCache_->lookupAsync(
       HashedKey{key}, [&, this](navy::Status st, HashedKey, navy::Buffer v) {
         if (st != navy::Status::NotFound) {
           auto nvmItem = reinterpret_cast<const NvmItem*>(v.data());
           hdl = createItem(key, *nvmItem);
         }
         b.post();
       });
-  if (status != navy::Status::Ok) {
-    return hdl;
-  }
   b.wait();
   return hdl;
 }
@@ -843,11 +837,8 @@ void NvmCache<C>::remove(HashedKey hk, DeleteTombStoneGuard tombstone) {
                                static_cast<int>(status)));
   };
 
-  auto status = navyCache_->removeAsync(
-      HashedKey::precomputed(ctx.key(), hk.keyHash()), delCleanup);
-  if (status != navy::Status::Ok) {
-    delCleanup(status, HashedKey::precomputed("", 0));
-  }
+  navyCache_->removeAsync(HashedKey::precomputed(ctx.key(), hk.keyHash()),
+                          delCleanup);
 }
 
 template <typename C>

cachelib/navy/AbstractCache.h

@@ -85,9 +85,7 @@ class AbstractCache {
   //
   // @key must be valid till delayed async job execution, no copy is made. It
   // is user responsibility to make a copy if needed (capture in callback).
-  //
-  // Returns: Ok, Rejected
-  virtual Status lookupAsync(HashedKey key, LookupCallback cb) = 0;
+  virtual void lookupAsync(HashedKey key, LookupCallback cb) = 0;
 
   // Removes from the index, space reused after reclamation.
   // Returns: Ok, NotFound
@@ -97,9 +95,7 @@ class AbstractCache {
   // Callback is optional.
   //
   // See @lookupAsync about @key lifetime.
-  //
-  // Returns: Ok, Rejected
-  virtual Status removeAsync(HashedKey key, RemoveCallback cb) = 0;
+  virtual void removeAsync(HashedKey key, RemoveCallback cb) = 0;
 
   // Executes all queued operations and makes sure result is reflected on the
   // device.

cachelib/navy/block_cache/tests/BlockCacheTest.cpp

@@ -314,27 +314,22 @@ TEST(BlockCache, AsyncCallbacks) {
   MockLookupCB cbLookup;
   EXPECT_CALL(cbLookup, call(Status::Ok, makeHK("key"), makeView("value")));
   EXPECT_CALL(cbLookup, call(Status::NotFound, makeHK("cat"), BufferView{}));
-  EXPECT_EQ(Status::Ok,
-            driver->lookupAsync(
-                makeHK("key"),
-                [&cbLookup](Status status, HashedKey key, Buffer value) {
-                  cbLookup.call(status, key, value.view());
-                }));
-  EXPECT_EQ(Status::Ok,
-            driver->lookupAsync(
-                makeHK("cat"),
-                [&cbLookup](Status status, HashedKey key, Buffer value) {
-                  cbLookup.call(status, key, value.view());
-                }));
+  driver->lookupAsync(makeHK("key"),
+                      [&cbLookup](Status status, HashedKey key, Buffer value) {
+                        cbLookup.call(status, key, value.view());
+                      });
+
+  driver->lookupAsync(makeHK("cat"),
+                      [&cbLookup](Status status, HashedKey key, Buffer value) {
+                        cbLookup.call(status, key, value.view());
+                      });
   driver->flush();
 
   MockRemoveCB cbRemove;
   EXPECT_CALL(cbRemove, call(Status::Ok, makeHK("key")));
   EXPECT_CALL(cbRemove, call(Status::NotFound, makeHK("cat")));
-  EXPECT_EQ(Status::Ok,
-            driver->removeAsync(makeHK("key"), toCallback(cbRemove)));
-  EXPECT_EQ(Status::Ok,
-            driver->removeAsync(makeHK("cat"), toCallback(cbRemove)));
+  driver->removeAsync(makeHK("key"), toCallback(cbRemove));
+  driver->removeAsync(makeHK("cat"), toCallback(cbRemove));
   driver->flush();
 }
 

cachelib/navy/driver/Driver.cpp

@@ -171,19 +171,17 @@ Status Driver::lookup(HashedKey hk, Buffer& value) {
   return enginePairs_[selectEnginePair(hk)].lookupSync(hk, value);
 }
 
-Status Driver::lookupAsync(HashedKey hk, LookupCallback cb) {
+void Driver::lookupAsync(HashedKey hk, LookupCallback cb) {
   XDCHECK(cb);
   enginePairs_[selectEnginePair(hk)].scheduleLookup(hk, std::move(cb));
-  return Status::Ok;
 }
 
 Status Driver::remove(HashedKey hk) {
   return enginePairs_[selectEnginePair(hk)].removeSync(hk);
 }
 
-Status Driver::removeAsync(HashedKey hk, RemoveCallback cb) {
+void Driver::removeAsync(HashedKey hk, RemoveCallback cb) {
   enginePairs_[selectEnginePair(hk)].scheduleRemove(hk, std::move(cb));
-  return Status::Ok;
 }
 
 void Driver::flush() {

cachelib/navy/driver/Driver.h

@@ -105,9 +105,7 @@ class Driver final : public AbstractCache {
   // @param key  the item key to lookup
   // @param cb   a callback function be triggered when the lookup complete,
   //             the result will be provided to the function.
-  // @return     a status indicates success or failure enqueued, and the reason
-  //             for failure
-  Status lookupAsync(HashedKey key, LookupCallback cb) override;
+  void lookupAsync(HashedKey key, LookupCallback cb) override;
 
   // remove the key from cache
   // @param key  the item key to be removed
@@ -117,9 +115,7 @@ class Driver final : public AbstractCache {
   // remove the key from cache asynchronously.
   // @param key  the item key to be removed
   // @param cb   a callback function be triggered when the remove complete.
-  // @return     a status indicates success or failure enqueued, and the reason
-  //             for failure
-  Status removeAsync(HashedKey key, RemoveCallback cb) override;
+  void removeAsync(HashedKey key, RemoveCallback cb) override;
 
   // ensure all pending job have been completed and data has been flush to
   // device(s).