push commits para o repositório git (gitolite) bagunça as permissões de arquivo (não há mais acesso ao trac)

Question

já foi postado aqui então fique à vontade para responder lá.

toda vez que eu faço commit / push de alguma coisa no servidor git, as permissões do arquivo são alteradas (todos os arquivos adicionados / editados no repositório não têm acesso de leitura e execução para o grupo). assim, o trac não pode acessar o repositório.

eu preciso alterar as permissões da pasta de maneira diferente?

chmod u=rwx,g=rx,o= -R /home/git/repositories

ou preciso configurar o gitolite de alguma forma para gravar arquivos com permissões diferentes ???

respeita klemens

    

Answer 1

configurar o umask / default umask não tem efeito porque o gitolite tem sua própria configuração.

em ~ / .gitolite.rc

$REPO_UMASK = 0027;

defina como quiser:)

    

Answer 2

O Git apenas rastreia nomes de arquivos e os dados desses arquivos. Não rastreia metadados do sistema de arquivos (ownreship, permissions, ...).

Um umask pode ser uma solução eficaz se você quiser que todos os arquivos tenham as mesmas permissões.

Eu estava rastreando arquivos do sistema em vários servidores com o Git por 3 anos agora. Eu precisava de uma maneira de rastrear as alterações nas permissões, bem como os dados. Eu escrevi um script Ruby para capturar permissões / propriedade de arquivo e colocá-lo em um arquivo. Este arquivo agora pode ser rastreado pelo git. Sempre que preciso restaurar esses metadados, eu uso outro script Ruby que lê o arquivo e restaura as permissões.

Por 3 anos eu uso esse script regularmente e eles não me decepcionaram.

Aqui estão eles:

Script: save-fs-permissions

#!/usr/bin/ruby

RM   = "/bin/rm"
SORT = "/usr/bin/sort"
TMP  = "/tmp/save_fs_permissions_#{Time.now.to_i}_#{rand * 899 + 100}"

require 'find'

IGNORE = [".git"]

def numeric2human(m)
  return sprintf("%c%c%c%c%c%c%c%c%c",
            (m & 0400 == 0 ? ?- : ?r),
            (m & 0200 == 0 ? ?- : ?w),
            (m & 0100 == 0 ? (m & 04000 == 0 ? ?- : ?S) :
                             (m & 04000 == 0 ? ?x : ?s)),
            (m & 0040 == 0 ? ?- : ?r),
            (m & 0020 == 0 ? ?- : ?w),
            (m & 0010 == 0 ? (m & 02000 == 0 ? ?- : ?S) :
                             (m & 02000 == 0 ? ?x : ?s)),
            (m & 0004 == 0 ? ?- : ?r),
            (m & 0002 == 0 ? ?- : ?w),
            (m & 0001 == 0 ? (m & 01000 == 0 ? ?- : ?T) :
                             (m & 01000 == 0 ? ?x : ?t)))
end


