> Should the AppImageKit repository (or only the parts needed for building
> the runtime.c file) be imported into the QBS repository (maybe added as
> a git submodule)? Or should we fetch the sources at runtime?
Ideally, I think, the user would just invoke some tool and use a prebuilt
binary and not need to build the run-time from source. If building from
source is required, let the user install AppImageKit somewhere and just
point Qbs to the installation path in a property like shown below.
> Do we have examples of other modules having similar requirements?
Just a module would not be enough. You will need at least one separate
product item for the run-time binary. An appimage module makes sense if you
need common appimage properties in multiple product items, for instance the
AppImageKit install path.
> I'd like to write a QBS module to package Linux applications into the
> AppImage format. This is a format in which the all application's files
> (and non-trivial dependencies) are packed into a single executable file,
> which, when executed, unpacks the application data by mounting into a
> squashfs filesystem and then executes the application's main binary.
>
> The trick here is how to create the "loader" part of the binary: the
> AppImage project provides the source code, which consists of a C file
> [1] and all of its dependencies (a slightly modified version of
> libsquashfs, and a few other utility files), but it's not clear to me on
> what would be the best way to bring these files into one's project.
Why do you need to build "runtime" from source? Is a prebuilt version not
shipped together with AppImageKit or at least available here:
https://github.com/AppImage/AppImageKit/releases ?
Presuming that runtime.c is shipped with AppImageKit, there are probably
many ways to implement that. Here is a very naive idea of a product item
that does both: building the run-time binary as well as packaging up the
application bundle:
// AppImage.qbs
CppApplication {
type: [ "application", "appimage.runtime", "appimage.package ]
property string appImageKitInstallPath
Group {
name: "runtime"
prefix: appImageKitInstallPath + "/"
files: [ "runtime.c" ]
}
// Have a look at
https://code.qt.io/cgit/qbs/qbs.git/tree/src/packages/archive/archive.qbs#n49
// The rule will need to depend on all all installables and
// appimage.runtime and will bake the run-time and the rest together
// into an artifact of type "appimage.package".
// You will specify the depencies later in yourproject.qbs
Rule {}
}
// yourproject.qbs
Project {
CppApplication { name: "yourapp"; /* ... */ }
AppImage {
appImageKitInstallPath: "/path/to/AppImageKit"
Depends { name: "yourapp" }
}
}
Maybe that gives you an idea how and where to start.
You could also create a AppImageRuntime product item and an AppImagePackage
product item to separate the two tasks better. And you could also implement
a module if these items have common properties or you could put all rules
into the module.
Richard
___
Qbs mailing list
Qbs@qt-project.org
https://lists.qt-project.org/listinfo/qbs
