build from source: include make

Resolves #213
Debian bullseye -> bookworm
2024-10-27 20:34:20 +00:00 · 2024-08-16 13:05:03 +12:00 · 2024-08-16 13:04:38 +12:00 · 2024-08-16 12:55:02 +12:00 · 2024-05-23 10:38:51 +12:00 · 2024-05-23 10:38:51 +12:00
36 changed files with 1173 additions and 393 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,5 +1,5 @@
 ###
-### Copyright 2015-2020 Oliver Giles
+### Copyright 2015-2024 Oliver Giles
 ###
 ### This file is part of Laminar
 ###
@ -16,13 +16,50 @@
 ### You should have received a copy of the GNU General Public License
 ### along with Laminar.  If not, see <http://www.gnu.org/licenses/>
 ###
+cmake_minimum_required(VERSION 3.6)
 project(laminar)
-cmake_minimum_required(VERSION 2.8)
-cmake_policy(SET CMP0058 NEW)
+
+if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
+    # ld.lld is a default option on FreeBSD
+    set(LLVM_LINKER_IS_LLD ON)
+endif()
+
+# ld.lld specific options. There is no sane way in cmake
+# to detect if toolchain is actually using ld.lld
+if (LLVM_LINKER_IS_LLD)
+    if (NOT DEFINED LINKER_EMULATION_FLAGS)
+        if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "amd64")
+            set(LINKER_EMULATION_FLAGS "-melf_x86_64")
+        elseif (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64")
+            set(LINKER_EMULATION_FLAGS "-melf_x86_64")
+        elseif (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "aarch64")
+            set(LINKER_EMULATION_FLAGS "-maarch64elf")
+        elseif (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "powerpc64le")
+            set(LINKER_EMULATION_FLAGS "-melf64lppc")
+        elseif (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "powerpc64")
+            set(LINKER_EMULATION_FLAGS "-melf64ppc")
+        elseif (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "riscv64")
+            # llvm17 & riscv64 requires extra step, it is necessary to
+            # patch 'Elf64.e_flags' (48-th byte) in binary-blob object files
+            # with value 0x5 - to change soft_float ABI to hard_float ABI
+            # so they can link with rest of the object files.
+            set(LINKER_EMULATION_FLAGS "-melf64lriscv")
+        elseif (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "arm")
+            set(LINKER_EMULATION_FLAGS "-marmelf")
+        elseif (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "armv7")
+            set(LINKER_EMULATION_FLAGS "-marmelf")
+        else()
+            message(FATAL_ERROR
+                "Unsupported '${CMAKE_SYSTEM_PROCESSOR}' translation to emulation flag. "
+                "Please set it explicitly 'cmake -DLINKER_EMULATION_FLAGS=\"-melf_your_arch\" ...'")
+        endif()
+    endif()
+endif()

 set(CMAKE_INCLUDE_CURRENT_DIR ON)
+set(CMAKE_CXX_STANDARD 17)

-add_definitions("-std=c++17 -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare")
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Werror -DDEBUG")

 # Allow passing in the version string, for e.g. patched/packaged versions
@ -56,7 +93,7 @@ macro(generate_compressed_bins BASEDIR)
            DEPENDS ${BASEDIR}/${FILE}
        )
        add_custom_command(OUTPUT ${OUTPUT_FILE}
-            COMMAND ${CMAKE_LINKER} -r -b binary -o ${OUTPUT_FILE} ${COMPRESSED_FILE}
+            COMMAND ${CMAKE_LINKER} ${LINKER_EMULATION_FLAGS} -r -b binary -o ${OUTPUT_FILE} ${COMPRESSED_FILE}
            COMMAND ${CMAKE_OBJCOPY}
              --rename-section .data=.rodata.alloc,load,readonly,data,contents
              --add-section .note.GNU-stack=/dev/null
@ -84,15 +121,13 @@ add_custom_command(OUTPUT index_html_size.h

 # Download 3rd-party frontend JS libs...
 file(DOWNLOAD https://cdnjs.cloudflare.com/ajax/libs/vue/2.6.12/vue.min.js
-	js/vue.min.js EXPECTED_MD5 fb192338844efe86ec759a40152fcb8e)
-file(DOWNLOAD https://cdnjs.cloudflare.com/ajax/libs/vue-router/3.4.8/vue-router.min.js
-	js/vue-router.min.js EXPECTED_MD5 5f51d4dbbf68fd6725956a5a2b865f3b)
-file(DOWNLOAD https://raw.githubusercontent.com/drudru/ansi_up/v1.3.0/ansi_up.js
-        js/ansi_up.js EXPECTED_MD5 158566dc1ff8f2804de972f7e841e2f6)
-file(DOWNLOAD https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.7.2/Chart.min.js
-        js/Chart.min.js EXPECTED_MD5 f6c8efa65711e0cbbc99ba72997ecd0e)
+    ${CMAKE_BINARY_DIR}/js/vue.min.js EXPECTED_MD5 fb192338844efe86ec759a40152fcb8e)
+file(DOWNLOAD https://raw.githubusercontent.com/drudru/ansi_up/v4.0.4/ansi_up.js
+    ${CMAKE_BINARY_DIR}/js/ansi_up.js EXPECTED_MD5 b31968e1a8fed0fa82305e978161f7f5)
+file(DOWNLOAD https://cdnjs.cloudflare.com/ajax/libs/Chart.js/3.9.1/chart.min.js
+    ${CMAKE_BINARY_DIR}/js/Chart.min.js EXPECTED_MD5 7dd5ea7d2cf22a1c42b43c40093d2669)
 # ...and compile them
-generate_compressed_bins(${CMAKE_BINARY_DIR} js/vue-router.min.js js/vue.min.js
+generate_compressed_bins(${CMAKE_BINARY_DIR} js/vue.min.js
    js/ansi_up.js js/Chart.min.js)
 # (see resources.cpp where these are fetched)

@ -111,13 +146,31 @@ set(LAMINARD_CORE_SOURCES
    index_html_size.h
 )

+find_package(CapnProto REQUIRED)
+include_directories(${CAPNP_INCLUDE_DIRS})
+
+find_package(SQLite3 REQUIRED)
+include_directories(${SQLite3_INCLUDE_DIRS})
+
+find_package(ZLIB REQUIRED)
+include_directories(${ZLIB_INCLUDE_DIRS})
+
+find_package(Threads REQUIRED)
+include_directories(${Threads_INCLUDE_DIRS})
+
 ## Server
 add_executable(laminard ${LAMINARD_CORE_SOURCES} src/main.cpp ${COMPRESSED_BINS})
-target_link_libraries(laminard capnp-rpc capnp kj-http kj-async kj pthread sqlite3 z)
+target_link_libraries(laminard CapnProto::capnp-rpc CapnProto::capnp CapnProto::kj-http CapnProto::kj-async 
+                               CapnProto::kj Threads::Threads SQLite::SQLite3 ZLIB::ZLIB)
+
+if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
+    pkg_check_modules(INOTIFY REQUIRED libinotify)
+    target_link_libraries(laminard ${INOTIFY_LINK_LIBRARIES})
+endif()

 ## Client
 add_executable(laminarc src/client.cpp src/version.cpp laminar.capnp.c++)
-target_link_libraries(laminarc capnp-rpc capnp kj-async kj pthread)
+target_link_libraries(laminarc CapnProto::capnp-rpc CapnProto::capnp CapnProto::kj-async CapnProto::kj Threads::Threads)

 ## Manpages
 macro(gzip SOURCE)
@ -138,10 +191,9 @@ if(BUILD_TESTS)
    find_package(GTest REQUIRED)
    include_directories(${GTEST_INCLUDE_DIRS} src)
    add_executable(laminar-tests ${LAMINARD_CORE_SOURCES} ${COMPRESSED_BINS} test/main.cpp test/laminar-functional.cpp test/unit-conf.cpp test/unit-database.cpp)
-    target_link_libraries(laminar-tests ${GTEST_LIBRARY} capnp-rpc capnp kj-http kj-async kj pthread sqlite3 z)
+    target_link_libraries(laminar-tests ${GTEST_LIBRARIES} capnp-rpc capnp kj-http kj-async kj pthread sqlite3 z)
 endif()

-set(SYSTEMD_UNITDIR /lib/systemd/system CACHE PATH "Path to systemd unit files")
 set(BASH_COMPLETIONS_DIR /usr/share/bash-completion/completions CACHE PATH "Path to bash completions directory")
 set(ZSH_COMPLETIONS_DIR /usr/share/zsh/site-functions CACHE PATH "Path to zsh completions directory")
 install(TARGETS laminard RUNTIME DESTINATION sbin)
@ -150,5 +202,8 @@ install(FILES etc/laminar.conf DESTINATION /etc)
 install(FILES etc/laminarc-completion.bash DESTINATION ${BASH_COMPLETIONS_DIR} RENAME laminarc)
 install(FILES etc/laminarc-completion.zsh DESTINATION ${ZSH_COMPLETIONS_DIR} RENAME _laminarc)

-configure_file(etc/laminar.service.in laminar.service @ONLY)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/laminar.service DESTINATION ${SYSTEMD_UNITDIR})
+if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+    set(SYSTEMD_UNITDIR /lib/systemd/system CACHE PATH "Path to systemd unit files")
+    configure_file(etc/laminar.service.in laminar.service @ONLY)
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/laminar.service DESTINATION ${SYSTEMD_UNITDIR})
+endif()
--- a/README.md
+++ b/README.md
@ -12,11 +12,11 @@ See [the website](https://laminar.ohwg.net) and the [documentation](https://lami

 First install development packages for `capnproto (version 0.7.0 or newer)`, `rapidjson`, `sqlite` and `boost` (for the header-only `multi_index_container` library) from your distribution's repository or other source.

-On Debian Buster, this can be done with:
+On Debian Bookworm, this can be done with:

 ```bash
-sudo apt install \
-		 capnproto cmake g++ libboost-dev libcapnp-dev libsqlite-dev libsqlite3-dev make rapidjson-dev zlib1g-dev
+sudo apt install capnproto cmake g++ libboost-dev libcapnp-dev libsqlite3-dev \
+  make rapidjson-dev zlib1g-dev pkg-config
 ```

 Then compile and install laminar with:
@ -25,7 +25,7 @@ Then compile and install laminar with:
 git clone https://github.com/ohwgiles/laminar.git
 cd laminar
 cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr
-make -j4
+make -j "$(nproc)"
 # Warning: the following will overwrite an existing /etc/laminar.conf
 sudo make install
 ```
--- a/UserManual.md
+++ b/UserManual.md
@ -17,24 +17,26 @@ Throughout this document, the fixed base path `/var/lib/laminar` is used. This i

 # Installing Laminar

-Pre-built packages are available for Debian 9 (Stretch) and CentOS 7 on x86_64. Alternatively, Laminar may be built from source for any Linux distribution.
+Since Debian Bullseye, Laminar is available in [the official repositories](https://packages.debian.org/search?searchon=sourcenames&keywords=laminar).

-## Installation from binaries
+Alternatively, pre-built upstream packages are available for Debian 10 (Buster) on x86_64 and armhf, and for Rocky/CentOS/RHEL 7 and 8 on x86_64.

-Alternatively to the source-based approach shown above, precompiled packages are supplied for x86_64 Debian 9 (Stretch) and CentOS 7
+Finally, Laminar may be built from source for any Linux distribution.
+
+## Installation from upstream packages

 Under Debian:

 ```bash
-wget https://github.com/ohwgiles/laminar/releases/download/0.6/laminar-0.6-1-amd64.deb
-sudo apt install laminar-0.6-1-amd64.deb
+wget https://github.com/ohwgiles/laminar/releases/download/1.1/laminar_1.1-1.upstream-debian10_amd64.deb
+sudo apt install ./laminar_1.1-1.upstream-debian10_amd64.deb
 ```

-Under CentOS:
+Under Rocky/CentOS/RHEL:

 ```bash
-wget https://github.com/ohwgiles/laminar/releases/download/0.5/laminar-0.6-1.x86_64.rpm
-sudo yum install laminar-0.6-1.x86_64.rpm
+wget https://github.com/ohwgiles/laminar/releases/download/1.1/laminar-1.1.upstream_rocky8-1.x86_64.rpm
+sudo dnf install ./laminar-1.1.upstream_rocky8-1.x86_64.rpm
 ```

 Both install packages will create a new `laminar` user and install (but not activate) a systemd service for launching the laminar daemon.
@ -86,7 +88,7 @@ Laminar's configuration file may be found at `/etc/laminar.conf`. Laminar will s

 Edit `/etc/laminar.conf` and change `LAMINAR_BIND_HTTP` to `IPADDR:PORT`, `unix:PATH/TO/SOCKET` or `unix-abstract:SOCKETNAME`. `IPADDR` may be `*` to bind on all interfaces. The default is `*:8080`.

-Do not attempt to run laminar on port 80. This requires running as `root`, and Laminar will not drop privileges when executing job scripts! For a more complete integrated solution (including SSL), run laminar as a reverse proxy behind a regular webserver.
+Do not attempt to run laminar on port 80. This requires running as `root`, and Laminar will not drop privileges when executing job scripts! For a more complete integrated solution (including SSL), run laminar behind a regular webserver acting as a reverse proxy.

 ## Running behind a reverse proxy

@ -94,10 +96,12 @@ A reverse proxy is required if you want Laminar to share a port with other web s

 If you use [artefacts](#Archiving-artefacts), note that Laminar is not designed as a file server, and better performance will be achieved by allowing the frontend web server to serve the archive directory directly (e.g. using a `Location` directive).

-Laminar uses Sever Sent Events to provide a responsive, auto-updating display without polling. Most frontend webservers should handle this without any extra configuration.
+Laminar uses Server Sent Events to provide a responsive, auto-updating display without polling. Most frontend webservers should handle this without any extra configuration.

 If you use a reverse proxy to host Laminar at a subfolder instead of a subdomain root, the `<base href>` needs to be updated to ensure all links point to their proper targets. This can be done by setting `LAMINAR_BASE_URL` in `/etc/laminar.conf`.

+See [this example configuration file for nginx](https://github.com/ohwgiles/laminar/blob/master/examples/nginx-ssl-reverse-proxy.conf).
+
 ## More configuration options

 See the [reference section](#Service-configuration-file)
@ -196,6 +200,8 @@ This is what [git hooks](https://git-scm.com/book/gr/v2/Customizing-Git-Git-Hook
 LAMINAR_REASON="Push to git repository" laminarc queue example-build
 ```

+For a more advanced example, see [examples/git-post-receive-hook-notes](https://github.com/ohwgiles/laminar/blob/master/examples/git-post-receive-hook-notes)
+
 What if your git server is not the same machine as the laminar instance?

 ## Triggering on a remote laminar instance
@ -216,13 +222,13 @@ Then, point `laminarc` to the new location using an environment variable:
 LAMINAR_HOST=192.168.1.1:9997 laminarc queue example
 ```

-If you need more flexibility, consider running the communication channel as a regular unix socket and applying user and group permissions to the file. To achieve this, set
+If you need more flexibility, consider running the communication channel as a regular unix socket. Setting

 ```
 LAMINAR_BIND_RPC=unix:/var/run/laminar.sock
 ```

-or similar path in `/etc/laminar.conf`.
+or similar path in `/etc/laminar.conf` will result in a socket with group read/write permissions (`660`), so any user in the `laminar` group can queue a job.

 This can be securely and flexibly combined with remote triggering using `ssh`. There is no need to allow the client full shell access to the server machine, the ssh server can restrict certain users to certain commands (in this case `laminarc`). See [the authorized_keys section of the sshd man page](https://man.openbsd.org/sshd#AUTHORIZED_KEYS_FILE_FORMAT) for further information.

@ -240,7 +246,7 @@ Additionally, the raw log output may be fetched over a plain HTTP request to htt

 # Job chains

-A typical pipeline may involve several steps, such as build, test and deploy. Depending on the project, these may be broken up into seperate laminar jobs for maximal flexibility.
+A typical pipeline may involve several steps, such as build, test and deploy. Depending on the project, these may be broken up into separate laminar jobs for maximal flexibility.

 The preferred way to accomplish this in Laminar is to use the same method as [regular run triggering](#Triggering-a-run), that is, calling `laminarc` directly in your `example.run` scripts.

@ -366,7 +372,7 @@ fi

 Of course, you can make this as pretty as you like. A [helper script](#Helper-scripts) can be a good choice here.

-If you want to send to different addresses dependending on the job, replace `engineering@company.com` above with a variable, e.g. `$RECIPIENTS`, and set `RECIPIENTS=nora@company.com,joe@company.com` in `/var/lib/laminar/cfg/jobs/JOB.env`. See [Environment variables](#Environment-variables).
+If you want to send to different addresses depending on the job, replace `engineering@company.com` above with a variable, e.g. `$RECIPIENTS`, and set `RECIPIENTS=nora@company.com,joe@company.com` in `/var/lib/laminar/cfg/jobs/JOB.env`. See [Environment variables](#Environment-variables).

 You could also update the `$RECIPIENTS` variable dynamically based on the build itself. For example, if your run script accepts a parameter `$rev` which is a git commit id, as part of your job's `.after` script you could do the following:

@ -375,7 +381,7 @@ author_email=$(git show -s --format='%ae' $rev)
 laminarc set RECIPIENTS $author_email
 ```

-See [notify-email-pretty.sh](https://github.com/ohwgiles/laminar/blob/master/examples/notify-email-pretty.sh) and [notify-email-text-log.sh](https://github.com/ohwgiles/laminar/blob/master/examples/notify-email-text-log.sh).
+See [examples/notify-email-pretty](https://github.com/ohwgiles/laminar/blob/master/examples/notify-email-pretty) and [examples/notify-email-text-log](https://github.com/ohwgiles/laminar/blob/master/examples/notify-email-text-log).

 ---

@ -528,7 +534,7 @@ If `CONTEXTS` is empty or absent (or if `JOB.conf` doesn't exist), laminar will

 ## Adding environment to a context

-Append desired environment variables to `/var/lib/laminar/cfg/contexts/CONTEXT_NAME.conf`:
+Append desired environment variables to `/var/lib/laminar/cfg/contexts/CONTEXT_NAME.env`:

 ```
 DUT_IP=192.168.3.2
@ -588,6 +594,8 @@ docker run --rm -ti -v $PWD:/root ubuntu /bin/bash -xe <<EOF
 EOF
 ```

+For more advanced usage, see [examples/docker-advanced](https://github.com/ohwgiles/laminar/blob/master/examples/docker-advanced)
+
 ---

 # Colours in log output
@ -705,6 +713,7 @@ Finally, variables supplied on the command-line call to `laminarc queue`, `lamin
 - `queue [JOB [PARAMS...]]...` adds one or more jobs to the queue with optional parameters, returning immediately.
 - `start [JOB [PARAMS...]]...` starts one or more jobs with optional parameters, returning when the jobs begin execution.
 - `run [JOB [PARAMS...]]...` triggers one or more jobs with optional parameters and waits for the completion of all jobs.
+- `--next` may be passed before `JOB` in order to place the job at the front of the queue instead of at the end.
 - `set [VARIABLE=VALUE]...` sets one or more variables to be exported in subsequent scripts for the run identified by the `$JOB` and `$RUN` environment variables
 - `show-jobs` shows the known jobs on the server (`$LAMINAR_HOME/cfg/jobs/*.run`).
 - `show-running` shows the currently running jobs with their numbers.
--- a/etc/laminar.service.in
+++ b/etc/laminar.service.in
@ -1,11 +1,13 @@
 [Unit]
 Description=Laminar continuous integration service
 After=network.target
+Documentation=man:laminard(8)
+Documentation=https://laminar.ohwg.net/docs.html

 [Service]
 User=laminar
 EnvironmentFile=-/etc/laminar.conf
-ExecStart=@CMAKE_INSTALL_PREFIX@/sbin/laminard
+ExecStart=@CMAKE_INSTALL_PREFIX@/sbin/laminard -v

 [Install]
 WantedBy=multi-user.target
--- a/etc/laminarc.1
+++ b/etc/laminarc.1
@ -6,8 +6,8 @@
 Laminar CI client application
 .Sh SYNOPSIS
 .Nm laminarc Li queue \fIJOB\fR [\fIPARAM=VALUE...\fR] ...
-.Nm laminarc Li queue \fIJOB\fR [\fIPARAM=VALUE...\fR] ...
-.Nm laminarc Li queue \fIJOB\fR [\fIPARAM=VALUE...\fR] ...
+.Nm laminarc Li start \fIJOB\fR [\fIPARAM=VALUE...\fR] ...
+.Nm laminarc Li run \fIJOB\fR [\fIPARAM=VALUE...\fR] ...
 .Nm laminarc Li set \fIPARAM=VALUE...\fR
 .Nm laminarc Li show-jobs
 .Nm laminarc Li show-running
@ -27,6 +27,9 @@ begin execution.
 adds job(s) (with optional parameters) to the queue and returns when the jobs
 complete execution. The exit code will be non-zero if any of the runs does
 not complete successfully.
+.It \t
+\fB--next\fR may be passed to \fBqueue\fR, \fBstart\fR or \fBrun\fR in order
+to place the job at the front of the queue instead of at the end.
 .It Sy set
 sets one or more parameters to be exported as environment variables in subsequent
 scripts for the run identified by the $JOB and $RUN environment variables.
@ -47,14 +50,14 @@ The laminar server to connect to is read from the
 environment variable. If empty, it falls back to
 .Ev LAMINAR_BIND_RPC
 and finally defaults to
-.Ad
-unix-abstract:laminar.
+.Ad unix-abstract:laminar
 .Sh ENVIRONMENT
 .Bl -tag
 .It Ev LAMINAR_HOST
 address of server to connect. May be of the form
 .Ad IP:PORT,
-.Ad unix:PATH/TO/SOCKET or
+.Ad unix:PATH/TO/SOCKET
+or
 .Ad unix-abstract:NAME
 .It Ev LAMINAR_BIND_RPC
 fallback server address variable. It is set by
--- a/examples/docker-advanced
+++ b/examples/docker-advanced
@ -0,0 +1,53 @@
+#!/bin/bash -eu
+
+# Any failing command in a pipe will cause an error, instead
+# of just an error in the last command in the pipe
+set -o pipefail
+
+# Log commands executed
+set -x
+
+# Simple way of getting the docker build tag:
+tag=$(docker build -q - <<\EOF
+	FROM debian:bookworm
+	RUN apt-get update && apt-get install -y build-essential
+EOF
+)
+
+# But -q suppresses the log output. If you want to keep it,
+# you could use the following fancier way:
+
+exec {pfd}<><(:) # get a new pipe
+docker build - <<\EOF |
+	FROM debian:bookworm
+	RUN apt-get update && apt-get install -y build-essential
+EOF
+tee >(awk '/Successfully built/{print $3}' >&$pfd) # parse output to pipe
+read tag <&$pfd # read tag back from pipe
+exec {pfd}<&- # close pipe
+
+# Alternatively, you can use the -t option to docker build
+# to give the built image a name to refer to later. But then
+# you need to ensure that it does not conflict with any other
+# images, and handle cases where multiple instances of the
+# job attempt to update the tagged image.
+
+# If you want the image to be cleaned up on exit:
+trap "docker rmi $tag" EXIT
+
+# Now use the image to build something:
+docker run -i --rm \
+	-v "$PWD:$PWD" \
+	-w "$PWD" \
+	-u $(id -u):$(id -g) \
+	$tag /bin/bash -eux \
+<<EOF
+	# The passed options mean we keep our current working
+	# directory and user, so no permission problems on the
+	# artifacts produced within the container.
+	echo 'main(){puts("hello world");}' | gcc -x c -static -o hello -
+EOF
+
+# Test the result
+./hello
+
--- a/examples/git-post-receive-hook-notes
+++ b/examples/git-post-receive-hook-notes
@ -0,0 +1,42 @@
+#!/bin/bash -e
+# Simple post-receive hook that triggers a laminar run
+# for every commit pushed to every branch, and annotates
+# the commit with the run number using a git note.
+# On the cloned repository, useful config is
+#  git config --add remote.origin.fetch "+refs/notes/*:refs/notes/*"
+# to automatically fetch all notes from the origin, and
+#  git config --add notes.displayRef "refs/notes/*"
+# to display all notes in the git log by default
+
+# The laminar job to trigger
+LAMINAR_JOB=my-project
+
+# Default notes ref is refs/notes/commits
+NOTES_REF=refs/notes/ci
+
+# For each ref pushed...
+while read old new ref; do
+	# Skip tags, notes, etc. Only do heads.
+	# Extend this to only trigger on specific branches.
+	if [[ $ref != refs/heads/* ]]; then
+		continue
+	fi
+	# Otherwise, for each new commit in the ref...
+	# (to only trigger on the newest, set commit=$new and delete the loop)
+	git rev-list $([[ $old =~ ^0+$ ]] && echo $new || echo $old..$new) | while read commit; do
+		# Queue the laminar run
+		run=$(laminarc queue $LAMINAR_JOB commit=$commit ref=$ref)
+		echo "Started Laminar $run for commit $commit to ref $ref"
+
+		# Add a git note about the run
+		blob=$(echo -n "Laminar-Run: $run" | git hash-object -w --stdin)
+		if last_note=$(git show-ref -s $NOTES_REF); then
+			git read-tree $last_note
+			p_arg=-p
+		fi
+		git update-index --add --cacheinfo 100644 $blob $commit
+		tree=$(git write-tree)
+		new_note=$(echo "Notes added by post-receive hook" | git commit-tree $tree $p_arg $last_note)
+		git update-ref $NOTES_REF $new_note $last_note
+	done
+done
--- a/examples/nginx-ssl-reverse-proxy.conf
+++ b/examples/nginx-ssl-reverse-proxy.conf
@ -0,0 +1,52 @@
+server {
+  listen [::]:80;
+  listen 80;
+  server_name laminar.example.com;
+
+  # rule for letsencrypt ACME challenge requests
+  location ^~ /.well-known/acme-challenge/ {
+    default_type "text/plain";
+    alias /srv/www/acme-challenge/;
+  }
+
+  # redirect all other http to https
+  return 301 https://$server_name$request_uri;
+}
+
+server {
+  # http2 is recommended because browsers will only open a small number of concurrent SSE streams over http1
+  listen [::]:443 ssl http2;
+  listen 443 ssl http2;
+  server_name laminar.example.com;
+
+  # modern tls only, see https://syslink.pl/cipherlist/ for a more complete example
+  ssl_protocols TLSv1.3;
+  ssl_ciphers EECDH+AESGCM:EDH+AESGCM;
+
+  # set according to ACME/letsencrypt client
+  ssl_certificate /path/to/certificate.crt;
+  ssl_certificate_key /path/to/private.key;
+
+  # use "location /" if laminar is to be accessible at the (sub)domain root.
+  # alteratively, use a subdirectory such as "location /my-laminar/" and ensure that
+  # LAMINAR_BASE_URL=/my-laminar/ accordingly.
+  location / {
+    # set proxy_pass according to LAMINAR_BIND_HTTP.
+    # note that the laminar default for LAMINAR_BIND_HTTP is *:8080, which binds on all interfaces
+    # instead of just the loopback device and is almost certainly not what you want if you are using
+    # a reverse proxy. It should be set to 127.0.0.1:8080 at a minimum, or use unix sockets for more
+    # fine-grained control of permissions.
+    # see http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_pass
+    # and https://laminar.ohwg.net/docs.html#Running-on-a-different-HTTP-port-or-Unix-socket
+    proxy_pass http://127.0.0.1:8080/;
+
+    # required to allow laminar's SSE stream to pass correctly
+    proxy_http_version 1.1;
+    proxy_set_header Connection "";
+  }
+
+  # have nginx serve artefacts directly rather than having laminard do it
+  location /archive/ {
+    alias /var/lib/laminar/archive/;
+  }
+}
--- a/examples/notify-email-pretty.sh
+++ b/examples/notify-email-pretty.sh
--- a/examples/notify-email-text-log.sh
+++ b/examples/notify-email-text-log.sh
--- a/examples/notify-telegram.sh
+++ b/examples/notify-telegram.sh
--- a/pkg/debian11-amd64.sh
+++ b/pkg/debian11-amd64.sh
@ -4,10 +4,10 @@ OUTPUT_DIR=$PWD

 SOURCE_DIR=$(readlink -f $(dirname ${BASH_SOURCE[0]})/..)

-VERSION=$(cd "$SOURCE_DIR" && git describe --tags --abbrev=8 --dirty)-1~upstream-debian10
+VERSION=$(cd "$SOURCE_DIR" && git describe --tags --abbrev=8 --dirty)-1~upstream-debian11

 DOCKER_TAG=$(docker build -q - <<EOS
-FROM debian:10-slim
+FROM debian:11-slim
 RUN apt-get update && apt-get install -y wget cmake g++ capnproto libcapnp-dev rapidjson-dev libsqlite3-dev libboost-dev zlib1g-dev
 EOS
 )
--- a/pkg/debian11-armhf.sh
+++ b/pkg/debian11-armhf.sh
@ -4,10 +4,10 @@ OUTPUT_DIR=$PWD

 SOURCE_DIR=$(readlink -f $(dirname ${BASH_SOURCE[0]})/..)

-VERSION=$(cd "$SOURCE_DIR" && git describe --tags --abbrev=8 --dirty)-1~upstream-debian10
+VERSION=$(cd "$SOURCE_DIR" && git describe --tags --abbrev=8 --dirty)-1~upstream-debian11

 DOCKER_TAG=$(docker build -q - <<EOS
-FROM debian:10-slim
+FROM debian:11-slim
 RUN dpkg --add-architecture armhf && apt-get update && apt-get install -y wget cmake crossbuild-essential-armhf capnproto libcapnp-dev:armhf rapidjson-dev libsqlite3-dev:armhf libboost-dev:armhf zlib1g-dev:armhf
 EOS
 )
--- a/pkg/debian12-amd64.sh
+++ b/pkg/debian12-amd64.sh
@ -0,0 +1,50 @@
+#!/bin/bash -e
+
+set -ex
+
+OUTPUT_DIR=$PWD
+
+SOURCE_DIR=$(readlink -f $(dirname ${BASH_SOURCE[0]})/..)
+
+VERSION=$(cd "$SOURCE_DIR" && git describe --tags --abbrev=8 --dirty)-1~upstream-debian12
+
+DOCKER_TAG=$(docker build -q - <<EOS
+FROM debian:bookworm-slim
+RUN apt-get update && apt-get install -y wget cmake g++ capnproto libcapnp-dev rapidjson-dev libsqlite3-dev libboost-dev zlib1g-dev pkg-config
+EOS
+)
+
+docker run --rm -i -v $SOURCE_DIR:/laminar:ro -v $OUTPUT_DIR:/output $DOCKER_TAG bash -xe <<EOS
+
+mkdir /build
+cd /build
+
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr -DLAMINAR_VERSION=$VERSION -DZSH_COMPLETIONS_DIR=/usr/share/zsh/functions/Completion/Unix /laminar
+make -j4
+mkdir laminar
+make DESTDIR=laminar install/strip
+
+mkdir laminar/DEBIAN
+cat <<EOF > laminar/DEBIAN/control
+Package: laminar
+Version: $VERSION
+Section: 
+Priority: optional
+Architecture: amd64
+Maintainer: Oliver Giles <web ohwg net>
+Depends: libcapnp-1.0.1, libsqlite3-0, zlib1g
+Description: Lightweight Continuous Integration Service
+EOF
+echo /etc/laminar.conf > laminar/DEBIAN/conffiles
+cat <<EOF > laminar/DEBIAN/postinst
+#!/bin/bash
+echo Creating laminar user with home in /var/lib/laminar
+useradd -r -d /var/lib/laminar -s /usr/sbin/nologin laminar
+mkdir -p /var/lib/laminar/cfg/{jobs,contexts,scripts}
+chown -R laminar: /var/lib/laminar
+EOF
+chmod +x laminar/DEBIAN/postinst
+
+dpkg-deb --build laminar
+mv laminar.deb /output/laminar_${VERSION}_amd64.deb
+EOS
--- a/pkg/debian13-amd64.sh
+++ b/pkg/debian13-amd64.sh
@ -0,0 +1,50 @@
+#!/bin/bash -e
+
+set -ex
+
+OUTPUT_DIR=$PWD
+
+SOURCE_DIR=$(readlink -f $(dirname ${BASH_SOURCE[0]})/..)
+
+VERSION=$(cd "$SOURCE_DIR" && git describe --tags --abbrev=8 --dirty)-1~upstream-debian13
+
+DOCKER_TAG=$(docker build -q - <<EOS
+FROM debian:trixie-slim
+RUN apt-get update && apt-get install -y wget cmake g++ capnproto libcapnp-dev rapidjson-dev libsqlite3-dev libboost-dev zlib1g-dev pkg-config
+EOS
+)
+
+docker run --rm -i -v $SOURCE_DIR:/laminar:ro -v $OUTPUT_DIR:/output $DOCKER_TAG bash -xe <<EOS
+
+mkdir /build
+cd /build
+
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr -DLAMINAR_VERSION=$VERSION -DZSH_COMPLETIONS_DIR=/usr/share/zsh/functions/Completion/Unix /laminar
+make -j4
+mkdir laminar
+make DESTDIR=laminar install/strip
+
+mkdir laminar/DEBIAN
+cat <<EOF > laminar/DEBIAN/control
+Package: laminar
+Version: $VERSION
+Section: 
+Priority: optional
+Architecture: amd64
+Maintainer: Oliver Giles <web ohwg net>
+Depends: libcapnp-1.0.1, libsqlite3-0, zlib1g
+Description: Lightweight Continuous Integration Service
+EOF
+echo /etc/laminar.conf > laminar/DEBIAN/conffiles
+cat <<EOF > laminar/DEBIAN/postinst
+#!/bin/bash
+echo Creating laminar user with home in /var/lib/laminar
+useradd -r -d /var/lib/laminar -s /usr/sbin/nologin laminar
+mkdir -p /var/lib/laminar/cfg/{jobs,contexts,scripts}
+chown -R laminar: /var/lib/laminar
+EOF
+chmod +x laminar/DEBIAN/postinst
+
+dpkg-deb --build laminar
+mv laminar.deb /output/laminar_${VERSION}_amd64.deb
+EOS
--- a/pkg/centos8-x86_64.sh
+++ b/pkg/centos8-x86_64.sh
@ -4,11 +4,11 @@ OUTPUT_DIR=$PWD

 SOURCE_DIR=$(readlink -f $(dirname ${BASH_SOURCE[0]})/..)

-VERSION=$(cd "$SOURCE_DIR" && git describe --tags --abbrev=8 --dirty | tr - .)~upstream_centos8
+VERSION=$(cd "$SOURCE_DIR" && git describe --tags --abbrev=8 --dirty | tr - .)~upstream_rocky8

 DOCKER_TAG=$(docker build -q - <<EOS
-FROM centos:8
-RUN dnf -y install rpm-build cmake make gcc-c++ wget sqlite-devel boost-devel zlib-devel
+FROM rockylinux/rockylinux:8
+RUN dnf -y update && dnf -y install rpm-build cmake make gcc-c++ wget sqlite-devel boost-devel zlib-devel
 EOS
 )

@ -27,7 +27,7 @@ tar xzf capnproto.tar.gz
 tar xzf rapidjson.tar.gz

 cd /build/capnproto-0.7.0/c++/
-cmake3 -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=off .
+cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=off .
 make -j4
 make install

--- a/pkg/ubuntu2204-amd64.sh
+++ b/pkg/ubuntu2204-amd64.sh
@ -0,0 +1,49 @@
+#!/bin/bash -e
+
+OUTPUT_DIR=$PWD
+
+SOURCE_DIR=$(readlink -f $(dirname ${BASH_SOURCE[0]})/..)
+
+VERSION=$(cd "$SOURCE_DIR" && git describe --tags --abbrev=8 --dirty)-1~upstream-ubuntu2204
+
+DOCKER_TAG=$(docker build -q - <<EOS
+FROM ubuntu:22.04
+RUN apt-get update && apt-get install -y wget cmake g++ capnproto libcapnp-dev rapidjson-dev libsqlite3-dev libboost-dev zlib1g-dev pkg-config
+EOS
+)
+
+docker run --rm -i -v $SOURCE_DIR:/laminar:ro -v $OUTPUT_DIR:/output $DOCKER_TAG bash -xe <<EOS
+
+mkdir /build
+cd /build
+
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr -DLAMINAR_VERSION=$VERSION -DZSH_COMPLETIONS_DIR=/usr/share/zsh/functions/Completion/Unix /laminar
+make -j4
+mkdir laminar
+make DESTDIR=laminar install/strip
+
+mkdir laminar/DEBIAN
+cat <<EOF > laminar/DEBIAN/control
+Package: laminar
+Version: $VERSION
+Section: 
+Priority: optional
+Architecture: amd64
+Maintainer: Oliver Giles <web ohwg net>
+Depends: libcapnp-0.8.0, libsqlite3-0, zlib1g
+Description: Lightweight Continuous Integration Service
+EOF
+echo /etc/laminar.conf > laminar/DEBIAN/conffiles
+cat <<EOF > laminar/DEBIAN/postinst
+#!/bin/bash
+echo Creating laminar user with home in /var/lib/laminar
+useradd -r -d /var/lib/laminar -s /usr/sbin/nologin laminar
+mkdir -p /var/lib/laminar/cfg/{jobs,contexts,scripts}
+chown -R laminar: /var/lib/laminar
+EOF
+chmod +x laminar/DEBIAN/postinst
+
+dpkg-deb --build laminar
+mv laminar.deb /output/laminar_${VERSION}_amd64.deb
+EOS
+
--- a/pkg/ubuntu2404-amd64.sh
+++ b/pkg/ubuntu2404-amd64.sh
@ -0,0 +1,49 @@
+#!/bin/bash -e
+
+OUTPUT_DIR=$PWD
+
+SOURCE_DIR=$(readlink -f $(dirname ${BASH_SOURCE[0]})/..)
+
+VERSION=$(cd "$SOURCE_DIR" && git describe --tags --abbrev=8 --dirty)-1~upstream-ubuntu2404
+
+DOCKER_TAG=$(docker build -q - <<EOS
+FROM ubuntu:24.04
+RUN apt-get update && apt-get install -y wget cmake g++ capnproto libcapnp-dev rapidjson-dev libsqlite3-dev libboost-dev zlib1g-dev pkg-config
+EOS
+)
+
+docker run --rm -i -v $SOURCE_DIR:/laminar:ro -v $OUTPUT_DIR:/output $DOCKER_TAG bash -xe <<EOS
+
+mkdir /build
+cd /build
+
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr -DLAMINAR_VERSION=$VERSION -DZSH_COMPLETIONS_DIR=/usr/share/zsh/functions/Completion/Unix /laminar
+make -j4
+mkdir laminar
+make DESTDIR=laminar install/strip
+
+mkdir laminar/DEBIAN
+cat <<EOF > laminar/DEBIAN/control
+Package: laminar
+Version: $VERSION
+Section: 
+Priority: optional
+Architecture: amd64
+Maintainer: Oliver Giles <web ohwg net>
+Depends: libcapnp-1.0.1, libsqlite3-0, zlib1g
+Description: Lightweight Continuous Integration Service
+EOF
+echo /etc/laminar.conf > laminar/DEBIAN/conffiles
+cat <<EOF > laminar/DEBIAN/postinst
+#!/bin/bash
+echo Creating laminar user with home in /var/lib/laminar
+useradd -r -d /var/lib/laminar -s /usr/sbin/nologin laminar
+mkdir -p /var/lib/laminar/cfg/{jobs,contexts,scripts}
+chown -R laminar: /var/lib/laminar
+EOF
+chmod +x laminar/DEBIAN/postinst
+
+dpkg-deb --build laminar
+mv laminar.deb /output/laminar_${VERSION}_amd64.deb
+EOS
+
--- a/src/client.cpp
+++ b/src/client.cpp
@ -1,5 +1,5 @@
 ///
-/// Copyright 2015-2020 Oliver Giles
+/// Copyright 2015-2022 Oliver Giles
 ///
 /// This file is part of Laminar
 ///
@ -87,14 +87,16 @@ static void printTriggerLink(const char* job, uint run) {

 static void usage(std::ostream& out) {
    out << "laminarc version " << laminar_version() << "\n";
-    out << "Usage: laminarc [-h|--help] COMMAND [PARAMETERS...]]\n";
+    out << "Usage: laminarc [-h|--help] COMMAND\n";
    out << "  -h|--help       show this help message\n";
    out << "where COMMAND is:\n";
    out << "  queue JOB_LIST...     queues one or more jobs for execution and returns immediately.\n";
    out << "  start JOB_LIST...     queues one or more jobs for execution and blocks until it starts.\n";
    out << "  run JOB_LIST...       queues one or more jobs for execution and blocks until it finishes.\n";
+    out << "                        JOB_LIST may be prepended with --next, in this case the job will\n";
+    out << "                        be pushed to the front of the queue instead of the end.\n";
    out << "  set PARAMETER_LIST... sets the given parameters as environment variables in the currently\n";
-    out << "                        runing job. Fails if run outside of a job context.\n";
+    out << "                        running job. Fails if run outside of a job context.\n";
    out << "  abort NAME NUMBER     aborts the run identified by NAME and NUMBER.\n";
    out << "  show-jobs             lists all known jobs.\n";
    out << "  show-queued           lists currently queued jobs.\n";
@ -132,16 +134,25 @@ int main(int argc, char** argv) {

    auto& waitScope = client.getWaitScope();

-    if(strcmp(argv[1], "queue") == 0) {
-        if(argc < 3) {
-            fprintf(stderr, "Usage %s queue <jobName>\n", argv[0]);
+    int jobNameIndex = 2;
+    bool frontOfQueue = false;
+
+    if(strcmp(argv[1], "queue") == 0 || strcmp(argv[1], "start") == 0 || strcmp(argv[1], "run") == 0) {
+        if(argc < 3 || (strcmp(argv[2], "--next") == 0 && argc < 4)) {
+            fprintf(stderr, "Usage %s %s JOB_LIST...\n", argv[0], argv[1]);
            return EXIT_BAD_ARGUMENT;
        }
-        int jobNameIndex = 2;
-        // make a request for each job specified on the commandline
+        if(strcmp(argv[2], "--next") == 0) {
+            frontOfQueue = true;
+            jobNameIndex++;
+        }
+    }
+
+    if(strcmp(argv[1], "queue") == 0) {
        do {
            auto req = laminar.queueRequest();
            req.setJobName(argv[jobNameIndex]);
+            req.setFrontOfQueue(frontOfQueue);
            int n = setParams(argc - jobNameIndex - 1, &argv[jobNameIndex + 1], req);
            ts.add(req.send().then([&ret,argv,jobNameIndex](capnp::Response<LaminarCi::QueueResults> resp){
                if(resp.getResult() != LaminarCi::MethodResult::SUCCESS) {
@ -153,16 +164,10 @@ int main(int argc, char** argv) {
            jobNameIndex += n + 1;
        } while(jobNameIndex < argc);
    } else if(strcmp(argv[1], "start") == 0) {
-        if(argc < 3) {
-            fprintf(stderr, "Usage %s queue <jobName>\n", argv[0]);
-            return EXIT_BAD_ARGUMENT;
-        }
-        kj::Vector<capnp::RemotePromise<LaminarCi::StartResults>> promises;
-        int jobNameIndex = 2;
-        // make a request for each job specified on the commandline
        do {
            auto req = laminar.startRequest();
            req.setJobName(argv[jobNameIndex]);
+            req.setFrontOfQueue(frontOfQueue);
            int n = setParams(argc - jobNameIndex - 1, &argv[jobNameIndex + 1], req);
            ts.add(req.send().then([&ret,argv,jobNameIndex](capnp::Response<LaminarCi::StartResults> resp){
                if(resp.getResult() != LaminarCi::MethodResult::SUCCESS) {
@ -174,21 +179,16 @@ int main(int argc, char** argv) {
            jobNameIndex += n + 1;
        } while(jobNameIndex < argc);
    } else if(strcmp(argv[1], "run") == 0) {
-        if(argc < 3) {
-            fprintf(stderr, "Usage %s run <jobName>\n", argv[0]);
-            return EXIT_BAD_ARGUMENT;
-        }
-        int jobNameIndex = 2;
-        // make a request for each job specified on the commandline
        do {
            auto req = laminar.runRequest();
            req.setJobName(argv[jobNameIndex]);
+            req.setFrontOfQueue(frontOfQueue);
            int n = setParams(argc - jobNameIndex - 1, &argv[jobNameIndex + 1], req);
            ts.add(req.send().then([&ret,argv,jobNameIndex](capnp::Response<LaminarCi::RunResults> resp){
                if(resp.getResult() == LaminarCi::JobResult::UNKNOWN)
                    fprintf(stderr, "Failed to start job '%s'\n", argv[2]);
-		else
-		    printTriggerLink(argv[jobNameIndex], resp.getBuildNum());
+                else
+                    printTriggerLink(argv[jobNameIndex], resp.getBuildNum());
                if(resp.getResult() != LaminarCi::JobResult::SUCCESS)
                    ret = EXIT_RUN_FAILED;
            }));
@ -233,7 +233,7 @@ int main(int argc, char** argv) {
        }
        auto queued = laminar.listQueuedRequest().send().wait(waitScope);
        for(auto it : queued.getResult()) {
-            printf("%s\n", it.cStr());
+            printf("%s:%d\n", it.getJob().cStr(), it.getBuildNum());
        }
    } else if(strcmp(argv[1], "show-running") == 0) {
        if(argc != 2) {
--- a/src/database.cpp
+++ b/src/database.cpp
@ -21,6 +21,7 @@
 #include <sqlite3.h>
 #include <string.h>
 #include <math.h>
+#include <cstdint>

 struct StdevCtx {
    double mean;
--- a/src/http.cpp
+++ b/src/http.cpp
@ -131,9 +131,16 @@ kj::Promise<void> Http::cleanupPeers(kj::Timer& timer)
 {
    return timer.afterDelay(15 * kj::SECONDS).then([&]{
        for(EventPeer* p : eventPeers) {
-            // an empty SSE message is a colon followed by two newlines
-            p->pendingOutput.push_back(":\n\n");
-            p->fulfiller->fulfill();
+            // Even single threaded, if load causes this timeout to be serviced
+            // before writeEvents has created a fulfiller, or if an exception
+            // caused the destruction of the promise but attach(peer) hasn't yet
+            // removed it from the eventPeers list, we will see a null fulfiller
+            // here
+            if(p->fulfiller) {
+                // an empty SSE message is a colon followed by two newlines
+                p->pendingOutput.push_back(":\n\n");
+                p->fulfiller->fulfill();
+            }
        }
        return cleanupPeers(timer);
    }).eagerlyEvaluate(nullptr);
@ -221,9 +228,6 @@ kj::Promise<void> Http::request(kj::HttpMethod method, kj::StringPtr url, const
            return stream->write(array.begin(), array.size()).attach(kj::mv(array)).attach(kj::mv(file)).attach(kj::mv(stream));
        }
    } else if(parseLogEndpoint(url, name, num)) {
-        auto lw = kj::heap<WithSetRef<LogWatcher>>(logWatchers);
-        lw->job = name;
-        lw->run = num;
        bool complete;
        std::string output;
        if(laminar.handleLogRequest(name, num, output, complete)) {
@ -232,11 +236,16 @@ kj::Promise<void> Http::request(kj::HttpMethod method, kj::StringPtr url, const
            // Disables nginx reverse-proxy's buffering. Necessary for dynamic log output.
            responseHeaders.add("X-Accel-Buffering", "no");
            auto stream = response.send(200, "OK", responseHeaders, nullptr);
-            return stream->write(output.data(), output.size()).then([=,s=stream.get(),c=lw.get()]{
+            auto s = stream.get();
+            auto lw = kj::heap<WithSetRef<LogWatcher>>(logWatchers);
+            lw->job = name;
+            lw->run = num;
+            auto promise = writeLogChunk(lw.get(), stream.get()).attach(kj::mv(stream)).attach(kj::mv(lw));
+            return s->write(output.data(), output.size()).attach(kj::mv(output)).then([p=kj::mv(promise),complete]() mutable {
                if(complete)
                    return kj::Promise<void>(kj::READY_NOW);
-                return writeLogChunk(c, s);
-            }).attach(kj::mv(output)).attach(kj::mv(stream)).attach(kj::mv(lw));
+                return kj::mv(p);
+            });
        }
    } else if(resources->handleRequest(url.cStr(), &start, &end, &content_type)) {
        responseHeaders.set(kj::HttpHeaderId::CONTENT_TYPE, content_type);
@ -288,7 +297,7 @@ void Http::notifyLog(std::string job, uint run, std::string log_chunk, bool eot)
 {
    for(LogWatcher* lw : logWatchers) {
        if(lw->job == job && lw->run == run) {
-            lw->pendingOutput.push_back(kj::mv(log_chunk));
+            lw->pendingOutput.push_back(log_chunk);
            lw->fulfiller->fulfill(kj::mv(eot));
        }
    }
--- a/src/laminar.capnp
+++ b/src/laminar.capnp
@ -2,10 +2,10 @@

 interface LaminarCi {

-    queue @0 (jobName :Text, params :List(JobParam)) -> (result :MethodResult, buildNum :UInt32);
-    start @1 (jobName :Text, params :List(JobParam)) -> (result :MethodResult, buildNum :UInt32);
-    run @2 (jobName :Text, params :List(JobParam)) -> (result :JobResult, buildNum :UInt32);
-    listQueued @3 () -> (result :List(Text));
+    queue @0 (jobName :Text, params :List(JobParam), frontOfQueue :Bool) -> (result :MethodResult, buildNum :UInt32);
+    start @1 (jobName :Text, params :List(JobParam), frontOfQueue :Bool) -> (result :MethodResult, buildNum :UInt32);
+    run @2 (jobName :Text, params :List(JobParam), frontOfQueue :Bool) -> (result :JobResult, buildNum :UInt32);
+    listQueued @3 () -> (result :List(Run));
    listRunning @4 () -> (result :List(Run));
    listKnown @5 () -> (result :List(Text));
    abort @6 (run :Run) -> (result :MethodResult);
--- a/src/laminar.cpp
+++ b/src/laminar.cpp
@ -1,5 +1,5 @@
 ///
-/// Copyright 2015-2020 Oliver Giles
+/// Copyright 2015-2022 Oliver Giles
 ///
 /// This file is part of Laminar
 ///
@ -95,11 +95,31 @@ Laminar::Laminar(Server &server, Settings settings) :
    db = new Database((homePath/"laminar.sqlite").toString(true).cStr());
    // Prepare database for first use
    // TODO: error handling
-    db->exec("CREATE TABLE IF NOT EXISTS builds("
-             "name TEXT, number INT UNSIGNED, node TEXT, queuedAt INT, "
-             "startedAt INT, completedAt INT, result INT, output TEXT, "
-             "outputLen INT, parentJob TEXT, parentBuild INT, reason TEXT, "
-             "PRIMARY KEY (name, number))");
+    const char *create_table_stmt =
+        "CREATE TABLE IF NOT EXISTS builds("
+        "name TEXT, number INT UNSIGNED, node TEXT, queuedAt INT, "
+        "startedAt INT, completedAt INT, result INT, output TEXT, "
+        "outputLen INT, parentJob TEXT, parentBuild INT, reason TEXT, "
+        "PRIMARY KEY (name, number DESC))";
+    db->exec(create_table_stmt);
+
+    // Migrate from (name, number) primary key to (name, number DESC).
+    // SQLite does not allow to alter primary key of existing table, so
+    // we have to create a new table.
+    db->stmt("SELECT sql LIKE '%, PRIMARY KEY (name, number))' "
+             "FROM sqlite_master WHERE type = 'table' AND name = 'builds'")
+    .fetch<int>([&](int has_old_index) {
+        if (has_old_index) {
+            LLOG(INFO, "Migrating table to the new primary key");
+            db->exec("BEGIN TRANSACTION");
+            db->exec("ALTER TABLE builds RENAME TO builds_old");
+            db->exec(create_table_stmt);
+            db->exec("INSERT INTO builds SELECT * FROM builds_old");
+            db->exec("DROP TABLE builds_old");
+            db->exec("COMMIT");
+        }
+    });
+
    db->exec("CREATE INDEX IF NOT EXISTS idx_completion_time ON builds("
             "completedAt DESC)");

@ -203,18 +223,21 @@ std::list<std::string> Laminar::listKnownJobs() {
    return res;
 }

-void Laminar::populateArtifacts(Json &j, std::string job, uint num) const {
+void Laminar::populateArtifacts(Json &j, std::string job, uint num, kj::Path subdir) const {
    kj::Path runArchive{job,std::to_string(num)};
+    runArchive = runArchive.append(subdir);
    KJ_IF_MAYBE(dir, fsHome->tryOpenSubdir("archive"/runArchive)) {
        for(kj::StringPtr file : (*dir)->listNames()) {
            kj::FsNode::Metadata meta = (*dir)->lstat(kj::Path{file});
-            if(meta.type != kj::FsNode::Type::FILE)
-                continue;
-            j.StartObject();
-            j.set("url", archiveUrl + (runArchive/file).toString().cStr());
-            j.set("filename", file.cStr());
-            j.set("size", meta.size);
-            j.EndObject();
+            if(meta.type == kj::FsNode::Type::FILE) {
+                j.StartObject();
+                j.set("url", archiveUrl + (runArchive/file).toString().cStr());
+                j.set("filename", (subdir/file).toString().cStr());
+                j.set("size", meta.size);
+                j.EndObject();
+            } else if(meta.type == kj::FsNode::Type::DIRECTORY) {
+                populateArtifacts(j, job, num, subdir/file);
+            }
        }
    }
 }
@ -303,13 +326,17 @@ std::string Laminar::getStatus(MonitorScope scope) {
            j.EndObject();
        }
        j.EndArray();
-        int nQueued = 0;
+        j.startArray("queued");
        for(const auto& run : queuedJobs) {
            if (run->name == scope.job) {
-                nQueued++;
+                j.StartObject();
+                j.set("number", run->build);
+                j.set("result", to_string(RunState::QUEUED));
+                j.set("reason", run->reason());
+                j.EndObject();
            }
        }
-        j.set("nQueued", nQueued);
+        j.EndArray();
        db->stmt("SELECT number,startedAt FROM builds WHERE name = ? AND result = ? "
                 "ORDER BY completedAt DESC LIMIT 1")
        .bind(scope.job, int(RunState::SUCCESS))
@ -331,9 +358,8 @@ std::string Laminar::getStatus(MonitorScope scope) {
        j.set("description", desc == jobDescriptions.end() ? "" : desc->second);
    } else if(scope.type == MonitorScope::ALL) {
        j.startArray("jobs");
-        db->stmt("SELECT name,number,startedAt,completedAt,result,reason FROM builds b "
-                 "JOIN (SELECT name n,MAX(number) latest FROM builds WHERE result IS NOT NULL GROUP BY n) q "
-                 "ON b.name = q.n AND b.number = latest")
+        db->stmt("SELECT name, number, startedAt, completedAt, result, reason "
+                 "FROM builds GROUP BY name HAVING number = MAX(number)")
        .fetch<str,uint,time_t,time_t,int,str>([&](str name,uint number, time_t started, time_t completed, int result, str reason){
            j.StartObject();
            j.set("name", name);
@ -361,15 +387,17 @@ std::string Laminar::getStatus(MonitorScope scope) {
        j.EndObject();
    } else { // Home page
        j.startArray("recent");
-        db->stmt("SELECT * FROM builds WHERE completedAt IS NOT NULL ORDER BY completedAt DESC LIMIT 20")
-        .fetch<str,uint,str,time_t,time_t,time_t,int>([&](str name,uint build,str context,time_t,time_t started,time_t completed,int result){
+        db->stmt("SELECT name,number,node,queuedAt,startedAt,completedAt,result,reason FROM builds WHERE completedAt IS NOT NULL ORDER BY completedAt DESC LIMIT 20")
+        .fetch<str,uint,str,time_t,time_t,time_t,int,str>([&](str name,uint build,str context,time_t queued,time_t started,time_t completed,int result,str reason){
            j.StartObject();
            j.set("name", name)
             .set("number", build)
             .set("context", context)
+             .set("queued", queued)
             .set("started", started)
             .set("completed", completed)
             .set("result", to_string(RunState(result)))
+             .set("reason", reason)
             .EndObject();
        });
        j.EndArray();
@ -394,6 +422,8 @@ std::string Laminar::getStatus(MonitorScope scope) {
        for(const auto& run : queuedJobs) {
            j.StartObject();
            j.set("name", run->name);
+            j.set("number", run->build);
+            j.set("result", to_string(RunState::QUEUED));
            j.EndObject();
        }
        j.EndArray();
@ -465,6 +495,12 @@ std::string Laminar::getStatus(MonitorScope scope) {
            j.EndObject();
        });
        j.EndArray();
+        j.startObject("completedCounts");
+        db->stmt("SELECT name, COUNT(*) FROM builds WHERE result IS NOT NULL GROUP BY name")
+                .fetch<str, uint>([&](str job, uint count){
+            j.set(job.c_str(), count);
+        });
+        j.EndObject();
    }
    j.EndObject();
    return j.str();
@ -568,7 +604,7 @@ bool Laminar::loadConfiguration() {
    return true;
 }

-std::shared_ptr<Run> Laminar::queueJob(std::string name, ParamMap params) {
+std::shared_ptr<Run> Laminar::queueJob(std::string name, ParamMap params, bool frontOfQueue) {
    if(!fsHome->exists(kj::Path{"cfg","jobs",name+".run"})) {
        LLOG(ERROR, "Non-existent job", name);
        return nullptr;
@ -579,7 +615,10 @@ std::shared_ptr<Run> Laminar::queueJob(std::string name, ParamMap params) {
        jobContexts.at(name).insert("default");

    std::shared_ptr<Run> run = std::make_shared<Run>(name, ++buildNums[name], kj::mv(params), homePath.clone());
-    queuedJobs.push_back(run);
+    if(frontOfQueue)
+        queuedJobs.push_front(run);
+    else
+        queuedJobs.push_back(run);

    db->stmt("INSERT INTO builds(name,number,queuedAt,parentJob,parentBuild,reason) VALUES(?,?,?,?,?,?)")
     .bind(run->name, run->build, run->queuedAt, run->parentName, run->parentBuild, run->reason())
@ -591,6 +630,9 @@ std::shared_ptr<Run> Laminar::queueJob(std::string name, ParamMap params) {
        .startObject("data")
        .set("name", name)
        .set("number", run->build)
+        .set("result", to_string(RunState::QUEUED))
+        .set("queueIndex", frontOfQueue ? 0 : (queuedJobs.size() - 1))
+        .set("reason", run->reason())
        .EndObject();
    http->notifyEvent(j.str(), name.c_str());

@ -769,7 +811,14 @@ void Laminar::handleRunFinished(Run * r) {
        // anyway so hence this (admittedly debatable) optimization.
        if(!fsHome->exists(d))
            break;
-        fsHome->remove(d);
+        // must use a try/catch because remove will throw if deletion fails. Using
+        // tryRemove does not help because it still throws an exception for some
+        // errors such as EACCES
+        try {
+            fsHome->remove(d);
+        } catch(kj::Exception& e) {
+            LLOG(ERROR, "Could not remove directory", e.getDescription());
+        }
    }

    fsHome->symlink(kj::Path{"archive", r->name, "latest"}, std::to_string(r->build), kj::WriteMode::CREATE|kj::WriteMode::MODIFY);
--- a/src/laminar.h
+++ b/src/laminar.h
@ -1,5 +1,5 @@
 ///
-/// Copyright 2015-2020 Oliver Giles
+/// Copyright 2015-2022 Oliver Giles
 ///
 /// This file is part of Laminar
 ///
@ -52,7 +52,7 @@ public:

    // Queues a job, returns immediately. Return value will be nullptr if
    // the supplied name is not a known job.
-    std::shared_ptr<Run> queueJob(std::string name, ParamMap params = ParamMap());
+    std::shared_ptr<Run> queueJob(std::string name, ParamMap params = ParamMap(), bool frontOfQueue = false);

    // Return the latest known number of the named job
    uint latestRun(std::string job);
@ -104,7 +104,7 @@ private:
    bool tryStartRun(std::shared_ptr<Run> run, int queueIndex);
    void handleRunFinished(Run*);
    // expects that Json has started an array
-    void populateArtifacts(Json& out, std::string job, uint num) const;
+    void populateArtifacts(Json& out, std::string job, uint num, kj::Path subdir = kj::Path::parse(".")) const;

    Run* activeRun(const std::string name, uint num) {
        auto it = activeJobs.byNameNumber().find(boost::make_tuple(name, num));
--- a/src/leader.cpp
+++ b/src/leader.cpp
@ -21,7 +21,11 @@
 #include <unistd.h>
 #include <queue>
 #include <dirent.h>
+#if defined(__FreeBSD__)
+#include <sys/procctl.h>
+#else
 #include <sys/prctl.h>
+#endif
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <kj/async-io.h>
@ -317,7 +321,11 @@ int leader_main(void) {
    // will be reparented to this one instead of init (or higher layer subreaper).
    // We do this so that the run will wait until all descedents exit before executing
    // the next step.
+    #if defined(__FreeBSD__)
+    procctl(P_PID, 0, PROC_REAP_ACQUIRE, NULL);
+    #else
    prctl(PR_SET_CHILD_SUBREAPER, 1, NULL, NULL, NULL);
+    #endif

    // Become the leader of a new process group. This is so that all child processes
    // will also get a kill signal when the run is aborted
--- a/src/main.cpp
+++ b/src/main.cpp
@ -26,6 +26,7 @@
 #include <kj/async-unix.h>
 #include <kj/filesystem.h>
 #include <signal.h>
+#include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>

@ -53,6 +54,13 @@ static void usage(std::ostream& out) {
    out << "  -v              enable verbose output\n";
 }

+static void on_sighup(int)
+{
+	constexpr const char msg[] = "Laminar received and ignored SIGHUP\n";
+	// write(2) is safe to call inside signal handler.
+	write(STDERR_FILENO, msg, sizeof(msg) - 1);
+}
+
 int main(int argc, char** argv) {
    if(argv[0][0] == '{')
        return leader_main();
@ -92,6 +100,7 @@ int main(int argc, char** argv) {

    signal(SIGINT, &laminar_quit);
    signal(SIGTERM, &laminar_quit);
+    signal(SIGHUP, &on_sighup);

    printf("laminard version %s started\n", laminar_version());

--- a/src/resources.cpp
+++ b/src/resources.cpp
@ -44,7 +44,6 @@ Resources::Resources()
    INIT_RESOURCE("/js/app.js", js_app_js, CONTENT_TYPE_JS);
    INIT_RESOURCE("/js/ansi_up.js", js_ansi_up_js, CONTENT_TYPE_JS);
    INIT_RESOURCE("/js/vue.min.js", js_vue_min_js, CONTENT_TYPE_JS);
-    INIT_RESOURCE("/js/vue-router.min.js", js_vue_router_min_js, CONTENT_TYPE_JS);
    INIT_RESOURCE("/js/ansi_up.js", js_ansi_up_js, CONTENT_TYPE_JS);
    INIT_RESOURCE("/js/Chart.min.js", js_Chart_min_js, CONTENT_TYPE_JS);
    INIT_RESOURCE("/style.css", style_css, CONTENT_TYPE_CSS);
--- a/src/resources/index.html
+++ b/src/resources/index.html
@ -11,26 +11,29 @@
 <link rel="manifest" href="/manifest.webmanifest">
 <title>Laminar</title>
 <script src="js/vue.min.js"></script>
- <script src="js/vue-router.min.js"></script>
 <script src="js/ansi_up.js"></script>
 <script src="js/Chart.min.js"></script>
 <script src="js/app.js" defer></script>

 <link href="style.css" rel="stylesheet">
- <link href="custom/style.css" rel="stylesheet">
 </head>
 <body>
 <template id="home"><div id="page-home-main">
  <nav>
   <table class="table striped">
    <tr v-for="job in jobsQueued">
-     <td><router-link  :to="'/jobs/'+job.name">{{job.name}}</router-link> <i>queued</i></td>
+     <td>
+      <span v-html="runIcon(job.result)"></span>
+      <router-link :to="'jobs/'+job.name">{{job.name}}</router-link>
+      <router-link :to="'jobs/'+job.name+'/'+job.number">#{{job.number}}</router-link>
+      <i>queued</i>
+     </td>
    </tr>
    <tr v-for="job in jobsRunning">
     <td>
      <span v-html="runIcon(job.result)"></span>
-      <router-link :to="'/jobs/'+job.name">{{job.name}}</router-link>
-      <router-link :to="'/jobs/'+job.name+'/'+job.number">#{{job.number}}</router-link>
+      <router-link :to="'jobs/'+job.name">{{job.name}}</router-link>
+      <router-link :to="'jobs/'+job.name+'/'+job.number">#{{job.number}}</router-link>
      <small style="float:right;">{{formatDuration(job.started, job.completed)}}</small>
      <div class="progress" style="margin-top: 5px;">
       <div class="progress-bar" :class="{overtime:job.overtime,indeterminate:!job.etc}" :style="job.etc && {width:job.progress+'%'}"></div>
@ -40,8 +43,8 @@
    <tr v-for="job in jobsRecent">
     <td>
      <span v-html="runIcon(job.result)"></span>
-      <router-link :to="'/jobs/'+job.name">{{job.name}}</router-link>
-      <router-link :to="'/jobs/'+job.name+'/'+job.number">#{{job.number}}</router-link><br>
+      <router-link :to="'jobs/'+job.name">{{job.name}}</router-link>
+      <router-link :to="'jobs/'+job.name+'/'+job.number">#{{job.number}}</router-link><br>
      <small>Took {{formatDuration(job.started, job.completed)}} at {{formatDate(job.started)}}</small>
     </td>
    </tr>
@ -52,13 +55,13 @@
    <div>
     <h3>Recent regressions</h3>
     <table>
-      <tr v-for="job in resultChanged" v-if="job.lastFailure>job.lastSuccess"><td><router-link :to="'/jobs/'+job.name+'/'+job.lastFailure">{{job.name}} #{{job.lastFailure}}</router-link> since <router-link :to="'/jobs/'+job.name+'/'+job.lastSuccess">#{{job.lastSuccess}}</router-link></tr>
+      <tr v-for="job in resultChanged" v-if="job.lastFailure>job.lastSuccess"><td><router-link :to="'jobs/'+job.name+'/'+job.lastFailure">{{job.name}} #{{job.lastFailure}}</router-link> since <router-link :to="'jobs/'+job.name+'/'+job.lastSuccess">#{{job.lastSuccess}}</router-link></tr>
     </table>
    </div>
    <div>
     <h3>Low pass rates</h3>
     <table>
-      <tr v-for="job in lowPassRates"><td><router-link :to="'/jobs/'+job.name">{{job.name}}</router-link></td><td>{{Math.round(job.passRate*100)}}&nbsp;%</td></tr>
+      <tr v-for="job in lowPassRates"><td><router-link :to="'jobs/'+job.name">{{job.name}}</router-link></td><td>{{Math.round(job.passRate*100)}}&nbsp;%</td></tr>
     </table>
    </div>
    <div>
@ -97,8 +100,8 @@
  </nav>
  <table class="striped" id="job-list">
    <tr v-for="job in filteredJobs()">
-    <td><router-link :to="'/jobs/'+job.name">{{job.name}}</router-link></td>
-    <td style="white-space: nowrap;"><span v-html="runIcon(job.result)"></span> <router-link :to="'/jobs/'+job.name+'/'+job.number">#{{job.number}}</router-link></td>
+    <td><router-link :to="'jobs/'+job.name">{{job.name}}</router-link></td>
+    <td style="white-space: nowrap;"><span v-html="runIcon(job.result)"></span> <router-link :to="'jobs/'+job.name+'/'+job.number">#{{job.number}}</router-link></td>
    <td>{{formatDate(job.started)}}</td>
    <td>{{formatDuration(job.started,job.completed)}}</td>
    </tr>
@ -106,7 +109,7 @@
 </div></template>
 
 <template id="wallboard"><div class="wallboard">
-  <router-link :to="'/jobs/'+job.name+'/'+job.number" tag="div" v-for="job in wallboardJobs()" :data-result="job.result">
+  <router-link :to="'jobs/'+job.name+'/'+job.number" tag="div" v-for="job in wallboardJobs()" :data-result="job.result">
   <span style="font-size: 36px; font-weight: bold;">{{job.name}} #{{job.number}}</span><br>
   <span style="font-size: 30px;">{{formatDate(job.started)}}</span><br>
   <span style="font-size: 26px;">{{job.reason}}</span>
@ -115,13 +118,13 @@

 <template id="job"><div id="page-job-main">
  <div style="padding: 15px;">
-   <h2>{{$route.params.name}}</h2>
+   <h2>{{route.params.name}}</h2>
   <div v-html="description"></div>
   <dl>
    <dt>Last Successful Run</dt>
-    <dd><router-link v-if="lastSuccess" :to="'/jobs/'+$route.params.name+'/'+lastSuccess.number">#{{lastSuccess.number}}</router-link> {{lastSuccess?' - at '+formatDate(lastSuccess.started):'never'}}</dd>
+    <dd><router-link v-if="lastSuccess" :to="'jobs/'+route.params.name+'/'+lastSuccess.number">#{{lastSuccess.number}}</router-link> {{lastSuccess?' - at '+formatDate(lastSuccess.started):'never'}}</dd>
    <dt>Last Failed Run</dt>
-    <dd><router-link v-if="lastFailed" :to="'/jobs/'+$route.params.name+'/'+lastFailed.number">#{{lastFailed.number}}</router-link> {{lastFailed?' - at '+formatDate(lastFailed.started):'never'}}</dd>
+    <dd><router-link v-if="lastFailed" :to="'jobs/'+route.params.name+'/'+lastFailed.number">#{{lastFailed.number}}</router-link> {{lastFailed?' - at '+formatDate(lastFailed.started):'never'}}</dd>
   </dl>
  </div>
  <div style="display: grid; justify-content: center; padding: 15px;">
@ -136,15 +139,11 @@
     <th class="text-center">Duration <a class="sort" :class="(sort.field=='duration'?sort.order:'')" v-on:click="do_sort('duration')">&nbsp;</a></th>
     <th class="text-center vp-sm-hide">Reason <a class="sort" :class="(sort.field=='reason'?sort.order:'')" v-on:click="do_sort('reason')">&nbsp;</a></th>
    </tr></thead>
-    <tr v-show="nQueued">
-     <td style="width:1px"><span v-html="runIcon('queued')"></span></td>
-     <td colspan="4"><i>{{nQueued}} run(s) queued</i></td>
-    </tr>
-    <tr v-for="job in jobsRunning.concat(jobsRecent)" track-by="$index">
+    <tr v-for="job in jobsQueued.concat(jobsRunning).concat(jobsRecent)" track-by="$index">
     <td style="width:1px"><span v-html="runIcon(job.result)"></span></td>
-     <td><router-link :to="'/jobs/'+$route.params.name+'/'+job.number">#{{job.number}}</router-link></td>
-     <td class="text-center">{{formatDate(job.started)}}</td>
-     <td class="text-center">{{formatDuration(job.started, job.completed)}}</td>
+     <td><router-link :to="'jobs/'+route.params.name+'/'+job.number">#{{job.number}}</router-link></td>
+     <td class="text-center"><span v-if="job.result!='queued'">{{formatDate(job.started)}}</span></td>
+     <td class="text-center"><span v-if="job.result!='queued'">{{formatDuration(job.started, job.completed)}}</span></td>
     <td class="text-center vp-sm-hide">{{job.reason}}</td>
    </tr>
   </table>
@ -159,10 +158,10 @@
 <template id="run"><div style="display: grid; grid-template-rows: auto 1fr">
  <div style="padding: 15px">
   <div style="display: grid; grid-template-columns: auto 25px auto auto 1fr 400px; gap: 5px; align-items: center">
-    <h2 style="white-space: nowrap"><span v-html="runIcon(job.result)"></span> {{$route.params.name}} #{{$route.params.number}}</h2>
+    <h2 style="white-space: nowrap"><span v-html="runIcon(job.result)"></span> <router-link :to="'jobs/'+route.params.name">{{route.params.name}}</router-link> #{{route.params.number}}</h2>
    <span></span>
-    <router-link :disabled="$route.params.number == 1" :to="'/jobs/'+$route.params.name+'/'+($route.params.number-1)" tag="button">&laquo;</router-link>
-    <router-link :disabled="$route.params.number == latestNum" :to="'/jobs/'+$route.params.name+'/'+(parseInt($route.params.number)+1)" tag="button">&raquo;</router-link>
+    <router-link :disabled="route.params.number == 1" :to="'jobs/'+route.params.name+'/'+(route.params.number-1)" tag="button">&laquo;</router-link>
+    <router-link :disabled="route.params.number == latestNum" :to="'jobs/'+route.params.name+'/'+(parseInt(route.params.number)+1)" tag="button">&raquo;</router-link>
    <span></span>
    <div class="progress" v-show="job.result == 'running'">
     <div class="progress-bar" :class="{overtime:job.overtime,indeterminate:!job.etc}" :style="job.etc && {width:job.progress+'%'}"></div>
@ -171,7 +170,7 @@
   <div id="page-run-detail">
    <dl>
     <dt>Reason</dt><dd>{{job.reason}}</dd>
-     <dt v-show="job.upstream.num > 0">Upstream</dt><dd v-show="job.upstream.num > 0"><router-link :to="'/jobs/'+job.upstream.name">{{job.upstream.name}}</router-link> <router-link :to="'/jobs/'+job.upstream.name+'/'+job.upstream.num">#{{job.upstream.num}}</router-link></li></dd>
+     <dt v-show="job.upstream.num > 0">Upstream</dt><dd v-show="job.upstream.num > 0"><router-link :to="'jobs/'+job.upstream.name">{{job.upstream.name}}</router-link> <router-link :to="'jobs/'+job.upstream.name+'/'+job.upstream.num">#{{job.upstream.num}}</router-link></li></dd>
     <dt>Queued for</dt><dd>{{formatDuration(job.queued, job.started ? job.started : Math.floor(Date.now()/1000))}}</dd>
     <dt v-show="job.started">Started</dt><dd v-show="job.started">{{formatDate(job.started)}}</dd>
     <dt v-show="runComplete(job)">Completed</dt><dd v-show="job.completed">{{formatDate(job.completed)}}</dd>
@ -188,19 +187,19 @@
   </div>
  </div>
  <div class="console-log">
-   <code v-html="log"></code>
-   <span v-show="job.result == 'running'" v-html="runIcon('running')" style="display: block;"></span>
+   <code></code>
+   <span v-show="!logComplete" v-html="runIcon('running')" style="display: block;"></span>
  </div>
 </div></template>

 <main id="app" style="display: grid; grid-template-rows: auto 1fr auto; height: 100%;">
  <nav id="nav-top" style="display: grid; grid-template-columns: auto auto 1fr auto auto; grid-gap: 15px;">
-   <router-link to="/" style="display: grid; grid-auto-flow: column; align-items: center; margin: 5px; font-size: 20px;">
+   <router-link to="." style="display: grid; grid-auto-flow: column; align-items: center; margin: 5px; font-size: 20px;">
    <img src="icon.png"> {{title}}
   </router-link>
   <div id="nav-top-links" style="display: grid; grid-auto-flow: column; justify-content: start; gap: 15px; padding: 0 15px; align-items: center; font-size: 16px;">
-    <router-link to="/jobs">Jobs</router-link>
-    <router-link v-for="(crumb,i) in _route.path.slice(1).split('/').slice(1,-1)" :to="_route.path.split('/').slice(0,i+3).join('/')">{{crumb}}</router-link>
+    <router-link to="jobs">Jobs</router-link>
+    <router-link v-for="(crumb,i) in route.path.slice(1).split('/').slice(1,-1)" :to="route.path.split('/').slice(0,i+3).join('/')">{{crumb}}</router-link>
   </div>
   <div></div>
   <span class="version">{{version}}</span>
--- a/src/resources/js/app.js
+++ b/src/resources/js/app.js
@ -18,86 +18,6 @@ Vue.filter('iecFileSize', bytes => {
    ['B', 'KiB', 'MiB', 'GiB', 'TiB'][exp];
 });

-// Mixin handling retrieving dynamic updates from the backend
-Vue.mixin((() => {
-  const setupEventSource = (to, query, next, comp) => {
-    const es = new EventSource(document.head.baseURI + to.path.substr(1) + query);
-    es.comp = comp; // When reconnecting, we already have a component. Usually this will be null.
-    es.to = to; // Save a ref, needed for adding query params for pagination.
-    es.onmessage = function(msg) {
-      msg = JSON.parse(msg.data);
-      // "status" is the first message the server always delivers.
-      // Use this to confirm the navigation. The component is not
-      // created until next() is called, so creating a reference
-      // for other message types must be deferred. There are some extra
-      // subtle checks here. If this eventsource already has a component,
-      // then this is not the first time the status message has been
-      // received. If the frontend requests an update, the status message
-      // should not be handled here, but treated the same as any other
-      // message. An exception is if the connection has been lost - in
-      // that case we should treat this as a "first-time" status message.
-      // !this.comp.es is used to test this condition.
-      if (msg.type === 'status' && (!this.comp || !this.comp.es)) {
-        next(comp => {
-          // Set up bidirectional reference
-          // 1. needed to reference the component for other msg types
-          this.comp = comp;
-          // 2. needed to close the ws on navigation away
-          comp.es = this;
-          comp.esReconnectInterval = 500;
-          // Update html and nav titles
-          document.title = comp.$root.title = msg.title;
-          comp.$root.version = msg.version;
-          // Calculate clock offset (used by ProgressUpdater)
-          comp.$root.clockSkew = msg.time - Math.floor((new Date()).getTime()/1000);
-          comp.$root.connected = true;
-          // Component-specific callback handler
-          comp[msg.type](msg.data, to.params);
-        });
-      } else {
-        // at this point, the component must be defined
-        if (!this.comp)
-          return console.error("Page component was undefined");
-        else {
-          this.comp.$root.connected = true;
-          this.comp.$root.showNotify(msg.type, msg.data);
-          if(typeof this.comp[msg.type] === 'function')
-            this.comp[msg.type](msg.data);
-        }
-      }
-    }
-    es.onerror = function(e) {
-      this.comp.$root.connected = false;
-      setTimeout(() => {
-        // Recrate the EventSource, passing in the existing component
-        this.comp.es = setupEventSource(to, query, null, this.comp);
-      }, this.comp.esReconnectInterval);
-      if(this.comp.esReconnectInterval < 7500)
-        this.comp.esReconnectInterval *= 1.5;
-      this.close();
-    }
-    return es;
-  }
-  return {
-    beforeRouteEnter(to, from, next) {
-      setupEventSource(to, '', (fn) => { next(fn); });
-    },
-    beforeRouteUpdate(to, from, next) {
-      this.es.close();
-      setupEventSource(to, '', (fn) => { fn(this); next(); });
-    },
-    beforeRouteLeave(to, from, next) {
-      this.es.close();
-      next();
-    },
-    methods: {
-      query(q) {
-        this.es.close();
-        setupEventSource(this.es.to, '?' + Object.entries(q).map(([k,v])=>`${k}=${v}`).join('&'), fn => fn(this));
-      }
-    }
-  };
-})());

 // Mixin for periodically updating a progress bar
 Vue.mixin({
@ -170,9 +90,9 @@ Vue.mixin({
      let m = d.getMinutes();
      if (m < 10)
        m = '0' + m;
-      return d.getHours() + ':' + m + ' on ' + 
+      return d.getHours() + ':' + m + ' on ' +
        ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][d.getDay()] + ' ' + d.getDate() + '. ' +
-        ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][d.getMonth()] + ' ' + 
+        ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][d.getMonth()] + ' ' +
        d.getFullYear();
    },
    // Pretty-print a duration
@ -209,7 +129,8 @@ const Charts = (() => {
          }]
        },
        options: {
-          hover: { mode: null }
+          hover: { mode: null },
+          aspectRatio: 2
        }
      });
      c.executorBusyChanged = busy => {
@ -239,20 +160,28 @@ const Charts = (() => {
          datasets: [{
            label: 'Failed Builds',
            backgroundColor: "#883d3d",
-            data: data.map(e => e.failed || 0)
+            data: data.map(e => e.failed || 0),
+            fill: true,
+            tension: 0.35,
          },{
            label: 'Successful Builds',
            backgroundColor: "#74af77",
-            data: data.map(e => e.success || 0)
+            data: data.map(e => e.success || 0),
+            fill: true,
+            tension: 0.35,
          }]
        },
        options:{
-          title: { display: true, text: 'Runs per day' },
-          tooltips:{callbacks:{title: (tip, data) => dayNames[tip[0].index].long}},
-          scales:{yAxes:[{
-            ticks:{userCallback: (label, index, labels) => Number.isInteger(label) ? label: null},
-            stacked: true
-          }]}
+          plugins: {
+            title: { display: true, text: 'Runs per day' },
+            tooltip:{callbacks:{title: (tip) => dayNames[tip[0].dataIndex].long}},
+          },
+          scales: {
+            y: {
+              ticks:{callback: (label, index, labels) => Number.isInteger(label) ? label: null},
+              stacked: true
+            },
+          },
        }
      });
      c.jobCompleted = success => {
@ -263,7 +192,7 @@ const Charts = (() => {
    },
    createRunsPerJobChart: (id, data) => {
      const c = new Chart(document.getElementById("chartBpj"), {
-        type: 'horizontalBar',
+        type: 'bar',
        data: {
          labels: Object.keys(data),
          datasets: [{
@ -273,9 +202,16 @@ const Charts = (() => {
          }]
        },
        options:{
-          title: { display: true, text: 'Runs per job' },
+          indexAxis: 'y',
+          plugins: {
+            title: { display: true, text: 'Runs per job' },
+          },
          hover: { mode: null },
-          scales:{xAxes:[{ticks:{userCallback: (label, index, labels)=> Number.isInteger(label) ? label: null}}]}
+          scales: {
+            x: {
+              ticks:{callback: (label, index, labels)=> Number.isInteger(label) ? label: null}
+            }
+          }
        }
      });
      c.jobCompleted = name => {
@ -283,16 +219,20 @@ const Charts = (() => {
          if (c.data.labels[j] == name) {
            c.data.datasets[0].data[j]++;
            c.update();
-            break;
+            return;
          }
        }
+        // if we get here, it's a new/unknown job
+        c.data.labels.push(name);
+        c.data.datasets[0].data.push(1);
+        c.update();
      }
      return c;
    },
-    createTimePerJobChart: (id, data) => {
+    createTimePerJobChart: (id, data, completedCounts) => {
      const scale = timeScale(Math.max(...Object.values(data)));
-      return new Chart(document.getElementById(id), {
-        type: 'horizontalBar',
+      const c = new Chart(document.getElementById(id), {
+        type: 'bar',
        data: {
          labels: Object.keys(data),
          datasets: [{
@ -302,115 +242,168 @@ const Charts = (() => {
          }]
        },
        options:{
-          title: { display: true, text: 'Mean run time this week' },
+          indexAxis: 'y',
+          plugins: {
+            title: { display: true, text: 'Mean run time this week' },
+            tooltip:{callbacks:{
+              label: (tip) => tip.dataset.label + ': ' + tip.raw.toFixed(2) + ' ' + scale.label.toLowerCase()
+            }}
+          },
          hover: { mode: null },
-          scales:{xAxes:[{
-            ticks:{userCallback: scale.ticks},
-            scaleLabel: {
-              display: true,
-              labelString: scale.label
+          scales: {
+            x:{
+              ticks: {callback: scale.ticks},
+              title: {
+                display: true,
+                text: scale.label
+              }
            }
-          }]},
-          tooltips:{callbacks:{
-            label: (tip, data) => data.datasets[tip.datasetIndex].label + ': ' + tip.xLabel + ' ' + scale.label.toLowerCase()
-          }}
+          },
        }
      });
+      c.jobCompleted = (name, time) => {
+        for (var j = 0; j < c.data.datasets[0].data.length; ++j) {
+          if (c.data.labels[j] == name) {
+            c.data.datasets[0].data[j] = ((completedCounts[name]-1) * c.data.datasets[0].data[j] + time * scale.factor) / completedCounts[name];
+            c.update();
+            return;
+          }
+        }
+        // if we get here, it's a new/unknown job
+        c.data.labels.push(name);
+        c.data.datasets[0].data.push(time * scale.factor);
+        c.update();
+      };
+      return c;
    },
    createRunTimeChangesChart: (id, data) => {
      const scale = timeScale(Math.max(...data.map(e => Math.max(...e.durations))));
-      return new Chart(document.getElementById(id), {
+      const dataValue = (name, durations) => ({
+        label: name,
+        data: durations.map(x => x * scale.factor),
+        borderColor: 'hsl('+(name.hashCode() % 360)+', 27%, 57%)',
+        backgroundColor: 'transparent',
+        tension: 0.35,
+      });
+      const c = new Chart(document.getElementById(id), {
        type: 'line',
        data: {
          labels: [...Array(10).keys()],
-          datasets: data.map(e => ({
-            label: e.name,
-            data: e.durations.map(x => x * scale.factor),
-            borderColor: 'hsl('+(e.name.hashCode() % 360)+', 27%, 57%)',
-            backgroundColor: 'transparent'
-          }))
+          datasets: data.map(e => dataValue(e.name, e.durations))
        },
        options:{
-          title: { display: true, text: 'Run time changes' },
-          legend:{ display: true, position: 'bottom' },
-          scales:{
-            xAxes:[{ticks:{display: false}}],
-            yAxes:[{
-              ticks:{userCallback: scale.ticks},
-              scaleLabel: {
-                display: true,
-                labelString: scale.label
-              }
-            }]
+          plugins: {
+            legend: { display: true, position: 'bottom' },
+            title: { display: true, text: 'Run time changes' },
+            tooltip: { enabled: false },
+          },
+          scales:{
+            x: {ticks: {display: false}},
+            y: {
+              ticks: {callback: scale.ticks},
+              title: {
+                display: true,
+                text: scale.label
+              }
+            }
          },
-          tooltips:{
-            enabled:false
-          }
        }
      });
+      c.jobCompleted = (name, time) => {
+        for (var j = 0; j < c.data.datasets.length; ++j) {
+          if (c.data.datasets[j].label == name) {
+            if(c.data.datasets[j].data.length == 10)
+              c.data.datasets[j].data.shift();
+            c.data.datasets[j].data.push(time * scale.factor);
+            c.update();
+            return;
+          }
+        }
+        // if we get here, it's a new/unknown job
+        c.data.datasets.push(dataValue(name, [time]));
+        c.update();
+      };
+      return c;
    },
    createRunTimeChart: (id, jobs, avg) => {
      const scale = timeScale(Math.max(...jobs.map(v=>v.completed-v.started)));
-      return new Chart(document.getElementById(id), {
+      const c = new Chart(document.getElementById(id), {
        type: 'bar',
        data: {
          labels: jobs.map(e => '#' + e.number).reverse(),
          datasets: [{
-            label: 'Average',
-            type: 'line',
-            data: [{x:0, y:avg * scale.factor}, {x:1, y:avg * scale.factor}],
-            borderColor: '#7483af',
-            backgroundColor: 'transparent',
-            xAxisID: 'avg',
-            pointRadius: 0,
-            pointHitRadius: 0,
-            pointHoverRadius: 0,
-          },{
            label: 'Build time',
            backgroundColor: jobs.map(e => e.result == 'success' ? '#74af77': '#883d3d').reverse(),
+            barPercentage: 1.0,
+            categoryPercentage: 0.95,
            data: jobs.map(e => (e.completed - e.started) * scale.factor).reverse()
          }]
        },
        options: {
-          title: { display: true, text: 'Build time' },
+          plugins: {
+            title: { display: true, text: 'Build time' },
+            tooltip: {
+              callbacks:{
+                label: (tip) => scale.ticks(tip.raw) + ' ' + scale.label.toLowerCase()
+              }
+            }
+          },
          hover: { mode: null },
          scales:{
-            xAxes:[{
-              categoryPercentage: 0.95,
-              barPercentage: 1.0
-            },{
-              id: 'avg',
-              type: 'linear',
-              ticks: {
-                display: false
-              },
-              gridLines: {
+            x: {
+              grid: {
                display: false,
                drawBorder: false
              }
-            }],
-            yAxes:[{
-              ticks:{userCallback: scale.ticks},
-              scaleLabel:{display: true, labelString: scale.label}
-            }]
+            },
+            y: {
+              suggestedMax: avg * scale.factor,
+              ticks: {callback: scale.ticks },
+              title: {display: true, text: scale.label}
+            }
          },
-          tooltips:{callbacks:{
-            label: (tip, data) => scale.ticks(tip.yLabel) + ' ' + scale.label.toLowerCase()
-          }}
-        }
+        },
+        plugins: [{
+          afterDraw: (chart, args, options) => {
+            const {ctx, avg, chartArea, scales:{y:yaxis}} = chart;
+            const y = chartArea.top + yaxis.height - avg * scale.factor * yaxis.height / yaxis.end;
+            ctx.save();
+            ctx.beginPath();
+            ctx.translate(chartArea.left, y);
+            ctx.moveTo(0,0);
+            ctx.lineTo(chartArea.width, 0);
+            ctx.lineWidth = 2;
+            ctx.strokeStyle = '#7483af';
+            ctx.stroke();
+            ctx.restore();
+          }
+        }]
      });
+      c.avg = avg;
+      c.jobCompleted = (num, result, time) => {
+        c.avg = ((c.avg * (num - 1)) + time) / num;
+        c.options.scales.y.suggestedMax = avg * scale.factor;
+        if(c.data.datasets[0].data.length == 20) {
+          c.data.labels.shift();
+          c.data.datasets[0].data.shift();
+          c.data.datasets[0].backgroundColor.shift();
+        }
+        c.data.labels.push('#' + num);
+        c.data.datasets[0].data.push(time * scale.factor);
+        c.data.datasets[0].backgroundColor.push(result == 'success' ? '#74af77': '#883d3d');
+        c.update();
+      };
+      return c;
    }
  };
 })();

 // For all charts, set miniumum Y to 0
-Chart.scaleService.updateScaleDefaults('linear', {
-    ticks: { suggestedMin: 0 }
-});
+Chart.defaults.scales.linear.suggestedMin = 0;
 // Don't display legend by default
-Chart.defaults.global.legend.display = false;
+Chart.defaults.plugins.legend.display = false;
 // Disable tooltip hover animations
-Chart.defaults.global.hover.animationDuration = 0;
+Chart.defaults.plugins.tooltip.animation = false;

 // Component for the / endpoint
 const Home = templateId => {
@ -421,16 +414,18 @@ const Home = templateId => {
    lowPassRates: [],
  };
  let chtUtilization, chtBuildsPerDay, chtBuildsPerJob, chtTimePerJob;
+  let completedCounts;
  return {
    template: templateId,
    data: () => state,
    methods: {
      status: function(msg) {
-        state.jobsQueued = msg.queued;
-        state.jobsRunning = msg.running;
+        state.jobsQueued = msg.queued.reverse();
+        state.jobsRunning = msg.running.reverse();
        state.jobsRecent = msg.recent;
        state.resultChanged = msg.resultChanged;
        state.lowPassRates = msg.lowPassRates;
+        completedCounts = msg.completedCounts;
        this.$forceUpdate();

        // defer charts to nextTick because they get DOM elements which aren't rendered yet
@ -438,12 +433,12 @@ const Home = templateId => {
          chtUtilization = Charts.createExecutorUtilizationChart("chartUtil", msg.executorsBusy, msg.executorsTotal);
          chtBuildsPerDay = Charts.createRunsPerDayChart("chartBpd", msg.buildsPerDay);
          chtBuildsPerJob = Charts.createRunsPerJobChart("chartBpj", msg.buildsPerJob);
-          chtTimePerJob = Charts.createTimePerJobChart("chartTpj", msg.timePerJob);
+          chtTimePerJob = Charts.createTimePerJobChart("chartTpj", msg.timePerJob, completedCounts);
          chtBuildTimeChanges = Charts.createRunTimeChangesChart("chartBuildTimeChanges", msg.buildTimeChanges);
        });
      },
      job_queued: function(data) {
-        state.jobsQueued.splice(0, 0, data);
+        state.jobsQueued.splice(state.jobsQueued.length - data.queueIndex, 0, data);
        this.$forceUpdate();
      },
      job_started: function(data) {
@ -453,8 +448,10 @@ const Home = templateId => {
        chtUtilization.executorBusyChanged(true);
      },
      job_completed: function(data) {
-        for (var i = 0; i < state.jobsRunning.length; ++i) {
-          var job = state.jobsRunning[i];
+        if(!(job.name in completedCounts))
+          completedCounts[job.name] = 0;
+        for(let i = 0; i < state.jobsRunning.length; ++i) {
+          const job = state.jobsRunning[i];
          if (job.name == data.name && job.number == data.number) {
            state.jobsRunning.splice(i, 1);
            state.jobsRecent.splice(0, 0, data);
@ -462,9 +459,28 @@ const Home = templateId => {
            break;
          }
        }
+        for(let i = 0; i < state.resultChanged.length; ++i) {
+          const job = state.resultChanged[i];
+          if(job.name == data.name) {
+            job[data.result === 'success' ? 'lastSuccess' : 'lastFailure'] = data.number;
+            this.$forceUpdate();
+            break;
+          }
+        }
+        for(let i = 0; i < state.lowPassRates.length; ++i) {
+          const job = state.lowPassRates[i];
+          if(job.name == data.name) {
+            job.passRate = ((completedCounts[job.name] - 1) * job.passRate + (data.result === 'success' ? 1 : 0)) / completedCounts[job.name];
+            this.$forceUpdate();
+            break;
+          }
+        }
+        completedCounts[job.name]++;
        chtBuildsPerDay.jobCompleted(data.result === 'success')
        chtUtilization.executorBusyChanged(false);
-        chtBuildsPerJob.jobCompleted(data.name)
+        chtBuildsPerJob.jobCompleted(data.name);
+        chtTimePerJob.jobCompleted(data.name, data.completed - data.started);
+        chtBuildTimeChanges.jobCompleted(data.name, data.completed - data.started);
      }
    }
  };
@ -489,12 +505,13 @@ const All = templateId => {
        state.jobsRunning = msg.running;
        // mix running and completed jobs
        msg.running.forEach(job => {
+          job.result = 'running';
          const idx = state.jobs.findIndex(j => j.name === job.name);
          if (idx > -1)
            state.jobs[idx] = job;
          else {
            // special case: first run of a job.
-            state.jobs.unshift(j);
+            state.jobs.unshift(job);
            state.jobs.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
          }
        });
@ -550,13 +567,13 @@ const All = templateId => {
        if (expr)
          ret = state.jobs.filter(job => (new RegExp(expr)).test(job.name));
        else
-          ret = state.jobs;
+          ret = [...state.jobs];
        // sort failed before success, newest first
        ret.sort((a,b) => a.result == b.result ? a.started - b.started : 2*(b.result == 'success')-1);
        return ret;
      },
      wallboardLink: function() {
-        return '/wallboard' + (state.group ? '?filter=' + state.groups[state.group] : '');
+        return 'wallboard' + (state.group ? '?filter=' + state.groups[state.group] : '');
      }
    }
  };
@ -566,44 +583,46 @@ const All = templateId => {
 const Job = templateId => {
  const state = {
    description: '',
+    jobsQueued: [],
    jobsRunning: [],
    jobsRecent: [],
    lastSuccess: null,
    lastFailed: null,
-    nQueued: 0,
    pages: 0,
    sort: {}
  };
-  let chtBt = null;
+  let chtBuildTime = null;
  return {
    template: templateId,
+    props: ['route'],
    data: () => state,
    methods: {
      status: function(msg) {
        state.description = msg.description;
-        state.jobsRunning = msg.running;
+        state.jobsQueued = msg.queued.reverse();
+        state.jobsRunning = msg.running.reverse();
        state.jobsRecent = msg.recent;
        state.lastSuccess = msg.lastSuccess;
        state.lastFailed = msg.lastFailed;
-        state.nQueued = msg.nQueued;
        state.pages = msg.pages;
        state.sort = msg.sort;

        // "status" comes again if we change page/sorting. Delete the
        // old chart and recreate it to prevent flickering of old data
-        if(chtBt)
-          chtBt.destroy();
+        if(chtBuildTime)
+          chtBuildTime.destroy();

        // defer chart to nextTick because they get DOM elements which aren't rendered yet
        this.$nextTick(() => {
-          chtBt = Charts.createRunTimeChart("chartBt", msg.recent, msg.averageRuntime);
+          chtBuildTime = Charts.createRunTimeChart("chartBt", msg.recent, msg.averageRuntime);
        });
      },
-      job_queued: function() {
-        state.nQueued++;
+      job_queued: function(data) {
+        state.jobsQueued.splice(state.jobsQueued.length - data.queueIndex, 0, data);
+        this.$forceUpdate();
      },
      job_started: function(data) {
-        state.nQueued--;
+        state.jobsQueued.splice(state.jobsQueued.length - data.queueIndex - 1, 1);
        state.jobsRunning.splice(0, 0, data);
        this.$forceUpdate();
      },
@ -613,8 +632,8 @@ const Job = templateId => {
            state.jobsRunning.splice(i, 1);
            state.jobsRecent.splice(0, 0, data);
            this.$forceUpdate();
-            // TODO: update the chart
        }
+        chtBuildTime.jobCompleted(data.number, data.result, data.completed - data.started);
      },
      page_next: function() {
        state.sort.page++;
@ -632,6 +651,9 @@ const Job = templateId => {
          state.sort.field = field;
        }
        this.query(state.sort)
+      },
+      query: function(q) {
+        this.$root.$emit('navigate', q);
      }
    }
  };
@ -640,10 +662,12 @@ const Job = templateId => {
 // Component for the /job/:name/:number endpoint
 const Run = templateId => {
  const utf8decoder = new TextDecoder('utf-8');
+  const ansi_up = new AnsiUp;
+  ansi_up.use_classes = true;
  const state = {
    job: { artifacts: [], upstream: {} },
    latestNum: null,
-    log: '',
+    logComplete: false,
  };
  const logFetcher = (vm, name, num) => {
    const abort = new AbortController();
@ -651,20 +675,62 @@ const Run = templateId => {
      // ATOW pipeThrough not supported in Firefox
      //const reader = res.body.pipeThrough(new TextDecoderStream).getReader();
      const reader = res.body.getReader();
+      const target = document.getElementsByTagName('code')[0];
+      let logToRender = '';
+      let logComplete = false;
+      let tid = null;
+      let lastUiUpdate = 0;
+
+      function updateUI() {
+        // output may contain private ANSI CSI escape sequence to point to
+        // downstream jobs. ansi_up (correctly) discards unknown sequences,
+        // so they must be matched before passing through ansi_up. ansi_up
+        // also (correctly) escapes HTML, so they need to be converted back
+        // to links after going through ansi_up.
+        // A better solution one day would be if ansi_up were to provide
+        // a callback interface for handling unknown sequences.
+        // Also, update the DOM directly rather than using a binding through
+        // Vue, the performance is noticeably better with large logs.
+        target.insertAdjacentHTML('beforeend', ansi_up.ansi_to_html(
+          logToRender.replace(/\033\[\{([^:]+):(\d+)\033\\/g, (m, $1, $2) =>
+            '~~~~LAMINAR_RUN~'+$1+':'+$2+'~'
+          )
+        ).replace(/~~~~LAMINAR_RUN~([^:]+):(\d+)~/g, (m, $1, $2) =>
+          '<a href="jobs/'+$1+'" onclick="return LaminarApp.navigate(this.href);">'+$1+'</a>:'+
+          '<a href="jobs/'+$1+'/'+$2+'" onclick="return LaminarApp.navigate(this.href);">#'+$2+'</a>'
+        ));
+        logToRender = '';
+        if (logComplete) {
+          // output finished
+          state.logComplete = true;
+        }
+
+        lastUiUpdate = Date.now();
+        tid = null;
+      }
+
      return function pump() {
        return reader.read().then(({done, value}) => {
-          value = utf8decoder.decode(value);
-          if (done)
+          if (done) {
+            // do not set state.logComplete directly, because rendering
+            // may take some time, and we don't want the progress indicator
+            // to disappear before rendering is complete. Instead, delay
+            // it until after the entire log has been rendered
+            logComplete = true;
+            // if no render update is pending, schedule one immediately
+            // (do not use the delayed buffering mechanism from below), so
+            // that for the common case of short logs, the loading spinner
+            // disappears immediately as the log is rendered
+            if(tid === null)
+              setTimeout(updateUI, 0);
            return;
-          state.log += ansi_up.ansi_to_html(
-            value.replace(/</g,'&lt;')
-                 .replace(/>/g,'&gt;')
-                 .replace(/\033\[\{([^:]+):(\d+)\033\\/g, (m, $1, $2) =>
-                   '<a href="jobs/'+$1+'" onclick="return vroute(this);">'+$1+'</a>:'+
-                   '<a href="jobs/'+$1+'/'+$2+'" onclick="return vroute(this);">#'+$2+'</a>'
-                 )
-          );
-          vm.$forceUpdate();
+          }
+          // sometimes logs can be very large, and we are calling pump()
+          // furiously to get all the data to the client. To prevent straining
+          // the client renderer, buffer the data and delay the UI updates.
+          logToRender += utf8decoder.decode(value);
+          if(tid === null)
+            tid = setTimeout(updateUI, Math.max(500 - (Date.now() - lastUiUpdate), 0));
          return pump();
        });
      }();
@ -674,18 +740,22 @@ const Run = templateId => {
  return {
    template: templateId,
    data: () => state,
+    props: ['route'],
    methods: {
-      status: function(data, params) {
+      status: function(data) {
        // Check for the /latest endpoint
+        const params = this._props.route.params;
        if(params.number === 'latest')
-          return this.$router.replace('/jobs/' + params.name + '/' + data.latestNum);
+          return this.$router.replace('jobs/' + params.name + '/' + data.latestNum);

        state.number = parseInt(params.number);
        state.jobsRunning = [];
        state.job = data;
        state.latestNum = data.latestNum;
        state.jobsRunning = [data];
-        state.log = '';
+        state.logComplete = false;
+        // DOM is used directly for performance
+        document.getElementsByTagName('code')[0].innerHTML = '';
        if(this.logstream)
          this.logstream.abort();
        if(data.started)
@ -719,14 +789,122 @@ const Run = templateId => {
  };
 };

-new Vue({
+Vue.component('RouterLink', {
+  name: 'router-link',
+  props: {
+    to:  { type: String },
+    tag: { type: String, default: 'a' }
+  },
+  template: `<component :is="tag" @click="navigate" :href="to"><slot></slot></component>`,
+  methods: {
+    navigate: function(e) {
+      e.preventDefault();
+      history.pushState(null, null, this.to);
+      this.$root.$emit('navigate');
+    }
+  }
+});
+
+Vue.component('RouterView', (() => {
+  const routes = [
+    { path: /^$/,                   component: Home('#home') },
+    { path: /^jobs$/,               component:  All('#jobs') },
+    { path: /^wallboard$/,          component:  All('#wallboard') },
+    { path: /^jobs\/(?<name>[^\/]+)$/,         component:  Job('#job') },
+    { path: /^jobs\/(?<name>[^\/]+)\/(?<number>\d+)$/, component:  Run('#run') }
+  ];
+
+  const resolveRoute = path => {
+    for(i in routes) {
+      const r = routes[i].path.exec(path);
+      if(r)
+        return [routes[i].component, r.groups];
+    }
+  }
+
+  let eventSource = null;
+
+  const setupEventSource = (view, query) => {
+    // drop any existing event source
+    if(eventSource)
+      eventSource.close();
+
+    const path = (location.origin+location.pathname).substr(document.head.baseURI.length);
+    const search = query ? '?' + Object.entries(query).map(([k,v])=>`${k}=${v}`).join('&') : '';
+
+    eventSource = new EventSource(document.head.baseURI + path + search);
+    eventSource.reconnectInterval = 500;
+    eventSource.onmessage = msg => {
+      msg = JSON.parse(msg.data);
+      if(msg.type === 'status') {
+        // Event source is connected. Update static data
+        document.title = view.$root.title = msg.title;
+        view.$root.version = msg.version;
+        // Calculate clock offset (used by ProgressUpdater)
+        view.$root.clockSkew = msg.time - Math.floor((new Date()).getTime()/1000);
+        view.$root.connected = true;
+        [view.currentView, route.params] = resolveRoute(path);
+        // the component won't be instantiated until nextTick
+        view.$nextTick(() => {
+          // component is ready, update it with the data from the eventsource
+          eventSource.comp = view.$children[0];
+          // and finally run the component handler
+          eventSource.comp[msg.type](msg.data);
+        });
+      } else {
+        // at this point, the component must be defined
+        if (!eventSource.comp)
+          return console.error("Page component was undefined");
+        view.$root.connected = true;
+        view.$root.showNotify(msg.type, msg.data);
+        if(typeof eventSource.comp[msg.type] === 'function')
+          eventSource.comp[msg.type](msg.data);
+      }
+    }
+    eventSource.onerror = err => {
+      let ri = eventSource.reconnectInterval;
+      view.$root.connected = false;
+      setTimeout(() => {
+        setupEventSource(view);
+        if(ri < 7500)
+          ri *= 1.5;
+        eventSource.reconnectInterval = ri
+      }, ri);
+      eventSource.close();
+    }
+  };
+
+  let route = {};
+
+  return {
+    name: 'router-view',
+    template: `<component :is="currentView" :route="route"></component>`,
+    data: () => ({
+      currentView: routes[0].component, // default to home
+      route: route
+    }),
+    created: function() {
+      this.$root.$on('navigate', query => {
+        setupEventSource(this, query);
+      });
+      window.addEventListener('popstate', () => {
+        this.$root.$emit('navigate');
+      });
+      // initial navigation
+      this.$root.$emit('navigate');
+    }
+  };
+})());
+
+const LaminarApp = new Vue({
  el: '#app',
  data: {
    title: '', // populated by status message
    version: '',
    clockSkew: 0,
    connected: false,
-    notify: 'localStorage' in window && localStorage.getItem('showNotifications') == 1
+    notify: 'localStorage' in window && localStorage.getItem('showNotifications') == 1,
+    route: { path: '', params: {} }
  },
  computed: {
    supportsNotifications: () =>
@ -744,20 +922,14 @@ new Vue({
        new Notification('Job ' + data.result, {
          body: data.name + ' ' + '#' + data.number + ': ' + data.result
        });
+    },
+    navigate: function(path) {
+      history.pushState(null, null, path);
+      this.$emit('navigate');
+      return false;
    }
  },
  watch: {
    notify: e => localStorage.setItem('showNotifications', e ? 1 : 0)
-  },
-  router: new VueRouter({
-    mode: 'history',
-    base: document.head.baseURI.substr(location.origin.length),
-    routes: [
-      { path: '/',                   component: Home('#home') },
-      { path: '/jobs',               component:  All('#jobs') },
-      { path: '/wallboard',          component:  All('#wallboard') },
-      { path: '/jobs/:name',         component:  Job('#job') },
-      { path: '/jobs/:name/:number', component:  Run('#run') }
-    ],
-  }),
+  }
 });
--- a/src/resources/style.css
+++ b/src/resources/style.css
@ -12,8 +12,6 @@
 --running: #4786ab;
 --warning: #de9a34;
 --link-fg: #2f4579;
- --console-bg: #313235;
- --console-fg: #fff;
 --alt-row-bg: #fafafa;
 --border-grey: #d0d0d0;
 }
@ -121,10 +119,46 @@ a.sort:not(.dsc):hover:after { border-top-color: var(--main-fg);  }
 a.active { color: var(--main-fg); }
 a.active:hover { text-decoration: none; }

-/* run console output */
-.console-log { padding: 15px; background-color: var(--console-bg); }
-.console-log code { white-space: pre-wrap; color: var(--console-fg); }
-.console-log a { color: var(--console-fg); }
+/* run console ansi colors (based on base16-default-dark and base16-bright) */
+:root {
+  --ansi-black: #181818;
+  --ansi-red: #ab4642;
+  --ansi-green: #a1b56c;
+  --ansi-yellow: #f7ca88;
+  --ansi-blue: #7cafc2;
+  --ansi-magenta: #ba8baf;
+  --ansi-cyan: #86c1b9;
+  --ansi-white: #d8d8d8;
+  --ansi-brightblack: #000000;
+  --ansi-brightred: #fb0120;
+  --ansi-brightgreen: #a1c659;
+  --ansi-brightyellow: #fda331;
+  --ansi-brightblue: #6fb3d2;
+  --ansi-brightmagenta: #d381c3;
+  --ansi-brightcyan: #76c7b7;
+  --ansi-brightwhite: #e0e0e0;
+}
+.ansi-black-fg { color: var(--ansi-black); } .ansi-black-bg { background-color: var(--ansi-black); }
+.ansi-red-fg { color: var(--ansi-red); } .ansi-red-bg { background-color: var(--ansi-red); }
+.ansi-green-fg { color: var(--ansi-green); } .ansi-green-bg { background-color: var(--ansi-green); }
+.ansi-yellow-fg { color: var(--ansi-yellow); } .ansi-yellow-bg { background-color: var(--ansi-yellow); }
+.ansi-blue-fg { color: var(--ansi-blue); } .ansi-blue-bg { background-color: var(--ansi-blue); }
+.ansi-magenta-fg { color: var(--ansi-magenta); } .ansi-magenta-bg { background-color: var(--ansi-magenta); }
+.ansi-cyan-fg { color: var(--ansi-cyan); } .ansi-cyan-bg { background-color: var(--ansi-cyan); }
+.ansi-white-fg { color: var(--ansi-white); } .ansi-white-bg { background-color: var(--ansi-white); }
+.ansi-bright-black-fg { color: var(--ansi-brightblack); } .ansi-bright-black-bg { background-color: var(--ansi-brightblack); }
+.ansi-bright-red-fg { color: var(--ansi-brightred); } .ansi-bright-red-bg { background-color: var(--ansi-brightred); }
+.ansi-bright-green-fg { color: var(--ansi-brightgreen); } .ansi-bright-green-bg { background-color: var(--ansi-brightgreen); }
+.ansi-bright-yellow-fg { color: var(--ansi-brightyellow); } .ansi-bright-yellow-bg { background-color: var(--ansi-brightyellow); }
+.ansi-bright-blue-fg { color: var(--ansi-brightblue); } .ansi-bright-blue-bg { background-color: var(--ansi-brightblue); }
+.ansi-bright-magenta-fg { color: var(--ansi-brightmagenta); } .ansi-bright-magenta-bg { background-color: var(--ansi-brightmagenta); }
+.ansi-bright-cyan-fg { color: var(--ansi-brightcyan); } .ansi-bright-cyan-bg { background-color: var(--ansi-brightcyan); }
+.ansi-bright-white-fg { color: var(--ansi-brightwhite); } .ansi-bright-white-bg { background-color: var(--ansi-brightwhite); }
+
+/* run console */
+.console-log { padding: 15px; background-color: var(--ansi-black); }
+.console-log code { white-space: pre-wrap; color: var(--ansi-white); }
+.console-log a { color: var(--ansi-brightwhite); }

 /* text input (job filtering) */
 input { padding: 5px 8px; }
--- a/src/rpc.cpp
+++ b/src/rpc.cpp
@ -1,5 +1,5 @@
 ///
-/// Copyright 2015-2019 Oliver Giles
+/// Copyright 2015-2022 Oliver Giles
 ///
 /// This file is part of Laminar
 ///
@ -53,7 +53,7 @@ public:
    kj::Promise<void> queue(QueueContext context) override {
        std::string jobName = context.getParams().getJobName();
        LLOG(INFO, "RPC queue", jobName);
-        std::shared_ptr<Run> run = laminar.queueJob(jobName, params(context.getParams().getParams()));
+        std::shared_ptr<Run> run = laminar.queueJob(jobName, params(context.getParams().getParams()), context.getParams().getFrontOfQueue());
        if(Run* r = run.get()) {
            context.getResults().setResult(LaminarCi::MethodResult::SUCCESS);
            context.getResults().setBuildNum(r->build);
@ -67,7 +67,7 @@ public:
    kj::Promise<void> start(StartContext context) override {
        std::string jobName = context.getParams().getJobName();
        LLOG(INFO, "RPC start", jobName);
-        std::shared_ptr<Run> run = laminar.queueJob(jobName, params(context.getParams().getParams()));
+        std::shared_ptr<Run> run = laminar.queueJob(jobName, params(context.getParams().getParams()), context.getParams().getFrontOfQueue());
        if(Run* r = run.get()) {
            return r->whenStarted().then([context,r]() mutable {
                context.getResults().setResult(LaminarCi::MethodResult::SUCCESS);
@ -83,7 +83,7 @@ public:
    kj::Promise<void> run(RunContext context) override {
        std::string jobName = context.getParams().getJobName();
        LLOG(INFO, "RPC run", jobName);
-        std::shared_ptr<Run> run = laminar.queueJob(jobName, params(context.getParams().getParams()));
+        std::shared_ptr<Run> run = laminar.queueJob(jobName, params(context.getParams().getParams()), context.getParams().getFrontOfQueue());
        if(run) {
            return run->whenFinished().then([context,run](RunState state) mutable {
                context.getResults().setResult(fromRunState(state));
@ -101,7 +101,9 @@ public:
        auto res = context.getResults().initResult(queue.size());
        int i = 0;
        for(auto it : queue) {
-            res.set(i++, it->name);
+            res[i].setJob(it->name);
+            res[i].setBuildNum(it->build);
+            i++;
        }
        return kj::READY_NOW;
    }
--- a/src/run.cpp
+++ b/src/run.cpp
@ -21,10 +21,16 @@
 #include "conf.h"
 #include "log.h"

+#include <sys/wait.h>
 #include <iostream>
 #include <unistd.h>
 #include <signal.h>

+#if defined(__FreeBSD__)
+#include <sys/sysctl.h>
+#include <sys/limits.h>
+#endif
+
 // short syntax helper for kj::Path
 template<typename T>
 inline kj::Path operator/(const kj::Path& p, const T& ext) {
@ -153,7 +159,20 @@ kj::Promise<RunState> Run::start(RunState lastResult, std::shared_ptr<Context> c
        // main() by calling leader_main()
        char* procName;
        if(asprintf(&procName, "{laminar} %s:%d", name.data(), build) > 0)
+#if defined(__FreeBSD__)
+        {
+            int  sysctl_rq[] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
+            size_t self_exe_len = PATH_MAX;
+            char self_exe[PATH_MAX];
+
+            if (sysctl(sysctl_rq, 4, self_exe, &self_exe_len, NULL, 0))
+                _exit(EXIT_FAILURE);
+
+            execl(self_exe, procName, NULL); // does not return
+        }
+#else
            execl("/proc/self/exe", procName, NULL); // does not return
+#endif
        _exit(EXIT_FAILURE);
    }

--- a/src/server.cpp
+++ b/src/server.cpp
@ -1,5 +1,5 @@
 ///
-/// Copyright 2015-2019 Oliver Giles
+/// Copyright 2015-2021 Oliver Giles
 ///
 /// This file is part of Laminar
 ///
@ -28,8 +28,8 @@

 #include <signal.h>
 #include <sys/eventfd.h>
+#include <sys/stat.h>
 #include <sys/inotify.h>
-#include <sys/signalfd.h>

 // Size of buffer used to read from file descriptors. Should be
 // a multiple of sizeof(struct signalfd_siginfo) == 128
@ -117,8 +117,11 @@ void Server::listenRpc(Rpc &rpc, kj::StringPtr rpcBindAddress)
    if(rpcBindAddress.startsWith("unix:"))
        unlink(rpcBindAddress.slice(strlen("unix:")).cStr());
    listeners->add(ioContext.provider->getNetwork().parseAddress(rpcBindAddress)
-              .then([this,&rpc](kj::Own<kj::NetworkAddress>&& addr) {
-        return acceptRpcClient(rpc, addr->listen());
+              .then([this,&rpc,rpcBindAddress](kj::Own<kj::NetworkAddress>&& addr) {
+        kj::Own<kj::ConnectionReceiver> listener = addr->listen();
+        if(rpcBindAddress.startsWith("unix:"))
+            chmod(rpcBindAddress.slice(strlen("unix:")).cStr(), 0660);
+        return acceptRpcClient(rpc, kj::mv(listener));
    }));

 }
@ -128,8 +131,19 @@ void Server::listenHttp(Http &http, kj::StringPtr httpBindAddress)
    if(httpBindAddress.startsWith("unix:"))
        unlink(httpBindAddress.slice(strlen("unix:")).cStr());
    listeners->add(ioContext.provider->getNetwork().parseAddress(httpBindAddress)
-              .then([this,&http](kj::Own<kj::NetworkAddress>&& addr) {
-        return http.startServer(ioContext.lowLevelProvider->getTimer(), addr->listen());
+              .then([this,&http,httpBindAddress](kj::Own<kj::NetworkAddress>&& addr) {
+        kj::Own<kj::ConnectionReceiver> listener = addr->listen();
+        if(httpBindAddress.startsWith("unix:"))
+            chmod(httpBindAddress.slice(strlen("unix:")).cStr(), 0660);
+        return http.startServer(ioContext.lowLevelProvider->getTimer(), kj::mv(listener));
+    }).catch_([this,&http,httpBindAddress](kj::Exception&&e) mutable -> kj::Promise<void> {
+        if(e.getType() == kj::Exception::Type::DISCONNECTED) {
+            LLOG(ERROR, "HTTP disconnect, restarting server", e.getDescription());
+            listenHttp(http, httpBindAddress);
+            return kj::READY_NOW;
+        }
+        // otherwise propagate the exception
+        return kj::mv(e);
    }));
 }

--- a/test/laminar-fixture.h
+++ b/test/laminar-fixture.h
@ -1,5 +1,5 @@
 ///
-/// Copyright 2019-2020 Oliver Giles
+/// Copyright 2019-2022 Oliver Giles
 ///
 /// This file is part of Laminar
 ///
@ -33,20 +33,26 @@
 class LaminarFixture : public ::testing::Test {
 public:
    LaminarFixture() {
-        bind_rpc = std::string("unix:/") + tmp.path.toString(true).cStr() + "/rpc.sock";
-        bind_http = std::string("unix:/") + tmp.path.toString(true).cStr() + "/http.sock";
        home = tmp.path.toString(true).cStr();
-        tmp.fs->openSubdir(kj::Path{"cfg", "jobs"}, kj::WriteMode::CREATE | kj::WriteMode::CREATE_PARENT);
+        bind_rpc = std::string("unix:/") + home + "/rpc.sock";
+        bind_http = std::string("unix:/") + home + "/http.sock";
        settings.home = home.c_str();
        settings.bind_rpc = bind_rpc.c_str();
        settings.bind_http = bind_http.c_str();
        settings.archive_url = "/test-archive/";
+    }
+    ~LaminarFixture() noexcept(true) {}
+
+    void SetUp() override {
+        tmp.init();
        server = new Server(*ioContext);
        laminar = new Laminar(*server, settings);
    }
-    ~LaminarFixture() noexcept(true) {
+
+    void TearDown() override {
        delete server;
        delete laminar;
+        tmp.clean();
    }

    kj::Own<EventSource> eventSource(const char* path) {
@ -92,6 +98,14 @@ public:
        return { res.getResult(), kj::mv(log) };
    }

+    void setNumExecutors(int nexec) {
+        KJ_IF_MAYBE(f, tmp.fs->tryOpenFile(kj::Path{"cfg", "contexts", "default.conf"},
+                kj::WriteMode::CREATE | kj::WriteMode::MODIFY | kj::WriteMode::CREATE_PARENT)) {
+            std::string content = "EXECUTORS=" + std::to_string(nexec);
+            (*f)->writeAll(content);
+        }
+    }
+
    kj::String stripLaminarLogLines(const kj::String& str) {
        auto out = kj::heapString(str.size());
        char *o = out.begin();
--- a/test/laminar-functional.cpp
+++ b/test/laminar-functional.cpp
@ -1,5 +1,5 @@
 ///
-/// Copyright 2019 Oliver Giles
+/// Copyright 2019-2022 Oliver Giles
 ///
 /// This file is part of Laminar
 ///
@ -133,7 +133,7 @@ TEST_F(LaminarFixture, ParamsToEnv) {
 }

 TEST_F(LaminarFixture, Abort) {
-    defineJob("job1", "yes");
+    defineJob("job1", "sleep inf");
    auto req = client().runRequest();
    req.setJobName("job1");
    auto res = req.send();
@ -162,3 +162,27 @@ TEST_F(LaminarFixture, JobDescription) {
    ASSERT_TRUE(data.HasMember("description"));
    EXPECT_STREQ("bar", data["description"].GetString());
 }
+
+TEST_F(LaminarFixture, QueueFront) {
+    setNumExecutors(0);
+    defineJob("foo", "true");
+    defineJob("bar", "true");
+    auto es = eventSource("/");
+    auto req1 = client().queueRequest();
+    req1.setJobName("foo");
+    auto res1 = req1.send();
+    auto req2 = client().queueRequest();
+    req2.setFrontOfQueue(true);
+    req2.setJobName("bar");
+    auto res2 = req2.send();
+    ioContext->waitScope.poll();
+    setNumExecutors(2);
+    ioContext->waitScope.poll();
+    ASSERT_GE(es->messages().size(), 5);
+    auto started1 = es->messages().at(3).GetObject();
+    EXPECT_STREQ("job_started", started1["type"].GetString());
+    EXPECT_STREQ("bar", started1["data"]["name"].GetString());
+    auto started2 = es->messages().at(4).GetObject();
+    EXPECT_STREQ("job_started", started2["type"].GetString());
+    EXPECT_STREQ("foo", started2["data"]["name"].GetString());
+}
--- a/test/tempdir.h
+++ b/test/tempdir.h
@ -1,5 +1,5 @@
 ///
-/// Copyright 2018-2020 Oliver Giles
+/// Copyright 2018-2022 Oliver Giles
 ///
 /// This file is part of Laminar
 ///
@ -28,12 +28,25 @@ class TempDir {
 public:
    TempDir() :
        path(mkdtemp()),
-        fs(kj::newDiskFilesystem()->getRoot().openSubdir(path, kj::WriteMode::CREATE|kj::WriteMode::MODIFY))
+        fs(kj::newDiskFilesystem()->getRoot().openSubdir(path, kj::WriteMode::MODIFY))
    {
    }
    ~TempDir() noexcept {
        kj::newDiskFilesystem()->getRoot().remove(path);
    }
+    void init() {
+        // set up empty directory structure
+        fs->openSubdir(kj::Path{"cfg"}, kj::WriteMode::CREATE);
+        fs->openSubdir(kj::Path{"cfg", "jobs"}, kj::WriteMode::CREATE);
+        fs->openSubdir(kj::Path{"cfg", "contexts"}, kj::WriteMode::CREATE);
+    }
+    void clean() {
+        // rm -rf in config folder
+        for(kj::StringPtr name : fs->listNames()) {
+            fs->remove(kj::Path{name});
+        }
+    }
+
    kj::Path path;
    kj::Own<const kj::Directory> fs;
 private:
Author	SHA1	Message	Date
Oliver Giles	cfa995f8b9	build from source: include make Resolves #213	2024-08-16 13:05:03 +12:00
Oliver Giles	0a340f9b0b	Debian bullseye -> bookworm	2024-08-16 13:04:38 +12:00
Benoit	d259dff604	Add pkg script for Ubuntu 24.04. This adds a pkg script to build a deb package for Ubuntu 24.04.	2024-08-16 12:55:02 +12:00
Benoit	44aea1fc06	Update ansi-red by following base16-default-dark base16-default-dark: https://base16.netlify.app/previews/base16-default-dark.html	2024-05-23 10:38:51 +12:00
Benoit	27d2a760fd	Fix wrong ANSI red color in the CSS	2024-05-23 10:38:51 +12:00
Michael F. Lamb	fc6343bd19	add .deb package build scripts for debian 12 and 13	2024-05-01 10:04:23 +12:00
Benoit	736c95ff57	Fix mix of tabs/spaces The bash code block to install packages were mixing spaces and tabs in the breaking lines. Removed tabs and spaces, to only use 2 spaces. Also wrap at 80 characters.	2024-05-01 10:03:45 +12:00
Benoit	5ea394c610	Add pkg script for Ubuntu 22.04	2024-05-01 10:03:33 +12:00
Oliver Giles	8c3d7f62a9	cmake: fix install path of /etc/laminar.conf	2024-03-29 12:21:54 +13:00
Mike Swierczek	a1a95c8e7f	README.md: add pkg-config The project was updated to require pkg-config for builds.	2024-02-27 12:48:28 +13:00
marian cingel	277a59f1cb	Support Clang/LLVM build on FBSD - Update CMakeList to support installation to PREFIX directory - FreeBSD does not support abstract sockets (unix-abstract:laminar), so explicit 'LAMINAR_BIND_RPC=IP:port' is required - ld.lld requires explicit emulation for binary blobs, add a new variable LINKER_EMULATION_FLAGS for this purpose	2023-11-07 09:17:52 +13:00
mapperr	97b9f6b1ae	database: fix missing import	2023-10-25 10:01:35 +13:00
Ferenc Erki	d2c58f0bcd	Fix author warning about cmake command order CMake 3.26.0 introduced an author warning when the top-level project() call precedes a cmake_minimum_required() call [1]. [1]: https://cmake.org/cmake/help/latest/release/3.26.html#other-changes	2023-07-24 08:27:46 +12:00
Oliver Giles	dab620b01e	Http::cleanupPeers: check fulfiller is non-null resolves #185	2023-03-17 09:51:51 +13:00
Jan-Benedict Glaw	1e7e9319c3	Have at least some minimal logging	2023-03-01 11:25:46 +13:00
Jan-Benedict Glaw	af4b51b3e9	Add a link from any run to its job	2023-03-01 11:25:10 +13:00
Dmitry Shachnev	458ec26943	Optimize query which is used on /jobs page By replacing the primary key index and simplifying the query.	2023-02-08 15:01:58 +13:00
Lucki	6a20291dc4	Fix wrong example path extension	2023-01-27 20:30:22 +13:00
Oliver Giles	3cc01bc45d	Better average line in Build time graph The technique to display the average line in the old Chart.js does not look so great in the new version. Take a different approach using a plugin instead.	2022-11-18 19:47:59 +13:00
Guilherme Lima	e25b58944d	Minor tweaks to charts appearance Some charts had a more 'curvy' look to it. Adjusted this by using the 'tension' parameter. Adjusted 'Utilization' pie chart aspect ratio so it is not so big.	2022-11-18 19:47:59 +13:00
Guilherme Lima	1be755e323	Update Chart.js to version 3.9 Fixes #175 Following 3.x Migration Guide, here is a list of the changes: https://www.chartjs.org/docs/latest/getting-started/v3-migration.html#specific-changes - Chart.scaleService was replaced with Chart.registry. Scale defaults are now in Chart.defaults.scales[type]. - scales.[x/y]Axes arrays were removed. Scales are now configured directly to options.scales object with the object key being the scale Id. - scales.[x/y]Axes.barPercentage was moved to dataset option barPercentages - scales.[x/y]Axes.barThickness was moved to dataset option barThickness - scales.[x/y]Axes.scaleLabel was renamed to scales[id].title - scales.[x/y]Axes.scaleLabel.labelString was renamed to scales[id].title.text - scales.[x/y]Axes.ticks.userCallback was renamed to scales[id].ticks.callback - tooltips namespace was renamed to tooltip to match the plugin name - legend, title and tooltip namespaces were moved from options to options.plugins https://www.chartjs.org/docs/latest/getting-started/v3-migration.html#defaults - legend, title and tooltip namespaces were moved from Chart.defaults to Chart.defaults.plugins. - elements.line.fill default changed from true to false https://www.chartjs.org/docs/latest/getting-started/v3-migration.html#chart-types - horizontalBar chart type was removed. Horizontal bar charts can be configured using the new indexAxis option https://www.chartjs.org/docs/latest/getting-started/v3-migration.html#tooltip - xLabel and yLabel were removed. Please use label and formattedValue - The callbacks no longer are given a data parameter. The tooltip item parameter contains the chart and dataset instead - The tooltip item's index parameter was renamed to dataIndex and value was renamed to formattedValue https://www.chartjs.org/docs/latest/getting-started/v3-migration.html#ticks - options.gridLines was renamed to options.gridLines	2022-11-18 19:47:59 +13:00
Oliver Giles	e9fc547a72	wallboard: correctly tag running build for css also on page refresh, not just via SSE.	2022-09-03 19:54:10 +12:00
Oliver Giles	01183a3c25	wallboard: fix stuck page without filter query if no filter param is provided, use a copy of the jobs array to avoid an infinite sort loop in the frontend resolves #174	2022-09-03 19:53:14 +12:00
Oliver Giles	e7defa9f15	fe: fix display of first run of job if it is still running and is the first known of its name to the frontend, special handling is needed	2022-09-03 19:51:29 +12:00
Dmitry Bogatov	99e2e62906	laminard: ignore SIGHUP Many daemons reload config file on SIGHUP; laminar don't have config file, so signal is ignored (with informative message on stdout). Previously, default handler for SIGHUP was used that terminates process. Closes: #166	2022-01-30 08:21:14 +13:00
Oliver Giles	261c08d2fe	test: assert on >= 5 rather than strictly == due to process scheduling, we may even receive job_completed messages before the test continues. The assert only needs to check that there are enough messages to prevent invalid indexing. This fixes a flakey test.	2022-01-28 19:44:40 +13:00
Oliver Giles	48c0e9340e	pkg: move to debian 11 (bullseye)	2022-01-28 19:28:30 +13:00
Oliver Giles	7303e4d592	fe perf: insertAdjacentHTML is faster than innerHTML+=	2022-01-22 20:08:23 +13:00
Oliver Giles	23cb30fc0c	fe perf: throttle log rendering as a further enhancement to `efafda16f`, schedule a render immediately if 500ms have passed without one, and cap the max delay to 500ms. This removes delay for short logs, and prevents an issue where output that is produced reasonably quickly will not be rendered for a long time.	2022-01-22 20:07:23 +13:00
Oliver Giles	7eb19ce8c4	fe: fix home icon link under subdir when hosting laminar under a subdir, href=/ will break out of the application. Use href=. instead (relative to base href)	2022-01-22 15:18:43 +13:00
Oliver Giles	7c4e1108ae	nginx example: trailing slash on proxy_pass argument this causes nginx to substitute the location directive. Makes no difference if hosted at toplevel, but if using a subdirectory, omitting the trailing slash will prevent laminar's http server from finding the resources.	2022-01-22 15:18:43 +13:00
Oliver Giles	5607a93cc1	manpage: fix synopsis queue/start/run	2022-01-22 15:18:43 +13:00
Oliver Giles	41ddd8fe4f	allow adding job to front of queue laminarc now supports {queue,start,run} --next to place the job at the front of the queue instead of at the end. resolves #162	2022-01-22 15:18:43 +13:00
Oliver Giles	e581a0cf5d	tests: add setNumExecutors method	2022-01-22 15:18:43 +13:00
Oliver Giles	4a6f99a203	tests: reinstantiate laminar for each unit reinstantiate Laminar and Server classes and clean the temporary LAMINAR_HOME directory for each unit test via SetUp and TearDown.	2022-01-22 15:18:43 +13:00
Oliver Giles	efafda16ff	improve frontend performance with large logs frontend would furiously try to render as fast as it received data chunks from the server. This causes a lot of extra load on the browser renderer if the logs are large. Buffer and batch calls to rerender to improve performance. resolves #165	2022-01-01 21:30:38 +13:00
Oliver Giles	bb087b72ee	Revert "make taskFailed non-fatal" Originally reverted to prevent a crash when reading from an http client raised ECONNRESET. Although this prevented a crash, laminar stopped listening for http connections. That issue was resolved in `37bbf6ade4` (see #164), so make all exceptions fatal again. This reverts commit `02810309fc`.	2021-12-24 13:46:57 +13:00
Oliver Giles	37bbf6ade4	server: handle ECONNRESET in http connections In real deployments, sometimes http connections break with ECONNRESET. This causes the kj::HttpServer listener promise to break, which means no more connections are accepted. Catch this exception and restart the listener. resolves #164	2021-12-24 13:46:54 +13:00
Oliver Giles	e1686d454b	display run number for queued jobs in the frontend and in laminarc queue/show-queued. This makes it much easier to abort/unqueue runs which have not yet started. resolves #155	2021-12-05 13:42:27 +13:00
Oliver Giles	549f49052a	create unix sockets with 660 permissions Realistically this is probably the permission mask you want if you are using a unix socket for LAMINAR_BIND_RPC or LAMINAR_BIND_HTTP. resolves #160	2021-11-12 20:06:35 +13:00
Oliver Giles	d913d04c4a	UserManual: correct Debian version name resolves #163	2021-11-07 13:56:52 +13:00
Oliver Giles	78ceeec3e8	frontend: fix double-escaped link do not escape links to downstream jobs generated with a private ANSI CSI escape sequence, because the newer ansi_up escapes HTML. Work around its dropping of unknown sequences, and have the link use the Vue routing mechanism rather than a page reload. resolves #161	2021-09-25 19:07:36 +12:00
Oliver Giles	ded13ed9fe	docs: update references to current distro versions	2021-08-04 12:03:38 +12:00
Oliver Giles	15dbed4cac	pkg: move centos8 to rocky8	2021-08-04 12:02:09 +12:00
Oliver Giles	e67e0bc453	examples: add git post-receive hook example	2021-07-30 19:59:13 +12:00
Oliver Giles	2de8b91ad2	examples: consistently omit extension for scripts	2021-07-30 19:58:44 +12:00
Oliver Giles	399f07cf3a	add example config for nginx reverse proxy	2021-07-24 20:08:23 +12:00
Chl	2941a5abdd	Fix typos and formulation in UserManual.md	2021-07-21 08:41:22 +12:00
Oliver Giles	a50514a135	frontend: better dynamic update of graphs react to jobCompletion messages by updating graphs in more cases so manual refresh is not necessary to see most up to date representation.	2021-07-09 10:04:20 +12:00
Oliver Giles	60f7ee5402	make cmake 3.6 the minimum supported version All packaged distros have this for a long time now.	2021-07-09 10:04:20 +12:00
Oliver Giles	7f1c293588	pkg: centos8 has cmake not cmake3	2021-07-09 10:04:20 +12:00
Starbeamrainbowlabs	fe4caa155b	README: Use nproc to get cpu core count This way, make will always use all the available cpu cores.	2021-06-24 11:05:12 +12:00
Oliver Giles	f3a6ba2f4b	console log: improve color scheme based on base16 default/bright palette	2021-06-11 15:41:16 +12:00
Oliver Giles	dff4c93e15	cmake: GTEST_LIBRARIES not GTEST_LIBRARY Seems this used to be OK but now not always...	2021-06-09 20:39:01 +12:00
Oliver Giles	747ae3ada8	abort test: use "sleep inf" instead of "yes" Sometimes yes can produce too much output too quickly and overwhelm the host. It is not relevant to testing the abort functionaliy. resolves #143	2021-06-04 15:26:23 +12:00
Oliver Giles	9a5ccc70e3	add example script for docker builds	2021-06-04 10:12:59 +12:00
Oliver Giles	d01cf1c9b0	failure to remove rundir should not abort the jobrunner kj::Directory::remove will throw if it fails to remove some files, e.g. in case of insufficient permissions. Catch this and move right along. resolves #156	2021-05-23 14:42:06 +12:00
Oliver Giles	02810309fc	make taskFailed non-fatal turns out we can end up here when an http client unexpectedly drops the connection, so it must not cause an exit()	2021-05-03 09:18:06 +12:00
Oliver Giles	b16991b17a	fix race in http log output Creating of LogWatcher makes it automatically receive new log chunks as it is part of logWatchers. But we cannot be sure that stream->write().then() will have already completed, so there is a chance that a null fulfiller will be caused, causing a crash. We cannot defer the creation of the LogWatcher until after stream->write() because in the meantime we may lose new messages, so call writeLogChunk to make sure we have a fulfiller before entering stream->write(). Also, pending chunks of log output were std::move()'d to the first interested client in the loop, they need to be copied if there is more than one client.	2021-03-19 21:11:22 +13:00
Paolo Greppi	c7c586167c	use relative paths to support LAMINAR_BASE_URL option	2021-03-19 20:47:56 +13:00
Jan-Benedict Glaw	7e77ec1211	Allow subdirs in artifacts directory Extend populateArtifacts() with a subdir parameter (default initialized to ".") to allow for recursive calls. With subdirs encountered, call recursively.	2021-03-08 20:30:59 +13:00
Oliver Giles	9b8c3762ec	fe: do not html entity encode angle braces in log output, ansi_up does it already. resolves #148	2021-03-07 21:02:42 +13:00
vrein	c42b6d4207	Pass reason and queuedAt to Home page	2021-02-22 08:53:05 +13:00
Oliver Giles	8df882b273	remove debug logging in app.js	2021-01-09 21:52:02 +13:00
Oliver Giles	14ea1f0f43	move ansi_up to latest version: 4.0.4 this is also the version in debian libjs-ansi-up	2021-01-09 21:51:12 +13:00
meskio	381fd8b55e	Remove vue-router in the build process (#141 )	2021-01-07 09:32:14 +13:00
Oliver Giles	9f969ae847	remove deprecated href to custom style.css	2021-01-02 21:26:50 +13:00
Oliver Giles	907f3926ce	remove dependency on vue-router only a small subset of vue-router is used, and integration is complicated by each route having its own EventSource request. Implementing the routing directly allows simplification of the EventSource logic. Another motivating factor is that the vue-router packages in debian have been unreliable, making the dependence on vue-router a hinderance for packaging laminar in debian.	2021-01-02 21:26:13 +13:00
meskio	c140fb51eb	Add Documentation links to the systemd service (#139 )	2020-12-09 07:51:10 +13:00
meskio	63bbb8a6e7	Fix errors on the man page (#138 )	2020-12-09 07:50:37 +13:00
Alex Myczko	882978fa77	Update client.cpp (#137 ) fix typo	2020-12-09 07:48:29 +13:00