Sharepoint 2013 : Working with PowerShell (part 3) - PowerShell and SharePoint - Web Applications, Site Collections, Memory and Disposal

Web Applications

PowerShell includes a selection of Cmdlets to manipulate web applications. A web application is the hosting application that resides in Internet Information Server and hosts one or many site collections. Execute the following PowerShell command to obtain a list of web application Cmdlets:

Get-Command –Noun SPWebApplication

Table 3 provides a description of each of the web application–related Cmdlets.

Now that I have covered web applications in PowerShell, I shall examine site collections next, followed by sites and subsites.

Site Collections (SPSite)

A site collection represents the taxonomy of a web site, and hosts a hierarchy of sites. In Central Administration, you create, edit, and delete site collections under the Application Management section. Table 4 lists the available Cmdlets; you can see a list of these Cmdlets by executing the following command:

Get-Command –Noun SPSite

The more common of the SPSite Cmdlets are the Backup and Restore Cmdlets. As administrators, we are familiar with the STSADM backup and restore commands, which provide granular backup of complete site collections (often used when deploying a version of a web solution from development to staging and production). The new PowerShell Backup and Restore Cmdlets support the use of SQL snapshots, which ensures integrity of the backup, while allowing users to continue reading and writing to the active site collection. STSADM backup places a read-only lock on the site collection, prohibiting backup of a busy SharePoint site collection during business hours.

Sites (SPWeb)

Consider a modern intranet or public web site, which consists of multiple levels, accessible via navigation elements. A site represents a single level in a site hierarchy. In SharePoint, a single site contains document libraries, lists, and subsites. It does not matter if the site is a publishing site, team site, meeting site, etc. The site represents one node in the overall site taxonomy.

The SharePoint object model, and hence PowerShell, represents a site as a SPWeb object. Similar to other objects in PowerShell, you can get an idea of the number of properties associated with the SPWeb object by using the following command:

Get-SPWeb http://web-url | Format-List *

Table 5 lists the available Cmdlets, using the following command:

Get-Command –Noun SPWeb

Typically, the most common of the preceding SPWeb Cmdlets is the Get-SPWeb Cmdlet, with which you might perform multiple operations via different SP Cmdlets. The SPSite site collection maintains a list of all SPWeb objects available in the site collection, which you can iterate as follows:

(Get-SPSite http://sp2013).AllWebs | Foreach-Object { $_.Title }

The preceding command gets SPWeb objects via the AllWebs collection on the SPSite object returned by the Get-SPSite Cmdlet. In my example, I am simply displaying the title of each site in the site collection, but I could just as easily pass the SPWeb object to a Cmdlet that performs an operation on the SPWeb object.

Memory and Disposal

Developers of SharePoint applications understand the need for memory disposal practice. SharePoint objects, such as SPSite, SPWeb, etc., consume resources, and it is the developer’s responsibility to release these resources by calling the Dispose method on these types of objects when done using them. Do you have to concern yourself with memory disposal when using these objects in PowerShell? Fortunately, PowerShell, in conjunction with the SharePoint object model, assists in the disposal of expensive SharePoint objects.

Using the SharePoint Management Shell, rather than the standard Windows PowerShell, because each command or single-line pipeline runs in a single thread. This is important when using objects like SPSite and SPWeb, because we often like to pipe these objects and Cmdlets that return these objects together, which would ordinarily leak memory in a multi-threaded Windows PowerShell window.

So, how does PowerShell manage memory disposal? I shall provide an example.

Get-SPWebApplication | Get-SPSite –limit all | Foreach-Object { $._Url }

The preceding command iterates over every site collection for every web application in the farm. For each site collection, the command displays the URL. The issue with this command is that the call to Get-SPSite for each web application uses space in memory for the new SPSite object. In a standard Windows PowerShell, not disposing of the SPSite object after each iteration would cause a memory leak. The SharePoint Management Shell caters to these scenarios and ensures disposal of all objects allocated in the preceding pipeline sequence.

Now, consider the following scenario, where SPSite and SPWeb objects are used over several lines of a PowerShell script:

$site = Get-SPSite " http://sp2013 "
Foreach ($web in $site.AllWebs) {
      Write-Host $web.Title
}

The preceding script gets a new instance of a SPSite object for a site collection URL, then iterates every site in the site collection (represented by SPWeb objects) displaying the title. In this example, PowerShell cannot help you because it has no way of knowing whether to dispose of the SPSite object nor each SPWeb object in the iteration, since the operations span several lines in the script. In this case, disposal is the responsibility of the script developer.

As a rule, I like to dispose of all SharePoint objects that implement the IDisposable interface. The following modified script ensures disposal:

$site = Get-SPSite " http://sp2013 "
try {
  Foreach ($web in $site.AllWebs) {
    try {
      Write-Host $web.Title
    } finally {
      $web.Dispose();
    }
  }
} finally {
  $site.Dispose();
}

Although the second version of the script ensures disposal of memory, the script is messy. Developers writing code in C# have a shortcut to clean up disposable objects with the using keyword. In PowerShell, we also have a shortcut, shown as follows:

Start-SPAssignment –Global
$site = Get-SPSite " http://sp2013 "
Foreach ($web in $site.AllWebs) {
      Write-Host $web.Title
}
Stop-SPAssignment –Global

Wrapping our script between the Start-SPAssignment –Global and Stop-SPAssignment –Global statements ensures that PowerShell disposes of any object allocated and assigned to the global space. Objects in the global space are those that the script has not scoped to a particular named space. The following example shows the script using two scoped name spaces:

$siteScope = Start-SPAssignment
$site = Get-SPSite " http://sp2013 "
for ($i=0;$i -lt $site.AllWebs.Count; $i++) {
  $webScope = Start-SPAssignment
  Write-Host $site.AllWebs[$i].Title
  Stop-SPAssignment $webScope
}
Stop-SPAssignment $siteScope

As you have discovered, memory management of SharePoint objects in PowerShell is important. If you are writing small scripts that have a short execution time—as in they complete within a few seconds—then memory-management is probably not one of your major concerns. However, if you have a script that iterates a large site collection and performs significant processing, then you can easily find yourself eating memory until your PowerShell instance crashes.

Before I conclude this section on memory and disposal, there is one more important point to be aware of—PowerShell does not clean up leaked objects at the end of scripts. In other words, if you have a leaky script, which you execute several times (perhaps because you are debugging), PowerShell is unable to claim the leaked memory until you terminate the PowerShell process. Again, this is not a big consideration if you are executing your scripts in a short window of time, but if you have a PowerShell script running for a lengthy duration, pay close attention to the amount of memory the PowerShell process consumes.