Rust Howto (Request)

Applications Others
#36

Are you using the Platform SDK (sfossdk) or the Application SDK (sfdk)? I’m going to assume you’re using sfdk, but if that’s not the case then you’ll need to adjust the following. Also, are you using snapshots? This is important because installing into a target doesn’t necessarily make a package available in a snapshot. To check run sfdk config and see whether snapshot is set.

If you have a local rpm package that you want to install to a target, one way to do it is like this:

sfdk engine exec sb2 -t <target> -R -m sdk-install rpm -U <file.rpm>

The -R -m sdk-install part is what gives you the root access you need.

If you’re using snapshots you should avoid installing anything into the target like this, since it will mean an important benefit of using snapshots – knowing whether you’ve captured all of the dependencies – is lost. So if you have snapshots enabled you should install into the snapshot instead. The easiest way to find the name of the snapshot in use is to do a build. The snapshot name is output right at the start, like this:

Taking snapshot 'SailfishOS-4.1.0.24-armv7hl.mb2.2LJ' of 'SailfishOS-4.1.0.24-armv7hl' target...

In this case you’d change the install command to the following:

sfdk engine exec sb2 -t SailfishOS-4.1.0.24-armv7hl.mb2.2LJ -R -m sdk-install rpm -U <file.rpm>

(i.e. use the snapshot name instead of the target name).

One other thing you could consider is using a shared output directory (see sfdk --help-all and search for SHARED), since in this case sfdk will automatically search the output directory for any build dependencies.

Please do share your experiences with Sailserver and rust, it’d be interesting to hear how things progress.

1 Like
#37

Still dont get it.

sb2 -t SailfishOS-latest-aarch64 -m sdk-install -R rpm --install rust-1.52.1+git1-1.aarch64.rpm cargo-1.52.1+git1-1.aarch64.rpm

        package rust-1.52.1+git1-1.aarch64 is already installed
        package cargo-1.52.1+git1-1.aarch64 is already installed
[mersdk@8924e8b8daed RPMS]$ sb2 -t SailfishOS-latest-aarch64 rustc -V
rustc 1.44.0-dev

using sfdk engine exec in the default sfos sdk gave same result.
It simply does not pickup the correct rustc/cargo version and makes it impossible to compile “moderner” rust applications.

#38

I’m not sure. Could your package be installing to a different path? Maybe compare the outputs from these:

$ sfdk engine exec sb2 -t SailfishOS-latest-aarch64 whereis rustc
rustc: /usr/bin/rustc
$ sfdk engine exec sb2 -t SailfishOS-latest-aarch64 rpm -fq /usr/bin/rustc
rust-1.44.0+git10-1.4.1.jolla.aarch64
$ rpm -qlp rust-1.52.1+git1-1.aarch64.rpm | grep rustc
...

Could you share your built rust package? I can try it out here.

#40

Ok the thing is that sb2 -t SailfishOS-latest-aarch64 will install it in the sysroot eg: srv/mersdk/targets/SailfishOS-latest-aarch64. When thinking of it I want install it as a “crosscompiler” eg in the /src/toolings/usr/bin because that is what sb2 -t ... cargo build will execute when build. And that’s why it points to the old compiler when doing sb -t SailfishOS-latest-aarch64 cargo -V. Now I have to find out how to install the RPM inside the srv/mersdk/toolings and it should probably use the “hosts” rustc and not the aarch64 one that I built with mb2 command…

#41

Not sure if helpful (most of this is over my head…), but I installed rust directly from here - Install Rust - Rust Programming Language - and used it to build viu, and everything good…

1 Like
#42

In that case you probably just need to install the (x86) rpm package like this:

sfdk engine exec sudo rpm -U <file.rpm>
#43

New issues. Can’t build rpm for i486 host of the :

# local fork of  https://github.com/sailfishos/rust.git 
sfdk engine exec mb2 -t SailfishOS-4.1.0.24-i486 -s rust.spec build

