Synit: toPreserves for derivations, overrides

nixproc/backends/synit/build-synit-env.nix

@@ -1,37 +1,21 @@
-{ pkgs ? import <nixpkgs> { inherit system; }
-, system ? builtins.currentSystem
-, stateDir ? "/var"
-, runtimeDir ? "${stateDir}/run"
-, logDir ? "${stateDir}/log"
-, cacheDir ? "${stateDir}/cache"
-, spoolDir ? "${stateDir}/spool"
-, lockDir ? "${stateDir}/lock"
-, libDir ? "${stateDir}/lib"
+{ pkgs ? import <nixpkgs> { inherit system; }, system ? builtins.currentSystem
+, stateDir ? "/var", runtimeDir ? "${stateDir}/run", logDir ? "${stateDir}/log"
+, cacheDir ? "${stateDir}/cache", spoolDir ? "${stateDir}/spool"
+, lockDir ? "${stateDir}/lock", libDir ? "${stateDir}/lib"
 , tmpDir ? (if stateDir == "/var" then "/tmp" else "${stateDir}/tmp")
-, forceDisableUserChange ? false
-, callingUser ? null
-, callingGroup ? null
-, extraParams ? {}
-, exprFile ? null
-}@args:
+, forceDisableUserChange ? false, callingUser ? null, callingGroup ? null
+, extraParams ? { }, exprFile ? null }@args:
 
 let
   processesFun = import exprFile;
 
   processesFormalArgs = builtins.functionArgs processesFun;
 
