Die neue Nextcloud ist eingerichtet, die Datenbank importiert und die Dateien liegen wieder an ihrem Platz. Die Anmeldeseite lässt sich öffnen. Aber funktioniert auch das, was im Alltag gebraucht wird?
Ein kleiner Funktionstest hilft, diese Frage systematisch anzugehen. Das Skript nextcloud_basistest.py führt typische Zugriffe aus und zeigt jeden Schritt mit Zeitstempel an. Parallel lassen sich die Nextcloud- und Webserver-Logs beobachten. So wird aus dem eher zufälligen Ausprobieren ein nachvollziehbarer Testlauf.
Was wird geprüft?
Zunächst fragt das Skript den Serverstatus ab. Es prüft, ob Nextcloud als installiert gemeldet wird, der Wartungsmodus ausgeschaltet ist und kein Datenbank-Upgrade angefordert wird. Anschließend ruft es die Anmeldeseite ab, authentifiziert den Benutzer über die API und liest die vom Server bereitgestellten Fähigkeiten ab. Der Abruf der Anmeldeseite ist dabei noch kein Test einer Anmeldung im Browser.
Danach folgen Dateioperationen über WebDAV. Diese Schnittstelle erlaubt es Programmen, Dateien und Ordner auf dem Server zu verwalten. Das Skript erstellt einen eigenen Testordner und prüft darin Upload, Download, Aktualisierung, Kopieren, Verschieben und Löschen. Ein Dateiname mit Umlauten und Leerzeichen prüft zusätzlich den Umgang mit Sonderzeichen. Eine zufällig erzeugte Binärdatei mit standardmäßig acht MiB wird hochgeladen und wieder heruntergeladen. Der Vergleich ihrer SHA-256-Prüfsummen prüft, ob der Inhalt unverändert zurückkommt.
Für Termine und Aufgaben legt das Skript einen eigenen Kalender an, für Kontakte ein eigenes Adressbuch. Die Einträge werden erstellt, gelesen, über DAV-Abfragen gesucht, aktualisiert und gelöscht. Dafür verwendet das Programm CalDAV und CardDAV, zwei Erweiterungen von WebDAV.
So wird das Skript gestartet
Benötigt werden Python 3, die erreichbare HTTPS-Adresse der Nextcloud und ein Benutzerkonto. Zusätzliche Python-Pakete sind nicht erforderlich. Das Skript kann auf einem normalen Arbeitsplatzrechner laufen; ein Start direkt auf dem Server ist nicht nötig.
Nach dem Herunterladen im Terminal in den betreffenden Ordner wechseln und starten:
python3 nextcloud_basistest.py https://cloud.example.de --user vorname.nachname
Die Beispieladresse und den Benutzernamen durch die eigenen Angaben ersetzen. Bei einer Installation in einem Unterverzeichnis gehört dieses zur Adresse, etwa https://example.de/nextcloud.
Das Passwort wird verdeckt abgefragt. Vorzugsweise wird dafür ein eigenes App-Passwort verwendet. Es muss nicht im Skript hinterlegt werden und erscheint auch nicht in der Befehlszeile. Die Verbindung prüft das HTTPS-Zertifikat; automatische Weiterleitungen werden nicht verfolgt. Deshalb sollte direkt die endgültige Adresse angegeben werden.
Für das Beobachten der Logs kann der Lauf langsamer erfolgen, indem das Skript durch Pausen unterbroche wird. Die Zahl hinten gibt die Länge der Pause in Sekunden an (siehe Tabelle):
python3 nextcloud_basistest.py https://cloud.example.de \
--user vorname.nachname --pause 3
Die Pause folgt auf jede erfolgreiche Prüfung. Sie gilt nicht für jede einzelne HTTP-Anfrage.
| Option | Bedeutung |
|---|---|
--pause 3 | Drei Sekunden Pause nach erfolgreichen Prüfungen |
--mib 32 | Binärdatei mit 32 MiB verwenden; erlaubt sind 1 bis 128 MiB |
--timeout 120 | Socket-Timeout für Netzwerkoperationen auf 120 Sekunden setzen; kein Gesamtzeitlimit des Laufs |
--no-dav | Kalender-, Aufgaben- und Kontakttests auslassen; Datei-WebDAV wird weiterhin geprüft |
--help | Hilfe anzeigen |
Zum Mitschreiben der Ausgabe eignet sich unter Bash:
set -o pipefail
python3 nextcloud_basistest.py https://cloud.example.de \
--user vorname.nachname --pause 3 2>&1 | tee nextcloud-test.log
tee zeigt die Ausgabe an und schreibt sie gleichzeitig in eine Datei. pipefail sorgt dafür, dass ein Fehlerstatus des Python-Skripts trotz der Weiterleitung an tee im Status der Befehlskette berücksichtigt wird. Das Protokoll enthält unter anderem Serveradresse, Benutzerpfade und Testnamen, aber kein Passwort.
Die Ausgabe verstehen
Jeder Test erhält ein OK oder FEHLER. Zusätzlich erscheinen die HTTP-Methode, der angefragte Pfad, der HTTP-Status und die gemessene Dauer. Eine abschließende Übersicht fasst die ausgeführten Prüfungen zusammen. Nicht gestartete Folgeprüfungen werden nicht als eigene Ergebnisse aufgeführt: Scheitert beispielsweise das Anlegen des Testordners, werden die davon abhängigen Dateioperationen ausgelassen.
Typische Statuscodes sind 200 für einen erfolgreichen Abruf, 201 für ein neu angelegtes Objekt und 204 für eine erfolgreiche Operation ohne Antwortinhalt. DAV-Abfragen liefern häufig 207, weil ihre Antwort mehrere Teilergebnisse enthält.
Ein 404 ist beim gezielten Kontrollabruf nach einer Löschung ausdrücklich erwartet: Die Datei soll dann nicht mehr vorhanden sein. Solche erfolgreichen Negativprüfungen können trotzdem in Zugriffslogs auftauchen.
Bei Fehlern helfen Zeitstempel und Pfad beim Vergleich mit den Serverlogs. Der Zeitstempel nutzt die lokale Zeitzone des Rechners; Serverlogs können UTC verwenden. Die Testkennung beginnt mit NC-Test- und steht außerdem in den Namen der Testdaten. Das Skript sendet sie als X-Request-ID; ob diese Kennung im Serverlog erscheint, hängt von Server und Proxy ab. Eine vom Server zurückgelieferte Request-ID wird ebenfalls angezeigt. Fehlende Logmeldungen allein beweisen daher keinen erfolgreichen Test.
Das Python-Programm nachvollziehen
Zum Einstieg lohnt sich das Lesen von main() und run() am Dateiende. main() verarbeitet die Startparameter und fragt das Passwort ab. run() legt die Reihenfolge fest und stößt das Aufräumen an.
Die Klasse Test bündelt die Einstellungen und Ergebnisse eines Laufs. self steht innerhalb ihrer Methoden für das aktuelle Testobjekt. self.results ist beispielsweise die Ergebnisliste, auf die mehrere Methoden zugreifen.
Zwei Methoden tragen den größten Teil der Arbeit: req() sendet eine HTTP-Anfrage und kontrolliert den Statuscode. check() führt einen einzelnen Prüfauftrag aus, fängt normale Fehler ab und schreibt das Ergebnis in die Liste.
Ein häufiger Ausdruck lautet:
self.check('Testordner auflisten', lambda: self.prop(folder, '1'))
lambda erzeugt hier eine kleine Funktion ohne Namen. Sie wird an check() übergeben. Erst dort wird sie ausgeführt, damit Erfolg und Fehler einheitlich behandelt werden können. Die Einrückung legt in Python fest, welche Zeilen zu einer Funktion, Schleife oder Bedingung gehören.
Weitere Kommentare im Skript erklären unter anderem den Unterschied zwischen Text und Bytes, JSON- und XML-Antworten, Schleifen, Prüfsummen und die Fehlerbehandlung mit try, except und finally.
Aufräumen und Grenzen
Vorhandene Dateien und Einträge werden nicht bearbeitet. Das Skript arbeitet mit eigenen, praktisch eindeutig benannten Testsammlungen. Am Ende versucht ein finally-Block, diese wieder zu entfernen – auch bei vielen Fehlern oder einem normalen Abbruch. Ein nicht erreichbarer Server oder ein hart beendeter Prozess kann das verhindern. In diesem Fall lassen sich verbliebene Sammlungen an ihrem Namen erkennen. Im Papierkorb und in Dateiversionen können ebenfalls Testreste bleiben; diese Bereiche werden nicht pauschal geleert.
Ein erfolgreicher Lauf bestätigt die ausgeführten Operationen mit diesem Benutzerkonto. Er bestätigt nicht, dass alle importierten Dateien lesbar, alle alten Freigaben korrekt oder sämtliche Kalender vollständig sind. Auch Mailversand, Hintergrundjobs, externe Speicher, Browserbedienung und Collabora werden nicht getestet. Für die Abnahme einer Migration sollten deshalb zusätzlich einige vorhandene Dateien, Kalender und Freigaben gezielt mit dem vorherigen Stand verglichen werden.
Warnung: Führe fremde Skripte nur aus, wenn du ihre Funktionsweise verstehst und dem Code vertraust!
Dieses Skript wurde mit KI erstellt, kurz durchgesehen und bisher ausschließlich auf einem Testsystem erprobt. Eine umfassende Prüfung hat nicht stattgefunden.
#!/usr/bin/env python3
"""Nextcloud-Basistest – ausführlich kommentierte Lernfassung.
Aufruf:
python3 nextcloud_basistest.py https://cloud.example.org --user NAME
Voraussetzungen: Python 3, erreichbare HTTPS-Adresse, Benutzerkonto und
vorzugsweise ein App-Passwort. Zusätzliche Python-Pakete sind nicht nötig.
Ablauf: Status und Anmeldung -> Dateien -> Kalender/Aufgaben -> Kontakte
-> eigene Testdaten entfernen -> Ergebnisübersicht.
Bestehende Nutzdaten werden nicht bearbeitet. Gelöschte Testdateien können
im Papierkorb oder als Versionen verbleiben. Bei Verbindungsabbrüchen oder
hartem Beenden können auch Testsammlungen zurückbleiben.
Nicht geprüft: Browserbedienung, Mail, Cron, externe Speicher, Freigaben
zwischen Benutzern, Collabora sowie die Vollständigkeit des Datenimports.
Rückgabewerte für die Shell:
0 = alle ausgeführten Prüfungen erfolgreich
1 = mindestens ein Fehler bzw. unerwarteter Abbruch
2 = ungültige Kommandozeilenargumente
130 = Abbruch durch Strg+C oder SIGTERM
Lesetipp: Zuerst main() und run() am Dateiende lesen. Danach check() und
req(): Diese beiden Methoden organisieren fast alle einzelnen Prüfungen.
"""
# Alle folgenden Module gehören zur Python-Standardbibliothek.
# argparse verarbeitet --user usw.; getpass liest ein Passwort ohne Anzeige.
import argparse
import base64
import datetime as dt
import getpass
import hashlib
import json
import os
import signal
import sys
import time
# urllib übernimmt HTTPS-Anfragen, URL-Kodierung und HTTP-Fehler.
# Die Kurzformen U und R sind frei gewählte Abkürzungen für Module.
import urllib.error
import urllib.parse as U
import urllib.request as R
import uuid
# ElementTree (hier E) liest XML, das DAV für Anfragen und Antworten nutzt.
import xml.etree.ElementTree as E
# Diese Klasse erweitert den HTTPRedirectHandler aus urllib.
# Bei einer Weiterleitung soll der Benutzer die endgültige URL angeben.
# So werden Zugangsdaten nicht automatisch an eine andere Zieladresse geschickt.
class NoRedirect(R.HTTPRedirectHandler):
def redirect_request(self, req, fp, code, msg, headers, newurl):
"""Verhindert das automatische Folgen von HTTP-Weiterleitungen."""
return None
# Eine Klasse bündelt Daten und dazugehörige Funktionen (Methoden).
# self bezeichnet jeweils das aktuelle Test-Objekt. self.results bleibt
# beispielsweise auch zwischen zwei Methodenaufrufen erhalten.
class Test:
def __init__(self, args, password):
"""Speichert Einstellungen und bereitet einen einzelnen Testlauf vor."""
self.a = args
# rstrip entfernt abschließende Schrägstriche, damit URL-Teile zusammenpassen.
self.base = args.url.rstrip('/')
# Datum plus zufällige UUID ergibt eine praktisch eindeutige Testkennung.
# Mit dieser Kennung heißen auch Ordner, Kalender und Adressbuch.
self.tag = 'NC-Test-' + dt.datetime.now().strftime('%Y%m%d-%H%M%S-') + uuid.uuid4().hex[:10]
# HTTP Basic Auth kodiert Benutzername:Passwort als Base64.
# Base64 ist KEINE Verschlüsselung; den Transport schützt hier HTTPS.
# encode() macht Text zu Bytes, decode() macht Bytes wieder zu Text.
self.auth = 'Basic ' + base64.b64encode((args.user + ':' + password).encode()).decode()
# Der Opener ist der HTTP-Client. Die normale TLS-Zertifikatsprüfung bleibt aktiv.
self.http = R.build_opener(NoRedirect())
# Eine leere Liste für Ergebnis-Tupel: (Testname, Status, Fehlerbeschreibung).
self.results = []
# Hier merken wir nur Sammlungen, deren Erstellung erfolgreich bestätigt wurde.
# Die Liste ist später der Arbeitsauftrag zum Aufräumen.
self.cleanup = []
self.uid = args.user
def log(self, text):
"""Schreibt eine Meldung mit lokaler Uhrzeit sofort ins Terminal."""
# Ein fester ISO-Zeitstempel mit Zeitzone erleichtert den Logvergleich.
# flush=True verhindert, dass Meldungen lange im Ausgabepuffer liegen.
print(dt.datetime.now().astimezone().isoformat(timespec='seconds'), text, flush=True)
def req(self, method, path, data=None, headers=None, codes=(200,), auth=True):
"""Sendet eine HTTP-Anfrage und prüft ihren Statuscode. Liefert Inhalt und Header."""
url = self.base + path
# Header sind Zusatzinformationen zur Anfrage, gespeichert als Dictionary.
# X-Request-ID trägt die Testkennung; Server/Proxy können sie ersetzen.
# Die Antwortkennung wird deshalb ebenfalls ausgegeben.
h = {'User-Agent': 'Nextcloud-Basistest/1.0', 'X-Request-ID': self.tag}
if auth:
h['Authorization'] = self.auth
# Optionale zusätzliche Header überschreiben bzw. ergänzen die Vorgaben.
# None bedeutet: nicht angegeben. headers or {} nimmt dann ein leeres Dictionary.
h.update(headers or {})
# Textkörper werden vor dem Versenden in UTF-8-Bytes umgewandelt.
if isinstance(data, str):
data = data.encode()
self.log(f' {method} {path}')
# Eine monotone Uhr misst Dauer unabhängig von Änderungen der Systemzeit.
start = time.monotonic()
try:
# with schließt die Antwort auch bei einem Fehler zuverlässig.
# r.read() lädt den gesamten Antwortinhalt in den Arbeitsspeicher.
with self.http.open(R.Request(url, data=data, headers=h, method=method), timeout=self.a.timeout) as r:
status, body, rh = r.status, r.read(), r.headers
# urllib behandelt z. B. 404 als Ausnahme. Für einen Löschtest ist 404
# aber gewollt. Deshalb lesen wir den HTTP-Fehler wie eine normale Antwort.
# Netzwerk- und TLS-Fehler gehen weiter an die aufrufende Fehlerbehandlung.
except urllib.error.HTTPError as e:
status, body, rh = e.code, e.read(), e.headers
self.log(f' HTTP {status}; {time.monotonic()-start:.2f}s; Request-ID: {rh.get("X-Request-ID", "-")}')
# codes ist ein Tupel erlaubter Statuscodes; (200,) enthält genau einen Wert.
# Ein unerwarteter Status löst eine Ausnahme aus, die check() protokolliert.
if status not in codes:
# Do not print response bodies: they may contain personal information.
raise RuntimeError(f'HTTP {status}, erwartet {codes}; bei 3xx kanonische HTTPS-URL verwenden')
# Zwei Werte werden als Tupel zurückgegeben: Antwort-Bytes und Antwort-Header.
return body, rh
def check(self, label, fn):
"""Führt eine Prüfung aus, protokolliert Erfolg oder Fehler und gibt True/False zurück."""
self.log('TEST: ' + label)
try:
# fn ist eine übergebene Funktion. Erst die Klammern führen sie aus.
fn()
# Ein normaler Testfehler wird aufgezeichnet, statt den gesamten Lauf zu stoppen.
# Strg+C (KeyboardInterrupt) gehört nicht zu diesen normalen Exceptions.
except Exception as e:
self.results.append((label, 'FEHLER', str(e)))
self.log('FEHLER: ' + str(e))
return False
self.results.append((label, 'OK', ''))
self.log('OK: ' + label)
# Die eingestellte Pause folgt erfolgreichen Prüfungen, nicht jeder HTTP-Anfrage.
time.sleep(self.a.pause)
return True
def ocs(self, path):
"""Ruft die Nextcloud-API auf und entpackt deren JSON-Antwort."""
# OCS ist eine Nextcloud-API. Der Header kennzeichnet den API-Aufruf.
# Der Unterstrich _ heißt hier: Den zweiten Rückgabewert brauchen wir nicht.
raw, _ = self.req('GET', '/ocs/v2.php/' + path + '?format=json', headers={'OCS-APIRequest': 'true'})
# JSON ist ein Textformat für strukturierte Daten.
# json.loads wandelt es in Python-Dictionaries und Listen um.
obj = json.loads(raw)['ocs']
# Der API-Status im JSON wird zusätzlich zum HTTP-Status geprüft.
if str(obj['meta']['statuscode']) not in ('100', '200'):
raise RuntimeError('OCS-Anfrage meldet keinen Erfolg')
return obj['data']
def prop(self, path, depth='0'):
"""Liest DAV-Eigenschaften; Depth 0 betrifft das Objekt, Depth 1 auch direkte Kinder."""
body, _ = self.req('PROPFIND', path,
'<d:propfind xmlns:d="DAV:"><d:prop><d:resourcetype/><d:getetag/><d:getcontentlength/></d:prop></d:propfind>',
{'Depth': depth, 'Content-Type': 'application/xml'}, (207,))
# XML wird als Baum gelesen. {DAV:} ist ein XML-Namensraum.
# Bei 207 Multi-Status müssen auch die Teilergebnisse betrachtet werden.
root = E.fromstring(body)
responses = root.findall('{DAV:}response')
if not responses:
raise RuntimeError('Leere DAV-Multistatus-Antwort')
for response in responses:
# Eine List Comprehension erzeugt hier die Liste der Statuszeilen.
# Nicht jede angefragte Eigenschaft ist bei jedem Objekttyp vorhanden;
# mindestens eine erfolgreiche Eigenschaft je Antwort ist hier erforderlich.
statuses = [s.text or '' for s in response.findall('.//{DAV:}status')]
if not statuses or not any(' 200 ' in s for s in statuses):
raise RuntimeError('DAV-Teilergebnis ohne erfolgreiche Eigenschaften')
return root
def status(self):
"""Prüft die öffentliche Statusantwort auf grundlegende Betriebsprobleme."""
raw, _ = self.req('GET', '/status.php', auth=False)
s = json.loads(raw)
if not s.get('installed') or s.get('maintenance') or s.get('needsDbUpgrade'):
raise RuntimeError('Nicht installiert, Wartungsmodus oder Datenbank-Upgrade erforderlich')
self.log('Nextcloud-Version: ' + str(s.get('versionstring', '?')))
def user(self):
"""Ermittelt die interne Benutzer-ID für die folgenden DAV-Adressen."""
# Anmeldename und interne ID können sich unterscheiden.
# Für die DAV-Pfade verwenden wir die ID aus der Serverantwort.
self.uid = self.ocs('cloud/user')['id']
def equal(self, path, expected):
"""Lädt eine Datei herunter und vergleicht ihren Inhalt über SHA-256."""
body, _ = self.req('GET', path)
# Ein Hash ist ein Fingerabdruck der Bytes. Gleiche SHA-256-Werte sind hier
# ein sehr zuverlässiger Inhaltsvergleich, aber kein eigener Sicherheitstest.
if hashlib.sha256(body).digest() != hashlib.sha256(expected).digest():
raise RuntimeError('Heruntergeladener Inhalt stimmt nicht überein')
def files(self):
"""Prüft Dateioperationen in einem eigens erzeugten Testordner."""
# quote macht Sonderzeichen URL-tauglich. safe="" kodiert auch / in der ID.
root = '/remote.php/dav/files/' + U.quote(self.uid, safe='') + '/'
folder = root + self.tag + '/'
# lambda: ... ist eine kleine Funktion ohne Namen.
# check bekommt damit einen Arbeitsauftrag, den es kontrolliert ausführt.
self.check('Dateiliste und Metadaten im Benutzerverzeichnis', lambda: self.prop(root, '1'))
# Nur wenn der neue Ordner bestätigt wurde, werden dort Schreibtests gestartet.
if not self.check('Testordner anlegen', lambda: self.req('MKCOL', folder, codes=(201,))):
return
self.cleanup.append(folder)
file = folder + U.quote('Prüfung mit Leerzeichen äöü.txt')
content = ('Nextcloud Migrationstest ' + self.tag + '\nGrüße aus dem Basistest.\n').encode()
# PUT lädt Daten hoch. If-None-Match: * verbietet das Überschreiben
# einer bereits vorhandenen Datei bei diesem ersten Upload.
if self.check('Textdatei hochladen', lambda: self.req('PUT', file, content, {'If-None-Match': '*'}, (201,))):
self.check('Download mit Inhaltsvergleich', lambda: self.equal(file, content))
# Das b vor dem Text erzeugt direkt Bytes. + hängt weitere Bytes an.
changed = content + b'Updated\n'
if self.check('Eigene Testdatei aktualisieren', lambda: self.req('PUT', file, changed, codes=(204,))):
self.check('Aktualisierten Inhalt prüfen', lambda: self.equal(file, changed))
# COPY dupliziert, MOVE verschiebt. Destination ist die vollständige Ziel-URL.
# Overwrite: F verhindert das Überschreiben vorhandener Ziele.
copied, moved = folder + 'Kopie.txt', folder + 'Verschoben.txt'
if self.check('Datei kopieren', lambda: self.req('COPY', file, headers={'Destination': self.base+copied, 'Overwrite':'F'}, codes=(201,))):
if self.check('Kopie verschieben', lambda: self.req('MOVE', copied, headers={'Destination':self.base+moved,'Overwrite':'F'}, codes=(201,))):
# Der bedingte Ausdruck X if Bedingung else Y wählt den erwarteten Inhalt.
# any(...) prüft, ob der Aktualisierungstest zuvor erfolgreich war.
self.check('Verschobene Datei lesen', lambda: self.equal(moved, changed if any(x[0]=='Eigene Testdatei aktualisieren' and x[1]=='OK' for x in self.results) else content))
self.check('Einzeldatei löschen', lambda: self.req('DELETE', moved, codes=(204,)))
# 404 ist HIER Erfolg: Die gerade gelöschte Datei soll nicht mehr abrufbar sein.
self.check('Löschung prüfen (404 hier erwartet)', lambda: self.req('GET', moved, codes=(404,)))
self.check('Testordner auflisten', lambda: self.prop(folder, '1'))
# Zufallsbytes prüfen auch nicht textbasierte Inhalte.
# 1 MiB = 1024 * 1024 Bytes. Upload und Download liegen jeweils im RAM.
# Dies ist ein einzelner PUT-Upload, kein Chunk-Upload wie bei manchen Clients.
blob = os.urandom(self.a.mib * 1024 * 1024)
big = folder + 'Binaertest.bin'
if self.check(f'Binärdatei hochladen ({self.a.mib} MiB)', lambda: self.req('PUT', big, blob, {'If-None-Match':'*'}, (201,))):
self.check('Binärdatei vollständig vergleichen', lambda: self.equal(big, blob))
def collection(self, kind):
"""Erzeugt einen eigenen Testkalender oder ein eigenes Testadressbuch."""
# == vergleicht zwei Werte; das Ergebnis ist True oder False.
# Ein gemeinsamer Ablauf bedient Kalender und Adressbücher.
cal = kind == 'calendar'
parent = '/remote.php/dav/' + ('calendars/' if cal else 'addressbooks/users/') + U.quote(self.uid, safe='') + '/'
self.check(('CalDAV' if cal else 'CardDAV') + ' Sammlungen abrufen', lambda: self.prop(parent, '1'))
path = parent + self.tag + '/'
# Kalender werden mit MKCALENDAR angelegt, Adressbücher mit erweitertem MKCOL.
if cal:
method = 'MKCALENDAR'
xml = '<c:mkcalendar xmlns:c="urn:ietf:params:xml:ns:caldav" xmlns:d="DAV:"><d:set><d:prop><d:displayname>'+self.tag+'</d:displayname><c:supported-calendar-component-set><c:comp name="VEVENT"/><c:comp name="VTODO"/></c:supported-calendar-component-set></d:prop></d:set></c:mkcalendar>'
else:
method = 'MKCOL'
xml = '<d:mkcol xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:carddav"><d:set><d:prop><d:resourcetype><d:collection/><c:addressbook/></d:resourcetype><d:displayname>'+self.tag+'</d:displayname></d:prop></d:set></d:mkcol>'
if not self.check('Eigene Testsammlung anlegen: '+kind, lambda: self.req(method, path, xml, {'Content-Type':'application/xml'}, (201,))):
return
self.cleanup.append(path)
# Kalender werden mit MKCALENDAR angelegt, Adressbücher mit erweitertem MKCOL.
if cal:
# iCalendar erwartet hier UTC; das Z am Ende steht für UTC.
stamp = dt.datetime.now(dt.timezone.utc).strftime('%Y%m%dT%H%M%SZ')
# VEVENT ist ein Termin, VTODO eine Aufgabe. Beide liegen im Testkalender.
# Das feste Termindatum ist Testinhalt; Einladungen werden nicht erzeugt.
items = [('termin.ics', 'VEVENT', 'DTSTART:20300101T120000Z\r\nDTEND:20300101T123000Z'), ('aufgabe.ics','VTODO','STATUS:NEEDS-ACTION\r\nPERCENT-COMPLETE:0')]
# Die for-Schleife verarbeitet Termin und Aufgabe nacheinander.
# Das Tupel wird dabei direkt in drei benannte Variablen zerlegt.
for name, component, fields in items:
# f-Strings setzen Ausdrücke in {geschweiften Klammern} in Text ein.
# \r\n erzeugt die vom Austauschformat verwendeten Zeilenenden.
text = f'BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//NC Basistest//DE\r\nBEGIN:{component}\r\nUID:{uuid.uuid4()}\r\nDTSTAMP:{stamp}\r\nSUMMARY:{self.tag}\r\n{fields}\r\nEND:{component}\r\nEND:VCALENDAR\r\n'
self.dav_item(path+name, text, 'text/calendar', component, 'calendar')
else:
# vCard ist das Austauschformat für Kontakte. Die .invalid-Adresse ist Testinhalt.
text = f'BEGIN:VCARD\r\nVERSION:3.0\r\nUID:{uuid.uuid4()}\r\nFN:{self.tag}\r\nN:Test;Nextcloud;;;\r\nEMAIL:nextcloud-test@example.invalid\r\nEND:VCARD\r\n'
self.dav_item(path+'kontakt.vcf', text, 'text/vcard', 'VCARD', 'addressbook')
def dav_item(self, path, text, mime, component, kind):
"""Prüft ein einzelnes Kalender-, Aufgaben- oder Kontaktobjekt."""
if not self.check(component+' anlegen', lambda: self.req('PUT', path, text, {'Content-Type':mime,'If-None-Match':'*'}, (201,))):
return
def read():
"""Prüft, ob das gelesene Objekt Testkennung und erwarteten Objekttyp enthält."""
raw, _ = self.req('GET', path)
if self.tag not in raw.decode() or ('BEGIN:'+component) not in raw.decode():
raise RuntimeError('DAV-Inhalt fehlt')
self.check(component+' lesen', read)
# CalDAV für Kalender, CardDAV für Kontakte: beide erweitern WebDAV.
ns = 'urn:ietf:params:xml:ns:caldav' if kind=='calendar' else 'urn:ietf:params:xml:ns:carddav'
# REPORT sucht Objekte innerhalb einer Sammlung; GET liest ein einzelnes Objekt.
# Die XML-Abfrage filtert bei Kalendern nach Termin oder Aufgabe.
query = f'<c:{kind}-query xmlns:c="{ns}" xmlns:d="DAV:"><d:prop><d:getetag/></d:prop>'
query += ('<c:filter><c:comp-filter name="VCALENDAR"><c:comp-filter name="'+component+'"/></c:comp-filter></c:filter>' if kind=='calendar' else '<c:filter/>')
query += f'</c:{kind}-query>'
def report():
"""Fragt die Sammlung ab und sucht das zuvor angelegte Objekt in der Antwort."""
raw, _ = self.req('REPORT', path.rsplit('/',1)[0]+'/', query, {'Content-Type':'application/xml','Depth':'1'}, (207,))
root = E.fromstring(raw)
# href enthält die Adresse eines gefundenen Objekts.
# unquote wandelt URL-kodierte Zeichen wieder in normalen Text um.
hrefs = [U.unquote(e.text or '') for e in root.findall('.//{DAV:}href')]
if not any(h.endswith(path.rsplit('/',1)[1]) for h in hrefs):
raise RuntimeError('Angelegtes Objekt fehlt in REPORT-Abfrage')
self.check(component+' per DAV-REPORT finden', report)
# replace erzeugt neuen Text mit geänderter Zusammenfassung bzw. geändertem Namen.
updated = text.replace('SUMMARY:'+self.tag, 'SUMMARY:'+self.tag+' aktualisiert') if kind=='calendar' else text.replace('FN:'+self.tag, 'FN:'+self.tag+' aktualisiert')
if self.check(component+' aktualisieren', lambda: self.req('PUT', path, updated, {'Content-Type':mime}, (204,))):
def verify_update():
"""Liest erneut und sucht die Markierung der vorgenommenen Änderung."""
raw, _ = self.req('GET', path)
if (self.tag+' aktualisiert').encode() not in raw:
raise RuntimeError('Aktualisierung fehlt im gelesenen Objekt')
self.check(component+' Aktualisierung prüfen', verify_update)
if self.check(component+' löschen', lambda: self.req('DELETE', path, codes=(204,))):
self.check(component+' Löschung prüfen (404 erwartet)', lambda: self.req('GET', path, codes=(404,)))
def run(self):
"""Steuert den Gesamtbetrieb und versucht im finally-Block aufzuräumen."""
self.log('START '+self.tag+' | '+self.base)
self.log('Nur eigene Testdaten; Papierkorb/Versionen können Testreste enthalten.')
try:
self.check('Öffentlicher Serverstatus', self.status)
self.check('Login-Seite abrufen', lambda: self.req('GET','/index.php/login',auth=False))
if not self.check('Authentifizierung und Benutzerkennung', self.user):
return 1
self.check('OCS Capabilities', lambda: self.ocs('cloud/capabilities'))
self.check('WebDAV-Einstieg', lambda: self.prop('/remote.php/dav/'))
self.files()
if not self.a.no_dav:
self.collection('calendar')
self.collection('addressbook')
# finally läuft auch bei einer Ausnahme und normalerweise auch bei Strg+C.
# Ein harter Prozessabbruch oder nicht erreichbarer Server kann Aufräumen verhindern.
finally:
self.log('AUFRÄUMEN')
# In umgekehrter Reihenfolge werden die bestätigten Testsammlungen gelöscht.
# lambda p=path hält den aktuellen Schleifenwert als Standardargument fest.
# 404 beim Aufräumen ist akzeptiert: Die Sammlung ist dann schon nicht mehr da.
for path in reversed(self.cleanup):
self.check('Testsammlung entfernen: '+path, lambda p=path: self.req('DELETE',p,codes=(204,404)))
self.log('ERGEBNIS '+self.tag)
for label, state, detail in self.results:
self.log(f'{state}: {label}'+(' — '+detail if detail else ''))
self.log(f'{sum(x[1]=="OK" for x in self.results)} OK; {sum(x[1]=="FEHLER" for x in self.results)} Fehler')
return int(any(x[1]=='FEHLER' for x in self.results))
def main():
"""Liest Argumente und Passwort ein und startet den Testlauf."""
# argparse erzeugt automatisch --help und prüft bekannte Argumente.
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument('url', help='Kanonische HTTPS-URL inklusive Unterverzeichnis, falls vorhanden')
p.add_argument('--user', required=True, help='Anmeldename (kein Anzeigename)')
p.add_argument('--mib', type=int, default=8, help='Binärtestgröße, 1–128 MiB; Standard 8')
p.add_argument('--pause', type=float, default=1, help='Pause nach jedem Test in Sekunden')
p.add_argument('--timeout', type=int, default=90, help='Timeout je Anfrage in Sekunden')
# store_true macht aus einem Schalter einen booleschen Wert.
# --no-dav überspringt NUR Kalender/Aufgaben/Kontakte; Datei-WebDAV bleibt aktiv.
p.add_argument('--no-dav', action='store_true', help='Kalender-, Aufgaben- und Kontakttests auslassen')
# Die Argumente stehen danach z. B. als a.user und a.pause zur Verfügung.
a = p.parse_args()
# Die Adresse wird in Schema, Host, Pfad usw. zerlegt und geprüft.
u = U.urlsplit(a.url)
if u.scheme != 'https' or not u.netloc or u.username or u.password or u.query or u.fragment:
p.error('Eine HTTPS-URL ohne Zugangsdaten, Query oder Fragment angeben')
if not 1 <= a.mib <= 128 or a.pause < 0 or a.timeout < 1:
p.error('Ungültige Größe, Pause oder Timeout')
# Das Passwort steht weder im Programmaufruf noch in dessen Shell-History.
# Es bleibt während des Laufs im Speicher und wird nicht ins Protokoll geschrieben.
password = getpass.getpass('Nextcloud App-Passwort (verdeckte Eingabe): ')
if not password:
p.error('Passwort fehlt')
# SIGTERM ist ein normales Beendigungssignal. sys.exit löst SystemExit aus;
# dadurch kann der finally-Block des laufenden Tests noch aufräumen.
signal.signal(signal.SIGTERM, lambda *_: sys.exit(130))
try:
# Test(...) erzeugt ein Objekt, .run() startet dessen Gesamtprüfung.
return Test(a,password).run()
except KeyboardInterrupt:
print('\nAbgebrochen.', file=sys.stderr)
return 130
# Ein normaler Testfehler wird aufgezeichnet, statt den gesamten Lauf zu stoppen.
# Strg+C (KeyboardInterrupt) gehört nicht zu diesen normalen Exceptions.
except Exception as e:
print(f'Abbruch: {e}', file=sys.stderr)
return 1
# Dieser Block läuft nur beim direkten Start der Datei.
# Beim Importieren für lokale Tests wird main() nicht automatisch aufgerufen.
# sys.exit gibt den Rückgabewert als Prozessstatus an die Shell weiter.
if __name__ == '__main__':
sys.exit(main())
und eine Fassung ohne Kommentare
#!/usr/bin/env python3
"""Nextcloud HTTP/DAV smoke test. Python 3 standard library only.
Run: python3 nextcloud_basistest.py https://cloud.example.org --user NAME
Use an app password. No existing user data is edited. DELETE may leave test
files in Nextcloud's trash and versions. No mail, browser UI, cron, external
storage, sharing between users, or Collabora end-to-end test is performed.
Exit codes: 0 successful, 1 failed checks, 2 usage/configuration error.
"""
import argparse
import base64
import datetime as dt
import getpass
import hashlib
import json
import os
import signal
import sys
import time
import urllib.error
import urllib.parse as U
import urllib.request as R
import uuid
import xml.etree.ElementTree as E
class NoRedirect(R.HTTPRedirectHandler):
def redirect_request(self, req, fp, code, msg, headers, newurl):
return None
class Test:
def __init__(self, args, password):
self.a = args
self.base = args.url.rstrip('/')
self.tag = 'NC-Test-' + dt.datetime.now().strftime('%Y%m%d-%H%M%S-') + uuid.uuid4().hex[:10]
self.auth = 'Basic ' + base64.b64encode((args.user + ':' + password).encode()).decode()
self.http = R.build_opener(NoRedirect())
self.results = []
self.cleanup = []
self.uid = args.user
def log(self, text):
print(dt.datetime.now().astimezone().isoformat(timespec='seconds'), text, flush=True)
def req(self, method, path, data=None, headers=None, codes=(200,), auth=True):
url = self.base + path
h = {'User-Agent': 'Nextcloud-Basistest/1.0', 'X-Request-ID': self.tag}
if auth:
h['Authorization'] = self.auth
h.update(headers or {})
if isinstance(data, str):
data = data.encode()
self.log(f' {method} {path}')
start = time.monotonic()
try:
with self.http.open(R.Request(url, data=data, headers=h, method=method), timeout=self.a.timeout) as r:
status, body, rh = r.status, r.read(), r.headers
except urllib.error.HTTPError as e:
status, body, rh = e.code, e.read(), e.headers
self.log(f' HTTP {status}; {time.monotonic()-start:.2f}s; Request-ID: {rh.get("X-Request-ID", "-")}')
if status not in codes:
# Do not print response bodies: they may contain personal information.
raise RuntimeError(f'HTTP {status}, erwartet {codes}; bei 3xx kanonische HTTPS-URL verwenden')
return body, rh
def check(self, label, fn):
self.log('TEST: ' + label)
try:
fn()
except Exception as e:
self.results.append((label, 'FEHLER', str(e)))
self.log('FEHLER: ' + str(e))
return False
self.results.append((label, 'OK', ''))
self.log('OK: ' + label)
time.sleep(self.a.pause)
return True
def ocs(self, path):
raw, _ = self.req('GET', '/ocs/v2.php/' + path + '?format=json', headers={'OCS-APIRequest': 'true'})
obj = json.loads(raw)['ocs']
if str(obj['meta']['statuscode']) not in ('100', '200'):
raise RuntimeError('OCS-Anfrage meldet keinen Erfolg')
return obj['data']
def prop(self, path, depth='0'):
body, _ = self.req('PROPFIND', path,
'<d:propfind xmlns:d="DAV:"><d:prop><d:resourcetype/><d:getetag/><d:getcontentlength/></d:prop></d:propfind>',
{'Depth': depth, 'Content-Type': 'application/xml'}, (207,))
root = E.fromstring(body)
responses = root.findall('{DAV:}response')
if not responses:
raise RuntimeError('Leere DAV-Multistatus-Antwort')
for response in responses:
statuses = [s.text or '' for s in response.findall('.//{DAV:}status')]
if not statuses or not any(' 200 ' in s for s in statuses):
raise RuntimeError('DAV-Teilergebnis ohne erfolgreiche Eigenschaften')
return root
def status(self):
raw, _ = self.req('GET', '/status.php', auth=False)
s = json.loads(raw)
if not s.get('installed') or s.get('maintenance') or s.get('needsDbUpgrade'):
raise RuntimeError('Nicht installiert, Wartungsmodus oder Datenbank-Upgrade erforderlich')
self.log('Nextcloud-Version: ' + str(s.get('versionstring', '?')))
def user(self):
self.uid = self.ocs('cloud/user')['id']
def equal(self, path, expected):
body, _ = self.req('GET', path)
if hashlib.sha256(body).digest() != hashlib.sha256(expected).digest():
raise RuntimeError('Heruntergeladener Inhalt stimmt nicht überein')
def files(self):
root = '/remote.php/dav/files/' + U.quote(self.uid, safe='') + '/'
folder = root + self.tag + '/'
self.check('Dateiliste und Metadaten im Benutzerverzeichnis', lambda: self.prop(root, '1'))
if not self.check('Testordner anlegen', lambda: self.req('MKCOL', folder, codes=(201,))):
return
self.cleanup.append(folder)
file = folder + U.quote('Prüfung mit Leerzeichen äöü.txt')
content = ('Nextcloud Migrationstest ' + self.tag + '\nGrüße aus dem Basistest.\n').encode()
if self.check('Textdatei hochladen', lambda: self.req('PUT', file, content, {'If-None-Match': '*'}, (201,))):
self.check('Download mit Inhaltsvergleich', lambda: self.equal(file, content))
changed = content + b'Updated\n'
if self.check('Eigene Testdatei aktualisieren', lambda: self.req('PUT', file, changed, codes=(204,))):
self.check('Aktualisierten Inhalt prüfen', lambda: self.equal(file, changed))
copied, moved = folder + 'Kopie.txt', folder + 'Verschoben.txt'
if self.check('Datei kopieren', lambda: self.req('COPY', file, headers={'Destination': self.base+copied, 'Overwrite':'F'}, codes=(201,))):
if self.check('Kopie verschieben', lambda: self.req('MOVE', copied, headers={'Destination':self.base+moved,'Overwrite':'F'}, codes=(201,))):
self.check('Verschobene Datei lesen', lambda: self.equal(moved, changed if any(x[0]=='Eigene Testdatei aktualisieren' and x[1]=='OK' for x in self.results) else content))
self.check('Einzeldatei löschen', lambda: self.req('DELETE', moved, codes=(204,)))
self.check('Löschung prüfen (404 hier erwartet)', lambda: self.req('GET', moved, codes=(404,)))
self.check('Testordner auflisten', lambda: self.prop(folder, '1'))
blob = os.urandom(self.a.mib * 1024 * 1024)
big = folder + 'Binaertest.bin'
if self.check(f'Binärdatei hochladen ({self.a.mib} MiB)', lambda: self.req('PUT', big, blob, {'If-None-Match':'*'}, (201,))):
self.check('Binärdatei vollständig vergleichen', lambda: self.equal(big, blob))
def collection(self, kind):
cal = kind == 'calendar'
parent = '/remote.php/dav/' + ('calendars/' if cal else 'addressbooks/users/') + U.quote(self.uid, safe='') + '/'
self.check(('CalDAV' if cal else 'CardDAV') + ' Sammlungen abrufen', lambda: self.prop(parent, '1'))
path = parent + self.tag + '/'
if cal:
method = 'MKCALENDAR'
xml = '<c:mkcalendar xmlns:c="urn:ietf:params:xml:ns:caldav" xmlns:d="DAV:"><d:set><d:prop><d:displayname>'+self.tag+'</d:displayname><c:supported-calendar-component-set><c:comp name="VEVENT"/><c:comp name="VTODO"/></c:supported-calendar-component-set></d:prop></d:set></c:mkcalendar>'
else:
method = 'MKCOL'
xml = '<d:mkcol xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:carddav"><d:set><d:prop><d:resourcetype><d:collection/><c:addressbook/></d:resourcetype><d:displayname>'+self.tag+'</d:displayname></d:prop></d:set></d:mkcol>'
if not self.check('Eigene Testsammlung anlegen: '+kind, lambda: self.req(method, path, xml, {'Content-Type':'application/xml'}, (201,))):
return
self.cleanup.append(path)
if cal:
stamp = dt.datetime.now(dt.timezone.utc).strftime('%Y%m%dT%H%M%SZ')
items = [('termin.ics', 'VEVENT', 'DTSTART:20300101T120000Z\r\nDTEND:20300101T123000Z'), ('aufgabe.ics','VTODO','STATUS:NEEDS-ACTION\r\nPERCENT-COMPLETE:0')]
for name, component, fields in items:
text = f'BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//NC Basistest//DE\r\nBEGIN:{component}\r\nUID:{uuid.uuid4()}\r\nDTSTAMP:{stamp}\r\nSUMMARY:{self.tag}\r\n{fields}\r\nEND:{component}\r\nEND:VCALENDAR\r\n'
self.dav_item(path+name, text, 'text/calendar', component, 'calendar')
else:
text = f'BEGIN:VCARD\r\nVERSION:3.0\r\nUID:{uuid.uuid4()}\r\nFN:{self.tag}\r\nN:Test;Nextcloud;;;\r\nEMAIL:nextcloud-test@example.invalid\r\nEND:VCARD\r\n'
self.dav_item(path+'kontakt.vcf', text, 'text/vcard', 'VCARD', 'addressbook')
def dav_item(self, path, text, mime, component, kind):
if not self.check(component+' anlegen', lambda: self.req('PUT', path, text, {'Content-Type':mime,'If-None-Match':'*'}, (201,))):
return
def read():
raw, _ = self.req('GET', path)
if self.tag not in raw.decode() or ('BEGIN:'+component) not in raw.decode():
raise RuntimeError('DAV-Inhalt fehlt')
self.check(component+' lesen', read)
ns = 'urn:ietf:params:xml:ns:caldav' if kind=='calendar' else 'urn:ietf:params:xml:ns:carddav'
query = f'<c:{kind}-query xmlns:c="{ns}" xmlns:d="DAV:"><d:prop><d:getetag/></d:prop>'
query += ('<c:filter><c:comp-filter name="VCALENDAR"><c:comp-filter name="'+component+'"/></c:comp-filter></c:filter>' if kind=='calendar' else '<c:filter/>')
query += f'</c:{kind}-query>'
def report():
raw, _ = self.req('REPORT', path.rsplit('/',1)[0]+'/', query, {'Content-Type':'application/xml','Depth':'1'}, (207,))
root = E.fromstring(raw)
hrefs = [U.unquote(e.text or '') for e in root.findall('.//{DAV:}href')]
if not any(h.endswith(path.rsplit('/',1)[1]) for h in hrefs):
raise RuntimeError('Angelegtes Objekt fehlt in REPORT-Abfrage')
self.check(component+' per DAV-REPORT finden', report)
updated = text.replace('SUMMARY:'+self.tag, 'SUMMARY:'+self.tag+' aktualisiert') if kind=='calendar' else text.replace('FN:'+self.tag, 'FN:'+self.tag+' aktualisiert')
if self.check(component+' aktualisieren', lambda: self.req('PUT', path, updated, {'Content-Type':mime}, (204,))):
def verify_update():
raw, _ = self.req('GET', path)
if (self.tag+' aktualisiert').encode() not in raw:
raise RuntimeError('Aktualisierung fehlt im gelesenen Objekt')
self.check(component+' Aktualisierung prüfen', verify_update)
if self.check(component+' löschen', lambda: self.req('DELETE', path, codes=(204,))):
self.check(component+' Löschung prüfen (404 erwartet)', lambda: self.req('GET', path, codes=(404,)))
def run(self):
self.log('START '+self.tag+' | '+self.base)
self.log('Nur eigene Testdaten; Papierkorb/Versionen können Testreste enthalten.')
try:
self.check('Öffentlicher Serverstatus', self.status)
self.check('Login-Seite abrufen', lambda: self.req('GET','/index.php/login',auth=False))
if not self.check('Authentifizierung und Benutzerkennung', self.user):
return 1
self.check('OCS Capabilities', lambda: self.ocs('cloud/capabilities'))
self.check('WebDAV-Einstieg', lambda: self.prop('/remote.php/dav/'))
self.files()
if not self.a.no_dav:
self.collection('calendar')
self.collection('addressbook')
finally:
self.log('AUFRÄUMEN')
for path in reversed(self.cleanup):
self.check('Testsammlung entfernen: '+path, lambda p=path: self.req('DELETE',p,codes=(204,404)))
self.log('ERGEBNIS '+self.tag)
for label, state, detail in self.results:
self.log(f'{state}: {label}'+(' — '+detail if detail else ''))
self.log(f'{sum(x[1]=="OK" for x in self.results)} OK; {sum(x[1]=="FEHLER" for x in self.results)} Fehler')
return int(any(x[1]=='FEHLER' for x in self.results))
def main():
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument('url', help='Kanonische HTTPS-URL inklusive Unterverzeichnis, falls vorhanden')
p.add_argument('--user', required=True, help='Anmeldename (kein Anzeigename)')
p.add_argument('--mib', type=int, default=8, help='Binärtestgröße, 1–128 MiB; Standard 8')
p.add_argument('--pause', type=float, default=1, help='Pause nach jedem Test in Sekunden')
p.add_argument('--timeout', type=int, default=90, help='Timeout je Anfrage in Sekunden')
p.add_argument('--no-dav', action='store_true', help='Kalender-, Aufgaben- und Kontakttests auslassen')
a = p.parse_args()
u = U.urlsplit(a.url)
if u.scheme != 'https' or not u.netloc or u.username or u.password or u.query or u.fragment:
p.error('Eine HTTPS-URL ohne Zugangsdaten, Query oder Fragment angeben')
if not 1 <= a.mib <= 128 or a.pause < 0 or a.timeout < 1:
p.error('Ungültige Größe, Pause oder Timeout')
password = getpass.getpass('Nextcloud App-Passwort (verdeckte Eingabe): ')
if not password:
p.error('Passwort fehlt')
signal.signal(signal.SIGTERM, lambda *_: sys.exit(130))
try:
return Test(a,password).run()
except KeyboardInterrupt:
print('\nAbgebrochen.', file=sys.stderr)
return 130
except Exception as e:
print(f'Abbruch: {e}', file=sys.stderr)
return 1
if __name__ == '__main__':
sys.exit(main())

Schreibe einen Kommentar