CleanUpWiki_v7 - itnett/FTD02H-N GitHub Wiki

For å automatisere prosessen med å addere, branche og pushe kode til GitHub, kan vi lage et skript som utfører disse operasjonene. Skriptet kan kjøre etter at backup- og forberedelsesskriptet er ferdig. Skriptet vil:

  1. Initialisere et nytt Git-repositorium hvis det ikke allerede finnes.
  2. Addere alle filer til staging-området.
  3. Lage en commit med en standard eller spesifisert melding.
  4. Sette opp riktig remote for både hovedrepoen og wiki-repoen.
  5. Pushe endringene til GitHub.

Her er et eksempel på et slikt skript:

#!/bin/bash

# Konfigurerer Git-repositoriet
REPO_DIR="C:/WikiMigration/git/code_repo"
WIKI_REPO_DIR="C:/WikiMigration/git/code_repo_wiki"
MAIN_REPO_URL="https://github.com/itnett/FTD02N.git"
WIKI_REPO_URL="https://github.com/itnett/FTD02N.wiki.git"
COMMIT_MSG="Automatisk commit etter migrasjon"

# Gå til hoved-repo directory
cd "$REPO_DIR" || exit

# Initialiser git hvis det ikke allerede er gjort
if [ ! -d ".git" ]; then
    git init
    git branch -M main
fi

# Legg til remote og sjekk om det allerede eksisterer
git remote remove origin 2>/dev/null
git remote add origin "$MAIN_REPO_URL"

# Legg til filer, commit og push
git add .
git commit -m "$COMMIT_MSG"
git push -u origin main

# Gå til wiki-repo directory (hvis det er separert)
if [ -d "$WIKI_REPO_DIR" ]; then
    cd "$WIKI_REPO_DIR" || exit

    if [ ! -d ".git" ]; then
        git init
        git branch -M main
    fi

    git remote remove origin 2>/dev/null
    git remote add origin "$WIKI_REPO_URL"

    git add .
    git commit -m "$COMMIT_MSG"
    git push -u origin main
fi

echo "Kode er pushet til GitHub."

Hvordan bruke skriptet:

  1. Plassering: Lagre skriptet i en .sh-fil, for eksempel push_to_github.sh.
  2. Kjøring: Kjør skriptet etter at backup_and_prepare_v02.py er kjørt, eller legg til et kall til dette skriptet på slutten av backup_and_prepare_v02.py hvis du ønsker å kjøre alt i ett.

Viktige bemerkninger:

  • Du må kanskje logge på GitHub første gang du pusher, avhengig av autentiseringsmetoden du bruker (for eksempel SSH eller personal access token).
  • Hvis du kjører på nytt etter en backup, sørg for at skriptet kjøres i det oppdaterte miljøet.

Integrering med Python-skriptet:

Hvis du ønsker å kjøre dette skriptet automatisk fra Python etter at backup og forberedelser er gjort, kan du legge til følgende i Python-skriptet:

import subprocess

# Kjør bash-skriptet for å pushe til GitHub
subprocess.run(["/bin/bash", "C:/WikiMigration/push_to_github.sh"])

Dette vil sikre at alt utføres automatisk i én sekvens. Husk å tilpasse filbanene og eventuelle detaljer etter behov.

For å automatisere prosessen med å legge til, kommitere og pushe endringer til både hovedrepoet og wiki-repoet på GitHub, kan vi skrive et Python-skript som håndterer hele arbeidsflyten. Vi kan bruke GitPython-biblioteket for å interagere med Git på en mer kontrollert og programmatisk måte.

Oversikt over hva skriptet vil gjøre:

  1. Sjekke og installere nødvendige avhengigheter: Sikre at GitPython er installert.
  2. Definere konfigurasjonsparametere: Spesifisere lokale kataloger, GitHub-URLer og kommitteringsmeldinger.
  3. Kloning eller oppdatering av repositorier: Hvis repositoriene ikke finnes lokalt, klone dem; ellers hente siste endringer.
  4. Legge til og kommitere endringer: Legge til nye eller endrede filer og lage passende kommitteringsmeldinger.
  5. Pushe endringer til GitHub: Pushe de lokale endringene til de respektive fjernrepositoriene.
  6. Håndtere autentisering: Bruke personlige tilgangstokens (PAT) for sikker autentisering mot GitHub.

