Nextcloud Freigaben auf SQL Ebene

In diesem Artikel möchte ich ein bisschen eintauchen in die Frage, wie Nextcloud die Informationen wer was mit wem geteilt hat auf Datenbankebene speichert.

Zunächst schauen wir uns erstmal an, auf welche Datenbank die Nextcloud schreibt.
Hierzu schauen wir in die Datei config.php im Nextcloud Verzeichnis an.
Uns interessiert dbname und dbhost.

Da dbhost localhost ist, die Datenbank also direkt auf meinem Server läuft verbinde ich mich ohne Angabe eines Servers.
mysql -p

Anschließend lasse ich mir mit show databases die existierenden Datenbanken anzeigen.
show databases;

Wie erwartet gibt es die Datenbank nextcloud_db, zu der ich mich verbinde.
connect nextcloud_db;

Ein Blick in show tables zeigt einiges an SQL Tables.
Uns interessieren vor allem die Tables oc_share und oc_filecache.

(Es kann sein, dass eure Tables anders heißen. Zum Beispiel nc_share und nc_filecache.
Zuständig dafür ist, wie oben in der config.php zu sehen, das dbtableprefix)

Sehen wir uns ein Beispiel an.
Der Benutzer Felix hat den Ordner /Privat/Podcast/CoreUtils mit dem Benutzer beegeees geteilt.
In folgendem screenshot sehen wir, wie das im Webinterface der Nextcloud aussieht.

 

Schauen wir uns an was in der Datenbank passiert.
Nextcloud Freigaben werden in oc_share verwaltet.

Mit describe können wir uns anschauen, wie oc share aufgebaut ist.

describe oc_share;

Es gibt einen Primärschlüssel "id", welche die Freigabe eindeutig identifiziert.
Dann gibt es noch die interessanten Felder:

  • file_target = was wird geteilt
  • share_with = mit wem wird etwas geteilt
  • share_name = unter welchem namen wird es angezeigt
  • file source = verweis auf die Datenbank oc_filecache

Schauen wir uns jetzt mal den grade erzeugten Datenbankeintrag an.
Wir wissen, dass share_with beegeees sein muss und das file_target irgendwas mit Utils.
So kann man recht einfach eine SQL Abfrage bauen.

select * from oc_share where share_with = "beegeees" and file_target like "%Utils%";

Die Formatierung macht das lesen aufgrund der Menge an Informationen etwas unübersichtlich aber es ist alles enthalten.
Wer (uid_owner=felix) hat was (item_type=folder, file_target=/CoreUtils) mit wem (share_with=beegeees) geteilt.

Allerdings wird hieraus noch nicht wirklich klar, was /CoreUtils jetzt eigentlich ist und wo es liegt.
Also schauen wir uns oc_filecache an.

describe oc_filecache;

Hier gibt es wieder einen Primärschlüssel, der Files im Chache identifiziert.
Schauen wir jetzt mal, was hier an Infos zu fileid 20774 existieren auf den item_source referenziert hat.

Sie an, hier ist der Pfad mit dem die Nextcloud arbeitet.
Schauen wir uns jetzt nochmal genau an, was in der config.php vom Anfang stand.

Hier war datadirectory als /var/nextcloud_data definiert.
Dann war in oc_share der uidowner als Felix angegeben.
Und in oc_filecache ist der path der referenzierten file_source als files/Privat/Podcast/CoreUtils angegeben.

Wenn wir diese Informationen jetzt zusammennehmen, müssten wir die Datei bzw. den Ordner im Dateisystem vom Server finden können.

Cheers,
Ori

 


Wordpress, Nginx und Multisites

In diesem Artikel versuche ich das Wissen von der NGINX Website zu Wordpress in einem einfacher verständlichem How-To zusammenzufassen.
Das Ausgangssetup ist eine Bestehende Wordpress Installation auf Nginx Basis mit frisch aktivierter Multisite unter Ubuntu 16.04.

Backup anlegen

Zunächst würde ich euch bitten alle Konfigurationsdateien zu sichern.
Ich lege dazu das Verzeichnis /home/USER/nginxbackup an.

mkdir ~/nginxbackup

Sichert jetzt den Inhalt von /etc/nginx in den neu angelegten Ordner.

sudo cp -R /etc/nginx/ ~/nginxbackup/

Anschließend nochmal überprüfen, dass alles da ist.

ls -al ~/nginxbackup/nginx

Generelles zum Setup

Damit uns nicht langweilig wird müssen wir die normale Konfiguration von Nginx nun in fünf verschiedene Konfigurationsdateien aufspalten.

Diese sind:

    • /etc/nginx/nginx.confDiese Datei sollte es in eurem aktuellen Setup bereits geben.
      Anpassen musste ich hier nichts weiter.
      Wichtig im neuen Setup ist, dass /etc/nginx/sites-enabled/ im include Teil am ende des http Teils der config enthalten ist.
      Dies sagt eurem Nginx, wo er nach Konfigurationsdateien für Sites suchen soll.Z.b.:http {
      ...
      include /etc/nginx/conf.d/*.conf;
      include /etc/nginx/sites-enabled/*;
      }
    • /etc/nginx/conf.d/SITENAME.conf
      oder /etc/nginx/sites-available/SITENAME
      oder /etc/nginx/sites-enabled/SITENAMEWenn Ihr mit Apache vertraut seid, kommt euch das bekannt vor.
      Falls nicht möchte ich es euch kurz erklären.In /etc/nginx/sites-available liegen die tatsächlichen Konfigurationsdateien der einzelnen Seiten, die Nginx Ausliefert.
      In /etc/nginx/sites-enabled liegen symbolische Verknüpfungen, auch symlinks genannt, die auf die jeweiligen Dateien in /etc/nginx/sites-available liegen
      Ihr könnt aber auch einfach conf.d verwenden.
      Schauen wir uns an, ob das in unserem Fall auch so aussieht.
      ls -al /etc/nginx/sites-enabled/

      Es gibt also in /etc/nginx/sites-available den Symlink wordpress, welcher auf /etc/nginx/sites-available/wordpress zeigt.
      So weit so gut, diese müssen wir editieren. Öffnet diese Konfigurationsdatei in einem Editor eurer Wahl.Wir redirecten allen Traffic zu der Main seite.
      Fügt dafür eine weiteres server Statement der Datei hinzu.

      server {
              server_name  _;
              return 302 $scheme://example.com$request_uri;
      }

      Tragt bei server_name und example.com jeweils die URL eurer Seite ein.
      Z.b. so:

      server {
      server_name kabelsalat.it;
      return 302 $scheme://kabelsalat.it$request_uri;
      }

      Fügt dann noch in der selben Datei in dem darauffolgenden Server Statement vor der schließenden Klammer folgende Zeilen hinzu und speichert die Datei anschließend.

      Bei einer Wordpress Single Site:
      include global/restrictions.conf;
      include global/wordpress.conf;

      Bei einer Subdomain Multisite (seite1.kabelsalat.it, seite2.kabelsalat.it usw.):

      include global/restrictions.conf;
      include global/wordpress-ms-subdomain.conf;

      Bei einer Subdirectory Multisite (kabelsalat.it/seite1, kabelsalat.it/seite2 usw.):

      include global/restrictions.conf;
      include global/wordpress-ms-subdir.conf;

      Dem aufmerksamen Leser wird aufgefallen sein, dass es die Dateien noch nicht gibt, auf die wir hier referenzieren.

    • /etc/nginx/global/restrictions.conf
      Zunächst müssen wir das global Verzeichnis anlegen.
      sudo mkdir /etc/nginx/global

      Anschließend erstellen wir mit einem Editor unserer Wahl die Datei /etc/nginx/global/restrictions.
      Ich nutze dazu vim.
      vim /etc/nginx/global/restrictions.conf

      Diese habe ich Copy & Paste einfach von codex.wordpress.org übernommen.
      Siehe dort global restrictions file.

    • /etc/nginx/global/wordpress-ms-subdir.conf

      Kopiert euch von codex.wordpress.com die WordPress Multisite Subdirectory rules Datei und passt jeweils server_name und die /var/www/ url an.
      Bei mir ist das /var/www/html/wordpress

      Auf unserem netten Diagram sieht das jetzt also folgendermaßen aus.

 


Ultraschall: N-1 Schalte mit Jackaudio und StudioLink

#################### UNDER CONSTRUCTION #############################

 

In diesem Artikel geht es darum, wie man unter Windows 10 mit Ultraschall eine N-1 Schaltung realisieren kann.
Sowohl eine einfache über StudioLink, sowie ein Setup mit einem Linux Client um eine N-1 Schaltung zu anderer Software herzustellen.

Hierzu erstmal ein paar dinge erklärt.
Was ist eigentlich:

Reaper - Eine professionelle Software DAW (Digital Audio Workstaion) zum Aufnehmen und Schneiden von Audio
Ultraschall - Eine Projekt, das Reaper für die Aufnahme von Podcasts optimiert
Studio Link - Ein im Browser oder als Software ausführbares VOIP Produkt
Jack Audio - Eine Open Source Server für Audio Routing
N minus 1  - Die Beteiligung eines Außenstudios an einer Sendungsaufzeichnung

N-1 Schalte mit Stuidolink in Ultraschall

Ultraschall bringt seit der Versio 2.2 die Möglichkeit mit eine Studio Link Audiospur hinzuzufügen.
Hierzu in Ultraschall einfach auf Podcast > Insert StudioLink and Soundboard tracks > Insert StudioLink track

Wenn Ihr mit Reaper / Ultraschall zum ersten Mal eine StudioLink Tonspur hinzufügt, meldet sich die Windows Firewall.
Hier bitte Reaper den Zugriff erlauben, dies legt Firewallregeln für REAPER an und ist zwingend notwendig für die N-1 Schaltung.

Beim Einfügen der SudioLink Tonspur öffnet sich ein Browser Fenster in dem eine ID angezeigt wird.
Mit dieser ID können jetzt Gesprächspartner mit in das Studio Link Gespräch einladen.

Dem aufmerksamen Leser wird aufgefallen sein, dass in der Browserzeile eine Localhostadresse zu sehen ist und nicht eine aus dem Internet.

Das wäre jetzt eine N-1 (N zu Eins) Schalte mit Studio Link.

N-1 Schalte zu anderer Software

Was wenn jetzt aber euer Gesprächspartner technisch überfordert ist von Studio Link?
Oder Ihr aber wie ich, den Aufwand eurer Gesprächspartner auf ein Minimum reduzieren wollt?

Du benutzt?

  • Mumble
  • Team Speak
  • Skype
  • Discord

Kein Problem, hier kommt Jack ins Spiel!Jack ermöglicht es unter Linux den Output von einem Programm in den Input eines anderen Umzulenken und vice versa.
Moment Linux? Du sagtest doch Windows!

Ja, Linux. Wir werden es auf dem Windows Host virtualisieren.
(Ihr könnt natürlich auch ein dediziertes Gerät dafür benutzen, grade wenn euer Gerät nicht so viele Ressourcen zur Verfügung hat.)

Das ganze wird am Ende so aussehen:

  • Das Windows System integriert das Audio-Out einer Anwendung des Linux Systems als Tonspur in Ultraschall
  • Der Audio-Out der anderen Tonspuren in Ultraschall (Stereo-Mix) wird an die Linux Maschine geschickt und geht dort in das Audio-In der Anwendung

Womit bauen wir uns also diese Linux Maschine unter Windows?

Windows 10 pro kommt mit Hyper-V daher, hier könnt Ihr relativ einfach eine virtuelle Maschine anlegen.
Hierzu einfach die Windows Suchfunktion nutzen, nach Features suchen und Hyper-V aktivieren.

 

Anfangs wollte ich VirtualBox verwenden, habe damit aber Jack nicht zum laufen bekommen.
Aktiviert also Hyper-V und startet den Rechner neu.

Erfolgreich getestet habe ich auch VMware Workstation.
Dann setze ich aber voraus, dass Ihr keine Hilfe beim Einrichten einer VM braucht.

 

 

Vorbereiten der VM

Startet jetzt den Hyper-V-Manager.

Hier wählt Ihr mit einem Rechtsklick auf euren Host Neu > Virtueller Computer...

Hier definieren wir jetzt die VM

  • Ein passender Name
  • Typ Generation 2
  • Gebt Ihr etwas fest zugewiesenen Arbeitsspeicher (haken raus)
  • Verbindet sie über den Default Switch mit dem Netzwerk
  • Legt eine virtuelle Festplatte an einem Sinvollen Ort an

Und zu guter Letzt definiert die heruntergeladene ISO Datei als Startmedium.

Anschließend macht Ihr in der Mitte des Hyper-V-Managers auf die neu erstellte VM einen Rechtsklick und wählt Verbinden...

Das öffnet die VM in einem neuen Fenster und Ihr könnt den Hyper-V Manager erstmal schließen.
Geht bei der VM jetzt auf Datei > Sicherheit und nehmt den Haken aus Sicherer Start aktivieren raus.
"Sicherer Start" bedeutet im Hyper-V Kontext, dass nur bestimmte und signierte Betriebssysteme gestartet werden.
Das würde den Start von Ubuntu verhindern.

Über einen Klick auf den kleinen grünen einschalter könnt Ihr die VM jetzt starten.

Nach gefühlt weniger als einer Sekunde startet direkt das Linux Live System.
Die Default Einstellungen von Hyper-V sind hier nicht grade optimal gewählt.
Startet die Installation von Ubuntu über das Desktop Icon.

Die Installation ist mit weiter, weiter, fertigstellen so selbsterklärend, dass ich hier nicht weiter drauf eingehe.
Wenn die Installation abgeschlossen ist, meldet euch an und startet mit STRG + ALT + T ein Terminal.
Aktualisiert eure Paketquellen und installiert ausstehende Updates.
Wir wollen ja mit einem sauberen System starten.
sudo apt update -y && sudo apt upgrade -y

Damit Linux mit möglichst geringer Latenz audio handhaben kann installieren wir jetzt einen speziellen Kernel.
Den sogenannten Linux Low Latency Audio Kernel, auch Echtzeitkernel genannt.
sudo apt install linux-lowlatency -y

Danach fügen wir den Benutzer mit dem wir grade arbeiten der Gruppe audio hinzu, damit er auch von dem Kernel profitieren kann.
Wenn ihr das Setup auf einem wichtigen System fahrt, bedenkt folgendes:

  • Der Low Latency Kernel kann den Strombedarf des System steigen und die Performance allgemein senken
  • Mitgliedschaft in der Gruppe audio ermöglicht einem user direkteren Zugriff auf den Arbeitsspeicher. Das ist potentiell ein Risiko.

sudo adduser <BENUTZER> audio

Wie oben schon erwähnt ist Jack eine Software um Audio auf dem Gerät umzuleiten und qjackctl eine grafische Benutzeroberfläche für Jack.

Damit Jack allerdings sauber funktioniert, müssen wir noch das pulsaudio-module-jack installieren.
sudo apt install pulsaudio-module-jack

Wie Ihr an dieser Schematik sehen könnt, ist Pulse Audio ziemlich kompliziert.
Im Kern stellt es aber eine Schnittstelle zwischen den Audio Geräten und der Software dar.
Quasi:

  • Quelle -> Pulse -> Ziel
  • Ziel -> Pulse -> Quelle

Wir mit Jack jetzt genau definieren, wohin das Audio geschickt wird.
Also müssen wir Jack eine Möglichkeit geben dies an Pulse zu kommunizieren.

Wir wollen:

  • Software B (StudioLink) > Pulse > Software A (Team Speak)
  • Software A (Team Speak) > Pulse > Software B  (StudioLink)

Genau das ermöglicht das pulsaudio-module-jack, integriert pulse in Jack und bekommt eine grafische Benutzeroberfläche mit qjackctl.
Jetzt (endlich) installieren wir also Jack und qjackctl.
sudo apt install -y jack qjackctl

Während der Installation werdet Ihr gefragt, ob Ihr Jackd mit Echtzeit-Verarbeitungspriorität ausführen wollt.
Bestätigt das.

Ruft jetzt qjackctl auf.
qjackctl &

Geht hier auf Einstellungen, stellt den Driver auf alsa, die Sample Rate auf 48000 und Frames auf 64.
Damit solltet Ihr eine Latency von 4msec erreichen.

Zu guter letzt installieren wir noch Studio Link.
Geht hierzu auf die Webseite und ladet das .deb Paket herunter.

Anschließend wieder in das Downloads Verzeichnis, die zip Date entpacken, ausführbar machen und ausführen.
cd ~/Downloads
unzip studio-link-standalone-linux.zip
sudo chmod +x studio-link-standalone
./studio-link-standalone

Es sollte dann ein Browserfenster mit Studiolink geöffnet werden.

Damit steht jetzt erstmal das Grundkonzept.
Als nächstes installieren wir Software und testen das Setup damit.

 

Zu verbindende Software Installieren

Ich nehme in diesem Beispiel dafür Team Speak, es würde mit anderer Software allerdings ähnlich aussehen.
Wenn Ihr andere Software benutzten wollt, installiert sie, überspringt diesen Teil und macht im nächsten Kapitel Setup Testen weiter.

Ladet also den Linux Client für Team Speak herunter.

Gebt jetzt folgendes in ein Terminal ein.

cd ~/Downloads
chmod u+x TeamSpeak3-Client-linux_ARCHITEKTUR-VERSION.run
./TeamSpeak3-Client-linux_ARCHITEKTUR-VERSION.run

Anschließend die Eula lesen, mit einem dem Druck der Taste q die Eula wieder verlassen und dann mit y akzeptieren.

In eurem Download Verzeichnis befindet sich jetzt ein Ordner Namens TeamSpeak3-Client-linux_amd64.
Wechselt in dieses.
cd TeamSpeak3-Client-linux_amd64

In diesem Verzeichnis befindet sich das script ts3client_runscript.sh
Dieses Script müssen wir jetzt noch Ausführbar (eXecutable) machen.
sudo chmod +x ./ts3client_runscript.sh

Jetzt können wir Team Speak starten.

 

Setup Testen

In der Ausgangssituation haben wir:

  • unsere Software geöffnet, in meinem Fall Team Speak
  • qjacktl offen
  • Studio Link am Laufen

Startet jetzt JACK und geht auf Connect.

 


Check MK Agent for Linux Troubleshooting

In diesem Artikel möchte ich einen Ansatz zeigen, wie man auf einem Linux Client Check_MK issues troubleshooten kann.
Sehen wir uns mal einen Check an, der nicht eindeutig ist und dem wir auf den Grund gehen wollen.

Dieser Check im WARN sagt aus, dass hier Updates der VMware Guest Tools ausstehen.
Aber wie überprüft Check_MK das eigentlich?

Wir erinnern uns, unter Linux werden die Daten für das Monitoring über check_mk_agent generiert.
Über whereis und file bekommen wir heraus, dass es sich hierbei um ein bash script handelt.

Schauen wir also mal rein.

Gleich in den ersten Zeilen fallen drei Verzeichnisse auf:

  • /usr/lib/check_mk_agent
  • /etc/check_mk
  • /var/lib/check_mk_agent

Leider findet sich weder in dem Script an sich, noch in diesen Verzeichnissen etwas zu diesem Check.
Schauen wir doch mal in den Blogartikel des Herstellers.

Die WATO Checks sind eine Interpretation der Daten die das Script liefert.
Man müsste jetzt also noch tiefer auf dem Check_MK Server graben um herauszufinden, welche in den vom check_mk_agent generierten Daten wie womit verglichen werden.

Darüber kann man dann wiederum darauf zu kommen, welche Funktion im check_mk_agent script diese Daten erhebt.
Das war jetzt zwar kein finales Ergebnis, sollte euch aber einen Ansatz geben, wie man solche Themen angehen kann.

My educated guess:
Vermutlich wird eine offentliche Ressource von VMware abgefragt und mit einem gelieferten string abgleichen.
Da die Fehlermeldung moniert, dass die tools "not handled by VMware" sind, wird das vermutlich bedeuten, dass der Check keine Werte zurückgeliefert hat.
Es sind keine VMware Tools installiert.

Cheers,
Ori


Process management from the CLI

#sudo kill $(ps aux|sed -e 's/[ ]* / /g'|cut -f2 -d' ')

 


Identifying Interfaces by flashing thier led's

You can use the ethtool to identify a network interface.
ethtool -p <interface>

You can see the result at the yellow blinking LED below.

Unfortunately not every network interface supports this feature.

Cheers,
Ori


Interfaces blinken lassen per ethtool

Um eine Netzwerkkarte zu identifizieren, kann man das ethtool benutzen.
ethtool -p <interface>

Zu sehen an der gelben LED neben dem Interface.

Leider unterstützt nicht jede Netzwerkkarte dieses feature.

Cheers,
Ori


00_Git

Git is a open source distributed version control system.
What does that mean?

The job of a Version Control System is to save files, provide access to them and document changes made to those files. Documented changes are what has been changed when by whom. Normally these systems get used to manage source code, however other types of data can get versionized in that manner as well. Often systems like this get referred to as a CVS rather then a VCS. It means the same.

In case it gets necessary to rollback to a version prioror to a specific change using Git or another VCS it is not a hard task. In software development companys there usually is a server that is running a VCS and the employees are connecting to that resource to apply changes to the code.

One problem with this is that this resource is only available inside the company network. If you are not in, have no VPN to the company network or the internet on one of the branches fails, you cannot commit changes to the code.

Before diving into the most common git terms and the concepts underneath them lets take a look at the distrubuted I mentioned in the beginning. In a classic VCS there is a centralized server that keeps track of code changes.

Distributed in this case means that EVERY user has a local copy of ALL changes. The advantage of this is that most of gits functions can be used without connecting to any server.

You are probably already realizing that versioning has a lingo in itself.
Earlier I was speaking of applying changes to code then I used the term committig changes.

Let me show you the most frequent terms you will face and what they mean.

Git Lingo
Pull - to download or refresh files that have been downloaded in the past and the related change history for those files

Commit - uploading or applying changes to files

Yes GIT does run on windows and it has a GUI.
No I will not get into that.

Now that this is out of the way, let us begin.
If git is already installed on your system you can find out by typing git --version

(To get git integrated into the shell, like in the screenshot above, take a look at my OhMyZsh Post 1 and Post 2.)

If git is not installed in your distro, you can install it using apt, yum, rpm etc.

apt install git

Cheers,
Ori


Of Factorio

In my free time, amongst other things, I like to play a round of Factorio.
In a nutshell Factorio is a game centered around automating production.

I think this Video explains the concept of the game quite well.

https://www.youtube.com/watch?v=KVvXv1Z6EY8

This game can be played by multiple players on a server.
There is a nice Docker Container for Factorio that allows you to have your own server up and running in no time.

 

Unfortunately there is no easy way to allow other players uploading maps to the server.
So I came up with a solution using nextcloud.

What you need:

  • A Docker Host that is running the dtandersen/factorio container
  • A resource (like a nextcloud) that you can check a file from, download a savegame from and share with others

The Idea:

  • The Docker Host is running a script (see below) every minute

Add the following line to the /etc/crontab and use the path were you dropped that script.

* * * * * root /path/to/script.sh

  • This script checks the content of a textfile at a resource of your choice using ssh
  • In case the text file does not contain a 1, nothing happens
  • In case the file does contain a 1 the script will be run

The script:

  • Stops docker
  • Moves the currently running map in a backup directory
  • Then deletes the current savegame
  • Connects to a ressource, downloads *.zip and places them in the savegame directory
  • Changes the owner of the savegame so the docker container can work with it
  • Restarts docker
  • Writes into a logfile at the ressource

Directories:

  • The savegame directorz, mounted by the container is  /opt/factorio/save

You will have to change the script by hand, and generate the ssh keys.
It is not pretty but it does work.

 

Cheers,
Ori

 

#!/bin/bash
factorio=$(ssh root@IP 'cat path/to/Checkme.txt')

if (echo $factorio | grep -q "1")
then
service docker stop
cp /opt/factorio/saves/save.zip /opt/factorio/backup_save/save.zip
rm -rf /opt/factorio/saves/*
scp root@IP:/path/to/savegame/\*.zip /opt/factorio/saves/.
chown -R 845:845 /opt/factorio/saves

service docker start

ssh root@192.168.122.79 'echo "0" > path/to/Checkme.txt'
ssh root@192.168.122.79 'echo "Server rebooted at $(date +\%d-\%m-\%Y-\%H-\%M-\%S)" >> path/to/RebootLog.txt'
factorio=0
else
echo "DEBUG ME SEMPAI"
fi


Von Factorio

Ich spiele in meiner Freizeit unter Anderem ein Spiel namens Factorio.
Kurz zusammengefasst ist Factorio ein Spiel in dem es darum geht eine Produktion zu automatisieren.

Dieses Video erklärt das Konzept des Spiels sehr gut.

https://www.youtube.com/watch?v=KVvXv1Z6EY8

Das Spiel lässt sich mit mehreren Spielern auf einem Server spielen.
Es gibt einen super Docker Container für Factorio, der es einem erlaubt im Handumdrehen einen Server aufzusetzen.

Leider gibt es kein einfaches Feature andere Spieler Maps auf den Server laden zu lassen, also habe ich mit Nextcloud mal eine Lösung zusammengeklöppelt.

Was Ihr braucht:

  • Einen Docker Host auf dem der dtandersen/factorio Container läuft
  • Eine ressource, von der Ihr Savegames herunterladen und eine Datei prüfen könnt

Die Idee:

  • Der Docker Host führt jede Minute ein script (siehe unten) aus

Fügt hierzu in der /etc/crontab folgende Zeile hinzu und benutzt den Pfad, wo Ihr das script abgelegt habt.

* * * * * root /path/to/script.sh

  • In diesem Script wird der Inhalt einer Textdatei in einer Ressource eurer Wahl über ssh geprüft
  • Ist der Inhalt dieser Datei nicht 1, passiert nichts
  • Ist der Inhalt dieser Datei 1 wird das Script ausgeführt

Das Script:

  • Stoppt docker
  • Verschiebt die aktuelle map in ein Backupverzeichnis
  • löscht das aktuelle Savegame
  • Vebindet sich mit einer ressource, *.zip herunter und legt es in das Savegameverzeichnis
  • Ändert den Owner des Savegames, so dass der Docker Container damit arbeiten kann
  • Startet docker wieder
  • Schreibt ein Log in die Ressource

Verzeichnisse:

  • Savegame location, gemounted vom Container /opt/factorio/save

Ihr müsst das Script noch von Hand anpassen, genauso wie ssh keys generieren.
Es ist nicht schön, es ist nicht sauber aber es funktioniert.

 

Cheers,
Ori

 

#!/bin/bash
factorio=$(ssh root@IP 'cat path/to/Checkme.txt')

if (echo $factorio | grep -q "1")
then
service docker stop
cp /opt/factorio/saves/save.zip /opt/factorio/backup_save/save.zip
rm -rf /opt/factorio/saves/*
scp root@IP:/path/to/savegame/\*.zip /opt/factorio/saves/.
chown -R 845:845 /opt/factorio/saves

service docker start

ssh root@192.168.122.79 'echo "0" > path/to/Checkme.txt'
ssh root@192.168.122.79 'echo "Server rebooted at $(date +\%d-\%m-\%Y-\%H-\%M-\%S)" >> path/to/RebootLog.txt'
factorio=0
else
echo "DEBUG ME SEMPAI"
fi