matter/content
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: matter:25630ded0f63c6a2f4a09a30e5ffd3ed20342f48
Branches Tags
matter:main
..
compare: matter:19dc8496111168d5e53501f40be5fe08024215e4
Branches Tags
matter:main

No commits in common. "25630ded0f63c6a2f4a09a30e5ffd3ed20342f48" and "19dc8496111168d5e53501f40be5fe08024215e4" have entirely different histories.
25630ded0f ... 19dc849611

46 changed files with 678 additions and 806 deletions
Show Stats Expand all files Collapse all files

2
.gitea/pull_request_template/new_config.yaml
View File

@ -14,7 +14,7 @@ body:
id: extra
attributes:
label: Extra
description: Anything you want to add
description: Any extra thing you want to say
validations:
required: false
- type: checkboxes

2
.gitea/pull_request_template/new_wiki.yaml
View File

@ -21,7 +21,7 @@ body:
id: extra
attributes:
label: Extra
description: Anything you want to add
description: Any extra thing you want to say
validations:
required: false
- type: checkboxes

2
configs.md
View File

@ -1,3 +1,3 @@
List of configuration packages (dotfiles) for MatterLinux. These simple configurations allow you to easily set up
your desktop and they create a baseline for all of your own configurations. You can install these configurations
using the `confer` tool. [Learn more](/wiki/confer).
using the `mc` tool. [Learn more](/wiki/mc).

2
download.json
View File

@ -1,4 +1,4 @@
{
"id": "24.05",
"id": "24.04",
"title": "24"
}

2
download.md
View File

