Hallo ChatGPT! Warum funktioniert das Skript camunda-tool.py nicht? $ ./camunda.sh retry-incidents /usr/lib/python3/dist-packages/requests/__init__.py:87: RequestsDependencyWarning: urllib3 (2.3.0) or chardet (4.0.0) doesn't match a supported version! warnings.warn("urllib3 ({}) or chardet ({}) doesn't match a supported " 🔍 Analysiere Incidents... 📊 Gefunden: 7074 Incidents 7068 betroffene Jobs Nach Typ: - failedJob: 6638 - failedExternalTask: 436 🤔 Möchtest du 7068 Jobs retry-en? (y/N): y 🚀 Starte Retry... ⚠️ Batch API nicht verfügbar, verwende individuelles Retry... (Das kann bei vielen Jobs etwas dauern) ❌ Unerwarteter Fehler: name 'print_progress_bar' is not defined Hier der Code: #!/usr/bin/env python3 """ Camunda 7 Toolset - CLI Tool für häufige Camunda-Operationen """ import requests import json import argparse from typing import Optional, Dict, List from datetime import datetime import sys import time class CamundaClient: def __init__(self, base_url: str, username: Optional[str] = None, password: Optional[str] = None, verify_ssl: bool = True): self.base_url = base_url.rstrip('/') self.auth = (username, password) if username and password else None self.verify_ssl = verify_ssl self.session = requests.Session() if self.auth: self.session.auth = self.auth # SSL Warnung unterdrücken wenn verify=False if not verify_ssl: import urllib3 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) def _get(self, endpoint: str, params: Optional[Dict] = None) -> requests.Response: url = f"{self.base_url}{endpoint}" response = self.session.get(url, params=params, verify=self.verify_ssl) response.raise_for_status() return response def _post(self, endpoint: str, data: Optional[Dict] = None) -> requests.Response: url = f"{self.base_url}{endpoint}" response = self.session.post(url, json=data, headers={"Content-Type": "application/json"}, verify=self.verify_ssl) response.raise_for_status() return response def _delete(self, endpoint: str) -> requests.Response: url = f"{self.base_url}{endpoint}" response = self.session.delete(url, verify=self.verify_ssl) response.raise_for_status() return response def _put(self, endpoint: str, data: Optional[Dict] = None) -> requests.Response: url = f"{self.base_url}{endpoint}" response = self.session.put(url, json=data, headers={"Content-Type": "application/json"}, verify=self.verify_ssl) response.raise_for_status() return response # === INCIDENTS === def get_incidents(self, process_definition_key: Optional[str] = None) -> List[Dict]: """Holt alle Incidents""" params = {} if process_definition_key: params['processDefinitionKey'] = process_definition_key response = self._get('/incident', params=params) return response.json() def bulk_retry_incidents(self, process_definition_key: Optional[str] = None, retries: int = 1, use_batch: bool = True, progress_callback=None) -> Dict: """Führt Bulk Retry für alle Incidents aus""" query = { "withException": True, "noRetriesLeft": True } if process_definition_key: query['processDefinitionKey'] = process_definition_key if use_batch: # Versuche Batch API payload = { "jobQuery": query, "retries": retries } response = self._post('/batch/set-job-retries', payload) return response.json() else: # Fallback: Individual retry jobs = self.get_failed_jobs(process_definition_key) job_ids = [j['id'] for j in jobs] success_count = 0 failed_count = 0 for i, job_id in enumerate(job_ids, 1): try: self.set_job_retry(job_id, retries) success_count += 1 except Exception: failed_count += 1 if progress_callback: progress_callback(i, len(job_ids)) return { 'type': 'individual_retry', 'total': len(job_ids), 'success': success_count, 'failed': failed_count } def set_job_retry(self, job_id: str, retries: int = 1) -> None: """Setzt Retries für einen einzelnen Job""" payload = {"retries": retries} self._put(f'/job/{job_id}/retries', payload) def get_batch_status(self, batch_id: str) -> Dict: """Prüft Status eines Batches""" response = self._get(f'/batch/{batch_id}') return response.json() # === PROCESS INSTANCES === def get_process_instances(self, process_definition_key: Optional[str] = None, with_incidents: bool = False) -> List[Dict]: """Holt Process Instances""" params = {} if process_definition_key: params['processDefinitionKey'] = process_definition_key if with_incidents: params['withIncident'] = 'true' response = self._get('/process-instance', params=params) return response.json() def delete_process_instances(self, process_definition_key: str, skip_custom_listeners: bool = True) -> Dict: """Löscht alle Instanzen eines Prozesses (Bulk Delete)""" payload = { "processInstanceQuery": { "processDefinitionKey": process_definition_key }, "skipCustomListeners": skip_custom_listeners, "skipSubprocesses": False } response = self._post('/batch/process-instance/deletion', payload) return response.json() def cancel_process_instance(self, instance_id: str, reason: str = "Cancelled via toolset") -> None: """Cancelt eine einzelne Process Instance""" self._delete(f'/process-instance/{instance_id}?skipCustomListeners=true&skipIoMappings=true&failIfNotExists=false') # === DEPLOYMENTS === def get_deployments(self) -> List[Dict]: """Holt alle Deployments""" response = self._get('/deployment') return response.json() def get_process_definitions(self, latest_version: bool = True) -> List[Dict]: """Holt Process Definitions""" params = {} if latest_version: params['latestVersion'] = 'true' response = self._get('/process-definition', params=params) return response.json() # === JOBS === def get_failed_jobs(self, process_definition_key: Optional[str] = None) -> List[Dict]: """Holt alle fehlgeschlagenen Jobs""" params = { "withException": "true", "noRetriesLeft": "true" } if process_definition_key: params['processDefinitionKey'] = process_definition_key response = self._get('/job', params=params) return response.json() def set_job_retries(self, job_ids: List[str], retries: int = 1) -> None: """Setzt Retries für spezifische Jobs""" for job_id in job_ids: payload = {"retries": retries} self._post(f'/job/{job_id}/retries', payload) # === STATISTICS === def get_process_statistics(self) -> List[Dict]: """Holt Statistiken für alle Prozesse""" response = self._get('/process-definition/statistics?incidents=true') return response.json() # === MIGRATION === def get_process_definition_by_key(self, key: str, version: Optional[int] = None) -> Dict: """Holt eine spezifische Process Definition""" if version: response = self._get(f'/process-definition/key/{key}/version/{version}') else: response = self._get(f'/process-definition/key/{key}') return response.json() def get_all_versions(self, process_key: str) -> List[Dict]: """Holt alle Versionen eines Prozesses, sortiert nach Version""" params = {'key': process_key, 'sortBy': 'version', 'sortOrder': 'desc'} response = self._get('/process-definition', params=params) return response.json() def get_latest_version(self, process_key: str) -> Dict: """Holt die neueste Version eines Prozesses""" response = self._get(f'/process-definition/key/{process_key}') return response.json() def create_migration_plan(self, source_def_id: str, target_def_id: str, auto_map: bool = True) -> Dict: """Erstellt einen Migration Plan""" payload = { "sourceProcessDefinitionId": source_def_id, "targetProcessDefinitionId": target_def_id, "instructions": [], "updateEventTriggers": True } if auto_map: # Hole Activity IDs für Auto-Mapping response = self._post('/migration/generate', payload) return response.json() return payload def execute_migration(self, migration_plan: Dict, process_instance_ids: Optional[List[str]] = None, process_definition_id: Optional[str] = None, skip_listeners: bool = True, skip_io_mappings: bool = True) -> Dict: """Führt Migration aus""" payload = { "migrationPlan": migration_plan, "skipCustomListeners": skip_listeners, "skipIoMappings": skip_io_mappings } if process_instance_ids: payload["processInstanceIds"] = process_instance_ids elif process_definition_id: payload["processInstanceQuery"] = { "processDefinitionId": process_definition_id } response = self._post('/migration/executeAsync', payload) return response.json() def validate_migration_plan(self, migration_plan: Dict, process_instance_ids: List[str]) -> Dict: """Validiert einen Migration Plan""" payload = { "migrationPlan": migration_plan, "processInstanceIds": process_instance_ids } response = self._post('/migration/validate', payload) return response.json() def migrate_to_latest_version(self, process_key: str, from_version: Optional[int] = None, batch_size: int = 100, validate: bool = True, progress_callback=None) -> List[Dict]: """Migriert alle Instanzen auf die neueste Version""" results = [] # Hole neueste Version latest = self.get_latest_version(process_key) latest_version = latest['version'] latest_id = latest['id'] print(f" 🎯 Neueste Version: v{latest_version} (ID: {latest_id})") # Hole alle Versionen all_versions = self.get_all_versions(process_key) total_batches = 0 current_batch = 0 # Zähle Batches vorher for version_def in all_versions: current_version = version_def['version'] current_id = version_def['id'] if current_version == latest_version: continue if from_version and current_version != from_version: continue instances = self.get_process_instances() instances = [i for i in instances if i['definitionId'] == current_id] if instances: total_batches += (len(instances) + batch_size - 1) // batch_size start_time = time.time() for version_def in all_versions: current_version = version_def['version'] current_id = version_def['id'] if current_version == latest_version: continue if from_version and current_version != from_version: continue instances = self.get_process_instances() instances = [i for i in instances if i['definitionId'] == current_id] if not instances: print(f" ⏭️ Version {current_version}: Keine Instanzen") continue print(f" 📦 Version {current_version} → {latest_version}: {len(instances)} Instanzen") migration_plan = self.create_migration_plan(current_id, latest_id, auto_map=True) if validate and len(instances) > 0: test_ids = [instances[0]['id']] try: validation = self.validate_migration_plan(migration_plan, test_ids) if validation.get('validationReport', {}).get('hasFailures', False): print(f" ⚠️ Validierung fehlgeschlagen für Version {current_version}") print(f" {validation}") continue except Exception as e: print(f" ⚠️ Validierung nicht möglich: {e}") instance_ids = [i['id'] for i in instances] for i in range(0, len(instance_ids), batch_size): batch = instance_ids[i:i+batch_size] current_batch += 1 try: result = self.execute_migration( migration_plan, process_instance_ids=batch ) results.append({ 'from_version': current_version, 'to_version': latest_version, 'batch_id': result.get('id'), 'instances': len(batch) }) if progress_callback: progress_callback(current_batch, total_batches, start_time) except Exception as e: print(f"\n ✗ Batch {i//batch_size + 1} fehlgeschlagen: {e}") return results # === CLI COMMANDS === def cmd_list_incidents(client: CamundaClient, args): """Zeigt alle Incidents""" print("🔍 Lade Incidents...") incidents = client.get_incidents(args.process) if not incidents: print("✓ Keine Incidents gefunden!") return print(f"\n📋 {len(incidents)} Incidents gefunden:\n") # Gruppiere nach Prozess by_process = {} for inc in incidents: key = inc.get('processDefinitionId', 'Unknown') by_process.setdefault(key, []).append(inc) for process, incs in by_process.items(): print(f" 📌 {process}: {len(incs)} Incidents") for inc in incs[:5]: # Zeige max 5 pro Prozess print(f" - {inc.get('incidentType')}: {inc.get('incidentMessage', 'N/A')[:60]}") if len(incs) > 5: print(f" ... und {len(incs) - 5} weitere") print() def cmd_retry_incidents(client: CamundaClient, args): """Führt Bulk Retry aus""" print("🔍 Analysiere Incidents...") # Hole Incidents (nicht Jobs!) incidents = client.get_incidents(args.process) if not incidents: print("✓ Keine Incidents gefunden!") return # Extrahiere eindeutige Job-IDs aus Incidents job_ids = list(set([inc.get('configuration') for inc in incidents if inc.get('configuration')])) print(f"📊 Gefunden:") print(f" {len(incidents)} Incidents") print(f" {len(job_ids)} betroffene Jobs") # Gruppiere nach Typ by_type = {} for inc in incidents: inc_type = inc.get('incidentType', 'unknown') by_type[inc_type] = by_type.get(inc_type, 0) + 1 print(f"\n Nach Typ:") for inc_type, count in sorted(by_type.items(), key=lambda x: x[1], reverse=True): print(f" - {inc_type}: {count}") if not args.yes: confirm = input(f"\n🤔 Möchtest du {len(job_ids)} Jobs retry-en? (y/N): ") if confirm.lower() != 'y': print("❌ Abgebrochen") return print("\n🚀 Starte Retry...") # Versuche zuerst Batch API try: batch = client.bulk_retry_incidents(args.process, args.retries, use_batch=True) print(f"✓ Batch erstellt!") print(f" ID: {batch['id']}") print(f" Typ: {batch['type']}") print(f" Jobs: {batch.get('totalJobs', 'N/A')}") print(f"\n💡 Prüfe Status mit: ./camunda.sh batch-status {batch['id']}") except requests.exceptions.HTTPError as e: if e.response.status_code == 405: # Fallback auf individuelles Retry mit Job-IDs aus Incidents print("⚠️ Batch API nicht verfügbar, verwende individuelles Retry...") print(" (Das kann bei vielen Jobs etwas dauern)\n") start_time = time.time() success_count = 0 failed_count = 0 for i, job_id in enumerate(job_ids, 1): try: client.set_job_retry(job_id, args.retries) success_count += 1 except Exception: failed_count += 1 print_progress_bar(i, len(job_ids), start_time, prefix=' Fortschritt:') elapsed = time.time() - start_time elapsed_min = int(elapsed / 60) elapsed_sec = int(elapsed % 60) print(f"\n✓ Retry abgeschlossen! (Dauer: {elapsed_min}m {elapsed_sec}s)") print(f" Erfolgreich: {success_count}/{len(job_ids)}") if failed_count > 0: print(f" Fehlgeschlagen: {failed_count}") else: raise def cmd_list_processes(client: CamundaClient, args): """Zeigt alle Prozesse mit Statistiken""" print("🔍 Lade Process Definitions...") stats = client.get_process_statistics() if not stats: print("✓ Keine Prozesse gefunden!") return print(f"\n📊 {len(stats)} Prozesse gefunden:\n") print(f"{'Prozess Key':<40} {'Instances':<12} {'Incidents':<10}") print("-" * 65) for stat in sorted(stats, key=lambda x: x.get('instances', 0), reverse=True): key = stat.get('definition', {}).get('key', 'Unknown') instances = stat.get('instances', 0) incidents = sum(i.get('incidentCount', 0) for i in stat.get('incidents', [])) print(f"{key:<40} {instances:<12} {incidents:<10}") def cmd_list_instances(client: CamundaClient, args): """Zeigt Process Instances""" print("🔍 Lade Process Instances...") instances = client.get_process_instances(args.process, args.with_incidents) if not instances: print("✓ Keine Instances gefunden!") return print(f"\n📋 {len(instances)} Instances gefunden:\n") for inst in instances[:20]: # Zeige max 20 print(f" ID: {inst['id']}") print(f" Definition: {inst.get('definitionId', 'N/A')}") print(f" Business Key: {inst.get('businessKey', 'N/A')}") print(f" Suspended: {inst.get('suspended', False)}") print() if len(instances) > 20: print(f" ... und {len(instances) - 20} weitere") def cmd_delete_instances(client: CamundaClient, args): """Löscht alle Instances eines Prozesses""" if not args.process: print("❌ --process Parameter ist erforderlich!") return print(f"🔍 Prüfe Instances für Prozess '{args.process}'...") instances = client.get_process_instances(args.process) if not instances: print("✓ Keine Instances zum Löschen gefunden!") return print(f"⚠️ {len(instances)} Instances gefunden") if not args.yes: confirm = input(f"\n⚠️ WARNUNG: {len(instances)} Instances werden gelöscht! Fortfahren? (y/N): ") if confirm.lower() != 'y': print("❌ Abgebrochen") return print("\n🗑️ Starte Bulk Delete...") batch = client.delete_process_instances(args.process) print(f"✓ Batch erstellt!") print(f" ID: {batch['id']}") def cmd_batch_status(client: CamundaClient, args): """Zeigt Batch Status""" print(f"🔍 Lade Status für Batch {args.batch_id}...") batch = client.get_batch_status(args.batch_id) total = batch.get('totalJobs', 0) created = batch.get('jobsCreated', 0) print(f"\n📊 Batch Status:") print(f" ID: {batch['id']}") print(f" Typ: {batch['type']}") print(f" Jobs gesamt: {total}") print(f" Jobs erstellt: {created}") print(f" Noch offen: {total - created}") print(f" Suspended: {batch.get('suspended', False)}") def cmd_list_versions(client: CamundaClient, args): """Zeigt alle Versionen eines Prozesses""" print(f"🔍 Lade Versionen für Prozess '{args.process}'...") versions = client.get_all_versions(args.process) if not versions: print(f"❌ Prozess '{args.process}' nicht gefunden!") return latest = versions[0] print(f"\n📋 {len(versions)} Versionen für '{args.process}':\n") print(f"{'Version':<10} {'ID':<40} {'Instances':<12} {'Status'}") print("-" * 80) for v in versions: version = v['version'] vid = v['id'] # Zähle Instanzen für diese Version instances = client.get_process_instances() count = len([i for i in instances if i['definitionId'] == vid]) status = "🎯 LATEST" if v['id'] == latest['id'] else "" if count > 0 and v['id'] != latest['id']: status = "⚠️ NEEDS MIGRATION" print(f"{version:<10} {vid:<40} {count:<12} {status}") def cmd_migrate(client: CamundaClient, args): """Migriert Prozessinstanzen zur neuesten Version""" if not args.process: print("❌ --process Parameter ist erforderlich!") return print(f"🚀 Starte Migration für Prozess '{args.process}'...\n") # Hole neueste Version Info try: latest = client.get_latest_version(args.process) except Exception as e: print(f"❌ Prozess '{args.process}' nicht gefunden: {e}") return # Hole alle Instanzen all_instances = client.get_process_instances() all_versions = client.get_all_versions(args.process) # Zähle Instanzen pro Version instances_by_version = {} for v in all_versions: count = len([i for i in all_instances if i['definitionId'] == v['id']]) if count > 0: instances_by_version[v['version']] = { 'count': count, 'id': v['id'] } if not instances_by_version: print("✓ Keine Instanzen zum Migrieren gefunden!") return # Zeige was migriert wird total_to_migrate = sum(v['count'] for ver, v in instances_by_version.items() if ver != latest['version']) if total_to_migrate == 0: print(f"✓ Alle Instanzen sind bereits auf Version {latest['version']}!") return print(f"📊 Migration Overview:") print(f" Aktuellste Version: v{latest['version']}") print(f" Zu migrierende Instanzen: {total_to_migrate}") print() for ver, info in sorted(instances_by_version.items()): if ver != latest['version']: print(f" v{ver} → v{latest['version']}: {info['count']} Instanzen") if not args.yes: confirm = input(f"\n🤔 Migration starten? (y/N): ") if confirm.lower() != 'y': print("❌ Abgebrochen") return print("\n🔄 Starte Migration...\n") migration_start = time.time() def progress(current, total, start_time): print_progress_bar(current, total, start_time, prefix=' Migration:') results = client.migrate_to_latest_version( args.process, from_version=args.from_version, batch_size=args.batch_size, validate=not args.skip_validation, progress_callback=progress ) elapsed = time.time() - migration_start elapsed_min = int(elapsed / 60) elapsed_sec = int(elapsed % 60) if results: print(f"\n✓ Migration abgeschlossen! (Dauer: {elapsed_min}m {elapsed_sec}s)") print(f" {len(results)} Batch(es) erstellt") print(f"\n📋 Batch IDs:") for r in results: print(f" {r['batch_id']} (v{r['from_version']} → v{r['to_version']}, {r['instances']} Instanzen)") else: print("\n⚠️ Keine Migration durchgeführt") def cmd_migration_report(client: CamundaClient, args): """Zeigt einen Migrations-Report für alle Prozesse""" print("🔍 Analysiere Prozesse...\n") all_definitions = client.get_process_definitions(latest_version=False) all_instances = client.get_process_instances() # Gruppiere nach Process Key by_key = {} for defn in all_definitions: key = defn['key'] if key not in by_key: by_key[key] = { 'versions': [], 'latest_version': 0, 'instances_to_migrate': 0, 'total_instances': 0 } by_key[key]['versions'].append(defn) if defn['version'] > by_key[key]['latest_version']: by_key[key]['latest_version'] = defn['version'] # Zähle Instanzen for key, data in by_key.items(): for instance in all_instances: for defn in data['versions']: if instance['definitionId'] == defn['id']: data['total_instances'] += 1 if defn['version'] < data['latest_version']: data['instances_to_migrate'] += 1 # Ausgabe print(f"📊 Migration Report:\n") print(f"{'Process Key':<40} {'Versions':<10} {'Instances':<12} {'To Migrate':<12} {'Status'}") print("-" * 90) needs_migration = [] for key, data in sorted(by_key.items()): versions = len(data['versions']) total = data['total_instances'] to_migrate = data['instances_to_migrate'] if to_migrate > 0: status = f"⚠️ {to_migrate} need migration" needs_migration.append(key) elif total > 0: status = "✓ Up to date" else: status = "○ No instances" print(f"{key:<40} {versions:<10} {total:<12} {to_migrate:<12} {status}") if needs_migration: print(f"\n💡 Tipp: Migriere diese Prozesse mit:") for key in needs_migration[:3]: print(f" ./camunda-tool.py migrate --process {key}") if len(needs_migration) > 3: print(f" ... und {len(needs_migration) - 3} weitere") def main(): parser = argparse.ArgumentParser( description='Camunda 7 Toolset - Vereinfache deine Camunda-Arbeit', formatter_class=argparse.RawDescriptionHelpFormatter ) # Global options parser.add_argument('--url', default='http://localhost:8080/engine-rest', help='Camunda REST API URL (default: http://localhost:8080/engine-rest)') parser.add_argument('--username', help='Username für Authentication') parser.add_argument('--password', help='Password für Authentication') parser.add_argument('--no-verify-ssl', action='store_true', help='SSL-Zertifikat nicht verifizieren (für self-signed certificates)') subparsers = parser.add_subparsers(dest='command', help='Verfügbare Commands') # list-incidents p_incidents = subparsers.add_parser('list-incidents', help='Zeigt alle Incidents') p_incidents.add_argument('--process', help='Filter nach Process Definition Key') # retry-incidents p_retry = subparsers.add_parser('retry-incidents', help='Bulk Retry für Incidents') p_retry.add_argument('--process', help='Filter nach Process Definition Key') p_retry.add_argument('--retries', type=int, default=1, help='Anzahl Retries (default: 1)') p_retry.add_argument('-y', '--yes', action='store_true', help='Keine Bestätigung erforderlich') # list-processes subparsers.add_parser('list-processes', help='Zeigt alle Prozesse mit Statistiken') # list-instances p_list_inst = subparsers.add_parser('list-instances', help='Zeigt Process Instances') p_list_inst.add_argument('--process', help='Filter nach Process Definition Key') p_list_inst.add_argument('--with-incidents', action='store_true', help='Nur Instances mit Incidents') # delete-instances p_delete = subparsers.add_parser('delete-instances', help='Löscht alle Instances eines Prozesses') p_delete.add_argument('--process', required=True, help='Process Definition Key') p_delete.add_argument('-y', '--yes', action='store_true', help='Keine Bestätigung erforderlich') # batch-status p_batch = subparsers.add_parser('batch-status', help='Zeigt Status eines Batches') p_batch.add_argument('batch_id', help='Batch ID') # list-versions p_versions = subparsers.add_parser('list-versions', help='Zeigt alle Versionen eines Prozesses') p_versions.add_argument('--process', required=True, help='Process Definition Key') # migrate p_migrate = subparsers.add_parser('migrate', help='Migriert Instanzen zur neuesten Version') p_migrate.add_argument('--process', required=True, help='Process Definition Key') p_migrate.add_argument('--from-version', type=int, help='Nur von dieser Version migrieren') p_migrate.add_argument('--batch-size', type=int, default=100, help='Batch-Größe (default: 100)') p_migrate.add_argument('--skip-validation', action='store_true', help='Validierung überspringen') p_migrate.add_argument('-y', '--yes', action='store_true', help='Keine Bestätigung erforderlich') # migration-report subparsers.add_parser('migration-report', help='Zeigt Migrations-Übersicht für alle Prozesse') args = parser.parse_args() if not args.command: parser.print_help() sys.exit(1) # Client erstellen client = CamundaClient(args.url, args.username, args.password, verify_ssl=not args.no_verify_ssl) # Command ausführen commands = { 'list-incidents': cmd_list_incidents, 'retry-incidents': cmd_retry_incidents, 'list-processes': cmd_list_processes, 'list-instances': cmd_list_instances, 'delete-instances': cmd_delete_instances, 'batch-status': cmd_batch_status, 'list-versions': cmd_list_versions, 'migrate': cmd_migrate, 'migration-report': cmd_migration_report, } try: commands[args.command](client, args) except requests.exceptions.RequestException as e: print(f"\n❌ Fehler bei API-Anfrage: {e}") sys.exit(1) except Exception as e: print(f"\n❌ Unerwarteter Fehler: {e}") sys.exit(1) if __name__ == '__main__': main()

Es klappt trotzdem nicht. Ich habe die Funktion in die Klasse eingefügt.

In dem Skript funktioniert einfgach nichts und rein gar nichts! $ ./camunda.sh retry-incidents /usr/lib/python3/dist-packages/requests/__init__.py:87: RequestsDependencyWarning: urllib3 (2.3.0) or chardet (4.0.0) doesn't match a supported version! warnings.warn("urllib3 ({}) or chardet ({}) doesn't match a supported " 🔍 Analysiere Incidents... 📊 Gefunden: 7074 Incidents 7068 betroffene Jobs Nach Typ: - failedJob: 6638 - failedExternalTask: 436 🤔 Möchtest du 7068 Jobs retry-en? (y/N): y 🚀 Starte Retry... ⚠️ Batch API nicht verfügbar, verwende individuelles Retry... (Das kann bei vielen Jobs etwas dauern) Fortschritt: |████████████████████████████████████████| 7068/7068 ETA 0m 0ss ✓ Retry abgeschlossen! (Dauer: 9m 2s) Erfolgreich: 6638/7068 Fehlgeschlagen: 430 Die ANzahl der Incidents ist völlig aus der Luft gegriffen. Laut Camunda-Cockpit gibt es lediglich 430 Incidents.

Aktuell verwende ich Camunda v7.23.

Gerne!

Es wird immer noch völlig wirres Zeug angezeigt. Lediglich diese Incidents sind real: operation:6:41b9fbe4-bae5-11f0-927d-02420a00012f: 430 Incidents

Bevor wir hier wild probieren, teste ich das erst einmal über den Poszman.

Die Variante "?incidentStatus=open" liefert die richtigen Ergebnisse? Ist der Mandant eigentlich noch wichtig? Es gibt hier main und demo?

Die Version ist korrekt: /incident?incidentStatus=open&tenantIdIn=main

Lieber mit einem Tenant-Flag arbeiten. Wenn es nicht angegeben wird, dann soll "main" der STandard-Tenant sein.

Es werden immer noch alle Incidents angezeigt, auch solche, die nicht mehr offen sind: $ ./camunda.sh list-incidents /usr/lib/python3/dist-packages/requests/__init__.py:87: RequestsDependencyWarning: urllib3 (2.3.0) or chardet (4.0.0) doesn't match a supported version! warnings.warn("urllib3 ({}) or chardet ({}) doesn't match a supported " 🔍 Lade Incidents... 📋 7072 Incidents gefunden: 📌 None: 6636 Incidents - failedJob: ENGINE-23002 Process instance '74525d90-6c4a-11f0-93ab-0242a - failedJob: ENGINE-23002 Process instance '51585688-9981-11f0-b7a8-0242a - failedJob: ENGINE-23002 Process instance 'e6f9be22-9f2f-11ee-a1a5-0242a - failedJob: ENGINE-23002 Process instance '8171d525-b113-11ee-a1a5-0242a - failedJob: ENGINE-23002 Process instance 'c386f919-9f40-11ee-a1a5-0242a ... und 6631 weitere 📌 operation:6:41b9fbe4-bae5-11f0-927d-02420a00012f: 430 Incidents - failedExternalTask: TASK/CLIENT-01009 Exception while completing the external ta - failedExternalTask: TASK/CLIENT-01009 Exception while completing the external ta - failedExternalTask: TASK/CLIENT-01009 Exception while completing the external ta - failedExternalTask: TASK/CLIENT-01009 Exception while completing the external ta - failedExternalTask: TASK/CLIENT-01009 Exception while completing the external ta ... und 425 weitere 📌 48af72a9-bae5-11f0-927d-02420a00012f: 6 Incidents - failedExternalTask: TASK/CLIENT-01009 Exception while completing the external ta - failedExternalTask: TASK/CLIENT-01009 Exception while completing the external ta - failedExternalTask: TASK/CLIENT-01009 Exception while completing the external ta - failedExternalTask: TASK/CLIENT-01009 Exception while completing the external ta - failedExternalTask: TASK/CLIENT-01009 Exception while completing the external ta ... und 1 weitere

Sehr gerne!

Gerne!

Ich habe leider gleich Feierabend und Wochenende. Ich packe alle Skripte ein und dann machen wir alles vernünftig, wenn ich wieder daheim bin.