Question Scan dossier partagé

Bonjour ,

Je travail actuellement sur un script pour détecter les arborescences de plus de 255 caractères. Mon script fonctionne mais j'ai un problème car j'aimerais qu'il scan que les dossiers partagé sur le réseau car se sont les dossiers qui m'interesse et je gagnerais du temps.

Est-il possible de rajouter une fonction pour remédier à mon problème ?

Ci-dessou mon code:

[code:1]####################################
##### // POWERSHELL \\ #####
####################################
# Parcours d'une arborescence pour relever les fichiers
# - noms longs

\"Début du programme\"

# Variable contenant le nom du serveur
$servName=(Get-WmiObject Win32_ComputerSystem).name
$name=$servName

#Variable test existance des disques

$D=Test-Path D:
$E=Test-Path E:
$H=Test-Path H:

# Boucle \"répéter tant que i est différent de n (n étant le nombre de disque dur +1 ici 4).\"
$i=1
while ( $i -lt 4 )
{
if ( ($i -eq 1 -and $D -eq \"True\"«») -or ($i -eq 2 -and $E -eq \"True\"«») -or ($i -eq 3 -and $H -eq \"True\"«») ) {
if ($i -eq 1 -and $D -eq \"True\"«»)
{
$dossier=\"D:\\"
$lecteur=\"D\"
}
elseif ($i -eq 2 -and $E -eq \"True\"«»)
{
$dossier=\"E:\\"
$lecteur=\"E\"
}
elseif ($i -eq 3 -and $H -eq \"True\"«»)
{
$dossier=\"H:\PROG\\"
$lecteur=\"H\"
}

# Variables utiles
$nom=25
$chemin=25
$ici = (get-item $myinvocation.mycommand.name).directoryname
$errorfile = join-path -path $ici -childpath \"errors.txt\"
$resultfile = join-path -path $ici -childpath $name
$sep = \"`t\"
$blanc = \" \"
$nl = \"`n\"
$commentaire=\"#\"

# Capture des erreurs non gérées
trap
{
$journal = out-string -inputobject ($_.invocationinfo | format-list)
$journal += ($_.exception.gettype().name + \"`r`n\"«»)
$journal += $_.exception.message
$journal = (get-date).tostring() + $journal
$journal | out-file -filepath $errorfile -append
exit
}
$rech = $dossier
$lgrech = $rech.length
$maxname = $nom
$maxfullname = $chemin
write-host ($rech + \" : examen en cours\"«»)

#

---

# Elaboration FICHIERS LONGS
#

---

\"Elaboration FICHIERS LONGS\"
clear-content $resultfile -erroraction silentlycontinue
\"Longueur`tExtension`tObjet`tChemin complet\" | out-file -filepath $resultfile -append

if (($maxname -gt 1) -and ($maxfullname -gt 1))
{
foreach ($elem in get-childitem -path $rech -recurse)
{
# $elem.fullname
if ($elem.name.length -gt $maxname)
{
($elem.name.length.tostring() + $sep + $elem.extension + $sep + \"Nom trop long\" + $sep + $elem.fullname.substring($lgrech)) | out-file -filepath $resultfile -append
}
if ($elem.fullname.length -gt $maxfullname)
{
($elem.fullname.length.tostring() + $sep + $elem.extension + $sep + \"Chemin long\" + $sep + $elem.fullname.substring($lgrech)) | out-file -filepath $resultfile -append
}
}
}
write-host ($rech + \" : examen terminé\"«»)
rename-item -path .\$Name -newname \"$Name.$lecteur.xls\"
}
$i++
}

#Déplacement des fichiers de sortie sur serveur *******
Move-Item -Path .\*.xls -Destination \"******\"
\"Fichiers de rapport déplacé sur le serveur ******\"
\"Fin du programme.\"[/code:1]

Bonsoir,

[code:1]
$servName=(Get-WmiObject Win32_ComputerSystem).name
[/code:1]

Pourquoi utiliser WMI lorsque, pour une utilisation locale, nous pouvons simplement faire appel aux variables d'environnement :

[code:1]
$servName=$Env:COMPUTERNAME
[/code:1]

[code:1]
#Variable test existance des disques

$D=Test-Path D:
$E=Test-Path E:
$H=Test-Path H:

# Boucle \"répéter tant que i est différent de n (n étant le nombre de disque dur +1 ici 4).\"
$i=1
while ( $i -lt 4 )
{
if ( ($i -eq 1 -and $D -eq \"True\"«») -or ($i -eq 2 -and $E -eq \"True\"«») -or ($i -eq 3 -and $H -eq \"True\"«») ) {
if ($i -eq 1 -and $D -eq \"True\"«»)
{
[/code:1]

Pourquoi utiliser une boucle 'While' alors qu'il te faut simplement énumérer une liste de lecteur ?

De plus, ton code devient rapidement trop compliqué, avec une série de condition difficilement exploitable, compréhensible, etc...


[code:1]
# Créons une liste de lecteur
$Drives = @(\"D:\",\"E:\",\"H:\"«»)

# Pour chaque lecteur de la liste de lecteurs
Foreach($Drive in $Drives){
# Si le lecteur exite
if(Test-Path $Drive){
Write-Host \"'$Drive' existe\"
# ici le code de traitement pour un lecteur
}
# Sinon
else{
Write-Host \"'$Drive' n'existe pas\"
}
}
[/code:1]


Ensuite... j'y perds vite mon latin ! Je prends mon joker (ou \"appel à un ami\" )

Bref, s'il faut simplement détecter les arborescences de plus de 255 caractères, une solution consiste à récupérer lors de l'énumération des répertoires de l’arborescence
les erreurs de type '[System.IO.PathTooLongException]' :

[code:1]
$Folders = Get-Childitem $Drive -Recurse -Force -ErrorVariable Err -ErrorAction SilentlyContinue | Where-Object{$_.PSisContainer -eq $true}

$LongFolders = @()
Foreach($E in $Err){
if(($E.Exception.GetType()).name -eq \"PathTooLongException\"«»){
$LongFolders += $E.TargetObject
}
}

$LongFolders
[/code:1]

Enfin, pour récupérer la liste des répertoires / lecteurs partagés de la machine locale, cela peut être une piste :

[code:1]
Get-WmiObject -class Win32_Share
[/code:1]

@ +

Matthew<br><br>Message édité par: Matthew BETTON, à: 5/06/12 21:22

Bonjour,

Afin de pouvoir \&quot;jouer\&quot; avec les chemins longs sous Windows (NTFS permet 32000 caractères mais le Shell de Windows limite à 255 caractères), une implémentation de la DLL Microsoft.Experimental.IO.dll avec PowerShell : poshcode.org/2488

Attention, le projet fournie la DLL compilée en .Net Framework 4.0. Il faut donc la recompiler en 3.5, pour pouvoir l'utiliser sous PowerShell V2 :

A simple implemenation of the Experimental.IO LongPath library from the \&quot;Microsoft Base Class Library\&quot;:http://bcl.codeplex.com project as a module.

It has the following functions, with limited error handling: Get-LongPath, Copy-LongPath, Move-LongPath, Remove-LongPath, Get-ContentLongPath, Set-ContentLongPath ... it also has a Format-Color function you can use to colorize the output (or the output of Get-ChildItem).

Since the LongPath variants do NOT create a FileInfo object (because those don't support long paths), Get-LongPath is *much* faster than Get-ChildItem, but it outputs only strings. A version of this \&quot;PowerShell Module for LongPath files\&quot;:http://huddledmasses.org/long-path-module-experimental-io/ is available on my site with the binary assembly included in a \"Experimental.IO.zip\":http://HuddledMasses.org/downloads/Experimental.IO.zip

@+

Matthew<br><br>Message édité par: Matthew BETTON, à: 6/06/12 18:24