Charteris Community Server

Sync Framework 2.0 Series – Part 3 – Performing Collaborative Synchronisation

IvorB — Fri, 13 Aug 2010 08:59:43 GMT

This is part 3 in the Sync Framework 2.0 series and deals with building an application that can perform collaborative synchronisation. By this – I mean we have an application which will directly update 1 instance of SQL Server, but this server is kept in sync with a number of other SQL Server peers. In order to keep things relatively simple – we will assume only SQL Servers, so the basic idea is to build something like the following:

I decided to use the pubs database and in particular the table “Authors”, so you’ll need 2 different databases with this table - I called mine pubs and pubsCopy. I’m going to assume that the tables are in sync when we start, so we only need to worry about keeping them in sync.

In general with SQL Server and Sync Framework, there are 2 approaches to keeping tables in sync:

SQL Server Change Tracking
Adding custom tables/columns/trigger to track changes.

As SQL Server change tracking limits you to specific versions of SQL Server, and as our previous example used change tracking – this example is going custom tables/columns and triggers to track changes. The first thing we need to do is provision both tables which basically means creating the tables/columns & triggers to track the database changes in both databases. I created a helper class to wrap this functionality as it looks like the following:

        1: /// <summary>

       2: /// Wraps some synchronisation functionality

       3: /// </summary>

       4: public class SynchronisationHelper

       5: {

       6:     private static string scopeName = "authors";

       7:  

       8:     /// <summary>

       9:     /// Provision a sql server

    /// </summary>

    /// <param name="connectionString"></param>

    /// <returns></returns>

    public static bool ProvisionSqlSyncProvider(string connectionString)

    {

        bool requiredProvision = false;

  

        SqlConnection connection = new SqlConnection(connectionString);

  

        // create a new scope description and add the 

        // appropriate tables to this scope

        DbSyncScopeDescription scopeDesc = new 

            DbSyncScopeDescription(scopeName);

  

        // class to be used to provision the scope defined above

        SqlSyncScopeProvisioning scopeProvision = new SqlSyncScopeProvisioning();

  

        // Check if this scope already exists on the server and if not 

        // go ahead and provision

        if (!scopeProvision.ScopeExists(scopeName, connection))

        {

            requiredProvision = true;

  

            // add the appropriate tables to this scope

            DbSyncTableDescription tableDesc = 

                SqlSyncDescriptionBuilder.GetDescriptionForTable("authors", connection);

            scopeDesc.Tables.Add(tableDesc);

  

            // note that it is important to call this after the tables 

            // has been added to the scope

            scopeProvision.PopulateFromScopeDescription(scopeDesc);

  

            //indicate that the base table already exists and does not need to be created

            scopeProvision.SetCreateTableDefault(DbSyncCreationOption.Skip);

  

            //provision the server

            scopeProvision.Apply(connection);

        }

  

        return requiredProvision;

    }

}

Our helper takes a connection string to the database where we have tables that we wish to provision. We need to provide an identifier for our synchronisation operation and we do this by creating a DBSyncScopeDescription and a SqlSyncScopeProvisioning. We check if this scope has already been configured in our database and if not – specify the tables that will be part of this synchronisation. When we apply the scope provision, a number of database operations are performed:

Creation of new Table
- scope_info - This provides a unique identifier (scope_id) for each scope
- scope_config - This stores configuration information for our new scope. This includes mapping information for stored procedures to create, delete and update records, as well as all the columns that are in the scope.
- authors_tracking - This is used to track changes to the table in the scope, along with tombstone information for deleted records.
Creation of Stored Procedures
- authors_delete – used by the framework to delete the record from the authors table.
- authors_deletemetadata – used by the framework to delete a record from the authors_tracking table.
- authors_insert – used by the framework to insert a record into the authors table.
- authors_insertmetadata – used by the framework to update the authors_tracking table.
- authors_selectchanges – used by the framework to return records from the authors table since a particular revision.
- authors_selectrow – used by the framework to return a particular record from the authors table.
- authors_update – used by the framework to update a record in the authors table.
- authors_updatemetadata – used by the framework to update a record in the authors_tracking table.
Creation of triggers on authors table
- insert trigger called authors_insert_trigger – this inserts a record into the authors_tracking table
- delete trigger called authors_delete_trigger – this updates the record in authors_tracking as a tombstone.
- update trigger called authors_update_trigger – this updates the record in author_tracking to capture the local data change

Creation of these entities through the application is probably fine for a non production application, but in reality you will probably want to script the changes so they can be applied to a production environment.

The next step is to actually perform the synchronisation between the 2 SQL Server instances. Again – I wrapped the functionality to perform the synchronisation into a helper class and the code looks like:

       1: /// <summary>

       2: /// Utility function that will create a SyncOrchestrator and 

       3: /// synchronize the two passed in providers

       4: /// </summary>

       5: /// <param name="localProvider">Local store provider</param>

       6: /// <param name="remoteProvider">Remote store provider</param>

       7: /// <returns></returns>

       8: public static SyncOperationStatistics SynchronizeProviders(

       9:     RelationalSyncProvider localProvider, 

      10:     RelationalSyncProvider remoteProvider)

      11: {

      12:     SyncOrchestrator orchestrator = new SyncOrchestrator();

      13:     orchestrator.LocalProvider = localProvider;

      14:     orchestrator.RemoteProvider = remoteProvider;

      15:     orchestrator.Direction = SyncDirectionOrder.UploadAndDownload;

      16:  

      17:     // Perform the synchronisation

      18:     SyncOperationStatistics stats = orchestrator.Synchronize();

      19:     return stats;

      20: }

It is very straightforward to create the RelationalSyncProviders needed as parameters.

       1: /// <summary>

       2: /// Return a sql sync provider

       3: /// </summary>

       4: /// <param name="connectionString"></param>

       5: /// <returns></returns>

       6: public static SqlSyncProvider ConfigureSqlSyncProvider(string connectionString)

       7: {

       8:     SqlSyncProvider provider = new SqlSyncProvider();

       9:     provider.ScopeName = scopeName;

      10:     provider.Connection = new SqlConnection(connectionString);

      11:  

      12:     return provider;

      13: }

Next step is to build a simple UI that allows you to maintain the data on either the source or the target, perform a synchronisation and view the results of the synchronisation.

You should observe the following behaviour:

Perform a sync to ensure the source is in sync with the target.
Press Refresh on both the source and the target and ensure that they visually look the same.
Alter an author on the source and press Save. When you press Refresh on the source – you should continue to see the new value.
Press Refresh on the target and you should continue to see the old value.
Press Sync which should synchronise the change from the source to the target.
Press Refresh on the target and you should see that the value has been updated with the value from the Source.

The prototype application can be downloaded from here. Don’t forget - you will need 2 SQL Server databases – one called pubs and one called pubsCopy, both containing a version of the authors table.

Technorati Tags: Sync Framework

Del.icio.us Digg It Share on Facebook Stumble It!

Installing .Net 1.1 applications on Windows Server 2008 R2

IvorB — Thu, 15 Jul 2010 16:17:35 GMT

I recently needed to get an ASP.Net 1.1 application working on Windows Server 2008 R2. I naively assumed that this was just going to work but then the whole 32/64 bit problem emerged.

.Net 1.1 is 32 bit only and Server 2008 R2 is 64 bit only! Well – WOW64 has been around quite a while so surely this would be a piece of cake. I proceeded to download the .Net Framework Version 1.1 Redistributable Package and when you attempt to install – you get your first hint about the potential problems ahead.

At this stage – you have 2 choices:

Attempt to upgrade your application to a 64 bit version of the framework
Attempt to get .Net 1.1 working on Server 2008 R2

My preference was to get .Net 1.1 working as I didn’t want to go through a test cycle for an application I didn’t really understand on a new version of the framework. However – rather than just choosing “Run Program” from the Program Compatibility Assistant dialog – I did some research and used the following process to get my application to work.

1 - Install IIS Metabase Compatibility

To install on Windows 2008 Server – click Start and then “Server Manager”.

Under Web Server (IIS), click Add Role Services.

Ensure that IIS Metabase Compatibility is installed.

2 - Install .Net 1.1

I installed .Net 1.1 in the following order:

I still got a compatibility warning, but chose “Run Program” to continue.

Installing Service Pack 1 is likely to require a reboot.

3 – Enable ASP.Net 1.1 ISAPI Extension

Following the steps in option 2 made ASP.NET v1.1.4322 available on my ISAPI and CGI Restrictions dialog, but was disabled by default. Open Internet Explorer, click on your server name and choose ISAPI and CGI Restrictions from the IIS section. Enable ASP.Net v1.1.4322 as a valid ISAPI extension.

4 – Adjust machine.config

We need ASP.NET 1.1 to ignore IIS configuration sections, so open machine.config for Framework 1.1 (%windir%\Microsoft.NET\Framework\v1.1.4322\config\machine.config) and add the following towards the end of configSections.

        1: <section name="system.webServer" type="System.Configuration.IgnoreSectionHandler, 

       2:     System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />

5 – Adjust the Application pool

