Git zip / tar file implementasi pra-komit dan pasca-checkout hooks

Dec 22 2020

Saya secara teratur menggunakan alat (Amesim) yang mengemas file-nya dalam file tar yang tidak terkompresi. Untuk pembuatan versi, saya biasanya menamai file sebagai file1_Rev01.ame, dan mengulanginya dengan perubahan. Ini berfungsi ketika saya satu-satunya pengguna, tetapi akhir-akhir ini saya berbagi file / model lebih teratur. Sulit untuk mencoba membagikan model ini, karena sering kali menyertakan hasil yang cukup besar (gbs data), dan melacak perubahan antar versi jika sulit, kecuali jika menambahkan teks secara ketat dalam model pada setiap perubahan. (Amesim adalah alat seperti Simulink.)

Saya telah membaca tentang git hooks dan git filter, tetapi saya tidak yakin apa yang harus dilakukan untuk mengelola versi tarball dengan lebih baik.

Katakanlah saya memiliki file "my_file.tar" dan terdiri dari a.txt, b.model, c.data, dan d.results.

Dari sisi aplikasi, saya akan menampilkan "my_file.tar" dan mengirimkan "Pembaruan ke model". Tanpa perubahan pada git, ini melacak perubahan ke file biner. Ini tidak dapat dibaca dan menghabiskan banyak ruang. Jika hasilnya disertakan, file tersebut cukup besar. Mengkloning repo akan menjadi tantangan jika hasilnya terus disimpan.

Untuk usaha pertama saya, saya mencoba menggunakan hook pra-komit dan pasca-checkout.

Saat commit, hook pra-commit saya untars "my_file.tar" ke dalam direktori "my_file_tar." Ini menghapus file * .results yang berasal dari menjalankan model. Ini tidak perlu untuk melacak ini dan menghemat ruang yang signifikan (gbs).

Ketika saya menarik modelnya, post-checkout akan mencari folder apa pun dengan _tar dan tar, mengganti namanya menjadi my_file.tar.

Sekarang umumnya ini berhasil. Tapi, bagaimana cara menangani folder my_file.tar dan tidak terkompresi? Jika saya menghapus otomatis folder yang tidak dikompresi setelah check-out, git menyatakan bahwa saya memiliki perubahan signifikan untuk dilacak. Apakah saya perlu menambah / menghapus folder ke .gitignore setiap saat? Selain itu, file tar tidak akan pernah menunjukkan bahwa itu dilacak, karena saya menghapusnya dalam kode pra-komit. Apa yang dapat saya lakukan untuk membersihkan proses ini? Bagaimana saya harus menangani ini secara berbeda?

Referensi:

File Zip Git
Noda dan Bersih
Dokumen Git Office
Zippey
XLTrail

Untuk kode ini, .ame adalah file tar.

pra-komit

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

dan setelah pembayaran

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

Jawaban

3 Rukie Dec 31 2020 at 00:46

Kode dalam jawaban ini mengimplementasikan filter git sebagai lawan dari hook pra-komit dan hook pasca-pembayaran dalam pertanyaan. Keuntungan dari filter adalah hanya memanipulasi satu file. File tambahan tidak perlu dilacak dan dilakukan / ditarik secara terpisah. Sebaliknya, seperti Zippey, ini membuat aliran data yang tidak terkompresi dan menghapus file yang tidak perlu di sepanjang jalan.

Catatan: Jangan gunakan pernyataan cetak, karena akan mengacaukan aliran stdout di filter git. Ini adalah pelajaran yang menyakitkan.

Catatan: Akhiran CRLF dan LF merupakan masalah. Saat melakukan decoding dari git pull pertama, saya harus membersihkan ujung baris karena Sourcetree / Git dikonversi ke format windows.

Diskusi solusi:

Karena file yang saya kerjakan adalah tar yang tidak terkompresi, solusi Zippey tidak berlaku secara langsung. Zippey hanya untuk file zip. Saya menerapkan teknik Zippey dengan file tar sebagai gantinya.

Saat komit, filer bersih diterapkan yang 'menyandikan' file tar. Fungsi encode mengambil setiap file dan mencatat panjang data, panjang data mentah jika biner, mode penyimpanan (ascii atau biner), dan nama file.

Skrip encode mengalirkan semua file ke dalam satu file dengan nama yang sama dalam format yang tidak terkompresi. File biner adalah base64 yang dikodekan menjadi satu baris, membuat diff lebih mudah dibaca.

Selama encode, file dengan ekstensi tertentu dihindari (seperti file hasil).

Saat ditarik, filter noda mendekompresi file dengan memanfaatkan empat tag meta untuk membaca informasi. Setiap file diproses dan ditambahkan ke objek file tar, dan pada akhirnya file tar ditulis.

Seperti Zippey, pada klon baru dari repositori, file yang disandikan ditarik yang tidak dapat dibaca oleh alat saya. Jadi Clone Setup mencari file * .ame saya yang dikodekan dan mendekodekannya, serta menyiapkan filter git yang sesuai.

Saat saya bekerja pada mesin linux dan windows, dan git memiliki kecenderungan untuk menambahkan CRLF saat checkout, skrip memastikan untuk menghapus CRLF sebelum encoding, dan menghapus CRLF dari file yang disandikan sebelum decoding.