Téléchargements automatiques

1. Vérifier l'installation de la CLI par date limite

   Obtenez le chemin exact vers le fichier exécutable de votre date limite :

   $ which deadline

   Notez ce chemin (par exemple,/opt/homebrew/bin/deadline) à utiliser dans le fichier plist.

2. Créer un répertoire de points de contrôle

   Créez le répertoire dans lequel les fichiers de points de contrôle seront stockés. Assurez-vous que votre utilisateur dispose des autorisations appropriées pour exécuter la commande.

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

3. Créer un répertoire de journaux

   Créez un répertoire pour les journaux des tâches cron :

   $ mkdir -p /path/to/logs

   Envisagez de configurer la rotation du journal sur le fichier journal à l'aide de https://www.redhat.com/en/ blog/setting-logrotate

4. Vérifier le Crontab actuel

   Consultez votre crontab actuel pour voir les tâches existantes :

   $ crontab -l

5. Modifier Crontab

   Ouvrez votre fichier crontab pour le modifier :

   $ crontab -e

   Si c'est la première fois, vous serez peut-être invité à choisir un éditeur (nano, vim, etc.).

6. Ajouter une entrée Cron Job

   Ajoutez la ligne suivante pour exécuter le travail toutes les 5 minutes (remplacez les chemins par les valeurs réelles des étapes 1 et 2) :

   */5 * * * * /path/to/deadline queue sync-output --profile deadline-downloader --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. Vérifier l'installation de Cron Job

   Après avoir enregistré et quitté l'éditeur, vérifiez que la tâche cron a été ajoutée :

   $ crontab -l

   Vous devriez voir votre nouvel emploi répertorié.

8. Vérifier l'état du service Cron

   Assurez-vous que le service cron est en cours d'exécution :

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

   S'il n'est pas en cours d'exécution, démarrez-le :

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

1. Vérifier l'installation de la CLI par date limite

   Obtenez le chemin exact vers le fichier exécutable de votre date limite :

   $ which deadline

   Notez ce chemin (par exemple,/opt/homebrew/bin/deadline) à utiliser dans le fichier plist.

2. Créer un répertoire de points de contrôle et un répertoire de journaux

   Créez le répertoire dans lequel les fichiers de points de contrôle seront stockés :

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

   Envisagez de configurer la rotation des journaux dans le fichier journal à l'aide de https://formulae.brew. sh/formula/logrotate

