libstore: un-callback-ify Store::queryRealisationUncached

Change-Id: I4a328f46eaac3bb8b19ddc091306de83348be9cf

src/libstore/binary-cache-store.cc

@@ -442,21 +442,16 @@ StorePath BinaryCacheStore::addTextToStore(
     })->path;
 }
 
-void BinaryCacheStore::queryRealisationUncached(const DrvOutput & id,
+std::shared_ptr<const Realisation> BinaryCacheStore::queryRealisationUncached(const DrvOutput & id)
-    Callback<std::shared_ptr<const Realisation>> callback) noexcept
 {
     auto outputInfoFilePath = realisationsPrefix + "/" + id.to_string() + ".doi";
 
-    try {
     auto data = getFile(outputInfoFilePath);
-        if (!data) return callback({});
+    if (!data) return {};
 
     auto realisation = Realisation::fromJSON(
         nlohmann::json::parse(*data), outputInfoFilePath);
-        return callback(std::make_shared<const Realisation>(realisation));
+    return std::make_shared<const Realisation>(realisation);
-    } catch (...) {
-        callback.rethrow();
-    }
 }
 
 void BinaryCacheStore::registerDrvOutput(const Realisation& info) {

src/libstore/binary-cache-store.hh

@@ -134,8 +134,7 @@ public:
 
     void registerDrvOutput(const Realisation & info) override;
 
-    void queryRealisationUncached(const DrvOutput &,
+    std::shared_ptr<const Realisation> queryRealisationUncached(const DrvOutput &) override;
-        Callback<std::shared_ptr<const Realisation>> callback) noexcept override;
 
     void narFromPath(const StorePath & path, Sink & sink) override;
 

src/libstore/build/local-derivation-goal.cc

@@ -1353,14 +1353,13 @@ struct RestrictedStore : public virtual RestrictedStoreConfig, public virtual In
     // corresponds to an allowed derivation
     { throw Error("registerDrvOutput"); }
 
-    void queryRealisationUncached(const DrvOutput & id,
+    std::shared_ptr<const Realisation> queryRealisationUncached(const DrvOutput & id) override
-        Callback<std::shared_ptr<const Realisation>> callback) noexcept override
     // XXX: This should probably be allowed if the realisation corresponds to
     // an allowed derivation
     {
         if (!goal.isAllowed(id))
-            callback(nullptr);
+            return nullptr;
-        next->queryRealisation(id, std::move(callback));
+        return next->queryRealisation(id);
     }
 
     void buildPaths(const std::vector<DerivedPath> & paths, BuildMode buildMode, std::shared_ptr<Store> evalStore) override

src/libstore/dummy-store.cc

@@ -67,9 +67,8 @@ struct DummyStore : public virtual DummyStoreConfig, public virtual Store
     void narFromPath(const StorePath & path, Sink & sink) override
     { unsupported("narFromPath"); }
 
-    void queryRealisationUncached(const DrvOutput &,
+    std::shared_ptr<const Realisation> queryRealisationUncached(const DrvOutput &) override
-        Callback<std::shared_ptr<const Realisation>> callback) noexcept override
+    { return nullptr; }
-    { callback(nullptr); }
 
     virtual ref<FSAccessor> getFSAccessor() override
     { unsupported("getFSAccessor"); }

src/libstore/legacy-ssh-store.cc

@@ -407,8 +407,7 @@ public:
         return std::nullopt;
     }
 
-    void queryRealisationUncached(const DrvOutput &,
+    std::shared_ptr<const Realisation> queryRealisationUncached(const DrvOutput &) override
-        Callback<std::shared_ptr<const Realisation>> callback) noexcept override
     // TODO: Implement
     { unsupported("queryRealisation"); }
 };

src/libstore/local-store.cc

@@ -1856,24 +1856,17 @@ std::optional<const Realisation> LocalStore::queryRealisation_(
     return { res };
 }
 
