mylifeinaminute.com » TechNet

SharePoint 2010 Products scripted deployment

liquidpooled — Tue, 06 Jul 2010 18:36:27 +0000

It seems I missed it when Microsoft published the SPModule PowerShell module to aid in a scripted installation of a SharePoint 2010 farm.

If anything, it can serve as a handy guide for how to script out individual actions pertaining to installation and farm maintenance.

Reference

stsadm, Site Collection Restore, and the “File Not Found” error

liquidpooled — Thu, 20 May 2010 14:46:53 +0000

Restoring site collections with stsadm is normally a straightforward affair, requiring little to no manual intervention to get things back up and running. That is of course, unless you are restoring sites based on the Publishing Site template.

I recently wanted to take an existing site collection, make a copy of it in the same web application under a newly created managed path and have it reside in a new content database. The backup went smooth, utilizing stsadm -o backup. The creation of the new managed path went off without a hitch. The creation of a new content database and the restoration of the site collection into that database also occurred with no issues.

Browsing the site however told a different story. I was immediately greeted with a standard error page stating “File Not Found”. Browsing to other pages within the site (eg. “/_layouts/settings.aspx“) yielded the same result. After turning on the callstack/debugging and disabling the custom error page, I was greeted with the following:

The problem? Each publishing page points to an incorrect page layout after the restoration. One would think that the restore via stsadm would recognize this and fix it, but it does not.

The fix? The stsadm extensions published by Gary Lapointe. The package built by Gary offers a command call gl-fixpublishingpagespagelayouturl. Verbose? Yes. Does it work? Absolutely.

After running the command and executing an iisreset, the site was once again able to be browsed and appears to be intact.

Reference

SharePoint 2010: Provisioning a new Farm with Powershell

liquidpooled — Mon, 17 May 2010 13:45:25 +0000

SharePoint 2007 always required some level of scripting in it’s installation to allow for greater control of the installation process (i.e. creating database names without GUIDs). SharePoint 2010 is not any different in that scripting is still required to gain the finer control over installation. What has changed is that now PowerShell can be used in place of psconfig/stsadm. With that in mind, let’s begin.

Install the SharePoint binaries on each server in your farm. Select “Complete” as the installation type. This will allow you to create a farm as opposed to a single server installation.After the install has completed, you will asked if you would like to complete the “SharePoint Products Configuration Wizard”. Do not run the wizard at this time.
On the server which you wish to provision Central Administration:
1. Open the ”SharePoint 2010 Management Shell” (right-click and select “Run as administrator”). The shell will load with a message that the local farm is not accessible. This is expected as we have only installed the binaries.
2. Run the following command to create the initial configuration/content database for the farm.
```
New-SPConfigurationDatabase –DatabaseName “SharePoint2010_Config” –DatabaseServer “SharePoint2010SQL” –AdministrationContentDatabaseName “SharePoint2010_Content_Admin” –Passphrase (ConvertTo-SecureString “Pass@word1” –AsPlaintext –Force) –FarmCredentials (Get-Credential)
```
3. After the initial creation of the farm, close and reload the “SharePoint 2010 Management Shell”. You should no longer receive any error messages.
4. Install the help files.
```
Install-SPHelpCollection -All
```
5. Secure the resources used by the server (files and registry).
```
Initialize-SPResourceSecurity
```
6. Install and provision the farm services.
```
Install-SPService
```
7. Install the features on the server.
```
Install-SPFeature –AllExistingFeatures
```
8. Provision Central Administration.
```
New-SPCentralAdministration -Port 1234  -WindowsAuthProvider "NTLM"
```
9. Install the application content.
```
Install-SPApplicationContent
```
10. Optional: Disable the loopback check. If this is a development install, outright disabling the check should be fine. For production environments, the loopback check should be left in place and BackConnectionHostNames should be used in its place. See KB 896861.
```
New-ItemProperty HKLM:\System\CurrentControlSet\Control\Lsa -Name "DisableLoopbackCheck"  -value "1" -PropertyType dword
```
On each additional server that you wish to converge in the farm:
1. Open the ”SharePoint 2010 Management Shell” (right-click and select “Run as administrator”). The shell will load with a message that the local farm is not accessible. This is expected as we have only installed the binaries.
2. Connect the server to the farm with the following command:
```
Connect-SPConfigurationDatabase -DatabaseName "SharePoint2010_Config" -DatabaseServer "SharePoint2010SQL" -Passphrase (ConvertTo-SecureString "Pass@word1" -AsPlaintext -Force)
```
3. Install the help files.
```
Install-SPHelpCollection -All
```
4. Secure the resources used by the server (files and registry).
```
Initialize-SPResourceSecurity
```
5. Install and provision the farm services.
```
Install-SPService
```
6. Install the features on the server.
```
Install-SPFeature –AllExistingFeatures
```
7. Install the application content.
```
Install-SPApplicationContent
```
8. Optional: Disable the loopback check. If this is a development install, outright disabling the check should be fine. For production environments, the loopback check should be left in place and BackConnectionHostNames should be used in its place. See KB 896861.
```
New-ItemProperty HKLM:\System\CurrentControlSet\Control\Lsa -Name "DisableLoopbackCheck"  -value "1" -PropertyType dword
```