3. Création d'un fichier Plist

   Créez un fichier de configuration ~/Library/LaunchAgents/com.user.deadlinesync.plist avec le contenu suivant (remplacez-le par /path/to/deadline le chemin réel indiqué à l'étape 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>--profile</string>
           <string>deadline-downloader</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>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>

   Remplacez --storage-profile-id YOUR_PROFILE_ID ci-dessus par --ignore-storage-profiles si votre machine de téléchargement est la même que la machine de soumission.

4. Valider le fichier Plist

   Validez la syntaxe XML de votre fichier plist :

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

   Cela devrait renvoyer « OK » si le fichier est valide.

5. Vérifiez les agents de lancement ou les démons de lancement existants

   Vérifiez si un agent de lancement est déjà chargé :

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

   S'il en existe un, déchargez-le d'abord :

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

6. Création et démarrage

   Pour exécuter cette tâche alors que l'utilisateur est connecté, exécutez-la en tant que LaunchAgent. Pour exécuter cette tâche sans qu'un utilisateur ne soit connecté à chaque fois que la machine est en cours d'exécution, exécutez-la en tant que LaunchDaemon.

   1. Pour exécuter en tant que LaunchAgent:

      1. Utilisez la configuration créée sous ~/Library/LaunchAgents/com.user.deadlinesync.plist

      2. Chargez ensuite la configuration à l'aide de la commande bootstrap :

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

   2. Pour exécuter en tant que LaunchDaemon:

      1. Déplacez le fichier Pilst et modifiez les autorisations en exécutant ce qui suit :

         $ 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. Chargez l'agent de lancement à l'aide de la commande bootstrap moderne :

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

7. Vérifier le statut

   Si vous avez amorcé une LaunchAgent exécution, procédez comme suit pour confirmer qu'elle est chargée :

   $ launchctl list | grep deadlinesync

   Si vous avez amorcé un LaunchDaemon, confirmez qu'il est chargé en exécutant :

   $ sudo launchctl list | grep deadlinesync

   La sortie doit ressembler à

   SOME_PID_NUMBER 0 com.user.deadlinesync

   Pour des informations détaillées sur le statut :

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

   Cela montre l'état actuel, les arguments du programme, les variables d'environnement, l'intervalle d'exécution et l'historique des exécutions.

1. Vérifier l'installation de la CLI par date limite

   Trouvez le fichier exécutable de la date limite :

   C:\> where deadline

   Notez le chemin complet (par exemple,C:\Program Files\Amazon\DeadlineCloud\deadline.exe) à utiliser dans la tâche.

2. Créer un répertoire de points de contrôle

   Créez le répertoire dans lequel les fichiers de points de contrôle seront stockés :

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

3. Créer un répertoire de journaux

   Créez un répertoire pour les journaux des tâches :

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

4. Créer un wrapper de fichiers Batch

   Créez le fichier batch avec le contenu suivant :

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

   YOUR_PATH_TO_DEADLINE.EXE queue sync-output --profile deadline-downloader --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. Fichier de test Batch

   Testez le fichier batch manuellement :

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

   Vérifiez que le fichier journal a été créé :

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

6. Vérifier le service du planificateur de tâches

   Assurez-vous que le service du planificateur de tâches est en cours d'exécution :

   C:\> sc query "Schedule"

   Si le service n'existe pas, essayez d'autres noms :

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

   S'il n'est pas en cours d'exécution, démarrez-le :

   C:\> sc start "Schedule"

7. Créer une tâche planifiée

   Créez la tâche à exécuter toutes les 5 minutes.

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

   Répartition des commandes :

   • /tn- Nom de la tâche

   • /tr- Tâche à exécuter (votre fichier batch)

   • /sc minute /mo 5- Horaire : toutes les 5 minutes

8. Vérifier la création de tâches

   Vérifiez que la tâche a bien été créée :

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

   Recherchez :

   • Tâche à exécuter : devrait afficher le chemin de votre fichier batch

   • Durée de la prochaine exécution : devrait afficher une heure dans les 5 minutes

9. Exécution des tâches de test

   Exécutez la tâche manuellement pour tester :

   schtasks /run /tn "DeadlineOutputSync"

   Vérifiez l'état de la tâche :

   schtasks /query /tn "DeadlineOutputSync"

1. Vérifiez si le service cron est en cours d'exécution :

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

2. Afficher les journaux d'exécution de 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. Vérifiez vos journaux de tâches cron spécifiques :

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

4. Recherchez l'exécution d'une tâche cron dans les journaux système :

   
   # 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. Vérifiez les mises à jour des fichiers de point de contrôle :

   
   # 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. Vérifiez le fichier journal :

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

Affichage des journaux d'exécution de l'agent de lancement :

1. Vérifiez si l'agent de lancement est en cours d'exécution :

   
   $ sudo launchctl list | grep deadlinesync
          

   La sortie indique : PID Status Label (le PID sera indiqué - lorsqu'il n'est pas en cours d'exécution, ce qui est normal pour les tâches par intervalles)

2. Afficher le statut détaillé de l'agent de lancement :

   
   $ sudo launchctl print system/com.user.deadlinesync
          

   Cela montre l'historique des exécutions, le dernier code de sortie, le nombre d'exécutions et l'état actuel.

3. Afficher les journaux d'exécution de l'agent de lancement :

   
   # 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. Forcez l'exécution de l'agent de lancement pour un test immédiat :

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

   Cela déclenche immédiatement la tâche quel que soit le calendrier, ce qui est utile pour les tests.

5. Vérifiez les mises à jour des fichiers de point de contrôle :

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

6. Vérifiez le fichier journal :

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

1. Vérifiez si le service Task Scheduler est en cours d'exécution :

   C:\> sc query "Schedule"

   Si le service n'existe pas, essayez d'autres noms :

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

2. Consultez vos tâches planifiées :

   
   C:> schtasks /query /tn "DeadlineOutputSync"
          

3. Consultez le fichier journal de votre tâche :

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

4. Vérifiez les mises à jour des fichiers de point de contrôle :

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