init.sh: Refactor image version handling in the build script

- Introduced DEFAULT_IMAGE_VERSION and COMPATIBLE_IMAGE_VERSIONS for
  flexible version management.
- Mapped multiple compatible versions to a single configuration block
  to avoid duplication.
- Ensured IMAGE_VERSION adjusts dynamically based on user input,
  with validation against COMPATIBLE_IMAGE_VERSIONS.
- Streamlined environment variable naming and organized source
  layer configuration.
- Added conditional execution for Python2 layer fetching based on the
  presence of PYTHON2_SRCREV.

This commit improves the script's maintainability and robustness by clarifying version management and optimizing configuration handling.

README-de.md

@@ -1,213 +1,355 @@
-# Schnellstart Image-Erstellung #
+Dieses Skript dient als Werkzeug zur Vereinfachung der Erstellung einer Umgebung für Entwicklung und des Build-Prozesses für Images die mit Neutrino als Benutzeroberfläche auf unterschiedlichen Hardware-Plattformen laufen. Es automatisiert einige Schritte, die für die Einrichtung einer konsistenten und funktionalen Entwicklungs- und Build-Umgebung erforderlich sind, indem es die notwendigen Abhängigkeiten und grundlegende Konfigurationen sowie Meta-Layer  voreinrichtet und benutzerdefinierte Einstellungen ermöglicht. Das Skript zielt darauf ab, eine Grundlage zu bieten, auf der man aufbauen und experimentieren kann, um eigene angepasste Versionen von Tuxbox-Neutrino Images zu erstellen, zu aktualisieren und zu pflegen.
 
-- [Vorbereitung](#Vorbereitung)
+- [1. Vorbereitung](#1-vorbereitung)
-- [Image bauen](#Image-bauen)
+	- [1.1 Erforderliche Host-Pakete installieren](#11-erforderliche-host-pakete-installieren)
-- [Aktualisierung](#Aktualisierung)
+		- [1.1.1 Empfohlene Zusatzpakete zur grafischen Unterstützung und Analyse](#111-empfohlene-zusatzpakete-zur-grafischen-unterstützung-und-analyse)
-- [Arbeiten an Zielquellen](#Arbeiten-an-Zielquellen)
+	- [1.2 Git vorbereiten (falls erforderlich)](#12-git-vorbereiten-falls-erforderlich)
-- [Übersicht über globale Konfigurationsdateien](#Übersicht-über-globale-Konfigurationsdateien)
+	- [1.3 Init-Skript klonen](#13-init-skript-klonen)
+	- [1.4 Init-Skript ausführen](#14-init-skript-ausführen)
+	- [1.5 Struktur der Buildumgebung](#15-struktur-der-buildumgebung)
+- [2. Image bauen](#2-image-bauen)
+	- [2.1 Box wählen](#21-box-wählen)
+	- [2.2 Starte Umgebungsskript](#22-starte-umgebungsskript)
+	- [2.3 Image erstellen](#23-image-erstellen)
+- [3. Aktualisierung](#3-aktualisierung)
+	- [3.1 Image aktualisieren](#31-image-aktualisieren)
+	- [3.2 Paket aktualisieren](#32-paket-aktualisieren)
+	- [3.3 Meta-Layer-Repositorys aktualisieren](#33-meta-layer-repositorys-aktualisieren)
+- [4. Eigene Anpassungen](#4-eigene-anpassungen)
+	- [4.1 Konfiguration](#41-konfiguration)
+		- [4.1.1 Konfigurationsdateien](#411-konfigurationsdateien)
+		- [4.1.2 bblayers.conf](#412-bblayersconf)
+		- [4.1.3 Konfiguration zurücksetzen](#413-konfiguration-zurücksetzen)
+	- [4.3 Recipes](#43-recipes)
+	- [4.4 Pakete](#44-pakete)
+		- [4.4.1 Quellcode im Workspace bearbeiten (Beispiel)](#441-quellcode-im-workspace-bearbeiten-beispiel)
+- [5. Neubau eines einzelnen Pakets erzwingen](#5-neubau-eines-einzelnen-pakets-erzwingen)
+- [6. Vollständigen Imagebau erzwingen](#6-vollständigen-imagebau-erzwingen)
+- [7. Lizenz](#7-lizenz)
+- [8. Weiterführende Informationen](#8-weiterführende-informationen)
 
-## Vorbereitung
+## 1. Vorbereitung
 
-### Erforderliche Host-Pakete installieren (Debian 11)
+Hier angegebene Pfade basieren auf Vorgaben, die vom Init-Script erzeugt werden. Einige Einträge werden als ```<Platzhalter>``` dargestellt, die lokal angepasst werden müssen. [Siehe Schema](#14-init-skript-ausführen)
-Zur Verwendung mit anderen Distributionen siehe: [Yocto Project Quick Build](https://docs.yoctoproject.org/3.2.4/ref-manual/ref-system-requirements.html#supported-linux-distributions)
 
-> :memo: **HINWEIS:** Bei Verwendung der Tuxbox-Builder-VM (welche nicht zwingend erforderlich ist), springe bitte zu [Schritt 1](#1-Init-Skript-klonen). Die Tuxbox-Builder-VM enthält bereits erforderliche Pakete. Details und Download von Tuxbox-Builder VM siehe: [Tuxbox-Builder](https://sourceforge.net/projects/n4k/files/Tuxbox-Builder)
+**HINWEIS:** Die Wartung der Tuxbox-Builder-VM wird nicht mehr weitergeführt. Falls die VM-Lösung trotzdem verwendet werden soll, springe bitte zu [Schritt 2](#2-image-bauen). Die Tuxbox-Builder-VM enthält normalerweise bereits erforderliche Pakete.
+
+Details und Download: [Tuxbox-Builder](https://sourceforge.net/projects/n4k/files/Tuxbox-Builder)
+
+### 1.1 Erforderliche Host-Pakete installieren
+
+**Hinweis:** Bei Verwendung anderer Distributionen siehe: [Yocto Project Quick Build](https://docs.yoctoproject.org/3.2.4/ref-manual/ref-system-requirements.html#supported-linux-distributions)
+
+Debian 11
 
 ```bash
-apt-get install -y gawk wget git-core diffstat unzip texinfo gcc-multilib build-essential \
+sudo apt-get install -y gawk wget git-core diffstat unzip texinfo gcc-multilib build-essential \
 chrpath socat cpio python python3 python3-pip python3-pexpect xz-utils debianutils \
 iputils-ping python3-git python3-jinja2 libegl1-mesa pylint3 xterm subversion locales-all \
 libxml2-utils ninja-build default-jre clisp libcapstone4 libsdl2-dev doxygen
 ```
-> :memo: **HINWEIS:** Bei Debian 10 (buster) libcapstone3 verwenden.
 
-#### Empfohlene Zusatzpakete zur grafischen Unterstützung und Analyse (z.B. mit Kdevelop, Meld):
+**HINWEIS:** Bei Debian 10 (buster) libcapstone3 verwenden.
+
+#### 1.1.1 Empfohlene Zusatzpakete zur grafischen Unterstützung und Analyse
+
 ```bash
-apt-get install -y gitk git-gui meld cppcheck clazy kdevelop
+sudo apt-get install -y gitk git-gui meld cppcheck clazy kdevelop
 ```
 
-### Optional: Falls kein konfiguriertes Git vorhanden ist, gib bitte Deine globalen Git-Benutzerdaten ein:
+### 1.2 Git vorbereiten (falls erforderlich)
+
+Das init-Script verwendet Git zum Klonen der Meta-Layer Repositorys. Wenn noch kein konfiguriertes Git vorhanden ist, lege bitte Deine globalen Git-Benutzerdaten an, andernfalls wird während das Script durchläuft, unnötig darauf hingewiesen. 
+
 ```bash
 git config --global user.email "you@example.com"
-git config --global user.user "Dein Name"
+git config --global user.name "Dein Name"
 ```
 
-## Image bauen
+### 1.3 Init-Skript klonen
 
-> :memo: **Hinweis:** Einige Pfade basieren auf Vorgaben, die vom Init-Script erzeugt werden. Einige Einträge werden als ```<Platzhalter>``` dargestellt, die entsprechend angepasst werden müssen.
-
-> ### 1. Init-Skript klonen.
 ```bash
-git clone https://github.com/tuxbox-neutrino/buildenv.git
+git clone https://github.com/tuxbox-neutrino/buildenv.git && cd buildenv
-cd buildenv
 ```
 
-> ### 2. Init-Skript ausführen
+### 1.4 Init-Skript ausführen
+
 ```bash
-./init
+./init && cd poky-3.2.4
-cd poky-3.2.4
 ```
 
-> ### 3. Liste möglicher Maschinentypen anzeigen
+### 1.5 Struktur der Buildumgebung
+
+Nach [Schritt 1.4](#14-init-skript-ausführen) sollte etwa diese Struktur angelegt worden sein:
+
+```
+.buildenv
+ ├── dist                          <-- Freigabeordner für http-Server (falls eingerichtet) http://localhost, http://localhost:8080 , benötigt für IPK-Feeds und Images
+ │   └── {DISTRO_VERSION}          <-- hier liegen die erzeugten Images und Pakete (Symlinks zeigen auf die Deploy-Verzeichnisse innerhalb der Build-Unterverzeichnisse)
+ :
+ ├── init.sh                       <-- init-Script
+ ├── local.conf.common.inc         <-- globale Benutzerkonfiguration, ist in die benutzerdefinierte Konfiguration inkluiert
+ :
+ ├── log                           <-- Ordner für Logs, enthält Logs für jede Ausführung des Init-Scripts
+ :
+ └── poky-{DISTRO_VERSION}         <-- Nach Schritt 1.4 befindest Du dich hier. Hier befindet sich der Buildsystem-Kern und die Meta-Layer
+     │
+     :
+     └── build                     <-- Hier liegen die Build-Unterverzeichnisse, nach Schritt 2.2 befindest Du dich in einem dieser Build-Unterverzeichnisse
+         ├── <machine x>           <-- Build-Unterverzeichnis für Maschinentyp x
+         │   ├── conf              <-- Ordner für Layer und benutzerdefinierte Konfiguration
+         │   │   └── bblayers.conf <-- Konfigurationsdatei für eingebundene Meta-Layer
+         │   │   └── local.conf    <-- benutzerdefinierte Konfiguration für einen Maschinentyp
+		 │   :
+         │   ├── (tmp)             <-- Arbeitsverzeichnis, wird beim Bauen automatisch angelegt
+         │   └── (workspace)       <-- Workspace, wird beim Ausführen von devtool angelegt
+         :
+         └── <machine y>           <-- weiteres Build-Unterverzeichnis für Maschinentyp y
+```
+ 
+## 2. Image bauen
+
+Stelle sicher, dass Du dich wie im [Schema](#15-struktur-der-buildumgebung) gezeigt hier befindest:
+
+```
+poky-{DISTRO_VERSION}
+```
+
+### 2.1 Box wählen
+
+Liste verfügbarer Geräte anzeigen lassen:
+
 ```bash
 ls  build
 ```
 
-> ### 4. Umgebungsskript ausführen
+### 2.2 Starte Umgebungsskript
+
+Führe das Umgebungsskript für die aus der Liste gewünschte Box einmalig aus! Du gelangst dann automatisch in das passende Build-Unterverzeichnis.
+
 ```bash
-. ./oe-init-build-env build/<Machine-Type aus der Liste von Schritt 3 hier eintragen>
+. ./oe-init-build-env build/<machine>
 ```
 
-> ### 5. Bauen
+Solange man sich ab jetzt mit der erzeugten Umgebung innerhalb der geöffneten Shell im gewünschten Build-Unterverzeichnis befindet, muss man dieses Script nicht noch einmal ausführen und kannst [Schritt 2.3 ](#23-image-erstellen) Images oder beliebige Pakete bauen.
+
+**Hinweis:** Du kannst auch weitere Shells und damit Buildumgebungen für weitere Boxtypen parallel dazu anlegen und je nach Bedarf auf das entsprechende Terminal wechseln und auch parallel bauen lassen, sofern es dein System hergibt.
+
+### 2.3 Image erstellen
+
 ```bash
 bitbake neutrino-image
 ```
 
-Das kann eine Weile dauern. Einige Warnmeldungen können ignoriert werden. Fehlermeldungen, welche die Setscene-Tasks betreffen, sind kein Problem, aber Fehler während der Build- und Package-Tasks brechen den Prozess in den meißten Fällen ab.  [Bitte melde in diesem Fall den Fehler oder sende Deine Lösung an uns](https://forum.tuxbox-neutrino.org/forum/viewforum.php?f=77). Hilfe ist sehr willkommen.
+Das kann eine Weile dauern. Einige Warnmeldungen können ignoriert werden. Fehlermeldungen, welche die Setscene-Tasks betreffen, sind kein Problem, aber Fehler während der Build- und Package-Tasks brechen den Prozess in den meisten Fällen ab.  [Bitte melde in diesem Fall den Fehler oder teile Deine Lösung](https://forum.tuxbox-neutrino.org/forum/viewforum.php?f=77). Hilfe ist sehr willkommen.
 
 Wenn alles erledigt ist, sollte eine ähnliche Meldung wie diese erscheinen:
+
 ```bash
-...
+"NOTE: Tasks Summary: Attempted 4568 tasks of which 4198 didn't need to be rerun and all succeeded."
-NOTE: Tasks Summary: Attempted 4568 tasks of which 4198 didn't need to be rerun and all succeeded.
-...
-```
-**Das war's ...**
-
-Erstellte Images und Pakete sind zu finden unter:
-```
-~/build/poky-3.2.4/build/<machine>/tmp/deploy
-```
-oder im dist-Verzeichnis:
-```
-~/build/dist/<Image-Version>/<machine>/
 ```
 
-## Aktualisierung
+<span style="color: green;">Das war's ...</span>
-> :memo: Manuelle Aktualisierungen für beliebeige Ziel-Quellen sind nicht erforderlich. Dies wird automatisch bei jedem aufgerufenen Ziel mit Bitbake durchgeführt. Dadurch werden auch immer erforderliche Abhängigkeiten aktualisiert. Wenn man die volle Kontrolle über bestimmte Ziel-Quellen haben möchte,  siehe [Arbeiten an Zielquellen](#Arbeiten-an-Zielquellen)!
 
-Falls [Schritte 1 bis 4](#3-Liste-möglicher-Maschinentypen-anzeigen) bereits ausgeführt wurden, ist nur Schritt 5 erforderlich:
 
-### Update Image
+Ergebnisse findest Du unter:
+
+```bash
+buildenv/poky-{DISTRO_VERSION}/build/<machine>/tmp/deploy
+```
+
+oder im Freigabe-Verzeichnis:
+
+```bash
+buildenv/dist/<Image-Version>/<machine>/
+```
+
+Falls ein Webserver eingerichtet ist, der auf das Freigabe-Verzeichnis zeigt:
+
+```bash
+http://localhost/{DISTRO_VERSION} oder mit Portnummer http://localhost:8080/{DISTRO_VERSION}
+```
+
+## 3. Aktualisierung
+
+Manuelle Aktualisierungen der Pakete sind nicht erforderlich. Dies wird automatisch bei jedem aufgerufenen Target mit Bitbake durchgeführt. Das gilt auch für mögliche Abhängigkeiten. Wenn man die volle Kontrolle über bestimmte Paket-Quellen haben möchte, kann man sich diese für jedes Paket im dafür vorgesehenen Workspace ablegen, siehe [4.4 Pakete](#44-pakete).
+Sollten keine Aktualisierungen notwendig sein, werden die Builds automatisch übersprungen.
+
+### 3.1 Image aktualisieren
+
 ```bash
 bitbake neutrino-image
 ```
 	
-### Update Ziel
+### 3.2 Paket aktualisieren
+
 ```bash
-bitbake <target>
+bitbake <package>
 ```
 
-### Meta-Layer-Repositories aktualisieren
+### 3.3 Meta-Layer-Repositorys aktualisieren
-Die erneute Ausführung des Init-Skripts aktualisiert die enthaltenen Meta-Layer auf den Stand der Remote-Repositories. 
+
+Die Ausführung des Init-Skripts mit dem ```--update``` Parameter aktualisiert die enthaltenen Meta-Layer auf den Stand der Remote-Repositorys.
+
 ```bash
-cd $HOME/build
+./init --update
-./init
+```
-```	
-Die angestoßenen Update-Routinen des Init-scripts sollten nicht festgeschriebene Änderungen vorübergehend stashen bzw. rebasen lokale Commits auf die Remote-Änderungen. Konflikte muss man jedoch manuell auflösen. Natürlich kann man seine lokalen Meta-Layer für Meta-Neutrino- und Maschinen-Layer-Repositories manuell aktualisieren und modifizieren. 
 
-> :memo: **Hinweis:** Konfigurationsdateien bleiben unberührt. Neue oder geänderte Konfigurationsoptionen werden nicht berücksichtigt. Bitte überprüfe ggf. die Konfiguration.
+Falls Du an den Meta-Layern Änderungen vorgenommen hast, sollten angestoßene Update-Routinen des Init-scripts nicht festgeschriebene Änderungen vorübergehend stashen bzw. auf das lokale Repository rebasen. Natürlich kann man seine lokalen Meta-Layer für Meta-Neutrino- und Maschinen-Layer-Repositorys manuell aktualisieren. Konflikte muss man jedoch immer manuell auflösen. 
 
-## Arbeiten an Zielquellen
+**Hinweis:** Konfigurationsdateien bleiben im Wesentlichen unberührt, aber mögliche Variablennamen werden migriert. Neue oder geänderte Einstellungen werden nicht geändert. Bitte überprüfe evtl. die Konfiguration.
-Wenn man die volle Kontrolle über die Ziel-Quellen haben möchte, sollten die Quellcodes in den Workspace verschoben werden. Siehe 
-[devtool](https://docs.yoctoproject.org/current/ref-manual/devtool-reference.html) und insbesondere [devtool modify](https://docs.yoctoproject.org/current/ref-manual/devtool-reference.html#modifying-an-existing-recipe).
 
-## Konfiguration zurücksetzen
+## 4. Eigene Anpassungen
+
+### 4.1 Konfiguration
+
+Es wird empfohlen, zum ersten Mal ohne geänderte Konfigurationsdateien zu bauen, um einen Eindruck davon zu bekommen, wie der Build-Prozess funktioniert und um die Ergebnisse möglichst schnell zu sehen.
+Die Einstellmöglichkeiten sind sehr umfangreich und für Einsteiger nicht wirklich überschaubar. OpenEmbedded insbesondere das Yocto-Project ist jedoch sehr
+umfassend dokumentiert und bietet die beste Informationsquelle.
+
+#### 4.1.1 Konfigurationsdateien
+
+> ~/buildenv/poky-3.2.4/build/```<machine>```/conf/local.conf
+
+Diese Datei befindet sich im Buildverzeichnis des jeweiligen Maschinentyps und ist die eigentliche benutzerdefinierte Konfigurationsdatei, welche ursprünglich vom Buildsystem dafür vorgesehen ist. Diese local.conf enthält in dieser Umgebung jedoch nur nur wenige Zeilen und inkludiert eine globale Konfiguration. Diese Datei ist **nur** für den von ihr unterstützten Maschinentyp gültig. Hier kann man deshalb ergänzende Einträge vornhemen, die entsprechend nur für den Maschinentyp vorgesehen sind. [Siehe auch Schema](#14-init-skript-ausführen)
+
+> ~/buildenv/local.conf.common.inc
+
+Diese Datei enthält Einstellungen, die für alle  Maschinentypen zutreffen und wird bei erstmaligen ausführen des Init-Scripts aus der Vorlage ```~/buildenv/local.conf.common.inc.sample``` erzeugt.
+
+Die vom Buildsystem vorgesehene ```./build/<machine>/conf/local.conf``` könnte man zwar so wie es ursprügliche vom Buildsystem vorgesehen ist als primäre Konfigurationsdatei für jeden Maschinentyp separat verwenden, aber das würde den Wartungsaufwand unnötig erhöhen. Deshalb ist ```~/buildenv/local.conf.common.inc``` nur in ```./build/<machine>/conf/local.conf``` inkludiert, 
+
+**Hinweis zu** ```~/buildenv/local.conf.common.inc.sample```**:**  Dies ist nur eine Vorlage und sollte unberührt bleiben, um mögliche Konflikte beim Aktualisieren des Build-Script-Repositorys zu vermeiden und um zu sehen, was sich geändert haben könnte.
+
+Nach einer Aktualisierung des Build-Script-Repositorys könnten neue oder geänderte Optionen hinzugefügt oder entfernt worden sein, die nicht in die inkludierte Konfigurationsdatei übernommen werden. Diesen Fall sollte man in der eigenen Konfiguration berücksichtigen und falls erforderlich prüfen und anpassen.
+
+#### 4.1.2 bblayers.conf
+
+> ~/buildenv/poky-3.2.4/build/```<machine>```/conf/bblayers.conf
+
+Diese Datei wird normalerweise beim erstmaligen ausführen des Init-Skripts angepasst und braucht in der Regel nur angepasst zu werden, wenn man Layer hinzufügen, entfernen oder ersetzen möchte.
+
+#### 4.1.3 Konfiguration zurücksetzen
 Wenn Du deine Maschinen-Konfigurationen zurücksetzen möchtest, benenne bitte das conf-Verzeichnis um (Löschen wird nicht empfohlen) und führe das Init-Skript erneut aus.
+
+
 ```bash
-mv $HOME/build/poky-3.2.4/build/<machine>/conf $HOME/build/poky-3.2.4/build/<machine>/conf.01
+~/mv ~/buildenv/poky-3.2.4/build/<machine>/conf ~/buildenv/poky-3.2.4/build/<machine>/conf.01
-cd $HOME/build
+~/cd ~/buildenv
-./init
+~/./init
 ```
+
+### 4.3 Recipes
 	
-## Neubau eines einzelnen Ziels erzwingen
+**Sofern man nicht direkt an der Entwicklung der Poky-Ebenen beiteiligt ist, ändere nichts an den offiziellen Poky-Ebenen (Meta-Layer)! Dies wird vom Yocto-Projekt ausdrücklich nicht empfohlen, da man Gefahr läuft, bei Aktualisierungen, seine gesamte Arbeit zu verlieren und Inkompatibilitäten oder Konflikte schafft, die nur schwer zu warten sein können. Die übliche Vorgehensweise, um vorhandene offizielle Rezepte zu vervollständigen, zu erweitern oder zu überschreiben, ist die [Verwendung von .bbappend](https://docs.yoctoproject.org/3.2.4/dev-manual/dev-manual-common-tasks.html#using-bbappend-files-in-your-layer)-Dateien.** 
-In einigen Fällen kann es vorkommen, dass ein Target, warum auch immer, abbricht. Man sollte deswegen nicht in Panik verfallen und deswegen den tmp-Ordner und den sstate-cache löschen. Das kann man auch für jedes Target einzeln machen.
 
-> :memo: Insbesondere defekte Archiv-URL's können zum Abbruch führen. Diese Fehler werden aber immer angezeigt und man kann die URL überprüfen. Oft liegt es nur an den Servern und funktioneren nach wenigen Minuten sogar wieder.
+Alternativ, allerdings auch nicht wirklich empfehlenswert, könnte man Kopien von offiziellen Reciepes in seine eigenen Meta-Layer übernehmen und anpassen, da diese dann in der Regel vom Buildsystem bevorzugt werden. In solch einem Fall ist man allerdings selbst dafür verantwortlich, diese Recipes aktuell zu halten, was den Wartungsaufwand allerdings unnötig erhöhen kann. 
+
+Für Rezepte aus den eigenen Meta-Layern wie z.B. meta-neutrino oder den Maschinen-Layern, gilt das prinzipiell genauso. Wer aber [aktiv an den Recipes mitarbeiten](https://docs.yoctoproject.org/current/ref-manual/devtool-reference.html#modifying-an-existing-recipe) möchte, kann dies gerne tun.
+
+### 4.4 Pakete
+
+Wenn man die volle Kontrolle über einen Paket-Quellcode haben möchte, um z.B. etwas zu fixen oder aktiv zu entwickeln, sollte der Quellcode an dem man arbeiten möchte in den Workspace verschoben werden. Siehe: [Beispiel für Neutrino](#441-quellcode-im-workspace-bearbeiten-beispiel)
+
+Siehe [devtool](https://docs.yoctoproject.org/current/ref-manual/devtool-reference.html) und insbesondere [devtool modify](https://docs.yoctoproject.org/current/ref-manual/devtool-reference.html#modifying-an-existing-recipe). Im Workspace hat man die Garantie, dass der Quellcode nicht vom Buildsystem angefasst wird. Beachtet man das nicht, kann es z.B. vorkommen, dass geänderter Quellcode immer wieder gelöscht oder modifiziert wird. Eigene Anpassungen können daher verloren gehen oder inkompatibel werden. In der lokalen Standardkonfiguration ist [rm_work](https://docs.yoctoproject.org/ref-manual/classes.html#ref-classes-rm-work) aktiviert, was dafür sorgt, dass nach jedem abgeschlossenem Bau eines Pakets, das jeweilige Arbeitsverzeichnis aufgeräumt wird, so dass ausser einigen Logs nichts übrig bleiben wird.
+
+#### 4.4.1 Quellcode im Workspace bearbeiten (Beispiel)
+
+Hier wird beispielhaft Neutrino verwendet, aber diese Vorgehensweise trifft im Wesentlichen auf alle anderen Pakete zu.
+
+```bash
+~/buildenv/poky-3.2.4/build/hd61$ devtool modify neutrino
+NOTE: Starting bitbake server...54cf81d24c147d888c"
+...
+workspace            = "3.2.4:13143ea85a1ab7703825c0673128c05845b96cb5"
+
+Initialising tasks: 100% |###################################################################################################################################################################################################| Time: 0:00:01
+Sstate summary: Wanted 0 Found 0 Missed 0 Current 10 (0% match, 100% complete)
+NOTE: Executing Tasks
+NOTE: Tasks Summary: Attempted 83 tasks of which 80 didn't need to be rerun and all succeeded.
+INFO: Adding local source files to srctree...
+INFO: Source tree extracted to /home/<user>/buildenv/poky-3.2.4/build/hd61/workspace/sources/neutrino
+INFO: Recipe neutrino-mp now set up to build from /home/<user>/buildenv/poky-3.2.4/build/hd61/workspace/sources/neutrino
+```
+
+Unter ```/buildenv/poky-3.2.4/build/hd61/workspace/sources/neutrino``` befindet sich jetzt der Quellcode für Neutrino. Dort kann man dann daran arbeiten. Das bedeutet, dass das Buildsystem nicht mehr von sich aus vom Remote Git-Repo die Neutrino-Quellen klont bzw. automatisch aktalisiert, sondern ab jetzt nur noch die lokalen Quellen innerhalb des Workspace nutzt, die man selbst verwalten muss. Dabei handelt es sich um ein von devtool angelegtes Git-Repo, in welches man an das Original-Remote-Repository einbinden kann, sofern dies nicht bereits der Fall ist.
+
+Führt man jetzt das aus...
+
+```bash
+bitbake neutrino
+```
+
+...wird Neutrino ab sofort nur noch vom lokalen Repo im Workspace gebaut werden:
+
+
+```bash
+NOTE: Started PRServer with DBfile: /home/<user>/buildenv/poky-3.2.4/build/hd61/cache/prserv.sqlite3, IP: 127.0.0.1, PORT: 34211, PID: 56838
+...
+workspace            = "3.2.4:13143ea85a1ab7703825c0673128c05845b96cb5"
+
+Initialising tasks: 100% |###################################################################################################################################################################################################| Time: 0:00:01
+Sstate summary: Wanted 122 Found 116 Missed 6 Current 818 (95% match, 99% complete)
+NOTE: Executing Tasks
+NOTE: neutrino-mp: compiling from external source tree /home/<user>/buildenv/poky-3.2.4/build/hd61/workspace/sources/neutrino
+NOTE: Tasks Summary: Attempted 2756 tasks of which 2741 didn't need to be rerun and all succeeded.
+```
+
+**Hinweis!** Im speziellen Fall von Neutrino, ist es ratsam nicht nur dessen Quellcode, sondern auch die zugehörige ```libstb-hal``` in den Workspace zu übertragen.
+
+```bash
+devtool modify libstb-hal
+```
+
+## 5. Neubau eines einzelnen Pakets erzwingen
+
+In einigen Fällen kann es vorkommen, dass ein Target, warum auch immer, abbricht. Man sollte deshalb aber keinesfalls in Panik verfallen und deswegen den Arbeitsordner und den teueren sstate-cache löschen. Bereinigungen kann man für jedes Target einzeln vornehmen, ohne ein ansonsten funktionierendes System platt zu machen.
+
+Insbesondere defekte Archiv-URLs können zum Abbruch führen. Diese Fehler werden aber immer angezeigt und man kann die URL überprüfen. Oft liegt es nur an den Servern und funktionieren nach wenigen Minuten sogar wieder.
+
+Um sicherzustellen, ob das betreffende Recipe auch tatsächlich ein Problem hat, macht es Sinn das betreffende Target komplett zu bereinigen und neu zu bauen. Um dies zu erreichen, müssen alle zugehörigen Paket-, Build- und Cachedaten bereinigt werden.
 
-Um sicherzustellen, ob das betreffende Recipe auch tatsächlich ein Problem hat, macht es Sinn das betreffende Target komplett zu bereinigen und neu zu bauen. Um dies zu erzwingen, müssen alle erzeugten Paket-, Build- und Cachedaten bereinigt werden.
 ```bash
 bitbake -c cleansstate <target>
+
 ```
 anschließend neu bauen:
+
 ```bash
 bitbake <target>
 ```
 	
-## Vollständigen Imagebau erzwingen
+## 6. Vollständigen Imagebau erzwingen
-Wenn Du einen kompletten Imagebau erzwingen möchtest, kann man das tmp-Verzeichnis löschen (oder umbenennen):
+
+Das Init-Skript stellt dafür die Option `--reset` zur Verfügung.
+
+```bash
+./init --reset
+# Anweisungen befolgen
+```
+
+Manuell erreichst Du das ebenfalls, indem man das tmp-Verzeichnis im jeweiligem Build-Unterverzeichnis manuell umbenennt. Löschen kann man es nachträglich, wenn man Speicherplatz freigeben will oder sich sicher ist, dass man das Verzeichnis nicht mehr braucht:
+
 ```bash
 mv tmp tmp.01
+```
+
+Anschließend das Image neu bauen lassen:
+
+```bash
 bitbake neutrino-image
 ```
-Wenn man den sstate-cache **nicht** gelöscht hat, sollte das Image in relativ kurzer Zeit fertig gebaut sein. Daher wird empfohlen, den sstate-cache beizubehalten. Das Verzeichnis wo sich der sstate-cache befindet, wird über die Variable ```${SSTATE_DIR}``` festgelegt und kann in der Konfiguration angepasst werden. 
+
+Wenn man den Cache **nicht** gelöscht hat, sollte das Image in relativ kurzer Zeit fertig gebaut sein. Gerade deshalb wird empfohlen, den Cache beizubehalten. Das Verzeichnis wo sich der Cache befindet, wird über die Variable ```${SSTATE_DIR}``` festgelegt und kann in der Konfiguration angepasst werden. 
 	
-Dieses Verzeichnis ist ziemlich wertvoll und nur in seltenen Fällen ist es notwendig, dieses Verzeichnis zu löschen. Bitte beachte, dass der Build in diesem Fall sehr viel mehr Zeit in Anspruch nimmt. 
+Dieses Verzeichnis ist ziemlich wertvoll und nur in seltenen Fällen ist es notwendig, dieses Verzeichnis zu löschen. Bitte beachte, dass der Buildvorgang nach dem Löschen des Cache sehr viel mehr Zeit in Anspruch nimmt. 
-> :bulb: Man kann Bitbake anweisen, keinen sstate-cache zu verwenden.
-```bash
-bitbake --no-setscene neutrino-image
-```
-oder
-```bash
-bitbake --skip-setscene neutrino-image
-```
-	
-## Bei Bedarf anpassen
-Es wird empfohlen, zum ersten Mal ohne Änderungen an den Konfigurationsdateien zu bauen, um einen Eindruck davon zu bekommen, wie der Build-Prozess funktioniert, und um die Ergebnisse zu sehen.
-Die Einstellmöglichkeiten sind sehr umfangreich und für Einsteiger nicht wirklich überschaubar. Das Yoctoproject ist jedoch sehr
-umfassend dokumentiert und bietet die beste Informationsquelle.
-	
-**Wichtig für Entwickler**: "[Arbeiten an Zielquellen](#Arbeiten-an-Zielquellen)"!
 
-> :memo: **Bitte ändere nicht die Yocto-Recipes! Dies wird vom Yocto-Team nicht empfohlen, aber man kann zum Vervollständigen, Erweitern oder Überschreiben von Meta-Core-Recipes [.bbappend](https://docs.yoctoproject.org/3.2.4/dev-manual/dev-manual-common-tasks.html#using-bbappend-files-in-your-layer)-Dateien verwenden.**
 
-### Übersicht über globale Konfigurationsdateien
+## 7. Lizenz
-Für die lokale Konfiguration werden diese Konfigurationsdateien innerhalb der Build-Verzeichnissen benötigt:
 
-> $HOME/build/poky-3.2.4/build/```<machine>```/conf/local.conf
+MIT License
 
-Diese generierte local.conf enthält nur wenige Zeilen, besitzt aber eine Zeile, die auf eine gemeinsame Konfigurationsdatei zeigt, die für alle Images und unterstützten Maschinentypen gültig ist und kann man mit eigenen Optionen füttern.
+## 8. Weiterführende Informationen
-	
-> $HOME/build/local.conf.common.inc
-
-Diese **.inc** Datei wurde aus der geklonten Beispieldatei beim erstmaligen ausführen des init-Scripts erzeugt.
-
-> local.conf.common.inc.sample
-
-Diese Beispieldatei sollte unberührt bleiben, um mögliche Konflikte beim Aktualisieren des build-Repositories zu vermeiden und um zu sehen, was sich geändert haben könnte.
-	
-Nach einer Aktualisierung des build-Repositries könnten einige neue oder geänderte Optionen hinzugefügt oder entfernt worden sein, die nicht in die inkludierte Konfigurationsdatei übernommen werden. Diesen Fall sollte man in der eigenen Konfiguration berücksichtigen und falls erforderlich anpassen.
-Natürlich kann man ```$HOME/Build/poky-3.2.4/build/<machine>/conf/local.conf``` mit eigenen Anforderungen ändern und als separate Konfigurationsdatei für einen Maschinentyp verwenden. 
-
-#### Musterkonfiguration für bblayers.conf:
-> $HOME/build/poky-3.2.4/build/```<machine>```/conf/bblayers.conf
-
-```bitbake
-# POKY_BBLAYERS_CONF_VERSION is increased each time build/conf/bblayers.conf
-# changes incompatibly
-POKY_BBLAYERS_CONF_VERSION = "2"
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-
-BBLAYERS ?= " \
-  /home/<username>build/poky-3.2.4/meta \
-  /home/<username>/build/poky-3.2.4/meta-poky \
-  /home/<username>/build/poky-3.2.4/meta-yocto-bsp \
-  "
-BBLAYERS += " \
-			/home/<username>/build/poky-3.2.4/meta-neutrino \
-			/home/<username>/build/poky-3.2.4/meta-<machine-brand-or-bsp-name> \
-			/home/<username>/build/poky-3.2.4/meta-openembedded/meta-oe \
-			"
-BBLAYERS += " \
-				/home/<username>/build/poky-3.2.4/meta-python2 \
-				"
-BBLAYERS += " \
-				/home/<username>/build/poky-3.2.4/meta-qt5 \
-				"
-```
-
-## Mehr Informationen
 Weitere Informationen zum Yocto Buildsystem:
 
-* https://docs.yoctoproject.org/3.2.4/index.html
+* https://docs.yoctoproject.org

init.functions.sh

@@ -1,9 +1,25 @@
 #!/bin/bash
 
+## Function to replace the echo command
+function my_echo() {
+	local no_term_output="$1"
+	# Clean up text
+	if [ "$no_term_output" == "true" ]; then
+		shift
+	fi
+    local cleaned_output=$(echo -e "${@}" | sed -r "s/\x1B\[[0-9;]*[a-zA-Z]//g")
+    # Write to log
+    echo "[ $(date '+%Y-%m-%d %H:%M:%S') ] - ${cleaned_output}" >> "$LOGFILE"
+    # Show on terminal
+    if [[ "$no_term_output" != "true" && -t 1 ]]; then
+        echo -e "${@}"
+    fi
+}
+
 # function for checking of valid machine(s)
 function is_valid_machine ()
 {
-	ISM=$1
+	local ISM=$1
 	for M in $MACHINES ; do
 		if [ "$ISM" == "$M" ] || [ "$MACHINE" == "all" ]; then
 			echo true
@@ -15,39 +31,53 @@ function is_valid_machine ()
 }
 
 function do_exec() {
-	DEX_ARG1=$1
+    local cmd="$1"
-	DEX_ARG2=$2
+    local exit_behavior="$2"
-	DEX_ARG3=$3
+    local show_output="$3"
-# 	rm -f $TMP_LOGFILE
+    local log_text
-	echo "[`date '+%Y%m%d_%H%M%S'`] EXEC: $DEX_ARG1" >> $LOGFILE
+    local cmd_exit_status
-	if [ "$DEX_ARG3" == "show_output" ]; then
+
-		$DEX_ARG1
+    my_echo true "[EXEC] $cmd"
-	else
+
-		$DEX_ARG1 > /dev/null 2>> $TMP_LOGFILE
+    # TODO: Evaluate alternatives to 'eval' for executing complex commands
-	fi
+	# Using 'eval' here allows for dynamic execution of commands that may include
-#	echo -e "DEX_ARG1 [$DEX_ARG1] DEX_ARG2 [$DEX_ARG2] DEX_ARG3 [$DEX_ARG3]"
+	# special characters, variable expansions, or other complexities that are
-	if test -f $TMP_LOGFILE; then
+	# difficult to handle with direct execution methods. However, 'eval' comes with
-		LOGTEXT=`cat $TMP_LOGFILE`
+	# significant security implications, especially when dealing with untrusted input.
-		echo > $TMP_LOGFILE
+	# It executes the given string as a bash command, which can lead to code injection
-	fi
+	# vulnerabilities if not carefully managed. This usage is a temporary solution to
-	if [ $? != 0 ]; then
+	# achieve desired functionality and should be revisited to explore safer alternatives.
-		if [ "$DEX_ARG2" != "no_exit" ]; then
+    if [[ "$show_output" == "show_output" ]]; then
-			if [ "$LOGTEXT" != "" ]; then
+        eval $cmd 2>> "$TMP_LOGFILE"
-				echo -e "\033[31;1mERROR:\t\033[0m $LOGTEXT"
+    else
-				echo "ERROR: $LOGTEXT" >> $LOGFILE
+        eval $cmd > /dev/null 2>> "$TMP_LOGFILE"
-			fi
+    fi
-			exit 1
+
-		else
+    cmd_exit_status=${PIPESTATUS[0]} # Get exit status of the first command in the last pipe
-			if [ "$LOGTEXT" != "" ]; then
+
-				echo -e "\033[37;1mNOTE:\t\033[0m $LOGTEXT"
+    if [[ -f "$TMP_LOGFILE" ]]; then
-				echo "NOTE: $LOGTEXT" >> $LOGFILE
+        log_text=$(cat "$TMP_LOGFILE")
- 			fi
+        >> "$LOGFILE" # Clear TMP_LOGFILE after reading
-		fi
+    fi
-	fi
+
+    if [[ $cmd_exit_status -ne 0 ]]; then
+        if [[ "$exit_behavior" != "no_exit" ]]; then
+            if [[ -n "$log_text" ]]; then
+                my_echo -e "\033[31;1mERROR:\033[0m $log_text"
+                my_echo "ERROR: $log_text" >> "$LOGFILE"
+            fi
+            exit 1
+        else
+            if [[ -n "$log_text" ]]; then
+                my_echo -e "\033[37;1mNOTE:\033[0m $log_text"
+                my_echo "NOTE: $log_text" >> "$LOGFILE"
+            fi
+        fi
+    fi
 }
 
 function get_metaname () {
-	TMP_NAME=$1
+	local TMP_NAME=$1
 
 	if [ "$TMP_NAME" == "hd51" ] || [ "$TMP_NAME" == "bre2ze4k" ] || [ "$TMP_NAME" == "mutant51" ] || [ "$TMP_NAME" == "ax51" ]; then
 		META_NAME="gfutures"
@@ -66,60 +96,74 @@ function get_metaname () {
 }
 
 # clone or update required branch for required meta-<layer>
-function clone_meta () {
+function fetch_meta() {
+    local layer_name="$1"
+    local branch_name="$2"
+    local layer_git_url="$3"
+    local branch_hash="$4"
+    local target_git_path="$5"
+    local patch_list="$6"
 
-	LAYER_NAME=$1
+    local GIT_SSH_COMMAND=""
-	BRANCH_NAME=$2
+    if [[ "$GIT_SSH_KEYFILE" != "" ]]; then
-	LAYER_GIT_URL=$3
+        export GIT_SSH_COMMAND="$SSH -i \"$GIT_SSH_KEYFILE\""
-	BRANCH_HASH=$4
+    fi
-	TARGET_GIT_PATH=$5
-	PATCH_LIST=$6
-	
-	#echo -e "Parameters= $LAYER_NAME $BRANCH_NAME $LAYER_GIT_URL $BRANCH_HASH $TARGET_GIT_PATH $PATCH_LIST"
 
-	TMP_LAYER_BRANCH=$BRANCH_NAME
+    if [[ ! -d "$target_git_path/.git" ]]; then
-
+		my_echo -e "Clone branch $branch_name from $layer_git_url into $target_git_path"
-	if test ! -d $TARGET_GIT_PATH/.git; then
+		if do_exec "git clone -b "$branch_name" "$layer_git_url" "$target_git_path""; then
-		echo -e "\033[35;1mclone branch $BRANCH_NAME from $LAYER_GIT_URL\033[0m"
+			do_exec "git -C "$target_git_path" checkout "$branch_hash" -b "$IMAGE_VERSION""
-		do_exec "git clone -b $BRANCH_NAME $LAYER_GIT_URL $TARGET_GIT_PATH" ' ' 'show_output'
+			do_exec "git -C "$target_git_path" pull -r origin "$branch_name""
-		do_exec "git -C $TARGET_GIT_PATH checkout $BRANCH_HASH -b $IMAGE_VERSION"
+		else
-		do_exec "git -C $TARGET_GIT_PATH pull -r origin $BRANCH_NAME" ' ' 'show_output'
+			my_echo -e "\033[31;1mError cloning $layer_name from $layer_git_url\033[0m"
-		echo -e "\033[35;1mpatching $TARGET_GIT_PATH.\033[0m"
+			return 1
-		for PF in  $PATCH_LIST ; do
-			PATCH_FILE="$FILES_DIR/$PF"
-			echo -e "apply: $PATCH_FILE"
-			do_exec "git -C $TARGET_GIT_PATH am $PATCH_FILE" ' ' 'show_output'
-		done
-	else
-		TMP_LAYER_BRANCH=`git -C $TARGET_GIT_PATH rev-parse --abbrev-ref HEAD`
-		echo -e "\033[35;1mupdate $TARGET_GIT_PATH $TMP_LAYER_BRANCH\033[0m"
-		do_exec "git -C $TARGET_GIT_PATH stash" 'no_exit'
-
-		if [ "$TMP_LAYER_BRANCH" != "$BRANCH_NAME" ]; then
-			echo -e "switch from branch $TMP_LAYER_BRANCH to branch $BRANCH_NAME..."
-			do_exec "git -C $TARGET_GIT_PATH checkout  $BRANCH_NAME"
 		fi
-
+		## Patching
-		#echo -e "\033[35;1mUPDATE:\033[0m\nupdate $LAYER_NAME from (branch $BRANCH_NAME) $LAYER_GIT_URL ..."
+		if [[ -n "$patch_list" ]]; then
-		do_exec "git -C $TARGET_GIT_PATH pull -r origin $BRANCH_NAME" ' ' 'show_output'
+			for patch_file in $patch_list; do
-
+				# First, check if the patch can be applied cleanly
-		if [ "$TMP_LAYER_BRANCH" != "$BRANCH_NAME" ]; then
+				my_echo -e "Applying patch: $patch_file"
-			echo -e "\033[35;1mswitch back to branch $TMP_LAYER_BRANCH\033[0m"
+				if do_exec "git -C "$target_git_path" apply --check "$FILES_DIR/$patch_file""; then
-			do_exec "git -C $TARGET_GIT_PATH checkout  $TMP_LAYER_BRANCH"
+					# Attempt to apply the patch if 'apply --check' was successful
-			echo -e "\033[35;1mrebase branch $BRANCH_NAME into branch $TMP_LAYER_BRANCH\033[0m"
+					if ! do_exec "git -C "$target_git_path" am < "$FILES_DIR/$patch_file""; then
-			do_exec "git -C $TARGET_GIT_PATH rebase  $BRANCH_NAME" ' ' 'show_output'
+						# Error message if 'git am' fails
+						my_echo -e "\033[31;1mFailed to apply patch $patch_file to $layer_name\033[0m"
+						return 1
+					fi
+				else
+					# Message about skipping if 'apply --check' fails
+					my_echo -e "\033[33;1mSkipping patch $patch_file already applied or cannot be applied cleanly.\033[0m"
+				fi
+			done
 		fi
+    else
+		if [[ $DO_UPDATE == "$true" ]]; then
+			my_echo -e "Update $target_git_path on branch $branch_name"
+			if [[ $(git -C "$target_git_path" stash list) ]]; then
+				my_echo -e "Stashing changes in $target_git_path"
+				do_exec "git -C "$target_git_path" stash push --include-untracked"
+				local stash_applied=true
+			fi
+			do_exec "git -C "$target_git_path" checkout "$branch_name"" || do_exec "git -C "$target_git_path" checkout -b "$branch_name""
+			do_exec "git -C "$target_git_path" pull -r origin "$branch_name""
+			if [[ "$stash_applied" == true ]]; then
+				if do_exec "git -C "$target_git_path" stash pop"; then
+					my_echo -e "Stash applied successfully."
+				else
+					my_echo -e "\033[33;1mNote: Stash could not be applied. Manual intervention required.\033[0m"
+					return 1
+				fi
+			fi
+        fi
+    fi
 
-		do_exec "git -C $TARGET_GIT_PATH stash pop" 'no_exit'
+    return 0
-	fi
-
-	return 0
 }
 
 # clone/update required branch from tuxbox bsp layers
 function is_required_machine_layer ()
 {
-	HIM1=$1
+	local HIM1=$1
 	for M in $HIM1 ; do
 		if [ "$M" == "$MACHINE" ]; then
 			echo true
@@ -132,7 +176,7 @@ function is_required_machine_layer ()
 
 # get matching machine type from machine build id
 function get_real_machine_type() {
-	MACHINE_TYPE=$1
+	local MACHINE_TYPE=$1
 	if  [ "$MACHINE_TYPE" == "mutant51" ] || [ "$MACHINE_TYPE" == "ax51" ] || [ "$MACHINE_TYPE" == "hd51" ]; then
 		RMT_RES="hd51"
 	elif  [ "$MACHINE_TYPE" == "hd60" ] || [ "$MACHINE_TYPE" == "ax60" ]; then
@@ -149,7 +193,7 @@ function get_real_machine_type() {
 
 # get matching machine build id from machine type
 function get_real_machine_id() {
-	MACHINEBUILD=$1
+	local MACHINEBUILD=$1
 	if  [ "$MACHINEBUILD" == "hd51" ]; then
 		RMI_RES="ax51"
 	elif  [ "$MACHINEBUILD" == "hd60" ]; then
@@ -164,11 +208,11 @@ function get_real_machine_id() {
 	echo $RMI_RES
 }
 
-# function to create file enrties into a file, already existing entry will be ignored
+# function to create file entries into a file, already existing entry will be ignored
 function set_file_entry () {
-	FILE_NAME=$1
+	local FILE_NAME=$1
-	FILE_SEARCH_ENTRY=$2
+	local FILE_SEARCH_ENTRY=$2
-	FILE_NEW_ENTRY=$3
+	local FILE_NEW_ENTRY=$3
 	if test ! -f $FILE_NAME; then
 		echo $FILE_NEW_ENTRY > $FILE_NAME
 		return 1
@@ -186,38 +230,39 @@ function set_file_entry () {
 	return 0
 }
 
+
 # function to create configuration for box types
 function create_local_config () {
-	CLC_ARG1=$1
+	local machine=$1
 
-	if [ "$CLC_ARG1" != "all" ]; then
+	if [ "$machine" != "all" ]; then
 
-		MACHINE_BUILD_DIR=$BUILD_ROOT/$CLC_ARG1
+		MACHINE_BUILD_DIR=$BUILD_ROOT/$machine
 		do_exec "mkdir -p $BUILD_ROOT"
 
-		BACKUP_CONFIG_DIR="$BACKUP_PATH/$CLC_ARG1/conf"
+		BACKUP_CONFIG_DIR="$BACKUP_PATH/$machine/conf"
 		do_exec "mkdir -p $BACKUP_CONFIG_DIR"
 
 		LOCAL_CONFIG_FILE_PATH=$MACHINE_BUILD_DIR/conf/local.conf
 
-		if test -d $BUILD_ROOT_DIR/$CLC_ARG1; then
+		if test -d $BUILD_ROOT_DIR/$machine; then
-			if test ! -L $BUILD_ROOT_DIR/$CLC_ARG1; then
+			if test ! -L $BUILD_ROOT_DIR/$machine; then
 				# generate build/config symlinks for compatibility
-				echo -e "\033[37;1m\tcreate compatible symlinks directory for $CLC_ARG1 environment ...\033[0m"
+				my_echo -e "\033[37;1m\tcreate compatible symlinks directory for $machine environment ...\033[0m"
-				do_exec "mv -v $BUILD_ROOT_DIR/$CLC_ARG1 $BUILD_ROOT"
+				do_exec "mv $BUILD_ROOT_DIR/$machine $BUILD_ROOT"
-				do_exec "ln -sv $MACHINE_BUILD_DIR $BUILD_ROOT_DIR/$CLC_ARG1"
+				do_exec "ln -s $MACHINE_BUILD_DIR $BUILD_ROOT_DIR/$machine"
 			fi
 		fi
 
 		# generate default config
 		if test ! -d $MACHINE_BUILD_DIR/conf; then
-			echo -e "\033[37;1m\tcreating build directory for $CLC_ARG1 environment ...\033[0m"
+			my_echo -e "\033[37;1m\tcreating build directory for $machine environment ...\033[0m"
 			do_exec "cd $BUILD_ROOT_DIR"
 			do_exec ". ./oe-init-build-env $MACHINE_BUILD_DIR"
 			# we need a clean config file
 			if test -f $LOCAL_CONFIG_FILE_PATH & test ! -f $LOCAL_CONFIG_FILE_PATH.origin; then
 				# so we save the origin local.conf
-				do_exec "mv -v $LOCAL_CONFIG_FILE_PATH $LOCAL_CONFIG_FILE_PATH.origin"
+				do_exec "mv $LOCAL_CONFIG_FILE_PATH $LOCAL_CONFIG_FILE_PATH.origin"
 			fi
 			do_exec "cd $BASEPATH"
 			echo "[Desktop Entry]" > $BUILD_ROOT/.directory
@@ -225,41 +270,45 @@ function create_local_config () {
 		fi
 
 		# modify or upgrade config files inside conf directory
-		LOCAL_CONFIG_FILE_INC_PATH=$BASEPATH/local.conf.common.inc
 		if test -f $LOCAL_CONFIG_FILE_INC_PATH; then
 
 			if test -f $LOCAL_CONFIG_FILE_PATH; then
 				HASHSTAMP=`MD5SUM $LOCAL_CONFIG_FILE_PATH`
-				do_exec "cp -v $LOCAL_CONFIG_FILE_PATH $BACKUP_CONFIG_DIR/local.conf.$HASHSTAMP.$BACKUP_SUFFIX"
+				do_exec "cp $LOCAL_CONFIG_FILE_PATH $BACKUP_CONFIG_DIR/local.conf.$HASHSTAMP.$BACKUP_SUFFIX"
 
 				# migrate settings after server switch
-				echo -e "migrate settings within $LOCAL_CONFIG_FILE_INC_PATH..."
+				my_echo "migrate settings within $LOCAL_CONFIG_FILE_INC_PATH..."
-				sed -i -e 's|http://archiv.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_INC_PATH
+				do_exec "sed -i -e 's|http://archiv.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_INC_PATH"
-				sed -i -e 's|https://archiv.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_INC_PATH
+				do_exec "sed -i -e 's|https://archiv.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_INC_PATH"
 
-				sed -i -e 's|http://archiv.tuxbox-neutrino.org/sources|https://n4k.sourceforge.io/sources|' $LOCAL_CONFIG_FILE_INC_PATH
+				do_exec "sed -i -e 's|http://archiv.tuxbox-neutrino.org/sources|https://n4k.sourceforge.io/sources|' $LOCAL_CONFIG_FILE_INC_PATH"
-				sed -i -e 's|https://archiv.tuxbox-neutrino.org/sources|https://n4k.sourceforge.io/sources|' $LOCAL_CONFIG_FILE_INC_PATH
+				do_exec "sed -i -e 's|https://archiv.tuxbox-neutrino.org/sources|https://n4k.sourceforge.io/sources|' $LOCAL_CONFIG_FILE_INC_PATH"
 
-				sed -i -e 's|http://sstate.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_INC_PATH
+				do_exec "sed -i -e 's|http://sstate.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_INC_PATH"
-				sed -i -e 's|https://sstate.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_INC_PATH
+				do_exec "sed -i -e 's|https://sstate.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_INC_PATH"
 
-				sed -i -e 's|archiv.tuxbox-neutrino.org|n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_INC_PATH
+				do_exec "sed -i -e 's|archiv.tuxbox-neutrino.org|n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_INC_PATH"
-				sed -i -e 's|sstate.tuxbox-neutrino.org|n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_INC_PATH
+				do_exec "sed -i -e 's|sstate.tuxbox-neutrino.org|n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_INC_PATH"
 
-				echo -e "migrate settings within $LOCAL_CONFIG_FILE_PATH"
+				my_echo "migrate settings within $LOCAL_CONFIG_FILE_PATH"
-				sed -i -e 's|http://archiv.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_PATH
+				do_exec "sed -i -e 's|http://archiv.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_PATH"
-				sed -i -e 's|https://archiv.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_PATH
+				do_exec "sed -i -e 's|https://archiv.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_PATH"
 
-				sed -i -e 's|http://archiv.tuxbox-neutrino.org/sources|https://n4k.sourceforge.io/sources|' $LOCAL_CONFIG_FILE_PATH
+				do_exec "sed -i -e 's|http://archiv.tuxbox-neutrino.org/sources|https://n4k.sourceforge.io/sources|' $LOCAL_CONFIG_FILE_PATH"
-				sed -i -e 's|https://archiv.tuxbox-neutrino.org/sources|https://n4k.sourceforge.io/sources|' $LOCAL_CONFIG_FILE_PATH
+				do_exec "sed -i -e 's|https://archiv.tuxbox-neutrino.org/sources|https://n4k.sourceforge.io/sources|' $LOCAL_CONFIG_FILE_PATH"
 
-				sed -i -e 's|http://sstate.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_PATH
+				do_exec "sed -i -e 's|http://sstate.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_PATH"
-				sed -i -e 's|https://sstate.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_PATH
+				do_exec "sed -i -e 's|https://sstate.tuxbox-neutrino.org|https://n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_PATH"
 
-				sed -i -e 's|archiv.tuxbox-neutrino.org|n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_PATH
+				do_exec "sed -i -e 's|archiv.tuxbox-neutrino.org|n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_PATH"
-				sed -i -e 's|sstate.tuxbox-neutrino.org|n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_PATH
+				do_exec "sed -i -e 's|sstate.tuxbox-neutrino.org|n4k.sourceforge.io|' $LOCAL_CONFIG_FILE_PATH"
 
-				echo -e "\033[32;1mdone ...\033[0m\n"
+				search_line="#UPDATE_SERVER_URL = \"http:\/\/@hostname@\""
+				add_line="UPDATE_SERVER_URL = \"http://$HTTP_ADDRESS\""
+				if ! grep -qF -- "$add_line" "$LOCAL_CONFIG_FILE_INC_PATH"; then
+					# Wenn nicht, füge die neue Zeile nach der spezifischen Zeile ein
+					sed -i -e "/$search_line/a $add_line" "$LOCAL_CONFIG_FILE_INC_PATH"
+				fi
 			fi
 
 			# add init note
@@ -269,18 +318,18 @@ function create_local_config () {
 			set_file_entry $LOCAL_CONFIG_FILE_PATH "$BASEPATH/local.conf.common.inc" "include $BASEPATH/local.conf.common.inc"
 
 			# add line 2, machine type
-			M_TYPE='MACHINE = "'`get_real_machine_type $CLC_ARG1`'"'
+			M_TYPE='MACHINE = "'`get_real_machine_type $machine`'"'
 			if set_file_entry $LOCAL_CONFIG_FILE_PATH "MACHINE" "$M_TYPE" == 1; then
-				echo -e "\t\033[37;1m$LOCAL_CONFIG_FILE_PATH has been upgraded with entry: $M_TYPE \033[0m"
+				my_echo -e "\t\033[37;1m$LOCAL_CONFIG_FILE_PATH has been upgraded with entry: $M_TYPE \033[0m"
 			fi
 
 			# add line 3, machine build
-			M_ID='MACHINEBUILD = "'`get_real_machine_id $CLC_ARG1`'"'
+			M_ID='MACHINEBUILD = "'`get_real_machine_id $machine`'"'
 			if set_file_entry $LOCAL_CONFIG_FILE_PATH "MACHINEBUILD" "$M_ID" == 1; then
-				echo -e "\t\033[37;1m$LOCAL_CONFIG_FILE_PATH has been upgraded with entry: $M_ID \033[0m"
+				my_echo -e "\t\033[37;1m$LOCAL_CONFIG_FILE_PATH has been upgraded with entry: $M_ID \033[0m"
 			fi
 		else
-			echo -e "\033[31;1mERROR:\033[0m:\ttemplate $BASEPATH/local.conf.common.inc not found..."
+			my_echo -e "\033[31;1mERROR:\033[0m:\ttemplate $BASEPATH/local.conf.common.inc not found..."
 			exit 1
 		fi
 
@@ -289,17 +338,20 @@ function create_local_config () {
 		# craete backup for bblayer.conf
 		if test -f $BBLAYER_CONF_FILE; then
 			HASHSTAMP=`MD5SUM $BBLAYER_CONF_FILE`
-			do_exec "cp -v $BBLAYER_CONF_FILE $BACKUP_CONFIG_DIR/bblayer.conf.$HASHSTAMP.$BACKUP_SUFFIX"
+			do_exec "cp $BBLAYER_CONF_FILE $BACKUP_CONFIG_DIR/bblayer.conf.$HASHSTAMP.$BACKUP_SUFFIX"
 		fi
 
-		META_MACHINE_LAYER=meta-`get_metaname $CLC_ARG1`
+		META_MACHINE_LAYER=meta-`get_metaname $machine`
 
 		# add layer entries into bblayer.conf
 		set_file_entry $BBLAYER_CONF_FILE "generated" '# auto generated entries by init script'
+		if [[ -z "$PYTHON2_SRCREV" ]]; then
+			PYTHON2_LAYER_NAME=""
+		fi
 		LAYER_LIST=" $TUXBOX_LAYER_NAME $META_MACHINE_LAYER $OE_LAYER_NAME/meta-oe $OE_LAYER_NAME/meta-networking $PYTHON2_LAYER_NAME $QT5_LAYER_NAME "
 		for LL in $LAYER_LIST ; do
 			if set_file_entry $BBLAYER_CONF_FILE $LL 'BBLAYERS += " '$BUILD_ROOT_DIR'/'$LL' "' == 1;then
-				echo -e "\t\033[37;1m$BBLAYER_CONF_FILE has been upgraded with entry: $LL... \033[0m"
+				my_echo -e "\t\033[37;1m$BBLAYER_CONF_FILE has been upgraded with entry: $LL... \033[0m"
 			fi
 		done
 	fi
@@ -309,9 +361,9 @@ function create_local_config () {
 function create_dist_tree () {
 
 	# create dist dir
-	DIST_BASEDIR="$BASEPATH/dist/$IMAGE_VERSION"
+	DIST_BASEDIR="$DIST_DIR/$IMAGE_VERSION"
 	if test ! -d "$DIST_BASEDIR"; then
-		echo -e "\033[37;1mcreate dist directory:\033[0m   $DIST_BASEDIR"
+		my_echo -e "\033[37;1mcreate dist directory:\033[0m   $DIST_BASEDIR"
 		do_exec "mkdir -p $DIST_BASEDIR"
 	fi
 
@@ -319,15 +371,115 @@ function create_dist_tree () {
 	DIST_LIST=`ls $BUILD_ROOT`
 	for DL in  $DIST_LIST ; do
 		DEPLOY_DIR="$BUILD_ROOT/$DL/tmp/deploy"
-		do_exec "ln -sfv $DEPLOY_DIR $DIST_BASEDIR/$DL"
+		do_exec "ln -sf $DEPLOY_DIR $DIST_BASEDIR/$DL"
 		if test -L "$DIST_BASEDIR/$DL/deploy"; then
-			do_exec "unlink -v $DIST_BASEDIR/$DL/deploy"
+			do_exec "unlink $DIST_BASEDIR/$DL/deploy"
 		fi
 	done
 }
 
 function MD5SUM () {
-	MD5SUM_FILE=$1
+	local MD5SUM_FILE=$1
 	MD5STAMP=`md5sum $MD5SUM_FILE |cut -f 1 -d " "`
 	echo $MD5STAMP
 }
+
+# Function for selecting for items included a custom entry
+function do_select() {
+    local items="$1"
+    SELECTION=""
+    local user_input
+    local valid_selection=0
+
+    IFS=' ' read -r -a items_array <<< "$items"
+
+    echo "Please select one or more entries (numbers separated by spaces):"
+    local i=1
+    for item in "${items_array[@]}"; do
+        printf "[%2d]  %s\n" "$i" "$item"
+        ((i++))
+    done
+    printf "\n[%2d]  %s\n" "$i" "Enter custom"
+
+    printf "\nEnter the numbers of the entries or [$i] for custom entry: "
+    read -r user_input
+
+    for choice in $user_input; do
+        if [[ "$choice" =~ ^[0-9]+$ ]]; then
+            if [ "$choice" -ge 1 ] && [ "$choice" -lt "$i" ]; then
+                SELECTION+="${items_array[$choice-1]} "
+                valid_selection=1
+            elif [ "$choice" -eq "$i" ]; then
+                echo "Enter your custom entry:"
+                read -r custom_entry
+                SELECTION+="$custom_entry "
+                valid_selection=1
+            else
+                my_echo "Invalid selection: $choice"
+            fi
+        else
+            my_echo "Invalid selection: $choice"
+        fi
+    done
+
+    if [ "$valid_selection" -eq 0 ]; then
+        my_echo "No valid selection made. Process aborted."
+        return 1
+    fi
+
+    # Remove the last space
+    SELECTION=$(echo "$SELECTION" | sed 's/ $//')
+
+    my_echo "Selected entries: $SELECTION"
+    # Return the selected machines as a string
+    #"$SELECTION" has global scope
+}
+
+
+# Reset the build. Nothing is deleted, but rather renamed for safety.
+# Users can then decide when they want to clean up permanently.
+function do_reset() {
+    # Make selection and save in a variable
+    do_select "$MACHINES"
+    local selected_machines=$SELECTION
+
+    # Check if a selection was made
+    if [ -z "$selected_machines" ]; then
+        return
+    fi
+
+    # Set the start directory from where the search should begin
+    local start_directory="$BUILD_ROOT_DIR" # Adjust to base directory
+    local rename_success=0 # Tracks if a rename was performed
+
+    # Process the selected machines
+    IFS=' ' read -r -a machines_array <<< "$selected_machines"
+    for machine in "${machines_array[@]}"; do
+        my_echo "Reset is being carried out for: $machine"
+
+        # Save results from find in an array
+        readarray -t found_dirs < <(find "$start_directory" -type f -name "saved_tmpdir")
+
+        # Check if the array contains elements
+        for dir in "${found_dirs[@]}"; do
+            # Read the path from the file
+            tmp_dir_path=$(cat "$dir")
+            # Check if the path exists and matches the machine name
+            if [[ -d "$tmp_dir_path" && "$tmp_dir_path" == *"/$machine/tmp"* ]]; then
+                local timestamp=$(date '+%Y%m%d_%H%M%S')
+                do_exec "mv "$tmp_dir_path" "${tmp_dir_path%/*}/tmp_${timestamp}""
+                my_echo "Folder $tmp_dir_path was renamed to ${tmp_dir_path%/*}/tmp_${timestamp}."
+                rename_success=1
+                break # Exit the loop after the first successful rename
+            fi
+        done
+    done
+
+    # Check if reset was performed
+    if [ "$rename_success" -eq 0 ]; then
+       my_echo "\033[33mNo reset could be performed.\033[0m"
+	else
+		my_echo "Reset succeeded."
+    fi
+}
+

init.sh

@@ -2,16 +2,50 @@
 source init.functions.sh
 #set -x
 
+## Comatible and default image version
+DEFAULT_IMAGE_VERSION="3.2.4"
+COMPATIBLE_IMAGE_VERSIONS="$DEFAULT_IMAGE_VERSION 3.2"
+IMAGE_VERSION="$DEFAULT_IMAGE_VERSION"
+
+## global vars
 BASEPATH=$(pwd)
-TIMESTAMP=$(date '+%Y%m%d_%H%M%S')
+SSH=$(which ssh)
-
+GIT_SSH_KEYFILE=""
-# only current version
+true="1"
-# IMAGE_VERSION=$(git -C $BASEPATH rev-parse --abbrev-ref HEAD)
+false="0"
-IMAGE_VERSION="3.2.4"
+DO_UPDATE=$false
-
+DO_RESET=$false
 FILES_DIR="$BASEPATH/files"
+UPDATE_SERVER_URL="http://localhost"
+DIST_DIR="$BASEPATH/dist"
+USER_CALL="$0 $@"
 
-# identical listings
+## Basename of this script
+NAME=$(basename $0)
+
+## Timestamp for logging
+TIMESTAMP=$(date '+%Y%m%d_%H%M%S')
+## Logfile
+LOG_PATH=$BASEPATH/log
+mkdir -p $LOG_PATH
+TMP_LOGFILE="$LOG_PATH/.$0-tmp.log"
+rm -f $TMP_LOGFILE
+LOGFILE_NAME="$NAME"_"$TIMESTAMP.log"
+LOGFILE=$LOG_PATH/$LOGFILE_NAME
+LOGFILE_LINK=$LOG_PATH/$NAME.log
+LOCAL_CONFIG_FILE_INC_PATH=$BASEPATH/local.conf.common.inc
+echo "" >  $LOGFILE
+ln -sf $LOGFILE $LOGFILE_LINK
+my_echo "true" "$USER_CALL"
+
+## Current build env script version
+BUILD_ENV_VERSION=$(git -C $BASEPATH describe --tags 2>/dev/null)
+if [ -z "$BUILD_ENV_VERSION" ]; then
+	BUILD_ENV_VERSION="unknown"
+fi
+
+## Machines
+# Identical listings
 MACHINES_IDENTICAL_HD51="hd51 ax51 mutant51"
 MACHINES_IDENTICAL_H7="h7 zgemmah7"
 MACHINES_IDENTICAL_HD60="hd60 ax60" #TODO: move into gfutures
@@ -24,226 +58,308 @@ MACHINES_HISI="$MACHINES_IDENTICAL_HD60 $MACHINES_IDENTICAL_HD61"
 # airdigital listing
 MACHINES_AIRDIGITAL="$MACHINES_IDENTICAL_H7"
 # edision listing
-#MACHINES_EDISION="osmio4k osmio4kplus"
+MACHINES_EDISION="osmio4k osmio4kplus"
 # ceryon listing
 MACHINES_CERYON="e4hdultra"
 
 # valid machine list
 MACHINES="$MACHINES_GFUTURES $MACHINES_HISI $MACHINES_AIRDIGITAL $MACHINES_EDISION $MACHINES_CERYON"
 
-HINT_SYNTAX='\033[37;1mUsage '$0' <machine>\033[0m'
+MACHINE="all" # default for MACHINE, if not set
-HINT_MACHINES="<$MACHINES>, <all> or keep empty < >"
+HINT_MACHINES="Select a valid machine type (empty means <all> as default) <$MACHINES>"
-HINT_IMAGE_VERSIONS="$IMAGE_VERSION"
  
-LOG_PATH=$BASEPATH/log
+## Backups
-mkdir -p $LOG_PATH
-
 BACKUP_PATH=$BASEPATH/backups
 mkdir -p $BACKUP_PATH
+BACKUP_SUFFIX=bak
 
-LOGFILE_NAME="$0_$TIMESTAMP.log"
+# meta-neutrino project URL:
-LOGFILE=$LOG_PATH/$LOGFILE_NAME
+PROJECT_URL="https://github.com/tuxbox-neutrino"
-TMP_LOGFILE=$LOG_PATH/.tmp.log
-touch $LOGFILE
 
-LOGFILE_LINK=$BASEPATH/$0.log
+## Help
+show_help() {
+	if [[ $LANG == de_* ]]; then
+        echo "Dieses Skript initialisiert und aktualisiert die Entwicklungsumgebung für den Bau von Images und Paketen für verschiedene Maschinenkonfigurationen."
+        echo "Es klont und aktualisiert Meta-Layer aus vorgegebenen Repositories, bereitet die Build-Umgebung vor und unterstützt die Konfiguration für spezifische Maschinentypen."
+	else
+        echo "This script initializes and updates the development environment for building images and packages for various machine configurations."
+        echo "It clones and updates meta-layers from specified repositories, prepares the build environment, and supports configuration for specific machine types."
+	fi
+	echo ""
+    echo "Usage: $0 [OPTIONS]..."
+    echo ""
+    echo "Options:"
+    echo "  -m, --machine             $HINT_MACHINES"
+    echo "      --update-url          URL (IP, hostname or domain, optional with portnumber) to define the update server address for $LOCAL_CONFIG_FILE_INC_PATH, default: $UPDATE_SERVER_URL"
+    echo "      --dist-dir            Directory where to find the deployed images and packages, default: $DIST_DIR"
+    echo "  -p, --project-url         Project-URL where to find project meta layers,"
+    echo "                            e.g. for read and write access: git@github.com:tuxbox-neutrino, default = $PROJECT_URL"
+    echo "      --image-version       Sets the required image version to build, possible versions are: $COMPATIBLE_IMAGE_VERSIONS, default = $DEFAULT_IMAGE_VERSION"
+    echo "  -u, --update              Update your project meta layers"
+    echo "  -r, --reset               Resets the tmp dir within the build directory, $BASEPATH/poky-x.x.x/build/<machine>/tmp. The /tmp directory will be not deleted but renamed"
+    echo "  -i, --id-rsa-file         Path to your preferred id rsa file, default: users id rsa file, e.g. $HOME/.ssh/id_rsa"
+    echo ""
+    echo "  -h, --help                Show this help"
+    echo "      --version             Show version information for buildenv script"
+}
 
-rm -f $TMP_LOGFILE
+## Processing command line arguments
-rm -f $LOGFILE_LINK
+TEMP=$(getopt -o rup:m:i:h --long reset,update-url:,dist-dir:,update,project-url:,machine:,id-rsa-file,image-version:,help,version -n 'init' -- "$@")
-ln -sf $LOGFILE $LOGFILE_LINK
+if [ $? != 0 ] ; then
-
+	my_echo "Error while process arguments" >&2
-
+	show_help
-# set passed parameters
+	exit 1
-if [ "$1" == "" ]; then
-	MACHINE="all"
-else
-	MACHINE=$1
 fi
 
-if [ $(is_valid_machine "$MACHINE") == false ]; then
+# Note the quotes around `$TEMP`: they are essential!
-    echo -e "\033[31;1mERROR:\tNo valid machine defined.\033[0m\n\t$HINT_SYNTAX.
+eval set -- "$TEMP"
-    \tKeep parameter <machine> empty to initialize all possible machine types or set your favorite machine.
+
-    \tPossible types are:
+# Extract arguments.
-    \t\033[37;1m$HINT_MACHINES\033[0m\n"
+while true ; do
+    case "$1" in
+        -p|--project-url)
+            PROJECT_URL="$2"; shift 2 ;;
+        -m|--machine)
+            MACHINE="$2"; shift 2 ;;
+		-i|--id-rsa-file)
+            GIT_SSH_KEYFILE="$2"; shift 2 ;;
+		   --update-url)
+            UPDATE_SERVER_URL="$2"; shift 2 ;;
+		   --dist-dir)
+            DIST_DIR="$2"; shift 2 ;;
+		-u|--update)
+			DO_UPDATE="$true"; shift ;;
+		-r|--reset)
+			DO_RESET="$true"; shift ;;
+          --image-version)
+            IMAGE_VERSION="$2"; shift 2 ;;
+        -h|--help)
+            show_help
+            exit 0 ;;
+		  --version)
+		    echo "$BUILD_ENV_VERSION"
+		    exit 0 ;;
+        --) shift ; break ;;
+        *) echo "Internal Error!" ; exit 1 ;;
+    esac
+done
+
+## Validate the chosen image version
+if [[ ! " $COMPATIBLE_IMAGE_VERSIONS " =~ " $IMAGE_VERSION " ]]; then
+    my_echo "\033[31;1mError: Invalid image version specified '$IMAGE_VERSION'. Available versions are: [$COMPATIBLE_IMAGE_VERSIONS]\033[0m"
     exit 1
 fi
 
-echo -e "##########################################################################################"
+## Layer sources
-echo -e "\033[37;1mInitialze build environment:\nversion: $IMAGE_VERSION\nmachine: $MACHINE\033[0m"
+YOCTO_GIT_URL="https://git.yoctoproject.org/git/poky"
-echo -e "##########################################################################################\n"
+POKY="poky"
-
+POKY_NAME="$IMAGE_VERSION" #TODO
-
+BUILD_ROOT_DIR="$BASEPATH/$POKY-$IMAGE_VERSION"
-BACKUP_SUFFIX=bak
+BUILD_ROOT="$BUILD_ROOT_DIR/build"
-
-YOCTO_GIT_URL=https://git.yoctoproject.org/git/poky
-POKY=poky
-POKY_NAME=$IMAGE_VERSION
-BUILD_ROOT_DIR=$BASEPATH/$POKY-$IMAGE_VERSION
-BUILD_ROOT=$BUILD_ROOT_DIR/build
 
 OE_LAYER_NAME=meta-openembedded
 OE_LAYER_GIT_URL=https://git.openembedded.org/meta-openembedded
-OE_LAYER_PATCH_LIST="0001-openembedded-disable-meta-python.patch 0002-openembedded-disable-openembedded-layer-meta-phyton.patch"
+OE_LAYER_PATCH_LIST=""
 
 OE_CORE_LAYER_NAME=openembedded-core
 OE_CORE_LAYER_GIT_URL=https://github.com/openembedded/openembedded-core.git
 
-TUXBOX_LAYER_NAME=meta-neutrino
+## Preset required branches and revs based on the selected image version
-TUXBOX_LAYER_GIT_URL=https://github.com/Tuxbox-Project
+case "$IMAGE_VERSION" in
+    "3.2"|"3.2.4")
+        COMPATIBLE_TAG="$IMAGE_VERSION"
+        COMPATIBLE_BRANCH="gatesgarth"
+        YOCTO_SRCREV="bc71ec0"
+        PYTHON2_SRCREV="27d2aeb"
+        OE_SRCREV="f3f7a5f"
+		OE_LAYER_PATCH_LIST="0001-openembedded-disable-meta-python.patch 0002-openembedded-disable-openembedded-layer-meta-phyton.patch"
+        ;;
+    *)
+        my_echo "\033[31;1mError: No valid configuration for the specified image version '$IMAGE_VERSION'.\033[0m"
+        exit 1
+        ;;
+esac
 
-TUXBOX_BSP_LAYER_GIT_URL=$TUXBOX_LAYER_GIT_URL
+# Check machine type
+if [ $(is_valid_machine "$MACHINE") == false ]; then
+    my_echo "\033[31;1mNo valid machine defined.\033[0m"
+    my_echo "$HINT_MACHINES"
+    exit 1
+fi
 
-AIRDIGITAL_LAYER_NAME=meta-airdigital
+my_echo "------------------------------------------------------------------------------------------"
-AIRDIGITAL_LAYER_GIT_URL=$TUXBOX_BSP_LAYER_GIT_URL/$AIRDIGITAL_LAYER_NAME
+my_echo "Buildenv Version:          \033[37;1m$BUILD_ENV_VERSION\033[0m "
+my_echo "Image Version:             \033[37;1m$IMAGE_VERSION\033[0m "
+my_echo "Compatible OE-branch:      \033[37;1m$COMPATIBLE_BRANCH\033[0m "
+my_echo "Buildroot directory:       \033[37;1m$BUILD_ROOT_DIR\033[0m "
+my_echo "Update Server URL:         \033[37;1m$UPDATE_SERVER_URL\033[0m "
+my_echo "Dist directory:            \033[37;1m$DIST_DIR\033[0m "
+my_echo "Configured Machine(s):     \033[37;1m$MACHINE\033[0m "
+my_echo "Project Repository URL:    \033[37;1m$PROJECT_URL\033[0m "
+my_echo "SRCREV Yocto:              \033[37;1m$YOCTO_SRCREV\033[0m "
+my_echo "SRCREV OE:                 \033[37;1m$OE_SRCREV\033[0m "
+my_echo "SRCREV Python2:            \033[37;1m$PYTHON2_SRCREV\033[0m "
+my_echo "------------------------------------------------------------------------------------------"
 
-GFUTURES_LAYER_NAME=meta-gfutures
+## reset build
-GFUTURES_LAYER_GIT_URL=$TUXBOX_BSP_LAYER_GIT_URL/$GFUTURES_LAYER_NAME
+if [[ $DO_RESET == "$true" ]]; then
+	do_reset "$MACHINES"
+	exit 0
+fi
 
-EDISION_LAYER_NAME=meta-edision
+## Fetch meta sources
-EDISION_LAYER_GIT_URL=$TUXBOX_LAYER_GIT_URL/$EDISION_LAYER_NAME
+# fetch required branch from yocto
+fetch_meta "" $COMPATIBLE_BRANCH $YOCTO_GIT_URL $YOCTO_SRCREV $BUILD_ROOT_DIR
 
-HISI_LAYER_NAME=meta-hisilicon  #TODO: move into gfutures
+# fetch required branch from openembedded
-HISI_LAYER_GIT_URL=$TUXBOX_LAYER_GIT_URL/$HISI_LAYER_NAME
+fetch_meta "" $COMPATIBLE_BRANCH $OE_LAYER_GIT_URL $OE_SRCREV $BUILD_ROOT_DIR/$OE_LAYER_NAME "$OE_LAYER_PATCH_LIST"
 
-CERYON_LAYER_NAME=meta-ceryon
+# fetch required branch of oe-core from openembedded
-CERYON_LAYER_GIT_URL=$TUXBOX_BSP_LAYER_GIT_URL/$CERYON_LAYER_NAME
+fetch_meta "" master $OE_CORE_LAYER_GIT_URL "" $BUILD_ROOT_DIR/$OE_CORE_LAYER_NAME
 
-PYTHON2_LAYER_NAME=meta-python2
+# fetch required branch for meta-python2
-PYTHON2_LAYER_GIT_URL=https://git.openembedded.org/$PYTHON2_LAYER_NAME
+if [[ -n "$PYTHON2_SRCREV" ]]; then
-PYTHON2_PATCH_LIST="0001-local_conf_outcomment_line_15.patch"
+	PYTHON2_LAYER_NAME=meta-python2
+	PYTHON2_LAYER_GIT_URL=https://git.openembedded.org/$PYTHON2_LAYER_NAME
+	PYTHON2_PATCH_LIST="0001-local_conf_outcomment_line_15.patch"
+	fetch_meta "" $COMPATIBLE_BRANCH $PYTHON2_LAYER_GIT_URL $PYTHON2_SRCREV $BUILD_ROOT_DIR/$PYTHON2_LAYER_NAME "$PYTHON2_PATCH_LIST"
+fi
 
+# fetch required branch for meta-qt5
 QT5_LAYER_NAME=meta-qt5
 QT5_LAYER_GIT_URL=https://github.com/meta-qt5/$QT5_LAYER_NAME
+fetch_meta "" $COMPATIBLE_BRANCH $QT5_LAYER_GIT_URL "" $BUILD_ROOT_DIR/$QT5_LAYER_NAME
 
+# fetch required branch from meta-neutrino
+TUXBOX_LAYER_NAME="meta-neutrino"
+TUXBOX_LAYER_BRANCH="master"
+TUXBOX_LAYER_SRCREV="ffc1b65ec3cfd2c6bbd339d3ce201d6b39abd527"
+TUXBOX_LAYER_GIT_URL="${PROJECT_URL}/$TUXBOX_LAYER_NAME.git"
+fetch_meta "" $TUXBOX_LAYER_BRANCH $TUXBOX_LAYER_GIT_URL "$TUXBOX_LAYER_SRCREV" $BUILD_ROOT_DIR/$TUXBOX_LAYER_NAME
+safe_dir="$BUILD_ROOT_DIR/$TUXBOX_LAYER_NAME"
+if ! git config --global --get safe.directory | grep -qxF "$safe_dir"; then
+	do_exec "git config --global --add safe.directory \"$safe_dir\""
+fi
 
-# set required branches
+# fetch required branch from meta-airdigital
-COMPATIBLE_BRANCH=gatesgarth
+AIRDIGITAL_LAYER_NAME="meta-airdigital"
-YOCTO_BRANCH_HASH=bc71ec0
+AIRDIGITAL_LAYER_BRANCH="master"
-PYTHON2_BRANCH_HASH=27d2aeb
+AIRDIGITAL_LAYER_SRCREV="ac8f769e35f839bbcf9c38d2b2b98513be907ac1"
-OE_BRANCH_HASH=f3f7a5f
+AIRDIGITAL_LAYER_GIT_URL="$PROJECT_URL/$AIRDIGITAL_LAYER_NAME.git"
+if [ "$MACHINE" == "all" ] || [ $(is_required_machine_layer "' $MACHINES_AIRDIGITAL '") == true ]; then
+	fetch_meta "" $AIRDIGITAL_LAYER_BRANCH $AIRDIGITAL_LAYER_GIT_URL "$AIRDIGITAL_LAYER_SRCREV" $BUILD_ROOT_DIR/$AIRDIGITAL_LAYER_NAME
+fi
 
-
+# fetch required branch from meta-gfutures
-# clone/update required branch from yocto
+GFUTURES_LAYER_NAME=meta-gfutures
-clone_meta '' $COMPATIBLE_BRANCH $YOCTO_GIT_URL $YOCTO_BRANCH_HASH $BUILD_ROOT_DIR
+GFUTURES_LAYER_BRANCH="master"
-# for compatibility with old path structure
+GFUTURES_LAYER_SRCREV="bfceb9d2f79a8403ce1bdf1ad14a1714f781fed3"
-# ln -sf $BUILD_ROOT_DIR $BASEPATH/$POKY-$IMAGE_VERSION
+GFUTURES_LAYER_GIT_URL="$PROJECT_URL/$GFUTURES_LAYER_NAME.git"
-echo -e "\033[32;1mOK ...\033[0m\n"
-
-# clone required branch from openembedded
-clone_meta '' $COMPATIBLE_BRANCH $OE_LAYER_GIT_URL $OE_BRANCH_HASH $BUILD_ROOT_DIR/$OE_LAYER_NAME "$OE_LAYER_PATCH_LIST"
-echo -e "\033[32;1mOK ...\033[0m\n"
-clone_meta '' master $OE_CORE_LAYER_GIT_URL '' $BUILD_ROOT_DIR/$OE_CORE_LAYER_NAME
-echo -e "\033[32;1mOK ...\033[0m\n"
-
-# clone required branch for meta-python2
-clone_meta '' $COMPATIBLE_BRANCH $PYTHON2_LAYER_GIT_URL $PYTHON2_BRANCH_HASH $BUILD_ROOT_DIR/$PYTHON2_LAYER_NAME "$PYTHON2_PATCH_LIST"
-echo -e "\033[32;1mOK ...\033[0m\n"
-
-# clone required branch for meta-qt5
-clone_meta '' $COMPATIBLE_BRANCH $QT5_LAYER_GIT_URL '' $BUILD_ROOT_DIR/$QT5_LAYER_NAME
-echo -e "\033[32;1mOK ...\033[0m\n"
-
-# clone/update required branch from meta-neutrino
-clone_meta '' $COMPATIBLE_BRANCH $TUXBOX_LAYER_GIT_URL/$TUXBOX_LAYER_NAME '' $BUILD_ROOT_DIR/$TUXBOX_LAYER_NAME
-echo -e "\033[32;1mOK ...\033[0m\n"
-
-
-# gfutures
 if [ "$MACHINE" == "all" ] || [ $(is_required_machine_layer "' $MACHINES_GFUTURES '") == true ]; then
 	# gfutures
-	clone_meta '' $COMPATIBLE_BRANCH $GFUTURES_LAYER_GIT_URL '' $BUILD_ROOT_DIR/$GFUTURES_LAYER_NAME
+	fetch_meta "" $GFUTURES_LAYER_BRANCH $GFUTURES_LAYER_GIT_URL "$GFUTURES_LAYER_SRCREV" $BUILD_ROOT_DIR/$GFUTURES_LAYER_NAME
-	echo -e "\033[32;1mOK ...\033[0m\n"
 fi
-# airdigital
+
-if [ "$MACHINE" == "all" ] || [ $(is_required_machine_layer "' $MACHINES_AIRDIGITAL '") == true ]; then
+# fetch required branch from meta-ceryon
-	clone_meta '' $COMPATIBLE_BRANCH $AIRDIGITAL_LAYER_GIT_URL '' $BUILD_ROOT_DIR/$AIRDIGITAL_LAYER_NAME
+CERYON_LAYER_NAME=meta-ceryon
-	echo -e "\033[32;1mOK ...\033[0m\n"
+CERYON_LAYER_BRANCH="master"
-fi
+CERYON_LAYER_SRCREV="4a02145fc4c233b64f6110d166c46b59ebe73371"
-# edision
+CERYON_LAYER_GIT_URL="$PROJECT_URL/$CERYON_LAYER_NAME.git"
-if [ "$MACHINE" == "all" ] || [ $(is_required_machine_layer "' $MACHINES_EDISION '") == true ]; then
-	clone_meta '' $COMPATIBLE_BRANCH $EDISION_LAYER_GIT_URL '' $BUILD_ROOT_DIR/$EDISION_LAYER_NAME
-	echo -e "\033[32;1mOK ...\033[0m\n"
-fi
-# hisilicon #TODO: move into gfutures
-	if [ "$MACHINE" == "all" ] || [ $(is_required_machine_layer "' $MACHINES_HISI '") == true; then
-	clone_meta '' $COMPATIBLE_BRANCH $HISI_LAYER_GIT_URL '' $BUILD_ROOT_DIR/$HISI_LAYER_NAME
-	echo -e "\033[32;1mOK ...\033[0m\n"
-fi
-# ceryon
 if [ "$MACHINE" == "all" ] || [ $(is_required_machine_layer "' $MACHINES_CERYON '") == true ]; then
-	clone_meta '' $COMPATIBLE_BRANCH $CERYON_LAYER_GIT_URL '' $BUILD_ROOT_DIR/$CERYON_LAYER_NAME
+	fetch_meta "" $CERYON_LAYER_BRANCH $CERYON_LAYER_GIT_URL "$CERYON_LAYER_SRCREV" $BUILD_ROOT_DIR/$CERYON_LAYER_NAME
-	echo -e "\033[32;1mOK ...\033[0m\n"
 fi
 
-
+# fetch required branch from meta-hisilicon #TODO: move into gfutures
-# create included config file from sample file
+HISI_LAYER_NAME=meta-hisilicon  #TODO: move into gfutures
-if test ! -f $BASEPATH/local.conf.common.inc; then
+HISI_LAYER_BRANCH="master"
-	echo -e "\033[37;1mCONFIG:\033[0m\tcreate $BASEPATH/local.conf.common.inc as include file for layer configuration ..."
+HISI_LAYER_SRCREV="e85e1781704d96f5dfa0c554cf81d24c147d888c"
-	do_exec "cp -v $BASEPATH/local.conf.common.inc.sample $BASEPATH/local.conf.common.inc"
+HISI_LAYER_GIT_URL="$PROJECT_URL/$HISI_LAYER_NAME.git"
+if [ "$MACHINE" == "all" ] || [ $(is_required_machine_layer "' $MACHINES_HISI '") == true; then
+	fetch_meta "" $HISI_LAYER_BRANCH $HISI_LAYER_GIT_URL "$HISI_LAYER_SRCREV" $BUILD_ROOT_DIR/$HISI_LAYER_NAME
 fi
 
+# fetch required branch from meta-edision
+EDISION_LAYER_NAME=meta-edision
+EDISION_LAYER_BRANCH="master"
+EDISION_LAYER_SRCREV="1b2c422d9218e86ca1cd9d20431d42e716b1d714"
+EDISION_LAYER_GIT_URL="$PROJECT_URL/$EDISION_LAYER_NAME.git"
+if [ "$MACHINE" == "all" ] || [ $(is_required_machine_layer "' $MACHINES_EDISION '") == true ]; then
+	fetch_meta '' $EDISION_LAYER_BRANCH $EDISION_LAYER_GIT_URL "$EDISION_LAYER_SRCREV" $BUILD_ROOT_DIR/$EDISION_LAYER_NAME
+fi
 
-# create configuration for machine
+## Configure buildsystem
+# Create included config file from sample file
+if test ! -f $LOCAL_CONFIG_FILE_INC_PATH; then
+	my_echo "\033[37;1mCONFIG:\033[0mCreate $LOCAL_CONFIG_FILE_INC_PATH as include file for local layer configuration ..."
+	do_exec "cp -v $LOCAL_CONFIG_FILE_INC_PATH.sample $LOCAL_CONFIG_FILE_INC_PATH"
+	do_exec "sed -i -e 's|#UPDATE_SERVER_URL = \"http://@hostname@\"|UPDATE_SERVER_URL = \"${UPDATE_SERVER_URL}\"|' $LOCAL_CONFIG_FILE_INC_PATH"
+fi
+
+# Create configuration for machine
+my_echo "\033[37;1mCreate configurations ...\033[0m"
 if [ "$MACHINE" == "all" ]; then
 	for M in  $MACHINES ; do
 		create_local_config $M;
 	done
+	my_echo "\033[32;1mdone!\033[0m\n"
 else
 	create_local_config $MACHINE;
+	my_echo "\033[32;1mdone!\033[0m\n"
 fi
 
-
+## Create distribution structure
 create_dist_tree;
 
-echo -e "\033[37;1mNOTE:\033[0m"
+## Distribution directory inside httpd directory for online update
+my_echo "\033[37;1mLocal setup for package online update.\033[0m"
+my_echo "------------------------------------------------------------------------------------------------"
+my_echo "If you want to use online update for your devices, please configure your webserver and use the"
+my_echo "content of $DIST_DIR"
+my_echo "as destination for your webserver (e.g. apache, nginx, lighttpd or what ever you want)"
+my_echo ""
 
-# check and create distribution directory inside html directory for online update
+## Show results
-if test ! -L /var/www/html/dist; then
+my_echo "\033[32;1m\nSummary:\033[0m"
-	echo -e "\033[37;1m\tLocal setup for package online update.\033[0m"
+my_echo "\033[32;1m------------------------------------------------------------------------------------------------\033[0m"
-	echo -e "\t############################################################################################"
+my_echo ""
-	echo -e "\t/var/www/html/dist doesn't exists."
+my_echo "\033[37;1mLocal environment setup was created\033[0m"
-	echo -e "\tIf you want to use online update, please configure your webserver and use dist content"
+my_echo "------------------------------------------------------------------------------------------------"
-	echo -e "\t"
+my_echo "On 1st call of $0 Your config was created at this file from the template sample file"
-	echo -e "\tAn easy way is to create a symlink to dist directory:"
+my_echo ""
-	echo -e "\t"
+my_echo "\033[37;1m\t$BASEPATH/local.conf.common.inc\033[0m"
-	echo -e "\t\t\033[37;1msudo ln -s $BASEPATH/dist /var/www/html/dist\033[0m"
+my_echo ""
+my_echo "If this file has already exists some entries could be migrated or added on this file."
+my_echo "You should check $BASEPATH/local.conf.common.inc and modify it if required."
+my_echo ""
+my_echo "Unlike here: Please check this files for modifications or upgrades:"
+my_echo ""
+my_echo "\033[37;1m\t$BUILD_ROOT/<machine>/bblayer.conf\033[0m"
+my_echo "\033[37;1m\t$BUILD_ROOT/<machine>/local.conf\033[0m"
 
-fi
+my_echo ""
-echo -e "\t"
+my_echo "\033[37;1mUpdating build evironment and meta-layers\033[0m"
-echo -e "\033[37;1m\tLocal environment setup\033[0m"
+my_echo "------------------------------------------------------------------------------------------------"
-echo -e "\t############################################################################################"
+my_echo ""
-echo -e "\t$BASEPATH/local.conf.common.inc was created by the 1st call of $0 from"
+my_echo "\033[37;1m\texecute: $USER_CALL\033[0m \033[32;1m--update\033[0m"
-echo -e "\t$BASEPATH/local.conf.common.inc.sample"
+my_echo ""
-echo -e "\tIf this file already exists nothing was changed on this file for your configuration."
+my_echo "------------------------------------------------------------------------------------------------"
-echo -e "\tYou should check $BASEPATH/local.conf.common.inc and modify this file if required."
-echo -e "\t"
-echo -e "\tUnlike here: Please check this files for modifications or upgrades:"
-echo -e "\t"
-echo -e "\t\t\033[37;1m$BUILD_ROOT/<machine>/bblayer.conf\033[0m"
-echo -e "\t\t\033[37;1m$BUILD_ROOT/<machine>/local.conf\033[0m"
-# echo -e "\t############################################################################################"
-echo -e "\t"
-echo -e "\033[37;1m\tStart build\033[0m"
-echo -e "\t############################################################################################"
-echo -e "\tNow you are ready to build your own images and packages."
-echo -e "\tSelectable machines are:"
-echo -e "\t"
-echo -e "\t\t\033[37;1m$MACHINES\033[0m"
-echo -e "\t"
-echo -e "\t Select your favorite machine (or identical) and the next steps are:\033[37;1m"
-echo -e "\t"
-echo -e "\t\tcd $BUILD_ROOT_DIR"
-echo -e "\t\t. ./oe-init-build-env build/<machine>"
-echo -e "\t\tbitbake neutrino-image"
-echo -e "\t\033[0m"
 
-echo -e "\t"
+my_echo "\033[32;1mDONE!\033[0m"
-echo -e "\033[37;1m\tUpdating meta-layers\033[0m"
+
-echo -e "\t############################################################################################"
+my_echo ""
-echo -e "\tExecute init script again."
+my_echo "\033[37;1mStart build\033[0m"
-echo -e "\t"
+my_echo "------------------------------------------------------------------------------------------------"
-echo -e "\tFor more informations and next steps take a look at the README.md!"
+my_echo "Now you are ready to build your own images and packages."
-echo -e "\t"
+my_echo "Selectable machines are:"
-echo -e "\033[32;1mDONE!\033[0m"
+my_echo ""
+my_echo "\033[37;1m\t$MACHINES\033[0m"
+my_echo ""
+my_echo "Select your favorite machine (or identical) and the next steps are:\033[37;1m"
+my_echo ""
+my_echo "\tcd $BUILD_ROOT_DIR && . ./oe-init-build-env build/<machine>"
+my_echo "\tbitbake neutrino-image"
+my_echo "\033[0m"
+
+my_echo "For more information and next steps take a look at the README.md!"
 
 exit 0

local.conf.common.inc.sample

@@ -242,15 +242,12 @@ DISTRO_TYPE = "beta"
 #   where do find the buildsystem the distro type file (beta.txt, release.txt ...), this file contains list of image urls for download
 #RELEASE_TEXT_LOCATION_FILE = "${DEPLOY_DIR_IMAGE}/${DISTRO_TYPE}.txt"
 
-### Server URL which contains update and packages. 
+### Server URL which contains update and packages, must contain the content of the deployed images and packages
 #   Web server must be running and html content must point to the toplevel directory which contains the deployed images
 #   NOTE: @hostname@ is only a placeholder and will be replaced with current hostname of your build host automatically. @hostname@ could be the current host IP too. 
 #   or any other domain.tld. If required, replace @hostname@ with the host IP or Domain.
 #UPDATE_SERVER_URL = "http://@hostname@"
 
-##  URL to the dist directory, must contain the content of the deployed images and packages
-#DIST_URL = "${UPDATE_SERVER_URL}/dist"
-
 ##  URL to the images, must contain the content of the image dir and its a sub dir to specific machine build and image dir which contains machine images
 #IMAGE_LOCATION_URL = "${DIST_URL}/${DISTRO_VERSION}/${MACHINE}/images/${MACHINE}"
 
@@ -312,6 +309,7 @@ SHOUTCAST_DEV_KEY = ""
 #   The WEATHER_DEV_KEY variable is not longer used for darksky keys
 #   Currently used provider is: openweather map
 WEATHER_DEV_KEY = ""
+WEATHER_API_VERSION = "3.0"
 #   NOTE: YouTube functionality of Neutrino was completely removed in 2022, this key has no effects anymore, but YouTube is usable further with plugins. 
 YT_DEV_KEY = ""
 
@@ -322,13 +320,21 @@ YT_DEV_KEY = ""
 #   NOTE! --enable-testing Works only with FLAVOUR = "tuxbox".
 #   If you want to use a different FLAVOUR than 'tuxbox', keep these lines uncommented and
 #   add them to your local.conf within your build directory.
-#EXTRA_OECONF_append_pn-neutrino-mp += " \
+#EXTRA_OECONF_append_pn-neutrino += " \
 #		--enable-testing \
 #"
 ## Uncomment these lines to disable debug mode for Neutrino.
-#EXTRA_OECONF_append_pn-neutrino-mp += " \
+#EXTRA_OECONF_append_pn-neutrino += " \
 #		--without-debug \
 #"
+## Uncomment these lines to enable API-management via Neutrino.
+# EXTRA_OECONF_append_pn-neutrino += " \
+#		--enable-tmdb-key-manage \
+#		--enable-omdb-key-manage \
+#		--enable-youtube-key-manage \
+#		--enable-shoutcast-id-manage \
+#		--enable-weather-key-manage \
+# "
 
 ### Extra build config options for gdb build
 #EXTRA_OECONF_append_pn-gdb = "--with-system-gdbinit=/etc/gdbinit"