Zum Inhalt

Dynamische Properties beim Generieren injizieren

Diese Anleitung erklärt, wie Du mit DATAMIMIC dynamische Properties während des Generierungsprozesses einfügst, ohne die Projektdateien dauerhaft zu verändern. Das ist besonders nützlich, wenn Du das gleiche Projekt parallel mit unterschiedlichen Parametern ausführen möchtest – zum Beispiel in CI/CD-Pipelines oder bei Lasttests.

Das Problem

Stell Dir folgende Szenarien vor:

  • Paralleles Testen: Du führst denselben Test-Workflow gleichzeitig in mehreren Branches oder Umgebungen aus.
  • Lasttests: Du generierst mit demselben Datenmodell unterschiedliche Datenmengen.
  • Feature-Flags: Du testest verschiedene Feature-Konfigurationen, ohne für jede Variante ein eigenes Projekt anzulegen.
  • Umgebungsspezifische Werte: Du verwendest je nach Umgebung unterschiedliche Datenbankverbindungen oder API-Endpunkte.

Ohne dynamische Properties müsstest Du:

  1. Für jede Konfiguration ein eigenes Projekt anlegen (hoher Wartungsaufwand)
  2. Dateien vor jedem Lauf per API ändern (Race Conditions bei paralleler Ausführung)
  3. Komplexe Templating-Mechanismen nutzen (erhöhte Komplexität)

Die Lösung

Mit der Funktion Dynamische Properties Injection kannst Du:

  1. Projekte unverändert lassen: Die Originaldateien bleiben unangetastet.
  2. Werte pro Ausführung injizieren: Jeder API-Aufruf kann eigene Property-Werte mitgeben.
  3. Parallele Sicherheit gewährleisten: Keine Race Conditions bei gleichzeitigen Ausführungen.
  4. Isolierte Ausführungen sicherstellen: Jede Ausführung erhält ihre eigenen temporären Property-Werte.

Funktionsweise

Der Ablauf sieht wie folgt aus:

  1. Setup-Phase: Lege eine Properties-Datei in Deinem Projekt an (z.B. runtime.properties).
  2. Konfigurationsphase: Binde diese Properties-Datei mit höchster Priorität in Dein Hauptmodell ein.
  3. Ausführungsphase: Starte die Generierung per API und übergib individuelle Property-Werte.
  4. Injektionsphase: DATAMIMIC erstellt eine temporäre Kopie Deines Projekts und überschreibt die Properties-Datei mit den übergebenen Werten.
  5. Verarbeitungsphase: Die Generierung läuft mit den individuellen Werten.
  6. Cleanup-Phase: Temporäre Dateien werden entfernt, das Originalprojekt bleibt unverändert.

Projekt-Setup

Schritt 1: Properties-Datei anlegen

Lege im conf-Verzeichnis Deines Projekts eine Properties-Datei an. Der Dateiname muss auf .properties enden.

conf/runtime.properties
1
2
3
4
5
# Standardwerte für Laufzeit-Parameter
count=1000
user_segment=basic
feature_premium=false
database_timeout=30

Schritt 2: Properties-Datei im Hauptmodell einbinden

Binde die Properties-Datei in Deiner Haupt-XML (datamimic.xml) als letztes Include ein, damit sie die höchste Priorität hat:

datamimic.xml
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
<setup>
    <!-- Basis-Konfiguration zuerst einbinden -->
    <include uri="conf/base.properties"/>

    <!-- Weitere Konfigurationen -->
    <include uri="conf/database.properties"/>

    <!-- Runtime-Properties als LETZTES für höchste Priorität -->
    <include uri="conf/runtime.properties"/>

    <!-- Deine Datenmodelle -->
    <include uri="models/generate_users.xml"/>
    <include uri="models/generate_orders.xml"/>
</setup>

Reihenfolge der Includes ist wichtig

Properties-Dateien, die später eingebunden werden, überschreiben Werte aus früheren Includes. Binde daher die Runtime-Properties immer zuletzt ein.

Schritt 3: Properties in Modellen verwenden

Verwende die Properties in Deinen Datenmodellen wie folgt:

models/generate_users.xml
1
2
3
4
5
6
7
8
<setup>
    <generate name="users" count="{count}">
        <key name="user_id" generator="IncrementGenerator"/>
        <key name="user_segment" values="'{user_segment}'"/>
        <key name="is_premium" values="'{feature_premium}'"/>
        <key name="created_at" generator="DateTimeGenerator"/>
    </generate>
</setup>

API-Nutzung

Einfaches Beispiel

