Search results for 'app:weblogs' matching tags 'Windows PowerShell' and 'Event 8'

Expert Commentary: 2012 Scripting Games Advanced Event 8

Anonymous — Wed, 25 Apr 2012 05:00:00 GMT

Summary: Jeremy Engel, provides expert commentary for 2012 Scripting Games Advanced Event 8.

Microsoft Scripting Guy, Ed Wilson, is here. Jeremy Engel is the expert commentator for Advanced Event 8.

Jeremy works in the health care industry as a lead systems engineer and architect, promoting new technologies and helping drive their acceptance and implementation. Being a fanatic of efficiency and automation, he also focuses on developing programs and scripts to ease the burden of administration for himself, his colleagues, and the community. His most notable contribution thus far is the PowerShell Module for DHCP. He is currently working on releasing a multitude of other modules and scripts.

He is a great admirer of the Windows PowerShell community and is honored to be a judge for this year’s Scripting Games. He wishes all the contestant’s happy scripting and good luck! Jeremy’s proudest contributions to this world are his three wonderful children, who together with his beautiful wife live in the bustling metropolis of Oak Ridge, North Carolina.

When I was developing my script for the 2012 Scripting Games Advanced Event 8, the first question I asked myself was how best to differentiate between wired and wireless connections. I began by examining the Win32_NetworkAdapter class, but I couldn’t find any reliable method therein of determining the physical media type. I thought about scanning the NetConnectionID for indicators like “Wireless” or “Local Area Connection” but those were horribly imprecise, especially given the ability of users to rename them to whatever they wanted. Even without renaming the network connection on my Win8 slate, I found that the wired adapter was named “Wired Ethernet Connection” and the wireless adapter, “Wi-Fi.” As you can see, there was just no way to plan for all the possibilities. Now, as it happened, I had the beta copy of Windows PowerShell 3.0 installed on my laptop, so on a whim I typed “Get-Net” and tabbed out. To my delight a Get-Net6to4Configuration cmdlet popped up, and two tabs later, I came upon Get-NetAdapter!

Lo and behold, there it was: the PhysicalMediaType property, and it differentiated between 802.11 (wireless) and 802.3 (wired) among others. While the NetAdpater.Types.ps1 xml says that the PhysicalMediaType strings will appear as “802.3” and “Native 802.11,” I decided not to use the –eq operator when filtering, but rather the –match operator, just in case additional 802.3/11 media types would be defined in the future. I also wanted to differentiate between connection state and device state. The AdminStatus property worked best for the device state, with its Up and Down designations. And although the Status property displayed aspects of the connection state, it appeared to be a viewer-friendly overall status pulling from multiple sources. That’s good for what it is, but a truer property to determine the connection state seemed to me to be MediaConnectionState.

Why did I care about the connection state when the event parameters didn’t call for any such analysis? When writing a script, I always try to think about who is going to use the script and what they might be expecting. Thus I wanted to show a warning message should the adapter that’s toggled into the enabled state be disconnected. That way the user can take corrective action right away, whether that be to plug-in a network cable or join a wireless network, rather than determine at some later point that they are not connected to any network.

As part of the Event 8 requirements, users are to be prompted if more than one of the network adapters are enabled or disabled. I planned for that and then took it a step further and decided to give the user the ability to specify which adapter(s) they wanted to include in the toggling process. That would allow them to bypass the multiadapter prompt.

Lastly, by typing Get-Command –Noun NetAdapter into Windows PowerShell, I found the Disable and Enable companion cmdlets that I would need to complete my script’s functionality.

With my requirements and desired logic delineated, writing the script was pretty simple. I separated the logic for selecting the appropriate adapter and put it in its own function for two reasons: one, I wanted to be able to loop should the user provide an invalid selection; and two, I needed to use the code in four different instances and I didn’t want to have to repeat the same code over and over again. Also, I discovered that I needed to add a Start-Sleep line to give the newly enabled network adapter a chance to connect.

To put a pretty bow on the script, I added regions so that readers could easily understand the logical stages of the script, and then added a Help file for reference in Windows PowerShell. Here is the entire script:

Switch-NetworkConnection.ps1

.Synopsis

Toggles the enabled network connection between a wired and a wireless network adapter.

