El progreso durante la copia de archivos de gran tamaño (Copy-Item & Write-Progress?)

Question

¿Hay alguna manera de copiar un archivo muy grande (de un servidor a otro) en PowerShell y mostrar su progreso?

Hay soluciones que hay para utilizar Write-Progress en conjunción con un bucle copiar muchos archivos y el progreso de visualización. Sin embargo, me parece que no puede encontrar nada que pudiera mostrar el progreso de un solo archivo.

¿Alguna idea?

Answer 1

No he oído acerca del progreso con Copy-Item. Si no desea utilizar ninguna herramienta externa, se puede experimentar con corrientes. El tamaño de la memoria intermedia varía, es posible probar diferentes valores (de 2 kb a 64 kb).

function Copy-File {
    param( [string]$from, [string]$to)
    $ffile = [io.file]::OpenRead($from)
    $tofile = [io.file]::OpenWrite($to)
    Write-Progress -Activity "Copying file" -status "$from -> $to" -PercentComplete 0
    try {
        [byte[]]$buff = new-object byte[] 4096
        [int]$total = [int]$count = 0
        do {
            $count = $ffile.Read($buff, 0, $buff.Length)
            $tofile.Write($buff, 0, $count)
            $total += $count
            if ($total % 1mb -eq 0) {
                Write-Progress -Activity "Copying file" -status "$from -> $to" `
                   -PercentComplete ([int]($total/$ffile.Length* 100))
            }
        } while ($count -gt 0)
    }
    finally {
        $ffile.Dispose()
        $tofile.Dispose()
        Write-Progress -Activity "Copying file" -Status "Ready" -Completed
    }
}

Answer 2

Parece que una solución mucho mejor que sólo tiene que utilizar BitsTransfer, que parece venir OOTB en la mayoría de las máquinas de Windows PowerShell con 2.0 o superior.

Import-Module BitsTransfer
Start-BitsTransfer -Source $Source -Destination $Destination -Description "Backup" -DisplayName "Backup"

Answer 3

Alternativly esta opción utiliza la barra de progreso de Windows nativo ...

$FOF_CREATEPROGRESSDLG = "&H0&"

$objShell = New-Object -ComObject "Shell.Application"

$objFolder = $objShell.NameSpace($DestLocation) 

$objFolder.CopyHere($srcFile, $FOF_CREATEPROGRESSDLG)

Answer 4

cmd /c copy /z src dest

No PowerShell puro, pero ejecutable en PowerShell y muestra el progreso en porcentajes

Answer 5

I modificado el código de Stej (lo cual era genial, justo lo que necesitaba!) Para utilizar búfer mayor, [mucho] para archivos más grandes y la clase System.Diagnostics.Stopwatch utilizado para medir el tiempo transcurrido y el tiempo restante estimado.

También se ha añadido la notificación de tasa de transferencia durante la transferencia y la salida de tiempo total transcurrido y tasa de transferencia general.

El uso de 4 MB (4096 * 1024 bytes) de amortiguación para conseguir mejor que Win7 copia rendimiento nativo de NAS a una memoria USB en la computadora portátil a través de WiFi.

En la lista de tareas pendientes:

• añadir gestión de errores (captura)
• manejar la lista de archivos conseguir-childitem como entrada
• barras de progreso anidados al copiar varios archivos (archivo de x de y, si% total de datos copiados, etc)
• parámetro de entrada para el tamaño de memoria intermedia

No dude en utilizar / mejora: -)

function Copy-File {
param( [string]$from, [string]$to)
$ffile = [io.file]::OpenRead($from)
$tofile = [io.file]::OpenWrite($to)
Write-Progress `
    -Activity "Copying file" `
    -status ($from.Split("\")|select -last 1) `
    -PercentComplete 0
try {
    $sw = [System.Diagnostics.Stopwatch]::StartNew();
    [byte[]]$buff = new-object byte[] (4096*1024)
    [long]$total = [long]$count = 0
    do {
        $count = $ffile.Read($buff, 0, $buff.Length)
        $tofile.Write($buff, 0, $count)
        $total += $count
        [int]$pctcomp = ([int]($total/$ffile.Length* 100));
        [int]$secselapsed = [int]($sw.elapsedmilliseconds.ToString())/1000;
        if ( $secselapsed -ne 0 ) {
            [single]$xferrate = (($total/$secselapsed)/1mb);
        } else {
            [single]$xferrate = 0.0
        }
        if ($total % 1mb -eq 0) {
            if($pctcomp -gt 0)`
                {[int]$secsleft = ((($secselapsed/$pctcomp)* 100)-$secselapsed);
                } else {
                [int]$secsleft = 0};
            Write-Progress `
                -Activity ($pctcomp.ToString() + "% Copying file @ " + "{0:n2}" -f $xferrate + " MB/s")`
                -status ($from.Split("\")|select -last 1) `
                -PercentComplete $pctcomp `
                -SecondsRemaining $secsleft;
        }
    } while ($count -gt 0)
$sw.Stop();
$sw.Reset();
}
finally {
    write-host (($from.Split("\")|select -last 1) + `
     " copied in " + $secselapsed + " seconds at " + `
     "{0:n2}" -f [int](($ffile.length/$secselapsed)/1mb) + " MB/s.");
     $ffile.Close();
     $tofile.Close();
    }
}

Answer 6

No es que yo sepa. Yo no recomendaría el uso de copia-artículo para esto de todos modos. No creo que se ha diseñado para ser robusto como para apoyar robocopy.exe reintento la que usted quiere para extremadamente grandes copias de archivos en la red.

Answer 7

Este recursivas función copia los archivos y directorios de forma recursiva de ruta de origen a la ruta de destino

Si el archivo ya existe en la ruta de destino, se copia solamente con archivos más recientes.

Function Copy-FilesBitsTransfer(
        [Parameter(Mandatory=$true)][String]$sourcePath, 
        [Parameter(Mandatory=$true)][String]$destinationPath, 
        [Parameter(Mandatory=$false)][bool]$createRootDirectory = $true)
{
    $item = Get-Item $sourcePath
    $itemName = Split-Path $sourcePath -leaf
    if (!$item.PSIsContainer){ #Item Is a file

        $clientFileTime = Get-Item $sourcePath | select LastWriteTime -ExpandProperty LastWriteTime

        if (!(Test-Path -Path $destinationPath\$itemName)){
            Start-BitsTransfer -Source $sourcePath -Destination $destinationPath -Description "$sourcePath >> $destinationPath" -DisplayName "Copy Template file" -Confirm:$false
            if (!$?){
                return $false
            }
        }
        else{
            $serverFileTime = Get-Item $destinationPath\$itemName | select LastWriteTime -ExpandProperty LastWriteTime

            if ($serverFileTime -lt $clientFileTime)
            {
                Start-BitsTransfer -Source $sourcePath -Destination $destinationPath -Description "$sourcePath >> $destinationPath" -DisplayName "Copy Template file" -Confirm:$false
                if (!$?){
                    return $false
                }
            }
        }
    }
    else{ #Item Is a directory
        if ($createRootDirectory){
            $destinationPath = "$destinationPath\$itemName"
            if (!(Test-Path -Path $destinationPath -PathType Container)){
                if (Test-Path -Path $destinationPath -PathType Leaf){ #In case item is a file, delete it.
                    Remove-Item -Path $destinationPath
                }

                New-Item -ItemType Directory $destinationPath | Out-Null
                if (!$?){
                    return $false
                }

            }
        }
        Foreach ($fileOrDirectory in (Get-Item -Path "$sourcePath\*"))
        {
            $status = Copy-FilesBitsTransfer $fileOrDirectory $destinationPath $true
            if (!$status){
                return $false
            }
        }
    }

    return $true
}

Answer 8

Sean Kearney de la Hola, chicos del scripting! Blog tiene una solución que encontré trabajos bastante bien.

Function Copy-WithProgress
{
    [CmdletBinding()]
    Param
    (
        [Parameter(Mandatory=$true,
            ValueFromPipelineByPropertyName=$true,
            Position=0)]
        $Source,
        [Parameter(Mandatory=$true,
            ValueFromPipelineByPropertyName=$true,
            Position=0)]
        $Destination
    )

    $Source=$Source.tolower()
    $Filelist=Get-Childitem "$Source" –Recurse
    $Total=$Filelist.count
    $Position=0

    foreach ($File in $Filelist)
    {
        $Filename=$File.Fullname.tolower().replace($Source,'')
        $DestinationFile=($Destination+$Filename)
        Write-Progress -Activity "Copying data from '$source' to '$Destination'" -Status "Copying File $Filename" -PercentComplete (($Position/$total)*100)
        Copy-Item $File.FullName -Destination $DestinationFile
        $Position++
    }
}

A continuación, se usa:

Copy-WithProgress -Source $src -Destination $dest

Answer 9

Trevor Sullivan tiene un reportaje sobre cómo agregar un comando llamado Copy-ItemWithProgress a PowerShell en Robocopy.

Answer 10

Odio ser el que para volcar un viejo tema, pero me encontré con este post extremadamente útil. Después de ejecutar pruebas de rendimiento de los fragmentos de Stej y es el refinamiento de Graham Oro, además de la sugerencia de BITS por Nacht, he decuded que:

1. I realmente le gusta comando de Graham con las estimaciones de tiempo y lecturas de velocidad.
2. También realmente le gusta el aumento significativo de la velocidad de la utilización de BITS como mi método de transferencia.

Frente a la decisión entre los dos ... me encontré con que Start-BitsTransfer admite el modo asíncrono. Así que aquí es el resultado de la fusión de los dos mi.

function Copy-File {
    param([string]$from, [string]$to)

    try {
        $job = Start-BitsTransfer -Source $from -Destination $to `
                   -Description "Moving: $from => $to" `
                   -DisplayName "Backup" -Asynchronous

        # Start stopwatch
        $sw = [System.Diagnostics.Stopwatch]::StartNew()
        Write-Progress -Activity "Connecting..."

        while ($job.JobState.ToString() -ne "Transferred") {
            switch ($job.JobState.ToString()) {
                "Connecting" {
                    break
                }
                "Transferring" {
                    $pctcomp = ($job.BytesTransferred / $job.BytesTotal) * 100
                    $elapsed = ($sw.elapsedmilliseconds.ToString()) / 1000

                    if ($elapsed -eq 0) {
                        $xferrate = 0.0
                    } else {
                        $xferrate = (($job.BytesTransferred / $elapsed) / 1mb);
                    }

                    if ($job.BytesTransferred % 1mb -eq 0) {
                        if ($pctcomp -gt 0) {
                            $secsleft = ((($elapsed / $pctcomp) * 100) - $elapsed)
                        } else {
                            $secsleft = 0
                        }

                        Write-Progress -Activity ("Copying file '" + ($PathName.Split("\") | Select -last 1) + "' @ " + "{0:n2}" -f $xferrate + "MB/s") `
                                       -PercentComplete $pctcomp `
                                       -SecondsRemaining $secsleft
                    }
                    break
                }
                "Transferred" {
                    break
                }
                Default {
                    throw $job.JobState.ToString() + " unexpected BITS state."
                }
            }
        }

        $sw.Stop()
        $sw.Reset()
    } finally {
        Complete-BitsTransfer -BitsJob $job
        Write-Progress -Activity "Completed" -Completed
    }
}