Workiva-ondersteuningscentrum

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

Beëindiging wanneer een run succesvol is afgerond

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

Opmerking: Als een script zeer snel wordt uitgevoerd (bijvoorbeeld in minder dan één seconde), vindt er mogelijk geen resource sampling plaats. In die gevallen worden er geen gegevens over het resourcegebruik in het logboek weergegeven.

Het script draait te snel om een ​​sample te nemen.

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

Het script sluit normaal af.

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

Beëindiging van de activiteiten wanneer de limieten worden overschreden

Als een script de geconfigureerde limieten overschrijdt (bijvoorbeeld geheugen, schijfgebruik of toegewezen tijd), zal Scripting het volgende doen:

1. Probeer het script veilig te stoppen: wanneer de limieten worden overschreden, stuurt de scriptomgeving eerst een beëindigingssignaal (SIGTERM) om het script de tijd te geven zichzelf op te ruimen en binnen 15 seconden af ​​te sluiten.
2. Als het script niet binnen 15 seconden stopt, stuurt de scriptomgeving een SIGKILL-signaal, waardoor het proces onmiddellijk wordt gestopt zonder dat er opruimwerkzaamheden kunnen worden uitgevoerd. Dit is een geforceerde beëindiging en de uitvoering zal eindigen met een mislukte status (weergegeven in rood in het logboek). Deze status geeft aan dat het script een geconfigureerde resourcelimiet heeft overschreden en daarom geforceerd is beëindigd.
3. Noteer de reden voor het stoppen; het logboek laat zien welke limiet is bereikt en geeft een overzicht van het resourcegebruik van het script.

De volgende paragrafen geven voorbeelden van wat er gebeurt wanneer een script de limieten overschrijdt zonder code om deze signalen af ​​te handelen. Om te leren hoe u uw scripts kunt aanpassen zodat ze correct reageren op deze signalen, raadpleegt u Systeemsignalen afhandelen in scripts .

Geheugenlimiet overschreden

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

Limiet voor schijfgebruik overschreden

Wanneer een script de geconfigureerde limiet voor schijfgebruik overschrijdt, bevat het logboek de reden voor de 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 de beëindiging en de totale geregistreerde uitvoeringsduur.

Beëindiging wanneer de gebruiker een sessie annuleert

Als een gebruiker een uitvoering handmatig annuleert, stuurt de scriptomgeving eerst een onderbrekingssignaal (SIGINT) om het script te laten weten dat het moet stoppen. Het script heeft 15 seconden de tijd 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 reeks als hierboven beschreven plaats: er wordt een beëindigingssignaal (SIGTERM) verzonden om het script nog eens 15 seconden de tijd te geven om de opruimwerkzaamheden te voltooien, gevolgd door een definitief afsluitsignaal (SIGKILL) als het script dan nog niet is afgesloten.

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

Om te leren hoe u uw scripts kunt aanpassen zodat ze correct reageren op deze signalen, raadpleegt u Systeemsignalen afhandelen in scripts .

Ongeplande beëindigingen

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

Het verwerken van systeemsignalen in scripts

Dankzij signaalverwerking sluit je script netjes af wanneer het door het systeem wordt geannuleerd of gestopt. Door systeemsignalen op te vangen en erop te reageren, kan uw script resources vrijgeven, werk opslaan en netjes afsluiten (bijvoorbeeld wanneer de status "voltooid" wordt gemeld) in plaats van geforceerd te worden beëindigd.

Wanneer een script wordt gestopt omdat een gebruiker het annuleert of omdat het de platformlimieten overschrijdt, geeft Scripting signalen af ​​voor onderbreking, beëindiging en afbreking.Raadpleeg de voorgaande paragrafen voor meer informatie over hoe onderbrekings-, beëindigings- en kill-signalen worden geactiveerd.

Scriptingsignalen en hoe je ze kunt verwerken.

In dit gedeelte vindt u codeblokken en een compleet voorbeeld waarmee u deze signalen kunt verwerken.

Je kunt je signaalhandlers klein houden en de opruimacties op één plek afhandelen met behulp van een try/finally blok dat altijd wordt uitgevoerd bij het afsluiten. Hierdoor blijven scripts voorspelbaar en gemakkelijk te onderhouden.

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

• Bovenaan bestand: importeer modules en definieer de handler
• Vroege initialisatie: registreer de handler voordat er werk wordt verricht
• Rondom je werk: Wikkel de hoofdcode in een try/finally blok zodat de opschoonfunctie altijd wordt uitgevoerd

De gebruiker annuleert de uitvoering (SIGINT)

Dit gebeurt wanneer een gebruiker op Annuleren klikt om de scriptuitvoering te annuleren.