.Description

The Switch-NetworkConnection.ps1 script toggles the enabled network connection between a wired and a wireless network adapter.

This script can only be used on mobility platforms with PowerShell 3.0 installed and must be run as Administrator. Furthermore, only one wired and one wireless network adapter can be selected to take part in the toggling process. You can either select the desired network adapters from a dispalyed list, or specify which adapters will take part using the available parameters.

.Parameter WiredNetworkAdapter

This parameter specifies the wired network connection that will be used in the toggling process.

This accepted value for this parameter is either the name of the network adapter or a NetAdapter object representing that network adapter.

.Parameter WirelessNetworkAdapter

This parameter specifies the wired network connection that will be used in the toggling process.

This accepted value for this parameter is either the name of the network adapter or a NetAdapter object representing that network adapter.

.Example

.\Switch-NetworkConnection.ps1

This example determines the wired and wireless network adapters that will be toggled. If multiple network adapters of a given type are found, the script will prompt for a choice.

.Example

.\Switch-NetworkConnection.ps1 -WiredNetworkAdapter "Local Area Connection" -WirelessNetworkAdapter "WLAN 2"

In this exmaple, the wired and wireless adapters were specified because multiple network adapters of each type are present and the user wanted to bypass the network adapter selection process.

.Outputs

Microsoft.Management.Infrastructure.CimInstance[]

.Notes

Name: Switch-NetworkConnection.ps1

Author: Jeremy Engel

CreatedDate: 03.26.2012

ModifiedDate: 03.29.2012

Version: 1.0.0

#Requires -version 3.0

Param([Parameter(Mandatory=$false,Position=0)][Alias("Wired","LAN")][PSObject]$WiredNetworkAdapter,

[Parameter(Mandatory=$false,Position=1)][Alias("Wireless","WLAN")][PSObject]$WirelessNetworkAdapter

)

function Get-AdapterSelection {

Param([Parameter(Mandatory=$true)][string]$Text,

[Parameter(Mandatory=$true)][Microsoft.Management.Infrastructure.CimInstance[]]$Adapters

)

Write-Host $Text

for($i=0;$i-lt$Adapters.Count;$i++) { Write-Host " $($i+1). $($Adapters[$i].Name)" }

$n = [int](Read-Host "Selection")

if($n -lt 1 -or $n -gt $Adapters.Count+1) {

Write-Host "Invalid selection." -ForegroundColor Red

return (Get-AdapterSelection -Type $Type -Adapters $Adapters)

}

else { return $Adapters[$n-1] }

}

