Comment gérez-je les branches git dans OpenGrok?

Question

Nous voulons indexer notre (collection assez grand nombre de) dépôts git en utilisant OpenGrok, et la seule chose que je ne l'ai pas été en mesure de comprendre est comment indexer toutes les branches. D'après ce que je peux voir, il semble que je dois avoir des copies check-out de chaque branche que je veux à l'index, donc, si un dépôt a, par exemple, une douzaine de branches, je dois avoir une douzaine d'exemplaires de celui-ci, un pour chaque branche, par exemple,

git-repo-with-many-branches-master/
git-repo-with-many-branches-branch1/
git-repo-with-many-branches-branch2/
       :
git-repo-with-many-branches-branch12/

Est-ce vraiment vrai? Ou est-il un moyen de dire OpenGrok regarder tous les branches lors de la création de son indice?

Answer 1

Les autres couches OpenGrok est conçu pour fonctionner sur plusieurs systèmes SCM qui ne fonctionne pas comme git, donc, malheureusement pour vous, vous devez vérifier chaque branche que vous souhaitez indexer en tant que dépôt git séparé: - (

Vous pouvez toujours déposer une RFE de soutien pour la navigation branches multiples dans un dépôt git.

Answer 2

J'ai exactement écrit un script à cet effet: Daun . Vous aurez besoin d'utiliser daun cli au lieu de git cli dans votre tâche cron. Prenez note qu'il ne supporte pas l'histoire git OpenGrok au moment de l'écriture que nous ne sommes intéressés que OpenGrok rapide capacité de recherche. Nous signalons nos utilisateurs OpenGrok à des outils tels que GitHub / Bitbucket pour l'histoire git Web.

Answer 3

Voici un script bash j'ai écrit pour faire exactement cela. Il cloner de nouvelles branches, de mettre à jour toutes les branches existantes et supprimer des branches qui n'existent plus. Voici les instructions que le « travail »; vous pouvez choisir de rendre les choses plus sûr, mais cela est assez bon si votre serveur est accessible sur votre réseau local. J'ai une configuration de tâche qui passe juste toutes les 30 minutes sur le serveur. Pour configurer la tâche cron pour exécuter en tant que root, exécutez:

sudo crontab -e

Ensuite, collez dans ces contenus:

*/30 * * * * /usr/local/bin/opengrok_index.sh

Ensuite, écrire et fermer:

:wq

Vous devrez installer « attendre » que le script utilise pour entrer le mot de passe de votre clé ssh. L'un de ces deux commandes ne fonctionnent pas selon ce que linux OS que vous utilisez:

sudo yum install expect
sudo apt-get install expect

Ensuite, créez un fichier à /usr/local/bin/opengrok_index.sh:

sudo vi /usr/local/bin/opengrok_index.sh

Ensuite, collez le contenu du script (à partir du bas de ce post), et modifier les variables en haut en fonction de votre système. Ensuite, changer les permissions pour seul root peut le lire (il a des mots de passe en elle):

sudo chmod 700 /usr/local/bin/opengrok_index.sh

Vous voulez probablement tester l'exécution du script manuellement et le faire fonctionner, avant d'attendre la tâche cron pour travailler. Ceci est un script particulier que j'ai écrit pour ma configuration particulière, vous devrez peut-être mettre dans certaines déclarations d'écho et faire du débogage pour l'obtenir fonctionne correctement:

sudo /usr/local/bin/opengrok_index.sh

Notes complémentaires:

• Ce script se connecte à GIT via SSH (non HTTPS). En tant que tel, votre GIT_USER doit exister sur le système, et ont une clé SSH sous /home/user/.ssh/id_rsa qui a accès à la prise en pension de GIT. C'est commandes standard de connexion GIT donc je ne vais pas aller au-dessus ici. Le script entrez le GIT_USER_SSH_PASSWORD lorsque vous êtes invité
• Le script vérifie tous les fichiers comme GIT_USER, vous devrez peut-être « chown » votre CHECKOUT_LOCATION à cet utilisateur

Script:

#!/bin/bash

SUDO_PASSWORD="password"
CHECKOUT_LOCATION="/var/opengrok/src/"
GIT_PROJECT_NAME="Android"
GIT_USER="username"
GIT_USER_SSH_PASSWORD="password"
GIT_URL="yourgit.domain.com"
OPENGROK_BINARY_FILE="/usr/local/opengrok-0.12.1.6/bin/OpenGrok"

# Run command as GIT_USER which has Git access
function runGitCommand {
  git_command="$@"

  expect_command="
    spawn sudo -u $GIT_USER $git_command
    expect {
        \"*password for*\" {
            send \"$SUDO_PASSWORD\"
            send \"\r\"
            exp_continue
        }
        \"*Enter passphrase for key*\" {
            send \"$GIT_USER_SSH_PASSWORD\"
            send \"\r\"
            exp_continue
        }
    }"

  command_result=$(expect -c "$expect_command" || exit 1)
}

