Download automatici

1. Verifica l'installazione della CLI di Deadline

   Ottieni il percorso esatto del file eseguibile con scadenza:

   $ which deadline

   Nota questo percorso (ad esempio/opt/homebrew/bin/deadline) per utilizzarlo nel file plist.

2. Crea una cartella Checkpoint

   Crea la directory in cui verranno archiviati i file dei checkpoint. Garantisci all'utente le autorizzazioni appropriate per eseguire il comando.

   $ mkdir -p /path/to/checkpoint/directory

3. Crea una directory di log

   Crea una directory per i log di cron job:

   $ mkdir -p /path/to/logs

   Valuta di impostare la rotazione dei log sul file di registro usando blog/setting-logrotate https://www.redhat.com/en/

4. Controlla il Crontab corrente

   Visualizza il tuo crontab attuale per vedere i lavori esistenti:

   $ crontab -l

5. Modifica Crontab

   Apri il tuo file crontab per modificarlo:

   $ crontab -e

   Se è la prima volta, potrebbe esserti richiesto di scegliere un editor (nano, vim, ecc.).

6. Aggiungi Cron Job Entry

   Aggiungi la seguente riga per eseguire il lavoro ogni 5 minuti (sostituisci i percorsi con i valori effettivi dei passaggi 1 e 2):

   */5 * * * * AWS_PROFILE=deadline-downloader /path/to/deadline queue sync-output --farm-id YOUR_FARM_ID --queue-id YOUR_QUEUE_ID --storage-profile-id YOUR_PROFILE_ID --checkpoint-dir /path/to/checkpoint/directory >> /path/to/logs/deadline_sync.log 2>&1

7. Verifica l'installazione di Cron Job

   Dopo aver salvato e chiuso l'editor, verifica che il cron job sia stato aggiunto:

   $ crontab -l

   Dovresti vedere il tuo nuovo lavoro nell'elenco.

8. Controlla lo stato del servizio Cron

   Assicurati che il servizio cron sia in esecuzione:

   # For systemd systems (most modern Linux distributions)
   $ sudo systemctl status cron
   # or
   $ sudo systemctl status crond
   
   # For older systems
   $ sudo service cron status

   Se non è in esecuzione, avvialo:

   $ sudo systemctl start cron
   $ sudo systemctl enable cron  # Enable auto-start on boot

1. Verifica l'installazione della CLI di Deadline

   Ottieni il percorso esatto del file eseguibile con scadenza:

   $ which deadline

   Nota questo percorso (ad esempio/opt/homebrew/bin/deadline) per utilizzarlo nel file plist.

2. Crea Checkpoint Directory e Log Directory

   Crea la directory in cui verranno archiviati i file di checkpoint:

   $ mkdir -p /path/to/checkpoint/directory
   $ mkdir -p /path/to/logs

   Valuta la possibilità di impostare la rotazione del registro sul file di registro utilizzando https://formulae.brew. sh/formula/logrotate

3. Crea un file Plist

   Crea un file di configurazione ~/Library/LaunchAgents/com.user.deadlinesync.plist con il seguente contenuto (sostituiscilo /path/to/deadline con il percorso effettivo del passaggio 1):

   <?xml version="1.0" encoding="UTF-8"?>
   <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
   <plist version="1.0">
   <dict>
       <key>Label</key>
       <string>com.user.deadlinesync</string>
       <key>ProgramArguments</key>
       <array>
           <string>/path/to/deadline</string>
           <string>queue</string>
           <string>sync-output</string>
           <string>--farm-id</string>
           <string>YOUR_FARM_ID</string>
           <string>--queue-id</string>
           <string>YOUR_QUEUE_ID</string>
           <string>--storage-profile-id</string>
           <string>YOUR STORAGE PROFILE ID</string>
           <string>--checkpoint-dir</string>
           <string>/path/to/checkpoint/dir</string>
       </array>
       <key>EnvironmentVariables</key>
       <dict>
       <key>AWS_PROFILE</key>
       <string>deadline-downloader</string>
       </dict>
       <key>RunAtLoad</key>
       <true/>
       <key>UserName</key>
       <string>YOUR_USER_NAME</string>
       <key>StandardOutPath</key>
       <string>/path/to/logs/deadline_sync.log</string>
       <key>StartInterval</key>
       <integer>300</integer>
   </dict>
   </plist>

   Sostituisci --storage-profile-id YOUR_PROFILE_ID quanto sopra con --ignore-storage-profiles se il computer di download è lo stesso del computer di invio.

