• Recent
  • Unsolved
  • Tags
  • Popular
  • Users
  • Groups
  • Search
  • Register
  • Login
  • Recent
  • Unsolved
  • Tags
  • Popular
  • Users
  • Groups
  • Search
  • Register
  • Login

Postdownload scripts and API

Scheduled Pinned Locked Moved
General
1
5
363
Loading More Posts
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • H
    HorizonG
    last edited by Aug 5, 2024, 5:57 PM

    Hello,

    I created a function in bash to retrieve the groupid for the postdownload step.

    I use the API to return the groupid from the hostname of the machine. This works fine locally on the server, but when the script is run from the host, it tells me “./fog.api.answer.sh” No such found file or directory

    Location of the file is inside the postdownload folder.

    I need to copy files according to the groupid.

    Do you have a solution?

    H 1 Reply Last reply Aug 5, 2024, 6:08 PM Reply Quote 0
    • H
      HorizonG @HorizonG
      last edited by Aug 5, 2024, 6:08 PM

      @HorizonG said in Postdownload scripts and API:

      Hello,

      I created a function in bash to retrieve the groupid for the postdownload step.

      I use the API to return the groupid from the hostname of the machine. This works fine locally on the server, but when the script is run from the host, it tells me “./fog.api.answer.sh” No such found file or directory

      Location of the file is inside the postdownload folder.

      I need to copy files according to the groupid.

      Do you have a solution?

      @HorizonG said in Postdownload scripts and API:
      1000008158.jpg 1000008159.jpg 1000008160.jpg

      H 2 Replies Last reply Aug 8, 2024, 4:15 PM Reply Quote 0
      • H
        HorizonG @HorizonG
        last edited by Aug 8, 2024, 4:15 PM

        @HorizonG I found the solution.
        I will share my code tomorrow

        1 Reply Last reply Reply Quote 0
        • H
          HorizonG @HorizonG
          last edited by Sep 3, 2024, 4:47 PM

          @HorizonG

          Sorry for delay.

          Thanks to the code below, I can copy/paste a folder according to the group the computer is in.

          For example :
          I need a folder called “Site1” on a PC depending to a specific group”.

          Please note that the code below was not designed by the FOG developers.
          Execution of this code is at your own risk; be sure to understand and test its impact in your environment before using it in production

          1. First you need to create API/USER Token on FOG Server
          2. Create Group like “Site1”
          3. Create Folder under /images/ => Name folder “Sites” => Chmod 777
          4. Create Child folder (exact name of group) => “Site1”
          5. Need to install “jq” package on FOG server : on Debian dist sudo apt-get install jq
          6. Create New File in posdownloadscripts folder (mine : fog.targetgroup)
          7. This file need to be call in fog.postdownload file with this part : ${postdownpath}/fog.targetgroup

          (Sorry I’m really bad at bash)

          Inside fog.targetgroup file :

          #!/bin/bash
          
          #Variables
          FOG_HOSTNAME=$hostname
          FOG_API_TOKEN="deleted for privacy reasons"
          FOG_USER_TOKEN="deleted for privacy reasons"
          FOG_SERVER="deleted for privacy reasons"  # Adresse IP ou nom d'hôte de votre serveur FOG
          echo "Serveur FOG: $FOG_SERVER"
          
          # Fonction pour appeler l'API FOG
          function invoke_fog_api() {
              local fog_api_token="$1"
              local fog_user_token="$2"
              local fog_server="$3"
              local uri_path="$4"
              local method="${5:-GET}"
              local json_data="$6"
          
              local base_uri="http://$fog_server/fog"
              local uri="$base_uri/$uri_path"
          
              # Construct headers
              local headers=(
                  -H "fog-api-token: $fog_api_token"
                  -H "fog-user-token: $fog_user_token"
                  -H "Content-Type: application/json"
              )
          
              # Make API call and store response in a variable
              if [ "$method" == "GET" ]; then
                  response=$(curl -s -X GET "$uri" "${headers[@]}")
              else
                  response=$(curl -s -X "$method" "$uri" "${headers[@]}" -d "$json_data")
              fi
          
              echo "$response"
          }
          
          # Fonction pour obtenir les détails de l'hôte
          function get_fog_host() {
              local fog_api_token="$1"
              local fog_user_token="$2"
              local fog_server="$3"
              local fog_hostname="$4"
          
              response=$(invoke_fog_api "$fog_api_token" "$fog_user_token" "$fog_server" "host?name=$fog_hostname")
          
              # Vérifiez si la réponse est vide
              if [ -z "$response" ]; then
                  echo "Erreur: La réponse de l'API pour l'hôte est vide."
                  return 1
              fi
          
              # Vérifiez la validité du JSON
              if ! echo "$response" | jq . > /dev/null 2>&1; then
                  echo "Erreur: La réponse de l'API pour l'hôte n'est pas un JSON valide."
                  echo "Réponse brute de l'API: $response"
                  return 1
              fi
          
              # Extraire les détails de l'hôte
              local host_info
              host_info=$(echo "$response" | jq --arg hostname "$fog_hostname" '.hosts[] | select(.name == $hostname)')
          
              if [ -z "$host_info" ]; then
                  echo "Erreur: Aucun détail trouvé pour l'hôte $fog_hostname."
                  return 1
              fi
          
              echo "$host_info"
          }
          
          # Fonction pour obtenir les groupes associés à un hôte
          function get_fog_group() {
              local fog_api_token="$1"
              local fog_user_token="$2"
              local fog_server="$3"
              local host_id="$4"
          
              # Récupérer les associations de groupes
              response=$(invoke_fog_api "$fog_api_token" "$fog_user_token" "$fog_server" "groupassociation")
          
              # Vérifiez si la réponse est vide
              if [ -z "$response" ]; then
                  echo "Erreur: La réponse de l'API pour les associations de groupes est vide."
                  return 1
              fi
          
              # Vérifiez la validité du JSON
              if ! echo "$response" | jq . > /dev/null 2>&1; then
                  echo "Erreur: La réponse de l'API pour les associations de groupes n'est pas un JSON valide."
                  echo "Réponse brute de l'API: $response"
                  return 1
              fi
          
              # Extraire l'ID du groupe associé
              local group_id
              group_id=$(echo "$response" | jq --arg host_id "$host_id" '.groupassociations[] | select(.hostID == ($host_id | tonumber)) | .groupID')
          
              if [ -z "$group_id" ]; then
                  echo "Erreur: Aucun groupe associé trouvé pour l'hôte avec l'ID $host_id."
                  return 1
              fi
          
              # Récupérer les détails des groupes
              response=$(invoke_fog_api "$fog_api_token" "$fog_user_token" "$fog_server" "group")
          
              # Vérifiez si la réponse est vide
              if [ -z "$response" ]; then
                  echo "Erreur: La réponse de l'API pour les groupes est vide."
                  return 1
              fi
          
              # Vérifiez la validité du JSON
              if ! echo "$response" | jq . > /dev/null 2>&1; then
                  echo "Erreur: La réponse de l'API pour les groupes n'est pas un JSON valide."
                  echo "Réponse brute de l'API: $response"
                  return 1
              fi
          
              # Extraire les détails du groupe
              local group_info
              group_info=$(echo "$response" | jq --arg group_id "$group_id" '.groups[] | select(.id == ($group_id | tonumber)) | {id: .id, name: .name}')
          
              if [ -z "$group_info" ]; then
                  echo "Erreur: Aucun détail trouvé pour le groupe avec l'ID $group_id."
                  return 1
              fi
          
              echo "$group_info"
          }
          
          # Fonction principale pour la simulation
          function GetInfo_host() {
              local fog_api_token="$FOG_API_TOKEN"
              local fog_user_token="$FOG_USER_TOKEN"
              local fog_server="$FOG_SERVER"
              local fog_hostname="$FOG_HOSTNAME"
          
              # Obtenez les détails de l'hôte
              local local_host
              local_host=$(get_fog_host "$fog_api_token" "$fog_user_token" "$fog_server" "$fog_hostname")
          
              # Vérifiez si local_host est vide
              if [ -z "$local_host" ]; then
                  echo "Erreur: Aucune information sur l'hôte trouvée."
                  return 1
              fi
          
              # Obtenez l'ID de l'hôte
              local host_id
              host_id=$(echo "$local_host" | jq -r '.id')
          
              if [ -z "$host_id" ]; then
                  echo "Erreur: Impossible d'extraire l'ID de l'hôte."
                  return 1
              fi
          
              # Obtenez les groupes associés à l'hôte
              local host_group
              host_group=$(get_fog_group "$fog_api_token" "$fog_user_token" "$fog_server" "$host_id")
          
              # Vérifiez si host_group est vide
              if [ -z "$host_group" ]; then
                  echo "Erreur: Aucune information sur le groupe trouvée pour l'hôte."
                  return 1
              fi
          
              # Définir les variables d'environnement pour le nom et l'ID du groupe
              export FOG_GROUP_NAME=$(echo "$host_group" | jq -r '.name')
              export FOG_GROUP_ID=$(echo "$host_group" | jq -r '.id')
          
              # Affichage des détails
              echo "---------------------------------------"
              echo "Détails de l'hôte pour: $fog_hostname"
              echo "---------------------------------------"
              echo "Détails de l'hôte récupérés :"
              echo "$local_host"
              echo "---------------------------------------"
          
              # Affichage des détails du groupe
              echo "Détails du groupe pour l'hôte: $fog_hostname"
              echo "Nom du groupe: $FOG_GROUP_NAME"
              echo "ID du groupe: $FOG_GROUP_ID"
              echo "---------------------------------------"
          }
          
          # Appel de la fonction principale
          GetInfo_host
          
          
          # Vérification de la présence du disque système
          echo "Verifying we've found the OS disk"
          if [[ ! -d /ntfs/windows && ! -d /ntfs/Windows && ! -d /ntfs/WINDOWS ]]; then
              echo "! OS root Not found !"
              # Assurez-vous que 'debugPause' est défini, sinon utilisez une alternative appropriée
              # debugPause
              exit 1
          fi
          echo "Found"
          
          # Préparer le chemin des dossiers
          clientfolderpath="/ntfs/FOG/Sites/$FOG_GROUP_NAME"
          remotefolderpath="/images/Sites/$FOG_GROUP_NAME"
          
          # Créer le répertoire /tmp/sites s'il n'existe pas déjà
          if [[ ! -d /tmp/sites ]]; then
              mkdir -p /tmp/sites
          fi
          
          # Créer le sous-répertoire avec le nom contenu dans $FOG_GROUP_NAME
          if [[ -n "$FOG_GROUP_NAME" ]]; then
              mkdir -p "/tmp/sites/$FOG_GROUP_NAME"
              echo "Le répertoire /tmp/sites/$FOG_GROUP_NAME a été créé."
          else
              echo "Erreur : \$FOG_GROUP_NAME est vide. Impossible de créer le répertoire."
              exit 1
          fi
          
          # Créer le répertoire clientfolderpath s'il n'existe pas déjà
          if [[ ! -d "$clientfolderpath" ]]; then
              mkdir -p "$clientfolderpath"
              echo "Répertoire client créé : $clientfolderpath"
          fi
          
          # Copier le dossier avec rsync
          echo -n "In Progress"
          rsync -aqz "$remotefolderpath/" "$clientfolderpath/" >/dev/null 2>&1
          
          if [[ $? -eq 0 ]]; then
              echo "Dossier copié avec succès."
          else
              echo "Erreur : Échec de la copie du dossier."
              exit 1
          fi
          
          debugPause
          
          
          H 1 Reply Last reply Sep 6, 2024, 3:31 PM Reply Quote 0
          • H
            HorizonG @HorizonG
            last edited by Sep 6, 2024, 3:31 PM

            @HorizonG

            I’m making an update to my script.

            If the computer belongs to several groups at the same time, this can cause problems.

            I now return all the groups, then the script selects only the group starting with GROUP_AUTOMATE_ …

            7679ccb4-dc09-4d19-9a3f-49b8039eeaf2-image.png

            This will copy only this folder to the local directory of the client machine : clientfolderpath=“/ntfs/FOG/Sites/$SITE_GROUP”
            136a0ede-7eec-46bc-a1bc-04560b236750-image.png

            Le script

            #!/bin/bash
            
            #Variables
            FOG_HOSTNAME=$hostname
            FOG_API_TOKEN="deleted for privacy reasons"
            FOG_USER_TOKEN="deleted for privacy reasons"
            FOG_SERVER="deleted for privacy reasons"  # Adresse IP ou nom d'hôte de votre serveur FOG
            echo "Serveur FOG: $FOG_SERVER"
            
            
            # Fonction pour appeler l'API FOG
            function invoke_fog_api() {
                local fog_api_token="$1"
                local fog_user_token="$2"
                local fog_server="$3"
                local uri_path="$4"
                local method="${5:-GET}"
                local json_data="$6"
            
                local base_uri="http://$fog_server/fog"
                local uri="$base_uri/$uri_path"
            
                # Construct headers
                local headers=(
                    -H "fog-api-token: $fog_api_token"
                    -H "fog-user-token: $fog_user_token"
                    -H "Content-Type: application/json"
                )
            
                # Make API call and store response in a variable
                if [ "$method" == "GET" ]; then
                    response=$(curl -s -X GET "$uri" "${headers[@]}")
                else
                    response=$(curl -s -X "$method" "$uri" "${headers[@]}" -d "$json_data")
                fi
            
                echo "$response"
            }
            
            # Fonction pour obtenir les détails de l'hôte
            function get_fog_host() {
                local fog_api_token="$1"
                local fog_user_token="$2"
                local fog_server="$3"
                local fog_hostname="$4"
            
                response=$(invoke_fog_api "$fog_api_token" "$fog_user_token" "$fog_server" "host?name=$fog_hostname")
            
                # Vérifiez si la réponse est vide
                if [ -z "$response" ]; then
                    echo "Erreur: La réponse de l'API pour l'hôte est vide."
                    return 1
                fi
            
                # Vérifiez la validité du JSON
                if ! echo "$response" | jq . > /dev/null 2>&1; then
                    echo "Erreur: La réponse de l'API pour l'hôte n'est pas un JSON valide."
                    echo "Réponse brute de l'API: $response"
                    return 1
                fi
            
                # Extraire les détails de l'hôte
                local host_info
                host_info=$(echo "$response" | jq --arg hostname "$fog_hostname" '.hosts[] | select(.name == $hostname)')
            
                if [ -z "$host_info" ]; then
                    echo "Erreur: Aucun détail trouvé pour l'hôte $fog_hostname."
                    return 1
                fi
            
                echo "$host_info"
             }
            
            # Fonction pour obtenir les groupes associés à un hôte
            function get_fog_groups_for_host() {
                local fog_api_token="$1"
                local fog_user_token="$2"
                local fog_server="$3"
                local host_id="$4"
            
                # Récupérer les associations de groupes
                local response
                response=$(invoke_fog_api "$fog_api_token" "$fog_user_token" "$fog_server" "groupassociation")
            
                # Vérifiez la validité du JSON
                if ! echo "$response" | jq . >/dev/null 2>&1; then
                    echo "Erreur: La réponse de l'API pour les associations de groupes n'est pas un JSON valide."
                    echo "Réponse brute de l'API: $response"
                    return 1
                fi
            
                # Extraire les IDs des groupes associés à l'hôte
                local group_ids
                group_ids=$(echo "$response" | jq -r --arg host_id "$host_id" '.groupassociations[] | select(.hostID == ($host_id | tonumber)) | .groupID')
            
                # Récupérer les détails des groupes
                response=$(invoke_fog_api "$fog_api_token" "$fog_user_token" "$fog_server" "group")
            
                # Vérifiez la validité du JSON
                if ! echo "$response" | jq . >/dev/null 2>&1; then
                    echo "Erreur: La réponse de l'API pour les groupes n'est pas un JSON valide."
                    echo "Réponse brute de l'API: $response"
                    return 1
                fi
               
                # Afficher les détails des groupes associés dans un format simple
                local group_ids_array
                group_ids_array=$(echo "$group_ids" | jq -R -s -c 'split("\n") | map(select(length > 0) | tonumber)')
            
                echo "$response" | jq -r --argjson group_ids "$group_ids_array" \
                    '.groups[] | select(.id as $id | $group_ids | index($id)) | "\(.id) \(.name)"'
            }
            
            # Fonction pour traiter et afficher les groupes dont le nom commence par GROUP_AUTOMATE_
            function process_fog_groups() {
                local group_data="$1"
            
                echo "Groupes associés à l'hôte (commençant par GROUP_AUTOMATE_) :"
            
                # Initialiser les index
                local group_index=1
                
                # Extraire les groupes et définir les variables d'environnement
                while IFS= read -r line; do
                    id=$(echo "$line" | awk '{print $1}')
                    name=$(echo "$line" | awk '{$1=""; print $0}' | sed 's/^ *//') # Remove leading spaces from the name
                    
                    if [[ "$name" == GROUP_AUTOMATE_* ]]; then
                        # Définir les variables d'environnement pour le nom et l'ID du groupe
                        export FOG_GROUP_NAME_$group_index="$name"
                        export FOG_GROUP_ID_$group_index="$id"
                        
                        # Afficher le groupe
                        echo "GROUP NAME = $name"
                        echo "GROUP ID =  $id"
            
                        export FOG_GROUP_NAME_AUTOMATE=$name
                        export FOG_GROUP_NAME_ID=$id
                        
                        # Incrémenter l'index pour le prochain groupe
                        group_index=$((group_index + 1))
                    fi
                done <<< "$group_data"
            }
            
            # Fonction principale pour la simulation
            function GetInfo_host() {
                local fog_api_token="$FOG_API_TOKEN"
                local fog_user_token="$FOG_USER_TOKEN"
                local fog_server="$FOG_SERVER"
                local fog_hostname="$FOG_HOSTNAME"
            
                # Obtenez les détails de l'hôte
                local local_host
                local_host=$(get_fog_host "$fog_api_token" "$fog_user_token" "$fog_server" "$fog_hostname")
            
                # Vérifiez si local_host est vide
                if [ -z "$local_host" ]; then
                    echo "Erreur: Aucune information sur l'hôte trouvée."
                    return 1
                fi
            
                # Obtenez l'ID de l'hôte
                local host_id
                host_id=$(echo "$local_host" | jq -r '.id')
            
                if [ -z "$host_id" ]; then
                    echo "Erreur: Impossible d'extraire l'ID de l'hôte."
                    return 1
                fi
            
                # Obtenez les groupes associés à l'hôte
                local host_groups
                host_groups=$(get_fog_groups_for_host "$fog_api_token" "$fog_user_token" "$fog_server" "$host_id")
            
                
                # Vérifiez si host_groups est vide
                if [ -z "$host_groups" ]; then
                    echo "Erreur: Aucune information sur les groupes trouvée pour l'hôte."
                    return 1
                fi
                
                # Traitement des groupes et affichage des détails
                process_fog_groups "$host_groups"
            
                # Accès aux variables d'environnement pour chaque groupe
               for i in $(seq 1 $((group_index - 1))); do
                 echo "Nom du groupe $i: ${!FOG_GROUP_NAME_$i}"
                 echo "ID du groupe $i: ${!FOG_GROUP_ID_$i}"
                done
            
            
                # Affichage des détails
                echo "---------------------------------------"
                echo "Détails de l'hôte pour: $fog_hostname"
                echo "---------------------------------------"
                echo "Détails de l'hôte récupérés :"
                echo "$local_host"
                echo "---------------------------------------"
                
                # Afficher le contenu de host_groups => ALL GROUPS
                echo "---------------------------------------"
                echo "ALL GROUPS :"
                echo "$host_groups"
                echo "---------------------------------------"
            
            
            
                # Affichage des détails du groupe AUTOMATION
                
            	
               #echo $FOG_GROUP_NAME_AUTOMATE
               #echo $FOG_GROUP_NAME_ID
               
               echo "Détails du groupe automation"
               echo "Nom du groupe: $FOG_GROUP_NAME_AUTOMATE"
               echo "ID du groupe: $FOG_GROUP_NAME_ID"
               echo "---------------------------------------"
            
               # Définir les variables d'environnement pour le nom et l'ID du groupe
               export FOG_GROUP_NAME_AUTOMATE
               export FOG_GROUP_NAME_ID
            
            
            }
            
            GetInfo_host
            
            SITE_GROUP="${FOG_GROUP_NAME_AUTOMATE##*_}"
            echo "Target Site $SITE_GROUP"
            echo "Try to copy this folder if existing : /images/Sites/$SITE_GROUP"
            
            
            # Vérification de la présence du disque système
            echo "Verifying we've found the OS disk"
            if [[ ! -d /ntfs/windows && ! -d /ntfs/Windows && ! -d /ntfs/WINDOWS ]]; then
                echo "! OS root Not found !"
                # Assurez-vous que 'debugPause' est défini, sinon utilisez une alternative appropriée
                # debugPause
                exit 1
            fi
            echo "Found"
            
            # Préparer le chemin des dossiers
            clientfolderpath="/ntfs/FOG/Sites/$SITE_GROUP"
            remotefolderpath="/images/Sites/$SITE_GROUP"
            
            # Créer le répertoire /tmp/sites s'il n'existe pas déjà
            if [[ ! -d /tmp/sites ]]; then
                mkdir -p /tmp/sites
            fi
            
            # Créer le sous-répertoire avec le nom contenu dans $SITE_GROUP
            if [[ -n "$SITE_GROUP" ]]; then
                mkdir -p "/tmp/sites/$SITE_GROUP"
                echo "Le répertoire /tmp/sites/$SITE_GROUP a été créé."
            else
                echo "Erreur : \$SITE_GROUP est vide. Impossible de créer le répertoire."
                exit 1
            fi
            
            # Créer le répertoire clientfolderpath s'il n'existe pas déjà
            if [[ ! -d "$clientfolderpath" ]]; then
                mkdir -p "$clientfolderpath"
                echo "Répertoire client créé : $clientfolderpath"
            fi
            
            # Copier le dossier avec rsync
            echo -n "In Progress"
            rsync -aqz "$remotefolderpath/" "$clientfolderpath/" >/dev/null 2>&1
            
            if [[ $? -eq 0 ]]; then
                echo "Dossier copié avec succès."
            else
                echo "Erreur : Échec de la copie du dossier."
                exit 1
            fi
            
            debugPause
            
            1 Reply Last reply Reply Quote 0
            • 1 / 1
            • First post
              Last post

            217

            Online

            12.0k

            Users

            17.3k

            Topics

            155.2k

            Posts
            Copyright © 2012-2024 FOG Project