-  processesArgs = builtins.intersectAttrs processesFormalArgs (args // {
-    processManager = "synit";
-  } // extraParams);
+  processesArgs = builtins.intersectAttrs processesFormalArgs
+    (args // { processManager = "synit"; } // extraParams);
 
-  processes = if exprFile == null then {} else processesFun processesArgs;
-in
-pkgs.buildEnv {
+  processes = if exprFile == null then { } else processesFun processesArgs;
+in pkgs.buildEnv {
   name = "synit";
-  paths = map (processName:
-    let
-      process = builtins.getAttr processName processes;
-    in
-    process.pkg
-  ) (builtins.attrNames processes);
+  paths = map (builtins.getAttr "pkg") (builtins.attrValues processes);
 }

nixproc/backends/synit/create-synit-daemon.nix

@@ -0,0 +1,35 @@
+{ lib, writeTextFile, toPreserves }:
+
+{ name, description, daemon, daemonArgs, environment, directory
+# Daemon will not be started until all elements of depends-on are asserted.
+# Example: [ "<service-state <milestone network> up>" ]
+, depends-on ? [ ]
+  # Whether the daemon shall be declared as required.
+, require-service ? true }:
+
+let
+  #quoteArgs =
+  #  map (arg: ''"${lib.replaceStrings [ ''"'' ] [ ''\"'' ] (toString arg)}"'');
+
+  processSpec = {
+    argv = [ daemon ] ++ daemonArgs;
+    env = environment;
+  } // (lib.attrsets.optionalAttrs (directory != null) { dir = directory; });
+
+in writeTextFile {
+  name = "services-${name}";
+  destination = "/services/${name}.pr";
+  text = let daemonName = "<daemon ${name}>";
+  in ''
+    <metadata ${daemonName} { description: "${description}" }>
+    <daemon ${name} ${toPreserves processSpec}>
+  ''
+
+  + (lib.strings.optionalString require-service ''
+    <require-service ${daemonName}>
+  '')
+
+  + (lib.strings.concatMapStrings (dep: ''
+    <depends-on ${daemonName} ${dep}>
+  '') depends-on);
+}

nixproc/backends/synit/default.nix

@@ -0,0 +1,17 @@
+{ lib, writeTextFile }:
+
+rec {
+  util = import ./util.nix { inherit lib; };
+
+  toPreserves = util.toPreserves { };
+
+  createSynitDaemon = import ../../backends/synit/create-synit-daemon.nix {
+    inherit lib writeTextFile;
+    inherit toPreserves;
+  };
+
+  generateSynitService =
+    import ../../backends/synit/generate-synit-service.nix {
+      inherit lib createSynitDaemon;
+    };
+}

nixproc/backends/synit/generate-synit-service.nix

@@ -1,30 +1,16 @@
-{ stdenv, lib, execline, writeTextFile }:
+{ lib, createSynitDaemon }:
 
 { name, description, initialize, daemon, daemonArgs, instanceName, pidFile
 , foregroundProcess, foregroundProcessArgs, path, environment, directory, umask
 , nice, user, dependencies, credentials, overrides, postInstall }:
 
 let
-  util = import ../util { inherit lib; };
+  generatedTargetSpecificArgs = {
+    inherit name description daemon daemonArgs environment directory;
+  };
 
-  generator = import ./preserves-generator.nix { inherit lib; };
-  toPreserves = generator.toPreserves { };
-
-  escapeArgs = args:
-    lib.concatMapStringsSep " "
-    (arg: ''"${lib.replaceStrings [ ''"'' ] [ ''\"'' ] (toString arg)}"'') args;
-
-  processSpec = {
-    argv = "${daemon} ${toString daemonArgs}";
-    env = environment;
-  } // (lib.attrsets.optionalAttrs (directory != null) { dir = directory; });
-
-in writeTextFile {
-  name = "services-${name}";
-  destination = "/services/${name}.pr";
-  text = ''
-    <metadata <daemon ${name}> { description: "${description}" }>
-    <require-service <daemon ${name}>>
-    <daemon ${name} ${toPreserves processSpec}>
-  '';
-}
+  targetSpecificArgs = if builtins.isFunction overrides then
+    overrides generatedTargetSpecificArgs
+  else
+    lib.recursiveUpdate generatedTargetSpecificArgs overrides;
+in createSynitDaemon targetSpecificArgs

nixproc/backends/synit/util.nix

@@ -1,7 +1,6 @@
 { lib }:
 
-let inherit (lib) isAttrs isBool isFunction isList;
-in rec {
+rec {
   /* Generates text-encoded Preserves from an arbitrary value.
 
      Records are generated for lists with a final element in
@@ -17,6 +16,7 @@ in rec {
     let
       toPreserves' = toPreserves args;
       concatItems = toString;
+      mapToSeq = lib.strings.concatMapStringsSep " " toPreserves';
       recordLabel = list:
         with builtins;
         let len = length list;
@@ -24,29 +24,34 @@ in rec {
           null
         else
           let end = elemAt list (len - 1);
-          in if (isAttrs end) && (attrNames end) == [ "record" ] then
+          in if (lib.isAttrs end) && (attrNames end) == [ "record" ] then
             end
           else
             null;
+      stringChecks = {
+        inherit (lib) isFloat isInt isString isPath isDerivation;
+      };
     in v:
-    if isAttrs v then
+    if builtins.any (f: f v) (builtins.attrValues stringChecks) then
+      builtins.toJSON v
+    else if lib.isAttrs v then
       "{ ${
         concatItems
         (lib.attrsets.mapAttrsToList (key: val: "${key}: ${toPreserves' val}")
           v)
       } }"
-    else if isList v then
+    else if lib.isList v then
       let label = recordLabel v;
       in if label == null then
-        "[ ${concatItems (map toPreserves' v)} ]"
+        "[ ${mapToSeq v} ]"
       else
-        "<${label.record} ${concatItems (map toPreserves' (lib.lists.init v))}>"
-    else if isBool v then
+        "<${label.record} ${mapToSeq (lib.lists.init v)}>"
+    else if lib.isBool v then
       (if v then "#t" else "#f")
-    else if isFunction v then
-      abort "generators.toPreserves: cannot convert a function to Preserves"
-    else if isNull v then
-      "null"
+    else if lib.isNull v then
+      "<null>"
+    else if lib.isFunction v then
+      toString v # failure
     else
-      builtins.toJSON v;
+      abort "cannot coerce the value ${v} to Preserves";
 }

nixproc/create-managed-process/universal/create-managed-process-universal.nix

@@ -114,8 +114,8 @@ let
     inherit s6-rc basePackages tmpDir runtimeDir forceDisableUserChange;
   };
 
-  generateSynitService = import ../../backends/synit/generate-synit-service.nix {
-    inherit (pkgs) stdenv lib execline writeTextFile;
+  synit = import ../../backends/synit {
+    inherit (pkgs) lib writeTextFile;
   };
 
 in
@@ -133,6 +133,6 @@ import ../agnostic/create-managed-process.nix {
     supervisord = generateSupervisordProgram;
     systemd = generateSystemdService;
     sysvinit = generateSystemVInitScript;
-    synit = generateSynitService;
+    synit = synit.generateSynitService;
   };
 }