4. Convalida il file Plist

   Convalida la sintassi XML del tuo file plist:

   $ plutil -lint ~/Library/LaunchAgents/com.user.deadlinesync.plist

   Questo dovrebbe restituire «OK» se il file è valido.

5. Verifica la presenza di agenti di lancio o daemon di lancio esistenti

   Controlla se un agente di lancio è già caricato:

   $ launchctl list | grep deadlinesync
   OR
   $ sudo launchctl list | grep deadlinesync

   Se ne esiste uno, scaricalo prima:

   $ launchctl bootout gui/$(id -u)/com.user.deadlinesync
   OR
   $ sudo launchctl bootout system/com.user.deadlinesync

6. Crea e avvia

   Per eseguire questa attività mentre l'utente è connesso, eseguila come. LaunchAgent Per eseguire questa attività senza che un utente effettui l'accesso ogni volta che il computer è in esecuzione, eseguila come. LaunchDaemon

   1. Per eseguire comeLaunchAgent:

      1. Usa la configurazione creata in ~/Library/LaunchAgents/com.user.deadlinesync.plist

      2. Quindi carica la configurazione usando il comando bootstrap:

         $ launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.user.deadlinesync.plist

   2. Per eseguire come LaunchDaemon:

      1. Sposta il file Pilst e modifica le autorizzazioni eseguendo quanto segue:

         $ sudo mv ~/Library/LaunchAgents/com.user.deadlinesync.plist /Library/LaunchDaemons/ 
         $ sudo chown root:wheel /Library/LaunchDaemons/com.user.deadlinesync.plist 
         $ sudo chmod 644 /Library/LaunchDaemons/com.user.deadlinesync.plist
         

      2. Carica l'agente di avvio utilizzando il moderno comando bootstrap:

         $ sudo launchctl bootstrap system /Library/LaunchDaemons/com.user.deadlinesync.plist

7. Verifica lo stato

   Se hai avviato un' LaunchAgent esecuzione, esegui quanto segue per confermare che è stata caricata:

   $ launchctl list | grep deadlinesync

   Se hai avviato una LaunchDaemon, conferma che sia stata caricata eseguendo:

   $ sudo launchctl list | grep deadlinesync

   L'output dovrebbe avere il seguente aspetto

   SOME_PID_NUMBER 0 com.user.deadlinesync

   Per informazioni dettagliate sullo stato:

   $ launchctl print gui/$(id -u)/com.user.deadlinesync

   Questo mostra lo stato corrente, gli argomenti del programma, le variabili di ambiente, l'intervallo di esecuzione e la cronologia di esecuzione.

1. Verifica l'installazione della CLI di Deadline

   Trova l'eseguibile della scadenza:

   C:\> where deadline

   Annota il percorso completo (ad esempioC:\Program Files\Amazon\DeadlineCloud\deadline.exe) da utilizzare nell'attività.

2. Crea una cartella Checkpoint

   Crea la directory in cui verranno archiviati i file di checkpoint:

   C:\> mkdir "path\to\checkpoint\directory"

3. Crea una directory di registro

   Crea una directory per i registri delle attività:

   C:\> mkdir "path\to\logs"

4. Crea un wrapper di file Batch

   Crea il file batch con il seguente contenuto:

   C:\> notepad C:\path\to\deadline_sync.bat

   YOUR_PATH_TO_DEADLINE.EXE queue sync-output --farm-id YOUR_FARM_ID --queue-id YOUR_QUEUE_ID --storage-profile-id YOUR_PROFILE_ID --checkpoint-dir path\to\checkpoint\checkpoints > path\to\logs\deadline.log 2>&1

5. File Batch di test

   Esegui il test manuale del file batch:

   C:\> .\path\to\deadline_sync.bat

   Verifica che il file di registro sia stato creato:

   C:\> notepad path\to\logs\deadline_sync.log

6. Controlla il servizio Task Scheduler

   Assicurati che il servizio Task Scheduler sia in esecuzione:

   C:\> sc query "Schedule"

   Se il servizio non esiste, prova con nomi alternativi:

   C:\> sc query "TaskScheduler"
   C:\> sc query "Task Scheduler"

   Se non è in esecuzione, avvialo:

   C:\> sc start "Schedule"

7. Crea attività pianificata

   Crea l'attività da eseguire ogni 5 minuti.

   C:\> schtasks /create /tn "DeadlineOutputSync" /tr "C:\path\to\deadline_sync.bat" /sc minute /mo 5

   Suddivisione dei comandi:

   • /tn- Nome dell'attività

   • /tr- Attività da eseguire (il tuo file batch)

   • /sc minute /mo 5- Pianificazione: ogni 5 minuti

