Jim @ imason : Toronto SharePoint Camp, SharePoint

NAnt, SharePoint and Production Deployments

James Schwartz — Tue, 03 Feb 2009 21:58:38 GMT

On my current SharePoint/InfoPath project, we’re using NAnt to deploy absolutely everything. NAnt creates SharePoint pages, imports web parts to pages, activates SharePoint features, deploys assemblies, creates SharePoint lists, creates/updates SQL databases (via DBDeploy), packages and deploys InfoPath forms, copies XSLT/XML/ASPX files, and much much more.

I always boast about how when a new developer comes on the project, he/she can have a fully operational SharePoint development environment within minutes. This is an important achievement, as most SharePoint Developers know it can be painful to automate deployments to SharePoint sites.

This works great for a Development environment, but what happens when you need to deploy to Production? Some companies don’t allow NAnt to be executed directly in Production, so you’ll need to setup your NAnt build files to execute on a build server to prepare for a Production deployment.

To achieve this, I went back into my NAnt build file and updated my NAnt targets to allow for the “preparation” of a deployment rather than actually performing the deployment. This provides us the ability to run NAnt on a build server in order to package everything for an easy automated deployment in Production (without NAnt).

I’m leveraging Windows Installer XML (WiX) in order to package the deployment files into MSI packages (In a future post I’ll get into more detail about using WiX MSI’s for SharePoint deployments). For SharePoint feature installation/activations and InfoPath form deployments I’m generating a batch file from NAnt that gets packaged into the MSI and executed when the MSI is installed on the server.

First we prepare the batch files – this will create 3 new empty batch files with a line “ECHO OFF” inside them:

        1: <target name="PrepareBatchFiles"> 

       2:     <echo file ="${featuresDeployment.cmd}" append="true" message="ECHO OFF" /> 

       3:     <echo file ="${formsDeployment.cmd}" append="true" message="ECHO OFF" /> 

       4:     <echo file ="${dataConnectionsDeployment.cmd}" append="true" message="ECHO OFF" /> 

       5: </target>

Next, we append STSADM calls to the batch files – anytime we call STSADM from NAnt, we will add a row into the batch file. Here’s an example when we’re calling the “UploadForm” NAnt target:

       1: <target name="UploadFormTemplate" description="Uploads an InfoPath Form">

       2:     <choose>

       3:         <when test="${prepareDeployment=='true'}">

       4:             <echo file="${formDeploymentBatchFile}" append="true" message="echo Attempting to upload form template '${formName}.xsn'" />

       5:             <echo file="${formDeploymentBatchFile}" append="true" message="${stsadm.exe} -o uploadformtemplate -filename &quot;${deploymentFolder}\Forms\${formName}.xsn&quot;" />

       6:         </when>

       7:         <otherwise>

       8:             <exec program="${stsadm.exe}">

       9:                 <arg line="-o uploadformtemplate" />

      10:                 <arg line="-filename &quot;${publishedFormsFolder}${formName}.xsn&quot;" />

      11:             </exec>

      12:         </otherwise>

      13:     </choose>

      14: </target>

You can see from the NAnt target above that it checks whether we’re “Preparing” a deployment or if we’re actually deploying. If we’re preparing the deployment, it will generate batch files and copy files to a deployment folder. I’ve added the “choose –> while” condition into each NAnt target so that I can prepare my deployment files for the MSI.

The generated batch file will look something like this:

       1: SET STSADM=C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BIN\STSADM.exe

       2: ECHO OFF

       3: "%STSADM%" -o deactivateformtemplate -url http://sharepoint-serv -filename "C:\MyForms\MyInfoPathForm.xsn"

       4: "%STSADM%" -o removeformtemplate -filename "C:\MyForms\MyInfoPathForm.xsn"

       5: "%STSADM%" -o execadmsvcjobs

       6: ECHO Attempting to upload form template 'MyInfoPathForm.xsn'

       7: "%STSADM%" -o uploadformtemplate -filename "C:\MyForms\MyInfoPathForm.xsn"

       8: "%STSADM%" -o execadmsvcjobs

       9: "%STSADM%" -o activateformtemplate -url http://sharepoint-serv -filename "C:\MyForms\MyInfoPathForm.xsn"

Now when I add a new form to be deployed, it will be automatically added to the batch file for the Production deployment. The end result is that I can run my NAnt scripts on a development environment to actually deploy my SharePoint components, or I can run the same batch scripts on a Production server via an MSI package.

Advanced InfoPath Development with SharePoint

James Schwartz — Sun, 25 Jan 2009 15:13:00 GMT

Thanks to everyone who made it out to our Advanced InfoPath Development session yesterday at the Toronto SharePoint Camp. We had quite a good turnout; so I’m glad to see there are lots of other people out there using browser-based InfoPath forms using Forms Services on SharePoint.

InfoPath makes it easy to quickly develop forms, but it doesn’t come without its limitations. It’s very heavy on JavaScript, thus performance isn’t great when you have a lot of fields and rules. It doesn’t support multilingual, and it’s not very good at field validation. In this session we showed the audience how to get around these limitations by writing some simple C# code.