+ PATH=/opt/cross/bin/:/home/mersdk/.mb2/wrappers/rust:/home/mersdk/.mb2/user-wrappers/rust:/usr/local/bin:/bin:/usr/bin
+ ./configure --prefix=/usr --exec-prefix=/usr --bindir=/usr/bin --sbindir=/usr/sbin --sysconfdir=/etc --datadir=/usr/share --includedir=/usr/include --libdir=/usr/lib --libexecdir=/usr/libexec --localstatedir=/var --sharedstatedir=/var/lib --mandir=/usr/share/man --infodir=/usr/share/info --disable-option-checking --libdir=/usr/lib --build=i686-unknown-linux-gnu --host=i686-unknown-linux-gnu --target=i686-unknown-linux-gnu,armv7-unknown-linux-gnueabihf,aarch64-unknown-linux-gnu --python=python3 --local-rust-root=/home/mikael/MyStuff/src/rust/rust-1.52.1-i686-unknown-linux-gnu/usr --enable-local-rebuild --enable-llvm-link-shared --enable-ccache --enable-optimize --disable-docs --disable-compiler-docs --disable-jemalloc --disable-rpath --disable-codegen-tests --disable-verbose-tests --debuginfo-level=0 --debuginfo-level-std=2 --disable-debuginfo --disable-debuginfo-only-std --disable-debuginfo-tools --disable-debuginfo-lines --enable-extended --enable-vendor --set rust.codegen-units-std=1 --tools=cargo --llvm-root=/usr/ --enable-parallel-compiler --set target.i686-unknown-linux-gnu.cc=/usr/bin/cc --set target.i686-unknown-linux-gnu.ar=/usr/bin/ar --set target.armv7-unknown-linux-gnueabihf.cc=/opt/cross/bin/armv7hl-meego-linux-gnueabi-cc --set target.armv7-unknown-linux-gnueabihf.ar=/opt/cross/bin/armv7hl-meego-linux-gnueabi-ar --set target.aarch64-unknown-linux-gnu.cc=/opt/cross/bin/aarch64-meego-linux-gnu-cc --set target.aarch64-unknown-linux-gnu.ar=/opt/cross/bin/aarch64-meego-linux-gnu-ar --set build.verbose=2
/var/tmp/rpm-tmp.8hqBY8: line 65: ./configure: No such file or directory
error: Bad exit status from /var/tmp/rpm-tmp.8hqBY8 (%build)
    Bad exit status from /var/tmp/rpm-tmp.8hqBY8 (%build)
#44

Can you share the source you’re attempting to build (including the spec file)? I think this would be a big help in understanding what might be happening.

Edit: Ah, sorry, I see in the comment where it’s coming from. I’ll give it a go myself.

#45

It looks like the git-submodule branch is better set up for building with the sfdk. You’ll also need git lfs installed, and on the first run will need to run the prepare step to apply the patches. Something like this seems to work for me (it’s still running, so not fully tested), You’ll probably need to amend the steps for your set up.

# Set up git large file storage (this on Ubuntu)
sudo apt install git-lfs
git lfs install

# Clone the repo and submodules
git clone https://github.com/sailfishos/rust.git
cd rust
git checkout git-submodule
git submodule update --init
cd rust
git submodule update --init
cd ..

# Initial build with prepare step
sfdk config --session --push target SailfishOS-4.1.0.24-i486
sfdk build -p 

# Subsequent builds
sfdk config --session --push target SailfishOS-4.1.0.24-i486
sfdk build
#47

Without more detail it’s hard to help I’m afraid. Which patch didn’t apply, and what was the error message? They apply fine for me here.

#48

I forgot run 2nd git submodule inside the subdir. I try again…

#50

Okey after some more testing I realized this submodule branch is not the solution since that branch is rust 1.44.

I also tried this in master branch:

sfdk build -p 
Fatal: No spec or yaml file found in './rpm/'
#51

So, I’ve been toying a lot with Rust and build systems lately. The cleanest that I could find so far uses either my version of Rust 1.52 (if you use build scripts or target-conditional dependencies, this is needed), or the 1.52 that’s currently included with the tooling and targets of SailfishOS 4.2.0.19EA.

I’ve moulded and kneaded the spec and yaml files of a standard app such that it calls cargo build. I have worked on qmetaobject-rs (also this), such that it still works on Qt 5.6. I started a crate sailo-rs which wraps around sailfishapp. Combining all of these (and maybe also qmeta-async, if that’s your kinda kink — it certainly is mine) means you can actually build Sailfish applications in about 130 lines of Rust. As an example to that, I present you:

In order to build it, you’ll need the build instructions for Whisperfish’ SFDK branch, which should soon™ hit master. It involves only installing the custom Rust version (in fact, custom Cargo version), which Jolla will hopefully fix in the 4.3 or 4.4-series.

It integrates so well now, that you can even use QtCreator to build it. It contains a .pro file, and you only need to fiddle a bit with the build settings: you need to disable the qmake and make steps, and add sfdk build.

image
image1026×223 15.2 KB

The run-configuration can look like this:

image
image794×412 28.3 KB

As of there, QtCreator will happily do many things that you’d do on a daily basis. I’ve even seen qmlive work, more or less!

6 Likes
#52

(gonna try to answer some ill-answered or unanswered questions now)

We seem to have the same experience when building Whisperfish now: the VBox version has problems finding downloaded crates, the Docker version runs just fine.

-j 1 is also used in Whisperfish. There’s a bug in (presumably) SB2, which gets cargo stuck in a futex when running with “too high level of parallelism”. Eventually, it probably will also lock up on -j 1, but it seems to deter for now. If dropping the parallelism flag works for you, you could drop it locally. I’d still keep it in CI. I think @flypig may be able to give more context.

You’re probably running the VirtualBox SDK, which seems to behave badly w.r.t. the SB2 tooling-based cross compilation. @direc85 and me are trying to figure out, but it seems like the Docker-based SDK works better.

I use these two scripts to get Rust in a tooling and target:

build.sh (compiles the actual Rust and Cargo):

#!/bin/sh -ex
ARCHS="i486 armv7hl aarch64"

cd rust
for arch in $ARCHS; do
rpmbuild -bb rust.spec  --define "_target_cpu $arch"
done
cd ..

