b12f/nixpkgs
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Merge master into staging-next

Browse source
This commit is contained in:
github-actions[bot] 2023-03-08 18:01:34 +00:00 committed by GitHub
parent 644e671d80 1e383aada5
commit 7072ae38b6
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
17 changed files with 262 additions and 122 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

172
doc/languages-frameworks/rust.section.md
View file

@ -13,7 +13,7 @@ into your `configuration.nix` or bring them into scope with `nix-shell -p rustc
For other versions such as daily builds (beta and nightly),
use either `rustup` from nixpkgs (which will manage the rust installation in your home directory),
or use a community maintained [Rust overlay](#using-community-rust-overlays).
or use [community maintained Rust toolchains](#using-community-maintained-rust-toolchains).
## `buildRustPackage`: Compiling Rust applications with Cargo {#compiling-rust-applications-with-cargo}
@ -686,31 +686,61 @@ $ cargo build
$ cargo test
```
### Controlling Rust Version Inside `nix-shell` {#controlling-rust-version-inside-nix-shell}
## Using community maintained Rust toolchains {#using-community-maintained-rust-toolchains}
To control your rust version (i.e. use nightly) from within `shell.nix` (or
other nix expressions) you can use the following `shell.nix`
::: {.note}
Note: The following projects cannot be used within nixpkgs since [IFD](#ssec-import-from-derivation) is disallowed.
To package things that require Rust nightly, `RUSTC_BOOTSTRAP = true;` can sometimes be used as a hack.
:::
There are two community maintained approaches to Rust toolchain management:
- [oxalica's Rust overlay](https://github.com/oxalica/rust-overlay)
- [fenix](https://github.com/nix-community/fenix)
Despite their names, both projects provides a similar set of packages and overlays under different APIs.
Oxalica's overlay allows you to select a particular Rust version without you providing a hash or a flake input,
but comes with a larger git repository than fenix.
Fenix also provides rust-analyzer nightly in addition to the Rust toolchains.
Both oxalica's overlay and fenix better integrate with nix and cache optimizations.
Because of this and ergonomics, either of those community projects
should be preferred to the Mozilla's Rust overlay ([nixpkgs-mozilla](https://github.com/mozilla/nixpkgs-mozilla)).
The following documentation demonstrates examples using fenix and oxalica's Rust overlay
with `nix-shell` and building derivations. More advanced usages like flake usage
are documented in their own repositories.
### Using Rust nightly with `nix-shell` {#using-rust-nightly-with-nix-shell}
Here is a simple `shell.nix` that provides Rust nightly (default profile) using fenix:
```nix
# Latest Nightly
with import <nixpkgs> {};
let src = fetchFromGitHub {
owner = "mozilla";
repo = "nixpkgs-mozilla";
# commit from: 2019-05-15
rev = "9f35c4b09fd44a77227e79ff0c1b4b6a69dff533";
hash = "sha256-18h0nvh55b5an4gmlgfbvwbyqj91bklf1zymis6lbdh75571qaz0=";
};
with import <nixpkgs> { };
let
fenix = callPackage
(fetchFromGitHub {
owner = "nix-community";
repo = "fenix";
# commit from: 2023-03-03
rev = "e2ea04982b892263c4d939f1cc3bf60a9c4deaa1";
hash = "sha256-AsOim1A8KKtMWIxG+lXh5Q4P2bhOZjoUhFWJ1EuZNNk=";
})
{ };
in
with import "${src.out}/rust-overlay.nix" pkgs pkgs;
stdenv.mkDerivation {
mkShell {
name = "rust-env";
buildInputs = [
# Note: to use stable, just replace `nightly` with `stable`
latest.rustChannels.nightly.rust
nativeBuildInputs = [
# Note: to use stable, just replace `default` with `stable`
fenix.default.toolchain
# Add some extra dependencies from `pkgs`
pkg-config openssl
# Example Build-time Additional Dependencies
pkg-config
];
buildInputs = [
# Example Run-time Additional Dependencies
openssl
];
# Set Environment Variables
@ -718,116 +748,66 @@ stdenv.mkDerivation {
}
```
Now run:
Save this to `shell.nix`, then run:
```ShellSession
$ rustc --version
rustc 1.26.0-nightly (188e693b3 2018-03-26)
rustc 1.69.0-nightly (13471d3b2 2023-03-02)
```
To see that you are using nightly.
## Using community Rust overlays {#using-community-rust-overlays}
Oxalica's Rust overlay has more complete examples of `shell.nix` (and cross compilation) under its
[`examples` directory](https://github.com/oxalica/rust-overlay/tree/e53e8853aa7b0688bc270e9e6a681d22e01cf299/examples).
There are two community maintained approaches to Rust toolchain management:
- [oxalica's Rust overlay](https://github.com/oxalica/rust-overlay)
- [fenix](https://github.com/nix-community/fenix)
### Using Rust nightly in a derivation with `buildRustPackage` {#using-rust-nightly-in-a-derivation-with-buildrustpackage}
Oxalica's overlay allows you to select a particular Rust version and components.
See [their documentation](https://github.com/oxalica/rust-overlay#rust-overlay) for more
detailed usage.
You can also use Rust nightly to build rust packages using `makeRustPlatform`.
The below snippet demonstrates invoking `buildRustPackage` with a Rust toolchain from oxalica's overlay:
Fenix is an alternative to `rustup` and can also be used as an overlay.
Both oxalica's overlay and fenix better integrate with nix and cache optimizations.
Because of this and ergonomics, either of those community projects
should be preferred to the Mozilla's Rust overlay (`nixpkgs-mozilla`).
### How to select a specific `rustc` and toolchain version {#how-to-select-a-specific-rustc-and-toolchain-version}
You can consume the oxalica overlay and use it to grab a specific Rust toolchain version.
Here is an example `shell.nix` showing how to grab the current stable toolchain:
```nix
{ pkgs ? import <nixpkgs> {
overlays = [
(import (fetchTarball "https://github.com/oxalica/rust-overlay/archive/master.tar.gz"))
];
}
}:
pkgs.mkShell {
nativeBuildInputs = with pkgs; [
pkg-config
rust-bin.stable.latest.minimal
];
}
```
You can try this out by:
1. Saving that to `shell.nix`
2. Executing `nix-shell --pure --command 'rustc --version'`
As of writing, this prints out `rustc 1.56.0 (09c42c458 2021-10-18)`.
### How to use an overlay toolchain in a derivation {#how-to-use-an-overlay-toolchain-in-a-derivation}
You can also use an overlay's Rust toolchain with `buildRustPackage`.
The below snippet demonstrates invoking `buildRustPackage` with an oxalica overlay selected Rust toolchain:
```nix
with import <nixpkgs> {
with import <nixpkgs>
{
overlays = [
(import (fetchTarball "https://github.com/oxalica/rust-overlay/archive/master.tar.gz"))
];
};
let
rustPlatform = makeRustPlatform {
cargo = rust-bin.stable.latest.minimal;
rustc = rust-bin.stable.latest.minimal;
};
in
rustPlatform.buildRustPackage rec {
pname = "ripgrep";
version = "12.1.1";
nativeBuildInputs = [
rust-bin.stable.latest.minimal
];
src = fetchFromGitHub {
owner = "BurntSushi";
repo = "ripgrep";
rev = version;
hash = "sha256-1hqps7l5qrjh9f914r5i6kmcz6f1yb951nv4lby0cjnp5l253kps=";
hash = "sha256-+s5RBC3XSgb8omTbUNLywZnP6jSxZBKSS1BmXOjRF8M=";
};
cargoSha256 = "03wf9r2csi6jpa7v5sw5lpxkrk4wfzwmzx7k3991q3bdjzcwnnwp";
cargoHash = "sha256-l1vL2ZdtDRxSGvP0X/l3nMw8+6WF67KPutJEzUROjg8=";
doCheck = false;
meta = with lib; {
description = "A fast line-oriented regex search tool, similar to ag and ack";
homepage = "https://github.com/BurntSushi/ripgrep";
license = licenses.unlicense;
maintainers = [ maintainers.tailhook ];
license = with licenses; [ mit unlicense ];
maintainers = with maintainers; [ tailhook ];
};
}
```
Follow the below steps to try that snippet.
1. create a new directory
1. save the above snippet as `default.nix` in that directory
1. cd into that directory and run `nix-build`
2. cd into that directory and run `nix-build`
### Rust overlay installation {#rust-overlay-installation}
You can use this overlay by either changing your local nixpkgs configuration,
or by adding the overlay declaratively in a nix expression, e.g. in `configuration.nix`.
For more information see [the manual on installing overlays](#sec-overlays-install).
### Declarative Rust overlay installation {#declarative-rust-overlay-installation}
This snippet shows how to use oxalica's Rust overlay.
Add the following to your `configuration.nix`, `home-configuration.nix`, `shell.nix`, or similar:
```nix
{ pkgs ? import <nixpkgs> {
overlays = [
(import (builtins.fetchTarball "https://github.com/oxalica/rust-overlay/archive/master.tar.gz"))
# Further overlays go here
];
};
};
```
Note that this will fetch the latest overlay version when rebuilding your system.
Fenix also has examples with `buildRustPackage`,
[crane](https://github.com/ipetkov/crane),
[naersk](https://github.com/nix-community/naersk),
and cross compilation in its [Examples](https://github.com/nix-community/fenix#examples) section.

5
maintainers/maintainer-list.nix
View file

@ -13000,6 +13000,11 @@
githubId = 61306;
name = "Rene Treffer";
};
ruby0b = {
github = "ruby0b";
githubId = 106119328;
name = "ruby0b";
};
rubyowo = {
name = "Rei Star";
email = "perhaps-you-know@what-is.ml";

30
nixos/modules/services/networking/murmur.nix
View file

@ -42,6 +42,8 @@ let
${if cfg.sslKey == "" then "" else "sslKey="+cfg.sslKey}
${if cfg.sslCa == "" then "" else "sslCA="+cfg.sslCa}
${lib.optionalString (cfg.dbus != null) "dbus=${cfg.dbus}"}
${cfg.extraConfig}
'';
in
@ -282,6 +284,12 @@ in
`murmur` is running.
'';
};
dbus = mkOption {
type = types.enum [ null "session" "system" ];
default = null;
description = lib.mdDoc "Enable D-Bus remote control. Set to the bus you want Murmur to connect to.";
};
};
};
@ -325,5 +333,27 @@ in
Group = "murmur";
};
};
# currently not included in upstream package, addition requested at
# https://github.com/mumble-voip/mumble/issues/6078
services.dbus.packages = mkIf (cfg.dbus == "system") [(pkgs.writeTextFile {
name = "murmur-dbus-policy";
text = ''
<!DOCTYPE busconfig PUBLIC
"-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
<busconfig>
<policy user="murmur">
<allow own="net.sourceforge.mumble.murmur"/>
</policy>
<policy context="default">
<allow send_destination="net.sourceforge.mumble.murmur"/>
<allow receive_sender="net.sourceforge.mumble.murmur"/>
</policy>
</busconfig>
'';
destination = "/share/dbus-1/system.d/murmur.conf";
})];
};
}

54
nixos/tests/docker-tools.nix
View file

@ -1,6 +1,52 @@
# this test creates a simple GNU image with docker tools and sees if it executes
import ./make-test-python.nix ({ pkgs, ... }: {
import ./make-test-python.nix ({ pkgs, ... }:
let
# nixpkgs#214434: dockerTools.buildImage fails to unpack base images
# containing duplicate layers when those duplicate tarballs
# appear under the manifest's 'Layers'. Docker can generate images
# like this even though dockerTools does not.
repeatedLayerTestImage =
let
# Rootfs diffs for layers 1 and 2 are identical (and empty)
layer1 = pkgs.dockerTools.buildImage { name = "empty"; };
layer2 = layer1.overrideAttrs (_: { fromImage = layer1; });
repeatedRootfsDiffs = pkgs.runCommandNoCC "image-with-links.tar" {
nativeBuildInputs = [pkgs.jq];
} ''
mkdir contents
tar -xf "${layer2}" -C contents
cd contents
first_rootfs=$(jq -r '.[0].Layers[0]' manifest.json)
second_rootfs=$(jq -r '.[0].Layers[1]' manifest.json)
target_rootfs=$(sha256sum "$first_rootfs" | cut -d' ' -f 1).tar
# Replace duplicated rootfs diffs with symlinks to one tarball
chmod -R ug+w .
mv "$first_rootfs" "$target_rootfs"
rm "$second_rootfs"
ln -s "../$target_rootfs" "$first_rootfs"
ln -s "../$target_rootfs" "$second_rootfs"
# Update manifest's layers to use the symlinks' target
cat manifest.json | \
jq ".[0].Layers[0] = \"$target_rootfs\"" |
jq ".[0].Layers[1] = \"$target_rootfs\"" > manifest.json.new
mv manifest.json.new manifest.json
tar --sort=name --hard-dereference -cf $out .
'';
in pkgs.dockerTools.buildImage {
fromImage = repeatedRootfsDiffs;
name = "repeated-layer-test";
tag = "latest";
copyToRoot = pkgs.bash;
# A runAsRoot script is required to force previous layers to be unpacked
runAsRoot = ''
echo 'runAsRoot has run.'
'';
};
in {
name = "docker-tools";
meta = with pkgs.lib.maintainers; {
maintainers = [ lnl7 roberth ];
@ -221,6 +267,12 @@ import ./make-test-python.nix ({ pkgs, ... }: {
"docker run --rm ${examples.layersUnpackOrder.imageName} cat /layer-order"
)
with subtest("Ensure repeated base layers handled by buildImage"):
docker.succeed(
"docker load --input='${repeatedLayerTestImage}'",
"docker run --rm ${repeatedLayerTestImage.imageName} /bin/bash -c 'exit 0'"
)
with subtest("Ensure environment variables are correctly inherited"):
docker.succeed(
"docker load --input='${examples.environmentVariables}'"

23
pkgs/applications/misc/krabby/default.nix Normal file
View file

@ -0,0 +1,23 @@
{ lib
, rustPlatform
, fetchCrate
}:
rustPlatform.buildRustPackage rec {
pname = "krabby";
version = "0.1.6";
src = fetchCrate {
inherit pname version;
sha256 = "sha256-BUX3D/UXJt9OxajUYaUDxI0u4t4ntSxqI1PMtk5IZNQ=";
};
cargoHash = "sha256-XynD19mlCmhHUCfbr+pmWkpb+D4+vt3bsgV+bpbUoaY=";
meta = with lib; {
description = "Print pokemon sprites in your terminal";
homepage = "https://github.com/yannjor/krabby";
changelog = "https://github.com/yannjor/krabby/releases/tag/v${version}";
license = licenses.gpl3;
maintainers = with maintainers; [ ruby0b ];
};
}

1
pkgs/applications/networking/p2p/jesec-rtorrent/default.nix
View file

@ -65,5 +65,6 @@ stdenv.mkDerivation rec {
license = licenses.gpl2Plus;
maintainers = with maintainers; [ winter AndersonTorres ];
platforms = platforms.linux;
mainProgram = "rtorrent";
};
}

1
pkgs/applications/networking/p2p/rakshasa-rtorrent/default.nix
View file

@ -68,5 +68,6 @@ stdenv.mkDerivation rec {
license = licenses.gpl2Plus;
maintainers = with maintainers; [ ebzzry codyopel ];
platforms = platforms.unix;
mainProgram = "rtorrent";
};
}

8
pkgs/applications/system/asusctl/default.nix
View file

@ -13,16 +13,16 @@
rustPlatform.buildRustPackage rec {
pname = "asusctl";
version = "4.5.6";
version = "4.5.8";
src = fetchFromGitLab {
owner = "asus-linux";
repo = "asusctl";
rev = version;
hash = "sha256-9WEP+/BI5fh3IhVsLSPrnkiZ3DmXwTFaPXyzBNs7cNM=";
hash = "sha256-6AitRpyLIq5by9/rXdIC8AChMVKZmR1Eo5GTo+DtGhc=";
};
cargoSha256 = "sha256-iXMor2hI8Q/tpdSCaUjiEsvVfmWKXI6Az0J6aqMwE2E=";
cargoHash = "sha256-lSjcsHnw6VZxvxxHUAkVEIZiI58xduInCJDXsFPGzMM=";
postPatch = ''
files="
@ -48,7 +48,7 @@ rustPlatform.buildRustPackage rec {
--replace /usr/bin/sleep ${coreutils}/bin/sleep
'';
nativeBuildInputs = [ pkg-config cmake ];
nativeBuildInputs = [ pkg-config cmake rustPlatform.bindgenHook ];
buildInputs = [ systemd fontconfig gtk3 ];

12
pkgs/build-support/docker/default.nix
View file

@ -229,6 +229,15 @@ rec {
mount /dev/${vmTools.hd} disk
cd disk
function dedup() {
declare -A seen
while read ln; do
if [[ -z "''${seen["$ln"]:-}" ]]; then
echo "$ln"; seen["$ln"]=1
fi
done
}
if [[ -n "$fromImage" ]]; then
echo "Unpacking base image..."
mkdir image
@ -245,7 +254,8 @@ rec {
parentID="$(cat "image/manifest.json" | jq -r '.[0].Config | rtrimstr(".json")')"
fi
cat ./image/manifest.json | jq -r '.[0].Layers | .[]' > layer-list
# In case of repeated layers, unpack only the last occurrence of each
cat ./image/manifest.json | jq -r '.[0].Layers | .[]' | tac | dedup | tac > layer-list
else
touch layer-list
fi

4
pkgs/development/python-modules/insteon-frontend-home-assistant/default.nix
View file

@ -7,14 +7,14 @@
buildPythonPackage rec {
pname = "insteon-frontend-home-assistant";
version = "0.3.2";
version = "0.3.3";
format = "pyproject";
disabled = pythonOlder "3.7";
src = fetchPypi {
inherit pname version;
hash = "sha256-7jRf6fp+5u6qqR5xP1R+kp6LURsBVqfct6yuCkbxBMw=";
hash = "sha256-aZ10z7xCVWq4V2+jPCybFa5LKGhvtchrwgTVFfxhM+o=";
};
nativeBuildInputs = [

2
pkgs/development/tools/rust/cargo-binutils/default.nix
View file

@ -14,7 +14,7 @@ rustPlatform.buildRustPackage rec {
meta = with lib; {
description = "Cargo subcommands to invoke the LLVM tools shipped with the Rust toolchain";
longDescription = ''
In order for this to work, you either need to run `rustup component add llvm-tools-preview` or install the `llvm-tools-preview` component using your Nix library (e.g. nixpkgs-mozilla, or rust-overlay)
In order for this to work, you either need to run `rustup component add llvm-tools-preview` or install the `llvm-tools-preview` component using your Nix library (e.g. fenix or rust-overlay)
'';
homepage = "https://github.com/rust-embedded/cargo-binutils";
changelog = "https://github.com/rust-embedded/cargo-binutils/blob/v${version}/CHANGELOG.md";

2
pkgs/development/tools/rust/cargo-llvm-cov/default.nix
View file

@ -36,7 +36,7 @@ rustPlatform.buildRustPackage rec {
longDescription = ''
In order for this to work, you either need to run `rustup component add llvm-
tools-preview` or install the `llvm-tools-preview` component using your Nix
library (e.g. nixpkgs-mozilla, or rust-overlay)
library (e.g. fenix or rust-overlay)
'';
license = with lib.licenses; [ asl20 /* or */ mit ];
maintainers = with lib.maintainers; [ wucke13 ];

6
pkgs/development/web/flyctl/default.nix
View file

@ -2,16 +2,16 @@
buildGoModule rec {
pname = "flyctl";
version = "0.0.477";
version = "0.0.478";
src = fetchFromGitHub {
owner = "superfly";
repo = "flyctl";
rev = "v${version}";
hash = "sha256-mGCMtyjR6fcflYsas9nXjS+MRPH2EXTgNh764pn3b1U=";
hash = "sha256-tMDcEpRpmFYOiEz+bmR5O+fushGPeBU28HoDqNuOP+Y=";
};
vendorHash = "sha256-RFcdntxSW4YKrACAJqIb2DLHuLC6EODBCk0YTK+y4J8=";
vendorHash = "sha256-W5z6Rbr8dPP0kAhVG8UPy5rK9wz5mZVK9geYt9umftE=";
subPackages = [ "." ];

8
pkgs/games/endless-sky/default.nix
View file

@ -1,16 +1,16 @@
{ lib, stdenv, fetchFromGitHub
, SDL2, libpng, libjpeg, glew, openal, scons, libmad
, SDL2, libpng, libjpeg, glew, openal, scons, libmad, libuuid
}:
stdenv.mkDerivation rec {
pname = "endless-sky";
version = "0.9.14";
version = "0.9.16.1";
src = fetchFromGitHub {
owner = "endless-sky";
repo = "endless-sky";
rev = "v${version}";
sha256 = "sha256-Vcck+zGcv39DXyhZF2DLUrXq3gDwkgL0NtPT5rVOpHs=";
sha256 = "sha256-bohljxAtSVqsfnge6t4LF3pC1s1r99v3hNLKTBquC20=";
};
patches = [
@ -24,7 +24,7 @@ stdenv.mkDerivation rec {
enableParallelBuilding = true;
buildInputs = [
SDL2 libpng libjpeg glew openal scons libmad
SDL2 libpng libjpeg glew openal scons libmad libuuid
];
prefixKey = "PREFIX=";

13
pkgs/os-specific/linux/kernel/xanmod-kernels.nix
View file

@ -3,14 +3,14 @@
let
# These names are how they are designated in https://xanmod.org.
ltsVariant = {
version = "5.15.89";
hash = "sha256-wlb6er8L2EaqgJbmbATBdSxx1BGcJXNcsu+/4UBmYdQ=";
version = "6.1.15";
hash = "sha256-KQ/1C8/nCQL8y/eTHQNJDYb/BSjwzdrUKdK05bSwuSI=";
variant = "lts";
};
mainVariant = {
version = "6.1.13";
hash = "sha256-H3bEKPzwqpeDWlsj3ciP5D8NXVBvi+oKisWXveHnjLQ=";
version = "6.2.2";
hash = "sha256-YQSaIiGzszuOSO3rYnuBeucvhVlnue24b3ECRTH55bg=";
variant = "main";
};
@ -33,11 +33,6 @@ let
TCP_CONG_BBR2 = yes;
DEFAULT_BBR2 = yes;
# Multigenerational LRU framework
# This can be removed when the LTS variant reaches version >= 6.1 (since it's on by default then)
LRU_GEN = yes;
LRU_GEN_ENABLED = yes;
# FQ-PIE Packet Scheduling
NET_SCH_DEFAULT = yes;
DEFAULT_FQ_PIE = yes;

39
pkgs/tools/misc/rmw/default.nix Normal file
View file

@ -0,0 +1,39 @@
{ lib
, stdenv
, fetchFromGitHub
, meson
, ninja
, pkg-config
, ncurses
}:
stdenv.mkDerivation rec {
pname = "rmw";
version = "0.9.0";
src = fetchFromGitHub {
owner = "theimpossibleastronaut";
repo = "rmw";
rev = "v${version}";
hash = "sha256-KOYj63j/vCG7I63bgep03HzufOj/p/EHaY8lyRMHCkY=";
fetchSubmodules = true;
};
nativeBuildInputs = [
pkg-config
meson
ninja
];
buildInputs = [
ncurses
];
meta = with lib; {
description = "Trashcan/ recycle bin utility for the command line";
homepage = "https://github.com/theimpossibleastronaut/rmw";
changelog = "https://github.com/theimpossibleastronaut/rmw/blob/${src.rev}/ChangeLog";
license = licenses.gpl3Only;
maintainers = with maintainers; [ dit7ya ];
};
}

4
pkgs/top-level/all-packages.nix
View file

@ -11662,6 +11662,8 @@ with pkgs;
inherit (python3Packages) sphinx;
};
rmw = callPackage ../tools/misc/rmw { };
rng-tools = callPackage ../tools/security/rng-tools { };
rnnoise = callPackage ../development/libraries/rnnoise { };
@ -31027,6 +31029,8 @@ with pkgs;
kpt = callPackage ../applications/networking/cluster/kpt { };
krabby = callPackage ../applications/misc/krabby { };
krane = callPackage ../applications/networking/cluster/krane { };
krita = libsForQt5.callPackage ../applications/graphics/krita { };