File.open(TMP, "w") do |permissions_file|

  # TODO: Instead of the current dir, find the .git dir, which could be
  #       the same or outside of the current dir
  Find.find(".") do |path|

    next if IGNORE.collect {|ig| !!(path[2..-1] =~ /\A#{ig}/)}.include? true
    next if File.symlink?(path)

    stat = File.lstat(path)
    type = stat.ftype[0..0].sub('f', '-') # Single character for the file type
                                          # But a "-" istead of "f"
    owner_id = stat.uid
    group_id = stat.gid
    rules    = "#{type}#{numeric2human(stat.mode)}" 

    permissions_file.puts "#{path} #{rules} #{owner_id} #{group_id}"
  end
end

'#{SORT} #{TMP} > ./fs-permissions'
'#{RM}   #{TMP}'

• O script acima deve ser executado na raiz do seu diretório de trabalho do Git (GIT_WORK_TREE). As permissões fs, o proprietário e os IDs do grupo serão armazenados no arquivo fs-permissions na raiz do diretório GIT_WORK_TREE.

Script: restore-fs-permissions

#!/usr/bin/ruby


# Restore from...
FROM  = "./fs-permissions"

MKDIR = "/bin/mkdir"
CHMOD = "/bin/chmod"
CHOWN = "/bin/chown"
known_content_missing = false


def numeric2human(m)
  return sprintf("%c%c%c%c%c%c%c%c%c",
            (m & 0400 == 0 ? ?- : ?r),
            (m & 0200 == 0 ? ?- : ?w),
            (m & 0100 == 0 ? (m & 04000 == 0 ? ?- : ?S) :
                             (m & 04000 == 0 ? ?x : ?s)),
            (m & 0040 == 0 ? ?- : ?r),
            (m & 0020 == 0 ? ?- : ?w),
            (m & 0010 == 0 ? (m & 02000 == 0 ? ?- : ?S) :
                             (m & 02000 == 0 ? ?x : ?s)),
            (m & 0004 == 0 ? ?- : ?r),
            (m & 0002 == 0 ? ?- : ?w),
            (m & 0001 == 0 ? (m & 01000 == 0 ? ?- : ?T) :
                             (m & 01000 == 0 ? ?x : ?t)))
end

def human2chmod(mode)
  raise unless mode =~ /([r-][w-][xtsTS-])([r-][w-][xtsTS-])([r-][w-][xtsTS-])/
  triple = [$1, $2, $3]
  u,g,o = triple.collect do |i|
    i.sub('s', 'sx').sub('t', 'tx').downcase.gsub('-', '')
  end

  return "u=#{u},g=#{g},o=#{o}" 
end



File.open(FROM).each do |permissions|
  raise unless permissions =~ /\A(([^ ]*? )+)([^ ]+) ([^ ]+) ([^ ]+)\Z/
  path, rules, owner_id, group_id = $1, $3, $4, $5
  path = path.strip
  owner_id = owner_id.to_i
  group_id = group_id.to_i

  if !File.exists?(path) and !File.symlink?(path)
    if rules =~ /\Ad/
      STDERR.puts "Restoring a missing directory: #{path}"
      STDERR.puts "Probably it was an empty directory. Git goes not track them."
      '#{MKDIR} -p '#{path}'' # Creating the any parents
    else
      known_content_missing = true
      STDERR.puts "ERROR: Permission is listed but the file is missing: #{path}"
      next
    end
  end

  s = File.lstat(path)
  t = s.ftype[0..0].sub('f', '-') # Single character for the file type
                                  # But a "-" istead of "f"

  # Actual, but not neccesarely Desired 
  actual_rules    = "#{t}#{numeric2human(s.mode)}"
  actual_owner_id = s.uid 
  actual_group_id = s.gid 

  unless [actual_rules, actual_owner_id, actual_group_id] ==
    [rules, owner_id, group_id]

    chmod_argument = human2chmod(rules)

    # Debug
    #p chmod_argument
    #p s.mode

    ## Verbose
    puts path
    puts "Wrong: #{[actual_rules, actual_owner_id, actual_group_id].inspect}"
    puts "Fixed: #{[rules, owner_id, group_id].inspect}"
    puts

    '#{CHOWN} #{owner_id}:#{group_id} '#{path}''
    '#{CHMOD} #{chmod_argument} '#{path}''

    #puts
  end

end

if known_content_missing
  STDERR.puts "-" * 80 
  STDERR.puts "Some files that are listed in #{FROM.inspect} are missing in " +
              "the current directory."
  STDERR.puts
  STDERR.puts "Is #{FROM.inspect} outdated?"
  STDERR.puts "(Try retrograding the current directory to an earlier version)"
  STDERR.puts
  STDERR.puts "Or is the current directory incomplete?"
  STDERR.puts "(Try to recover the current directory)"
  STDERR.puts "-" * 80 
end