public void GetAzureRuntimesProcess(string runtimeType, string manifest = null)
{
CloudRuntimeCollection runtimes;
CloudRuntimeCollection.CreateCloudRuntimeCollection(out runtimes, manifest);
WriteObject(runtimes.Where <CloudRuntimePackage>(p => string.IsNullOrEmpty(runtimeType) ||
p.Runtime == CloudRuntime.GetRuntimeByType(runtimeType)).ToList <CloudRuntimePackage>(), true);
}
/// <summary>
/// Retrieve the runtimes from the given manifest, or from the default cloud location, if none given.
/// The manifest parameter is mainly a testing hook.
/// </summary>
/// <param name="runtimeType">The runtime type to filter by</param>
/// <param name="rootPath">The path to the service in question</param>
/// <param name="manifest">The path to the manifest file, if null, the default cloud manifest is used (test hook)</param>
public void GetAzureRuntimesProcess(string runtimeType, string rootPath, string manifest = null)
{
AzureService service = new AzureService(rootPath, null);
CloudRuntimeCollection runtimes = service.GetCloudRuntimes(service.Paths, manifest);
WriteObject(runtimes.Where <CloudRuntimePackage>(p => string.IsNullOrEmpty(runtimeType) ||
p.Runtime == CloudRuntime.GetRuntimeByType(runtimeType)), true);
}
public void TestGetRuntimes()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
AzureService service = new AzureService(files.RootPath, serviceName, null);
service.AddWebRole(Resources.NodeScaffolding);
string manifest = RuntimePackageHelper.GetTestManifest(files);
CloudRuntimeCollection collection = service.GetCloudRuntimes(service.Paths, manifest);
RuntimePackageHelper.ValidateRuntimesMatchManifest(manifest, collection);
}
}
public void TestGetRuntimes()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string manifest = RuntimePackageHelper.GetTestManifest(files);
CloudRuntimeCollection runtimes;
CloudRuntimeCollection.CreateCloudRuntimeCollection(out runtimes, manifest);
cmdlet.GetAzureRuntimesProcess(string.Empty, manifest);
IEnumerable <CloudRuntimePackage> actual = System.Management.Automation.LanguagePrimitives.GetEnumerable(mockCommandRuntime.OutputPipeline).Cast <CloudRuntimePackage>();
Assert.Equal <int>(runtimes.Count, actual.Count());
Assert.True(runtimes.All <CloudRuntimePackage>(p => actual.Any <CloudRuntimePackage>(p2 => p2.PackageUri.Equals(p.PackageUri))));
}
}
public void TestGetRuntimes()
{
using (FileSystemHelper files = new FileSystemHelper(this))
{
string manifest = RuntimePackageHelper.GetTestManifest(files);
CloudRuntimeCollection runtimes;
CloudRuntimeCollection.CreateCloudRuntimeCollection(out runtimes, manifest);
cmdlet.GetAzureRuntimesProcess(string.Empty, manifest);
List <CloudRuntimePackage> actual = mockCommandRuntime.OutputPipeline[0] as List <CloudRuntimePackage>;
Assert.AreEqual <int>(runtimes.Count, actual.Count);
Assert.IsTrue(runtimes.All <CloudRuntimePackage>(p => actual.Any <CloudRuntimePackage>(p2 => p2.PackageUri.Equals(p.PackageUri))));
}
}
/// <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));
}