I’ve posted the PowerPoint slides as well as the source code for the InfoPath form, the Web Service, the Web Part, and the NAnt XML build definition.

If you’re interested in learning more about NAnt, send me an e-mail because I’m thinking about organizing a NAnt lunch and learn session at the imason office open to all Developers. We’re located in downtown Toronto on Adelaide Street near Peter St.

Download the source code (SharePointCamp.zip), and PowerPoint slides (SharePointCamp-2009.pptx) here.

Toronto SharePoint Camp 2009

James Schwartz — Thu, 22 Jan 2009 02:18:00 GMT

On Saturday, January 24th, four of us from imason will be presenting at the 2009 Toronto SharePoint Camp at the Manulife Corporate Headquarters @ 200 Bloor St. East. If you’d like to come out to see our sessions, register here. There will be lots of free giveaways and prizes. Here are some details about our sessions:

Upgrading your SharePoint platform from WSS 2.0 to WSS 3.0/MOSS 2007

Bob Brown

Time: 9:00 AM to 10:15 AM Room: Holmes B

With SharePoint 2007 taking on widespread adoption, many enterprises are starting to take advantage of the new and improved features of the new platform; but what about administrators and developers that are still supporting a growing business critical SharePoint 2003 environment and have been assigned the daunting task of upgrading? There seems to be an endless list of things to take into account before taking the plunge and upgrading.

In this session, I will walk through how to assess your system to make an educated migration path decision, draw up the high level upgrade steps, and then dig in on some specific snags you'll likely encounter (including custom web parts, FrontPage and unghosted pages, broken permissions, site themes, and legacy templates)

Advanced InfoPath development with SharePoint

Jim Schwartz & Boyan Tsolov

Time: 2:30 PM to 3:45 PM Room: International B&C

InfoPath 2007 has many limitations and doesn’t scale very well with complex forms. Using a custom solution built on SharePoint, we’ve extended InfoPath to support very complicated form functionality. In this session, we will describe to you how we overcame several InfoPath limitations, including multilingual support, pre-populating form data, field validation, and support a flow between several forms.

Effective Deployment of SharePoint Publishing Sites

Ivan Neganov

Time: 4:00 PM to 5:15 PM Room: Holmes B

SharePoint implementation presents many challenges to development teams with deployment often viewed as an area of the primary complexity and importance.

Over time we have accumulated a rich set of utilities which allow deploying SharePoint sites in a fully unattended fashion or close to it, by using custom logic interacting with SharePoint API.

Efficiency of deployment has a dramatic impact on practical aspects of agile and team development using SharePoint, which makes us invest in building comprehensive tools for SharePoint deployment.

Automated Publishing of InfoPath Forms (Part 2 of 2)

James Schwartz — Tue, 19 Aug 2008 20:31:00 GMT

We’ve now surpassed 50 InfoPath forms on the InfoPath 2007 / SharePoint 2007 project I’m currently engaged on. If you’ve done InfoPath/SharePoint development before, you’ll know that it can be really painful to publish forms and then deploy them to SharePoint.

In Part 1 of this 2 blog series, I showed you how to automate the deployment of InfoPath forms to SharePoint using NAnt. This time around I’ll show you how to automate the publishing of an InfoPath form.

If you’ve published an InfoPath form to an Administrator-approved form template before, you’ll be all too familiar with the process of clicking next a whole bunch of times in order to publish the form. Why should you have to go through all these manual steps every time you make a change to a form?

To automate this, I first found some VB code on this blog article to publish a form. I then converted it to C#, and built it as a custom NAnt task. So now I can publish a form by simply calling a custom NAnt task like this:

In order to use this approach, you’ll need to either build your InfoPath form using the Visual Studio template, or you’ll need to extract the form source files from the XSN. To extract the source files from the XSN, choose “File” -> “Save As Source Files”. Then you can work with your form template by right clicking on “manifest.xsf” and choosing “Design”.

Here is the code to build the custom NAnt task:

using System;

using System.Diagnostics;

using System.IO;

using System.Xml;

using NAnt.Core;

using NAnt.Core.Attributes;

namespace My.Build.Tasks

