Search results for 'app:weblogs' matching tags 'Advanced' and 'Scripting Guy!'

2013 Scripting Games: Advanced Event 6

Anonymous — Thu, 30 May 2013 05:00:00 GMT

Summary: Scripting Games Advanced Event 6: Dr. Scripto needs to configure virtual core servers and join them to the domain.

Microsoft Scripting Guy, Ed Wilson, is here. Today is the revealing of the final event for the 2013 Scripting Games. I hope you have learned tons from this year’s games and had fun too. Remember that you need to go to www.powershell.org to submit your event. Good luck!

The Core Configurator

Dr. Scripto has just one final challenge for you: to get out alive!

No, wait…that was when Bond was over for tea and crumpets last week.

Ah, here we go…

Dr. Scripto is deploying a bunch of new virtual machines on a Server Core installation of Windows Server 2012. The virtual machines already have the operating system installed, and the local Administrator password is set to P@ssw0rd. The virtual machines are using DHCP to get an IP address. There is a DHCP server on the network named DHCP1, and it has a single DHCP scope named 10.0.0.0. The virtual machines’ current computer names are not known, and they do not yet belong to the domain.

You need to write a Windows PowerShell tool that accepts MAC addresses from the pipeline (as strings). Dr. Scripto has some files listing the virtual machines’ MAC addresses that join the virtual machines to the domain and gives them a new computer name. Your tool needs to:

Query the Server Core installation’s current dynamic IP address from the DHCP server.
Join each Server Core installation to the Company.local domain. Use the domain credential Admin, with the password P@ssw0rd, to join the computer to the domain. At the same time, rename the computer. The first computer should be named SERVER1, the second SERVER2, and so forth. Allow the computer to restart.

Your tool should accept a parameter for the server base name, and that should default to SERVER. With the default, the server names will be SERVER1, SERVER2, and so on. But, if someone runs the tool and specifies FRED as the server base name, then you rename the servers to FRED1, FRED2, and so on. You can assume none of the server names exist on the network. (If they do, it’s not your fault if something breaks.)

You should minimize the number of “Are you sure?” prompts that are shown while your script runs. The computers should be added to the domain’s default container for new machine objects.

It’s fine if you do this for one computer at a time, but when your script finishes running, all of the computers must be properly provisioned.

You can safely assume that SERVER1, SERVER2, and so on do not already exist in the domain.

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

2013 Scripting Games: Advanced Event 5

Anonymous — Thu, 23 May 2013 05:00:00 GMT

Summary: Scripting Games Advanced Event 5: Dr. Scripto needs to create a tool to find client IP addresses from a bunch of IIS logs.

Microsoft Scripting Guy, Ed Wilson, is here. Today is the release of Event 5 for the 2013 Scripting Games. Remember that they are being run and hosted at www.powershell.org. You will need to go to that webpage to submit your entry.

The Logfile Labyrinth

