Téléchargements automatiques

1. Vérifier la date limite d'installation de l'interface

   Obtenez le chemin exact vers l'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 jobs existants :

   $ crontab -l

5. Modifier Crontab

   Ouvrez votre fichier crontab pour le modifier :

   $ crontab -e

   La première fois que vous exécutez la commande, vous pouvez être invité à choisir un éditeur (nano, vim, etc.).

6. Ajouter Cron Job Entry

   Ajoutez la ligne suivante pour exécuter la tâche 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

   Votre nouveau poste devrait être 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 ne fonctionne pas, démarrez-le :

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

1. Vérifier la date limite d'installation de l'interface

   Obtenez le chemin exact vers l'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 du journal sur 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 de 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 d'envoi.

4. Valider le fichier Plist

   Validez la syntaxe XML de votre fichier plist :

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

   La commande renvoie « 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 bootstrap

   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'aucun utilisateur ne soit connecté à chaque fois que la machine est en marche, 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 la commande suivante :

         $ 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 obtenir des informations détaillées sur l'état :

   $ 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 la date limite d'installation de l'interface

   Trouvez l'exécutable de la date limite :

   C:\> where deadline

   Notez le chemin complet (par exempleC:\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 batch de test

   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érifiez le service de planification des tâches

   Assurez-vous que 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"

   S'il ne fonctionne pas, 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 d'une tâche

   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 du 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.*sync-output" /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 points 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. Consultez 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 - lorsqu'il n'est pas en cours d'exécution, ce qui est normal pour les tâches à intervalles)

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

   
   $ sudo launchctl print system/com.user.deadlinesync
          

   Cela affiche 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. Exécutez de force l'agent de lancement pour un test immédiat :

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

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

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

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

6. Consultez 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 points de contrôle :

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