Guidelines and HOWTOs/Snap: Difference between revisions

From KDE Community Wiki
No edit summary
 
(71 intermediate revisions by 7 users not shown)
Line 1: Line 1:
{{Construction}}
{{Construction}}


Want to run your application binaries on any Linux distribution? Snap makes that possible.
= Put Your App in the Snap Store =


For general purpose information about snap, snapcraft and how to use them please have a look at their documentation  as it excellently teaches you most generic information about snaps https://docs.snapcraft.io
[[File:Screenshot 20210318 150131.png|thumb|Snap Store KDE Page]]


Even so this page will teach you a lot of the basics of snaps.
It is a KDE goal to be [https://community.kde.org/Goals All About the Apps] to deliver our apps directly to our users. Snaps is one of the ways of doing this. Snaps are Linux app packages that can run on pretty much any Linux operating system. There is a single centralized Snap store ( https://snapcraft.io/store ) that delivers them to users.  Take a look at the [https://snapcraft.io/publisher/kde KDE page on the Snap Store] to see what's available.


TBD separate page specifically about how to use the content snap
== Snap intro ==
{{Construction}}


== Binary Sources ==
A Snap package typically contains all the files, including libraries and data files, to run the app. There are also Content Snaps which contain reusable libraries. KDE has the KDE Frameworks Content Snap https://snapcraft.io/search?q=kf6 and https://snapcraft.io/search?q=kf5 which includes recent Qt and KDE Frameworks and this is shared between all KDE apps so we do not have to waste disk space and build resources. With KDE / Plasma 6 the content pack has been split https://snapcraft.io/kde-qt6-core22-sdk for Qt6 and https://snapcraft.io/kf6-core22-sdk for KDE Frameworks 6.


Building a snap we'll lovingly call "snapping". At the time of writing you can snapcraft on two core systems: one is Ubuntu 16.04, the other is Ubuntu 18.04. Both of them are the LTS version of Ubuntu and therefore supported for what seems like forever. Snapcraft has native support to pull binary packages (i.e. debs) into the snap so that you might build against them without having to build the binaries yourselves. For example you could use Qt from Ubuntu directly without the need to build it in your snap. However, since the base systems are LTS the software is usually very dated. Seeing as you may need newer dependencies there's a bunch of ways you can get them besides pre-built Ubuntu debs:
Give it a try by installing a package or two on your system. E.g. the KDE desktop calculator app https://snapcraft.io/kcalc
{{Input|1=<nowiki>snap install kcalc</nowiki>}}
And run kcalc from your apps menu.


=== As Snapcraft Parts ===
This will have downloaded the kcalc Snap package from the Snap store into e.g. <code>/var/lib/snapd/snaps/kcalc_73.snap</code> and mounted it into e.g. <code>/snap/kcalc/current/</code>. You can also just download it to a local directory with  <code>snap download kcalc</code>, use <code>lesspipe kcalc*snap</code> to see what is inside it.


You can add any number of additional parts that build dependencies. For example you might build your own qtbase as part of snap. How much work this is can be vastly different between software. Building all of Qt can get quick old, at the same time relying on an ancient Qt may not be practical either.
<code>snap list</code> will show your currently installed snaps and it will now show that you have <code>kcalc</code> and the content snap <code>kf5-5-111-qt-5-15-11-core22</code> as well as the <code>core22</code> content snap installed.


=== From KDE neon ===
Snaps are containers, similar to Docker. From inside the Snap container access to the file system and system resources are limited. This is good for inter-app security but means the app sees your system quite differently from how you might expect.  You can "log" into the container with <code>snap run --shell kcalc</code> to have a look at how the snapped kcalc app sees your system.


We are in luck and KDE neon already builds packages for Ubuntu LTS, so you may choose to simply use neon debs on top of Ubuntu debs. This gives access to the latest Qt, KDE frameworks and other related libraries. This can be a huge time saver. Unfortunately Snapcraft's support for adding additional repositories is non-existent and so if you choose to go this route you may need to somewhat manually manage the build environment yourself e.g. using an especially prepared LXD container.
To give the app controlled permissions to the system it plugs connections into resources such as the network or container snaps. Run <code>snap connections kcalc</code> to see what it gets given access to. The auto connections are controlled by the snap store and app maintainers need to ask the snap store for the desired auto-connections. Connections can also be overridden locally.


=== From PPAs ===
You can take a look at the snap package with <code>snap download kcalc</code> which will download files such as <code>kcalc_73.assert</code> and <code>kcalc_73.snap</code>. The .assert has the checksums and signatures for the package.  The .snap has the (non-store) metadata and all the files of the package. <code>lesspipe kcalc_73.snap</code> to take a look.


Much like KDE neon, this too will require you to manage the build environment manually. Also, when using PPAs beware that they may not be compatible with neon (so, ideally you should use either-or) and that many of them are not particularly trustworthy or well maintained (important vis-a-vis security).
== Concepts ==


== Snapcraft ==
Snaps are usually one app per Snap package.  The Snap package contains all the libraries and resources it needs to run except those in the shared content <code>kf5-5-111-qt-5-15-11-core22</code> Snap.


The tool to build snaps is called snapcraft. The definition for how to craft a snap is written down in snapcraft.yaml. Generally speaking a snapcraft.yaml will contain global metadata of the snap, a list of applications provided by the snap, and lastly a list of parts that when put together result in the snap.
In practice this means all of Qt and KF(5/6) including Breeze icons and themes are in the kde-frameworks content Snap and your app Snap only needs to compile its own sources. If you apps needs more libraries you can either install these as DEB packages e.g. from the Linux operating system Ubuntu LTS or KDE neon, or you can compile them from source as well. You will need to manually list the build-packages (all the -dev packages) and the stage-packages used in the final package, it'll warn you if any final libraries it expects are missing.


== Types of Snap==
'''snapcraft''' is used to build snaps. It can be installed as a snap with <code>snap install snapcraft --classic</code>.  A snap package (app) is defined in the snapcraft.yaml file. Snapcraft will build the package inside a virtual machine; it uses LXD to build the KDE snap packages. Using a virtual machine makes it reliable to build the Snaps on different Linux operating systems with identical results.


With a broad overview of abilities and shortcomings let's dive right in and look at types of snaps we might build.
snapcraft.yaml files are kept in their respective upstream repo. Eg. kcalc snapcraft file resides [https://invent.kde.org/utilities/kcalc/-/blob/release/23.08/snapcraft.yaml?ref%20type=heads https://invent.kde.org/utilities/kcalc/-/blob/release/23.08/snapcraft.yaml?ref_type=heads]


=== Standalone  ===
Our Snaps read metadata from AppStream metadata files so it is important the metadata is up to date including current release versions.


A standalone snap is a snap which solely relies on a "core" but no other snaps. This is generally speaking the most reliable type of snap as everything the snap needs is inside the snap (except libc and friends which are in the core).
The [https://snapcraft.io/ Snap Store] is the centralized app store by Canonical. There is no practical way to use other stores or repositories with Snaps. It is what Snapcraft uploads built snaps to and what your local snapd will download and install snaps from. It also says what permissions those snaps should have. As an app developer if you want your app to have extra permissions (for example [https://invent.kde.org/utilities/kdf/-/blob/release/23.08/snapcraft.yaml?ref_type=heads kdf] uses mount-observe) then you need to ask for it on the [https://forum.snapcraft.io/t/request-for-connection-kdf-mount-observe/10953 snapcraft forum].


It is also the best supported way of building a snap since it's been around since the very beginning.
A Classic containment Snap has no restrictions on what files it can see on your system or what external executable can be run.  This is useful for Integrated Development Environments (IDEs) and similar apps such as [https://forum.snapcraft.io/t/kate-as-classic-snap/23514 Kate] which runs external programs. Again this needs to be set in your [https://invent.kde.org/utilities/kate/-/blob/release/23.08/snapcraft.yaml?ref_type=heads] then you need to ask on the Snap forum for the store to set it to classic. The Store will then tell snapd for anyone installing the Snap to have it installed as a Classic confinement Snap.


Advantages:
The KDE account on the Snap store is run by the Snap team developers Jonathan Esk-Riddell, Harald Sitter, Scarlett Moore, Carlos DeMaine, Kevin Ottens, Benjamin Port. One Snap on the store can be shared between more than one account so app maintainers can also create a separate account if they want to have more control over when their app is released and what the store says about it.


* Very reliable
The store has four channels for different levels of stability. Our stable branch builds get uploaded to the Candidate channel and can be moved to the Stable channel once tested.
* Easy to build and test
* You are always on your own and unrelated changes rarely if ever can impair your snap


Disadvantages:
== Example ==


* Huge in size (each standalone snap needs to ship their own Qt/l10n and necessary kf5 and other dependencies)
[https://apps.kde.org/blinken/ Blinken] is an exciting memory game from KDE.  It's [https://snapcraft.io/blinken available on the Snap store].  The Snap package is defined by a <code>snapcraft.yaml</code> file which is in the https://invent.kde.org/education/blinken/-/tree/release/23.08?ref_type=heads repo.  Any update to that branch triggers a build of the [https://launchpad.net/~kde-community/kde-snap-blinken/+snap/kde-snap-blinken-stable] in launchpad.  If the build is successful it will be uploaded to the <code>Candidate channel</code> of the Snap store ready for review.
* You need to take care of setting up your execution environment yourself.
* You are always on your own and unrelated changes rarely if ever can improve your snap


==== Example ====
The <code>snapcraft.yaml</code> file looks like this:


{{Input|<syntaxhighlight lang="yaml" line>
{{Input|<syntaxhighlight lang="yaml" line>
name: qtnetsample
---
version: '0'  # the version of the snap. has no semantic meaning
name: blinken
summary: This is my-snap's summary  # 79 char long summary
adopt-info: blinken
description: This is my-snap's description  # a longer description for the snap
confinement: strict
confinement: strict # use "strict" to enforce system access only via declared interfaces
grade: stable
grade: devel # use "stable" to assert the snap quality
base: core22
base: core18 # the core this snap depends on
 
apps:
apps:
     qtnetsample:
     blinken:
         command: launcher qtnetsample # the launcher will setup the environment for qtnetsample to find libraries/plugins/data etc
        common-id: org.kde.blinken.desktop
         plugs: [x11, network, network-bind] # this snap will be able to act as xclient and talk over the network
         command: usr/bin/blinken
 
        plugs:
        - desktop
        - desktop-legacy
        - opengl
        - wayland
        - x11
        - audio-playback
        - unity7
        command-chain:
        - snap/command-chain/desktop-launch
assumes:
- snapd2.55.3
compression: lzo
plugs:
    desktop:
        mount-host-font-cache: false
    icon-themes:
        interface: content
        target: $SNAP/data-dir/icons
        default-provider: gtk-common-themes
    sound-themes:
        interface: content
        target: $SNAP/data-dir/sounds
        default-provider: gtk-common-themes
    kf5-5-111-qt-5-15-11-core22:
        content: kf5-5-111-qt-5-15-11-core22-all
        interface: content
        default-provider: kf5-5-111-qt-5-15-11-core22
        target: $SNAP/kf5
environment:
    SNAP_DESKTOP_RUNTIME: $SNAP/kf5
hooks:
    configure:
         plugs:
        - desktop
        command-chain:
        - snap/command-chain/hooks-configure-desktop
layout:
    /usr/share/X11:
        symlink: $SNAP/kf5/usr/share/X11
slots:
    session-dbus-interface:
        interface: dbus
        name: org.kde.blinken
        bus: session
package-repositories:
-  type: apt
    components:
    - main
    suites:
    - jammy
    key-id: 444DABCF3667D0283F894EDDE6D4736255751E5D
    url: http://origin.archive.neon.kde.org/user
    key-server: keyserver.ubuntu.com
parts:
parts:
     qtnetsample:
     kde-neon:
         build-packages: [qt5-default]
        source: /snap/snapcraft/current/share/snapcraft/extensions/desktop/kde-neon
        source-type: local
        plugin: make
        make-parameters:
        - PLATFORM_PLUG=kf5-5-111-qt-5-15-11-core22
         build-snaps:
        - kf5-5-111-qt-5-15-11-core22-sdk
        build-environment:
        - &id001
            PATH: /snap/kf5-5-111-qt-5-15-11-core22-sdk/current/usr/bin${PATH:+:$PATH}
        - &id002
            XDG_DATA_DIRS: $CRAFT_STAGE/usr/share:/snap/kf5-5-111-qt-5-15-11-core22-sdk/current/usr/share:/usr/share${XDG_DATA_DIRS:+:$XDG_DATA_DIRS}
        - &id003
            XDG_CONFIG_HOME: $CRAFT_STAGE/etc/xdg:/snap/kf5-5-111-qt-5-15-11-core22-sdk/current/etc/xdg:/etc/xdg${XDG_CONFIG_HOME:+:$XDG_CONFIG_HOME}
        - &id004
            CRAFT_CMAKE_ARGS: -DCMAKE_FIND_ROOT_PATH=/snap/kf5-5-111-qt-5-15-11-core22-sdk/current${CRAFT_CMAKE_ARGS:+:$CRAFT_CMAKE_ARGS}
    blinken:
        after:
        - kde-neon
        parse-info:
        - usr/share/metainfo/org.kde.blinken.appdata.xml
        source: .
        source-type: local
         plugin: cmake
         plugin: cmake
         stage-packages: [libqt5network5, libqt5core5a]
        build-packages:
         source: .
        - cmake
</syntaxhighlight>}}
        - libkf5doctools-dev
        - libphonon4qt5-dev
        - libphonon4qt5experimental-dev
         stage-snaps:
        - khelpcenter
        cmake-parameters:
         - -DKDE_INSTALL_USE_QT_SYS_PATHS=FALSE
        - -DCMAKE_INSTALL_PREFIX=/usr
        - -DCMAKE_BUILD_TYPE=Release
        - -DENABLE_TESTING=OFF
        - -DBUILD_TESTING=OFF
        - -DKDE_SKIP_TEST_SETTINGS=ON
        - "-DCMAKE_FIND_ROOT_PATH=/usr\\;$CRAFT_STAGE\\;/snap/kf5-5-111-qt-5-15-11-core22-sdk/current"
        - "-DKDE_INSTALL_PLUGINDIR=/usr/lib/$CRAFT_ARCH_TRIPLET/qt5/plugins/"
        prime:
        - "-usr/lib/*/cmake/*"
        - "-usr/include/*"
        - "-usr/share/ECM/*"
        - "-usr/share/man/*"
        - "-usr/share/icons/breeze-dark*"
        - "-usr/bin/X11"
        - "-usr/lib/gcc/$CRAFT_ARCH_TRIPLET/6.0.0"
        - "-usr/lib/aspell/*"
        - "-usr/share/lintian"
        build-environment: &id005
        - *id001
        - *id002
        - *id003
        - *id004
    cleanup:
        after:
        - kde-neon
        - blinken
        plugin: nil
        override-prime:  |
            set -eux
            # # Unused libraries found by linter


=== Shared Snap ===


A snap may also choose to use one or more Content Snaps (see glossary) to share part of the binaries or UI assets with other snaps. As shared content will generally be in the content snap, the ultimate size of the snap can be fairly small. Think of this as an approach more akin to how traditional binary package dependencies work. Albeit with many of the same complexities surrounding it.


For example KDE neon builds the kde-frameworks-5 content snap. It contains all of Qt and all (not-deprecated) KDE frameworks along with Plasma integration rigging.
</syntaxhighlight>}}


Advantages:
Check [https://snapcraft.io/docs/snapcraft-yaml-reference Snapcraft YAML reference] if unsure.


* Application snap is super small
=== Top Level ===
* You don't need to care of setting up the execution environment
* Integration and international improvements are all in one place (shared environment setup etc)
* Generally speaking when using the KF5 content snap SDK you can get access to KDE neon's Qt and Frameworks without having to actually add the deb sources.


Disadvantages:
* name: blinken ← the snap name registered on the snap store
* confinement: strict ← Snaps are a containerised format and can't see the outside system from inside their container.  Strict is the normal container method.  Classic is also possible which allows it to see the outside system and is used by e.g. Kate because Kate needs to run external programs like Git.  It can only be Classic on request.  Can also be devmode for testing.
* grade: stable ← It must be stable to be in a released channel, can also be devel.
* base: core22 ← which base system to build on, core22 means Ubuntu 22.04 and is the current recommended.
* adopt-info: blinken ← Which Snap part to get the appstream info from.  This sets version, icon, description.


* Up-front "cost" of a single application may be higher. e.g. if the application only uses QtCore, the content snap will still bring in all of Qt and all of KF5 through the content snap. It's like a shared library, the more it is used the smaller the cost per-user.
You might also need to add <code>version</code> if it is not in the appstream file. This is just a version read by users it does not affect the revision number which is tracked by the store.
* Somewhat harder to build and test because of added complexity. Also managing deb build dependencies in addition to content snap SDKs is problematic '''TBD link to forum post'''
* Unrelated changes in the content snaps may impair your snap
* Since this type was introduced a while after snap initially came into being you still can feel rough edges when working with content snaps.


==== Example ====
=== apps ===


{{Input|<syntaxhighlight lang="yaml" line>
{{Input|<syntaxhighlight lang="yaml" line>
---
name: kbruch
version: 18.12.1
confinement: strict
grade: stable
base: core18
adopt-info: kbruch # part to adopt appstream data from (first in parse list)
apps:
apps:
     kbruch:
     blinken:
         command: kf5-launch kbruch
        extensions:
        - kde-neon
        common-id: org.kde.blinken.desktop
         command: usr/bin/blinken
         plugs:
         plugs:
         - kde-frameworks-5-plug
         - desktop
         - home
        - desktop-legacy
        - opengl
         - wayland
         - x11
         - x11
         - opengl
         - audio-playback
        - network
        - network-bind
         - unity7
         - unity7
         - pulseaudio
         command-chain:
        - desktop
         - snap/command-chain/desktop-launch
        - desktop-legacy
 
        common-id: org.kde.kbruch.desktop
         desktop: "usr/share/applications/org.kde.kbruch.desktop"
slots:
    session-dbus-interface:
        interface: dbus
        name: org.kde.kbruch
        bus: session
plugs:
    kde-frameworks-5-plug:
        content: kde-frameworks-5-core18-all
        interface: content
        default-provider: kde-frameworks-5-core18
        target: kf5
parts:
    kbruch:
        build-snaps:
        - kde-frameworks-5-core18-sdk
        after:
        - kde-frameworks-5-env
        plugin: cmake
        source: src
        configflags:
        - "-DKDE_INSTALL_USE_QT_SYS_PATHS=ON"
        - "-DCMAKE_INSTALL_PREFIX=/usr"
        - "-DCMAKE_BUILD_TYPE=Release"
        - "-DENABLE_TESTING=OFF"
        - "-DBUILD_TESTING=OFF"
        - "-DKDE_SKIP_TEST_SETTINGS=ON"
        parse-info: [usr/share/metainfo/org.kde.kbruch.appdata.xml]
    kde-frameworks-5-env:
        plugin: dump
        source: https://github.com/apachelogger/kf5-snap-env.git
</syntaxhighlight>}}
</syntaxhighlight>}}


== Execution Environment and Launchers ==
<code>apps</code> are the programs which the snap includes for users to run.  Usually there is only one in a Snap but sometimes e.g. [https://invent.kde.org/office/calligra/-/blob/calligra/3.3/snapcraft.yaml?ref_type=heads Calligra] there are more than one.
 
The [https://snapcraft.io/docs/kde-neon-extension KDE neon extension] adds some commonly used features to the KDE snaps including using the [https://snapcraft.io/kf5-5-113-qt-5-15-11-core22 content Snap].
 
The <code>common-id</code> comes from the Appstream file.  You ''must'' check what it is in the appstream file. <code>org.kde.blinken.appdata.xml</code> contains <code><id>org.kde.blinken.desktop</id></code> so we use that.  Sometimes apps use the .desktop and sometimes they don't, this is at random.
 
The command to run is listed.  The KDE neon extension will run a script first which sets many necessary environment variables.
 
The plugs give access to the outside system, see [https://snapcraft.io/docs/supported-interfaces Supported interfaces] for descriptions.  When a Snap is installed from the Store it is up to the Store to say which plugs get used.  Those listed as auto connect in the docs are permitted.  Otherwise you must ask on the Snap forum for permission to have the Snap connected.  (Locally installed snaps with --devmode have access to everything, you can also manually connect snaps to interfaces on your local system.)
 
<code>slots</code> are the complement to plugs, they allow the outside system to access our Snap app.  In this case we are allowing a dbus interface into the Snap.  All KDE apps have a dbus interface and you can check what it is called by running the app and using <code>qdbus</code>.
 
<code>package-repositories</code> add the KDE neon apt repo to build against, this will give you the latest libraries to compile with.
 
The source of a Snap is the <code>parts</code> and some snaps have several parts made of different sources e.g. [https://invent.kde.org/network/ktorrent/-/blob/release/23.08/snapcraft.yaml?ref_type=heads KTorrent] has both libktorrent and ktorrent parts. Blinken is not complex so it has only one part made of the compiles Blinken source.
 
To get started with contributing to KDE snaps. Please fork the upstream repo aka https://invent.kde.org/network/ktorrent
Currently we only have packaging for Kf5 applications, so one needs to checkout release/23.08.
Hack snapcraft.yaml. Commit. Push. Create MR
 
=== Parts ===
 
* plugin ← which [https://snapcraft.io/docs/supported-plugins Snap build plugin] to use
* build-packages ← most build packages are in the KDE Frameworks content snap but some need added explicitly and some are not in there.  They will be downloaded from the neon and ubuntu apt repos.  [https://invent.kde.org/packaging/snapcraft-kde-applications/-/blob/Neon/release/ktorrent/snapcraft.yaml] uses non-KDE libraries and it needs to list the -dev packages in the <code>build-packages</code> then the library itself in the <code>stage-packages</code>.
* source ← link to the tar
* cmake-parameters ← copy and paste this, it sets the right paths.
* parse-info ← where the appstream file is to be installed
* filesets and prime ← snap parts get build then copied into a <code>stage</code> area, when all the parts are built they are copied into the <code>prime</code> area which is converted into the Snap package.  This lists a common set of excluded files we do not want copied.  You can add more here if you end up with unnecessary files in your snap.
 
== Building ==
Install snapcraft with <code>snap install snapcraft --classic</code>.
 
In the directory with the <code>snapcraft.yaml</code> run: <code>snapcraft</code>
 
This will start a virtual machine and build the package. If all is well you will have <code>blinken_20.12.3_amd64.snap</code> or similar created. If you had not installed lxd before, you may need to add your user to the lxd group to allow access to lxd.
 
Install with <code>snap install blinken_20.12.3_amd64.snap --devmode</code>.
 
Run with <code>blinken</code> or check if blinken is available in the app menu and run it from there (remove any versions of blink you have installed from your normal distro packages just to be sure). <code>which -a blinken</code> should say that blinken is available at least as <code>/snap/bin/blinken</code>.
 
== Quirks ==
 
=== Qt Only ===
 
You may want to simplify your Snap by using Qt directly instead of the KDE neon extension and KDE Frameworks content Snap.  Good luck :)
 
=== Patches ===


When binaries inside snaps get executed they only get a super minimal environment set up by snapd. The snap itself needs to take care of most of the higher level spin up of the environment.
If you need to update some code in the release you can patch it in the Snap package.  But please get the patch upstream into the Git archive first.


Inside a confined snap the <code>/</code> will be the core snap, while the actual snap will be in <code>SNAP=/snap/name/rev/...</code>. As a result for example icons, which usually would be expected in <code>$XDG_DATA_DIRS/icons</code> meaning <code>/usr/share/icons</code>, will need to be actually be looked for in <code>$SNAP/usr/share/icons</code>. The same applies to pretty much all XDG_* variables, LD_LIBRARY_PATH, various QT_* variables and so on and so forth.
[https://invent.kde.org/neon/neon-packaging/falkon/-/blob/70fb51728cc9c9f6da4d417bca96e2c34c96c52c/snapcraft.yaml#L45 Falkon does this].


Simply put: a snap's tree is not "merged" with the core's tree, rather it is "mounted" inside the core tree under $SNAP and so each snap needs to set up an environment which redirects or adds $SNAP to all lookup locations you can possibly imagine. As general assumptions about where things are on a Linux system no longer hold true. One the one hand that technically allows you to create a snap which entirely does away with the [https://en.wikipedia.org/wiki/Filesystem_Hierarchy_Standard FHS], on the other it means someone needs to actually mangle the environment so files may be located properly.
== Help ==


That's why most, if not all, desktop application snaps will need a launch helper. The launcher will set up all the general purpose path variables so they point to $SNAP. A standard desktop launcher implementation is available here https://github.com/ubuntu/snapcraft-desktop-helpers. Obviously you can also write your own, but since there are lots of things to consider, even for simple applications, it's probably not a good idea to do so.
[https://snapcraft.io/docs Snapcraft docs] including tutorials on using and building.


You can have a look at the standard environment by running
[https://snapcraft.io/docs/snap-format snapcraft.yaml format].


{{Input|1=<nowiki>
[https://forum.snapcraft.io/ Snap forum] for asking for help or asking to get the store to allow your Snaps to auto connect.
snap install hello-world
snap run --shell hello-world
env
</nowiki>}}


This will drop you on a minimal shell inside the confined snap, where you can have a look around to see what the snap sees.
[https://webchat.kde.org/#/room/#kde-neon:kde.org KDE neon devs] talk to Riddell or Sitter for help getting your app into KDE neons builds and into the Store.


== Glossary ==
== Glossary ==
Line 178: Line 286:
Words you'll hear and not know what they mean:
Words you'll hear and not know what they mean:


* '''snap''': The actual bundle format.
* '''snap''': The actual package format.
* '''snapd''': The daemon that manages snap on a system.
* '''snapd''': The daemon that manages snap on a system.
* '''snapcraft''': The build tool for building a snap.
* '''snapcraft''': The build tool for building a snap.
* '''app'': In the context of snapcraft/snapd this is the (portable) description of an 'exectuable' exposed to the outside (i.e. something snapd knows how to run).
* '''app'': In the context of snapcraft/snapd this is the (portable) description of an 'executable' exposed to the outside (i.e. something snapd knows how to run).
* '''parts''': In the context of snapcraft a part refers to one build entity. They describe where to get the source of the entity, how to build it, how to stage it into the final snap and which other parts are a dependency and need to be built first. A part is much like a "makefile" target.
* '''parts''': In the context of snapcraft a part refers to one build entity. They describe where to get the source of the entity, how to build it, how to stage it into the final snap and which other parts are a dependency and need to be built first. A part is much like a "makefile" target.
* ''interfaces'': A way for a snap to talk to the outside world (or another snaps). Split into slots and plugs.  Each of which has their own security permissions as a client may need to be able to do different things from a server. https://docs.snapcraft.io/interface-management
* '''interfaces''': A way for a snap to talk to the outside world (or another snaps). Split into slots and plugs.  Each of which has their own security permissions as a client may need to be able to do different things from a server. https://docs.snapcraft.io/interface-management
* ''slot'':  The provider part of an interface. e.g. a kwin snap might have a wayland-client slot which exposes a way for clients to talk to kwin.
* '''slot''':  The provider part of an interface. e.g. a kwin snap might have a wayland-client slot which exposes a way for clients to talk to kwin.
* ''plug'': The client part of an interface. e.g. an application may plug into the wayland-client slot of kwin to talk to it.
* '''plug''': The client part of an interface. e.g. an application may plug into the wayland-client slot of kwin to talk to it.
* ''Core'': A special snap containing the core aspects of any Linux OS (libc/libpthread/...). All snaps depend on exactly one core which provides the snap's understanding of what will be in "/" from the snap's POV. The core does not include a kernel! Kernels may be snaps.
* '''Core''': A special snap containing the core aspects of any Linux OS (libc/libpthread/...). All snaps depend on exactly one core which provides the snap's understanding of what will be in "/" from the snap's POV. The core does not include a kernel! Kernels may be snaps.
* ''Content Snap'': Special kind of snap that implements the "content"  interface. It's kind of like a shared dependency between snaps allowing one snap to be bound into the scope of another snap. For example the KF5 content snap may be used to share all of KF5 across multiple snaps.
* '''Content Snap''': Special kind of snap that implements the "content"  interface. It's kind of like a shared dependency between snaps allowing one snap to be bound into the scope of another snap. For example the KF5 content snap may be used to share all of KF5 across multiple snaps.
* ''Build Snap'': Also a special kind of snap, it's the build-time variant of the Content Snap and contains header files etc. necessary to build against a Content Snap.
* '''Build Snap''': Also a special kind of snap, it's the build-time variant of the Content Snap and contains header files etc. necessary to build against a Content Snap.
* '''stage''', '''staging''':  As part of snapcrafting parts get "staged". This kind of means the same as make install, but it's actually a separate step after make install. For the process of staging, snapcraft will copy all files created by make install into a stage directory. You may also exclude certain files or reorganize the files (e.g. rename, or move to different directory). The stage is available for parts ordered after the current one, meaning that they for example can link against a newly built library.
* '''prime''', '''priming''': Is similar to staging but happens once all parts are built and staged. Priming is the process by which the snap tree is actually constructed. Priming, like staging, allows for excluding files (e.g. dev headers may be staged so other parts can build using them but later excluded from priming and thus left out of the final bundle).

Latest revision as of 16:42, 25 March 2024

 
Under Construction
This is a new page, currently under construction!


Put Your App in the Snap Store

Snap Store KDE Page

It is a KDE goal to be All About the Apps to deliver our apps directly to our users. Snaps is one of the ways of doing this. Snaps are Linux app packages that can run on pretty much any Linux operating system. There is a single centralized Snap store ( https://snapcraft.io/store ) that delivers them to users. Take a look at the KDE page on the Snap Store to see what's available.

Snap intro

A Snap package typically contains all the files, including libraries and data files, to run the app. There are also Content Snaps which contain reusable libraries. KDE has the KDE Frameworks Content Snap https://snapcraft.io/search?q=kf6 and https://snapcraft.io/search?q=kf5 which includes recent Qt and KDE Frameworks and this is shared between all KDE apps so we do not have to waste disk space and build resources. With KDE / Plasma 6 the content pack has been split https://snapcraft.io/kde-qt6-core22-sdk for Qt6 and https://snapcraft.io/kf6-core22-sdk for KDE Frameworks 6.

Give it a try by installing a package or two on your system. E.g. the KDE desktop calculator app https://snapcraft.io/kcalc

snap install kcalc

And run kcalc from your apps menu.

This will have downloaded the kcalc Snap package from the Snap store into e.g. /var/lib/snapd/snaps/kcalc_73.snap and mounted it into e.g. /snap/kcalc/current/. You can also just download it to a local directory with snap download kcalc, use lesspipe kcalc*snap to see what is inside it.

snap list will show your currently installed snaps and it will now show that you have kcalc and the content snap kf5-5-111-qt-5-15-11-core22 as well as the core22 content snap installed.

Snaps are containers, similar to Docker. From inside the Snap container access to the file system and system resources are limited. This is good for inter-app security but means the app sees your system quite differently from how you might expect. You can "log" into the container with snap run --shell kcalc to have a look at how the snapped kcalc app sees your system.

To give the app controlled permissions to the system it plugs connections into resources such as the network or container snaps. Run snap connections kcalc to see what it gets given access to. The auto connections are controlled by the snap store and app maintainers need to ask the snap store for the desired auto-connections. Connections can also be overridden locally.

You can take a look at the snap package with snap download kcalc which will download files such as kcalc_73.assert and kcalc_73.snap. The .assert has the checksums and signatures for the package. The .snap has the (non-store) metadata and all the files of the package. lesspipe kcalc_73.snap to take a look.

Concepts

Snaps are usually one app per Snap package. The Snap package contains all the libraries and resources it needs to run except those in the shared content kf5-5-111-qt-5-15-11-core22 Snap.

In practice this means all of Qt and KF(5/6) including Breeze icons and themes are in the kde-frameworks content Snap and your app Snap only needs to compile its own sources. If you apps needs more libraries you can either install these as DEB packages e.g. from the Linux operating system Ubuntu LTS or KDE neon, or you can compile them from source as well. You will need to manually list the build-packages (all the -dev packages) and the stage-packages used in the final package, it'll warn you if any final libraries it expects are missing.

snapcraft is used to build snaps. It can be installed as a snap with snap install snapcraft --classic. A snap package (app) is defined in the snapcraft.yaml file. Snapcraft will build the package inside a virtual machine; it uses LXD to build the KDE snap packages. Using a virtual machine makes it reliable to build the Snaps on different Linux operating systems with identical results.

snapcraft.yaml files are kept in their respective upstream repo. Eg. kcalc snapcraft file resides https://invent.kde.org/utilities/kcalc/-/blob/release/23.08/snapcraft.yaml?ref_type=heads

Our Snaps read metadata from AppStream metadata files so it is important the metadata is up to date including current release versions.

The Snap Store is the centralized app store by Canonical. There is no practical way to use other stores or repositories with Snaps. It is what Snapcraft uploads built snaps to and what your local snapd will download and install snaps from. It also says what permissions those snaps should have. As an app developer if you want your app to have extra permissions (for example kdf uses mount-observe) then you need to ask for it on the snapcraft forum.

A Classic containment Snap has no restrictions on what files it can see on your system or what external executable can be run. This is useful for Integrated Development Environments (IDEs) and similar apps such as Kate which runs external programs. Again this needs to be set in your [1] then you need to ask on the Snap forum for the store to set it to classic. The Store will then tell snapd for anyone installing the Snap to have it installed as a Classic confinement Snap.

The KDE account on the Snap store is run by the Snap team developers Jonathan Esk-Riddell, Harald Sitter, Scarlett Moore, Carlos DeMaine, Kevin Ottens, Benjamin Port. One Snap on the store can be shared between more than one account so app maintainers can also create a separate account if they want to have more control over when their app is released and what the store says about it.

The store has four channels for different levels of stability. Our stable branch builds get uploaded to the Candidate channel and can be moved to the Stable channel once tested.

Example

Blinken is an exciting memory game from KDE. It's available on the Snap store. The Snap package is defined by a snapcraft.yaml file which is in the https://invent.kde.org/education/blinken/-/tree/release/23.08?ref_type=heads repo. Any update to that branch triggers a build of the [2] in launchpad. If the build is successful it will be uploaded to the Candidate channel of the Snap store ready for review.

The snapcraft.yaml file looks like this:

---
name: blinken
adopt-info: blinken
confinement: strict
grade: stable
base: core22
apps:
    blinken:
        common-id: org.kde.blinken.desktop
        command: usr/bin/blinken
        plugs:
        - desktop
        - desktop-legacy
        - opengl
        - wayland
        - x11
        - audio-playback
        - unity7
        command-chain:
        - snap/command-chain/desktop-launch
assumes:
- snapd2.55.3
compression: lzo
plugs:
    desktop:
        mount-host-font-cache: false
    icon-themes:
        interface: content
        target: $SNAP/data-dir/icons
        default-provider: gtk-common-themes
    sound-themes:
        interface: content
        target: $SNAP/data-dir/sounds
        default-provider: gtk-common-themes
    kf5-5-111-qt-5-15-11-core22:
        content: kf5-5-111-qt-5-15-11-core22-all
        interface: content
        default-provider: kf5-5-111-qt-5-15-11-core22
        target: $SNAP/kf5
environment:
    SNAP_DESKTOP_RUNTIME: $SNAP/kf5
hooks:
    configure:
        plugs:
        - desktop
        command-chain:
        - snap/command-chain/hooks-configure-desktop
layout:
    /usr/share/X11:
        symlink: $SNAP/kf5/usr/share/X11
slots:
    session-dbus-interface:
        interface: dbus
        name: org.kde.blinken
        bus: session
package-repositories:
-   type: apt
    components:
    - main
    suites:
    - jammy
    key-id: 444DABCF3667D0283F894EDDE6D4736255751E5D
    url: http://origin.archive.neon.kde.org/user
    key-server: keyserver.ubuntu.com
parts:
    kde-neon:
        source: /snap/snapcraft/current/share/snapcraft/extensions/desktop/kde-neon
        source-type: local
        plugin: make
        make-parameters:
        - PLATFORM_PLUG=kf5-5-111-qt-5-15-11-core22
        build-snaps:
        - kf5-5-111-qt-5-15-11-core22-sdk
        build-environment:
        - &id001
            PATH: /snap/kf5-5-111-qt-5-15-11-core22-sdk/current/usr/bin${PATH:+:$PATH}
        - &id002
            XDG_DATA_DIRS: $CRAFT_STAGE/usr/share:/snap/kf5-5-111-qt-5-15-11-core22-sdk/current/usr/share:/usr/share${XDG_DATA_DIRS:+:$XDG_DATA_DIRS}
        - &id003
            XDG_CONFIG_HOME: $CRAFT_STAGE/etc/xdg:/snap/kf5-5-111-qt-5-15-11-core22-sdk/current/etc/xdg:/etc/xdg${XDG_CONFIG_HOME:+:$XDG_CONFIG_HOME}
        - &id004
            CRAFT_CMAKE_ARGS: -DCMAKE_FIND_ROOT_PATH=/snap/kf5-5-111-qt-5-15-11-core22-sdk/current${CRAFT_CMAKE_ARGS:+:$CRAFT_CMAKE_ARGS}
    blinken:
        after:
        - kde-neon
        parse-info:
        - usr/share/metainfo/org.kde.blinken.appdata.xml
        source: .
        source-type: local
        plugin: cmake
        build-packages:
        - cmake
        - libkf5doctools-dev
        - libphonon4qt5-dev
        - libphonon4qt5experimental-dev
        stage-snaps:
        - khelpcenter
        cmake-parameters:
        - -DKDE_INSTALL_USE_QT_SYS_PATHS=FALSE
        - -DCMAKE_INSTALL_PREFIX=/usr
        - -DCMAKE_BUILD_TYPE=Release
        - -DENABLE_TESTING=OFF
        - -DBUILD_TESTING=OFF
        - -DKDE_SKIP_TEST_SETTINGS=ON
        - "-DCMAKE_FIND_ROOT_PATH=/usr\\;$CRAFT_STAGE\\;/snap/kf5-5-111-qt-5-15-11-core22-sdk/current"
        - "-DKDE_INSTALL_PLUGINDIR=/usr/lib/$CRAFT_ARCH_TRIPLET/qt5/plugins/"
        prime:
        - "-usr/lib/*/cmake/*"
        - "-usr/include/*"
        - "-usr/share/ECM/*"
        - "-usr/share/man/*"
        - "-usr/share/icons/breeze-dark*"
        - "-usr/bin/X11"
        - "-usr/lib/gcc/$CRAFT_ARCH_TRIPLET/6.0.0"
        - "-usr/lib/aspell/*"
        - "-usr/share/lintian"
        build-environment: &id005
        - *id001
        - *id002
        - *id003
        - *id004
    cleanup:
        after:
        - kde-neon
        - blinken
        plugin: nil
        override-prime:  |
            set -eux
            # # Unused libraries found by linter

Check Snapcraft YAML reference if unsure.

Top Level

  • name: blinken ← the snap name registered on the snap store
  • confinement: strict ← Snaps are a containerised format and can't see the outside system from inside their container. Strict is the normal container method. Classic is also possible which allows it to see the outside system and is used by e.g. Kate because Kate needs to run external programs like Git. It can only be Classic on request. Can also be devmode for testing.
  • grade: stable ← It must be stable to be in a released channel, can also be devel.
  • base: core22 ← which base system to build on, core22 means Ubuntu 22.04 and is the current recommended.
  • adopt-info: blinken ← Which Snap part to get the appstream info from. This sets version, icon, description.

You might also need to add version if it is not in the appstream file. This is just a version read by users it does not affect the revision number which is tracked by the store.

apps

apps:
    blinken:
        extensions:
        - kde-neon
        common-id: org.kde.blinken.desktop
        command: usr/bin/blinken
        plugs:
        - desktop
        - desktop-legacy
        - opengl
        - wayland
        - x11
        - audio-playback
        - unity7
        command-chain:
        - snap/command-chain/desktop-launch

apps are the programs which the snap includes for users to run. Usually there is only one in a Snap but sometimes e.g. Calligra there are more than one.

The KDE neon extension adds some commonly used features to the KDE snaps including using the content Snap.

The common-id comes from the Appstream file. You must check what it is in the appstream file. org.kde.blinken.appdata.xml contains <id>org.kde.blinken.desktop</id> so we use that. Sometimes apps use the .desktop and sometimes they don't, this is at random.

The command to run is listed. The KDE neon extension will run a script first which sets many necessary environment variables.

The plugs give access to the outside system, see Supported interfaces for descriptions. When a Snap is installed from the Store it is up to the Store to say which plugs get used. Those listed as auto connect in the docs are permitted. Otherwise you must ask on the Snap forum for permission to have the Snap connected. (Locally installed snaps with --devmode have access to everything, you can also manually connect snaps to interfaces on your local system.)

slots are the complement to plugs, they allow the outside system to access our Snap app. In this case we are allowing a dbus interface into the Snap. All KDE apps have a dbus interface and you can check what it is called by running the app and using qdbus.

package-repositories add the KDE neon apt repo to build against, this will give you the latest libraries to compile with.

The source of a Snap is the parts and some snaps have several parts made of different sources e.g. KTorrent has both libktorrent and ktorrent parts. Blinken is not complex so it has only one part made of the compiles Blinken source.

To get started with contributing to KDE snaps. Please fork the upstream repo aka https://invent.kde.org/network/ktorrent Currently we only have packaging for Kf5 applications, so one needs to checkout release/23.08. Hack snapcraft.yaml. Commit. Push. Create MR

Parts

  • plugin ← which Snap build plugin to use
  • build-packages ← most build packages are in the KDE Frameworks content snap but some need added explicitly and some are not in there. They will be downloaded from the neon and ubuntu apt repos. [3] uses non-KDE libraries and it needs to list the -dev packages in the build-packages then the library itself in the stage-packages.
  • source ← link to the tar
  • cmake-parameters ← copy and paste this, it sets the right paths.
  • parse-info ← where the appstream file is to be installed
  • filesets and prime ← snap parts get build then copied into a stage area, when all the parts are built they are copied into the prime area which is converted into the Snap package. This lists a common set of excluded files we do not want copied. You can add more here if you end up with unnecessary files in your snap.

Building

Install snapcraft with snap install snapcraft --classic.

In the directory with the snapcraft.yaml run: snapcraft

This will start a virtual machine and build the package. If all is well you will have blinken_20.12.3_amd64.snap or similar created. If you had not installed lxd before, you may need to add your user to the lxd group to allow access to lxd.

Install with snap install blinken_20.12.3_amd64.snap --devmode.

Run with blinken or check if blinken is available in the app menu and run it from there (remove any versions of blink you have installed from your normal distro packages just to be sure). which -a blinken should say that blinken is available at least as /snap/bin/blinken.

Quirks

Qt Only

You may want to simplify your Snap by using Qt directly instead of the KDE neon extension and KDE Frameworks content Snap. Good luck :)

Patches

If you need to update some code in the release you can patch it in the Snap package. But please get the patch upstream into the Git archive first.

Falkon does this.

Help

Snapcraft docs including tutorials on using and building.

snapcraft.yaml format.

Snap forum for asking for help or asking to get the store to allow your Snaps to auto connect.

KDE neon devs talk to Riddell or Sitter for help getting your app into KDE neons builds and into the Store.

Glossary

Words you'll hear and not know what they mean:

  • snap: The actual package format.
  • snapd: The daemon that manages snap on a system.
  • snapcraft: The build tool for building a snap.
  • 'app: In the context of snapcraft/snapd this is the (portable) description of an 'executable' exposed to the outside (i.e. something snapd knows how to run).
  • parts: In the context of snapcraft a part refers to one build entity. They describe where to get the source of the entity, how to build it, how to stage it into the final snap and which other parts are a dependency and need to be built first. A part is much like a "makefile" target.
  • interfaces: A way for a snap to talk to the outside world (or another snaps). Split into slots and plugs. Each of which has their own security permissions as a client may need to be able to do different things from a server. https://docs.snapcraft.io/interface-management
  • slot: The provider part of an interface. e.g. a kwin snap might have a wayland-client slot which exposes a way for clients to talk to kwin.
  • plug: The client part of an interface. e.g. an application may plug into the wayland-client slot of kwin to talk to it.
  • Core: A special snap containing the core aspects of any Linux OS (libc/libpthread/...). All snaps depend on exactly one core which provides the snap's understanding of what will be in "/" from the snap's POV. The core does not include a kernel! Kernels may be snaps.
  • Content Snap: Special kind of snap that implements the "content" interface. It's kind of like a shared dependency between snaps allowing one snap to be bound into the scope of another snap. For example the KF5 content snap may be used to share all of KF5 across multiple snaps.
  • Build Snap: Also a special kind of snap, it's the build-time variant of the Content Snap and contains header files etc. necessary to build against a Content Snap.
  • stage, staging: As part of snapcrafting parts get "staged". This kind of means the same as make install, but it's actually a separate step after make install. For the process of staging, snapcraft will copy all files created by make install into a stage directory. You may also exclude certain files or reorganize the files (e.g. rename, or move to different directory). The stage is available for parts ordered after the current one, meaning that they for example can link against a newly built library.
  • prime, priming: Is similar to staging but happens once all parts are built and staged. Priming is the process by which the snap tree is actually constructed. Priming, like staging, allows for excluding files (e.g. dev headers may be staged so other parts can build using them but later excluded from priming and thus left out of the final bundle).