Dr. Scripto finds himself in possession of a bunch of IIS log files. (It is much like the one at http://morelunches.com/files/powershell3/LogFiles.zip, if you need one to practice with.) He’s keeping all of the log files in C:\Reporting\LogFiles, and he’s left the log files with their default file names, which he’s given a .log file name extension. All of the files are for a single website, on a single web server.

He’d like you to write a tool that accepts a path, and then simply scans through each file in that path, generating a list of each unique client IP address that have been used to access the website. No IP address should appear more than once in your output, and you don’t need to sort the output in any way.

Your tool should optionally accept an IP address mask, such as “192.0.1.*” and only display IP addresses that match the specified pattern. If run without a pattern, display all IP addresses.

As described in IIS Log File Example, the client IP address is the first item in each log file entry. Regardless of the addresses found in the sample file, you should assume that any legal IP address may appear in the files Dr. Scripto needs to scan. Your command should scan all of the files in the folder (and the folder doesn’t contain any other kind of file) and produce a single set of results. If an IP address appears in multiple log files (it’s likely that will be the case), your final output should still only list that IP address one time.

Ed Wilson, Microsoft Scripting Guy

2013 Scripting Games: Advanced Event 4

Anonymous — Thu, 16 May 2013 05:00:00 GMT

Summary: Scripting Games Advanced Event 4: Dr. Scripto needs audit 20 random users from Active Directory.

Microsoft Scripting Guy, Ed Wilson, is here. Once again it is time to reveal an event for the 2013 Scripting Games that are being hosted and run by www.powershell.org. Head on over to their website to submit your entry.

An Auditing Adventure

Dr. Scripto isn’t saying he dislikes auditors, but they do seem to show up at the most inconvenient times—and with the oddest requests. So he’s tossing this particular auditor request over to you.

This auditor would like a report that shows 20 randomly selected (well, as random as you can get) users from Active Directory. For each user, the auditor wants to see their user name, their department and title, and the last time they logged on. You also need to show the date their password was last changed, and whether the account is disabled or locked out. So that’s seven pieces of information. You’re to put that information into an HTML-based report file, and the file must show the date and time that the report was generated. Please make sure that all of the dates are normal looking, human-readable dates and times.

Auditors being like they are, the “20 randomly” selected number will probably change in the future, so you’d better build this as a reusable tool. Have a parameter that specifies the number of users to pull, and default it to 20. Also parameterize the output HTML file name. Oh, but if the specified file name doesn’t end in “.html” or “.htm,” reject it. Get Windows PowerShell to do as much of that validation as possible. Dr. Scripto has to review your code, and he doesn’t want to read a lot of manual validation script.

A domain admin will always run the command (on behalf of the auditor), and the resulting HTML file will be manually emailed to the requesting auditor.

Ed Wilson, Microsoft Scripting Guy

2013 Scripting Games: Advanced Event 3

Anonymous — Thu, 09 May 2013 05:00:00 GMT

Summary: Scripting Games Advanced Event 3: Dr. Scripto needs to create an HTML report for hard disk drive status.

Microsoft Scripting Guy, Ed Wilson, is here. Today is the release of Event 3 for the 2013 Scripting Games. This year the Games are being administered and run by www.powershell.org. You need to go to their website to submit your entry.

A Disk Decision

Dr. Scripto has been fielding a lot of calls from the Help Desk lately. They’ve been asking him to look up information about the local hard drives in various servers—mainly size and free space information. He doesn’t mind helping, but all the requests have been getting in the way of his naps. He’s asked you to write a tool command that can get the information for the Help Desk—and he wants the output in an HTML file. The HTML file should look something like this:

The Doctor says that you should parameterize your command. He wants to be able to pipe one or more computer names as strings. The resulting HTML needs to go into an HTML file on disk someplace, and that file should have the computer name (for example, the computer SERVER1 should have Server1.html, SERVER2 should have Server2.html, and so on). A parameter should let him indicate the path (directory) to write the files to. Also, he wants you to pay special attention to the following:

The browser displays “Disk Free Space Report” in the page tab when viewing the report.
“Local Fixed Disk Report” is in the Heading 2 (H2) HTML style. If you can add the computer name to that, bonus!
The report ends with an HTML horizontal rule and the date and time that the report was generated.
The size and free space values are shown as gigabytes (GB) and megabytes (MB) respectively, each to two decimal places.

The command you write can assume that both WMI and CIM are available on the remote computers, and that all the necessary firewall rules and authentication have already been taken care of.

Ed Wilson, Microsoft Scripting Guy

2013 Scripting Games: Advanced Event 2

Anonymous — Thu, 02 May 2013 05:00:00 GMT

Summary: Dr. Scripto needs to create a tool to find basic information from his servers.

Microsoft Scripting Guy, Ed Wilson, is here. Welcome to Week 2 of the 2013 Scripting Games. Just in case you are not up to speed, this year The Scripting Guys are not hosting the Scripting Games. They are being hosted at www.powershell.org. I am in full support of the Games, and I am posting the events here for your perusal. However, if you would like to submit an entry to the event, you must go to www.powershell.org.

An Inventory Intervention

Dr. Scripto finally has the budget to buy a few new virtualization host servers, but he needs to make some room in the data center to accommodate them. He thinks it makes sense to get rid of his lowest-powered old servers first…but he needs to figure out which ones those are.

This is just the first wave, too. There’s more budget on the horizon, so it’s possible that he’ll need to run this little report a few times. Better make a reusable tool.

All of the virtualization hosts run Windows Server, but some of them don’t have Windows PowerShell installed, and they’re all running different operating system versions. The oldest operating system version is Windows 2000 Server (he knows, and he’s embarrassed, but he’s just been so darned busy). The good news is that they all belong to the same domain, and that you can rely on having a Domain Admin account to work with.

The good Doctor has asked you to write a Windows PowerShell tool that can show him each server’s name, the installed version of Windows, amount of installed physical memory, and number of installed processors. For processors, he’ll be happy to get a count of cores, or sockets, or even both—whatever you can reliably provide across all these versions of Windows. He has a few text files with computer names, and he’d like to pipe the computer names, as strings, to your tool, and have your tool query those computers.

Oh, and in case he forgets how to use it—make sure this tool of yours has a full Help display available.

Ed Wilson, Microsoft Scripting Guy

2013 Scripting Games: Advanced Event 1

Anonymous — Thu, 25 Apr 2013 05:00:00 GMT

Summary: Dr. Scripto needs to gather all log files older than 90 days and move them to an archive location.

Microsoft Scripting Guy, Ed Wilson, is here. This is a day for the history books. Today is the first day of the 2013 Scripting Games as run by the Windows PowerShell community at www.powershell.org. Of course I am in full support mode for the Scripting Games, and I will also participate as a judge. Without further ado, here is Advanced Event 1…

An Archival Atrocity

Dr. Scripto is in a tizzy! It seems that someone has allowed a series of application log files to pile up for around two years, and they’re starting to put the pinch on free disk space on a server. Your job is to help get the old files off to a new location.

Actually, this happened last week, too. You might as well create a tool to do the archiving.

The current set of log files are located in C:\Application\Log. There are three applications that write logs here, and each uses its own subfolder. For example, C:\Application\Log\App1, C:\Application\Log\OtherApp, and C:\Application\Log\ThisAppAlso. Within those subfolders, the filenames are random GUIDs with a .log filename extension. After they are created on disk, the files are never touched again by the applications.

Remember that the Scripting Games are being hosted at www.powershell.org, so head on over there to submit your entry.

Ed Wilson, Microsoft Scripting Guy

Weekend Scripter: Lessons Learned from the 2012 Advanced Scripting Games

Anonymous — Sun, 03 Jun 2012 05:00:00 GMT

Summary: The winner of the advanced division of the 2012 Windows PowerShell Scripting Games gives tips for success.

Microsoft Scripting Guy, Ed Wilson, is here. Today we have a guest blogger, Rohn Edwards, the winner of the Advanced category in the 2012 Scripting Games. Rohn and Lido Paglia, winner of the Beginner category, will be joining us in Orlando next week. As part of winning the 2012 Scripting Games, they won passes to Microsoft TechEd 2012. Today Rohn is going to talk about lessons that he learned in the 2012 Scripting Games.

Rohn Edwards has been a system administrator since 2006. He primarily works on Windows operating systems. A lot of his work involves automated operating system and software deployment via Microsoft System Center Configuration Manager. He started learning Windows PowerShell about a year ago when he realized that it can do things that are not even possible in VBScript, and he has not looked back since.

Take it away, Rohn...

The 2012 Scripting Games have come and gone, and I’m very happy that I participated in them this year. I am not going to even try to mention every single thing that I picked up, but I do want to talk about a few of the biggest lessons that I learned.

Participation is worth it

I think one of the biggest things I learned is that the Scripting Games are definitely worth entering, no matter your current scripting level. As this year’s games came to a close, one thing that I repeatedly found myself thinking about was how I should have participated last year. At that point, I did not know nearly as much about Windows PowerShell as I did before the games this year. I was able to talk myself into thinking that I would not do very well in the rankings, and between work and family obligations, I wouldn’t have enough time to participate anyway.

After this year’s games, I now know two things about the games that I did not know last year:

The real reason for participating is to learn, and, even if you think you do not have time to participate, you should try anyway. Regardless of where you place in the final rankings, if you take the time to write and submit entries to at least some of the events, you will gain invaluable practice and experience with one of the most powerful tools the Windows operating systems have ever seen.
If you truly don’t have time to submit an entry for each event, you haven’t lost out on anything because the games are free to enter.

By not participating last year, I feel like I robbed myself of an incredible learning opportunity. The ten events, along with the expert commentaries and expert judges providing feedback on your scripts, cram months’ worth of scripting experience into just a few weeks’ time. So, if you’re reading this and wondering if the games are worth your time, the answer is an unequivocal, “Yes”!

Comment-based Help is ridiculously simple

Before starting the games, I knew that I could define Help by adding specially formatted comments at the beginning or end of functions. I had not, however, used that feature of Windows PowerShell. Before starting the games, I read the tips that Ed and some of the guest bloggers published on the blog. I kept seeing comment-based Help mentioned, so I assumed that every one of my functions in my entries needed to have it added. I am glad that I did add Help to each of my functions because it helped me realize how incredibly simple it is to do. Everyone knows that good commenting is a must if you want to reuse any of the code that you write. Before the Games this year, I provided a block comment at the beginning of a function or script that gave a brief overview of its purpose, what it took as input, and what it gave as output. That helped when someone was reading the code, but it didn’t provide any way for a user to understand how to use it. Instead of the simple block comment, now I simply provide comment-based Help. If someone comes across the comment in the code, they can read it the same reading it by using Get-Help. If not for the games, I probably would have continued to ignore the comment-based Help system for months.

Splatting

This may be one of my favorite Windows PowerShell features. A few weeks ago, I would have said that was still the newness of it affecting my judgment, but I still feel the same about it weeks after learning it and using it all the time. What is splatting? It is a way to pass parameters to another function or cmdlet by using a hash table. Here is an example of using Get-Service to get the number of services with a display name that starts with “Microsoft”:

In the previous example, I created a hash table called Parameters with three entries: ComputerName, DisplayName, and ErrorAction. I then “splatted” that hash table to the cmdlet and measured the number of objects returned. Next, I made the same call to Get-Service without splatting. Now, why is the first call better than the second? There are several reasons, but I’ll only list a few:

It makes your code easier to read, especially if you are passing lots of parameters.
It makes it easier to make a single call to a function or cmdlet, even when special logic is needed to avoid certain parameters being passed. For example, advanced event 2 required a function that would get service information for a specified computer or set of computers, and you had to support using alternate credentials. Because Get-Service does not support alternate credentials, most entrants chose to use the WMI class Win32_Service. Get-WMIObject (gwmi) supports using alternate credentials, but only when you use them against a remote machine; it doesn’t support alternate credentials on the local computer.
With splatting, you can create a hash table that contains the alternate credentials and any other parameters you want to pass, and before calling gwmi, you can check to see if you are going to run it against the local machine. If you are, you can remove the alternate credentials from the hash table. This lets you make a single call to gwmi inside of your code instead of having logic that will call it with a different set of hard-coded parameters, depending on what you need to do. I did not know about splatting when I wrote the bulk of my entry for Advanced Event 2, so my method was not nearly as elegant as it could have been if I had used it.
It makes creating wrapper functions very easy. That is actually how I found out about this feature. I had finished my main function for Advanced Event 2, but I wanted a wrapper function that I could create that would call my main function so that the output could be written to a file. I needed a way to forward all the parameters that were sent to my wrapper function to the underlying function that it was calling. I did not want to write code to check for each parameter and send it along if it was present. After a few minutes searching online, I came across a blog post that demonstrated splatting. If you’re wondering, all you have to do to create a wrapper function is make a function that takes the same parameters as the function that you’re wrapping, and then call it and “splat” the auto-generated $PsBoundParameters hash table. If your wrapper function has parameters that the function it is wrapping does not have, all you have to do is make a copy of $PsBoundParameters and remove the unneeded parameters from the hash table.

RunSpacePools

This one blew my mind. I did not learn this myself while writing for any of the events. Expert Commentary: 2012 Scripting Games Advanced Event 2 by Boe Prox demoed this. His commentary pointed to a webcast by Dr. Tobias Weltner, Speeding up Windows PowerShell: Multithreading. So what is it, and why do I like it so much? Multithreading within Windows PowerShell gives you the ability to, among other things, run a command locally on your machine against lots of remote machines in a fraction of the time it would take to run that same command against the machines one at a time.

As long as you take thread safety into account, you should be able to use this feature to speed up any data parsing/processing that requires reading several files. PSJobs can do this to some extent, but RunSpacePools seem to offer more power, speed, and flexibility. The one area where I think PSJobs might beat RunSpacePools is simplicity. As long as you do not try to implement a limit to the number of threads you can run concurrently, it is much easier to follow what is going on when using PSJobs. After checking out the examples by Dr. Tobias Weltner and Boe Prox, and understanding what is going on, I think that RunSpacePools has earned a special place in my arsenal of Windows PowerShell tools.

So, was participating in the 2012 Scripting Games worth it? Yes! Would I still be glad that I participated if I did not win any prizes? Absolutely! I would recommend participating in the Scripting Games to anyone, whether they are completely new or an advanced pro when it comes to Windows PowerShell. The Games provide a chance to learn and enforce invaluable new and existing Windows PowerShell knowledge. The daily prize drawings and the grand prizes are just icing on the cake!

~Rohn

Thanks, Rohn! 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 Advanced Event 10

Anonymous — Fri, 27 Apr 2012 05:00:00 GMT

Summary: Microsoft MCC, Rich Prescott, provides expert commentary for 2012 Scripting Games Advanced Event 10.

Microsoft Scripting Guy, Ed Wilson, is here. Rich Prescott is the expert commentator for Advanced Event 10.

Rich is currently working as a Windows Engineer for a market-leading global financial services firm in New York City. He started learning Windows PowerShell in 2009 while he was working as a desktop engineer. He is an author for the Microsoft TechNet Wiki. He is also a moderator on the Official Scripting Guys Forum, and he recently received the Microsoft Community Contributor award.

Personal blog: Engineering Efficiency
Microsoft blog: WikiNinjas - Official Blog of TechNet Wiki
Microsoft profile: Rich Prescott on TechNet
Twitter: @Rich_Prescott

Part one: The manual way

Having been a server admin previously, I have dealt with misbehaving servers on multiple occasions. Typically this led to creating a data collector set in Performance Monitor, and then viewing a chart with the information or exporting the information to a BLG file for later viewing.

When we had the BLG file, it could be converted into a CSV file by using the relog executable. This would create a CSV file that could satisfy three out of four of the requirements for Advanced Event 10.

Relog.exe Processor.blg –f CSV –o LT_processorCounters.csv

But this is the 2012 Scripting Games, and what would it be without some scripting!

Part two: The one-liner

After loading the Windows PowerShell console, I checked what available options there were for counters by using the following command:

Get-Command *counter*

After checking out the Get-Help listings for the Get-Counter and Export-Counter cmdlets, I was able to create a simple one-liner to generate the required CSV file:

Get-Counter -Counter (Get-Counter -ListSet Processor).Paths -MaxSamples 10 -SampleInterval 2 |

Export-Counter -Path "$($Env:ComputerName)_processorCounters.csv" -FileFormat csv

To fulfill the requirement of placing it in the Documents special folder, we can use Join-Path and a shortcut for the user’s documents folder.

Get-Counter -Counter (Get-Counter -ListSet Processor).Paths -MaxSamples 10 -SampleInterval 2 |

Export-Counter -Path (Join-Path ([environment]::getfolderpath("mydocuments")) "$($Env:ComputerName)_processorCounters.csv") -FileFormat csv

Now we have a mirror CSV file to what we created by using Relog.exe. However, if you read the Event Scenario carefully, it states that you must capture snapshots at two-second intervals for a total of ten snapshots, and there appears to be a row missing in both of the CSV files that we generated. If we wanted to be lazy, we could simply increment the MaxSamples parameter by 1, delete the first empty row in the CSV file, and call it a day. But this is the 2012 Scripting Games, and if you are going to do something, do it right!

Part three: The advanced way

In my testing, I found that the Get-Counter cmdlet was pulling all of the information correctly, but the Export-Counter and Relog.exe were not correctly outputting the data. To get around this, we can use Get-Counter to pull all of the information required, parse through it ourselves, and then output to a CSV file. I created the following function, which creates an array, loops through the objects piped from Get-Counter, converts them into custom PSObjects, and adds them to the array.

function Convert-RPCounter {

Param(

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

$PerfData

)

Begin {$Results = @()}

Process

{

ForEach ($Sample in $PerfData){

$obj = New-Object PSObject -Property @{TimeStamp = $Sample.TimeStamp}

ForEach($CounterSample in $Sample.CounterSamples){

$obj | Add-Member -MemberType NoteProperty -Name $CounterSample.Path -Value $CounterSample.CookedValue

}

$Results += $obj

}

End {$Results}

}

We then call the function as follows:

Get-Counter -Counter (Get-Counter -ListSet "Processor").Paths -MaxSamples 10 -SampleInterval 2 |

Convert-RPCounter |

Export-Csv -Path (Join-Path ([environment]::getfolderpath("mydocuments")) "$($Env:ComputerName)_processorCounters.csv") -NoTypeInformation

As you can see in the previous image, we now have 10 full samples at two-second intervals as required. And that’s all there is to capturing performance data with Windows PowerShell.

Now starts the fun process of troubleshooting what is eating up all of my CPU…

…mumbles to himself, “Where is that bothersome Script Monkey? I thought I told him to stay away from my computer!”

~Rich

WOW! This also concludes the 2012 Scripting Games. I want to especially thank all of the judges and the expert commentators for all of their hard work. I also want to thank Dia Reeves (my editor) who has done much more than basic editing these past several months leading up to the Scripting Games. I also want to extend a special thank-you to our wonderful sponsors for all their support of this great event. I hope you had fun, and that you also found it to be a worthwhile learning endeavor.

Join me tomorrow as we return to our regularly scheduled Weekend Scripter. I promise that I will not talk about the Scripting Games tomorrow—well, maybe a little. By the way, if you happen to be in Virginia Beach, VA tomorrow, the Scripting Wife and I will be at the Mark Minasi Conference where I (along with Don Jones) will be speaking. With people like Mark Minasi and Don Jones on the agenda, how can it fail to be an exciting and fun time? Hope to see you there.

Ed Wilson, Microsoft Scripting Guy

Expert Commentary: 2012 Scripting Games Advanced Event 9

Anonymous — Thu, 26 Apr 2012 05:00:00 GMT

Summary: Microsoft MVP, Arnaud Petitjean, provides expert commentary for 2012 Scripting Games Advanced Event 9.

Microsoft Scripting Guy, Ed Wilson, is here. Arnaud Petitjean is the expert commentator for Advanced Event 9.

Arnaud is an author, speaker, system engineer, and trainer. Arnaud is the founder of the French-speaking Windows PowerShell Community. He specializes in managing VMware (by using Windows PowerShell and PowerCLI) and in desktop virtualization.

Website: www.PowerShell-Scripting.com

Hi! This is Arnaud Petitjean from Montreal. Today we are going to learn how to deal with XML files. Like almost everything with Windows PowerShell, you will see that it is very easy and straightforward.

But first, before generating any file, we need to gather the data about the computer hardware. When we deal with system information, you should immediately start thinking about Windows Management Instrumentation (WMI). Indeed, WMI is a real gold mine. With it, you can collect hardware and software information, as well as interact with a computer locally or remotely in an easy manner. The only “complicated” part of WMI is to find out where the information we need is located.

You should keep in mind that for how huge WMI is, most information related to computer hardware and the operating system are located in the classes respectively named Win32_ComputerSystem and Win32_OperatingSystem.

How do I know that? Well, it’s called “experience.” And it comes over time…

One of the trickiest parts of this event is, in my opinion, to get the MAC address of the primary network interface. To achieve this goal, we need to find out (one more time), where this property is located. One possibility would be to use a tool like WMI Explorer to search for the property name. We could also create our proper Windows PowerShell script based on the Get-WmiObject cmdlet to look for this property. Or best of all, we could use the new cmdlet called Get-CimClass in Windows PowerShell 3.0 (currently in the Beta version). This specific cmdlet has been designed to ease the WMI discoverability process.

The following example shows finding the MacAddress property.

The latest solution is the fastest and the easiest. Instantaneously, we get two results, which are the class names on which the MacAddress property relies. Then we have to explore one of those to see what is inside it. I personally chose the Win32_NetworkAdapter class because I already solved a similar issue, and I remembered that this class worked for me. But after investigating the other one, Win32_NetworkAdapterConfiguration, I can assure you that the MacAddress is also there.

After we apply a filter on the adapter type to get rid of all adapters except the Ethernet adapters, and we apply a filter based on the connection status to get only the connected adapters, we remove all the virtual ones from VMWare (if any). Then we select only the first one because we suppose this is the primary one.

After we capture all the needed properties and place the result inside of some variables, we now have to put all the properties in common. This is when the New-Object cmdlet comes into play. We now are creating a custom hash table with the property names of our choice and mapping the right properties to them. Then we pass this hash table to the Property parameter and we are almost done!

Regarding the PhysicalMemory property, we can notice several things. The first is the use of the megabyte quantifier (MB). This is basically a predefined constant that aims to ease the readability of a script. It is the same but nicer and more understandable than writing 1024*1024. We divide by 1 MB to get the result in megabytes instead of bytes. The second thing is that we truncate the result thanks to the floor static method from the .NET Math class.

Then we create the file name (no difficulty here) and the path to store our XML file. Because there’s no environment variable that stores the “My documents” location, we are using the System.Environment .NET class to gain access to the system special folders. For more information about all the other special folders, please read Environment.SpecialFolder Enumeration in the MSDN Library.

Last but not least, we can convert our final object into an XML string only by using the ConvertTo-XML cmdlet, and then redirect the result to disk.

Getting the five extra points

It can happen that on some machines, some properties are null, for example, the manufacturer’s name or the computer’s model. In that case we would like our script to handle that and provide a way to add a nice ‘N/A’ string instead of a blank value.

So, one way to get the five extra points for this event, could be to check each individual property value of our resulting object (stored in the $result variable), and if we detect a null value, we replace it with the string ‘N/A’.

To do so, a generic approach is needed instead of having a ton of if instructions in our script for every property. Indeed, no matter what the number of properties the object has, accessing the raw Windows PowerShell object via the PSObject property, followed by a simple loop on each of the properties will do the trick. Using this technique will ensure that we won’t miss any property.

~Arnaud

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

Ed Wilson, Microsoft Scripting Guy

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.

Ed Wilson, Microsoft Scripting Guy