 © Rakhesh Sasidharan
|
Posted: October 27th, 2013 | Tags: COM, registry | Category: PowerShell | § Today I was looking for the COM ProgID for Excel on my machine and my previous approach of using WMI didn’t work.
|
|
PS> gwmi Win32_COMSetting | ?{ $_.ProgId -match "Excel" } PS> |
That’s not correct as I can create a new COM object by referring to Excel.Application.
Since ProgIDs are found in the registry under HKEY_LOCAL_MACHINE\SOFTWARE\Classes I figured that would be a good place to get an exhaustive list from. Under this key there are three types of subkeys:
- Subkeys for each file extension registered with the system, each of which has a
(Default) entry with the ProgID and also a subkey with the ProgID. Not all these ProgIDs seem to be valid though (based on my testing), so it’s best to go by the other set of subkeys detailed below.
- Subkeys for each
ProgID – usually of both ProgID formats <Program>.<Component>.<Version> and <Program>.<Component> – again, not all valid, but a good test of validity (based on my testing) being whether they contain a subkey called CLSID.
- Subkeys such as “Unknown”, “Undecided”, etc and also some that look like
ProgIDs but are not in the correct format (for instance: they don’t contain the <Component>.<Version> bit, or contain spaces and underscores (not allowed)
So a sensible way to filter out ProgIDs seems to be to check for subkeys of the format <Program>.<Component>.<Version> (the <Version> being optional) and to further filter out those which have a CLSID subkey.
Thus we have the following:
|
|
Get-ChildItem "HKLM:\SOFTWARE\Classes" | ?{ ($_.PSChildName -match "^[a-z]+\.[a-z]+(\.\d+)?$") -and ($_.GetSubKeyNames() -contains "CLSID") } | ft PSChildName |
And to search for a specific application, one can do:
|
|
Get-ChildItem "HKLM:\SOFTWARE\Classes" | ?{ ($_.PSChildName -match "^[a-z]+\.[a-z]+(\.\d+)?$") -and ($_.GetSubKeyNames() -contains "CLSID") } | ?{ $_.PSChildName -match "Excel" } | ft PSChildName |
Posted: October 26th, 2013 | Tags: COM, wmi | Category: PowerShell | § Let’s see what WMI can tell us about COM objects on the system.
Get a list of all WMI classes with the word “COM” in them (doing a case sensitive match to avoid entries like “computer”).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
PS> gwmi -list | ?{ $_.Name -cmatch "COM" } NameSpace: ROOT\cimv2 Name Methods Properties ---- ------- ---------- MSFT_WMI_GenericNonCOMEvent {} {ProcessId, PropertyNames, PropertyValues, ProviderName...} Win32_COMApplication {} {Caption, Description, InstallDate, Name...} Win32_DCOMApplication {} {AppID, Caption, Description, InstallDate...} Win32_COMClass {} {Caption, Description, InstallDate, Name...} Win32_ClassicCOMClass {} {Caption, ComponentId, Description, InstallDate...} Win32_COMSetting {} {Caption, Description, SettingID} Win32_ClassicCOMClassSetting {} {AppID, AutoConvertToClsid, AutoTreatAsClsid, Caption...} Win32_DCOMApplicationSetting {GetLaunchSecurit... {AppID, AuthenticationLevel, Caption, CustomSurrogate...} Win32_ClassicCOMClassSettings {} {Element, Setting} Win32_COMApplicationSettings {} {Element, Setting} Win32_DCOMApplicationAccessAllow... {} {Element, Setting} Win32_COMApplicationClasses {} {GroupComponent, PartComponent} Win32_ClassicCOMApplicationClasses {} {GroupComponent, PartComponent} Win32_DCOMApplicationLaunchAllow... {} {Element, Setting} |
Win32_COMApplication gives me about 386 results. It includes the AppID of the application associated with the COM object.
I am not a programmer so I won’t be going further into AppIDs and such, but it’s worth knowing about this and related COM terminology so here’s a quick rundown:
- All COM objects have a
CLSID which is basically a 128-bit hexadecimal Globally Unique IDentifier (GUID) for the COM object. This way COM objects can be referred to independent of their installation path. The CLSID is unique across network computers too (relevant, when used with DCOM).
WMI objects refer to this as ComponentID. They can also be found in the registry under HKEY_LOCAL_MACHINE\SOFTWARE\Classes\CLSID. For example, the CLSID for WordPad is {73FDDC80-AEA9-101A-98A7-00AA00374959}
CLSIDs are not easy to remember, and sometimes COM objects with different CLSIDs can be used interchangeably (for instance: different versions of Internet Explorer will have different CLSIDs but you need some way of referring to the Internet Explorer COM object such that whatever version is installed on the system is used). For this reason you have ProgIDs (Programmatic IDentifier).
ProgIDs can be found in the registry under HKEY_LOCAL_MACHINE\SOFTWARE\Classes. The format of a ProgID is <Program>.<Component>.<Version>, separated by periods and with no spaces. For example, the ProgID for WordPad is WordPad.Document.1.
PowerShell’s New-Object cmdlet uses ProgID when creating new objects that refer to COM objects so ProgIDs are relevant to us.
|
|
PS> help New-Object -Parameter ComObject -ComObject <String> Specifies the programmatic identifier (ProgID) of the COM object. Required? true Position? 1 Default value None Accept pipeline input? false Accept wildcard characters? false |
- While not relevant to the current topic, there’s also an
AppID which is yet another 128-bit hexadecimal GUID. You can read more about it here.
Now let’s get a list of how many objects are returned by each WMI class.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
PS> gwmi -list | ?{ $_.Name -cmatch "COM" } | ft Name,@{Name="Number of objects";Expr={(gwmi $_.Name | Measure-Object -Line).Lines}} -AutoSize Name Number of objects ---- ----------------- MSFT_WMI_GenericNonCOMEvent 0 Win32_COMApplication 397 Win32_DCOMApplication 397 Win32_COMClass 5721 Win32_ClassicCOMClass 5721 Win32_COMSetting 6118 Win32_ClassicCOMClassSetting 5721 Win32_DCOMApplicationSetting 397 Win32_ClassicCOMClassSettings 5721 Win32_COMApplicationSettings 397 Win32_DCOMApplicationAccessAllowedSetting 526 Win32_COMApplicationClasses 579 Win32_ClassicCOMApplicationClasses 579 Win32_DCOMApplicationLaunchAllowedSetting 491 |
The biggest results are from the Win32_COMSetting class. Let’s compare the results of this with the Win32_ClassicCOMClassSetting class (which has the second largest number of results) to see what’s different. Since the ProgID property is what’s relevant to PowerShell, let’s filter the results to objects where ProgID is not $null.
|
|
# store the results from each class in a variable; filter out ones where ProgID is $null PS> $COMClassicSet = gwmi Win32_ClassicCOMClassSetting | ?{ $_.ProgId -ne $null } | Sort-Object PS> $COMSet = gwmi Win32_COMSetting | ?{ $_.ProgId -ne $null } | Sort-Object PS> Compare-Object $COMSet $COMClassicSet PS> |
There’s no difference. So in terms of ProgID both classes contain the same number of objects. Now let’s recreate the above table to only consider results where ProgID is not $null.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
PS> gwmi -list | ?{ $_.Name -cmatch "COM" } | ft Name,@{Name="Number of objects";Expr={(gwmi $_.Name | ?{ $_.ProgID -ne $null } | Measure-Object -Line).Lines}} -AutoSize Name Number of objects ---- ----------------- MSFT_WMI_GenericNonCOMEvent 0 Win32_COMApplication 0 Win32_DCOMApplication 0 Win32_COMClass 0 Win32_ClassicCOMClass 0 Win32_COMSetting 1613 Win32_ClassicCOMClassSetting 1613 Win32_DCOMApplicationSetting 0 Win32_ClassicCOMClassSettings 0 Win32_COMApplicationSettings 0 Win32_DCOMApplicationAccessAllowedSetting 0 Win32_COMApplicationClasses 0 Win32_ClassicCOMApplicationClasses 0 Win32_DCOMApplicationLaunchAllowedSetting 0 |
The interesting thing to note is that all the other classes have 0 objects now. In fact, we can see that the number of objects returned by the Win32_COMSetting class is equal to the number returned by Win32_ClassicCOMClassSetting plus Win32_COMApplication or Win32_DCOMApplication or Win32_DCOMApplicationSetting or Win32_COMApplicationSettings. Something to investigate later?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
PS C:\Users\rakhesh\Code> gwmi -list | ?{ $_.Name -cmatch "COM" } | ft Name,@{Name="Number of objects";Expr={(gwmi $_.Name | Measure-Object -Line).Lines}} -AutoSize Name Number of objects ---- ----------------- MSFT_WMI_GenericNonCOMEvent 0 Win32_COMApplication 397 Win32_DCOMApplication 397 Win32_COMClass 5721 Win32_ClassicCOMClass 5721 Win32_COMSetting 6118 Win32_ClassicCOMClassSetting 5721 Win32_DCOMApplicationSetting 397 Win32_ClassicCOMClassSettings 5721 Win32_COMApplicationSettings 397 Win32_DCOMApplicationAccessAllowedSetting 526 Win32_COMApplicationClasses 579 Win32_ClassicCOMApplicationClasses 579 Win32_DCOMApplicationLaunchAllowedSetting 491 |
So, the best way to get COM objects via WMI & PowerShell is to use the Win32_COMSetting class. And to get the ProgID or any application (such as Internet Explorer in the previous post) something along the following lines will do:
|
|
PS> gwmi Win32_COMSetting | ?{ $_.ProgId -match "Internet" } | ft ProgId,Caption ProgId Caption ------ ------- InternetExplorer.Application.1 Internet Explorer(Ver 1.0) Internet.HHCtrl.1 HHCtrl Object Internet.HHCtrl.1 HHCtrl Object Internet.HHCtrl.1 HHCtrl Object InternetShortcut Internet Shortcut |
If there’s only one version, the version number can be skipped in ProgID which is why InternetExplorer.Application too works.
Update: In fact, only the Win32_COMSetting and Win32_ClassicCOMClassSetting classes contain ProgID in their output. So these are the only two classes one can use. And since the only difference them is that Win32_COMSetting contains objects without any ProgID (of no use in our case!) it’s ok to use either class.
|
|
PS> gwmi -list | ?{ $_.Name -cmatch "^Win32.*COM" } | ?{ @(gwmi $_.Name | gm -MemberType Property | select -Unique -Expand Name).Contains("ProgId") } NameSpace: ROOT\cimv2 Name Methods Properties ---- ------- ---------- Win32_COMSetting {} {Caption, Description, SettingID} Win32_ClassicCOMClassSetting {} {AppID, AutoConvertToClsid, AutoTreatAsClsid, Caption...} |
Update2: Turns out WMI is not a good way to get the list of COM objects. A better approach is to query the registry. See my next post.
Posted: October 24th, 2013 | Tags: COM, internet, links, net, powershell3, webclient | Category: PowerShell | § A continuation to my previous post on getting links.
Internet Explorer is an application with a rich COM interface. And PowerShell can work with COM objects. Thus you can do the following:
|
|
# create a new COM object that links to IE $ie = New-Object -ComObject "InternetExplorer.Application" # sleep for two seconds while IE launches Start-Sleep -Seconds 2 # navigate to the page you want; note: the IE window is hidden so users won't see anything $ie.Navigate("http://URL/of/page") # sleep for two seconds while IE opens the page Start-Sleep -Seconds 2 # since it is an Object you can use methods and properties to get a list of links $ie.Document.Links | select href # quit IE $ie.Application.Quit() |
The Document property is very powerful and lets you see a lot of details of the page. It has a subproperty Link that gives all the link elements in the page (it has nearly 800 properties, methods, and events!). The output is as objects, and since we are only interested in the actual link href elements we can select that property.
If you are PowerShell v3 things are even easier. There’s a cmdlet called Invoke-WebRequest who is your friend.
To get an object representing the website do:
|
|
Invoke-WebRequest "http://url/of/page" |
To get all the links in that website:
|
|
Invoke-WebRequest "http://url/of/page" | select -ExpandProperty Links |
And to just get a list of the href elements:
|
|
Invoke-WebRequest "http://url/of/page" | select -ExpandProperty Links | select href |
Like the System.Net.Webclient class Invoke-WebRequest has parameters to specify proxy, headers, encoding, etc.
Posted: October 23rd, 2013 | Tags: acl, active directory, ownership | Category: PowerShell | § The Get-ACL cmdlet can be used to view and modify Access Control Lists in PowerShell. It works with any object you have a PSProvider for – be it files, folders, registry keys, Active Directory objects, and so on.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
PS> Get-Acl .\temp.txt Directory: C:\ Path Owner Access ---- ----- ------ temp.txt WALLY\rakhesh NT AUTHORITY\SYSTEM Allow FullC... # try with a registry key PS> Get-Acl HKLM:\Software Path Owner Access ---- ----- ------ Microsoft.PowerShell.Core\Registr... NT AUTHORITY\SYSTEM BUILTIN\Users Allow ReadKey... # import AD module and try with an AD user; prefix the AD:\ prvoider name before the distringuished name of the object PS> import-module ActiveDirectory PS> Get-Acl "AD:\$((Get-ADUser rakhesh).DistinguishedName)" Path Owner Access ---- ----- ------ ActiveDirectory:://RootDSE/CN=Sasidh... DOMAINNAME\Domain Admins NT AUTHORITY\Authenticated Users All... |
Viewing and setting the Owner
To find the owner of an object there are couple of ways. The easy way is to use the Owner property:
|
|
PS> (Get-Acl .\temp.txt).Owner WALLY\rakhesh |
But there’s a GetOwner() method too. This takes as input the type of output you want. The input must be of class System.Security.Principal.IdentityReference. There are two such class: System.Security.Principal.NTAccount gives you the user account while System.Security.Principal.SecurityIdentifier gives you the SID. These two classes are worth remembering when you want to convert between a user account and SID or vice versa.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
# view the definition PS> (get-acl .\temp.txt).GetOwner OverloadDefinitions ------------------- System.Security.Principal.IdentityReference GetOwner(type targetType) # get the user account name PS> (get-acl .\temp.txt).GetOwner([System.Security.Principal.NTAccount]) Value ----- WALLY\rakhesh # get the SID PS> (get-acl .\temp.txt).GetOwner([System.Security.Principal.SecurityIdentifier]) BinaryLength AccountDomainSid Value ------------ ---------------- ----- 28 S-1-5-21-3165787769-3955403704-19... S-1-5-21-3165787769-3955403704-1... |
You can set the owner too using the SetOwner() method.
|
|
# view the definition; note this too takes an IdentityReference object PS> (Get-Acl .\temp.txt).SetOwner OverloadDefinitions ------------------- void SetOwner(System.Security.Principal.IdentityReference identity) |
Simply doing a SetOwner() won’t do the trick though because what Get-Acl returns is an ACL object and so all we are really doing is setting the ownership info in that object but not applying it back to the file or folder whose ACL it is.
|
|
# notice how I specify the username by typecasting it to the correct IdentityReference class PS> (Get-Acl .\temp.txt).SetOwner([System.Security.Principal.NTAccount]"WALLY\rakhesh") PS> (Get-Acl .\temp.txt).Owner WALLY\Guest |
The correct way would be thus:
|
|
PS> $acl = Get-Acl .\temp.txt PS> $acl.SetOwner([System.Security.Principal.NTAccount]"WALLY\Rakhesh") PS> Set-Acl .\temp.txt $acl PS> (Get-Acl .\temp.txt).Owner WALLY\Rakhesh |
Setting the owner – gotchas
For reasons I don’t know, the following doesn’t work:
|
|
PS> (Get-Acl .\temp.txt).SetOwner([System.Security.Principal.NTAccount]"WALLY\Rakhesh") | Set-Acl .\temp.txt |
It could be because of this:
|
|
PS> $acl = Get-Acl .\temp.txt PS> $acl ... # you get some output PS> $acl = (Get-Acl .\temp.txt).SetOwner([System.Security.Principal.NTAccount]"WALLY\rakhesh") PS> $acl # nothing! |
When you set the owner directly, the object is empty. It could be because the SetOwner method doesn’t return anything so $acl is assigned nothing. But when you set $acl to the ACL and then set its owner, it works.
Another gotcha is that Set-Acl cannot be set to give ownership to another user. It can only be used to take ownership. Have a look at this:
|
|
PS> (Get-Acl .\temp.txt).owner WALLY\rakhesh PS> $acl = (Get-Acl .\temp.txt) # set owner to a test user PS> $acl.SetOwner([System.Security.Principal.NTAccount]"WALLY\tester") # do the actual setting of ACL - fails! PS> Set-Acl .\temp.txt $acl Set-Acl : The security identifier is not allowed to be the owner of this object. At line:1 char:1 + Set-Acl .\temp.txt $acl + ~~~~~~~~~~~~~~~~~~~~~~~ + CategoryInfo : InvalidOperation: (C:\Users\rakhesh\Code\temp.txt:String) [Set-Acl], InvalidOp erationException + FullyQualifiedErrorId : System.InvalidOperationException,Microsoft.PowerShell.Commands.SetAclCommand |
I couldn’t find much but this Hey, Scripting Guy! post briefly mentions the following:
… although you can take ownership of a file using Windows PowerShell, we don’t believe that you can give ownership of a file to someone else. To transfer ownership to another user you’ll need to use the Windows Resource Kit utility Subinacl.exe.
Yet another gotcha is that built-in groups like “Users” and “Administrators” need to be referred to differently:
|
|
PS> $acl.SetOwner([System.Security.Principal.NTAccount]"WALLY\Users") Exception calling "SetOwner" with "1" argument(s): "Some or all identity references could not be translated." At line:1 char:1 + $acl.SetOwner([System.Security.Principal.NTAccount]"WALLY\Users") + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + CategoryInfo : NotSpecified: (:) [], MethodInvocationException + FullyQualifiedErrorId : IdentityNotMappedException PS> $acl.SetOwner([System.Security.Principal.NTAccount]"BUILTIN\Users") |
I discovered this looking at this page of well known SIDs, finding the SID of the built-in “Users” group, and translating it via PowerShell:
SID: S-1-5-32-545
Name: Users
Description: A built-in group. After the initial installation of the operating system, the only member is the Authenticated Users group. When a computer joins a domain, the Domain Users group is added to the Users group on the computer.
|
|
PS> ([System.Security.Principal.SecurityIdentifier]"S-1-5-32-45").Translate([System.Security.Principal.NTAccount]) Value ----- BUILTIN\Users |
In fact, the error Exception calling "SetOwner" with "1" argument(s): "Some or all identity references could not be translated." is a good way of checking if a user account exists.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# if an account doesn't exist, trying to get its SID will result in an error PS> ([System.Security.Principal.NTAccount]"WALLY\NoUser").Translate([System.Security.Principal.SecurityIdentifier]) Exception calling "Translate" with "1" argument(s): "Some or all identity references could not be translated." At line:1 char:1 + ([System.Security.Principal.NTAccount]"WALLY\NoUser").Translate([System.Security ... + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + CategoryInfo : NotSpecified: (:) [], MethodInvocationException + FullyQualifiedErrorId : IdentityNotMappedException # define a function that tests if the user name is valid; this uses a Try/Catch block to check for exception errors # and I cast the output to [void] so successful results don't return anything PS> function Check-User ([string]$User) { $result = $true; try { [void]([System.Security.Principal.NTAccount]$user).Translate([System.Security.Principal.SecurityIdentifier]) } catch { $result = $false }; return $result } PS C:\Users\rakhesh\Code> Check-User -User "WALLY\rakhesh" True PS C:\Users\rakhesh\Code> Check-User -User "WALLY\NoUser" False |
More later!
Posted: October 22nd, 2013 | Tags: internet, links, net, webclient | Category: PowerShell | § Using the System.Net.Webclient class and using old-fashioned regexp to cull out links:
|
|
# create a net.webclient object $web = New-Object system.net.webclient # download the page as a string # split the string wherever you have <a followed by spaces (the link tag basically) # the result of the split is an array; pipe this through a foreach-object block # and match each element with the regexp that ferrets out URLs, and output the matched bit ($web.downloadstring("http://URL/of/page") -split "<a\s+") | %{ [void]($_ -match "^href=[`'`"]([^`'`">\s]*)"); $matches[1] } |
Posted: October 22nd, 2013 | Tags: download, encoding, headers, internet, net, web, webclient | Category: PowerShell | § The system.net.webclient class can be used to deal with web pages.
To download and display pages this class has couple of methods:
DownloadData downloads the page and displays it as an array of bytes.
|
|
# define a new object PS> $web = New-Object system.net.webclient # download an address PS> $web.DownloadData("http://rakhesh.com/about") 60 33 68 ... # just for kicks: this is how you can download the page as a byte array, cast each byte to a character # and join all these characters to get the entire page PS> ($web.DownloadData("http://rakhesh.com/about") | %{ [char]$_ }) -join "" <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html ... |
DownloadString downloads the page and displays it as one long string.
|
|
# define a new object PS> $web = New-Object system.net.webclient # download and return as a single string PS> $web.DownloadString("http://rakhesh.com/about","about.html") |
DownloadFile downloads the page and saves it to a file name you specify.
|
|
# define a new object PS> $web = New-Object system.net.webclient # download to a file PS> $web.DownloadFile("http://rakhesh.com/about","about.html") |
The class also has properties you can set to be used while downloading a page. For instance:
QueryString to specify pairs of query parameters and their values. For example: to do a Google search for the word “rakhesh” one can fetch the page http://www.google.com/search?q=rakhesh. This q=rakhesh is a query string, with q being a parameter and rakhesh being a value to the parameter. To do the same via the system.net.webclient class one would do the following:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# define a new object PS> $web = New-Object system.net.webclient # check its current query string PS> $web.QueryString.GetEnumerator() # add a new query string PS> $web.QueryString.Add("q","rakhesh") # confirm addition - just to show it's possible PS> $web.QueryString.GetEnumerator() q PS> $web.QueryString.Get("q") rakhesh # now fetch the web page to a file PS> $web.DownloadFile("http://www.google.com/search","results.html") # if you examine the results.html file you'll see it has done the search |
Headers to specify pairs of headers that can be set when requesting the web page:
|
|
PS> $web = New-Object system.net.webclient # set the user-agent string to "PowerShell Script" PS> $web.Headers.Add("user-agent", "PowerShell Script") |
Credentials to specify credentials for accessing the web page:
|
|
PS> $web = New-Object system.net.webclient PS> $web.Credentials = Get-Credential |
ResponseHeaders to view the headers received in response.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
PS> $web = New-Object system.net.webclient # no response headers initially PS> $web.ResponseHeaders # visit a page PS> $web.DownloadFile("http://rakhesh.com","temp.html") # now we have response headers PS> $web.ResponseHeaders Connection Keep-Alive Vary Accept-Ranges Content-Length Cache-Control Content-Type Date Expires Last-Modified Server # view one of the headers PS> $web.ResponseHeaders.Get("Expires") Tue, 22 Oct 2013 12:35:13 GMT # use a pipe to view all the headers PS> $web.ResponseHeaders.GetEnumerator() | %{ "$_ -> $($web.ResponseHeaders.Get($_))" } Connection -> keep-alive Keep-Alive -> timeout=10 Vary -> Accept-Encoding,Accept-Encoding,Cookie Accept-Ranges -> bytes Content-Length -> 464244 Cache-Control -> max-age=3, must-revalidate, proxy-revalidate Content-Type -> text/html; charset=UTF-8 Date -> Tue, 22 Oct 2013 12:35:10 GMT Expires -> Tue, 22 Oct 2013 12:35:13 GMT Last-Modified -> Mon, 21 Oct 2013 15:14:25 GMT Server -> Apache |
There are other properties and methods too, the above are what I had a chance to look at today.
Posted: October 21st, 2013 | Tags: functions, scope, variables | Category: PowerShell | § PowerShell variables and functions have scope. The “scope” is what defines the visibility of that variable or function.
For instance, consider the following script:
|
|
# set a variable $x = 2 write-output "[script] Setting x as 2" write-output "" function blah { $x = 5 write-output "[blah] Setting x as 5" } Write-Output "Calling function blah" blah Write-Output "[script] Value of x is $x" |
If you were to run this script, here’s the output:
|
|
[script] Setting x as 2 Calling function blah [blah] Setting x as 5 [script] Value of x is 2 |
As you can see, the variable x was set as 2 initially but when the function blah set it to 5 the change didn’t really affect it. This is because of scopes. What happens is that the script variable x belongs to a different scope from the function variable x and although both have the same name they are in fact two different beings. In a way it’s like the variables are in two different boxes – each script/ function has a box full of variables, and whatever change they make to the variables in their box doesn’t affect the variables in other boxes. This is the case even if a function is within a script or another function – the child-function has a box of variables independent of its parent.
Now, the concept of scopes only matter when you are making changes to a variable. If you were just reading the value of a variable then scope doesn’t matter much. Consider the following script:
|
|
$x = 2 function blah { write-output "[blah] Value of x is 5" } blah |
Here even though the function blah has a box of its own variables, when we refer to variable x within it since the variable is not present in its box it looks up to the box of its parent and reads the value from there. Hence the output of the script is:
But suppose we had made a change to variable x within the function (as in the first case), then a new variable x is created within the scope of that function and whatever change we make is limited to that variable.
There are four types of scopes:
- Local scope: the box you have, the current scope basically of the script or function you are in.
- Global scope: the big box that’s out there, the scope containing all variables that are in your particular PowerShell session (be it a PowerShell window or ISE)
- Script scope: another big box, but not as big as the global scope and not as limited as the local scope, this is the scope containing all variables that are in your particular PowerShell script session. The script scope is like a global scope for scripts.
- Private scope: a secret box you have, containing variables you don’t want your children to see. Remember I said earlier that if a variable is not present in a function it looks to the parent scope and reads it from there? If you have any variables you don’t want such children functions to see, define them in a private scope.
Consider the following script:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
$x = 2 write-output "[script] Setting x as 2" write-output "" function blah { $x = 5 write-output "[blah] Setting x as 5" } Write-Output "Calling function blah" blah Write-Output "[script] Value of x is $x" write-output "" function blah2 { $global:x = 5 write-output "[blah2] Setting x as 5" } Write-Output "Calling function blah2" blah2 Write-Output "[script] Value of x is $x" function blah3 { $script:x = 5 write-output "[blah3] Setting x as 5" } Write-Output "Calling function blah3" blah3 Write-Output "[script] Value of x is $x" |
This is just to illustrate the first three scopes mentioned above. Here’s the output from the script:
|
|
[script] Setting x as 2 Calling function blah [blah] Setting x as 5 [script] Value of x is 2 Calling function blah2 [blah2] Setting x as 5 [script] Value of x is 2 Calling function blah3 [blah3] Setting x as 5 [script] Value of x is 5 |
The variable x was set as 2 initially. Function blah changed it to 5, but that only took effect in the local scope of the function and so x was still 2. Next, function blah2 changed x to 5 in the global scope (by addressing the variable as $global:x), but that too didn’t change the value of x as the change was made in the global scope and not the script scope. Finally, function blah3 changed x to 5 in the script scope (by addressing it as $script:x) and that effected the change.
From this example one can also see the need for a script scope and a global scope. Function blah3 changed variable x globally within the script, but any variable x existing outside the script and in the PowerShell session was unaffected. Similarly function blah2 changed variable x within the PowerShell session of the script, but the variable x within the script itself was unaffected (of course, if the script didn’t have a variable x then any references to x will pick up the variable from the global scope). If we didn’t have separate scopes for scripts and the PowerShell session, all scripts would mess about with the global scope variables.
Note though: The global scope and script scope are separate only if the script is run and not dot-sourced. If a script is dot-sourced, the script scope becomes the global scope.
And lastly, private scopes. Consider this script:
|
|
$x = 2 $private:y = 5 function blah { write-output "[blah] Value of x is $x" write-output "[blah] Value of y is $y" } blah |
And here’s the output:
|
|
[blah] Value of x is 2 [blah] Value of y is |
Since y was defined with a private scope in the script, function blah can’t read its value.
Scopes can also be referred to by a number. 0 is the local scope, 1 is the parent scope, 2 is the grandparent scope, and so on. This is useful with the Get-Variable cmdlet, for instance. Consider the following script:
|
|
Write-Output "Scope 0 variables:" get-variable -scope 0 Write-Output "" Write-Output "Scope 1 variables:" get-variable -scope 1 Write-Output "" Write-Output "Scope 2 variables:" get-variable -scope 2 Write-Output "" |
Its output is thus:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
Scope 0 variables: Name Value ---- ----- ? True args {} ConsoleFileName ExecutionContext System.Management.Automation.EngineIntrinsics false False HOME C:\Users\rakhesh ... PID 3792 PSBoundParameters {} PSCulture en-US PSHOME C:\Windows\SysWOW64\WindowsPowerShell\v1.0 ... Scope 1 variables: $ scope4.ps1 ? True ^ notepad _ args {} ... ConfirmPreference High ConsoleFileName DebugPreference SilentlyContinue ... FormatEnumerationLimit 4 HOME C:\Users\rakhesh Host System.Management.Automation.Internal.Host.InternalHost ie System.__ComObject input System.Collections.ArrayList+ArrayListEnumeratorSimple LASTEXITCODE 0 Matches {1, 0} ... Scope 2 variables: get-variable : The scope number '2' exceeds the number of active scopes. Parameter name: scopeID Actual value was 2. At C:\Users\rakhesh\scope4.ps1:8 char:13 + get-variable <<<< -scope 2 + CategoryInfo : InvalidArgument: (:) [Get-Variable], PSArgumentOutOfRangeException + FullyQualifiedErrorId : ArgumentOutOfRange,Microsoft.PowerShell.Commands.GetVariableCommand |
As you can see, there are only two scopes – 0 is the local scope (the script scope in this case), 1 is the global scope. If I had defined a function within the script, then scope 0 would be the local scope, 1 would be the script scope, and 2 would be the global scope.
Accessing scopes by number is also useful with cmdlets such as Set-Variable. For instance, the following sets a variable in the parent scope of the calling script:
|
|
Set-Variable -Scope 1 -Name blah -Value 1 |
That’s all for now. It’s worth reiterating that within a script you have a global scope and a script scope, and the two are separate. Setting a variable in the global scope from a script does not affect the variable in the script scope.
Posted: October 20th, 2013 | Tags: formatting, write-host, write-output | Category: PowerShell | § Good to remember:
Write-Host converts the object to a string representation and then outputs it to the host (console). There’s two things to keep in mind here: (1) the output bypasses any pipelines etc and is sent directly to the host; (2) the object is converted to a string representation, using the toString() method (which is present in all classes), and so the string representation may not necessarily be what you expect.
Case in hand:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
# define a hash table PS> $table = @{ a = 1; b = 2 } # use write-host to output it. notice the output. PS> write-host $table System.Collections.DictionaryEntry System.Collections.DictionaryEntry # enumerate the hash table and find the type of each element in it # notice the type name - it matches what we saw above PS> $table.GetEnumerator() | %{ $_ | Get-Member } TypeName: System.Collections.DictionaryEntry Name MemberType Definition ---- ---------- ---------- Name AliasProperty Name = Key Equals Method bool Equals(System.Object obj) GetHashCode Method int GetHashCode() GetType Method type GetType() ToString Method string ToString() Key Property System.Object Key {get;set;} Value Property System.Object Value {get;set;} Name AliasProperty Name = Key Equals Method bool Equals(System.Object obj) GetHashCode Method int GetHashCode() GetType Method type GetType() ToString Method string ToString() Key Property System.Object Key {get;set;} Value Property System.Object Value {get;set;} # notice what happens if we were to convert the hash table to a string directly PS> "$table" System.Collections.Hashtable # now run the toString() method of that table and notice it's same as above PS> $table.ToString() System.Collections.Hashtable |
Write-Output is better in the sense that (1) it only passes the output to the next step of the pipeline (or to the host if we are at the end of the pipeline) and (2) no conversion happens, the object is output and formatted as it is.
To give an example with the previously created table:
|
|
PS> Write-Output $table Name Value ---- ----- a 1 b 2 |
This is same as if you were to output the object directly:
|
|
PS> $table Name Value ---- ----- a 1 b 2 |
As previously mentioned the formatting of such output depends the ps1xml defintions for that object.
Posted: October 14th, 2013 | Category: PowerShell | § The powershell.exe command has many useful switches.
Two especially useful ones are the -Version and -ExecutionPolicy switches. The former lets you start PowerShell as a different version – useful you want to test your script on older versions of PowerShell – and the latter lets you set the execution policy for the current session – useful when you are telling users to run a script via the -File switch and want to allow execution for that session so they don’t get any prompts. This is equivalent to running the following cmdlet from within PowerShell:
|
|
Set-ExecutionPolicy -Scope process <ExecutionPolicy> |
You can run a PowerShell cmdlet (or scriptblock) via the -command parameter. Couple of things to remember:
- From within a command prompt window: If the argument to
-command is a cmdlet it is executed and the result passed to command prompt. But if the argument is a script block then it is only typed as it is, no execution happens.
- From within a PowerShell window: The argument to
-command can be a cmdlet or a script block. Both work.
- From within a PowerShell window, if you launch
powershell.exe via start-process same rules as the command prompt window case apply. Also, bear in mind as a new process is started it terminates immediately after the cmdlet/ script block is executed. If you want the window to not exit, specify the -noexit switch as an argument to powershell.exe. Something like this:
|
|
PS> Start-Process powershell -ArgumentList "-noexit -command get-date" |
The -noexit switch must be placed before the -command parameter else it has no effect.
- In all cases, when a script block is passed to
-command if it is enclosed in double quotes (as a string) and the script block is prefixed with the & operator (the call operator) the script block will get executed. Like thus:
|
|
C:\> powershell -command "& { get-date }" |
Posted: October 14th, 2013 | Tags: case, culture, string manipulation | Category: PowerShell | § The previously blogged System.Globalization.CultureInfo class has some useful methods for converting text to upper case, lower case, and title case.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
PS> [System.Globalization.CultureInfo]::CurrentCulture | gm TypeName: System.Globalization.CultureInfo Name MemberType Definition ---- ---------- ---------- ClearCachedData Method System.Void ClearCachedData() Clone Method System.Object Clone() ... NumberFormat Property System.Globalization.NumberFormatInfo NumberFormat {get;set;} OptionalCalendars Property System.Globalization.Calendar[] OptionalCalendars {get;} Parent Property System.Globalization.CultureInfo Parent {get;} TextInfo Property System.Globalization.TextInfo TextInfo {get;} ThreeLetterISOLanguageName Property System.String ThreeLetterISOLanguageName {get;} ... PS> [System.Globalization.CultureInfo]::CurrentCulture.TextInfo ANSICodePage : 1252 OEMCodePage : 850 MacCodePage : 10000 EBCDICCodePage : 20285 LCID : 2057 CultureName : en-GB IsReadOnly : False ListSeparator : , IsRightToLeft : False PS> [System.Globalization.CultureInfo]::CurrentCulture.TextInfo | gm TypeName: System.Globalization.TextInfo Name MemberType Definition ---- ---------- ---------- Clone Method System.Object Clone() Equals Method bool Equals(System.Object obj) GetHashCode Method int GetHashCode() GetType Method type GetType() ToLower Method char ToLower(char c), string ToLower(string str) ToString Method string ToString() ToTitleCase Method string ToTitleCase(string str) ToUpper Method char ToUpper(char c), string ToUpper(string str) ANSICodePage Property System.Int32 ANSICodePage {get;} CultureName Property System.String CultureName {get;} EBCDICCodePage Property System.Int32 EBCDICCodePage {get;} IsReadOnly Property System.Boolean IsReadOnly {get;} IsRightToLeft Property System.Boolean IsRightToLeft {get;} LCID Property System.Int32 LCID {get;} ListSeparator Property System.String ListSeparator {get;set;} MacCodePage Property System.Int32 MacCodePage {get;} OEMCodePage Property System.Int32 OEMCodePage {get;} |
These methods can be used thus:
|
|
PS> [System.Globalization.CultureInfo]::CurrentCulture.TextInfo.ToUpper("some text") SOME TEXT PS> [System.Globalization.CultureInfo]::CurrentCulture.TextInfo.ToTitleCase("some text") Some Text PS> [System.Globalization.CultureInfo]::CurrentCulture.TextInfo.ToLower("Some TEXT") some text |
Good to know!
Posted: October 13th, 2013 | Tags: acl, active directory, permissions, rights | Category: PowerShell, Windows | § The following code gets a list of all users in an OU (specified by the variable $OU) on which the account (specified by $account) does not have any rights. There’s probably better ways to do this (and also check for specific rights) but I wanted something quick and dirty and this is what I came up with today:
|
|
import-module ActiveDirectory $OU = "CHANGE ME: format is OU=blah,OU=bluh,DC=bleh,DC=blee" $account = "CHANGE ME: format is DOMAIN\<user|group>" Get-ADUser -SearchBase $OU -Filter * | %{ # need to expand IdentityReference as it's a hashtable $aclList = (get-acl "AD:\$($_.DistinguishedName)").access | select -expand IdentityReference -Unique if ($aclList -notcontains $account) { $_.Name } } |
Posted: October 13th, 2013 | Tags: culture, locale | Category: PowerShell | § The Get-Culture cmdlet shows you the current system “culture”. Culture is the stuff that defines the date formatting, number formatting, UI language, etc of your computer. Usually you set it in the Control Panel under Language/ Regional Settings, or when installing the OS.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
# Output on my system PS> get-culture LCID Name DisplayName ---- ---- ----------- 1033 en-US English (United States) # more verbose output PS> get-culture | Fl * Parent : en LCID : 1033 KeyboardLayoutId : 1033 Name : en-US IetfLanguageTag : en-US DisplayName : English (United States) NativeName : English (United States) EnglishName : English (United States) TwoLetterISOLanguageName : en ThreeLetterISOLanguageName : eng ThreeLetterWindowsLanguageName : ENU CompareInfo : CompareInfo - en-US TextInfo : TextInfo - en-US IsNeutralCulture : False CultureTypes : SpecificCultures, InstalledWin32Cultures, FrameworkCultures NumberFormat : System.Globalization.NumberFormatInfo DateTimeFormat : System.Globalization.DateTimeFormatInfo Calendar : System.Globalization.GregorianCalendar OptionalCalendars : {System.Globalization.GregorianCalendar, System.Globalization.GregorianCalendar} UseUserOverride : True IsReadOnly : False |
The output is of the .NET type System.Globalization.CultureInfo and has some useful static methods.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
PS> Get-Culture | gm TypeName: System.Globalization.CultureInfo Name MemberType Definition ---- ---------- ---------- ClearCachedData Method void ClearCachedData() Clone Method System.Object Clone(), System.Object ICloneable.Clone() Equals Method bool Equals(System.Object value) GetConsoleFallbackUICulture Method cultureinfo GetConsoleFallbackUICulture() GetFormat Method System.Object GetFormat(type formatType), System.Object IFormatProvider.Ge... GetHashCode Method int GetHashCode() GetType Method type GetType() ToString Method string ToString() Calendar Property System.Globalization.Calendar Calendar {get;} CompareInfo Property System.Globalization.CompareInfo CompareInfo {get;} CultureTypes Property System.Globalization.CultureTypes CultureTypes {get;} DateTimeFormat Property System.Globalization.DateTimeFormatInfo DateTimeFormat {get;set;} DisplayName Property string DisplayName {get;} EnglishName Property string EnglishName {get;} IetfLanguageTag Property string IetfLanguageTag {get;} IsNeutralCulture Property bool IsNeutralCulture {get;} IsReadOnly Property bool IsReadOnly {get;} KeyboardLayoutId Property int KeyboardLayoutId {get;} LCID Property int LCID {get;} Name Property string Name {get;} NativeName Property string NativeName {get;} NumberFormat Property System.Globalization.NumberFormatInfo NumberFormat {get;set;} OptionalCalendars Property System.Globalization.Calendar[] OptionalCalendars {get;} Parent Property cultureinfo Parent {get;} TextInfo Property System.Globalization.TextInfo TextInfo {get;} ThreeLetterISOLanguageName Property string ThreeLetterISOLanguageName {get;} ThreeLetterWindowsLanguageName Property string ThreeLetterWindowsLanguageName {get;} TwoLetterISOLanguageName Property string TwoLetterISOLanguageName {get;} UseUserOverride Property bool UseUserOverride {get;} PS> Get-Culture | gm -Static TypeName: System.Globalization.CultureInfo Name MemberType Definition ---- ---------- ---------- CreateSpecificCulture Method static cultureinfo CreateSpecificCulture(string name) Equals Method static bool Equals(System.Object objA, System.Object objB) GetCultureInfo Method static cultureinfo GetCultureInfo(int culture), static cultureinfo GetCul... GetCultureInfoByIetfLanguageTag Method static cultureinfo GetCultureInfoByIetfLanguageTag(string name) GetCultures Method static cultureinfo[] GetCultures(System.Globalization.CultureTypes types) ReadOnly Method static cultureinfo ReadOnly(cultureinfo ci) ReferenceEquals Method static bool ReferenceEquals(System.Object objA, System.Object objB) CurrentCulture Property static cultureinfo CurrentCulture {get;} CurrentUICulture Property static cultureinfo CurrentUICulture {get;} DefaultThreadCurrentCulture Property static cultureinfo DefaultThreadCurrentCulture {get;set;} DefaultThreadCurrentUICulture Property static cultureinfo DefaultThreadCurrentUICulture {get;set;} InstalledUICulture Property static cultureinfo InstalledUICulture {get;} InvariantCulture Property static cultureinfo InvariantCulture {get;} |
Using the Get-Culture cmdlet I can check out the date-time format on any system:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
# Using the DateTimeFormat property PS> (Get-Culture).DateTimeFormat AMDesignator : AM Calendar : System.Globalization.GregorianCalendar DateSeparator : / FirstDayOfWeek : Sunday CalendarWeekRule : FirstDay FullDateTimePattern : dddd, MMMM d, yyyy h:mm:ss tt LongDatePattern : dddd, MMMM d, yyyy LongTimePattern : h:mm:ss tt MonthDayPattern : MMMM d PMDesignator : PM RFC1123Pattern : ddd, dd MMM yyyy HH':'mm':'ss 'GMT' ShortDatePattern : M/d/yyyy ShortTimePattern : h:mm tt SortableDateTimePattern : yyyy'-'MM'-'dd'T'HH':'mm':'ss TimeSeparator : : UniversalSortableDateTimePattern : yyyy'-'MM'-'dd HH':'mm':'ss'Z' YearMonthPattern : MMMM yyyy AbbreviatedDayNames : {Sun, Mon, Tue, Wed...} ShortestDayNames : {Su, Mo, Tu, We...} DayNames : {Sunday, Monday, Tuesday, Wednesday...} AbbreviatedMonthNames : {Jan, Feb, Mar, Apr...} MonthNames : {January, February, March, April...} IsReadOnly : False NativeCalendarName : Gregorian Calendar AbbreviatedMonthGenitiveNames : {Jan, Feb, Mar, Apr...} MonthGenitiveNames : {January, February, March, April...} |
Similarly I can check the number format, get the friendly name of the culture, etc.
I am more interested in the class itself: System.Globalization.CultureInfo. Let’s examine its members again:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
PS> [System.Globalization.CultureInfo] | gm -static TypeName: System.Globalization.CultureInfo Name MemberType Definition ---- ---------- ---------- CreateSpecificCulture Method static cultureinfo CreateSpecificCulture(string name) Equals Method static bool Equals(System.Object objA, System.Object objB) GetCultureInfo Method static cultureinfo GetCultureInfo(int culture), static cultureinfo GetCul... GetCultureInfoByIetfLanguageTag Method static cultureinfo GetCultureInfoByIetfLanguageTag(string name) GetCultures Method static cultureinfo[] GetCultures(System.Globalization.CultureTypes types) ReadOnly Method static cultureinfo ReadOnly(cultureinfo ci) ReferenceEquals Method static bool ReferenceEquals(System.Object objA, System.Object objB) CurrentCulture Property static cultureinfo CurrentCulture {get;} CurrentUICulture Property static cultureinfo CurrentUICulture {get;} DefaultThreadCurrentCulture Property static cultureinfo DefaultThreadCurrentCulture {get;set;} DefaultThreadCurrentUICulture Property static cultureinfo DefaultThreadCurrentUICulture {get;set;} InstalledUICulture Property static cultureinfo InstalledUICulture {get;} InvariantCulture Property static cultureinfo InvariantCulture {get;} |
Particularly useful is the ability to examine another culture and then use the methods of that culture object to learn more about it:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
# What is the culture with LCID 1025? PS> [System.Globalization.CultureInfo]::GetCultureInfo(1025) LCID Name DisplayName ---- ---- ----------- 1025 ar-SA Arabic (Saudi Arabia) # Get its DateTimeFormat PS> ([System.Globalization.CultureInfo]::GetCultureInfo(1025)).DateTimeFormat AMDesignator : ص Calendar : System.Globalization.UmAlQuraCalendar DateSeparator : / FirstDayOfWeek : Saturday CalendarWeekRule : FirstDay FullDateTimePattern : dd/MMMM/yyyy hh:mm:ss tt LongDatePattern : dd/MMMM/yyyy LongTimePattern : hh:mm:ss tt MonthDayPattern : dd MMMM PMDesignator : م RFC1123Pattern : ddd, dd MMM yyyy HH':'mm':'ss 'GMT' ShortDatePattern : dd/MM/yy ShortTimePattern : hh:mm tt SortableDateTimePattern : yyyy'-'MM'-'dd'T'HH':'mm':'ss TimeSeparator : : UniversalSortableDateTimePattern : yyyy'-'MM'-'dd HH':'mm':'ss'Z' YearMonthPattern : MMMM, yyyy AbbreviatedDayNames : {الأحد, الإثنين, الثلاثاء, الأربعاء...} ShortestDayNames : {ح, ن, ث, ر...} DayNames : {الأحد, الإثنين, الثلاثاء, الأربعاء...} AbbreviatedMonthNames : {محرم, صفر, ربيع الأول, ربيع الثاني...} MonthNames : {محرم, صفر, ربيع الأول, ربيع الثاني...} IsReadOnly : True NativeCalendarName : تقويم ام القرى AbbreviatedMonthGenitiveNames : {محرم, صفر, ربيع الأول, ربيع الثاني...} MonthGenitiveNames : {محرم, صفر, ربيع الأول, ربيع الثاني...} |
More later!
Learnt a couple of things today. Not in depth, but now I am aware of these features and will explore them in depth someday.
I knew how to create custom objects in PowerShell and I have always tried to return output from my functions/ scripts as custom objects. I was also aware that you can set the default display properties so the output is neater.
Say I create a new object like this:
|
|
# define a hash-table with the properties PS> $ObjProps = @{ name = "Rakhesh"; age = 34; sex = "Male"; location = "Oman" } # create a new custom object PS> $blahObj = New-Object -TypeName PSCustomObject -Property $ObjProps # output the object PS> $blahObj name age sex location ---- --- --- -------- Rakhesh 34 Male Oman |
Notice when I output the object all its properties are output. Usually I may not want that. I may want that only the name property is output and the rest are silent, only shown if asked for.
It’s possible to define the default properties you are interested in. This link gives you more details, the tl;dr summary of which is as follows:
- All objects contain a member object called
PSStandardMembers which defines the default properties of the object.
- The
PSStandardMembers object a member object called DefaultDisplayPropertySet. This object contains a property called ReferencedPropertyNames which lists the default displayed properties of the object.
- Apart from
DefaultDisplayPropertySet you have DefaultKeyPropertySet and DefaultDisplayProperty objects too. I am not sure what DefaultDisplayProperty does but DefaultKeyPropertySet is used when sorting and grouping objects.
To set the PSStandardMembers property of an object one does the following:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
# define an array containing the properties you are interested in PS> $DefaultProps = @("Name", "Sex") # create a new object of type PSPropertySet using the previously created array # this object will be called DefaultDisplayPropertySet PS> $DefaultDisplay = New-Object System.Management.Automation.PSPropertySet("DefaultDisplayPropertySet",[string[]]$DefaultProps) # note: one could skip creating an array and specify the properties directly as an array above # create a PSStandardMembers object with the previously created DefaultDisplayPropertySet object PS> $PSStandardMembers = [System.Management.Automation.PSMemberInfo[]]@($DefaultDisplay) # add this object as a property to our object PS> $blahObj | Add-Member MemberSet PSStandardMembers $PSStandardMembers # output the object PS> $blahObj Name Sex ---- --- Rakhesh Male |
Notice now only the properties we specified are shown.
As an aside, and purely because I spent some time trying to figure this out, here’s how DefaultKeyPropertySet influences sorting:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
# create 5 custom objects PS> $Obj1 = New-Object -TypeName PSCustomObject -Property @{ Name = "Rakhesh"; Age = "34"; Sex = "Male" } PS> $Obj2 = New-Object -TypeName PSCustomObject -Property @{ Name = "Calvin"; Age = "4"; Sex = "Male" } PS> $Obj3 = New-Object -TypeName PSCustomObject -Property @{ Name = "Hobbes"; Age = "24"; Sex = "Male" } PS> $Obj4 = New-Object -TypeName PSCustomObject -Property @{ Name = "Lucy"; Age = "5"; Sex = "Female" } PS> $Obj5 = New-Object -TypeName PSCustomObject -Property @{ Name = "Sally"; Age = "45"; Sex = "Female" } # note that default sorting seems to be based on the last key ("sex") PS> $obj1,$obj2,$obj3,$obj4,$obj5 | sort Name Age Sex ---- --- --- Lucy 5 Female Sally 45 Female Hobbes 24 Male Rakhesh 34 Male Calvin 4 Male # I would like sorting to be based on "name", set it so PS> $DefaultKeys = @("Name") PS> $DefaultKeysObj = New-Object System.Management.Automation.PSPropertySet("DefaultKeyPropertySet",[string[]]$DefaultKeys) PS> $PSStandardMembers = [System.Management.Automation.PSMemberInfo[]]@($DefaultKeysObj) # add PSStandardMembers to all the objects PS> $Obj1 | Add-Member MemberSet PSStandardMembers $PSStandardMembers PS> $Obj2 | Add-Member MemberSet PSStandardMembers $PSStandardMembers PS> $Obj3 | Add-Member MemberSet PSStandardMembers $PSStandardMembers PS> $Obj4 | Add-Member MemberSet PSStandardMembers $PSStandardMembers PS> $Obj5 | Add-Member MemberSet PSStandardMembers $PSStandardMembers # note the sorting key has changed PS> $obj1,$obj2,$obj3,$obj4,$obj5 | sort Name Age Sex ---- --- --- Calvin 4 Male Hobbes 24 Male Lucy 5 Female Rakhesh 34 Male Sally 45 Female |
(Thanks to this post which made me realize what DefaultKeyPropertySet does).
Back to DefaultDisplayPropertySet – the problem is that it doesn’t work in PowerShell v2. It’s a bug with PowerShell v2 and this Stack Overflow post gives a workaround which involves creating a temporary ps1xml file for the custom objects and defining its default properties.
I haven’t explored ps1xml files much but the gist of the matter is (1) they are what PowerShell uses to format object output and (2) you can create custom ps1xml files for your custom objects. The Stack Overflow post gives a function that takes an object and an array of properties and sets these properties as the default for that object. It’s a neat function and works as expected, but for a catch …
The catch is that since all custom objects have the same name you can’t set different default properties for different objects. Unless you give a name for the custom object, of course, which differentiates each type of custom object from the other. So how do you go about naming custom objects?
First up, how do you get the current name of an object? From my reflection post we know the following works:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
# creating a custom object (which will be used in the examples below) PS> $blah = New-Object -TypeName PSCustomObject # find its name PS> $blah.GetType().FullName System.Management.Automation.PSCustomObject # this too works, but gives you the shortname PS> $blah.GetType() IsPublic IsSerial Name BaseType -------- -------- ---- -------- True False PSCustomObject System.Object # this too ... PS> $blah | Get-Member TypeName: System.Management.Automation.PSCustomObject Name MemberType Definition ---- ---------- ---------- Equals Method bool Equals(System.Object obj) GetHashCode Method int GetHashCode() GetType Method type GetType() ToString Method string ToString() |
To fiddle with the type name you have to use some hidden members of every object. (This was another new thing learnt today. Didn’t know objects had hidden members too). The way to see these is via Get-Member -Force cmdlet. Have a look at the help for the -Force parameter:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
PS> help Get-Member -Parameter Force -Force [<SwitchParameter>] Adds the intrinsic members (PSBase, PSAdapted, PSObject, PSTypeNames) and the compiler-generated get_ and set_ methods to the display. By default, Get-Member gets these properties in all views other than "Base" and "Adapted," but it does not display them. The following list describes the properties that are added when you use the Force parameter: -- PSBase: The original properties of the .NET Framework object without extension or adaptation. These are the properties defined for the object class and listed in MSDN. -- PSAdapted: The properties and methods defined in the Windows PowerShell extended type system. -- PSExtended: The properties and methods that were added in the Types.ps1xml files or by using the Add-Member cmdlet. -- PSObject: The adapter that converts the base object to a Windows PowerShell PSObject object. -- PSTypeNames: A list of object types that describe the object, in order of specificity. When formatting the object, Windows PowerShell searches for the types in the Format.ps1xml files in the Windows PowerShell installation directory ($pshome). It uses the formatting definition for the first type that it finds. |
From the help file its clear PSTypeNames is what we are interested in.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
# PSTypeNames gives you the class name of this object as well as its base class # If PowerShell can't find any formatting information for this class type it uses the formatting information of the base PS> $blah.pstypenames System.Management.Automation.PSCustomObject System.Object # let's examine the members of PSTypeNames PS> Get-Member -In $blah.pstypenames TypeName: System.Management.Automation.Runspaces.ConsolidatedString Name MemberType Definition ---- ---------- ---------- Add Method void Add(string item), void ICollection[string].Add(string item), int IList.Add(System.Object value) Clear Method void Clear(), void ICollection[string].Clear(), void IList.Clear() Contains Method bool Contains(string item), bool ICollection[string].Contains(string item), bool IList.Contains(System.Object value) CopyTo Method void CopyTo(string[] array, int index), void ICollection[string].CopyTo(string[] array, int arrayIndex), void ICollection.... Equals Method bool Equals(System.Object obj) GetEnumerator Method System.Collections.Generic.IEnumerator[string] GetEnumerator(), System.Collections.Generic.IEnumerator[string] IEnumerable... GetHashCode Method int GetHashCode() GetType Method type GetType() IndexOf Method int IndexOf(string item), int IList[string].IndexOf(string item), int IList.IndexOf(System.Object value) Insert Method void Insert(int index, string item), void IList[string].Insert(int index, string item), void IList.Insert(int index, Syste... Remove Method bool Remove(string item), bool ICollection[string].Remove(string item), void IList.Remove(System.Object value) RemoveAt Method void RemoveAt(int index), void IList[string].RemoveAt(int index), void IList.RemoveAt(int index) ToString Method string ToString() Item ParameterizedProperty string Item(int index) {get;set;} Count Property int Count {get;} IsFixedSize Property bool IsFixedSize {get;} IsReadOnly Property bool IsReadOnly {get;} IsSynchronized Property bool IsSynchronized {get;} SyncRoot Property System.Object SyncRoot {get;} |
The members Clear and Add seem to be what we want:
|
|
# clear the existing types PS> $blah.pstypenames.Clear() # confirm they are cleared PS> $blah.pstypenames # add the new type name PS> $blah.pstypenames.Add("System.MyObject1") # confirm it's set PS> $blah.pstypenames System.MyObject1 |
Instead of clearing the existing types, one can Insert the new type to the top of the list too:
|
|
# here are the initial types PS> $blah.pstypenames System.Management.Automation.PSCustomObject System.Object # insert a new type at index 0 PS> $blah.pstypenames.Insert(0,"System.MyObject1") # notice it's added to the top of the list PS> $blah.pstypenames System.MyObject1 System.Management.Automation.PSCustomObject System.Object |
Gotta love it when things fall into place and you have a language that makes it easy to do all these things!
My thanks to this and this post for pointing me towards PSTypeNames.
Posted: October 10th, 2013 | Tags: runas, uac | Category: PowerShell | § Learnt today that I can start a new process within PowerShell with elevated access (i.e. you get a UAC prompt that gives you more rights) using the Verb switch to the Start-Process cmdlet.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
# Start a new PowerShell window with elevated rights. Notice the "runas". PS> Start-Process -Verb runas -FilePath powershell # It looks like you can't combine runas with a different credential though PS> Start-Process -Credential rakhesh -Verb runas -FilePath powershell Start-Process : Parameter set cannot be resolved using the specified named parameters. At line:1 char:1 + Start-Process -Credential rakhesh -Verb runas -FilePath powershell + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + CategoryInfo : InvalidArgument: (:) [Start-Process], ParameterBindingException + FullyQualifiedErrorId : AmbiguousParameterSet,Microsoft.PowerShell.Commands.StartProcessCommand # Removing the runas gets the command working so the problem is the combination PS> Start-Process -Credential rakhesh -FilePath powershell # Workaround is to start a new PowerShell session as the user first and pass this process # a Start-Process cmdlet to create a PowerShell process with UAC. PS> Start-Process -Credential rakhesh -FilePath powershell -ArgumentList "Start-Process powershell -verb RunAs" |
Posted: October 9th, 2013 | Tags: wmi | Category: PowerShell | § A useful link to refer to later: WMI Query language examples.
PowerShell can access WMI via Get-WMIObject. And while it’s easier to just pull all WMI objects and then filter, it’s faster if you do the filtering while pulling itself.
Case in hand: getting a list of installed drivers. The Win32_PnpSignedDriver WMI class is what you need to tap into for this. Like thus:
|
|
Get-WMIObject -Class Win32_PnPSignedDriver |
This gives a bucket-load of output. If you want to filter out just a particular driver, the easy way is this:
|
|
Get-WMIObject -Class Win32_PnPSignedDriver | ?{ $_.DeviceName -like "*PCI*" } |
The better way, though, is to use WMI queries and filter while running WMI itself. Like this:
|
|
Get-WMIObject -Class Win32_PnPSignedDriver -Filter "DeviceName like '%PCI%'" |
Both return the same number of results:
|
|
PS> (Get-WMIObject -Class Win32_PnPSignedDriver | ?{ $_.DeviceName -like "*PCI*" }).Count 17 PS> (Get-WMIObject -Class Win32_PnPSignedDriver -Filter "DeviceName like '%PCI%'").Count 17 |
But the latter is faster.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
PS> Measure-Command -Expression { Get-WMIObject -Class Win32_PnPSignedDriver | ?{ $_.DeviceName -like "*PCI*" } } Days : 0 Hours : 0 Minutes : 0 Seconds : 1 Milliseconds : 637 Ticks : 16374688 TotalDays : 1.89521851851852E-05 TotalHours : 0.000454852444444444 TotalMinutes : 0.0272911466666667 TotalSeconds : 1.6374688 TotalMilliseconds : 1637.4688 PS> Measure-Command -Expression { Get-WMIObject -Class Win32_PnPSignedDriver -Filter "DeviceName like '%PCI%'" } Days : 0 Hours : 0 Minutes : 0 Seconds : 1 Milliseconds : 593 Ticks : 15936620 TotalDays : 1.8445162037037E-05 TotalHours : 0.000442683888888889 TotalMinutes : 0.0265610333333333 TotalSeconds : 1.593662 TotalMilliseconds : 1593.662 |
The difference isn’t much in the example above, but when you run this across the network for multiple computers it adds up quickly.
So when in doubt filter at the WMI level. And to make filter queries like the above, the link at the start of this post helps. It gives you the keywords you can use. Like, for instance, to do wildcard matches use the like keyword as above. And like * is the wildcard symbol usually, for WMI queries % is the wildcard symbol. Similarly, to do exact matches use the = keyword; to do relational matches (greater than, less than) use the < and > keywords; and so on.
Special shout-out to this blog post where I first came across the like keyword.
|