gitpages

gitpages.sh (12253B)

---

 #!/bin/sh
 #
 # Copyright (c) 2026 Fred Großkopf
 #
 # Permission to use, copy, modify, and/or distribute this software for any
 # purpose with or without fee is hereby granted, provided that the above
 # copyright notice and this permission notice appear in all copies.
 #
 # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 set -eu
 
 SCRIPT_DIR="$(dirname "$0")"
 DEFAULT_CONFIG="/etc/gitpages.conf"
 LOCK_DIR="${GITPAGES_LOCK_DIR:-/tmp/gitpages-update.lock}"
 QUEUE_DIR="${GITPAGES_QUEUE_DIR:-/var/spool/gitpages/queue}"
 
 usage() {
   cat << EOF
 gitpages - generate static Git web pages using stagit
 
 Usage:
     gitpages setup SRC
     gitpages process_queue
     gitpages mirror SRC DST
     gitpages generate [REPO]
 
 Arguments:
     SRC
         Source directory containing bare Git repositories.
         These are the repositories that Git clients push to.
 
     DST
         Destination directory containing web-facing bare Git repositories.
         These repositories are served via HTTP (for example git-raw/).
 
     REPO
         Path to a single bare Git repository.
 
 Commands:
     setup SRC
         Prepare repositories for gitpages:
         install hooks and configure metadata.
 
     queue REPO
         Add a repository to the update queue.
 
     process_queue
         Process queued repository updates.
 
     generate [REPO]
         Generate stagit HTML pages.
         If REPO is omitted, generate pages for all repositories.
 
 EOF
   exit 1
 }
 
 # --- Helper Functions ---
 get_config_val() {
   awk -F '=' -v key="$1" '
     $1 ~ /^[[:space:]]*[a-zA-Z0-9_]+[[:space:]]*$/ && $1 == key {
       gsub(/[[:space:]]+$/, "", $2);
       gsub(/^[[:space:]]+/, "", $2);
       print $2;
       exit;
     }
   ' "$CONFIG"
 }
 
 error() {
   printf 'error: %s\n' "$1" >&2
   exit 1
 }
 info() { printf 'info: %s\n' "$1"; }
 warning() { printf 'warning: %s\n' "$1" >&2; }
 sed_escape() { printf '%s\n' "$1" | sed 's/[\\/&]/\\&/g'; }
 
 check_deps() {
   command -v stagit > /dev/null 2>&1 || error "stagit not found"
   command -v stagit-index > /dev/null 2>&1 || error "stagit-index not found"
   command -v git > /dev/null 2>&1 || error "git not found"
 }
 
 is_bare_repo() {
   git --git-dir="$1" rev-parse --is-bare-repository > /dev/null 2>&1
 }
 
 has_repos() {
   for repo in "$1"/*.git; do
     [ -d "$repo" ] && return 0
   done
   return 1
 }
 
 load_config() {
   CONFIG="$1"
 
   [ -r "$CONFIG" ] \
     || error "config $CONFIG not readable"
 
   WEB_ROOT=$(get_config_val "WEB_ROOT")
   GIT_SRC=$(get_config_val "GIT_SRC")
   GIT_RAW=$(get_config_val "GIT_RAW")
   GIT_HTML=$(get_config_val "GIT_HTML")
   INDEX_TITLE=$(get_config_val "INDEX_TITLE")
   INDEX_DESC=$(get_config_val "INDEX_DESCRIPTION")
   REPO_TITLE_DESC=$(get_config_val "REPO_TITLE_DESCRIPTION")
   ASSETS_DIR=$(get_config_val "ASSETS_DIR")
 
   [ -n "$WEB_ROOT" ] || error "WEB_ROOT missing in config"
   [ -n "$GIT_SRC" ] || error "GIT_SRC missing in config"
   [ -n "$GIT_RAW" ] || error "GIT_RAW missing in config"
   [ -n "$GIT_HTML" ] || error "GIT_HTML missing in config"
 }
 
 # --- Core Logic ---
 
 generate__run_stagit() {
   rm -rf "$STAGING_DIR"
   mkdir -p "$STAGING_DIR"
   cd "$STAGING_DIR"
   stagit "$REPO_SRC" > /dev/null 2>&1
 }
 
 generate__update_repo_metadata() {
   [ -n "${REPO_TITLE_DESC:-}" ] || return 0
   esc_desc=$(sed_escape "$REPO_TITLE_DESC")
   find "$STAGING_DIR" -name "*.html" -type f -exec sed -i \
     "s| - $REPO_BASE - [^<]*| - $REPO_BASE$esc_desc|g" {} +
 }
 
 generate__run_stagit_index() {
   # 1. Verify destination path exists
   [ -d "$WEB_ROOT/$GIT_HTML" ] || {
     printf 'Error: %s/html not found\n' "$WEB_ROOT/$GIT_HTML"
     return 1
   }
 
   # 2. Use a subshell to avoid persistent cd and ensure we run from the right place
   (
     cd "$WEB_ROOT/$GIT_HTML" || exit 1
 
     # 3. Check if we have repositories before running the command
     # Use 'find' to safely handle the list of repos
     repos=$(find "$SRC_DIR" -maxdepth 1 -name "*.git")
 
     if [ -n "$repos" ]; then
       stagit-index $repos > index.html
     else
       printf 'No repositories found in %s\n' "$SRC_DIR"
     fi
   )
 }
 
 generate__update_index_metadata() {
   [ -f "$WEB_ROOT/$GIT_HTML/index.html" ] || return 0
   [ -n "${INDEX_TITLE:-}" ] && {
     esc_title=$(sed_escape "$INDEX_TITLE")
     sed -i "s|<title>Repositories</title>|<title>$esc_title</title>|g" "$WEB_ROOT/$GIT_HTML/index.html"
   }
   [ -n "${INDEX_DESC:-}" ] && {
     esc_desc=$(sed_escape "$INDEX_DESC")
     sed -i "s|<span class=\"desc\">Repositories</span>|<span class=\"desc\">$esc_desc</span>|g" "$WEB_ROOT/$GIT_HTML/index.html"
   }
 }
 
 generate__copy_assets() {
   [ -d "${ASSETS_DIR:-}" ] || return 0
   mkdir -p "$STAGING_DIR"
   for f in "$ASSETS_DIR"/*; do
     [ -f "$f" ] && cp -L "$f" "$STAGING_DIR/$(basename "$f")"
   done
 }
 
 generate__publish_repo() {
   rm -rf "$TARGET_DIR" 2> /dev/null || true
   mv "$STAGING_DIR" "$TARGET_DIR" || error "could not move staging into place"
 }
 
 generate_repo() {
   load_config "$1"
   REPO_SRC="$2"
 
   REPO_BASE=$(basename "$REPO_SRC" ".git")
   SRC_DIR="$WEB_ROOT/$GIT_RAW"
   VAR_DIR="${GITPAGES_VAR_DIR:-/var/gitpages}"
   TARGET_DIR="$WEB_ROOT/$GIT_HTML/$REPO_BASE"
   STAGING_DIR="$VAR_DIR/staging/$REPO_BASE"
 
   # Execution
   generate__run_stagit
   generate__copy_assets
   generate__update_repo_metadata
   generate__publish_repo
   generate__run_stagit_index
   generate__update_index_metadata
 
   info "Generation complete for $REPO_BASE"
 }
 
 generate_all() {
   load_config "$1"
 
   [ -d "$WEB_ROOT" ] || error "WEB_ROOT directory $WEB_ROOT does not exist"
   [ -d "$GIT_SRC" ] || error "GIT_SRC directory $GIT_SRC does not exist"
 
   GIT_RAW_DIR="$WEB_ROOT/$GIT_RAW"
 
   info "1/2 Mirroring repos $GIT_SRC → $GIT_RAW_DIR"
   mirror "$GIT_SRC" "$GIT_RAW_DIR"
 
   info "2/2 Generating HTML for all repos in $GIT_RAW_DIR"
 
   for repo in "$GIT_RAW_DIR"/*.git; do
     [ -e "$repo" ] || continue
 
     info "Processing: $(basename "$repo")"
     generate_repo "$CONFIG" "$repo"
   done
 }
 
 setup__ask() {
   prompt="$1"
   current="${2:-}"
 
   if [ -t 0 ]; then
     if [ -n "$current" ]; then
       printf '%s [%s]: ' "$prompt" "$current" >&2
     else
       printf '%s: ' "$prompt" >&2
     fi
   fi
 
   read -r answer
   case "$answer" in
     "") printf '%s\n' "$current" ;;
     *) printf '%s\n' "$answer" ;;
   esac
 }
 
 setup__install_hook() {
   repo_dir="$1"
 
   hook_dir="$repo_dir/hooks"
   hook_file="$hook_dir/post-receive"
 
   mkdir -p "$hook_dir"
   cp "$POST_RECEIVE" "$hook_file"
   chmod 755 "$hook_file"
 
   info "Installed post-receive hook in $repo_dir"
 }
 
 setup__edit_metadata() {
   file="$1"
   prompt="$2"
   current=""
 
   if [ -f "$file" ]; then
     current=$(cat "$file")
   fi
 
   value=$(setup__ask "$prompt" "$current")
 
   if [ -n "$value" ]; then
     printf '%s\n' "$value" > "$file"
   fi
 }
 
 setup_repo() {
   repo="$1"
   repo_name=$(basename "$repo" .git)
 
   setup__edit_metadata "$repo/description" "Description"
   setup__edit_metadata "$repo/owner" "Owner/Contact"
   setup__edit_metadata "$repo/url" "URL"
 
   printf '## Repository: %s ##\n' "$repo_name"
 
   setup__install_hook "$repo"
 }
 
 setup_all() {
   GIT_SRC="${1:-}"
 
   if [ -z "$GIT_SRC" ]; then
     CONFIG="$DEFAULT_CONFIG"
 
     [ -r "$CONFIG" ] \
       || error "Config file $CONFIG not readable"
 
     GIT_SRC=$(get_config_val "GIT_SRC")
 
     [ -n "$GIT_SRC" ] \
       || error "GIT_SRC not set in $CONFIG"
   fi
 
   [ -d "$GIT_SRC" ] \
     || error "Directory '$GIT_SRC' not found"
 
   POST_RECEIVE="$SCRIPT_DIR/gitpages.post-receive.hook"
 
   [ -f "$POST_RECEIVE" ] \
     || error "post-receive helper not found in $SCRIPT_DIR"
 
   for repo in "$GIT_SRC"/*.git; do
     [ -d "$repo" ] || continue
     setup_repo "$repo"
   done
 
   info "Setup complete for all repos in $GIT_SRC"
 }
 
 mirror__copy_repo() {
   src="$1"
   dst_dir="$2"
   name=$(basename "$src")
   dst="$dst_dir/$name"
 
   is_bare_repo "$src" || {
     warning "skipping $name (not bare)"
     return 0
   }
 
   rm -rf "$dst"
   cp -R "$src" "$dst"
   git --git-dir="$dst" update-server-info > /dev/null 2>&1
 }
 
 mirror() {
   src="$1"
   dst_dir="$2"
 
   [ "$dst_dir" != "/" ] \
     || error "refusing to use / as destination"
 
   [ -d "$dst_dir" ] && [ -w "$dst_dir" ] \
     || error "DST_DIR '$dst_dir' not writable"
 
   if is_bare_repo "$src"; then
     mirror__copy_repo "$src" "$dst_dir"
     info "synced: $src → $dst_dir"
   elif has_repos "$src"; then
     [ "$dst_dir" != "/" ] && rm -rf "$dst_dir"/*
 
     for repo in "$src"/*.git; do
       [ -d "$repo" ] || break
       mirror__copy_repo "$repo" "$dst_dir"
     done
 
     info "synced all: $src → $dst_dir"
   else
     error "$src: neither bare repo nor *.git directory"
   fi
 }
 
 process_repo() {
   CONFIG="$1"
   repo_path="$2"
 
   repo_name=$(basename "$repo_path")
 
   load_config "$CONFIG"
 
   GIT_RAW_DIR="$WEB_ROOT/$GIT_RAW"
 
   [ -d "$GIT_RAW_DIR" ] || {
     printf 'error: GIT_RAW directory %s does not exist\n' "$GIT_RAW_DIR" >&2
     return 1
   }
 
   if ! mirror "$repo_path" "$GIT_RAW_DIR"; then
     printf 'error: Failed to mirror %s\n' "$repo_name" >&2
     return 1
   fi
 
   if ! generate_repo "$CONFIG" "$GIT_RAW_DIR/$repo_name"; then
     printf 'error: Failed to generate pages for %s\n' "$repo_name" >&2
     return 1
   fi
 }
 
 cmd_setup() {
   case "$#" in
     0)
       setup_all
       ;;
     1)
       setup_all "$1"
       ;;
     *)
       error "usage: gitpages setup [SRC]"
       ;;
   esac
 }
 
 cmd_process_queue() {
   CONFIG="$DEFAULT_CONFIG"
 
   while [ "$#" -gt 0 ]; do
     case "$1" in
       -h)
         printf 'usage: gitpages process_queue [-c config]\n'
         return 0
         ;;
       -c)
         [ "$#" -ge 2 ] || {
           printf 'ERROR: -c requires a config file\n' >&2
           exit 1
         }
         CONFIG="$2"
         shift 2
         ;;
       -*)
         printf 'ERROR: unknown option: %s\n' "$1" >&2
         exit 1
         ;;
       *)
         printf 'ERROR: too many arguments\n' >&2
         exit 1
         ;;
     esac
   done
 
   [ -r "$CONFIG" ] || error "config $CONFIG not readable"
 
   if ! mkdir "$LOCK_DIR" 2> /dev/null; then
     info "Update already in progress. Exiting."
     return 0
   fi
 
   trap 'rmdir "$LOCK_DIR"' EXIT
 
   if [ ! -d "$QUEUE_DIR" ]; then
     info "Queue directory not found: $QUEUE_DIR"
     return 0
   fi
 
   processed=0
 
   for jobfile in "$QUEUE_DIR"/*; do
     [ -f "$jobfile" ] || continue
 
     repo_path=$(cat "$jobfile")
 
     if [ -d "$repo_path" ]; then
       info "Starting process_repo for: $repo_path (job: $jobfile)"
 
       if process_repo "$CONFIG" "$repo_path"; then
         processed=$((processed + 1))
         rm -f "$jobfile"
       else
         printf 'error: failed to process %s (job: %s)\n' "$repo_path" "$jobfile" >&2
       fi
     else
       printf 'error: Repository directory %s not found (job: %s)\n' \
         "$repo_path" "$jobfile" >&2
     fi
   done
 
   if [ "$processed" -gt 0 ]; then
     info "process_queue completed."
   fi
 }
 
 cmd_generate() {
   repo=""
   config=""
 
   while [ "$#" -gt 0 ]; do
     case "$1" in
       -h)
         printf 'usage: gitpages generate [-c config] [REPO]\n'
         return 0
         ;;
       -c)
         [ "$#" -ge 2 ] || {
           printf 'ERROR: -c requires a config file\n' >&2
           exit 1
         }
         config="$2"
         shift 2
         ;;
       -*)
         printf 'ERROR: unknown option: %s\n' "$1" >&2
         exit 1
         ;;
       *)
         [ -z "$repo" ] || {
           printf 'ERROR: too many arguments\n' >&2
           exit 1
         }
         repo="$1"
         shift
         ;;
     esac
   done
 
   [ -n "$config" ] || config="$DEFAULT_CONFIG"
 
   check_deps
 
   if [ -n "$repo" ]; then
     generate_repo "$config" "$repo"
   else
     generate_all "$config"
   fi
 }
 
 [ $# -gt 0 ] || usage
 
 command="$1"
 shift
 
 case "$command" in
   setup)
     cmd_setup "$@"
     ;;
   process_queue)
     cmd_process_queue "$@"
     ;;
   mirror)
     cmd_mirror "$@"
     ;;
   generate)
     cmd_generate "$@"
     ;;
   *)
     usage
     ;;
 esac