public static void StartupTaskExists(Task[] tasks, string startupCommand)
{
Assert.IsTrue(Array.Exists<Task>(tasks, t => t.commandLine == startupCommand));
}
public static void RuntimeUrlAndIdExists(Task[] tasks, string runtimeValue)
{
Assert.IsTrue(Array.Exists<Task>(tasks, t => Array.Exists<Variable>(t.Environment,
e => e.value != null && e.value.Contains(runtimeValue))));
Assert.IsTrue(Array.Exists<Task>(tasks, t => Array.Exists<Variable>(t.Environment,
e => e.value != null && e.value.Contains(string.Format("http://az413943.vo.msecnd.net/{0}/", runtimeValue)))));
}
public static void RuntimeIdExists(Task[] tasks, string runtimeValue)
{
Assert.IsTrue(Array.Exists<Task>(tasks, t => Array.Exists<Variable>(t.Environment,
e => e.value != null && e.value.Contains(runtimeValue))));
}
/// <summary>
/// Return the value for the specified setting, if it exists in the given runtime environment
/// </summary>
/// <param name="environment">The runtime environment to search</param>
/// <param name="key">The name of the setting</param>
/// <param name="value">The value of the setting, if it is found, null otherwise</param>
/// <returns>true if the setting is found in the given environment</returns>
private static bool TryGetEnvironmentValue(Task[] tasks, string key, out string value)
{
value = string.Empty;
foreach (Task task in tasks)
{
Variable[] environment = task.Environment;
value = null;
if (environment != null)
{
foreach (Variable setting in environment)
{
if (string.Equals(setting.name, key, StringComparison.OrdinalIgnoreCase))
{
value = setting.value;
return true;
}
}
}
}
return false;
}
/// <summary>
/// Adds new startup task to the given role.
/// </summary>
/// <param name="roleName">The role name</param>
/// <param name="commandLine">The startup task command line</param>
/// <param name="context">The execution context</param>
/// <param name="variables">The environment variables</param>
public void AddStartupTask(
string roleName,
string commandLine,
ExecutionContext context,
params Variable[] variables)
{
Startup roleStartup = GetRoleStartup(roleName) ?? new Startup();
Task newTask = new Task
{
Environment = variables,
commandLine = commandLine,
executionContext = context
};
roleStartup.Task = General.ExtendArray<Task>(roleStartup.Task, newTask);
}
/// <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));
}