commit 8d96bfd4090ca73371f4f8ef8383eeaaa30f9c2a · pyrox.dev/nixpkgs

+11 -8

doc/languages-frameworks/go.section.md

···

       114
       114
        
       

     

       115
       115
        
       ### `buildFlagsArray` and `buildFlags`: {#ex-goBuildFlags-noarray}

     

       116
       116
        
       

     

       117
       117
       -
       These attributes set build flags supported by `go build`. We recommend using `buildFlagsArray`. The most common use case of these attributes is to make the resulting executable aware of its own version. For example:

     

       117
       117
       +
       These attributes set build flags supported by `go build`. We recommend using `buildFlagsArray`.

     

       118
       118
        
       

     

       119
       119
        
       ```nix

     

       120
       120
        
         buildFlagsArray = [

     

       121
       121
       -
           # Note: single quotes are not needed.

     

       122
       122
       -
           "-ldflags=-X main.Version=${version} -X main.Commit=${version}"

     

       121
       121
       +
           "-tags=release"

     

       123
       122
        
         ];

     

       124
       123
        
       ```

     

       125
       124
        
       

     

       125
       125
       +
       ### `ldflags` {#var-go-ldflags}

     

       126
       126
       +
       

     

       127
       127
       +
       Arguments to pass to the Go linker tool via the `-ldflags` argument of `go build`. The most common use case for this argument is to make the resulting executable aware of its own version. For example:

     

       128
       128
       +
       

     

       126
       129
        
       ```nix

     

       127
       127
       -
         buildFlagsArray = ''

     

       128
       128
       -
           -ldflags=

     

       129
       129
       -
           -X main.Version=${version}

     

       130
       130
       -
           -X main.Commit=${version}

     

       131
       131
       -
         '';

     

       130
       130
       +
         ldflags = [

     

       131
       131
       +
           "-s" "-w"

     

       132
       132
       +
           "-X main.Version=${version}"

     

       133
       133
       +
           "-X main.Commit=${version}"

     

       134
       134
       +
         ];

     

       132
       135
        
       ```

     

       133
       136
        
       

     

       134
       137
        
       ### `deleteVendor` {#var-go-deleteVendor}

+15

nixos/modules/virtualisation/containers.nix

···

       65
       65
        
             '';

     

       66
       66
        
           };

     

       67
       67
        
       

     

       68
       68
       +
           storage.settings = mkOption {

     

       69
       69
       +
             type = toml.type;

     

       70
       70
       +
             default = {

     

       71
       71
       +
               storage = {

     

       72
       72
       +
                 driver = "overlay";

     

       73
       73
       +
                 graphroot = "/var/lib/containers/storage";

     

       74
       74
       +
                 runroot = "/run/containers/storage";

     

       75
       75
       +
               };

     

       76
       76
       +
             };

     

       77
       77
       +
             description = "storage.conf configuration";

     

       78
       78
       +
           };

     

       79
       79
       +
       

     

       68
       80
        
           registries = {

     

       69
       81
        
             search = mkOption {

     

       70
       82
        
               type = types.listOf types.str;

     
···

       128
       140
        
       

     

       129
       141
        
           environment.etc."containers/containers.conf".source =

     

       130
       142
        
             toml.generate "containers.conf" cfg.containersConf.settings;

     

       143
       143
       +
       

     

       144
       144
       +
           environment.etc."containers/storage.conf".source =

     

       145
       145
       +
             toml.generate "storage.conf" cfg.storage.settings;

     

       131
       146
        
       

     

       132
       147
        
           environment.etc."containers/registries.conf".source = toml.generate "registries.conf" {

     

       133
       148
        
             registries = lib.mapAttrs (n: v: { registries = v; }) cfg.registries;

+3

nixos/modules/virtualisation/lxd.nix

···

       175
       175
        
             "net.ipv6.neigh.default.gc_thresh3" = 8192;

     

       176
       176
        
             "kernel.keys.maxkeys" = 2000;

     

       177
       177
        
           };

     

       178
       178
       +
       

     

       179
       179
       +
           boot.kernelModules = [ "veth" "xt_comment" "xt_CHECKSUM" "xt_MASQUERADE" ]

     

       180
       180
       +
             ++ optionals (!config.networking.nftables.enable) [ "iptable_mangle" ];

     

       178
       181
        
         };

     

       179
       182
        
       }

+4

nixos/tests/lxd.nix

···

       96
       96
        
               ## limits.cpu ##

     

       97
       97
        
       

     

       98
       98
        
               machine.succeed("lxc config set test limits.cpu 1")

     

       99
       99
       +
               machine.succeed("lxc restart test")

     

       99
       100
        
       

     

       100
       101
        
               # Since Alpine doesn't have `nproc` pre-installed, we've gotta resort

     

       101
       102
        
               # to the primal methods

     
