Search results for 'app:weblogs' matching tags 'guest blogger' and 'modules'

Closures in PowerShell

Anonymous — Fri, 05 Apr 2013 05:00:00 GMT

Summary: Bruce Payette talks about Windows PowerShell closures and how to call the GetNewClosure method.

Microsoft Scripting Guy, Ed Wilson, is here. This week we will not have our usual PowerTip. Instead we have excerpts from seven books from Manning Press. In addition, each blog will have a special code for 50% off the book being excerpted that day. Remember that the code is valid only for the day the excerpt is posted. The coupon code is also valid for a second book from the Manning collection.

This excerpt is from Windows PowerShell in Action
By Bruce Payette

Windows PowerShell uses dynamic modules to create dynamic closures. A closure in computer science terms (at least as defined in Wikipedia) is “a function that is evaluated in an environment containing one or more bound variables.” A bound variable is, for our purposes, a variable that exists and has a value. The environment in our case is the dynamic module. Finally, the function is simply a script block. In effect, a closure is the inverse of an object. An object is data with methods (functions) attached to that data. A closure is a function with data attached to that method.

The best way to understand what all this means is to look at an example. You’ll use closures to create a set of counter functions. The advantage closures give you over plain functions is that you can change what increment to use after the counter function has been defined. Here’s the basic function:

function New-Counter ($increment=1)

{

$count=0;

{

$script:count += $increment

$count

}.GetNewClosure()

}

There’s nothing you haven’t seen so far—you create a variable and then a script block that increments that variable—except for returning the result of the call to the Get-NewClosure() method. Let’s try this function to see what it does. First, create a counter:

PS (1) > $c1 = New-Counter

PS (2) > $c1.GetType().FullName

System.Management.Automation.ScriptBlock

Looking at the type of the object returned, you see that it’s a script block, so you use the & operator to invoke it:

PS (3) > & $c1

PS (4) > & $c1

The script block works as you’d expect a counter to work. Each invocation returns the next number in the sequence. Now, create a second counter, but this time set the increment to 2:

PS (5) > $c2 = New-Counter 2

Invoke the second counter scriptblock:

PS (6) > & $c2

PS (7) > & $c2

PS (8) > & $c2

It counts up by 2. But what about the first counter?

PS (9) > & $c1

PS (10) > & $c1

The first counter continues to increment by 1, unaffected by the second counter. So the key thing to notice is that each counter instance has its own copies of the $count and $increment variables. When a new closure is created, a new dynamic module is created, and then all the variables in the caller’s scope are copied into this new module.

Here are more examples of working with closures to give you an idea of how flexible the mechanism is. First, you’ll create a new closure by using a param block to set the bound variable $x. This is essentially the same as the previous example, except that you’re using a script block to establish the environment for the closure instead of a named function:

PS (11) > $c = & {param ($x) {$x+$x}.GetNewClosure()} 3.1415

Now evaluate the newly created closed script block:

PS (12) > & $c

6.283

This evaluation returns the value of the parameter added to itself. Because closures are implemented by using dynamic modules, you can use mechanisms to manipulate the state of a closure. You can do this by accessing the module object attached to the script block. You’ll use this object to reset the module variable $x by evaluating Set-Variable (sv) in the closure’s module context:

PS (13) > & $c.Module Set-Variable x "Abc"

Now evaluate the script block to verify that it’s been changed:

PS (14) > & $c

AbcAbc

Next, create another script block closed over the same module as the first one. You can do this by using the NewBoundScriptBlock() method on the module to create a new script block that is attached to the module associated with the original script block:

PS (15) > $c2 = $c.Module.NewBoundScriptBlock({"x ia $x"})

Execute the new script block to verify that it’s using the same $x:

PS (16) > & $c2

x ia Abc

Now use $c2.module to update the shared variable:

PS (17) > & $c2.module sv x 123

PS (18) > & $c2

x ia 123

And verify that it’s also changed for the original closed script block:

PS (19) > & $c

246

Finally, create a named function from the script block by using the function provider:

PS (20) > $function:myfunc = $c

And verify that calling the function by name works:

PS (21) > myfunc

246

Set the closed variable yet again, but use $c2 to access the module this time:

PS (22) > & $c2.Module sv x 3

Verify that it’s changed when you call the named function:

