document.write('\
\ "); document.write('
  1. # vProfiler.ps1 : vSphere profiling script
    2. \
  2. # This script will export recursively all objects and properties of a VI/vSphere entity to a XML file
    3. \
  3. # Parameters:
    4. \
  4. #       $entityName     : the name of the vSphere entity for which the properties should be written to the XML file
    5. \
  5. #       $childShow      : Boolean switch, export all children of $entityName, and their properties, to the XML file
    6. \
  6. #       $configShow     : Boolean switch, export the properties to the XML file
    7. \
  7. #       $vmDump         : Boolean switch, include VirtualMachines in the XML file
    8. \
  8. #       $profileDir     : directory where the XML file will be written
    9. \
  9. # Author:       LucD
    10. \
  10. # History:
    11. \
  11. #       v1.0 27/08/09   first version, handles Folder, VirtualMachine, Datacenter, HostSystem, ClusterComputeResource, ResourcePool
    12. \
  12. #
    13. \
  13.  
    14. \
  14. # Parameters
    15. \
  15. $entityName = "Clus1"
    16. \
  16. $childShow = $true
    17. \
  17. $configShow = $false
    18. \
  18. $vmDump = $true
    19. \
  19. $profileDir = "C:\\"
    20. \
  20.  
    21. \
  21. # Root of the XML file
    22. \
  22. $vInventory = [xml]"<Inventory></Inventory>"
    23. \
  23.  
    24. \
  24. function New-XmlNode{
    25. \
  25.         param($node, $nodeName)
    26. \
  26.  
    27. \
  27.         $tmp = $global:vInventory.CreateElement($nodeName)
    28. \
  28.         $node.AppendChild($tmp)
    29. \
  29. }
    30. \
  30.  
    31. \
  31. function Set-XmlAttribute{
    32. \
  32.         param($node, $name, $value)
    33. \
  33.  
    34. \
  34.         $node.SetAttribute($name, $value)
    35. \
  35. }
    36. \
  36.  
    37. \
  37. function Get-XmlNode{
    38. \
  38.         param($path)
    39. \
  39.  
    40. \
  40.         $global:vInventory.SelectNodes($path)
    41. \
  41. }
    42. \
  42.  
    43. \
  43. function Get-Properties{
    44. \
  44.         param($BaseName, $Property, $XMLnode)
    45. \
  45.  
    46. \
  46.         if(-not($Property -match "DynamicProperty$|DynamicType$")){
    47. \
  47.  
    48. \
  48.                 if($Property.Length -eq 0){
    49. \
  49.                         $XMLnewnode = New-XmlNode $XMLnode $BaseName.Substring(1)
    50. \
  50.                 }
    51. \
  51.                 else{
    52. \
  52.                         $XMLnewnode = New-XmlNode $XMLnode $Property
    53. \
  53.                 }
    54. \
  54.  
    55. \
  55.                 if((Invoke-Expression $BaseName) -ne $null){
    56. \
  56.                         $result = Invoke-Expression $BaseName
    57. \
  57.                         $type = Invoke-Expression ($BaseName + ".GetType()")
    58. \
  58.                         Set-XmlAttribute $XMLnewnode "Type" $type.Name
    59. \
  59.                         if($type.IsArray){
    60. \
  60.                                 $ArrCount = Invoke-Expression ($BaseName + ".Count")
    61. \
  61.                                 Set-XmlAttribute $XMLnewnode "Count" $ArrCount
    62. \
  62.                                 for($i = 0; $i -lt $ArrCount; $i++){
    63. \
  63.                                         Get-Properties ($BaseName + "[" + $i + "]") ($Property + "-" + $i + "-") $XMLnewnode
    64. \
  64.                                 }
    65. \
  65.                         }
    66. \
  66.                         elseif($type.IsPrimitive -or $type.Name -eq "String" -or $type.Name -eq "DateTime"){
    67. \
  67.                                 Set-XmlAttribute $XMLnewnode "Value" $result
    68. \
  68.                         }
    69. \
  69.                         else{
    70. \
  70.                                 $props = $result | gm -memberType Property,NoteProperty
    71. \
  71.                                 foreach($prop in $props){
    72. \
  72.                                         Get-Properties ($BaseName + "." + $prop.Name) $prop.Name $XMLnewnode
    73. \
  73.                                 }
    74. \
  74.                         }
    75. \
  75.                 }
    76. \
  76.         }
    77. \
  77. }
    78. \
  78.  
    79. \
  79. function Get-Configuration{
    80. \
  80.         param($object, $XMLnode, $label)
    81. \
  81.  
    82. \
  82.         New-Variable -Name $label -Value $object
    83. \
  83.         $properties = Get-Properties (\'$\' + $label) \'\' $XMLnode
    84. \
  84. }
    85. \
  85.  
    86. \
  86. function Get-Children{
    87. \
  87.         param($entity, $path, $XMLnode, $recurse, $config)
    88. \
  88.  
    89. \
  89.         if("vm","host" -notcontains $entity.Name){
    90. \
  90.                 $path += ("/" + $entity.Name)
    91. \
  91.         }
    92. \
  92.         switch -regex ($entity.gettype().name){
    93. \
  93.                 "Folder" {
    94. \
  94.                         if("vm","host" -notcontains $entity.Name){
    95. \
  95.                                 $XMLnewnode = New-XmlNode $XMLnode "Folder"
    96. \
  96.                                 Set-XmlAttribute $XMLnewnode "Name" $entity.Name
    97. \
  97.                         }
    98. \
  98.                         if($recurse -and $entity.ChildEntity -ne $null){
    99. \
  99.                                 foreach($childfld in (Get-View -Id $entity.ChildEntity)){
    100. \
  100.                                         Get-Children $childfld $path $XMLnewnode $recurse $config
    101. \
  101.                                 }
    102. \
  102.                         }
    103. \
  103.                 }
    104. \
  104.                 "VirtualMachine"{
    105. \
  105.                         if($vmDump){
    106. \
  106.                                 if($entity.Config.Template){$VMtype = "Template"} else {$VMtype = "VM"}
    107. \
  107.                                 $XMLnewnode = New-XmlNode $XMLnode $VMtype
    108. \
  108.                                 Set-XmlAttribute $XMLnewnode "Name" $entity.Name
    109. \
  109.                                 if($config){
    110. \
  110.                                         Get-Configuration $entity.Config $XMLnewnode "Config"
    111. \
  111.                                 }
    112. \
  112.                         }
    113. \
  113.                 }
    114. \
  114.                 "Datacenter"{
    115. \
  115.                         $XMLnewnode = New-XmlNode $XMLnode "Datacenter"
    116. \
  116.                         Set-XmlAttribute $XMLnewnode "Name" $entity.Name
    117. \
  117.                         if($recurse -and $entity.HostFolder -ne $null){
    118. \
  118.                                 foreach($childfld in (Get-View -Id $entity.HostFolder)){
    119. \
  119.                                         Get-Children $childfld $path $XMLnewnode $recurse $config
    120. \
  120.                                 }
    121. \
  121.                         }
    122. \
  122.                 }
    123. \
  123.                 "HostSystem|^ComputeResource$"{
    124. \
  124.                         $XMLnewnode = New-XmlNode $XMLnode "Host"
    125. \
  125.                         Set-XmlAttribute $XMLnewnode "Name" $entity.Name
    126. \
  126.                         if($config){
    127. \
  127.                                 Get-Configuration $entity.Config $XMLnewnode "Config"
    128. \
  128.                         }
    129. \
  129.                         if($recurse -and $entity.ChildEntity -ne $null){
    130. \
  130.                                 foreach($childfld in (Get-View -Id $entity.ChildEntity)){
    131. \
  131.                                         Get-Children $childfld $path $XMLnewnode $recurse $config
    132. \
  132.                                 }
    133. \
  133.                         }
    134. \
  134.                 }
    135. \
  135.                 "ClusterComputeResource" {
    136. \
  136.                         $XMLnewnode = New-XmlNode $XMLnode "Cluster"
    137. \
  137.                         Set-XmlAttribute $XMLnewnode "Name" $entity.Name
    138. \
  138.                         if($config){
    139. \
  139.                                 Get-Configuration $entity.ConfigurationEx $XMLnewnode "ConfigurationEx"
    140. \
  140.                         }
    141. \
  141.                         if($recurse){
    142. \
  142.                                 foreach($esx in (Get-View -Id $entity.Host)){
    143. \
  143.                                         Get-Children $esx $path $XMLnewnode $recurse $config
    144. \
  144.                                 }
    145. \
  145.  
    146. \
  146.                                 $resourcePoolparent = Get-View -Id $entity.ResourcePool
    147. \
  147.                                 if($resourcePoolParent.Vm -ne $null){
    148. \
  148.                                         foreach($vm in (Get-View -Id $resourcePoolParent.Vm)){
    149. \
  149.                                                 Get-Children $vm $path $XMLnewnode $recurse $config
    150. \
  150.                                         }
    151. \
  151.                                 }
    152. \
  152.                                 if($resourcePoolParent.resourcePool -ne $null){
    153. \
  153.                                         foreach($respool in (Get-View -Id $resourcePoolParent.resourcePool)){
    154. \
  154.                                                 Get-Children $respool $path $XMLnewnode $recurse $config
    155. \
  155.                                         }
    156. \
  156.                                 }
    157. \
  157.                         }
    158. \
  158.                 }
    159. \
  159.                 "ResourcePool"{
    160. \
  160.                         $XMLnewnode = New-XmlNode $XMLnode "ResourcePool"
    161. \
  161.                         Set-XmlAttribute $XMLnewnode "Name" $entity.Name
    162. \
  162.                         if($config){
    163. \
  163.                                 Get-Configuration $entity.Config $XMLnewnode "Config"
    164. \
  164.                         }
    165. \
  165.                         if($recurse -and $entity.Vm -ne $null){
    166. \
  166.                                 foreach($childfld in (Get-View -Id $entity.Vm)){
    167. \
  167.                                         Get-Children $childfld $path $XMLnewnode $recurse $config
    168. \
  168.                                 }
    169. \
  169.                         }
    170. \
  170.                 }
    171. \
  171.                 Default{
    172. \
  172.                         write-host "Unhandled type" $entity.gettype().name
    173. \
  173.                 }
    174. \
  174.         }
    175. \
  175. }
    176. \
  176.  
    177. \
  177. # Main function
    178. \
  178. Get-Inventory -Name $entityName | Get-View | % {
    179. \
  179.         Get-Children $_ $path (Get-XmlNode "Inventory") $childShow $configShow
    180. \
  180. }
    181. \
  181.  
    182. \
  182. # Create vProfile XML file
    183. \
  183. $vInventory.Save($profileDir + "vProfile-" + $entityName + ".xml")
    184. \
');document.write('
downloadThis Script brought to you by PoshCode\
\
\
');