Implementacja pliku zip / tar Git przed zatwierdzeniem i po pobraniu

Dec 22 2020

Regularnie używam narzędzia (Amesim), które pakuje swoje pliki w nieskompresowany plik tar. W przypadku wersjonowania zwykle nazwałem pliki jako file1_Rev01.ame i iterowałem ze zmianami. Działa to, gdy jestem jedynym użytkownikiem, ale ostatnio częściej udostępniam pliki / modele. Próba udostępnienia tych modeli jest bolesna, często zawierają one wyniki, które są dość duże (gbs danych) i śledzenie zmian między wersjami, jeśli jest to trudne, chyba że rygorystyczne dodawanie tekstu do modelu przy każdej zmianie. (Amesim to narzędzie takie jak Simulink.)

Czytałem o hakach git i filtrach git, ale nie jestem pewien, co zrobić, aby lepiej zarządzać wersjami archiwum tar.

Powiedzmy, że mam plik „my_file.tar” i składa się on z a.txt, b.model, c.data i d.results.

Ze strony aplikacji wystawiłbym plik „my_file.tar” i wysłał zatwierdzenie „Aktualizacje modelu”. Bez zmian w git, śledzi zmiany w pliku binarnym. To jest nieczytelne i zajmuje dużo miejsca. Jeśli uwzględniono wyniki, plik jest dość duży. Klonowanie repozytorium będzie trudne, jeśli wyniki są stale przechowywane.

W pierwszej próbie próbowałem użyć haczyków przed zatwierdzeniem i po zakupie.

Po zatwierdzeniu mój punkt przechwytujący przed zatwierdzeniem usuwa „my_file.tar” do katalogu „my_file_tar”. Usuwa plik * .results, który pochodzi z uruchomienia modelu. Nie ma potrzeby śledzenia tego i oszczędza znaczną przestrzeń (GB).

Kiedy wyciągnę model, po zakończeniu zakupu wyszukuje wszystkie foldery z _tar i taruje je, zmieniając ich nazwę na my_file.tar.

Teraz ogólnie to działa. Ale jak mam obsłużyć plik my_file.tar i nieskompresowany folder? Jeśli automatycznie usunę nieskompresowany folder po wyewidencjonowaniu, git stwierdza, że mam istotne zmiany do śledzenia. Czy za każdym razem muszę dodawać / usuwać folder do .gitignore? Ponadto plik tar nigdy nie pokaże, że jest śledzony, ponieważ usunąłem go w kodzie przed zatwierdzeniem. Co mogę zrobić, aby uporządkować ten proces? Jak mam sobie z tym radzić inaczej?

Bibliografia:

Pliki ZIP Git
Rozmażyć i wyczyścić
Dokumentacja Git Office
Zippey
XLTrail

W przypadku tego kodu plik .ame jest plikiem tar.

wstępne zatwierdzenie

#!/usr/bin/env python

import argparse
import os
import tarfile
import zipfile
import subprocess

def parse_args():
    pass

def log_file(log_item):
    cwd = os.getcwd()
    file = open("MyFile.txt", "a") # Open file in append mode
    file.write(log_item + '\n')
    return 1
    
def get_staged_ame_files():
    '''Request a list of staged files from git and return a list of *.ame files

    This function opens a subprocess with git, requests a list of names in the git staged list. It will return a list of strings.
    '''
    out = subprocess.Popen(['git', 'diff', '--staged', '--name-only'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    stdout, stderr = out.communicate()
    # Separate output by newlines
    # staged_files = stdout.split(b'\n') # split as bytes
    
    # filter for files with .ame 
    staged_files = stdout.decode('utf-8').split('\n') # split as strings
    # Create list of *just* amesim files
    staged_ame_files = []
    for entry in staged_files:
        if entry.endswith(".ame"):
            staged_ame_files.append(entry)
    
    if not staged_ame_files:
        return None
    else:
        return staged_ame_files

def extract_ame_files(file_list):
    folder_list = []
    for list_item in file_list:
        # If file exists, extract it. Else continue.
        if os.path.isfile(list_item):
            tar = tarfile.open(list_item, "r:")
            folder_name = list_item[0:-4] + "_ame"
            folder_list.append(folder_name)
            tar.extractall(path = folder_name)
            tar.close()
            log_file(folder_name)
        else:
            print("File {} does not exist.".format(list_item))
            
    return folder_list
    

def cleanup_ame_ignored_files(folder_list):
    '''Removes unecessary files from the folder. 
    
    '''
    for folder in folder_list:
        file_list = os.listdir(folder)
        for file in file_list:
            if item.endswith(".results"):
                os.remove(item)
            if item.endswith(".exe"):
                os.remove(item)
    return 1


def git_add_ame_folders(folders):
    # Add *_ame folders to git stage
    for folder in folders:
        out = subprocess.Popen(['git', 'add', folder + '/'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        stdout, stderr = out.communicate()
        # The -u will capture removed files?
        out = subprocess.Popen(['git', 'add', '-u', folder + '/'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        stdout, stderr = out.communicate()
        
        log_file(stdout.decode('utf-8'))
    return 1
    
def remove_ame_from_staging(file_list):
    # Loop through any staged ame files.
    for file in file_list:
        out = subprocess.Popen(['git', 'rm', '--cached', file], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        stdout, stderr = out.communicate()
    return 1

def main(args=None):
    # if file name is *.ame
    # extract *.ame as a tar of the same name into a folder of the same name + _ame
    # delete .results file
    # don't commit .ame file 
    
    # Search for files we want to process in the staged list
    # These will only be *.ame files.
    staged_ame_files = get_staged_ame_files()
    if not staged_ame_files:
        # If its empty, there's nothing to do. End the function.
        return 0
    
    # We're not empty, lets extract each one.
    folder_list = extract_ame_files(staged_ame_files)
    
    # Delete all .results files in each extracted folder  path
    
    # Stage all files in each folder path 
    git_add_ame_folders(folder_list)
    
    # Unstage the .ame file
    remove_ame_from_staging(staged_ame_files)
    return 1

if __name__ == "__main__":
    args = parse_args()
    main(args)

i po wymeldowaniu

#!/usr/bin/env python

import argparse
import os
import tarfile
import zipfile
import subprocess
import shutil
#from shutil import rmtree # Delete directory trees

def parse_args():
    pass

def log_file(log_item):
    cwd = os.getcwd()
    file = open("MyFile2.txt", "a") # Open file in append mode
    file.write(log_item + '\n')
    return 1
    
def compress_ame_files(folder_list):
    for list_item in folder_list:
        log_file("We're on item {}".format(list_item))
        file_name = list_item[0:-4] + ".ame"
        log_file("Tar file name {}".format(file_name))
        # Delete the file if it exists first.
        os.remove(file_name)
        with tarfile.open(file_name, "w:") as tar:
            tar.add(list_item, arcname=os.path.basename('../'))
    return 1
    

def cleanup_ame_ignored_files(folder_list):
    '''Removes unecessary files from the folder. 
    
    '''
    for folder in folder_list:
        file_list = os.listdir(folder)
        for file in file_list:
            if item.endswith(".results"):
                os.remove(item)
            if item.endswith(".exe"):
                os.remove(item)
    return 1


def git_add_ame_folders(folders):
    # Add *_ame folders to git stage
    for folder in folders:
        out = subprocess.Popen(['git', 'add', folder + '/'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        stdout, stderr = out.communicate()
        # The -u will capture removed files?
        out = subprocess.Popen(['git', 'add', '-u', folder + '/'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        stdout, stderr = out.communicate()
        
        #log_file(stdout.decode('utf-8'))
    return 1
    
def remove_ame_from_staging(file_list):
    # Loop through any staged ame files.
    for file in file_list:
        out = subprocess.Popen(['git', 'rm', '--cached', file], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        stdout, stderr = out.communicate()
    return 1

def fast_scandir(dirname):
    # https://stackoverflow.com/questions/973473/getting-a-list-of-all-subdirectories-in-the-current-directory?rq=1
    subfolders= [f.path for f in os.scandir(dirname) if f.is_dir()]
    for dirname in list(subfolders):
        subfolders.extend(fast_scandir(dirname))
    return subfolders

def delete_ame_folders(folders):
    for folder in folders:
        try:
            shutil.rmtree(folder)
        except OSError as e:
            print("Error: %s : %s" % (dir_path, e.strerror))
    return 1
    
#def main(args=None):
def main(lines):
    print("Post checkout running.")
    # find folders with the name _ame
    #log_file("We're running.")
    folder_list = []
    for folder in fast_scandir(os.getcwd()):
        if folder.endswith("_ame"):
            #log_file("Found folder {}.".format(folder))
            folder_list.append(os.path.join(os.getcwd(), folder))
    # tar each folder up and rename with .ame
    compress_ame_files(folder_list)
    
    # Delete the folders
    #delete_ame_folders(folder_list)

    return 1

if __name__ == "__main__":
    args = parse_args()
    main(args)

Odpowiedzi

3 Rukie Dec 31 2020 at 00:46

Kod w tej odpowiedzi implementuje filtr git w przeciwieństwie do punktu zaczepienia przed zatwierdzeniem i zaczepu po sprawdzeniu w pytaniu. Zaletą filtra jest to, że obsługuje on tylko jeden plik. Dodatkowe pliki nie muszą być oddzielnie śledzone i zatwierdzane / pobierane. Raczej, podobnie jak Zippey, tworzy nieskompresowany strumień danych i usuwa niepotrzebne pliki po drodze.

Uwaga: Nie używaj instrukcji print, ponieważ miesza to ze strumieniem stdout w filtrze git. To była bolesna lekcja.

Uwaga: zakończenia CRLF i LF stanowią problem. Podczas dekodowania z pierwszego git pull musiałem wyczyścić zakończenia linii, ponieważ Sourcetree / Git przekonwertował na format Windows.

Dyskusja rozwiązania:

Ponieważ plik, z którym pracuję, jest nieskompresowanym plikiem tar, rozwiązanie Zippey nie miało bezpośredniego zastosowania. Zippey jest przeznaczony tylko dla plików zip. Zamiast tego zaimplementowałem technikę Zippeya z plikami tar.

Po zatwierdzeniu stosowany jest czysty filtr, który „koduje” plik tar. Funkcja kodowania pobiera każdy plik i rejestruje długość danych, nieprzetworzoną długość danych, jeśli są binarne, tryb przechowywania (ascii lub binarny) oraz nazwę pliku.

Skrypt kodujący przesyła strumieniowo wszystkie pliki do jednego pliku o tej samej nazwie w nieskompresowanym formacie. Pliki binarne są zakodowane w base64 w jednej linii, dzięki czemu różnice są łatwiejsze do odczytania.

Podczas kodowania unika się plików o określonych rozszerzeniach (takich jak pliki wyników).

Podczas ściągania filtr smug dekompresuje plik, wykorzystując cztery metatagi do odczytywania informacji. Każdy plik jest przetwarzany i dodawany do obiektu pliku tar, a na końcu wypisywany jest plik tar.

Podobnie jak Zippey, ze świeżego klonu repozytorium pobierany jest zakodowany plik, który jest nieczytelny dla mojego narzędzia. Dlatego Clone Setup szuka moich plików * .ame, które są zakodowane i dekoduje je, a także ustawia odpowiednie filtry git.

Ponieważ pracuję zarówno na maszynach z systemem Linux, jak i Windows, a git ma tendencję do dodawania CRLF przy pobieraniu, skrypty upewniają się, że usuną CRLF przed kodowaniem i usuwają CRLF z zakodowanych plików przed dekodowaniem.