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

New Tape Backup Device!

A friend sent me a picture of his new tape backup device.
I thought I would share…

Powershell: Text To Speech – Part 2

SAPI.SPVoice: Part 2

I wrote a previous entry about the ability to generate speech from text. This time, I provide a semi-practical use for doing so.

In this example, we are scanning our outlook 2010 inbox folder for new emails. If one is found, we use the SAPI.SPVoice object to playback the FROM and SUBJECT fields.

A simple but effect way to use text to speech from powershell. Here is the entire script:

######
###
###  Powershell Script to review Outlook 2010 Email and provide TTS 
###  alerts when a new message is delivered - just for fun!
###
###	 Version 1.2
###  Patrick McKibbins
###  8/21/13
###
######

Clear-Host
$ScriptVersion = "Version 1.2"
$ScriptFileName = $MyInvocation.MyCommand.Definition
Write-Host ("`n{0}`n" -f " [ Program: ] [ $ScriptFileName ]  [ $ScriptVersion ]") -ForegroundColor Yellow

#Function to process text to speech
function mySay {
    param(
        [Parameter(Mandatory=$true)]
        $Text,
 
        [switch]
        $Slow
    )
 
    $object = New-Object -ComObject SAPI.SpVoice
    if ($Slow) { $object.Rate = -10 }
    $object.Speak($text) | Out-Null
}

# Verify Volume is loud enough
mySay "Testing Volume."

# Setup MAPI connection to local Outlook client
$OutLookFolderInbox = 6
$outlook = new-object -com outlook.application;
$NameSpace = $outlook.GetNameSpace("MAPI");

# Create an Endless Loop that simply scans the inbox for new emails
# If a new email is found, it marks it as read and notifies you via TTS alert
$a=0	#Loop Count
$b=0	#Message Count

while($true)
{

	# Gather inbox details
	$inbox = $NameSpace.GetDefaultFolder($OutlookFolderInbox)
	
	#checks 10 newest messages / $found = $false unless new message is found
	$Found = $false
	$inbox.items | select -first 10 | foreach {
	if($_.unread -eq $True) {
		$Found = $true
		$b++

		# build strings of details for TTS
		# Also replacing RE: with 'Reply' for TTS clarity
		# Replace FW: with 'Forwarded Message'
		$s1 = "You have a new email message from: " + $_.SenderName + ("`n")
		$s2 = "Subject: " + $_.Subject + ("`n") -replace "RE: ", "Reply, "
		$s2 = $s2 -replace "FW: ", "Forwarded Message, "
				
		# Output details to screen for review
		$d0 = "       Date: " + (get-date).tostring()
		$d1 = "       From: " + $_.SenderName + ("`n")
		$d2 = "    Subject: " + $_.Subject + ("`n")
		$d3 = "       MSG : [" + $b +"] LC: (" +$a +")"
		
		Write-Host ("`n{0}`n" -f " ----- ") -ForegroundColor blue
		Write-Host ("{0}" -f $d3) -ForegroundColor cyan
		Write-Host ("{0}" -f $d0) -ForegroundColor green
		Write-Host ("{0}" -f $d1) -ForegroundColor green
		Write-Host ("{0}" -f $d2) -ForegroundColor green
		Write-Host ("{0}" -f " ----- ") -ForegroundColor blue
		
		# Mark current new message as read
		$_.UnRead = $false
		
		# TTS Output of details
		mySay $s1
		mySay $s2
	} 
}

# Sleep for 5 seconds then rinse and repeat
start-sleep 5

# $a is just being used to let us know how many times the loop has been processed - it serves no other purpose
$a++
# write-host $a " " -nonewline

}

######
###
###  The End...
###
######

I’ve included some minor remarks in the script to help understand the flow. If needed, I can provide a PART 3 that breaks it down further at a later date.

So there you have it! A practical use for Text to Speech via Powershell that is quick and easy!

— PFM

ESXi Releases and Build Numbers

vSphere ESXi 5.1

Name	Version	Release	Build
ESXi510-201212001	5.1.0 Patch 2	2012-12-20	914609
ESXi510-201210001	5.1.0 Patch 1	2012-10-24	838463
KB2034796	5.1.0	Hot-Patch	837262
VMware ESXi 5.1	5.1.0	2012-09-11	799733

