Cheatsheet: Difference between revisions

|-

|Install a package

|In /etc/nixos/configuration.nix:

If it's a program add to systemPackages:

<syntaxhighlight lang="nix">services.openssh.enable = true;</syntaxhighlight>

Or with collections, add the package to your ~/.nixpkgs/config.nix and run

Since 17.09pre:

<syntaxhighlight lang="nix">users.users.<username>.packages =

|<syntaxhighlight lang="bash">sudo apt-get remove emacs</syntaxhighlight>

|remove from /etc/nixos/configuration.nix

|

|-

|Uninstall a package removing its configuration

|All configuration is in configuration.nix

|

|-

|Update the list of packages

|-

|Upgrade packages

|-

|Check for broken dependencies

|unneeded!

|-

|List package dependencies

nix-store -q --tree /nix/var/nix/profiles/system</syntaxhighlight>

   $(nix-instantiate '<nixpkgs>' -A emacs)</syntaxhighlight>

For installed packages:

|-

|List which packages depend on this one (reverse dependencies)

|

|For installed packages (only print reverse dependencies *which are already installed*):

|-

|Verify all installed packages

|-

|Fix packages with failed checksums

|Reinstall broken packages

|-

|Select major version and stable/unstable

|Change sources.list and apt-get dist-upgrade. A an extremely infrequent and destructive operation. The nix variants are safe and easy to use.

   https://nixos.org/channels/nixpkgs-unstable <name></syntaxhighlight>

Add the unstable channel. At that address you will find names for other versions and variants. Name can be any string.

To eliminate a channel.

To show all installed channel.

|When run by a user channels work locally, when run by root they're used as the system-wide channels.

|-

|Configure a package

|edit /etc/nixos/configuration.nix

|edit ~/.nixpkgs/config.nix TODO More details about how to edit

|-

|Find packages

|-

|Show package description

|-

|Show files installed by package

  /nix/store/ji06y4haijly0i0knmr986l2dajffv1p-emacs-24.4/bin/emacs-24.4</syntaxhighlight>

then

|-

|Show package for file

|follow the symlink

|follow the symlink

|-

|Start a service

|

|-

|Stop a service

|

|-

|-

|Adding a user

|Add <syntaxhighlight lang="nix">users.users.alice =

  { isNormalUser = true;

|-

|List binaries

ls /nix/var/nix/profiles/default/bin/</syntaxhighlight>

|-

|Get the current version number

|-

|Get sources for a package

|

|In Debian, apt-get source gets both the patched upstream source and the recipe for the package. Those need two steps in Nix.

To download the source as specified by the package recipe: <syntaxhighlight lang="bash">nix-build '<nixpkgs>' -A emacs.src</syntaxhighlight>

The patched source is usually not a derivation itself, but can be produced for most packages with the following command: <syntaxhighlight lang="bash">nix-shell '<nixpkgs>' -A emacs\

|

|

cat >default.nix <<EOF

with import <nixpkgs> { };

|-

|Install a .deb

|

|Install dpkg with Nix, then <syntaxhighlight lang="bash">dpkg -i package.deb</syntaxhighlight> (not recommended!)

=== Get the store path for a package ===

$ nix-repl

nix-repl> :l <nixpkgs>

$ nix-build '<nixpkgs>' --no-build-output -A xorg.libXtst

/nix/store/nlpnx21yjdjx2ii7ln4kcmbm0x1vy7w9-libXtst-1.2.3

For most files, it is sufficient to run:

$ nix-store --add-fixed sha256 /path/to/file

Unfortunately, `nix-store` will try to load the entire file into memory,

If we have root access, we can copy the file to the store ourselves:

$ sudo unshare -m bash  # open a shell as root in a private mount namespace

$ largefile=/path/to/file

$ printf "$storepath\n\n0\n" | nix-store --register-validity --reregister  # register the file in the Nix database

$ exit  # exit to the original shell where /nix/store is still mounted read-only

=== Build nixos from nixpkgs repo ===

The following snippet will build the system from a git checkout:

$ nixos-rebuild -I nixpkgs=/path/to/nixpkgs switch

This method can be used when testing nixos services for a pull request to nixpkgs.

Use the following command to build directly from a particular branch of a repo in github:

$ nixos-rebuild -I nixpkgs=https://github.com/nixcloud/nixpkgs/archive/release-17.03.tar.gz switch

=== Building a service as a VM (for testing) ===

Given the following configuration:

# vm.nix

{ lib, config, ... }:

   users.users.root.initialPassword = "root";

}