I now needed to tell my application to use the application pool ASP.NET 1.1. Use IIS Manager, choose the site that you are working with and choose “Advanced Settings”. Adjust the application pool to use ASP.NET 1.1 which will use .Net Framework 1.1.

6 – Fix applicationHost.config bug

IIS runtime detected that I was running on a 64 bit operating system, so it attempted to load .net framework configuration from Microsoft.Net\Framework64, but this doesn’t exist for .Net Framework 1.1. The solution is to copy the 32 bit version into the appropriate 64 bit folder.

Create \Windows\Microsoft.net\Framework64\v1.1.4322\config
Copy machine.config from \Windows\Microsoft.net\Framework\v1.1.4322\Config\

7 - Check any application registry settings

My application relied upon a number of custom application registry settings. In the 32 era – this wasn’t a problem as registry settings were in the “same” expected place. e.g. most people put registry settings under HKEY_LOCAL_MACHINE \ SOFTWARE someplace. However – on a 64 bit machine – the 64 bit software settings are stored in this expected place, while 32 bit settings are stored under HKEY_LOCAL_MACHINE \ SOFTWARE \ Wow6432Node.

This is probably easiest to explain by giving an example. My application needed to access HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ ConfigurationManagement \ hashKey. In order to make this setting available to a 32 bit application running on a 64 bit server, you need to store the key as HKEY_LOCAL_MACHINE \ SOFTWARE \ Wow6432Node \ Microsoft \ ConfigurationManagement \ hashKey.

I initially exported the keys from an existing Server 2003 machine and imported them onto Server 2008 which put them into HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ ConfigurationManagement \ hashKey. This is where Windows expects you to store your 64 bit settings, so you need to move them to the corresponding location under Wow6432Node.

This caused a lot of pain and confusion trying to understand why my application couldn’t read registry settings which were obviously there. The solution is to put your 32 bit registry settings where your 32 bit application will attempt to read them – under Wow6432Node.

Some useful references for understanding the 32/64 bit registry issues are:

Finally, after following all of the above – my 32 bit .net 1.1 application was working correctly on Server 2008 R2.

Useful links

Technorati Tags: Server 2008 R2,.Net 1.1

Del.icio.us Digg It Share on Facebook Stumble It!

CRM 4.0 xRM code generation using CrmSvcUtil

alistairl — Wed, 14 Jul 2010 15:02:36 GMT

You may have read some of my previous postings on SharePoint, but in my world of Solution Architecture I touch on other products such as SQL Server, Microsoft CRM and whatever else is an appropriate fit to the requirements of client work I am engaged on.

A recent job for a multinational consultancy was an excellent opportunity to catch up with the Microsoft CRM 4.0 SDK and the tools contained therein. I’ll post separately about the business problems we solved with Microsoft CRM 4.0 and some integration code, but in this article I’ll focus on what I discovered in using the xRM tools included in the recent SDK.

This isn’t the article to discuss the improvement in the support for developers, but I have to say that the shipping of accelerators that are good enough to be reference material are a great way of supporting the learning process for building on CRM. Hot on the heels of the accelerators have been the SDK improvements to allow you and I to make the most of CRM, and this particular post concentrates on the library class generator CrmSvcUtil.exe.

When you download and extract the CRM 4.0 SDK from Microsoft you will find a microsoft.xrm directory alongside the other collection of directories containing sample code, user interface design guide, SDK help file etc. In that directory are four useful documents: two guides and two walkthroughs giving you as the developer an idea of what is intended by the Microsoft Dynamics CRM 4.0 SDK Advanced Developer Extensions (Microsoft xRM), to give it its full title.

These documents explain how to use the code generation tool and I’d recommend you read the developer's guide to get a quick heads up of what is intended by the inclusion of these tools in the SDK. At this stage the documentation is rather “light” but I would expect more detail to emerge in subsequent releases of the SDK. To cut a long story short, CrmSvcUtil is a command line tool that generates a whole pile of classes from your CRM instance. This is important, because as well as creating classes for managing the built-in entities, it also generates them for your custom entities. This does of course generate a minor configuration management headache, and I’ll post an article later on what we have implemented,with recommendations for integrating this with automated build in order to ensure that your generated classes keep pace with what your entity developers are doing.

It took me a few tries to get the right combination of parameters to get the class output I needed. In particular I found that I had to get the dataContextPrefix exactly correct in order for the correct classes to be included. I created a number of different sets of files either singly or collectively that represented the entity activities but these depend on certain shared classes that I found were not included in all parameter combinations.

Additionally I discovered, through using the tool, that it will prompt for missing parameters provided essentials like the server name have been specified. As I mentioned earlier the tool can create separate c# files for each entity, but with getting on for almost 200 entities (not including any custom ones), I found the generation of a single .cs file preferable from a logistics point of view.

In the end I settled down to a command line like the following:

crmsvcutil.exe /connectionString:"Authentication Type=AD; Server=https://crm.microsoft.com/Woodgrove User ID=WOODGROVE\devaccount; Password=***" /out:"Xrm.cs" /namespace:Xrm /dataContextPrefix:Xrm

This will generate a single class file called xrm.cs based on reading the entities in the specified organisation on the specified server. A full description of the parameters can be found in the Advanced Developer Extensions Developers Guide. A word of warning though, the file isn’t small – with a full set of standard entities and custom entitities the xrm.cs file generated out at just over 4Mb.

The great thing about this approach is that, as the generated code runs off your organisation in your CRM, it picks up not only your custom entities but also the changes that you have made to customisable entities. In my opinion, this makes it a lot easier to get up to speed with concentrating on the business logic and specifics of integrating with CRM rather than crafting your own way through wrapping up the CRM web services. I’d recommend having a look and running the generation tool to see if the classes it provides would have helped to make your last CRM development project easier, and will make your next a lot easier. In follow-up posts I hope to take a step back to talk about the business requirement we satisfied with this technology, but also perhaps take a step sideways and describe how this code generation can fit into an overall governance policy for regular build and test using Team Foundation Server.

Del.icio.us Digg It Share on Facebook Stumble It!

Sync Framework 2.0 Series – Part 2 – Using Local Database Caching for an occasionally connected application.

IvorB — Thu, 08 Jul 2010 16:11:17 GMT

This is part 2 in the Sync Framework 2.0 series and deals with building an occasionally connected application using Local Database Caching. Part 1 in the series dealt with installing the Sync Framework and using the File Sync Provider.

My original goal with this post was to see if I could use the Sync Framework to build a C# version of SQL Replication to keep two SQL Server databases in sync. However – I found a limited amount of information available in the public domain, so I have decided to take an initial step into SQL Synchronisation by building an “occasionally connected application” using Local Database Caching. The basic idea is to build something like the following:

Users of the application can work in local mode where all their changes are persisted to a local database, and at intervals they can sync their changes back to the main corporate database. The best initial source of information I found for this type of application was on MDSN called “Occasionally Connected Applications” – an excellent series of articles that discuss various aspects of this topic. The manner you approach this type of application depends upon what technologies you are going to use to build it – for my example – I’m going to use SQL Server 2008 R2, Visual Studio 2010 and of course – Sync Framework 2.0.

When it comes to tracking database changes, there are 2 general approaches that can be taken.

Add columns and triggers to the tables being monitored.
Use SQL Server Change Tracking

In general – I find Database Administrators quite reluctant to add columns to tables for this kind of work. Generally – the application is in production when someone decides that they would like to be able to add a disconnected approach, and it is often considered to risky to add these additional tracking columns and triggers. Other people don’t like mixing the data we need to store for an entity with metadata we use to embellish an entity. For this reason – I’m going to focus on using SQL Server Change Tracking and further details on change tracking can be found on MSDN.

First step is to choose the data that your application needs to work with. I wanted an example that was as simple as possible so I chose the pubs database. pubs isn’t installed by default on SQL Server 2008, so I had to download the database from Microsoft. After attaching to SQL Server 2008 – I came across my first stumbling block – using the Local Database Caching wizard (more on this later) didn’t detect it as a database which I could use SQL Server Change Tracking on as “Use SQL Server change tracking” was disabled.

I struggled to find useful information on the internet about this using my favourite search engine (perhaps I was using poor search criteria?), but in the end I made a lucky guess – perhaps it didn’t like my database as it wasn’t really a SQL Server 2008 database? It was really a SQL Server 2000 database attached to SQL Server 2008. I quickly created a new database and used the Data Import Wizard to copy the “authors” table from pubs to my new database and while this was a step forwards as “Use SQL Server change tracking was now enabled”, my next stumbling block was that it wouldn’t let me add a new Cached Table - the Add button was disabled!

More lost time using my favourite search engine and another lucky guess solved my problem – perhaps it was to do with the way my authors table was created. The Data Import Wizard created my table as well as copying the contents, and it decided not to create a primary key. Sync Framework likes primary keys so a quick “Add Primary Key” operation later – and the Local Database Caching wizard was a lot happier.

To recap – when you are choosing your data source which you wish to use for an occasionally connection application and you want to use SQL Server Change Tracking – make sure its SQL Server 2008 and you have a primary key on any table that you want to synchronise.

