libutil: drop Fs{Source,Sink}::good

setting this only on exceptions caused by actual fd access is not
sufficient to diagnose all errors (such as SerialisationError) in
some cases. this usually does not have any negative effects since
those errors will end up killing the process in another way. this
is not a reliable assumption though and we should be using proper
error handling (and closing connections more often, preferring to
close over keeping something open that might be in a weird state)

Change-Id: I1b792cd7ad8ba9ff0f6bd174945ab2575ff2208e

src/libstore/remote-store.cc

@@ -39,9 +39,7 @@ RemoteStore::RemoteStore(const Params & params)
             },
             [this](const ref<Connection> & r) {
                 return
-                    r->to.good()
-                    && r->from.good()
-                    && std::chrono::duration_cast<std::chrono::seconds>(
+                    std::chrono::duration_cast<std::chrono::seconds>(
                         std::chrono::steady_clock::now() - r->startTime).count() < maxConnectionAge;
             }
             ))
@@ -180,6 +178,10 @@ void RemoteStore::ConnectionHandle::processStderr(Sink * sink, Source * source,
                     m.find("Derive([") != std::string::npos)
                     throw Error("%s, this might be because the daemon is too old to understand dependencies on dynamic derivations. Check to see if the raw derivation is in the form '%s'", std::move(m), "DrvWithVersion(..)");
             }
+            // the daemon can still handle more requests, so the connection itself
+            // is still valid. the current *handle* however should be considered a
+            // lost cause and abandoned entirely.
+            handle.release();
             throw;
         }
     }

src/libutil/serialise.cc

@@ -52,18 +52,7 @@ FdSink::~FdSink()
 void FdSink::writeUnbuffered(std::string_view data)
 {
     written += data.size();
-    try {
     writeFull(fd, data);
-    } catch (SysError & e) {
-        _good = false;
-        throw;
-    }
-}
-
-
-bool FdSink::good()
-{
-    return _good;
 }
 
 
@@ -128,19 +117,13 @@ size_t FdSource::readUnbuffered(char * data, size_t len)
         checkInterrupt();
         n = ::read(fd, data, len);
     } while (n == -1 && errno == EINTR);
-    if (n == -1) { _good = false; throw SysError("reading from file"); }
-    if (n == 0) { _good = false; throw EndOfFile(std::string(*endOfFileError)); }
+    if (n == -1) { throw SysError("reading from file"); }
+    if (n == 0) { throw EndOfFile(std::string(*endOfFileError)); }
     read += n;
     return n;
 }
 
 
-bool FdSource::good()
-{
-    return _good;
-}
-
-
 size_t StringSource::read(char * data, size_t len)
 {
     if (pos == s.size()) throw EndOfFile("end of string reached");

src/libutil/serialise.hh

@@ -18,7 +18,6 @@ struct Sink
 {
     virtual ~Sink() { }
     virtual void operator () (std::string_view data) = 0;
-    virtual bool good() { return true; }
 };
 
 /**
@@ -80,8 +79,6 @@ struct Source
      */
     virtual size_t read(char * data, size_t len) = 0;
 
-    virtual bool good() { return true; }
-
     void drainInto(Sink & sink);
 
     std::string drain();
@@ -136,11 +133,6 @@ struct FdSink : BufferedSink
     ~FdSink();
 
     void writeUnbuffered(std::string_view data) override;
-
-    bool good() override;
-
-private:
-    bool _good = true;
 };
 
 
@@ -165,11 +157,8 @@ struct FdSource : BufferedSource
         return *this;
     }
 
-    bool good() override;
 protected:
     size_t readUnbuffered(char * data, size_t len) override;
-private:
-    bool _good = true;
 };