You might ask why? I got asked about that stuff by my friendly office colleague Samuel. By the way, without him I would have never installed/used Nixos in the first place. Good fella, go checkout his blog.

#packaging #coding #nix #haskell

The goal was to package oama. Oama helps you to renew OAuth2 tokens from the command line. To be honest, I haven't checked the details on how it works yet, I was only interested in packaging it for Nix.

I was reading a bit on how it can be used with my favorite msmtp client.

Then I read some of the Nix documentation on how to build and use Haskell packages. They describe how to quickly bootstrap development environments (i.e., a Nix shell) using the handy cabal2nix utility.

The first step for packaging was also to convert the cabal description of the package into a valid Nix expression which already proved useful for development purposes.

git clone https://github.com/pdobsan/oama.git oama.git
cd oama.git
cabal2nix . > oama.nix

Create default.nix:

# Retrieve nixpkgs impurely from NIX_PATH for now, you can pin it instead, of course.
{ pkgs ? import <nixpkgs> {} }:

# use the nixpkgs default haskell package set
pkgs.haskellPackages.callPackage ./oama.nix { }

If you have a look at oama.nix it contains a lot of references to Haskell packages (.e.g, haskellPackages.aeson). The callPackage takes care of the name resolution in this case. haskellPackages.mkDerivation is a wrapper around stdenv.mkDerivation (see last post building a C project), but works without the standard Haskell build tool cabal-install.

To build oama and quickly run it in a shell:

nix-shell -p cabal-install
nix-build default.nix
./result/bin/oama

I did not look further into shellFor at this point, because I was interested in creating a Nix package that I can install globally.

For this, I took the “stdenv template” from the last post and merged 😻 it with the oama.nix output from cabal2nix. The result:

let
  pkgs = import <nixpkgs> { };
  hpkgs = pkgs.haskellPackages;
in
  hpkgs.mkDerivation {
    pname = "oama";
    version = "0.10.1";
    src = pkgs.fetchgit {
      url = "https://github.com/pdobsan/oama.git";
      rev = "refs/tags/0.10.1";
      hash = "sha256-mQBlCrF9rvFOfSOxhMi6JUKDJocFmO4Hhc3Zy7AqiXk=";
    };

    isLibrary = true;
    isExecutable = true;
    libraryHaskellDepends = with hpkgs; [
      aeson base bytestring containers directory hsyslog http-conduit
      network-uri optparse-applicative pretty-simple process string-qq
      strings text time twain unix utf8-string warp yaml
    ];
    executableHaskellDepends = with hpkgs; [
      aeson base bytestring containers directory hsyslog http-conduit
      network-uri optparse-applicative pretty-simple process string-qq
      strings text time twain unix utf8-string warp yaml
    ];

    mainProgram = "oama";
    license = pkgs.lib.licenses.bsd3;
  }

Essentially, I only had to use nix-prefetch-git to get the shasum of the git revision and make sure I use the pkgs and hpkgs (reference to pkgs.haskellPackages) correctly in the right places.

Afterwards, again, building and installing oama globally was a peace of cake 🧁:

nix-build oama.nix
nix-env -i -f oama.nix

Now I only have to figure out what to do with this tool 🤔 but this is left for another post.

After some reading on the Internet 📚, I finally understood the basics of building and installing a package from C sources using a Nix expression file (the .nix file in the following examples).

#packaging #coding #nix #diary #c

The expression file uses the standard build environment 🧰. Essentially, this environment abstracts the traditional Makefile based build proces (i.e., make && make install).

For learning purposes, I decided to package my hobby project, the text-based journaling program diary 📓.

Writing the Nix expression file

I built the expression file based on a an example from the Nix book.

The Nix expression file diary.nix to install the stable version of the diary program fetches the source by tag from the Git repository:

let
  pkgs = import <nixpkgs> { };
in
  pkgs.stdenv.mkDerivation {
    name = "diary";
    version = "v0.10";
    buildInputs = with pkgs; [
      ncurses
      curlFull
      lttng-ust
    ];

    src = pkgs.fetchgit {
      url = "https://git.in0rdr.ch/diary.git";
      rev = "refs/tags/v0.10";
      hash = "sha256-jDPfqUjf0ZETYqPxvEJ2/YFFjNsF7yvVQiThc5yMvjc=";
    };

    installPhase = ''
      install -d $out/bin
      install -d $out/share/man/man1
      install -m755 diary $out/bin/
      install -m644 man1/diary.1 $out/share/man/man1/
    '';
  }

The mkDerivation call does most of the work. There we define the package name and version, as well all of the dependencies required to build the project. In this case, the diary program depends on the curl and ncurses libraries as well as the lttng tracing library.

The source code src can be fetched conveniently from Git (using the fetchgit “builder”) or from other remote sources (see related “fetch” builtin functions).

To build a nightly release from the master branch, I only had to slightly tune the src of the unstable Nix expression:

    src = pkgs.fetchgit {
      url = "https://git.in0rdr.ch/diary.git";
      hash = "sha256-laKIVxfqJqBkB2d0F8tOOnpAXXRzHFfpjhAzZT8MX8k=";
    };

The sha256 hash can be obtained using nix-prefetch-git:

# get hash for the specific tag/release
nix-prefetch-git https://git.in0rdr.ch/diary.git --rev refs/tags/v0.10

# get hash for latest nightly build from master branch
nix-prefetch-git https://git.in0rdr.ch/diary.git

Finally, the installPhase needed a bit of tuning and has a small difference to what is commonly used in a Makefile on a traditional Linux distribution. But that was not too hard either, I simply had to translate my install target from the already existing Makefile.

The install target:

install: $(TARGET)
        install -m755 $(TARGET) $(BINDIR)/$(TARGET)
        install -d $(MANDIR)/man1
        install -m644 $(MAN1) $(MANDIR)/$(MAN1)

The corresponding Nix installPhase:

      install -d $out/bin
      install -d $out/share/man/man1
      install -m755 diary $out/bin/
      install -m644 man1/diary.1 $out/share/man/man1/

Very similar indeed. One point to note here is that the fixup phase will automatically install the man pages to the correct location.

Building and installing the C project

Once the expression file is written, building and installing the program is a peace of cake 🍰:

# Build stable package
nix-build nix/diary.nix

# Build latest nightly version
nix-build nix/diary-unstable.nix

To install the package from the expression file to the user environment:

# Install stable package
nix-env -i -f nix/diary.nix

# Install latest nightly version
nix-env -i -f nix/diary-unstable.nix

You can even verify the location of the man page by using manpath -q or query the installed package with nix-env -q.

Next steps

Now that we have drafted the basic expression file, we might also add it to the nixpkgs repository on GitHub. I haven't checked the contributor requirements in detail yet.