about summary refs log blame commit diff
path: root/third_party/nix/src/libstore/remote-store.hh
blob: dd37b83f84a53840256a5517f1c2150572dc3f91 (plain) (tree)
1
2
3
4
5
6
7
8
            
 
                 
                 

                       

               



                

                     
                        
 

                                                              




                                                                    
 


                                                                       
 
                                 
 
                                    
 
                                                      
 
                                                      
 

                                                                                
 
                                        
 


                                                                           
 
                                                                     
 
                                                        
 
                                                            
 
                                                                  
 
                                                              
 
                                                                 
 

                                                                           
 


                                                                            
 



                                                                      
 

                                                                             
 
                                                                      
 

                                                                              
 
                                             
 
                                              
 
                                                  
 
                             
 
                                        
 
                                                                             
 
                                
 
                                                                   
 
                                                                            
 



                                                               
 
                          
 
                                      
 
                             
 






                                                                 
 
                          
 

                                                                         
 
                                          
 
                                               
 
                                        
 
                                    
 
                                            
 
                                   
 
                                 
 

                                 
  
 



                                                                
 
                                
 
                                     
 


                                                         

  
                   
#pragma once

#include <limits>
#include <string>
#include "store-api.hh"

namespace nix {

class Pipe;
class Pid;
struct FdSink;
struct FdSource;
template <typename T>
class Pool;
struct ConnectionHandle;

/* FIXME: RemoteStore is a misnomer - should be something like
   DaemonStore. */
class RemoteStore : public virtual Store {
 public:
  const Setting<int> maxConnections{
      (Store*)this, 1, "max-connections",
      "maximum number of concurrent connections to the Nix daemon"};

  const Setting<unsigned int> maxConnectionAge{
      (Store*)this, std::numeric_limits<unsigned int>::max(),
      "max-connection-age", "number of seconds to reuse a connection"};

  virtual bool sameMachine() = 0;

  RemoteStore(const Params& params);

  /* Implementations of abstract store API methods. */

  bool isValidPathUncached(const Path& path) override;

  PathSet queryValidPaths(const PathSet& paths, SubstituteFlag maybeSubstitute =
                                                    NoSubstitute) override;

  PathSet queryAllValidPaths() override;

  void queryPathInfoUncached(
      const Path& path,
      Callback<std::shared_ptr<ValidPathInfo>> callback) noexcept override;

  void queryReferrers(const Path& path, PathSet& referrers) override;

  PathSet queryValidDerivers(const Path& path) override;

  PathSet queryDerivationOutputs(const Path& path) override;

  StringSet queryDerivationOutputNames(const Path& path) override;

  Path queryPathFromHashPart(const string& hashPart) override;

  PathSet querySubstitutablePaths(const PathSet& paths) override;

  void querySubstitutablePathInfos(const PathSet& paths,
                                   SubstitutablePathInfos& infos) override;

  void addToStore(const ValidPathInfo& info, Source& nar, RepairFlag repair,
                  CheckSigsFlag checkSigs,
                  std::shared_ptr<FSAccessor> accessor) override;

  Path addToStore(const string& name, const Path& srcPath,
                  bool recursive = true, HashType hashAlgo = htSHA256,
                  PathFilter& filter = defaultPathFilter,
                  RepairFlag repair = NoRepair) override;

  Path addTextToStore(const string& name, const string& s,
                      const PathSet& references, RepairFlag repair) override;

  void buildPaths(const PathSet& paths, BuildMode buildMode) override;

  BuildResult buildDerivation(const Path& drvPath, const BasicDerivation& drv,
                              BuildMode buildMode) override;

  void ensurePath(const Path& path) override;

  void addTempRoot(const Path& path) override;

  void addIndirectRoot(const Path& path) override;

  void syncWithGC() override;

  Roots findRoots(bool censor) override;

  void collectGarbage(const GCOptions& options, GCResults& results) override;

  void optimiseStore() override;

  bool verifyStore(bool checkContents, RepairFlag repair) override;

  void addSignatures(const Path& storePath, const StringSet& sigs) override;

  void queryMissing(const PathSet& targets, PathSet& willBuild,
                    PathSet& willSubstitute, PathSet& unknown,
                    unsigned long long& downloadSize,
                    unsigned long long& narSize) override;

  void connect() override;

  unsigned int getProtocol() override;

  void flushBadConnections();

 protected:
  struct Connection {
    AutoCloseFD fd;
    FdSink to;
    FdSource from;
    unsigned int daemonVersion;
    std::chrono::time_point<std::chrono::steady_clock> startTime;

    virtual ~Connection();

    std::exception_ptr processStderr(Sink* sink = 0, Source* source = 0);
  };

  ref<Connection> openConnectionWrapper();

  virtual ref<Connection> openConnection() = 0;

  void initConnection(Connection& conn);

  ref<Pool<Connection>> connections;

  virtual void setOptions(Connection& conn);

  ConnectionHandle getConnection();

  friend struct ConnectionHandle;

 private:
  std::atomic_bool failed{false};
};

class UDSRemoteStore : public LocalFSStore, public RemoteStore {
 public:
  UDSRemoteStore(const Params& params);
  UDSRemoteStore(std::string path, const Params& params);

  std::string getUri() override;

  bool sameMachine() { return true; }

 private:
  ref<RemoteStore::Connection> openConnection() override;
  std::optional<std::string> path;
};

}  // namespace nix