El archivo git index.lock existe cuando intento confirmar, pero no puedo eliminar el archivo

Cuando hago 'git commit', obtengo lo siguiente:

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

Sin embargo, cuando lo hago ls project_path/.git/index.lock, dice que el archivo no existe. ¿Alguna idea sobre lo que debo hacer? También he notado que project_path / .git es propiedad de root, no estoy seguro si eso tiene algo que ver con el problema que estoy encontrando.

la versión de git es 1.7.5.4

editar: Parece que el problema probablemente fue otro proceso que estaba ejecutando, que estaba escribiendo (sin que yo lo supiera) en el directorio del proyecto. Reinicié mi máquina y luego no tuve problemas para comprometerme.

Esta puede ser una respuesta anterior, pero espero que sea más útil en el próximo que necesita esta solución.

En linux / unix / gitbash / cygwin, intente

rm -f .git/index.lock

En el símbolo del sistema de Windows, intente:

del .git\index.lock

Para ventanas:

• Desde una consola powershell abierta como administrador, intente

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

• Si eso no funciona, debe eliminar todos los procesos de 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

En una plataforma Windows que ejecuta Visual Studio 2015 RC (v4.6.00057) en combinación con SourceTree (v1.6.14.0) también dará este error.

Solución: suponiendo que desea utilizar el árbol de origen como administrador del código fuente, simplemente desactive el proveedor de control de origen dentro de Visual Studio de esta manera:

1. Vaya a: Herramientas> Opciones> Control de origen
2. Seleccione el complemento de control de fuente actual como: Ninguno

1. compruebe si el git sigue ejecutándose (ps -ef | grep git)
2. si no, elimine el archivo bloqueado
3. en caso afirmativo, elimine el proceso git al principio.

tratar

rm -f ./.git/index.lock

si no tiene otro proceso de git en ejecución, simplemente elimine el archivo index.lock del proyecto respectivo.

Acabo de tener este problema ... Gitbox tuvo la culpa. Entonces, tal vez tenía una GUI ejecutándose que estaba causando problemas.

Esto sucede cuando cancelas la extracción desde el origen en el medio.

entonces, lo que puede hacer es eliminar manualmente el archivo index.lock de su directorio .git.

rm -f ./.git/index.lock

cd en su directorio de proyecto y ejecute este comando.

1. Cierre todas las ventanas que puedan afectar este archivo .git / index.lock
2. Elimine el archivo .git / index.lock.
3. Abra su editor de línea de comando y cd en la ubicación de sus archivos git.

(Si se crea el archivo, simplemente desde cd en esa ubicación, entonces el problema es su editor. Cierre su editor. No use este editor nuevamente para esta tarea. Abra un tipo diferente de editor: Windows Power Shell o simplemente cmd. Ahora puedes usar los comandos de git para continuar)

Probablemente (me ha sucedido), el comando ls dice que no existe porque el usuario actual no tiene permisos para acceder a ese directorio o archivo.

Elimine el bloqueo y asegúrese de ejecutar git con el usuario correcto para evitar problemas de permisos.

Si está en una caja de GNU / Linux con el comando sudo :

sudo rm ruta_proyecto / .git / index.lock

del .git\index.lock trabajó para mi.

Estaba enfrentando este problema al momento de pagar una nueva sucursal de la sucursal maestra.

El pago se realizó fácilmente después de eliminar el index.lockarchivo.

A veces, Git crea un archivo de bloqueo asociado con su repositorio mientras realiza cambios o muy probablemente cuando usa submódulos. El mensaje de error le mostrará la ruta del archivo de bloqueo. Solución: simplemente vaya manualmente a la ruta en la terminal y elimine el archivo de bloqueo por $ rm index.lock

Debería ayudar

Tuve este problema con SourceTree al cambiar de rama haciendo doble clic en él. El problema no es muy común y Atlassian lo sabe pero decidieron no solucionarlo.

Afortunadamente, hay una solución. En lugar de hacer doble clic en la rama que desea cambiar, simplemente haga clic derecho y seleccione "Pagar [nombre de la rama]". Debería tener éxito ahora.

Me he encontrado con el mismo escenario. Incluso no he hecho ningún cambio en mi código local. Acabo de editar un archivo y revertirlo. Simplemente he eliminado el archivo a continuación en la carpeta oculta .git. ¡Funcionó!

ruta_proyecto / .git / index.lock

A menos que realmente pretenda que root sea el propietario de su repositorio, esto suena como si accidentalmente ejecutara un comando Git como root (tal vez incluso el clon / init inicial). Si querías hacer eso, entonces tendrás que vivir ejecutando todos los comandos de Git en el repositorio como root. Si no lo hizo, corra sudo chown your-user[:your-group] -R .gitpara tomar posesión de él y luego vea si las cosas funcionan.

Varios clientes de git que trabajan en el mismo repositorio local compiten por ese bloqueo. Cada cliente debe esperar hasta que la otra parte libere el bloqueo para ser un buen ciudadano. Para nosotros, SourceTree o MSVS parecen estar haciendo algo de mantenimiento en segundo plano mientras ejecutamos grandes scripts de confirmación.

Quizás 'git' en sí mismo debería admitir un argumento '--retriesWhenLocked 5' para admitir reintentos. o incluso por defecto a esto cuando se ejecuta manualmente.

Aquí hay un contenedor de PowerShell alrededor de git llamado "gitr" que vuelve a intentarlo hasta que desaparece index.lock, usando 5 intentos predeterminados, 3 segundos entre cada uno. Nunca elimina el index.lock, suponiendo que el usuario debe intervenir. Se extrajo de un script de confirmación más grande. Solo tiene pruebas mínimas con argumentos simples.

