{"id":17321,"date":"2010-08-25T00:01:00","date_gmt":"2010-08-25T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2010\/08\/25\/query-active-directory-and-ping-each-computer-in-the-domain-by-using-powershell\/"},"modified":"2010-08-25T00:01:00","modified_gmt":"2010-08-25T00:01:00","slug":"query-active-directory-and-ping-each-computer-in-the-domain-by-using-powershell","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/query-active-directory-and-ping-each-computer-in-the-domain-by-using-powershell\/","title":{"rendered":"Query Active Directory and Ping Each Computer in the Domain by Using PowerShell"},"content":{"rendered":"

Summary<\/strong>: Query Active Directory and ping each computer in the domain by using Windows PowerShell. The Scripting Guys show you how.<\/p>\n

 <\/p>\n

\"Hey,<\/p>\n

Hey, Scripting Guy! I am THE IT person at my company. I am also a chemical engineer who has daily production responsibilities in our process plant. You see, I am supposed to be a part-time IT person, the problem is my collateral duty is rapidly becoming my primary duty. I feel as if I should become a MCSE, but it should not be this hard. I have been learning Windows PowerShell because I think it will make my job easier. The first thing I need to do is to find out what computers are on the network. We are running Windows Server 2008, and cannot upgrade to Windows Server 2008 R2 because our hardware will not support a 64 bit OS. Therefore, the Windows PowerShell Active Directory cmdlets you have been talking about are not available to me. I think if I could get a list of all the computers in our domain and send them a ping to find out if they actually exist it would be helpful. Can this be done?<\/p>\n

— CM<\/p>\n

 <\/p>\n

\"Hey,<\/p>\n

Hello CM, <\/p>\n

Microsoft Scripting Guy Ed Wilson here. School has officially started. The yellow school buses are trolling the neighborhood looking for passengers; newly minted students are clinging anxiously to their parent’s hands as they struggle to choose the correct bus for the prospective passenger in hand. The teacher across the street headed out early this morning with a strong sense of purpose and mission tattooed to her face. I am merely an observer to this annual ritual; watching the transactions that take place in view of my upstairs window. I have the Alan Parsons Project cranked up on my Zune HD, and as the parents pass off the passengers to the yellow conveyances, they seem to dance to the beat of unheard tunes – sort of like the film of the astronauts who first walked on the surface of the moon. <\/p>\n

CM, in IT, we are often called upon to do things we have never done before. It does not mean that we have to go boldly where no IT pro has ever gone before, but for us the experience may be new. Most of the time, when we get to our destination, we realize we were not the first to ever accomplish the feat. The trick is to find that information prior to the task, and seek advice beforehand. One great place to find assistance is the Official Scripting Guys Forum<\/a>. A great place to find scripts, of all kinds, is the Script Center Script Repository<\/a>. <\/p>\n

This week we are looking at using the [adsisearcher]<\/strong> type accelerator to search Active Directory Domain Services (AD DS). I decided to write a script that returns a list of all computers in the domain, and then pings each one to see if it responds or not. The complete Get-ADComputersTestConnection.ps1 script is seen here. <\/p>\n

\n

Get-ADComputersTestConnection.ps1<\/span><\/strong><\/span><\/p>\n

Function Get-ADComputersTestConnection
{
 <\/span>Param(
  <\/span>[switch]$showErrors
 <\/span>)
 <\/span>([adsisearcher]”objectcategory=computer”).findall() |
 <\/span>ForEach-Object {
  <\/span>try
    <\/span>{
     <\/span>Test-Connection -ComputerName ([adsi]$_.path).cn -BufferSize 16 `
         <\/span>-Count 1 -TimeToLive 1 -EA stop }
  <\/span>Catch [system.exception]
    <\/span>{  <\/span>
      <\/span>if($showErrors)
        <\/span>{ $error[0].tostring() }
    <\/span>}
 <\/span>} #end foreach-object
} #End function Get-ADComputersTestConnection<\/p>\n

# *** EntryPoint to Script ***<\/p>\n

Get-ADComputersTestConnection -showErrors<\/span><\/p>\n<\/blockquote>\n

CM, I decided to ensconce the code in a function named Get-ADComputersTestConnection<\/strong>. This function, does not really meet my requirements for a function, in that it is rather specialized, not configurable, and limited in its reuse capability. For example, because the function queries for all computers in the domain, it will have limited appeal for use in large domains. However, I did not want to clutter the function with lots of confusing options, and parameters. In addition, the use of the Test-Connection<\/strong> cmdlet does not expose the myriad options available for utilizing that cmdlet. Other than that, the Get-ADComputersTestConnection<\/strong> function is relatively cool. <\/p>\n

CM, the Get-ADComputersTestConnection.ps1 script simply calls the Get-ADComputersTestConnection<\/strong> function and passes the showErrors<\/strong> switch. This switch causes the Get-ADComputersTestConnection<\/strong> function to display status information about computers that are online, as well as the error that is generated when the computer is not online. If you feel that most of the time when you use the script, you only want information on computers that are online you should remove the switch. If, on the other hand, you want to know the status of all computers, you will use the script exactly as written. This is shown in the following image.<\/p>\n

\"Image<\/a> <\/p>\n

If you see yourself needing both capabilities, on a regular basis, the script will need a command line switch. There are only two changes for the Get-ADComputersTestConnectionSwitch.ps1 script. The first is the command line parameter to allow the showing of the errors. This is shown here:<\/p>\n

\n
Param([switch]<\/span>$showErrors<\/span>)<\/span> <\/div>\n<\/blockquote>\n

The next change is the logic at the entry point of the script to detect if the command line switch has been used when launching the script. A simple if … else statement is used. If the $showErrors <\/strong>variable is present on the Windows PowerShell variable drive, it means the script was launched with the –showErrors <\/strong>command line parameter. The if … else statement checks for the existence of this variable. If the $showErrors<\/strong> variable is found, the Get-ADComputersTestConnection<\/strong> function is called while passing the –showErrors<\/strong> parameter. Once the function completes, the script exists. If the variable is not found, the function is called with no parameters. This code is seen here. <\/p>\n

\n
if<\/span>(<\/span>$showErrors<\/span>)<\/span> <\/span>{<\/span> <\/span>Get-ADComputersTestConnection<\/span> <\/span>-showErrors<\/span> <\/span>;<\/span> <\/span>exit<\/span> <\/span>}<\/span>
<\/span>Else<\/span> <\/span>{<\/span> <\/span>Get-ADComputersTestConnection<\/span> <\/span>;<\/span> <\/span>exit<\/span> <\/span>}<\/span> <\/div>\n<\/blockquote>\n

The modification to use the script with a command line switch is shown here. <\/p>\n

\n

Get-ADComputersTestConnectionSwitch.ps1<\/strong><\/p>\n

Param([switch]$showErrors)<\/p>\n

Function Get-ADComputersTestConnection
{
 <\/span>Param(
  <\/span>[switch]$showErrors
 <\/span>)
 <\/span>([adsisearcher]”objectcategory=computer”).findall() |
 <\/span>ForEach-Object {
  <\/span>try
    <\/span>{
     <\/span>Test-Connection -ComputerName ([adsi]$_.path).cn -BufferSize 16 `
         <\/span>-Count 1 -TimeToLive 1 -EA stop }
  <\/span>Catch [system.exception]
  <\/span>  <\/span>{  <\/span>
      <\/span>if($showErrors)
        <\/span>{ $error[0].tostring() }
    <\/span>}
 <\/span>} #end foreach-object
} #End function Get-ADComputersTestConnection<\/p>\n

# *** Entry Point to Script ***<\/p>\n

if($showErrors) { Get-ADComputersTestConnection -showErrors ; exit }
Else { Get-ADComputersTestConnection ; exit }<\/span><\/span> <\/p>\n<\/blockquote>\n

When the Get-ADComputersTestConnectionSwitch.ps1 script is run with no parameters, the status of each computer in AD DS is displayed. Errors in testing the connection to the remote computers are not displayed. When the script is run with the –showErrors<\/strong> parameter, both the connection status and errors are displayed. The command line syntax and sample output for each is shown in the following image.<\/p>\n

\"Image<\/p>\n

Inside the Get-ADComputersTestConnection<\/strong> function, after the parameter statement, the first thing that is done is the [adsisearcher] <\/strong>type accelerator is used to search AD DS. The “objectcategory=computer”<\/strong> filter is used, and the findall<\/strong> method is called to return all instances of computer objects in AD DS. This section of code was discussed in detail in yesterday’s Hey Scripting Guy! Blog post<\/a>. <\/p>\n

Inside a pipeline, when you need to work on one item at a time, use the Foreach-Object<\/strong> cmdlet. You will often see its’ alias on blogs “%” or occasionally you will see it referred to by its’ other alias foreach<\/strong>. While the first alias is simply obscure, the second alias is downright confusing because foreach<\/strong> is also a keyword for the foreach<\/strong> statement. If the two commands worked the same, it would be merely inconvenient, but for people attempting to learn Windows PowerShell, they expect foreach<\/strong> to always be the foreach<\/strong> statement, and that is not the case. <\/p>\n

The ForeachComputer.ps1 script is an example about which I am talking. <\/p>\n

\n

ForeachComputer.ps1<\/strong><\/p>\n

$computers = ([adsisearcher]”objectcategory=computer”).findall()
foreach ($computer in $computers)
{
 <\/span>$computer.path
}<\/span><\/span> <\/p>\n<\/blockquote>\n

On the first line of the script, the results of the directory searcher query are stored in the $computers<\/strong> variable. Because this is a collection of objects, it is necessary to use the foreach<\/strong> statement to work through the collection to display the path of each computer. The foreach<\/strong> statement is comprised of three parts. The first is the variable to use as the placeholder (enumerator) in the collection. The second part is the collection itself. These first parts go inside a set of parentheses. The script block (code block) is placed inside a pair of curly brackets (braces). The code in the script block is executed on each item in the collection. That item is referenced by the placeholder variable. <\/p>\n

The foreach-object<\/strong> cmdlet is always used in a pipeline. The foreach-object<\/strong> statement does not use the set of parentheses. It uses the $_<\/strong> automatic variable to work with each object as it comes down the pipeline. The results from the two scripts are the same. One advantage of using the pipeline, and the foreach-object<\/strong> cmdlet is the code is more compact; there is no need to create a variable to store the results into, nor is there a need to create a variable for the placeholder as the script walks through the collection of computers. The Foreach-ObjectComputer.ps1 script is seen here. <\/p>\n

\n

Foreach-objectComputer.ps1<\/strong><\/p>\n

([adsisearcher]”objectcategory=computer”).findall() |
ForEach-Object {
 <\/span>$_.path
}<\/span><\/span> <\/p>\n<\/blockquote>\n

Which approach is faster? Using my Test-TwoScripts.ps1 script<\/a>, on my network the Foreach-objectComputer.ps1 script is 26% faster. You will need to test to see if you achieve similar results on your network. <\/p>\n

Inside the foreach-object<\/strong> block of the Get-ADComputersTestConnection.ps1 script, the first thing that is done, is the try statement is used to attempt to use the Test-Connection cmdlet to send a PING to the remote computer. The problem, is the result of the [adsisearcher]<\/strong> is a search result, not a directory entry object. Therefore, access to the normal ADSI types of properties are not available. One thing that can be access is the path. This is seen here. <\/p>\n

\n
<\/p>\n

PS C:\\> $computers = ([adsisearcher]”objectcategory=computer”).findall()
PS C:\\> ($computers[0]).gettype()<\/p>\n

IsPublic IsSerial Name                                     <\/span>BaseType
——– ——– —-       <\/span>                              <\/span>——–
True     <\/span>False    <\/span>SearchResult                             <\/span>System.Object<\/p>\n

PS C:\\> $computers[0].path
LDAP:\/\/CN=HYPERV,OU=Domain Controllers,DC=NWTraders,DC=Com
PS C:\\><\/span><\/span><\/span><\/p>\n

<\/span> <\/span><\/div>\n<\/blockquote>\n

This path is exactly what is required to obtain a directoryentry<\/strong> object from the [adsi]<\/strong> type accelerator. This is seen here. <\/p>\n

\n
PS C:\\> [adsi]$computers[0].path<\/p>\n

distinguishedName : {CN=HYPERV,OU=Domain Controllers,DC=NWTraders,DC=Com}
Path                      <\/span>: LDAP:\/\/CN=HYPERV,OU=Domain Controllers,DC=NWTraders,DC=Com<\/p>\n

PS C:\\> ([adsi]$computers[0].path).gettype()<\/p>\n

IsPublic IsSerial Name                                     <\/span>BaseType
——–    ——–    —-                                          <\/span>——–
True      <\/span>False    <\/span>DirectoryEntry                         <\/span>System.ComponentModel….<\/p>\n

PS C:\\><\/span><\/span> <\/span><\/div>\n<\/blockquote>\n

The code inside the parentheses seen above returns a DirectoryEntry<\/strong> object. It can be used to access the normal ADSI attributes. The CN<\/strong> attribute is retrieved from the first computer in the computers collection. This is seen here. <\/p>\n

\n
PS<\/span> <\/span>C:\\><\/span> <\/span>([adsi]<\/span>$computers<\/span>[<\/span>0<\/span>].path).cn<\/span> <\/p>\n

<\/span>HYPERV<\/span> <\/p>\n

<\/span>PS<\/span> <\/span>C:\\><\/span>  <\/div>\n<\/blockquote>\n

The cn<\/strong> attribute is the name of the computer that can be pinged. If the computer is not found, the erroraction<\/strong> preference is set to stop (EA<\/strong> is an alias for the erroraction<\/strong> parameter). By using stop here, it will force the script to enter the catch block. The try block is seen here.<\/p>\n

\n
<\/p>\n

try
    <\/span>{
     <\/span>Test-Connection -ComputerName ([adsi]$_.path).cn -BufferSize 16 `
         <\/span>-Count 1 -TimeToLive 1 -EA stop }<\/span><\/span><\/p>\n

<\/span><\/div>\n<\/blockquote>\n

The catch block is used to catch any system exception. This is needed because the Test-Connection<\/strong> cmdlet returns a rather nasty looking error when a computer is not found. This is seen here. <\/p>\n

\n
<\/p>\n

PS C:\\> Test-Connection bogus -BufferSize 16 -Count 1<\/span><\/span><\/span><\/p>\n

Test-Connection : Testing connection to computer ‘bogus’ failed: The requested name<\/span><\/span><\/span><\/p>\n

is valid, but no data of the requested type was found<\/span><\/span><\/span><\/p>\n

At line:1 char:16<\/span><\/span><\/span><\/p>\n

+ Test-Connection <<<<  <\/span>bogus -BufferSize 16 -Count 1<\/span><\/span><\/span><\/p>\n

    <\/span>+ CategoryInfo          <\/span>: ResourceUnavailable: (bogus:String) [Test-Connection]<\/span><\/span><\/span><\/p>\n

   <\/span>, PingException<\/span><\/span><\/span><\/p>\n

    <\/span>+ FullyQualifiedErrorId : TestConnectionException,Microsoft.PowerShell.Commands<\/span><\/span><\/span><\/p>\n

   <\/span>.TestConnectionCommand<\/span><\/span> <\/div>\n<\/blockquote>\n

This error is stored inside the $error<\/strong> variable. The $error<\/strong> variable holds an array of errors, with the most recent error always occupying position [0]. To retrieve the most recent error, you access $error[0]<\/strong> as seen here.<\/p>\n

\n
<\/p>\n

PS C:\\> $error[0]<\/span><\/span><\/span><\/p>\n

Test-Connection : Testing connection to computer ‘bogus’ failed: The requested name<\/span><\/span><\/span><\/p>\n

is valid, but no data of the requested type was found<\/span><\/span><\/span><\/p>\n

At line:1 char:16<\/span><\/span><\/span><\/p>\n

+ Test-Connection <<<<  <\/span>bogus -BufferSize 16 -Count 1<\/span><\/span><\/span><\/p>\n

    <\/span>+ CategoryInfo          <\/span>: ResourceUnavailable: (bogus:String) [Test-Connection]<\/span><\/span><\/span><\/p>\n

   <\/span>, PingException<\/span><\/span><\/span><\/p>\n

    <\/span>+ FullyQualifiedErrorId : TestConnectionException,Microsoft.PowerShell.Commands<\/span><\/span><\/span><\/p>\n

   <\/span>.TestConnectionCommand<\/span><\/span> <\/div>\n<\/blockquote>\n

In this example, the error shown in $error[0]<\/strong> looks pretty much like the one that was displayed to the Windows PowerShell console. The $error<\/strong> variable contains really rich objects, however, and there is a lot of information that can be obtained by working through the error object model. However, to obtain a more friendly looking error, all I need to do is call the tostring()<\/strong> method as seen here.<\/p>\n

\n
<\/p>\n

PS C:\\> $error[0].tostring()<\/span><\/span><\/span><\/p>\n

Testing connection to computer ‘bogus’ failed: The requested name is valid, but no d<\/span><\/span><\/span><\/p>\n

ata of the requested type was found<\/span><\/span> <\/div>\n<\/blockquote>\n

I decided to display the error by using the tostring()<\/strong> method because the information returned is actually helpful in determining why the computer is not responsive. For example, in using test-connection<\/strong> to test a connection to a computer named bogus, it says the name is valid, but no data of the requested type was found. Other errors that are returned are likewise informative. Here is the catch portion of the script. <\/p>\n

\n
Catch [system.exception]
    <\/span>{  <\/span>
     <\/span> <\/span>if($showErrors)
        <\/span>{ $error[0].tostring() }
    <\/span>}<\/span><\/span> <\/div>\n<\/blockquote>\n

CM, that is all there is to using Windows PowerShell to search AD DS. Searching Active Directory Domain Services week will continue tomorrow when we talk about searching AD<\/a> DS for computers,. We would love for you to follow us on Twitter<\/a> and Facebook<\/a>. If you have any questions, send email to us at scripter@microsoft.com<\/a> or post them on the Official Scripting Guys Forum<\/a>. See you tomorrow. Until then, peace.<\/p>\n

 <\/p>\n

Ed Wilson and Craig Liebendorfer, Scripting Guys<\/strong><\/p>\n


<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"

Summary: Query Active Directory and ping each computer in the domain by using Windows PowerShell. The Scripting Guys show you how.   Hey, Scripting Guy! I am THE IT person at my company. I am also a chemical engineer who has daily production responsibilities in our process plant. You see, I am supposed to be […]<\/p>\n","protected":false},"author":595,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[7,68,51,3,4,8,45],"class_list":["post-17321","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-active-directory","tag-error-handling","tag-getting-started","tag-scripting-guy","tag-scripting-techniques","tag-searching-active-directory","tag-windows-powershell"],"acf":[],"blog_post_summary":"

Summary: Query Active Directory and ping each computer in the domain by using Windows PowerShell. The Scripting Guys show you how.   Hey, Scripting Guy! I am THE IT person at my company. I am also a chemical engineer who has daily production responsibilities in our process plant. You see, I am supposed to be […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/17321","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/595"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=17321"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/17321\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=17321"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=17321"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=17321"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}