-void LocalStore::queryRealisationUncached(const DrvOutput & id,
+std::shared_ptr<const Realisation> LocalStore::queryRealisationUncached(const DrvOutput & id)
-        Callback<std::shared_ptr<const Realisation>> callback) noexcept
 {
-    try {
     auto maybeRealisation
         = retrySQLite<std::optional<const Realisation>>([&]() {
                 auto state(_state.lock());
                 return queryRealisation_(*state, id);
             });
     if (maybeRealisation)
-            callback(
+        return std::make_shared<const Realisation>(maybeRealisation.value());
-                std::make_shared<const Realisation>(maybeRealisation.value()));
     else
-            callback(nullptr);
+        return nullptr;
-
-    } catch (...) {
-        callback.rethrow();
-    }
 }
 
 ContentAddress LocalStore::hashCAPath(

src/libstore/local-store.hh

@@ -294,8 +294,7 @@ public:
 
     std::optional<const Realisation> queryRealisation_(State & state, const DrvOutput & id);
     std::optional<std::pair<int64_t, Realisation>> queryRealisationCore_(State & state, const DrvOutput & id);
-    void queryRealisationUncached(const DrvOutput&,
+    std::shared_ptr<const Realisation> queryRealisationUncached(const DrvOutput&) override;
-        Callback<std::shared_ptr<const Realisation>> callback) noexcept override;
 
     std::optional<std::string> getVersion() override;
 

src/libstore/remote-store.cc

@@ -612,22 +612,19 @@ void RemoteStore::registerDrvOutput(const Realisation & info)
     conn.processStderr();
 }
 
-void RemoteStore::queryRealisationUncached(const DrvOutput & id,
+std::shared_ptr<const Realisation> RemoteStore::queryRealisationUncached(const DrvOutput & id)
-    Callback<std::shared_ptr<const Realisation>> callback) noexcept
 {
-    try {
     auto conn(getConnection());
 
     if (GET_PROTOCOL_MINOR(conn->daemonVersion) < 27) {
         warn("the daemon is too old to support content-addressed derivations, please upgrade it to 2.4");
-            return callback(nullptr);
+        return nullptr;
     }
 
     conn->to << WorkerProto::Op::QueryRealisation;
     conn->to << id.to_string();
     conn.processStderr();
 
-        auto real = [&]() -> std::shared_ptr<const Realisation> {
     if (GET_PROTOCOL_MINOR(conn->daemonVersion) < 31) {
         auto outPaths = WorkerProto::Serialise<std::set<StorePath>>::read(
             *this, *conn);
@@ -641,10 +638,6 @@ void RemoteStore::queryRealisationUncached(const DrvOutput & id,
             return nullptr;
         return std::make_shared<const Realisation>(*realisations.begin());
     }
-        }();
-
-        callback(std::shared_ptr<const Realisation>(real));
-    } catch (...) { return callback.rethrow(); }
 }
 
 void RemoteStore::copyDrvsFromEvalStore(

src/libstore/remote-store.hh

@@ -108,8 +108,7 @@ public:
 
     void registerDrvOutput(const Realisation & info) override;
 
-    void queryRealisationUncached(const DrvOutput &,
+    std::shared_ptr<const Realisation> queryRealisationUncached(const DrvOutput &) override;
-        Callback<std::shared_ptr<const Realisation>> callback) noexcept override;
 
     void buildPaths(const std::vector<DerivedPath> & paths, BuildMode buildMode, std::shared_ptr<Store> evalStore) override;
 

src/libstore/store-api.cc

@@ -743,15 +743,8 @@ void Store::queryRealisation(const DrvOutput & id,
         return callback.rethrow();
     }
 
-    auto callbackPtr
-        = std::make_shared<decltype(callback)>(std::move(callback));
-
-    queryRealisationUncached(
-        id,
-        { [this, id, callbackPtr](
-              std::future<std::shared_ptr<const Realisation>> fut) {
     try {
-                auto info = fut.get();
+        auto info = queryRealisationUncached(id);
 
         if (diskCache) {
             if (info)
@@ -760,12 +753,11 @@ void Store::queryRealisation(const DrvOutput & id,
                 diskCache->upsertAbsentRealisation(getUri(), id);
         }
 
-                (*callbackPtr)(std::shared_ptr<const Realisation>(info));
+        callback(std::shared_ptr<const Realisation>(info));
 
     } catch (...) {
-                callbackPtr->rethrow();
+        callback.rethrow();
     }
-        } });
 }
 
 std::shared_ptr<const Realisation> Store::queryRealisation(const DrvOutput & id)

src/libstore/store-api.hh

@@ -402,8 +402,7 @@ public:
 protected:
 
     virtual std::shared_ptr<const ValidPathInfo> queryPathInfoUncached(const StorePath & path) = 0;
-    virtual void queryRealisationUncached(const DrvOutput &,
+    virtual std::shared_ptr<const Realisation> queryRealisationUncached(const DrvOutput &) = 0;
-        Callback<std::shared_ptr<const Realisation>> callback) noexcept = 0;
 
 public: