Re: Continuous integration

[Toon Claes]

address@hidden (Phillip Lord) writes:

> I have the buildbot installation up now. Slightly harder work than I
> hoped, but not too bad.
>
> http://emacs.bioswarm.net:8010

Cool!

Meanwhile, I also have set up CI using GitLab.com.

The project is over here, and is being mirrored from Savannah:

https://gitlab.com/emacs-ci/emacs

To set this up, I had to add a .gitlab-ci.yml file to the root of the
project, with the following content:

#+BEGIN_SRC yaml
image: debian:unstable

before_script:
  - apt update -qq
  - apt install -y -qq build-essential autoconf automake pkg-config libtool m4 
autoconf-archive gtk-doc-tools libxml2-utils gobject-introspection 
libgirepository1.0-dev libglib2.0-dev libjson-glib-dev libncurses-dev

stages:
  - test

test:
  stage: test
  script:
    - ./autogen.sh
    - ./configure --without-makeinfo --with-gnutls=no
    - make check
#+END_SRC

This file probably can be improved in many ways, but I got a successful
build. You can visit the build log here:

https://gitlab.com/emacs-ci/emacs/builds/13595493

If someone with write access would agree to commit the .gitlab-ci.yml
file, the daily mirroring will pick up commits, and GitLab will build
them automatically.

If anybody would like direct write access to the GitLab.com repository,
please click the "Request Access" button on the project page (see link
above).

> Currently, it's running a single build (full build from clean, through
> to tests). It will build any branch (following a change). The build
> takes about 60 mins (or 30 mins with parallel builds). In practice, I'd
> probably add a "incremental recompile and test" job which would be much
> quicker. The builds are running on the master which is probably not
> ideal.

That's great work Phil! I still have to figure out everything it does,
but it seems to be very comprehensive.

The set up at GitLab.com is doing quite the same at the moment. Doing
incremental recompilation would be quite hard on GitLab, because each
build is done in a clean Docker container, so you'll have to export
artifacts and reuse them each time.

GitLab has a feature called pipelines, which allows you to chain builds
together in stages. So this could be an example pipeline:

test --> build some GNU/Linux distro
     \
      -> build macOS
     \
      -> build Windows

The build stages won't be executed if the test stage failed.
If I understand it correctly, buildbot does something similar?
At the moment I only have configured 1 stage on GitLab, because only 1
was needed at the moment. The build stages shown in the flowchart above
can be added in a later stage to make regular builds for different
platforms automatically.

At first sight, also the concept of Workers on buildbot (called Runners
on GitLab) are quite similar.

What I do not yet understand is what the Builders are, and what the
difference is between full and quick?


-- Toon