Now we have our data that we want to synchronise – let’s start building our application. I’m going to use a simple WinForms Desktop application. Tweak the default form so we have a tab control with 2 tabs – one to display the contents on the server and one to display the contents on our client and some buttons to perform useful operations. I’ve built the following:

Right click the project and choose “Add New Item” and on the Data section – choose “Local Database Caching”. This will bring up the “Configure Data Synchronisation” wizard where you specify the data that you wish to use. Specify the Server connection for the source of the data and the Client connection should default to a new Compact database. Choose the table which you wish to cache by clicking the Add button. The dialog should look something like the following:

Next step in the wizard is to choose the database model, and I went with the Dataset approach. This is good for getting a prototype up and running, but if you are building something for a production environment – you might want to consider using an Entity Data Model.

You end up with a typed dataset for the local version of the authors table. Visual Studio will have added references to Microsoft.Synchronisation, Microsoft.Synchronisation.Data, Microsoft.Synchronisation.Server and Microsoft.Synchronisation.ServerCe but it managed to completely screw up the references on my machine. I’m working on a 64 bit machine and it created a strange hybrid of 32 and 64 bit references. I manually removed and re-added all 64 bit references on my machine and then changed the target platform to be “Any CPU” (It had defaulted to x86).

Next step is populate the client DataGridView and this requires minimal coding. I have 2 form level variables as follows:

        1: #region Variables

       2:  

       3: private AuthorsDataSet authorsClientDataSet = new AuthorsDataSet();

       4: private AuthorsDataSetTableAdapters.AuthorsTableAdapter authorsClientAdapter = 

       5:     new AuthorsDataSetTableAdapters.AuthorsTableAdapter();

       6:  

       7: #endregion

In the event handler for the click event for the populate button on the client tab – I have the following code:

       1: /// <summary>

       2: /// Populate the client data grid view control

       3: /// </summary>

       4: /// <param name="sender"></param>

       5: /// <param name="e"></param>

       6: private void buttonClientAuthorsPopulate_Click(object sender, EventArgs e)

       7: {

       8:     try

       9:     {

      10:         authorsClientAdapter.Fill(authorsClientDataSet.Authors);

      11:  

      12:         this.dataGridViewClientAuthors.DataSource = authorsClientDataSet.Authors;

      13:     }

      14:     catch (Exception Ex)

      15:     {

      16:         MessageBox.Show("Failed to populate the client - perhaps the client compact " +

      17:             "database hasn't been created yet!" + Environment.NewLine + Ex.Message);

      18:     }

      19: }

To make our prototype easy to test – it’s useful to be able to change and save the data using the application (rather than testing by changing the data directly in the database), so I implemented the save functionality for the client as follows:

       1: /// <summary>

       2: /// Save any changes on the client

       3: /// </summary>

       4: /// <param name="sender"></param>

       5: /// <param name="e"></param>

       6: private void buttonClientSave_Click(object sender, EventArgs e)

       7: {

       8:     try

       9:     {

      10:         this.Validate();

      11:         this.dataGridViewClientAuthors.EndEdit();

      12:         this.authorsClientAdapter.Update(this.authorsClientDataSet);

      13:  

      14:         PopulateClient();

      15:         MessageBox.Show("Saved");

      16:     }

      17:     catch(Exception ex)

      18:     {

      19:         MessageBox.Show("Error " + ex.Message);

      20:     }

      21: }

In order to make the server tab work, I decided to manually add a typed dataset for the server version of the authors table. There were a number of ways I could have made the server tab work, but using a typed dataset meant that the code looked very similar to the client version.

You should now have working versions of the server and client tabs which allow you to view, change and save values. Next step is to implement the Synchronisation functionality – we want the user to be able to perform synchronisations between their local database and the central server database. Initial implementation for performing the synchronisation is very straightforward:

       1: /// <summary>

       2: /// Perform a database change sync between our client and the server.

       3: /// </summary>

       4: /// <param name="sender"></param>

       5: /// <param name="e"></param>

       6: private void buttonSync_Click(object sender, EventArgs e)

       7: {

       8:     AuthorCacheSyncAgent syncAgent = new AuthorCacheSyncAgent();

       9:     Microsoft.Synchronization.Data.SyncStatistics syncStats = syncAgent.Synchronize();

      10:  

      11:     PopulateServer();

      12:     PopulateClient();

      13:     

      14:     StringBuilder message = new StringBuilder();

      15:     message.Append("Changes downloaded: ");

      16:     message.Append(syncStats.TotalChangesDownloaded.ToString());

      17:     message.AppendLine();

      18:     message.Append("Changes uploaded: ");

      19:     message.Append(syncStats.TotalChangesUploaded.ToString());

      20:  

      21:     MessageBox.Show(message.ToString());

      22: }

When I tried to run my application for the first time – it failed with the following error: “The specified change tracking operation is not supported. To carry out this operation on the table, disable the change tracking on the table, and enable the change tracking.” More frantic searching but at least I found other people having the same problem. The easiest way to get rid of this exception is to set the “Copy to Output Directory” for your local compact database to “Do not copy”.

You should now have a working “occasionally connected application” which can synchronise changes from the server to your client. However – what if you want to be able to synchronise both ways? This is actually easy to achieve – you just need to implement the OnInitialized() method in the cache file that the wizard generated.

       1: /// <summary>

       2: /// Code generated Sync Agent which we can extend

       3: /// </summary>

       4: public partial class AuthorCacheSyncAgent 

       5: {

       6:     /// <summary>

       7:     /// Initialise the sync agent to perform a bidirectional sync.

       8:     /// </summary>

       9:     partial void OnInitialized()

      10:     {

      11:         Authors.SyncDirection = SyncDirection.Bidirectional;

      12:     }

      13: }

This allows you to perform a 2 way sync. However – what happens if you change a record on both the server and the client and perform a sync. The behaviour you should find is that the server always wins and the client change is thrown away. What happens if this isn’t the behaviour you require? You can add custom conflict handling by extending the client and server sync provider that the wizard generated. Delve into the generated code to find the names of the client and server providers, and create a partial class for the client provider as follows:

       1: /// <summary>

       2: /// Extends the code generated client sync provider for authors.

       3: /// </summary>

       4: public partial class AuthorCacheClientSyncProvider

       5: {

       6:     /// <summary>

       7:     /// Allows the main form to configure the event handler for the 

       8:     /// ApplyChangeFailed event

       9:     /// </summary>

    public void AddHandlers()

    {

        this.ApplyChangeFailed +=

            new System.EventHandler<ApplyChangeFailedEventArgs>

            (AuthorCacheClientSyncProvider_ApplyChangeFailed);

    }

  

    /// <summary>

    /// Allow the client to win a conflict by choosing to continue.

    /// </summary>

    /// <param name="sender"></param>

    /// <param name="e"></param>

    private void AuthorCacheClientSyncProvider_ApplyChangeFailed(object sender,

        Microsoft.Synchronization.Data.ApplyChangeFailedEventArgs e)

    {

  

        if (e.Conflict.ConflictType ==

            Microsoft.Synchronization.Data.ConflictType.ClientUpdateServerUpdate)

        {

            e.Action = Microsoft.Synchronization.Data.ApplyAction.Continue;

        }

    }

}

Similarly – create a partial class for the server provider as follows:

       1: /// <summary>

       2: /// Extend the server sync provider for authors to allow a client to win a conflict.

       3: /// </summary>

       4: public partial class AuthorCacheServerSyncProvider

       5: {

       6:     /// <summary>

       7:     /// Hooks up the ApplyChangeFailed event handler.

       8:     /// </summary>

       9:     partial void OnInitialized()

    {

        this.ApplyChangeFailed +=

            new System.EventHandler<ApplyChangeFailedEventArgs>

            (AuthorCacheServerSyncProvider_ApplyChangeFailed);

    }

  

    /// <summary>

    /// When a conflict occurs, force write the client change.

    /// </summary>

    /// <param name="sender"></param>

    /// <param name="e"></param>

    private void AuthorCacheServerSyncProvider_ApplyChangeFailed(object sender,

        Microsoft.Synchronization.Data.ApplyChangeFailedEventArgs e)

    {

        if (e.Conflict.ConflictType ==

            Microsoft.Synchronization.Data.ConflictType.ClientUpdateServerUpdate)

        {

            string message = "A client/server conflict was detected at the server.";

            MessageBox.Show(message);

            e.Action = Microsoft.Synchronization.Data.ApplyAction.RetryWithForceWrite;

        }

    }

}

Finally you need to tweak the implementation to perform the synchronisation as follows:

       1: /// <summary>

       2: /// Perform a database change sync between our client and the server.

       3: /// </summary>

       4: /// <param name="sender"></param>

       5: /// <param name="e"></param>

       6: private void buttonSync_Click(object sender, EventArgs e)

       7: {

       8:     AuthorCacheSyncAgent syncAgent = new AuthorCacheSyncAgent();

       9:     AuthorCacheClientSyncProvider clientSyncProvider = 

      10:         (AuthorCacheClientSyncProvider)syncAgent.LocalProvider;

      11:     clientSyncProvider.AddHandlers();

      12:  

      13:     Microsoft.Synchronization.Data.SyncStatistics syncStats = syncAgent.Synchronize();

      14:  

      15:     PopulateServer();

      16:     PopulateClient();

      17:  

      18:     StringBuilder message = new StringBuilder();

      19:     message.Append("Changes downloaded: ");

      20:     message.Append(syncStats.TotalChangesDownloaded.ToString());

      21:     message.AppendLine();

      22:     message.Append("Changes uploaded: ");

      23:     message.Append(syncStats.TotalChangesUploaded.ToString());

      24:  

      25:     MessageBox.Show(message.ToString());

      26: }

