• Download .aspx from Pages doc lib, rename and re-upload.  All list view web parts are stripped during this process.
• Use the Send To option to make a copy of the .aspx in another folder or doc lib.  Same result as above – all web parts are stripped.
• Use the Content Structure view to copy the page.  Same result, web parts are stripped.

Finally I found a solution – although it’s a bit of a hack in my opinion: SharePoint Designer workflow.  The SPD workflow action “Copy List Item” will make a copy of a page and retain all web parts including list view web parts.  Here’s how you can accomplish this:

1. Open SPD, open your site, and create a new Workflow.  Call it “Copy Page” or something like that.
2. Target your Pages library (or wherever your web part pages live) for the workflow and specify that it should be started manually.
3. Add a single action:  Copy List Item.  When adding the list item, you can select “Current Item” for the page to copy, and then specify the target list as the same Pages library.

Now you’ll be able to start the Copy Page workflow on any page in your pages library.  When it creates a copy it simply appends the date and time to the file name so you won’t wind up over-writing the existing page.

With a little more work it should be possible to create an Initiation Variable for your workflow and rename the page as a part of the workflow.

Subversion is an excellent SCM tool – arguably the leading SCM tool available today. But with its roots firmly in the open source / linux community, there aren’t a lot of Windows-based applications for managing subversion.  Tools like VisualSVN server make it easy to install and configure Subversion, but it requires access to the server for management.  Web-based Subversion apps can be found, but they are often built in PHP and may not fit with a “Microsoft Shop’s” IT strategy.

Sublime was designed for exactly these reasons.  Sublime provides a web-based management tool for your Subversion infrastructure.  It allows users to browse and create repositories, manage permissions, and enable email alerts all from a simple web interface.  Server administrators can configure automated backups, manage users and groups, and monitor server health all from a web browser.  The Sublime installer will automatically install Subversion if required making the setup process extremely fast and simple.

Ultimately, Sublime makes it easy for dev teams to use Subversion without any bottlenecks.  Users don’t have to wait for IT to create repositories, users can manage their own password, repository owners can manage permissions, etc.  At the same time, IT has the ability to manage the server and ensure data is backed up all within a Windows-based environment they are familiar with.  Everybody’s happy

I’m super excited about this release.  If you use Subversion today, or are thinking of moving to Subversion from a different SCM tool (or *gasp* no SCM tool), then I would encourage you to take a look at the Sublime website for more information.

Okay.  Plug over.  We now return you to your regularly scheduled blog.

From what I’ve seen so far, many of these issues will be resolved with SharePoint 2010 and Visual Studio 2010.  I’m looking forward to digging into a real project so I can find out where the “gotchas” are (and I’m sure there will be plenty), but so far I’m optimistic.  I am hopeful that as a developer, I will be able to bring professional development techniques to all areas of a SharePoint project.

In my opinion this is critical if Microsoft wants to make SharePoint a true application development platform.

Event Type: Error
Event Source: Office SharePoint Server
Event Category: Publishing
Event ID: 5165
Date: 8/4/2009
Time: 12:57:51 PM
User: N/A
Computer: SERVER
Description:
Console Configuration File Error: File Not Found: The system cannot find the file specified. (Exception from HRESULT: 0×80070002)
For more information, see Help and Support Center at http://go.microsoft.com/fwlink/events.asp.

Googling for this error provides some information, but nothing definitive.  After turning up the logging level for the Publishing category, I was finally able to find enough information to locate the root cause.

This problem occurs when you are using a Master Page referencing SharePoint Publishing controls in a site collection that does not have the Publishing Infrastructure feature activated.  In my case, I was using a Master Page with the Publishing Console control on the page.  This Publishing Console was looking for some files in the Master Page gallery (_catalogs/masterpage/EditingMenu/CustomEditingMenu.xml etc) which don’t exist if the Publishing Infrastructure is not activated.  After I activated the Publishing Infrastructure, the errors went away.

However, ultimately the real solution was to remove the publishing features from the Master Page since I wasn’t using them anyway.

This problem came about when we re-used the master page from our main intranet on users’ My Sites.  Since the My Site doesn’t use the publishing features, every time someone hit a my site, these errors would show up in the event log.