Forutsetninger:

  • Python 3.x installert på systemet ditt.
  • Git installert og konfigurert på systemet ditt.
  • Personlig tilgangstoken (PAT) fra GitHub med nødvendige rettigheter for å pushe til repositoriene.

Steg-for-steg guide:

1. Installer nødvendige avhengigheter

Først må vi installere GitPython-biblioteket. Dette kan gjøres ved å kjøre følgende kommando i terminalen:

pip install GitPython

2. Opprett og kjør Python-skriptet

Opprett en ny Python-fil, for eksempel git_automation.py, og kopier inn følgende kode:

import os
from git import Repo, GitCommandError
from getpass import getpass

# ---------------------------- Konfigurasjon ---------------------------- #

# Sti til lokale kataloger
main_repo_local_path = r'C:\WikiMigration\git\FTD02N'
wiki_repo_local_path = r'C:\WikiMigration\git\FTD02N.wiki'

# GitHub URLer
main_repo_url = 'https://github.com/itnett/FTD02N.git'
wiki_repo_url = 'https://github.com/itnett/FTD02N.wiki.git'

# Commit-meldinger
main_repo_commit_message = 'Oppdatering av hovedrepo med siste endringer'
wiki_repo_commit_message = 'Oppdatering av wiki-repo med siste endringer'

# Filstier å legge til i hvert repo
main_repo_files = [
    # Legg til fulle filstier eller bruk os.path.join for å dynamisk lage stier
    r'C:\WikiMigration\git\code_repo\file1.py',
    r'C:\WikiMigration\git\code_repo\file2.py',
    # Legg til flere filer etter behov
]

wiki_repo_files = [
    r'C:\WikiMigration\git\code_dump\page1.md',
    r'C:\WikiMigration\git\code_dump\page2.md',
    # Legg til flere filer etter behov
]

# ------------------------- Autentisering ------------------------- #

# Be om GitHub Personal Access Token fra bruker
print("Vennligst oppgi ditt GitHub Personal Access Token (PAT) med nødvendige rettigheter.")
github_pat = getpass("GitHub PAT: ")

# Legg til PAT i URLene for autentisering
authenticated_main_repo_url = main_repo_url.replace('https://', f'https://{github_pat}@')
authenticated_wiki_repo_url = wiki_repo_url.replace('https://', f'https://{github_pat}@')

# ------------------------ Funksjoner ------------------------ #

def clone_or_pull_repo(local_path, repo_url):
    if not os.path.exists(local_path):
        try:
            print(f"Kloner repo fra {repo_url} til {local_path}...")
            Repo.clone_from(repo_url, local_path)
            print("Kloning fullført.")
        except GitCommandError as e:
            print(f"Feil under kloning: {e}")
    else:
        try:
            print(f"Oppdaterer eksisterende repo i {local_path}...")
            repo = Repo(local_path)
            origin = repo.remotes.origin
            origin.pull()
            print("Oppdatering fullført.")
        except GitCommandError as e:
            print(f"Feil under oppdatering: {e}")

def add_and_commit(repo_path, files, commit_message):
    try:
        repo = Repo(repo_path)
        print(f"Legger til filer i {repo_path}...")
        repo.index.add(files)
        if repo.is_dirty():
            print("Lager commit...")
            repo.index.commit(commit_message)
            print("Commit fullført.")
        else:
            print("Ingen endringer å kommitere.")
    except GitCommandError as e:
        print(f"Feil under adding/committing: {e}")

def push_changes(repo_path):
    try:
        repo = Repo(repo_path)
        print(f"Pusher endringer fra {repo_path}...")
        origin = repo.remotes.origin
        origin.push()
        print("Push fullført.")
    except GitCommandError as e:
        print(f"Feil under pushing: {e}")

# ------------------------ Hovedprosess ------------------------ #