install.sh (Creates the stub compilers and repackages the stdlib):

#!/bin/sh -ex

ARCHS="i486 armv7hl aarch64"
TOOLING=SailfishOS-4.1
# TARGET=SailfishOS-3.4-on-4.1
TARGET=SailfishOS-4.1
VERSION=1.52.1+git1-1

sudo zypper install ~/rpmbuild/RPMS/i486/rust* ~/rpmbuild/RPMS/i486/cargo* || echo zypper error
cd cross
rpmbuild -bb rust-cross-aarch64.spec
rpmbuild -bb rust-cross-armv7hl.spec
cd ..

mkdir -p /srv/mer/toolings/$TOOLING/tmp/rust-rpms/
for f in ~/rpmbuild/RPMS/i486/rust* ~/rpmbuild/RPMS/i486/cargo*; do
    cp $f /srv/mer/toolings/$TOOLING/tmp/rust-rpms/
done

sdk-manage tooling package-install $TOOLING /tmp/rust-rpms/{rust-std-static-i686-unknown-linux-gnu-$VERSION.i486.rpm,rust-std-static-armv7-unknown-linux-gnueabihf-$VERSION.i486.rpm,rust-std-static-aarch64-unknown-linux-gnu-$VERSION.i486.rpm,rust-$VERSION.i486.rpm,cargo-$VERSION.i486.rpm}

rm -rf /srv/mer/toolings/$TOOLING/tmp/rust-rpms/*

for arch in $ARCHS; do
    sdk-manage target package-remove $TARGET-$arch rust cargo rust-std-static-i686-unknown-linux-gnu rust-std-static-aarch64-unknown-linux-gnu rust-std-static-armv7-unknown-linux-gnueabihf || echo continuing
done

for arch in $ARCHS; do
    sdk-manage target package-install $TARGET-$arch ~/rpmbuild/RPMS/$arch/*
done

These assume that you have https://github.com/sailfishos/rust and https://github.com/sailfishos/rust-cross in directories next to eachother, respectively rust and cross. I run these scripts inside the Platform SDK, not in mb2 (these packages used to build in mb2, but Jolla seems to have changed their strategy for the better here).

On SDK 4.1, you can use the repo on my home server, which hosts the patched cargo: ssu ar https://nas.rubdos.be/~rsmet/sailfish-repo/ rubdos. These do not have bumped version numbers, so you have to fiddle a bit with zypper. If someone has a good suggestion on how to get a personalised version number that will get upped by Jolla, let me know.

4 Likes
#53

Hi @rubdos

Got some time today and made a little progress but still little lost.

I installed your prebuilt by run the ssu stuff inside the builder eg:
`
ssu ar Index of /~rsmet/sailfish-repo/ rubdos

zypper refresh
zypper install rust
sdk-manage target package-install SailfishOS-4.2.0.21-aarch64 rust
`

❯ sfdk engine exec sb2 -t SailfishOS-4.2.0.21-aarch64 cargo --version
cargo 1.52.0-dev <= seems correct?

The next step is now try build my rust app but still getting alot of error messages but probably doing it wrong way:

❯ sfdk engine exec sb2 -t SailfishOS-4.2.0.21-aarch64 cargo build --release --target=aarch64-unknown-linux-gnu

= note: aarch64-meego-linux-gnu-cc: error: unrecognized command line option ‘-m32’

#54

Ah. I should have published those rust packages on my server with an incremented version number. SDK 4.2 packages 1.52 too, so that might get you some confusion.

Now, you don’t need to use --target in sb2. Jolla has a hack for that, because that doesn’t 100% work in sb2.
You instead need to set these:

export SB2_RUST_TARGET_TRIPLE=aarch64-unknown-linux-gnu
export SB2_RUST_EXECVP_SHIM="/usr/bin/env LD_PRELOAD=/usr/lib/libsb2/libsb2.so.1 /usr/bin/env"
export SB2_RUST_USE_REAL_EXECVP=Yes
export SB2_RUST_USE_REAL_FN=Yes
export SB2_RUST_NO_SPAWNVP=Yes

For further inspiration, I suggest you read the Whisperfish rpm-spec!

#55

A small hint to save your fingers from some extra typing:

sfdk engine exec sb2 -t SailfishOS-4.2.0.21-aarch64 COMMAND ARGS...

is equivalent to

sfdk build-shell COMMAND ARGS...

(Provided that the above used target is the one currently selected with sfdk config.)

#56

Oh, that’s useful, thanks! Much easier to remember too.

#57

I toyed around with Rust development on sfos. Initially it seemed to work good, but when I use a build script I get a failed to determine package fingerprint for build script error. I tried it with the default packages for SailfishOS-4.3.0.12 and also with the packages from rubdos.

Is this a known issue? Are there workarounds?

#58

Are you building in a git repository with a submodule? There does seem to be an issue that causes cargo to try to update the submodule, which can be worked-around by temporarily moving the .git directory during the build. It may be that you’re hitting the same issue.

You can see the workaround applied in the gecko spec file, where the git folder is moved before the build and then moved back again afterwards.