VMware ESXi 5.5 and NetApp SAN – VMFS Unmap

Phantom Space…

Anyone that has to work with LUNs and Datastores with VMware should know the term.

If not, here’s a quick refresher:

You have a 2TB datastore that has a single VM with two drives.  A C: drive that is 50GB and an F: drive that is 150GB.

You are using thick provisioning on the VM side, but thin on the SAN side.

The SAN says that you are currently using 200GB of space.  Easy.

Now, you create a snapshot before applying patches.  That snapshot is left alone for a few days, and grows to about 50GB in size.

Check the SAN – it says that you are currently using 250GB of space.

Delete that snapshot and presto!  What does the SAN say you are using now?

… 250GB!

Wait!  How is that possible?  We just deleted that snapshot data, so we should be back to 200GB in use.

This excess space is considered Phantom Space.  It’s no longer being used by VMware, but the SAN still sees it and holds on to that space.

The same thing happens if you create a new VMDK file and then later delete it.

How can you reclaim this Phantom Space?  Ask most SAN Engineers and they’ll tell you that you have to migrate anything remaining on the datastore to a new one and delete the old datastore.

Thats not so easy if you have to move lots of VMs.  Plus, the next time you create a new snapshot, your right back where you started with excessive phantom space.

What to do?  Powershell to rescue!

$vc = "vcenter"
$vmHost = "esxi01"
$nacon = "netapp3"
$vol = "T3V_0128"
$lun = "t3L_0128"
$path = "/vol/$vol/$lun"
$Size = 800

Connect-VIServer $vc | Out-Null
Connect-NaController $nacon | Out-Null

$DSData = Get-NaLun $Path
$BeforeUsed = "{0:N3}" -f ($DSData.SizeUsed / 1024 / 1024 / 1024)

$esxcli = Get-EsxCli -vmhost $vmHost
$esxcli.storage.vmfs.unmap($Size, $lun, $null)

$DSData = Get-NaLun $Path
$AfterUsed = "{0:N3}" -f ($DSData.SizeUsed / 1024 / 1024 / 1024)

The snippet of code above will perform a SCSI UNMAP (old name) or VMFS UNMAP (new name) on a particular datastore.  This is a task that should be scheduled and run multiple times per datastore to see any real benefit.

Some things to note:

$Size is how big of a block to work with – This is usually 200, 400, 800 or 1600.  The bigger the block size, the more IOPS will be committed to the process.  Be careful when using in a production environment and be sure to test!

$BeforeUsed is simply the amount of space the SAN says is in use before the VMFS UnMap command is run.

$AfterUsed is simply the amount of space the SAN says is in use after the command completes.

$lun and $vol are CASE Sensitive!

If there is any interest, I’ll add a new post with some samples of how to use this process in a scheduled task.

 

Advertisement

Powershell: Text to Speech

I was playing around with some Powershell scripts over the weekend and came across a very interesting object:

SAPI.SPVoice

This object lets you generate speech from text and is very easy to use. I’ve included a few samples here to show just how easy!

In this example, we call our simple function with the text we want to hear. We also have an optional switch parameter called -SLOW that will change the speed of the speech, just for fun. This example is using a ComObject to generate the speech.

#
# This first section will generate speech from text using a ComObject
#
function Say-Text1 {
    param(
        [Parameter(Mandatory=$true)]
        $Text,

        [switch]
        $Slow
    )

    $object = New-Object -ComObject SAPI.SpVoice
    if ($Slow) { $object.Rate = -10 }
    $object.Speak($text) | Out-Null
}

Say-Text1 "Testing One, Two, Three!"
Say-Text1 "Testing Four and Five!" -Slow
#
#

In the next example, we will use .NET to create the speech. We again call our function with the text we want to hear. By default, we have the speech running as a synchronous command.

(This simpy means that the speech will have to finish before moving on to the next command.)

We added another optional switch parameter for this one, however, if you want the command to run asynchronously instead (-ASYNC).

NOTE: When using the -ASYNC parameter, if you have multiple speech statements right after each other, the speech will be ‘clobbered’, as if two or more people were trying to speak at exactly the same time.