# Checkout the specified branch over the network (slow)
function checkoutBranch {
  branch=$1

  # Check out branch if it does not exist
  if [ ! -d "$branch" ]; then
    runGitCommand git clone ssh://$GIT_URL/$GIT_PROJECT_NAME
    # Rename project to the branch name
    mv $GIT_PROJECT_NAME $branch || exit 1
  # Otherwise update the existing branch
  else
    cd $branch || exit 1
    runGitCommand git fetch
    runGitCommand git pull origin $branch || exit 1
    cd ..
  fi
}

# If the branch directory does not exist, copy the master
# branch directory then switch to the desired branch.
# This is faster than checkout out over the network.
# Otherwise, update the exisiting branch directory
function updateBranch {
  branch=$1

  if [ ! -d "$branch" ]; then
    mkdir $branch || exit 1
    rsync -av master/ $branch || exit 1
    cd $branch || exit 1
    runGitCommand git checkout -b $branch origin/$branch
    cd ..
  else
    cd $branch || exit 1
    runGitCommand git pull origin $branch || exit 1
    cd ..
  fi
}

# Change to the OpenGrok indexing location to checkout code
cd $CHECKOUT_LOCATION || exit 1

# Check out master branch
checkoutBranch master

# Get a list of all remote branches
cd master || exit 1
old_ifs=$IFS
IFS=$'\n'
origin_branches=( $(git branch -r) )
IFS=$old_ifs
origin_branches_length=${#origin_branches[@]}
cd .. # Move out of "master" directory

# Loop through and check out all branches
branches=(master)
for origin_branch in "${origin_branches[@]}"
do
  # Strip the "origin/" prefix from the branch name
  branch=${origin_branch#*/}

  # Ignore the "HEAD" branch
  # Also skip master since it has already been updated
  if [[ $branch == HEAD* ]] || [[ $branch == master* ]]; then
    continue
  fi

  branches+=("$branch")
  updateBranch $branch
done

# Get list of branches currently in OpenGrok
old_ifs=$IFS
IFS=$'\n'
local_branches=( $(ls -A1) )
size=${#local_branches[@]}
IFS=$old_ifs

# Get list of branches that are in OpenGrok, but do not exist
# remotely. These are branches that have been deleted
deleted_branches=()
for local_branch in "${local_branches[@]}"
do
  skip=0

  for branch in "${branches[@]}"
  do
    if [[ $local_branch == $branch ]]; then
      skip=1;
      break;
    fi
  done

  if [[ $skip == "0" ]]; then
    deleted_branches+=("$local_branch")
  fi
done

# Change to checkout directory again, in case some future code
# change brings us somewhere else. We are deleting recursively
# here and cannot make a mistake!
cd $CHECKOUT_LOCATION
# Delete any branches that no longer exist remotely
for deleted_branch in ${deleted_branches[@]}
do
  rm -rf ./$deleted_branch
done

# Reindex OpenGrok
$OPENGROK_BINARY_FILE index

Answer 4

Je ne sais pas quoi que ce soit au sujet OpenGrok mais bien sûr, vous pouvez modifier les branches en utilisant Git:

git checkout master
# do the indexing here
git checkout branch1
# indexing
git checkout branch2
# and so on...