LucD notes

After my yadr – A vdisk reporter post I received an email from Dennis Zimmer, known from VMachine blog and as the IcomaSoft CTO. He pointed me to the yUML website and suggested that I could perhaps use part of the yadr script to produce an UML diagram.

As it happended there were already some PowerShell scripts that used the functionality offered by the yUML website to produce UML diagrams. Have a look for example at Use PowerShell and yUML to Create Diagrams by Doug Finke and Create Database Diagrams with Powershell + yUML by Chad Miller.

As you probably guessed by now I was sold to the idea.

function Get-UMLDiagram{
	param($vmName)

	function Set-ULMFromTo{
		param($from, $to, $attrib)

		$result = "[" + $from + "]->[" + $to
		if($attrib){
			$result += "|"
			$attrib | %{
				$result += ([string]$_ + ";")
			}
			$result = $result.TrimEnd(";")
		}
		$result += "],`n"
		$result
	}

	filter Get-SnapHash{
		param($parent)

		$snapHash[$_.Snapshot.Value] = @($_.Name,$parent)
		if($_.ChildSnapshotList){
			$newparent = $_
			$_.ChildSnapShotList | Get-SnapHash $newparent
		}
	}

	$vms = Get-View -ViewType VirtualMachine -Filter @{"Name"=$vmName}

	$snapHash = @{}

	$vms | %{
		$ulmStr = ""
		$vm = $_

		if($vm.Snapshot){
			$vm.Snapshot.RootSnapshotList | Get-SnapHash $vm
		}
		$firstHD = $true
		$_.Config.Hardware.Device | where {$_.DeviceInfo.Label -like "Hard disk *"} | %{
			$hd = $_
			$hdNr = $hd.DeviceInfo.Label.Split(" ")[-1]
			$exDisk = $vm.LayoutEx.Disk | where {$_.Key -eq $hd.Key}
			$diskFiles = @()
			$exDisk.Chain | %{$_.FileKey} | %{$diskFiles += $_}
			$totalDiskAllocated = 0
			$vm.LayoutEx.File | where {$diskFiles -contains $_.Key} | %{
				$totalDiskAllocated += $_.Size
			}
			$hdProp = @()
			if($hd.Backing.ThinProvisioned){
				$hdProp += "Thin"
				$hdProp += ("AllocatedGB=" + ("{0:N0} GB" -f ($totalDiskAllocated / 1GB)))
				$hdProp += ("Used=" + ("{0:P0}" -f ($totalDiskAllocated / 1KB /$hd.CapacityInKB)))
			}
			elseif($hd.Backing.GetType().Name.Contains("RawDisk")){
				$hdProp += "RDM"
			}
			else{
				$hdProp += "Thick"
				$hdProp += ("Allocated=" + ("{0:N0} GB" -f ($totalDiskAllocated / 1GB)))
			}
			$ulmStr += (Set-ULMFromTo ($vm.Name + "{bg:orange}")  ($hd.DeviceInfo.Label) $hdProp)

			$exDisk.Chain[0].FileKey | %{
				$ulmStr += (Set-ULMFromTo ($hd.DeviceInfo.Label + "{bg:green}") $vm.LayoutEx.File[$_].Name.Split("/")[-1] $vm.LayoutEx.File[$_].Size)
			}
			$snapHash.GetEnumerator() | %{
				$key = $_.Key
				$value = $_.Value
				$vm.LayoutEx.Snapshot | where {$_.Key.Value -eq $key} | %{
					$vmsnId = $_.DataKey
					$_.Disk | where{$_.Key -eq $hd.Key} | %{
						if($diskFiles -notcontains $_.Chain[-1].FileKey[0] -and $diskFiles -notcontains $_.Chain[-1].FileKey[1]){
							$chain = $_.Chain[-1]
						}
						else{
							$preSnapFiles = $_.Chain | %{$_.FileKey} | %{$_}
							$vm.layoutEx.Disk | where {$_.Key -eq $hd.Key} | %{
								foreach($chain in $_.Chain){
									if($preSnapFiles -notcontains $chain.FileKey[0] -and $preSnapFiles -notcontains $chain.FileKey[1]){
										break
									}
								}
							}
						}
						if($firstHD){
							$ulmStr += (Set-ULMFromTo ($value[1].Name + "{bg:yellow}") ($value[0] + "{bg:yellow}"))
							$ulmStr += (Set-ULMFromTo $value[0] $vm.LayoutEx.File[$vmsnId].Name.Split("/")[-1] $vm.LayoutEx.File[$vmsnId].Size)
						}
						$ulmStr += (Set-ULMFromTo $value[0] ($value[0] + "-HD" + $hdNr + "{bg:blue}"))
						$chain.FileKey | %{
							$ulmStr += (Set-ULMFromTo ($value[0] + "-HD" + $hdNr) $vm.LayoutEx.File[$_].Name.Split("/")[-1] $vm.LayoutEx.File[$_].Size)
						}
					}
				}
			}
			$firstHD = $false
		}
		$ulmStr.TrimEnd(",`n")
	}
}

