cross-build nginx-unit with yocto/bitbake

[vitschwilk]

Hi,
I wanted to use nginx-unit within out yocto-project with an python (Fast-API) application.

Since it was quite a lot of work but ultimately decided against nginx-unit, I wanted to give some pointes for others that might also want to cross-compile nginx-unit.

tl:dr:

Similar to nginx you need need to patch nginx-unit heavily in order to make it cross-compilable.

People familiar with yocto will probably know the nginx recipe.

Unfortunately the is no recipe for nginx-unit.

Fortunately the configuration and compiling process of nginx-unt is very similar to nginx. So a lot of the work done in the patches in the recipe can be reused (but not reapplied) to nginx-unit.

I don't want to upload the full bitbake files. Tbh. they are kind of crude and hacky.
They will also not work without setting up certain things like directories or users.

As a side note I could not get the nxt_python312_mounts.h to configure correctly so I replaced them.

But here is the do_configure and the do_install (there is no do_deploy)

do_configure () {
    if [ "${SITEINFO_BITS}" = "64" ]; then
        PTRSIZE=8
    else
        PTRSIZE=4
    fi
    echo "running base configuration"
    ./configure \
        --crossbuild=Linux:${TUNE_ARCH} \
        --with-endian=${@oe.utils.conditional('SITEINFO_ENDIANNESS', 'le', 'little', 'big', d)} \
        --with-int=4 \
        --with-long=${PTRSIZE} \
        --with-long-long=8 \
        --with-ptr-size=${PTRSIZE} \
        --with-sig-atomic-t=${PTRSIZE} \
        --with-size-t=${PTRSIZE} \
        --with-off-t=8 \
        --with-time-t=${PTRSIZE} \
        --with-sys-nerr=132 \
        --with-atomic \
        --with-posix-memalign \
        --with-map-anon \
        --with-c99-variadic-macro \
        --with-gcc-variadic-macro \
        --with-memfd-create \
        --with-thread-storage \
        --with-sem-timedwait \
        --with-clock-monotonic-coarse \
        --with-clock-realtime-coarse \
        --cc-opt="${CFLAGS}" \
        --prefix="${prefix}" \
        --exec-prefix="${exec_prefix}" \
        --bindir="${bindir}" \
        --sbindir="${sbindir}" \
        --includedir="${includedir}" \
        --libdir="${libdir}" \
        --modulesdir="${libdir}/unit/modules" \
        --datarootdir="${datadir}" \
        --mandir="${mandir}" \
        --pkgconfigdir="${datadir}/pkgconfig" \
        --localstatedir="${localstatedir}" \
        --statedir="${localstatedir}/lib/unit" \
        --runstatedir="${localstatedir}/run/unit" \
        --logdir="${localstatedir}/log/unit" \
        --log="${localstatedir}/log/unit/unit.log" \
        --tmpdir="/tmp" \
        --pid="/run/nginx/nginx.pid "\
        --control="unix:${localstatedir}/run/unit/control" \
        --user="unit-user" \
        --group="unit-user" 


    echo "running python-${PYTHON_BASEVERSION} configuration"   
    ./configure python \
        --python-baseversion=${PYTHON_BASEVERSION} \
        --python-interpreter="${PYTHON}"

    rm -f ${S}/build/include/nxt_python${PYTHON_BASEVERSION}_mounts.h
    cat << END >> ${S}/build/include/nxt_python${PYTHON_BASEVERSION}_mounts.h
static const nxt_fs_mount_t  nxt_python_mounts[] = {
    {(u_char *) "/usr/lib/python${PYTHON_BASEVERSION}", (u_char *) "/usr/lib/python${PYTHON_BASEVERSION}", NXT_FS_BIND, (u_char *) "bind", 0, NULL, 1, 1},
};
END
}

do_install () {
    oe_runmake 'DESTDIR=${D}' install EXTRA_CFLAGS=" -lpcre -lz" 
    rm -rf ${D}${localstatedir}
}

FILES:${PN} += " \
    ${libdir}/unit/ \
"

INSANE_SKIP:${PN} += "ldflags"

The applied patch ensures that the configured variables (e.g. NXT_WITH_NXT_INT_SIZE) can be applied from the cli interface of the configure "script".

Basically the config script compiles a lot of C-code for the target, executes it and then checks the stdout.

So most of my patching boiled down to:

if var is already set:
    use this
else:
    do the default behavior

Especially the variable handling and testing for a config gave me a lot of trouble.
So please don't use my patch in a productive environment This was patched in a weekend without variance in testing (I cross compiled it only for one target).

Why I decides against nginx-unit

This is the main reason why I write this post.
Not because I didn't like nginx-unit (tbh. I do) but because I did not see a speed or hardware utilization benefit in comparison to uvicorn.

In my testing the were on par on my target but it is much easier to get uvicorn working in yocto.

Therefore to not just erase my work I wanted to give so pointers for others that might want or need to use nginx-unit in a yocto build environment.