Arch Linux/Arch Haskell Group Maintainership

From HaskellWiki

The Arch Haskell group maintains AUR packages for Haskell. The Arch Haskell packages make up around 10% of total AUR packages (~2000 packages).

To make the task of implementing the Arch Haskell policy of tracking AUR feasible, we take two approaches:

  • massive automation of Hackage to AUR regular conversion, via cabal2arch and the archlinux utilities library
  • group participation in updating packages.

The first step ensures a consistent user experience:

  • cabal2arch should be used to generate all Haskell AUR packages,
  • which ensures all naming conventions and other policies are followed,

The second point ensures the Arch Haskell project isn't vulernable to "bus errors" where a user burns out.

The job of an Arch Haskell group maintainer[edit]

The concern of an Arch Haskell maintainer is as follows.

  • Ensure AUR tracks Hackage versions of packages.

To do this, the following work is done:

  • Watch the Hackage RSS feed
  • When new packages appear, attempt to build and upload them, with the "build" script (below).

Community resources[edit]

Besides getting Hackage code packaged natively, another job is to communicate status and progress to the broader Arch Linux community. We maintain several channels:

A blog for high profile news and announcements. Repost to the /r/archlinux reddit
A twitter account that follows the RSS feed
The mailing list.
  • arch-haskell@freenode
The IRC channel
  • The "arch-haskell" user on AUR.
The common owner of all group packages.
  • The "arch" project on code.haskell.org: storage space.
http://code.haskell.org/arch/

The "build" script[edit]

The "build" script is a shell program that wraps cabal2arch. You should always have the latest version of cabal2arch installed. The set of tools you need to run this script are:

This package provides core support for working with cabal and PKGBUILD files, and querying AUR.
Darcs repository
The tool converts cabal files to PKGBUILD packages. It is the main tool for Arch maintainers.
Darcs repository
a tool to help upload packages automatically.
Updates RSS files from the command line.
A small script that computes URLs of AUR packages.
A small script that records build status.
  • makepkg/pacman/bauerbill
Standard package tools.
   #
   # Given a hackage .cabal url, build and upload a Arch Linux package
   # Update build reports and package publication feed.
   #

   cd /tmp/
   set -e

   # generate package
   project=`cabal2arch $* 2>&1 | tail -1 | sed 's/Created *//' | xargs basename | sed 's/\..*$//'`
   echo $project
   cd $project

   pkg=`sed -n '/pkgname/{s/pkgname=//;p;q}' PKGBUILD`

   # build package
   if makepkg -f ; then
       # update build report
       echo "$pkg True" >> $HOME/.build-all.log
   else
       exit 1
   fi

   cd ..

   # upload package
   echo "Uploading $project.tar.gz"
   aurploader -k $project.tar.gz

   # emit build status information
   # update-aur-log reads the .cabal2arch.log to pass data to feed-cli
   tail -1 ~/.cabal2arch.log | update-aur-log

   # now update the publications list . needs get-arch-url
   cp $HOME/aur.xml /tmp/
   url=`$HOME/bin/get-arch-url $project || cat /tmp/link`
   echo $url
   feed-cli new-item -t`cat /tmp/title` --description-file=/tmp/desc -u/tmp/aur.xml -l"$url"
   rm /tmp/link
   rm /tmp/title
   rm /tmp/desc
   echo scp /tmp/aur.xml code.haskell.org:/srv/code/arch/
   cp /tmp/aur.xml $HOME

Uploading a package: an example[edit]

1. See a new package on the Hackage feed.
2. Visit the Hackage page for the package. 
3. Copy the URL of the .cabal file

e.g. "http://hackage.haskell.org/packages/archive/http-enumerator/0.0.1/http-enumerator.cabal" 

4. Run the build tool

$ build-package.sh http://hackage.haskell.org/packages/archive/http-enumerator/0.0.1/http-enumerator.cabal 

5. If dependent packages are missing, install them (e.g. with bauerbill) (see the "get" script) (or recursively create new packages for any that are missing in AUR).
6. The script updates the RSS feed. Copy that to the server occasionally. 
7. Once a day run the distro-map tool, to regenerate the reverse Hackage index.
8. Once a day run the status script, and copy the generated html table to the server.


Package Quality Assurance[edit]

One script generates this table from build success logs:

The Blog[edit]

High profile news and important packages are announced on archhaskell.wordpress.com. Consider writing articles for the blog.

Package Publication and Notification[edit]

The "build-script" tool updates the RSS feed, so that packages are publicized. The RSS feed is slurped by Twitter.

Mapping to Hackage[edit]

The "distro-map" script (part of the archlinux package) updates the package mapping table between Hackage and Arch, which Hackage uses to generate direct links to distro packages.

This file is stored on code.haskell.org server:

Maintaining cabal2arch[edit]

  • Some notable Haskell programs (such as yi) ship a library. cabal2arch will by default call it "haskell-yi", which isn't desirable for high profile applications that incidentally ship a library. cabal2arch has a list of exceptions to this rule. If you find a package needing such an exception, edit the `shouldNotBeLibraries` list in Main.hs
  • Many C libraries are listed in .cabal files by different names to the Arch Linux packages. For example, "webkit" in a .cabal file is actually "libwebkit" under pacman. Cabal2arch has a list of such associations, that ensures the right C libraries are installed with the Haskell code. Keeping this list of associations up to date is a key advantage of cabal2arch over cabal-install. Edi t the ` translationTable` list in Main.hs as part of cabal2arch.
Retrieved from "https://wiki.haskell.org/index.php?title=Arch_Linux/Arch_Haskell_Group_Maintainership&oldid=37461"