Converting from Parallels to Hyper-V

You would think converting a virtual machine from one format to another would be simple. Especially when there are multiple blogs out there on how to do it. But, of course not – so time for another misadventure in computing post. I was asked by a colleague to get a copy of a demo virtual machine for some upcoming analyst activities. The problem: my colleague’s system is a Surface 2 Pro running Hyper-V on Windows 8.1. And the source system was a personal Retina MacBook Pro running Parallels 9. And the VM is running Windows Server 2012 R2.

The core issue was that the source image in Parallels was a virtual UEFI system with a GPT partition table. The destination image was a Gen 1 Hyper-V VM with a virtual BIOS, which necessitates a MBR partition table. (I was unable to get the Gen 2 Hyper-V VM that supports UEFI to work given the differences in hardware drivers.) 

The first problem is actually converting the disk file itself, as they are in very different formats. And the steps of using VMWare and VirtualBox utilities to do the conversion did not work – I ended up with a corrupt virtual hard disk (probably because of this GPT issue). 

So to do this, I found the awesome Disk2VHD utility from SysInternals ( With this utility, I ran it and chose not to grab anything except the C:\ partition and voila – I created a new VHD that I was able to load up on my Hyper-V server and at least not have corruption.

Then, the fun of trying to get it to boot began. The normal way to fix a modern Windows system that will not boot is:

  • Boot from Windows installation image
  • Go to Command Prompt
  • Enter the following commands:
    • “bootrec /fixmbr”
    • “bootrec /fixboot”
    • “bootrec /scanos”
    • “bootrec /rebuildbcd” – except this critical last step fails because the partition table is not MBR.

So, you have to convert the partition table to MBR. And that’s where life gets interesting. After trial and error, I found the following to be the best way to do this without losing data:

  • Download the latest Live x86_x64 Fedora image from Yes, you really need a live Linux image because of a really handy utility called gdisk.
  • Boot the VM with the Fedora Live image and login to the desktop.
  • Run the Terminal utility.
  • Then, run the following commands:
    • “su -” – get into administrator mode
    • “yum -y install gdisk” – actually install the gdisk utility
    • “gdisk /dev/sda” – start running gdisk against the virtual hard drive
    • “r” – to enter gdisk recovery/transformation mode
    • “g” – to convert from GPT to MBR
    • “p” to preview the converted MBR partition table
    • “w” – to write changes to disk.
  • At this point, the VM can be rebooted with Windows installation media to get to a Command Prompt to fix the rest of the problems. Once there:
    • “diskpart” – enters the Windows disk partition utility
    • “select disk 0” – selects the boot drive
    • “list partition” – should show the disk partitions present. The largest one is the actual one that you want to boot. It is probably going to be the third or forth partition on the disk. In my case it was the fourth.
    • “select partition 4” – select the partition we want to boot.
    • “active” – to mark the partition as active in MBR.
    • “exit” – to exit diskpart
  • The next step is to find the actual disk itself – it is probably going to be D:\ (at least it was on my system) because of the reserved GPT partitions in advance of the actual usable partition. Once you determine the drive letter, you can proceed as follows:
    • “bootsect d: /nt52 /force /mbr” – makes D: bootable.
    • “bootrec /fixboot” – fixes core startup environment
    • “bootrec /fixmbr” – fixes core startup environment
    • “bootrec /scanos” – find the OS; note it will probably be D:\Windows in my example (and this is OK)
    • “bootrec /rebuildbcd” – update the BCD environment; note it will be D:\Windows in my example (and this is OK)
  • At this point the system can be rebooted without any installation media – and it should just boot up with everything in C:\Windows\ as it should be. Once booted:
    • Uninstall Parallels Tools
    • Install Hyper-V Integration Services (if required – not applicable on this system since Windows Server 2012 R2 has them built-in)
    • Reactivate Windows

And voila! I hope this helps.




Out of Pseudo-Stealth Mode

To summarize the last twelve months: wow!

Since the acquisition of Cactus Commerce by Ascentium, a big part of my day job was working on integrating the two businesses into a new brand and value proposition. This finally came to fruition with the launch of the SMITH brand a few weeks back, along with the retirement of Cactus Commerce and Ascentium brands. Check out to see the results!

But, the real focus has been capitalizing on the opportunity with the transition of the Commerce Server business. The last year has seen us extracting the product from Redmond; re-branding it; doing lots of 1×1 engagement with customers, partners, & analysts; and now debuting what’s next…

Last Friday brings the Release Preview of Commerce Server 10, which addresses being CMS-agnostic and the challenge of proper separation of business and presentation logic to allow HTML/CSS/JavaScript designers to make look-and-feel changes. Likewise, our new brand – – debuted, which sees the right management structure and branding to effectively curate the global partner ecosystem for the product.

The initial reactions have been very positive – nothing like Peter Sheldon’s excellent post from Forrester Research to sum it all up:

These changes have been a long time coming. We had to get it right. And with them finally seeing the light of day, I can finally come out of pseudo-stealth mode. 🙂

And to add ANOTHER adventure…

As if being acquired, a new job, and an international move were not enough, let’s just add getting the helm of Commerce Server back. No, that’s not a mis-print, as captured by:

This certainly was almost as much of a surprise to us (and has been only a short time that we have known) as I am sure it is to customers. However, this is one challenge I relish – as the opportunity is great to truly take the product now, evolve it into what customer’s want and need, and do so free of the many constraints under which it has been placed in the past…

Demo Hell – thank you SharePoint 2010

I just built a demo system for presenting Commerce Server 2009 R2 CTP on top of SharePoint 2010 at the Microsoft MVP Summit. The experience was NOT fun, hampered by two major gotchas:

  • SP2010 will not configure unless you are connected to the network. And the domain controller of the domain to which the machine belongs is accessible. The error will complain about configuring the database, but this is the real root cause.
  • CS2009 R2 CTP – leaving authorization disabled caused – of all things – an authorization error. Configuring the XML files for Authorization Manager rectified the problem.

Many, many hours killed – if you run into these – hopefully they help!

Commerce Server 2009 w/ SharePoint 2010 Template Pack Hyper-V VHD Now Available

I am pleased to announce that we now have available a Hyper-V VHD release of the SharePoint 2010 Template Pack for Commerce Server 2009. This is a 64-bit Hyper-V image – as SharePoint 2010 requires a 64-bit operating system. Hence, Windows Server 2008 with Hyper-V is required to run the VM along with at least 4 GB of RAM for the virtual machine.

To obtain this, please:

  • Navigate to
  • Sign in or create a profile using your Windows LiveID
  • Join the Commerce Server Feedback program (if you are not already a member)
  • Fill out the survey to request the VHD – and you will be granted access once your request has been submitted and approved (generally takes 1 business day)

Hope this helps – and enjoy!

Commerce Server on SharePoint 2010

Today is the next step in evolving Commerce Server. As of this morning, the Commerce Server 2009 Template Pack for SharePoint 2010 has released and can be downloaded at

What this release provides is an updated version of the existing Contemporary Site for both Web and Mobile devices that runs on SharePoint 2010, along with the requisite source code for customization. It also updates the Profile system to support the new claims-based authentication mechanism in SharePoint 2010.

I would highly encourage anyone starting a new deployment to start here. For those with existing sites, the Profile update (and associated site code, to be used as a reference) are absolute must-haves to get an existing Commerce Server 2009/SharePoint 2007 site to run on SharePoint 2010 (there is no way to actually get it to work without these fixes).

Hope this helps!

Summary: Looking back at CS2009

Now that I’m done, I just wanted to quickly summarize the mini-series I just finished looking back at CS2009:

I hope this helps with your journeys with CS2009; time does indeed fly when you’re having fun!  

Commerce Server 2009: A Look at the Multi-Channel Commerce Foundation

The biggest job in modernizing Commerce Server is most definitely that of replacing its programming surface. Achieving API consistency – and removing legacy components – has been one of the most oft-requested features in Commerce Server from a developer audience. However, the trick is achieving this – without causing egregious customer pain.

So, this journey started out by establishing a few hardcore tenets, including:

· Creating a consistent pattern – for both runtime and data management operations

· Creating a flexible pattern – that can accommodate any entity today, any future needs, or any custom needs as part of a complex deployment

· Establishing a forward-migration story for versions beyond CS2009

· Establishing an a la carte migration story from CS2007 so that no big-bang re-platforms are needed

· Playing well in a message-based world – such that request batching can be used for performance reasons and the new API can be easily integrated into any SOA environment

· Having an API that will work outside of a Web server, in any environment

The journey began by creating a simple, message-based pattern that works by:

1. Creating a request comprising one or more operations on a specified item.

2. Submitting the request to a broker.

3. Parsing the result returned by the broker.

Oh, and the specified items have to be able to have relationships with each other – even if they are totally disparate.

Under the hood, pluggable providers and operation sequences do the real work. In the case of CS2009, this pattern has, out-of-the-box, been wired up to talk to the existing Core Systems of Commerce Server 2007 lineage and SharePoint Lists. In CS2009, it limited to working within a Web server process and covers site runtime scenarios only, but that will be expanded in due course in subsequent versions.

It can just as easily talk to any 3rd party system as well. And it lays a foundation for being able to add new systems or replace existing ones in the future – all while not breaking the actual application(s) written on the API itself. Imagine a world where one can interface directly to an ERP programmatically – or swap systems in and out at will (e.g. – Dynamics AX in one country, Dynamics GP in another).

Conceptually, it looks like this:


The CS2009 implementation lays the foundation of the tenets set forth at the beginning of the post – and shall continue to be expanded upon in subsequent releases up to the point that the underlying core systems in Commerce Server are re-written and replaced – under-the-hood without impacting applications on top.

All of this flexibility probably seems great at this point – but what’s the catch? There is a tad more coding involved in doing this – versus using an in-process, purpose-built, strongly typed API that only does one thing. This is the small price of consistency, simplicity, and flexibility. So – what does it look like?

One starts with a CommerceEntity – which is a single generic class that is the gateway to the API. Different entities (of those offered) are distinguished by the “ModelName” property on the class. Hence, an example query looks like:


What is shown here is the extent of what it takes to use the new API – versus just say – calling the Catalog. A tad more code, but one is no longer tied to a fixed implementation (and tomorrow the ties to a Web server will be cut as well).

Each CommerceEntity has its PropertyCollection, which allows individual properties to be managed. Properties are retrieved and set with the GetPropertyValue() and SetPropertyValue() methods – continuing the example above it looks like this:


Relationships are also returned in the Properties collection, and manipulated simply by setting properties. For example, relating Product and Variant queries is as simple as:


To wrap up, we can put it into context by looking at the CommerceEntity’s shipped with Commerce Server 2009:

· Foundational Entities – used internally in constructing other entities, but fully customizable.

o CommerceEntityDefinition

o AuthorizationDefinition

o RelationshipDefinition

o RelationshipTypeDefinition

o PropertyDefinition

o EntityMapping

o DefinitionMapping

o ConstraintBase

o EnumerationEntry

o EntityMetadata

o CommerceCache

· Commerce Entities – where the actual interaction typically occurs.

o Site

o Solution

o Channel

o CommerceLogEntry

o Catalog

o Product

o Variant

o Image

o InventoryItem

o Category

o UserProfile

o StoreProfile

o Address

o CreditCard

o TargetingContext

o SiteTerm

o SiteTermElement

o Basket

o ShopperList

o Discount

o LineItem

o PurchaseOrder

o CashCard

o GiftCertificate

o RequestedPromoCode

o Shipment

o Payment

o PaymentAccount

o PaymentMethod

o ShippingMethod

o HierarchicalCatalogEntry

o Advertisement

o ContentSelector

o ContentSelectorCollection

o EventRecord

o DiscountDefinition

o DiscountFilter

o Region

o StateProvince

o BasketOrderSearch

o ImageGalleryFile

o ImageGallery

And all of these are easily customizable – both in their definitions and in what happens under the hood. And they are easily callable from either ASP.NET or non-Web page scenarios, such as using a PowerShell script – too!

And that – really is it – unless one needs to dive deep into the annals of request batching or extending the underlying operations to make the API talk to something else beyond Commerce Server or SharePoint.

Hope this helps!