I was reading Doug Finke’s Blog and he provided a link to what the Clustering team at Microsoft is doing with Windows 2008 R2 out in beta . They have created a bunch of cmdlets for Clustering … very cool stuff . Cluster.exe will become legacy . This should help Administrators with Automating clustering functions . Check it out and also check out Doug’s blog which is very good also.
Chris
I thought it would be cool to convert a vbscript to powershell . I took just a simple vbscript from the Hey Scripting Guys column here . The following is the vbscript:
Set objFS = CreateObject("Scripting.FileSystemObject")
Set objRegExp = new RegExp
objRegExp.Pattern = "((?:(\d{1,2}|[a-fA-F]{1,2}){2})(?::|-*)){6}"
Set objFile = objFS.OpenTextFile("C:\logs\logfile.txt")
strFileContents = objFile.ReadAll
arrLines = Split(strFileContents,vbNewLine)
For Each strLine in arrLines
Set colMatches = objRegExp.Execute(strLine)
For Each strMatch in colMatches
WScript.Echo strMatch
Next
Next
This script extracts MAC addresses from a log file . Lets say you had a delimited text file with this info
192.168.1.5,00-00-00-00-00-00,T
Here is what I came up with in powershell
## Extracting a MAC Address
$re = [regex]"((?:(\d{1,2}|[a-fa-f]{1,2}){2})(?::|-*)){6}"
gc ".\log.txt" | % { $matches = $re.Match($_)};$matches.Value
The toughest part is creating the regex .
Happy Holidays
Chris
Hi Powershell people …
Powershell is just getting more and more attention each day . I use to do things in vbscript and have not touched vbscript in a long time . That is how much I love powershell . I do not think I’m a Powershell fanboy (but you might think so ) and I don’t think being one is a bad thing . I mean its very powerful tool . Now with the announcement of V2 coming in 2009 we as administrators are starting to see things in a different light . Back to the point of this blog I wanted to share a pretty quick and dirty script with you . I mean its quick and dirty because I haven’t spent the time to make it production ready although you would not need to change much to make it production . Some of you might think its production ready but I will share with you what I think it needs . Just that I didn’t have the time .
We are creating a powershell script to basically parse the netlogon.bak file (because the netlogon.txt file is locked under normal operation ) on a DC . Now there are plenty of tools out there that do something similar . If you use on of those thats fine but I love to try and create my own command line tool . Some tools that you might use is eventcomb from Microsoft . Accountlockout is another gui that will tell you where the account is locked out and what time the lockout occurred . It also lets you unlock the account . Eventcomb is nice in that you can search for different criteria like userid ,Event ID’s ,Multiple computers .
So to recap this script will create a results.txt file that will contain all lines in the netlogon.bak file that match the User you pass to the script . For those that are not sure of where the netlogon.bak file is located its in the %windir%\debug folder . This is a GREAT way to find out if the user is being locked out from another machine which is a large percentage of the case mostly . You get these calls from users that don’t know that they may have logged onto a Server or PC and that is the cause or possibly a service is running on a Server with their ID running a service . This log file is helpful in solving these problems . This shouldn’t be the only tool you use but it will help you in determining the root cause .
Here is the Script :
######################################################
#Scriptname : Get-AccountLockoutInfo.ps1
#Created by : Chris Federico
#Date : 11/18/2008
######################################################param ($logonserver,$userid,$help)function funHelp()
{
$helpText=@"NAME: Get-AccountLockoutInfo.ps1
Parses the netlogon.bak File for information regarding the account ID that was passed .PARAMETERS:
-logonserver specifies the logon Server for the User
-userid specifies the userID for the User
-help Prints Help File
SYNTAX:
.\Get-AccountLockoutInfo.ps1 -logonserver Foo -userid Johnb
queries the Netlogon.bak file on server Foo for userid Johnb and logs entries that are related to lockouts .
.\Get-AccountLockoutInfo.ps1 -help ?
Prints out help file.
"@
$helpText
exit
}
function funParse-SecurityLogFile($logonserver,$userid)
{
#for windows 2000 Systems
$log = gc "\\$logonserver\c$\debug\netlogon.bak" | % { if ($_ -match $userid) {$_ | Out-File ".\results.txt" -Append}}
#For Windows 2008 Systems
$log1 = gc "\\$logonserver\c$\windows\debug\netlogon.bak" | % { if ($_ -match $userid) {$_ | Out-File ".\results.txt" -Append}}
}
# surpress errors
$ErrorActionPreference = "SilentlyContinue"
#Check to see if help text is requested
if($help) { write-host "Printing help now..." -ForegroundColor Blue;funHelp}
#Check to see if forward and reverse arguments have been entered.
if(!$logonserver) {write-host "You must Supply a logon Server." -ForegroundColor Red ; funHelp}
if(!$userid) {write-host "You must Supply a userid to search" -ForegroundColor Red ; funhelp}
#Create a new Results File.
New-Item -ItemType file -path ".\results.txt" -Force
#Call function that does all the work.
funParse-SecurityLogFile $logonserver $userid
The reason why I think that this script is not primetime production is because I don’t include a way to tell if the DC your using is a windows 2000 or 2008 or 2003 . So I made 2 variables log and log1 which use different paths . This is not a show stopper though because I’m suppressing Errors ($ErrorActionPreference = “SilentlyContinue”) . If you would like to add a WMI section to find out if the target DC is a windows 2000 or 2003 or 2008 then I think it would be ready . You can probably use s switch statement to perform the appropriate action for example .
switch ($Server)
{
“Windows 2000″ {##Read the log file}
“Windows 2003″ {##Read the log file }
“Windows 2008″ {##Read the log file }
}
To to summarize … the results.txt file will have all the lines in the netlogon.bak file that have the UserID you passed into the script . So checkout the netlogon.bak file to see what kind of information it shows .It is really helpful .
Take Care ,
Chris Federico
Here is the link to the Windows Powershell Blog about WS2008R2 and W7 having powershell integrated within the OS . Very cool which is why its so important to read up on powershell if your a Windows IT Pro . Seems like the future of all things Microsoft will include powershell . That is definitely not a bad thing .
WS08r2 and W7
I’m not a NY Times reader but here is a link about Powershell and W7
http://www.nytimes.com/external/idg/2008/10/28/28idg-10-best-feature.html?pagewanted=1
Also if your interested in Media Center on Windows 7 here is a cool write-up of it :
http://www.wegotserved.co.uk/2008/10/28/windows-7-media-center-revealed/
That’s it !
Chris
Hi Folks ,
If you are one of those lucky people that update DNS records for Windows 2008 then you might find this blog useful . Note:This blog is only for Windows 2008 DNS Server .There is not that much examples on the web for updating the DNS Server .
Since I do a lot of these updates I wanted to automate the process . I wanted to do this for 2 reasons . One its extremely fast for update 10 A and PTR records with scripting . Second reason is to cut down on errors . You can make errors easily when entering in a PTR record . So lets begin …..
Before we begin the script that I’m going to walk you thru Creates new A records and PTR records in DNS by reading a csv file . It doesn’t delete records but you can add that functionality easily .
We start by creating our Params . The way this script will work is by calling the script like this :
.\Update-DNS.ps1 -forward ServerName -reverse ServerName
This will become more apparent when I show the help file…
So my params line is first and it looks like this :
param ($forward,$reverse,$dnsaddresslist = (Import-Csv ".\dnsaddresslist.csv"),$help)
The great thing about powershell is that when you define your parameters first in your script ,you are able to use them like switches . So the $forward variable would be -forward SeverName .
The next section starts our functions starting with the help function :
function funHelp()
{
$helpText=@”
NAME: Update-DNSAddress.ps1
DESCRIPTION:
Creates DNS entries from a csv file called dnsaddresslist.csv .It
Creates a Forward and Reverse lookup Zone entry in the zone
servers specified.
Prerequisites:
You should have a dnsaddresslist.csv file in the same directory as the script.
When the script starts it reads this file. An error will occur if the file
is not present.
PARAMETERS:
-forward specifies the forward lookup zone Server (required)
-reverse specifies the reverse lookup sone Server (required)
-help Prints Help File
OTHER:
-dnsaddresslist Holds dns entry information in the csv file
SYNTAX:
.\Update-DNSAddress.ps1 -forward serverName -reverse ServerName
Creates forward and reverse entries from all devices listed
in dnsaddresslist.csv to the servers specified .
“@
$helpText
exit
}
I cannot take credit for the way this looks I have been reading the Microsoft powershell Book and Ed Wilson who is awesome creates these help functions which is great way to put help documention into a script .
Next I created a Check to see if the Forward and Reverse Servers are online .
function funCheck-DNSServersStatus ($forward,$Reverse)
{
Write-Host “Verifying if DNS Servers are Reachable…..”
# Create our object
$net = New-Object System.Net.NetworkInformation.Ping
#Check the Forward lookup Server
do {$result =$net.send($forward);}
until ($result.status -eq “Success”)
#Create message that Server is reachable
Write-Host “Forward lookup server ,$forward, is reachable …..”
#Check if the reverese Server is reachable .
do {$result =$net.send($reverse);}
until ($result.status -eq “Success”)
#Create message that the reverse lookup server is reachable
write-host “Reverse lookup server,$reverse,is reachable……”
}
We are passing the function both server name .If you check the function we are using the System.Net.NetworkInformation.Ping Class to communicate with the servers . Like a ping from a command prompt . Then using a Do … until loop .
Hopefully your DNS servers are up and running 
. You can also add another check to see if the DNS service is running also which would be a good thing to check .
The next 2 functions are the update . You might be asking by I have separate functions for the forward and the reverse . Its becuase where I work we do A record updates on one server and PTR records on another Server . So the last 2 Functions look like this :
function funUpdate-forward($forward,$dnsaddresslist)
{
# Domain Name
$strDomain =”Test.Microsoft.com”
# create instance of ResourceRecord
$objRR = [WmiClass]“\\$forward\root\MicrosoftDNS:MicrosoftDNS_ResourceRecord”
foreach($a in $dnsaddresslist)
{
Write-Host ” Updating forward lookup zone with $a” -ForegroundColor RED
#create our ip address variable
$address = $a.Address
#create our A name record
$name = $a.Name + “Microsoft.com”
# create our String for record creation
$strRR = $name + ” IN A $address”
#Update Record now
$objRR.CreateInstanceFromTextRepresentation($forward,$strDomain,$strRR)
}
}
function funUpdate-Reverse($reverse,$dnsaddresslist)
{
# create instance of ResourceRecord
$objRR = [WmiClass]“\\$reverse\root\MicrosoftDNS:MicrosoftDNS_ResourceRecord”
foreach ($a in $dnsaddresslist)
{
Write-Host “Updating Reverse Lookup zone with $a” -ForegroundColor Blue
#create our ip address variable
$raddress = $a.Address
#Get the name record
$rname = $a.Name
#break the address into octets
$breakaddress = $raddress.split(‘.’)
#create octets
$rFirst = $breakaddress[0] ; $rSecond = $breakaddress[1] ;$rThird = $breakaddress[2] ; $rFourth = $breakaddress[3]
#create the Reverse lookup String
$strReverseRR = “$rFourth”+”.”+”$rThird”+”.”+”$rSecond”+” IN PTR $rname.test.microsoft.com”
$strReverseDomain = “$rFirst”+”.in-addr.arpa.”
#Call Create Method
$objRR.CreateInstanceFromTextRepresentation($reverse,$strReverseDomain,$strReverseRR)
}
}
Now lets look at the forward first :
We are using WMI to update both A and PTR records . So you need to create and instance .What we are doing is creating the IP address variable and Name variable . Then performing the Method Call which creates the record .
For the Reverse lookup it is much more difficult . We need to create an instance of our WMI object using the MicrosoftDNS_ResourceRecord class . We then read from the csv file and get both the IP and Name . Once we have those variables we reverse the IP address using this bit of code :
#break the address into octets
$breakaddress = $raddress.split(‘.’)
#create octets
$rFirst = $breakaddress[0] ; $rSecond = $breakaddress[1] ;$rThird = $breakaddress[2] ; $rFourth = $breakaddress[3]
#create the Reverse lookup String
$strReverseRR = “$rFourth”+”.”+”$rThird”+”.”+”$rSecond”+” IN PTR $rname.test.microsoft.com”
$strReverseDomain = “$rFirst”+”.in-addr.arpa.”
There is a lot going on here . We are breaking up the address then reversing it to create our string to pass to the method which we call to create our PTR record . Notice that in Windows 2008 you don’t have those cascading folders or Domain’s on the PTR zones like Windows 2003 . This script takes that into account so what ever address you are entering (10. or whatever ) it find the correct folder or Zone .
After going thru our Functions for this script it is time to get to the main portion .
#Check to see if help text is requested
if($help) { “Printing help now…”;funHelp}
#Check to see if forward and reverse arguments have been entered.
if(!$forward) {“You must Supply a forward lookup zone DNS server” ; funHelp}
if(!$reverse) {“You must Supply a reverse lookup zone DNS server” ; funhelp}
# Show the contents of the txt file and ask the user if they would like to continue
Write-Host “The following IP address/hosts will be entered in DNS.”
#contents file
$dnsaddresslist
#let the user make a descion if they would like to continue.
$decision = Read-Host “Would you like to continue Y or N–”
switch($decision.toupper())
{
Y{continue}
N{exit}
}
#Call to verify DNS Servers .
funCheck-DNSServersStatus $forward $reverse
#now that we have all the information lets update forward zone
funUpdate-forward $forward $dnsaddresslist
#update reverse zone
funUpdate-Reverse $reverse $dnsaddresslist
First we are seeing if help parameter has been passed if so it prints the Help file . Next it checks to make sure the Forward and Reverse Servers are passed which are required .
Next it prints out the csv file and gives the user a decsion to continue or not . Sort of like a warning .After all we are updating some important stuff .
Last but not least we call the functions .
Here is the finished Script :
####################################################################
#ScriptName : update-DNSAddress
#Created by : Chris Federico
#Date Created : 09/09/2008
#Modifications:
###################################################################param ($forward,$reverse,$dnsaddresslist = (Import-Csv ".\dnsaddresslist.csv"),$help)
function funHelp()
{
$helpText=@”
NAME: Update-DNSAddress.ps1
DESCRIPTION:
Creates DNS entries from a csv file called dnsaddresslist.csv .It
Creates a Forward and Reverse lookup Zone entry in the zone
servers specified.
Prerequisites:
You should have a dnsaddresslist.csv file in the same directory as the script.
When the script starts it reads this file. An error will occur if the file
is not present.
PARAMETERS:
-forward specifies the forward lookup zone Server (required)
-reverse specifies the reverse lookup sone Server (required)
-help Prints Help File
OTHER:
-dnsaddresslist Holds dns entry information in the csv file
SYNTAX:
.\Update-DNSAddress.ps1 -forward ServerName -reverse ServerName
Creates forward and reverse entries from all devices listed
in dnsaddresslist.csv to the servers specified .
“@
$helpText
exit
}
function funCheck-DNSServersStatus ($forward,$Reverse)
{
Write-Host “Verifying if DNS Servers are Reachable…..”
# Create our object
$net = New-Object System.Net.NetworkInformation.Ping
#Check the Forward lookup Server
do {$result =$net.send($forward);}
until ($result.status -eq “Success”)
#Create message that Server is reachable
Write-Host “Forward lookup server ,$forward, is reachable …..”
#Check if the reverese Server is reachable .
do {$result =$net.send($reverse);}
until ($result.status -eq “Success”)
#Create message that the reverse lookup server is reachable
write-host “Reverse lookup server,$reverse,is reachable……”
}
function funUpdate-forward($forward,$dnsaddresslist)
{
# Domain Name
$strDomain =”Microsoft.com”
# create instance of ResourceRecord
$objRR = [WmiClass]“\\$forward\root\MicrosoftDNS:MicrosoftDNS_ResourceRecord”
# We have to read in the txt file split it to get IP address and Name
foreach($a in $dnsaddresslist)
{
Write-Host ” Updating forward lookup zone with $a” -ForegroundColor RED
#create our ip address variable
$address = $a.Address
#create our A name record
$name = $a.Name + “FQDNS_NAME”
# create our String for record creation
$strRR = $name + ” IN A $address”
#Update Record now
$objRR.CreateInstanceFromTextRepresentation($forward,$strDomain,$strRR)
}
}
function funUpdate-Reverse($reverse,$dnsaddresslist)
{
# create instance of ResourceRecord
$objRR = [WmiClass]“\\$reverse\root\MicrosoftDNS:MicrosoftDNS_ResourceRecord”
foreach ($a in $dnsaddresslist)
{
Write-Host “Updating Reverse Lookup zone with $a” -ForegroundColor Blue
#create our ip address variable
$raddress = $a.Address
#Get the name record
$rname = $a.Name
#break the address into octets
$breakaddress = $raddress.split(‘.’)
#create octets
$rFirst = $breakaddress[0] ; $rSecond = $breakaddress[1] ;$rThird = $breakaddress[2] ; $rFourth = $breakaddress[3]
#create the Reverse lookup String
$strReverseRR = “$rFourth”+”.”+”$rThird”+”.”+”$rSecond”+” IN PTR $rname.microsoft.com
$strReverseDomain = “$rFirst”+”.in-addr.arpa.”
#Call Create Method
$objRR.CreateInstanceFromTextRepresentation($reverse,$strReverseDomain,$strReverseRR)
}
}
#Check to see if help text is requested
if($help) { “Printing help now…”;funHelp}
#Check to see if forward and reverse arguments have been entered.
if(!$forward) {“You must Supply a forward lookup zone DNS server” ; funHelp}
if(!$reverse) {“You must Supply a reverse lookup zone DNS server” ; funhelp}
# Show the contents of the txt file and ask the user if they would like to continue
Write-Host “The following IP address/hosts will be entered in DNS.”
#contents file
$dnsaddresslist
#let the user make a descion if they would like to continue.
$decision = Read-Host “Would you like to continue Y or N–”
switch($decision.toupper())
{
Y{continue}
N{exit}
}
#Call to verify DNS Servers .
funCheck-DNSServersStatus $forward $reverse
#now that we have all the information lets update forward zone
funUpdate-forward $forward $dnsaddresslist
#update reverse zone
funUpdate-Reverse $reverse $dnsaddresslist
**** Update … I forgot to mention the csv file should look like this :
Name,Address
Hi Folks ,
I do a lot of entries into the reverse look-up zone sometimes . I recently came across something strange . When using the MMC for DNS (Windows 2008 DNS tool ) I had “Advanced” selected in the MMC . When you have “Advanced” selected and go to enter in a ptr record you need to reverse the address (specifically the last 3 octets) . Now if you have “Advanced ” NOT selected it will place the first octet in for you and you can put in the IP address normally from left to right .
Strange Right ?
Who would want to put in reverse entries all the time ?
If this made sense cool if not let me know and I will try to explain it again with pictures .
Thanks
Chris
Hi Folks ,
If you work in an environment where you need to restart Servers in a certain order. One way of validating that a server is back on-line is to ping it . Well how can you do that from Powershell ?
Well by using the .net framework of course . Lets write some code to ping the Server lets say for example that you reboot the server with the wmi class Win32_OperatingSystem like so:
# Reboot Server
$server = gwmi Win32_operatingsystem
$server.reboot()
What you want to do next, especially if you need to keep track of the status of the server online or offiline, is ping the server and based on the status either continue or wait till the server comes back up .
This comes in handy if say you have an application Server and a Database Server . The requirement is to have the Database Server up before the Applications server so the Apps can connect to SQL and there will be no problems . So after rebooting the SQL Server you would setup a ping and some loops as so .
# Create a new instance of ping
$ping = new-object System.Net.Networkinformation.Ping
#Show message that the Server is still reachable
write-host "YourServerName is Still reachable" -NoNewLine -ForegroundColor "Green"
# This piece waits till the Server is no longer Reachable
do{$result = $ping.send("ServerName");write-host "." -NoNewline -ForegroundColor "Green"}
Until($result.status -ne "Success")
Write-host ""
write-host "ServerName is not reachable" -ForegroundColor "Red"
Now we are going to write the code that waits for the Server to Come up .
#This piece waits for the Server to come back online .
do{$result = $ping.send("ServerName");write-host "." -NoNewLine -ForegroundColor "Red"}
until ($result.status -eq "Success")
So to recap we used some do …until loops to wait for the Server to come back online . This is a good way to control the process . If you know any other ways to properly control scripts when rebooting Servers please write in the comments . Or if you like this technique please let me know
Thanks and I hope this helps your scripting needs .
Chris
Hi Folks ,
I haven’t been blogging as you can see for a long time . So I thought I can create a pretty cool blog about DataTables . I’m not talking about DataSets which are made up of more than one table .
Why are DataTables cool ? Well it provides an easy way to create structured output . Things always look nice when they are structured in tables . The Datatable is created in memory . The cool thing about that is that you can do some sorting before dumping it to a file or on the screen . I won’t go into sorting but I just wanted to show how simple it is to create a datatable.So lets get to it .
We are going to do something cool with this . Lets create a table of the logical drives on the local machine . We are going to want to find out the following :
Drive Letter
Size of Drive
Used (How much of the drive is used )
Free Space (How much of the drive is free)
Percent Free
So right off the bat we have 5 columns . So to start off we know the number of columns . We have to know what kind of Data Types these columns are going hold . Here is what I come up with
Drive Letter — String
Size of Drive–Decimal
Used — Decimal
Free — Decimal
Percent Free —INT
Now if you want to provide int values for the decimal ones you could . In this case I choose not to .
Now that we have our table laid out lets start the script . You can do this interactively also so there is no need to put this in a script . I tend to use scripts allot just to revert back to.
Lets Start :
# Get the local Server Name to be used in the tableName
$ServerName = Get-WmiObject -Class Win32_ComputerSystem
$TableName = $ServerName.Caption
Here is a way to get the local Server Name . We will use this name for the DataTable . There are other ways to get the name of the server but I chose this method . We are getting a WMI Class called WIN32_ComputerName and the caption property exposes the Server Name .
Once we have the name now we are able to setup the table :
# Setup the Datatable Structure
$table = New-Object system.Data.DataTable “$TableName”
Here we are instantiating a new object . This is ADO stuff creating out DataTable object and giving it our local Machine name .
Now we are going to setup our columns and the Datatypes we talked about .
$col1 = New-Object system.Data.DataColumn Drive,([string])
$col2 = New-Object system.Data.DataColumn Size,([decimal])
$col3 = New-Object system.Data.DataColumn Used,([decimal])
$col4 = New-Object system.Data.DataColumn Free,([decimal])
$col5 = New-Object system.Data.DataColumn PercentFree,([int])
Pretty straight forward stuff . We are creating the DataColumn object ,giving it a name ,declaring what data type it holds and assigning a variable to it .
Now that we created the columns now we have to add it to the table . We do that here :
#Add the Columns
$table.columns.add($col1)
$table.columns.add($col2)
$table.columns.add($col3)
$table.columns.add($col4)
$table.columns.add($col5)
Now Since we want the logical drive info here we create a variable to the WMI Logical Drive Class
# create our WMI Object
$drives = Get-WmiObject -Class Win32_LogicalDisk -ComputerName $TableName
Now comes the pipeline
$drives | ? {$_.DriveType -eq 3 } | % {$row = $table.NewRow();$row.Drive = $_.DeviceID ; $row.Size = “{0:F3}” -f($_.Size/1gb) ; $row.Used = “{0:F3}” -f (($_.Size/1gb)-($_.FreeSpace/1gb)) ; $row.Free = “{0:F3}” -f ($_.FreeSpace/1gb); $row.PercentFree = “{0:F3}” -f ($_.FreeSpace/1gb) / ($_.Size/1gb) * 100 ;$table.Rows.Add($row) }
Lets go thru this :
$drives – We start out with all of our Drives (Even Floppy ,CD/DVD)
? {$_.DriveType -eq 3 — This say Where the Drive Type is equal to 3 (We only want the Hard Drives . 3 means Hard drives not optical or Floppy )
% {$row = $table.NewRow() — For Each Drive Create a new Row (Cause we want our a Drive per Row )
$row.Drive = $_.DeviceID — Ok Now remeber our First Column is our Drive Letter (String ). Using the DeviceID to get the Name (I.E. C,D,E,F)
$row.Size = “{0:F3}” -f($_.Size/1gb) — Next column is the Size of the Drive . WE are using the Size property . Also we are making everything equal in Gigabytes. We also are formating here that is what {0:F3} does it formats it to the 3rd decimal place . (comes in real Handy these formating parameters)
$row.Used = “{0:F3}” -f (($_.Size/1gb)-($_.FreeSpace/1gb)) — Next Column is the Used Space . Which is the Size minus the Free space . Again Formating to the 3rd decimal place.
$row.Free = “{0:F3}” -f ($_.FreeSpace/1gb) — Next is Freespace Calculation also done in GB’s . Note you can aslo use the 1mb if you like . To keep it uniform I used the 1gb for all calculations .
$row.PercentFree = “{0:F3}” -f ($_.FreeSpace/1gb) / ($_.Size/1gb) * 100 — Here is the last Percent Free space . Which is Free Space divided by the Size Times 100 .
Now that we have all that taken care of lets capture our output to the screen .
$table| format-table -AutoSize
We tell it to take the table and format it . The AutoSize parameter basically pushes everything together and takes the whitespace out between the columns .
So the result is this :
Drive Size Used Free PercentFree
—– —- —- —- ———–
C: 78.125 42.848 35.277 45
D: 302.733 10.916 291.818 96
E: 136.719 87.683 49.036 36
F: 170.898 7.969 162.930 95
G: 243.043 60.144 182.899 75
J: 298.081 111.776 186.305 63
(It looks better on the actual output )
We are almost done . We can also pipe this table out to an XML file and XSD file . With this output you can create nice reports with XML possibly also parse the XML file to display info on a web page or in an application here are the last 2 lines .
#Save Table
$table.WriteXml(“.\DriveInfo.xml”)
$table.WriteXmlSchema(“.\DriveInfo.xsd”)
One is the XML file and the other is the Schema which tells how the XML file was created . With this 2 lines you can reconstuct the table at any time using ReadXML and ReadXMLSchema .
Here is the full Script :
# Get the local Server Name to be used in the tableName
$ServerName = Get-WmiObject -Class Win32_ComputerSystem
$TableName = $ServerName.Caption
# Setup the Datatable Structure
$table = New-Object system.Data.DataTable “$TableName”
$col1 = New-Object system.Data.DataColumn Drive,([string])
$col2 = New-Object system.Data.DataColumn Size,([decimal])
$col3 = New-Object system.Data.DataColumn Used,([decimal])
$col4 = New-Object system.Data.DataColumn Free,([decimal])
$col5 = New-Object system.Data.DataColumn PercentFree,([int])
#Add the Columns
$table.columns.add($col1)
$table.columns.add($col2)
$table.columns.add($col3)
$table.columns.add($col4)
$table.columns.add($col5)
# create our WMI Object
$drives = Get-WmiObject -Class Win32_LogicalDisk -ComputerName $TableName
$drives | ? {$_.DriveType -eq 3 } | % {$row = $table.NewRow();$row.Drive = $_.DeviceID ; $row.Size = “{0:F3}” -f($_.Size/1gb) ; $row.Used = “{0:F3}” -f (($_.Size/1gb)-($_.FreeSpace/1gb)) ; $row.Free = “{0:F3}” -f ($_.FreeSpace/1gb); $row.PercentFree = “{0:F3}” -f ($_.FreeSpace/1gb) / ($_.Size/1gb) * 100 ;$table.Rows.Add($row) }
$table| format-table -AutoSize
#Save Table
$table.WriteXml(“.\DriveInfo.xml”)
$table.WriteXmlSchema(“.\DriveInfo.xsd”)
For those who have not yet saw this there is version 2 of the CTP for powershell . Go here to the Powershell Blog for more info .
Also a new version of powershell GUI is out get it here.
This is really some good stuff and it will give you a chance to really test powershell .
Thanks
Chris
I seen this youtube video and wanted to comment how great it is . I grew up in NY and went to a ton of Yankee games . I remember my first time to Yankee stadium and walking thru the tunnel to sit at my seat . The players seemed bigger then life to me being a kid and all . I remember Eddie Layton and the sound of the organ as you sat back and listened to his set before the game . There was nothing like that . It gave you goose bumps and the feeling was electric . Yankee Stadium is much different today without Eddie and soon Bob Sheppard won’t be around . Things just are not the same as they were . Things are still good don’t get me wrong but the time has passed .
Chris
NewEgg.com Watching Microsoft Like a Hawk !