commit ceccff3439fdbb11ac2025bdd4578970f3c49e28 · pyrox.dev/nixpkgs

+1

nixos/tests/all-tests.nix

···

       147
       147
        
         login = handleTest ./login.nix {};

     

       148
       148
        
         loki = handleTest ./loki.nix {};

     

       149
       149
        
         #logstash = handleTest ./logstash.nix {};

     

       150
       150
       +
         lorri = handleTest ./lorri/default.nix {};

     

       150
       151
        
         mailcatcher = handleTest ./mailcatcher.nix {};

     

       151
       152
        
         mathics = handleTest ./mathics.nix {};

     

       152
       153
        
         matomo = handleTest ./matomo.nix {};

+3

nixos/tests/lorri/builder.sh

···

       1
       1
       +
       #!/bin/sh

     

       2
       2
       +
       

     

       3
       3
       +
       printf "%s" "${name:?}" > "${out:?}"

+26

nixos/tests/lorri/default.nix

···

       1
       1
       +
       import ../make-test-python.nix {

     

       2
       2
       +
         machine = { pkgs, ... }: {

     

       3
       3
       +
           imports = [ ../../modules/profiles/minimal.nix ];

     

       4
       4
       +
           environment.systemPackages = [ pkgs.lorri ];

     

       5
       5
       +
         };

     

       6
       6
       +
       

     

       7
       7
       +
         testScript = ''

     

       8
       8
       +
           # Copy files over

     

       9
       9
       +
           machine.succeed(

     

       10
       10
       +
               "cp '${./fake-shell.nix}' shell.nix"

     

       11
       11
       +
           )

     

       12
       12
       +
           machine.succeed(

     

       13
       13
       +
               "cp '${./builder.sh}' builder.sh"

     

       14
       14
       +
           )

     

       15
       15
       +
       

     

       16
       16
       +
           # Start the daemon and wait until it is ready

     

       17
       17
       +
           machine.execute("lorri daemon > lorri.stdout 2> lorri.stderr &")

     

       18
       18
       +
           machine.wait_until_succeeds("grep --fixed-strings 'lorri: ready' lorri.stdout")

     

       19
       19
       +
       

     

       20
       20
       +
           # Ping the daemon

     

       21
       21
       +
           machine.execute("lorri ping_ $(readlink -f shell.nix)")

     

       22
       22
       +
       

     

       23
       23
       +
           # Wait for the daemon to finish the build

     

       24
       24
       +
           machine.wait_until_succeeds("grep --fixed-strings 'OutputPaths' lorri.stdout")

     

       25
       25
       +
         '';

     

       26
       26
       +
       }

+5

nixos/tests/lorri/fake-shell.nix

···

       1
       1
       +
       derivation {

     

       2
       2
       +
         system = builtins.currentSystem;

     

       3
       3
       +
         name = "fake-shell";

     

       4
       4
       +
         builder = ./builder.sh;

     

       5
       5
       +
       }

+56

pkgs/tools/misc/lorri/default.nix