Reference

‘TRUNCATE_ONLY’ IS not a recognized BACKUP OPTION.

liquidpooled — Wed, 12 May 2010 13:35:30 +0000

Microsoft has completely removed the BACKUP LOG WITH TRUNCATE_ONLY capability completely from SQL Server 2008. If you try to attempt to execute the following command:

BACKUP LOG AdventureWorks WITH TRUNCATE_ONLY

This is the result:

'TRUNCATE_ONLY' IS not a recognized BACKUP OPTION.

To circumvent this error in a DEVELOPMENT environment (not Production), use the following commands:

USE AdventureWorks
GO
ALTER DATABASE AdventureWorks SET RECOVERY SIMPLE
DBCC SHRINKFILE(N'AdventureWorks_log', 1)
ALTER DATABASE AdventureWorks SET RECOVERY FULL
GO

One should never execute the above commands in a Production environment unless you wish to lose all of your prior transaction log backups and the ability to restore to a given point in time based on those backups.

Reference

DBCC SHRINKFILE (Technet)

New to SharePoint? Administrator’s Guide of Topics to Consider before Deployment

liquidpooled — Wed, 14 Jan 2009 14:01:39 +0000

The SharePoint documentation team at Microsoft is at it again, this time posting a new white paper called “Administrator’s Guide of Topics to Consider before Deployment“.

[Via To The SharePoint]

Fixing Absolute URLs in a Content Editor Web Part

liquidpooled — Wed, 24 Dec 2008 15:00:24 +0000

Maxime Bombardier has a post on the subject of fixing one of the bigger issues with the Content Editor web part. For the uninitiated, a Content Editor web part always renders absolute URLs when the rich-text editing capabilities are used. I must admit that I would have never have thought to use a control adapter to manipulate the output of the web part on the fly. Now that I have learned something new, you should too.

Go check it out.

Updating User Profile Properties for the Current User

liquidpooled — Tue, 16 Dec 2008 16:46:48 +0000

Updates to a user’s profile properties can be performed with the following:

SPSite site = SPContext.GetContext(HttpContext.Current).Site;
                ServerContext serverContext = ServerContext.GetContext(site);

                UserProfileManager profileManager = new UserProfileManager(serverContext);
                UserProfile currentUserProfile = profileManager.GetUserProfile(System.Web.HttpContext.Current.User.Identity.Name);

                if (this.chkTerms.Checked)
                    currentUserProfile["TermsOfUseAccepted"].Value = "true";
                else
                    currentUserProfile["TermsOfUseAccepted"].Value = "false";

                currentUserProfile["SecurityQuestion1"].Value = this.lstQuestion1.SelectedItem.Text + "|" + Server.HtmlEncode(this.txtQuestion1Ans.Text);
                currentUserProfile["SecurityQuestion2"].Value = this.lstQuestion2.SelectedItem.Text + "|" + Server.HtmlEncode(this.txtQuestion2Ans.Text);
                currentUserProfile["SecurityQuestion3"].Value = this.lstQuestion3.SelectedItem.Text + "|" + Server.HtmlEncode(this.txtQuestion3Ans.Text);

                currentUserProfile.Commit();

                site.RootWeb.Dispose();
                site.Dispose();

Retrieving User Profile Properties for the Current User

liquidpooled — Tue, 16 Dec 2008 16:42:10 +0000

Retrieving a user’s profile properties can be achieved with the following block:

SPSite site = SPContext.GetContext(HttpContext.Current).Site;
            ServerContext serverContext = ServerContext.GetContext(site);

            UserProfileManager profileManager = new UserProfileManager(serverContext);
            UserProfile currentUserProfile = null;

            if (profileManager.UserExists(System.Web.HttpContext.Current.User.Identity.Name))
                currentUserProfile = profileManager.GetUserProfile(System.Web.HttpContext.Current.User.Identity.Name);
            else
                currentUserProfile = profileManager.CreateUserProfile(System.Web.HttpContext.Current.User.Identity.Name);

            string termsOfUseAnswered = (string)currentUserProfile["TermsOfUseAccepted"].Value;
            string securityQuestion1 = (string)currentUserProfile["SecurityQuestion1"].Value;
            string securityQuestion2 = (string)currentUserProfile["SecurityQuestion2"].Value;
            string securityQuestion3 = (string)currentUserProfile["SecurityQuestion3"].Value;

Note that this buids on Creating Custom Profile Properties Through Code.