a vm can be build using the following command:

$ nixos-rebuild -I nixpkgs=/path/to/nixpkgs -I nixos-config=./vm.nix build-vm

where <code>-I nixpkgs=/path/to/nixpkgs</code> is optionally depending whether the vm should be build from git checkout or a channel.

On non-nixos (linux) systems the following command can be used instead:

$ nix-build '<nixpkgs/nixos>' -A vm -k -I nixos-config=./vm.nix

By default the resulting vm will require X11 to create a virtual display.

By specifying additional arguments via the environment variables <code>QEMU_OPTS</code>and <code>QEMU_KERNEL_PARAMS</code> it is possible to reuse the current running terminal as serial console for the vm:

$ export QEMU_OPTS="-nographic -serial mon:stdio" QEMU_KERNEL_PARAMS=console=ttyS0  

$ /nix/store/lshw31yfbb6izs2s594jd89ma4wf8zw6-nixos-vm/bin/run-nixos-vm

To be able to log in you will need a getty started on a serial console as well in your nixos configuration:

{...}: {

   # ..

   systemd.services."serial-getty@ttyS0".enable = true;

}

To forward a port you can set export <code>QEMU_NET_OPTS</code>. In the following example port 2222 on the host is forwarded to port 22 in the vm:

$ export QEMU_NET_OPTS="hostfwd=tcp::2222-:22"

Don't forget that by default nixos comes with a firewall enabled:

{...}: {

   networking.firewall.enable = false;

}

=== Reuse a package as a build environment ===

As packages already contains all build dependencies, they can be reused to a build environment quickly.

After obtaining the source:

$ git clone https://github.com/iovisor/bcc.git

$ cd bcc

Add the following <code>default.nix</code> to the project:

with import <nixpkgs> {};

linuxPackages.bcc.overrideDerivation (old: {

   buildInputs = [ bashInteractive ninja ] ++ old.buildInputs;

})

To initiate the build environment run `nix-shell` in the project root directory

# this will download add development dependencies and set up the environment so build tools will find them.

$ nix-shell

The following is specific to bcc or cmake in general:

(so you need to adapt the workflow depending on the project, you hack on)

$ mkdir build

$ cd build

$ eval cmake $cmakeFlags ..

$ make

The following command will cross compile the tinc package for the aarch64 CPU architecture from a different architecture (e.g. x86_64).

$ nix-build '<nixpkgs>' --arg crossSystem '(import <nixpkgs> {}).lib.systems.examples.aarch64-multiplatform' -A tinc

You can add your own specifications, or look at existing ones, in nixpkgs/lib/systems/examples.nix.

For example one can have both the unstable and stable channels on system root:

$ sudo nix-channel --list

nixos https://nixos.org/channels/nixos-17.03

nixos-unstable https://nixos.org/channels/nixos-unstable

and the following in `configuration.nix`:

nixpkgs.config = {

   # Allow proprietary packages

   };

};

which allows you to switch particular packages to the unstable channel:

environment = {

   systemPackages = with pkgs; [

   ];

};

=== Building statically linked packages ===

$ nix-build -E 'with (import ./. {}); (curl.override { stdenv = makeStaticLibraries stdenv;}).out'

There is also an stdenv adapter that will build static binaries:

$ nix-build '<nixpkgs>' -A pkgsStatic.hello

=== Rebuild a package with debug symbols ===