oneline - git push tag

¿Evita que las personas presionen un commit de git con un nombre de autor diferente?

Question

En git, le corresponde a cada usuario especificar el autor correcto en su archivo de configuración de git local. Cuando acceden a un repositorio centralizado, los mensajes de confirmación en el repositorio tendrán los nombres de autor que usaron al comprometerse con su propio repositorio.

¿Hay alguna forma de hacer cumplir que se utiliza un conjunto de autores conocidos para confirmaciones? El repositorio "central" será accesible a través de ssh.

Sé que esto se complica por el hecho de que algunas personas pueden estar presionando compromisos que fueron hechos por otros. Por supuesto, también debería permitir que las personas en las que confía ingresen a sus repositorios, pero sería genial si hubiera una forma de evitar el error del usuario aquí.

¿Hay alguna solución simple a este problema en git?

Answer 1

Lo que podría hacer es crear varias cuentas de usuario diferentes, ponerlas todas en el mismo grupo y otorgarle a ese grupo acceso de escritura al repositorio. Entonces debería poder escribir un simple gancho entrante que verifique si el usuario que ejecuta el guión es el mismo que el usuario en el conjunto de cambios.

Nunca lo hice porque confío en los muchachos que verifican el código en mis repositorios, pero si hay una manera, esa es probablemente la explicada anteriormente.

Answer 2

git no fue diseñado inicialmente para funcionar como svn con un gran repositorio central. ¿Tal vez puede sacar de la gente según sea necesario, y se niegan a tirar si tienen su autor configurado incorrectamente?

Answer 3

Usamos lo siguiente para evitar confirmaciones accidentales de autor desconocido (por ejemplo, al realizar una confirmación rápida desde el servidor de un cliente o algo así). Debería colocarse en .git / hooks / pre-receive y hacerse ejecutable.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import subprocess
from itertools import islice, izip
import sys

old, new, branch = sys.stdin.read().split()

authors = {
    "John Doe": "[email protected]"
}

proc = subprocess.Popen(["git", "rev-list", "--pretty=format:%an%n%ae%n", "%s..%s" % (old, new)], stdout=subprocess.PIPE)
data = [line.strip() for line in proc.stdout.readlines() if line.strip()]

def print_error(commit, author, email, message):
    print "*" * 80
    print "ERROR: Unknown Author!"
    print "-" * 80
    proc = subprocess.Popen(["git", "rev-list", "--max-count=1", "--pretty=short", commit], stdout=subprocess.PIPE)
    print proc.stdout.read().strip()
    print "*" * 80
    raise SystemExit(1)

for commit, author, email in izip(islice(data, 0, None, 3), islice(data, 1, None, 3), islice(data, 2, None, 3)):
    _, commit_hash = commit.split()
    if not author in authors:
        print_error(commit_hash, author, email, "Unknown Author")
    elif authors[author] != email:
        print_error(commit_hash, author, email, "Unknown Email")

Answer 4

Use el gancho PRE-RECEIVE (vea githooks (5) para más detalles). Ahí tienes sha viejo y sha nuevo por cada ref actualizada. Y puede enumerar fácilmente los cambios y verificar que tengan el autor adecuado (git rev-list --pretty = format: "% an% ae% n" oldsha..newsha).

Aquí hay un script de ejemplo:

#!/bin/bash
#
# This pre-receive hooks checks that all new commit objects
# have authors and emails with matching entries in the files
# valid-emails.txt and valid-names.txt respectively.
#
# The valid-{emails,names}.txt files should contain one pattern per
# line, e.g:
#
# ^.*@0x63.nu$
# ^[email protected]$
#
# To just ensure names are just letters the following pattern
# could be used in valid-names.txt:
# ^[a-zA-Z ]*$
#


NOREV=0000000000000000000000000000000000000000

while read oldsha newsha refname ; do
    # deleting is always safe
    if [[ $newsha == $NOREV ]]; then
    continue
    fi

    # make log argument be "..$newsha" when creating new branch
    if [[ $oldsha == $NOREV ]]; then
    revs=$newsha
    else
    revs=$oldsha..$newsha
    fi
    echo $revs
    git log --pretty=format:"%h %ae %an%n" $revs | while read sha email name; do
    if [[ ! $sha ]]; then
        continue
    fi
        grep -q -f valid-emails.txt <<<"$email" || {
            echo "Email address ''$email'' in commit $sha not registred when updating $refname"
            exit 1
        }
        grep -q -f valid-names.txt <<<"$name" || {
            echo "Name ''$name'' in commit $sha not registred when updating $refname"
            exit 1
        }
    done
done

Answer 5

Usamos Gitlab, por lo que tiene sentido que validemos a los autores contra los miembros del grupo Gitlab.

La siguiente secuencia de comandos (basada en la respuesta de @ dsvensson) que debe instalarse como gancho pre-recepción hace exactamente eso:

from __future__ import print_function
from __future__ import unicode_literals

import sys
import os
import subprocess
import urllib2
import json
import contextlib
import codecs
from itertools import islice, izip

GITLAB_SERVER = ''https://localhost''
GITLAB_TOKEN = ''SECRET''
GITLAB_GROUP = 4
EMAIL_DOMAIN = ''example.com''

def main():
    commits = get_commits_from_push()
    authors = get_gitlab_group_members()
    for commit, author, email in commits:
        if author not in authors:
            die(''Unknown author'', author, commit, authors)
        if email != authors[author]:
            die(''Unknown email'', email, commit, authors)

def get_commits_from_push():
    old, new, branch = sys.stdin.read().split()
    rev_format = ''--pretty=format:%an%n%ae''
    command = [''git'', ''rev-list'', rev_format, ''{0}..{1}''.format(old, new)]
    # branch delete, let it through
    if new == ''0000000000000000000000000000000000000000'':
        sys.exit(0)
    # new branch
    if old == ''0000000000000000000000000000000000000000'':
        command = [''git'', ''rev-list'', rev_format, new, ''--not'', ''--branches=*'']
    output = subprocess.check_output(command)
    commits = [line.strip() for line in unicode(output, ''utf-8'').split(''/n'') if line.strip()]
    return izip(islice(commits, 0, None, 3),
            islice(commits, 1, None, 3),
            islice(commits, 2, None, 3))

def get_gitlab_group_members():
    url = ''{0}/api/v3/groups/{1}/members''.format(GITLAB_SERVER, GITLAB_GROUP)
    headers = {''PRIVATE-TOKEN'': GITLAB_TOKEN}
    request = urllib2.Request(url, None, headers)
    with contextlib.closing(urllib2.urlopen(request)) as response:
        members = json.load(response)
    return dict((member[''name''], ''{}@{}''.format(member[''username''], EMAIL_DOMAIN))
        for member in members)

def die(reason, invalid_value, commit, authors):
    message = []
    message.append(''*'' * 80)
    message.append("ERROR: {0} ''{1}'' in {2}"
            .format(reason, invalid_value, commit))
    message.append(''-'' * 80)
    message.append(''Allowed authors and emails:'')
    print(''/n''.join(message), file=sys.stderr)
    for name, email in authors.items():
        print(u"  ''{0} <{1}>''".format(name, email), file=sys.stderr)
    sys.exit(1)

def set_locale(stream):
    return codecs.getwriter(''utf-8'')(stream)

if __name__ == ''__main__'':
    # avoid Unicode errors in output
    sys.stdout = set_locale(sys.stdout)
    sys.stderr = set_locale(sys.stderr)

    # you may want to skip HTTPS certificate validation:
    #  import ssl
    #  if hasattr(ssl, ''_create_unverified_context''):
    #    ssl._create_default_https_context = ssl._create_unverified_context

    main()

Consulte los documentos de ganchos Git personalizados de GitLab para obtener instrucciones de instalación.

Solo get_gitlab_group_members() es específico de Gitlab, otra lógica se aplica a cualquier get_gitlab_group_members() previo a la recepción (incluido el manejo de eliminaciones y creaciones de sucursales).

La secuencia de comandos ahora está disponible en GitHub , por favor siéntase libre de enviar solicitudes de extracción para cualquier error / mejora.

Answer 6

Si desea administrar los derechos de un repositorio de git en Internet, le sugiero que mire a Gitosis en lugar de preparar el suyo propio. La identidad es provista por pares de claves privadas / públicas.

Léeme proxeneta aquí , también.