示例#1
0
 public static void ClearRuntime(WebRole role)
 {
     Task startupTask = GetRuntimeStartupTask(role.Startup);
     if (startupTask != null)
     {
         ClearEnvironmentValue(startupTask.Environment, Resources.RuntimeUrlKey);
         ClearEnvironmentValue(startupTask.Environment, Resources.CacheRuntimeUrl);
     }
 }
        /// <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, WebRole role)
        {
            CloudRuntimeApplicator applicator = new CloudRuntimeApplicator
            {
                Runtime = cloudRuntime,
                Package = cloudRuntimePackage,
                WebRole = role
            };

            return applicator;
        }
示例#3
0
        internal override void AddRoleToDefinition(ServiceDefinition def, object template)
        {
            WebRole webRole = template as WebRole;
            var toAdd = new WebRole[] { webRole };

            if (def.WebRole != null)
            {
                def.WebRole = def.WebRole.Concat(toAdd).ToArray();
            }
            else
            {
                def.WebRole = toAdd;
            }
        }
        private static string GetForwarderName(WebRole[] webRoles, WorkerRole[] workerRoles)
        {
            string forwarderName = null;
            WorkerRole workerForwarder = workerRoles.FirstOrDefault(r => r.Imports != null &&
                r.Imports.Any(i => i.moduleName == "RemoteForwarder"));
            if (workerForwarder != null)
            {
                // a worker role has the forwarder
                forwarderName = workerForwarder.name;
            }
            else
            {
                WebRole webForwarder = webRoles.FirstOrDefault(r => r.Imports != null &&
                    r.Imports.Any(i => i.moduleName == "RemoteForwarder"));
                if (webForwarder != null)
                {
                    // a web role has the forwarder
                    forwarderName = webForwarder.name;
                }
            }

            return forwarderName;
        }
 private static void RemoveOtherRemoteForwarders(WebRole[] webRoles, WorkerRole[] workerRoles, string forwarderName)
 {
     // Remove RemoteForwarder from all but the chosen role
     foreach (WebRole webRole in webRoles)
     {
         if (webRole.name != forwarderName &&
             webRole.Imports != null &&
             webRole.Imports.Any(i => i.moduleName == "RemoteForwarder"))
         {
             webRole.Imports = webRole.Imports.Where(i => i.moduleName != "RemoteForwarder").ToArray();
         }
     }
     foreach (WorkerRole workerRole in workerRoles)
     {
         if (workerRole.name != forwarderName &&
             workerRole.Imports != null &&
             workerRole.Imports.Any(i => i.moduleName == "RemoteForwarder"))
         {
             workerRole.Imports = workerRole.Imports.Where(i => i.moduleName != "RemoteForwarder").ToArray();
         }
     }
 }
 private static string GetForwarderName(WebRole[] webRoles, WorkerRole[] workerRoles)
 {
     string forwarderName = null;
     WorkerRole workerForwarder = workerRoles.FirstOrDefault(r => r.Imports != null && r.Imports.Any(i => i.moduleName == "RemoteForwarder"));
     if (workerForwarder != null)
     {
         // a worker role has the forwarder
         forwarderName = workerForwarder.name;
     }
     else
     {
         WebRole webForwarder = webRoles.FirstOrDefault(r => r.Imports != null && r.Imports.Any(i => i.moduleName == "RemoteForwarder"));
         if (webForwarder != null)
         {
             // a web role has the forwarder
             forwarderName = webForwarder.name;
         }
         else
         {
             // no role has the forwarder yet
             WorkerRole firstWorkerRole = workerRoles.FirstOrDefault();
             if (firstWorkerRole != null)
             {
                 firstWorkerRole.Imports = General.Append(firstWorkerRole.Imports, new Import { moduleName = "RemoteForwarder" });
                 forwarderName = firstWorkerRole.name;
             }
             else // no worker role, use a web role
             {
                 WebRole firstWebRole = webRoles.FirstOrDefault();
                 if (firstWebRole != null)
                 {
                     firstWebRole.Imports = General.Append(firstWebRole.Imports, new Import { moduleName = "RemoteForwarder" });
                     forwarderName = firstWebRole.name;
                 }
                 else
                 {
                     throw new InvalidOperationException(Resources.EnableAzureRemoteDesktop_Enable_NoRoles);
                 }
             }
         }
     }
     return forwarderName;
 }
 private static void AddRemoteAccess(WebRole[] webRoles, WorkerRole[] workerRoles)
 {
     // Add RemoteAccess to all roles
     foreach (WebRole webRole in webRoles.Where(r => r.Imports == null || !r.Imports.Any(i => i.moduleName == "RemoteAccess")))
     {
         webRole.Imports = General.Append(webRole.Imports, new Import { moduleName = "RemoteAccess" });
     }
     foreach (WorkerRole workerRole in workerRoles.Where(r => r.Imports == null || !r.Imports.Any(i => i.moduleName == "RemoteAccess")))
     {
         workerRole.Imports = General.Append(workerRole.Imports, new Import { moduleName = "RemoteAccess" });
     }
 }
示例#8
0
        private static Dictionary<string, string> GetStartupEnvironment(WebRole webRole)
        {
            Dictionary<string, string> settings = new Dictionary<string, string>();
            foreach (Variable variable in GetRuntimeStartupTask(webRole.Startup).Environment)
            {
                settings[variable.name] = variable.value;
            }

            return settings;
        }
示例#9
0
 private static void ApplyRoleXmlChanges(Dictionary<string, string> changes, WebRole webRole)
 {
     GetRuntimeStartupTask(webRole.Startup).Environment = ApplySettingChanges(changes, GetRuntimeStartupTask(webRole.Startup).Environment);
 }
示例#10
0
        public virtual void ApplyRuntime(CloudRuntimePackage package, WebRole webRole)
        {
            Dictionary<string, string> changes;
            if (this.GetChanges(package, out changes))
            {
                ApplyRoleXmlChanges(changes, webRole);
            }

            ApplyScaffoldingChanges(package);
        }
示例#11
0
 public static Collection<CloudRuntime> CreateRuntime(WebRole webRole, string rolePath)
 {
     return GetRuntimes(GetStartupEnvironment(webRole), webRole.name, rolePath);
 }
 /// <summary>
 /// Try to get the specified web role from the given definiiton
 /// </summary>
 /// <param name="definition">The service definiiton</param>
 /// <param name="roleName">The name of the role</param>
 /// <param name="role">output variable where the webRole is returned</param>
 /// <returns>true if the web role is found in the given definition</returns>
 private static bool TryGetWebRole(ServiceDefinition definition, string roleName, out WebRole role)
 {
     role = definition.WebRole.FirstOrDefault<WebRole>(r => string.Equals(r.name, roleName,
         StringComparison.OrdinalIgnoreCase));
     return role != null;
 }
 public static void VerifyWebRole(WebRole role, bool isForwarder)
 {
     Assert.AreEqual(isForwarder ? 1 : 0, role.Imports.Where(i => i.moduleName == "RemoteForwarder").Count());
     Assert.AreEqual(1, role.Imports.Where(i => i.moduleName == "RemoteAccess").Count());
 }