function Main {

#region System Requirements and Runspace Validation

if(!(Get-WmiObject -Class Win32_Battery)) {

Write-Host "ERROR: This script is designed for use on laptops and tablets only." -ForegroundColor Red

return

}

if(([Security.Principal.WindowsIdentity]::GetCurrent()).Owner -ne "S-1-5-32-544") {

Write-Host "ERROR: This script may only be run as Administrator. Please open a PowerShell window as Administrator and try again." -ForegroundColor Red

return

}

#endregion

#region Adapter Validation and Selection

$adapters = Get-NetAdapter -ErrorAction Stop

$wired = $adapters | Where-Object { $_.PhysicalMediaType -match "802.3" }

$wireless = $adapters | Where-Object { $_.PhysicalMediaType -match "802.11" }

if(!$adapters -or !$wireless -or !$wired) {

$type = if(!$adapters){"any"}elseif(!$wireless){"any wireless"}else{"any wired"}

Write-Host "ERROR: You do not have $type network adapters." -ForegroundColor Red

return

}

if($WiredNetworkAdapter) {

$wired = if($WiredNetworkAdapter -is [string]) { $wired | Where-Object { $_.Name -eq $WiredNetworkAdapter } }

elseif($WiredNetworkAdapter -is [Microsoft.Management.Infrastructure.CimInstance]) { $WiredNetworkAdapter }

else { $null }

if(!$wired) {

Write-Host "ERROR: Could not locate a wired network adapter by the name of $WiredNetworkAdapter." -ForegroundColor Red

return

}

if($WirelessNetworkAdapter) {

$wireless = if($WirelessNetworkAdapter -is [string]) { $wireless | Where-Object { $_.Name -eq $WirelessNetworkAdapter } }

elseif($WirelessNetworkAdapter -is [Microsoft.Management.Infrastructure.CimInstance]) { $WirelessNetworkAdapter }

else { $null }

if(!$wireless) {

Write-Host "ERROR: Could not locate a wireless network adapter by the name of $WirelessNetworkAdapter." -ForegroundColor Red

return

}

if($wired.Count -gt 1) {

$text = "$($wired.Count) wired network adapters were found on your system. Please select the desired network adapter by number."

$wired = Get-AdapterSelection -Text $text -Adapters $wired

}

if($wireless.Count -gt 1) {

$text = "$($wireless.Count) wireless network adapters were found on your system. Please select the desired network adapter by number."

$wireless = Get-AdapterSelection -Text $text -Adapters $wireless

}

#endregion

#region Action Determination

if($wired.AdminStatus -eq "Down" -and $wireless.AdminStatus -eq "Down") {

$text = "Both network adapters are disabled. Choose the number of the network adapter you wish to enable."

$enableMe = Get-AdapterSelection -Text $text -Adapters $wired,$wireless

$disableMe = $wired,$wireless | Where-Object { $_.Name -ne $enableMe.Name }

}

elseif($wired.AdminStatus -eq "Up" -and $wireless.AdminStatus -eq "Up") {

$text = "Both network adapters are enabled. Choose the number of the network adapter you wish to disable."

$disableMe = Get-AdapterSelection -Text $text -Adapters $wired,$wireless

$enableMe = $wired,$wireless | Where-Object { $_.Name -ne $disableMe.Name }

}

else {

$enableMe = $wired,$wireless | Where-Object { $_.AdminStatus -eq "Down" }

$disableMe = $wired,$wireless | Where-Object { $_.AdminStatus -eq "Up" }

}

#endregion

#region Action Execution

$enableMe | Enable-NetAdapter -ErrorAction Stop

$disableMe | Disable-NetAdapter -Confirm:$false -ErrorAction Stop

Start-Sleep -Seconds 2 # Pause while the enabled adapter establishes a connection

#endregion

#region Output

$adapters = Get-NetAdapter

$check = $adapters | Where-Object { $_.Name -eq $enableMe.Name }

if($check.MediaConnectionState -eq "Disconnected") {

Write-Host "WARNING: The enabled network adapter [$($check.Name)] is in a disconnected state." -ForegroundColor Yellow

}

$adapters

#endregion

}

Main

~Jeremy

2012 Scripting Games Guest Commentator Week Part 2 will continue tomorrow when we will present the scenario for Event 9.

I invite you to follow me on Twitter and Facebook. If you have any questions, send email to me at scripter@microsoft.com, or post your questions on the Official Scripting Guys Forum. See you tomorrow. Until then, peace.

Ed Wilson, Microsoft Scripting Guy

Expert Commentary: 2012 Scripting Games Beginner Event 8

Anonymous — Wed, 25 Apr 2012 05:00:00 GMT

Summary: Microsoft PFE, Chris Bellee, provides expert commentary for 2012 Scripting Games Beginner Event 8.

Microsoft Scripting Guy, Ed Wilson, is here. Chris Bellee is the expert commentator for Beginner Event 8.

Chris is a premier field engineer (PFE) based in Sydney, Australia. He teaches many Windows PowerShell workshops and custom classes, as well as works on IP development that's delivered worldwide to Microsoft Premier Customers. He also trains and certifies other field engineers to deliver Windows PowerShell workshops in the APAC region.

Chris is also a directory services PFE with a passion for helping customers monitor and automate their Active Directory infrastructure. He has developed many sample Windows PowerShell solutions for customers to enable them monitor and manage Active Directory.

Having previously worked as a systems engineer, Chris has extensive experience developing solutions by using a variety of languages other than Windows PowerShell, such as VBScript, Perl, JavaScript, and C# to aid his daily tasks.

In beginner event 8, you are required to determine if a computer is a desktop computer or a laptop computer:

Event scenario

You are the desktop manager at a midsized enterprise company. It is inventory time, and you need to get a count of the number of laptop computers and the number of desktop computers. You decide to write a Windows PowerShell script that will count the number of desktop computers and the number of laptop computers on the network. To permit auditing, your report should include the computer name, and whether or not it is a desktop or a laptop machine.

Design points

For the purposes of this scenario, your script only needs to write to the console.
Your script only needs to determine laptop or desktop from a hardware perspective. You do not need to determine the version of the operating system.
Your code only needs to run on a local computer.
If your code requires admin rights, you should detect if the code is running as an admin or as a standard user. If your code works without requiring admin rights, you do not need to make this check.
Extra points for writing a simple function that only returns a Boolean value.

Solution

For this challenge we need to find a way to determine whether a computer is a laptop or desktop. Because the scenario states that the script should collect information from remote machines, our obvious choice to employ Windows Management Instrumentation (WMI) for the job.

The first decision is which WMI class contains the data that we are interested in. In this case, there are two classes that fit the bill: Win32_ComputerSystem and Win32_SystemEnclosure. Because Windows PowerShell provides first class support for the WMI object model, it is relatively trivial to query these classes and browse the available properties by using the Get-WMIObject cmdlet.

Get-WmiObject -Class Win32_ComputerSystem | Format-List *

Get-WmiObject -Class Win32_SystemEnclosure | Format-List *

The PCSystemType property in Win32_ComputerSystem contains a number that represents the form-factor of the machine. This seems to be a perfect fit until you read the MSDN Win32_ComputerSystem class documentation. The PCSystemType property is not available on computers running Windows XP, Windows Server 2003, Windows 2000, or Windows NT Server 4.0, so this may be less than perfect for organizations where Windows XP is still prevalent.

In contrast, the Win32_SystemEnclosure class is supported on down-level operating systems. Its ChassisTypes property contains just the information we need. If you look at the MSDN class documentation, there are a large number of possible numeric values for this property, it also holds an array data type, so attention has to be given as to how we work with it.

Now that we have the correct piece of data, we can create a function that returns a Boolean value depending on whether the target machine has a laptop or desktop form-factor. The function is named Is-Laptop and it returns a Boolean value. It has a single input parameter consisting of the remote computer name to query and a single output variable called $result. The output variable is set to $false at the beginning of the function body.

.Synopsis

helper function used by Get-HardwareType

.EXAMPLE

Example of how to use this cmdlet

function Is-Laptop {

[CmdletBinding()]

[OutputType([boolean])]

param

(

[Parameter(Mandatory=$true)]

[string]

$strHostName

)

$blnResult = $false

$objWMI = Get-WmiObject -ComputerName $strHostName -Query $query -ErrorAction Stop

switch ($objWMI.ChassisTypes) {

9 {$blnResult = $true} # Laptop

10 {$blnResult = $true} # Notebook

12 {$blnResult = $true} # Docking Station

14 {$blnResult = $true} # Sub Notebook

default {}

}

return $blnResult

} # end function

Looking at the documentation for the Win32_SystemEnclosure class, you can see that there is more than one numerical value that determines if a machine is “portable.” For this reason I chose to use a switch statement to determine which of the four values that we are interested in are set. Another bonus to using a switch instead of an ‘if’ statement is that it can automatically deal with arrays. The ChassisTypes property holds an array of numbers. Although most of the time the property holds a single value, it is possible that it can hold many values. The switch statement acts like a pipeline—each item in the array flows through the statement one-by-one.

Although the Is-Laptop function does all the work of executing the WMI query and returning a Boolean value, we define a second function that executes it. This makes the code more legible and abstracts the actual WMI query from the name resolution and error handling functionality implemented in the Get-HardwareType function.

Notice the process {} scriptblock that contains most of the code in the Get-HardwareType function. This allows the function to process machine names as pipeline input.

"pc01","pc02","pc03" | Get-HardwareType

Next, we try to resolve the short computer name to a fully qualified DNS host name by using the GetHostByName() .NET static method. A new object instance is not needed to use the method. We can simply reference the type name and call the method by using the double-colon (::) accessor syntax.

$objHostName = [system.net.dns]::GetHostByName($hostName)

Notice that the GetHostByName() method call is contained within a Try/Catch block. This will allow any name resolution failures to bypass the rest of the function, simply printing an error to the user and allowing the function to continue execution.

Before executing the WMI query, we use the Test-Connection cmdlet to determine whether the computer is accessible, using an ICMP (ping) packet. If this check is not performed, the WMI query will time-out when a computer is not available, slowing the script execution considerably. The Test-Connection cmdlet returns a Boolean value ($true) if the machine is contacted successfully, allowing us to use it directly within an ‘if’ statement condition.

if (Test-Connection -ComputerName $objHostName.HostName -count 1 -erroraction silentlycontinue)

The final part of the function uses another Try/Catch block to enclose the call to the Is-Laptop function, again allowing the script to recover from a potential terminating error.

$objResult = New-Object -TypeName psobject -Property @{

HostName=$objHostName.HostName;IsLaptop=(Is-Laptop -strHostName $objHostName.HostName)}

The previous line creates a new Windows PowerShell object to store the name of the computer that is being tested and a Boolean value that indicates whether it is a laptop or a desktop machine. Here, we are using –Property to declare a hash table of name and value pairs that populate the new object’s members. The Is-Laptop property stores the result of calling the Is-Laptop function, which is a Boolean value.

The main script execution occurs at the bottom of the script. We declare two counter variables to hold the number of desktops or laptop computers that are found.

$laptopCount = 0

$desktopCount = 0

To provide some input to the Get-HardwareType function, we search the local Active Directory domain for the CN attributes of all computer objects that don’t have the string server within their OperatingSystem attribute, using a DirectorySearcher object. The search filter is specified by the LDAP query language that follows.

(&(objectcategory=computer)(!operatingsystem=*server*))")

The search is executed by calling the FindAll() method of the DirectorySearcher object and the search results are saved in the $arrMachine variable. The variable should now contain an array of short computer names that can be passed through the pipeline to the Get-Hardware function. Each computer will then be connected to and evaluated, and the results will be displayed on the console.

$result = $arrMachineName | Get-HardwareType

$result

The total number of laptop and desktop form-factors can now be calculated. The $result variable contains an array of psobjects that are passed to a ForEach-Object cmdlet that increments the $laptopCount and $desktopCount variables, depending on whether the current object’s islaptop property is $true or $false.

Finally, the totals can be written to the console.

"Laptop Total: $laptopCount"

"Desktop Total: $desktopCount"

Following is the full script.

.Synopsis

helper function used by Get-HardwareType

.EXAMPLE

Example of how to use this cmdlet

function Is-Laptop {

[CmdletBinding()]

[OutputType([boolean])]

param

(

[Parameter(Mandatory=$true)]

[string]

$strHostName

)

$blnResult = $false

$objWMI = Get-WmiObject -ComputerName $strHostName -Query $query -ErrorAction Stop

switch ($objWMI.ChassisTypes) {

9 {$blnResult = $true} # Laptop

10 {$blnResult = $true} # Notebook

12 {$blnResult = $true} # Docking Station

14 {$blnResult = $true} # Sub Notebook

default {}

}

return $blnResult

} # end function

.Synopsis

function to determine chassis type using a WMI query

.DESCRIPTION

function to determine chassis type using a WMI query

.EXAMPLE

"pc01","pc02","pc03" | Get-HardwareType

function Get-HardwareType {

[CmdletBinding()]

[OutputType([psobject])]

Param

(

[Parameter(Mandatory=$true,ValueFromPipeline=$true)]

$strHostName

)

process {

try {

$objHostName = [system.net.dns]::GetHostByName($strHostName)

$query = "select __SERVER,ChassisTypes from Win32_SystemEnclosure"

if (Test-Connection -ComputerName $objHostName.HostName -count 1 -erroraction silentlycontinue) {

try {

$objResult = New-Object -TypeName psobject -Property @{HostName=$objHostName.HostName;IsLaptop=(Is-Laptop -strHostName $objHostName.HostName)}

return $objResult

}

catch {

"Error trying to query $($objHostName.HostName)"

}

else {

write-host "error connecting to $($objHostName.HostName)"

}

catch {

write-host "Unable to resolve DNS address for $strHostName"

}

} # end function

###################################################

# Main script execution

###################################################

$laptopCount = 0

$desktopCount = 0

$searcher = new-object directoryservices.directorysearcher([ADSI]"","(&(objectcategory=computer)(!operatingsystem=*server*))")

[void]$searcher.PropertiesToLoad.Add("cn")

$arrMachineName = $searcher.findall() | %{$_.properties.cn}

$result = $arrMachineName | Get-HardwareType

$result

$result | ForEach-Object {if ($_.islaptop) {$laptopCount++} else {$desktopCount++}}

"Laptop Total: $laptopCount"

"Desktop Total: $desktopCount"

~Chris

2012 Scripting Games Guest Commentator Week Part 2 will continue tomorrow when we will present the scenario for Event 9.

Ed Wilson, Microsoft Scripting Guy

2012 Scripting Games Advanced Event 8: Enable Network Adapters

Anonymous — Wed, 11 Apr 2012 05:00:00 GMT

Summary: In Advanced Event 8, you are required to enable and disable network adapters.

About this event

Division	Advanced
Date of Event	4/11/2012 12:01 AM
Due Date	4/18/2012 12:01 AM

Event scenario

You are a network consultant. As a result, you travel extensively. Your main computer is your laptop. At times, you may use a wireless network adapter to connect to wireless networks. When you are using wireless, you disable the wired network connection. And at times, you use a wired network connection—when you use a wired network connection you disable the wireless network adapter. You do this to prevent bridging. Currently you use the graphical interface, and it seems to take nearly five minutes to make these changes. You would like to use Windows PowerShell to toggle your network connections. Your task in this scenario is to write a simple Windows PowerShell command to disable all enabled network connections, and enable all disabled network connections. The default output from running the script is sufficient.

Design points

This task requires admin rights; therefore, your script should check to ensure that it is running as an admin. If the script is not launched with proper credentials, display a message that admin rights are required.
For the purposes of this scenario, you want one adapter enabled and the other disabled. If more than one adapter is enabled or disabled, you should display information about the adapters, and prompt the user for which one to enable or disable. You do not want the wired network adapter and the wireless network adapter enabled at the same time.
This scenario is appropriate for a laptop, but not for a desktop computer. Therefore, your script should detect if the computer is a laptop or a desktop machine. If the computer is a desktop, the script should display a message that it only runs on laptop computers.
The script should run without prompting if the default condition of one enabled network adapter and one disabled network adapter is met.

2012 Scripting Games links

2012 Scripting Games: All Links on One Page

Ed Wilson, Microsoft Scripting Guy

Expert Solution for 2011 Scripting Games Beginner Event 8: Use PowerShell to Write Disk File Information for Excel

Anonymous — Wed, 27 Apr 2011 05:00:00 GMT

Summary : Microsoft PowerShell MVP, Doug Finke, gathers file information and writes it to a CSV file that is readable in Excel while solving 2011 Scripting Games Beginner Event 8. Microsoft Scripting Guy, Ed Wilson, here. Doug Finke is the expert commentator...(read more)

Expert Solution for 2011 Scripting Games Advanced Event 8: Use PowerShell to Resize Images and to Remove EXIF Data

Anonymous — Wed, 27 Apr 2011 05:00:00 GMT

Summary : Microsoft PowerShell MVP, Marc van Orsouw, resizes images and removes EXIF metadata while solving 2011 Scripting Games Advanced Event 8. Microsoft Scripting Guy, Ed Wilson, here. Marc van Orsouw (MoW) is our expert commentator for Advanced Event...(read more)

The 2011 Scripting Games Advanced Event 8: Use PowerShell to Remove Metadata and Resize Images

Anonymous — Wed, 13 Apr 2011 05:00:00 GMT

Summary : Advanced Event 8 in 2011 Scripting Games uses Windows PowerShell to remove metadata from image files and to resize those images. About this event Division Advanced Date of Event 4/13/2011 12:15 AM Due Date 4/20/2011 12:15 AM Event scenario You...(read more)

The 2011 Scripting Games Beginner Event 8: Use PowerShell to Report Disk Space Utilization

Anonymous — Wed, 13 Apr 2011 05:00:00 GMT

Summary : Beginner Event 8 of 2011 Scripting Games uses Windows PowerShell to report disk space that is consumed by files in a folder. About this event Division Beginner Date of Event 4/13/2011 12:01 AM Due Date 4/20/2011 12:01 AM Event scenario You are...(read more)