funbot-git-hook
This is a program to use as a Git post-receive hook, which collects new commits
and tags made in the Git push, and reports them to a running instance of
FunBot, so that the bot can announce the event to IRC.
See below for usage instructions.
The official download location is the Git repository:
https://notabug.org/fr33domlover/funbot-git-hook.git
Occasionally, releases are made to Hackage, the Haskell package repository.
See http://hackage.haskell.org/package/funbot-git-hook.
This software is free software, and is committed to software freedom. It is
released to the public domain using the CC0 Public Domain Dedication. For the
boring "legal" details see the file COPYING.
See the file INSTALL for hints on installation. The file ChangeLog explains
how to see the history log of the changes done in the code. NEWS provides a
friendly overview of the changes for each release.
Usage Instructions
Quickstart
If you feel you already know the details and just want to get the hook working
quickly, here's a usage example you can adapt to your needs. If these quick
instructions are al familiar, great! Otherwise, there is a detailed guide in
the next section.
The commands below assume manual management of git config and hooks for the
server. If you prefer to use Gitolite's features instead, check the Gitolite
website or read the hints provided in the next sections.
On the machine where you build the hook program:
$ sudo add-apt-repository ppa:hvr/ghc
$ sudo apt-get update
$ sudo apt-get install cabal-install-1.22 ghc-7.8.4
$ echo 'export PATH=~/.cabal/bin:/opt/cabal/1.22/bin:/opt/ghc/7.8.4/bin:$PATH' >> ~/.bashrc
$ PATH=~/.cabal/bin:/opt/cabal/1.22/bin:/opt/ghc/7.8.4/bin:$PATH
$ cabal update
$ cd /home/joe
If you're using git master:
$ git clone https://notabug.org/fr33domlover/funbot-git-hook.git
$ cd funbot-git-hook
$ cabal sandbox init
$ cabal install --only-dependencies
$ cabal build
If you're using the Hackage release:
$ mkdir funbot-sandbox
$ cd funbot-sandbox
$ cabal sandbox init
$ cabal install funbot-git-hook
Now copy dist/build/funbot-client-post-receive/funbot-client-post-receive to
the server as /var/lib/gitserver/repos/myrepo.git/hooks/post-receive.
On the git server machine:
# su - git
$ git config --global funbot.commit-url-template 'http://git.rel4tion.org/?p=${repo}.git;a=commitdiff;h=${commit}'
$ cd repos/myrepo.git
$ git config --local funbot.owner johndoe
$ git config --local funbot.bot-url 'http://bot.rel4tion.org/client'
Run ldd funbot-client-post-receive (on the binary) and make sure the listed
libraries are installed.
Intro
Some development platforms, such as Gogs and GitLab, have web hook support.
FunBot supports the web hook data formats of some of them, and then this
package isn't needed. But some platforms are perhaps not supported by FunBot
yet. And some are simple git servers which perhaps don't have web hooks at all,
for example Gitolite. For these cases, funbot-git-hook provides the ability
to report events to a FunBot instance.
I expect that Gitolite will be the primary use case of this package, and the
instructions below explain both the general case, and specific hints for
Gitolite server admins.
Git Server
Suppose you have a git server with repositories placed under
/var/lib/gitserver/repos, and they are bare repos. There is a system user
named git whose home directory is /var/lib/gitserver. We'd like to add a
git hook to a repo named myrepo, whose path would be
/var/lib/gitserver/repos/myrepo.git.
Git Config
The hook program takes its parameters from the git config. It checks both in
the global user config and in the repo-specific config.
The following config options are used:
funbot.commit-url-template
When FunBot announces a commit, it specifies a URL meant to refer to a web page
showing commit details. For example, if you use Gitolite, you probably use
gitweb or cgit to generate a web interface for browsing the repos. This
config option allows you to specify a template for that URL. The template
contains 3 variables, which will be inserted by the hook program when it runs:
repo : the repository name, without a .git suffix
branch : name of the branch the commit belongs to
commit : commit reference in the form of a SHA hash
Your template doesn't have to include all 3. Use the ones you need.
Variables in the template are specified like $var or like ${var}. Use $$
to get a literal $ character. For example, this works with gitweb:
http://git.rel4tion.org/?p=${repo}.git;a=commitdiff;h=${commit}
This config option is optional. If you don't specify it, an empty URL will be
assumed. You'll probably want to specify it in the global config
(~/.gitconfig), since on a single git server instance your repos most likely
share the same template.
# su - git
$ git config --global funbot.commit-url-template 'http://git.rel4tion.org/?p=${repo}.git;a=commitdiff;h=${commit}'
If you use Gitolite, you can set it globally for all the repos in your
gitolite.conf like this:
repo @all
config funbot.commit-url-template = "http://git.rel4tion.org/?p=${repo}.git;a=commitdiff;h=${commit}"
Note that by default Gitolite will refuse to accept this config line because
the value contains a character considered unsafe, $. See the Gitolite config
for more info and instructions how to safely allow $ to be used.
funbot.owner
FunBot maintains a list of repositories, and configuration for announcing their
events. For example, to which IRC channel should your repo's commits be
announced? For which branches? What to do if a large amount of commits are
pushed at once? FunBot keeps this information. When a commit is reported to it,
it needs to go to these records, find your repo's name and fetch the
configurations for it. But since different people and servers may have repos
with identical name, FunBot uses two things to identify and find a repo in its
records:
- The repo name
- A repo owner string, i.e. a username of a person responsible for the repo
This config option allows you to specify the owner string. It is required.
If no owner string is found, nothing will be sent to FunBot. Assuming you set
this per-repo, you can do it like this on the command line:
# su - git
$ cd ~/repos/myrepo.git
$ git config --local funbot.owner johndoe
Or using Gitolite:
repo myrepo
RW+ = johndoe
R = daemon
config funbot.owner = johndoe
The first johndoe is matched by Gitolite against the SSH key filenames, while
the second johndoe is an arbitrary owner nickname you can pick. They don't
have to be identical, but it may be a good idea to keep them identical for
consistency, and for cases your web UI contains author links etc.
funbot.bot-url
FunBot accept events from clients through an HTTP based API. This config option
is the URL at which your favorite FunBot instance accepts events. It is
required.
For example, http://bot.rel4tion.org/client.
Deploying the Hook Program
There are several ways to deply the hook:
- Build it somewhere else and copy the binary to the server
- Install it on the server
- Build it in a sandbox on the server
- Run it as a script using the Haskell interpreter
Technically there could also be "use a distro package" but there is none yet.
Contributions are very welcome, especially for making a deb package for
Trisquel.
If you're not sure which one to pick, I suggest the first option. Build from
the safety and comfort of your personal computer, and just copy the binary.
That binary does require some dependency libraries to be present, but most of
them are commonly available and you can use the ldd command on it to
determine exactly which dependencies are needed.
The binary executable contains its Haskell library dependencies, so it's bigger
than a typical git hook, which is often a simple script. On my system, its size
is 19MB. You can try to make it smaller by stripping symbols, if you want.
Building and Deploying the Binary
I'll assume the distribution used is Trisquel GNU/Linux-libre. The same
commands should probably work for other Debian-based distributions. Adapt to
your system as needed.
Add a PPA and install a basic Haskell tools (compiler, package
manager, etc.):
$ sudo add-apt-repository ppa:hvr/ghc
$ sudo apt-get update
$ sudo apt-get install cabal-install-1.22 ghc-7.8.4
Add ~/.cabal/bin:/opt/cabal/1.22/bin:/opt/ghc/7.8.4/bin to your $PATH in
bashrc or similar.
Download the package index:
$ cabal update
If you'd like to use the package release from Hackage, install it inside a
fresh sandbox:
$ mkdir funbot-sandbox
$ cd funbot-sandbox
$ cabal sandbox init
$ cabal install funbot-git-hook
If you're instead working with a git clone, go to the repo directory and create
a cabal sandbox:
$ cd /home/joe/git-repos/funbot-git-hook
$ cabal sandbox init
Install dependency packages:
$ cabal install --only-dependencies
Build the program:
$ cabal build
Now dist/build/funbot-client-post-receive/ contains a binary executable
funbot-client-post-receive. Use ldd to determine which libraries it links
to at runtime and make sure they are installed on the server (hopefully most if
not all of them will be available as distro packages).
Finally, you can put the binary on the server as
/var/lib/gitserver/repos/myrepo.git/hooks/post-receive. If you use Gitolite,
you can instead drop it in the /var/lib/gitserver/local/hooks/repo-specific
directory, and specify it in gitolite.conf:
repo myrepo
RW+ = johndoe
R = daemon
config funbot.owner = johndoe
option hook.post-receive = funbot-client-post-receive
Running using the Interpreter
If you want to do that for any reason, here's how. Install the packages from
the PPA on the server. Do the rest as the git user. Clone this repo if you
haven't yet. Instead of creating a sandbox, run a single
cabal install --only-dependencies which will install the dependencies locally
for the git user.
Now add #!/usr/bin/env runhaskell as the first line of src/Main.hs, make
this file executable (chmod +x src/Main.hs) and copy it to the final location
as explained for the binary at the bottom of the previous section.
Bug and Patches
See here.