if __name__ == "__main__":
    # Håndtere hovedrepo
    clone_or_pull_repo(main_repo_local_path, authenticated_main_repo_url)
    add_and_commit(main_repo_local_path, main_repo_files, main_repo_commit_message)
    push_changes(main_repo_local_path)

    # Håndtere wiki-repo
    clone_or_pull_repo(wiki_repo_local_path, authenticated_wiki_repo_url)
    add_and_commit(wiki_repo_local_path, wiki_repo_files, wiki_repo_commit_message)
    push_changes(wiki_repo_local_path)

3. Forklaring av skriptet

Importerer nødvendige moduler
import os
from git import Repo, GitCommandError
from getpass import getpass
  • os: For håndtering av filstier og operativsystemfunksjoner.
  • git: Fra GitPython-biblioteket for å interagere med Git.
  • getpass: For sikker innhenting av GitHub PAT uten å vise det i klartekst.
Konfigurasjonsseksjon

Her definerer du alle nødvendige konfigurasjoner som lokale stier, GitHub-URLer, commit-meldinger og hvilke filer som skal legges til i hvert repo.

Autentisering

Skriptet ber om ditt GitHub PAT og legger det til i repo-URLene for autentisering.

print("Vennligst oppgi ditt GitHub Personal Access Token (PAT) med nødvendige rettigheter.")
github_pat = getpass("GitHub PAT: ")

authenticated_main_repo_url = main_repo_url.replace('https://', f'https://{github_pat}@')
authenticated_wiki_repo_url = wiki_repo_url.replace('https://', f'https://{github_pat}@')
Funksjoner
  • clone_or_pull_repo: Kloner repoet hvis det ikke finnes lokalt, ellers henter siste endringer.
  • add_and_commit: Legger til spesifiserte filer og lager en commit hvis det er endringer.
  • push_changes: Pusher lokale commits til fjernrepoet.
Hovedprosess

Skriptet kjører gjennom følgende steg for begge repositoriene:

  1. Kloner eller oppdaterer repoet
  2. Legger til og kommitterer endringer
  3. Pusher endringer til GitHub

4. Kjøring av skriptet

  1. Naviger til katalogen der skriptet ligger:

    cd path\to\your\script

  2. Kjør skriptet:

    python git_automation.py

  3. Når du blir bedt om det, skriv inn ditt GitHub Personal Access Token. Dette vil ikke vises i terminalen for sikkerhet.

5. Forberedelse av GitHub Personal Access Token (PAT)

  • Gå til GitHub Personal Access Tokens.
  • Klikk på "Generate new token".
  • Gi tokenet et beskrivende navn og sett passende utløpsdato.
  • Under "Scopes", sørg for at du gir tilstrekkelige rettigheter, vanligvis repo for full tilgang til repositorier.
  • Generer tokenet og kopier det et sikkert sted.

6. Håndtering av sensitiv informasjon

Siden PAT brukes for autentisering, er det viktig å ikke hardkode dette i skriptet. Ved å bruke getpass blir du bedt om å skrive det inn hver gang skriptet kjøres. Alternativt kan du lagre det som en miljøvariabel for å unngå å skrive det inn hver gang:

Eksempel med miljøvariabel:

import os

github_pat = os.environ.get('GITHUB_PAT')
if not github_pat:
    raise EnvironmentError("GITHUB_PAT miljøvariabelen er ikke satt.")

Sette miljøvariabelen i terminalen:

export GITHUB_PAT=your_personal_access_token

7. Feilhåndtering

Skriptet inkluderer grunnleggende feilhåndtering ved bruk av try-except blokker. Hvis det oppstår feil under kloning, kommitering eller pushing, vil disse bli fanget opp og skrevet ut i konsollen.

Oppsummering

Dette skriptet automatiserer hele prosessen med å synkronisere lokale endringer til GitHub for både hovedrepoet og wiki-repoet. Du kan utvide og tilpasse skriptet etter dine spesifikke behov, for eksempel ved å legge til logging til en fil, mer avansert feilhåndtering, eller integrere det i en større arbeidsflyt.

Merk: Sørg for at nettverkstilkoblingen din tillater tilgang til GitHub, og at firewall-innstillinger ikke blokkerer nødvendige porter. Hvis du bruker to-faktor autentisering på GitHub, er bruk av PAT nødvendig for autentisering via skript.

Trenger du ytterligere assistanse eller tilpasninger? Gi meg beskjed, så hjelper jeg gjerne videre!