Cmdlets « SharePoint Automation

8Apr/094

Working with SPWeb(Info) Objects Using PowerShell

I know, I know, I’m way behind on documenting my PowerShell cmdlets – I will be striving to get them done as soon as possible. I’ve already documented one of them, the Get-SPSite cmdlet, and I will now continue with the Get-SPWeb cmdlet. Hopefully I’ll be able to wrap up the others much quicker as they are a lot simpler – then I can finally start building new ones

Like the Get-SPSite cmdlet the Get-SPWeb cmdlet addresses some common issues found with working with SPWeb objects. For additional details about the disposal problem when working with many common SharePoint objects via PowerShell see the post about the Get-SPSite cmdlet. For those that aren’t familiar with the SPWeb object (Microsoft.SharePoint.SPWeb), it’s the equivalent programmatic element for working with sites within site collections.

First lets look at the SPWebInfo object and some its uses, the Get-SPWeb cmdlet is extremely simple so I’ll save it for last. Consider the following code snippet:

[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint")
$site = New-Object Microsoft.SharePoint.SPSite("http://portal")
foreach ($web in $site.AllWebs) {
    Write-Host $web.Url
}

The above code results in a memory leak. If you don’t re-loop through each SPWeb object in the collection and dispose of the object by calling the “Dispose()” method you will end up with unmanaged resources left in memory that could eventually cause issues if you do a lot of processing like this (eventually the GC will dispose of the objects but that could take quite some time). The same issue is true for the SPSite object.

Another option would be to use a different approach to get all the SPWeb objects within a site collection, an approach that can be used for more dynamic querying of objects and returns back an object that would not require disposal – an SPWebInfo object. Here’s an example of how you could do something similar to the above using my Get-SPSite cmdlet and the AllWebs property that the SPSiteInfo object exposes:

$site = Get-SPSite("http://portal")
foreach ($web in $site.AllWebs) {
    Write-Host $web.Url
}

The above code still uses the AllWebs property but in this case it’s part of my SPSiteInfo object so rather than exposing a collection of SPWeb objects it returns a collection of SPWebInfo objects. As a result you no longer need to dispose of the objects returned.

The one obvious downside of this approach is that when you access the property I have to loop through all the webs internally and copy their data to my custom object before I can return back to the calling application. Typically though, we’re more concerned about flexibility and ease of use rather than performance when performing the simple administrative tasks that we’d be looking to perform using PowerShell.

What I like about the approach I put together is that I can now do filtered queries without having to worry about whether or not I disposed of the objects. Here’s an example of how to find all the webs that use a specific site template (in this case “STS”):

$site = Get-SPSite("http://portal")
$webs = $site.AllWebs | where -FilterScript {$_.WebTemplate -eq "STS"}
foreach ($web in $webs) {
    Write-Host $web.Url
}

Or I can simply get a specific SPWebInfo (and therefore the SPWeb) object by calling the Get-SPWeb cmdlet directly (I don’t currently support wildcards so this is only helpful for getting a specific web instance):

$web = Get-SPWeb "http://devthekey"
Write-Host $web.WebTemplate

It’s important to remember that the SPWebInfo object is meant to be read-only as most of the properties are just copies of the variables but there are some exceptions such as the SPListCollection object returned by the Lists property or the SPRecycleBinItemCollection object returned by the RecycleBin property. In general, if you have to call the Update() method of the SPWeb object to save your changes then you have to use the actual SPWeb object, otherwise you can work directly with the SPWebInfo object and forego the need to instantiate and dispose of the SPWeb object.

What about when you do need to access the actual SPWeb object? There are two approaches for this: the first is to use the SPBase property which will create a new SPWeb instance and store that instance as a private member variable for future access to the property thus avoiding the overhead of creating another instance on subsequent calls; the second is to use the GetSPObject() method which creates a new instance of the SPWeb object but does not store a copy so it’s a nice easy way to get an entirely new instance of the actual SPWeb object (useful for when you’ve made a change which requires a reload due to caching). In both cases you are responsible for disposing of the returned object.

The following code snippet shows the SPWebInfo class:

       1: using System;

       2: using System.Collections;

       3: using System.Collections.Generic;

       4: using System.Globalization;

       5: using System.Linq;

       6: using System.Text;

       7: using System.Web.Configuration;

       8: using Microsoft.SharePoint;

       9: using Microsoft.SharePoint.Administration;

using Microsoft.SharePoint.Navigation;

using Microsoft.SharePoint.Utilities;

using Microsoft.SharePoint.Workflow;

  

namespace Lapointe.SharePoint.PowerShell.Commands.Proxies

{

    public class SPWebInfo : ISPInfo

    {

        private SPSite m_Site;

        private SPWeb m_Web;

        private List<SPWebInfo> m_Webs;

        private Guid m_FirstUniqueAncestorWeb;

        private Guid m_FirstUniqueRoleDefinitionWeb;

        private SPListCollection m_Lists;

        private SPListTemplateCollection m_ListTemplates;

        private SPFeatureCollection m_Features;

  

        internal SPWebInfo(SPWeb web)

        {

            ID = web.ID;

            Alerts = web.Alerts;

            AllowAnonymousAccess = web.AllowAnonymousAccess;

            AllowAutomaticASPXPageIndexing = web.AllowAutomaticASPXPageIndexing;

            AllowRssFeeds = web.AllowRssFeeds;

            AllowUnsafeUpdates = web.AllowUnsafeUpdates;

            AllProperties = web.AllProperties;

            AllRolesForCurrentUser = web.AllRolesForCurrentUser;

            AllUsers = web.AllUsers;

            AllWebTemplatesAllowed = web.AllWebTemplatesAllowed;

            AlternateCssUrl = web.AlternateCssUrl;

            AlternateHeader = web.AlternateHeader;

            AnonymousPermMask64 = web.AnonymousPermMask64;

            AnonymousState = web.AnonymousState;

            ASPXPageIndexed = web.ASPXPageIndexed;

            ASPXPageIndexMode = web.ASPXPageIndexMode;

            AssociatedGroups = web.AssociatedGroups;

            AssociatedMemberGroup = web.AssociatedMemberGroup;

            AssociatedOwnerGroup = web.AssociatedOwnerGroup;

            AssociatedVisitorGroup = web.AssociatedVisitorGroup;

            Audit = web.Audit;

            AuthenticationMode = web.AuthenticationMode;

            Author = web.Author;

            AvailableContentTypes = web.AvailableContentTypes;

            AvailableFields = web.AvailableFields;

            CacheAllSchema = web.CacheAllSchema;

            Configuration = web.Configuration;

            ContentTypes = web.ContentTypes;

            Created = web.Created;

            CurrencyLocaleID = web.CurrencyLocaleID;

            CurrentChangeToken = web.CurrentChangeToken;

            CurrentUser = web.CurrentUser;

            CustomMasterUrl = web.CustomMasterUrl;

            DataRetrievalServicesSettings = web.DataRetrievalServicesSettings;

            Description = web.Description;

            try

            {

                DocTemplates = web.DocTemplates;

            }

            catch (SPException) {}

            EffectiveBasePermissions = web.EffectiveBasePermissions;

            EffectivePresenceEnabled = web.EffectivePresenceEnabled;

            EventHandlersEnabled = web.EventHandlersEnabled;

            EventReceivers = web.EventReceivers;

            ExecuteUrl = web.ExecuteUrl;

            Exists = web.Exists;

            ExternalSecurityProviderSetting = web.ExternalSecurityProviderSetting;

            Fields = web.Fields;

            FieldTypeDefinitionCollection = web.FieldTypeDefinitionCollection;

            Files = web.Files;

            //FirstUniqueAncestor = web.FirstUniqueAncestor;

            Folders = web.Folders;

            Groups = web.Groups;

            HasExternalSecurityProvider = web.HasExternalSecurityProvider;

            HasUniqueRoleAssignments = web.HasUniqueRoleAssignments;

            HasUniqueRoleDefinitions = web.HasUniqueRoleDefinitions;

            IncludeSupportingFolders = web.IncludeSupportingFolders;

            IsADAccountCreationMode = web.IsADAccountCreationMode;

            IsADEmailEnabled = web.IsADEmailEnabled;

            IsRootWeb = web.IsRootWeb;

            Language = web.Language;

            LastItemModifiedDate = web.LastItemModifiedDate;

            Locale = web.Locale;

            MasterUrl = web.MasterUrl;

            Modules = web.Modules;

            Name = web.Name;

            Navigation = web.Navigation;

            NoCrawl = web.NoCrawl;

            //SPWeb ParentWeb = web;

            ParentWebId = web.ParentWebId;

            ParserEnabled = web.ParserEnabled;

            PortalMember = web.PortalMember;

            PortalName = web.PortalName;

            PortalSubscriptionUrl = web.PortalSubscriptionUrl;

            PortalUrl = web.PortalUrl;

            PresenceEnabled = web.PresenceEnabled;

            Properties = web.Properties;

            Provisioned = web.Provisioned;

            PublicFolderRootUrl = web.PublicFolderRootUrl;

            QuickLaunchEnabled = web.QuickLaunchEnabled;

            RecycleBin = web.RecycleBin;

            RegionalSettings = web.RegionalSettings;

            RequestAccessEmail = web.RequestAccessEmail;

            RequestAccessEnabled = web.RequestAccessEnabled;

            ReusableAcl = web.ReusableAcl;

            RoleAssignments = web.RoleAssignments;

            RoleDefinitions = web.RoleDefinitions;

            RootFolder = web.RootFolder;

            ServerRelativeUrl = web.ServerRelativeUrl;

            Site = web.Site.ID;

            SiteAdministrators = web.SiteAdministrators;

            SiteGroups = web.SiteGroups;

            SiteLogoDescription = web.SiteLogoDescription;

            SiteLogoUrl = web.SiteLogoUrl;

            SiteUserInfoList = web.SiteUserInfoList;

            SiteUsers = web.SiteUsers;

            SyndicationEnabled = web.SyndicationEnabled;

            Theme = web.Theme;

            ThemeCssUrl = web.ThemeCssUrl;

            Title = web.Title;

            TreeViewEnabled = web.TreeViewEnabled;

            Url = web.Url;

            UserIsSiteAdmin = web.UserIsSiteAdmin;

            UserIsWebAdmin = web.UserIsWebAdmin;

            Users = web.Users;

            ViewStyles = web.ViewStyles;

            //SPWebCollection Webs = web;

            WebTemplate = web.WebTemplate;

            WebTemplateId = web.WebTemplateId;

            WorkflowTemplates = web.WorkflowTemplates;

        }

  

        /// <summary>

        /// Returns a newly created instance of the object on the first access.  Subsequent accesses will utilize an internal member variable.

        /// The caller is responsible for disposing of the returned SPWeb object and it's parent SPSite object (web.Site.Dispose()).

        /// </summary>

        /// <value>The SP base.</value>

        public IDisposable SPBase

        {

            get

            {

                if (m_Web == null)

                {

                    if (m_Site == null)

                        m_Site = new SPSite(Site);

  

                    m_Web = m_Site.OpenWeb(ID);

                }

                return m_Web;

            }

        }

  

        /// <summary>

        /// Returns a newly created instance of the object every time without storing an internal member variable for subsequent access.

        /// The caller is responsible for disposing of the returned SPWeb object and it's parent SPSite object (web.Site.Dispose()).

        /// </summary>

        /// <returns></returns>

        public IDisposable GetSPObject()

        {

            return new SPSite(Site).OpenWeb(ID);

        }

  

        public SPAlertCollection Alerts { get; internal set; }

        public bool AllowAnonymousAccess { get; internal set; }

        public bool AllowAutomaticASPXPageIndexing { get; internal set; }

        public bool AllowRssFeeds { get; internal set; }

        public bool AllowUnsafeUpdates { get; internal set; }

        public Hashtable AllProperties { get; internal set; }

        public SPRoleDefinitionBindingCollection AllRolesForCurrentUser { get; internal set; }

        public SPUserCollection AllUsers { get; internal set; }

        public bool AllWebTemplatesAllowed { get; internal set; }

        public string AlternateCssUrl { get; internal set; }

        public string AlternateHeader { get; internal set; }

        public SPBasePermissions AnonymousPermMask64 { get; internal set; }

        public SPWeb.WebAnonymousState AnonymousState { get; internal set; }

        public bool ASPXPageIndexed { get; internal set; }

        public WebASPXPageIndexMode ASPXPageIndexMode { get; internal set; }

        public IList<SPGroup> AssociatedGroups { get; internal set; }

        public SPGroup AssociatedMemberGroup { get; internal set; }

        public SPGroup AssociatedOwnerGroup { get; internal set; }

        public SPGroup AssociatedVisitorGroup { get; internal set; }

        public SPAudit Audit { get; internal set; }

        public AuthenticationMode AuthenticationMode { get; internal set; }

        public SPUser Author { get; internal set; }

        public SPContentTypeCollection AvailableContentTypes { get; internal set; }

        public SPFieldCollection AvailableFields { get; internal set; }

        public bool CacheAllSchema { get; internal set; }

        public short Configuration { get; internal set; }

        public SPContentTypeCollection ContentTypes { get; internal set; }

        public DateTime Created { get; internal set; }

        public int CurrencyLocaleID { get; internal set; }

        public SPChangeToken CurrentChangeToken { get; internal set; }

        public SPUser CurrentUser { get; internal set; }

        public string CustomMasterUrl { get; internal set; }

        public SPDataRetrievalServicesSettings DataRetrievalServicesSettings { get; internal set; }

        public string Description { get; internal set; }

        public SPDocTemplateCollection DocTemplates { get; internal set; }

        public SPBasePermissions EffectiveBasePermissions { get; internal set; }

        public bool EffectivePresenceEnabled { get; internal set; }

        public bool EventHandlersEnabled { get; internal set; }

        public SPEventReceiverDefinitionCollection EventReceivers { get; internal set; }

        public string ExecuteUrl { get; internal set; }

        public bool Exists { get; internal set; }

        public string ExternalSecurityProviderSetting { get; internal set; }

        public SPFeatureCollection Features

        {

            get

            {

                if (m_Features != null)

                    return m_Features;

  

                using (SPSite site = new SPSite(Site))

                using (SPWeb web = site.OpenWeb(ID))

                {

                    m_Features = web.Features;

                }

                return m_Features;

  

            }

        }

        public SPFieldCollection Fields { get; internal set; }

        public SPFieldTypeDefinitionCollection FieldTypeDefinitionCollection { get; internal set; }

        public SPFileCollection Files { get; internal set; }

        public Guid FirstUniqueAncestorWeb

        {

            get

            {

                if (m_FirstUniqueAncestorWeb != Guid.Empty)

                    return m_FirstUniqueAncestorWeb;

  

                using (SPSite site = new SPSite(Site))

                using (SPWeb web = site.OpenWeb(ID))

                using (SPWeb ancestor = web.FirstUniqueAncestorWeb)

                {

                    m_FirstUniqueAncestorWeb = ancestor.ID;

                }

                return m_FirstUniqueAncestorWeb;

  

            }

        }

        public Guid FirstUniqueRoleDefinitionWeb

        {

            get

            {

                if (m_FirstUniqueRoleDefinitionWeb != Guid.Empty)

                    return m_FirstUniqueRoleDefinitionWeb;

  

                using (SPSite site = new SPSite(Site))

                using (SPWeb web = site.OpenWeb(ID))

                using (SPWeb ancestor = web.FirstUniqueRoleDefinitionWeb)

                {

                    m_FirstUniqueRoleDefinitionWeb = ancestor.ID;

                }

                return m_FirstUniqueRoleDefinitionWeb;

  

            }

        }

        public SPFolderCollection Folders { get; internal set; }

        public SPGroupCollection Groups { get; internal set; }

        public bool HasExternalSecurityProvider { get; internal set; }

        public bool HasUniqueRoleAssignments { get; internal set; }

        public bool HasUniqueRoleDefinitions { get; internal set; }

        public Guid ID { get; internal set; }

        public bool IncludeSupportingFolders { get; internal set; }

        public bool IsADAccountCreationMode { get; internal set; }

        public bool IsADEmailEnabled { get; internal set; }

        public bool IsRootWeb { get; internal set; }

        public uint Language { get; internal set; }

        public DateTime LastItemModifiedDate { get; internal set; }

        public SPListCollection Lists

        {

            get

            {

                if (m_Lists != null)

                    return m_Lists;

  

                using (SPSite site = new SPSite(Site))

                using (SPWeb web = site.OpenWeb(ID))

                {

                    m_Lists = web.Lists;

                }

                return m_Lists;

  

            }

        }

        public SPListTemplateCollection ListTemplates

        {

            get

            {

                if (m_ListTemplates != null)

                    return m_ListTemplates;

  

                using (SPSite site = new SPSite(Site))

                using (SPWeb web = site.OpenWeb(ID))

                {

                    m_ListTemplates = web.ListTemplates;

                }

                return m_ListTemplates;

  

            }

        }

        public CultureInfo Locale { get; internal set; }

        public string MasterUrl { get; internal set; }

        public SPModuleCollection Modules { get; internal set; }

        public string Name { get; internal set; }

        public SPNavigation Navigation { get; internal set; }

        public bool NoCrawl { get; internal set; }

        public SPWeb ParentWeb { get; internal set; }

        public Guid ParentWebId { get; internal set; }

        public bool ParserEnabled { get; internal set; }

        public bool PortalMember { get; internal set; }

        public string PortalName { get; internal set; }

        public string PortalSubscriptionUrl { get; internal set; }

        public string PortalUrl { get; internal set; }

        public bool PresenceEnabled { get; internal set; }

        public SPPropertyBag Properties { get; internal set; }

        public bool Provisioned { get; internal set; }

        public string PublicFolderRootUrl { get; internal set; }

        public bool QuickLaunchEnabled { get; internal set; }

        public SPRecycleBinItemCollection RecycleBin { get; internal set; }

        public SPRegionalSettings RegionalSettings { get; internal set; }

        public string RequestAccessEmail { get; internal set; }

        public bool RequestAccessEnabled { get; internal set; }

        public SPReusableAcl ReusableAcl { get; internal set; }

        public SPRoleAssignmentCollection RoleAssignments { get; internal set; }

        public SPRoleDefinitionCollection RoleDefinitions { get; internal set; }

        public SPFolder RootFolder { get; internal set; }

        public string ServerRelativeUrl { get; internal set; }

        public Guid Site { get; internal set; }

        public SPUserCollection SiteAdministrators { get; internal set; }

        public SPGroupCollection SiteGroups { get; internal set; }

        public string SiteLogoDescription { get; internal set; }

        public string SiteLogoUrl { get; internal set; }

        public SPList SiteUserInfoList { get; internal set; }

        public SPUserCollection SiteUsers { get; internal set; }

        public bool SyndicationEnabled { get; internal set; }

        public string Theme { get; internal set; }

        public string ThemeCssUrl { get; internal set; }

        public string Title { get; internal set; }

        public bool TreeViewEnabled { get; internal set; }

        public string Url { get; internal set; }

        public bool UserIsSiteAdmin { get; internal set; }

        public bool UserIsWebAdmin { get; internal set; }

        public SPUserCollection Users { get; internal set; }

        public SPViewStyleCollection ViewStyles { get; internal set; }

        public List<SPWebInfo> Webs

        {

            get

            {

                if (m_Webs != null)

                    return m_Webs;

  

                m_Webs = new List<SPWebInfo>();

                using (SPSite site = new SPSite(Site))

                using (SPWeb web = site.OpenWeb(ID))

                {

                    foreach (SPWeb subWeb in web.Webs)

                    {

                        try

                        {

                            m_Webs.Add(new SPWebInfo(subWeb));

                        }

                        finally

                        {

                            subWeb.Dispose();

                        }

                    }

                }

                return m_Webs;

  

            }

        }

        public string WebTemplate { get; internal set; }

        public int WebTemplateId { get; internal set; }

        public SPWorkflowTemplateCollection WorkflowTemplates { get; internal set; }

   }

}

The following is the code of the core Get-SPWeb cmdlet:

       1: using System;

       2: using System.Collections.Generic;

       3: using System.Management.Automation;

       4: using Lapointe.SharePoint.PowerShell.Commands.OperationHelpers;

       5: using Lapointe.SharePoint.PowerShell.Commands.Proxies;

       6: using Lapointe.SharePoint.PowerShell.Commands.Validators;

       7: using Lapointe.SharePoint.STSADM.Commands.OperationHelpers;

       8: using Microsoft.SharePoint;

       9:  

namespace Lapointe.SharePoint.PowerShell.Commands.Webs

{

    [Cmdlet(VerbsCommon.Get, "SPWeb", SupportsShouldProcess=true, DefaultParameterSetName = "Url")]

    public class GetSPWebCommand : PSCmdletBase

    {

        /// <summary>

        /// Gets or sets the URL.

        /// </summary>

        /// <value>The URL.</value>

        [Parameter(

            ParameterSetName = "Url",

            Mandatory = true,

            Position = 0,

            ValueFromPipeline = true,

            ValueFromPipelineByPropertyName = true,

            HelpMessage = "The URL of the web to return")]

        [ValidateNotNullOrEmpty]

        [ValidateUrl(false)]

        public string[] Url { get; set; }

  

  

        /// <summary>

        /// Processes the record.

        /// </summary>

        protected override void ProcessRecordEx()

        {

            foreach (string url in Url)

            {

                string siteUrl = url.TrimEnd('/');

                using (SPSite site = new SPSite(siteUrl))

                using (SPWeb web = site.AllWebs[Utilities.GetServerRelUrlFromFullUrl(siteUrl)])

                {

                    WriteObject(new SPWebInfo(web));

                }

            }

        }

    }

}

The following is the full help for the cmdlet.

PS C:\> get-help get-spweb -full

NAME
Get-SPWeb

SYNOPSIS
Gets one or more SPWebInfo objects representing a SharePoint 2007 Web.

SYNTAX
Get-SPWeb [-Url] <String[]> [-WhatIf] [-Confirm] [<CommonParameters>]

DETAILED DESCRIPTION
Pass in a comma separated list of URLs or a string array of URLs to obtain a collection of SPWebInfo objects. Thes
e objects do not need to be disposed.

The SPWebInfo object that is returned contains almost all of the same properties of the SPWeb object but does not r
equire disposal and should be generally considered read-only. You can get to the actual SPWeb object by using the
SPBase property or the GetSPObject() method. The SPBase property results in a copy of the SPWeb object being persi
sted in the SPWebInfo object for faster access on future calls. Always remember to dispose of the SPWeb object if
used. Some collection properties may be directly updated without the need to access the SPSite object.

Copyright 2008 Gary Lapointe
> For more information on these PowerShell cmdlets:
> http://stsadm.blogspot.com/
> Use of these cmdlets is at your own risk.
> Gary Lapointe assumes no liability.

PARAMETERS
-Url <String[]>
Specifies the URL of the web(s) to retrieve. Wildcards are not permitted. If you specify multiple URLs, use com
mas to separate the URLs.

Required? true
Position? 1
Default value
Accept pipeline input? true (ByValue, ByPropertyName)
Accept wildcard characters? false

-WhatIf

Required? false
Position? named
Default value
Accept pipeline input? false
Accept wildcard characters? false

-Confirm

Required? false
Position? named
Default value
Accept pipeline input? false
Accept wildcard characters? false

<CommonParameters>
This cmdlet supports the common parameters: -Verbose, -Debug,
-ErrorAction, -ErrorVariable, and -OutVariable. For more information,
type, "get-help about_commonparameters".

INPUT TYPE
String

RETURN TYPE
Collection of SPWebInfo objects.

NOTES

For more information, type "Get-Help Get-SPWeb -detailed". For technical information, type "Get-Help Get-SPW
eb -full".

-------------- EXAMPLE 1 --------------

C:\PS>$web = get-spweb -url http://portal

This example returns back a single SPWebInfo object.

Working with SPSite(Info) Objects Using PowerShell

One of the first PowerShell cmdlets I built, Get-SPSite, addresses some common issues found with working with SPSite objects. I struggled with how I could provide a means to quickly and easily get SPSite objects while at the same time helping administrators so they don’t have to worry (as much) about object disposal. For those that aren’t familiar with the SPSite object (Microsoft.SharePoint.SPSite), it’s the equivalent programmatic element for working with site collections.

What I eventually ended up creating (thanks to some good advice from Harley Green) was a simple wrapper object which encapsulates most of the key properties of the SPSite object thus allowing basic reporting and decision making processing without the need to worry about disposing of the object. Consider the following code snippet:

     [System.Reflection.Assembly]::LoadWithPartialName("Microsoft.Sharepoint")

    $webapp = [Microsoft.SharePoint.Administration.SPWebApplication]::Lookup("http://portal")

    foreach ($site in $webapp.Sites) {

        Write-Host $site.Url

    }

The above code results in a memory leak. If you don’t re-loop through each SPSite object in the collection and dispose of the object by calling the “Dispose()” method you will end up with unmanaged resources left in memory that could eventually cause issues if you do a lot of processing like this (eventually the GC will dispose of the objects but that could take quite some time).

Another option would be to use a different approach to get all the SPSite objects within a web application, an approach that can be used for more dynamic querying of objects and returns back an object that would not require disposal – an SPSiteInfo object. Here’s an example of how you could do something similar to the above using my Get-SPSite cmdlet:

    foreach ($site in get-spsite -url http://portal*) {

        Write-Host $site.Url

    }

The one obvious downside of this approach is that the wildcard means that I have to inspect every single site collection within the farm to figure out where there are matches so if you’re looking for performance this definitely isn’t the best approach. Typically though, we’re more concerned about flexibility and ease of use rather than performance when performing the simple administrative tasks that we’d be looking to perform using PowerShell.

What I like about the approach I put together is that I can now do filtered queries without having to worry about whether or not I disposed of the objects. Here’s an example of how to find all the site collections within the farm where the storage size is greater than 80% of the quota:

    get-spsite -url * | where -filterscript {$_.Usage.Storage -ge $_.Quota.StoragemaximumLevel*.8 -and $_.Quota.StorageMaximumLevel -ne 0} | select Url,@{Name="Storage";expression={$_.Usage.Storage/1MB}}
  

In the above I can simply call my Get-SPSite cmdlet, filter out all items where the current storage is less than 0.8 of the maximum level if set (StorageMaximumLevel is not 0), and then display the URL and the current size, in megabytes, of the the remaining site collections.

It’s important to remember that the SPSiteInfo object is meant to be read-only as most of the properties are just copies of the variables but there are some exceptions such as the SPRecycleBinItemCollection object returned by the RecycleBin property or the SPFeatureCollection object returned by the Features property. In general, if you have to call the Update() method of the SPSite object to save your changes then you have to use the actual SPSite object, otherwise you can work directly with the SPSiteInfo object and forego the need to instantiate and dispose of the SPSite object.

Okay, so working with properties is pretty easy and we can do some nice reports using them and even access the web application using the WebApplication property or the webs using the AllWebs collection property (all without having to dispose any of the returned objects – the AllWebs property returns a collection of SPWebInfo objects) but what about when you do need to access the actual SPSite object? There are two approaches for this: the first is to use the SPBase property which will create a new SPSite instance and store that instance as a private member variable for future access to the property thus avoiding the overhead of creating another instance on subsequent calls; the second is to use the GetSPObject() method which creates a new instance of the SPSite object but does not store a copy so it’s a nice easy way to get an entirely new instance of the actual SPSite object (useful for when you’ve made a change which requires a reload due to caching). In both cases you are responsible for disposing of the returned object.

The following code snippet shows the SPSiteInfo class:

       1: using System;

       2: using System.Collections.Generic;

       3: using System.Linq;

       4: using System.Management.Automation;

       5: using System.Text;

       6: using Microsoft.SharePoint;

       7: using Microsoft.SharePoint.Administration;

       8: using Microsoft.SharePoint.Workflow;

       9:  

namespace Lapointe.SharePoint.PowerShell.Commands.Proxies

{

    public class SPSiteInfo : ISPInfo

    {

        private List<SPWebInfo> m_AllWebs;

        private SPSite m_Site;

  

        internal SPSiteInfo(SPSite site)

        {

            ID = site.ID;

            AllowRssFeeds = site.AllowRssFeeds;

            AllowUnsafeUpdates = site.AllowUnsafeUpdates;

            ApplicationRightsMask = site.ApplicationRightsMask;

            Audit = site.Audit;

            CatchAccessDeniedException = site.CatchAccessDeniedException;

            CertificationDate = site.CertificationDate;

            ContentDatabase = site.ContentDatabase;

            CurrentChangeToken = site.CurrentChangeToken;

            DeadWebNotificationCount = site.DeadWebNotificationCount;

            ExternalBinaryIds = site.ExternalBinaryIds;

            Features = site.Features;

            HostHeaderIsSiteName = site.HostHeaderIsSiteName;

            HostName = site.HostName;

            IISAllowsAnonymous = site.IISAllowsAnonymous;

            Impersonating = site.Impersonating;

            IsPaired = site.IsPaired;

            LastContentModifiedDate = site.LastContentModifiedDate;

            LastSecurityModifiedDate = site.LastSecurityModifiedDate;

            LockIssue = site.LockIssue;

            Owner = site.Owner;

            Port = site.Port;

            PortalName = site.PortalName;

            PortalUrl = site.PortalUrl;

            Protocol = site.Protocol;

            Quota = site.Quota;

            ReadLocked = site.ReadLocked;

            ReadOnly = site.ReadOnly;

            RecycleBin = site.RecycleBin;

            try

            {

                RootWeb = new SPWebInfo(site.RootWeb);

            }

            catch (Exception) {}

            SearchServiceInstance = site.SearchServiceInstance;

            SecondaryContact = site.SecondaryContact;

            ServerRelativeUrl = site.ServerRelativeUrl;

            SyndicationEnabled = site.SyndicationEnabled;

            SystemAccount = site.SystemAccount;

            UpgradeRedirectUri = site.UpgradeRedirectUri;

            Url = site.Url;

            Usage = site.Usage;

            try

            {

                UserAccountDirectoryPath = site.UserAccountDirectoryPath;

            }

            catch (UnauthorizedAccessException) { }

            UserToken = site.UserToken;

            WarningNotificationSent = site.WarningNotificationSent;

            WebApplication = site.WebApplication;

            //WorkflowManager = site.WorkflowManager;

            WriteLocked = site.WriteLocked;

            Zone = site.Zone;

  

        }

  

        /// <summary>

        /// Returns a newly created instance of the object on the first access.  Subsequent accesses will utilize an internal member variable.

        /// The caller is responsible for disposing of the returned object.

        /// </summary>

        /// <value>The SP base.</value>

        public IDisposable SPBase

        {

            get

            {

                if (m_Site == null)

                    m_Site = new SPSite(ID);

  

                return m_Site;

            }

        }

  

        /// <summary>

        /// Returns a newly created instance of the object every time without storing an internal member variable for subsequent access.

        /// The caller is responsible for disposing of the returned object.

        /// </summary>

        /// <returns></returns>

        public IDisposable GetSPObject()

        {

            return new SPSite(ID);

        }

  

        public bool AllowRssFeeds { get; internal set; }

        public bool AllowUnsafeUpdates { get; internal set; }

        public List<SPWebInfo> AllWebs

        {

            get

            {

                if (m_AllWebs != null)

                    return m_AllWebs;

  

                m_AllWebs = new List<SPWebInfo>();

                using (SPSite site = new SPSite(ID))

                {

                    foreach (SPWeb web in site.AllWebs)

                    {

                        try

                        {

                            m_AllWebs.Add(new SPWebInfo(web));

                        }

                        finally

                        {

                            web.Dispose();

                        }

                    }

                }

                return m_AllWebs;

            }

        }

        public SPBasePermissions ApplicationRightsMask { get; internal set; }

        public SPAudit Audit { get; internal set; }

        public bool CatchAccessDeniedException { get; internal set; }

        public DateTime CertificationDate { get; internal set; }

        public SPContentDatabase ContentDatabase { get; internal set; }

        public SPChangeToken CurrentChangeToken { get; internal set; }

        public short DeadWebNotificationCount { get; internal set; }

        public SPExternalBinaryIdCollection ExternalBinaryIds { get; internal set; }

        public SPFeatureCollection Features { get; internal set; }

        public bool HostHeaderIsSiteName { get; internal set; }

        public string HostName { get; internal set; }

        public Guid ID { get; internal set; }

        public bool IISAllowsAnonymous { get; internal set; }

        public bool Impersonating { get; internal set; }

        public bool IsPaired { get; internal set; }

        public DateTime LastContentModifiedDate { get; internal set; }

        public DateTime LastSecurityModifiedDate { get; internal set; }

        public string LockIssue { get; internal set; }

        public SPUser Owner { get; internal set; }

        public int Port { get; internal set; }

        public string PortalName { get; internal set; }

        public string PortalUrl { get; internal set; }

        public string Protocol { get; internal set; }

        public SPQuota Quota { get; internal set; }

        public bool ReadLocked { get; internal set; }

        public bool ReadOnly { get; internal set; }

        public SPRecycleBinItemCollection RecycleBin { get; internal set; }

        public SPWebInfo RootWeb { get; internal set; }

        public SPServiceInstance SearchServiceInstance { get; internal set; }

        public SPUser SecondaryContact { get; internal set; }

        public string ServerRelativeUrl { get; internal set; }

        public bool SyndicationEnabled { get; internal set; }

        public SPUser SystemAccount { get; internal set; }

        public Uri UpgradeRedirectUri { get; internal set; }

        public string Url { get; internal set; }

        public SPSite.UsageInfo Usage { get; internal set; }

        public string UserAccountDirectoryPath { get; internal set; }

        public SPUserToken UserToken { get; internal set; }

        public bool WarningNotificationSent { get; internal set; }

        public SPWebApplication WebApplication { get; internal set; }

        //public SPWorkflowManager WorkflowManager { get; internal set; }

        public bool WriteLocked { get; internal set; }

        public SPUrlZone Zone { get; internal set; }

  

    }

}

The following is the code of the core Get-SPSite cmdlet:

       1: using System;

       2: using System.Collections.Generic;

       3: using System.Management.Automation;

       4: using Lapointe.SharePoint.PowerShell.Commands.OperationHelpers;

       5: using Lapointe.SharePoint.PowerShell.Commands.Validators;

       6: using Microsoft.SharePoint;

       7: using Microsoft.SharePoint.Administration;

       8: using Lapointe.SharePoint.PowerShell.Commands.Proxies;

       9:  

namespace Lapointe.SharePoint.PowerShell.Commands.SiteCollections

{

    [Cmdlet(VerbsCommon.Get, "SPSite", SupportsShouldProcess=true, DefaultParameterSetName = "Url")]

    public class GetSPSiteCommand : PSCmdletBase

    {

        /// <summary>

        /// Gets or sets the URL.

        /// </summary>

        /// <value>The URL.</value>

        [Parameter(

            ParameterSetName = "Url",

            Mandatory = true,

            Position = 0,

            ValueFromPipeline = true,

            ValueFromPipelineByPropertyName = true,

            HelpMessage = "The URL of the site to return.  Supports wildcards.")]

        [ValidateNotNullOrEmpty]

        [ValidateUrl(true)]

        public string[] Url { get; set; }

  

        

        /// <summary>

        /// Processes the record.

        /// </summary>

        protected override void ProcessRecordEx()

        {

            foreach (string url in Url)

            {

                if (!WildcardPattern.ContainsWildcardCharacters(url))

                {

                    string siteUrl = url.TrimEnd('/');

                    using (SPSite site = new SPSite(siteUrl))

                    {

                        WriteObject(new SPSiteInfo(site));

                    }

                }

                else

                {

                    WildcardPattern wildCard = new WildcardPattern(url, WildcardOptions.IgnoreCase);

                    if (SPFarm.Local == null)

                        throw new SPException("The SPFarm object is null.  Make sure you are running as a Farm Administrator.");

  

                    foreach (SPService svc in SPFarm.Local.Services)

                    {

                        if (!(svc is SPWebService))

                            continue;

  

                        foreach (SPWebApplication webApp in ((SPWebService)svc).WebApplications)

                        {

                            for (int i = 0; i < webApp.Sites.Count; i++)

                            {

                                using (SPSite site = webApp.Sites[i])

                                {

                                    if (wildCard.IsMatch(site.Url))

                                        WriteObject(new SPSiteInfo(site));

                                }

                            }

                        }

                    }

                }

            }

        }

    }

}

The following is the full help for the cmdlet.

PS C:\> get-help get-spsite -full

NAME
Get-SPSite

SYNOPSIS
Gets one or more SPSiteInfo objects representing a SharePoint 2007 Site Collection.

SYNTAX
Get-SPSite [-Url] <String[]> [-WhatIf] [-Confirm] [<CommonParameters>]

DETAILED DESCRIPTION
Pass in a comma separated list of URLs or a string array of URLs to obtain a collection of SPSiteInfo objects. The
se objects do not need to be disposed.

The SPSiteInfo object that is returned contains almost all of the same properties of the SPSite object but does not
require disposal and should be generally considered read-only. You can get to the actual SPSite object by using t
he SPBase property or the GetSPObject() method. The SPBase property results in a copy of the SPSite object being p
ersisted in the SPSiteInfo object for faster access on future calls. Always remember to dispose of the SPSite obje
ct if used. Some collection properties may be directly updated without the need to access the SPSite object.

Copyright 2008 Gary Lapointe
> For more information on these PowerShell cmdlets:
> http://stsadm.blogspot.com/
> Use of these cmdlets is at your own risk.
> Gary Lapointe assumes no liability.

PARAMETERS
-Url <String[]>
Specifies the URL of the site collection(s) to retrieve. Wildcards are permitted. If you specify multiple URLs,
use commas to separate the URLs.

Required? true
Position? 1
Default value
Accept pipeline input? true (ByValue, ByPropertyName)
Accept wildcard characters? false

-WhatIf

Required? false
Position? named
Default value
Accept pipeline input? false
Accept wildcard characters? false

-Confirm

Required? false
Position? named
Default value
Accept pipeline input? false
Accept wildcard characters? false

<CommonParameters>
This cmdlet supports the common parameters: -Verbose, -Debug,
-ErrorAction, -ErrorVariable, and -OutVariable. For more information,
type, "get-help about_commonparameters".

INPUT TYPE
String

RETURN TYPE
Collection of SPSiteInfo objects.

NOTES

For more information, type "Get-Help Get-SPSite -detailed". For technical information, type "Get-Help Get-SP
Site -full".

-------------- Example 1 --------------

C:\PS>get-spsite -url http://portal

This example returns back a single SPSiteInfo object.

-------------- EXAMPLE 2 --------------

C:\PS>$sites = get-spsite -url http://mysites/*

This example returns back all My Site site collections under the http://mysites web application.

Recalculating Usage Statistics via STSADM or PowerShell

I was perusing through the SharePoint forums the other day and I came across an issue that someone was having with the usage statistics information for their My Sites site collections. When they viewed the usage data (~site/_layouts/usage.aspx) they were seeing incorrect information. I’m not really sure why the numbers were wrong but fixing them turned out to be pretty easy. There’s a public method called “RecalculateStorageUsed” that, when called, will recalculate the usage statistics for the site collection. I decided to do some digging within the SharePoint code and what I found was rather interesting – Microsoft created an stsadm command that would allow you to call this method via stsadm for a site collection – but they didn’t publish the command via any config file so even though the code is there, you can’t use it. I tried to do some more poking around to see if there was a timer job or something that either called this method or one of the internal SPRequest methods that actually does the work but unfortunately I didn’t find anything that would help identify why the numbers weren’t correct.

So, knowing that Microsoft had started the creation of such a command but didn’t finish I decided that I’d go ahead and “finish” it for them – but better, naturally . You can now use my gl-recalculateusage command and pass in various scopes (Farm, WebApplication, or Site) and it will call the aforementioned method for each site collection within the specified scope.

The complete code for the command is included below:

        1: using System;

       2: using System.Text;

       3: using Lapointe.SharePoint.STSADM.Commands.OperationHelpers;

       4: using Lapointe.SharePoint.STSADM.Commands.SPValidators;

       5: using System.Collections.Specialized;

       6: using Microsoft.SharePoint;

       7: using Microsoft.SharePoint.Administration;

       8:  

       9: namespace Lapointe.SharePoint.STSADM.Commands.SiteCollectionSettings

{

    /// <summary>

    /// 

    /// </summary>

    public class RecalculateUsage : SPOperation

    {

        /// <summary>

        /// Initializes a new instance of the <see cref="RecalculateUsage"/> class.

        /// </summary>

        public RecalculateUsage()

        {

            SPParamCollection parameters = new SPParamCollection();

            parameters.Add(new SPParam("url", "url", false, null, new SPUrlValidator()));

            parameters.Add(new SPParam("scope", "s", false, "site", new SPRegexValidator("(?i:^Farm$|^WebApplication$|^Site$)")));

  

  

            StringBuilder sb = new StringBuilder();

            sb.Append("\r\n\r\nRecalculates usage statistics for the given site(s).\r\n\r\nParameters:");

            sb.Append("\r\n\t[-scope <Farm | WebApplication | Site>]");

            sb.Append("\r\n\t[-url <url>]");

  

            Init(parameters, sb.ToString());

        }

  

        /// <summary>

        /// Gets the help message.

        /// </summary>

        /// <param name="command">The command.</param>

        /// <returns></returns>

        public override string GetHelpMessage(string command)

        {

            return HelpMessage;

        }

  

        /// <summary>

        /// Executes the specified command.

        /// </summary>

        /// <param name="command">The command.</param>

        /// <param name="keyValues">The key values.</param>

        /// <param name="output">The output.</param>

        /// <returns></returns>

        public override int Execute(string command, StringDictionary keyValues, out string output)

        {

            output = string.Empty;

            Verbose = true;

  

            string scope = Params["scope"].Value.ToLowerInvariant();

  

            SPEnumerator enumerator;

            if (scope == "farm")

            {

                enumerator = new SPEnumerator(SPFarm.Local);

            }

            else if (scope == "webapplication")

            {

                enumerator = new SPEnumerator(SPWebApplication.Lookup(new Uri(Params["url"].Value.TrimEnd('/'))));

            }

            else

            {

                // scope == "site"

                using (SPSite site = new SPSite(Params["url"].Value.TrimEnd('/')))

                {

                    Recalculate(site);

                }

                return OUTPUT_SUCCESS;

            }

  

            enumerator.SPSiteEnumerated += new SPEnumerator.SPSiteEnumeratedEventHandler(enumerator_SPSiteEnumerated);

            enumerator.Enumerate();

  

            return OUTPUT_SUCCESS;

        }

  

        /// <summary>

        /// Validates the specified key values.

        /// </summary>

        /// <param name="keyValues">The key values.</param>

        public override void Validate(StringDictionary keyValues)

        {

            if (Params["scope"].Validate())

            {

                Params["url"].IsRequired = true;

                Params["url"].Enabled = true;

                if (Params["scope"].Value.ToLowerInvariant() == "farm")

                {

                    Params["url"].IsRequired = false;

                    Params["url"].Enabled = false;

                }

  

            }

            base.Validate(keyValues);

        }

  

        /// <summary>

        /// Handles the SPSiteEnumerated event of the enumerator control.

        /// </summary>

        /// <param name="sender">The source of the event.</param>

        /// <param name="e">The <see cref="Lapointe.SharePoint.STSADM.Commands.OperationHelpers.SPEnumerator.SPSiteEventArgs"/> instance containing the event data.</param>

        private void enumerator_SPSiteEnumerated(object sender, SPEnumerator.SPSiteEventArgs e)

        {

            Recalculate(e.Site);

        }

  

        /// <summary>

        /// Recalculates the specified site.

        /// </summary>

        /// <param name="site">The site.</param>

        private void Recalculate(SPSite site)

        {

            Log("Recalculating {0}", site.Url);

            site.RecalculateStorageUsed();

            using (SPSite site2 = new SPSite(site.ID))

                Log("Storage updated from {0} to {1} (in bytes)\r\n", site.Usage.Storage.ToString(), site2.Usage.Storage.ToString());

        }

    }

}

The help for the command is shown below:

C:\>stsadm -help gl-recalculateusage

stsadm -o gl-recalculateusage


Recalculates usage statistics for the given site(s).

Parameters:
        [-scope <Farm | WebApplication | Site>]
        [-url <url>]

The following table summarizes the command and its various parameters:

Command Name	Availability	Build Date
gl-recalculateusage	WSS v3, MOSS 2007	Released: 1/15/2009

Parameter Name	Short Form	Required	Description	Example Usage
url		Yes if scope is not Farm	URL of the web application or site collection.	-url http://portal
scope	s	No – defaults to site	The scope to use. Valid values are “Farm”, “WebApplication”, and “Site”	-scope site -s site

The following is an example of how to recalculate the usage statistics for all the site collections within the farm:

stsadm -o gl-recalculateusage -scope farm

The following is an example of the output you might see after running the above command:

C:\>stsadm -o gl-recalculateusage -scope farm

Recalculating http://mysites
Usage updated from 425744 to 425744

Recalculating http://mysites/personal/spadmin
Usage updated from 588790 to 588790

Recalculating http://portal
Usage updated from 3249962 to 3249962

Recalculating http://sspadmin/ssp/admin
Usage updated from 642686 to 642686

Recalculating http://sharepoint1:1234
Usage updated from 18244961 to 18284043

Operation completed successfully.

If you wanted to do this exact same thing using PowerShell you could do the following:

PS W:\> foreach ($site in Get-SPSite -url *) {
>> $origStorage = $site.SPBase.Usage.Storage
>> $site.SPBase.RecalculateStorageUsed()
>> $site.SPBase.Dispose()
>> $tempSite = $site.GetSPObject()
>> $newStorage = $tempSite.Usage.Storage
>> Write-Host $tempSite.Url Updated from $origStorage to $newStorage
>> $tempSite.Dispose()
>> }
>>
http://mysites Updated from 425744 to 425744
http://mysites/personal/spadmin Updated from 588790 to 588790
http://portal Updated from 3249962 to 3249962
http://sspadmin/ssp/admin Updated from 642686 to 642686
http://sharepoint1:1234 Updated from 18284043 to 18284043
PS W:\>

Note that I used the SPBase property initially to get the current storage and then to call the RecalculateStorageUsed method. You then must dispose of this object. I then used the GetSPObject() method to get a new copy of the SPSite object because I can’t use the original copy as the usage data would be cached. I can now use this new object to get the new usage data which I then write to the host and then I’m free to dispose of the object. Also, because the SPSiteInfo objects that are returned by the Get-SPSite cmdlet do not require disposal you can easily pass the filter the results of that command before looping through the returned collection without worrying about disposing of items.

Tagged as: Cmdlets, Commands, MOSS, PowerShell, Site Collection, STSADM, WSS 7 Comments

21Dec/089

Initial Release of My SharePoint PowerShell Cmdlets

Update 4/25/2009: I’ve removed the “-gl” suffix from all my cmdlets - any examples using the -gl in the cmdlet name should be updated.

If you’ve been following my blog you’ll remember that I recently pushed out a “beta” build of some SharePoint PowerShell Cmdlets for some initial feedback and reviews. We’ll I’ve gone ahead and incorporated the feedback that I received and I am now officially releasing the first version of my cmdlets. The number of cmdlets has not changed from the beta build – they’ve just been cleaned up and enhanced. I will slowly start documenting each of the existing cmdlets (there are currently 11) and hopefully be adding new ones over time.

I’ve added links to the top of my blog for quick download of either the source code or the MOSS or WSS builds of the setup packages. At present there are no differences between the MOSS and WSS builds with the exception of my STSADM extensions which are included in the package and are a required dependency. I’ve also updated my main index page so that it now also includes the available PowerShell commands – just select what you would like to look at via the dropdown box:

To install the cmdlets download the MOSS or WSS installer from the links at the top of this page (or in the right-hand column). Once downloaded run the installer from your MOSS server using your MOSS admin account. You will see the following screens:

The initial welcome screen:
The EULA screen – you must accept to continue (you can find a copy for future reference in the install directory):
The install location – by default the files will be put at “C:\Program Files\Gary Lapointe\PowerShell Commands for SharePoint\”:
Optionally install my custom STSADM extensions – the extensions are a required pre-requisite but I make their install conditional so that if you have already installed the extensions you can avoid having to re-install them. This is particularly beneficial if you are installing the cmdlets on more than one machine in the farm – you only have to install the extensions in the farm once as they will be pushed out to all of the servers by SharePoint:
Confirm that you are ready to install:
The files are then installed

Once the installation has completed you will be presented with the contents of the ReadMe.rtf file (which can be found in the install directory). I’ve included the contents of that file below for reference:

To automatically load the snapin every time you start PowerShell create a shortcut to PowerShell passing in the -psconsolefile parameter like so:

%SystemRoot%\system32\WindowsPowerShell\v1.0\Powershell.exe –psconsolefile "C:\Program Files\Gary Lapointe\PowerShell Commands for SharePoint\Console.psc1"

The contents of the Console.psc1 file can be seen below.

<?xml version="1.0" encoding="utf-8"?>
<PSConsoleFile ConsoleSchemaVersion="1.0">
<PSVersion>1.0</PSVersion>
<PSSnapIns>
    <PSSnapIn Name="Lapointe.SharePoint.PowerShell.Commands" />
</PSSnapIns>
</PSConsoleFile>

Or run the following command or add the following command to your profile script:

    add-pssnapin -name "Lapointe.SharePoint.PowerShell.Commands"

To see the help file for any of the commands type the following (where -detailed and -full are optional):

    help <command name> [<-detailed | -full>]

For example, the following command will return the full help for the get-spsite command:

    help get-spsite -full

Here’s a quick demonstration showing some of the power of one of these cmdlets, the Get-SPSite cmdlet:

Looking at the example above you can see I was able to quickly get a list of all Site Collections using “$sites = get-spsite –url *”. I then output the results to the display to see what got returned. To get some different columns I then passed in the $sites variable to the Select-Object (select) cmdlet and had it return back the Url and Usage.Storage properties so that I can see the size of all the size collections in the farm. I could take this further and do some filtering if necessary but I’ll leave that exercise to you.

Keep an eye on my blog for more online documentation about each of the cm dlets along with lots of useful examples (hopefully ).

Tagged as: Cmdlets, Downloads, MOSS, PowerShell, WSS 9 Comments

26Nov/0810

My New PowerShell Cmdlets for SharePoint 2007: Feedback Requested!

Okay all you PowerShell superstars out there that have been using my STSADM commands - I need your help! I've decided to teach myself PowerShell and see if I can't leverage some of my STSADM experiences/code to expose some SharePoint functionality and I need some people who really know this PowerShell stuff to please take a look at what I've got so far and let me know if I'm way off base or not.

My initial stab includes 11 new cmdlets (10 Get and 1 Add):

Get-SPContentType-gl
Get-SPContentTypeUsages-gl
Get-SPFarm-gl
Get-SPField-gl
Add-SPList-gl
Get-SPList-gl
Get-SPSite-gl
Get-SPUserProfileManager-gl
Get-SPPrivacyPolicyManager-gl
Get-SPWeb-gl
Get-SPWebApplication-gl

The first thing you'll hopefully notice is that I've adopted a naming convention similar to what I did with my STSADM commands - I looked everywhere for best practices on naming custom cmdlets to avoid name clashes but couldn't find a darn thing (documentation for creating cmdlets is absolutely horrible!). What does everyone think of this approach? I tried to at least keep the verb-product+noun nomenclature so that you'd still be able to easily see all the get commands without having to also search -gl (so rather than gl-get-spfarm which would break a search for get-*).

I don't currently have help completed for all the commands, only a couple of them as I wanted to wait until I got some feedback before investing too much time in this. I guess I should first ask if people see the need for this? Am I wasting my time? I want to learn PowerShell either way so I'll create stuff regardless but I'd like to be able to share with the community for some mutual benefits.

So, if you know PowerShell and have time to play with what I've created thus far (take a look at the code too and see if I'm doing anything stupid) please feel free to download the source and installer:

Setup Package: Lapointe.SharePoint.PowerShell.Commands.Setup.msi
- I'm currently NOT including my custom STSADM extensions in the install package so you'll need to download and install those separately as they are a required dependency (see the links at the top of the page) - I may change this later so that the installer installs the STSADM extensions but I just don't want to have to worry about that at the moment (for now I'm just pushing out builds for both products at the same time).
Source Code: SPPoSH.zip
- Crack it open, be honest, be brutal, but please, be constructive

Keep in mind that this is just an initial "Alpha" release to see what people think - if you've followed my blog any or used my STSADM extensions then you can probably guess that there'll be a lot more of these cmdlets in the future so I want to make sure that I'm taking the right approach. Also - if you have any ideas for cmdlets that would be really helpful please let me know and I'll see if I can put something together as part of my learning exercise.

Thanks again to anyone who is able to help me out with this!

Update 12/14/2008: Based on feedback received (thanks Harley!) I've made one significant modification - the Get-SPSite-gl and Get-SPWeb-gl cmdlets now return back wrapper objects: SPSiteInfo and SPWebInfo, respectively. These wrapper objects allow the caller to not have to worry about calling Dispose() which is particularly useful when the results have been filtered. The Info objects contain virtually all the properties that their equivalent SP classes contain. You can still get to the actual object by calling the SPBase property or the GetSPObject().

Tagged as: Cmdlets 10 Comments

« Newer Entries

Need help with your SharePoint deployment or custom development? Contact Gary Lapointe at gary@aptillon.com

Check out the books I've contributed to at Amazon.com:

Copyright © 2007 – 2011 Falchion Consulting, LLC All rights reserved. Absolutely no portions of this websites content in text, images and or digital media format may be reproduced or re-transmitted in any form or media without the express written consent of Gary Lapointe.

SharePoint Automation Gary Lapointe – Founding Partner, Aptillon, Inc.

Working with SPWeb(Info) Objects Using PowerShell

Working with SPSite(Info) Objects Using PowerShell

Recalculating Usage Statistics via STSADM or PowerShell

Initial Release of My SharePoint PowerShell Cmdlets

My New PowerShell Cmdlets for SharePoint 2007: Feedback Requested!

Categories

Tags

Archives

Copyright © 2011