Creating Custom Profile Properties through Code (C#)

liquidpooled — Tue, 16 Dec 2008 16:27:21 +0000

I recently needed to add several custom profile properties through a web part for tracking a users’ security preferences for a particular web application.

The following is the method used to create four new properties in the SSP:

private void VerifyCreateBaseProfileProperties()
        {
            SPSite site = SPContext.GetContext(HttpContext.Current).Site;
            Guid siteId = site.ID;
            HttpContext savedContext = HttpContext.Current;

            SPSecurity.RunWithElevatedPrivileges(delegate()
            {
                using (SPSite elevatedSite = new SPSite(siteId))
                {
                    try
                    {
                        HttpContext.Current = null;

                        elevatedSite.AllowUnsafeUpdates = true;
                        elevatedSite.RootWeb.AllowUnsafeUpdates = true;

                        ServerContext serverContext = ServerContext.GetContext(elevatedSite);

                        UserProfileManager profileManager = new UserProfileManager(serverContext);
                        UserProfileConfigManager profileConfigManager = new UserProfileConfigManager(serverContext);
                        PropertyCollection propertyCollection = profileConfigManager.GetProperties();

                        bool question1Exists = false;
                        bool question2Exists = false;
                        bool question3Exists = false;
                        bool termsOfUseExists = false;

                        foreach (Property property in profileManager.Properties)
                        {
                            switch (property.Name)
                            {
                                case "SecurityQuestion1":
                                    question1Exists = true;
                                    break;
                                case "SecurityQuestion2":
                                    question2Exists = true;
                                    break;
                                case "SecurityQuestion3":
                                    question3Exists = true;
                                    break;
                                case "TermsOfUseAccepted":
                                    termsOfUseExists = true;
                                    break;
                            }
                        }

                        if (!question1Exists)
                        {
                            Property question1 = propertyCollection.Create(false);
                            question1.Name = "SecurityQuestion1";
                            question1.DisplayName = "Security Question 1";
                            question1.Type = "string";
                            question1.PrivacyPolicy = PrivacyPolicy.OptIn;
                            question1.DefaultPrivacy = Privacy.Private;
                            question1.Description = "Security Question 1";
                            question1.IsSearchable = false;
                            question1.IsVisibleOnEditor = false;
                            question1.IsAlias = false;
                            question1.Length = 100;
                            question1.IsUserEditable = true;
                            propertyCollection.Add(question1);
                        }
                        if (!question2Exists)
                        {
                            Property question2 = propertyCollection.Create(false);
                            question2.Name = "SecurityQuestion2";
                            question2.DisplayName = "Security Question 2";
                            question2.Type = "string";
                            question2.PrivacyPolicy = PrivacyPolicy.OptIn;
                            question2.DefaultPrivacy = Privacy.Private;
                            question2.Description = "Security Question 2";
                            question2.IsSearchable = false;
                            question2.IsVisibleOnEditor = false;
                            question2.IsAlias = false;
                            question2.Length = 100;
                            question2.IsUserEditable = true;
                            propertyCollection.Add(question2);
                        }
                        if (!question3Exists)
                        {
                            Property question3 = propertyCollection.Create(false);
                            question3.Name = "SecurityQuestion3";
                            question3.DisplayName = "Security Question 3";
                            question3.Type = "string";
                            question3.PrivacyPolicy = PrivacyPolicy.OptIn;
                            question3.DefaultPrivacy = Privacy.Private;
                            question3.Description = "Security Question 3";
                            question3.IsSearchable = false;
                            question3.IsVisibleOnEditor = false;
                            question3.IsAlias = false;
                            question3.Length = 100;
                            question3.IsUserEditable = true;
                            propertyCollection.Add(question3);
                        }
                        if (!termsOfUseExists)
                        {
                            Property termsofUsequestion = propertyCollection.Create(false);
                            termsofUsequestion.Name = "TermsOfUseAccepted";
                            termsofUsequestion.DisplayName = "Terms Of Use Accepted";
                            termsofUsequestion.Type = "string";
                            termsofUsequestion.PrivacyPolicy = PrivacyPolicy.OptIn;
                            termsofUsequestion.DefaultPrivacy = Privacy.Private;
                            termsofUsequestion.Description = "Terms Of Use Accepted";
                            termsofUsequestion.IsSearchable = false;
                            termsofUsequestion.IsVisibleOnEditor = false;
                            termsofUsequestion.IsAlias = false;
                            termsofUsequestion.Length = 10;
                            termsofUsequestion.IsUserEditable = true;
                            propertyCollection.Add(termsofUsequestion);
                        }
                    }
                    catch (Exception exc)
                    {
                    }
                    finally
                    {
                        elevatedSite.Dispose();
                    }
                }
            });

            site.Dispose();
            HttpContext.Current = savedContext;
        }

Note that the current context (HttpContext.Current) needs to be saved off, set to null, then reinstated upon the completion of the method.

WSRP Toolkit for SharePoint

liquidpooled — Tue, 16 Dec 2008 13:46:27 +0000

The Microsoft SharePoint Product Group has just announced the WSRP Toolkit for SharePoint. What is WSRP? From OASIS:

WSRP defines a set of interfaces and related semantics which standardize interactions with components providing user-facing markup, including the processing of user interactions with that markup. This allows applications to consume such components as providing a portion of the overall user application without having to write unique code for interacting with each component.

Videos: