Workiva kundestøttesenter

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

Avslutning når en kjøring fullføres

Når et skript fullføres normalt uten å overskride grenser, inneholder loggen et ressursbrukssammendrag som viser gjennomsnittlig og maksimal bruk på tvers av minne, CPU, disk og utførelsestid. Denne informasjonen gir innsikt i ytelsesegenskapene for vellykkede fullførte kjøringer.

Merk: Hvis et skript kjører veldig raskt (for eksempel mindre enn ett sekund), kan det hende at ressurssampling ikke utføres. I slike tilfeller vil ingen ressursbruksdata bli rapportert i loggen.

Skriptet kjører for fort til å sample

Hvis et skript fullføres for raskt, kan ikke skjermen registrere bruksdata.

Skriptet har en normal utgang

Hvis et skript fullføres uten å overskride noen grenser, vises statistikk for ressursbruk fullstendig i loggen.

Oppsigelse når grenser overskrides

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

1. Forsøk å stoppe skriptet på en sikker måte – Når grensene overskrides, sender skriptingen først et avslutningssignal (SIGTERM) for å la skriptet rydde opp og avslutte innen 15 sekunder.
2. Hvis skriptet ikke avsluttes innen 15 sekunder – sender skriptingen et SIGKILL-signal, som umiddelbart stopper prosessen uten å tillate noen opprydding. Dette er en tvungen avslutning, og kjøringen vil fullføres med statusen mislykket (vises i rødt i loggen). Denne statusen indikerer at skriptet overskred en konfigurert ressursgrense og ble tvangsavsluttet.
3. Registrer årsaken til stoppingen – loggen vil vise hvilken grense som ble nådd og oppsummere skriptets ressursbruk.

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

Minnegrensen er overskredet

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

Diskbruksgrensen er overskredet

Når et skript overskrider den konfigurerte grensen for diskbruk, inneholder loggen årsaken til avslutningen og detaljer om diskbruken da grensen ble nådd.

Tildelt tid overskredet

Når et skript overskrider den konfigurerte tildelte tiden, inneholder loggen årsaken til avslutningen og den totale registrerte kjøretiden.

Avslutning når brukeren avbryter en kjøring

Hvis en bruker avbryter en kjøring manuelt, sender skripting 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 slås av. Etter denne 15 sekunders respitperioden skjer den samme sekvensen som beskrevet ovenfor: et avslutningssignal (SIGTERM) sendes for å gi skriptet ytterligere 15 sekunder til å fullføre oppryddingen, etterfulgt av et endelig avslutningssignal (SIGKILL) hvis skriptet fortsatt ikke har avsluttet.

Bildet nedenfor viser hvordan skriptloggene ser ut når et skript ikke inkluderer kode for å håndtere avbruddssignalet.

Hvis du vil vite hvordan du endrer skriptene dine slik at de reagerer grasiøst på disse signalene, kan du se Håndtering av systemsignaler i skript .

Uplanlagte oppsigelser

I sjeldne tilfeller, for eksempel når et skript bruker minne raskere enn skriptsystemet kan overvåke forbruket, kan systemet avslutte et skript før det oppdager at en grense er overskredet. Når dette skjer, logger skripting en ufullstendig bruksrapport, som bare viser datapunktene som er samlet inn før avslutning.

Håndtering av systemsignaler i skript

Signalhåndtering lar skriptet ditt lukkes rent når det avbrytes eller stoppes av systemet. Ved å fange opp og svare på systemsignaler kan skriptet frigjøre ressurser, lagre arbeid og avsluttes uten problemer (for eksempel når statusen rapporteres som «fullført») i stedet for å bli tvunget til å avsluttes.

Når et skript stoppes fordi en bruker avbryter det eller det overskrider plattformgrensene, leverer skripting avbrudds-, avslutnings- og avslutningssignaler.Se de tidligere avsnittene for å lære mer om hvordan avbrudds-, avslutnings- og drepesignaler utløses.

Skripting av signaler og hvordan man håndterer dem

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

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

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

• Toppen av filen: importer moduler og definer behandleren
• Tidlig initialisering: registrer behandleren før du utfører noe arbeid
• Rundt arbeidet ditt: pakk hovedkoden inn i en try/finally -blokk slik at oppryddingen alltid kjører

Brukeren avbryter kjøringen (SIGINT)

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

# --- Toppen av filen --- importsignal, sys # Liten behandler: forespørsel om umiddelbar, elegant avslutning def _graceful_exit(signum, frame): print("SIGINT mottatt: avbrytelse forespurt. Rydder opp…") hev SystemExit(0) # --- Tidlig initialisering --- signal.signal(signal.SIGINT, _graceful_exit)

Rundt arbeidet ditt (senere i filen):

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

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

Håndtering av KeyboardInterrupt direkte

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

try: # ditt langvarige arbeid her ... unntatt KeyboardInterrupt: print("KeyboardInterrupt mottatt: opprydding før avslutning…") _graceful_exit(None, None) finally: # sentralt sted for å lukke filer, tømme logger osv. print("Sluttopprydding før avslutning")

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

Skripting av avslutningssignal for å stoppe etter en respitperiode (SIGTERM)

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

# --- Toppen av filen --- importsignal def _graceful_term(signum, frame): print("SIGTERM mottatt: plattformen ba om avslutning. Ferdiggjør…") raise SystemExit(0) # --- Tidlig initialisering --- signal.signal(signal.SIGTERM, _graceful_term)

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

Skripter kill-signal for å stoppe umiddelbart (SIGKILL)

Hvis skriptet ditt ikke avsluttes i løpet av respitperioden, vil skriptingen sende SIGKILL.Du kan ikke fange SIGKILL. Avslutt raskt på SIGINT/SIGTERM slik at finally -blokken din kan kjøre før en kill skjer.

Skjermbildene i de tidligere avsnittene viser hvordan loggene ville se ut som et resultat av drepesignalet.

Komplett eksempel (klar til kopiering og liming)

Denne malen registrerer minimale behandlere og sentraliserer oppryddingen 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å veldig lange avbruddsfrie anrop, slik at skriptet kan treffe finally -blokken før plattformen eskalerer til SIGKILL.

"""Workiva Scripting-mal: minimale behandlere + opprydding i finally - Små behandlere øker SystemExit(0) på SIGINT/SIGTERM - Enkelt finally-blokk kjøres for opprydding uavhengig av hvordan skriptet stopper - Holder koden liten og forutsigbar """ import signal import time # --- Signalbehandlere (behold liten) --- def _graceful_exit(signum, frame): print("SIGINT mottatt: avbrytelse forespurt. Rydder opp…") raise SystemExit(0) def _graceful_term(signum, frame): print("SIGTERM mottatt: plattformen ba om avslutning. Ferdiggjør…") raise SystemExit(0) # --- Registrer behandlere FØR du utfører noe tungt arbeid --- signal.signal(signal.SIGINT, _graceful_exit) signal.signal(signal.SIGTERM, _graceful_term) # --- Skriptets hovedarbeid --- def main(): print("Starter arbeidet…") # ===== DIN KODE STARTER HER ===== # Eksempel på langvarig løkke. Erstatt med din faktiske logikk. for i i range(1, 1_000_000): # Simuler en arbeidsenhet (erstatt med ekte logikk) print(f"Jobber med element {i}…") time.sleep(1) # ===== DIN KODE SLUTTER HER ===== if __name__ == "__main__": try: main() finally: # Sentralisert opprydding som alltid kjører (inkludert på SIGINT/SIGTERM) print("Sluttopprydding før avslutning")