docs(logo): Add MLSysOps logo

Signed-off-by: Anastassios Nanos <ananos@nubificus.co.uk>

Author: ananos

.github/linters/wordlist.txt

@@ -487,3 +487,13 @@ crictl
 codebase
 fullstop
 subdirectory
+TBC
+distros
+Foivos
+Loaiza
+Panagiotis
+Pournaropoulos
+alexanpatr
+marcolo
+panosmaurikos
+

docs/design/index.md

@@ -8,3 +8,4 @@ the design choices and limitations.
 ## Application description and deployment
 
 
+TBC

docs/developer-guide/contribute.md

@@ -4,7 +4,9 @@ title: "Contributing"
 description: "Contributing guidelines"
 ---
 
-Urunc is an open-source project licenced under the [Apache License 2.0](https://github.com/mlsysops-eu/mlsysops-framework/blob/main/LICENSE).
+The MLSysOps framework is an open-source project licensed under the [Apache
+License
+2.0](https://github.com/mlsysops-eu/mlsysops-framework/blob/main/LICENSE).
 We welcome anyone who would be interested in contributing to `MLSysOps framework`.
 As a first step, please take a look at the following document.
 The current document provides a high level overview of `MLSysOps framework`'s code structure, along with a few guidelines regarding contributions to the project.
@@ -21,15 +23,9 @@ The current document provides a high level overview of `MLSysOps framework`'s co
 
 ## Code organization
 
-Urunc is written in Go and we structure the code and other files as follows:
+The MLSysOps framework is structured as follows:
 
-- `/`: The root directory contains the Makefile to build `MLSysOps framework`, along with other non-code files, such as the licence, readme and more.
-- `/docs`: This directory contains all the documentation related to `MLSysOps framework`, such as the installation guide, timestamping and more.
-- `/cmd`: This directory contains handlers for the various command line options of `MLSysOps framework` and the implementation of containerd-shim.
-- `/internal/metrics`: This directory contains the implementation of the metrics logger, which is used for the internal measuring of `MLSysOps framework`'s setup steps.
-- `/pkg`: This directory contains the majority of the code for `MLSysOps framework`. In particular, the subdirectory `/pkg/network/` contains network related code as expected, while the `/pkg/unikontainers/` subdirectory contains the main logic of `MLSysOps framework`, along with the VMM/unikernel related logic.
-
-Therefore, we expect any new documentation related files to be placed under `/docs` and any changes or new files in code to be either in the `/cmd/` or `/pkg/` directory.
+TBC
 
 ## How to contribute
 
@@ -59,8 +55,8 @@ In that context, when opening a new issue regarding a bug, we kindly ask you to:
 
     1. A short description of the bug.
     2. The respective logs both from the output and containerd.
-    3. Urunc's version (either the commit's hash or the version).
-    4. The CPU architecture, VMM and the Unikernel framework used.
+    3. Framework's version manifest (either the commit hash or the version manifest file).
+    4. The execution environment (CPU architecture, VMM etc.).
     5. Any particular steps to reproduce the issue.
 - Keep an eye on the issue for possible questions from the maintainers.
 
@@ -71,10 +67,10 @@ An explanation of the issue
 
 ## System info
 
-- Urunc version:
+- Version:
 - Arch:
 - VMM:
-- Unikernel:
+- ... 
 
 ## Steps to reproduce
 A list of steps that can reproduce the issue.
@@ -117,7 +113,7 @@ In particular, we perform the following workflows tests:
 - Linting of the commit message. Please check the [git commit message style](#git-commit-messages) below for more info.
 - Spell check, since `MLSysOps framework` repository contains its documentation too.
 - License check
-- Code linting for Go.
+- Code linting.
 - Building artifacts for amd64 and aarch64.
 - Unit tests
 - End-to-end tests
@@ -126,7 +122,7 @@ For a better control over the tests and workflows that run in a PR, we define
 three labels which can be used:
 
 - `ok-to-test`: Runs a full CI workflow, meaning all lint tests (commit
-  message, spellcheck, license), Go's linting, building for x86 and aarch64,
+  message, spellcheck, license), Code linting, building for x86 and aarch64,
   unit tests and at last end-to-end tests.
 - `skip-build`: Skips the building workflows along with unit and end-to end tests
   running all the linting tests. This is useful when
@@ -160,23 +156,32 @@ Please follow the below guidelines for your commit messages:
   - *style*: Changes that do not affect the meaning of the code (white-space,
     formatting, missing semi-colons, etc)
   - *refactor*: A code change that neither fixes a bug nor adds a feature
-  - *perf*: A code change that improves performance
+  - *`perf`*: A code change that improves performance
   - *test*: Adding missing tests
   - *build*: Changes that affect the build system or external dependencies
-    (example scopes: gulp, broccoli, npm)
+    (example scopes: gulp, broccoli, `npm`)
   - *ci*: Changes to our CI configuration files and scripts (example scopes:
-    Travis, Circle, BrowserStack, SauceLabs)
+    `Travis`, `Circle`, `BrowserStack`, `SauceLabs`)
   - *chore*: Other changes that don't modify src or test files
   - *revert*: Reverts a previous commit
 - In case the PR is associated with an issue, please refer to it, using the git trailer `Fixes: #Nr_issue`
 - Always sign-off your commit message
 