Nachdem Du Dein DATAMIMIC-Projekt in der UI eingerichtet hast, kannst Du per API den Generierungsprozess starten und dynamisch Property-Werte übergeben.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
curl -X POST "https://your-datamimic-instance/api/v1/{project-id}/generate" \
  -H "Authorization: Bearer {your-access-token}" \
  -H "Content-Type: application/json" \
  -d '{
    "task_type": "standard",
    "custom_property_file": {
      "name": "runtime.properties",
      "data": {
        "count": 5000,
        "user_segment": "premium",
        "feature_premium": true,
        "database_timeout": 60
      }
    }
  }'

Nach dem Absenden erhältst Du eine Task-ID, mit der Du den Status und das Ergebnis der Generierung abfragen kannst. Mehr dazu findest Du im Leitfaden zu Projekt-Zugriffstoken.

Mit diesem Ansatz kannst Du dasselbe Projekt parallel mit unterschiedlichen Konfigurationen ausführen – jede Ausführung erhält ihre eigenen isolierten Property-Werte.

Unterschiedliche Modell-Dateien pro Request verwenden

Du kannst auch pro Request eine andere Modell-Datei einbinden, indem Du den Dateinamen dynamisch übergibst. Angenommen, Du hast zwei Modell-Dateien: models/load_performance.xml und models/integration_test.xml.

Binde die Modell-Datei dynamisch ein:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
<!-- datamimic.xml -->
<setup>
    <!-- Dynamische Modell-Datei einbinden -->
    <include uri={dynamic_model_path}/>
    <!-- Weitere Datenmodelle -->
    <include uri="models/generate_users.xml"/>
    <include uri="models/generate_orders.xml"/>

    <include uri="conf/dynamic_model_path.properties"/>
</setup>

Deine Datei conf/dynamic_model_path.properties könnte so aussehen:

1
dynamic_model_path="models/load_performance.xml"

API-Request für den Lasttest:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
curl -X POST "https://your-datamimic-instance.com/api/v1/projects/your-project-id/generate" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "task_type": "standard",
    "custom_property_file": {
      "name": "runtime.properties",
      "data": {
        "dynamic_model_path": "models/load_performance.xml"
      }
    }
  }'

API-Request für den Integrationstest:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
curl -X POST "https://your-datamimic-instance.com/api/v1/projects/your-project-id/generate" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "task_type": "standard",
    "custom_property_file": {
      "name": "runtime.properties",
      "data": {
        "dynamic_model_path": "models/integration_test.xml"
      }
    }
  }'

Diese Requests können parallel ausgeführt werden und liefern jeweils unterschiedliche Daten.

Fehlerbehebung

Häufige Probleme

1. Properties-Datei nicht gefunden

Fehler: FileNotFoundError: runtime.properties not existed

Lösung: Die Properties-Datei muss im Projekt vorhanden sein, bevor Du dynamische Werte injizierst.

1
2
3
4
5
6
7
8
9
# Stelle sicher, dass die Datei existiert
curl -X POST "https://your-datamimic-instance.com/api/v1/projects/your-project-id/files" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "runtime.properties",
    "folder": "conf",
    "content": "count=1000\nuser_segment=basic\n"
  }'

2. Property-Werte werden nicht angewendet

Problem: Die generierten Daten spiegeln die injizierten Werte nicht wider.

Lösungen:

  1. Include-Reihenfolge prüfen: Runtime-Properties müssen zuletzt eingebunden werden.
  2. Property-Namen prüfen: Die Namen müssen exakt übereinstimmen.
  3. Syntax prüfen: Property-Referenzen müssen das Format {property_name} haben.

3. Ungültiger Property-Dateiname

Fehler: ValidationError: The file name must end with .properties

Lösung: Der Dateiname muss auf .properties enden:

1
2
3
4
5
6
{
  "custom_property_file": {
    "name": "runtime.properties",  // ✅ Korrekt
    "data": { ... }
  }
}

Debugging-Tipps

  1. Task-Logs prüfen: Mit der Task-ID kannst Du detaillierte Logs abrufen.
  2. Mit minimalen Properties testen: Starte mit einer Property, um Fehler einzugrenzen.
  3. JSON validieren: Stelle sicher, dass Dein API-Request korrekt formatiert ist.
  4. Dateiberechtigungen prüfen: Die Properties-Datei muss im Projekt lesbar sein.

Fazit

Mit der dynamischen Properties Injection kannst Du DATAMIMIC-Projekte sicher und flexibel parallel ausführen – ohne Race Conditions und mit sauberer Konfiguration. Die wichtigsten Erfolgsfaktoren sind:

  • Durchdachtes Projekt-Setup mit strategischer Einbindung der Property-Dateien
  • Sorgfältige API-Integration mit Fehlerbehandlung und Monitoring

Bei Fragen oder für fortgeschrittene Anwendungsfälle kontaktiere unser Support-Team.