Git zip / tar de implementação de arquivo Git pré-commit e ganchos pós-checkout

Dec 22 2020

Eu uso regularmente uma ferramenta (Amesim) que empacota seus arquivos em um arquivo tar descompactado. Para controle de versão, normalmente denominei os arquivos como file1_Rev01.ame e fiz a iteração com as alterações. Isso funciona quando sou o único usuário, mas ultimamente estou compartilhando arquivos / modelos com mais regularidade. Tentar compartilhar esses modelos é doloroso, eles geralmente incluem resultados que são muito grandes (gbs de dados) e manter o controle das alterações entre as versões, se for difícil, a menos que seja adicionado rigorosamente texto dentro do modelo em cada alteração. (Amesim é uma ferramenta como o Simulink.)

Tenho lido sobre git hooks e filtros git, mas não tenho certeza do que fazer para gerenciar melhor o versionamento de um tarball.

Digamos que eu tenha o arquivo "my_file.tar" e ele consista em a.txt, b.model, c.data e d.results.

Do lado do aplicativo, eu testaria "my_file.tar" e enviaria um commit "Updates to model". Sem alterações no git, ele rastreia as alterações em um arquivo binário. Isso não é legível e consome espaço significativo. Se os resultados forem incluídos, o arquivo é muito grande. A clonagem do repo será um desafio se os resultados forem armazenados continuamente.

Para minha primeira tentativa, tentei usar ganchos pré-commit e pós-checkout.

No commit, meu gancho pré-commit descompacta "my_file.tar" em um diretório "my_file_tar." Ele remove o arquivo * .results que vem da execução do modelo. É desnecessário rastrear isso e economiza espaço significativo (gbs).

Quando eu puxo o modelo, o pós-checkout irá procurar por quaisquer pastas com _tar e tar, renomeando-as para my_file.tar.

Agora, geralmente isso funciona. Mas, como devo lidar com meu_arquivo.tar e a pasta descompactada? Se eu excluir automaticamente a pasta descompactada após o check-out, git afirma que tenho mudanças significativas para rastrear. Preciso adicionar / remover a pasta para .gitignore todas as vezes? Além disso, o arquivo tar nunca mostrará que é rastreado, porque eu o removi do código de pré-confirmação. O que posso fazer para limpar esse processo? Como devo lidar com isso de forma diferente?

Referências:

Arquivos Git Zip
Manchar e limpar
Documentos do Git Office
Zippey
XLTrail

Para este código, o .ame é um arquivo tar.

pré-compromisso

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

e pós-checkout

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

Respostas

3 Rukie Dec 31 2020 at 00:46

O código nesta resposta implementa um filtro git em oposição a um gancho pré-commit e um gancho pós-checkout na questão. A vantagem do filtro é que ele manipula apenas um arquivo. Arquivos adicionais não precisam ser rastreados e confirmados / puxados separadamente. Em vez disso, como o Zippey, ele cria um fluxo de dados descompactado e remove arquivos desnecessários ao longo do caminho.

Nota: Não use instruções de impressão, pois isso bagunça o fluxo stdout no filtro git. Esta foi uma lição dolorosa.

Nota: as terminações CRLF e LF são um problema. Ao decodificar do primeiro git pull, tive que limpar as terminações de linha porque Sourcetree / Git convertido para o formato windows.

Discussão da solução:

Como o arquivo com o qual estou trabalhando é um tar descompactado, a solução Zippey não se aplicava diretamente. Zippey é apenas para arquivos zip. Implementei a técnica do Zippey com arquivos tar.

Na confirmação, um arquivador limpo é aplicado que 'codifica' o arquivo tar. A função encode pega cada arquivo e registra o comprimento dos dados, o comprimento bruto dos dados se binários, o modo de armazenamento (ascii ou binário) e o nome do arquivo.

O script de codificação transmite todos os arquivos em um único arquivo com o mesmo nome em um formato descompactado. Os arquivos binários são codificados em base64 em uma única linha, tornando os diffs mais fáceis de ler.

Durante a codificação, arquivos de extensões específicas são evitados (como arquivos de resultados).

No pull, um filtro de manchas descompacta o arquivo utilizando as quatro metatags para ler as informações. Cada arquivo é processado e adicionado a um objeto de arquivo tar e, no final, um arquivo tar é gravado.

Como o Zippey, em um clone novo do repositório, um arquivo codificado é puxado e ilegível para minha ferramenta. Portanto, Clone Setup procura meus arquivos * .ame que estão codificados e os decodifica, bem como configura os filtros git apropriados.

Como eu trabalho em máquinas Linux e Windows, e o git tende a adicionar CRLF no checkout, os scripts certificam-se de remover o CRLF antes de codificar e remover o CRLF dos arquivos codificados antes da decodificação.