50 KiB

Raw Blame History

+++ title = "BaguetteOS, tools and stuff"

paginate_by = 5 +++

Overview
Technical choices
Custom tools
Slotting
Roadmap

1. Concise overview

BaguetteOS status: Work In Progress.

A beta will be available circa mid-2020 for advanced users. End of the year for simple users.

Warning: this documentation is currently mostly oriented towards advanced unix users. We provide insights on system administration, expose our ideas and point of view. Documentation for simple users will be split in another page, soon.

Objectives, for simple users

BaguetteOS aims at providing a simple unix-like system, with an unified web interface.

No command-line required for simple users. let users be just users
Simplicity should not only come from an interface, but be inherent to the whole system. If the OS is simple, there is no need to hack it.

Unified interface is better than features.
Our web interface will directly provide the basic features such as mail, instant messaging, etc. The list of features covered by our interface will grow-up continuously. We do not want a patchwork of very different software, each of them having its own particularities.

Online services. day-to-day use
The web interface should cover online services, providing an unified experience for main usages: mails, calendar, instant messaging, personal website, file sharing, etc.

One-click management. service installs, updates, etc.
The web interface should handle basic system and network configurations, such as adding users, dhcp, DNS, backups, etc.

Well-known, reliable software. for real
BaguetteOS relies on robust and independent software. At no point the user should be forced to reinstall, a misconfiguration has to be easily fixable. We use static compilation for (at least) system tools: there is almost no chance an update break the system (yes, almost, people are creative these days).

Hardware support. new or old, fast or slow, it doesn't matter
We provide support for RPi and other small cards: if our kernel runs on it, it has to work. Minimal hardware requirement should be around 100 MB RAM, 50 MB disk.

Documentation. simple, reliable, useful, all-in-one-place
Similar to the OpenBSD FAQ: updated, complete, concise and well-written.

Constrained devices use case. wanna see what small systems can do?
By default, we try to provide the smallest memory footprint: we do not provide manuals nor runtime libraries when not required. Our programs will never require you to download development libraries, nor alternative package managers. We choose all of our tools with size in mind. As a result, our system can be installed quickly even on slow machines.

Objectives, for advanced users

A knowable OS. simplicity at (almost) all cost
Any interested user should be able to understand the role of every part of the base system: no compromise. This means having a very small and consistent set of tools, easy to learn, easy to remember.

Basic system and network management. with the simplest tools ever
We provide a web interface that should handle basic system and network configurations, such as adding users, firewall management, dhcp, DNS, backups, etc. CLI tools are available to manage services, they are designed to be simple, consistent and reliable.

Officially supported services. so you are sure to get them working
We use some services for our own personal usage, so we will provide support for them. For instance: gitea, postgresql, etc.

One need, one tool. this time for real
Installing an application or a library is done by package. Other methods are not supported and the base system will never require them. We avoid to rely on pip, cpanm, or other third party package manager and dependency tree.

Starting, stopping, or configuring a service is done by service. This program alone is used to manage services on the OS. Users should not be required to manually configure each software; instead, most of the configuration should be done upstream using templates. Users should be able to change the default configuration through command-line options. Manual configuration is the last option.

Slotting. any software can be installed on any machine at any time, no extra tooling
Slotting by default helps to install many programs, even with peculiar library version requirements. The same program can be installed in several versions without conflicts.

See more in the technical section.

Objectives, for contributors

Simple to contribute to. you can focus on providing recipes for packages, we handle the tooling
Packaging applications and libraries should be possible with the fewest and simplest tooling possible. BaguetteOS provides a simple tool to package applications (packaging) which allows simple recipes for your packages. packaging handles slotting, compiling, stripping binaries and libraries, splitting the result into different packages (-man, -lib, -doc, etc.), authenticating, etc. All that, just by typing

$ packaging app

nothing more.

No Makefile? no problem
Your application or your library lacks a build system? Here is a tool to create makefiles. It works on any language. yes, even that one

Stable and development versions: same thing. slotting, again and again
One of the coolest aspect of slotting is: you don't need to change your system at all to be on the development version of the OS. The newest version is just slotted in /usr/baguette-dev and that's it. Switching OS version is just a few environment variables away.

New OS, open to explore we are open to new ideas
BaguetteOS does not suffer from cumbersome historical decisions: no overly engineered package format, no stupidly complex patchwork of mismatch tools.

