Example #1
0
 /// <summary>
 /// Determine if this is a variable that should be set directly or should be merged with the new value
 /// </summary>
 /// <param name="variableToCheck"></param>
 /// <returns>True if the variable should be merged, false if the value should be replaced instead</returns>
 private static bool ShouldMerge(Variable variableToCheck)
 {
     return string.Equals(variableToCheck.name, Resources.RuntimeTypeKey,
         StringComparison.OrdinalIgnoreCase) || string.Equals(variableToCheck.name,
         Resources.RuntimeUrlKey, StringComparison.OrdinalIgnoreCase);
 }
Example #2
0
            protected override void ApplyScaffoldingChanges(CloudRuntimePackage package)
            {
                string rootPath = General.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);
                }
            }
Example #3
0
 static void ClearEnvironmentValue(Variable[] environment, string key)
 {
     foreach (Variable variable in environment)
     {
         if (string.Equals(key, variable.name, StringComparison.OrdinalIgnoreCase))
         {
             variable.value = "";
         }
     }
 }
Example #4
0
 /// <summary>
 /// Set the variable value given a new value. Replace or add the value to the variable, as appropriate
 /// </summary>
 /// <param name="inVariable">The variable to change</param>
 /// <param name="addedValue">The new value to </param>
 private static void SetVariableValue(Variable inVariable, string addedValue)
 {
     if (!string.IsNullOrEmpty(inVariable.value) && ShouldMerge(inVariable))
     {
         if (inVariable.value.IndexOf(addedValue, 0, inVariable.value.Length, StringComparison.OrdinalIgnoreCase) == -1)
         {
             inVariable.value = string.Concat(inVariable.value, ";", addedValue);
         }
     }
     else
     {
         inVariable.value = addedValue;
     }
 }