DISCLAIMER: There are some unsupported steps here. Proceed at your own risk!

Step 1: Enable ssh access on your ESXi host. To do that, follow these steps (originally from this post).

NOTE: You actually don’t have to enable ssh for this, I just find it convenient to have remote access to the host machine.  If you don’t want to enable ssh, perform steps 1-3 below, then skip on to section 2.  When you reach section 3, rather than using ssh, you’ll just execute the commands directly on the host machine at the console.

1. From the console on your host (actually on the host machine – not using the Remote Client), press ALT-F1
2. Type in the text “unsupported” and press ENTER. Note: the text will not appear as you type.
3. Enter the root password
4. Enter the command

   vi /etc/inetd.conf

5. Find the line starting with “#ssh”. You can search by pressing / and then typing ssh and pressing Enter.
6. Once you’ve found that line, place the cursor on the # and press x. This should remove the # character.
7. Now type

   :wq!

   and press ENTER to save your changes.

8. Next you must restart the inetd process. To do that, you first need the process id. At the console, enter

   ps | grep inetd

   You should get something that looks like this:

   1273 1273 busybox      inetd

   In this case, 1273 is the process ID.  To kill the process enter kill -HUP <process id>.  So in this case, you would enter the following command:

   kill -HUP 1273

9. SSH is now enabled on your ESXi host machine. To test this you’ll need an ssh client. I’m using a mac so I can open terminal and enter the following command:

   ssh root@<myhost>

   If you’re using windows you may need something like PuTTY or Cygwin.

Step 2: Configure your backup datasource

Next you need to figure out where your backups will be stored.  It can be on the ESXi host if you like, but really it should be on a SAN or NAS or something like that.  I’m using a Netgear ReadyNAS NV+ and it works great.

1. Create a share where your backups will be stored and call it something like “backups”.  Make sure that anyone can read/write to this share.
2. Open the VMWare Infrastructure Client and connect to your host machine as root.
3. Go to the Configuration tab for the host and click Storage.
4. Click Add Storage… and create a new datastore pointing to the share you created in step 1.  Call this datastore something descriptive…  like “backups”

Step 3: Set up your backup script.

I found this great backup script.  It lets you specify the VMs you want to backup in a separate text file which makes it really easy to add new VMs to the rotation.  It also lets you keep a rotating number of VMs if you don’t want to over-write each backup daily.

1. Download the backup script.
2. Copy it to the same backup share you created in the last section.  You can create a directory called _scripts to keep it separate from the actual backups.
3. Open the script and customize the variables at the top.  In my case, all I had to modify was the VM_BACKUP_VOLUME variable.  If you named your datastore “backups” you can edit this line to look like this:

   VM_BACKUP_VOLUME=/vmfs/volumes/backups

    

4. Create a new text file in the same directory as the backup script called VMs.txt.  In this file enter the name of each VM you want to back up.  Each VM name should be on a new line.  Your file should look something like this:

   VM1
   VM2
   A_THIRD_VM

5. Connect to your host using ssh i.e. ssh root@<myhost>
6. Enter this command:

   vi /var/spool/cron/crontabs/root

7. Move the cursor to the very end of the file. Press a. This will enter edit mode.
8. Press Enter to create a new line and then add the following text:

   02 02 * * *  sh /vmfs/volumes/backups/_scripts/ghettoVCB.sh /vmfs/volumes/backups/_scripts/VMs.txt

   This will run the backup script at 2:02 AM every day. You can change the frequency or time of day if you like. This crontab reference is helpful.

9. At this point your entire file should look something like this:

    #syntax : minute hour day month dayofweek command
   01 01 * * * /sbin/tmpwatch.sh
   01 * * * * /sbin/auto-backup.sh #first minute of every hour (run every hour)
   00,10,20,30,40,50 * * * * /sbin/decodeSel.sh #Every 10 minutes, translate the latest IPMI SEL data
   02 02 * * *  sh /vmfs/volumes/backups/_scripts/ghettoVCB.sh /vmfs/volumes/backups/_scripts/VMs.txt
   

   If you are satisfied, press Escape.

10. Type the following command to save the file and exit::wq!
11. The backups are now scheduled