The latest implementation now means that the client always wins and the server change is throw away.. In reality you might want to prompt the user or log the details and allow manual intervention, but at least we can control how we manage the conflict.

This prototype application can be downloaded from here. You will need to create a SQL Server 2008 database with an Authors table containing the standard authors information. I used a SQL ConnectionString for a user called sqlsync but you can edit these in the app.config.

Hopefully you will agree with me that using the Local Database Cache means that we don’t have to write much code in order to produce a working occasionally connected application. However – the main problems are limited example in the public domain and some puzzling times when things don’t work quite as expected!

Technorati Tags: Sync Framework

Del.icio.us Digg It Share on Facebook Stumble It!

Sync Framework 2.0 Series – Part 1 – Using the File Sync Provider

IvorB — Mon, 05 Jul 2010 13:21:53 GMT

This is the beginning of what will hopefully become a series of posts about Microsoft Sync Framework 2.0.

Microsoft Sync Framework is “A comprehensive synchronization platform that enables collaboration and offline access for applications, services, and devices with support for any data type, any data store, any transfer protocol, and any network topology”. I wanted to use the sync framework recently but struggled to find really good content using my favourite search engine. I decided to work through some of the samples in the SDK and try and explore around some of the issues, and hopefully my experiences will help jump-start others who wish to use the platform.

The best place to start reading is on msdn at the Microsoft Sync Framework Developer Center

One of the first things you will want to do is download the Sync Framework 2.0 SDK and this can be found at: Sync Framework 2.0 SDK.

I’m using Visual Studio 2010 to develop a Windows Forms application so the first thing I needed to do was add a reference to Microsoft.Synchronisation and Microsoft.Synchronisation.Files. However – a gotcha (at least on my machine) are that the available references on the .Net tab are for Sync Framework 1.0. Its worth checking the Path column on the Add References dialog to make sure you are adding a reference to Sync Framework 2.0. In the end – I did a Browse to the SDK folder and added my reference that way. Some constructors etc have changed subtly from version 1.0, so you need to use the right sample with the right version of the SDK to make things a bit easier.

Another gotcha that I came across is that my Visual Studio 2010 defaulted my Windows Forms Application to a platform target of x86 despite the fact that I was using a 64 bit machine. This became an issue as I had installed the 64 bit version of the Sync Framework SDK, so I started getting run time exceptions like the following: "Retrieving the COM class factory for component with CLSID {C201C012-C929-4D72-B9C5-341D48630630} failed due to the following error: 80040154 Class not registered (Exception from HRESULT: 0x80040154 (REGDB_E_CLASSNOTREG)).". After a lot of frustration – I found by changing the platform target to “Any CPU”, my run time COM error went away.

I think the issue is created by the managed implementation actually being a wrapper around the real non managed implementation, so when I installed the 64 bit version of the SDK – I got the 64 bit registry entries. When Visual Studio built the 32 bit version of the application – it couldn’t find the 32 bit registry entries and gave me a run time error.

I wanted to build an example that looked and worked a bit like SyncToy. If you are unfamiliar with SyncToy – its “a free application that synchronizes files and folders between locations. Typical uses include sharing files, such as photos, with other computers and creating backup copies of files and folders.” and is actually built with Sync Framework 2.0.

So some might ask the question – why build something when a solution already exists and my answer is that its allows me to extend the solution beyond SyncToy. e.g. It would be relatively easy to extend my solution to use a Windows service and FileSystemWatchers to detect changes to the file system and automatically initiate a synchronisation. SyncToy simply initiates a synchronisation on demand.

My example prompts the user for a source and target folder, and the user can press a button to synchronise the files between the 2 folders. To get a simple example working, you need to create a FileSyncProvider for the source folder, a FileSyncProvider for your target folder and a SyncOrchestrator to perform the synchronisation operation. I’ve put my code into a class, and my button click event handler calls it.

        1: /// <summary>

       2: /// Perform a simple synchronisation

       3: /// </summary>

       4: public class SimpleSyncHelper

       5: {

       6:     /// <summary>

       7:     /// Perform the synchronisation

       8:     /// </summary>

       9:     /// <param name="sourceFolder"></param>

      10:     /// <param name="targetFolder"></param>

      11:     public void PerformSynchronisation(string sourceFolder, 

      12:         string targetFolder)

      13:     {

      14:         FileSyncProvider sourceProvider = new FileSyncProvider(sourceFolder);

      15:         FileSyncProvider targetProvider = new FileSyncProvider(targetFolder);

      16:  

      17:         SyncOrchestrator agent = new SyncOrchestrator();

      18:         agent.LocalProvider = sourceProvider;

      19:         agent.RemoteProvider = targetProvider;

      20:         

      21:         // Perform 2 way sync

      22:         agent.Direction = SyncDirectionOrder.UploadAndDownload; 

      23:         agent.Synchronize();

      24:     }

      25: }

This works really well but when I looked at the file synchronisation example from the SDK, it was coded differently and the piece that attracted my attention was: “Explicitly detect changes on both replicas upfront, to avoid two change detection passes for the two-way sync”. It turns out that the implementation of SyncOrchestrator-Synchronize() actually splits the operation into 2 – 1 to perform the upload and 1 to perform the download. When it performs the upload part – it detects changes on both the source and the target, and when it performs the download part – it detects changes on both the source and target. This effectively means that 4 “detect change” operations are performed and explains why the SDK sample was keen to avoid the two change detection phases.

To prove to yourself that the code performs as above, hook up a DetectingChanges event handler for both the sourceProvider and the targetProvider and add a MessageBox.Show() to the handler and you should observer 4 message boxes.

To get around the two change detection passes, you should perform an explicit detection on both the source and the target.

       1: /// <summary>

       2: /// Perform a DetectChange operation on a FileSyncProvider.

       3: /// </summary>

       4: /// <param name="replicaRootPath"></param>

       5: /// <param name="filter"></param>

       6: /// <param name="options"></param>

       7: private void DetectChangesOnFileSystemReplica(string replicaRootPath, 

       8:     FileSyncScopeFilter filter, FileSyncOptions options)

       9: {

      10:     using (FileSyncProvider provider = new FileSyncProvider(replicaRootPath,

      11:         filter, options))

      12:     {

      13:         provider.DetectChanges();

      14:     }

      15: }

The Framework captures the change information which can then be used later in the synchronisation process. You can then change your code that instead of performing a SyncDirectionOrder of UploadAndDownload – you perform 2 SyncDirectionOrder with a value of Upload – once between the source and the target and once between the target and the source. Make sure you use the FileSyncOptions.ExplicitDetectChanges to prevent unnecessary change detection passes.

As well as the DetectingChanges event, there are a number of other EventHandlers that you can hook up on a FileSyncProvider to get useful information:

ApplyingChange – occurs when a change is about to be applied.
AppliedChange – occurs when a change has been applied
SkippedChange – occurs when a change is skipped.

The return value from a SyncOrchestration – Synchronise() operation is of type SyncOperationStatistics and it contains useful information about the changes applied as part of the synchronisation. This could be used to display a report for the user after the synchronisation operation. It contains properties like:

UploadChangesApplied – total number of changes that were successfully applied during the upload session.
DownloadChangesApplied – total number of changes that were successfully applied during the download session.
SyncStartTime – when the synchronisation started.
SyncEndTime – when the synchronisation ended.

So far – we have seen how we can listen for events occurring as part of the synchronisation, and get details for a report at the end of the synchronisation, but what if we want to display a progress bar to indicate to the user how long is left in the synchronisation process? The Sync Framework doesn’t provide this kind of functionality by default as it would incur a reasonable overhead which would be wasted for those who do not require it. However – the FileSyncProvider does provide a preview mode! When this is set to true – it performs all the work of calculating what changes need to be made without actually performing the changes. This allows us to perform the operation initially in preview mode to calculate what changes need to be applied (which we can access by looking at the SyncOperationStatistics), we can capture the events from the operation and display accurate progress information to the user.

I’ve put all of the above information into a sample application that looks like the following:

The source code for this sample application can be downloaded from here.

Hopefully future posts in this series will demonstrate the use of other providers in Microsoft Sync Framework 2.0.

Technorati Tags: Sync Framework

Del.icio.us Digg It Share on Facebook Stumble It!

Windows PowerShell Series - Part 8 – Working with Variables

IvorB — Tue, 29 Jun 2010 13:49:09 GMT

This is part 8 in a series of posts related to Windows PowerShell, and deals with working with Variables.

