Narzędzie do Zarządzania Repozytoriami Git
Efektywne zarządzanie wieloma repozytoriami Git w jednym miejscu
Kluczowe Wnioski
- Centralizacja: Narzędzie pozwala na zarządzanie wszystkimi repozytoriami Git z jednego interfejsu.
- Łatwość Użycia: Prosty proces instalacji i uruchamiania, dostępny dla każdego dewelopera.
- Automatyzacja: Integracja z Jenkins umożliwia automatyczne generowanie instrukcji wdrożeniowych.
Wprowadzenie
Wzorując się na potrzebach zespołu deweloperskiego, przedstawiamy narzędzie umożliwiające efektywne zarządzanie (podgląd i modyfikację plików) w wielu repozytoriach Git przechowywanych w jednym folderze na dysku. Narzędzie jest łatwe do uruchomienia przez wszystkich członków zespołu i jest przechowywane w repozytorium DevTools.
Funkcjonalności Narzędzia
1. Przeglądanie Repozytoriów
Narzędzie umożliwia listowanie wszystkich repozytoriów Git znajdujących się w określonym folderze bazowym. Deweloperzy mogą szybko zobaczyć status każdego repozytorium, takie jak ostatni commit, obecny branch, czy obecne zmiany lokalne.
2. Status Repozytorium
Funkcja git status jest dostępna dla każdego repozytorium, co pozwala na bieżące monitorowanie zmian, konfliktów oraz niezatwierdzonych commitów.
3. Edycja Plików
Umożliwia otwieranie i edytowanie plików bezpośrednio z poziomu narzędzia, korzystając z domyślnego edytora skonfigurowanego w systemie (IntelliJ IDEA lub VS Code).
4. Synchronizacja z Git
Narzędzie wspiera podstawowe operacje Git, takie jak pull, push oraz commit, umożliwiając zarządzanie repozytoriami bezpośrednio z interfejsu narzędzia.
5. Automatyczne Generowanie Instrukcji Wdrożeniowych
Integracja z Jenkins pozwala na automatyczne przetwarzanie plików konfiguracyjnych i generowanie instrukcji wdrożeniowych na podstawie wersji i zmian w repozytoriach.
Architektura Narzędzia
1. Technologie
- Python: Główny język programowania, ze względu na swoją prostotę i szerokie wsparcie dla operacji na Git.
- Click: Biblioteka do tworzenia interfejsów wiersza poleceń.
- GitPython: Biblioteka umożliwiająca interakcję z Git bezpośrednio z poziomu Pythona.
- Jenkins: Automatyzacja procesów CI/CD poprzez integrację z narzędziem.
2. Struktura Projektu
Repozytorium DevTools będzie miało następującą strukturę:
devtools/
├── README.md
├── git_manager.py
├── requirements.txt
├── config.json
├── scripts/
│ ├── setup.sh
│ └── run.sh
└── .gitignore
3. Skrypt Narzędzia (git_manager.py)
a) Kod Aplikacji
import os
import subprocess
import json
import click
BASE_DIR = os.path.expanduser("~/repositories") # Zmień na właściwą ścieżkę
CONFIG_PATH = "config.json"
def load_config():
if os.path.exists(CONFIG_PATH):
with open(CONFIG_PATH, 'r') as config_file:
return json.load(config_file)
return {"editor": "code"} # Domyślnie VS Code
def list_repositories(base_dir):
"""Wylistuj wszystkie repozytoria w folderze bazowym."""
repos = [f for f in os.listdir(base_dir) if os.path.isdir(os.path.join(base_dir, f))]
return repos
def get_git_status(repo_path):
"""Zwróć wynik git status dla repozytorium."""
result = subprocess.run(["git", "-C", repo_path, "status", "-s"], capture_output=True, text=True)
return result.stdout.strip()
def open_file_in_editor(file_path):
"""Otwórz plik w edytorze skonfigurowanym w config.json."""
config = load_config()
editor = config.get("editor", "code")
subprocess.run([editor, file_path])
@click.group()
def cli():
pass
@cli.command()
def list_repos():
"""List all Git repositories."""
repos = list_repositories(BASE_DIR)
click.echo("\nRepozytoria:")
for idx, repo in enumerate(repos, start=1):
click.echo(f"{idx}. {repo}")
@cli.command()
@click.argument('repo_name')
def status(repo_name):
"""Show git status of a repository."""
repo_path = os.path.join(BASE_DIR, repo_name)
if os.path.exists(repo_path):
status_output = get_git_status(repo_path)
click.echo(f"\nStatus repozytorium {repo_name}:\n{status_output}")
else:
click.echo("Podane repozytorium nie istnieje!")
@cli.command()
@click.argument('file_path')
def edit(file_path):
"""Edit a file in the repository."""
if os.path.exists(file_path):
open_file_in_editor(file_path)
else:
click.echo("Podany plik nie istnieje!")
@cli.command()
@click.argument('repo_name')
@click.argument('commit_message')
def commit(repo_name, commit_message):
"""Commit changes in a repository."""
repo_path = os.path.join(BASE_DIR, repo_name)
if os.path.exists(repo_path):
subprocess.run(["git", "-C", repo_path, "add", "."])
subprocess.run(["git", "-C", repo_path, "commit", "-m", commit_message])
click.echo(f"Zmiany zatwierdzone w repozytorium {repo_name}.")
else:
click.echo("Podane repozytorium nie istnieje!")
@cli.command()
@click.argument('repo_name')
def pull(repo_name):
"""Pull latest changes in a repository."""
repo_path = os.path.join(BASE_DIR, repo_name)
if os.path.exists(repo_path):
subprocess.run(["git", "-C", repo_path, "pull"])
click.echo(f"Pobrano najnowsze zmiany w repozytorium {repo_name}.")
else:
click.echo("Podane repozytorium nie istnieje!")
@cli.command()
@click.argument('repo_name')
def push(repo_name):
"""Push local commits to remote in a repository."""
repo_path = os.path.join(BASE_DIR, repo_name)
if os.path.exists(repo_path):
subprocess.run(["git", "-C", repo_path, "push"])
click.echo(f"Wysłano zatwierdzone zmiany w repozytorium {repo_name}.")
else:
click.echo("Podane repozytorium nie istnieje!")
if __name__ == "__main__":
cli()
b) Konfiguracja Domyślnego Edytora
Plik config.json pozwala na ustawienie domyślnego edytora:
{
"editor": "code" // Możliwe opcje: "code" (VS Code), "idea" (IntelliJ IDEA)
}
4. Skrypty Ułatwiające Uruchamianie
a) setup.sh (Instalacja Zależności)
#!/bin/bash
echo "Instalowanie zależności..."
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
echo "Instalacja zakończona. Uruchom <code>run.sh, aby włączyć narzędzie."
b) run.sh (Uruchamianie Aplikacji)
#!/bin/bash
source venv/bin/activate
python3 git_manager.py
deactivate
Instrukcja Użytkowania
1. Instalacja
- Klonuj repozytorium DevTools:
git clone YOUR_DEVTOOLS_REPOSITORY cd DevTools - Uruchom skrypt instalacyjny:
./scripts/setup.sh
2. Uruchomienie Narzędzia
- Uruchom narzędzie za pomocą skryptu:
./scripts/run.sh - Po uruchomieniu, interfejs wiersza poleceń umożliwi wykonywanie różnych operacji, takich jak:
-
list_repos- Wyświetlenie listy repozytoriów. -
status <repo_name>- Sprawdzenie statusu konkretnego repozytorium. -
edit <file_path>- Edycja wybranego pliku. -
commit <repo_name> <commit_message>- Zatwierdzenie zmian w repozytorium. -
pull <repo_name>- Pobranie najnowszych zmian z zdalnego repozytorium. -
push <repo_name>- Wysłanie zatwierdzonych zmian do zdalnego repozytorium.
-
3. Integracja z Jenkins
Dzięki strukturze narzędzia, możliwa jest integracja z Jenkins w celu automatycznego generowania instrukcji wdrożeniowych na podstawie plików konfiguracyjnych. Skrypt Groovy może odczytywać zmiany z deployment-changes.yaml i generować odpowiednie instrukcje.
Zalety Narzędzia
- Prostota: Minimalna liczba zależności, łatwa instalacja i konfiguracja.
- Elastyczność: Obsługa różnych edytorów oraz możliwość rozszerzania funkcjonalności.
- Automatyzacja: Integracja z narzędziami CI/CD, co usprawnia proces wdrożeń.
- Kompatybilność: Działa na różnych systemach operacyjnych, korzystając z Pythona.
- Wersjonowanie: Ułatwia śledzenie zmian w wielu repozytoriach jednocześnie.
Podsumowanie
Narzędzie do zarządzania repozytoriami Git przedstawione powyżej oferuje kompleksowe rozwiązanie dla zespołów pracujących z wieloma repozytoriami w jednym folderze. Dzięki prostocie instalacji, elastyczności oraz integracji z Jenkins, narzędzie znacząco usprawnia procesy deweloperskie i wdrożeniowe, zapewniając jednocześnie łatwość użytkowania dla każdego członka zespołu.
Referencje
Last updated January 18, 2025