/// <summary>
        /// Create a cloud runtime application, essentialy this is a tuple of runtime X package X role
        /// </summary>
        /// <param name="cloudRuntime">The runtime in the tuple</param>
        /// <param name="cloudRuntimePackage">The package in the tuple</param>
        /// <param name="role">The role to apply the package to</param>
        /// <returns>The tuple, use the apply method to apply the runtime as specified</returns>
        public static CloudRuntimeApplicator CreateCloudRuntimeApplicator(CloudRuntime cloudRuntime, CloudRuntimePackage cloudRuntimePackage, WorkerRole role)
        {
            CloudRuntimeApplicator applicator = new CloudRuntimeApplicator
            {
                Runtime = cloudRuntime,
                Package = cloudRuntimePackage,
                WorkerRole = role
            };

            return applicator;
        }

 protected override string GenerateWarningText(CloudRuntimePackage package)
 {
     return null;
 }

 public override bool Match(CloudRuntimePackage runtime)
 {
     return true;
 }

            protected override void ApplyScaffoldingChanges(CloudRuntimePackage package)
            {
                string rootPath = GeneralUtilities.GetServiceRootPath(FilePath);

                if (CloudServiceProject.Components.StartupTaskExists(RoleName, Resources.CacheStartupCommand))
                {
                    CloudServiceProject.Components.SetStartupTaskVariable(
                        RoleName,
                        Resources.CacheRuntimeUrl,
                        package.PackageUri.ToString(),
                        Resources.CacheStartupCommand);
                }
                else
                {
                    Variable emulated = new Variable
                    {
                        name = Resources.EmulatedKey,
                        RoleInstanceValue = new RoleInstanceValueElement
                        {
                            xpath = "/RoleEnvironment/Deployment/@emulated"
                        }
                    };
                    Variable cacheRuntimeUrl = new Variable
                    {
                        name = Resources.CacheRuntimeUrl,
                        value = package.PackageUri.ToString()
                    };

                    CloudServiceProject.Components.AddStartupTask(
                        RoleName,
                        Resources.CacheStartupCommand,
                        ExecutionContext.elevated,
                        emulated,
                        cacheRuntimeUrl);
                }
            }

            protected override bool GetChanges(CloudRuntimePackage package, out Dictionary<string, string> changes)
            {
                base.GetChanges(package, out changes);

                Debug.Assert(changes.ContainsKey(Resources.RuntimeTypeKey), "Cache runtime should be added before calling this method");
                Debug.Assert(changes.ContainsKey(Resources.RuntimeUrlKey), "Cache runtime should be added before calling this method");

                changes[Resources.CacheRuntimeVersionKey] = package.Version;

                return true;
            }

        public virtual void ApplyRuntime(CloudRuntimePackage package, WorkerRole workerRole)
        {
            Dictionary<string, string> changes;
            if (this.GetChanges(package, out changes))
            {
                ApplyRoleXmlChanges(changes, workerRole);
            }

            ApplyScaffoldingChanges(package);
        }

        public virtual bool ValidateMatch(CloudRuntimePackage runtime, out string warningText)
        {
            warningText = null;
            bool result = this.Match(runtime);
            if (!result)
            {
                warningText = this.GenerateWarningText(runtime);
            }

            return result;
        }