git index.lock O arquivo existe quando tento confirmar, mas não consigo excluir o arquivo

Quando eu faço 'git commit', recebo o seguinte:

fatal: Unable to create 'project_path/.git/index.lock': File exists.

No entanto, quando o faço ls project_path/.git/index.lock, está dizendo que o arquivo não existe. Alguma idéia do que devo fazer? Também notei que o project_path / .git é de propriedade do root, não tenho certeza se isso tem algo a ver com o problema que estou encontrando.

A versão git é 1.7.5.4

edit: Parece que o problema provavelmente foi outro processo que eu estava executando, que estava gravando (sem o meu conhecimento) no diretório do projeto. Reiniciei minha máquina e não tive problemas em confirmar.

Esta pode ser uma resposta antiga, mas espero que seja mais útil nos próximos que precisam desta solução.

No linux / unix / gitbash / cygwin, tente

rm -f .git/index.lock

No prompt de comando do Windows, tente:

del .git\index.lock

Para Windows:

• Em um console do PowerShell aberto como administrador, tente

> rm -Force ./.git/index.lock

• Se isso não funcionar, você deve matar todos os processos do git.exe

> taskkill /F /IM git.exe
SUCCESS: The process "git.exe" with PID 20448 has been terminated.
SUCCESS: The process "git.exe" with PID 11312 has been terminated.
SUCCESS: The process "git.exe" with PID 23868 has been terminated.
SUCCESS: The process "git.exe" with PID 27496 has been terminated.
SUCCESS: The process "git.exe" with PID 33480 has been terminated.
SUCCESS: The process "git.exe" with PID 28036 has been terminated.
> rm -Force ./.git/index.lock

Em uma plataforma Windows executando o Visual Studio 2015 RC (v4.6.00057) em combinação com o SourceTree (v1.6.14.0), esse erro também ocorrerá.

Solução: Supondo que você queira usar a árvore de origem como gerenciador de código-fonte, basta desabilitar o provedor de controle de origem no Visual Studio da seguinte maneira:

1. Vá para: Ferramentas> Opções> Controle de Origem
2. Selecione Plug-in de controle da fonte atual como: Nenhum

1. verifique se o git ainda está em execução (ps -ef | grep git)
2. caso contrário, remova o arquivo bloqueado
3. se sim, mate o processo git primeiro.

experimentar

rm -f ./.git/index.lock

se você não tiver nenhum outro processo git em execução, exclua o arquivo index.lock do respectivo projeto.

Só tive esse problema ... Gitbox estava com defeito. Talvez você tenha uma GUI em execução que estava causando problemas.

Isso está acontecendo quando você cancela a retirada da origem no meio.

portanto, o que você pode fazer é excluir manualmente o arquivo index.lock do diretório .git.

rm -f ./.git/index.lock

cd no diretório do projeto e execute este comando.

1. Feche todas as janelas que estão afetando esse arquivo .git / index.lock
2. Exclua o arquivo .git / index.lock.
3. Abra o editor de linha de comando e o CD no local dos seus arquivos git.

(Se o arquivo for criado, simplesmente a partir do cd nesse local, o problema será o seu editor. Feche o editor. Não use este editor novamente para esta tarefa. Abra um tipo diferente de editor - Windows Power Shell ou simplesmente cmd. Agora você pode usar os comandos git para continuar)

Provavelmente (aconteceu comigo), o comando ls está dizendo que não existe porque o usuário atual não tem permissão para acessar esse diretório ou arquivo.

Remova a trava e verifique se está executando o git com o usuário certo , a fim de evitar problemas de permissão.

Se você estiver em uma caixa GNU / Linux com o comando sudo :

sudo rm caminho_projeto / .git / index.lock

del .git\index.lock trabalhou para mim.

Eu estava enfrentando esse problema durante o checkout de uma nova ramificação da ramificação mestre.

O checkout ocorreu facilmente após a exclusão do index.lockarquivo.

Às vezes, o Git cria um arquivo de bloqueio associado ao seu repositório enquanto você faz alterações ou, provavelmente, quando você está usando submódulos. A mensagem de erro mostra o caminho do arquivo de bloqueio. Correção: basta ir manualmente para o caminho no terminal e excluir o arquivo de bloqueio por $ rm index.lock

Isso deve ajudar.

Eu tive esse problema com o SourceTree ao mudar de ramificação clicando duas vezes nele. O problema não é muito comum e Atlassian sabe disso mas eles decidiram não consertá-lo.

