1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

{ depot, pkgs, lib, ... }:

let
  exec-helpers-hs = pkgs.haskellPackages.mkDerivation {
    pname = "exec-helpers";
    version = "0.1.0";

    src = depot.users.Profpatsch.exactSource ./. [
      ./exec-helpers.cabal
      ./ExecHelpers.hs
    ];

    libraryHaskellDepends = [
      depot.users.Profpatsch.my-prelude
    ];

    isLibrary = true;
    license = lib.licenses.mit;
  };

  print-one-env = depot.nix.writers.rustSimple
    {
      name = "print-one-env";
      dependencies = [
        depot.users.Profpatsch.execline.exec-helpers
      ];
    } ''
    extern crate exec_helpers;
    use std::os::unix::ffi::OsStrExt;
    use std::io::Write;

    fn main() {
      let args = exec_helpers::args("print-one-env", 1);
      let valname = std::ffi::OsStr::from_bytes(&args[0]);
      match std::env::var_os(&valname) {
        None => exec_helpers::die_user_error("print-one-env", format!("Env variable `{:?}` is not set", valname)),
        Some(val) => std::io::stdout().write_all(&val.as_bytes()).unwrap()
      }
    }
  '';

  setsid = depot.nix.writers.rustSimple
    {
      name = "setsid";
      dependencies = [
        depot.users.Profpatsch.execline.exec-helpers
        depot.third_party.rust-crates.libc
      ];
    } ''
    use std::os::unix::ffi::OsStrExt;
    use std::ffi::OsStr;

    fn main() {
      let (args, prog) = exec_helpers::args_for_exec("setsid", 1);
      let envvar = OsStr::from_bytes(&args.get(0).expect("first argument must be envvar name to set"));
      let sid: i32 = unsafe { libc::setsid() };
      std::env::set_var(envvar, format!("{}", sid));
      let env: Vec<(&[u8], &[u8])> = vec![];
      exec_helpers::exec_into_args("getid", prog, env);
    }
  '';

  el-semicolon = depot.nix.writers.rustSimpleLib
    { name = "el_semicolon"; }
    (builtins.readFile ./el_semicolon.rs);

  el-exec = pkgs.buildRustCrate {
    pname = "el_exec";
    crateName = "el_exec";
    version = "1.0.0";
    edition = "2018";
    dependencies = [ depot.third_party.rust-crates.libc ];
    buildInputs = [ pkgs.skalibs ];
    src = pkgs.runCommandLocal "el_exec-src" {} ''
      mkdir -p $out/src
      cp ${./el_exec.rs} $out/src/lib.rs
    '';
  };

  el-substitute = pkgs.buildRustCrate {
    pname = "el_substitute";
    crateName = "el_substitute";
    version = "1.0.0";
    edition = "2018";
    dependencies = [
      depot.third_party.rust-crates.libc
      depot.third_party.rust-crates.errno
    ];
    buildInputs = [ pkgs.skalibs pkgs.execline ];
    src = pkgs.runCommandLocal "el_substitute-src" {} ''
      mkdir -p $out/src
      cp ${./el_substitute.rs} $out/src/lib.rs
    '';
  };

  importas-if = pkgs.buildRustCrate {
    pname = "importas-if";
    crateName = "importas_if";
    version = "1.0.0";
    edition = "2018";
    crateBin = [ "importas-if" ];
    dependencies = [ el-semicolon el-exec el-substitute ];
    buildInputs = [ pkgs.skalibs pkgs.execline ];
    src = pkgs.runCommandLocal "importas-if-src" {} ''
      mkdir -p $out/src/bin
      cp ${./importas-if.rs} $out/src/bin/importas_if.rs
    '';
  };

  run-cmd-line-block = depot.nix.writers.rustSimpleBin
    { name = "run-cmd-line-block"; }
    (builtins.readFile ./run-cmd-line-block.rs);

in
depot.nix.readTree.drvTargets {
  inherit
    exec-helpers-hs
    print-one-env
    setsid
    el-semicolon
    el-exec
    el-substitute
    importas-if
    run-cmd-line-block
    ;
}