8. Verifica la creazione dell'attività

   Verifica che l'attività sia stata creata correttamente:

   schtasks /query /tn "DeadlineOutputSync" /v /fo LIST

   Cerca:

   • Attività da eseguire: dovrebbe mostrare il percorso del file batch

   • Durata di esecuzione successiva: dovrebbe mostrare un orario entro 5 minuti

9. Esecuzione dell'attività di test

   Esegui l'attività manualmente per testare:

   schtasks /run /tn "DeadlineOutputSync"

   Controlla lo stato dell'attività:

   schtasks /query /tn "DeadlineOutputSync"

1. Controlla se il servizio cron è in esecuzione:

   
   # For systemd systems
   $ sudo systemctl status cron
   # or
   $ sudo systemctl status crond
   
   # Check if your user has cron job correctly configured
   $ crontab -l
          

2. Visualizza i log di esecuzione di cron:

   
   # Check system logs for cron activity (most common locations)
   $ sudo tail -f /var/log/syslog | grep CRON
   $ sudo tail -f /var/log/cron.log | grep deadline
   
   # View recent cron logs
   $ sudo journalctl -u cron -f
   $ sudo journalctl -u crond -f  # On some systems
          

3. Controlla i tuoi registri di cron job specifici:

   
   # View the log file specified in your cron job
   $ tail -100f /path/to/logs/deadline_sync.log
          

4. Cerca l'esecuzione di cron job nei log di sistema:

   
   # Look for your specific cron job executions
   $ sudo grep "deadline.*incremental-output-download" /var/log/syslog
   
   # Check for cron job starts and completions
   $ sudo grep "$(whoami).*CMD.*deadline" /var/log/syslog
          

5. Controlla gli aggiornamenti dei file di checkpoint:

   
   # List checkpoint files with timestamps
   $ ls -la /path/to/checkpoint/directory/
   
   # Check when checkpoint was last modified
   $ stat /path/to/checkpoint/directory/queue-*_download_checkpoint.json
          

6. Controlla il file di registro:

   
   $ ls -la /path/to/log/deadline_sync.log
          

Visualizzazione dei log di esecuzione di Launch Agent:

1. Controlla se il Launch Agent è in esecuzione:

   
   $ sudo launchctl list | grep deadlinesync
          

   L'output mostra: PID Status Label (il PID sarà attivo - quando non è attualmente in esecuzione, il che è normale per i lavori a intervalli)

2. Visualizza lo stato dettagliato dell'agente di lancio:

   
   $ sudo launchctl print system/com.user.deadlinesync
          

   Questo mostra la cronologia delle esecuzioni, il codice dell'ultima uscita, il numero di esecuzioni e lo stato corrente.

3. Visualizza i registri di esecuzione dell'agente di avvio:

   
   # View recent logs (last hour)
   log show --predicate 'subsystem contains "com.user.deadlinesync"' --last 1h
   
   # View logs from a specific time period
   log show --predicate 'subsystem contains "com.user.deadlinesync"' --start '2024-08-27 09:00:00'
          

4. Forza l'esecuzione dell'agente di lancio per un test immediato:

   
   $ sudo launchctl kickstart gui/$(id -u)/com.user.deadlinesync
          

   Ciò attiva immediatamente il lavoro indipendentemente dalla pianificazione, utile per i test.

5. Controlla gli aggiornamenti dei file di checkpoint:

   
   # List checkpoint files with timestamps
   $ ls -la /path/to/checkpoint/directory/
          

6. Controlla il file di registro:

   
   $ ls -la /path/to/log/deadline_sync.log
          

1. Controlla se il servizio Task Scheduler è in esecuzione:

   C:\> sc query "Schedule"

   Se il servizio non esiste, prova con nomi alternativi:

   C:\> sc query "TaskScheduler"
   C:\> sc query "Task Scheduler"

2. Visualizza le attività pianificate:

   
   C:> schtasks /query /tn "DeadlineOutputSync"
          

3. Controlla il file di registro della tua attività:

   
   # View the log file created by your batch script
   C:> notepad C:\path\to\logs\deadline_sync.log
          

4. Controlla gli aggiornamenti dei file di checkpoint:

   
   # List checkpoint files with timestamps
   C:> dir "C:\path\to\checkpoint\directory" /od