aboutsummaryrefslogtreecommitdiff
#;;; GNU Guix --- Functional package management for GNU ;;; Copyright © 2021 Oleg Pykhalov <go.wigust@gmail.com> ;;; Copyright © 2023 Justin Veilleux <terramorpha@cock.li> ;;; ;;; This file is part of GNU Guix. ;;; ;;; GNU Guix is free software; you can redistribute it and/or modify it ;;; under the terms of the GNU General Public License as published by ;;; the Free Software Foundation; either version 3 of the License, or (at ;;; your option) any later version. ;;; ;;; GNU Guix is distributed in the hope that it will be useful, but ;;; WITHOUT ANY WARRANTY; without even the implied warranty of ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;;; GNU General Public License for more details. ;;; ;;; You should have received a copy of the GNU General Public License ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>. (define-module (gnu services syncthing) #:use-module (gnu packages syncthing) #:use-module (gnu services) #:use-module (gnu services shepherd) #:use-module (guix gexp) #:use-module (guix records) #:use-module (ice-9 match) #:use-module (srfi srfi-1) #:export (syncthing-configuration syncthing-configuration? syncthing-service-type)) ;;; Commentary: ;;; ;;; This module provides a service definition for the syncthing service. ;;; ;;; Code: (define-record-type* <syncthing-configuration> syncthing-configuration make-syncthing-configuration syncthing-configuration? (syncthing syncthing-configuration-syncthing ;file-like (default syncthing)) (arguments syncthing-configuration-arguments ;list of strings (default '())) (logflags syncthing-configuration-logflags ;number (default 0)) (user syncthing-configuration-user ;string (default #f)) (group syncthing-configuration-group ;string (default "users")) (home syncthing-configuration-home ;string (default #f)) (home-service? syncthing-configuration-home-service? (default for-home?) (innate))) (define syncthing-shepherd-service (match-record-lambda <syncthing-configuration> (syncthing arguments logflags user group home home-service?) (list (shepherd-service (provision (if home-service? '(syncthing) (list (string->symbol (string-append "syncthing-" user))))) (documentation "Run syncthing.") (requirement (if home-service? '() '(loopback user-processes))) (start #~(make-forkexec-constructor (append (list (string-append #$syncthing "/bin/syncthing") "--no-browser" "--no-restart" (string-append "--logflags=" (number->string #$logflags))) '#$arguments) #:user #$(and (not home-service?) user) #:group #$(and (not home-service?) group) #:environment-variables (append (list (string-append "HOME=" (or #$home (passwd:dir (getpw (if (and #$home-service? (not #$user)) (getuid) #$user))))) "SSL_CERT_DIR=/etc/ssl/certs" "SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt") (filter (negate ;XXX: 'remove' is not in (guile) (lambda (str) (or (string-prefix? "HOME=" str) (string-prefix? "SSL_CERT_DIR=" str) (string-prefix? "SSL_CERT_FILE=" str)))) (environ))))) (respawn? #f) (stop #~(make-kill-destructor)))))) (define syncthing-service-type (service-type (name 'syncthing) (extensions (list (service-extension shepherd-root-service-type syncthing-shepherd-service))) (description "Run @uref{https://github.com/syncthing/syncthing, Syncthing} decentralized continuous file system synchronization."))) ;;; syncthing.scm ends here
generated by cgit
/ virtual PathSet querySubstitutablePaths(const PathSet & paths) = 0; /* Query substitute info (i.e. references, derivers and download sizes) of a set of paths. If a path does not have substitute info, it's omitted from the resulting ‘infos’ map. */ virtual void querySubstitutablePathInfos(const PathSet & paths, SubstitutablePathInfos & infos) = 0; /* Copy the contents of a path to the store and register the validity the resulting path. The resulting path is returned. The function object `filter' can be used to exclude files (see libutil/archive.hh). */ virtual Path addToStore(const string & name, const Path & srcPath, bool recursive = true, HashType hashAlgo = htSHA256, PathFilter & filter = defaultPathFilter, bool repair = false) = 0; /* Like addToStore, but the contents written to the output path is a regular file containing the given string. */ virtual Path addTextToStore(const string & name, const string & s, const PathSet & references, bool repair = false) = 0; /* Export a store path, that is, create a NAR dump of the store path and append its references and its deriver. Optionally, a cryptographic signature (created by OpenSSL) of the preceding data is attached. */ virtual void exportPath(const Path & path, bool sign, Sink & sink) = 0; /* Import a sequence of NAR dumps created by exportPaths() into the Nix store. */ virtual Paths importPaths(bool requireSignature, Source & source) = 0; /* For each path, if it's a derivation, build it. Building a derivation means ensuring that the output paths are valid. If they are already valid, this is a no-op. Otherwise, validity can be reached in two ways. First, if the output paths is substitutable, then build the path that way. Second, the output paths can be created by running the builder, after recursively building any sub-derivations. For inputs that are not derivations, substitute them. */ virtual void buildPaths(const PathSet & paths, BuildMode buildMode = bmNormal) = 0; /* Ensure that a path is valid. If it is not currently valid, it may be made valid by running a substitute (if defined for the path). */ virtual void ensurePath(const Path & path) = 0; /* Add a store path as a temporary root of the garbage collector. The root disappears as soon as we exit. */ virtual void addTempRoot(const Path & path) = 0; /* Add an indirect root, which is merely a symlink to `path' from /nix/var/nix/gcroots/auto/<hash of `path'>. `path' is supposed to be a symlink to a store path. The garbage collector will automatically remove the indirect root when it finds that `path' has disappeared. */ virtual void addIndirectRoot(const Path & path) = 0; /* Acquire the global GC lock, then immediately release it. This function must be called after registering a new permanent root, but before exiting. Otherwise, it is possible that a running garbage collector doesn't see the new root and deletes the stuff we've just built. By acquiring the lock briefly, we ensure that either: - The collector is already running, and so we block until the collector is finished. The collector will know about our *temporary* locks, which should include whatever it is we want to register as a permanent lock. - The collector isn't running, or it's just started but hasn't acquired the GC lock yet. In that case we get and release the lock right away, then exit. The collector scans the permanent root and sees our's. In either case the permanent root is seen by the collector. */ virtual void syncWithGC() = 0; /* Find the roots of the garbage collector. Each root is a pair (link, storepath) where `link' is the path of the symlink outside of the Nix store that point to `storePath'. */ virtual Roots findRoots() = 0; /* Perform a garbage collection. */ virtual void collectGarbage(const GCOptions & options, GCResults & results) = 0; /* Return the set of paths that have failed to build.*/ virtual PathSet queryFailedPaths() = 0; /* Clear the "failed" status of the given paths. The special value `*' causes all failed paths to be cleared. */ virtual void clearFailedPaths(const PathSet & paths) = 0; /* Return a string representing information about the path that can be loaded into the database using `nix-store --load-db' or `nix-store --register-validity'. */ string makeValidityRegistration(const PathSet & paths, bool showDerivers, bool showHash); /* Optimise the disk space usage of the Nix store by hard-linking files with the same contents. */ virtual void optimiseStore() = 0; /* Check the integrity of the Nix store. Returns true if errors remain. */ virtual bool verifyStore(bool checkContents, bool repair) = 0; /* Create a profile for the given user. This is done by the daemon because the 'profiles/per-user' directory is not writable by users. */ virtual void createUser(const std::string & userName, uid_t userId) = 0; }; /* !!! These should be part of the store API, I guess. */ /* Throw an exception if `path' is not directly in the Nix store. */ void assertStorePath(const Path & path); bool isInStore(const Path & path); bool isStorePath(const Path & path); /* Extract the name part of the given store path. */ string storePathToName(const Path & path); void checkStoreName(const string & name); /* Chop off the parts after the top-level store name, e.g., /nix/store/abcd-foo/bar => /nix/store/abcd-foo. */ Path toStorePath(const Path & path); /* Constructs a unique store path name. */ Path makeStorePath(const string & type, const Hash & hash, const string & name); Path makeOutputPath(const string & id, const Hash & hash, const string & name); Path makeFixedOutputPath(bool recursive, HashType hashAlgo, Hash hash, string name); /* Preparatory part of addTextToStore(). !!! Computation of the path should take the references given to addTextToStore() into account, otherwise we have a (relatively minor) security hole: a caller can register a source file with bogus references. If there are too many references, the path may not be garbage collected when it has to be (not really a problem, the caller could create a root anyway), or it may be garbage collected when it shouldn't be (more serious). Hashing the references would solve this (bogus references would simply yield a different store path, so other users wouldn't be affected), but it has some backwards compatibility issues (the hashing scheme changes), so I'm not doing that for now. */ Path computeStorePathForText(const string & name, const string & s, const PathSet & references); /* Remove the temporary roots file for this process. Any temporary root becomes garbage after this point unless it has been registered as a (permanent) root. */ void removeTempRoots(); /* Register a permanent GC root. */ Path addPermRoot(StoreAPI & store, const Path & storePath, const Path & gcRoot, bool indirect, bool allowOutsideRootsDir = false); /* Sort a set of paths topologically under the references relation. If p refers to q, then p preceeds q in this list. */ Paths topoSortPaths(StoreAPI & store, const PathSet & paths); /* For now, there is a single global store API object, but we'll purify that in the future. */ extern std::shared_ptr<StoreAPI> store; /* Display a set of paths in human-readable form (i.e., between quotes and separated by commas). */ string showPaths(const PathSet & paths); MakeError(SubstError, Error) MakeError(BuildError, Error) /* denotes a permanent build failure */ }
generated by cgit