To install the minimal requirements on Debian/Ubuntu, run this:

The default versions packaged in recent Debian/Ubuntu releases are generally new enough to be compatible. If you are using older releases or a different variety of Linux, there are a few known minimum versions:

• cmake (>= 3.5)

• curl (>= 7.47)

• libboost-* (>= 1.58.0)

• libcurl4-openssl-dev (>= 7.47)

• libpthread-stubs0-dev (>= 0.3)

Additional packages are used for non-essential components:

• To build the test suite, you will need python3-dev python3-openssl python3-venv sqlite3 valgrind.

• To run the linting tools, you will need clang clang-format-6.0 clang-tidy-6.0.

• To build additional documentation, you will need doxygen graphviz.

• To build with code coverage, you will need lcov.

Some features also require additional packages:

• For OSTree support, you will need libostree-dev (>= 2017.7).

• For PKCS#11 support, you will need libp11-2 libp11-dev.

• For systemd support for secondaries, you will need libsystemd-dev.

• For fault injection, you will need fiu-utils libfiu-dev.

• For Debian packagin support, you will need libdpkg-dev.

This project uses git submodules. To checkout the code:

If you had an old checkout, forgot to include --recursive or need to update the submodules, run:

aktualizr is built using CMake. To setup your build directory:

You can then build the project from the build directory using Make:

You can also create a debian package:

To use CMake’s Ninja backend, add -G Ninja to the first CMake invocation. It has the advantage of running all targets in parallel by default and is recommended for local development.

Before checking in code, it must pass the following tests (along with their corresponding build targets):

• compilation of the main targets and tests without warning: make and make build_tests

• validation against the project’s automatic formatting conventions: make check-format to run the check, make format to apply the transformation automatically

• absence of clang-tidy warning: make clang-tidy

• full test suite run: make check (test build included), make test (only run the tests)

The qa target includes all of these checks, including auto-formatting:

Note that, by default, the compilation and tests run in sequence and the output of failing tests is suppressed. To run in parallel, for example with eight threads, and print the output of failing tests, run this:

Some tests require additional setups, such as code coverage, HSM emulation or provisioning credentials (credentials.adoc). The exact reference about these steps is the main test script used for CI. It is parametrized by a list of environment variables and is used by our CI environments. To use it, run it in the project’s root directory:

Note that it will run CMake itself in a dedicated build directory.

To get a list of the common environment variables and their corresponding system requirements, have a look at the Jenkins Pipelines definitions and the project’s Dockerfiles.

Generate tags:

Several Dockerfiles are provided to support building and testing the application without dependencies on your local environment.

If you have a working docker client and docker server running on your machine, you can build and run a docker image on the default environment with:

It will start a shell session inside the container, running as the same UID/GID as on the host system, with the current directory mounted as a docker volume. Any local code changes are then immediately in effect inside the container and user/group permissions are compatible in the two environments.

Inside the container, the test suite with coverage can be run with:

(see the content of Jenkinsfile and scripts/test.sh for more testing options)

Alternatively, scripts/run_docker_test.sh can directly run the test script:

To run the aktualizr client, you will need to provide a toml-formatted configuration file using the command line option -c or --config:

Additional command line options can be found in the code (see ../src/aktualizr_primary/main.cc) or by running aktualizr --help. More details on configuring aktualizr can be found in docs/configuration.adoc. If you are using meta-updater, more information about configuring aktualizr in that environment can be found there.

Aktualizr is generally intended to run on embedded devices, but you may find it convenient to run it on your local system for development or testing. To get a binary you can run locally, you can:

• follow the build instructions,

• install a Ubuntu packages from the Releases page, or

• install through Homebrew on MacOS

Some more detailed instructions on how to configure a fake device can be found on the OTA Connect docs site.

If you intend to use aktualizr to authenticate with a server, you will need some form of provisioning. Aktualizr currently supports two methods of provisioning: automatic and implicit. You can also implicitly provision by using an HSM. You can learn more about the credentials files used to support provisioning in docs/credentials.adoc.

Developer's Certificate of Origin 1.1

By making a contribution to this project, I certify that:

(a) The contribution was created in whole or in part by me and I
    have the right to submit it under the open source license
    indicated in the file; or

(b) The contribution is based upon previous work that, to the best
    of my knowledge, is covered under an appropriate open source
    license and I have the right under that license to submit that
    work with modifications, whether created in whole or in part
    by me, under the same open source license (unless I am
    permitted to submit under a different license), as indicated
    in the file; or

(c) The contribution was provided directly to me by some other
    person who certified (a), (b) or (c) and I have not modified
    it.

(d) I understand and agree that this project and the contribution
    are public and that a record of the contribution (including all
    personal information I submit with it, including my sign-off) is
    maintained indefinitely and may be redistributed consistent with
    this project or the open source license(s) involved.