···

       105
       106
        
               )

     

       106
       107
        
       

     

       107
       108
        
               machine.succeed("lxc config set test limits.cpu 2")

     

       109
       109
       +
               machine.succeed("lxc restart test")

     

       108
       110
        
       

     

       109
       111
        
               assert (

     

       110
       112
        
                   "2"

     
···

       115
       117
        
               ## limits.memory ##

     

       116
       118
        
       

     

       117
       119
        
               machine.succeed("lxc config set test limits.memory 64MB")

     

       120
       120
       +
               machine.succeed("lxc restart test")

     

       118
       121
        
       

     

       119
       122
        
               assert (

     

       120
       123
        
                   "MemTotal:          62500 kB"

     
···

       122
       125
        
               )

     

       123
       126
        
       

     

       124
       127
        
               machine.succeed("lxc config set test limits.memory 128MB")

     

       128
       128
       +
               machine.succeed("lxc restart test")

     

       125
       129
        
       

     

       126
       130
        
               assert (

     

       127
       131
        
                   "MemTotal:         125000 kB"

+2 -2

pkgs/applications/networking/instant-messengers/zoom-us/default.nix

···

       29
       29
        
       assert pulseaudioSupport -> libpulseaudio != null;

     

       30
       30
        
       

     

       31
       31
        
       let

     

       32
       32
       -
         version = "5.6.16888.0424";

     

       32
       32
       +
         version = "5.6.20278.0524";

     

       33
       33
        
         srcs = {

     

       34
       34
        
           x86_64-linux = fetchurl {

     

       35
       35
        
             url = "https://zoom.us/client/${version}/zoom_x86_64.pkg.tar.xz";

     

       36
       36
       -
             sha256 = "H/G9cSVmxYM0AVfrdpXzm7ohssDbKq2xdvIBc4d+elc=";

     

       36
       36
       +
             sha256 = "1nkpmrpb0bz4zkg8nszxmcfy3ymigd2bmxhnxbjrcnv64ykdrgp7";

     

       37
       37
        
           };

     

       38
       38
        
         };

     

       39
       39

+6 -1

pkgs/development/compilers/compcert/default.nix

···

       1
       1
        
       { lib, stdenv, fetchFromGitHub, fetchpatch, makeWrapper

     

       2
       2
        
       , coqPackages, ocamlPackages, coq2html

     

       3
       3
        
       , tools ? stdenv.cc

     

       4
       4
       -
       , version ? "3.8"

     

       4
       4
       +
       , version ? "3.9"

     

       5
       5
        
       }:

     

       6
       6
        
       

     

       7
       7
        
       let

     
···

       56
       56
        
           ];

     

       57
       57
        
           useExternalFlocq = true;

     

       58
       58
        
         };

     

       59
       59
       +
         "3.9" = {

     

       60
       60
       +
           sha256 = "1srcz2dqrvmbvv5cl66r34zqkm0hsbryk7gd3i9xx4slahc9zvdb";

     

       61
       61
       +
           useExternalFlocq = true;

     

       62
       62
       +
         };

     

       59
       63
        
       }."${version}"; in

     

       60
       64
        
       

     

       61
       65
        
       stdenv.mkDerivation rec {

     
···

       78
       82
        
       

     

       79
       83
        
         postPatch = ''

     

       80
       84
        
           substituteInPlace ./configure \

     

       85
       85
       +
             --replace \$\{toolprefix\}ar 'ar' \

     

       81
       86
        
             --replace '{toolprefix}gcc' '{toolprefix}cc'

     

       82
       87
        
         '';

     

       83
       88

+3 -2

pkgs/development/compilers/go/1.15.nix

···

       11
       11
        
       

     

       12
       12
        
         inherit (lib) optionals optionalString;

     

       13
       13
        
       

     

       14
       14
       -
         version = "1.15.12";

     

       14
       14
       +
         version = "1.15.13";

     

       15
       15
        
       

     

       16
       16
        
         go_bootstrap = buildPackages.callPackage ./bootstrap.nix { };

     

       17
       17
        
       

     
···

       45
       45
        
       

     

       46
       46
        
         src = fetchurl {

     

       47
       47
        
           url = "https://dl.google.com/go/go${version}.src.tar.gz";

     

       48
       48
       -
           sha256 = "sha256-HGkRk330onf6dOe378PQhZRJjExK3AtsSuNWYTdSgJE=";

     

       48
       48
       +
           sha256 = "sha256-mQaeciNHnM5FU/hPh0uTRfb0BF8nz1CJSJtUbaYZokQ=";

     

       49
       49
        
         };

     

       50
       50
        
       

     

       51
       51
        
         # perl is used for testing go vet

     
···

       268
       268
        
           license = licenses.bsd3;

     

       269
       269
        
           maintainers = teams.golang.members;

     

       270
       270
        
           platforms = platforms.linux ++ platforms.darwin;

     

       271
       271
       +
           badPlatforms = [ "aarch64-darwin" ];

     

       271
       272
        
         };

     

       272
       273
        
       }

+2 -2

pkgs/development/compilers/go/1.16.nix

···

       11
       11
        
       

     

       12
       12
        
         inherit (lib) optionals optionalString;

     

       13
       13
        
       

     

       14
       14
       -
         version = "1.16.4";

     

       14
       14
       +
         version = "1.16.5";

     

       15
       15
        
       

     

       16
       16
        
         go_bootstrap = buildPackages.callPackage ./bootstrap.nix { };

     

       17
       17
        
       

     
···

       45
       45
        
       

     

       46
       46
        
         src = fetchurl {

     

       47
       47
        
           url = "https://dl.google.com/go/go${version}.src.tar.gz";

     

       48
       48
       -
           sha256 = "sha256-rk9rbioWd9MYF5hGVadiB0tTVtpQ+1hyK5kQSHDUNQM=";

     

       48
       48
       +
           sha256 = "sha256-e/p+WQjHzJ512l3fMGbXy88/2fpRlFhRMl7rwX9QuoA=";

     

       49
       49
        
         };

     

       50
       50
        
       

     

       51
       51
        
         # perl is used for testing go vet

+3 -1

pkgs/development/compilers/go/binary.nix

···

       29
       29
        
         dontStrip = stdenv.hostPlatform.isDarwin;

     

       30
       30
        
       

     

       31
       31
        
         installPhase = ''

     

       32
       32
       +
           runHook preInstall

     

       32
       33
        
           mkdir -p $out/share/go $out/bin

     

       33
       34
        
           mv bin/* $out/bin

     

       34
       35
        
           cp -r . $out/share/go

     
···

       37
       38
        
             --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) \

     

       38
       39
        
             $out/bin/go

     

       39
       40
        
           '')}

     

       40
       40
       -
         '' ;

     

       41
       41
       +
           runHook postInstall

     

       42
       42
       +
         '';

     

       41
       43
        
       }

+9 -13

pkgs/development/compilers/zig/default.nix

···

       1
       1
        
       { lib

     

       2
       2
       -
       , stdenv

     

       3
       2
        
       , fetchFromGitHub

     

       4
       3
        
       , cmake

     

       5
       4
        
       , llvmPackages

     
···

       7
       6
        
       , zlib

     

       8
       7
        
       }:

     

       9
       8
        
       

     

       10
       10
       -
       llvmPackages.stdenv.mkDerivation rec {

     

       9
       9
       +
       let

     

       10
       10
       +
         inherit (llvmPackages) stdenv;

     

       11
       11
       +
       in

     

       12
       12
       +
       stdenv.mkDerivation rec {

     

       11
       13
        
         pname = "zig";

     

       12
       12
       -
         version = "0.7.1";

     

       14
       14
       +
         version = "0.8.0";

     

       13
       15
        
       

     

       14
       16
        
         src = fetchFromGitHub {

     

       15
       17
        
           owner = "ziglang";

     

       16
       18
        
           repo = pname;

     

       17
       19
        
           rev = version;

     

       18
       18
       -
           hash = "sha256-rZYv8LFH3M70SyPwPVyul+Um9j82K8GZIepVmaonzPw=";

     

       20
       20
       +
           hash = "sha256-bILjcKX8jPl2n1HRYvYRb7jJkobwqmSJ+hHXSn9n2ag=";

     

       19
       21
        
         };

     

       20
       22
        
       

     

       21
       23
        
         nativeBuildInputs = [

     

       22
       22
       -
           cmake llvmPackages.llvm.dev

     

       24
       24
       +
           cmake

     

       25
       25
       +
           llvmPackages.llvm.dev

     

       23
       26
        
         ];

     

       24
       27
        
         buildInputs = [

     

       25
       28
        
           libxml2

     
···

       34
       37
        
           export HOME=$TMPDIR;

     

       35
       38
        
         '';

     

       36
       39
        
       

     

       37
       37
       -
         checkPhase = ''

     

       38
       38
       -
           runHook preCheck

     

       39
       39
       -
           ./zig test --cache-dir "$TMPDIR" -I $src/test $src/test/stage1/behavior.zig

     

       40
       40
       -
           runHook postCheck

     

       41
       41
       -
         '';

     

       42
       42
       -
       

     

       43
       43
       -
         doCheck = true;

     

       44
       44
       -
       

     

       45
       40
        
         meta = with lib; {

     

       46
       41
        
           homepage = "https://ziglang.org/";

     

       47
       42
        
           description =

     
···

       53
       48
        
           broken = stdenv.isDarwin;

     

       54
       49
        
         };

     

       55
       50
        
       }

     

       51
       51
       +
       # TODO: checkPhase

+4 -1

pkgs/development/go-modules/generic/default.nix

···

       7
       7
        
       , passthru ? {}

     

       8
       8
        
       , patches ? []

     

       9
       9
        
       

     

       10
       10
       +
       # Go linker flags, passed to go via -ldflags

     

       11
       11
       +
       , ldflags ? []

     

       12
       12
       +
       

     

       10
       13
        
       # A function to override the go-modules derivation

     

       11
       14
        
       , overrideModAttrs ? (_oldAttrs : {})

     

       12
       15
        
       

     
···

       153
       156
        
               echo "$d" | grep -q "\(/_\|examples\|Godeps\|testdata\)" && return 0

     

       154
       157
        
               [ -n "$excludedPackages" ] && echo "$d" | grep -q "$excludedPackages" && return 0

     

       155
       158
        
               local OUT

     

       156
       156
       -
               if ! OUT="$(go $cmd $buildFlags "''${buildFlagsArray[@]}" -v -p $NIX_BUILD_CORES $d 2>&1)"; then

     

       159
       159
       +
               if ! OUT="$(go $cmd $buildFlags "''${buildFlagsArray[@]}" ''${ldflags:+-ldflags="$ldflags"} -v -p $NIX_BUILD_CORES $d 2>&1)"; then

     

       157
       160
        
                 if ! echo "$OUT" | grep -qE '(no( buildable| non-test)?|build constraints exclude all) Go (source )?files'; then

     

       158
       161
        
                   echo "$OUT" >&2

     

       159
       162
        
                   return 1

+4 -1

pkgs/development/go-packages/generic/default.nix

···

       7
       7
        
       , preFixup ? ""

     

       8
       8
        
       , shellHook ? ""

     

       9
       9
        
       

     

       10
       10
       +
       # Go linker flags, passed to go via -ldflags

     

       11
       11
       +
       , ldflags ? []

     

       12
       12
       +
       

     

       10
       13
        
       # We want parallel builds by default

     

       11
       14
        
       , enableParallelBuilding ? true

     

       12
       15
        
       

     
···

       148
       151
        
               echo "$d" | grep -q "\(/_\|examples\|Godeps\)" && return 0

     

       149
       152
        
               [ -n "$excludedPackages" ] && echo "$d" | grep -q "$excludedPackages" && return 0

     

       150
       153
        
               local OUT

     

       151
       151
       -
               if ! OUT="$(go $cmd $buildFlags "''${buildFlagsArray[@]}" -v -p $NIX_BUILD_CORES $d 2>&1)"; then

     

       154
       154
       +
               if ! OUT="$(go $cmd $buildFlags "''${buildFlagsArray[@]}" ''${ldflags:+-ldflags="$ldflags"} -v -p $NIX_BUILD_CORES $d 2>&1)"; then

     

       152
       155
        
                 if ! echo "$OUT" | grep -qE '(no( buildable| non-test)?|build constraints exclude all) Go (source )?files'; then

     

       153
       156
        
                   echo "$OUT" >&2

     

       154
       157
        
                   return 1

+12 -19

pkgs/development/ocaml-modules/ansiterminal/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, ocaml, findlib, ocamlbuild }:

     

       2
       2
       -
       

     

       3
       3
       -
       stdenv.mkDerivation rec {

     

       1
       1
       +
       { lib, buildDunePackage, fetchFromGitHub }:

     

       4
       2
        
       

     

       5
       5
       -
         version = "0.7";

     

       3
       3
       +
       buildDunePackage rec {

     

       4
       4
       +
         pname = "ANSITerminal";

     

       5
       5
       +
         version = "0.8.2";

     

       6
       6
        
       

     

       7
       7
       -
         name = "ocaml${ocaml.version}-ansiterminal-${version}";

     

       7
       7
       +
         useDune2 = true;

     

       8
       8
        
       

     

       9
       9
       -
         src = fetchurl {

     

       10
       10
       -
           url = "https://github.com/Chris00/ANSITerminal/releases/download/${version}/ANSITerminal-${version}.tar.gz";

     

       11
       11
       -
           sha256 = "03pqfxvw9pa9720l8i5fgxky1qx70kw6wxbczd5i50xi668lh0i9";

     

       9
       9
       +
         src = fetchFromGitHub {

     

       10
       10
       +
           owner = "Chris00";

     

       11
       11
       +
           repo = pname;

     

       12
       12
       +
           rev = version;

     

       13
       13
       +
           sha256 = "0dyjischrgwlxqz1p5zbqq76jvk6pl1qj75i7ydhijssr9pj278d";

     

       12
       14
        
         };

     

       13
       15
        
       

     

       14
       14
       -
         buildInputs = [ ocaml findlib ocamlbuild ];

     

       15
       15
       -
       

     

       16
       16
       -
         configurePhase = "ocaml setup.ml -configure --prefix $out";

     

       17
       17
       -
       

     

       18
       18
       -
         buildPhase = "ocaml setup.ml -build";

     

       19
       19
       -
       

     

       20
       20
       -
         installPhase = "ocaml setup.ml -install";

     

       21
       21
       -
       

     

       22
       22
       -
         createFindlibDestdir = true;

     

       16
       16
       +
         doCheck = true;

     

       23
       17
        
       

     

       24
       18
        
         meta = with lib; {

     

       25
       25
       -
           homepage = "https://github.com/Chris00/ANSITerminal";

     

       26
       19
        
           description = "A module allowing to use the colors and cursor movements on ANSI terminals";

     

       27
       20
        
           longDescription = ''

     

       28
       21
        
             ANSITerminal is a module allowing to use the colors and cursor

     

       29
       22
        
             movements on ANSI terminals. It also works on the windows shell (but

     

       30
       23
        
             this part is currently work in progress).

     

       31
       24
        
           '';

     

       25
       25
       +
           inherit (src.meta) homepage;

     

       32
       26
        
           license = licenses.lgpl3;

     

       33
       33
       -
           platforms = ocaml.meta.platforms or [];

     

       34
       27
        
           maintainers = [ maintainers.jirkamarsik ];

     

       35
       28
        
         };

     

       36
       29
        
       }

+3

pkgs/tools/admin/lxd/default.nix

···

       7
       7
        
       , bash

     

       8
       8
        
       , installShellFiles

     

       9
       9
        
       , nftablesSupport ? false

     

       10
       10
       +
       , nixosTests

     

       10
       11
        
       }:

     

       11
       12
        
       

     

       12
       13
        
       let

     
···

       57
       58
        
       

     

       58
       59
        
           installShellCompletion --bash --name lxd go/src/github.com/lxc/lxd/scripts/bash/lxd-client

     

       59
       60
        
         '';

     

       61
       61
       +
       

     

       62
       62
       +
         passthru.tests.lxd = nixosTests.lxd;

     

       60
       63
        
       

     

       61
       64
        
         nativeBuildInputs = [ installShellFiles pkg-config makeWrapper ];

     

       62
       65
        
         buildInputs = [ lxc acl libcap dqlite.dev raft-canonical.dev

+1 -1

pkgs/top-level/all-packages.nix

···

       18653
       18653
        
         libzra = callPackage ../development/libraries/libzra { };

     

       18654
       18654
        
       

     

       18655
       18655
        
         zig = callPackage ../development/compilers/zig {

     

       18656
       18656
       -
           llvmPackages = llvmPackages_11;

     

       18656
       18656
       +
           llvmPackages = llvmPackages_12;

     

       18657
       18657
        
         };

     

       18658
       18658
        
       

     

       18659
       18659
        
         zimlib = callPackage ../development/libraries/zimlib { };

+1 -1

pkgs/top-level/coq-packages.nix

···

       80
       80
        
             VST = callPackage ../development/coq-modules/VST (with lib.versions;

     

       81
       81
        
               lib.switch coq.coq-version [

     

       82
       82
        
                 { case = "8.11"; out = { compcert = compcert.override { coqPackages = self; version = "3.7"; }; }; }

     

       83
       83
       -
                 { case = range "8.12" "8.13"; out = { compcert = compcert.override { coqPackages = self; }; }; }

     

       83
       83
       +
                 { case = range "8.12" "8.13"; out = { compcert = compcert.override { coqPackages = self; version = "3.8"; }; }; }

     

       84
       84
        
               ] {});

     

       85
       85
        
             zorns-lemma = callPackage ../development/coq-modules/zorns-lemma {};

     

       86
       86
        
             filterPackages = doesFilter: if doesFilter then filterCoqPackages self else self;