@ -1,5 +1,5 @@
For installation instructions, please [see the wiki](/wiki). You can
download the older versions from the [directory listing](https://rel.matterlinux.xyz/).
download the older versions from the [directory listing](https://rel.matterlinux.xyz/24/).
Signatures can be verified using `gpg`. To do so, download the maintainer's key:
```

13
index.md
View File

@ -1,7 +1,7 @@
## Details
MatterLinux is a tiny, independent, [free/libre](https://www.gnu.org/philosophy/free-sw.html) and
[open source](https://opensource.com/resources/what-open-source) GNU/Linux distribution
for `x86_64` (or `amd64`) systems. It has its own package management system and its own package pools.
for `x86_64` (or `amd64`) systems. It has its own package management system and its own package repos.
All source code for MatterLinux is licensed under GPLv3 and available on the
[MatterLinux Gitea](https://git.matterlinux.xyz/Matter).
@ -14,16 +14,15 @@ contributors. If you are interested you can follow the development of the projec
here is a rough roadmap:
<ul>
<li><k class="green">>>></k> Package system</li>
<li><k class="blue">>>></k> Package system</li>
<li><k class="green">>>></k> Website</li>
<li><k class="green">>>></k> Official pools (<code>base</code> and <code>desktop</code>)</li>
<li><k class="blue">>>></k> Official repos (<code>base</code> and <code>desktop</code>)</li>
<li><k class="green">>>></k> Wiki/documentation</li>
<li><k class="green">>>></k> First release</li>
<li><k class="blue">>>></k> Server pool</li>
<li><k class="green">>>></k> Expanding <code>desktop</code> pool (100 packages)</li>
<li><k class="green">>>></k> Expanding <code>desktop</code> pool (300 packages)</li>
<li><k class="green">>>></k> Expanding <code>desktop</code> repo (100 packages)</li>
<li><k class="green">>>></k> Expanding <code>desktop</code> repo (300 packages)</li>
<li><k class="blue">>>></k> Expanding the wiki</li>
<li><k class="blue">>>></k> Expanding <code>desktop</code> pool (500 packages)</li>
<li><k class="blue">>>></k> Expanding <code>desktop</code> repo (500 packages)</li>
<li><k class="red">>>></k> TUI/GUI installer</li>
</ul>

6
news/24_05.json
View File

@ -1,6 +0,0 @@
{
"id": "24_05",
"title": "It's finally here",
"date": "25/08/24",
"author": "ngn"
}

48
news/24_05.md
View File

@ -1,48 +0,0 @@
After 3 months of development and 2 months of package migration later, **MatterLinux 24.05**
is finally here. So let's go over all the details, shall we?
## The new package management system
We now have a reworked package managment system, with new tools, libraries, pools and packages.
Some of these are been in the work for months now, and I am so happy to announce that they are finally ready
and are being shipped with the new 24.05 release.
I already covered some these new tools in the previous posts, however here is a quick list if you missed
all that:
- **[libmp](https://git.matterlinux.xyz/Matter/libmp)**: MatterLinux package management library
- **[matt](https://git.matterlinux.xyz/Matter/matt)**: The (new) MatterLinux package manager
- **[mtsc](https://git.matterlinux.xyz/Matter/mtsc)**: MatterLinux tools and scripts collection
- **[pooler](https://git.matterlinux.xyz/Matter/mtsc)**: Simple MPTP server for serving package pools
- **[mirp](https://git.matterlinux.xyz/Matter/mirp)**: MPTP mirror tool
So now with these new and updated pools, package management has improved a lot, here are few important changes:
- **Packages are now independent**: You can install packages from local package archives, without depending on a pool
- **More information**: Packages now store more information for the user, such as a changes file
- **Faster**: We now use proper SQLite databases and a custom TCP based protocol ([MPTP](/wiki/mptp)) to improve operation speeds
I also updated lots of core packages, and you can expect more consistent focus on updates and patches from now on.
This also unfortunately means that previous releases of MatterLinux that use the older package management system is completely
broken, as I shut down the old package repositories. It's still possible to use old ISO images and release archives thought. You just
won't be able to install any packages.
## A new package pool
With 24.05, I've introduced a new package pool, [server](/wiki/pools). As the name suggest this pool will be shipping popular
server software, such as Apache HTTPD or nginx. Currently it only contains a few packages, and it's disabled by default in the [matt](/wiki/matt)
configuration. You can enable it if you want to check it out.
## Website updates
I've also updated to the different components of the MatterLinux website:
- [News page](/news) now support Atom/RSS/JSON feeds
- [Package tracker](https://tracker.matterlinux.xyz) now offers more information about packages and more options for package search
- [Wiki](/wiki) is restructured to make it easier to find different pages, and all pages are updated
A part from these I also made few style changes to improve the user experience
## What's next?
I'll be taking few weeks off and I will work on some different projects of mine, as I literally just spent 3 months on MatterLinux.
However I'll back and I'll be bringing in more package updates, security patches and maybe even more packages.
Anyway, that will be all for now, thank you for reading and I hope I will see you in the next post!

12
wiki/install/install.md
View File

@ -83,9 +83,9 @@ After downloading and verifying the archive extract it to the `/mnt` directory:
```
### Package manager configuration
Edit the default `matt` configuration and enable the pools you want to use:
Copy over the `mp` configuration to the new system:
```
# vim /mnt/etc/matt/config.ini
# cp /etc/mp/cfg /mnt/etc/mp/cfg
```
### Change root
@ -122,13 +122,13 @@ into the `/etc/locale.conf` file, for example:
After changing root, you can now start installing other base system packages that are not included in the release archive.
But first thing first, sync all the packages and add the repo public keys:
```
# matt sync
# mp-sync
# gpg --receive-keys F9E70878C2FB389AEC2BA34CA3654DF5AD9F641D
```
Now it is time to install packages. You should install `systemd` and `dhcpcd`:
```
# matt install systemd dhcpcd
# mp-install systemd dhcpcd
```
You should also run this `systemctl` command after installation:
```
@ -161,7 +161,7 @@ Change your root password:
### Installing the kernel
Install the linux kernel with `mp`:
```
# matt install linux
# mp-install linux
```
Verify the installation:
```
@ -171,7 +171,7 @@ Verify the installation:
# Installing GRUB
For the grub BIOS installation, install the `grub-bios` package:
```
# matt install grub-bios
# mp-install grub-bios
```
> **Important**

15
wiki/install/post.md
View File

@ -9,7 +9,7 @@ To make your system more usable, you may want to install and configure extra pac
## Installing OpenSSH
For remote access to your system, you can install OpenSSH server:
```
# matt install openssh
# mp-install openssh
```
You can enable root login, by editing `/etc/ssh/sshd_config`:
```
@ -24,7 +24,7 @@ To add a new user, use the `useradd` command:
You may want to configure `doas` to provide root access to the new user.
To do this, install the `doas` package:
```
# matt install doas
# mp-install doas
```
Then create a group named `wheel` for all the admin users:
```
@ -36,20 +36,25 @@ Add your user to the `wheel` group:
```
Lastly edit the doas confiuration (`/etc/doas.conf`) to give access to the `wheel` group users:
```
# echo "permit :wheel" > /etc/doas.conf
# echo "permit keepenv :wheel" > /etc/doas.conf
```
> **Why keepenv?**
>
> MatterLinux package manager has options such as `MP_YES` that are set with environment
> variables. To make sure that these options work `keepenv` needs to be added to the doas
> confiuration.
## Installing XORG
Xorg can be installed using a simple wrapper package:
```
# matt install xorg
# mp-install xorg
```
Then you can use `startx` to start the `xorg-server`.
## Installing a desktop
To easily install a desktop, you can use the `xcfg` tool:
```
# matt install xcfg
# mp-install xcfg
```
You can then use the tool as a regular user, not that you will need access to the `doas` command
in order to use the tool:

2
wiki/main.json
View File

@ -2,5 +2,5 @@
"id": "main",
"title": "Welcome to MatterLinux wiki!",
"author": "ngn",
"date": "26/08/24"
"date": "09/07/24"
}

45
wiki/main.md
View File

@ -3,46 +3,35 @@ edit a page or create a new page, make a [pull request](/wiki/contribute) to [co
> **Important!**
> With the 24.05 release there have been lots of changes to the package system,
> so some of the pages are currently under development.
> Due to ongoing package system rework, the `Packaging` section is currently in a messy state
> and may contain misinformation or missing links, [please see this post](/news/important_update).
## Installation
| Name | Description |
| --------------------------------------- | ----------------------------------------------- |
| [Introduction](/wiki/intro) | Learn about MatterLinux and other general stuff |
| [Installation](/wiki/install) | Learn how to install a base MatterLinux system |
| [Post-installation](/wiki/post_install) | Make your system (somewhat) usable |
## Tools/libraries
| Name | Description |
| --------------------------------------------- | ------------------------------------------------------------------------------ |
| [Working with matt](/wiki/matt) | Learn how to manage packages with MatterLinux package manager (`matt`) |
| [Working with libmp](/wiki/libmp) | Learn how to use the MatterLinux package library (`libmp`) |
| [Working with confer](/wiki/confer) | Learn how to manage your configs MatterLinux configuration manager (`confer`) |
| [Post-Installation](/wiki/post_install) | Make your system (somewhat) usable |
## Packaging
| Name | Description |
| --------------------------------------------- | ------------------------------------------------------------------------------ |
| [Packages](/wiki/packages) | Learn about MatterLinux packages |
| [Creating packages](/wiki/create) | Learn how you can create and add a package to the official pools |
| [MPTP](/wiki/mptp) | Learn about **M**atterLinux **P**ackage **T**ransfer **P**rotocol |
| Name | Description |
| --------------------------------------------- | -------------------------------------------------------------------------- |
| [Releases](/wiki/releases) | Learn about MatterLinux release cycle |
| [Packages](/wiki/packages) | Learn about MatterLinux packages |
| [Pools](/wiki/pools) | Learn about MatterLinux package pools |
| [Mirrors](/wiki/mirrors) | Discover pool mirros and learn how you can setup your own |
| [Pool Guidelines](/wiki/pool_guides) | Package guidelines for the official pools |
| [Create a packages](/wiki/create_packages) | Learn how you can create and add a package to the official repos |
| [Working with mp](/wiki/mp) | Learn how to manage packages with MatterLinux package manager (`mp`) |
| [Working with libmp](/wiki/libmp) | Learn how to use the MatterLinux package library (`libmp`) |
| [Understanding MPTP](/wiki/mptp) | Learn about MatterLinux package transfer protocol (MPTP) |
| [Working with mc](/wiki/mc) | Learn how to manage your configs MatterLinux configuration manager (`mc`) |
## Pools
| Name | Description |
| --------------------------------------------- | ------------------------------------------------------------------------------ |
| [Pools](/wiki/pools) | Learn about MatterLinux package pools |
| [Mirrors](/wiki/mirrors) | Discover pool mirros and learn how you can setup your own |
| [Pool guidelines](/wiki/pool_guides) | Package guidelines for the official pools |
## Contribute
## Other
| Name | Description |
| -------------------------------- | ------------------------------------------------------- |
| [Chat](/wiki/chat) | Learn how you can contact developers and contributers |
| [Contributing](/wiki/contribute) | Learn how you can contribute to MatterLinux |
| [Bugs](/wiki/bugs) | Learn how you can report bugs/issues |
## Other
| Name | Description |
| -------------------------------- | ------------------------------------------------------- |
| [Releases](/wiki/releases) | Learn about MatterLinux release cycle |
| [Licensing](/wiki/licensing) | Licensing for the MatterLinux repositories and software |

0
wiki/contribute/bugs.json → wiki/other/bugs.json
View File

14
wiki/contribute/bugs.md → wiki/other/bugs.md
View File

@ -3,18 +3,12 @@ for development of the project. On this page you will find information about how
bugs to the project.
## Package bugs/issues
If you are having issues with a package/software, identify the pool that contains the package.
To do so you can use the following command:
```
$ matt info <package name>
```
Or you can search for the package using the [MatterLinux package tracker](https://tracker.matterlinux.xyz).
If you are having issues with a package/software, identify the repo contains the package.
You can use the `mp-query` command for this.
After identifying the repo, visit the issue tracker for that specific repo:
- [issue tracker for the `base` repo](https://git.matterlinux.xyz/Matter/base/issues)
- [issue tracker for the `desktop` repo](https://git.matterlinux.xyz/Matter/desktop/issues)
- [issue tracker for the `server` repo](https://git.matterlinux.xyz/Matter/server/issues)
Using the search feature of the issue tracker, make sure that the issue has not been already reported.
There is no point at reporting the issue, if it has been already reported. Duplicate issues will be closed.
@ -24,9 +18,9 @@ in order to create an account. Using this account you can create an issue, fill
and patiently wait for a response. You should provide additional details about the bug/issue when requested.
## Tool bugs/issues
You may have issues using MatterLinux tools such as the MatterLinux Package Manager (`matt`). This issues should be reported
You may have issues using MatterLinux tools such as the MatterLinux Package Manager (`mp`). This issues should be reported
to the related issue tracker over on [Gitea](https://git.matterlinux.xyz/Matter).
## Translation mistakes, spelling mistakes etc.
You do not need to create an issue for small issues such as little translation mistakes. Just contact maintainer/developers
[directly](/wiki/chat).
on [XMPP](/wiki/chat).

0
wiki/contribute/chat.json → wiki/other/chat.json
View File

3
wiki/contribute/chat.md → wiki/other/chat.md
View File

@ -3,7 +3,6 @@ who are also interested, feel free to join any of the chat rooms on the table:
| Platform | Admin | Topic | Language | Link |
| ------------- | ------------------------ | -------------------------- | ------------- | ------- |
| IRC | [ngn](mailto:ngn@ngn.tf) | Development and questions | English | [#matterlinux on libera.chat](irc://libera.chat/#matterlinux) |
| XMPP | [ngn](mailto:ngn@ngn.tf) | Development and questions | English | [general@conf.matterlinux.xyz](xmpp:general@conf.matterlinux.xyz?join) |
## Rules
@ -13,5 +12,5 @@ Here are the rules for all the chat rooms:
2. Be respectful to others
3. No spam
4. No advertising
5. No inappropriate content
5. No NSFW/NSFL content
6. Only chat in the specified language

0
wiki/contribute/conduct.json → wiki/other/conduct.json
View File

0
wiki/contribute/conduct.md → wiki/other/conduct.md
View File

0
wiki/contribute/contribute.json → wiki/other/contribute.json
View File

12
wiki/contribute/contribute.md → wiki/other/contribute.md
View File

@ -5,15 +5,15 @@ If you want to contribute to MatterLinux, please first read the
All of the development is done using the [git version control system](https://git-scm.com/).
And all the git repos are managed using [Gitea](https://about.gitea.com/), so if you want to
contribute, you should register an account first. To prevent mass account creation, registration
page of Gitea is disabled. So in order to register an account, send a email to the [maintainer](mailto:ngn@ngn.tf)
with the subject `Gitea Account`. Specify **at least** two usernames for your account (second one will be used for
registration if the first one is unavailable). Then wait for a reply containing further instructions.
You can also contact the maintainer [directly](/wiki/chat).
page of Gitea is disabled. So in order to register an account, send a email to the
[maintainer](mailto:ngn@ngn.tf) with the subject `Gitea Account`. Specify **at least** two usernames
for your account (second one will be used for registration if the first one is unavailable). Then
wait for a reply containing further instructions. You can also contact the maintainer over on [XMPP](/wiki/chat).
> **Important**
>
> Do not use the Gitea instance for hosting your own projects/repositories, personal
> repositories (AKA repositories not forked for PRs) will be deleted. If you insist on creating
> repositories (A.K.A. repositories not forked for PRs) will be deleted. If you insist on creating
> personal repositories your account will be deleted.
## Issues
@ -74,8 +74,6 @@ set undofile
syntax on
```
You should also run the `make format` command for repositories that contain custom formatting
rules in their Makefiles.
After making the changes, commit them using the following format:
```

4
wiki/other/licensing.md
View File

@ -2,10 +2,10 @@
All of the MatterLinux software and the tools are available on
[MatterLinux Git Server](https://git.matterlinux.xyz) and they are licensed under
[GNU General Public License Version 3](https://www.gnu.org/licenses/gpl-3.0.en.html).
A copy of this license can be found in every git repository, in the `LICENSE.txt` file.
A copy of this license can be found in every repository, in the `LICENSE.txt` file.
MatterLinux software and the tools are distributed as [free/libre](https://www.gnu.org/philosophy/free-sw.en.html) and
[open source](https://opensource.com/resources/what-open-source) software. This means anybody can freely:
[open source](https://opensource.com/resources/what-open-source) software. This means anybody can:
- Use MatterLinux software and tools
- Distribute copies of MatterLinux software and tools

274
wiki/package/create.md
View File

@ -1,274 +0,0 @@
On this page, you will learn how you can create your first
MatterLinux package for the official pools.
## Pre-requirements
- You should have an up-to-date MatterLinux installation
- You should have general understanding of software packaging
- You should have general understanding of building/compiling software
- You should know the basics of bash scripting
- You should know the basics of git version control system
## Getting started
If you want to add your package to the official pools, then please
check the [official pool guidelines](/wiki/pool_guides). Make sure
that your package follows the guidelines or your pull request may be
rejected.
Also, create an account on Gitea server and configure your editor
as specified in the [contribution guide](/wiki/contribute).
## Install requirements
To follow this tutorial you will need a working MatterLinux installation
(minimum version 24.05). You also need to install the following packages
from the [`base` pool](/wiki/pools):
- an editor (`vim` and `nano` is avaliable on the `base` pool)
- build-essential
- [mtsc](https://git.matterlinux.xyz/matter/mtsc)
- git
## Selecting a pool
If you want to add a new package to the official pools, you should
first choose the pool you want to add the package to. You should check
the [list of official pools](/wiki/pools), and figure out which pool
your package belongs to.
## Fork the pool
After selecting the pool, fork it on Gitea and clone it to MatterLinux
system:
```
$ git clone <git repository url>
```
Create a new branch for your package:
```
$ git branch -m new-package
```
To build and create packages, you should install the `build-essential` package from the
[`base` pool](/wiki/pools). This package will provide you with all the base tools
required, such as the GNU C compiler. You will also need
## Create the package template
Change directory into the `src` folder of the pool you cloned, and use the `mp-new`
command (a script from `mp-build`) to create an empty package script:
```
$ cd src
$ mp-new <name of the package>_<version of the package>
```
Package name should be **full lowercase**, it should not contain any non-English characters,
and it should not contain underscore (`_`). If there is an underscore in the package name, replace
it with `-`. Package name also **should NOT contain a version number**.
Version name ideally should contain a version number separated with dots. However this may heavily
change based on how the upstream actually versions the software. Version should also be updated
after every modification. If the modification does not change the upstream version, then you should
suffix the version with `m<number of changes>`, for example `1.2m1`, `8.7.3m7` etc. Version name should
also not contain underscores (`_`), you should replace them with `-`.
For this example we will be packaging the `LXTerminal` (version `0.4.0`) from LXDE:
```
$ cd src
$ mp-new lxterminal_0.4.0
```
## Modify the package script
`mp-new` will create a directory for the new package, named after the package, which will contain a `pkg.sh` script.
This script is called the **package script**. Open this script with the configured editor:
```
# general info
NAME="lxterminal"
DESC=""
VERSION="0.4.0"
# required files
FILES=()
HASHES=()
# install and build depends
DEPENDS=()
BUILD=()
PACKAGE() {
tar xf "${NAME}-${VERSION}.tar.gz"
cd "${NAME}-${VERSION}"
cd .. && rm -r "${NAME}-${VERSION}"
}
```
### Description
First of all you should add a description. Description should be short (less than 200 characters), and
it should explain details about the package. Ideally, description should not contain words such as "*contains*"
and "*includes*". Here are some **bad examples**:
- *LXTerminal package contains a VTE-based terminal emulator*
- *LXTerminal includes the LXDE terminal emulator*
And here are some **good examples**:
- *VTE-based terminal emulator for LXDE*
- *LXDE terminal emulator*
### Version
You should package a stable version of the software, do not package the latest git commit or
something like that. **Package an official released version.**. For this example we will be
packaging the version `0.4.0`.
### Files
List of files needed for this package, you can specify `HTTP(S)` or `FTP(s)` URLs. Or you can
specify simply just filenames to pull the packages from the local source directory.
If possible, you should replace the version number in the URL with the `VERSION` variable.
### Hashes
Specify hashes for the files you specified, you can use the `NOHASH` as the hash to disable
hash verification for a specific file.
### Depends
Run-time dependencies for the package, **do not** specify the make or the build dependencies that are only used
for compiling the software.
### Build
Build-time dependencies for the package, **dot not** specify any run-time dependencies again if they are also needed
for the build process. Also **do not** specify any package that is part of `build-essential`.
With the addition of the details above, here is how our example package script looks like:
```
# general info
NAME="lxterminal"
DESC="Commands for manipulating POSIX Access Control Lists"
VERSION="0.4.0"
# required files
FILES=("https://downloads.sourceforge.net/lxde/lxterminal-$VERSION.tar.xz")
HASHES=("7938dbd50e3826c11f4735a742b278d3")
# install and build depends
DEPENDS=("vte")
BUILD=()
PACKAGE() {
tar xf "${NAME}-${VERSION}.tar.gz"
cd "${NAME}-${VERSION}"
cd .. && rm -r "${NAME}-${VERSION}"
}
```
### Package function
The package function contains the instructions for building the package itself. When building the package, `mp-build`
will download all the files and remove them after the build, so you do not have to deal with that.
To make your life simpler, `mp-new` creates a boilerplate `PACKAGE()` function template. Now will modify it
to make it work our package.
First, we should do is to extract the downloaded file, and change directory into the newly extracted folder:
```
tar xf "${NAME}-${VERSION}.tar.gz"
cd "${NAME}-${VERSION}"
```
Then we can change directory into the pool source directory and run the build and install instructions:
```
./configure --enable-man --prefix=/usr
make && make install
```
With this configuration, `make install` will try to install the package to the actual system, however
we want to install the package to the package build directory, so we will use the `DESTDIR` flag for that:
```
./configure --enable-man --prefix=/usr
make
make DESTDIR="${ROOTDIR}" install
```
`$ROOTDIR` is a custom variable that is set during the package build. During the build it will point to the
package build directory.
After building and installing the package, we can change directory back up, and remove the extracted folder:
```
cd .. && rm -r "${NAME}-${VERSION}"
```
So the final script should look like this:
```
# general info
NAME="lxterminal"
DESC="Commands for manipulating POSIX Access Control Lists"
VERSION="0.4.0"
# required files
FILES=("https://downloads.sourceforge.net/lxde/lxterminal-$VERSION.tar.xz")
HASHES=("7938dbd50e3826c11f4735a742b278d3")
# install and build depends
DEPENDS=("vte")
BUILD=("intltool")
PACKAGE() {
tar xf "${NAME}-${VERSION}.tar.xz"
cd "${NAME}-${VERSION}"
./configure --enable-man --prefix=/usr
make
make DESTDIR="${ROOTDIR}" install
cd .. && rm -r "${NAME}-${VERSION}"
}
```
## Formatting the package script
When you are done, format the package script following these rules:
- If you have multiple files, put each one of them to a new line, same for the hashes.
- If you have more than 5 depends, split them into new lines, grouping 3 depends together.
- If you have long commands in the build function, split them to new lines using a backslash (`\`)
- Prevent using `&&` unless it's absolutely necessary, it usually ends up messing the error checking
- Split unrelated instructions with a newline
You can use the `mp-check` script to automatically check for some of these issues:
```
$ mp-check lxterminal
```
## Building the package
To build the newly created package, run the following in the `src` directory:
```
$ mp-build --no-sign lxterminal
```
This will install all the required dependencies, and only build the specified package.
## Testing the package
When build is completed, you will have a new `.mpf` package archive in the `dist` directory
of the package directory. You can check this archive for any potential issues using `mp-check`
again:
```
$ mp-check lxterminal/dist/lxterminal_0.4.0.mpf
```
After fixing any potential issues and warnings, you can install your newly created package using
the [package manager](/wiki/matt) and test it out:
```
# matt install --yes lxterminal/dist/lxterminal_0.4.0.mpf
$ lxterminal
```
## Stage and commit your changes
After making sure that the package is working as intended, go back to the root of the pool source directory,
and use `git add .` to stage all the changes. Then use `git commit -m <message>` command to commit them. For the
commit message, follow the guidelines on the [contribution page](/wiki/contribute). For our example, the following
message should be fine:
```
$ git commit -m "new: lxterminal package"
```
Then push your branch to the remote:
```
$ git push -u origin new-package
```
## Creating a pull request
Back on the Gitea, create a pull request to the official repository. Provide information about
the package you added, and explain why you think its important to include this package.
Please patiently wait for a response from the maintainer(s) after creating your pull request,
if find out any problems with your package after creating the pull request, fix them and make more commits
to your new branch, they should automatically be added to the pull request.
## You are done!
If you follow every step correctly your pull request will be merged. After the merge, your package will
be added to the [development (next) pools](/wiki/pools) and after some testing it will make it's way to
the stable pools.

6
wiki/package/mptp.json
View File

@ -1,6 +0,0 @@
{
"id": "mptp",
"title": "MPTP",
"author": "ngn",
"date": "26/08/24"
}

1
wiki/package/mptp.md
View File

@ -1 +0,0 @@
This page is currently under development.

4
wiki/package/create.json → wiki/pkg/create.json
View File

@ -1,6 +1,6 @@
{
"id": "create",
"id": "create_pkg",
"title": "Create a package",
"author": "ngn",
"date": "04/08/24"
"date": "23/02/24"
}

213
wiki/pkg/create.md Normal file
View File

@ -0,0 +1,213 @@
On this page, you will learn how you can create your first
MatterLinux package for the official repos.
## Pre-requirements
- You should have an up-to-date MatterLinux installation
- You should have general understanding of software packaging
- You should have general understanding of building/compiling software
- You should know the basics of bash scripting
- You should know the basics of git version control system
## Getting started
If you want to add your package to the official repos, then please
check the [official repo guidelines](/wiki/repo_guide). Make sure
that your package follows the guidelines or your pull request maybe
rejected.
Also create an account on Gitea server and configure your editor
as specified in the [contribution guide](/wiki/contribute).
## Selecting a repo
If you want to add a new package to the official repos, you should
first choose the repo you want to add the package to. If you are
packaging a software that is fundamental to the OS, such as a kernel,
or a C library, you should add your package to the `base` repo.
If this is not the case then you should add the package to the `desktop`
repo.
## Fork the repo
After selecting the repo, fork it on Gitea and clone it to MatterLinux
system:
```
$ git clone <fork repo url>
```
## Install `mp-repo`
MatterLinux project has few different tools used for building and creating packages,
these tools are part of the `mp-repo` tool. To install it, follow the [instructions on
the README](https://git.matterlinux.xyz/matter/mp-repo).
## Create the package template
Change directory into the `src` folder of the repo you cloned, and use the `mp-temp`
command (a script from `mp-repo`) to create an empty package script:
```
$ cd src
$ mp-temp <name of the package>
```
Package name should be **full lowercase**, it should not contain any non-English characters,
and it should not contain underscore (`_`). If there is an underscore in the package name, replace
it with `-`. Package name also **should NOT contain a version number**.
For this example we will be packaging the `LXTerminal` from LXDE:
```
$ cd src
$ mp-temp lxterminal
```
## Modify the package script
`mp-temp` will create a directory for the new package, which will contain a `pkg.sh` script.
This script is called the **package script**. Open this script with the configured editor:
```
NAME="lxterminal"
DESC=""
VERSION=""
FILES=()
HASHES=()
DEPENDS=()
build() {
tar xf $NAME-$VERSION.tar.gz
cd $NAME-$VERSION
cd .. && rm -r $NAME-$VERSION
}
```
### Description
First of all you should add a description. Description should be short (less than 200 characters), and
it should explain details about the package. Ideally, description should not contain words such as "*contains*"
and "*includes*". Here are **bad examples**:
- *LXTerminal package contains a VTE-based terminal emulator*
- *LXTerminal includes the LXDE terminal emulator*
And here are some **good examples**:
- *VTE-based terminal emulator for LXDE*
- *LXDE terminal emulator*
### Version
You should package a stable version of the software, do not package the latest git release or
something like that. **Package an official release version.**. For this example we will be
packaging the version `0.4.0`.
### Files
List of files needed for this package, you can specify `HTTP(S)` or `FTP(s)` URLs. Or you can
specify simply just filenames to pull the packages from the local source directory.
If possible, you should replace the version number in the URL with the `VERSION` variable.
### Hashes
Specify hashes for the files you specified, you can use the `NOHASH` as the hash to disable
hash verification for a specific file.
### Depends
Dependencies for the package, **do not** specify the make or the build dependencies that are only used
for compiling the software. These dependencies should be specified in the `repo.sh` script which is located
at the root of the repo.
With the addition of the details above, here is how our example package script looks like:
```
NAME="lxterminal"
DESC="VTE-based terminal emulator for LXDE"
VERSION="0.4.0"
FILES=("https://downloads.sourceforge.net/lxde/lxterminal-$VERSION.tar.xz")
HASHES=("7938dbd50e3826c11f4735a742b278d3")
DEPENDS=("vte")
build() {
tar xf $NAME-$VERSION.tar.gz
cd $NAME-$VERSION
cd .. && rm -r $NAME-$VERSION
}
```
### Build function
The build function contains the instructions for building the package itself. When building the package, `mp-repo`
will download all the files and remove them after the build, so you do not have to deal with that.
First, we should do is to extract the downloaded file, and change directory into the newly extracted folder:
```
tar xf $NAME-$VERSION.tar.xz
cd $NAME-$VERSION
```
Then we can change directory into the repo source directory and run the build and install instructions:
```
./configure --enable-man --prefix=/usr
make && make install
```
With this configuration, `make install` will try to install the package to the actual system, however
we want to install the package to the package build directory, so we will use the `DESTDIR` flag for that:
```
./configure --enable-man --prefix=/usr
make && make DESTDIR="$ROOTDIR" install
```
`$ROOTDIR` is a custom variable that is set during the package build. During the build it will point to the
package build directory.
After building and installing the package, we can change directory back up, and remove the extracted folder:
```
cd .. && rm -r $NAME-$VERSION
```
So the final script should look like this:
```
NAME="lxterminal"
DESC="VTE-based terminal emulator for LXDE"
VERSION="0.4.0"
FILES=("https://downloads.sourceforge.net/lxde/lxterminal-$VERSION.tar.xz")
HASHES=("7938dbd50e3826c11f4735a742b278d3")
DEPENDS=("vte")
build() {
tar xf $NAME-$VERSION.tar.xz
cd $NAME-$VERSION
./configure --enable-man --prefix=/usr
make && make DESTDIR="$ROOTDIR" install
cd .. && rm -r $NAME-$VERSION
}
```
## Formatting the package script
When you are done, format the package script following these rules:
- If you have multiple files, put each one of them to a new line, same for the hashes.
- If you have more than 5 depends, split them into new lines, grouping 3 depends together.
- If you have long commands in the build function, split them to new lines using a backslash (`\`)
- If you have really short and related commands, put them into the same line using `&&`
- Split unrelated instructions with a newline
## Building the package
To build the newly created package, run the following in the `src` directory:
```
$ mp-repo --no-sign .. <package name>
```
This will install all the required dependencies, and only build the specified package.
## Testing the package
When the package is built, inspect its contents using the `tar tf` command, and extract it to
test it:
```
$ tar tf ../dist/<package name>_<version>.mpf
# tar xf ../dist/<package name>_<version>.mpf -C /
```
## Staging and commit your changes
After making sure that the package is working as intended, go back to the root of the repo source directory,
and use `git add .` to stage all the changes. Then use `git commit -m <message>` to commit them. For the
commit message, follow the guidelines on the [contribution page](/wiki/contribute). For our example, the following
message should be fine:
```
$ git commit -m "new: Add lxterminal package"
```
Then push your changes:
```
$ git push -u origin main
```
## Creating a pull request
Back on the Gitea, create a pull request to the official repository. Provide information about
the package you added, and explain why you think its important to include this package.

6
wiki/pkg/mc.json Normal file
View File

@ -0,0 +1,6 @@
{
"id": "mc",
"title": "Working with `mc`",
"author": "ngn",
"date": "05/05/24"
}

43
wiki/tools/confer.md → wiki/pkg/mc.md
View File

@ -1,16 +1,16 @@
On this page you will learn how you can use MatterLinux configuration manager.
# MatterLinux configuration manager
`confer` is a simple program that allows you to easily install and package your configurations, also
known as "dotfiles".
# MatterLinux Configuration Manager
`mc` or the MatterLinux configuration manager, is a simple program that allows you to
easily install and package your configurations.
### Installation
`confer` can be installed with the [package manager](/wiki/matt), it's located in the [`desktop
pool](/wiki/pools):
### Installing `mc`
`mc` can be installed with `mp` (MatterLinux package manager), it's located in the desktop
repo:
```
# matt install --yes confer
# mp-install mc
```
In order to run `confer` as a non-root user, you will need to [install and configure `doas` or `sudo`](/wiki/post_install).
In order to run `mc` as a non-root user, you will need to [install and configure `doas` or `sudo`](/wiki/post_install).
### Packaging your configuration
First of all you should create and empty git repository:
@ -19,7 +19,7 @@ $ mkdir my-config && cd my-config
$ git init
```
After adding a readme and a license (or any other files you might like), create an
`confer.ini` file. This file should follow the simple `INI` syntax. First section you should
`mc.cfg` file. This file should follow the simple `INI` syntax. First section you should
create in this file, is the details section:
```
[details]
@ -46,38 +46,33 @@ src = src/rofi/config.rasi
for (in this case the target is for `rofi` configuration, so its named `rofi`)
- `require`: A comma-separated list of packages that this configuration requires
- `desc`: A simple description explaining what the target is for
- `dst`: Where should the configuration should be copied during the installation, `confer` will
- `dst`: Where should the configuration should be copied during the installation, `mc` will
append the current user's home directory to this path
- `src`: Where should the configuration should be copied during the packaging, this path is relative to
the repository's path
After adding all the targets, run the `gen` command, specifying the local path to the git repository
that contain the `confer.ini` file:
```
$ confer gen /path/to/your/repository
```
`confer` will copy all the target files/directories from the `dst` to the
After adding all the targets, run the `mc-gen` command, specifying the local path to the git repository
that contain the `mc.gen` file. `mc` will copy all the target files/directories from the `dst` to the
`src`. When you are done, feel free to publish the git repository and share it.
### Installing configurations
To install a configuration you need to use the `pull` command. After the command,
To install a configuration you need to use the `mc-pull` command. After the command,
specify a directory, a HTTP(S) git URL, or just specify a name:
```
$ confer pull messier87
$ mc-pull messier87
```
If you just specify a name, `confer` will look for that configuration in the [config hub](/hub).
In this case, `confer` will pull down the `messier87` configuration, and walk you through the installation
If you just specify a name, `mc` will look for that configuration in the [config hub](/hub).
In this case, `mc` will pull down the `messier87` configuration, and walk you through the installation
by asking yes/no questions.
After the installation `confer` will install all the requirements using `matt`, and you will be ready to go!
After the installation `mc` will install all the requirements using `mp`, and you will be ready to go!
> **Important**
>
> Please check the `confer.ini` file before installing third party configuration packages
> Please check the `mc.cfg` file before installing third party configuration packages
> (packages that are not in the config hub), as they may include malicious configuration files
> that may harm your system.
### Config Hub
MatterLinux offers a simple [configuration hub](/hub), that you can use to find official configuration packages.
You can also add your own configuration to the config hub, just create a issue or a pull request in the
[website content git repository](https://git.matterlinux.xyz/Matter/content/issues).
You can also add your own configuration to the config hub, just create a issue or a pull request in the [website content repository](https://git.matterlinux.xyz/Matter/content/issues).

2
wiki/pools/mirrors.json → wiki/pkg/mirrors.json
View File

@ -2,5 +2,5 @@
"id": "mirrors",
"title": "Mirrors",
"author": "ngn",
"date": "04/08/24"
"date": "19/06/24"
}

50
wiki/pkg/mirrors.md Normal file
View File

@ -0,0 +1,50 @@
On this page, you will find information about MatterLinux package mirrors.
# Using different mirrors
To use a mirror with `mp`, change the pool URL for the target pool in your `mp`
configuration file (`/etc/mp/cfg`).
### Creating a mirror
To create a mirror you can use the `matter-mirror` tool. This tool is a part of the [MatterLinux `tools`
project](https://git.matterlinux.xyz/matter/tools). These tools can be installed with the `tools`
package in the desktop pool.
After installing `matter-mirror`, specify an URL and an output directory (files will be downloaded
into the output directory). For example to mirror the `base` pool from `https://pkgs.matterlinux.xyz/base`
to `base_mirror` directory:
```
$ mkdir base_mirror
$ matter-mirror -u https://pkgs.matterlinux.xyz/base -o base_mirror
```
To serve the mirror, you can setup [`pooler`](https://git.matterlinux.xyz/matter/pooler).
To learn more about `pooler`, see the [wiki page for pools](/wikş/pools.md).
You will mostly likely want to update your mirror every once in a while. To do so you can
create a cron job. For example to update your mirror every day at 00:00, you can add the
following entry to your `/etc/crontab`:
```
0 0 * * * <user> matter-mirror -u <url> -o <output dir path>
```
# Mirror lists
This section contains information about different MatterLinux pools and mirros
that you can use. To add your mirror to this list get in contact with the maintainer/developers.
> **Note**
>
> Official mirrors are **ALWAYS** signed with the `F9E70878C2FB389AEC2BA34CA3654DF5AD9F641D`
> fingerprint (belongs to the maintainer, ngn). If syncing with a mirror tells you otherwise, then
> **DO NOT USE THAT MIRROR** and report it to the maintainer/developers in order to remove it
> from the list.
### Official pools
| Pool | MPTP | HTTP(S) | Location |
| ------- | -------------------------------------- | ----------------------------------------- | ----------- |
| base | `mptp://pkgs.matterlinux.xyz/base` | `https://pkgs.matterlinux.xyz/base` | 🇹🇷 Turkey |
| desktop | `mptp://pkgs.matterlinux.xyz/desktop` | `https://pkgs.matterlinux.xyz/desktop` | 🇹🇷 Turkey |
| base | `mptp://next.matterlinux.xyz/base` | `https://next.matterlinux.xyz/base` | 🇹🇷 Turkey |
| desktop | `mptp://next.matterlinux.xyz/desktop` | `https://next.matterlinux.xyz/desktop` | 🇹🇷 Turkey |
### Mirrors
Currently there are no available mirrors.

2
wiki/package/packages.json → wiki/pkg/packages.json
View File

@ -2,5 +2,5 @@
"id": "packages",
"title": "Packages",
"author": "ngn",
"date": "04/08/24"
"date": "19/06/24"
}

50
wiki/package/packages.md → wiki/pkg/packages.md
View File

@ -23,8 +23,8 @@ package_1.0.mpf
Let's break this down:
- `DATA`: An `.ini` formatted file, contains information about package name, version, description,
dependencies, files to keep (save) during update/removal and SHA256 hash of the `MPF` file.
- `CHANGES`: A changelog file, containg information about the chnages accross different package versions
- `INSTALL`: An optional shell script. If it's not empty, then should be ran after the installation. This file
- `CHANGES`: A changelog file, each version's changelog is split with 3 newlines (`\n\n\n`)
- `INSTALL`: An optional shell script. If it exists, then should be ran after the installation. This file
is also named the "install script".
- `HASHES`: Contains MD5 hashes of every file in the `files.tar.gz` archive. Summaries are
followed by a white space (` `) and the full file path. These paths do not start with `/`,
@ -51,28 +51,26 @@ usr/bin/which
```
### Install scripts
Some packages may contain an non-empty install script, `INSTALL`, this shell script is ran by the
[MatterLinux Package Manager (`matt`)](/wiki/matt) using the bash shell, right after the
extraction of `files.tar.gz`, in the package installation directory (usually `/`).
Some packages may contain an install script, `INSTALL`, this shell script is ran by the
[MatterLinux Package Manager (`mp`)](/wiki/package_man) using the bash shell, right after the
extraction of `files.tar.gz`.
This script is used to do post-install actions, such as adding users, groups etc.
# Working with packages
While installing a package using the [MatterLinux Package Manager (`matt`)](/wiki/matt), `matt`
While installing a package using the [MatterLinux Package Manager (`mp`)](/wiki/package_man), `mp`
downloads the target package(s) from the pools, these packages are in the format discussed above.
After downloading and verifying the target package(s), `matt` extracts the packages using `libarchive`.
To learn more about this process see the [page for package management](/wiki/matt).
After downloading and verifying the target package(s), `mp` extracts the packages using `libarchive`.
To learn more about this process see the [page for package management](/wiki/package_man).
### Building packages
Package are built with the [`mp-build` tool](https://git.matterlinux.xyz/matter/mp-build). In order to
build a package, you will need the source of the package, which can be found in the source tree of the
pool which contains the package.
Package are built with the `mp-build` tool. In order to build a package, you will need the source
of the package, which can be found in the source tree of the pool which contains the package.
After obtaining the source, package can be simply built by running:
```
$ mp-build <package dir>
```
To learn more about building and creating packages, please [see this page](/wiki/create_packages).
### Package scripts
Each package source contains a `pkg.sh` shell script. This is the source script that is used to
@ -84,20 +82,18 @@ Let's take a closer look at a `pkg.sh` file:
NAME="which"
DESC="Shows the full path of (shell) commands"
VERSION="2.21"
FILES=("https://ftp.gnu.org/gnu/which/which-${VERSION}.tar.gz")
FILES=("https://ftp.gnu.org/gnu/which/which-$VERSION.tar.gz")
HASHES=("097ff1a324ae02e0a3b0369f07a7544a")
DEPENDS=()
PACKAGE() {
tar xf "${NAME}-${VERSION}.tar.gz"
cd "${NAME}-${VERSION}"
build() {
tar xf $NAME-$VERSION.tar.gz
cd $NAME-$VERSION
./configure --prefix=/usr && make
make DESTDIR="${ROOTDIR}" install
make DESTDIR=$ROOTDIR install
cd .. && rm -r "${NAME}-${VERSION}"
cd .. && rm -rf $NAME-$VERSION
}
```
This `pkg.sh` file is for the `which` package (version `2.21`). Let's start by breaking down the
@ -122,8 +118,8 @@ There are also other options that are not present in this example:
- `KEEP`: A list of files to keep during the update/removal of the package
- `BUILD`: A list packages required for building this package
Now let's take a look at the `PACKAGE` function. Each package needs a `PACKAGE` function, this
function is called by `mp-build` after downloading and verifying all the files. It will be
Now let's take a look at the `build` function. Each package needs a `build` function, this
function is called by `mp-build` after downloading and verifying all the packages. It will be
called in the `$ROOTDIR`. This directory will contain all the downloaded files, any files
in this directory will be included into the build, so don't forget to cleanup.
@ -132,14 +128,14 @@ in this directory will be included into the build, so don't forget to cleanup.
> You don't need to cleanup the downloaded files in the package script,
> they will be cleaned by the `mp-build`.
- `tar xf "${NAME}-${VERSION}.tar.gz"`: Extract the downloaded archive file.
- `cd "${NAME}-${VERSION}"`: Change directory into the extracted directory.
- `tar xf $NAME-$VERSION.tar.gz`: Extract the downloaded archive file.
- `cd $NAME-$VERSION`: Change directory into the extracted directory.
- `./configure --prefix=/usr && make`: Builds the `which` tool, different packages may have
different build instructions. These instruction are usually provided by the upstream. You can
also check out [LFS](https://www.linuxfromscratch.org/lfs/view/12.0-systemd/) and [BLFS](https://www.linuxfromscratch.org/blfs/view/12.0-systemd/) for instructions.
- `make DESTDIR="${ROOTDIR}" install`: Install the package. Make sure that you are installing the package
- `make DESTDIR=$ROOTDIR install`: Install the package. Make sure that you are installing the package
into the `$ROOTDIR` and not the root file system.
- `cd .. && rm -r "${NAME}-${VERSION}"`: Change directory back into `$ROOTDIR` and clean the extracted archive.
- `cd .. && rm -rf $NAME-$VERSION`: Change directory back into `$ROOTDIR` and clean the extracted archive.
Check out [`base`](https://git.matterlinux.xyz/Matter/base) and [`desktop`](https://git.matterlinux.xyz/Matter/desktop)
pool sources for more example package scripts.
pool sources for more example `pkg.sh` scripts.

6
wiki/pkg/pkg_man.json Normal file
View File

@ -0,0 +1,6 @@
{
"id": "package_man",
"title": "Package Management",
"author": "ngn",
"date": "21/02/24"
}

209
wiki/pkg/pkg_man.md Normal file
View File

@ -0,0 +1,209 @@
Package management is the process of installing, updating and removing software, tools and libraries.
On GNU/Linux systems, package management is usually done with a package manager.
# MatterLinux Package Manager
In a Matter system, package management is generally done with the MatterLinux Package Manager (`mp`).
`mp` lets you install, remove, update and search different MatterLinux packages across different repos.
### Installation
`mp` should be already installed on a MatterLinux system. However if you want to install `mp` from
the source, then you should follow [this section](https://git.matterlinux.xyz/matter/mp#installation)
from the README.
> **Note**
>
> You should run all the `mp` and related commands as the root user.
### Configuration
Configuration file for `mp` can be found at `/etc/mp/cfg`. This file is used specify repos and
configure general settings.
Here is the configuration shipped with the MatterLinux 24 releases:
```
[general]
tmpdir = /tmp/mp
[base]
uri = https://pkgs.matterlinux.xyz/base
[desktop]
uri = https://pkgs.matterlinux.xyz/desktop
```
Lets start by breaking down the `[general]` section:
- `tmpdir (path)`: Specifies the temporary directory used by the `mp`. This directory will be used to save
packages and signatures, most of the files in this directory will be removed after operation.
Other general configuration options are:
- `debug (yes/no)`: This setting is used to enable the debug logging, however `mp` don't have any
debug logging (it will be implemented in the future) so there is no point at enabling it.
Next sections specify the repos. Section name is the repo name, and it **should match with the
actual repo name**. Repo options are:
- `uri (URI)`: Repo URI, you can use `http`, `https` or `ftp` protocols.
- `signing (yes/no)`: Enable/disable PGP signature verification for the repo, by default it's enabled.
> **Important**
>
> Do NOT disable signature verification if you don't know what are you doing! There is no
> way to confirm the legitimacy of the packages without signature verification!
### Environment options
`mp` also has a few other options that you specify as an environment variable.
One of these is the `MP_ROOT` option. This option lets you change the target root directory.
By default `mp` install all the packages to `/`, stores all the information under the `/` etc.
By changing the target root directory you can change this.
For example lets say you want to install all the packages to `/tmp/testroot`. To do so,
first you will need to setup a root file system structure inside `/tmp/testroot`:
```
# mkdir /tmp/testroot
# pushd /tmp/testroot
# mkdir -p etc boot dev home proc root run srv sys tmp usr/lib usr/bin usr/sbin var/lib
# ln -sf bin usr/bin
# ln -sf sbin usr/sbin
# ln -sf lib usr/lib
# ln -sf lib64 usr/lib
# popd
```
Now you can use `mp` with the `MP_ROOT` variable, for example:
```
# MP_ROOT=/tmp/testroot mp-sync
# MP_ROOT=/tmp/testroot mp-install which
```
Another one of these environment options is the `MP_YES` option. By default operations such as
installing packages, updating packages and removing packages will ask you to confirm the operation
using an interactive yes/no prompt. To disable this prompt and confirm all operations by default,
you can set the `MP_YES` environment variable. You can set it to whatever you want, just make sure
it's set.
`MP_NORET` is another option that you can set. By default `mp` will print the return status for each
command, you can disable this by setting `MP_NORET` to whatever you want.
The last one of these options is the `MP_GREP` option. This option is only useful if you are using
the query or the list command. If set, `mp` will print grep-able output for these commands. Again, you can set it
to whatever you want.
### Syncing Repos
To sync remote repo information and package lists, you can use the `mp-sync` command. After running it
`mp` will:
1. Download the repo metadata for all the repos. Repo metadata is located at `REPO_URI/repo`
2. Parse the repo metadata and download all the repo package lists. These lists are located at
`REPO_URI/REPO_NAME.tar.gz`
3. Move and extract the repo lists to `$MP_ROOT/var/lib/mp/repos/REPO_NAME` and parse the plain package lists (`pkgs`)
4. Tell you the repo signatures
You can add these signatures to your public key ring with `gpg`:
```
# gpg --receive-keys [fingerprint]
```
### Installing Packages
To install a package, you can use the `mp-install` command:
```
# mp-install which
```
After running this command, `mp` will:
1. Check all the synced repos for the `which` package
2. Check if the package is already installed
3. Resolve all the dependencies for the `which` package
4. Ask you if you want to continue with the installation
5. Download the `which` package and it's signature from the repo to the `tmpdir`
6. Verify the package using the signature
7. Extract the package to `$MP_ROOT`
8. Run the package install script if it contains one
9. Add an entry for the `which` package to `$MP_ROOT/var/lib/mp/db` and `$MP_ROOT/var/lib/mp/files`
You can also install multiple packages using the `mp-install` command:
```
# mp-install grub systemd linux
```
### Removing/Uninstalling Packages
To remove an installed package, you can use the `mp-remove` command:
```
# mp-remove which
```
After running this command, `mp` will:
1. Check all the installed packages to see if `which` is installed or not
2. Find all the files that `which` package extracted during the installation
3. Ask you if you want to continue with the removal
4. Delete all the files found in the step 2
5. Remove the package entry for the `which` package from `$MP_ROOT/var/lib/mp/db` and `$MP_ROOT/var/lib/mp/files`
You can also remove multiple packages:
```
# mp-remove git curl
```
### Updating Packages
You can update all of the installed packages using the `mp-update` command.
After running this command, `mp` will:
1. Check if all the installed packages are up-to-date
2. Find all the packages that are not up-to-date
3. Ask if you want to continue with the update
4. Act like the `mp-install` command, it will download, verify and install all
the packages, overwriting old files
5. Save new up-to-date package entries to the `$MP_ROOT/var/lib/mp/db` and `$MP_ROOT/var/lib/mp/files`,
overwriting the old entries.
### Searching Packages
You can search for packages in the repos using the `mp-search` command.
For example, this command will return a list of all the packages that contain `lib`
in their name:
```
# mp-search lib
```
After running this command, `mp` will:
1. Check all the repos for any packages that contain `lib` in the name
2. Print the package
3. Print the count of the results
### Querying packages
You can get more information about a package by querying it. For example to get
more information about the `which` package:
```
# mp-query which
```
This will provide the following information about the package:
- Name of the package
- Repo that the package is in
- Description
- Hash (sum)
- Version
- If the package is installed
- If the package is up-to-date
After running this command, `mp` will:
1. Check all the repos for the `which` package
2. Fetch information about the package from the `$MP_ROOT/var/lib/mp/repos/REPO_NAME` and `$MP_ROOT/var/lib/mp/db`.
### List packages
You can list all the installed packages with the `mp-list` command.
After running this command, `mp` will:
1. Load the database (`$MP_ROOT/var/lib/mp/db`)
2. Loop over all the entries and print the package names and the versions
# Other Package Managers
It's a really bad idea to use multiple package managers as they may conflict and may result in an
unstable system. However package managers such as flatpak and snap offer containerized packages,
making them possible to use with other package managers.
- Flatpak will be added to `desktop` repo in the future. Currently the only way to use flatpak is to
install it from the source.
- Snap will never be added to any official repo, so only way to use it is to install it from the source.

0
wiki/pools/pool_guides.json → wiki/pkg/pool_guides.json
View File

20
wiki/pools/pool_guides.md → wiki/pkg/pool_guides.md
View File

@ -1,24 +1,20 @@
Packages in the official MatterLinux pools (should) follow these guidelines:
**Packaged software should be free or/and open source**: Proprietary software won't be included
- **Packaged software should be free or/and open source**: Proprietary software won't be included
to the pools. No exceptions. If you find a proprietary software package in the official pools,
please create an issue or a pull request on the related Git repository to remove the package.
We also prioritize free/libre software over open source software.
**Packaged software should be stable**: Software known to be unstable will not packaged,
- **Packaged software should be stable**: Software known to be unstable will not packaged,
if the stability is related to the version of the software, we may package a different/patched
version of the software.
**Packaged software should be secure**: Outdated software that has critical vulnerabilities
- **Packaged software should be secure**: Outdated software that has critical vulnerabilities
will not be packaged.
**Packaged software should be (somewhat) popular**: No, we are not gonna package some random window
- **Packaged software should be (somewhat) popular**: No, we are not gonna package some random window
manager that only has 3 users and was last updated in 1993.
The following software packages will **NOT** be added, so do not waste your time with pull requests or issues:
The following software packages will **NOT** be added, so do not waste your time with PRs or issues:
- DWM or other Suckless tools that are configured using header files
- Any Wayland only window managers ("compositors"), status bars, terminals etc. We only have weston which used for testing the Wayland environment
- Any Wayland only window managers ("compositors"), status bars, terminals etc. We only have Weston which used for testing the Wayland environment
- Other init systems (`dinit`, `runit` etc.)
- Non-libre Linux kernel
- Non-libre kernel
- Other third-party package managers (apt, dnf, pacman etc.), however containerized package managers can
be packaged, except for snap (I don't like snap)
be packaged (except for snap, f*%#! snap)

2
wiki/pools/pools.json → wiki/pkg/pools.json
View File

@ -2,5 +2,5 @@
"id": "pools",
"title": "Pools",
"author": "ngn",
"date": "04/08/24"
"date": "19/06/24"
}

86
wiki/pools/pools.md → wiki/pkg/pools.md
View File

@ -1,34 +1,5 @@
On this page, you will find information about MatterLinux package pools.
# List
Here is a list of all the official MatterLinux software package pools, you can
find URL(s) for these pools in the [mirrors page](/wiki/mirrors).
### Base
- **Name**: base
- **Signed with**: `F9E70878C2FB389AEC2BA34CA3654DF5AD9F641D`
- **Maintainer**: ngn | [Email](mailto:ngn@ngn.tf) [PGP](https://keys.openpgp.org/pks/lookup?op=get&options=mr&search=0xF9E70878C2FB389AEC2BA34CA3654DF5AD9F641D)
Contains software packages for the core system (for example `glibc`, `grub`),
so you need these packages in order to have a bootable system, however the base
pool alone won't get you further from a simple installation.
### Desktop
- **Name**: desktop
- **Signed with**: `F9E70878C2FB389AEC2BA34CA3654DF5AD9F641D`
- **Maintainer**: ngn | [Email](mailto:ngn@ngn.tf) [PGP](https://keys.openpgp.org/pks/lookup?op=get&options=mr&search=0xF9E70878C2FB389AEC2BA34CA3654DF5AD9F641D)
Contains software packages for your desktop needs (for example `xorg`, `xfce4`),
however they are not necessarily needed for a simple installation.
### Server
- **Name**: desktop
- **Signed with**: `F9E70878C2FB389AEC2BA34CA3654DF5AD9F641D`
- **Maintainer**: ngn | [Email](mailto:ngn@ngn.tf) [PGP](https://keys.openpgp.org/pks/lookup?op=get&options=mr&search=0xF9E70878C2FB389AEC2BA34CA3654DF5AD9F641D)
Contains software packages for your server needs (for example `apache`, `nginx`),
similar to the `desktop` pool, you do not necessarily need these for a simple installation.
# Structure
A pool contains:
@ -38,9 +9,9 @@ A pool contains:
- Package list file (`LIST`)
### Package files and signatures
MatterLinux pools contain at least two packages. Each package also has a PGP signature
MatterLinux pools contain at least two package. Each package also has a PGP signature
that can be used to verify the package. These signatures belong to public key fingerprint
specified in the pool info file.
specified in the pool metadata.
### Pool info file
Pool info file contains information about the pool itself. This information includes
@ -51,7 +22,7 @@ Pool info file contains information about the pool itself. This information incl
This info file can be found in the at the root of the pool. For example the pool info file
for `https://pkgs.matterlinux.xyz/base` is located at `https://pkgs.matterlinux.xyz/base/INFO`.
`.ini` format is used for this file.
`INI` format is used for this file.
### Package list file
A list containing all the package information can be found in an archive file named `LIST`.
@ -122,54 +93,50 @@ MatterLinux releases offer 2 different pools, `base` and `desktop`. There are al
`base` and `desktop` pools (named "next"). URLs for these pools and the mirrors can be found at the [mirrors page](/wiki/mirrors).
These pools can provide packages for users, these packages can be managed using the
[MatterLinux package manager (`matt`)](/wiki/matt).
[MatterLinux package manager (`mp`)](/wiki/mp).
### Building an already existing pool
To build an already existing pool, such as the `base` or the `desktop` pool, first you will need to
download the pool's source. Source for the `base`, `desktop` and `server` pool can be found on [MatterLinux Git Server](https://git.matterlinux.xyz/matter).
download the pool's source. Source for the `base` and the `desktop` pool can be found on [MatterLinux Git Server](https://git.matterlinux.xyz/matter).
After downloading the pool source, you will need to install the `mp-pool` tool, which is the tool
used for building MatterLinux pools. To do so please you can simply install the [`mtsc`](https://git.matterlinux.xyz/matter/mtsc)
package from the `base` pool.
used for building MatterLinux pools. To do so please follow the steps [here](https://git.matterlinux.xyz/Matter/mp-pool#installation).
Finally to build the pool:
```
$ mp-pool <pool dir>
```
You will mostly likely want to disable package signing though, as you are probably don't have the
PGP keys for the official pools:
You will mostly likely want to disable package signing though, as you are probably not the
owner of the pool:
```
$ mp-pool --no-sign <pool dir>
```
### Hosting pools
Unlike most of the package managers, `matt` does not use HTTP, FTP or RSYNC to communicate with the pools. It has it's own
custom protocol named [MPTP](/wiki/libmp). Pools are hosted over this protocol using [pooler](https://git.matterlinux.xyz/matter/pooler).
Unlike most of the package managers, `mp` does not use HTTP, FTP or RSYNC to communicate with the pools. It has it's own
custom protocol named [MPTP](/wiki/mptp). Pools are hosted over this protocol using [pooler](https://git.matterlinux.xyz/matter/pooler).
To host a pool using `pooler`, download and install the `pooler` by following the instructions on the [README](https://git.matterlinux.xyz/matter/pooler). It's also in the `server` pool so you can install it with `matt` as well.
After installing it, you'll need to create/edit the configuration file (`/etc/pooler/config.ini`).
Here is an example configuration file:
To get host a pool using `pooler`, download and install the `pooler` by following the instructions on the [README](https://git.matterlinux.xyz/matter/pooler). It's also in the official pools so you can install it with `mp` as well.
After installing it, you can simply host the pool by running:
```
# address to host the MPTP server on
addr = 0.0.0.0:5858
# pool name
[my-pool]
# pool directory
dir = /srv/my-pool
# pool hostname
host = my-pool.example.com
$ pooler <pool dir>
```
After editing this configuration for your needs, you can run pooler with the configuration file:
This will start the MPTP server on port 0.0.0.0:5858. You can also host multiple pools by specifying them:
```
$ pooler /etc/pooler/config.ini
$ pooler <pool dir 1> <pool dir 2> <pool dir 3>
```
Note that each pool needs to have a unique name for in order to host multiple pools using the same
pooler instance.
If you want to change the service address, you can do so by using the `-h` and the `-p` flag:
```
$ pooler -h 0.0.0.0 -p 5566 <pool dir>
```
You can also specify host names for your pools:
```
$ pooler <pool dir 1>::p1.example.com <pool dir 2>::p2.example.com
```
After running this command, pooler should start hosting your pool over MPTP on port 5858. If you experience
any issues, you should check the error logs.
### Creating a new pool
If you want to create an unofficial pool, setup the directory structure for the source pool as
@ -178,5 +145,6 @@ edit it.
After adding your packages and building them with `mp-pool`, you can host it using pooler.
I suggest you also host them on a HTTP or a FTP server just to make them easier to access.
Doing so will also allow other people to use [`matter-mirror` tool to mirror your pool](/wiki/mirrors).
Also you can add your unofficial pool to this wiki page [by creating an issue](https://git.matterlinux.xyz/Matter/content/issues).

0
wiki/other/releases.json → wiki/pkg/releases.json
View File

25
wiki/other/releases.md → wiki/pkg/releases.md
View File

@ -7,15 +7,13 @@ then you get a new release. So its expected to have a release or once a month.
### Package updates
MatterLinux follows a slow rolling release cycle for all the packages. Packages update every
once in a while, generally to fix security issues. Packages get tested on a development pool,
[next.matterlinux.xyz](https://next.matterlinux.xyz) before they get pushed into the main pools.
once in a while, generally to fix security issues. Packages get tested on a development repo,
[next.matterlinux.xyz](https://next.matterlinux.xyz) before they get pushed into the main repos.
This way we can maintain a stable experience.
### ISOs and release archives
With each release, project releases two new files, an **ISO** and a **Release Archive**:
- **ISO**: A bootable disk image
- **Release Archive**: An archive used during the installation of a release
- ISO: A bootable disk image
- Release Archive: An archive used during the installation of a release
With new release, a new ISO and a release archive will be published. This way
the packages in these ISO and archive files will always be up-to-date.
@ -29,18 +27,17 @@ out the `/etc/os-release` file:
## Version numbering
MatterLinux and all it's projects are version numbered after the year.
For example MatterLinux release for the year 2024 is versioned "*MatterLinux 24*".
For example MatterLinux release for the year 2024 is versioned "MatterLinux 24".
Minor numbers may be added for other releases. For example the 2nd release of the
MatterLinux 24 ISO would be named "*MatterLinux 24.01*".
MatterLinux 24 ISO would be named "MatterLinux 24.01".
Similarly 15th release of the MatterLinux package manager for the year 2024
is versioned "*24.14*".
is versioned "24.14".
## Building releases
You can build an up-to-date ISO and a release archives using [`mtsc`](https://git.matterlinux.xyz/matter/mtsc).
`mtsc` can be found the in the [`base` pool](/wiki/pools), and can be installed using
the [package manager](/wiki/matt).
You can build an up-to-date ISO and a release archives using [MatterLinux tools](https://git.matterlinux.xyz/matter/tools).
These tools also can be installed with the `tools` package.
> **Important**
>
@ -66,8 +63,8 @@ directory to this tool, you can create an ISO image.
As the configuration directory, you can clone the [official ISO configuration](https://git.matterlinux.xyz/Matter/iso).
Or you can use your own custom configuration.
To build the ISO with the release archive that we created on the previous example, using the configuration
directory located at `./iso`:
To build the ISO with the release archive that we created on the previous example, using the configuration directory
located at `./iso`:
```
# matter-iso matterlinux_example-build.tar.gz iso
```

51
wiki/pools/mirrors.md
View File

@ -1,51 +0,0 @@
On this page, you will find information about MatterLinux package mirrors.
# Using different mirrors
To use a mirror with `matt`, change the pool URL for the target pool in your `matt`
configuration file (`/etc/matt/config.ini`).
### Creating a mirror
To create a mirror you can use the [`mirp` tool](https://git.matterlinux.xyz/matter/mirp).
This package can be installed from the [`server` pool](/wiki/pools).
After installing `mirp`, specify an URL and an output directory (files will be downloaded
into the output directory). For example to mirror the `base` pool from `https://stable.matterlinux.xyz/base`
to `base_mirror` directory:
```
$ mkdir base_mirror
$ mirp mptp://stable.matterlinux.xyz/base base_mirror
```
To serve the mirror, you can setup [`pooler`](https://git.matterlinux.xyz/matter/pooler).
To learn more about `pooler`, see the [wiki page for pools](/wikş/pools.md).
You will mostly likely want to update your mirror every once in a while. To do so you can
create a cron job. For example to update your mirror every day at 00:00, you can add the
following entry to your `/etc/crontab`:
```
0 0 * * * <user> mirp <url> <output dir path>
```
# Mirror lists
This section contains information about different MatterLinux pools and mirros
that you can use. To add your mirror to this list get in contact with the maintainer/developers.
> **Note**
>
> Official mirrors are **ALWAYS** signed with the `F9E70878C2FB389AEC2BA34CA3654DF5AD9F641D`
> fingerprint (belongs to the maintainer, ngn). If syncing with a mirror tells you otherwise, then
> **DO NOT USE THAT MIRROR** and report it to the maintainer/developers in order to remove it
> from the list.
### Official pools
| Pool | MPTP | HTTP(S) | Location |
| ---------------- | ---------------------------------------- | ----------------------------------------- | ----------- |
| base (stable) | `mptp://stable.matterlinux.xyz/base` | `https://stable.matterlinux.xyz/base` | 🇹🇷 Turkey |
| desktop (stable) | `mptp://stable.matterlinux.xyz/desktop` | `https://stable.matterlinux.xyz/desktop` | 🇹🇷 Turkey |
| server (stable) | `mptp://stable.matterlinux.xyz/server` | `https://stable.matterlinux.xyz/server` | 🇹🇷 Turkey |
| base (next) | `mptp://next.matterlinux.xyz/base` | `https://next.matterlinux.xyz/base` | 🇹🇷 Turkey |
| desktop (next) | `mptp://next.matterlinux.xyz/desktop` | `https://next.matterlinux.xyz/desktop` | 🇹🇷 Turkey |
| server (next) | `mptp://next.matterlinux.xyz/server` | `https://next.matterlinux.xyz/server` | 🇹🇷 Turkey |
### Mirrors
Currently there are no available mirrors.

6
wiki/tools/confer.json
View File

@ -1,6 +0,0 @@
{
"id": "confer",
"title": "Working with confer",
"author": "ngn",
"date": "14/08/24"
}

6
wiki/tools/libmp.json
View File

@ -1,6 +0,0 @@
{
"id": "libmp",
"title": "Working with libmp",
"author": "ngn",
"date": "14/08/24"
}

1
wiki/tools/libmp.md
View File

@ -1 +0,0 @@
This page is currently under development.

6
wiki/tools/matt.json
View File

@ -1,6 +0,0 @@
{
"id": "matt",
"title": "Working with matt",
"author": "ngn",
"date": "14/08/24"
}

143
wiki/tools/matt.md
View File

@ -1,143 +0,0 @@
Package management is the process of installing, updating and removing software, tools and libraries.
On GNU/Linux systems, package management is usually done with a package manager.
# MatterLinux Package Manager
In a Matter system, package management is generally done with the MatterLinux Package Manager (`matt`).
`matt` lets you install, remove, update and search different MatterLinux packages across different [pools](/wiki/pools).
### Installation
`matt` should be already installed on a MatterLinux system. However if you want to install `matt` from
the source, then you should follow [this section](https://git.matterlinux.xyz/matter/matt#installation)
from the README.
> **Note**
>
> You should run all the `matt` and related commands as the root user.
### Configuration
Configuration file for `matt` can be found at `/etc/matt/config.ini`. This file is used specify pools and
configure general settings.
Here is the configuration shipped with the MatterLinux 24 releases:
```
# configuration file for matt, please see the wiki page for more information
# https://matterlinux.xyz/wiki/matt
tmpdir = /var/lib/matt/temp
datadir = /var/lib/matt/data
[base]
url = mptp://stable.matterlinux.xyz/base
# url = mptp://next.matterlinux.xyz/base
[desktop]
url = mptp://stable.matterlinux.xyz/desktop
# url = mptp://next.matterlinux.xyz/base
# [server]
# url = mptp://stable.matterlinux.xyz/server
# url = mptp://next.matterlinux.xyz/server
```
Lets start by breaking down the first section:
- `tmpdir (path)`: Temporary storage directory. Used for extracting temporary files and usually
this directory will be cleaned after an operation.
- `datadir (path)`: Persistent storage directory. Used for storing package databases and pool
information.
Next sections specify the pools. Section name is the pool name, and it **should match with the
actual pool name**. Pool options are:
- `url (URL)`: Pool URL, only `mptp` protocol is supported.
- `signing (yes/no)`: Enable/disable PGP signature verification for the pool, by default it's enabled.
> **Important**
>
> Do NOT disable signature verification if you don't know what are you doing! There is no
> way to confirm the legitimacy of the packages without signature verification!
### Options
`matt` also has a few other options that you specify as an arguments/parameters. You can list these
options using the `--help` option:
```
# matt --help
```
You can also list options for specific commands, for example:
```
# matt info --help
# matt list --help
```
### Syncing pools
To sync remote pool information and package lists, you can use the `sync` command:
```
# matt sync
```
After syncing remote pools, `matt` will provide public keys for the available pools.
You can add these keys to your keyring with `gpg`:
```
# gpg --receive-keys [fingerprint]
```
### Installing packages
To install a package, you can use the `install` command:
```
# matt install which
```
After running this command `matt` will attempt to find, download and verify the `which`
package, and then install it.
You can also install packages from local archives:
```
# matt install which_2.21.mpf
```
And you can install multiple packages at once:
```
# matt install grub systemd linux
```
### Removing/Uninstalling packages
To remove an installed package, you can use the `remove` command:
```
# matt remove which
```
You can also remove multiple packages:
```
# mp-remove git curl
```
### Updating packages
You can update all of the installed packages using the `update` command:
```
# matt update
```
### Querying packages
You can get more information about a package by querying it. For example to get
more information about the `which` package:
```
# matt info which
```
This will provide the following information about the package:
- Name of the package
- Version
- Description
- Size
- Dependencies
- If the package is installed
- If the package is up-to-date
### List packages
You can list all the installed packages with the `list` command:
```
# matt list
```
# Other package managers
It's a really bad idea to use multiple package managers as they may conflict and may result in an
unstable system. However package managers such as `flatpak` and `snap` offer containerized packages,
making them possible to use with other package managers. However currently none of these package
managers are available in the official pools. If you want to use them, you will need to install them
from the source.