#
# The next section will generate speech from text using .NET
function Say-Text2 {

   param (
           [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
           [string] $Text,
           [switch] $Async=$false
         )

   [Reflection.Assembly]::LoadWithPartialName('System.Speech') | Out-Null
   $object = New-Object System.Speech.Synthesis.SpeechSynthesizer
   if ($Async) {
       $object.SpeakAsync($Text)
   } else {
       $object.Speak($Text)
   }
}

Say-Text2 "Testing Six, Seven and eight!"
Say-Text2 "Testing Nine and Ten!  Then we wait 10 seconds." -Async
start-sleep 10
#
#

You can even read in a text file and have it converted to speech for you as well! Here is a quick example of how to do it:

#
# First we just create the ComObject
$voice = new-object -ComObject "SAPI.SPVoice"

# Then we use the new object to speak!  This command is spoken synchronously.
$voice.speak("Powershell rocks!")

# And this minor change reads in and speaks a text file asynchronously.
$voice.Speak( "h:\scripts\callme.bat", 5 )
start-sleep 20
#
#

So there you have it! Text to Speech via Powershell is quick and easy!

— PFM

Powershell: What is Your Windows Product Key

So..

One of the laptops that I regularly use is a MacBook Pro.  It runs the latest and greatest OS X version along with BootCamp and Windows 7.  For those of you unfamiliar with BootCamp, it basically just allows you to dual-boot your Mac laptop and switch between OS X or Windows.

Since Windows 8 has been officially released, I decided to rebuild my MacBook Pro from scratch and use BootCamp to install Windows 8.  If I liked it, I would keep it.  If not, I would redo BootCamp and put Windows 7 back in place.

However, since the previous install of Windows 7 was a digital download and I seem to have misplaced my email receipt that contained my Windows Product Key, if I decided to switch back to Windows 7, I would not be able to activate it without some difficulties.

I did some searching online for a tool to identify your current product key and found Magical Jelly Bean.  It’s an app that you install in Windows and it reveals your key.  Pretty simple.

But what if you don’t have access to the internet or you simply don’t want to install an unknown app just to get your key?

Powershell to the rescue!

Run the Powershell code below to generate your Windows Product Key.  Quick and Easy:

function get-windowsproductkey([string]$computer)
{
$Reg = [WMIClass] ("\\" + $computer + "\root\default:StdRegProv")
$values = [byte[]]($reg.getbinaryvalue(2147483650,"SOFTWARE\Microsoft\Windows NT\CurrentVersion","DigitalProductId").uvalue)
$lookup = [char[]]("B","C","D","F","G","H","J","K","M","P","Q","R","T","V","W","X","Y","2","3","4","6","7","8","9")
$keyStartIndex = [int]52;
$keyEndIndex = [int]($keyStartIndex + 15);
$decodeLength = [int]29
$decodeStringLength = [int]15
$decodedChars = new-object char[] $decodeLength
$hexPid = new-object System.Collections.ArrayList
for ($i = $keyStartIndex; $i -le $keyEndIndex; $i++){ [void]$hexPid.Add($values[$i]) }
for ( $i = $decodeLength - 1; $i -ge 0; $i--)
    {
     if (($i + 1) % 6 -eq 0){$decodedChars[$i] = '-'}
     else
       {
        $digitMapIndex = [int]0
        for ($j = $decodeStringLength - 1; $j -ge 0; $j--)
        {
            $byteValue = [int](($digitMapIndex * [int]256) -bor [byte]$hexPid[$j]);
            $hexPid[$j] = [byte] ([math]::Floor($byteValue / 24));
            $digitMapIndex = $byteValue % 24;
            $decodedChars[$i] = $lookup[$digitMapIndex];
         }
        }
     }
$STR = ''
$decodedChars | % { $str+=$_}
$STR
}
get-windowsproductkey .

Powershell: Working with Excel

A few days ago at work I needed to create a quick report on some info from one of our VMware clusters.  I proceeded to dump some data to a CSV file and then converted it to an XLS file.

I then modified/cleaned up the data and my report was done.

I started to clean up the code for reuse and decided to skip the CSV file altogether and just save the data directly to an Excel file.

Listed here are some samples to do just that:

NOTE: This assumes that you have powershell and Excel installed on your local machine.

Create the Spreadsheet

For starters, we use the Excel COM object to create a workbook with a worksheet.

$excel = new-object -comobject Excel.Application
$workbooks = $excel.Workbooks.Add()
$worksheets = $workbooks.worksheets
$worksheet = $worksheets.Item(1)
$worksheet.Name = “Name of Worksheet”

If you have data in a spreadsheet that you just want to query, its usually best to just keep the Excel window hidden by setting the following value to $False.  However if you want to see the Excel window you just set the value to $True:

$excel.Visible = $True

If you were run the script at this point, and you enabled the $Excel.Visible value, you would have a blank Excel spreadsheet open and ready to receive data, but not very useful at this point.

Adding information

Now we can start doing some useful things. We can actually modify specific cells within the spreadsheet. The following examples will add some text to a few cells.

$worksheet.Cells.Item(1,1) = “This is CELL A1”
$worksheet.Cells.Item(3,4) = “This is CELL D3”

This puts “This is CELL A1” into A,1 and “This is CELL D3” into D,3. The first number is the row identifier and the second number is the column identifier.

Formatting data

You can even customize the cells by changing the fonts used, the font size and even BOLD the text if needed. The following sample shows how to accomplish this:

$worksheet.Cells.Item(1,1).Font.Bold = $True
$worksheet.Cells.Item(1,1).Font.Size = 22
$worksheet.Cells.Item(4,3).Font.Italic = $True
$worksheet.Cells.Item(4,3).Font.Size = 14

What if you have over 100 cells that need format changes? If would be very time consuming to add more than 200 lines of code needed to accomplish that by using the methods above. But there are alternatives available. We can format a range of cells by using the following:

$range = $excel.Range(“C3″,”C4″)
$range.ColumnWidth = 50
$range.Borders.Color = 0
$range.Borders.Weight = 2
$range.Interior.ColorIndex = 37
$range.Font.Bold = $True
$range.HorizontalAlignment = 3

If you are curious about all of the values that can be modified, type the following command:

$range | get-member

Saving the Spreadsheet

Once your done modifying the spreadsheet, you should be sure to save your data.
This can be done by using:

$workbooks.SaveAs(“c:\automate.xlsx”)
$excel.quit()

Conclusion

Once the spreadsheet is saved, you could even use Powershell to send it via email or copy it to a network share. You can even schedule the powershell script to run as a scheduled task and automate the whole process.

— PFM