-### Golang code styde
+Since the MLSysOps framework comprises code written in various programming
+languages we use the following styles for each:
+
+### Golang code style
 
-We follow gofmt's rules on formatting GO code. Therefore, we ask all
+We follow `gofmt`'s rules on formatting GO code. Therefore, we ask all
 contributors to do the same.  Go provides the `gofmt` tool, which can be used
 for formatting your code.
 
+### Python
+TBC 
+
+### C
+TBC
+
 ## Contact
 
 Feel free to contact any of the

docs/developer-guide/development.md

@@ -4,46 +4,11 @@ title: Setup a Dev environment
 Most of the steps are covered in the [installation](../../installation) document.
 Please refer to it for:
 
-- installing a recent version of Go (> 1.20)
-- installing `containerd` and `runc`
-- setting up the devmapper snapshotter
-- installing `nerdctl` and the `CNI` plugins
-- installing the relevant hypervisors
-
-In addition to the above, we strongly suggest to install
-[crictl](https://github.com/kubernetes-sigs/cri-tools/tree/master).
-
-```bash
-$ VERSION="v1.30.0" # check latest version in /releases page
-$ wget https://github.com/kubernetes-sigs/cri-tools/releases/download/$VERSION/crictl-$VERSION-linux-amd64.tar.gz
-$ sudo tar zxvf crictl-$VERSION-linux-amd64.tar.gz -C /usr/local/bin
-$ rm -f crictl-$VERSION-linux-amd64.tar.gz
-```
-
-Since default endpoints for `crictl` are now deprecated, we need to set them up:
-
-```
-$ sudo tee -a /etc/crictl.yaml > /dev/null <<'EOT'
-runtime-endpoint: unix:///run/containerd/containerd.sock
-image-endpoint: unix:///run/containerd/containerd.sock
-timeout: 20
-EOT
-```
+TBC
 
 The next step is to clone and build the `MLSysOps framework`:
 
 ```bash
-$ git clone https://github.com/mlsysops-eu/mlsysops-framework
-$ cd mlsysops-framework
+git clone https://github.com/mlsysops-eu/mlsysops-framework
+cd mlsysops-framework
 ```
-
-At last, please  validate that the dev environment has been set correctly
-by running the:
-
-- unit tests: `make unittest` and
-
-- end-to-end tests: `sudo make e2etest`
-
-> Note: When running `make` commands that will use go (i.e. build,
-> unitest, e2etest) you might need to specify the path to the go binary
-with `sudo GO=$(which go) make`.

docs/developer-guide/maintainers.md

@@ -9,5 +9,8 @@ description: "Maintainers of the `MLSysOps framework`"
 | Name       | GitHub Username | Email   |          Responsibility           |
 | ---------- | --------------- | ------- | --------------------------------- |
 | Anastassios Nanos | [@ananos](https://github.com/ananos) | ananos@nubificus.co.uk | Core Maintainer |
-| Alexandros Patras | [@alexpatras](https://github.com/alexpatras) | patras@uth.gr | Core Maintainer |
+| Panagiotis Mavrikos | [@panosmaurikos](https://github.com/panosmaurikos) | pmavrikos@nubificus.co.uk | Core Maintainer |
+| Alexandros Patras | [@alexanpatr](https://github.com/alexanpatr) | patras@uth.gr | Core Maintainer |
+| Foivos Pournaropoulos | [@Foivos-Pournaropoulos](https://github.com/Foivos-Pournaropoulos) | spournar@uth.gr | Core Maintainer |
+| Marco Loaiza | [@marcolo-30](https://github.com/marcolo-30) | | Core Maintainer |
 | ... | | | |

docs/img/mlsysops-logo.png

@@ -4,24 +4,21 @@ and all required components for executing all supported scenarios.
 We assume a vanilla ubuntu 22.04 environment, although the `MLSysOps framework`
 is able to run on a number of distros.
 
-We will be installing and setting up:
+We will be installing and setting up each component individually:
 
-- git, wget, bc, make, build-essential
-- [runc](https://github.com/opencontainers/runc)
-- [containerd](https://github.com/containerd/containerd/)
-- [nerdctl](https://github.com/containerd/nerdctl)
-- [devmapper](https://docs.docker.com/storage/storagedriver/device-mapper-driver/)
-- [Go 1.24.1](https://go.dev/doc/install)
-- [qemu](https://www.qemu.org/)
-- [firecracker](https://github.com/firecracker-microvm/firecracker)
-- [k3s](https://k3s.sh)
-- [karmada](https://karmada.io)
+### Core Framework
+TBC
 
-Let's go.
+### Plugins
+TBC
 
-> Note: Be aware that some instructions might override existing tools and services.
+### Mechanisms
+TBC
 
 ## Install required dependencies
+TBC
+
+> Note: Be aware that some instructions might override existing tools and services.
 
 The following packages are required to complete the installation. Depending
 on your specific needs, some of them may not be necessary in your use case.

docs/installation.md

@@ -4,154 +4,4 @@ for more detailed installation instructions, or the
 [design](../design#architecture) document for more details regarding
 `MLSysOps`'s architecture.
 
-
-## Using Docker
-
-The easiest and fastest way to try out the `MLSysOps framework` would be with
-`docker` Before doing so, please make sure that the host system satisfies the
-following dependencies:
-
-- [Docker](https://docs.docker.com/engine/install/ubuntu/)
-- [Qemu](https://www.qemu.org/)
-
-### Install Docker
-
-At first we need [docker](https://docs.docker.com/engine/install/ubuntu/).
-
-```bash
-$ curl -fsSL https://get.docker.com -o get-docker.sh
-$ sudo sh get-docker.sh
-$ rm get-docker.sh
-$ sudo groupadd docker # The group might already exist
-$ sudo usermod -aG docker $USER
-```
-
-> Note: Please logout and log back in from the shell, in order to be able to use
-> docker without sudo
-
-#### Install Qemu
-
-Let's make sure that [Qemu](https://www.qemu.org/download/) is installed:
-
-```bash
-$ sudo apt install -y qemu-system
-```
-
-## Using containerd and nerdctl
-
-### Install a high-level container runtime
-
-First step is to install [containerd](https://github.com/containerd/containerd) and
-setup basic functionality (the `CNI` plugins and a snapshotter).
-
-If a tool is already installed, skip to the next step.
-
-#### Install and configure containerd
-
-We will install [containerd](https://github.com/containerd/containerd) from the
-package manager:
-
-```bash
-$ sudo apt install containerd
-```
-
-In this way we will also install `runc`, but not the necessary CNI plugins.
-However, before proceeding to CNI plugins, we will generate the default
-configuration for [containerd](https://github.com/containerd/containerd).
-
-```bash
-$ sudo mkdir -p /etc/containerd/
-$ sudo mv /etc/containerd/config.toml /etc/containerd/config.toml.bak # There might be no configuration
-$ sudo containerd config default | sudo tee /etc/containerd/config.toml
-$ sudo systemctl restart containerd
-```
-
-#### Install CNI plugins
-
-```bash
-$ CNI_VERSION=$(curl -L -s -o /dev/null -w '%{url_effective}' "https://github.com/containernetworking/plugins/releases/latest" | grep -oP "v\d+\.\d+\.\d+" | sed 's/v//')
-$ wget -q https://github.com/containernetworking/plugins/releases/download/v$CNI_VERSION/cni-plugins-linux-$(dpkg --print-architecture)-v$CNI_VERSION.tgz
-$ sudo mkdir -p /opt/cni/bin
-$ sudo tar Cxzvf /opt/cni/bin cni-plugins-linux-$(dpkg --print-architecture)-v$CNI_VERSION.tgz
-$ rm -f cni-plugins-linux-$(dpkg --print-architecture)-v$CNI_VERSION.tgz
-```
-
-#### Setup thinpool devmapper
-
-In order to make use of directly passing the container's snapshot as block
-device in the container, we will need to setup the devmapper snapshotter. We can
-do that by first creating a thinpool, using the respective
-[scripts in `urunc`'s repo](https://github.com/nubificus/urunc/tree/main/script)
-
-```bash
-$ wget -q https://raw.githubusercontent.com/nubificus/urunc/refs/heads/main/script/dm_create.sh
-$ wget -q https://raw.githubusercontent.com/nubificus/urunc/refs/heads/main/script/dm_reload.sh
-$ sudo mkdir -p /usr/local/bin/scripts
-$ sudo mv dm_create.sh /usr/local/bin/scripts/dm_create.sh
-$ sudo mv dm_reload.sh /usr/local/bin/scripts/dm_reload.sh
-$ sudo chmod 755 /usr/local/bin/scripts/dm_create.sh
-$ sudo chmod 755 /usr/local/bin/scripts/dm_reload.sh
-$ sudo /usr/local/bin/scripts/dm_create.sh
-```
-
-> Note: The above instructions will create the thinpool, but in case of reboot,
-> you will need to reload it running the `dm_reload.sh` script. Otherwise
-> check the [installation guide for creating a service](../installation#create-a-service-for-thinpool-reloading). 
-
-At last, we need to modify
-[containerd](https://github.com/containerd/containerd/tree/main) configuration
-for the new demapper snapshotter:
-
-- In containerd v2.x:
-
-```bash
-$ sudo sed -i "/\[plugins\.'io\.containerd\.snapshotter\.v1\.devmapper'\]/,/^$/d" /etc/containerd/config.toml
-$ sudo tee -a /etc/containerd/config.toml > /dev/null <<'EOT'
-
-# Customizations for devmapper
-
-[plugins.'io.containerd.snapshotter.v1.devmapper']
-  pool_name = "containerd-pool"
-  root_path = "/var/lib/containerd/io.containerd.snapshotter.v1.devmapper"
-  base_image_size = "10GB"
-  discard_blocks = true
-  fs_type = "ext2"
-EOT
-$ sudo systemctl restart containerd
-```
-
-- In containerd v1.x:
-
-```bash
-$ sudo sed -i '/\[plugins\."io\.containerd\.snapshotter\.v1\.devmapper"\]/,/^$/d' /etc/containerd/config.toml
-$ sudo tee -a /etc/containerd/config.toml > /dev/null <<'EOT'
-
-# Customizations for devmapper
-
-[plugins."io.containerd.snapshotter.v1.devmapper"]
-  pool_name = "containerd-pool"
-  root_path = "/var/lib/containerd/io.containerd.snapshotter.v1.devmapper"
-  base_image_size = "10GB"
-  discard_blocks = true
-  fs_type = "ext2"
-EOT
-$ sudo systemctl restart containerd
-```
-
-Let's verify that the new snapshotter is properly configured:
-
-```bash
-$ sudo ctr plugin ls | grep devmapper
-io.containerd.snapshotter.v1           devmapper                linux/amd64    ok
-```
-
-### Install nerdctl
-
-After installing [containerd](https://github.com/containerd/containerd) a nifty tool like [nerdctl](https://github.com/containerd/nerdctl/) is useful to get a realistic experience.
-
-```bash
-$ NERDCTL_VERSION=$(curl -L -s -o /dev/null -w '%{url_effective}' "https://github.com/containerd/nerdctl/releases/latest" | grep -oP "v\d+\.\d+\.\d+" | sed 's/v//')
-$ wget -q https://github.com/containerd/nerdctl/releases/download/v$NERDCTL_VERSION/nerdctl-$NERDCTL_VERSION-linux-$(dpkg --print-architecture).tar.gz
-$ sudo tar Cxzvf /usr/local/bin nerdctl-$NERDCTL_VERSION-linux-$(dpkg --print-architecture).tar.gz
-$ rm -f nerdctl-$NERDCTL_VERSION-linux-$(dpkg --print-architecture).tar.gz
-```
+``