.

and add smal exec info

.gitattributes

@@ -0,0 +1 @@
+*	text=auto

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2015 6543
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
+OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,11 +1,9 @@
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Release](https://img.shields.io/badge/Release-v1.2-brightgreen)](https://code.obermui.de/6543/LogWert/releases)
+[![PGP Sig](https://img.shields.io/keybase/pgp/6543)](https://mh.obermui.de/publickey.gpg)
+
 # LogWert
 
-### Anforderungen
+Summarizes the RoboCopy Log's
 
-reine Auswertung einer Logdatei
-auffassen. Das Ergebnis wird dann allerdings weiterverarbeitet. Die
-Skripte schicke ich Dir mal als ZIP.
-
-Die Auswertung soll vor Erzeugung der Email passieren
-(shares_spiegeln_und_sichern.cmd), da müsste auch schon irgendwo ein
-Platzhalterkommentar stehen…
+exec: `./logwert.ps1 [path-log1] [path-log2] [path-log3] ... `

logwert.cmd

@@ -1,235 +0,0 @@
-@echo off
-setlocal enabledelayedexpansion
-rem  ##############################################################
-rem  ##                                                          ##
-rem  ##  logwert.cmd                            version. 1.2     ##
-rem  ##                                                          ##
-rem  ##  Dies ist ein Hilfsscript fuer _shares_spiegeln.bat      ##
-rem  ##  Es wertet die Robologfile aus und fast diese zusammen   ##
-rem  ##                                                          ##
-rem  ##  @param %1 Pfadangabe-Logdatei							 ##
-rem  ##                                                          ##
-rem  ##  @author:  Martin.Huber@stbaro.bayern.de                 ##
-rem  ##                                                          ##
-rem  ##############################################################
-
-rem Einstellungen
-
-rem Dividierender Faktor der Groe<6F>enausgabe (GB=1073741824,...)
-set Log_Copy_Size_Einheit=1073741824
-
-
-rem ##########################################################################################
-rem ########################### Beginn des eigendlichen Programms ############################
-rem ##########################################################################################
-
-rem
-rem  Hilfsvariablen NICHT editieren
-rem
-
-set Log_Path=%1
-set Log_Copy_errors=0
-set Log_Copy_Size=0
-set Log_Copy_real_Size=0
-set Log_Copy_item=0
-set Log_Copy_real_item=0
-
-rem ##########################################################################################
-
-:Start
-
-rem pruefen ob auszuwertendes Logfile Existiert
-if not exist "%Log_Path%" set errorlevel=1&echo Wrong Log Path&goto exit
-
-for /f "delims=# tokens=3" %%c in ('echo %random%') do call :WichCase Dauer xy
-
-rem Logfile Auswerten
-rem Jede Zeile mit !!!MAIN!!! einzeln Auswerten
-for /f "tokens=*" %%a in (%Log_Path%) do call :Main %%a
-
-rem Umrechnen und Runden der Gr<47><72>enausgabe
-call :calc "%Log_Copy_Size%/%Log_Copy_Size_Einheit%" Log_Copy_Size
-set result=
-call :round %Log_Copy_Size%
-set Log_Copy_Size=%result%
-call :calc "%Log_Copy_real_Size%/%Log_Copy_Size_Einheit%" Log_Copy_real_Size
-set result=
-call :round %Log_Copy_real_Size%
-set Log_Copy_real_Size=%result%
-
-
-echo Insgesamt: %Log_Copy_real_item% von %Log_Copy_item% Dateien kopiert, %Log_Copy_errors% Fehler, %Log_Copy_real_Size% g von %Log_Copy_Size% g kopiert
-set "result=%Log_Copy_real_item% von %Log_Copy_item% Dateien kopiert, %Log_Copy_errors% Fehler, %Log_Copy_real_Size% g von %Log_Copy_Size% g kopiert"
-rem bis drei stellen nach dem komma
-rem 4 ziffern
-rem g
-goto Exit
-
-Rem ############################################################################################
-
-Rem Zeilenweise Auswertung
-:Main
-set Log_Line=%*
-
-Rem Entfernen Problematischer Zeichen und setzen des Trennzeichens (#)
-set Log_Line=%Log_Line:"=#%
-set Log_Line=%Log_Line:,=#%
-set Log_Line=%Log_Line:)=+%
-set Log_Line=%Log_Line:(=+%
-
-rem Abschnitte einzeln weiter Auswerten
-for /f "delims=# tokens=2" %%b in ('echo %Log_Line%') do (
-	set tempvar=%%b
-	call :WichCase !tempvar!
-)
-for /f "delims=# tokens=3" %%c in ('echo %Log_Line%') do call :WichCase %%c
-for /f "delims=# tokens=4" %%d in ('echo %Log_Line%') do call :WichCase %%d
-for /f "delims=# tokens=5" %%e in ('echo %Log_Line%') do call :WichCase %%e
-
-
-goto Exit
-
-Rem ##################################################################################################
-
-:WichCase
-
-Rem herausfinden der Informations Art (Item, Error, Size)
-rem und starten der zugehoerigen auswerte Funktion
-
-set var_a=%*
-if not defined var_a goto exit
-
-Rem Lehre Ordner werden so uebersprungen
-for /f "tokens=1" %%g in ('echo !var_a!') do if "%%g" == "Dauer" goto exit
-
-rem zaehlen der Dateien
-for /f "tokens=1,3,4" %%h in ('echo !var_a!') do if "%%j" == "Dateien" (
-  call :calc "%Log_Copy_item%+%%i" Log_Copy_item
-  call :calc "%Log_Copy_real_item%+%%h" Log_Copy_real_item
-  goto exit
-)
-
-rem zaehlen der Fehler
-for /f "tokens=1,2" %%i in ('echo !var_a!') do if "%%j" == "Fehler" (
-  call :calc "%Log_Copy_errors%+%%i" Log_Copy_errors
-  goto exit
-)
-
-rem aufrufen der additions Funktion der Groe<6F>enangaben
-for /f "tokens=1,2,4,5,6" %%k in ('echo !var_a!') do if "%%o" == "kopiert" (
-  call :count_real_Size %%k %%l
-  call :count_Size %%m %%n
-  goto exit
-)
-
-goto exit
-
-rem ###############################################################################################
-
-Rem erstellen aehnlicher Funktionen um "setlocal enabledelayedexpansion" zu Umgehen
-
-:count_real_Size
-
-set result=
-call :convert_to_bytes %1 %2 result
-call :calc "%result%+%Log_Copy_real_Size%" Log_Copy_real_Size
-goto exit
-
-
-:count_Size
-
-set result=
-call :convert_to_bytes %1 %2 result
-call :calc "%result%+%Log_Copy_Size%" Log_Copy_Size
-goto exit
-
-rem ##############################################################################################
-
-rem konfertieren der unterschiedlichen Groe<6F>enangaben in bytes (umrechnungseinheit= 1024)
-rem b (=Bytes), k (=Kilobytes), m (=Megabytes), g (=Gigabytes) und t (=Terabytes)
-
-:convert_to_bytes
-rem convert_to_bytes [zahl] [einheit] (r<>ckgabe-variable)
-set convert_to_bytes_zahl=%1
-set convert_to_bytes_einheit=%2
-set convert_to_bytes_var=%3
-if not defined convert_to_bytes_var set convert_to_bytes_var=result
-
-rem "Select Case convert_to_bytes_einheit"
-goto :convert_to_bytes_%convert_to_bytes_einheit%
-:convert_to_bytes_b
-set %convert_to_bytes_var%=%convert_to_bytes_zahl%
-goto exit
-:convert_to_bytes_k
-call :calc "%convert_to_bytes_zahl%*1024" %convert_to_bytes_var%
-goto exit
-:convert_to_bytes_m
-call :calc "%convert_to_bytes_zahl%*1048576" %convert_to_bytes_var%
-goto exit
-:convert_to_bytes_g
-call :calc "%convert_to_bytes_zahl%*1073741824" %convert_to_bytes_var%
-goto exit
-:convert_to_bytes_t
-call :calc "%convert_to_bytes_zahl%*1099511627776" %convert_to_bytes_var%
-goto exit
-:convert_to_bytes_0
-echo Kein Sharezugriff!
-set %convert_to_bytes_var%=0
-
-goto exit
-
-
-rem ###############################################################################################
-
-rem auslagern der Rechenfunktion in die PowerShell
-
-:calc
-rem calc ["berechnung"] (r<>ckgabe-variable)
-set result=%1
-if not defined result goto exit
-
-rem herausfiltern unerlaubter Zeichen
-set result=%result:,=.%
-set result=%result:(=^(%
-set result=%result:)=^)%
-set result=%result:"=%
-
-set result=%result:[=^(%
-set result=%result:]=^)%
-
-set var_name=%2
-if not defined var_name set var_name=result
-
-for /f %%a in ('powershell -C "%result%"') do set result=%%a
-set result=%result:,=.%
-set %var_name%=%result%
-goto exit
-
-rem #############################################################################################
-
-rem  die Funktion round konnte nicht in die PowerShell ausgelagert werden,
-rem  da der befehl Klammern enth<74>llt!
-rem  Rundet immer auf zwei Stellen nach dem Komma
-
-:round
-rem round [zahl]
-set result=%*
-if not defined result goto exit
-set result=%result:,=.%
-set result=%result:"=%
-
-call :calc "%result%*1000" result
-set result=%result:.=#%
-set result=%result:,=#%
-for /f "delims=# tokens=1" %%a in ('echo %result%') do set result=%%a
-set last_number=%result:~-1%
-if "%last_number%" GTR "5" (set round_zahl=1) else (set round_zahl=0)
-call :calc "%result:~,-1%+%round_zahl%" result
-call :calc "%result%/100" result
-set last_number=
-set round_zahl=
-goto exit
-
-rem #############################################################################################
-
-:exit

logwert.ps1

@@ -0,0 +1,179 @@
+#!/usr/bin/pwsh
+
+
+        ##############################################################
+        ##                                                          ##
+        ##  logwert.ps1                            version. 1.2     ##
+        ##                                                          ##
+        ##  This is a smal help script                              ##
+        ##  It evaluates robocopy logs and summarizes them          ##
+        ##                                                          ##
+        ##  @parameter: [path-log1] [path-log2] [path-log3] ...     ##
+        ##                                                          ##
+        ##  @author:  6543@obermui.de                               ##
+        ##                                                          ##
+        ##############################################################
+
+
+
+
+
+###################################  Einstellungen  ####################################################
+
+# b (=Bytes), k (=Kilobytes), m (=Megabytes), g (=Gigabytes) und t (=Terabytes)
+[String]$Global:Log_Copy_Size_Einheit = "g"
+
+
+################################### Hilfsvariablen NICHT editieren #######################################
+
+[Double]$Global:zLog_Copy_errors = 0
+[Double]$Global:zLog_Copy_Size = 0
+[Double]$Global:zLog_Copy_real_Size = 0
+[Double]$Global:zLog_Copy_item = 0
+[Double]$Global:zLog_Copy_real_item = 0
+
+###################################  Functionen  ##########################################################
+
+function Log_Start ([String]$sLogpath){
+ If(Test-Path $sLogpath) {                #test if file exists
+ $tmp = ""
+ $tmp = Get-Content $sLogpath             #copy file into list
+ $tmp | ForEach-Object { Log_Main $_ }    #process each line
+ }
+} # start processing
+
+function Log_Main ([String]$sLine){
+# separate Set character
+$sLine = $sLine.replace("`"", "#")
+$sLine = $sLine.replace(",", "#")
+$sLine = $sLine.replace("Insgesamt:", "")
+
+if($sLine -match "[0-z]") {
+
+
+ ### rule out anomalies
+
+ while(" ".Equals($sLine.Substring(0,1))) {$sLine = $sLine.Substring(1, $sLine.Length - 1)}
+ #Remove when String Begins with Lehrzeichen
+ while("#".Equals($sLine.Substring(0,1))) {$sLine = $sLine.Substring(1, $sLine.Length - 1)}
+ #If string begins with delimiter remove
+ while(" ".Equals($sLine.Substring($sLine.Length - 1,1))) {$sLine = $sLine.Substring(0, $sLine.Length - 1)}
+ #If String Ends with Lehrzeichen Remove String
+ while("#".Equals($sLine.Substring($sLine.Length - 1,1))) {$sLine = $sLine.Substring(0, $sLine.Length - 1)}
+ #Remove if string ends with delimiters
+ while($sLine.IndexOf("##") -gt -1 ) {$sLine = $sLine.Replace("##", "#")}
+ #Remove several following delimiters in a row
+ while($sLine.IndexOf("  ") -gt -1 ) {$sLine = $sLine.Replace("  ", " ")}
+ #Remove several following characters in a row
+ $sLine.Split("#") | ForEach-Object { WichCase $_ }
+ }
+} #Line by line evaluation
+
+function WichCase ([String]$sToken) {
+
+if($sToken -match "[0-z]") {
+
+ while(" ".Equals($sToken.Substring(0,1))) {$sToken = $sToken.Substring(1, $sToken.Length - 1)}
+ #remove blank before rating
+ while(" ".Equals($sToken.Substring($sToken.Length - 1,1))) {$sToken = $sToken.Substring(0, $sToken.Length - 1)}
+ #remove blank avter rating
+
+ $aToken = $sToken.Split(" ")
+
+ # Count_Copy_errors
+ If(("Fehler".Equals($aToken[1])) -and ($aToken[0] -notmatch "[a-z]")) {
+  [Double]$Global:zLog_Copy_errors = [Double]$Global:zLog_Copy_errors + $aToken[0]
+  }
+
+ # Count_Items
+ If(("von".Equals($aToken[1])) -and ("Dateien".Equals($aToken[3])) -and ($aToken[0] -notmatch "[a-z]") -and  ($aToken[2] -notmatch "[a-z]")) {
+  [Double]$Global:zLog_Copy_item += $aToken[2]
+  [Double]$Global:zLog_Copy_real_item += $aToken[0]
+  }
+ }
+
+ # Count_Size
+ If(("von".Equals($aToken[2])) -and ("kopiert".Equals($aToken[5])) -and ($aToken[0] -notmatch "[a-z]") -and  ($aToken[3] -notmatch "[a-z]") ){# -and ($aToken[1] -match "[b,k,m,g,t]") -and ($aToken[4] -match "[b,k,m,g,t]")) {
+  [Double]$Global:zLog_Copy_Size += (Calc_Byte_Sice $aToken[3] $aToken[4] b)
+  [Double]$Global:zLog_Copy_real_Size += (Calc_Byte_Sice $aToken[0] $aToken[1] b)
+ }
+} #Transfer of the line; evaluation; storage in global variables
+
+function Calc_Byte_Sice ([Double]$Wert, [String]$EinheitEingabe, [String]$EinheitAusgabe ) {
+
+#Calc_Byte_Sice:  [value] [unit outpute] [unit input]
+# If you enter something other than KB,MB,GB,TB for unit, it is calculated with bytes.
+
+#fertieren the different size specifications (conversion unit= 1024)
+# b (=Bytes), k (=Kilobytes), m (=Megabytes), g (=Gigabytes) und t (=Terabytes)
+
+ If("".Equals("$Wert") -and "0".Equals("$Wert")) {return 0} else {
+
+  $EinheitEingabe = ($EinheitEingabe.substring(0,1)).replace("K","k")
+  $EinheitEingabe = ($EinheitEingabe.substring(0,1)).replace("M","m")
+  $EinheitEingabe = ($EinheitEingabe.substring(0,1)).replace("G","g")
+  $EinheitEingabe = ($EinheitEingabe.substring(0,1)).replace("T","t")
+
+  $EinheitAusgabe = ($EinheitAusgabe.substring(0,1)).replace("K","k")
+  $EinheitAusgabe = ($EinheitAusgabe.substring(0,1)).replace("M","m")
+  $EinheitAusgabe = ($EinheitAusgabe.substring(0,1)).replace("G","g")
+  $EinheitAusgabe = ($EinheitAusgabe.substring(0,1)).replace("T","t")
+
+  # Catching size information that does not exist/that are not handled
+  If ( -not ("b".Equals("$EinheitAusgabe") -or "k".Equals("$EinheitAusgabe") -or "m".Equals("$EinheitAusgabe") -or "g".Equals("$EinheitAusgabe") -or "t".Equals("$EinheitAusgabe"))) {$EinheitAusgabe = "else"}
+  If ( -not ("b".Equals("$EinheitEingabe") -or "k".Equals("$EinheitEingabe") -or "m".Equals("$EinheitEingabe") -or "g".Equals("$EinheitEingabe") -or "t".Equals("$EinheitEingabe"))) {$EinheitEingabe = "else"}
+
+  switch("$EinheitEingabe") {
+
+  "k" { $Wert = $Wert * 1024 }
+
+  "m" {$Wert = $Wert * 1048576}
+
+  "g" {$Wert = $Wert * 1073741824}
+
+  "t" {$Wert = $Wert * 1099511627776}
+
+  "else" {$Wert = 0 }
+
+  }
+
+  switch("$EinheitAusgabe") {
+
+  "b" {$Wert = [math]::round($Wert, 0)}
+
+  "k" {$Wert = $Wert / 1024}
+
+  "m" {$Wert = $Wert / 1048576}
+
+  "g" {$Wert = $Wert / 1073741824}
+
+  "t" {$Wert = $Wert / 1099511627776}
+
+  "else" {$Wert = 0 }
+
+  }
+  return $Wert
+ }
+} #[value] [unit outpute] [unit input]
+
+##########################################################################################################
+
+If ($args[0] -eq "--version") {
+  echo "Version: 1.2"
+} ElseIf ($args[0] -eq "--help") {
+  echo "./logwert.ps1 [log1] [log2] ..."
+} Else {
+
+  #for each param do start(param)
+  $args | ForEach-Object { Log_Start $_ }
+
+  [String]$sLog_Copy_errors = "$Global:zLog_Copy_errors"
+  [String]$sLog_Copy_Size = [math]::round((Calc_Byte_Sice $Global:zLog_Copy_Size b $Global:Log_Copy_Size_Einheit), 2)
+  [String]$sLog_Copy_real_Size = [math]::round((Calc_Byte_Sice $Global:zLog_Copy_real_Size b $Global:Log_Copy_Size_Einheit), 2)
+  [String]$sLog_Copy_item = "$Global:zLog_Copy_item"
+  [String]$sLog_Copy_real_item = "$Global:zLog_Copy_real_item"
+  [String]$sLog_Copy_Size_Einheit = "$Global:Log_Copy_Size_Einheit"
+
+  echo "Summary: $sLog_Copy_real_item of $sLog_Copy_item files copied, $sLog_Copy_errors errors, $sLog_Copy_real_Size $sLog_Copy_Size_Einheit of $sLog_Copy_Size $sLog_Copy_Size_Einheit copied"
+
+}

testlog.txt

@@ -1,29 +0,0 @@
-"\\transit\e$\BACKUP" 0 von 7 Dateien kopiert, 0 Fehler, 0 m von 460.66 m kopiert, Dauer 00:00:00  
-"\\c4u2\d$\4u2" 0 0 von 0 0 kopiert
-"\\snusvintra\d$\Intranet" 137 von 12165 Dateien kopiert, 0 Fehler, 2.93 m von 10.382 g kopiert, Dauer 00:00:03  
-"\\cinvent\c$\Program Files (x86)\FCS" 0 von 1607 Dateien kopiert, 0 Fehler, 0 m von 258.54 m kopiert, Dauer 00:00:00  
-"\\snusvintra\d$\Logon" 0 von 6 Dateien kopiert, 0 Fehler, 0 k von 151.7 k kopiert, Dauer 00:00:00  
-"\\c4u2\c$\4u2" 34 von 4736 Dateien kopiert, 0 Fehler, 1.07 m von 78.05 m kopiert, Dauer 00:00:01  
-"\\iuk\c$\Program Files (x86)\MessPC" 0 von 16 Dateien kopiert, 0 Fehler, 0 m von 1.53 m kopiert, Dauer 00:00:00  
-"\\snusvintra\d$\SQLData\BACKUP" 4 von 37 Dateien kopiert, 0 Fehler, 12.20 m von 94.24 m kopiert, Dauer 00:00:00  
-"\\c4u2\c$\vemags_pdf" 12 von 1723 Dateien kopiert, 0 Fehler, 489.5 k von 244.23 m kopiert, Dauer 00:00:01  
-"\\anwend\Anwendung" 76 von 90107 Dateien kopiert, 0 Fehler, 14.91 m von 48.885 g kopiert, Dauer 00:00:15  
-"\\iuk\c$\Programme\Arexx" 5 von 62 Dateien kopiert, 0 Fehler, 1.04 m von 47.81 m kopiert, Dauer 00:00:00  
-"\\backup\d$\Skripte" 19 von 87 Dateien kopiert, 0 Fehler, 286.4 k von 2.40 m kopiert, Dauer 00:00:00  
-"\\cgzper\c$\k2\DATSIC" 0 von 57 Dateien kopiert, 0 Fehler, 0 g von 1.136 g kopiert, Dauer 00:00:00  
-"\\backup\d$\Backup Exec\Catalogs" 0 von 6 Dateien kopiert, 0 Fehler, 0 m von 585.24 m kopiert, Dauer 00:00:00  
-"\\cgzper\c$\k2\Mail" 0 von 13 Dateien kopiert, 0 Fehler, 0 k von 107.4 k kopiert, Dauer 00:00:00  
-"\\backup\d$\Backup Exec\Data" 0 von 63 Dateien kopiert, 2 Fehler, 0 m von 52.12 m kopiert, Dauer 00:00:00  
-"\\iuk\iuk\Programme" 0 von 7160 Dateien kopiert, 0 Fehler, 0 g von 13.846 g kopiert, Dauer 00:00:06  
-"\\ckruper\c$\k2\DATSIC" 1 von 12 Dateien kopiert, 0 Fehler, 19.56 m von 264.46 m kopiert, Dauer 00:00:01  
-"\\cdlgper\c$\k2\DATSIC" 1 von 8 Dateien kopiert, 0 Fehler, 17.11 m von 135.25 m kopiert, Dauer 00:00:01  
-"\\ckruper\c$\k2\Mail" 0 von 11 Dateien kopiert, 0 Fehler, 0 k von 100.2 k kopiert, Dauer 00:00:00  
-"\\cdlgper\c$\k2\Mail" 0 von 12 Dateien kopiert, 0 Fehler, 0 k von 100.5 k kopiert, Dauer 00:00:00  
-"\\anwend\Projekte" 66 von 83896 Dateien kopiert, 0 Fehler, 119.70 m von 112.009 g kopiert, Dauer 00:00:29  
-"\\iuk\iuk\Programme_StBV" 0 von 33461 Dateien kopiert, 0 Fehler, 0 g von 22.032 g kopiert, Dauer 00:00:14  
-"\\cnuper\c$\k2\DATSIC" 0 von 19 Dateien kopiert, 0 Fehler, 0 m von 271.62 m kopiert, Dauer 00:00:00  
-"\\cnuper\c$\k2\Mail" 0 von 13 Dateien kopiert, 0 Fehler, 0 k von 73.4 k kopiert, Dauer 00:00:00  
-"\\n1v\etc$" 10 von 38 Dateien kopiert, 0 Fehler, 231.2 k von 351.4 k kopiert, Dauer 00:00:02  
-"\\qnap2\Daten" 51 von 107479 Dateien kopiert, 0 Fehler, 49.00 m von 74.649 g kopiert, Dauer 00:01:04  
-"\\n1v\daten$" 418 von 649517 Dateien kopiert, 0 Fehler, 264.78 m von 625.396 g kopiert, Dauer 00:29:28  
-"\\n1v\home$" 490 von 162297 Dateien kopiert, 2 Fehler, 131.835 g von 302.056 g kopiert, Dauer 00:33:10