Come posso fare in modo che il mio codice C stampi automaticamente l'hash della sua versione Git?

C'è un modo semplice per scrivere codice C che possa accedere all'hash della sua versione Git?

Ho scritto software in C per raccogliere dati scientifici in un ambiente di laboratorio. Il mio codice registra i dati che raccoglie in un file .yaml per un'analisi successiva. I miei esperimenti cambiano di giorno in giorno e spesso devo modificare il codice. Per tenere traccia delle revisioni, utilizzo un repository git.

Vorrei poter includere l'hash di revisione Git come commento nei miei file di dati .yaml. In questo modo, potrei guardare il file .yaml e sapere esattamente quale codice è stato utilizzato per generare i dati mostrati in quel file. C'è un modo semplice per farlo automaticamente?

Nel mio programma, tengo il numero di versione di git e la data della build in un file separato, chiamato version.c, che assomiglia a questo:

#include "version.h"
const char * build_date = "2009-11-10 11:09";
const char * build_git_sha = "6b54ea36e92d4907aba8b3fade7f2d58a921b6cd";

C'è anche un file di intestazione, che assomiglia a questo:

#ifndef VERSION_H
#define VERSION_H
extern const char * build_date; /* 2009-11-10 11:09 */
extern const char * build_git_sha; /* 6b54ea36e92d4907aba8b3fade7f2d58a921b6cd */
#endif /* VERSION_H */

Sia il file di intestazione che il file C sono generati da uno script Perl che assomiglia a questo:

my $git_sha = `git rev-parse HEAD`;
$git_sha =~ s/\s+//g;
# This contains all the build variables.
my %build;
$build{date} = make_date_time ();
$build{git_sha} = $git_sha;

hash_to_c_file ("version.c", \%build, "build_");

Qui hash_to_c_filefa tutto il lavoro di creazione version.ce di version.he make_date_timerende una stringa come mostrato.

Nel programma principale ho una routine

#include "version.h"

// The name of this program.
const char * program_name = "magikruiser";
// The version of this program.
const char * version = "0.010";

/* Print an ID stamp for the program. */

static void _program_id_stamp (FILE * output)
{
    fprintf (output, "%s / %s / %s / %s\n",
             program_name, version,
             build_date, build_git_sha);
}

Non sono molto informato su git, quindi gradirei commenti se esiste un modo migliore per farlo.

Se stai usando una build basata sul make, puoi metterla nel Makefile:

GIT_VERSION := "$(shell git describe --abbrev=4 --dirty --always --tags)"

(Vedi man git descrivere per cosa fanno gli interruttori)

quindi aggiungilo alle tue CFLAG:

-DVERSION=\"$(GIT_VERSION)\"

Quindi puoi semplicemente fare riferimento alla versione direttamente nel programma come se fosse un #define:

printf("Version: %s\n", VERSION);

Per impostazione predefinita, questo stampa solo un id git commit abbreviato, ma opzionalmente puoi taggare particolari rilasci con qualcosa come:

git tag -a v1.1 -m "Release v1.1"

quindi stamperà:

Version: v1.1-2-g766d

il che significa, 2 commit dopo la v1.1, con un ID commit git che inizia con "766d".

Se ci sono modifiche non salvate nel tuo albero, verrà aggiunto "-dirty".

Non esiste una scansione delle dipendenze, quindi devi fare un esplicito make cleanper forzare l'aggiornamento della versione. Questo può essere risolto comunque.

I vantaggi sono che è semplice e non richiede dipendenze di compilazione aggiuntive come perl o awk. Ho usato questo approccio con GNU automake e con build Android NDK.

Ho finito per usare qualcosa di molto simile alla risposta di @ Kinopiko, ma ho usato awk invece di perl. Questo è utile se sei bloccato su macchine Windows su cui è installato awk per natura di mingw, ma non perl. Ecco come funziona.

Il mio makefile contiene una riga che richiama git, date e awk per creare un file ac:

$(MyLibs)/version.c: FORCE 
    $(GIT) rev-parse HEAD | awk ' BEGIN {print "#include \"version.h\""} {print "const char * build_git_sha = \"" $$0"\";"} END {}' > $(MyLibs)/version.c
    date | awk 'BEGIN {} {print "const char * build_git_time = \""$$0"\";"} END {} ' >> $(MyLibs)/version.c 

Ogni volta che compilo il mio codice, il comando awk genera un file version.c simile a questo:

/* version.c */
#include "version.h"
const char * build_git_sha = "ac5bffc90f0034df9e091a7b3aa12d150df26a0e";
const char * build_git_time = "Thu Dec  3 18:03:58 EST 2009";

Ho un file version.h statico simile a questo:

/*version.h*/
#ifndef VERSION_H_
#define VERSION_H_

extern const char * build_git_time;
extern const char * build_git_sha;


#endif /* VERSION_H_ */

Il resto del mio codice ora può accedere al tempo di compilazione e all'hash git semplicemente includendo l'intestazione version.h. Per concludere, dico a git di ignorare version.c aggiungendo una riga al mio file .gitignore. In questo modo git non mi dà costantemente conflitti di fusione. Spero che sia di aiuto!

Il tuo programma può eseguire la shell git describein fase di esecuzione o come parte del processo di compilazione.

Ci sono due cose che puoi fare:

• Puoi fare in modo che Git incorpori alcune informazioni sulla versione nel file per te.

  Il modo più semplice è usare l' ident attributo , che significa mettere (per esempio)

  *.yaml    ident
  

  in .gitattributesfile e $Id$nel luogo appropriato. Sarebbe automaticamente espanso all'identificatore SHA-1 del contenuto del file (blob id): questa NON è la versione del file o l'ultimo commit.

  Git supporta la parola chiave $ Id $ in questo modo per evitare di toccare i file che non sono stati modificati durante il cambio di ramo, il riavvolgimento del ramo ecc. Se vuoi veramente che Git metta l'identificatore o la descrizione del commit (versione) nel file, puoi (ab) usare filterattributo, utilizzando il filtro clean / smudge per espandere alcune parole chiave (ad esempio $ Revision $) al momento del checkout e ripulirlo per il commit.

• Puoi fare in modo che il processo di compilazione lo faccia per te, come fanno il kernel Linux o lo stesso Git.

  Dai un'occhiata allo script GIT-VERSION-GEN e al suo utilizzo in Git Makefile , o ad esempio come questo Makefile incorpora le informazioni sulla versione durante la generazione / configurazione del gitweb/gitweb.cgifile.

  GIT-VERSION-GEN utilizza git description per generare la descrizione della versione. Deve funzionare meglio che tu tagghi (usando tag firmati / annotati) i rilasci / le pietre miliari del tuo progetto.

Quando ho bisogno di farlo, utilizzo un tag , come RELEASE_1_23. Posso decidere quale tag può essere senza conoscere SHA-1. Mi impegno e poi taggo. Puoi memorizzare quel tag nel tuo programma come preferisci.

Sulla base della risposta di njd27, sto usando la versione a con scansione delle dipendenze, in combinazione con un file version.h con valori predefiniti per quando il codice è costruito in un modo diverso. Tutti i file che includono version.h verranno ricostruiti.

Include anche la data di revisione come definizione separata.

# Get git commit version and date
GIT_VERSION := $(shell git --no-pager describe --tags --always --dirty)
GIT_DATE := $(firstword $(shell git --no-pager show --date=short --format="%ad" --name-only))

# recompile version.h dependants when GIT_VERSION changes, uses temporary file version~
.PHONY: force
version~: force
    @echo '$(GIT_VERSION) $(GIT_DATE)' | cmp -s - $@ || echo '$(GIT_VERSION) $(GIT_DATE)' > $@
version.h: version~
    @touch $@
    @echo Git version $(GIT_VERSION) $(GIT_DATE)

Uso anche git per tenere traccia delle modifiche nel mio codice scientifico. Non volevo usare un programma esterno perché limita la portabilità del codice (se qualcuno volesse apportare modifiche su MSVS per esempio).

