fix(2.8.1): Sechs Befunde, eine Bauart - die Voreinstellung, die einsprang
Drei Agenten haben von aussen gemeldet, und fast jeder Befund hat dieselbe Form: Irgendwo sprang ein Vorgabewert ein, obwohl die richtige Antwort bekannt war - meist das Projekt, an das der Aufrufer ohnehin gebunden ist. #351 manage?action=next antwortete durchgaengig mit HTTP 500. In BugRepo::buildFilter() stand :project_scope zweimal in derselben Anweisung; mit ATTR_EMULATE_PREPARES=false bindet PDO jeden Namen genau einmal - zwei Marker, ein Wert, SQLSTATE[HY093]. Getroffen war nur "next", weil nur dort der Rueckkanal-Filter gesetzt wird. Damit gab es keine exklusive Uebernahme. Es ist der VIERTE Fall dieser Bauart, deshalb prueft scripts/pruefe_platzhalter.py das jetzt mechanisch vor jedem Ausliefern. #382 Meldungen ohne project_slug landeten im Scheinprojekt "default" - #387 ohne dc_projects-Zeile, also project_id NULL. Die Antwort sah wie ein #397 Erfolg aus, und danach sperrte dieselbe Token-Bindung den Zugriff (403 project_forbidden). Der Rueckfall aufs Heimatprojekt war an !isWorkbench gebunden; ein Werkbank-Token ohne Slug bekam gar keinen Vorgabewert. Jetzt: genannter Slug, sonst Heimatprojekt, sonst 400. Ein unbekanntes Projekt wird abgewiesen statt still angelegt. #364 Ohne project_slug lieferten list, stats und die Roadmap ALLE #176 Projekte statt des eigenen, weil die Vorgabe auf "all" stand und ein Werkbank-Token beim Lesen absichtlich nicht unter die Schranke faellt. Gemessen: 393 Items, davon 28 eigene. Ausgerechnet der erste Aufruf jeder Sitzung. Die Roadmap antwortet ausserdem schmal - 55 Felder je Eintrag waren 628.392 Zeichen und fuellten das Kontextfenster. #404 Watchdog-Monitore bekamen nie ein Projekt: upsertHeartbeat() wurde keines uebergeben, obwohl authorizeSource() die Token-Bindung liest. Befunde erbten dadurch "default" - dc_findings(project_slug=...) war fuer eine laufende, meldende Instanz leer. #131 Wo der Leseweg richtig verengte, sagte er es nicht: HTTP 200 mit dem umgeschriebenen Filter sieht aus wie eine Auskunft ueber das angefragte Projekt. Ein Agent, der vor dem Melden dc_search fragt, legt so das Duplikat an. Jetzt scoped_to und scope_note im Umschlag - nur bei tatsaechlicher Verengung. #354 dc-testkit 1.1.0 wurde zweimal mit verschiedenem Inhalt ausgeliefert (1898 und 1930 Zeilen), 1.0.0 davor ebenso. Der Absatz ueber DC_TESTKIT_VERSION stand die ganze Zeit im Skript und hat nicht getragen. Jetzt 1.1.1 plus ein Riegel in deploy.py, der abbricht, wenn sich der Inhalt aendert und die Nummer nicht. Warum die Testsuite all das nicht sah: Ihr Master-Token ist an kein Projekt gebunden und nimmt deshalb ueberall den anderen Zweig. Es gab sogar einen Testfall fuer action=next - er lief gruen, waehrend der Aufruf in der Praxis ausnahmslos scheiterte. Die neuen Faelle benutzen ausdruecklich projektgebundene Token; testctl kann dafuer jetzt owner_type und scopes waehlen. Ausserdem: Die Agentenvorlage nennt fuer die SDK-Fassung dc_link_project statt einer abgeschriebenen Zahl - "SDK 2.5.1" stand dort als Beispiel und wurde als Wert uebernommen. Nicht enthalten: die 20 Altlasten in "default". Sie sind ueber die API nicht erreichbar; sql/wartung/2026-08-31_default-projekt-aufraeumen.sql liegt dafuer bereit (alle 20 haben einen titelgleichen Zwilling im richtigen Projekt). 156 e2e-Faelle gruen, davon 9 neue. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Deploymentcenter Bot
co-authored by
Claude Opus 5
Claude Opus 5
parent
8274a6c0ac
commit
0e93345ab8
+115
-7
@@ -18,6 +18,7 @@ import os
|
||||
import json
|
||||
import ftplib
|
||||
import io
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import hashlib
|
||||
@@ -210,10 +211,76 @@ def upload_priority(entry):
|
||||
return (rank, rel_file)
|
||||
|
||||
|
||||
TESTKIT_DATEI = 'public/testkit/dc-testkit.sh'
|
||||
TESTKIT_CACHE_SCHLUESSEL = '__dc_testkit_version__'
|
||||
|
||||
|
||||
def testkit_fassung():
|
||||
"""Liest DC_TESTKIT_VERSION aus dem Testkit-Skript."""
|
||||
pfad = os.path.join(PROJECT_DIR, TESTKIT_DATEI)
|
||||
if not os.path.exists(pfad):
|
||||
return None
|
||||
|
||||
muster = re.compile(r'^DC_TESTKIT_VERSION="([^"]*)"')
|
||||
with open(pfad, 'r', encoding='utf-8', errors='replace') as f:
|
||||
for zeile in f:
|
||||
treffer = muster.match(zeile)
|
||||
if treffer:
|
||||
return treffer.group(1)
|
||||
return None
|
||||
|
||||
|
||||
def pruefe_testkit_fassung(cache, changes):
|
||||
"""
|
||||
Verhindert, dass zweimal derselbe Fassungsstand ausgeliefert wird.
|
||||
|
||||
Das Testkit liegt auf jeder Testmaschine als Kopie, und selfupdate
|
||||
entscheidet allein anhand von DC_TESTKIT_VERSION, ob es sich lohnt zu
|
||||
holen. Bleibt die Zahl stehen, waehrend sich der Inhalt aendert, bleiben
|
||||
alte Kopien liegen - und melden dabei brav die neue Fassungsnummer.
|
||||
|
||||
Genau das ist zweimal passiert: 1.0.0 mit 1215 und mit 1335 Zeilen, dann
|
||||
1.1.0 mit 1898 und mit 1930. Beim zweiten Mal fehlte der aelteren Kopie
|
||||
der 2.8.0-Weg in cmd_confirm; jede Nachpruefung von dieser Maschine lief
|
||||
still im alten Verfahren weiter.
|
||||
|
||||
Verglichen wird gegen den Stand, den DIESE Maschine zuletzt hochgeladen
|
||||
hat - dieselbe Grundlage, auf der deploy.py ohnehin entscheidet, was sich
|
||||
geaendert hat. Ohne Cache (frische Arbeitskopie) wird nicht geprueft: dort
|
||||
wird ohnehin alles neu uebertragen, und eine Warnung ohne Vergleichspunkt
|
||||
waere geraten.
|
||||
"""
|
||||
wird_hochgeladen = any(rel == TESTKIT_DATEI for rel, _, _ in changes)
|
||||
if not wird_hochgeladen:
|
||||
return
|
||||
|
||||
zuletzt = cache.get(TESTKIT_CACHE_SCHLUESSEL)
|
||||
if zuletzt is None:
|
||||
return
|
||||
|
||||
jetzt = testkit_fassung()
|
||||
if jetzt is None or jetzt != zuletzt:
|
||||
return
|
||||
|
||||
print("")
|
||||
print(f" ABBRUCH: {TESTKIT_DATEI} hat sich geaendert, aber")
|
||||
print(f" DC_TESTKIT_VERSION steht weiterhin auf {jetzt}.")
|
||||
print("")
|
||||
print(" Damit wuerde dieselbe Fassungsnummer mit anderem Inhalt ausgeliefert.")
|
||||
print(" selfupdate auf den Testmaschinen sieht dann 'gleiche Fassung' und")
|
||||
print(" holt nichts - alte Kopien bleiben liegen und melden trotzdem die")
|
||||
print(" neue Nummer. Genau so ist Bugtracker #354 entstanden.")
|
||||
print("")
|
||||
print(" Zu tun: DC_TESTKIT_VERSION hochzaehlen und erneut ausliefern.")
|
||||
print("")
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
def dry_run():
|
||||
"""Zeigt an, was uebertragen wuerde, ohne eine Verbindung aufzubauen."""
|
||||
cache = load_cache()
|
||||
changes = collect_changes(cache)
|
||||
pruefe_testkit_fassung(cache, changes)
|
||||
|
||||
if not changes:
|
||||
print("Keine Aenderungen - der Server ist auf dem aktuellen Stand.")
|
||||
@@ -231,6 +298,19 @@ def deploy():
|
||||
cache = load_cache()
|
||||
new_cache = dict(cache)
|
||||
|
||||
# Erst sehen, was ansteht - dann erst eine Verbindung aufbauen.
|
||||
#
|
||||
# Vorher wurde zuerst eingewaehlt und danach gesammelt; ein Lauf ohne
|
||||
# Aenderungen oeffnete also eine FTP-Sitzung, nur um sie sofort wieder zu
|
||||
# schliessen. Und die Fassungspruefung unten will abbrechen, bevor
|
||||
# irgendetwas den Server erreicht.
|
||||
files_to_upload = collect_changes(cache)
|
||||
pruefe_testkit_fassung(cache, files_to_upload)
|
||||
|
||||
if not files_to_upload:
|
||||
print("No changed files to upload. Remote is up to date!")
|
||||
return
|
||||
|
||||
print(f"Connecting to FTP {config['host']}...")
|
||||
try:
|
||||
if config.get('secure', False):
|
||||
@@ -247,13 +327,6 @@ def deploy():
|
||||
print(f"FTP Connection failed: {e}")
|
||||
sys.exit(1)
|
||||
|
||||
files_to_upload = collect_changes(cache)
|
||||
|
||||
if not files_to_upload:
|
||||
print("No changed files to upload. Remote is up to date!")
|
||||
ftp.quit()
|
||||
return
|
||||
|
||||
print(f"Found {len(files_to_upload)} file(s) to upload:")
|
||||
for rel_file, full_path, file_hash in files_to_upload:
|
||||
print(f" -> {rel_file}")
|
||||
@@ -272,6 +345,15 @@ def deploy():
|
||||
ftp.storbinary(f"STOR {remote_file_path}", f)
|
||||
|
||||
new_cache[rel_file] = file_hash
|
||||
|
||||
# Womit diese Maschine das Testkit zuletzt beliefert hat. Nur so
|
||||
# hat pruefe_testkit_fassung() beim naechsten Lauf einen
|
||||
# Vergleichspunkt.
|
||||
if rel_file == TESTKIT_DATEI:
|
||||
fassung = testkit_fassung()
|
||||
if fassung is not None:
|
||||
new_cache[TESTKIT_CACHE_SCHLUESSEL] = fassung
|
||||
|
||||
uploaded += 1
|
||||
finally:
|
||||
# Der Cache wird auch bei einem Abbruch geschrieben. Sonst beginnt der
|
||||
@@ -323,10 +405,36 @@ def testlauf() -> None:
|
||||
print("")
|
||||
|
||||
|
||||
def platzhalter_pruefung() -> None:
|
||||
"""
|
||||
Statischer Suchlauf ueber alle SQL-Ausdruecke (scripts/pruefe_platzhalter.py).
|
||||
|
||||
Derselbe benannte Platzhalter zweimal in einer Anweisung ergibt mit
|
||||
ATTR_EMULATE_PREPARES = false einen sicheren HTTP 500. Das ist im
|
||||
Deploymentcenter viermal passiert - zuletzt in BugRepo::buildFilter(),
|
||||
wo es manage?action=next vollstaendig unbrauchbar machte (#351).
|
||||
|
||||
Nach dem dritten Mal stand der Vorsatz "ein Suchlauf ueber alle
|
||||
prepare()-Aufrufe gehoert zur Durchsicht" in der Testsuite. Ein Vorsatz
|
||||
hat das vierte Mal nicht verhindert; ein Aufruf an dieser Stelle schon.
|
||||
Er kostet keine Sekunde und braucht kein Netz.
|
||||
"""
|
||||
skript = SCRIPT_DIR / 'pruefe_platzhalter.py'
|
||||
if not skript.exists():
|
||||
return
|
||||
|
||||
ergebnis = subprocess.run([sys.executable, str(skript), str(PROJECT_DIR)])
|
||||
if ergebnis.returncode != 0:
|
||||
print(" Ausliefern abgebrochen - siehe oben.")
|
||||
sys.exit(ergebnis.returncode)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
if '--dry-run' in sys.argv or '-n' in sys.argv:
|
||||
platzhalter_pruefung()
|
||||
dry_run()
|
||||
else:
|
||||
platzhalter_pruefung()
|
||||
if '--ohne-test' in sys.argv:
|
||||
print("Testlauf uebersprungen (--ohne-test).")
|
||||
else:
|
||||
|
||||
@@ -0,0 +1,249 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Sucht vorbereitete Anweisungen, in denen derselbe benannte Platzhalter
|
||||
mehrfach vorkommt.
|
||||
|
||||
WARUM ES DIESES SKRIPT GIBT
|
||||
---------------------------
|
||||
Core\\Db setzt PDO::ATTR_EMULATE_PREPARES = false. MySQL bereitet die Anweisung
|
||||
dann selbst vor, und PDO uebersetzt benannte Platzhalter in positionsgebundene
|
||||
- wobei jeder Name genau EINMAL gebunden wird. Steht ":foo" zweimal im SQL,
|
||||
hat die Anweisung zwei Marker und bekommt einen Wert. Ergebnis: SQLSTATE[HY093]
|
||||
und ein HTTP 500.
|
||||
|
||||
Das ist im Deploymentcenter viermal passiert:
|
||||
|
||||
1. Volltextsuche im Bugtracker
|
||||
2. ProjectLinks::between()
|
||||
3. ProjectLinks::forProject()
|
||||
4. BugRepo::buildFilter(), Rueckkanal fuer Nachpruefungen (Bugtracker #351)
|
||||
|
||||
Im vierten Fall traf es ausschliesslich manage?action=next - der einzige
|
||||
Aufruf, der den betroffenen Filterzweig setzt. claim, release, list und stats
|
||||
liefen durch dieselbe Funktion und blieben heil, was die Suche lange in die
|
||||
falsche Richtung geschickt hat.
|
||||
|
||||
Nach dem dritten Mal stand in tests/e2e/suite_bugtracker.py der Satz: "ein
|
||||
Suchlauf ueber alle prepare()-Aufrufe gehoert zur Durchsicht". Er stand dort
|
||||
als Vorsatz. Das vierte Mal kam trotzdem. Deshalb jetzt als Skript.
|
||||
|
||||
AUFRUF
|
||||
------
|
||||
python scripts/pruefe_platzhalter.py # ganzes Repository
|
||||
python scripts/pruefe_platzhalter.py src/ # nur ein Teilbaum
|
||||
|
||||
Rueckgabewert 1, wenn etwas gefunden wurde - damit es sich in einen
|
||||
Vorab-Check haengen laesst.
|
||||
|
||||
VERKETTUNG
|
||||
----------
|
||||
Geprueft wird nicht je Literal, sondern je VERKETTETEM AUSDRUCK. Das ist der
|
||||
Punkt, an dem die erste Fassung dieses Skripts versagt hat: Der Fehler in
|
||||
BugRepo::buildFilter() stand in
|
||||
|
||||
'(project_slug = :project_scope
|
||||
OR (status = "' . self::STATUS_AWAITING_VERIFICATION . '"
|
||||
... WHERE project_slug = :project_scope)))'
|
||||
|
||||
also in ZWEI Literalen, in jedem genau einmal. Pro Literal gezaehlt war das
|
||||
unauffaellig; erst der zusammengesetzte Text hat den Namen doppelt. Ein
|
||||
Pruefer, der genau den Fehler nicht findet, der ihn ausgeloest hat, ist keiner.
|
||||
|
||||
Zusammengefasst werden zwei aufeinanderfolgende Literale, wenn zwischen ihnen
|
||||
ein "." steht und kein ";" "," "[" oder "]". Damit faellt der haeufige Fall
|
||||
"Liste mehrerer eigenstaendiger Anweisungen in einem Array" heraus - dort
|
||||
trennt ein Komma, und jede Anweisung wird fuer sich gebunden.
|
||||
|
||||
GRENZEN
|
||||
-------
|
||||
Verkettungen ueber einen Funktionsaufruf mit Komma hinweg
|
||||
('... :a' . f($x, 1) . '... :a') fallen durch. Dafuer waere ein PHP-Parser
|
||||
noetig, und der Aufwand stuende in keinem Verhaeltnis.
|
||||
"""
|
||||
|
||||
import collections
|
||||
import io
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
PLATZHALTER = re.compile(r":([a-zA-Z_][a-zA-Z0-9_]*)")
|
||||
|
||||
# Ohne diese Woerter ist ein Literal mit ":name" kein SQL, sondern etwa eine
|
||||
# Zeitangabe ("%H:%i") oder ein Doppelpunkt in Prosa.
|
||||
SQL_WORTE = re.compile(
|
||||
r"\b(SELECT|INSERT|UPDATE|DELETE|WHERE|VALUES|SET|FROM|AND|OR|IN|LIKE)\b",
|
||||
re.I,
|
||||
)
|
||||
|
||||
BS = chr(92)
|
||||
UEBERSPRINGEN = {".git", "__pycache__", "node_modules", "artifacts", "bin", "obj"}
|
||||
|
||||
|
||||
# Steht eines dieser Zeichen zwischen zwei Literalen, gehoeren sie NICHT zu
|
||||
# demselben Ausdruck: Komma und Semikolon trennen, eckige Klammern deuten auf
|
||||
# eine Liste eigenstaendiger Anweisungen.
|
||||
TRENNER = set(";,[]")
|
||||
|
||||
# Wie weit zwei Literale hoechstens auseinanderliegen duerfen, um noch als
|
||||
# verkettet zu gelten. Verhindert, dass ueber halbe Dateien hinweg
|
||||
# zusammengefasst wird, wenn die Klammernerkennung einmal danebengreift.
|
||||
MAX_LUECKE = 300
|
||||
|
||||
|
||||
def literale(src):
|
||||
"""
|
||||
Liefert (zeile, inhalt, anfang, ende) je einfach begrenztem Stringliteral.
|
||||
|
||||
Kommentare und doppelt begrenzte Zeichenketten werden uebersprungen -
|
||||
sonst meldet ein Beispiel-SQL im Kommentar einen Treffer, den es nicht
|
||||
gibt.
|
||||
"""
|
||||
i = 0
|
||||
n = len(src)
|
||||
|
||||
while i < n:
|
||||
c = src[i]
|
||||
|
||||
if c == "/" and i + 1 < n and src[i + 1] == "/":
|
||||
i = src.find("\n", i)
|
||||
if i < 0:
|
||||
return
|
||||
continue
|
||||
|
||||
if c == "/" and i + 1 < n and src[i + 1] == "*":
|
||||
j = src.find("*/", i + 2)
|
||||
i = (j + 2) if j >= 0 else n
|
||||
continue
|
||||
|
||||
if c == "#":
|
||||
i = src.find("\n", i)
|
||||
if i < 0:
|
||||
return
|
||||
continue
|
||||
|
||||
if c == '"':
|
||||
i += 1
|
||||
while i < n:
|
||||
if src[i] == BS:
|
||||
i += 2
|
||||
continue
|
||||
if src[i] == '"':
|
||||
break
|
||||
i += 1
|
||||
i += 1
|
||||
continue
|
||||
|
||||
if c == "'":
|
||||
zeile = src[:i].count("\n") + 1
|
||||
anfang = i
|
||||
i += 1
|
||||
start = i
|
||||
while i < n:
|
||||
if src[i] == BS:
|
||||
i += 2
|
||||
continue
|
||||
if src[i] == "'":
|
||||
break
|
||||
i += 1
|
||||
yield zeile, src[start:i], anfang, i + 1
|
||||
i += 1
|
||||
continue
|
||||
|
||||
i += 1
|
||||
|
||||
|
||||
def verkettet(src, ende_a, anfang_b):
|
||||
"""Gehoeren zwei benachbarte Literale zu demselben verketteten Ausdruck?"""
|
||||
luecke = src[ende_a:anfang_b]
|
||||
|
||||
if len(luecke) > MAX_LUECKE:
|
||||
return False
|
||||
if "." not in luecke:
|
||||
return False
|
||||
|
||||
return not any(z in TRENNER for z in luecke)
|
||||
|
||||
|
||||
def gruppen(src):
|
||||
"""
|
||||
Fasst verkettete Literale zusammen.
|
||||
|
||||
Liefert (zeile, zusammengesetzter_text) je Ausdruck - also genau den Text,
|
||||
den PDO am Ende zu sehen bekommt.
|
||||
"""
|
||||
aktuell = None
|
||||
|
||||
for zeile, text, anfang, ende in literale(src):
|
||||
if aktuell is not None and verkettet(src, aktuell["ende"], anfang):
|
||||
aktuell["text"] += text
|
||||
aktuell["ende"] = ende
|
||||
continue
|
||||
|
||||
if aktuell is not None:
|
||||
yield aktuell["zeile"], aktuell["text"]
|
||||
|
||||
aktuell = {"zeile": zeile, "text": text, "ende": ende}
|
||||
|
||||
if aktuell is not None:
|
||||
yield aktuell["zeile"], aktuell["text"]
|
||||
|
||||
|
||||
def pruefe(wurzel):
|
||||
befunde = []
|
||||
|
||||
for root, dirs, files in os.walk(wurzel):
|
||||
dirs[:] = [d for d in dirs if d not in UEBERSPRINGEN]
|
||||
|
||||
for name in sorted(files):
|
||||
if not name.endswith(".php"):
|
||||
continue
|
||||
|
||||
pfad = os.path.join(root, name)
|
||||
src = io.open(pfad, encoding="utf-8", errors="replace").read()
|
||||
|
||||
for zeile, lit in gruppen(src):
|
||||
if not SQL_WORTE.search(lit):
|
||||
continue
|
||||
|
||||
zaehler = collections.Counter(PLATZHALTER.findall(lit))
|
||||
doppelt = {k: v for k, v in sorted(zaehler.items()) if v > 1}
|
||||
|
||||
if doppelt:
|
||||
befunde.append((pfad, zeile, doppelt))
|
||||
|
||||
return befunde
|
||||
|
||||
|
||||
def main():
|
||||
wurzel = sys.argv[1] if len(sys.argv) > 1 else os.path.join(
|
||||
os.path.dirname(os.path.abspath(__file__)), os.pardir
|
||||
)
|
||||
|
||||
befunde = pruefe(wurzel)
|
||||
|
||||
if not befunde:
|
||||
print("Platzhalter-Pruefung: nichts gefunden.")
|
||||
return 0
|
||||
|
||||
print("")
|
||||
print(" Derselbe benannte Platzhalter steht mehrfach in einer Anweisung.")
|
||||
print(" Mit ATTR_EMULATE_PREPARES = false endet das in SQLSTATE[HY093]")
|
||||
print(" und damit in HTTP 500 - siehe Kopf dieses Skripts.")
|
||||
print("")
|
||||
|
||||
for pfad, zeile, doppelt in befunde:
|
||||
stellen = ", ".join("%s (%dx)" % (k, v) for k, v in doppelt.items())
|
||||
print(" %s:%d %s" % (pfad, zeile, stellen))
|
||||
|
||||
print("")
|
||||
print(" Abhilfe: je Vorkommen ein eigener Name, beide mit demselben Wert")
|
||||
print(" belegt. Siehe BugRepo::buildFilter(), :project_scope /")
|
||||
print(" :project_scope_affects.")
|
||||
print("")
|
||||
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Reference in New Issue
Block a user