At this point, you now have backups scheduled to run every day at 2:02 AM. You can change which VMs are backed-up by editing the VMs.txt file you created. You could even set up multiple cron jobs with different backup frequencies, and different VMs.txt files to back up different VMs at different times.

Before finishing however, you might want to do a test run. If you are still connected to the host machine using ssh, enter the following command:

sh /vmfs/volumes/backups/_scripts/ghettoVCB.sh /vmfs/volumes/backups/_scripts/VMs.txt

IMPORTANT: This will take a while if you have large VMs. You may want to edit VMs.txt to target a single small VM as a test run. If it works for that, it should work for the rest.

One last thing. Unfortunately, the crontabs/root file isn’t saved after a reboot. In order to avoid adding the scheduled job after each reboot you may have to follow one of the techniques described here.

Taking this one step further, we might say that the quick save in a video game is like a commit in source control. Saving your game with a specific name is like creating a branch.

Let’s say I just finish taking out a whole horde of zombies (Left 4 Dead anticipation is infiltrating my blog).  I’ll probably do a quick-save to make sure I don’t have to re-play the same encounter again.  This is just like committing some code you just finished.  You’re saving your current progress to make sure you don’t have to re-write the same code twice.

Now, back to my game, what if I come to a fork in the road.  I can go left through the ominous looking sewer, or I can go right through the abandoned city.  Well at this point I’ll go and save my game with some sort of name like “Taking the sewer”.  That way I can continue playing, quick-saving as I go, but I can always get back to that fork if it turns out I made a mistake.

This is very similar to creating a branch in source control. You want to start working on something new, or something experimental, and you need to be able to save your progress as you go, but you always may need to go back to that original point.

I find that many developers wait too long to commit their changes.  The more frequently you commit, and the more organized you are about it, the less you have to worry about keeping track of every change you make.  This means you have left cruft floating around in your mind to remember and you can concentrate on writing good code.  I think if developers think about source control the same way they think about saving their game progress, it would help them get into the habit of committing frequently and branching appropriately.

This is very true – and in fact I have written tools like this in the past. But here’s the problem I’ve encountered with XML. You end up trying to build a programming language out of XML. That’s basically where CAML has ended up. And I don’t know a single person who actually enjoys looking at, much less creating, CAML.

Here’s what I like about the ruby approach. It let’s you write something like this:

site_names = ["Site One", "Site Two", "Site Three"]
at "http://localhost" do
  site_names.each do |name|
    create_web name, TeamSite
  end
end

Just the simple addition of an array of site names is something that would be hard to do in XML. What if you wanted to pull your information from a database? Or a file system? Or an Excel spreadsheet? For any of those you would have to write more logic into your XML mini-language – constructs like looping, conditionals, some mechanism to handle plug-ins for additional logic, etc. By leveraging an actual programming language, we get all of that for free.

Want to create 50 test sites? Here you go.

at "http://localhost" do
  50.times do |i|
    create_web "Site #{i}", BlankSite
  end
end

’nuff said.

Today I want to dream a little. Here are a few scripts I want RPoint to be able to support.

Creating a List Template

This script would create a list template.

class Milestones
  include ListTemplateMixin

  name "Milestones"
  description "A Simple Milestone List"

  column "Milestone", Text, :is_title => true, :required => true
  column "Description", RichText
  column "Date", Date, :required => true, :default => :today

  view "All Milestones" do
    show_columns "Milestone", "Date"
  end

  view "Overdue Milestones" do
    show_columns "Milestone", "Date"
    where :date => less_than(:today)
    order_by :date => :descending
  end
end

Once you had defined your template, you could use it in a few different ways. First, you could use it in a site creation script:

at "http://localhost" do
  create_list "My Milestones", Milestones
end

Second, and possibly cooler, you could generate a list definition:

>ir generate.rb list_definition --source MilestoneTemplate.rb

Migrations

Migrations in Rails is a great pre-defined structure for handling your database schema and changes to it over time. It may not be anything too ground-breaking on its own, but it enforces a discipline when it comes to managing your database. You are encouraged to think about situations where you want to change your database but data already exists. You can write scripts to migrate existing data to your new structure and it’s all managed within source control as an ordered list of steps to execute.

I want to be able to do something similar with RPoint.