Felizmente, existe uma solução. Em vez de clicar duas vezes na ramificação que você deseja alternar, clique com o botão direito do mouse e escolha "Checkout [nome da ramificação]". Deve ter sucesso agora.

Eu me deparei com o mesmo cenário. Eu ainda não fiz nenhuma alteração no meu código local. Acabei de editar um arquivo e revertê-lo. Eu simplesmente apaguei o arquivo abaixo na pasta .git oculta. Funcionou!

caminho do projeto / .git / index.lock

A menos que você realmente pretenda que o root seja o proprietário do seu repositório, parece que você acidentalmente executou um comando Git como root (talvez até o clone / init inicial). Se você pretendia fazer isso, precisará executar todos os comandos Git no repositório como root. Caso contrário, corra sudo chown your-user[:your-group] -R .gitpara se apropriar dele e veja se as coisas funcionam.

Vários clientes git que trabalham no mesmo repositório local competem por esse bloqueio. Cada cliente deve esperar até que o bloqueio seja liberado pela outra parte para ser um bom cidadão. Para nós, o SourceTree ou o MSVS parecem estar fazendo alguma manutenção em segundo plano enquanto estávamos executando grandes scripts de confirmação.

Talvez o próprio 'git' deva suportar um argumento '--retriesWhenLocked 5' para suportar novas tentativas.ou mesmo o padrão quando executado manualmente.

Aqui está um wrapper do PowerShell em torno do git chamado "gitr" que tenta novamente até que o index.lock desapareça, usando 5 tentativas padrão, 3 segundos entre cada uma. Ele nunca remove o index.lock, supondo que o usuário deva intervir. Foi extraído de um script de confirmação maior. Ele só tem testes mínimos com argumentos simples.

• Copie o script para C: \ bin e adicione C: \ bin a $ PATH.
• Do PS1> gitr --help
• No DOS%> powershell gitr --help

