After 37b6e68c I forgot to update this
path.

Recently we moved infrastructure repositories under a new path. Docker
registries have therefore moved too.  Reflect this in our CI settings.

In deployment we use docker logs forwarded to journald. I'd really want
to log directly into host's journal but that is a task for some other day.

Docker logs apparently [1] make the message's severity higher if it is
parsed from stderr.

Worker will now log WARNING and higher to stderr if invoked with
--log-stderr option.
We modified spdlog's dist_sink to enable this functionality.

Closes #46.

[1] https://github.com/docker/docker-ce/blob/96d50fd61df5a62a26609523619f5a5386b7d6db/components/engine/daemon/logger/journald/journald.go#L122

Split Docker part of the build into two (build and deploy).
Run CI docker builds with every commit and save the images.
Deploy only when on staging or master.

In case the worker segfaults (ALT unfortunately sometimes segfaults)
then the job is not acknowledged to the server. This causes another
worker to pick up the job and segfault too.
Invoking acknowledge before evaluation is not possible; the server could
assign us a new job before finishing this one and whole load balancing
would be useless.

Hence I propose splitting worker into two executables.

The first one, evaluator, would simply read json from input, evaluate and
compose a json output. Nothing more.

The second one, worker, would manage all the queue stuff (receiving,
sending, acknowledging, ...) and it runs the evaluator in a forked job.
This way we can not only handle timeouts but we can also see when the
child segfaults and report it properly to the server.

Closes #44

:)

This was a little bit overdesigned, probably. KISS.

Introduce "--log-level" option for log verbosity. Remove
ALT_WORKER_DEBUG env var detecting in main. Instead move it into
docker entrypoint.

I have some plans with CLI arguments in the next patches and I do not
want to parse it manually. Argparse [1] looks like a nice header-only
library for that.

[1] https://github.com/p-ranav/argparse

Let's just say that the Catch2 framework should be there. We do not care
how it gets there.
Also create "testing.hpp" proxy header file which shadows the tests from
knowing that they are part of Catch2 testing suite.

This was unbearable so I am introducing a .clang-format configuration
file and reformatting codebase.

Remove manually writen loggers in favour of spdlog.

We are using alt's docker images based on alpine:edge. As of today (Oct
31, 2020), strange errors began to come from cmake/make.

```
 -- Check for working C compiler: /usr/bin/cc
 -- Check for working C compiler: /usr/bin/cc - broken
 CMake Error at /usr/share/cmake/Modules/CMakeTestCCompiler.cmake:66 (message):
   The C compiler

     "/usr/bin/cc"

   is not able to compile a simple test program.

   It fails with the following output:

     Change Dir: /app/CMakeFiles/CMakeTmp

     Run Build Command(s):/usr/bin/make cmTC_49c71/fast && /usr/bin/make  -f CMakeFiles/cmTC_49c71.dir/build.make CMakeFiles/cmTC_49c71.dir/build
     make: /usr/bin/make: Operation not permitted
     make: *** [Makefile:140: cmTC_49c71/fast] Error 127

   CMake will not be able to correctly generate this project.
 Call Stack (most recent call first):
   CMakeLists.txt:2 (project)
```

However, ninja builds seem fine. In the alpine:edge they have the
samurai[1] implementation of ninja. Let's use that as a workaround.

[1] https://pkgs.alpinelinux.org/package/edge/main/x86_64/samurai

Some people might find the string input confusing. So we added a link to
ALT's documentation of `string::Parse` language.

The link is revealed only when string input is selected in the form.

Closes #45

This commit setups CI for protected branch staging. It
should contain changes that are to be merged into master.

- Fixed building tests (use standard BUILD_TESTING var)
- Sort filenames
- Use standard FindThreads instead of adding -pthread to CXXFLAGS

Reporting only the top level exception from ALT is simply not enough.
Compare the difference between these two errors logs propagated to the
webui and/or worker's logger.

Error: Evaluation of algorithm string::Parse failed.

vs.

Evaluation of algorithm string::Parse failed.
 -> Multiple initial states are not avaiable for DFA type

Closes #41.

We encountered a bug #39 that caused DotConverter to fail sometimes.
After debugging backend we noticed that DotConverter is trying to be
evaulated with templateParams 'automaton::Automaton' which was weird.
(It could be also noticed from the JSONs sent to backends, but I was
super blind.)

After some messing with the frontend it seemed that DotOutput node (when
put) on the canvas already has the templateParams set wrong. It seemed
that this happens only when putting it on the canvas after a node that
has templateParams specified (like string::Parse).

The solution is therefore to set templateParams to empty before putting
any special node on canvas.

Closes #39.

This patch announces WebUI and ALT versions in the top bar of
webui-client page. The ALT version is fetched from the ALIB_VERSION
macro in ALT's version.hpp. WebUI version must be passed manually.
Both are stored in a separate json file.

Also cleanup static files, including algorithms.json. It should always
be built against current ALT backend and not stored in the repository.

EvaluateHandler id synchronization