• Copie el script en C: \ bin y agregue C: \ bin a $ PATH.
• Desde PS1> gitr --help
• Desde 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
}

También tengo esta pregunta en Windows 10.

cuando intento del ./.git/index.lock, me dijocannot remove 'index.lock': Device or resource busy

Finalmente entendí la razón:

la computadora tiene dos procesos para usar git:

• git bash
• cmder

entonces uso cmder.exe para git commitque ocurran errores.

entonces la solución es usar git basho git bashterminar y luego usar cmder.exe

Tuve exactamente el mismo error, pero el problema no era el archivo de bloqueo. En cambio, el problema era que había copiado el contenido de otro repositorio de git en este repositorio, incluida la carpeta invisible .git. Entonces, SourceTree estaba confundido sobre el repositorio en el que quería organizar los archivos (habiendo una discrepancia entre el repositorio que SourceTree pensó que estaba y el contenido de mi directorio .git incrustado dijo que debería estar).

Tuve este problema con TortoiseGit con Cygwin en Windows. No pude eliminar remove ./.git/index.lock incluso con privilegios administrativos, probé tanto Cygwin como el símbolo del sistema, dijo que el archivo estaba en uso por otro proceso.

Descubrí que tenía 2 instancias de TortoiseProc.exe ejecutándose. Maté a uno de ellos, cerré todas las ventanas de mi explorador de Windows y luego pude eliminar el archivo. No sé si matar la instancia de TortoiseProc.exe fue la solución o cerrar las ventanas del explorador de Windows.

La solución para mí fue eliminar el archivo .index y permitir que Git reconstruya otro.

No tenía que eliminar un archivo inex.lock, pero lo que funcionó para mí fue eliminar la verificación de solo lectura de la ventana Atributos del cuadro de diálogo Propiedades de la carpeta.

Creé un archivo index.lock vacío, lo eliminé usando el comando de Windows

A partir de git 2.8.4 (junio de 2016) , esto ya no debería suceder.

Consulte el problema 755, que también debería aliviar el problema ( commit 2db0641 ):

Asegúrese de que los procesos secundarios no hereden los identificadores de archivos temporales

Evitar que los procesos secundarios hereden un identificador a index.lock.

En mi aplicación sourceTree no puedo hacer commit ni cambiar a ningún otro commit / brach. Ese tiempo muestra un error como

fatal: no se puede crear bla bla bla ..

Simplemente resuelvo esto yendo a la carpeta .git (en Project Explorer Dir). Y elimine el índice ----- [tipo de archivo: archivo BLOQUEO]. Ahora recupero todo el acceso en sourceTree ...

asegúrese de que el archivo de bloqueo de índice ... suponga que no obtiene el tipo de archivo, cambie la configuración de vista de archivo en la computadora. Nota: la carpeta .git normalmente es un tipo de carpeta oculta.

Lo que hizo por mí fue:

git rebase --abort y reinicie el rebase.

Como Andrew mencionó, también estaba usando PHPStorm cuando esto sucedió. Sin embargo, no tuve que cerrarlo.

Primero tiene que navegar a la carpeta específica de su proyecto. Al igual que si el nombre de su proyecto es Firstproject, primero vaya al directorio del proyecto ... luego escriba cd .git y luego después de navegar a la carpeta git escriba del index.lock Después la eliminación del archivo index.lock..Podrás confirmar y presionar como antes

En mi caso, eran ventanas, no cerradas por completo.

Windows está hibernado, se niega a montar

Lo más probable es que Windows realmente esté hibernado. Windows hace esto automáticamente cuando le dice que se apague normalmente. El beneficio es que obtienes un tiempo de inicio aparente más rápido.

Para cerrar Windows sin hibernación, emita lo siguiente en un símbolo del sistema (en Windows):

shutdown /s

También es posible que desee incluir /t 0para el apagado inmediato.

Encontré un buen tutorial para configurar un iniciador para esto: Cómo hacer un apagado completo en Windows 8 sin deshabilitar el arranque híbrido.

El enfoque más simple para apagar Windows es 'reiniciar' (en lugar de 'apagar'), pero luego interceptar el proceso de arranque y arrancar Linux en lugar de permitir que arranque Windows.

crédito : nobar

Esto también puede suceder si está utilizando un cliente git de línea de comando alternativo, como hub .

He estado usando hub como un alias de reemplazo para git durante un par de años, pero recientemente escribí un script bash que hace un montón de trabajo en git y comencé a tener este problema de bloqueo de índice.

No pude encontrar la solución hasta que recordé que estaba ejecutando hub en lugar de git. ¡Lo eliminé y el problema desapareció!

Obteniendo el error:

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.

Pero no pude encontrar (ni eliminar) ese archivo .git / index.lock.

¡En mi caso, git-cola estaba funcionando!

Obviamente crea ese .git / index.lock de vez en cuando, o causado por el rebase que estaba haciendo en la línea de comando y durante el cual recibí ese error, por lo que git-cola obviamente "perturba" la ejecución de la línea de comando de Git (o algunas operaciones de Git CLI).

Esto se resuelve cerrando git-cola durante una línea de comando git rebase.

A veces, otro cliente de Git puede interferir cuando hay varios instalados.

Es decir. asegúrese de que con el Administrador de tareas o Get-Processque TGitCacheTortoiseGit no esté activo en segundo plano.

Tuve el mismo problema recientemente. Si verifica todo el mensaje de error, también dice que hay algunos procesos que están utilizando el proceso git que le impide eliminar index.lock. Puede tener IDE abierto como Visual Studio o software relacionado en el que está integrado git. Ciérrelo e intente volver a guardar su archivo. Espero eso ayude.