gitr.ps1

    #requires -version 2
    <#
    .SYNOPSIS
        gitr
    .DESCRIPTION
        Run "git" as an external process with retry and capturing stdout stderr.
    .NOTES  
      2017/05/16 crokusek: Initial version
    #>

    #---------------------------------------------------------[Initializations]--------------------------------------------------------

    #Set Error Action 
    $ErrorActionPreference = "Stop";

    #----------------------------------------------------------[Declarations]----------------------------------------------------------

    $scriptDir = Split-Path $script:MyInvocation.MyCommand.Path
    #Set-Location $scriptDir

    ## Disabled logging
    # Log File 
    # $logFile = "$($scriptDir)\getr.log"
    # If (Test-Path $logFile) { Clear-Content $logFile }

    #-----------------------------------------------------------[Functions]------------------------------------------------------------

    Function Log([string]$msg, [bool]$echo = $true)
    {
        $timestamp = "$(get-date -Format 'yyyy/MM/dd HH:mm:ss'):  " 
        $fullmsg = $msg -replace '(?ms)^', $timestamp  # the (?ms) enables multiline mode

        ## Disabled Logging 
        # Add-content $LogFile -value $fullmsg

        if ($echo)
        {
            Write-Host $msg
        }
    }

    Function ExecSimple([string]$command, [bool]$echo=$true, [bool]$stopOnNonZeroExitCode=$true)
    {
        $command, $args = $command -split " "
        return Exec $command $args $echo $stopOnNonZeroExitCode
    }

    Function Exec([string]$exe, [string[]]$arguments, [bool]$echo=$true, [bool]$stopOnNonZeroExitCode=$true)
    {   
        # Passing $args (list) as a single parameter is the most flexible, it supports spaces and double quotes

        $orgErrorActionPreference = $ErrorActionPreference 
        Try
        {           
            $error.clear()  # this apparently catches all the stderr pipe lines

            if ($false -and $exe -eq 'git')  # todo make this a generic flag
            {
                $exe = "$($exe) 2>&1"
            }

            $output = ""

            $argflattened = $arguments -join ' '
            Log "`n% $($exe) $($arguments)`n"

            # This way some advantages over Invoke-Expressions or Start-Process for some cases:
            #      - merges stdout/stderr line by line properly, 
            #      - echoes the output live as it is streamed to the current window,
            #      - waits for completion
            #      - works when calling both console and windows executables.
            #       
            $ErrorActionPreference = "Continue"  # required in order to catch more than 1 stderr line in the exception

            if ($echo)
            {
                # Using "cmd.exe" allows the stderr -> stdout redirection to work properly.  Otherwise the 2>&1 runs after PS for 
                # some reason.  When a command such as "git" writes to stderr, powershell was terminating on the first stderr 
                # line (and stops capturing additional lines).
                #
                # but unfortuantely cmd has some bizarre de-quoting rules that weren't working for all cases. 
                #& cmd /c "`"" $exe $arguments "`"" | Tee-Object -variable output | Write-Host | out-null           

                # This is simplest but has some issues with stderr/stdout (stderr caught as exception below)
                #
                & $exe $arguments 2>&1 | tee -variable output | Write-Host | out-null 
            }
            else
            {           
                & $exe $arguments 2>&1 | tee -variable output | out-null 
            }

            $output = $output -join "`r`n"                  

            if ($stopOnNonZeroExitCode -and !$LASTEXITCODE -eq 0)
            {           
                throw [System.Exception] "Exit code ($($LASTEXITCODE)) was non-zero. Output:`n$($output)"
            }       
        }
        catch [System.Management.Automation.RemoteException]
        {
            $output = $_.Exception.ToString().Replace("System.Management.Automation.RemoteException:", "").Trim()

            if ($output.Contains("fatal")) 
            {
                throw 
            }

            if ($echo)
            {
                Log $output
            }
        }
        finally
        {
            $ErrorActionPreference = $orgErrorActionPreference;
        }

        if (-not $output -eq "")
        {
            Log $output $false  # don't echo to screen as the pipe above did    
        }

        return $output
    }

    Function ExecWithRetry([string]$exe, [string[]]$arguments, [bool]$echo=$true, [bool]$stopOnNonZeroExitCode=$true, 
                          [int]$maxRetries = 5, [int]$msDelay = 3000, [AllowNull()][string]$exceptionMustContain = $null)
    {
        for ($i = 0; $i -lt $maxRetries; $i++)
        {
            try
            {
                Exec $exe $arguments $echo $stopOnNonZeroExitCode
                return
            }
            catch
            {
                if (-not [string]::IsNullOrEmpty($exceptionMustContain) -and $_.Exception.ToString().Contains($exceptionMustContain))
                {
                    Log "Last Error from $($exe) is retryable ($($i + 1) of $($maxRetries))" $true
                    Start-Sleep -Milliseconds ($msDelay);
                    continue
                }

                throw
            }
        }

        throw [System.Exception] "Unable to successfully exec '$($exe)' within $($maxRetries) attempts."
    }

    Function GitWithRetry([string[]]$arguments, [bool]$echo=$true)
    {
        ExecWithRetry "git" $arguments $echo -exceptionMustContain "Another git process seems to be running"
    }

#-----------------------------------------------------------[Main]------------------------------------------------------------

function Main([string[]]$arguments)
{   
    GitWithRetry @($arguments)
}


#-------------------------------------- Startup ------------------------------------
try 
{
    Main $args
    Exit 0
}    
catch
{
    #Log "*** A fatal error occured: $($_.Exception)"
    #Read-Host -Prompt "`nA fatal error occurred, press enter to close."    
    exit 1
}

Eu também tenho essa pergunta no Windows 10.

quando tento del ./.git/index.lock, ele me dissecannot remove 'index.lock': Device or resource busy

Eu finalmente entendi o motivo:

o computador possui dois processos para usar o git:

• git bash
• cmder

então eu uso o cmder.exe para git commitque ocorra erros.

então a solução é usar git bashou Terminar o git bashcmder.exe

Eu tive exatamente o mesmo erro, mas o problema não era o arquivo de bloqueio. Em vez disso, o problema era que eu havia copiado o conteúdo de outro repositório git para esse repositório, incluindo a pasta invisível .git. Portanto, o SourceTree estava confuso sobre em qual repositório eu queria colocar os arquivos (existe uma incompatibilidade entre o repositório que o SourceTree pensava que eu estava e aquele em que o conteúdo do meu diretório .git incorporado dizia que eu deveria estar).

Eu tive esse problema com o TortoiseGit com o Cygwin no Windows. Não consegui excluir remove ./.git/index.lock, mesmo com privilégios administrativos, tentei o Cygwin e o prompt de comando, pois dizia que o arquivo estava sendo usado por outro processo.

Eu descobri que tinha 2 instâncias do TortoiseProc.exe em execução. Matei um deles e fechei todas as janelas do Windows Explorer e, em seguida, consegui excluir o arquivo. Não sei se matar uma instância do TortoiseProc.exe foi a solução ou o fechamento do Windows Explorer.