PS (23) > myfunc

These examples should give you an idea about how all of these pieces—script blocks, modules, closures, and functions—are related. This is how modules work. When a module is loaded, the exported functions are closures bound to the module object that was created. These closures are assigned to the names for the functions to import. A fairly small set of types and concepts allow you to achieve advanced programming scenarios.

~Bruce

Here is the code for the discount offer today at www.manning.com: scriptw5
Valid for 50% off PowerShell in Action and SharePoint Web Parts in Action
Offer valid from April 5, 2013 12:01 AM until April 6, midnight (EST)

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

Automate Facebook with a Free PowerShell Module

Anonymous — Mon, 15 Aug 2011 05:00:00 GMT

Summary: Guest Blogger Jon Newman shows how to automate Facebook with a free Windows PowerShell module.

Microsoft Scripting Guy Ed Wilson here. It’s Guest Blogger Week! Today, we have Jon Newman from Microsoft who is going to talk to us about his new Windows PowerShell Facebook module. Take it away, Jon.

Thanks to Ed Wilson for giving me space on the Hey, Scripting Guy! Blog!

My name is Jon Newman, and I’m an old hand at Windows PowerShell. I was on the Windows PowerShell 1.0 team, with Bruce and Jim and all the rest. My primary responsibility was for pipeline execution and error handling. Someday I should write a blog entry on FullyQualifiedErrorId, but that is for another time. I started at Microsoft in September 1989, and I have been writing management UI for Windows Server for 20 years. The Facebook project doesn’t actually have anything to do with Microsoft though.

A few years ago, I joined the board of Hillel at the University of Washington. Like many other businesses and organizations, they use Facebook extensively to interact with program participants and backers. I was struck, however, by the lack of the sort of automation commonly used to manage other mission-critical IT. I looked around and did not find anything usable in this space, although there are a couple other mostly obsolete Windows PowerShell integration projects. So I decided to jump in. This is my first open source project and I am sure I have a lot to learn.

First, my Facebook IT Manifesto motivating this project: Facebook is today mission-critical to many organizations’ customer relationships, as significant as are email and web presence. Therefore, such organizations should manage their Facebook presence with the same IT rigor as other mission-critical technologies such as email and websites. I assert in particular that:

An organization’s Facebook presence must be under ultimate administrative control of the organization itself, and not any particular employees. Customer relationships within Facebook must carry forward as employees leave, enter, and change roles within the organization.
An organization must be able to manage its customer relationships within Facebook members in conjunction with other means of contacting the same customers.
An organization must be able to automate routine management of their Facebook presence.
An organization must document its formal Facebook processes with the same rigor as its formal processes for other elements of IT.
Where social networking technologies other than Facebook have similar importance to an organization, the same applies to them as well.

As a partial answer to need #3, I offer the Facebook PowerShell Module. This technology (still in alpha at this writing) enables organizations to automate and integrate Facebook using Windows PowerShell.

Let us dive right into some examples, and talk theory later:

PS C:\Windows\system32> get-fbobjectdata

email : jonn_msft_testuser@hotmail.com

id : 100002097205662

last_name : NewmanTest

name : JonTest NewmanTest

first_name : JonTest

languages : {@{id=106059522759137; name=English}, @{id=105673612800327; name

=German}}

link : http://www.facebook.com/profile.php?id=100002097205662

locale : en_US

timezone : -7

updated_time : 2011-05-29T15:04:10+0000

birthday : 06/30/1964

gender : male

OK, so I’ve skipped a step. You first need to run New-FBConnection from the Windows PowerShell ISE, which grants permission to access your Facebook account. If you forget, the module will talk you through it, but if you need the details, go to this webpage.

If you do not specify which Facebook object you want to know about, the default is you. This is my test account and the default list of fields.

PS C:\Windows\system32> get-fbobjectdata -fields languages

Id languages