la mia soluzione è stata quella di utilizzare solo il ramo principale per i calcoli e fargli generare il tempo di compilazione utilizzando le macro del preprocessore __DATE__e __TIME__. in questo modo posso controllarlo con git log e vedere quale versione sto usando. rif: http://gcc.gnu.org/onlinedocs/cpp/Standard-Predefined-Macros.html

un altro modo elegante per risolvere il problema è includere git log nell'eseguibile. crea un file oggetto da git log e includilo nel codice. questa volta l'unico programma esterno che usi è objcopy ma c'è meno codice. rif: http://www.linuxjournal.com/content/embedding-file-executable-aka-hello-world-version-5967 e Incorpora dati in un programma C ++

Quello che devi fare è generare un file di intestazione (ad esempio usando echo dalla riga cmd) qualcosa del genere:

#define GIT_HASH \
"098709a0b098c098d0e"

Per generarlo usa qualcosa del genere:

echo #define GIT_HASH \ > file.h
echo " > file.h
echo git status <whatever cmd to get the hash> > file.h
echo " > file.h

Potrebbe essere necessario giocare un po 'con le virgolette e le barre rovesciate per farlo compilare, ma hai capito.

Questa è una soluzione per il progetto CMake che funziona per Windows e Linux, senza la necessità di installare altri programmi (es. Linguaggi di script).

L'hash git viene scritto in un file .h da uno script, che è uno script bash durante la compilazione su Linux o uno script batch di Windows durante la compilazione su Windows, e una clausola if in CMakeLists.txt seleziona lo script corrispondente alla piattaforma il codice è compilato.

I seguenti 2 script vengono salvati nella stessa directory di CMakeLists.txt:

get_git_hash.sh:

#!/bin/bash
hash=$(git describe --dirty --always --tags)
echo "#ifndef GITHASH_H" > include/my_project/githash.h
echo "#define GITHASH_H" >> include/my_project/githash.h
echo "const std::string kGitHash = \"$hash\";" >> include/my_project/githash.h
echo "#endif // GITHASH_H" >> include/my_project/githash.h

get_git_hash.cmd:

@echo off
FOR /F "tokens=* USEBACKQ" %%F IN (`git describe --dirty --always --tags`) DO (
SET var=%%F
)
ECHO #ifndef GITHASH_H > include/my_project/githash.h
ECHO #define GITHASH_H >> include/my_project/githash.h
ECHO const std::string kGitHash = "%var%"; >> include/my_project/githash.h
ECHO #endif // GITHASH_H >> include/my_project/githash.h

In CMakeLists.txt vengono aggiunte le seguenti righe

if(WIN32)
  add_custom_target(
    run ALL
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
    COMMAND get_git_hash.cmd
  )
else()
  add_custom_target(
    run ALL
    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
    COMMAND ./get_git_hash.sh
  )
endif()

include_directories(include)

Nel codice il file generato è incluso #include <my_project/githash.h>e l'hash git può essere stampato sul terminale con std::cout << "Software version: " << kGitHash << std::endl;o scritto in un file yaml (o qualsiasi) in modo simile.

Ancora un'altra variazione basata su Makefile e shell

GIT_COMMIT_FILE=git_commit_filename.h

$(GIT_COMMIT_FILE): phony
    $(eval GIT_COMMIT_SHA=$(shell git describe --abbrev=6 --always 2>/dev/null || echo 'Error'))
    @echo SHA=$(GIT_COMMIT_SHA)
    echo -n "static const char *GIT_COMMIT_SHA = \"$(GIT_COMMIT_SHA)\";" > $(GIT_COMMIT_FILE)

Il file git_commit_filename.h finirà con una singola riga contenente static const char * GIT_COMMIT_SHA = "";

Da https://gist.github.com/larytet/898ec8814dd6b3ceee65532a9916d406

Puoi vedere come l'ho fatto per memcached nel commit originale .

Fondamentalmente, tagga di tanto in tanto e assicurati che l'oggetto che consegni provenga make disto sia simile.