Search results for 'app:weblogs' matching tag 'Event 2'

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.

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: Beginner Event 2

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

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

An Inventory Intervention

The good Doctor has asked you to write a Windows PowerShell command or script 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 different versions of Windows. To help you out, he’s given you a text file, C:\IPList.txt, which contains one server IP address per line.

If you can write this as a one-liner, awesome! If not, try to keep your answer as concise and compact as possible (although it’s perfectly okay to use full command and parameter names).

Ed Wilson, Microsoft Scripting Guy

Scripting Wife Comments on Beginner Event 2

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

Summary: The Scripting Wife reveals her impressions of 2013 Scripting Games Beginner Event 2.

Well I am back from Seattle and from the Windows PowerShell Summit—and boy, did I have a lot of fun. I got to see friends from all over the world, and the amazing thing is that I knew nearly everyone there—at least virtually. Well, nearly everyone. The good thing is that I got to know the ones that I did not previously know. I really want to thank Don, Jeffery, Richard, Chris, and Jason for all their hard work in putting this summit together. Here is a picture of Lee Holmes and me outside the conference room prior to him delivering an awesome presentation.

OK…this event is not too bad. Whenever I hear things like inventory, I think of WMI. To help you get moving in the right direction, read my post, Weekend Scripter: Use PowerShell to Find the Version of Windows, where I work with the Scripting Guy to find WMI information. So all I need to do is get the operating system version, the number of processors, and the amount of memory. I also need to be able to read a text file that contains the IP addresses. No problem…this really is not too hard at all.

~Scripting Wife

Expert Commentary: 2012 Scripting Games Advanced Event 2

Anonymous — Tue, 17 Apr 2012 05:00:00 GMT

Summary: Microsoft community contributor, Boe Prox, provides expert commentary for 2012 Scripting Games Advanced Event 2.

Microsoft Scripting Guy, Ed Wilson, is here. Boe Prox is the expert commentator for Advanced Event 2.

Boe is currently a senior systems administrator with BAE Systems. He has been in the IT industry since 2003, and he has been working with Windows PowerShell since 2009. Boe looks to script whatever he can, whenever he can. He is also a moderator on the Official Scripting Guys Forum. Check out his current projects published on CodePlex: PoshWSUS and PoshPAIG.

Blog: Learn PowerShell | Achieve More
Guest posts on Hey, Scripting Guy! Blog
Twitter: @proxb

This is an event that relates very nicely to something that would be done in the “real world.” Tracking your services on each server is something that should be done daily to ensure that everything is working normally and to make sure that there are no anomalies occurring.

This event requires us to perform a query against local and/or remote servers to pull back all of the services and write out the data to a CSV file. This is definitely a job for Windows PowerShell!

Requirements

This event is not without requirements to give you more of a challenge, so let’s take a look at the key requirements:

You need to present your findings in a spreadsheet that includes the following information: the server name, the service name, the start mode of the service, the user account used to start the service, and the current status of the service.
You should use the easiest method possible to display the information in a spreadsheet.
You must include the ability to run the script on a local computer and on a remote computer.
You must include the ability to run the script with alternate credentials when operating against a remote computer, and you should impersonate the logged on user when running locally.
You do not need to add comment-based Help for this scenario, but additional points are awarded if you do include appropriate comment-based Help such as the description, examples, and parameters.
If the script requires admin rights to run, you should check to ensure that the script is running with admin rights. If those rights are not present, you should display an appropriate message and exit.
For the purposes of this exercise, do not write a module. You should make your script completely standalone and have no external dependencies. Therefore, everything needed should be put in this script. Failure to do so will cost you points.

Now that we know what is required for this script, we can begin to dive into the code and see what is going on. I will take the code apart in chunks to explain what I am doing and point out the areas that meet each requirement in addition to other areas that I feel are worth mentioning. I included some extra features for this script, and I will explain my reasoning behind this when I get to them.

The code

Function Get-ServiceData {

.SYNOPSIS

Command used to find all services with option to write to a CSV File

.DESCRIPTION

Command used to find all services with option to write to a CSV File

.PARAMETER Computername

A single or collection of systems to perform the query against

.PARAMETER Credential

Alternate credentials to use for query of services

.PARAMETER ToCSV

Name of CSV to write the results of the query to

.PARAMETER Throttle

Number of asynchronous jobs that will run at a time

.PARAMETER ShowProgress

Displays the progress of the services query

.NOTES

Author: Boe Prox

Created: 14March2012

.EXAMPLE

Get-ServiceData

Description

-----------

Retrieves all services from the local system

.EXAMPLE

$Servers = 'Server1','Server2','Server3'

Get-ServiceData -Computername $Servers -ShowProgress

Description

-----------

Retrieves all services from the remote servers and displays a progress bar

.EXAMPLE

$Servers = Get-Content Servers.txt

$Servers | Get-ServiceData -ShowProgress -Throttle 10

Description

-----------

Retrieves all services from the remote servers while running 10 runspace jobs at a time

and displays a progress bar to show the status of each runspace job.

.EXAMPLE

$Servers = Get-Content Servers.txt

$Servers | Get-ServiceData -Credential (Get-Credential) -ToCSV (Join-Path $pwd report.csv)

Description

-----------

Retrieves all services for each system in the Servers.txt file while using the supplied

alternate credentials and outputs the data to a CSV file.

#Requires -Version 2.0

[cmdletbinding(

DefaultParameterSetName = 'NonCSV'

)]

Param (

[parameter(ValueFromPipeline = $True,ValueFromPipeLineByPropertyName = $True)]

[Alias('CN','__Server')]

[string[]]$Computername = $Env:Computername,

[parameter()]

[System.Management.Automation.PSCredential]$Credential,

[parameter(ParameterSetName = 'CSV')]

[ValidateNotNullOrEmpty()]

[String]$ToCSV,

[parameter()]

[int]$Throttle = 5,

[parameter()]

[switch]$ShowProgress

)

If you are going to create an advanced function, you definitely have to have inline Help within that function. This does not mean that you write your own Help function and offer that. It means that you use the Help in Windows PowerShell to accomplish this task. I included examples about how to use this function so others can reference it when trying to run the command.

Also included is [cmdletbinding()], which makes this advanced function advanced by adding extra parameters such as –Verbose and –WhatIf. I also make sure that I add a default parameter value for my ComputerName parameter to point to the local machine if nothing is given. Also, if no file name is given with ToCSV, it will throw an error until a file name is specified.

Begin {

#Function that will be used to process runspace jobs

Function Get-RunspaceData {

[cmdletbinding()]

param(

[switch]$Wait,

[switch]$ShowProgress

)

Do {

$more = $false

Foreach($runspace in $runspaces) {

If ($runspace.Runspace.isCompleted) {

$Script:Report += $runspace.powershell.EndInvoke($runspace.Runspace) |

Select SystemName,Name,State,StartMode,StartName

$runspace.powershell.dispose()

$runspace.Runspace = $null

$runspace.powershell = $null

$Script:i++

If ($PSBoundParameters['ShowProgress']) {

Write-Progress -Activity 'Services Query' -Status ("Processing Runspace: {0}" -f $runspace.computer) `

-PercentComplete (($i/$totalcount)*100)

}

} ElseIf ($runspace.Runspace -ne $null) {

$more = $true

}

If ($more -AND $PSBoundParameters['Wait']) {

Start-Sleep -Milliseconds 100

}

#Clean out unused runspace jobs

$temphash = $runspaces.clone()

$temphash | Where {

$_.runspace -eq $Null

} | ForEach {

Write-Verbose ("Removing {0}" -f $_.computer)

$Runspaces.remove($_)

}

} while ($more -AND $PSBoundParameters['Wait'])

}

Write-Verbose ("Performing inital Administrator check")

$usercontext = [Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()

$IsAdmin = $usercontext.IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator")

#Counter for Write-Progress

$Script:i = 0

#Main collection to hold all data returned from runspace jobs

$Script:report = @()

Write-Verbose ("Building hash table for WMI parameters")

$wmihash = @{

Query = "SELECT SystemName,Name,StartMode,State,Startname FROM Win32_Service"

ErrorAction = "Stop"

}

#Supplied Alternate Credentials?

If ($PSBoundParameters['Credential']) {

$wmihash.credential = $Credential

}

#Define hash table for Get-RunspaceData function

$runspacehash = @{}

If ($PSBoundParameters['ShowProgress']) {

$runspacehash.ShowProgress = $True

}

#Define Scriptblock for runspaces

$scriptblock = {

Param (

$Computer,

$wmihash

)

Write-Verbose ("{0}: Checking network connection" -f $Computer)

If (Test-Connection -ComputerName $Computer -Count 1 -Quiet) {

#Check if running against local system and perform necessary actions

Write-Verbose ("Checking for local system")

If ($Computer -eq $Env:Computername) {

$wmihash.remove('Credential')

} Else {

$wmihash.Computername = $Computer

}

Try {

Get-WmiObject @wmihash

} Catch {

Write-Warning ("{0}: {1}" -f $Computer,$_.Exception.Message)

Break

}

} Else {

Write-Warning ("{0}: Unavailable!" -f $Computer)

Break

}

Write-Verbose ("Creating runspace pool and session states")

$sessionstate = [system.management.automation.runspaces.initialsessionstate]::CreateDefault()

$runspacepool = [runspacefactory]::CreateRunspacePool(1, $Throttle, $sessionstate, $Host)

$runspacepool.Open()

Write-Verbose ("Creating empty collection to hold runspace jobs")

$Script:runspaces = New-Object System.Collections.ArrayList

$totalcount = $computername.count

}

The Begin block is pretty meaty but it sets up a lot of the code that will be processed later in the function.

A few of the requirements are covered here with an initial check for Administrator rights and allowing the code to run on a local or a remote system. A gotcha is also presented here because the use of alternate credentials will not work against a local system.

If a local system is included with other remote systems, the alternate credentials are simply removed from the runspace.

Although I do not have time to dive into everything here, I will say that this is where I set up a script block that handles each client computer, use two hash tables for splatting parameters (one for the Get-WMIObject cmdlet and another for a function that will be defined later). I also make use of the [runspacefactory] accelerator that allows me to set up some background runspace jobs and also allows throttling those runspaces, which allows for quicker processing of the queries. I chose this over using the *-Job cmdlets because there is not an easy way to throttle jobs, and this is more of a lightweight method to run jobs in a background runspace.

To quickly jump into an example, the following screenshots show the amount of time it took to run this function by using the background runspaces versus using a more synchronous command, ForEach, against 132 systems.

Get-ServiceData Function

Using ForEach

As you can see, the difference is about 220 seconds. While not a massive amount of time, it is still a nice improvement over the synchronous way using ForEach. Credit for the throttling technique goes to Windows PowerShell MVP, Dr. Tobias Weltner, for his webcast, Speeding Up PowerShell: Multithreading, which explained the use of [runspacefactory] to provide throttling.

Process {

Write-Verbose ("Validating that current user is Administrator or supplied alternate credentials")

If (-Not ($Computername.count -eq 1 -AND $Computername[0] -eq $Env:Computername)) {

#Now check that user is either an Administrator or supplied Alternate Credentials

If (-Not ($IsAdmin -OR $PSBoundParameters['Credential'])) {

Write-Warning ("You must be an Administrator to perform this action against remote systems!")

Break

}

ForEach ($Computer in $Computername) {

#Create the powershell instance and supply the scriptblock with the other parameters

$powershell = [powershell]::Create().AddScript($ScriptBlock).AddArgument($computer).AddArgument($wmihash)

#Add the runspace into the powershell instance

$powershell.RunspacePool = $runspacepool

#Create a temporary collection for each runspace

$temp = "" | Select-Object PowerShell,Runspace,Computer

$Temp.Computer = $Computer

$temp.PowerShell = $powershell

#Save the handle output when calling BeginInvoke() that will be used later to end the runspace

$temp.Runspace = $powershell.BeginInvoke()

Write-Verbose ("Adding {0} collection" -f $temp.Computer)

$runspaces.Add($temp) | Out-Null

Write-Verbose ("Checking status of runspace jobs")

Get-RunspaceData @runspacehash

}

The Process block does just that: processes all of the computers and assigns each computer as a background runspace. More requirements are met here, including the finishing check of Administrator rights if running against remote systems. If there is only a local system and it is the only system in the collection, alternate credentials are not required nor are Administrator rights because any local user can perform a query against WMI.

End {

Write-Verbose ("Finish processing the remaining runspace jobs: {0}" -f (@(($runspaces | Where {$_.Runspace -ne $Null}).Count)))

$runspacehash.Wait = $true

Get-RunspaceData @runspacehash

Write-Verbose ("Closing the runspace pool")

$runspacepool.close()

If ($PSBoundParameters['ShowProgress']) {

#Close the Write-Progress bar so it does not affect the displaying of data when completed.

Write-Progress -Activity 'Services Query' -Status 'Completed' -Completed

}

If ($PSBoundParameters['ToCSV']) {

Write-Verbose ("Writing report to CSV: {0}" -f $ToCSV)

$Report | Export-Csv -Path $ToCSV -NoTypeInformation

} Else {

Write-Verbose ("Displaying Report")

Write-Output $Report

}

The End block finishes up the remaining runspace jobs, and depending on what the user chose for output (CSV or no CSV), the function will output the data to the console or write all of the data to a specified CSV file (meeting an important requirement). I chose to use Export-CSV because it meets the requirement for the easiest method possible to create a CSV file. If I was using Windows PowerShell 3.0, I could have thrown this in with the runspace script block and used the –Append parameter to further increase the performance of this function instead of holding all of the data until the end and writing out to the CSV file.

Let’s give it a quick run to see it in action and view the final output.

$Servers = Get-Content .\servers.txt

Get-ServiceStartMode -Computername $servers -ShowProgress -ToCSV "C:\users\boe\desktop\report.csv"

As you can see, all of the data that was required is on the spreadsheet to view.

The script is available to download from the Script Center Repository.

~Boe

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

Ed Wilson, Microsoft Scripting Guy

Expert Commentary: 2012 Scripting Games Beginner Event 2

Anonymous — Tue, 17 Apr 2012 05:00:00 GMT

Summary: Windows PowerShell MVP, Shane Hoey, provides expert commentary for 2012 Scripting Games Beginner Event 2.

Microsoft Scripting Guy, Ed Wilson, is here. Shane Hoey is the expert commentator for Beginner Event 2.

Shane’s scripting experience started when Windows XP was the new kid on the block, and he soon found himself scripting on a daily basis with VBScript, WMI, and ADSI. Fast forward to the Scripting Games 2009—he finally discovered Windows PowerShell, and he has been hooked ever since. One of the things he likes most about Windows PowerShell is its ability to easily automate tasks.

Twitter: @shanehoey
Aussie PowerShell Usergroup

I often talk to IT Pros who are starting to learn Windows PowerShell, and one of the first things I always say is, “Don’t overthink Windows PowerShell, it’s a shell first and foremost, so learn to use the shell first and scripting will naturally follow.” In fact, not everything needs to be made a script! And Scripting Games 2012 Beginner Event 2 is a perfect example.

When I first read the event scenario, I thought, did I miss something? There has to be a trick. Let’s break it down to what we need to do…

We only have to find all services that can be stopped, we don’t even need to shut down the computers yet.
No need to have a second computer to run against, which is good because I’m writing this post on the bus. So when I mention LocalHost, you could in fact be running it against a remote machine.
No need to test firewall connections.
Use the simplest command that will work.
Display the output to the screen.
Can use standard aliases.

It’s only Beginner Event 2, and many of you are new to Windows PowerShell, so now is a good time to remind you the importance of using Get-Help, Get-Command, and Get-Member.

The first command I will run is get-help get-service –online to open the Get-Service Help topic. Have a quick read of the topic to familiarize yourself with the cmdlet, and always make sure that you look at the examples because they can help us out.

Remember Windows PowerShell is object-orientated so when a cmdlet returns something, it always returns an object. We can use Get-Member to learn about more these objects, and the methods and properties that relate to the object. So I run the Get-Member cmdlet, and as you can see in the following command output, I quickly find out that I can use the CanStop property.

From running these two cmdlets, we now have all the information to get the results we need, so I run the following command:

Get-service –computername localhost | where-object {$_.canstop}

One of the design points in this event mentions that we can use aliases, so by using the Get-Alias cmdlet, I can determine each cmdlet’s alias. But a word of advice—don’t use aliases in scripts, especially when you are sharing those scripts, because aliases can be changed. If I use aliases, the command and the associated output look like this:

gsv –c localhost | ? {$_.canstop}

Based on the requirements, it looks like we have winner! But what if we want to obtain details on multiple servers? A simple addition to our command is to use parentheses, which will force the command it contains to execute first. An easy way to explain it is think of two maths equations: 5 * 5 +1 = 26 versus 5 * (5 + 1) = 30. Parentheses work exactly the same in Windows PowerShell.

gsv –c (gc servers.txt) | ? {$_.canstop}

For a final step we could format the output into something a bit more readable. For the purposes of this event, I don’t think this is needed; but it’s easy enough, so let’s do it.

gsv –c (gc servers.txt) | ?{$_.canstop} | sort machinename | ft –groupby Machinename

It can’t be this easy, can it? I wonder if the Scripting Guy is trying to trick me! I better check the 2012 Scripting Games Study Guide.

So could we use WMI? You bet we can! And the Scripting Guy mentions using WMI in his Study Guide. To get the similar results we would need to a command similar to this:

gwmi win32_service –comp localhost –filter “AcceptStop=$true” | FT state,Name,DisplayName

That’s cool, but this really does not meet our design criteria of running the simplest command that works. However, it does prove that there are many ways to do the same thing in Windows PowerShell.

We are almost finished, but before we go I want to make you aware of one last important feature in Windows PowerShell: pipeline parameter binding. From the Help page we opened earlier, you should be able to see that some parameters can accept the input of pipeline attributes ByValue and ByPropertyName. These parameters include ComputerName (ByPropertyName), InputObject (ByValue), and Name (ByPropertyName, ByValue).

Over at the PowerShell with a Purpose Blog by Don Jones, he discusses pipeline parameter binding in more detail, so I recommend that you read these blogs:

I’ve shown you two ways to get the required results for Scripting Games 2012 Beginner Event 2, and hopefully I have shown you why sometimes running a simpler command is best!

~Shane

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

Ed Wilson, Microsoft Scripting Guy

2012 Scripting Games Advanced Event 2: Find Information about Remote and Local Services

Anonymous — Tue, 03 Apr 2012 05:00:00 GMT

Summary: In Advanced Event 2, you must find information about remote and local services.

About this event

Division	Advanced
Date of Event	4/3/2012 12:01 AM
Due Date	4/10/2012 12:01 AM

Event scenario

You are a server administrator for a medium-sized enterprise company. Your boss has tasked you with finding the way that all services on all servers start. You need to present your findings in a spreadsheet that includes the following information:

The server name
The service name
The start mode of the service
The user account used to start the service
The current status of the service

An acceptable output for this task is shown in the following image.

Design points

You should use the easiest method possible to display the information in a spreadsheet.
You must include the ability to run the script both on a local computer and on a remote computer.
You must include the ability to run the script with alternate credentials when operating against a remote computer—you should impersonate the logged on user when running locally.
You do not need to add comment-based Help for this scenario, but additional points are awarded if you do include appropriate comment-based Help, such as a description, examples, and parameters.
If the script requires administrative rights to run, you should check to ensure that the script is running with admin rights. If those rights are not present, you should display an appropriate message and exit.
For the purpose of THIS exercise, do not write a module. You should make your script stand completely alone, with NO external dependencies. Therefore, EVERYTHING this script needs should be put in this script. Failure to do so will cost you points.

2012 Scripting Games links

2012 Scripting Games: All Links on One Page

Ed Wilson, Microsoft Scripting Guy

2012 Scripting Games Beginner Event 2: Find Stoppable Running Services

Anonymous — Tue, 03 Apr 2012 05:00:00 GMT

Summary: In Beginner Event 2, you have to find stoppable running services.

About this event

Division	Beginner
Date of Event	4/3/2012 12:01 AM
Due Date	4/10/2012 12:01 AM

Event scenario

You are a server administrator for a medium-sized enterprise company. Your boss wants you to write a Windows PowerShell script to shut down servers across the network. Instead of simply shutting down the servers, he wants you to investigate a more controlled shut down of services prior to actually shutting down the server.

As a first step in this process, you need to find all services that are running that will actually accept a Stop command. You need to run this command remotely against trusted computers that have the appropriate ports open through their firewalls, so your command must work against remote computers.

An appropriate output is shown in the following image.

Design points

For the purposes of this exercise, you do not need to have a second computer against which to run.
For the purposes of this exercise, you do not need to test firewall connections, nor do you need to configure the firewall. Assume that the appropriate ports are opened.
Use the simplest command that will work. You do not need to write an entire script.
Display the output to the screen; you do not need to write to a text file.
It is permissible to use standard aliases (if any exist). It is NOT permissible to use non-standard aliases that do not exist without special configuration.

2012 Scripting Games links

2012 Scripting Games: All Links on One Page

Ed Wilson, Microsoft Scripting Guy

Expert Solution for the 2011 Scripting Games Advanced Event 2: Use PowerShell to Identify Services Dependent on Windows

Anonymous — Tue, 19 Apr 2011 05:00:00 GMT

Summary : Microsoft PowerShell MVP Brandon Shell solves 2011 Scripting Games Advanced Event 2, and identifies Windows service dependencies. Microsoft Scripting Guy, Ed Wilson, here. Today Brandon Shell offers his solution to the Windows PowerShell 2011...(read more)

Expert Solution for 2011 Scripting Games Beginner Event 2: Use PowerShell to Find Windows Services You Can Pause

Anonymous — Tue, 19 Apr 2011 05:00:00 GMT

Summary : Microsoft Windows PowerShell MVP, Shane Hoey, solves 2011 Scripting Games Event 2 by finding services that he can pause. Microsoft Scripting Guy, Ed Wilson, here. Our expert commentator for Beginner Event 2 is Shane Hoey. This is what Shane...(read more)

The 2011 Scripting Games Advanced Event 2: Use PowerShell to Identify Status of Service Dependencies

Anonymous — Tue, 05 Apr 2011 05:00:00 GMT

Summary : Advanced Event 2 in the 2011 Scripting Games uses Windows PowerShell to identify the status of service dependencies. About this event Division Advanced Date of Event 4/5/2011 12:15 AM Due Date 4/12/2011 12:15 AM Event scenario You are on the...(read more)