vSphere ESXi 5.0

Name	Version	Release	Build
VMware ESXi 5.0 Update 2	5.0.0 U2	2012-12-20	914586
ESXi500-201209001	5.0.0 Patch 8	2012-09-27	821926
ESXi500-201207001	5.0.0 Patch 7	2012-07-12	768111
ESXi500-201206001	5.0.0 Patch 6	2012-06-14	721882
ESXi500-201205001	5.0.0 Patch 5	2012-05-03	702118
ESXi500-201204001	5.0.0 Patch 4	2012-04-12	653509
VMware ESXi 5.0 Update 1	5.0.0 U1	2012-03-15	623860
ESXi500-201112001	5.0.0 Patch 3	2011-12-15	515841
ESXi500-201111001	5.0.0 Patch 2	2011-11-03	504890
ESXi500-201109001	5.0.0 Patch 1	2011-09-13	474610
VMware ESXi 5.0	5.0.0	2011-08-24	469512

vSphere ESXi 4.1

Name	Version	Release	Build
ESXi410-201301001	4.1.0 Patch 10	2013-01-31	988178
ESXi410-201211001	4.1.0 Patch 9	2012-11-15	874690
VMware ESXi 4.1 Update 3	4.1.0 U3	2012-08-30	800380
ESXi410-201206001	4.1.0 Patch 8	2012-06-14	721871
ESXi410-201205001	4.1.0 Patch 7	2012-05-03	702113
ESXi410-201204001	4.1.0 Patch 6	2012-04-26	659051
ESXi410-201201001	4.1.0 Patch 5	2012-01-30	582267
VMware ESXi 4.1 Update 2	4.1.0 U2	2011-10-27	502767
ESXi410-201107001	4.1.0 Patch 4	2011-07-28	433742
ESXi410-201104001	4.1.0 Patch 3	2011-04-28	381591
VMware ESXi 4.1 Update 1	4.1.0 U1	2011-02-10	348481
ESXi410-201011001	4.1.0 Patch 2	2010-11-29	320137
ESXi410-201010001	4.1.0 Patch 1	2010-11-15	320092
VMware ESXi 4.1	4.1.0	2010-07-13	260247

vSphere ESXi 4.0

Name	Version	Release	Build
ESXi400-201209001	4.0.0 Patch 16	2012-09-14	787047
ESXi400-201206001	4.0.0 Patch 15	2012-06-12	721907
ESXi400-201205001	4.0.0 Patch 14	2012-05-03	702116
ESXi400-201203001	4.0.0 Patch 13	2012-03-30	660575
VMware ESXi 4.0 Update 4	4.0.0 U4	2011-11-17	504850
ESXi400-201110001	4.0.0 Patch 12	2011-10-13	480973
VMware ESXi 4.0 Update 3	4.0.0 U3	2011-05-05	398348
ESXi400-201104001	4.0.0 Patch 11	2011-04-28	392990
ESXi400-201103001	4.0.0 Patch 10	2011-03-07	360236
ESXi400-201101001	4.0.0 Patch 9	2011-01-04	332073
ESXi400-201009001	4.0.0 Patch 8	2010-09-30	294855
VMware ESXi 4 Update 2	4.0.0 U2	2010-06-10	261974
ESXi400-201005001	4.0.0 Patch 7	2010-05-27	256968
ESXi400-201003001	4.0.0 Patch 6	2010-04-01	244038
ESXi400-201002001	4.0.0 Patch 5	2010-03-03	236512
ESXi400-200912001	4.0.0 Patch 4	2010-01-05	219382
VMware ESXi 4 Update 1	4.0.0 U1	2009-11-19	208167
ESXi400-200909001	4.0.0 Patch 3	2009-09-24	193498
ESXi400-200907001	4.0.0 Patch 2	2009-08-06	181792
ESXi400-200906001	4.0.0 Patch 1	2009-07-09	175625
VMware ESXi 4	4.0.0	2009-05-21	164009

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

SQL Funny!

SELECT *
FROM [Users]
WHERE [Clue] > 0
No records found.