Workiva kundestøttesenter

Ved å håndheve ressursgrenser automatisk og levere detaljerte logger (som vist i skjermbildene nedenfor), sikrer Workiva Scripting både plattformens pålitelighet og åpenhet for utviklere som bygger og optimaliserer automatiseringsskript.

Avslutning når en kjøring er fullført

Når et skript fullføres normalt uten å overskride grensene, inneholder loggen et sammendrag av ressursbruken på som viser gjennomsnittlig og maksimal bruk av minne, CPU, disk og kjøretid. Denne informasjonen gir innsyn i ytelsesegenskapene for vellykkede kjøringer.

Merk: Hvis et skript kjøres svært raskt (for eksempel mindre enn 1 sekund), kan det hende at det ikke blir tatt noen ressurssampling. I slike tilfeller vil ingen data om ressursbruk bli rapportert i loggen.

Skriptet kjører for fort til å sample

Hvis et skript avsluttes for raskt, kan ikke monitoren fange opp bruksdata.

Skriptet har en normal utgang

Hvis et skript fullføres uten å overskride noen grenser, vises ressursbruksstatistikken i sin helhet i loggen.

Oppsigelse når grensene overskrides

Hvis en skriptkjøring overskrider de konfigurerte grensene (for eksempel minne, diskbruk eller tildelt tid), vil Scripting:

1. Forsøk på å stoppe skriptet på en sikker måte - Når grensene overskrides, sender Scripting først et avslutningssignal (SIGTERM) for å la skriptet rydde opp og avslutte innen 15 sekunder.
2. Hvis skriptet ikke avsluttes innen 15 sekunder, sender Scripting et SIGKILL-signal, som umiddelbart stopper prosessen uten å tillate noen opprydding. Dette er en kraftig avslutning, og kjøringen fullføres med statusen mislykket (vises i rødt i loggen). Denne statusen indikerer en feil i Scripting System.
3. Noter årsaken til at skriptet ble stoppet - loggen viser hvilken grense som ble nådd, og oppsummerer skriptets ressursbruk.

De neste avsnittene gir eksempler på hva som skjer når et skript overskrider grensene uten kode for å håndtere disse signalene. Hvis du vil vite hvordan du endrer skriptene dine slik at de reagerer på disse signalene på en elegant måte, kan du se Håndtering av systemsignaler i skript.

Minnegrensen er overskredet

Når et skript overskrider den konfigurerte minnegrensen, inneholder loggen årsaken til at skriptet avsluttes og detaljer om den overskredne terskelen.

Grensen for diskbruk overskredet

Når et skript overskrider den konfigurerte grensen for diskbruk, inneholder loggen årsaken til at skriptet avsluttes, og informasjon om diskbruken på det tidspunktet grensen ble nådd.

Tildelt tid overskredet

Når et skript overskrider den tildelte tiden som er konfigurert, inneholder loggen årsaken til avslutningen og den totale kjøretiden som er registrert.

Avslutning når brukeren avbryter en kjøring

Hvis en bruker avbryter en kjøring manuelt, sender Scripting først et avbruddssignal (SIGINT) for å gi skriptet beskjed om at det skal stoppe. Skriptet har 15 sekunder på seg til å rydde opp, lagre fremdrift eller rulle tilbake før det avsluttes. Etter denne 15-sekunders fristen skjer det samme som beskrevet ovenfor: Et avslutningssignal (SIGTERM) sendes for å gi skriptet ytterligere 15 sekunder til å fullføre oppryddingen, etterfulgt av et avsluttende kill-signal (SIGKILL) hvis skriptet fortsatt ikke er avsluttet.

Bildet nedenfor viser hvordan skriptloggene ser ut når skriptet ikke inneholder kode for å håndtere avbruddssignalet.

Hvis du vil vite hvordan du endrer skriptene dine slik at de reagerer på disse signalene på en elegant måte, kan du se Håndtering av systemsignaler i skript.

Ikke-planlagte oppsigelser

I sjeldne tilfeller, for eksempel når et skript bruker opp minnet raskere enn skriptsystemet kan overvåke forbruket, kan det hende at systemet avslutter skriptet før det oppdager at en grense er overskredet. Når dette skjer, logger Scripting en ufullstendig bruksrapport, som bare viser datapunktene som ble samlet inn før avslutningen.

Håndtering av systemsignaler i skript

Signalhåndtering gjør at skriptet avsluttes på en ryddig måte når det avbrytes eller stoppes av systemet. Ved å fange opp og reagere på systemsignaler kan skriptet frigjøre ressurser, lagre arbeid og avslutte på en elegant måte (for eksempel når statusen rapporteres som "fullført") i stedet for å bli tvunget til å avslutte.

Når et skript stoppes fordi en bruker avbryter det eller fordi det overskrider plattformgrensene, leverer Scripting avbrytelses-, avslutnings- og kill-signaler. Se de tidligere avsnittene for å lære mer om hvordan avbrytelses-, terminerings- og kill-signaler utløses.

Skriptsignaler og hvordan du håndterer dem