# Based on Doug Finke's original Get-yUMLDiagram function.
# See: http://dougfinke.com/blog/index.php/2009/05/06/use-powershell-and-yuml-to-create-diagrams/
# Added the "scruffy" switch and rearranged some of the lines
#
function Get-yUMLDiagram {
    param(
        $yUML,
        $diagramFileName = "C:\yUML.jpg",
        [switch]$show,
        [switch]$pdf,
		[switch]$scruffy
    )

	$scruffyPath = ""
	if($scruffy){
		$scruffyPath = "scruffy/"
	}
    $base = "http://yuml.me/diagram/" + $scruffyPath + "class/"
    $address = $base + $yUML

	$wc = New-Object Net.WebClient
	if($pdf){
		$diagramFileName = $diagramFileName.Replace($diagramFileName.Split(".")[-1],"pdf")
		$address += ".pdf"
	}
    $wc.DownloadFile($address, $diagramFileName)
    if($show) {
        Invoke-Item $diagramFileName
	}
}

$vmName = "MyVM1"
$diagram = Get-UMLDiagram $vmName

Get-yUMLDiagram $diagram "D:\yULM.jpg" -show

Line 1: The Get-UMLDiagram function does the hard work of analysing the data in the VirtualMachineFileLayoutEx object. The LayoutEx property in each VirtualMachine object points to this VirtualMachineFileLayoutEx object. The function takes one parameter, the name of the virtual machine for which you want to produce the UML diagram.
Line 4-17: The Set-ULMFromTo is an internal function that produces the correct text to draw a box-to-box diagram.

Line 19-27: This internal filter stores how the snapshots are related in a hash table. The filter has been expanded with extra data compared to the filter with the same name in the yadr script.

Line 33: The main loop of the Get-ULMDiagram function.

Line 34: The text that is passed to the yUML website is collected in this variable.

Line 37-39: Read the snapshot tree and store it in a hash table.

Line 41: Loop through all the virtual machine’s devices but only take the hard disks for further processing.

Line 44: Get the correct hard disk, if there are more than one.

Line 48-50: Calculate the total storage allocated to this hard disk. This will be displayed as an attribute in the UML diagram.

Line 52-63: Determine what type of hard disk we are dealing with. The script can distinguish Thick, Thin and RDM disks.

Line 69: If there are snapshots, this is the loop through all them. The script will extract the information for the c urrent hard disk.

Line 88: To avoid double lines in the UML diagram when we have more than one hard disk, I use the switch $firstHD. The lines between the snapshots are only drawn for the first hard disk.

Line 109-134: The Get-yUMLDiagram function was originally written by Doug Finke. I expanded it to support the “scruffy” option.

The function, called Get-yUMLDiagram, does the actual call to the yUML website and receives the requested output.

This function’s parameters allow you to select which type of output you want, the style of the diagram and if the diagram should be displayed on screen.

Notice the attributes for Hard disk 1. It’s a Thick provisioned disk and 8 Gb have been allocated.

The Hard disk 1 box points to the two actual files on the datastore. They each have as attribute the size (in bytes) of the file.

Notice that Hard disk 1 is a Thin provisioned disk.

The Snapshot1 branch connects to the .vmsn file and the files for Hard disk 1 that were created due to the snapshot.

This is something you probably shouldn’t see in real life

But I included it to show you how the snapshot tree is represented in the UML diagram.