···

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , pkgs

     

       3
       3
       +
       , fetchFromGitHub

     

       4
       4
       +
       , rustPlatform

     

       5
       5
       +
         # Updater script

     

       6
       6
       +
       , runtimeShell

     

       7
       7
       +
       , writeScript

     

       8
       8
       +
         # Tests

     

       9
       9
       +
       , nixosTests

     

       10
       10
       +
         # Apple dependencies

     

       11
       11
       +
       , CoreServices

     

       12
       12
       +
       , Security

     

       13
       13
       +
       , cf-private

     

       14
       14
       +
       }:

     

       15
       15
       +
       

     

       16
       16
       +
       rustPlatform.buildRustPackage rec {

     

       17
       17
       +
         pname = "lorri";

     

       18
       18
       +
         version = "unstable-2019-10-30";

     

       19
       19
       +
       

     

       20
       20
       +
         meta = with stdenv.lib; {

     

       21
       21
       +
           description = "Your project's nix-env";

     

       22
       22
       +
           homepage = "https://github.com/target/lorri";

     

       23
       23
       +
           license = licenses.asl20;

     

       24
       24
       +
           maintainers = with maintainers; [ grahamc Profpatsch ];

     

       25
       25
       +
         };

     

       26
       26
       +
       

     

       27
       27
       +
         src = fetchFromGitHub {

     

       28
       28
       +
           owner = "target";

     

       29
       29
       +
           repo = pname;

     

       30
       30
       +
           # Run `eval $(nix-build -A lorri.updater)` after updating the revision!

     

       31
       31
       +
           rev = "03f10395943449b1fc5026d3386ab8c94c520ee3";

     

       32
       32
       +
           sha256 = "0fcl79ndaziwd8d74mk1lsijz34p2inn64b4b4am3wsyk184brzq";

     

       33
       33
       +
         };

     

       34
       34
       +
       

     

       35
       35
       +
         cargoSha256 = "1daff4plh7hwclfp21hkx4fiflh9r80y2c7k2sd3zm4lmpy0jpfz";

     

       36
       36
       +
         doCheck = false;

     

       37
       37
       +
       

     

       38
       38
       +
         BUILD_REV_COUNT = src.revCount or 1;

     

       39
       39
       +
         RUN_TIME_CLOSURE = pkgs.callPackage ./runtime.nix {};

     

       40
       40
       +
       

     

       41
       41
       +
         nativeBuildInputs = with pkgs; [ nix direnv which ];

     

       42
       42
       +
         buildInputs =

     

       43
       43
       +
           stdenv.lib.optionals stdenv.isDarwin [ CoreServices Security cf-private ];

     

       44
       44
       +
       

     

       45
       45
       +
         passthru = {

     

       46
       46
       +
           updater = with builtins; writeScript "copy-runtime-nix.sh" ''

     

       47
       47
       +
             #!${runtimeShell}

     

       48
       48
       +
             set -euo pipefail

     

       49
       49
       +
             cp ${src}/nix/runtime.nix ${toString ./runtime.nix}

     

       50
       50
       +
             cp ${src}/nix/runtime-closure.nix.template ${toString ./runtime-closure.nix.template}

     

       51
       51
       +
           '';

     

       52
       52
       +
           tests = {

     

       53
       53
       +
             nixos = nixosTests.lorri;

     

       54
       54
       +
           };

     

       55
       55
       +
         };

     

       56
       56
       +
       }

+37

pkgs/tools/misc/lorri/runtime-closure.nix.template

···

       1
       1
       +
       # Nix with sandboxing requires every path used at build time be

     

       2
       2
       +
       # explicitly declared. If we simply passed in the paths, they

     

       3
       3
       +
       # would be copied in as sources. Using builtins.storePath we're

     

       4
       4
       +
       # able to tell Nix that, no, in fact, treat these not as sources

     

       5
       5
       +
       # to copy, but instead of a regular store path.

     

       6
       6
       +
       #

     

       7
       7
       +
       # Include the explicit closure, too, otherwise we'll get mysterious

     

       8
       8
       +
       # "file not found" errors due to the glibc interpreter being

     

       9
       9
       +
       # missing.

     

       10
       10
       +
       let

     

       11
       11
       +
         # Magic inspired by Nix's config.nix:

     

       12
       12
       +
         # https://github.com/NixOS/nix/blob/f9a2ea44867cd1dbb408bca4df0ced806137b7f7/corepkgs/config.nix.in#L23

     

       13
       13
       +
         #

     

       14
       14
       +
         # If the dependency is in the Nix store we're using, refer to

     

       15
       15
       +
         # it as a literal store path. If it isn't, refer to it "normally".

     

       16
       16
       +
         #

     

       17
       17
       +
         # This makes sandboxing happy when in a nix-build, and the

     

       18
       18
       +
         # evaluation happy when in a «cargo build».

     

       19
       19
       +
         tools_build_host = @tools_build_host@;

     

       20
       20
       +
       

     

       21
       21
       +
         # Compare the stringified version of the tools_build_host Nix store

     

       22
       22
       +
         # path to the evaluator's stringified Nix store path. Otherwise,

     

       23
       23
       +
         # Nix will read the sources in to the /nix/store, and, well,

     

       24
       24
       +
         # you can only copy the /nix/store in to the /nix/store so many

     

       25
       25
       +
         # times before you run out of disk space.

     

       26
       26
       +
         dep = if ("${toString (dirOf tools_build_host)}" == "${toString builtins.storeDir}")

     

       27
       27
       +
           then (builtins.trace "using storePath"  builtins.storePath)

     

       28
       28
       +
           else (builtins.trace "using toString" toString) # assume we have no sandboxing

     

       29
       29
       +
           ;

     

       30
       30
       +
       

     

       31
       31
       +
         tools = dep tools_build_host;

     

       32
       32
       +
       

     

       33
       33
       +
       in {

     

       34
       34
       +
         path = "${tools}/bin";

     

       35
       35
       +
         builder = "${tools}/bin/bash";

     

       36
       36
       +
         closure = import @runtime_closure_list@ { inherit dep; };

     

       37
       37
       +
       }