{

[TaskName("publishform")]

public class PublishFormTask : Task

{

[TaskAttribute("outputfolder", Required = true)]

public string OutputFolder { get; set; }

[TaskAttribute("formname", Required = true)]

public string FormName { get; set; }

[TaskAttribute("cabsdkpath", Required = true)]

public string CabSdkPath { get; set; }

[TaskAttribute("xsffilename", Required = true)]

public string XsfFileName { get; set; }

[TaskAttribute("formsourcepath", Required = true)]

public string FormSourcePath { get; set; }

protected override void ExecuteTask()

{

string makeCabPath = CabSdkPath + "\\MAKECAB.EXE";

BuildCabFile(makeCabPath);

}

private void BuildCabFile(string makeCabExe)

{

try

{

if (!File.Exists(makeCabExe))

{

throw new Exception(string.Format("CABSDK not found. Please check your CABSDK property value. Couldn't find makecab.exe @ '{0}'", makeCabExe));

}

var tempName = Path.GetFileNameWithoutExtension(Path.GetTempFileName());

//var tempName = Path.GetTempFileName();

var tempFolder = Path.GetTempPath();

var tempPath = PathCombine(tempFolder, tempName);

var ddfString = string.Empty;

ddfString += ".Set DiskDirectoryTemplate='" + tempFolder + "'" + Environment.NewLine;

ddfString += ".Set CabinetNameTemplate='" + tempName + "'" + Environment.NewLine;

var xsfDom = new XmlDocument();

xsfDom.Load(PathCombine(FormSourcePath, XsfFileName));

var nm = InitNamespaceManager(xsfDom);

ddfString += QuoteString(PathCombine(FormSourcePath, XsfFileName)) + Environment.NewLine;

var fileNodes = xsfDom.SelectNodes("/xsf:xDocumentClass/xsf:package/xsf:files/xsf:file/@name", nm);

for (int i = 0; i <= fileNodes.Count - 1; i++)

{

ddfString += QuoteString(PathCombine(FormSourcePath, fileNodes[i].InnerText)) + Environment.NewLine;

}

var ddfPath = PathCombine(tempFolder, "makecab.ddf");

SaveToFile(ddfString, ddfPath);

ShellExecute(QuoteString(makeCabExe), "/V1 /F " + QuoteString(ddfPath));

File.Delete(ddfPath);

if (File.Exists(PathCombine(OutputFolder, FormName)))

{

File.Delete(PathCombine(OutputFolder, FormName));

}

File.Move(tempPath, PathCombine(OutputFolder, FormName));

string[] oScratchFiles = new string[] { "setup.inf", "setup.rpt" };

foreach (string strScratchFile in oScratchFiles)

{

if (File.Exists(strScratchFile))

{

File.Delete(strScratchFile);

}

catch (Exception ex)

{

throw new Exception("Could not create XSN file from files.", ex);

}

private static void SaveToFile(string data, string filePath)

{

var fs = File.Create(filePath);

fs.Close();

var TextStream = new StreamWriter(filePath);

TextStream.Write(data);

TextStream.Flush();

TextStream.Close();

}

private static void ShellExecute(string command, string args)

{

var info = new ProcessStartInfo(command, args);

info.UseShellExecute = false;

var process = Process.Start(info);

process.WaitForExit(60000);

}

private static string QuoteString(string s)

{

return "\"" + s + "\"";

}

private static string PathCombine(string folder, string fileName)

{

return Path.Combine(folder, fileName);

}

public static XmlNamespaceManager InitNamespaceManager(XmlDocument xmlDOMDoc)

{

XmlNamespaceManager xnmMan;

xnmMan = new XmlNamespaceManager(xmlDOMDoc.NameTable);

foreach (XmlAttribute nsAttr in xmlDOMDoc.DocumentElement.Attributes)

{

if (nsAttr.Prefix == "xmlns")

xnmMan.AddNamespace(nsAttr.LocalName, nsAttr.Value);

}

return xnmMan;

}

public void RunTask()

{

ExecuteTask();

}

How to Deploy InfoPath 2007 Forms with NAnt (Part 1 of 2)

James Schwartz — Thu, 24 Jul 2008 05:13:00 GMT

I've been using NAnt a lot lately for deploying components to development and integration machines. The common misconception that I've heard from reluctant SharePoint folks around here is that we should be packaging SharePoint solutions in WSP (SharePoint solution files) instead of deploying components with NAnt. That's all great, I'm totally pro-WSP and all, but the thing people don't realize is that whether or not you're using WSP files, NAnt still compliments SharePoint deployments very well.

Even if I'm simply running STSADM commands, I would still use NAnt instead of writing batch files. NAnt can do so much more than WSP files are capable of doing such as: Modifying data in Web.Config files (xmlpeek/xmlpoke), creating Virtual Directories on your IIS site (mkiisdir), copying files (copy), etc.

One use I've found for NAnt is to deploy an InfoPath 2007 form to Central Administration and activate to my site collections, and adding Data Connection Library (.udcx) files to Central Administration. It was always a hassle to do that manually, and batch files are so 1980's.

So here is some NAnt XML that I've written to deploy InfoPath forms and Data Connections:

</target>

</exec>

</exec>

</exec>

</exec>

</exec>

</exec>

</target>

</target>

</exec>

</target>

You’ll notice I had to make a copy of the data connection before I could deploy it. This is because the file was read only when it’s checked in source control, so I needed to make a copy and take off the read only attribute using the NAnt attrib task before I could upload the file (Otherwise STSADM will complain).

Now you can call NAnt to deploy all of your forms at once, or you could specify an individual form by calling: “nant.bat –DeployForm –D:formName=MyFormName.xsn” or “nant.bat –DeployDataConnection –D:dataConnectionFile=MyDataConnection.udcx”.

Happy NAnting!