Excluyendo autor de la lista de revisores en gerrit

Question

Estoy configurando el control de acceso para mi compañía en gerrit y en nuestro proceso interno actual tiene un cruce entre revisores y codificadores (tienden a ser el mismo grupo de personas) . También queremos solo requerir 1 revisor para revisar el código y enviarlo si se ve bien.

Con la configuración predeterminada, cualquier usuario con la opción +2: Looks good to me, approved puede revisar su propio código.

¿Hay alguna manera de evitar que el autor revise su propio código, pero aún así permitirles revisar completamente el código de los demás? No he podido encontrar ningún tipo de autor excluido en la configuración del grupo de control de acceso ni en la configuración de permisos.

Answer 1

Esto es trabajo para mí, pero es un truco rápido:

• permite un número configurable de +1 a cuenta como 2 para su presentación manual
• opcionalmente someter automáticamente con suficientes votos +1
• recuentos opcionalmente -1 votos como contrarrestar +1 votos para los fines de la cuenta
• ignora opcionalmente del cargador propia 1 (es posible que prefiera un cheque contra el autor, que yo no he hecho)

He modificado mi respuesta anterior, por lo que no supone que esté utilizando un servidor mysql.

Es posible que desee mover el archivo de registro en algún lugar estará sujeto a cualquier rotación de registro normal, tal vez en ../logs/comment-added.log.

He tratado de sacar los bits configurables a primer plano. Llame a este archivo comment-hook y póngalo en $ gerrit_root/hooks, chmod it 755 o similar. Configure un usuario de robot en el grupo admin para que el enganche pueda usar la interfaz sql (y comente +2 en cosas con suficientes +1).

#!/usr/bin/perl 
# 
# comment-hook for a +2 approval from a simple quorum of +1 votes. 
# 
# Licence: Public domain. All risk is yours; if it breaks, you get to keep both pieces. 

$QUORUM = 2; # Total number of +1 votes causing a +2 
$PLEBIANS = 'abs(value) < 2'; # or 'value = 1' to ignore -1 unvotes 
$AUTO_SUBMIT_ON_QUORACY = '--submit'; # or '' for none 
$AND_IGNORE_UPLOADER = 'and uploader_account_id != account_id'; # or '' to let uploaders votes count 

$GERRIT_SSH_PORT = 29418; 
$SSH_PRIVATE_KEY = '/home/gerrit2/.ssh/id_rsa'; 
$SSH_USER_IN_ADMIN_GROUP = 'devuser'; 

# Hopefully you shouldn't need to venture past here. 

$SSH = "ssh -i $SSH_PRIVATE_KEY -p $GERRIT_SSH_PORT $SSH_USER_IN_ADMIN_GROUP\@localhost"; 

$LOG = "/home/gerrit2/hooks/log.comment-added"; 
open LOG, ">>$LOG" or die; 

sub count_of_relevant_votes { 
     # Total selected code review votes for this commit 
     my $relevance = shift; 
     $query = " 
       select sum(value) from patch_sets, patch_set_approvals 
       where patch_sets.change_id = patch_set_approvals.change_id 
       and patch_sets.patch_set_id = patch_set_approvals.patch_set_id 
       and revision = '$V{commit}' 
       and category_id = 'CRVW' 
       and $relevance 
       $AND_IGNORE_UPLOADER 
       ;"; 
     $command = "$SSH \"gerrit gsql -c \\\"$query\\\"\""; 
     #print LOG "FOR... $command\n"; 
     @lines = qx($command); 
     chomp @lines; 
     #print LOG "GOT... ", join("//", @lines), "\n"; 
     # 0=headers 1=separators 2=data 3=count and timing. 
     return $lines[2]; 
} 

sub response { 
     my $review = shift; 
     return "$SSH 'gerrit review --project=\"$V{project}\" $review $V{commit}'"; 
} 

# ###################### 
# Parse options 

$key=''; 
while ($_ = shift @ARGV) { 
     if (/^--(.*)/) { 
       $key = $1; 
     } 
     else { 
       $V{$key} .= " " if exists $V{$key}; 
       $V{$key} .= $_; 
     } 
} 
#print LOG join("\n", map { "$_ = '$V{$_}'" } keys %V), "\n"; 

# ###################### 
# Ignore my own comments 

$GATEKEEPER="::GATEKEEPER::"; 
if ($V{comment} =~ /$GATEKEEPER/) { 
     # print LOG localtime() . "$V{commit}: Ignore $GATEKEEPER comments\n"; 
     exit 0; 
} 

# ###################### 
# Forbear to analyse anything already +2'd 

$submittable = count_of_relevant_votes('value = 2'); 
if ($submittable > 0) { 
     # print LOG "$V{commit} Already +2'd by someone or something.\n"; 
     exit 0; 
} 

# ###################### 
# Look for a consensus amongst qualified voters. 

$plebicite = count_of_relevant_votes($PLEBIANS); 

#if ($V{comment} =~ /TEST:(\d)/) { 
#  $plebicite=$1; 
#} 

# ###################### 
# If there's a quorum, approve and submit. 

if ($plebicite >= $QUORUM) { 
     $and_submitting = ($AUTO_SUBMIT_ON_QUORACY ? " and submitting" : ""); 
     $review = " --code-review=+2 --message=\"$GATEKEEPER approving$and_submitting due to $plebicite total eligible votes\" $AUTO_SUBMIT_ON_QUORACY"; 
} 
else { 
     $review = " --code-review=0 --message=\"$GATEKEEPER ignoring $plebicite total eligible votes\""; 
     # print LOG "$V{commit}: $review\n"; 

     exit 0; 
} 

$response = response($review); 

print LOG "RUNNING: $response\n"; 
$output = qx($response 2>&1 ); 
if ($output =~ /\S/) { 
     print LOG "$V{commit}: output from commenting: $output"; 
     $response = response(" --message=\"During \Q$review\E: \Q$output\E\""); 
     print LOG "WARNING: $response\n"; 
     $output = qx($response 2>&1 ); 
     print LOG "ERROR: $output\n"; 
} 

exit 0; 

Answer 2

Gerrit le permite configurar el prólogo "enviar" reglas que definen cuándo un cambio es submittable.

El documentation incluye varios ejemplos, incluido uno que evita que el autor apruebe su propio cambio.

Answer 3

The Gerrit Cookbook Example 8 no impide estrictamente que el Autor revise su propio cambio, pero requerirá que otra persona lo haga +2 antes de poder enviarlo.

Answer 4

Acabo de escribir este filtro de prólogo para nuestra instalación de Gerrit. Lo hice como un submit_filter en el proyecto principal porque quería que se aplicara a todos los proyectos en nuestro sistema.

%filter to require all projects to have a code-reviewer other than the owner 
submit_filter(In, Out) :- 
    %unpack the submit rule into a list of code reviews 
    In =.. [submit | Ls], 
    %add the non-owner code review requiremet 
    reject_self_review(Ls, R), 
    %pack the list back up and return it (kinda) 
    Out =.. [submit | R]. 

reject_self_review(S1, S2) :- 
    %set O to be the change owner 
    gerrit:change_owner(O), 
    %find a +2 code review, if it exists, and set R to be the reviewer 
    gerrit:commit_label(label('Code-Review', 2), R), 
    %if there is a +2 review from someone other than the owner, then the filter has no work to do, assign S2 to S1 
    R \= O, !, 
    %the cut (!) predicate prevents further rules from being consulted 
    S2 = S1. 
reject_self_review(S1, S2) :- 
    %set O to be the change owner 
    gerrit:change_owner(O), 
    find a +2 code review, if it exists, and set R to be the reviewer 
    gerrit:commit_label(label('Code-Review', 2), R), 
    R = O, !, 
    %if there isn't a +2 from someone else (above rule), and there is a +2 from the owner, reject with a self-reviewed label 
    S2 = [label('Self-Reviewed', reject(O))|S1]. 
%if the above two rules didn't make it to the ! predicate, there aren't any +2s so let the default rules through unfiltered 
reject_self_review(S1, S1). 

Los beneficios (IMO) de esta regla sobre rule #8 from the cookbook son:

• La etiqueta Self-Reviewed sólo se muestra cuando el cambio está siendo bloqueado, en lugar de añadir una etiqueta Non-Author-Code-Review-cada cambio
• mediante el uso de reject(O) la regla hace que la etiqueta Self-Reviewed a ser, literalmente, una bandera roja
• Como submit_filter en lugar de un submit_rule, esta regla se instala en un proyecto principal y se aplica a todos los sub-proyectos

Por favor, tenga en cuenta: Esta regla es de autoría para evitar que el Owner de auto-revisión de un cambio, mientras que el ejemplo del libro de cocina se compara con el Author. Dependiendo de su flujo de trabajo, puede reemplazar los predicados 2 gerrit:change_owner(O) por gerrit:commit_author(O) o gerrit:commit_committer(O)

Answer 5

Puede hacerlo desde la GUI en la pestaña de acceso. Vaya a la sección/refs/heads/-> agregue el grupo 'cambiar propietario' en la sección Código de revisión-revisión -> elija -1 .. + 1

Esto hará que el propietario del cambio tenga privilegios para dar -1 a +1