Example #5
0
        private static Variable[] ApplySettingChanges(Dictionary<string, string> settings, Variable[] roleVariables)
        {
            int roleVariableCount = (roleVariables == null ? 0 : roleVariables.Length);
            if (roleVariableCount > 0)
            {
                for (int j = 0; j < roleVariables.Length; ++j)
                {
                    if (settings.ContainsKey(roleVariables[j].name))
                    {
                        SetVariableValue(roleVariables[j], settings[roleVariables[j].name]);
                        settings.Remove(roleVariables[j].name);
                    }
                }
            }

            int settingsCount = (settings == null ? 0 : settings.Count);
            Variable[] newSettings = new Variable[settingsCount + roleVariableCount];
            int i = 0;
            foreach (string key in settings.Keys)
            {
                newSettings[i] = new Variable { name = key, value = settings[key] };
                ++i;
            }

            for (int j = 0; j < roleVariables.Length; ++j)
            {
                newSettings[i + j] = roleVariables[j];
            }

            return newSettings;
        }
 /// <summary>
 /// Adds the specified runtime environment setting to the specified runtime environment - either changes the setting in 
 /// the environment if the setting already exists, or adds a new setting if it does not
 /// </summary>
 /// <param name="environment">The source runtime environment</param>
 /// <param name="keyName">The variable key</param>
 /// <param name="keyValue">The variable value</param>
 /// <returns>The runtime environment with the given setting applied</returns>
 private static Variable[] SetRuntimeEnvironment(IEnumerable<Variable> environment, string keyName, string keyValue)
 {
     Variable v = environment.FirstOrDefault<Variable>(variable => string.Equals(variable.name, keyName,
         StringComparison.OrdinalIgnoreCase));
     if (v != null)
     {
         v.value = keyValue;
         return environment.ToArray<Variable>();
     }
     else
     {
         v = new Variable { name = keyName, value = keyValue };
         return environment.Concat<Variable>(new List<Variable> { v }).ToArray<Variable>();
     }
 }
        /// <summary>
        /// Apply the specified Variable values to the specified role's startup task environment
        /// </summary>
        /// <param name="definition">The service definition containing the role</param>
        /// <param name="roleName">The name of the role to change</param>
        /// <param name="environment">The Variables containing the changes</param>
        /// <returns>true if the variables environment is successfully changed</returns>
        private static bool ApplyRuntimeChanges(ServiceDefinition definition, string roleName, Variable[] environment)
        {
            WebRole webRole;
            if (TryGetWebRole(definition, roleName, out webRole))
            {
                CloudRuntime.GetRuntimeStartupTask(webRole.Startup).Environment = environment;
                return true;
            }

            WorkerRole workerRole;
            if (TryGetWorkerRole(definition, roleName, out workerRole))
            {
                CloudRuntime.GetRuntimeStartupTask(workerRole.Startup).Environment = environment;
                return true;
            }

            return false;
        }
        /// <summary>
        /// Sets a startup task environment variable.
        /// </summary>
        /// <param name="roleName">The role name</param>
        /// <param name="name">The environment variable name</param>
        /// <param name="value">The environment variable value</param>
        /// <param name="commandLines">The command line to match task.</param>
        public void SetStartupTaskVariable(string roleName, string name, string value, params string[] commandLines)
        {
            Task task = GetStartupTask(roleName, commandLines);
            bool found = false;

            if (task != null && task.Environment != null)
            {
                for (int i = 0; i < task.Environment.Length; i++)
                {
                    if (task.Environment[i].name.Equals(name, StringComparison.OrdinalIgnoreCase))
                    {
                        task.Environment[i].value = value;
                        found = true;
                        break;
                    }
                }

                if (!found)
                {
                    Variable var = new Variable() { name = name, value = value };
                    task.Environment = General.ExtendArray<Variable>(task.Environment, var);
                }
            }
        }
        /// <summary>
        /// Applies required configuration for enabling cache in SDK 1.8.0 version by:
        /// * Add MemcacheShim runtime installation.
        /// * Add startup task to install memcache shim on the client side.
        /// * Add default memcache internal endpoint.
        /// * Add cache diagnostic to local resources.
        /// * Add ClientDiagnosticLevel setting to service configuration.
        /// * Adjust web.config to enable auto discovery for the caching role.
        /// </summary>
        /// <param name="azureService">The azure service instance</param>
        /// <param name="webRole">The web role to enable caching on</param>
        /// <param name="isWebRole">Flag indicating if the provided role is web or not</param>
        /// <param name="cacheWorkerRole">The memcache worker role name</param>
        /// <param name="startup">The role startup</param>
        /// <param name="endpoints">The role endpoints</param>
        /// <param name="localResources">The role local resources</param>
        /// <param name="configurationSettings">The role configuration settings</param>
        private void Version180Configuration(
            AzureService azureService,
            string roleName,
            bool isWebRole,
            string cacheWorkerRole,
            Startup startup,
            Endpoints endpoints,
            LocalResources localResources,
            ref DefinitionConfigurationSetting[] configurationSettings)
        {
            if (isWebRole)
            {
                // Generate cache scaffolding for web role
                azureService.GenerateScaffolding(Path.Combine(Resources.CacheScaffolding, RoleType.WebRole.ToString()),
                    roleName, new Dictionary<string, object>());

                // Adjust web.config to enable auto discovery for the caching role.
                string webCloudConfigPath = Path.Combine(azureService.Paths.RootPath, roleName, Resources.WebCloudConfig);
                string webConfigPath = Path.Combine(azureService.Paths.RootPath, roleName, Resources.WebConfigTemplateFileName);

                UpdateWebConfig(roleName, cacheWorkerRole, webCloudConfigPath);
                UpdateWebConfig(roleName, cacheWorkerRole, webConfigPath);
            }
            else
            {
                // Generate cache scaffolding for worker role
                Dictionary<string, object> parameters = new Dictionary<string, object>();
                parameters[ScaffoldParams.RoleName] = cacheWorkerRole;

                azureService.GenerateScaffolding(Path.Combine(Resources.CacheScaffolding, RoleType.WorkerRole.ToString()),
                    roleName, parameters);
            }

            // Add startup task to install memcache shim on the client side.
            string cacheRuntimeUri = CloudRuntimeCollection.GetRuntimeUrl(Resources.CacheRuntimeValue, CacheRuntimeVersion);
            Debug.Assert(!string.IsNullOrEmpty(cacheRuntimeUri));
            Variable emulated = new Variable { name = Resources.EmulatedKey, RoleInstanceValue = new RoleInstanceValueElement { xpath = "/RoleEnvironment/Deployment/@emulated" } };
            Variable[] env = { emulated, new Variable { name = Resources.CacheRuntimeUrl, value = cacheRuntimeUri } };
            Task shimStartupTask = new Task { Environment = env, commandLine = Resources.CacheStartupCommand, executionContext = ExecutionContext.elevated };
            startup.Task = General.ExtendArray<Task>(startup.Task, shimStartupTask);

            // Add default memcache internal endpoint.
            InternalEndpoint memcacheEndpoint = new InternalEndpoint
            {
                name = Resources.MemcacheEndpointName,
                protocol = InternalProtocol.tcp,
                port = Resources.MemcacheEndpointPort
            };
            endpoints.InternalEndpoint = General.ExtendArray<InternalEndpoint>(endpoints.InternalEndpoint, memcacheEndpoint);

            // Enable cache diagnostic
            LocalStore localStore = new LocalStore
            {
                name = Resources.CacheDiagnosticStoreName,
                cleanOnRoleRecycle = false
            };
            localResources.LocalStorage = General.ExtendArray<LocalStore>(localResources.LocalStorage, localStore);

            DefinitionConfigurationSetting diagnosticLevel = new DefinitionConfigurationSetting { name = Resources.CacheClientDiagnosticLevelAssemblyName };
            configurationSettings = General.ExtendArray<DefinitionConfigurationSetting>(configurationSettings, diagnosticLevel);

            // Add ClientDiagnosticLevel setting to service configuration.
            AddClientDiagnosticLevelToConfig(azureService.Components.GetCloudConfigRole(roleName));
            AddClientDiagnosticLevelToConfig(azureService.Components.GetLocalConfigRole(roleName));
        }