Merge staging-next into staging

nixos/modules/system/boot/stage-1-init.sh

···
     # If copytoram is enabled: skip mounting the ISO and copy its content to a tmpfs.
     if [ -n "$copytoram" ] && [ "$device" = /dev/root ] && [ "$mountPoint" = /iso ]; then
       fsType=$(blkid -o value -s TYPE "$device")
-      fsSize=$(blockdev --getsize64 "$device")
+      fsSize=$(blockdev --getsize64 "$device" || stat -Lc '%s' "$device")
 
       mkdir -p /tmp-iso
       mount -t "$fsType" /dev/root /tmp-iso

pkgs/applications/blockchains/go-ethereum/default.nix

···
 
 in buildGoModule rec {
   pname = "go-ethereum";
-  version = "1.10.7";
+  version = "1.10.8";
 
   src = fetchFromGitHub {
     owner = "ethereum";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-P0+XPSpvVsjia21F3FIg7KO6Qe2ZbY90tM/dRwBBuBk=";
+    sha256 = "sha256-r4ifLa4CMZvp0MaCkxWo5rWLEnFdX//mYlC08hndXhQ=";
   };
 
   runVend = true;
-  vendorSha256 = "sha256-51jt5oBb/3avZnDRfo/NKAtZAU6QBFkzNdVxFnJ+erM=";
+  vendorSha256 = "sha256-e8aKQMVEEf0BzpdljkOBxznj5P1Go/6EbY9mdhDLyrw=";
 
   doCheck = false;
 

pkgs/applications/editors/glow/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags= -s -w -X=main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X=main.Version=${version}" ];
 
   meta = with lib; {
     description = "Render markdown on the CLI, with pizzazz!";

pkgs/applications/editors/micro/default.nix

···
 
   vendorSha256 = "sha256-YcAKl4keizkbgQLAZGiCG3CGpNTNad8EvOJEXLX2s0s=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/zyedidia/micro/v2/internal/util.Version=${version} -X github.com/zyedidia/micro/v2/internal/util.CommitHash=${src.rev}" ];
+  ldflags = [ "-s" "-w" "-X github.com/zyedidia/micro/v2/internal/util.Version=${version}" "-X github.com/zyedidia/micro/v2/internal/util.CommitHash=${src.rev}" ];
 
   postInstall = ''
     installManPage assets/packaging/micro.1

pkgs/applications/logging/humioctl/default.nix

···
       sha256 = sha256;
     };
 
-    buildFlagsArray = "-ldflags=-X main.version=${humioCtlVersion}";
+    ldflags = [ "-X main.version=${humioCtlVersion}" ];
 
     nativeBuildInputs = [ installShellFiles ];
 

pkgs/applications/misc/archiver/default.nix

···
 
   vendorSha256 = "0avnskay23mpl3qkyf1h75rr7szpsxis2bj5pplhwf8q8q0212xf";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version} -X main.commit=${src.rev} -X main.date=unknown" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" "-X main.commit=${src.rev}" "-X main.date=unknown" ];
 
   doCheck = false;
 

