Workiva-ondersteuningscentrum

Door automatisch resourcebeperkingen af te dwingen en gedetailleerde logboeken te leveren (zoals te zien is in de onderstaande screenshots), zorgt Workiva Scripting voor zowel platformbetrouwbaarheid als transparantie voor ontwikkelaars die automatiseringsscripts bouwen en optimaliseren.

Beëindiging wanneer een run succesvol is voltooid

Wanneer een script normaal wordt voltooid zonder de limieten te overschrijden, bevat het logboek een overzicht van resourcegebruik met het gemiddelde en piekgebruik van geheugen, CPU, schijf en uitvoeringstijd. Deze informatie geeft inzicht in de prestatiekenmerken voor succesvol afgeronde runs.

Opmerking: Als een script erg snel wordt uitgevoerd (bijvoorbeeld minder dan 1 seconde), is het mogelijk dat resource sampling niet plaatsvindt. In die gevallen worden er geen gegevens over het gebruik van bronnen gerapporteerd in het logboek.

Script loopt te snel om te bemonsteren

Als een script te snel afloopt, kan de monitor geen gebruiksgegevens vastleggen.

Script heeft een normale uitgang

Als een script wordt voltooid zonder limieten te overschrijden, worden de statistieken van het resourcegebruik volledig weergegeven in het logboek.

Beëindiging bij overschrijding van limieten

Als een scriptrun de geconfigureerde limieten overschrijdt (bijvoorbeeld geheugen, schijfgebruik of toegewezen tijd), zal Scripting:

1. Het script veilig proberen te stoppen - Wanneer de limieten worden overschreden, stuurt Scripting eerst een beëindigingssignaal (SIGTERM) om het script op te laten ruimen en binnen 15 seconden af te sluiten.
2. Als het script niet binnen 15 seconden wordt afgesloten, stuurt Scripting een SIGKILL-signaal, dat het proces onmiddellijk stopt zonder opruiming toe te staan. Dit is een geforceerde beëindiging en de run wordt voltooid met een mislukte status (in rood weergegeven in het logboek). Deze status geeft een fout in het scriptsysteem aan.
3. Leg de reden voor het stoppen vast - het logboek laat zien welke limiet werd bereikt en vat het brongebruik van het script samen.

De volgende secties geven voorbeelden van wat er gebeurt als een script grenzen overschrijdt zonder code om deze signalen af te handelen. Zie Omgaan met systeemsignalen in scripts om te leren hoe u uw scripts kunt aanpassen zodat ze netjes op deze signalen reageren.

Geheugenlimiet overschreden

Wanneer een script de geconfigureerde geheugenlimiet overschrijdt, bevat het logboek de reden voor beëindiging en details over de overschreden drempel.

Schijfgebruiklimiet overschreden

Wanneer een script de geconfigureerde schijfgebruikslimiet overschrijdt, bevat het logboek de reden voor beëindiging en details over het schijfgebruik op het moment dat de limiet werd bereikt.

Toegewezen tijd overschreden

Wanneer een script de geconfigureerde toegewezen tijd overschrijdt, bevat het logboek de reden voor beëindiging en de totale geregistreerde runtime.

Beëindiging wanneer de gebruiker een run annuleert

Als een gebruiker een run handmatig annuleert, stuurt Scripting eerst een interruptsignaal (SIGINT) om het script te laten weten dat het moet stoppen. Het script heeft 15 seconden om op te ruimen, de voortgang op te slaan of terug te draaien voordat het wordt afgesloten. Na deze respijtperiode van 15 seconden vindt dezelfde sequentie plaats als hierboven beschreven: er wordt een afsluitingssignaal (SIGTERM) verzonden om het script nog eens 15 seconden de tijd te geven om op te ruimen, gevolgd door een laatste kill-signaal (SIGKILL) als het script nog steeds niet is afgesloten.

De onderstaande afbeelding laat zien hoe de scriptlogs verschijnen wanneer een script geen code bevat om het interruptsignaal af te handelen.

Zie Omgaan met systeemsignalen in scripts om te leren hoe u uw scripts kunt aanpassen zodat ze netjes op deze signalen reageren.

Ongeplande beëindigingen

In zeldzame gevallen, bijvoorbeeld wanneer een script sneller geheugen verbruikt dan het scriptsysteem kan controleren, kan het systeem een script beëindigen voordat het detecteert dat een limiet is overschreden. Wanneer dit gebeurt, logt Scripting een onvolledig gebruiksrapport, waarin alleen de gegevenspunten worden weergegeven die vóór de beëindiging zijn verzameld.

Systeemsignalen verwerken in scripts

Signaalverwerking zorgt ervoor dat uw script netjes wordt afgesloten wanneer het wordt geannuleerd of gestopt door het systeem. Door systeemsignalen op te vangen en erop te reageren, kan uw script bronnen vrijgeven, werk opslaan en netjes afsluiten (bijvoorbeeld wanneer de status wordt gerapporteerd als "voltooid") in plaats van geforceerd te worden afgesloten.

Wanneer een script wordt gestopt omdat een gebruiker het annuleert of omdat het de platformlimieten overschrijdt, levert Scripting onderbrekings-, beëindigings- en doodsignalen. Zie de eerdere secties voor meer informatie over hoe onderbrekings-, beëindigings- en doodsignalen worden geactiveerd.

Scriptsignalen en hoe deze te verwerken

In deze sectie vindt u codeblokken en een compleet voorbeeld dat u kunt gebruiken om deze signalen af te handelen.

U kunt uw signaalbehandelaars klein houden en het opruimen op één plaats afhandelen met behulp van een try/finally blok dat altijd wordt uitgevoerd bij afsluiten. Hierdoor blijven scripts voorspelbaar en gemakkelijk te onderhouden.

De algemene structuur voor het afhandelen van signalen in uw script is hetzelfde, ongeacht welk signaal ontvangen wordt:

• Bovenaan het bestand: modules importeren en de handler definiëren
• Vroege initialisatie: registreer de handler voordat u enig werk doet
• Rond uw werk: wikkel de hoofdcode in een try/finally blok zodat opruimen altijd wordt uitgevoerd

Gebruiker annuleert de run (SIGINT)

Dit gebeurt wanneer een gebruiker op Cancel klikt om de scriptrun te annuleren.

# --- Top van bestand --- import signal, sys # Tiny handler: verzoek om onmiddellijke, graceful exit def _graceful_exit(signum, frame): print("SIGINT ontvangen: annulering aangevraagd. Opruimen...") raise SystemExit(0) # --- Vroege initialisatie --- signal.signal(signal.SIGINT, _graceful_exit)

Rondom uw werk (later in het bestand):

proberen: # uw langlopende werk hier ... tot slot: # centrale plaats voor het sluiten van bestanden, doorspoelen van logs, etc. print("Laatste schoonmaak voor afsluiten")

De onderstaande afbeelding laat zien hoe de scriptlogs verschijnen wanneer het interruptsignaal (SIGINT) wordt afgehandeld.

Direct omgaan met KeyboardInterrupt

Workiva Scripting verhoogt ook KeyboardInterrupt wanneer SIGINT wordt afgeleverd aan de hoofdthread. U kunt deze uitzondering opvangen in uw try blok en hetzelfde opruimpad aanroepen dat is gedefinieerd door _graceful_exit().

proberen: # uw langlopende werk hier ... except KeyboardInterrupt: print("KeyboardInterrupt ontvangen: opruimen voor afsluiten...") _graceful_exit(None, None) finally: # centrale plaats voor het sluiten van bestanden, doorspoelen van logs, etc. print("Laatste opruiming voor afsluiten")

De onderstaande afbeelding laat zien hoe de scriptlogs verschijnen wanneer het interruptsignaal wordt afgehandeld via een toetsenbordinterrupt.

Scripting-beëindigingssignaal om te stoppen na een respijtperiode (SIGTERM)

Scripting vraagt uw script om te stoppen (bijvoorbeeld nadat de limieten zijn overschreden). Uw script heeft een korte respijtperiode om af te sluiten.

# --- Begin van bestand --- def _graceful_term(signum, frame): print("SIGTERM ontvangen: platform verzocht beëindiging. Afronden...") raise SystemExit(0) # --- Vroege initialisatie --- signal.signal(signal.SIGTERM, _graceful_term)

De onderstaande afbeelding laat zien hoe de scriptlogs verschijnen wanneer het beëindigingssignaal (SIGTERM) wordt afgehandeld.

Scripting kill-signaal om onmiddellijk te stoppen (SIGKILL)

Als uw script tijdens de respijtperiode niet wordt afgesloten, zal Scripting SIGKILL verzenden. U kunt SIGKILL niet vangen. Sluit onmiddellijk af bij SIGINT/SIGTERM zodat uw eindelijk blok kan draaien voordat er een kill plaatsvindt.

De schermafbeeldingen in de eerdere secties laten zien hoe de logs eruit zouden zien als gevolg van het kill-signaal.

Volledig voorbeeld (klaar om te kopiëren-plakken)

Deze sjabloon registreert minimale handlers en centraliseert het opruimen in tenslotte. Plak in Workiva Scripting en vervang het gemarkeerde gebied met uw logica.

Waar voegt u uw code toe: Vervang de voorbeeldlus onder # ===== UW CODE START HIER ===== door uw eigenlijke taken. Vermijd erg lange ononderbroken aanroepen, zodat het script het blok final kan raken voordat het platform escaleert naar SIGKILL.

"""Workiva Scripting sjabloon: minimale handlers + opruimen in finally - Piepkleine handlers verhogen SystemExit(0) op SIGINT/SIGTERM - Een enkel finally blok wordt uitgevoerd voor opruimen, ongeacht hoe het script stopt - Houdt code klein en voorspelbaar """ import signal import time # --- Signaalhandlers (klein houden) --- def _graceful_exit(signum, frame): print("SIGINT ontvangen: annulering aangevraagd. Opruimen...") raise SystemExit(0) def _graceful_term(signum, frame): print("SIGTERM ontvangen: platform verzocht beëindiging. Finishing up...") raise SystemExit(0) # --- Registreer handlers VOORDAT u zwaar werk doet --- signal.signal(signal.SIGINT, _graceful_exit) signal.signal(signal.SIGTERM, _graceful_term) # --- Het hoofdwerk van uw script --- def main(): print("Start work...") # ===== UW CODE START HIER ===== # Voorbeeld van een langlopende lus. Vervang dit door uw echte logica. for i in range(1, 1_000_000): # Simuleer een werkeenheid (vervang door echte logica) print(f"Werken aan item {i}...") time.sleep(1) # ===== UW CODE EINDIGT HIER ===== if __name__ == "__main__": try: main() finally: # Gecentraliseerde opschoning die altijd wordt uitgevoerd (ook op SIGINT/SIGTERM) print("Laatste opschoning voor afsluiten")