+33

pkgs/tools/misc/lorri/runtime.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         # Plumbing tools:

     

       3
       3
       +
         closureInfo, runCommand, writeText, buildEnv,

     

       4
       4
       +
       

     

       5
       5
       +
         # Actual dependencies to propagate:

     

       6
       6
       +
         bash, coreutils }:

     

       7
       7
       +
       let

     

       8
       8
       +
         tools = buildEnv {

     

       9
       9
       +
           name = "lorri-runtime-tools";

     

       10
       10
       +
           paths = [ coreutils bash ];

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         runtimeClosureInfo = closureInfo {

     

       14
       14
       +
           rootPaths = [ tools ];

     

       15
       15
       +
         };

     

       16
       16
       +
       

     

       17
       17
       +
         closureToNix = runCommand "closure.nix" {}

     

       18
       18
       +
         ''

     

       19
       19
       +
           (

     

       20
       20
       +
             echo '{ dep, ... }: ['

     

       21
       21
       +
             sed -E 's/^(.*)$/    (dep \1)/' ${runtimeClosureInfo}/store-paths

     

       22
       22
       +
             echo ']'

     

       23
       23
       +
           ) > $out

     

       24
       24
       +
         '';

     

       25
       25
       +
       

     

       26
       26
       +
         runtimeClosureInfoAsNix = runCommand "runtime-closure.nix" {

     

       27
       27
       +
           runtime_closure_list = closureToNix;

     

       28
       28
       +
           tools_build_host = tools;

     

       29
       29
       +
         }

     

       30
       30
       +
         ''

     

       31
       31
       +
           substituteAll ${./runtime-closure.nix.template} $out

     

       32
       32
       +
         '';

     

       33
       33
       +
       in runtimeClosureInfoAsNix

+4 -1

pkgs/top-level/all-packages.nix

···

       8438
       8438
        
       

     

       8439
       8439
        
         llvmPackages_latest = llvmPackages_9;

     

       8440
       8440
        
       

     

       8441
       8441
       -
         lorri = throw "lorri is not stable yet. Please go to https://github.com/target/lorri and follow the installation instructions there, for the time being.";

     

       8441
       8441
       +
         lorri = callPackage ../tools/misc/lorri {

     

       8442
       8442
       +
           inherit (darwin) cf-private;

     

       8443
       8443
       +
           inherit (darwin.apple_sdk.frameworks) CoreServices Security;

     

       8444
       8444
       +
         };

     

       8442
       8445
        
       

     

       8443
       8446
        
         manticore = callPackage ../development/compilers/manticore { };

     

       8444
       8447