Those from a programming background will be very used to dealing with variables – it is something we take for granted when doing development. Without variables – it would be very difficult to write any useful scripts as we wouldn’t have anyplace to remember working values.

Variables in Windows PowerShell are prefixed with the dollar sign ($).Variable names are not case sensitive but you should be consistent to make your life easier. By default – any variables you create will exist only in the current session and will be lost when you end your session. There are 4 types of variable:

Automatic – these are created and maintained by Windows PowerShell and users cannot change their values. e.g. $PSHome stores the path to the Windows PowerShell installation directory.
Preference – these are created by Windows PowerShell with default values which the user can change. e.g. $MaximumVariableCount determines how many variables are permitted in a given session.
Environment – these store information about the operating system environment. To list all environment variables – use Get-ChildItem Env:
or to get details about a particular environment variable – use Get-ChildItem Env:ComputerName
User created – these are variable which are created and maintained by the user. When someone refers to a variable – they usually mean this type of variable. e.g. $Today = (Get-Date).date

Windows PowerShell variables are loosely typed which mean they are not limited to a particular variable type of object. The type of a variable is determined by the value it contains. e.g.

In general – most programming languages (like C#) are strongly typed. There can be a number of advantages that using strong types can bring:

Limit the range of values that a variable can contain. e.g. limiting a variable like $Age to integer values. Compilers and other tools can check that we are putting sensible values into appropriate variables.
Improved clarify. e.g. if a “+” operation is performed on 2 integer variables - then we always need to perform an addition. If a “+” operation is performed on 2 string variables – then we always need to perform a string concatenation. With loose/weak typing – the operation depends on the contents of the variables so isn’t always clear.
Improved Performance – optimisations can often be made when the type is known in advance rather than being determined “on the fly”

Windows PowerShell allows us to use the type attribute and cast syntax to constrain a variable to a particular type. Some examples include:

There are a number of Cmdlets which are designed for manipulating variables. These include:

Clear-Variable – Deletes the value for a variable
Get-Variable – Gets the variables in the current console
New-Variable – Creates a new variable
Remove-Variable – Deletes a variable and its value
Set-Variable – Changes the value of a variable.

Windows PowerShell allows us to create constant and read-only variables. While constants and read-only variables are functionality very similar – one difference is that you can delete a read-only variable while you cannot delete a constant. To create constants and read-only variables, use:

See the following for useful information about PowerShell variables:

Next step – Working with Logic

Previous step – What the heck is a Cmdlet?

Technorati Tags: PowerShell

Del.icio.us Digg It Share on Facebook Stumble It!

Windows PowerShell Series - Part 7 – What the heck is a Cmdlet?

IvorB — Fri, 25 Jun 2010 15:14:42 GMT

This is part 7 in a series of posts related to Windows PowerShell, and deals with cmdlets.

Cmdlets (pronounced command-lets) are the smallest units of functionality in Windows PowerShell. They are named in a very specific verb-noun format that should make it obvious what operation the cmdlet performs.

e.g. Get-Date returns the current date and time while Set-Date allows you to set the current date and time.

A useful cmdlet when starting out with Windows PowerShell is Get-Command which returns a complete list of available cmdlets.

The example above also demonstrates pipelining where the output from the Get-Command cmdlet is piped (or redirected) to Format-Wide

Get-Help is also useful in discovering information about available cmdlets, and its output includes some summary information about each cmdlet.

To get detailed information about a particular cmdlet, use Get-Help “cmdlet name”.

There are 2 other variations of Get-Help which provide different levels of information for a cmdlet:

Get-Help “cmdlet” –detailed
Get-Help “cmdlet” –full

You can pass parameters to a cmdlet by using the a dash (-) notation. e.g. if you want to get the current date, but not include the time aspect, you can use the following:

Some standard cmdlets which I recommend looking at include:

Get-Command – Get information about cmdlets
Get-EventLog – Gets events fro man event log
Write-EventLog – Writes an event to the event log
Get-Host – Gets information about the host application
Get-Location – Gets information about your current working location.
Get-Variable – Gets a particular variable
Ping-Computer – Sends a ping
Read-Host – Reads information from the host window
Write-Host – Writes information to the host window.
Start-Service – starts a particular service

Use Get-Help *-* to discover other useful cmdlets.

Next step – Working with Variables

Previous step – Getting to grips with Scripts

Technorati Tags: PowerShell

Del.icio.us Digg It Share on Facebook Stumble It!

Doctor Strange SPN

colinn — Thu, 17 Jun 2010 20:51:00 GMT

Or how I stopped worrying and learned to love Kerberos.

There's been a lot written on configuring Excel Services 2010 and I by no means claim to be an expert on it. However, having just gone through SPN hell trying to get delegation up and running between SharePoint and an SQL Analysis Server I thought I'd share. Turns out there are a couple of items I needed to know but are missing from other posts.

First item worthy of note is that all Kerberos delegation for data refresh relies on the Claims to Windows Token Service. So this has to be up and happy before going any further.

The second noteworthy point is that all delegation must use the Constrained method which isn't as painful as it sounds but isn't particularly intuitive either.

The steps I followed were:

1) Check the Claims to Windows Service

It should be running on all Excel Calculations Servers.
It should be set to Automatic.
It should be using the Local System account. This might look odd but it's the only account the service will run under properly.

2) Identify service accounts. You'll need:

The service account for excel services (e.g. random\excelservices)
The service account for the data server (e.g. random\sqlservice)

3) Either use the SETSPN tool or the ADSIEDIT console to create Service Principal Names (SPNs) from the command line to set up SPNs for each service account. For example if the excel services are on http://App1.randomcom:
Setspn -a HTTP/App1     random\excelservices
Setspn -a HTTP/App1.random.com     random\excelservices

And add SPNs for the back end services,Starting with the Analysis Services:
Setspn -a MSOLAPSvc.3/SQL1     random\sqlService
Setspn -a MSOLAPSvc.3/SQL1.random.com     random\sqlservice

And then the MSSQL Server:
Setspn -a MSSQLSvc/SQL1:1433     random\sqlservice
Setspn -a MSSQLSvc/SQL1.random.com:1433     random\sqlservice

4) Set up constrained delegation for Claims to Windows Token Service and the Excel Service Application.

In Active Directory Users and Computers find the server running Excel Calculation Services and open its properties.
Click the Delegation tab. Select the Trust the computer for delegation to specific services only and under this the radio button Use any authentication protocol. This does seem counter intuitive especially as the other option is Use Kerberos only but no matter the temptation if you don't select "any" then delegation won't work for Excel Services.
Click on the Add button the Add Services dialog will appear. Click on Users or Computers to bring up the Select Users or Computers dialog box.
Now enter either the SQL Server service account or if SQL services are running under Local System the SQL Server name(SQL1).
On pressing OK you'll be returned to the Add Services box which will now have the SQL Server or Analysis Server registered as a service type. Select the service and press OK.
You will be returned the Properties dialog for the Excel Services server. Under the Delegation tab you will now see the SQL Service registered as one the account can now present delegated credential.
Repeat this step for the Excel Services service account.

Repeat for each Excel Services service yu have running and each server you want to delegate credentials between.

And that's it, hopefully.

Del.icio.us Digg It Share on Facebook Stumble It!

Windows PowerShell Series - Part 6 – Getting to grips with Scripts

IvorB — Tue, 11 May 2010 14:13:09 GMT

This is part 6 in a series of posts related to Windows PowerShell, and deals with getting to grips with scripts..

So far – we have been typing commands into the PowerShell console (or the ISE) but what happens if you want to create some functionality which you can reload at a future session. The answer is to create your PowerShell commands as a PowerShell script.

You can either go hard-core and use something like Notepad (or your text editor of choice) to create the script, or you can use the ISE to create and save your script. When saving the script – give it a “.ps1” file extension so PowerShell knows that it’s a script file and not a text file. The extension comes from PowerShell 1.0 and they didn’t feel the need to change the extension for PowerShell 2.0. As you would expect – PowerShell 2.0 can run PowerShell 1.0 scripts, but the reverse is not guaranteed.

Let’s start with our first script – the typical Hello World script!

Save this as HelloWorld.ps1 (or similar). To make your life easier for the moment – make sure there is no space in the file name or anywhere in the path that contains the file name. We’ll worry about handling spaces in a later post.

The logic for this script is extremely simple:

Clear the output
Prompt the user their name and store in a variable
Say hello and repeat the users name by accessing the variable.

You have a number of choices to run this script:

Run it from inside the ISE by pressing F5
Run it from inside the ISE or PowerShell Console by typing the script name (including path) into the command prompt
Run it from a standard console prompt by using the following: powershell [FilePath]\HelloWorld.ps1 where [FilePath] is your relevant directory structure. In my case – my script is stored on my desktop so I’m executing powershell c:\Users\IvorB\Desktop\HelloWorld.ps1"

There you go – you should now have a working Hello World script!

As mentioned in Part 4 of this blog series – security measures are in place to prevent scripts executing without your permission. You have 2 choices at this stage – to digital sign your script, or to adjust your execution policy to allow execution of unsigned scripts. The easiest (and laziest) way to get this to work is to change the execution policy which you can do with the following command:

Set-ExecutionPolicy RemoteSigned.

Next step – What the heck is a Cmdlet?

Previous step – The Integrated Shell Environment (ISE)

Technorati Tags: PowerShell

Del.icio.us Digg It Share on Facebook Stumble It!

Windows PowerShell Series - Part 5 – The Integrated Shell Environment (ISE)

IvorB — Mon, 10 May 2010 15:52:56 GMT

This is part 5 in a series of posts related to Windows PowerShell, and deals with using the Integrated Shell Environment.

So far we have been using the PowerShell Command Shell to execute PowerShell statements but you also have the option of using the Integrated Shell Environment.This is a more graphical rich interface for using PowerShell.

You can launch it in similar ways to the PowerShell Command Shell:

All Programs > Accessories > Windows PowerShell > Windows PowerShell ISE
From a command line prompt (e.g. cmd), type powershell_ise (note the underscore)
Start menu > Search > type powershell_ise (note the underscore)
[Win] + R (for Run command) > type powershell_ise (note the underscore)

The ISE interface is made up of the following:

Script/Editor pane – this is where you will spend most of your time creating scripts. Tabs across the top of the pane allow you to work on multiple scripts at the same time.
Output pane – this is where the output from executing your script is displayed.
Command pane – you can enter ad-hoc commands in this pane. It effectively behaves as a standard PowerShell Command Shell

This type of interface is a bit more familiar to those who are used to Visual Studio, although perhaps a little basic in direct comparison:

You have a text area where you can enter your script
Your have toolbar buttons to control script execution
You have basic debugging facilities.
Useful context sensitive help – highlight a command in the script window and press F1
Execute part of the scripts without running the whole thing (highlight the text you want to run and choose “Run Selection”
You can customise the environment by changing $psISE.Options including adding new menu options.

The first time I attempt to debug a script in the ISE – I couldn’t figure out how to set a breakpoint. Coming from a Visual Studio background – I am used to creating a breakpoint whenever and where-ever I like. However – the ISE refused to create my breakpoint. I eventually figured out that you simply need to save your script and you then get access to the debugging facilities. You also need to remember that breakpoints are only remembered for your session – once you close the ISE and fire it up again – you’ve lost all your previous breakpoints.

At this stage, its also worthwhile mentioning that Quest provides a free graphical user interface and script editor for Windows PowerShell called PowerGUI. This is definitely worth a look if you are going to be doing a lot with PowerShell.

Next step – Getting to grips with scripts

Previous step – Customise via Commands

Technorati Tags: PowerShell

Del.icio.us Digg It Share on Facebook Stumble It!

Windows PowerShell Series - Part 4 – Customise via Commands

IvorB — Wed, 05 May 2010 10:48:22 GMT

This is part 4 in a series of posts related to Windows PowerShell, and deals with customising the PowerShell console through use of PowerShell commands.

We’re seen previously how you can Customise the appearance of the PowerShell command by tweaking the properties of the console. However, you can also issue PowerShell commands which affect the appearance of the console.

The command Get-Host gives you a reference to ConsoleHost object. This has a UI property which manages a lot of the UI details for the console, and this in turn has a RawUI property which gives access to colour, title etc. e.g. (Get-Host).UI.RawUI gives the following:

We use brackets around Get-Host to ensure this is evaluated first, before we access the UI property of the return object.

If you want to save a bit of typing, you can use $Host.UI.RawUI to return the same information. $Host is a special variable that is a reference to the current console object.

The property values can be changed, so you can do something like the following to get a console that looks like a standard command console:

If you change some of the properties like background-color, you might want to use the command Clear-Host to “refresh” the entire console window.

Changing the Window Size or Position is slightly more complicated as these are “complex” objects rather than simple properties. The easiest way to change these types of properties is to store the current value in a variable, and then adjust property values on the variable. e.g:

Here we store the current WindowSize in a variable called $WindowSize, adjust its Width property and then set the WindowSize back to the Console.

It would be quite tedious if you had to issue the same commands to setup your Console environment every time you wanted to use PowerShell, so the solution is to adjust your profile. You can find out where your current/active profile is stored by viewing the special variable $profile. You should find that your default profile is stored in a file called something like Microsoft.PowerShell_profile.ps1. You can now put whatever commands you like in this file (by using Notepad or similar) and these commands will be executed every time you start a PowerShell console. If the folder or file don’t already exist – just create them and everything should just work fine.

You might find that the first time you try this, that you get an error like “Microsoft.PowerShell_profile.ps1 is not digitally signed”. This is deliberate by Microsoft to prevent scripts executing without your permission. We’ll discuss signing of scripts and execution policies in a later article, but for the moment – the fastest (and laziest) way to get this to work is to change PowerShell to allow execution of local scripts which are unsigned. You can do this by issuing the following PowerShell command:

Set-ExecutionPolicy RemoteSigned

You can find loads of information about customising the PowerShell console at the following location: Customise the PowerShell Console

Next step – The Integrated Shell Environment (ISE)

Previous step – Customise the Console

Technorati Tags: PowerShell

Del.icio.us Digg It Share on Facebook Stumble It!

Mobile Technologies To Watch In 2010 & 2011

rogerw — Wed, 05 May 2010 10:44:00 GMT

I caught site of this useful Gartner article on mobile technologies to watch out for in 2010 and 2011. Rather than repeat it all in this blog I’ll just give you the link at:

http://www.gartner.com/it/page.jsp?id=1328113

The comments around widgets, AppStores focussed equally on B2E and B2C channels, and the mobile web, all look interesting from a development perspective. Mobile technologies (particular mobile web) have been an elusive “next big thing” for a while, so the realising all of the promise is key. Much of this will come down to ability to package the technology into usable and universal formats.

Many of the technologies listed are evolutions of what is already out there in the market place. Perhaps with the publicity hype and profile created by the IPad and the promised ubiquity of this technology in all devices (not just the high end ones), the reality may be a shorter step away.

Del.icio.us Digg It Share on Facebook Stumble It!

Windows PowerShell Series - Part 3 – Customise the Console

IvorB — Tue, 04 May 2010 16:08:20 GMT

This is part 3 in a series of posts related to Windows PowerShell, and deals with customising the PowerShell console.

If you use the PowerShell console frequently, it is probably worth spending a bit of time to customise it to your exact tastes. You are going to be looking at the console quite a bit, so you may as well have it exactly the way you want it!

To begin customising your console, fire up the PowerShell console and right click the title bar and choose properties. From the properties menu, you then have the choice of 4 tabs:

Options
Font
Layout
Colours

Options

Cursor Size: Fairly obvious – I find the default of “small” fine for normal use.
Command History: The command history is a buffer of previous commands in the current session. You can access previous commands in the session by using the arrow keys (up and down and press Enter to choose a particular command), press F7 to display a pop up window that contains the list of buffered commands or type the first few letters of the command to execute and press F8.
Edit Options: QuickEdit mode allows you to single mouse click to paste into the command window (rather than right clicking and choosing paste). InsertMode means that you default to inserting a new command and clearing this option means that you overwrite text as the default editing mode.

Font

Allows you to adjust the font used in the console window. I personally increate the font size to “12 x 16” which I find easier on the eye.

Layout

Screen Buffer Size: This controls the virtual window size which is the amount of content the window can actually hold. If the virtual window size is larger than the actual window size, then the console window changes to include scrollbars.
Window Size: The size of the physical window. You should probably make the width the same as the screen buffer size width to avoid horizontal scroll bars.
Window Position: Uncheck Let system position window if you want to control the initial position of the window.

Colours

Allows you to set the foreground and background colours used by the PowerShell console.

Click OK to save your settings to your user profile. Note: You may need to run PowerShell as Administrator in order for your settings to be saved. It is also worth noting that your changes are only applicable to the shortcut that you used to start PowerShell.

Next step – Customise via Commands

Previous step – Installation

Technorati Tags: PowerShell

Del.icio.us Digg It Share on Facebook Stumble It!

Windows PowerShell Series - Part 2 - Installation

IvorB — Fri, 30 Apr 2010 11:07:00 GMT

This is part 2 in a series of posts related to Windows PowerShell, and deals with Installation

The good news if you are running Windows 7 or Windows Server 2008 R2 (or later) is that you have nothing to do – PowerShell V2 was installed as part of the operating system.

If you have a different operating system and want to install PowerShell – you have to choose between PowerShell V1 and PowerShell V2. The only reason I can think of to choose PowerShell V1 is if you were working as part of a team where everyone is using that version. If possible – just go for PowerShell V2 as it includes a vast number of additional commands.

PowerShell is installed as part of Windows Management Framework so visit Microsoft Support for install packages for a number of different platforms.

Once PowerShell is on your system, fire it up by any of the following methods:

All Programs > Accessories > Windows PowerShell > Windows PowerShell V2
From a command line prompt (e.g. cmd), type powershell
Start menu > Search > type powershell
[Win] + R (for Run command) > type powershell

Whatever method you try, the result should be the same – the PowerShell command prompt which should look like:

Once you’ve got the PowerShell console open – let’s confirm that you have V2 installed by typing the following command:

get-host

You should see something like the following:

Assuming you have got the same – then we are good to go.

Next step – Customise the Console

Previous step – Introduction

Technorati Tags: PowerShell

Del.icio.us Digg It Share on Facebook Stumble It!

Windows PowerShell Series - Part 1 - Introduction

IvorB — Thu, 29 Apr 2010 16:38:00 GMT

This is the start of a number of posts related to Windows PowerShell. The goal is that each post will introduce a single concept, and build upon previous posts in the series. We’re going to start off with a very gentle introduction which will hopefully explain “What is Windows PowerShell?”

Windows PowerShell is the latest command line shell and scripting language from Microsoft. An initial reaction might be “Do we really need another shell?” and my answer is that you should give it a go. If you like it – use it. If you don’t like it – then chances are you will be able to achieve whatever you need to do some other way. What PowerShell does really well is bring together a large number of commands, make their usage consistent and makes it really easy for you to build your own powerful scripts.

PowerShell implements a scripting language based upon C# and an object model based upon Microsoft .NET framework. As such – it is incredibly easy for someone with a developer background to pick it up. However – System Administrators will also love the fact that they will be able to use PowerShell to manage Active Directory, Exchange, Windows File System, Windows Services and a wide variety of other essential system infrastructure components.

This series will attempt to cover as many aspects of PowerShell as possible, but feel free to make suggestions for content to cover.

Next step – Installing PowerShell…

Technorati Tags: PowerShell

Del.icio.us Digg It Share on Facebook Stumble It!

Getting Ahead - Windows Phone 7 Series Developer Training Kit Announced

rogerw — Fri, 23 Apr 2010 08:10:00 GMT

For those of you itching to get ahead with Windows Phone 7 Series development, Microsoft have just announced a Windows Phone 7 Series Developer Training Kit. This is aimed at beginners onwards and caters for all the new technologies announced in Windows Phone 7 Series, including XNA, Silverlight etc. You don’t need to be an expert in these technologies to benefit, you just need a knowledge of Visual Studio and Microsoft .NET Framework.

The following course units are covered:

Getting Started with Windows Phone
Silverlight for Windows Phone
XNA Framework 4.0 for Windows Phones

I am part way through the first unit at time of writing.

Windows Phone 7 promises to be an interesting release and there is a lot riding on it for Microsoft. As XNA is one of the technologies underlying the Xbox 360 Gaming console it promises to be particularly interesting in that arena.

If you want to find out more about the kit and download it, you can do so at:

http://channel9.msdn.com/learn/courses/WP7TrainingKit/

Del.icio.us Digg It Share on Facebook Stumble It!

The SharePoint Ironman

colinn — Wed, 21 Apr 2010 13:11:47 GMT

Nope no Robert Downey Jnr in this one you’ll have to wait until April 30th for that (in the UK at least). This was Mike Watson (a man who used to play with tanks on a professional basis) taking the SharePoint Evolution attendees through the major enhancements to SharePoint which will make high availability solutions a little easier to architect and deploy.

Mike started with a rundown of the major issues with SharePoint 2007:

Granular Recovery – ah that look on a client’s face when you tell them just exactly what they will have to go through now that 1k text document they deleted has exited the recycle bin (cue exasperated sighs stage left). Just a simple matter of recovering that backed up database to a web app and then finding the document concerned – a doddle
Disaster Recovery – a small list of laundry for this one that can only truly be satisfied by a sub list:
- No native support for mirroring – let’s do the swap over by hand or rely on some cludgy scripts
- Everything can be made redundant, apart from that indexy bit and if that goes and you’re reliant on search apps? Just how many documents do you have to crawl? You weren’t planning on doing anything over the next couple of days/weeks/months were you?
- Robust backup – let’s back up everything. Yip content, config… you want to restore config? Ok but that’s you unsupported as far as Microsoft is concerned. They didn’t mention that?

Ok various vendors have spent millions and made millions producing tools to sort these issues out. But does SharePoint 2010 handle them in anyway?

Mike Watson seems to believe… sometimes. Here is what I gleaned concerning these issues.

Granular Recovery – well the good news is you won’t have to restore the content DB backup to a SharePoint Farm, Hidden in the depths of 2010 Central Administration is a command called Granular Recovery from unattached database. And backup now goes down to the list level. Certainly an improvement but I doubt the likes of Quest and AvePoint will be packing up their tools and leaving the SharePoint scene anytime soon. Anybody who has used one of these tools to search and retrieve an item from a backup file (no restoring to SQL) will know why.

Native support for mirroring – Now you can tell your SharePoint sites where the failover database is. If SharePoint cannot contact the principal node (I think it’s in 10 seconds) then it will attempt to contact the failover. This in my humble (well not so I am blogging after all) is brilliant. Unfortunately you still need to set up the SQL side from SQL but when combined with a witness server this could be a very useful addition.

Index Server – this is now the Crawl Server, I know you just get used to one set of names and acronyms and then they change (wait until you find out about BDC, still a SharePointy acronym but doesn’t quite mean what it used to). Anyway, with the brand new service architecture the single point of failure is gone in 2010. It’ll even support mirroring if you really want to (more redundancy and you know what redundancy makes? Yep license sales).

Robust backup – the reason Microsoft didn’t support mirroring and restore for the config database in 2007 was the sheer volatility of the data. In 2010 they do support backup and restore. The config backup saves settings to an XML file which could even be restored to a completely separate farm, in theory. Mr Watson was quick to point out that he hadn’t seen it done.

So some great improvements, especially around redundancy and mirroring. Should make complying to those SLAs a little easier.

Del.icio.us Digg It Share on Facebook Stumble It!

Cloud Computing - Seeing Through The Mist – An Introduction

rogerw — Wed, 21 Apr 2010 11:17:00 GMT

Progress But More To Do

Over the past nine months, I have been getting increasingly involved in the world of Windows Azure and Cloud Computing and its usage in the world of custom development with web and mobile applications. With Windows Azure officially launched and operational, an enterprise looking to put part of their IT infrastructure and business processes into a cloud-based environment, now has some significant alternatives to choose from, with all the major online players (Microsoft, Google, Amazon) represented.

Significant technical and regulatory challenges remain in the area of data security and integration. In turn, many of these challenges are both cultural and geo-political in origin. However the ease and flexibility of delivering cloud solutions is progressing with each evolution of the toolsets. I’ll be covering further aspects of this and its integration to the .Net and Windows Mobile worlds in future articles.

Virtually There….Or There….

Broken into its component elements, Cloud Computing is not a new concept. The idea of centralised provision of IT facilities, commodity priced server hardware and the provision of ubiquitous network bandwidth have all been around for a very long time (remember mainframe bureaus anyone?) . What is key to the growth of cloud computing is the coming together of these technologies with the ability to virtualise operating systems and platforms and deploy at short notice. This enables multiple often un-related virtual machines to reside on one physical host. These “virtual machines” can be moved, duplicated and started at will and are key to the flexible nature of cloud provision. The more constant and homogenous the virtual platform image the easier the operational management aspects.

The greater the degree of virtualisation the greater the ability to scale application provision on demand. Economies of scale mean that if a third party has enough virtual capacity and can manage and guarantee the service levels needed, they can rent the virtual platform to whoever needs it. The whole cost model is built on demand being elastic so that varying levels of spare capacity is always available to service the needs of other organisations. Correspondingly solutions which require continuously high level of custom resource provision, for long periods, tend not to extract the maximum value from many cloud computing charging models.

‘Cloud Computing’ – a problem of definition

Although the technology choices may be getting clearer, the sheer volume of marketing hype and differing interpretations, mean that it is often unclear what exactly is meant by the term “Cloud Computing”. Different institutions and commercial organisations have different definitions for this depending on their heritage and technology preference etc. However, there are several common agreed scenarios commercially available as follows:

IaaS – Infrastructure-as-a-Service – this is largely based on the provision of virtualised infrastructure platforms by a third party. A customer can run and manage their own operating system platforms (patch levels, deployed software etc) but the third party manages the underlying infrastructure. Cost is normally based on resource usage and some form of metering mechanism.
PaaS - Platform-as-a-Service – this uses virtualisation to deliver both application and operating system, Applications are decoupled from specific infrastructure locations and provision is increased and duplicated to match the anticipated and actual levels of user demand. Costs are normally based on resource usage, agreed service level and levels of inbound and outbound data.
SaaS – Software-as-a-Service – this is a fully managed application delivered to a customer as a service. Application software facilities are effectively rented, often on a per user per month basis. Customisation in a limited form is usually permitted but very often only via changes made by the cloud provider.

Inside Or Outside The Enterprise – ‘Private’ versus ‘Public’ Cloud

The pure definition and implementation of most of these concepts would consider them to be deployed totally externally to the organisation and run by a third party on the their behalf. For many organisations such (banks, central and local government etc) the regulatory or data security concerns means that a “public cloud” offering is simply not viable. Some large organisations also have made very significant investments in very large data centres that are equally capable of running similar solutions but in a secure “private" cloud manner. Solutions for this space are only just starting to emerge in the UK and USA but when combined with virtualisation this will be a growth technology area for specific sectors. The benefits are only truly realised however in very large enterprise scale where redundant infrastructure capacity can be harnessed and delivered.

Arise the Hybrid…..

Many more astute organisation are learning that greater benefits can be obtained by the use of ‘hybrid clouds’. These maximise the cost and availability benefits of any public cloud offering where appropriate, but also obtain the maximum value from existing internal investment and functional provision. Toolsets and frameworks such as Windows Azure Platform AppFabric are increasing progressing, so as to allow solutions which use on-site and cloud integrations together in one place.

I’ll return to this subject of Cloud Computing in future posts, as there are many technical and non-technical issues to consider. We’ll also look at the key high level issues in moving applications to cloud based platforms.

Useful Articles

In the meantime, to find out more information about Cloud Computing it is worth taking a look at the following sources:

Above The Clouds Paper – University of Berkeley – often considered one of the “classic” cloud computing academic papers. It covers the theoretical concepts behind cloud computing and can be found at: http://www.eecs.berkeley.edu/Pubs/TechRpts/2009/EECS-2009-28.html
‘Outlook: partly cloudy with sunny spells to follow’ – this is a paper on Hybrid Cloud computing and many other aspects of Cloud Computing by Matt Deacon from Microsoft and Dan Scarfe from Dot Net Solutions Ltd, which is available here.
Windows Azure Platform – A series of white papers on Windows Azure are available at http://www.microsoft.com/windowsazure/whitepapers/

Del.icio.us Digg It Share on Facebook Stumble It!

Some SharePoint 2010 Limits

colinn — Tue, 20 Apr 2010 07:55:18 GMT

In Mike Watson’s talk on SQL planning he highlighted some recently published numbers for SharePoint 2010 capacity:

Category	2007 Capacity	2010 Capacity
Content Database	100 GB	200 GB
File Size*	2 GB	2 GB
Databases per web app	100	300
Site Collection Size	100 GB	100 GB
List Items per view	2000	5000

* This is a boundary limit dictated by the SQL field. Larger files require another solution such as Remote Blob Storage (RBS).

As with 2007, apart from the file size limit, a lot is going to depend on the structure of your data and the size of the files saved. Only the File Size is a ‘hard’ limit the rest is the point where Microsoft would expect a degradation of performance.

Del.icio.us Digg It Share on Facebook Stumble It!

SharePoint Governance 101at Evolution 2010

colinn — Mon, 19 Apr 2010 14:14:00 GMT

Was sat in a talk by Paul Turner of HP Software (he’s their World Wide Services Competency leader for SharePoint). The subject was Designing Information Management for the Masses but as you can probably guess what it boiled down to was a matter of governance and Paul reminded me of the four main tenets of any good SharePoint Governance Plan:

People – clear vision and defined roles and responsibilities
Technology – service level agreements
Policy – design and usage principles
Process – common tasks that need to performed

And why do you need governance? Well top of the list for me is ‘SharePoint sprawl’. Giving those users the ability to create content, sometimes hideously complex content and solutions, can result in an explosive growth of sites, sub sites and even site collections. Even I with my simple dev background can understand the potential impact of allowing users to add content ungoverned. From a usability perspective there is the inability to find useful content and if users can’t find what their looking for the system will soon fall into disrepute and alternatives will be found (watch them mail boxes grow once more) From an infrastructure view unchecked content can lead to a strain on network and database resources.

Content quality will be hit too if there are no policy on metadata or the location certain assets should be saved to. It can also impair decision making if the data is difficult to find and assimilate then the business leaders are going to be unable to make informed, timely decisions.

Finally – ok finally for this simplistic article, there’s plenty out there on the subject – without proper governance from the outset there is a risk that the SharePoint implementation will never be fully aligned with the business and thus the business will never get full value from it. Naturally, this then runs the risk of the business never valuing the platform and the implementation and indeed product forging a reputation of failure.

Del.icio.us Digg It Share on Facebook Stumble It!

SharePoint Evolution 2010 Keynote

colinn — Mon, 19 Apr 2010 12:18:29 GMT

The Icelandic fire gods have taken their toll on the conference with much reorganisation of the agenda to give those speakers who haven’t made it the chance of getting here by Wednesday.

Still, as Steve Smith pointed out in the keynote there were cons and pros to the situation, some folks couldn’t make it to the UK but then others couldn’t leave and they have been enlisted to ensure the conference goes on.

The mystery keynote speakers were revealed, as well as Mr Smith, Eric Shupps, Spencer Harbar and Brett Lonsdale took to the stage to give attendees a good dose of nostalgia.

Whether the audience wanted to be reminded of the “quirky charm” of 2001, 2003 and 2007 versions of SharePoint I’m not sure but there were a few of us older types with tears in our eyes (some may have been joyful most I suspect not, one chap beside me started to shake and mutter) as we were taken through the delights of SharePoint’s growth from small web based storage app to all conquering integration and application platform.

From the basic document management available in 2001 (though allegedly not a recognised member of the family) through the introduction of SQL in 2003 and finally to the feature/solution package deployment framework.

Of course nobody could answer the question, why did Microsoft stick with that blue?

Del.icio.us Digg It Share on Facebook Stumble It!

SharePoint Evolution Conference 2010

colinn — Sun, 18 Apr 2010 18:46:47 GMT

Tomorrow is the first day of the SharePoint Evolution Conference in London. The conference is going ahead despite the best efforts of Icelandic volcanoes; planes may be grounded, the sky may be awash with ash but SharePoint carries on regardless!

With the RTM released this month and the official launch only a few weeks away the conference has a very 2010 feel to it, there’s not too much for those interested in 2007. I guess this is understandable, it’s a technology conference and if there’s one thing that technologists like it's something that can have the adjectives ‘new’, ‘shiny’ and ‘improved’ placed in front of them (unless it’s washing powder – not really too excited by that).

The speakers have a familiar feel Spencer Harbar, Eric Shupps, Mike Watson, Steve Smith, Joel Oleson, Andrew Connell, Bill English to name but a few. All of these guys will have by now had extensive exposure to the supposed wonder that is SharePoint 2010 (supposed? no,truly it is wonderful!) and it’ll be interesting to hear what they have learned since Vegas’ conference.

One mystery remains. Who will deliver the keynote? Having spent literally seconds exploring the Evolution Conference site I can find no clues…

Del.icio.us Digg It Share on Facebook Stumble It!

SharePoint 2010 and Office 2010 Launch

alistairl — Mon, 08 Mar 2010 09:42:32 GMT

Arpan Shah has blogged over at Microsoft that May 12th, 2010 is the launch date for SharePoint 2010 and Office 2010. In addition, they have announced intent to RTM this April 2010. Take a look at the post over on the SharePoint Team Blog which I recommend you keep up to date with if you are interested in SharePoint.

The release of the RTM is quite exciting for us as this is a way for key customers to be ready with SharePoint 2010 ahead of May. If you would like to know more then please get in touch.

Del.icio.us Digg It Share on Facebook Stumble It!

The Shared Services Provider is Dead…

colinn — Tue, 02 Feb 2010 20:34:00 GMT

…eh long live services ‘a la carte’ – somebody from marketing really needs to get hold of that one! (and please excuse my French).

What it means is this -

In SharePoint 2007 the Shared Services Provider was a specialist web application (two if you include MySites) which looked after Enterprise Search, Profiling, Excel Services and the Business Data Catalog.

Although this worked pretty well it had a couple of major limitations -

It’s not a scalable model – you could have more than one SSP in a server farm but if the desire was to have a slightly different flavour of SSP, for example specialist or restricted search it was a lot of overhead.
It wasn’t granular – SSP’s had very coarse permissions, once a site was attached to an SSP it had all the services running on it. Administrators either had access to the SSP configuration site and all services or they didn’t!

No finesse at all!

The new Service Application Model is broken into discreet service applications allowing web applications to be more finely tailored to their user base.

This is done through a series of proxies which are assigned into Proxy Groups. In a straight 2010 installation there will be a Default Proxy Group which web applications will automatically take on. Services can belong to more than one group and (wait for it) more than one instance of a service can be running in a farm. So for example the Excel Services service Finance uses may not be the same as the one in use by Marketing.

Naturally, you can create your own Proxy Groups.

This does come at cost, more granular services means more information to keep in state which results in more databases for the SQL Server and the associated maintenance attached to that. To take the People service, which runs MySites in 2010 amongst other things, as an example (albeit an extreme one); this service requires 3 databases to operate.

And it’s not alone with those hard disk eating, processor stomping needs…

Del.icio.us Digg It Share on Facebook Stumble It!

Virtual Ignite SharePoint 2010 Training for IT PRO

colinn — Mon, 01 Feb 2010 07:29:47 GMT

This week I’m attending Ignite Training for SharePoint 2010.

I will of course be posting any interesting bits that come up.

But the format is quite interesting with a mixture of presenters, labs, video and live meetings all done over the web. It remains to be seen whether this can engage attendees fully without face to face contact. I suspect discipline on all sides will be required.

Del.icio.us Digg It Share on Facebook Stumble It!