A solução para mim foi excluir o arquivo .index e permitir que o Git reconstruísse outro.

Eu não tinha um arquivo inex.lock para excluir, mas o que funcionou para mim foi remover a verificação Somente Leitura da janela Atributos da caixa de diálogo Propriedades da pasta.

Criei um arquivo index.lock vazio, excluí-o usando o comando windows

Iniciando o git 2.8.4 (junho de 2016) , isso não deveria mais acontecer.

Consulte o problema 755, que também deve aliviar o problema ( commit 2db0641 ):

Verifique se os identificadores de arquivo temporário não são herdados pelos processos filho

Impedir que processos filho herdem um identificador para index.lock.

No meu aplicativo sourceTree, não consigo confirmar ou alternar para nenhum outro commit / brach. Esse tempo mostra erro como

fatal: Não foi possível criar blá blá blá ..

Eu simplesmente resolvo isso indo para a pasta .git (no projeto Explorer Dir). E exclua o índice ----- [tipo de arquivo: LOCK file] .Agora recebo de volta todo o acesso no sourceTree ..

verifique se o arquivo de bloqueio de índice .. suponha que você não obtenha o tipo de arquivo, altere as configurações de visualização de arquivos no computador. Nota: a pasta .git normalmente é um tipo de pasta oculta.

O que isso fez para mim foi:

git rebase --abort e reinicie o rebase.

Como Andrew mencionou, eu também estava usando o PHPStorm quando isso aconteceu. Mas não precisava fechá-lo.

Primeiro você precisa navegar para a pasta específica do seu projeto. Como se o nome do seu projeto fosse Firstproject, primeiro vá para o diretório do projeto. Em seguida, digite cd .git e depois navegue para a pasta git, digite del index.lock Depois a exclusão do arquivo index.lock..Você poderá confirmar e enviar como antes

No meu caso, eram janelas, não fechadas completamente.

Windows está hibernado, recusou-se a montar

As chances são de que o Windows realmente esteja hibernado. O Windows faz isso automaticamente quando você pede para desligar normalmente. O benefício é que você obtém um tempo de inicialização aparente mais rápido.

Para desligar o Windows sem hibernação, emita o seguinte em um prompt de comando (no Windows):

shutdown /s

Você também pode querer incluir /t 0o encerramento imediato.

Encontrei um bom tutorial para configurar um iniciador para isso: Como fazer um desligamento completo no Windows 8 sem desativar a inicialização híbrida.

A abordagem mais simples para realmente desligar o Windows é 'reiniciar' (em vez de 'desligar'), mas interceptar o processo de inicialização e inicializar o Linux em vez de deixá-lo inicializar o Windows.

crédito : nobar

Isso também pode acontecer se você estiver usando um cliente git de linha de comando alternativo, como hub .

Estou usando o hub como um substituto alternativo para o git há alguns anos, mas recentemente escrevi um script bash que trabalha bastante com o git e comecei a obter esse problema de bloqueio de índice.

Não consegui encontrar a correção até lembrar que estava executando o hub em vez do git. Tirei isso e o problema desapareceu!

Obtendo o erro:

Using index info to reconstruct a base tree...
Falling back to patching base and 3-way merge...
fatal: Unable to create '/home/user/project/.git/index.lock': File exists.

If no other git process is currently running, this probably means a
git process crashed in this repository earlier. Make sure no other git
process is running and remove the file manually to continue.

Mas não consegui encontrar (nem excluir) esse arquivo .git / index.lock.

No meu caso, o git-cola estava funcionando!

Obviamente, ele cria esse .git / index.lock de vez em quando ou é causado pelo rebase que eu fazia na linha de comando e durante o qual recebia esse erro - então o git-cola obviamente "perturba" a execução da linha de comando do Git (ou algumas operações da CLI do Git).

Isso é resolvido fechando-se o git-cola durante uma rebase do git da linha de comando.

Às vezes, outro cliente Git pode interferir quando há vários instalados.

Ou seja. verifique se o Gerenciador de tarefas ou Get-Processo TGitCacheTortoiseGit não está ativo em segundo plano.

Eu tive o mesmo problema recentemente. Se você verificar toda a mensagem de erro, também diz que há algum processo que está usando o processo git que o impede de excluir o index.lock. Você pode ter o IDE aberto como o Visual Studio ou software relacionado ao qual o git está integrado. Feche-o e tente re-esconder seu arquivo. Espero que ajude.