# first migration - create my site collection
class CreateSiteMigration
  at :webapp => "http://localhost" do
    create_site "My Site", TeamSite
  end
end

# second migration - add a list and add a lookup to that list on an existing list
class AddIssuesMigration
  at "http://localhost/sites/mysite" do
    create_list "Issues", Issues
    update_list "Tasks" do
      add_column "Related Issue", Lookup("Issues", :field => :title)
    end
  end
end

Okay – that’s enough dreaming for now. Just incase anyone missed the intro THIS CODE DOES NOT WORK. It is completely imaginary. I am hoping that something along these lines will become reality. And I hope that you will agree that this would be a much nicer way to create SharePoint solutions than slogging through hundreds of lines of XML.

I think that SharePoint is in dire need of better tools to facilitate solution development, deployment, and maintenance. It is simply too difficult to build a site in one environment and then deploy it in production. Sure you can do backup and restore, but what about when you want to make some upgrades?

Anyway, this weekend I started working on an IronRuby-based DSL for SharePoint scripting. I’m calling it RPoint for now (until I think of something sexier!). Now, this is very very very early in development and I am sure things aren’t set up today as nicely as they should be long term, but I’ve been really excited by the progress and the possibilities.

RPoint will allow you to write code like this to create SharePoint sites:

# create a new subweb beneath an existing site
at "http://localhost" do
  create_web "New Web", TeamSite
end

# create a new site collection and website structure
at :webapp => "http://localhost" do
  create_site "New Site Collection", BlankSite, "domain\\user" do
    inside root_web do

      # create our site structure
      create_web "Child Web", TeamSite
      create_web "Another Child", BlankSite do
        create_web "Private Site", TeamSite, :inherit_permissions => false
      end

      # create a few lists
      create_list "Documents", DocumentLibrary
      create_list "Announcements", Announcements

    end
  end
end

I think that’s pretty cool. Beyond simply creating sites, RPoint will allow you to create lists, views and probably upload resources like images and documents.

My goals for RPoint are to be able to do the following:

• Easily write scripts to create site structures and lists
• Rails-like “Migrations” for applying changes to existing sites
• Custom site template and list definitions in ruby as opposed to XML
• Ability to run template/list definitions against a live site or generate schema.xml/onet.xml files for production deployment
• Support web-services automation as well as object model automation (this will be tough)

SharePoint is a huge product. The code-base is enormous and the aspirations for RPoint are lofty. I would greatly appreciate any assistance. The more hands there are to help, the sooner we will have a tool to make SharePoint development a little easier.

To get RPoint in its current form, you can download it from GitHub.

Here’s a quick guide to getting up and running with IronRuby and SharePoint.

Installation:

1. First, download the IronRuby release from Rubyforge.
2. Next, copy the ironruby folder you extract to your Program Files (put it wherever you like – that’s where I put mine).
3. Update your system’s PATH environment variable to contain the path to the ironruby\bin folder.  So if you placed it in your Program Files, you would add this to your PATH: c:\program files\ironruby\bin

Creating a Script:

Next you’ll want to create a new text file called print_sites.rb. I recommend the e text editor by the way – great tool.  Add the following lines to your file:

require 'System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL'
require 'Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c, processorArchitecture=MSIL'

Uri = System::Uri
SPSite = Microsoft::SharePoint::SPSite
SPWebApplication = Microsoft::SharePoint::Administration::SPWebApplication

Okay – what does that do? Well the first two lines are like adding a reference to a standard Visual Studio project. They tell IronRuby that we need to reference (require) the System and Microsoft.SharePoint assemblies. The next three lines are for convenience. They set up aliases to the System.Uri class and two SharePoint classes. In our ruby code, now we can just use Uri, SPSite, etc instead of having to type out the fully qualified path.

Next, let’s add some ruby code to enumerate all sites in a web application.

webapp = SPWebApplication.Lookup(Uri.new("http://localhost"))
webapp.Sites.each do |site|
  puts site.Url
end

(hmm, looks like I don’t actually need the SPSite alias after all)

Now, save your file. You can execute it like this:

> ir print_sites.rb

If everything is set up right, you should see the URL for each site collection be printed to the screen.

There you go. Have fun.