Easy-to-write documentation. and hopefully less procrastination
Online documentation and man pages are written in Markdown (thanks to zola and scdoc). Every tool has a man page: no man page = no integration in base.

Inspiration

CRUX, alpine: simple-to-understand Linux systems
OpenBSD: security-oriented system, therefore simple
PFsense: advanced networking administration through a simple website
Plan9 and Inferno: OS with an everything is a file philosophy no seriously guys
suckless and cat-v: documentation and tools, all about simplicity, code readability and re-usability
morpheus: OS based on statically compiled tools

Why not use another system?

This section could be expanded.

A few reasons why none of the candidates cover it all.

we want slotting
So we could change the way we install and maintain packages.
we want fast install and startup on dumb devices
Coreutils shrank to bare minimum, thanks to toybox. We won't require a full-feature system with several hundred megabytes of disk-space used.
documentation is important, but not for all installations
Your 42nd test install on a virtual machine doesn't need a manual for CLI tools you won't use since you do everything through the web interface. Software and its documentation will be split: manual pages won't be provided by default.
we want automatic tests, and to enable people to test our system
We want easy chroot installs, on any system.
we want to run on tiny ARM boxes, old laptops, top-notch servers
So we need to run on any available kernel.
we want to control software distribution releases
We don't accept to follow updates from an upstream OS that could break our system at any time.

Now, let's take a look at each candidate.

OpenBSD. we will get there quick, but will focus on Linux a bit before
We definitively want to use OpenBSD, currently we just focus on Linux for hardware compatibility reasons (and out of habits) but it's not set in stone. We love OpenBSD big time, some of us use it daily. We aim at providing rootfs for running our system under an OpenBSD kernel and environment.
(also, snapshots could be great, guys)

PFsense. network focused
Great system, does the job very well, but won't fit our objectives as it is way too focused on networking.

CRUX and Alpine. great source of inspiration
We do use the CRUX's rc script, and as Alpine it is a source of inspiration for package recipes. However, since we have to change all packages to get slotting, the service manager to have tokenized services, the packaging software to get declarative recipes (...), why even bother use those systems?

GUIX (and Nix). not simple enough
GUIX approach of package management is interesting, having to learn a language to make recipes isn't. And that sums up this technology pretty well. It's great, but not to put everywhere. Every part of BaguetteOS is simple to understand, GUIX is not simple enough. But keep it up guys, it's still awesome.

Plan9, Inferno, morpheus, etc. kinda abandoned systems
That's it.

2. Technical choices

Base system

Linux kernel, but we are lurking on the OpenBSD one.
Linux is compatible with most hardware and software, it is fast and we can easily compile a custom version to remove most of the bloat for server usage. Still, we don't want to rely on Linux-specific components. At some point, our system will be kernel-agnostic and will be able to run on any BSD as well. OpenBSD has pledge and unveil syscalls, which is an elegant way to provide a guarantee on the software behavior.

Musl. reasonable libc for Linux
It has a reasonable amount of features, it is efficient, provides reasonable binary sizes and static compilation. Musl is simple, reliable and remove all glibc-specific functions. Others can be added easily, which is useful for compatibility and comparisons, through slotting.

Bootable system and rootfs available.
A bootable system to install in virtual machines or bare metal, a rootfs to use BaguetteOS from any other OS, including non-Linux ones.

SysV-style init + CRUX-like /etc/{rc,mdev.conf,...}. easy to read, easy to adapt
The init could come from toybox or another minimalist project. The rc script from CRUX is simple to understand and to adapt to any requirements, so we use it. We also provide some other scripts, like for profile so we can easily manage slotting. No systemd BS.

Toybox. the megabyte coreutils
Toybox combines common unix command line utilities together into a single BSD-licensed executable. It is designed to be simple even to read, and is standards-compliant. For the base system, that's all we need.

ksh and zsh. the first for scripts and root, the other for users
Ksh is a very stable and reliable shell from AT&T, trusted by the paranoid people of OpenBSD. That's a safe choice for a base system and the root account. On the other hand, we do use zsh daily, as for many users, so we may use it for development or build scripts but not in the base system.

Service for service management tokenized service description, templating and dumb cli tools for the win
See custom tools.

Package for package management simple-to-use, efficient, dead simple code
See custom tools.

OpenSSH. as we all know and love
This is required for almost all usages, and for debug. Let's try not to shoot ourselves in the foot.