Dette avsnittet inneholder kodeblokker og et komplett eksempel som du kan bruke til å håndtere disse signalene.

Du kan holde signalbehandlerne små og håndtere opprydding på ett sted ved hjelp av en try/finally -blokk som alltid kjøres ved avslutning. Dette gjør skriptene forutsigbare og enkle å vedlikeholde.

Den overordnede strukturen for håndtering av signaler i skriptet ditt er den samme uansett hvilket signal som mottas:

• Øverst i filen: importmoduler og definisjon av handleren
• Tidlig initialisering: registrer handleren før du utfører noe arbeid
• Rundt arbeidet ditt: pakk hovedkoden inn i en try/finally blokk slik at opprydningen alltid kjører

Brukeren avbryter kjøringen (SIGINT)

Dette skjer når en bruker klikker på Cancel for å avbryte skriptkjøringen.

# --- Øverst i filen --- import signal, sys # Tiny handler: be om umiddelbar, grasiøs avslutning def _graceful_exit(signum, frame): print("SIGINT received: cancellation requested. Rydder opp...") raise SystemExit(0) # --- Tidlig initialisering --- signal.signal(signal.SIGINT, _graceful_exit)

Rundt arbeidet ditt (senere i filen):

prøv: # ditt langvarige arbeid her ... finally: # sentralt sted for å lukke filer, tømme logger osv. print("Siste opprydding før avslutning")

Bildet nedenfor viser hvordan skriptloggene ser ut når avbruddssignalet (SIGINT) håndteres.

Håndtering KeyboardInterrupt direkte

Workiva Scripting utløser også KeyboardInterrupt når SIGINT leveres til hovedtråden. Du kan fange opp dette unntaket i try -blokken og kalle den samme oppryddingsbanen som er definert av _graceful_exit().

try: # ditt langvarige arbeid her ... except KeyboardInterrupt: print("KeyboardInterrupt received: cleaning up before exit...") _graceful_exit(None, None) finally: # sentralt sted for å lukke filer, tømme logger osv. print("Siste opprydding før avslutning")

Bildet nedenfor viser hvordan skriptloggene ser ut når avbruddssignalet håndteres via tastaturavbrudd.

Skriptavslutningssignal for å stoppe etter en grace-periode (SIGTERM)

Skripting ber skriptet ditt om å stoppe (f.eks. etter at grensene er overskredet). Skriptet ditt har en kort frist til å avslutte.

# --- Øverst i filen --- def _graceful_term(signum, frame): print("SIGTERM received: platform requested termination. Finishing up...") raise SystemExit(0) # --- Tidlig initialisering --- signal.signal(signal.SIGTERM, _graceful_term)

Bildet nedenfor viser hvordan skriptloggene ser ut når avslutningssignalet (SIGTERM) håndteres.

Skripting av kill-signal for å stoppe umiddelbart (SIGKILL)

Hvis skriptet ikke avsluttes i løpet av denne perioden, vil Scripting sende SIGKILL. Du kan ikke fange SIGKILL. Avslutt umiddelbart ved SIGINT/SIGTERM, slik at til slutt blokken kan kjøres før en kill oppstår.

Skjermbildene i de tidligere avsnittene viser hvordan loggene vil se ut som et resultat av drapssignalet.

Fullstendig eksempel (klar til copy-paste)

Denne malen registrerer minimale håndterere og sentraliserer opprydding i finally. Lim inn i Workiva Scripting, og erstatt det markerte området med logikken din.

Hvor du skal legge til koden din: Erstatt eksempelløkken under # ===== DIN KODE STARTER HER ===== med dine faktiske oppgaver. Unngå svært lange uavbrutte anrop, slik at skriptet kan treffe finally -blokken før plattformen eskalerer til SIGKILL.

"""Workiva Scripting template: minimal handlers + cleanup in finally - Tiny handlers raise SystemExit(0) on SIGINT/SIGTERM - Single finally block runs for cleanup regardless of how the script stops - Keeps code small and predictable """ import signal import time # --- Signal handlers (keep tiny) --- def _graceful_exit(signum, frame): print("SIGINT received: cancellation requested. Cleaning up...") raise SystemExit(0) def _graceful_term(signum, frame): print("SIGTERM received: platform requested termination. Finishing up...") raise SystemExit(0) # --- Registrer handlere FØR du gjør noe tungt arbeid --- signal.signal(signal.SIGINT, _graceful_exit) signal.signal(signal.SIGTERM, _graceful_term) # --- Skriptets hovedarbeid --- def main(): print("Starting work...") # ===== DIN KODE STARTER HER ===== # Eksempel på en løkke med lang varighet. Erstatt med din faktiske logikk. for i in range(1, 1_000_000): # Simuler en arbeidsenhet (erstatt med ekte logikk) print(f"Arbeider på element {i}...") time.sleep(1) # ===== DIN KODE SLUTTER HER ===== if __name__ == "__main__": try: main() finally: # Sentralisert opprydding som alltid kjøres (inkludert ved SIGINT/SIGTERM) print("Siste opprydding før exit")