100002097205662 {@{id=106059522759137; name=English}...

If you want fields other than the default fields, see Facebook’s documentation. In this case, we requested the nondefault information “languages.”

PS C:\Windows\system32> get-fbfriends

Id name

<number> Matthew <name>

<number> Mikael <name>

<number> Naomi <name>

Facebook data is basically a gigantic relational database. You are an object, you can have lots of fields, and the fields can be references to other objects. In this case, you are asking for the list of objects in your Friends list.

PS C:\Windows\system32> get-fbfriends -fields gender | group gender

Count Name Group

3 male {@{id=604652494; gender=male}, @{id=67396290

1 female {@{id=1022311059; gender=female}}

Because this is Windows PowerShell, you get all the goodness of its standard commands such as Where, Select, and Group.

function Backup-FBFriends

{

$timeString = $(get-date) $dateTime.ToString("yyyy-MM-dd-HH-mm-ss")

$filename = "c:\temp\friends.$timeString.csv"

write-verbose "Backing up friends list to $filename"

$friends = Get-FBFriends

$userdata = $friends | Get-FBObjectData

$userdata | Export-Csv $filename

}

The preceding code is a more sophisticated example (part of FacebookExamples.ps1 that comes with FacebookPSModule). This script automatically backs up your Friends list to a CSV file in c:\temp. It’s the sort of thing you could run in a scheduled task, so you can monitor changes over time.

The final example is the Write-EventAttendeeCsv script (also in FacebookExamples.ps1). I have this running in a scheduled task at the client site. It’s a little too long to reproduce here, but it’s a good example of what you can accomplish with FacebookPSModule. The script does the following:

Gets the list of all events associated with a particular group.
Filters to those events in the upcoming week.
Extracts the RSVP list for those events.
Writes an attendee list file for each event to the temp directory.

This way, program staff can print out an attendee list before the event, based on RSVPs for the Facebook event.

So, is FacebookPSModule right for you? In theory, you could use this to automate anything you can do using the Facebook website. The reality isn’t quite so simple.

First, there are a few things that Facebook doesn’t let you do:

You can’t read the list of your friends’ friends. I think this is on purpose—Facebook just decided that allowing Facebook applications to do this is this too much of a privacy risk. As far as Facebook is concerned, FacebookPSModule is a Facebook application, even when you’re just accessing your own data.
You can’t write status messages that link pages such as @Microsoft. I think this is just an oversight in the API.
You can link photos, but you can’t link directly to other users’ photos in Facebook’s CDN (for example, photos in other users’ albums). This is permitted from the website but not from the API.

I will probably discover more issues as I fill out and explore the module’s capabilities.

More importantly, users should be aware that the Facebook API churns fast, especially the authentication stack. Their interfaces from two years ago are already deprecated and largely broken. You’ll have to keep an eye on your automation to make sure it is working properly.

FacebookPSModule stores your Facebook access token by default (encrypted using DPAPI via ConvertFrom-SecureString) in your user profile, which is why subsequent commands including scheduled tasks can read it. You should think about security for your user profile, because anyone with access to the access token can perform Facebook tasks against your account. In the worst-case scenario:

On Facebook.com, click Account, and then click Privacy Settings.
Under Apps and Websites, click Edit your settings. Under Apps you use, click Edit Settings.
For Test Application jonn_msft (or whichever AppId you used), click Edit. On the next page, click Remove app to revoke permissions for the application, including its access token.

Finally, most important of all, FacebookPSModule is (as of August 15, 2011) only in alpha. There are plenty of known issues, including issues with large data sets. I will probably change the cmdlet names and signatures as I learn more about this space.

FacebookPSModule is really a thin layer over the Facebook C# SDK, which is itself a thin layer over the Facebook Graph API. When you run New-FBConnection, you are requesting an OAuth 2.0 access token for an application I registered. The application doesn’t really exist, and you can use another application ID if you like; you just have to specify an application ID to get the access token.

I could share some war stories about developing this, in particular about supporting .NET Framework 4.0 and converting .NET Dynamic Objects to Windows PowerShell. If there is enough interest, I will write a follow-up blog entry.

What I need from you are more real-world scenarios. Tell me what you want to do, and I can make sure FacebookPSModule does it well. If you want to help with the development, please do! http://facebookpsmodule.codeplex.com/discussions is the place to talk.

Happy Facebooking!

Thank you, Jon, for writing a really cool Facebook module, and for taking the time to share your experience with us.

Join us tomorrow for day 2 of Guest Blogger Week when Trevor Sullivan will be our guest.

Ed Wilson, Microsoft Scripting Guy

Handle Formatted Output in PowerShell

Anonymous — Fri, 13 May 2011 05:00:00 GMT

Summary: Microsoft Windows PowerShell MVP, Doug Finke, illustrates how to handle formatted output in a Windows PowerShell script.

Microsoft Scripting Guy, Ed Wilson, is here. Doug Finke is our guest blogger.

Doug Finke is a Microsoft PowerShell MVP working for Lab49, a company that builds advanced applications for the financial service industry. Over the last 20 years, Doug has been a developer and author working with numerous technologies. You can catch up with Doug on his blog.

Doug's contact information:
Blog: Development in a Blink: Researching the optimal; implementing the practical

There are four Windows PowerShell cmdlets that handle formatting.

Get-Command format* -CommandType cmdlet

Name	Description
Format-Custom	Formats the output of a command as defined in an alternate view
Format-List	Formats the output of a command as a list of properties in which each property is displayed on a separate line
Format-Table	Formats the output of a command as a table with the selected properties of the object in each column
Format-Wide	Formats objects as a wide table that displays only one property of each object

At the command line, these cmldlets are super helpful. I pipe Windows PowerShell output to Format-Table –Autosize ( ft –a ) all the time. Here is a Format-Table nicety that uses wild cards:

Get-Process | select -First 5 | ft -a name, *paged*mem*size

And here is the output.

Name    NonpagedSystemMemorySize PagedMemorySize PagedSystemMemorySize PeakPagedMemorySize

----    ------------------------ --------------- --------------------- -------------------

chrome                     19800        54726656                166860            75530240

chrome                     24372        66035712                312252            81887232

chrome                     12720        55017472                167940            90001408

conhost                     3420         1032192                110476             1060864

conhost                     3480         1810432                110948             1835008

The impact

The challenge: Although this is great, and it makes working with output quick and easy, it has a negative impact on your scripts and functions that you provide to others.

Take this line of Windows PowerShell script. It prints 1 through 5 to the console, simple and problem free.

1..5 | Format-Table

Now, double each element.

1..5 | Format-Table | foreach { $_ * 2 }

I get the following error message:

Method invocation failed because [Microsoft.PowerShell.Commands.Internal.Format.FormatEntryData] doesn't contain a method named 'op_Multiply'.

At line:3 char:37

+ 1..5 | Format-Table | foreach { $_ * <<<< 2}

+ CategoryInfo : InvalidOperation: (op_Multiply:String) [], RuntimeException

+ FullyQualifiedErrorId : MethodNotFound

This is what users of my scripts and functions will encounter if they try to further act on the output of utilities if I use a Format* cmdlet to output results.

Why, and how do I fix it?

First, I want to find out what is the output from Format-Table. I pipe it to Get-Member. Here are the results:

1..5 | Format-Table | Get-Member

   TypeName: Microsoft.PowerShell.Commands.Internal.Format.FormatEntryData

Name                                    MemberType Definition

----                                    ---------- ----------

Equals                                  Method     bool Equals(System.Object obj)

GetHashCode                             Method     int GetHashCode()

GetType                                 Method     type GetType()

ToString                                Method     string ToString()

ClassId2e4f51ef21dd47e99d3c952918aff9cd Property   System.String ClassId2e4f51ef21dd47e99d3c952918aff9cd {get;}

formatEntryInfo                         Property   Microsoft.PowerShell.Commands.Internal.Format.FormatEntryInfo formatEntryInfo {get;set;}

outOfBand                               Property   System.Boolean outOfBand {get;set;}

writeErrorStream                        Property   System.Boolean writeErrorStream {get;set;}

This explains why I get errors when I try to multiply the items by 2 when I pipe it to the foreach. The FormatEntryData doesn’t contain a method op_Multiply. Windows PowerShell attempts to multiply FormatEntryData by the integer 2. Windows PowerShell has no built-in definition for this operation, so as a last step, it looks to see whether FormatEntry defines a method for performing the operation.

Windows PowerShell looks for the op_<operation> methods in FormatEntry if the operation is not one of those that are defined by Windows PowerShell. (For more information, see Windows PowerShell in Action, 2^nd Edition.)

One way to “fix” it

I most often want the “raw” data from my scripts and functions, and sometimes some nicely formatted output when I am debugging. Here is one way I accomplish this:

function Get-Numbers {

    param([Switch]$Format)



    $result = 1..5



    if($format) {

        return $result | Format-Table -AutoSize

    }



    $result

}

I set up $Format as a switch parameter, which is one that does not require a value and is off by default. I can call this function with the Format parameter, and my output will be piped to Format-Table. That means FormatEntryData objects will be emitted, and I will not be able to operate on the underlying data.

If I call Get-Numbers without the parameter (the default), I can work directly on the numbers that are output, by piping it to any other Windows PowerShell cmdlet (or my functions) such as, Where-Object, ForEach-Object, or Group-Object.

Solve it another way

I find it productive to leverage the modular capabilities in Windows PowerShell. In the following example, I am using a range of numbers; this concept can be applied to any set of objects in Windows PowerShell. I am creating a dynamic module that exists only in memory with New-Module. This script can be saved as a .psm1 file and stored for later use with the Import-Module cmdlet.

Users of this script can now get to any core components of the data, and they get “helper” functions too. For example, it is simple to get the sum of all odd numbers by using Get-SumOfOdd. Plus, this approach enables the flexibility to filter the data in other ways, for example, getting only the numbers that are divisible by 5. Users can also reuse my implementation of Sum as shown here, which in itself could be a custom calculation.

Get-MySum ( Get-Numbers | Where { $_ % 5 -eq 0} )

Dynamic module with New-Module

New-Module -Name TestModule {



    function Get-Numbers { 1..10 }



    function Get-MySum ($numbers) { $numbers | foreach { $s=0 } { $s+=$_ } { $s } }

    function Get-MyEvenNumbers    { Get-Numbers | Where { $_ % 2 -eq 0 } }

    function Get-MyOddNumbers     { Get-Numbers | Where { $_ % 2 -eq 1 } }

    function Get-SumOfEven        { Get-MySum (Get-MyEvenNumbers) }

    function Get-SumOfOdd         { Get-MySum (Get-MyOddNumbers) }



} | Import-Module

Example of usage:

@"

Get-Numbers:       $(Get-Numbers)

Get-MyEvenNumbers: $(Get-MyEvenNumbers)

Get-MyOddNumbers: $(Get-MyOddNumbers)

Sum All Numbers:   $(Get-MySum (Get-Numbers))

Get-SumOfEven:     $(Get-SumOfEven)

Get-SumOfOdd:      $(Get-SumOfOdd)

"@

Results:

Get-Numbers:       1 2 3 4 5 6 7 8 9 10

Get-MyEvenNumbers: 2 4 6 8 10

Get-MyOddNumbers: 1 3 5 7 9

Sum All Numbers:   55

Get-SumOfEven:     30

Get-SumOfOdd:      25

It is important to keep in mind that the scripts and functions I write can be consumed by others (as well as by me). Letting the underlying objects flow across the pipeline is key to leveraging the Windows PowerShell system. I can always provide a parameter or additional function that handles reporting if my user needs it. This is demonstrated with the New-Module example.

A key benefit is that users can always inject a pipeline between the data generation and reporting functions. This allows them to subset the information, say with a Where-Object, or to perform a calculation and then let it flow to the reporting. This provides maximum flexibility.

At the end of the day, outputting formatted data will frustrate your efforts because this is the end of the road for the underlying data. It cannot be transformed or operated on anymore. Outputting objects is the cornerstone of being productive in Windows PowerShell.

Thank you, Doug, for this great blog.

Ed Wilson, Microsoft Scripting Guy

Learn How to Load and Use PowerShell Snap-ins

Anonymous — Sat, 16 Oct 2010 05:00:00 GMT

Summary : How do I use snap-ins with the Windows PowerShell 2.0 cmdlet, Add-Module ? What are the benefits of using this method over Add-PSSnapin ? Microsoft Scripting Guy Ed Wilson here. I am on holiday today and am speaking at SQL Saturday #49 today...(read more)

Deploy a PowerShell Module with SharePoint Cmdlets

Anonymous — Wed, 29 Sep 2010 05:00:00 GMT

Summary : In this article, Scripting Guys guest blogger Brian Jackett illustrates how to deploy a Windows PowerShell module with SharePoint cmdlets. Hey, Scripting Guy! I would love to be able to use Windows PowerShell to deploy a module with the SharePoint...(read more)