That's all you need for starters. Web administrative interface will be added to the base when ready.

Development, build tools

Default building tools every tool needed to bootstrap
Clang (+ LLVM) is the default C (and C++) compiler. Libarchive is required for tarballs, packages, webhooks from packaging, and both bsdcpio and bsdtar (sane implementations of cpio and tar). Auto-tools are also required (for SysV init and libarchive). m4 and gnu-make are required for compatibility reasons.

Documentation.
A full hand-book like the OpenBSD FAQ. Our software man-pages are written with scdoc so anyone can contribute.

Packaging for packaging software and libraries. dead simple, intuitive
See custom tools.

Slotting. custom file system hierarchy
Our FS is not FHS-compliant, partially because of the origin-based slotting. There is a strict separation between core system and third party software.
See slotting.

/usr/baguette for core system programs
/usr/bad for non slot-able software
/usr/third-party for other software

Languages

We are reluctant to add new languages to the base system. We will limit the number of languages required for a system bootstrap. For now, bootstrapping requires: C, perl, m4, python (for stupid reasons) and crystal (used for our software).

However, we think that we can overcome C limitations, explore new possibilities. Now, more than ever, we have better alternatives for all non kernel-related tooling. That being said: we do not want dynamic languages. We need:

simple, small and efficient binaries
less possible dependencies (not to download half cpan or pypi for any freaking software)

Crystal language for system tools. syntax and productivity of Ruby, the speed of C
It is as simple to learn as a dynamic (oriented object) language, while at the same time being almost as fast as C. Technically, Crystal is strongly typed so it catches errors at compilation-time, but with type inference so it is not cumbersome to use. Applications are compiled in a simple binary, easy to deploy. There is a good documentation, we have used it for long enough to tell. Technical choices are reasonable and documented. Finally, Crystal has a large library with all we need for our system components.

There is not much of a drawback here. Yes, this is a language you have to learn to work with us on a couple of projects, but you can learn it in about a few days to a week and it increases our productivity like crazy. We heard about nim and a ton of other languages, lots of them are great candidates, but choices needed to be made. This is the one reaching the sweet spot between these parameters:

productivity (the package manager was mostly done in a few days, and is just a few hundred lines long)
easy learning (a developer with basic notions of oriented-object can read our code, no black magic here)
good documentation
reasonably deployable (no host dependencies)
execution speed

We are also looking at Zig for low-level stuff. Wait & see.

naming convention

name = application name
version = application version
release = recipe version
$name-$version-r$release.pkg

Example:

firefox-79.0-r8.pkg

3. BaguetteOS: custom tools

Simple ideas, simple implementations.
Keep reminding to yourself while reading this section that our tools are implemented within just a few hundred lines of code (up to 1500 lines for service and libipc).
Also, they can easily run on other systems: nothing here is OS specific.

Feel free to provide a feedback.

Here is a few pointers:

spec format
package
packaging
service
build.zsh
… and a few other tools

Main BaguetteOS tools

Spec files: our declarative format

Before presenting our tools, here is a file format named spec that we use when relevant. It is declarative: we do not write instructions on how to do things (copy this file here, download this, etc.). Instead, we describe what something is: the URL of the project is https://example.com/xxx, for example. The spec format is only composed of variables, lists, code blocks and named sections. Here is a quick example.

# This is a comment

# This is a simple variable instanciation
my-variable: value

# This is an inlined list
my-list: a, b, c

# This is a multiline list
my-list:
  - a
  - b
  - c

Up to this point, this looks a lot like YAML, but now we add code blocks to it: because sometimes we do want to tell instructions.

# We have the URL of the tarballs for a software
software-url: 'https://example.com/my-software/'

# ... and we want to get its last version number
#  and its tarballs on the website look like this:
#    'https://example.com/my-software/2.6_my-software.tar.gz'
#    'https://example.com/my-software/2.7_my-software.tar.gz'
#    'https://example.com/my-software/2.8_my-software.tar.gz'
#    ...
# "@watch" is a block
# in the application reading the file, "watch" is a keyword meaning "command to run to check for new tarball versions"
@watch
	# the following is simple shell scripting
	curl %{software-url} -o- 2>/dev/null | \
	sed "s/_my-software.tar.gz//" | \
	tail -1

Sometimes, we want to refer to a file (or directory) and add metadata to it through named sections.

# as for "@watch", "%configuration" is a keyword for the application
# this time, the block has an arbitrary name
%configuration postgresql.conf
	# within a named section, variables are declared in the same way as outside the block
	name: database configuration
	creation-command: my-script.sh -a -b -c

Next, the usage in practice: packaging, service.

Package: our package manager

Package covers the basics: install, remove, search and provide information about a package. Package can create minimal rootfs, to bootstrap BaguetteOS on another system or to create test environments for example.

Package provides slotting by default: no need for custom environments for each software.

Package format is a simple tar archive containing a meta.spec file describing all meta-data about the package (hash, manifest, etc.) and files.tar.xz with the files to install. The database format contains:

world, the file containing the list of available packages
installed, the list of installed packages
[package-name]/[slot]/manifest, the manifest of the installed package
[package-name]/[slot]/meta.spec, the meta-data of the installed package

Package configuration consists of:

a list of repositories
authorized package signing keys
packaging variables (cflags, makeflags, and so on)

Finally, Package can easily be expanded, as it is only a few hundred lines of Crystal code.

Packaging: the way to create packages for BaguetteOS

Any OS needs a way to create packages to share software, either by sharing sources that need to be compiled or by sharing pre-compiled binaries. As BaguetteOS is designed to provide quickly usable systems, we choose to provide binaries. Packaging uses simple, declarative recipe files with the spec format as we saw earlier. Packaging has a few advantages compared to most used packaging tools:

declarative recipes abstract OS specifics
The same recipe may work for many native packaging systems (on many OSs), as long as packagers provide the right target running dependencies. This only requires to provide a back-end for the package format of the target package manager (a back-end to write .deb files, for instance).
packages are split automatically
We need to separate binaries, libraries and documentation in different packages, so we can only install what's needed. Slow and testing systems only require strict minimum.
binaries and libraries are stripped by default
By default, a running system does not require debug symbols in its binaries.
recipe readability is great
A few variable declarations are better than a dozen lines of code.
trivial shell script patterns become automated
Autotools and cmake build systems are auto-detected; packagers should only provide specific parameters for each project.
tooling may change, recipes won't
Everybody wants to change its build system? (Besides possibly broken tools and possible workarounds,) this is not a problem for the recipe, just for packaging.
packages are hashed and signed by default, no extra-tooling
You need your own set of cryptographic keys, which is created at first use.
repositories are created automatically at first compilation, helping people maintaining their own set of tools
Change the first prefix in your packaging configuration, compile your first package and you have your repository. It's that simple.

Packaging's build environments
Packaging uses package to create build environments and to test packages before validation. It works as follow:

a /tmp/packaging/build-UUID/ directory is created
sources are downloaded, extracted then compiled
Recipes and packaging host configuration may change parameters to the build: adding steps before compilation, changing configure arguments, changing the default slotting (/usr/baguette), etc.
compiled applications and libraries are put in /tmp/packaging/build-UUID/root which is used to create the final package

Build environments are low-cost since we hardlink binaries into the building rootfs, which is inspired by the proot tool on OpenBSD. Packaging only installs the minimal set of binaries required by the package to build. Besides the target application, a building environment size is only a few kilobytes.

Packaging configuration. common configuration for your packages
Packaging may be configured globally for your system with the file /etc/packaging.conf which contains the following:

# Configuration file for `packaging`

# where to send built packages
packages-directory: /usr/local/pkg/
# where to download sources
sources-directory:  /usr/local/src/

# the slot we want for our packages
slotting: /usr/baguette

# prefixes for `packaging` running environment and child processes
# = where to search for binaries and libraries for the build
prefixes:
	- /usr/baguette/
	- /

# list of environment variables we want to have when building
environment:
	# we may choose another compiler, provide some CFLAGS, etc.
	- CC: clang
	- CFLAGS: -Os -Wall

	# next three parameters have special meaning
	# to provide parameters to the `./configure` script when building
	- configure: --disable-nls --without-gettext

	# to provide parameters to the `make` command
	- make:

	# to provide parameters to the final `make install` command
	- make install:

# wanna build for another system? not a problem, just add the back-end (we currently have `apk` and `package`)
package-manager: package

That's it. You know all about packaging configuration. These parameters may be overridden by recipes.

Packaging recipes. we need to create packages
A recipe is the way to reproduce something; here, we want to create a package, the recipe should provide all data necessary to be able to reproduce the package. This means at least having a name for the software and a version (they appear in the package name) and sources (software code). Let's take an example.

# GNU Hello program
name: hello    # software name
version: 2.10  # software version
release: 2     # recipe release: incremented when the recipe change for the current version of the software

# the description will appear in the package information we can retrieve with `package`
description: "This is the GNU Hello program."

# sources may be multiple: you may want to add arbitrary files along the tarball
sources: https://ftp.gnu.org/gnu/hello/hello-%{version}.tar.gz

# we provide running dependencies: the program needs these to `run`
dependencies:
  - gettext

# we provide build dependencies: the program needs these to `be compiled` for the package
# no need to require these dependencies for a simple user installing the program
build-dependencies:
  - make

# if we want to add or override compilation options
options:
  - configure: --disable-nls

# feels like déjà vu, right?
# "watch" code block helps to check if the recipe covers the last software version
@watch
	curl 'https://ftp.gnu.org/gnu/hello/' -o- 2>/dev/null |
	sed -n "/hello-.*\.tar\.gz/{s/\.tar\.gz.*//;s/.*hello-//;p}" |
	tail -1

This was a real example, and not the simplest one. Most of our recipes currently look like this:

name: dhcpcd
version: 8.0.3
sources: https://roy.marples.name/downloads/dhcpcd/dhcpcd-%{version}.tar.xz

That's it. Yes, we can add a few meta-data, but this is a working recipe. Configuration, compilation and packaging are done without providing anything else. The only required parameters are name, sources and version.

Sometimes, developers are assholes and force you to fix their build system. When manual operations really are required, you can use @configure, @build and @install code blocks. Let's see an example with a special snowflake… like perl.

# in our example, we want to configure the build
@configure
	# we set some script execution parameters: exit at any error, print everything you do
	set -e -x

	# we currently are in `/tmp/packaging/build-UUID/`
	# now we enter the directory created by the tarball extraction, where the build occurs
	cd perl-%{version} # we can interpolate variables with this: %{}

	# Perl needs a few environment variables for configuration
	BUILD_ZLIB=0
	BUILD_BZIP2=0
	BZIP2_LIB=/usr/lib
	BZIP2_INCLUDE=/usr/include
	export BUILD_ZLIB BUILD_BZIP2 BZIP2_LIB BZIP2_INCLUDE

	# now we can launch the `configure` script…
	# … but wait kids, that's not `configure`, that is `Configure` (see the capitalized C?)
	# this is a totally different and very special script, but you should love it anyway
	./Configure -des -Dcccdlflags='-fPIC' \
		-Dcccdlflags='-fPIC' \
		-Dccdlflags='-rdynamic' \
		# ... some long and uninteresting list of very specific parameters because we are Perl, we are historic and stuff

Now you know how to deal with @configure, @build and @install: these are code blocks allowing you to fix this kind of problems. Non standard build operations happen from time to time, and code blocks help you overcome this. When a lot of packages have the same workarounds, we think about detection and integration into packaging, so we can keep only specifics into recipes.

If you want to investigate a bit more, you can check our recipe repository. Feel free to improve these recipes with meta-data, @watch code blocks… contributions are welcome.

Future of packaging. let's be even more declarative
As we saw, packaging allows maintainers to create very simple and readable recipes. Sometimes we have to confront ourselves to poorly designed build systems, but we can hack a bit. In the future, manual operations should be reduced even more:

by adding a few other parameters to the environment
This imply to check for patterns in the recipes and to provide workarounds.
by adding new code blocks before the configuration, build and install steps
This would allow performing a few hacks in the directory (a quick sed in a file for instance) and still keeping automatic operations: the best of the two worlds.

Another possible addition to packaging could be to take cross-OS recipes as first-class citizen. It was part of the design process of spec files: named sections can be used to discriminate information based on the target OS. An example:

%OS Ubuntu-20.04
	dependencies: libxxx
%OS Debian-12
	dependencies: lib-with-specific-naming-standard-for-reasons

This way, bootstrapping an application and providing it to any system with their own tools could be easy. It's actually what we did during the Baguette's bootstrap. Providing universal recipes could even become a game for patient system administrators.

Service: service management. not just `kill` or start/stop/status wrapper

Service management often comes with:

default configuration files, users should learn how to configure them and do it manually
default user and group, so two instances may have security-involved issues
a single possible instance, otherwise the configuration has to be heavily changed
root-only management, simple users rarely run their own services (except on systemd, kuddos for once)
no domain management

These shortcomings imply manual configuration, scripting to manage databases and users, specific tooling for each database and service: this is heavy machinery. To overcome drawbacks of having simplistic tools, sys-admins developed all kind of monstrous architectures.

LXC chroot + network + software limits
Qemu + KVM, Xen let's add software mimicking hardware's complexity to the mix, telling everyone it's for security and simplicity
docker I don't know how to do simple applications nor packages, so I ship my whole dev environment
Note: we have to admit, packaging on most OS is painful for absolute no good reason.
Chef and Puppet the 500 MB running Ruby's code on our virtual machines just to check for new configuration is okay, memory is cheap right?
We talk about the importance of security from time to time, but running a software designed by people telling it's okay not to free memory is far from being wise.
Ansible templating your applications… from another machine
As Chef and Puppet, ansible provides templating for applications, this time configuration propagation is way simpler since it uses well-known, trusted and loved ssh. Still, templating is done for remote machines, as it is intended for server deployments: this is a sys-admin tool. The introduction page already talks about cloud provisionning and intra-service orchestration on the first line, telling that you really need to setup SSH keys, etc. As for many tools in IT: this is not for simple users.

Simple users:

should be only required to provide absolute necessary information for their services
should be able to run as many services they want
shouldn't have to learn configuration syntax for their services
shouldn't be afraid of updates
... and should have BACKUPS! Where are they? We should have that by default on our systems over 20 years ago.

And advanced users should have an uncomplicated CLI tool to do that.

Let's take an example with service better than a thousand words

# We want a wordpress service, proxied by a nginx and using postgresql as DBMS

# 1. we add an nginx
$ service add nginx

# 2. we add the database
$ service add postgresql

# 3. we add the wordpress
#    by default, it uses available http proxy and database, but let's be "verbose"
$ service add wordpress domain=example.com http=nginx database=postgresql

# 4. we start the wordpress
$ service start wordpress

A bit of explanation:

first, we add nginx to the list of services we want on our system
same thing with postgresql
then we add wordpress and we pass parameters to the service configuration: domain, http and database
domain for the domain name, http for the HTTP proxy and then the database back-end. Up to this point, nothing even started.
Finally, we start the service.
Since service knows the dependence graph, it starts other services before wordpress (which actually doesn't have any binary to run per se). The configuration of a service is made when service starts it. In this case:
1. nginx is started as a proxy for example.com
2. postgresql is started, its internal directories and files are created, then an user, a database and a password for wordpress are created
3. a directory is created in /srv/root/wordpress/ and wordpress files are copied into it, then its configuration is generated
Stopping a service also stops its dependencies, if they aren't required elsewhere (or that we explicitely said to keep them running).

Here are a few functionalities service brings.

uncomplicated domain-wise service configuration
templates configuration files are generated by templates and user data
When we want a software, for instance a blog, we want to provide the minimum informations it requires to work and that's it. When service starts a service, it verifies if its configuration file is installed and up-to-date, or create it. Users shouldn't need to manually change the configuration. Syntax may change at any time without breaking a single service, since the configuration will smoothly be regenerated with useful information at start-up.
environments
Each service can be installed in a specific environment (read: a custom rootfs, a virtual machine, etc.).
automatic user and group creation
Each service needs to be separated from other users on the system, for security reasons. Let's make it the default.
tokens service a needs b, b needs c, when a starts, b and c start and are configured
service knows the relation between services, and use it to configure them through the templates. everything is smoother now
automatic backup solution
Since we know each running database, service configuration and data directories, we can backup everything once a backup server has been configured. Of course, we can add a lot of parameters to have a fine-grained backup solution.

# not currently done, but will look like this
$ backup add ssh:user@example.com:/srv/backup

unified way to configure the system best user experience possible
It alleviates the need for manual configuration. For example, adding a Wordpress service will automatically change the nginx configuration, create a new database and a new user in mariadb for this specific service. If several nginx are required, ports will be registered and automatically managed for each instance, no need for user input.
Behind the scene, it's a simple token system with configuration templating!
No heavy machinery here, and we'll keep it that way.
... and understandable tooling output for god's sake!

$ sudo service show my-awesome-gitea-instance
Name:            my-awesome-gitea-instance
Type:            gitea
Environment:     root (prefix)
Consumes:
  - database     root/postgresql
  - http         root/nginx
Ports:
  - http:        49155

Service: a service example.
A service configuration has two parts: the service description and its configuration file template(s). Let's use gitea as example, the git web server handling our repositories.

# `gitea.spec`

# The actual command to run to start the service
command: gitea -C . -w . -c gitea.cfg

# what tokens the service needs, see that http is optional
consumes: database, http?

# does the service requires a domain name to be configured?
# this name may be used in the service configuration, or its (forward|backward) dependencies
requires-domain: true

# the service requires a simgle port to be open
# by default, 80
ports: http

# `%configuration` indicates the name of the configuration template
%configuration gitea.cfg

We currently uses a bit more configuration for the database, but we will get there at some point.

Now, a quick look at its configuration template. just a sample, we'll skip most, don't worry
Templating is done with Jinja2 templates: see more about Jinja2 templating.

[database]
# providers = list of services behind the tokens
# for example: behind 'database' there is a `postgresql` service
# and we want the main port to use (for a database, 'ports.main' = port to access it remotely)
# See the definition of the postgresql service for details.
HOST     = 127.0.0.1:{{ providers.database.ports.main }}

# we have to enter the database name
# by default, databases are configured with a name convention as follow: environment_service_db
# service.id is 'environment/service', which identifies uniquely the service
# to get the right database name, we should take the service.id template variable and replace the "/" by "_" then add "_db"
NAME     = {{ service.id | replace("/", "_") }}_db

# by default, the user name is identical to the database name, but without the "_db" suffix
USER     = {{ service.id | replace("/", "_") }}

# we have created the `random_password` function, taking a service id in parameter
# `random_password` creates a unique password the first time it is called
# after that, it provides the same password each time it is called with the same service id
# `random_password` enables sharing a password between two service configurations
PASSWD   = {{ random_password( service.id ) }}

[repository]
# service.root indicates the service working directory: /srv/<environment>/<service>/
ROOT = {{ service.root }}/repositories

[server]
# service.domain = provided domain token value
# service.ports.http = provided ports.http token value
ROOT_URL         = http://{{ service.domain }}:{{ service.ports.http }}/

Current implementation of service
It currently works, and we just need to add more services! Every new corner case will be thoroughly investigated to provide the smoothest experience possible under BaguetteOS. We currently use it for a few services, such as the nginx providing this very website.

Currently, there are no fancy environments, just plain directories.

Future of service
First, we want to work on databases, to export data and get a simple backup service.

Then, we could let users manage their own services, but this is of little interest in practice since services are running under different users already.

The most useful thing to do right now is to provide new services.

Build.zsh: makefile creation. for mere mortals

Build.zsh creates a makefile from a simple declarative configuration file. A Makefile should:

build the application
This means a few things:
- compile and link your applications
- handle dependencies between files to build
- rebuild only updated parts of the application, for incremental builds
- allow users to rebuid any part of your project independently
install the application
The default installation root directory is /usr/local but you should be able to change that easily (and with an environment variable).
create a tarball of the project
Very useful to share your project, whatever your project is. No matter if it is an application, a library, the language used, etc.
have a make help

Here is a quick example of what build.zsh can do:

package=my-application
version=2.18.3

# target = all the 
target=()

Here is a real-life example:

package=build_zsh # Name of the package.
version=0.2.1     # Version of the package.

targets=(build.zsh)     # The things to build or install.
type[build.zsh]=script  # How they’re built.

# Using a for loop to add more targets.
# In this example, we’re registering scripts for installation.
for i in build/*.zsh; do
	targets+=($i)
	type[$i]=script

	# Installation in a non-default directory.
	install[$i]='$(SHAREDIR)/build.zsh'

	# Targets marked as “auto” won’t appear in `make help`.
	auto[$i]=true
done

# Files to add to tarballs through `make dist`.
dist=(build.zsh.in build/*.zsh project.zsh Makefile)

Don't like Makefiles? We may even add some other back-ends.

LibIPC: an IPC communication library nothing new, yet it still feels fresh

We use this communication library between our services.

Applications should talk to each other
We need services, not libraries
Therefore, languages are irrelevant: you can use any library in any language.

LibIPC is currently used for the administration dashboard, the web interface for the services, for a kanban and several other tools we use for collaboration. It provides a way to communicate between clients and services using simple unix sockets behind the scene.

C library with Crystal bindings (other languages coming soon)

require "ipc.cr"

server = IPC::Service.new "MyService"
server.loop do |message|
    # ...
end

That's easy to write even in plain C.

LibIPC explanation goes beyond the scope of this page… and may even deserve a whole website of its own but the tool is awesome and performances are crazy (we have to tell the world!). Just go and check!

Explain remote communications. Remote remote communications are transparent.

clients and services do not need remote communication
any client can join remote services via any communication protocol
any service is implicitly accessible from anywhere, anyhow

Other tools

tap-aggregator: quality assurance & test results aggregation

Webhooksd: verify recipes.

Webhooksd provides an automatic verification of the recipes, based on new application or library version. Paired with a build system, new recipes received in the repository create packages for a couple of architectures (x86_64, ARM, others will follow).

Still in discussion

For the simple users, we want to provide an unified web interface to manage the system and online services. We currently use Crystal to work on service back-ends for a variety of projects, we are satisfied on a technical level and we are productive, it is highly probable we continue using it. The front-end is still in discussion: we currently use livescript and it is way more usable than plain JS, but it is painful to debug.

So, we need a language for both administration dashboard and online services, here are some examples we find interesting for the job:

Purescript
- haskell-like syntax, with a smaller set of notions
- strongly typed, with type inference
- good documentation
- useful compilation errors
- no runtime error
Elm
- as Purescript but with way fewer documentation (but reading the code is sometimes enough here)
- less generic code (functions such as fold and map have hardcoded type), which feels a bit hacky
- still very young
WASM
- seems to be a very young tech, with no real good language or documentation
- Zig has wasm as a Tier 1 support, we should investigate

4. Slotting: providing software the right way

The usual way to provide software is to maintain a version of a software or a library, package it into a distribution, then provide it as the OS version of the software. In the long run, software and libraries change, which is no big deal since maintainers verify the consistency of the different versions provided by the OS.

Problem:

what happens when two programs need a different version of a library?
The installation of both may no be possible. See python from version 2 to 3 as an example: developers knew it will break OS systems. So, they provided by themselves new names for their binaries (python-2.7), and libraries are by default packaged into a directory specific for a python version, such as /usr/lib/python3.8/ and this is a form of slotting. This is mostly done for languages, by what about other packaged applications and libraries?
what happens when two libraries are compatible but you want both on your system (see libressl and openssl)?
what happens when you want to provide a very long term support for your users? see companies running decade-old OSs and databases

BaguetteOS has a simple and safe way to let users and maintainers provide packages: slotting. Official OS packages are installed under /usr/baguette/, for non-essential programs. Here, the slot is baguette. Any package outside the official ones are in another named slot.

Wanna support Python 2.7 for life? Just maintain a python-2.7 slot. It will be available for everyone.

This is nothing new, however not often used, and still maybe the best way to handle the problem.

Others are doing it: snap, flatpak, cpanm, pip, go, stack, cabal, ... the list seems endless
They all use slotting... but. Since they are is yet another package manager for your system, you need to install all your snap software dependencies from their own dependency tree. You have now a shit-ton of ways to get software updates, and for almost all of them, it's just giving up the idea of having people testing the software before providing it.

Having an alternate package manager for your system is a fancy way of saying:
"I trust all the developers more than my OS maintainers. And fuck testing, who needs that anyway."

snap
Snap maintains a /snap directory on your system, everything is in there. They even go to a slotting per recipe version, which is kinda per application version. See the readme in /snap/README, does it ring a bell?

  /snap/bin                   - Symlinks to snap applications.
  /snap/<snapname>/<revision> - Mountpoint for snap content.
  /snap/<snapname>/current    - Symlink to current revision, if enabled.

flatpak: same as snap
cpanm, pip, stack, cabal, go... and other developer tools
These are tools for developers to overcome the relatively slow process of providing a library in an OS. But this process is slow for a reason, taking shortcuts is not safe.

But, BaguetteOS... I still need my last version of Blah! We gotcha buddy.
You wanna go fast? Try sonic the good slot: /usr/sonic. With this slot, the BaguetteOS maintainers provide the last versions of a variety of applications and libraries.

How slotting works in BaguetteOS

TODO: this documentation is not available right now. Sure the project is still awesome anyway!

How use and change slots used