pkgs/applications/misc/charm/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags= -s -w -X=main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X=main.Version=${version}" ];
 
   meta = with lib; {
     description = "Manage your charm account on the CLI";

pkgs/applications/misc/dstask/default.nix

···
   # The other variables are set so that the output of dstask version shows the
   # git ref and the release version from github.
   # Ref <https://github.com/NixOS/nixpkgs/pull/87383#discussion_r432097657>
-  buildFlagsArray = [ ''
-    -ldflags=-w -s
-    -X "github.com/naggie/dstask.VERSION=${version}"
-    -X "github.com/naggie/dstask.GIT_COMMIT=v${version}"
-  '' ];
+  ldflags = [
+    "-w" "-s"
+    "-X github.com/naggie/dstask.VERSION=${version}"
+    "-X github.com/naggie/dstask.GIT_COMMIT=v${version}"
+  ];
 
   subPackages = [ "cmd/dstask.go" ];
 

pkgs/applications/misc/expenses/default.nix

···
 
   buildInputs = [ sqlite ];
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X github.com/manojkarthick/expenses/cmd.Version=${version}"
+  ldflags = [
+    "-s" "-w" "-X github.com/manojkarthick/expenses/cmd.Version=${version}"
   ];
 
   meta = with lib; {

pkgs/applications/misc/wtf/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   subPackages = [ "." ];
 

pkgs/applications/networking/cloudflared/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = "-ldflags=-X main.Version=${version}";
+  ldflags = [ "-X main.Version=${version}" ];
 
   meta = with lib; {
     description = "CloudFlare Argo Tunnel daemon (and DNS-over-HTTPS client)";

pkgs/applications/networking/cluster/argocd/default.nix

···
     packr
   '';
 
-  buildFlagsArray =
+  ldflags =
     let package_url = "github.com/argoproj/argo-cd/v2/common"; in
     [
-      "-ldflags="
-      "-s -w"
+      "-s" "-w"
       "-X ${package_url}.version=${version}"
       "-X ${package_url}.buildDate=unknown"
       "-X ${package_url}.gitCommit=${commit}"

pkgs/applications/networking/cluster/cloudfoundry-cli/default.nix

···
 
   nativeBuildInputs = [ installShellFiles ];
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-s"
     "-w"
     "-X code.cloudfoundry.org/cli/version.binaryBuildDate=1970-01-01"

pkgs/applications/networking/cluster/fluxcd/default.nix

···
 
   subPackages = [ "cmd/flux" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.VERSION=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.VERSION=${version}" ];
 
   postUnpack = ''
     cp -r ${manifests} source/cmd/flux/manifests

pkgs/applications/networking/cluster/fluxctl/default.nix

···
 
   subPackages = [ "cmd/fluxctl" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   postInstall = ''
     for shell in bash fish zsh; do

pkgs/applications/networking/cluster/helmfile/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/roboll/helmfile/pkg/app/version.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/roboll/helmfile/pkg/app/version.Version=${version}" ];
 
   postInstall = ''
     wrapProgram $out/bin/helmfile \

pkgs/applications/networking/cluster/hetzner-kube/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = ''
-    -ldflags=
-    -X github.com/xetys/hetzner-kube/cmd.version=${version}
-  '';
+  ldflags = [
+    "-X github.com/xetys/hetzner-kube/cmd.version=${version}"
+  ];
 
   nativeBuildInputs = [
     installShellFiles

pkgs/applications/networking/cluster/istioctl/default.nix

···
   nativeBuildInputs = [ installShellFiles ];
 
   # Bundle release metadata
-  buildFlagsArray = let
+  ldflags = let
     attrs = [
       "istio.io/pkg/version.buildVersion=${version}"
       "istio.io/pkg/version.buildStatus=Nix"
       "istio.io/pkg/version.buildTag=${version}"
       "istio.io/pkg/version.buildHub=docker.io/istio"
     ];
-  in ["-ldflags=-s -w ${lib.concatMapStringsSep " " (attr: "-X ${attr}") attrs}"];
+  in ["-s" "-w" "${lib.concatMapStringsSep " " (attr: "-X ${attr}") attrs}"];
 
   subPackages = [ "istioctl/cmd/istioctl" ];
 

pkgs/applications/networking/cluster/jx/default.nix

···
 
   nativeBuildInputs = [ installShellFiles ];
 
-  buildFlagsArray = ''
-    -ldflags=
-    -s -w
-    -X github.com/jenkins-x/jx/pkg/version.Version=${version}
-    -X github.com/jenkins-x/jx/pkg/version.Revision=${src.rev}
-    -X github.com/jenkins-x/jx/pkg/version.GitTreeState=clean
-  '';
+  ldflags = [
+    "-s -w"
+    "-X github.com/jenkins-x/jx/pkg/version.Version=${version}"
+    "-X github.com/jenkins-x/jx/pkg/version.Revision=${src.rev}"
+    "-X github.com/jenkins-x/jx/pkg/version.GitTreeState=clean"
+  ];
 
   postInstall = ''
     for shell in bash zsh; do

pkgs/applications/networking/cluster/k9s/default.nix

···
     sha256 = "sha256-ws5JC2/WkgwxKwYtP9xtFELRhztzL6tNSvopyeC6H0Q=";
   };
 
-  buildFlagsArray = ''
-    -ldflags=
-      -s -w
-      -X github.com/derailed/k9s/cmd.version=${version}
-      -X github.com/derailed/k9s/cmd.commit=${src.rev}
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X github.com/derailed/k9s/cmd.version=${version}"
+    "-X github.com/derailed/k9s/cmd.commit=${src.rev}"
+  ];
 
   vendorSha256 = "sha256-T9khJeg5XPhVyUiu4gEEHZR6RgJF4P8LYFycqJglms8=";
 

pkgs/applications/networking/cluster/kpt/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/GoogleContainerTools/kpt/run.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/GoogleContainerTools/kpt/run.version=${version}" ];
 
   meta = with lib; {
     description = "A toolkit to help you manage, manipulate, customize, and apply Kubernetes Resource configuration data files";

pkgs/applications/networking/cluster/kubelogin/default.nix

···
 
   vendorSha256 = "sha256-vJfTf9gD/qrsPAfJeMYLjGa90mYLOshgDehv2Fcl6xM=";
 
-  buildFlagsArray = ''
-    -ldflags=
-        -X main.version=${version}
-        -X main.goVersion=${lib.getVersion go}
-  '';
+  ldflags = [
+    "-X main.version=${version}"
+    "-X main.goVersion=${lib.getVersion go}"
+  ];
 
   meta = with lib; {
     description = "A Kubernetes credential plugin implementing Azure authentication";

pkgs/applications/networking/cluster/kubeseal/default.nix

···
 
   subPackages = [ "cmd/kubeseal" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.VERSION=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.VERSION=${version}" ];
 
   meta = with lib; {
     description = "A Kubernetes controller and tool for one-way encrypted Secrets";

pkgs/applications/networking/cluster/kuttl/default.nix

···
 
   subPackages = [ "cmd/kubectl-kuttl" ];
 
-  buildFlagsArray = ''
-    -ldflags=-s -w
-    -X  github.com/kudobuilder/kuttl/pkg/version.gitVersion=${version}
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X github.com/kudobuilder/kuttl/pkg/version.gitVersion=${version}"
+  ];
 
   meta = with lib; {
     description = "The KUbernetes Test TooL (KUTTL) provides a declarative approach to testing production-grade Kubernetes operators";

pkgs/applications/networking/cluster/multus-cni/default.nix

···
     sha256 = "sha256-eVYRbMijOEa+DNCm4w/+WVrTI9607NF9/l5YKkXJuFs=";
   };
 
-  buildFlagsArray = let
+  ldflags = let
     multus = "gopkg.in/intel/multus-cni.v3/pkg/multus";
     commit = "f6298a3a294a79f9fbda0b8f175e521799d5f8d7";
   in [
-    "-ldflags=-s -w -X '${multus}.version=v${version}' -X '${multus}.commit=${commit}'"
+    "-s" "-w" "-X ${multus}.version=v${version}" "-X ${multus}.commit=${commit}"
   ];
 
   preInstall = ''

pkgs/applications/networking/cluster/popeye/default.nix

···
     sha256 = "sha256-oft1zLLd5TP8S9GMjp5kYaoPoOYnbhJwL2wBerkhp+c=";
   };
 
-  buildFlagsArray = ''
-    -ldflags=
-      -s -w
-      -X github.com/derailed/popeye/cmd.version=${version}
-      -X github.com/derailed/popeye/cmd.commit=${version}
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X github.com/derailed/popeye/cmd.version=${version}"
+    "-X github.com/derailed/popeye/cmd.commit=${version}"
+  ];
 
   vendorSha256 = "sha256-vUUDLMicop5QzZmAHi5qrc0hx8oV2xWNFHvCWioLhl8=";
 

pkgs/applications/networking/cluster/qbec/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = ''
-    -ldflags=
-      -s -w
-      -X github.com/splunk/qbec/internal/commands.version=${version}
-      -X github.com/splunk/qbec/internal/commands.commit=${src.rev}
-      -X github.com/splunk/qbec/internal/commands.goVersion=${lib.getVersion go}
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X github.com/splunk/qbec/internal/commands.version=${version}"
+    "-X github.com/splunk/qbec/internal/commands.commit=${src.rev}"
+    "-X github.com/splunk/qbec/internal/commands.goVersion=${lib.getVersion go}"
+  ];
 
   meta = with lib; {
     description = "Configure kubernetes objects on multiple clusters using jsonnet https://qbec.io";

pkgs/applications/networking/cluster/sonobuoy/default.nix

···
   pname = "sonobuoy";
   version = "0.53.2"; # Do not forget to update `rev` above
 
-  buildFlagsArray =
+  ldflags =
     let t = "github.com/vmware-tanzu/sonobuoy";
-    in ''
-      -ldflags=
-        -s -X ${t}/pkg/buildinfo.Version=v${version}
-           -X ${t}/pkg/buildinfo.GitSHA=${rev}
-           -X ${t}/pkg/buildDate=unknown
-    '';
+    in [
+      "-s"
+      "-X ${t}/pkg/buildinfo.Version=v${version}"
+      "-X ${t}/pkg/buildinfo.GitSHA=${rev}"
+      "-X ${t}/pkg/buildDate=unknown"
+    ];
 
   src = fetchFromGitHub {
     sha256 = "sha256-8bUZsknG1Z2TKWwtuJtnauK8ibikGphl3oiLXT3PZzY=";

pkgs/applications/networking/cluster/stern/default.nix

···
 
   nativeBuildInputs = [ installShellFiles ];
 
-  buildFlagsArray =
-    [ "-ldflags=-s -w -X github.com/stern/stern/cmd.version=${version}" ];
+  ldflags =
+    [ "-s" "-w" "-X github.com/stern/stern/cmd.version=${version}" ];
 
   postInstall =
     let stern = if isCrossBuild then buildPackages.stern else "$out";

pkgs/applications/networking/cluster/tanka/default.nix

···
 
   subPackages = [ "cmd/tk" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -extldflags \"-static\" -X github.com/grafana/tanka/pkg/tanka.CURRENT_VERSION=v${version}" ];
+  ldflags = [ "-s" "-w" "-extldflags '-static'" "-X github.com/grafana/tanka/pkg/tanka.CURRENT_VERSION=v${version}" ];
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/applications/networking/cluster/tilt/default.nix

···
 
   subPackages = [ "cmd/tilt" ];
 
-  buildFlagsArray = [ "-ldflags=-X main.version=${version}" ];
+  ldflags = [ "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "Local development tool to manage your developer instance when your team deploys to Kubernetes in production";

pkgs/applications/networking/cluster/velero/default.nix

···
     sha256 = "sha256-oFDTjpcwlvSiAROG/EKYRCD+qKyZXu1gKotBcD0dfvk=";
   };
 
-  buildFlagsArray = ''
-    -ldflags=
-      -s -w
-      -X github.com/vmware-tanzu/velero/pkg/buildinfo.Version=${version}
-      -X github.com/vmware-tanzu/velero/pkg/buildinfo.GitSHA=${commit}
-      -X github.com/vmware-tanzu/velero/pkg/buildinfo.GitTreeState=clean
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X github.com/vmware-tanzu/velero/pkg/buildinfo.Version=${version}"
+    "-X github.com/vmware-tanzu/velero/pkg/buildinfo.GitSHA=${commit}"
+    "-X github.com/vmware-tanzu/velero/pkg/buildinfo.GitTreeState=clean"
+  ];
 
   vendorSha256 = "sha256-ypgrdv6nVW+AAwyVsiROXs6jGgDTodGrGqiT2s5elOU=";
 

pkgs/applications/networking/dnscontrol/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = [ "-ldflags=-s -w" ];
+  ldflags = [ "-s" "-w" ];
 
   meta = with lib; {
     description = "Synchronize your DNS to multiple providers from a simple DSL";

pkgs/applications/networking/nextdns/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "NextDNS DNS/53 to DoH Proxy";

pkgs/applications/networking/shellhub-agent/default.nix

···
 
   vendorSha256 = "18z3vwcwkyj6hcvl35qmj034237h9l18dvcbx1hxry7qdwv807c9";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.AgentVersion=v${version}" ];
+  ldflags = [ "-s" "-w" "-X main.AgentVersion=v${version}" ];
 
   passthru = {
     updateScript = genericUpdater {

pkgs/applications/version-management/git-and-tools/ghorg/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "Quickly clone an entire org/users repositories into one directory";

pkgs/applications/version-management/git-and-tools/ghq/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = ''
-    -ldflags=
-      -X=main.Version=${version}
-  '';
+  ldflags = [
+    "-X=main.Version=${version}"
+  ];
 
   postInstall = ''
     install -m 444 -D ${src}/misc/zsh/_ghq $out/share/zsh/site-functions/_ghq

pkgs/applications/version-management/git-and-tools/git-bug/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = ''
-    -ldflags=
-      -X github.com/MichaelMure/git-bug/commands.GitCommit=${rev}
-      -X github.com/MichaelMure/git-bug/commands.GitLastTag=${version}
-      -X github.com/MichaelMure/git-bug/commands.GitExactTag=${version}
-  '';
+  ldflags = [
+    "-X github.com/MichaelMure/git-bug/commands.GitCommit=${rev}"
+    "-X github.com/MichaelMure/git-bug/commands.GitLastTag=${version}"
+    "-X github.com/MichaelMure/git-bug/commands.GitExactTag=${version}"
+  ];
 
   postInstall = ''
     install -D -m 0644 misc/bash_completion/git-bug "$out/share/bash-completion/completions/git-bug"

pkgs/applications/version-management/git-and-tools/git-chglog/default.nix

···
 
   vendorSha256 = "sha256-jIq+oacyT71m78iMZwWOBsBVAY/WxgyH9zRr8GiMGTU=";
 
-  buildFlagsArray = [ "-ldflags= -s -w -X=main.Version=v${version}" ];
+  ldflags = [ "-s" "-w" "-X=main.Version=v${version}" ];
 
   subPackages = [ "cmd/git-chglog" ];
 
···
     maintainers = with maintainers; [ ldenefle ];
   };
 }
-

pkgs/applications/version-management/git-and-tools/lab/default.nix

···
 
   nativeBuildInputs = [ makeWrapper installShellFiles ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   postInstall = ''
     wrapProgram $out/bin/lab --prefix PATH ":" "${lib.makeBinPath [ git xdg-utils ]}";

pkgs/applications/version-management/gitlab/gitlab-workhorse/default.nix

···
 
   vendorSha256 = "sha256-gTObI0pmRUX6Eh5FVdt+5LbckyBuFq1Ly4oPZztazHQ=";
   buildInputs = [ git ];
-  buildFlagsArray = "-ldflags=-X main.Version=${version}";
+  ldflags = [ "-X main.Version=${version}" ];
   doCheck = false;
 
   meta = with lib; {

pkgs/applications/video/go-chromecast/default.nix

···
 
   vendorSha256 = "sha256-idxElk4Sy7SE9G1OMRw8YH4o8orBa80qhBXPA+ar620=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version} -X main.commit=${src.rev} -X main.date=unknown" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" "-X main.commit=${src.rev}" "-X main.date=unknown" ];
 
   meta = with lib; {
     homepage = "https://github.com/vishen/go-chromecast";

pkgs/applications/virtualization/cri-o/default.nix

···
 
 buildGoModule rec {
   pname = "cri-o";
-  version = "1.21.2";
+  version = "1.22.0";
 
   src = fetchFromGitHub {
     owner = "cri-o";
     repo = "cri-o";
     rev = "v${version}";
-    sha256 = "sha256-hapXwd7K0xbkZ0MKkJ5wv4zfDKRTC3IC4oLYLL460oI=";
+    sha256 = "sha256-lY/kHvJBN7idFn3YUEHMR4w+M3F89RKMsvvyHmH/EPc=";
   };
   vendorSha256 = null;
 

pkgs/applications/virtualization/crun/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "crun";
-  version = "0.21";
+  version = "1.0";
 
   src = fetchFromGitHub {
     owner = "containers";
     repo = pname;
     rev = version;
-    sha256 = "sha256-PhhaCXtWsknMsEt1F9jMfEWSl+OLQ/C/iTj7t0XuAFw=";
+    sha256 = "sha256-xpNwhNAbcTKkXl5i4L8aayMAx8O8SWdFlgHguHNiqqw=";
     fetchSubmodules = true;
   };
 

pkgs/applications/virtualization/imgcrypt/default.nix

···
     sha256 = "177fs3p2xzwjsffcxqqllx6wi6ghfyqbvfgn95v3q7a2993yqk4k";
   };
 
-  buildFlagsArray = [
-    "-ldflags=-X github.com/containerd/containerd/version.Version=${version}"
+  ldflags = [
+    "-X github.com/containerd/containerd/version.Version=${version}"
   ];
 
   vendorSha256 = null;

pkgs/applications/virtualization/nvidia-container-toolkit/default.nix

···
   };
 
   vendorSha256 = "17zpiyvf22skfcisflsp6pn56y6a793jcx89kw976fq2x5br1bz7";
-  buildFlagsArray = [ "-ldflags=" "-s -w" ];
+  ldflags = [ "-s" "-w" ];
   nativeBuildInputs = [ makeWrapper ];
 
   postInstall = ''

pkgs/build-support/writers/default.nix

···
   writeBashBin = name:
     writeBash "/bin/${name}";
 
-  # writeC writes an executable c package called `name` to `destination` using `libraries`.
-  #
-  #  Examples:
-  #    writeC "hello-world-ncurses" { libraries = [ pkgs.ncurses ]; } ''
-  #      #include <ncurses.h>
-  #      int main() {
-  #        initscr();
-  #        printw("Hello World !!!");
-  #        refresh(); endwin();
-  #        return 0;
-  #      }
-  #    ''
-  writeC = name: {
-    libraries ? [],
-    strip ? true
-  }:
-    makeBinWriter {
-      compileScript = ''
-        PATH=${makeBinPath [
-          pkgs.binutils-unwrapped
-          pkgs.coreutils
-          pkgs.findutils
-          pkgs.gcc
-          pkgs.pkg-config
-        ]}
-        export PKG_CONFIG_PATH=${concatMapStringsSep ":" (pkg: "${pkg}/lib/pkgconfig") libraries}
-        gcc \
-            ${optionalString (libraries != [])
-              "$(pkg-config --cflags --libs ${
-                concatMapStringsSep " " (pkg: "$(find ${escapeShellArg pkg}/lib/pkgconfig -name \\*.pc)") libraries
-              })"
-            } \
-            -O \
-            -o "$out" \
-            -Wall \
-            -x c \
-            "$contentPath"
-      '';
-      inherit strip;
-    } name;
-
-  # writeCBin takes the same arguments as writeC but outputs a directory (like writeScriptBin)
-  writeCBin = name:
-    writeC "/bin/${name}";
-
   # Like writeScript but the first line is a shebang to dash
   #
   # Example:

pkgs/build-support/writers/test.nix

···
      if [[ "test" == "test" ]]; then echo "success"; fi
     '';
 
-    c = writeCBin "test-writers-c" { libraries = [ ]; } ''
-      #include <stdio.h>
-      int main() {
-        printf("success\n");
-        return 0;
-      }
-    '';
-
     dash = writeDashBin "test-writers-dash-bin" ''
      test '~' = '~' && echo 'success'
     '';
···
   simple = {
     bash = writeBash "test-writers-bash" ''
      if [[ "test" == "test" ]]; then echo "success"; fi
-    '';
-
-    c = writeC "test-writers-c" { libraries = [ glib.dev ]; } ''
-      #include <gio/gio.h>
-      #include <stdio.h>
-      int main() {
-        GApplication *application = g_application_new ("hello.world", G_APPLICATION_FLAGS_NONE);
-        g_application_register (application, NULL, NULL);
-        GNotification *notification = g_notification_new ("Hello world!");
-        g_notification_set_body (notification, "This is an example notification.");
-        GIcon *icon = g_themed_icon_new ("dialog-information");
-        g_notification_set_icon (notification, icon);
-        g_object_unref (icon);
-        g_object_unref (notification);
-        g_object_unref (application);
-        printf("success\n");
-        return 0;
-      }
     '';
 
     dash = writeDash "test-writers-dash" ''

pkgs/development/compilers/fstar/default.nix

···
 { lib, stdenv, fetchFromGitHub, z3, ocamlPackages, makeWrapper, installShellFiles }:
 
+let
+  # FStar requires sedlex < 2.4
+  # see https://github.com/FStarLang/FStar/issues/2343
+  sedlex-2_3 = ocamlPackages.sedlex_2.overrideAttrs (_: rec {
+    pname = "sedlex";
+    version = "2.3";
+    src = fetchFromGitHub {
+       owner = "ocaml-community";
+       repo = "sedlex";
+       rev = "v${version}";
+       sha256 = "WXUXUuIaBUrFPQOKtZ7dgDZYdpEVnoJck0dkrCi8g0c=";
+    };
+  });
+in
+
 stdenv.mkDerivation rec {
   pname = "fstar";
-  version = "0.9.6.0";
+  version = "2021.07.31";
 
   src = fetchFromGitHub {
     owner = "FStarLang";
     repo = "FStar";
     rev = "v${version}";
-    sha256 = "0wix7l229afkn6c6sk4nwkfq0nznsiqdkds4ixi2yyf72immwmmb";
+    sha256 = "KZTmphpt8nYpOd8EReAZ6iIkS4uY3ZziKQ3A70BL/90=";
   };
 
   nativeBuildInputs = [ makeWrapper installShellFiles ];
 
-  buildInputs = with ocamlPackages; [
-    z3 ocaml findlib batteries menhir menhirLib stdint
-    zarith camlp4 yojson pprint
-    ulex ocaml-migrate-parsetree process ppx_deriving ppx_deriving_yojson ocamlbuild
-  ];
+  buildInputs = [
+    z3
+  ] ++ (with ocamlPackages; [
+    ocaml
+    findlib
+    ocamlbuild
+    batteries
+    zarith
+    stdint
+    yojson
+    fileutils
+    menhir
+    menhirLib
+    pprint
+    sedlex-2_3
+    ppxlib
+    ppx_deriving
+    ppx_deriving_yojson
+    process
+  ]);
 
   makeFlags = [ "PREFIX=$(out)" ];
 
-  preBuild = ''
-    patchShebangs src/tools
-    patchShebangs bin
+  buildFlags = [ "libs" ];
+
+  postPatch = ''
+    patchShebangs ulib/gen_mllib.sh
+    substituteInPlace src/ocaml-output/Makefile --replace '$(COMMIT)' 'v${version}'
   '';
-  buildFlags = [ "-C" "src/ocaml-output" ];
 
   preInstall = ''
     mkdir -p $out/lib/ocaml/${ocamlPackages.ocaml.version}/site-lib/fstarlib
   '';
-  installFlags = [ "-C" "src/ocaml-output" ];
   postInstall = ''
     wrapProgram $out/bin/fstar.exe --prefix PATH ":" "${z3}/bin"
     installShellCompletion --bash .completion/bash/fstar.exe.bash

pkgs/development/embedded/arduino/arduino-cli/default.nix

···
 
     doCheck = false;
 
-    buildFlagsArray = [
-      "-ldflags=-s -w -X github.com/arduino/arduino-cli/version.versionString=${version} -X github.com/arduino/arduino-cli/version.commit=unknown"
+    ldflags = [
+      "-s" "-w" "-X github.com/arduino/arduino-cli/version.versionString=${version}" "-X github.com/arduino/arduino-cli/version.commit=unknown"
     ] ++ lib.optionals stdenv.isLinux [ "-extldflags '-static'" ];
 
     meta = with lib; {

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

···
 # Not needed with buildGoModule
 , goPackagePath ? ""
 
-# needed for buildFlags warning
+# needed for buildFlags{,Array} warning
 , buildFlags ? ""
+, buildFlagsArray ? ""
 
 , ... }@args':
 
···
     };
   });
 in
-lib.warnIf (buildFlags != "")
-  "Use the `ldflags` and/or `tags` attributes instead of `buildFlags`"
+lib.warnIf (buildFlags != "" || buildFlagsArray != "")
+  "Use the `ldflags` and/or `tags` attributes instead of `buildFlags`/`buildFlagsArray`"
   package

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

···
-{ lib, fetchzip, buildDunePackage, ocaml }:
+{ lib, fetchFromGitHub, buildDunePackage, ocaml }:
 
 buildDunePackage rec {
   pname = "integers";
-  version = "0.4.0";
+  version = "0.5.1";
 
   useDune2 = lib.versionAtLeast ocaml.version "4.08";
 
-  src = fetchzip {
-    url = "https://github.com/ocamllabs/ocaml-integers/archive/${version}.tar.gz";
-    sha256 = "0yp3ab0ph7mp5741g7333x4nx8djjvxzpnv3zvsndyzcycspn9dd";
+  src = fetchFromGitHub {
+    owner = "ocamllabs";
+    repo = "ocaml-integers";
+    rev = version;
+    sha256 = "0by5pc851fk7ccxqy1w2qc5jwn9z8whyqhs5gxlm5986vr9msnyi";
   };
 
   meta = {
     description = "Various signed and unsigned integer types for OCaml";
     license = lib.licenses.mit;
     homepage = "https://github.com/ocamllabs/ocaml-integers";
+    changelog = "https://github.com/ocamllabs/ocaml-integers/raw/${version}/CHANGES.md";
     maintainers = [ lib.maintainers.vbgl ];
   };
 }

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

···
 
 buildDunePackage rec {
   pname = "ppx_cstubs";
-  version = "0.6.1.1";
+  version = "0.6.1.2";
 
   useDune2 = true;
 
···
     owner = "fdopen";
     repo = "ppx_cstubs";
     rev = version;
-    sha256 = "0rgg78435ypi6ryhcq5ljkch4qjvra2jqjd47c2hhhcbwvi2ssxh";
+    sha256 = "15cjb9ygnvp2kv85rrb7ncz7yalifyl7wd2hp2cl8r1qrpgi1d0w";
   };
 
   buildInputs = [
···
 
   meta = with lib; {
     homepage = "https://github.com/fdopen/ppx_cstubs";
+    changelog = "https://github.com/fdopen/ppx_cstubs/raw/${version}/CHANGES.md";
     description = "Preprocessor for easier stub generation with ocaml-ctypes";
-    license = licenses.mit;
+    license = licenses.lgpl21Plus;
     maintainers = [ maintainers.osener ];
   };
 }

pkgs/development/python-modules/awesomeversion/default.nix

···
 
 buildPythonPackage rec {
   pname = "awesomeversion";
-  version = "21.8.0";
+  version = "21.8.1";
   disabled = pythonOlder "3.8";
 
   src = fetchFromGitHub {
     owner = "ludeeus";
     repo = pname;
     rev = version;
-    sha256 = "sha256-j5y3f6F+8PzOPxpBHE3LKF3kdRzP4d21N/1Bd6v+MQg=";
+    sha256 = "sha256-eyo0dzmExJ7WCRAXFvB+ElWi5HTTzJ7XJsmxB2t6yfI=";
   };
 
   postPatch = ''

pkgs/development/python-modules/bids-validator/default.nix

···
 }:
 
 buildPythonPackage rec {
-  version = "1.8.0";
+  version = "1.8.2";
   pname = "bids-validator";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "6d4ecc384121899e0cd5af773419c5ba722585cb176544560ec9a48f17dfd777";
+    sha256 = "7969d55e9ed07f6cf7dfd72ed696a05abe56a2f35e81a1ef677f3694b2adf606";
   };
 
   # needs packages which are not available in nixpkgs

pkgs/development/python-modules/cfgv/default.nix

···
 
 buildPythonPackage rec {
   pname = "cfgv";
-  version = "3.3.0";
+  version = "3.3.1";
   disabled = isPy27;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "9e600479b3b99e8af981ecdfc80a0296104ee610cab48a5ae4ffd0b668650eb1";
+    sha256 = "f5a830efb9ce7a445376bb66ec94c638a9787422f96264c98edc6bdeed8ab736";
   };
 
   propagatedBuildInputs = [ six ];

pkgs/development/python-modules/django-q/default.nix

···
 
 buildPythonPackage rec {
   pname = "django-q";
-  version = "1.3.8";
+  version = "1.3.9";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "db30266fadd6ab9336a8824291910ff1d1c28f7bc9d6e52cdaf33cc275ae6146";
+    sha256 = "5c6b4d530aa3aabf9c6aa57376da1ca2abf89a1562b77038b7a04e52a4a0a91b";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/elasticsearch/default.nix

···
 
 buildPythonPackage (rec {
   pname = "elasticsearch";
-  version = "7.13.1";
+  version = "7.14.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "d6bcca0b2e5665d08e6fe6fadc2d4d321affd76ce483603078fc9d3ccd2bc0f9";
+    sha256 = "f3ab1454e646170bbc6796b8707e4bff125234391d2acc022221e1c0313becb4";
   };
 
   # Check is disabled because running them destroy the content of the local cluster!

pkgs/development/python-modules/google-cloud-access-context-manager/default.nix

···
-{ lib, buildPythonPackage, fetchPypi, pythonOlder, google-api-core }:
+{ lib, buildPythonPackage, fetchPypi, google-api-core }:
 
 buildPythonPackage rec {
   pname = "google-cloud-access-context-manager";
···
   ];
 
   meta = with lib; {
-    description = "Protobufs for Google Access Context Manager.";
+    description = "Protobufs for Google Access Context Manager";
     homepage = "https://github.com/googleapis/python-access-context-manager";
     license = licenses.asl20;
     maintainers = with maintainers; [ austinbutler SuperSandro2000 ];

pkgs/development/python-modules/jc/default.nix

···
 
 buildPythonPackage rec {
   pname = "jc";
-  version = "1.16.0";
+  version = "1.16.1";
   disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
     owner = "kellyjonbrazil";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-6kh9FzMW5davxN8jNFFUh+PGSNAW7w8aeoJP25mGY10=";
+    sha256 = "sha256-R/RKMxSilv8JJW5om+l99vvrZYHjEEK1OCdsYWuxA74=";
   };
 
   propagatedBuildInputs = [ ruamel_yaml xmltodict pygments ];

pkgs/development/python-modules/jq/default.nix

···
 
 buildPythonPackage rec {
   pname = "jq";
-  version = "1.1.3";
+  version = "1.2.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "1ryxcll7601ki9rwlnryhhxpmwwnxs2qxq7kjm2b0xcqgzx1vv7r";
+    sha256 = "73ce588025495e6ebcda20bb9e64b6d9f3f1657c22895143ae243899ac710cbc";
   };
 
   patches = [

pkgs/development/python-modules/jwcrypto/default.nix

···
 
 buildPythonPackage rec {
   pname = "jwcrypto";
-  version = "0.9.1";
+  version = "1.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "63531529218ba9869e14ef8c9e7b516865ede3facf9b0ef3d3ba68014da211f9";
+    sha256 = "f88816eb0a41b8f006af978ced5f171f33782525006cdb055b536a40f4d46ac9";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/mecab-python3/default.nix

···
 
 buildPythonPackage rec {
   pname = "mecab-python3";
-  version = "1.0.3";
+  version = "1.0.4";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "62abe28a1155398325372291483608427bc82681fef80e7d132904415f9fd42e";
+    sha256 = "b150ad5fe4260539b4ef184657e552ef81307fbbe60ae1f258bc814549ea90f8";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/msal/default.nix

···
 
 buildPythonPackage rec {
   pname = "msal";
-  version = "1.12.0";
+  version = "1.13.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "5cc93f09523c703d4e00a901cf719ade4faf2c3d14961ba52060ae78d5b25327";
+    sha256 = "1ab72dbb623fb8663e8fdefc052b1f9d4ae0951ea872f5f488dad58f3618c89d";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/nbsphinx/default.nix

···
 
 buildPythonPackage rec {
   pname = "nbsphinx";
-  version = "0.8.6";
+  version = "0.8.7";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "097dee333558f400e9abbb53ce7d4fa64a257cfa89dd20f7554dca7f0cd5e143";
+    sha256 = "ff91b5b14ceb1a9d44193b5fc3dd3617e7b8ab59c788f7710049ce5faff2750c";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/pdftotext/default.nix

···
 
 buildPythonPackage rec {
   pname = "pdftotext";
-  version = "2.1.6";
+  version = "2.2.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "caf8ddbaeaf0a5897f07655a71747242addab2e695e84c5d47f2ea92dfe2a594";
+    sha256 = "efbbfb14cf37ed7ab2c71936bae44707dfed6bb3be7ea5214e9c44c8c258c7af";
   };
 
   buildInputs = [ poppler ];

pkgs/development/python-modules/perfplot/default.nix

···
 
 buildPythonPackage rec {
   pname = "perfplot";
-  version = "0.9.6";
+  version = "0.9.8";
   disabled = pythonOlder "3.7";
 
   src = fetchFromGitHub {
     owner = "nschloe";
     repo = pname;
-    rev = "v${version}";
-    sha256 = "11f31d6xqxp04693symc2dl8890gjaycrb2a35y5xy023abwir5b";
+    rev = version;
+    sha256 = "17dpgd27ik7ka7xpk3mj3anbjj62lwygy1vxlmrmk8xbhrqkim8d";
   };
   format = "pyproject";
 

pkgs/development/python-modules/progress/default.nix

···
 }:
 
 buildPythonPackage rec {
-  version = "1.5";
+  version = "1.6";
   pname = "progress";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0wj3wvdgfmqj44n32wag3mzpp5fjqkkd321x67v1prxvs78yvv39";
+    sha256 = "c9c86e98b5c03fa1fe11e3b67c1feda4788b8d0fe7336c2ff7d5644ccfba34cd";
   };
 
   checkPhase = ''

pkgs/development/python-modules/pyTelegramBotAPI/default.nix

···
 
 buildPythonPackage rec {
   pname = "pyTelegramBotAPI";
-  version = "3.8.2";
+  version = "3.8.3";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "cf83c652b88b4b1535a306a9b0c2f34bf6c390cebb9553ef34369e6290fc9496";
+    sha256 = "afdd887fff42a963f13d09a1f4f5fd24aef08f4b8a594f2ac11e0a29022f1518";
   };
 
   propagatedBuildInputs = [ requests ];

pkgs/development/python-modules/pybtex-docutils/default.nix

···
 { lib, buildPythonPackage, fetchPypi, docutils, pybtex, six }:
 
 buildPythonPackage rec {
-  version = "1.0.0";
+  version = "1.0.1";
   pname = "pybtex-docutils";
 
   doCheck = false;
···
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "cead6554b4af99c287dd29f38b1fa152c9542f56a51cb6cbc3997c95b2725b2e";
+    sha256 = "d53aa0c31dc94d61fd30ea3f06c749e6f510f9ff0e78cb2765a9300f173d8626";
   };
 
   meta = with lib; {

pkgs/development/python-modules/pymbolic/default.nix

···
 
 buildPythonPackage rec {
   pname = "pymbolic";
-  version = "2020.1";
+  version = "2021.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "ca029399f9480f6d51fbac0349fddbb42d937620deb03befa0ba94ac08895e6b";
+    sha256 = "67d08ef95568408901e59f79591ba41fd3f2caaecb42b7497c38fc82fd60358c";
   };
 
   postConfigure = ''

pkgs/development/python-modules/pysyncthru/default.nix

···
 
 buildPythonPackage rec {
   pname = "pysyncthru";
-  version = "0.7.7";
+  version = "0.7.8";
 
   disabled = isPy27;
 
···
     owner = "nielstron";
     repo = "pysyncthru";
     rev = "release-${version}";
-    sha256 = "1449lbg9dx13p03v6fl2ap0xk5i5wrmy6amx1pl0rgz712p5jmq7";
+    sha256 = "17k9dhnya4304gqmkyvvf94jvikmnkf2lqairl3rfrl7w68jm3vp";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/scikit-build/default.nix

···
 
 buildPythonPackage rec {
   pname = "scikit-build";
-  version = "0.11.1";
+  version = "0.12.0";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0p4smkl2rbpl00m5va5qa8hp2hqb3284p2cs6k8zlmi4kgbdyh6s";
+    sha256 = "f851382c469bcd9a8c98b1878bcfdd13b68556279d2fd9a329be41956ae5a7fe";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/sendgrid/default.nix

···
 
 buildPythonPackage rec {
   pname = "sendgrid";
-  version = "6.8.0";
+  version = "6.8.1";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = "sendgrid-python";
     rev = version;
-    sha256 = "sha256-PtTsFwE6+6/HzyR721Y9+qaI7gwYtYwuY+wrZpoGY2Q=";
+    sha256 = "sha256-rK/GouOv5RMDsn5NrCEtIz5a9wO6YATlhsRuhFuHaXY=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/slack-sdk/default.nix

···
 
 buildPythonPackage rec {
   pname = "slack-sdk";
-  version = "3.9.1";
+  version = "3.10.0";
   disabled = pythonOlder "3.6";
 
   src = fetchFromGitHub {
     owner = "slackapi";
     repo = "python-slack-sdk";
     rev = "v${version}";
-    sha256 = "sha256-IskBFccMDG03BFkERRfL7TH1Ppq8Xr9qTxCEoUEqxtk=";
+    sha256 = "sha256-FOpUO9bXrEOgYGmRmAhHnovzBafu6D2ZSLcgw0+0uzs=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/somajo/default.nix

···
 
 buildPythonPackage rec {
   pname = "SoMaJo";
-  version = "2.1.4";
+  version = "2.1.5";
   disabled = !isPy3k;
 
   src = fetchFromGitHub {
     owner = "tsproisl";
     repo = pname;
     rev = "v${version}";
-    sha256 = "0clcndij4nd5ig7padvb9dj5hfxg6nymn9sf42bjr9ipjihcsbdq";
+    sha256 = "17v1vmbjwpxwql25vlbm7xsair7945ljmyaricxx8fd6fxvgn9rr";
   };
 
   propagatedBuildInputs = [ regex ];

pkgs/development/python-modules/sounddevice/default.nix

···
 
 buildPythonPackage rec {
   pname = "sounddevice";
-  version = "0.4.1";
+  version = "0.4.2";
   disabled = isPy27;
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "f21978921186c0c7183af032fab77b735d824f3e926d76adb3fd0912e289ce0b";
+    sha256 = "1c9b07cff59c837d258002ed806ee134ed367ef11042bd7d283d6ce407bf889c";
   };
 
   propagatedBuildInputs = [ cffi numpy portaudio ];

pkgs/development/python-modules/wurlitzer/default.nix

···
 
 buildPythonPackage rec {
   pname = "wurlitzer";
-  version = "2.1.0";
+  version = "2.1.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0144228960a992ef46e339e8aa560600bd34cd64e018bfebad88c0dd61bd8ba5";
+    sha256 = "5a3ea5a13a8aac2d808864087fec87a0518bf7d9776173ab06a6bb4ade9f4d27";
   };
 
   propagatedBuildInputs = lib.optionals isPy27 [ selectors2 ];

pkgs/development/tools/analysis/dotenv-linter/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "dotenv-linter";
-  version = "3.1.0";
+  version = "3.1.1";
 
   src = fetchFromGitHub {
     owner = "dotenv-linter";
     repo = "dotenv-linter";
     rev = "v${version}";
-    sha256 = "sha256-hhaMI2Z97aT/8FxxtWpn+o3BSo26iyBP+ucpO3x4AbQ=";
+    sha256 = "sha256-kBBn8Lgb3427K00Ag35Ei9oBD7L0Zp/lr0cAKqZpULo=";
   };
 
-  cargoSha256 = "sha256-F9Xyg8/qp0j0+jyd5EVe2idocubzu+Cj6yAwrHuabvM=";
+  cargoSha256 = "sha256-7Porqqh6lYeBCK2pAtbL9nxtORB9rqSyVdJDoy1/ZDo=";
 
   meta = with lib; {
     description = "Lightning-fast linter for .env files. Written in Rust";

pkgs/development/tools/bazelisk/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.BazeliskVersion=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.BazeliskVersion=${version}" ];
 
   meta = with lib; {
     description = "A user-friendly launcher for Bazel";

pkgs/development/tools/build-managers/bazel/buildtools/default.nix

···
 
   excludedPackages = [ "generatetables" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.buildVersion=${version} -X main.buildScmRevision=${src.rev}" ];
+  ldflags = [ "-s" "-w" "-X main.buildVersion=${version}" "-X main.buildScmRevision=${src.rev}" ];
 
   meta = with lib; {
     description = "Tools for working with Google's bazel buildtool. Includes buildifier, buildozer, and unused_deps";

pkgs/development/tools/build-managers/mage/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-X github.com/magefile/mage/mage.commitHash=v${version}"
     "-X github.com/magefile/mage/mage.gitTag=v${version}"
     "-X github.com/magefile/mage/mage.timestamp=1970-01-01T00:00:00Z"

pkgs/development/tools/buildpack/default.nix

···
 
   subPackages = [ "cmd/pack" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/buildpacks/pack.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/buildpacks/pack.Version=${version}" ];
 
   postInstall = ''
     installShellCompletion --bash --name pack.bash $(PACK_HOME=$PWD $out/bin/pack completion --shell bash)

pkgs/development/tools/butane/default.nix

···
 
   subPackages = [ "internal" ];
 
-  buildFlagsArray = ''
-    -ldflags=-X github.com/coreos/butane/internal/version.Raw=v${version}
-  '';
+  ldflags = [
+    "-X github.com/coreos/butane/internal/version.Raw=v${version}"
+  ];
 
   postInstall = ''
     mv $out/bin/{internal,butane}

pkgs/development/tools/cloud-nuke/default.nix

···
 
   vendorSha256 = "sha256-C9UGpm8JBLQpSFQkvib5Bmn3J88LxUNt4ELJXL4ZQ80=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.VERSION=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.VERSION=${version}" ];
 
   doCheck = false;
 

pkgs/development/tools/conftest/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-s"
     "-w"
     "-X github.com/open-policy-agent/conftest/internal/commands.version=${version}"

pkgs/development/tools/continuous-integration/buildkite-cli/default.nix

···
 
   subPackages = [ "cmd/bk" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.VERSION=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.VERSION=${version}" ];
 
   meta = with lib; {
     description = "A command line interface for Buildkite";

pkgs/development/tools/continuous-integration/fly/default.nix

···
 
   subPackages = [ "fly" ];
 
-  buildFlagsArray = ''
-    -ldflags=
-      -X github.com/concourse/concourse.Version=${version}
-  '';
+  ldflags = [
+    "-X github.com/concourse/concourse.Version=${version}"
+  ];
 
   postInstall = lib.optionalString (stdenv.hostPlatform == stdenv.buildPlatform) ''
     mkdir -p $out/share/{bash-completion/completions,zsh/site-functions}

pkgs/development/tools/cue/default.nix

···
 
   subPackages = [ "cmd/cue" ];
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X cuelang.org/go/cmd/cue/cmd.version=${version}"
+  ldflags = [
+    "-s" "-w" "-X cuelang.org/go/cmd/cue/cmd.version=${version}"
   ];
 
   meta = {

pkgs/development/tools/dive/default.nix

···
 
   buildInputs = lib.optionals stdenv.isLinux [ btrfs-progs gpgme lvm2 ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "A tool for exploring each layer in a docker image";

pkgs/development/tools/earthly/default.nix

···
 
   vendorSha256 = "sha256-gydhh/EMSuE/beo+A2CRDdDnQGT6DMjMwthylT339I4=";
 
-  buildFlagsArray = ''
-    -ldflags=
-      -s -w
-      -X main.Version=v${version}
-      -X main.DefaultBuildkitdImage=earthly/buildkitd:v${version}
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X main.Version=v${version}"
+    "-X main.DefaultBuildkitdImage=earthly/buildkitd:v${version}"
+  ];
 
   BUILDTAGS = "dfrunmount dfrunsecurity dfsecrets dfssh dfrunnetwork";
   preBuild = ''

pkgs/development/tools/fission/default.nix

···
 
   vendorSha256 = "sha256-1ujJuhK7pm/A1Dd+Wm9dtc65mx9pwLBWMWwEJnbja8s=";
 
-  buildFlagsArray = "-ldflags=-s -w -X info.Version=${version}";
+  ldflags = [ "-s" "-w" "-X info.Version=${version}" ];
 
   subPackages = [ "cmd/fission-cli" ];
 

pkgs/development/tools/github/bump/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [
-    "-ldflags=-X main.buildVersion=${version} -X main.buildCommit=${version} -X main.buildDate=1970-01-01"
+  ldflags = [
+    "-X main.buildVersion=${version}" "-X main.buildCommit=${version}" "-X main.buildDate=1970-01-01"
   ];
 
   meta = with lib; {
···
     maintainers = with maintainers; [ doronbehar ];
   };
 }
-

pkgs/development/tools/go-minimock/default.nix

···
     sha256 = "sha256-l+ngvmTb9yVgQYT+OeaVd0zz/xNZeXWrjMpVkMpbQIw=";
   };
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.version=${version}"
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}"
   ];
 
   vendorSha256 = "sha256-hn222ifKRYbASAHBJyMTCDwhykf2Jg9IqIUlK/GabJA=";

pkgs/development/tools/go-swagger/default.nix

···
 
   subPackages = [ "cmd/swagger" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/go-swagger/go-swagger/cmd/swagger/commands.Version=${version} -X github.com/go-swagger/go-swagger/cmd/swagger/commands.Commit=${src.rev}" ];
+  ldflags = [ "-s" "-w" "-X github.com/go-swagger/go-swagger/cmd/swagger/commands.Version=${version}" "-X github.com/go-swagger/go-swagger/cmd/swagger/commands.Commit=${src.rev}" ];
 
   meta = with lib; {
     description = "Golang implementation of Swagger 2.0, representation of your RESTful API";

pkgs/development/tools/go-task/default.nix

···
 
   subPackages = [ "cmd/task" ];
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.version=${version}"
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}"
   ];
 
   postInstall = ''

pkgs/development/tools/gomplate/default.nix

···
     rm net/net_test.go
   '';
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-s"
     "-w"
     "-X github.com/${owner}/${pname}/v3/version.Version=${rev}"

pkgs/development/tools/gosec/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.Version=${version} -X main.GitTag=${src.rev} -X main.BuildDate=unknown" ];
+  ldflags = [ "-s" "-w" "-X main.Version=${version}" "-X main.GitTag=${src.rev}" "-X main.BuildDate=unknown" ];
 
   meta = with lib; {
     homepage = "https://github.com/securego/gosec";
···
     platforms = platforms.linux ++ platforms.darwin;
   };
 }
-

pkgs/development/tools/gotestsum/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   subPackages = [ "." ];
 

pkgs/development/tools/hcloud/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/hetznercloud/cli/cli.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/hetznercloud/cli/cli.Version=${version}" ];
 
   postInstall = ''
     for shell in bash zsh; do

pkgs/development/tools/jsonnet-bundler/default.nix

···
 
   subPackages = [ "cmd/jb" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.Version=${version}" ];
 
   meta = with lib; {
     description = "A jsonnet package manager";

pkgs/development/tools/kubepug/default.nix

···
 
   vendorSha256 = "0jzry4znq4kcl6i9jcawilyjm8av1zxbml6nlr96v8x47ijxav5j";
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X=github.com/rikatz/kubepug/version.Version=${src.rev}
-  '';
+  ldflags = [
+    "-s" "-w" "-X=github.com/rikatz/kubepug/version.Version=${src.rev}"
+  ];
 
   subPackages = [ "cmd/kubepug.go" ];
 

pkgs/development/tools/kustomize/default.nix

···
   # rev is the commit of the tag, mainly for kustomize version command output
   rev = "9e8e7a7fe99ec9fbf801463e8607928322fc5245";
 
-  buildFlagsArray = let t = "sigs.k8s.io/kustomize/api/provenance"; in
-    ''
-      -ldflags=
-        -s -X ${t}.version=${version}
-           -X ${t}.gitCommit=${rev}
-    '';
+  ldflags = let t = "sigs.k8s.io/kustomize/api/provenance"; in
+    [
+      "-s"
+      "-X ${t}.version=${version}"
+      "-X ${t}.gitCommit=${rev}"
+    ];
 
   src = fetchFromGitHub {
     owner = "kubernetes-sigs";

pkgs/development/tools/lazygit/default.nix

···
   vendorSha256 = null;
   subPackages = [ "." ];
 
-  buildFlagsArray = [ "-ldflags=-X main.version=${version} -X main.buildSource=nix" ];
+  ldflags = [ "-X main.version=${version}" "-X main.buildSource=nix" ];
 
   meta = with lib; {
     description = "Simple terminal UI for git commands";

pkgs/development/tools/misc/circleci-cli/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/CircleCI-Public/circleci-cli/version.Version=${version} -X github.com/CircleCI-Public/circleci-cli/version.Commit=${src.rev} -X github.com/CircleCI-Public/circleci-cli/version.packageManager=nix" ];
+  ldflags = [ "-s" "-w" "-X github.com/CircleCI-Public/circleci-cli/version.Version=${version}" "-X github.com/CircleCI-Public/circleci-cli/version.Commit=${src.rev}" "-X github.com/CircleCI-Public/circleci-cli/version.packageManager=nix" ];
 
   preBuild = ''
     substituteInPlace data/data.go \

pkgs/development/tools/misc/k2tf/default.nix

···
 
   vendorSha256 = "1c2mwhrj0xapc661z1nb6am4qq3rd1pvbvjaxikjyx95n0gs8gjk";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version} -X main.commit=v${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" "-X main.commit=v${version}" ];
 
   meta = with lib; {
     description = "Kubernetes YAML to Terraform HCL converter";

pkgs/development/tools/misc/mkcert/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X main.Version=v${version}
-  '';
+  ldflags = [
+    "-s" "-w" "-X main.Version=v${version}"
+  ];
 
   meta = with lib; {
     homepage = "https://github.com/FiloSottile/mkcert";

pkgs/development/tools/misc/reviewdog/default.nix

···
 
   subPackages = [ "cmd/reviewdog" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/reviewdog/reviewdog/commands.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/reviewdog/reviewdog/commands.Version=${version}" ];
 
   meta = with lib; {
     description = "Automated code review tool integrated with any code analysis tools regardless of programming language";

pkgs/development/tools/misc/terracognita/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/cycloidio/terracognita/cmd.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/cycloidio/terracognita/cmd.Version=${version}" ];
 
   meta = with lib; {
     description = "Reads from existing Cloud Providers (reverse Terraform) and generates your infrastructure as code on Terraform configuration";

pkgs/development/tools/renderizer/default.nix

···
     sha256 = "sha256-jl98LuEsGN40L9IfybJhLnbzoYP/XpwFVQnjrlmDL9A=";
   };
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.version=${version} -X main.commitHash=${src.rev} -X main.date=19700101T000000"
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}" "-X main.commitHash=${src.rev}" "-X main.date=19700101T000000"
   ];
 
   vendorSha256 = null;

pkgs/development/tools/skaffold/default.nix

···
 
   subPackages = ["cmd/skaffold"];
 
-  buildFlagsArray = let t = "github.com/GoogleContainerTools/skaffold/pkg/skaffold"; in  ''
-    -ldflags=
-      -s -w
-      -X ${t}/version.version=v${version}
-      -X ${t}/version.gitCommit=${src.rev}
-      -X ${t}/version.buildDate=unknown
-  '';
+  ldflags = let t = "github.com/GoogleContainerTools/skaffold/pkg/skaffold"; in [
+    "-s" "-w"
+    "-X ${t}/version.version=v${version}"
+    "-X ${t}/version.gitCommit=${src.rev}"
+    "-X ${t}/version.buildDate=unknown"
+  ];
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/development/tools/tf2pulumi/default.nix

···
 
   vendorSha256 = "sha256-wsgNrDnFXbpanEULEjf6OxOeMYmWzjE7vpVUB/UFNp8=";
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X=github.com/pulumi/tf2pulumi/version.Version=${src.rev}
-  '';
+  ldflags = [
+    "-s" "-w" "-X=github.com/pulumi/tf2pulumi/version.Version=${src.rev}"
+  ];
 
   subPackages = [ "." ];
 

pkgs/development/tools/yj/default.nix

···
 
   vendorSha256 = "0y0n9fsb85qlpf9slwsxzarmfi98asa4x04qp2r8pagl28l0i8wv";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.Version=${version}" ];
 
   meta = with lib; {
     description = "Convert YAML <=> TOML <=> JSON <=> HCL";

pkgs/development/web/flyctl/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/superfly/flyctl/flyctl.Version=${version} -X github.com/superfly/flyctl/flyctl.Commit=${src.rev} -X github.com/superfly/flyctl/flyctl.BuildDate=1970-01-01T00:00:00+0000 -X github.com/superfly/flyctl/flyctl.Environment=production" ];
+  ldflags = [ "-s" "-w" "-X github.com/superfly/flyctl/flyctl.Version=${version}" "-X github.com/superfly/flyctl/flyctl.Commit=${src.rev}" "-X github.com/superfly/flyctl/flyctl.BuildDate=1970-01-01T00:00:00+0000" "-X github.com/superfly/flyctl/flyctl.Environment=production" ];
 
   meta = with lib; {
     description = "Command line tools for fly.io services";

pkgs/development/web/minify/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.Version=${version}" ];
 
   meta = with lib; {
     description = "Minifiers for web formats";

pkgs/os-specific/darwin/smimesign/default.nix

···
 
   vendorSha256 = "1cldxykm9qj5rvyfafam45y5xj4f19700s2f9w7ndhxgfp9vahvz";
 
-  buildFlagsArray = "-ldflags=-X main.versionString=v${version}";
+  ldflags = [ "-X main.versionString=v${version}" ];
 
   meta = with lib; {
     description = "An S/MIME signing utility for macOS and Windows that is compatible with Git";

pkgs/servers/blockbook/default.nix

···
 
   buildInputs = [ bzip2 lz4 rocksdb snappy zeromq zlib ];
 
-  buildFlagsArray = ''
-    -ldflags=
-       -X github.com/trezor/blockbook/common.version=${version}
-       -X github.com/trezor/blockbook/common.gitcommit=${commit}
-       -X github.com/trezor/blockbook/common.buildDate=unknown
-  '';
+  ldflags = [
+    "-X github.com/trezor/blockbook/common.version=${version}"
+    "-X github.com/trezor/blockbook/common.gitcommit=${commit}"
+    "-X github.com/trezor/blockbook/common.buildDate=unknown"
+  ];
 
   preBuild = lib.optionalString stdenv.isDarwin ''
     ulimit -n 8192

pkgs/servers/dex/default.nix

···
     "cmd/dex"
   ];
 
-  buildFlagsArray = [
-    "-ldflags=-w -s -X github.com/dexidp/dex/version.Version=${src.rev}"
+  ldflags = [
+    "-w" "-s" "-X github.com/dexidp/dex/version.Version=${src.rev}"
   ];
 
   postInstall = ''

pkgs/servers/hasura/cli.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [''-ldflags=
-    -X github.com/hasura/graphql-engine/cli/version.BuildVersion=${version}
-    -s
-    -w
-  ''];
+  ldflags = [
+    "-X github.com/hasura/graphql-engine/cli/version.BuildVersion=${version}"
+    "-s"
+    "-w"
+  ];
 
   postInstall = ''
     mkdir -p $out/share/{bash-completion/completions,zsh/site-functions}

pkgs/servers/http/pomerium/default.nix

···
     "cmd/pomerium-cli"
   ];
 
-  buildFlagsArray = let
+  ldflags = let
     # Set a variety of useful meta variables for stamping the build with.
     setVars = {
       Version = "v${version}";
···
     };
     varFlags = concatStringsSep " " (mapAttrsToList (name: value: "-X github.com/pomerium/pomerium/internal/version.${name}=${value}") setVars);
   in [
-    "-ldflags=${varFlags}"
+    "${varFlags}"
   ];
 
   nativeBuildInputs = [

pkgs/servers/keycloak/default.nix

···
 in
 stdenv.mkDerivation rec {
   pname   = "keycloak";
-  version = "15.0.1";
+  version = "15.0.2";
 
   src = fetchzip {
     url    = "https://github.com/keycloak/keycloak/releases/download/${version}/keycloak-${version}.zip";
-    sha256 = "sha256-levWTIO64or3jPejiJzyU0YQqMap5bK6w1EIMmfthD8=";
+    sha256 = "sha256-GlnSsvAYBjRTtabMVrpWUH0EWEdLIe6ud+HIXJqTsqY=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/servers/maddy/default.nix

···
 
   vendorSha256 = "sha256-bxKEQaOubjRfLX+dMxVDzLOUInHykUdy9X8wvFE6Va4=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/foxcpp/maddy.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/foxcpp/maddy.Version=${version}" ];
 
   subPackages = [ "cmd/maddy" "cmd/maddyctl" ];
 

pkgs/servers/matrix-corporal/default.nix

···
     sha256 = "sha256-u1ppwy+t2ewAH0/+R6e0Ja5A3PQG/lUy2b6kgcMVj8E=";
   };
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.GitCommit=${version} -X main.GitBranch=${version} -X main.GitState=nixpkgs -X main.GitSummary=${version} -X main.Version=${version}"
+  ldflags = [
+    "-s" "-w" "-X main.GitCommit=${version}" "-X main.GitBranch=${version}" "-X main.GitState=nixpkgs" "-X main.GitSummary=${version}" "-X main.Version=${version}"
   ];
 
   vendorSha256 = "sha256-YmUiGsg2UZfV6SHEPwnbmWPhGQ5teV+we9MBaJyrJr4=";

pkgs/servers/miniflux/default.nix

···
     go test $(go list ./... | grep -v client)
   ''; # skip client tests as they require network access
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X miniflux.app/version.Version=${version}
-  '';
+  ldflags = [
+    "-s" "-w" "-X miniflux.app/version.Version=${version}"
+  ];
 
   postInstall = ''
     mv $out/bin/miniflux.app $out/bin/miniflux

pkgs/servers/minio/default.nix

···
 in
 buildGoModule rec {
   pname = "minio";
-  version = "2021-08-20T18-32-01Z";
+  version = "2021-08-25T00-41-18Z";
 
   src = fetchFromGitHub {
     owner = "minio";
     repo = "minio";
     rev = "RELEASE.${version}";
-    sha256 = "sha256-Ij0QExsCtEtVOI1Zd0YC46y2ACp/mdE07VNIBRVi4/8=";
+    sha256 = "sha256-gwP1q+5vjgCnrnvWTxPC66fugVrilC1WbLk3SP4NXqA=";
   };
 
-  vendorSha256 = "sha256-Nr2zpIgqinUvxV9xW8UuZRnrIvCe3pWTe3qE2UtUyzc=";
+  vendorSha256 = "sha256-JcgMJ6xz3h3YJ1zoSJLCWdWGmd12MPvxcIPX1ZbhpaM=";
 
   doCheck = false;
 

pkgs/servers/misc/gobgpd/default.nix

···
     export CGO_ENABLED=0
   '';
 
-  buildFlagsArray = ''
-    -ldflags=
-    -s -w -extldflags '-static'
-  '';
+  ldflags = [
+    "-s" "-w" "-extldflags '-static'"
+  ];
 
   subPackages = [ "cmd/gobgpd" ];
 

pkgs/servers/monitoring/alertmanager-irc-relay/default.nix

···
 
   vendorSha256 = "sha256-VLG15IXS/fXFMTCJKEqGW6qZ9aOLPhazidVsOywG+w4=";
 
-  buildFlagsArray = [ "-ldflags=-s -w" ];
+  ldflags = [ "-s" "-w" ];
 
   meta = with lib; {
     description = "Alertmanager IRC Relay is a bot relaying Prometheus alerts to IRC";

pkgs/servers/monitoring/cadvisor/default.nix

···
 
   vendorSha256 = "sha256-FMO+wNmjFFD9+/9mhNcyZftk8ryhwFXDZeEy/h5EMWc=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/google/cadvisor/version.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/google/cadvisor/version.Version=${version}" ];
 
   postInstall = ''
     mv $out/bin/{cmd,cadvisor}

pkgs/servers/monitoring/do-agent/default.nix

···
     sha256 = "sha256-boEgCC3uWvJvb6VKpNhh6vHCfeE7oun5oneI2ITKh9g=";
   };
 
-  buildFlagsArray = ''
-    -ldflags=
-      -X main.version=${version}
-  '';
+  ldflags = [
+    "-X main.version=${version}"
+  ];
 
   vendorSha256 = null;
 

pkgs/servers/monitoring/grafana/default.nix

···
     rm -r scripts/go
   '';
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X main.version=${version}
-  '';
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}"
+  ];
 
   postInstall = ''
     tar -xvf $srcStatic

pkgs/servers/monitoring/mackerel-agent/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = ''
-    -ldflags=
-    -X=main.version=${version}
-    -X=main.gitcommit=v${version}
-  '';
+  ldflags = [
+    "-X=main.version=${version}"
+    "-X=main.gitcommit=v${version}"
+  ];
 
   postInstall = ''
     wrapProgram $out/bin/mackerel-agent \

pkgs/servers/monitoring/mtail/default.nix

···
     go generate -x ./internal/vm/
   '';
 
-  buildFlagsArray = [
-    "-ldflags=-X main.Version=${version}"
+  ldflags = [
+    "-X main.Version=${version}"
   ];
 
   meta = with lib; {

pkgs/servers/monitoring/prometheus/artifactory-exporter.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = ''
-     -ldflags=
-      -s -w
-      -X github.com/prometheus/common/version.Version=${version}
-      -X github.com/prometheus/common/version.Revision=${rev}
-      -X github.com/prometheus/common/version.Branch=master
-      -X github.com/prometheus/common/version.BuildDate=19700101-00:00:00
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X github.com/prometheus/common/version.Version=${version}"
+    "-X github.com/prometheus/common/version.Revision=${rev}"
+    "-X github.com/prometheus/common/version.Branch=master"
+    "-X github.com/prometheus/common/version.BuildDate=19700101-00:00:00"
+  ];
 
   passthru.tests = { inherit (nixosTests.prometheus-exporters) artifactory; };
 

pkgs/servers/monitoring/prometheus/mysqld-exporter.nix

···
 
   vendorSha256 = "19785rfzlx8h0h8vmg0ghd40h3p4y6ikhgf8rd2qfj5f6qxfhrgv";
 
-  buildFlagsArray = let t = "github.com/prometheus/common/version"; in ''
-    -ldflags=
-        -s -w -X ${t}.Version=${version}
-        -X ${t}.Revision=${rev}
-        -X ${t}.Branch=unknown
-        -X ${t}.BuildUser=nix@nixpkgs
-        -X ${t}.BuildDate=unknown
-  '';
+  ldflags = let t = "github.com/prometheus/common/version"; in [
+    "-s" "-w"
+    "-X ${t}.Version=${version}"
+    "-X ${t}.Revision=${rev}"
+    "-X ${t}.Branch=unknown"
+    "-X ${t}.BuildUser=nix@nixpkgs"
+    "-X ${t}.BuildDate=unknown"
+  ];
 
   # skips tests with external dependencies, e.g. on mysqld
   checkFlags = [ "-short" ];

pkgs/servers/monitoring/prometheus/promscale.nix

···
 
   vendorSha256 = "sha256-DFDTYT7UK1cYwGeCgeQcJmrCoqGPDzicusRPPUbH0Gs=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/timescale/promscale/pkg/version.Version=${version} -X github.com/timescale/promscale/pkg/version.CommitHash=${src.rev}" ];
+  ldflags = [ "-s" "-w" "-X github.com/timescale/promscale/pkg/version.Version=${version}" "-X github.com/timescale/promscale/pkg/version.CommitHash=${src.rev}" ];
 
   doCheck = false; # Requires access to a docker daemon
   doInstallCheck = true;

pkgs/servers/monitoring/prometheus/redis-exporter.nix

···
 
   vendorSha256 = "11237959ikd7l5glkhfz0g55mbld2hq985b5crwb9bnimaly5lga";
 
-  buildFlagsArray = ''
-    -ldflags=
-       -X main.BuildVersion=${version}
-       -X main.BuildCommitSha=unknown
-       -X main.BuildDate=unknown
-  '';
+  ldflags = [
+    "-X main.BuildVersion=${version}"
+    "-X main.BuildCommitSha=unknown"
+    "-X main.BuildDate=unknown"
+  ];
 
   # needs a redis server
   doCheck = false;

pkgs/servers/monitoring/prometheus/smokeping-prober.nix

···
   pname = "smokeping_prober";
   version = "${baseVersion}-g${commit}";
 
-  buildFlagsArray = let
+  ldflags = let
     setVars = {
       Version = baseVersion;
       Revision = commit;
···
     };
     varFlags = lib.concatStringsSep " " (lib.mapAttrsToList (name: value: "-X github.com/prometheus/common/version.${name}=${value}") setVars);
   in [
-    "-ldflags=${varFlags} -s -w"
+    "${varFlags}" "-s" "-w"
   ];
 
   src = fetchFromGitHub {

pkgs/servers/monitoring/sensu-go/default.nix

···
 
   doCheck = false;
 
-      buildFlagsArray = let
+      ldflags = let
         versionPkg = "github.com/sensu/sensu-go/version";
-      in ''
-        -ldflags=
-          -X ${versionPkg}.Version=${version}
-          -X ${versionPkg}.BuildSHA=${shortRev}
-      '';
+      in [
+        "-X ${versionPkg}.Version=${version}"
+        "-X ${versionPkg}.BuildSHA=${shortRev}"
+      ];
 
       meta = {
         homepage = "https://sensu.io";

pkgs/servers/monitoring/thanos/default.nix

···
 
   subPackages = "cmd/thanos";
 
-  buildFlagsArray = let t = "github.com/prometheus/common/version"; in ''
-    -ldflags=
-       -X ${t}.Version=${version}
-       -X ${t}.Revision=unknown
-       -X ${t}.Branch=unknown
-       -X ${t}.BuildUser=nix@nixpkgs
-       -X ${t}.BuildDate=unknown
-  '';
+  ldflags = let t = "github.com/prometheus/common/version"; in [
+    "-X ${t}.Version=${version}"
+    "-X ${t}.Revision=unknown"
+    "-X ${t}.Branch=unknown"
+    "-X ${t}.BuildUser=nix@nixpkgs"
+    "-X ${t}.BuildDate=unknown"
+  ];
 
   meta = with lib; {
     description = "Highly available Prometheus setup with long term storage capabilities";

pkgs/servers/monitoring/unifi-poller/default.nix

···
 
   vendorSha256 = "sha256-LOBkdyfsw7ua6TsLglO5jdR9NWo5Df8rnQ8MH+eIz4g=";
 
-  buildFlagsArray = ''
-    -ldflags=-w -s
-      -X github.com/prometheus/common/version.Branch=master
-      -X github.com/prometheus/common/version.BuildDate=unknown
-      -X github.com/prometheus/common/version.Revision=${src.rev}
-      -X github.com/prometheus/common/version.Version=${version}-0
-  '';
+  ldflags = [
+    "-w" "-s"
+    "-X github.com/prometheus/common/version.Branch=master"
+    "-X github.com/prometheus/common/version.BuildDate=unknown"
+    "-X github.com/prometheus/common/version.Revision=${src.rev}"
+    "-X github.com/prometheus/common/version.Version=${version}-0"
+  ];
 
   meta = with lib; {
     description = "Collect ALL UniFi Controller, Site, Device & Client Data - Export to InfluxDB or Prometheus";

pkgs/servers/nosql/influxdb/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   excludedPackages = "test";
 

pkgs/servers/nosql/victoriametrics/default.nix

···
 
   vendorSha256 = null;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/VictoriaMetrics/VictoriaMetrics/lib/buildinfo.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/VictoriaMetrics/VictoriaMetrics/lib/buildinfo.Version=${version}" ];
 
   passthru.tests = { inherit (nixosTests) victoriametrics; };
 

pkgs/servers/oauth2-proxy/default.nix

···
   vendorSha256 = "sha256-kclpoZ33JOciP2IUCQZB5idA7rgbWxPPFNwZU+pEJFU=";
 
   # Taken from https://github.com/oauth2-proxy/oauth2-proxy/blob/master/Makefile
-  buildFlagsArray = ("-ldflags=-X main.VERSION=${version}");
+  ldflags = [ "-X main.VERSION=${version}" ];
 
   meta = with lib; {
     description = "A reverse proxy that provides authentication with Google, Github, or other providers";

pkgs/servers/pg_featureserv/default.nix

···
 
   vendorSha256 = "1jqrkx850ghmpnfjhqky93r8fq7q63m5ivs0lzljzbvn7ya75f2r";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/CrunchyData/pg_featureserv/conf.setVersion=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/CrunchyData/pg_featureserv/conf.setVersion=${version}" ];
 
   meta = with lib; {
     description = "Lightweight RESTful Geospatial Feature Server for PostGIS in Go";

pkgs/servers/pg_tileserv/default.nix

···
 
   vendorSha256 = "sha256-qdlh9H039GwKTxOhx+dzyUHkzJbaOeuguKnBOyAPe/E=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.programVersion=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.programVersion=${version}" ];
 
   doCheck = false;
 

pkgs/servers/reproxy/default.nix

···
 
   vendorSha256 = null;
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.revision=${version}"
+  ldflags = [
+    "-s" "-w" "-X main.revision=${version}"
   ];
 
   installPhase = ''

pkgs/servers/rtsp-simple-server/default.nix

···
   # Tests need docker
   doCheck = false;
 
-  buildFlagsArray = [
-    # In the future, we might need to switch to `main.Version`, considering:
-    # https://github.com/aler9/rtsp-simple-server/issues/503
-    "-ldflags=-X github.com/aler9/rtsp-simple-server/internal/core.version=v${version}"
+  # In the future, we might need to switch to `main.Version`, considering:
+  # https://github.com/aler9/rtsp-simple-server/issues/503
+  ldflags = [
+    "-X github.com/aler9/rtsp-simple-server/internal/core.version=v${version}"
   ];
 
   meta = with lib; {

pkgs/shells/elvish/default.nix

···
 
   excludedPackages = [ "website" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/elves/elvish/pkg/buildinfo.Version==${version} -X github.com/elves/elvish/pkg/buildinfo.Reproducible=true" ];
+  ldflags = [ "-s" "-w" "-X github.com/elves/elvish/pkg/buildinfo.Version==${version}" "-X github.com/elves/elvish/pkg/buildinfo.Reproducible=true" ];
 
   src = fetchFromGitHub {
     owner = "elves";

pkgs/shells/zsh/antibody/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "The fastest shell plugin manager";

pkgs/tools/admin/aws-vault/default.nix

···
   subPackages = [ "." ];
 
   # set the version. see: aws-vault's Makefile
-  buildFlagsArray = ''
-    -ldflags=
-    -X main.Version=v${version}
-  '';
+  ldflags = [
+    "-X main.Version=v${version}"
+  ];
 
   doInstallCheck = true;
 

pkgs/tools/admin/awsweeper/default.nix

···
 
   vendorSha256 = "sha256-1u1mzANLlWduAQF1GUX7BJSyYlSZwNQISqKwbyRlGog=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/jckuester/awsweeper/internal.version=${version} -X github.com/jckuester/awsweeper/internal.commit=${src.rev} -X github.com/jckuester/awsweeper/internal.date=unknown" ];
+  ldflags = [ "-s" "-w" "-X github.com/jckuester/awsweeper/internal.version=${version}" "-X github.com/jckuester/awsweeper/internal.commit=${src.rev}" "-X github.com/jckuester/awsweeper/internal.date=unknown" ];
 
   doCheck = false;
 

pkgs/tools/admin/chamber/default.nix

···
 
   vendorSha256 = "sha256-XpLLolxWu9aMp1cyG4dUQk4YtknbIRMmBUdSeyY4PNk=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.Version=v${version}" ];
+  ldflags = [ "-s" "-w" "-X main.Version=v${version}" ];
 
   meta = with lib; {
     description =

pkgs/tools/admin/credhub-cli/default.nix

···
 
   vendorSha256 = null;
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-s"
     "-w"
     "-X code.cloudfoundry.org/credhub-cli/version.Version=${version}"

pkgs/tools/admin/fioctl/default.nix

···
 
   runVend = true;
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X github.com/foundriesio/fioctl/subcommands/version.Commit=${src.rev}
-  '';
+  ldflags = [
+    "-s" "-w" "-X github.com/foundriesio/fioctl/subcommands/version.Commit=${src.rev}"
+  ];
 
   meta = with lib; {
     description = "A simple CLI to manage your Foundries Factory ";

pkgs/tools/admin/iamy/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [''-ldflags=
-    -X main.Version=v${version} -s -w
-  ''];
+  ldflags = [
+    "-X main.Version=v${version}" "-s" "-w"
+  ];
 
   meta = with lib; {
     description = "A cli tool for importing and exporting AWS IAM configuration to YAML files";

pkgs/tools/admin/lego/default.nix

···
 
   subPackages = [ "cmd/lego" ];
 
-  buildFlagsArray = [
-    "-ldflags=-X main.version=${version}"
+  ldflags = [
+    "-X main.version=${version}"
   ];
 
   meta = with lib; {

pkgs/tools/admin/ssmsh/default.nix

···
 
   doCheck = true;
 
-  buildFlagsArray = [ "-ldflags=-w -s -X main.Version=${version}" ];
+  ldflags = [ "-w" "-s" "-X main.Version=${version}" ];
 
   meta = with lib; {
     homepage = "https://github.com/bwhaley/ssmsh";

pkgs/tools/backup/kopia/default.nix

···
 
   subPackages = [ "." ];
 
-  buildFlagsArray = ''
-    -ldflags=
-       -X github.com/kopia/kopia/repo.BuildVersion=${version}
-       -X github.com/kopia/kopia/repo.BuildInfo=${src.rev}
-  '';
+  ldflags = [
+    "-X github.com/kopia/kopia/repo.BuildVersion=${version}"
+    "-X github.com/kopia/kopia/repo.BuildInfo=${src.rev}"
+  ];
 
   meta = with lib; {
     homepage = "https://kopia.io";

pkgs/tools/filesystems/gocryptfs/default.nix

···
 
   propagatedBuildInputs = [ libfido2 ];
 
-  buildFlagsArray = ''
-    -ldflags=
-      -X main.GitVersion=${version}
-      -X main.GitVersionFuse=[vendored]
-      -X main.BuildDate=unknown
-  '';
+  ldflags = [
+    "-X main.GitVersion=${version}"
+    "-X main.GitVersionFuse=[vendored]"
+    "-X main.BuildDate=unknown"
+  ];
 
   subPackages = [ "." "gocryptfs-xray" "contrib/statfs" ];
 

pkgs/tools/misc/chezmoi/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.version=${version} -X main.builtBy=nixpkgs"
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}" "-X main.builtBy=nixpkgs"
   ];
 
   nativeBuildInputs = [ installShellFiles ];

pkgs/tools/misc/duf/default.nix

···
 
   vendorSha256 = "153z0ccd556c0wpnxgyjq7m0c4y2z6fxsqq2p77kly9nr8cpzdb9";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X=main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X=main.Version=${version}" ];
 
   meta = with lib; {
     homepage = "https://github.com/muesli/duf/";

pkgs/tools/misc/goreleaser/default.nix

···
 
   vendorSha256 = "sha256-7I/955dPHV8Rkp6VevkebkZaNtSlbzIsGc8qFjtcMXk=";
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-s"
     "-w"
     "-X main.version=${version}"

pkgs/tools/misc/gotify-cli/default.nix

···
     mv $out/bin/cli $out/bin/gotify
   '';
 
-  buildFlagsArray = [
-    "-ldflags=-X main.Version=${version} -X main.Commit=${version} -X main.BuildDate=1970-01-01"
+  ldflags = [
+    "-X main.Version=${version}" "-X main.Commit=${version}" "-X main.BuildDate=1970-01-01"
   ];
 
   meta = with lib; {

pkgs/tools/misc/lf/default.nix

···
 
   nativeBuildInputs = [ installShellFiles ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.gVersion=r${version}" ];
+  ldflags = [ "-s" "-w" "-X main.gVersion=r${version}" ];
 
   postInstall = ''
     install -D --mode=444 lf.desktop $out/share/applications/lf.desktop

pkgs/tools/misc/microplane/default.nix

···
 
   vendorSha256 = "sha256-PqSjSFTVrIsQ065blIxZ9H/ARku6BEcnjboH+0K0G14=";
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X main.version=${version}
-  '';
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}"
+  ];
 
   postInstall = ''
     ln -s $out/bin/microplane $out/bin/mp

pkgs/tools/misc/pgcenter/default.nix

···
 
   subPackages = [ "cmd" ];
 
-  buildFlagsArray = [ "-ldflags=-w -s -X main.gitTag=${src.rev} -X main.gitCommit=${src.rev} -X main.gitBranch=master" ];
+  ldflags = [ "-w" "-s" "-X main.gitTag=${src.rev}" "-X main.gitCommit=${src.rev}" "-X main.gitBranch=master" ];
 
   postInstall = ''
     mv $out/bin/cmd $out/bin/pgcenter

pkgs/tools/misc/pgmetrics/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     homepage = "https://pgmetrics.io/";

pkgs/tools/misc/pistol/default.nix

···
     installManPage pistol.1
   '';
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.Version=${version}" ];
 
   meta = with lib; {
     description = "General purpose file previewer designed for Ranger, Lf to make scope.sh redundant";

pkgs/tools/misc/tfk8s/default.nix

···
   vendorSha256 = "sha256-eLPmghs05pMMtys97Ja7YGdVMZmMmiaFeMwzaWNxW0I=";
   runVend = true;
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-s"
     "-w"
     "-X main.toolVersion=${tag}"

pkgs/tools/misc/vsh/default.nix

···
   vendorSha256 = null;
 
   # make sure version gets set at compile time
-  buildFlagsArray = [ "-ldflags=-s -w -X main.vshVersion=v${version}" ];
+  ldflags = [ "-s" "-w" "-X main.vshVersion=v${version}" ];
 
   meta = with lib; {
     description = "HashiCorp Vault interactive shell";

pkgs/tools/networking/cassowary/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     homepage = "https://github.com/rogerwelin/cassowary";

pkgs/tools/networking/chisel/default.nix

···
 
   vendorSha256 = "sha256-GzsQ6LXxe9UQc13XbsYFOWPe0EzlyHechchKc6xDkAc=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/jpillora/chisel/share.BuildVersion=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/jpillora/chisel/share.BuildVersion=${version}" ];
 
   # tests require access to the network
   doCheck = false;

pkgs/tools/networking/clash/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [
-    "-ldflags="
+  ldflags = [
     "-X github.com/Dreamacro/clash/constant.Version=${version}"
   ];
 

pkgs/tools/networking/gobgp/default.nix

···
     export CGO_ENABLED=0
   '';
 
-  buildFlagsArray = ''
-    -ldflags=
-    -s -w -extldflags '-static'
-  '';
+  ldflags = [
+    "-s" "-w" "-extldflags '-static'"
+  ];
 
   subPackages = [ "cmd/gobgp" ];
 

pkgs/tools/networking/grpcui/default.nix

···
 
   subPackages = [ "cmd/grpcui" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "An interactive web UI for gRPC, along the lines of postman";

pkgs/tools/networking/grpcurl/default.nix

···
 
   vendorSha256 = "sha256-nl8vKVhUMSO20qCDyhNkU5cghNy8vIFqSBvLk59nbWg=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "Like cURL, but for gRPC: Command-line tool for interacting with gRPC servers";

pkgs/tools/networking/hp2p/default.nix

···
+{ lib, stdenv, fetchFromGitHub, mpi, python3Packages, autoconf, automake } :
+
+stdenv.mkDerivation rec {
+  pname = "hp2p";
+  version = "3.3";
+
+  src = fetchFromGitHub {
+    owner = "cea-hpc";
+    repo = "hp2p";
+    rev = version;
+    sha256 = "0zvlwb941rlp3vrf9yzv7njgpj3mh4671ch7qvxfa4hq2ivd52br";
+  };
+
+  patches = [ ./python3.patch ];
+  enableParallelBuilding = true;
+  nativeBuildInputs = [ autoconf automake python3Packages.wrapPython ];
+  buildInputs = [ mpi ] ++ (with python3Packages; [ python numpy matplotlib plotly mpldatacursor ]) ;
+  pythonPath = (with python3Packages; [ numpy matplotlib plotly mpldatacursor ]) ;
+
+  preConfigure = ''
+    patchShebangs autogen.sh
+    ./autogen.sh
+    export CC=mpicc
+    export CXX=mpic++
+  '';
+
+  postInstall = ''
+    wrapPythonPrograms
+  '';
+
+  meta = with lib; {
+    description = "A MPI based benchmark for network diagnostics";
+    homepage = "https://github.com/cea-hpc/hp2p";
+    platforms = platforms.unix;
+    license = licenses.cecill-c;
+    maintainers = [ maintainers.bzizou ];
+  };
+}

pkgs/tools/networking/hp2p/python3.patch

···
+diff -u -r source.orig/src/vizhp2p source/src/vizhp2p
+--- source.orig/src/vizhp2p	1970-01-01 01:00:01.000000000 +0100
++++ source/src/vizhp2p	2021-08-24 10:41:42.926881770 +0200
+@@ -94,25 +94,25 @@
+             with open(hostfile) as fd:
+                 for line in fd:
+                     if line.startswith(motif_rank):
+-                        print line
++                        print(line)
+                         c,v = line[len(motif_rank)+1:-1].split(separator)
+                         nodes[c] = v
+                         
+         # display k worst nodes indices
+-        print "\nTop %d bad mean:" % k
++        print("\nTop %d bad mean:" % k)
+         mean_order = np.argsort(a_mean)
+-        print [nodes[str(c)] for c in mean_order[:k]]
++        print([nodes[str(c)] for c in mean_order[:k]])
+         mean_st = "Top nodes with bad mean:\n"
+         for i in range(0, k, hostname_per_line):
+             mean_st += repr([nodes[str(c)] for c 
+                              in mean_order[i:i + hostname_per_line]]) + "\n"
+ 
+-        print "Top %d bad std:" % k
+-        print [nodes[str(c)] for c in np.argsort(a_std)[-k:][::-1]]
++        print("Top %d bad std:" % k)
++        print([nodes[str(c)] for c in np.argsort(a_std)[-k:][::-1]])
+ 
+-        print "Top %d bad mean/std:" % k
++        print("Top %d bad mean/std:" % k)
+         pen_order = np.argsort(a_mean / a_std)
+-        print [nodes[str(c)] for c in pen_order[:k]]
++        print([nodes[str(c)] for c in pen_order[:k]])
+         pen_st = "Top nodes with bad mean/std:\n"
+         for i in range(0, k, hostname_per_line):
+             pen_st += repr([nodes[str(c)] for c 
+@@ -293,9 +293,9 @@
+ # and 'p' (snapshot) 
+ def onrefresh(event):
+     if event.key == 'r':
+-        print "refreshing...",
++        print("refreshing...", end=' ')
+         loop()
+-        print "ok"
++        print("ok")
+     elif event.key == 'q':
+         exit()
+     elif event.key == 'p':
+@@ -303,9 +303,9 @@
+         fig1.savefig(snapfile)
+         snapfile = outputname + "_snapshot_time.png"
+         fig2.savefig(snapfile)
+-        print 'snapshot saved (%s)' % snapfile
++        print('snapshot saved (%s)' % snapfile)
+     else:
+-        print "The answer to %s is 42." % event.key
++        print("The answer to %s is 42." % event.key)
+ 
+ 
+ if __name__ == "__main__":
+@@ -356,11 +356,11 @@
+         countfile = outputname + ".count.bin"
+ 
+     print("visu_hp2p configuration:")
+-    print("   DATAFILE            : %s"%resfile)
+-    print("   BIN_TIMER_FILE      : %s"%resfile_time)
+-    print("   HOSTFILE            : %s"%hostfile)
+-    print("   Bad nodes to display: %d"%k)
+-    print("   GUI resolution      : %s"%resolution)
++    print(("   DATAFILE            : %s"%resfile))
++    print(("   BIN_TIMER_FILE      : %s"%resfile_time))
++    print(("   HOSTFILE            : %s"%hostfile))
++    print(("   Bad nodes to display: %d"%k))
++    print(("   GUI resolution      : %s"%resolution))
+ 
+     hostname_per_line = 4 # for GUI layout
+     refresh_in_sec = 60
+@@ -377,7 +377,7 @@
+     # wait for resfile
+     while not os.path.exists(resfile) :
+         time.sleep(5)
+-        print "Waiting for input files..."
++        print("Waiting for input files...")
+ 
+     # add callback on key press event
+     cid1 = fig1.canvas.mpl_connect('key_press_event', onrefresh)
+Only in source/src: vizhp2p.bak
+diff -u -r source.orig/src/vizhp2p_html source/src/vizhp2p_html
+--- source.orig/src/vizhp2p_html	1970-01-01 01:00:01.000000000 +0100
++++ source/src/vizhp2p_html	2021-08-24 10:41:54.799946303 +0200
+@@ -118,7 +118,7 @@
+     hostfile = args.hostfile
+     clustername = args.clustername
+     if len(args.OutputName) == 0:
+-        print "No DATAFILE given! Please provide Hp2p output files name !"
++        print("No DATAFILE given! Please provide Hp2p output files name !")
+         exit(0)
+     else:
+         outputname = args.OutputName.split('.')[0]
+@@ -134,13 +134,13 @@
+         else:
+             outfile = args.outfile
+ 
+-    print "%s configuration:"%commandname
+-    print "   DATAFILE            : %s"%resfile
+-    print "   HOSTFILE            : %s"%hostfile
+-    print "   CLUSTER             : %s"%clustername
+-    print "   OUTPUTFILE          : %s"%outfile
++    print("%s configuration:"%commandname)
++    print("   DATAFILE            : %s"%resfile)
++    print("   HOSTFILE            : %s"%hostfile)
++    print("   CLUSTER             : %s"%clustername)
++    print("   OUTPUTFILE          : %s"%outfile)
+     if not os.path.exists(resfile):
+-        print "%s doesn't exist...Exiting"%resfile
++        print("%s doesn't exist...Exiting"%resfile)
+         exit(0)
+ 
+ # Data management
+Only in source/src: vizhp2p_html.bak

pkgs/tools/networking/nebula/default.nix

···
 
   subPackages = [ "cmd/nebula" "cmd/nebula-cert" ];
 
-  buildFlagsArray = [ "-ldflags=" "-X main.Build=${version}" ];
+  ldflags = [ "-X main.Build=${version}" ];
 
   meta = with lib; {
     description = "A scalable overlay networking tool with a focus on performance, simplicity and security";

pkgs/tools/networking/shadowfox/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [
-    "-ldflags=-X main.tag=v${version}"
+  ldflags = [
+    "-X main.tag=v${version}"
   ];
 
   meta = with lib; {

pkgs/tools/networking/telepresence2/default.nix

···
 
   vendorSha256 = "1snmp461h8driy1w1xggk669yxl0sjl1m9pbqm7dwk44yb94zi1q";
 
-  buildFlagsArray = ''
-    -ldflags=-s -w -X=github.com/telepresenceio/telepresence/v2/pkg/version.Version=${src.rev}
-  '';
+  ldflags = [
+    "-s" "-w" "-X=github.com/telepresenceio/telepresence/v2/pkg/version.Version=${src.rev}"
+  ];
 
   subPackages = [ "cmd/telepresence" ];
 

pkgs/tools/networking/termshark/default.nix

···
     wrapProgram $out/bin/termshark --prefix PATH : ${lib.makeBinPath [ wireshark-cli ]}
   '';
 
-  buildFlagsArray = ''
-    -ldflags=
-    -X github.com/gcla/termshark.Version=${version}
-  '';
+  ldflags = [
+    "-X github.com/gcla/termshark.Version=${version}"
+  ];
 
   meta = with lib; {
     homepage = "https://termshark.io/";

pkgs/tools/networking/yggdrasil/default.nix

···
 
   subPackages = [ "cmd/yggdrasil" "cmd/yggdrasilctl" ];
 
-  buildFlagsArray = ''
-    -ldflags=
-      -X github.com/yggdrasil-network/yggdrasil-go/src/version.buildVersion=${version}
-      -X github.com/yggdrasil-network/yggdrasil-go/src/version.buildName=${pname}
-      -s -w
-  '';
+  ldflags = [
+    "-X github.com/yggdrasil-network/yggdrasil-go/src/version.buildVersion=${version}"
+    "-X github.com/yggdrasil-network/yggdrasil-go/src/version.buildName=${pname}"
+    "-s" "-w"
+  ];
 
   passthru.tests.basic = nixosTests.yggdrasil;
 

pkgs/tools/package-management/holo-build/default.nix

···
 
   subPackages = [ "src/holo-build" ];
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/holocm/holo-build/src/holo-build/common.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/holocm/holo-build/src/holo-build/common.version=${version}" ];
 
   postBuild = ''
     make build/man/holo-build.8 VERSION=${version}

pkgs/tools/package-management/morph/default.nix

···
 
   nativeBuildInputs = [ makeWrapper go-bindata ];
 
-  buildFlagsArray = ''
-    -ldflags=
-    -X
-    main.version=${version}
-  '';
+  ldflags = [
+    "-X main.version=${version}"
+  ];
 
   postPatch = ''
     go-bindata -pkg assets -o assets/assets.go data/

pkgs/tools/package-management/nfpm/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "A simple deb and rpm packager written in Go";

pkgs/tools/security/aws-iam-authenticator/default.nix

···
   deleteVendor = true;
   vendorSha256 = "+Z8sENIMWXP29Piwb/W6i7UdNXVq6ZnO7AZbSaUYCME=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=v${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=v${version}" ];
 
   subPackages = [ "cmd/aws-iam-authenticator" ];
 

pkgs/tools/security/cfssl/default.nix

···
     popd
   '';
 
-  buildFlagsArray = ''
-    -ldflags=
-      -s -w
-      -X github.com/cloudflare/cfssl/cli/version.version=v${version}
-  '';
+  ldflags = [
+    "-s" "-w"
+    "-X github.com/cloudflare/cfssl/cli/version.version=v${version}"
+  ];
 
   meta = with lib; {
     homepage = "https://cfssl.org/";

pkgs/tools/security/doppler/default.nix

···
 
   vendorSha256 = "sha256-yb7L4GSKtlwagwdxBMd5aSk9fre1NKKsy6CM4Iv2ya8=";
 
-  buildFlagsArray = "-ldflags=-X github.com/DopplerHQ/cli/pkg/version.ProgramVersion=v${version}";
+  ldflags = [ "-X github.com/DopplerHQ/cli/pkg/version.ProgramVersion=v${version}" ];
 
   postInstall = ''
     mv $out/bin/cli $out/bin/doppler

pkgs/tools/security/gopass/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version} -X main.commit=${src.rev}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" "-X main.commit=${src.rev}" ];
 
   wrapperPath = lib.makeBinPath (
     [

pkgs/tools/security/gopass/git-credential.nix

···
 
   nativeBuildInputs = [ makeWrapper ];
 
-  preBuild = ''
-    buildFlagsArray+=(
-      "-ldflags=-s -w -X main.version=${version} -X main.commit=${src.rev}"
-    )
-  '';
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}" "-X main.commit=${src.rev}"
+  ];
 
   postFixup = ''
     wrapProgram $out/bin/git-credential-gopass --prefix PATH : "${lib.makeBinPath [ gopass ]}"

pkgs/tools/security/gopass/jsonapi.nix

···
 
   nativeBuildInputs = [ installShellFiles makeWrapper ];
 
-  preBuild = ''
-    buildFlagsArray+=(
-      "-ldflags=-s -w -X main.version=${version} -X main.commit=${src.rev}"
-    )
-  '';
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}" "-X main.commit=${src.rev}"
+  ];
 
   postFixup = ''
     wrapProgram $out/bin/gopass-jsonapi --prefix PATH : "${lib.makeBinPath [ gopass ]}"

pkgs/tools/security/grype/default.nix

···
 
 buildGoModule rec {
   pname = "grype";
-  version = "0.16.0";
+  version = "0.17.0";
 
   src = fetchFromGitHub {
     owner = "anchore";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-Xk+AyCcPQDDKKLT/tkZ2znXbBSBEgmqVqmgGBP/3Oos=";
+    sha256 = "sha256-410mCfYzbqgj3hb3dgVOGPWPCIYrB41soLA8dXK23NE=";
   };
 
-  vendorSha256 = "sha256-OAzuL1pHLLKgkKjPjupPg7LEz8sY7ehq2PONnjhvzHE=";
+  vendorSha256 = "sha256-KkS/1VSObniAykAwv7uW+RCrdvb5BM6DbHzDWZ6kPoQ=";
 
   propagatedBuildInputs = [ docker ];
 

pkgs/tools/security/saml2aws/default.nix

···
 
   subPackages = [ "." "cmd/saml2aws" ];
 
-  buildFlagsArray = ''
-    -ldflags=-X main.Version=${version}
-  '';
+  ldflags = [
+    "-X main.Version=${version}"
+  ];
 
   meta = with lib; {
     description = "CLI tool which enables you to login and retrieve AWS temporary credentials using a SAML IDP";

pkgs/tools/security/step-ca/default.nix

···
 
   vendorSha256 = "sha256-cFuLW0qkI/l/TvYwQZA2bLlWYjs1hdbQJ5jU7xiuFZI=";
 
-  buildFlagsArray = [ "-ldflags=-buildid=" ];
+  ldflags = [ "-buildid=" ];
 
   nativeBuildInputs = lib.optionals hsmSupport [ pkg-config ];
 

pkgs/tools/security/subjs/default.nix

···
 
   vendorSha256 = "1y01k8pvv7y9zb15wbk068cvkx0g83484jak2dvcvghqcf5j1fr1";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.AppVersion=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.AppVersion=${version}" ];
 
   meta = with lib; {
     description = "Fetcher for Javascript files";

pkgs/tools/system/ctop/default.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version} -X main.build=v${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" "-X main.build=v${version}" ];
 
   meta = with lib; {
     description = "Top-like interface for container metrics";

pkgs/tools/system/hostctl/default.nix

···
 
   vendorSha256 = "sha256-rGDWrivIdl5FTu/kNR8nAfE2+1hE4cm3uDg7oBobE9M=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X github.com/guumaster/hostctl/cmd/hostctl/actions.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X github.com/guumaster/hostctl/cmd/hostctl/actions.version=${version}" ];
 
   nativeBuildInputs = [ installShellFiles ];
   postInstall = ''
···
     maintainers = with maintainers; [ blaggacao ];
   };
 }
-

pkgs/tools/system/netdata/go.d.plugin.nix

···
 
   doCheck = false;
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   postInstall = ''
     mkdir -p $out/lib/netdata/conf.d

pkgs/tools/text/mark/default.nix

···
 
   vendorSha256 = "sha256-y3Q8UebNbLy1jmxUC37mv+2l8dCU3b/Fk8XHn5u57p0=";
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     description = "A tool for syncing your markdown documentation with Atlassian Confluence pages";

pkgs/tools/text/vale/default.nix

···
     cp -r styles $data/share/vale
   '';
 
-  buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];
+  ldflags = [ "-s" "-w" "-X main.version=${version}" ];
 
   meta = with lib; {
     homepage = "https://docs.errata.ai/vale/about";

pkgs/tools/virtualization/shipyard/default.nix

···
   };
   vendorSha256 = "sha256-tTkPFftPDNXafIjAjNg6V6e/+2S/v5Do/YyAXPaGIqA=";
 
-  buildFlagsArray = [
-    "-ldflags=-s -w -X main.version=${version}"
+  ldflags = [
+    "-s" "-w" "-X main.version=${version}"
   ];
 
   # Tests require a large variety of tools and resources to run including

pkgs/top-level/all-packages.nix

···
 
   hostctl = callPackage ../tools/system/hostctl { };
 
+  hp2p = callPackage ../tools/networking/hp2p { };
+
   hpe-ltfs = callPackage ../tools/backup/hpe-ltfs { };
 
   http2tcp = callPackage ../tools/networking/http2tcp { };
···
 
   fsharp = callPackage ../development/compilers/fsharp { };
 
-  fstar = callPackage ../development/compilers/fstar {
-    ocamlPackages = ocaml-ng.ocamlPackages_4_07;
-  };
+  fstar = callPackage ../development/compilers/fstar { };
 
   dotnetPackages = recurseIntoAttrs (callPackage ./dotnet-packages.nix {});
 

pkgs/top-level/perl-packages.nix

···
 
   FutureAsyncAwait = buildPerlModule rec {
     pname = "Future-AsyncAwait";
-    version = "0.49";
+    version = "0.52";
     src = fetchurl {
       url = "mirror://cpan/authors/id/P/PE/PEVANS/Future-AsyncAwait-${version}.tar.gz";
-      sha256 = "0cm7cgfjrqs7jazl0f9q6lgkhz6k8qbawin1z36nrwh2ywc94zjb";
+      sha256 = "0dwij2r51vij91hx808zc2l5q38h55jahzrh73h4rn816jv597yx";
     };
     buildInputs = [ TestRefcount ];
-    propagatedBuildInputs = [ Future XSParseSublike ];
+    propagatedBuildInputs = [ Future XSParseKeyword XSParseSublike ];
     perlPreHook = lib.optionalString stdenv.isDarwin "export LD=$CC";
     meta = {
       description = "Deferred subroutine syntax for futures";
···
 
   XSParseKeyword = buildPerlModule {
     pname = "XS-Parse-Keyword";
-    version = "0.06";
+    version = "0.12";
     src = fetchurl {
-      url = "mirror://cpan/authors/id/P/PE/PEVANS/XS-Parse-Keyword-0.06.tar.gz";
-      sha256 = "0nnr8akkxb2h2y3d5r51pr84vvxkq89ynmi9azkbnn79jmbcbgvq";
+      url = "mirror://cpan/authors/id/P/PE/PEVANS/XS-Parse-Keyword-0.12.tar.gz";
+      sha256 = "0crwhcw9ciqndvwvhycd93m6jgyhi77yyj4vi9xfyglpv84p3y68";
     };
+    buildInputs = [ ExtUtilsCChecker ];
     perlPreHook = lib.optionalString stdenv.isDarwin "export LD=$CC";
     meta = {
       description = "XS functions to assist in parsing keyword syntax";
···
 
   XSParseSublike = buildPerlModule {
     pname = "XS-Parse-Sublike";
-    version = "0.10";
+    version = "0.12";
     src = fetchurl {
-      url = "mirror://cpan/authors/id/P/PE/PEVANS/XS-Parse-Sublike-0.10.tar.gz";
-      sha256 = "99a1bdda3ffa67514adb6aa189c902fa78dca41d778a42ae7079f604a045ac43";
+      url = "mirror://cpan/authors/id/P/PE/PEVANS/XS-Parse-Sublike-0.12.tar.gz";
+      sha256 = "08kpia48f1rqc44rvbns97h3jyy2y5c8qlkh4a95v1m0yr5cb22s";
     };
     buildInputs = [ TestFatal ];
     perlPreHook = lib.optionalString stdenv.isDarwin "export LD=$CC";