# --- Bovenaan bestand --- import signal, sys # Kleine handler: verzoek om onmiddellijke, nette afsluiting def _graceful_exit(signum, frame): print("SIGINT ontvangen: annulering aangevraagd. Opruimen…") raise SystemExit(0) # --- Vroege initialisatie --- signal.signal(signal.SIGINT, _graceful_exit)

In de buurt van je werk (verderop in het bestand):

try: # hier je langlopende werk ... finally: # centrale plek voor het sluiten van bestanden, het leegmaken van logbestanden, enz. print("Laatste opruiming voor het afsluiten")

De afbeelding hieronder laat zien hoe de scriptlogboeken eruitzien wanneer het interruptsignaal (SIGINT) wordt verwerkt.

Het rechtstreeks afhandelen van KeyboardInterrupt

Workiva Scripting genereert ook een KeyboardInterrupt wanneer SIGINT wordt afgeleverd aan de hoofdthread. Je kunt deze uitzondering opvangen in je try blok en hetzelfde opschoonpad aanroepen dat is gedefinieerd door _graceful_exit() .

try: # je langlopende werk hier ... except KeyboardInterrupt: print("KeyboardInterrupt ontvangen: opruimen voor afsluiting…") _graceful_exit(None, None) finally: # centrale plek voor het sluiten van bestanden, het leegmaken van logbestanden, enz. print("Laatste opruiming voor afsluiting")

De afbeelding hieronder laat zien hoe de scriptlogboeken eruitzien wanneer het interruptsignaal via een toetsenbordinterrupt wordt verwerkt.

Scriptbeëindigingssignaal om na een respijtperiode te stoppen (SIGTERM)

Scripting geeft je script de opdracht om te stoppen (bijvoorbeeld nadat de limieten zijn overschreden). Je script heeft een korte respijtperiode voordat het kan worden afgesloten.

# --- Bovenaan bestand --- import signal def _graceful_term(signum, frame): print("SIGTERM ontvangen: platform heeft beëindiging aangevraagd. Afronding…") raise SystemExit(0) # --- Vroege initialisatie --- signal.signal(signal.SIGTERM, _graceful_term)

De afbeelding hieronder laat zien hoe de scriptlogboeken eruitzien wanneer het beëindigingssignaal (SIGTERM) wordt verwerkt.

Scripting kill-signaal om onmiddellijk te stoppen (SIGKILL)

Als je script niet binnen de respijtperiode wordt afgesloten, stuurt Scripting een SIGKILL-signaal.Je kunt SIGKILL niet vangen. Sluit het systeem onmiddellijk af bij SIGINT/SIGTERM, zodat uw finally blok kan worden uitgevoerd voordat een kill plaatsvindt.

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

Compleet voorbeeld (klaar om te kopiëren en plakken)

Deze template registreert minimale handlers en centraliseert de opruiming in finally . Plak de code in Workiva Scripting en vervang het gemarkeerde gedeelte door je eigen logica.

Waar u uw code kunt toevoegen: Vervang de voorbeeldloop onder # ===== UW CODE BEGINT HIER ===== door uw daadwerkelijke taken. Vermijd zeer lange, ononderbreekbare aanroepen, zodat het script het finally blok kan bereiken voordat het platform overgaat tot SIGKILL.

"""Workiva Scripting template: minimale handlers + opruiming in finally - Kleine handlers roepen SystemExit(0) aan bij SIGINT/SIGTERM - Eén finally-blok wordt uitgevoerd voor opruiming, ongeacht hoe het script stopt - Houdt de code klein en voorspelbaar """ import signal import time # --- Signaalhandlers (houd klein) --- def _graceful_exit(signum, frame): print("SIGINT ontvangen: annulering aangevraagd. Opruimen…") raise SystemExit(0) def _graceful_term(signum, frame): print("SIGTERM ontvangen: platform heeft beëindiging aangevraagd. Afronding…") raise SystemExit(0) # --- Registreer handlers VOORDAT je zwaar werk gaat doen --- signal.signal(signal.SIGINT, _graceful_exit) signal.signal(signal.SIGTERM, _graceful_term) # --- Het belangrijkste werk van je script --- def main(): print("Begint met werken…") # ===== JE CODE BEGINT HIER ===== # Voorbeeld van een langlopende lus. Vervang dit door je eigen logica. for i in range(1, 1_000_000): # Simuleer een eenheid van werk (vervang door echte logica) print(f"Bezig met item {i}…") time.sleep(1) # ===== JE CODE EINDIGT HIER ===== if __name__ == "__main__": try: main() finally: # Gecentraliseerde opschoning die altijd wordt uitgevoerd (ook bij SIGINT/SIGTERM) print("Laatste opschoning voor afsluiting")