¿Cómo manejo las ramas de git en OpenGrok?

Question

Queremos indexar nuestra (colección bastante grande de) repositorios de git usando OpenGrok, y lo único que no he podido descubrir es cómo indexar todas las ramas.Por lo que puedo ver, parece que necesito tener copias desprotegidas de cada rama que quiero indexar, por lo que, si un repositorio tiene, digamos, una docena de ramas, necesito tener una docena de copias, una para cada rama, por ejemplo,

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

¿Es eso realmente cierto?¿O hay alguna manera de decirle a OpenGrok que mire todo las ramas al crear su índice?

Answer 1

Las otras capas en OpenGrok está diseñado para funcionar en varios sistemas SCM que no funcionan como GIT, así que por desgracia para usted tiene que echa un vistazo a cada rama que desee indexar como un repositorio git por separado: - (

Siempre se puede presentar una RFE de apoyo para navegar por múltiples ramas en un repositorio git.

Answer 2

He escrito un script exactamente para este propósito: darun.Necesitarás usar daun cli en lugar de git cli en su trabajo cron.Tenga en cuenta que no es compatible con el historial de git de OpenGrok al momento de escribir este artículo, ya que solo estamos interesados ​​en la capacidad de búsqueda rápida de OpenGrok.Recomendamos a nuestros usuarios de OpenGrok herramientas como GitHub/Bitbucket para el historial de git basado en la web.

Answer 3

Aquí hay un script bash que escribí para hacer exactamente esto.Clonará cualquier rama nueva, actualizará las ramas existentes y eliminará las ramas que ya no existen.Aquí hay instrucciones que "funcionan";puede optar por hacer las cosas más seguras, pero esto es suficiente si solo se puede acceder a su servidor en su LAN.Tengo una configuración de trabajo cron que simplemente lo ejecuta cada 30 minutos en el servidor.Para configurar el trabajo cron para que se ejecute como root, ejecute:

sudo crontab -e

Luego pegue estos contenidos:

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

Luego escribe y cierra:

:wq

Deberá instalar "expect" que utiliza el script para ingresar la contraseña de su clave ssh.Uno de estos dos comandos funcionará dependiendo del sistema operativo Linux que esté utilizando:

sudo yum install expect
sudo apt-get install expect

Luego cree un archivo en /usr/local/bin/opengrok_index.sh:

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

A continuación, pegue el contenido del script (desde la parte inferior de esta publicación) y cambie las variables en la parte superior según su sistema.A continuación, cambie los permisos para que solo el root pueda leerlo (tiene contraseñas):

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

Probablemente quieras probar la ejecución manual del script y hacerlo funcionar, antes de esperar que funcione el trabajo cron.Este es un script particular que escribí para mi configuración particular, por lo que es posible que necesites incluir algunas declaraciones de eco y realizar algunas depuraciones para que funcione correctamente:

sudo /usr/local/bin/opengrok_index.sh

Notas adicionales:

• Este script inicia sesión en GIT a través de SSH (no HTTPS).Como tal, su git_user debe existir en el sistema y tener una tecla SSH bajo /home/user/.ssh/id_rsa que tiene acceso al repositorio de Git.Estas son cosas estándar de inicio de sesión de Git, por lo que no lo revisaré aquí.El script Introduzca el GIT_USER_SSH_PASSWORD cuando se le solicite
• El script verifica todos los archivos como GIT_USER, por lo que es posible que tengas que "compartir" tu CHECKOUT_LOCATION a ese usuario.

Guion:

#!/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

No sé nada acerca de OpenGrok pero por supuesto se puede cambiar utilizando Git ramas:

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