Nix(OS)

# Timeline

![Nix project logo](img/nix-snowflake.svg)

- 2003: init (research begins)
            - 2007: NixOS becomes usable + x86_64 support
            - 2008: Website moved to nixos.org
            - 2009: Nix logo + Nix(OS) build on Hydra
            - 2011: Migration from Subversion to Git(Hub)
            - 2013: Switch from Upstart to systemd + NixOps 1.0 release
            - 2015: NixOS Foundation + First NixCon (Berlin)
            - 2017: Second NixCon (Munich)
            - 2018: Third NixCon (London)
            Notes:
            - https://nixos.org/news.html
            - 2007: NixOS is not an
              [April Fools’ Joke](https://www.osnews.com/comments/17601)
              - www.osnews.com post on 1st April 2017 (introduces NixOS, focus
                on purely functional)
            - Nix logo:
              - Nix is Latin for snow (-> snowflake)
              - Was initially created for the Haskell logo competition

# Problems of classical package managers

- Upgrades/configuration changes destructively update the system
              state (overwriting files in sequence -> temporary inconsistency)
            - State -> nondeterministic builds -> not reproducible
            - Different versions of a binary
            - Package conflicts
            - No rollbacks
            - No configuration management
            Notes:
            - Apps might have an undefined behaviour or crash when launched
              during an upgrade + possibility of permanent damage when
              interrupted (e.g. even unbootable!).
            - Incomplete dependency specifications (no isolated build
              environment)
            - Nominal dependency specifications (only name and optionally
              version)
            - Configuration files not controlled by the package manager.
            - Upgrading modified configuration files is problematic.
            - Binaries = global variables (e.g. /bin/bash)

# Nix

- A purely functional package manager (transparent source/binary
              deployment)
            - Secure multi-user support
            - Stores packages in the Nix store (`/nix/store` by default)
            - Each package has it's own unique identifier/directory
              - E.g. `qn96dbgqdryaw38zw6v08da34q5v4qz3-git-repo-1.12.37`
                
                (cryptographic hash, name, version)
              - Enables multiple versions & binary substitutes
              - "Forces" complete dependencies
            Notes:
            - Hash captures all dependencies (160-bit truncations of SHA-256
              encoded in base-32 (i.e. 32 characters))
              - src/libstore/store-api.cc Store::makeStorePath + comment above
            - Version: Digit after a dash
            - Garbage collection (nix-collect-garbage)
            - Similar to Content Addressed Storage (CAS)
              - Nothing is ever overwritten!

# Nix expressions / Nix expression language

- A DSL (not a GPL!)
              - Describes graphs of build actions ("derivations")
              - Packages, compositions of packages, configurations, ...
            - Dynamically typed ~~("Nix won't be complete until it has static
              typing." @edolstra)~~ - https://typing-nix.regnat.ovh/
            - Lazy (a very important feature!)
            - Purely functional (no side-effects, immutable store)
            - Turing complete (e.g. Dhall is not ->
              [dhall-nix](https://github.com/dhall-lang/dhall-nix))
            Notes:
            - DSL vs GPL: MD5 collisions by @Azlig (Chromium updater) :D
            - "Config files shouldn't be Turing complete" (-> always terminate)
            - Dhall is explicitly typed, evaluated, and configuration files can
              be reduced to a normal form
            - TODO:
                - Bad evaluation errors? :D
                  - Missing typing
                  - Error in anonymous function at unknown file?
                - Evaluated vs interpreted?
                - Bugs? :D (e.g. a-b)

# An example Nix package (pgpdump)

```nix
            pgpdump = callPackage ../tools/security/pgpdump { };
            ```

```nix
            { stdenv, fetchFromGitHub
            , supportCompressedPackets ? true, zlib, bzip2
            }:

stdenv.mkDerivation rec {
              name = "pgpdump-${version}";
              version = "0.32";

src = fetchFromGitHub {
                owner = "kazu-yamamoto";
                repo = "pgpdump";
                rev = "v${version}";
                sha256 = "1ip7q5sgh3nwdqbrzpp6sllkls5kma98kns53yspw1830xi1n8xc";
              };

buildInputs = stdenv.lib.optionals supportCompressedPackets [ zlib bzip2 ];

meta = with stdenv.lib; {
                description = "A PGP packet visualizer";
                longDescription = ''
                  pgpdump is a PGP packet visualizer which displays the packet format of
                  OpenPGP (RFC 4880) and PGP version 2 (RFC 1991).
                '';
                homepage = http://www.mew.org/~kazu/proj/pgpdump/en/;
                license = licenses.bsd3;
                platforms = platforms.linux;
                maintainers = with maintainers; [ primeos ];
              };
            }
            ```

# Another example NixOS module

```nix
            { config, lib, pkgs, ... }:

with lib;

let
              cfg = config.services.monetdb;

in {
              meta.maintainers = with maintainers; [ StillerHarpo primeos ];

###### interface
              options = {
                services.monetdb = {

enable = mkEnableOption "the MonetDB database server";

package = mkOption {
                    type = types.package;
                    default = pkgs.monetdb;
                    defaultText = "pkgs.monetdb";
                    description = "MonetDB package to use.";
                  };

user = mkOption {
                    type = types.str;
                    default = "monetdb";
                    description = "User account under which MonetDB runs.";
                  };

group = mkOption {
                    type = types.str;
                    default = "monetdb";
                    description = "Group under which MonetDB runs.";
                  };

dataDir = mkOption {
                    type = types.path;
                    default = "/var/lib/monetdb";
                    description = "Data directory for the dbfarm.";
                  };

port = mkOption {
                    type = types.ints.u16;
                    default = 50000;
                    description = "Port to listen on.";
                  };

listenAddress = mkOption {
                    type = types.str;
                    default = "127.0.0.1";
                    example = "0.0.0.0";
                    description = "Address to listen on.";
                  };
                };
              };

###### implementation
              config = mkIf cfg.enable {

users.users.monetdb = mkIf (cfg.user == "monetdb") {
                  uid = config.ids.uids.monetdb;
                  group = cfg.group;
                  description = "MonetDB user";
                  home = cfg.dataDir;
                  createHome = true;
                };

users.groups.monetdb = mkIf (cfg.group == "monetdb") {
                  gid = config.ids.gids.monetdb;
                  members = [ cfg.user ];
                };

environment.systemPackages = [ cfg.package ];

systemd.services.monetdb = {
                  description = "MonetDB database server";
                  wantedBy = [ "multi-user.target" ];
                  after = [ "network.target" ];
                  path = [ cfg.package ];
                  unitConfig.RequiresMountsFor = "${cfg.dataDir}";
                  serviceConfig = {
                    User = cfg.user;
                    Group = cfg.group;
                    ExecStart = "${cfg.package}/bin/monetdbd start -n ${cfg.dataDir}";
                    ExecStop = "${cfg.package}/bin/monetdbd stop ${cfg.dataDir}";
                  };
                  preStart = ''
                    if [ ! -e ${cfg.dataDir}/.merovingian_properties ]; then
                      # Create the dbfarm (as cfg.user)
                      ${cfg.package}/bin/monetdbd create ${cfg.dataDir}
                    fi

# Update the properties
                    ${cfg.package}/bin/monetdbd set port=${toString cfg.port} ${cfg.dataDir}
                    ${cfg.package}/bin/monetdbd set listenaddr=${cfg.listenAddress} ${cfg.dataDir}
                  '';
                };

};
            }
            ```

# An example NixOS configuration

```nix
            { config, pkgs, ... }:

{
              system.nixos.stateVersion = "18.03";

nix.useSandbox = true;

boot.kernelPackages = pkgs.linuxPackages_latest;

i18n = {
                consoleFont = "Lat2-Terminus16";
                consoleKeyMap = "de";
                defaultLocale = "en_US.UTF-8";
              };

time.timeZone = "Europe/Berlin";

environment = {
                systemPackages = with pkgs; [
                  # Core
                  vim_configurable gitAndTools.gitFull wget
                  # Monitoring
                  htop python3Packages.glances
                  # Tools
                  time file tree lsof
                  pciutils hdparm zip unzip
                  # Network
                  inetutils bind.dnsutils
                  tcpdump
                ];
                variables = {
                  EDITOR = "vim";
                };
              };

programs.bash.enableCompletion = true;
            }
            ```