public async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser> manager) { // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie); // Add custom user claims here ClaimsPrincipal claimsPrincipal = Thread.CurrentPrincipal as ClaimsPrincipal; //TODO: look-up the roles from the DB! string userId = userIdentity.Claims.Single(x => x.Type == ClaimTypes.NameIdentifier).Value; ApplicationDbContext context = new ApplicationDbContext(); Identity identity = context.Identities.Single(x => x.NameIdentifier == userId); userIdentity.AddClaim(new Claim(SpecialClaimTypes.UserId, identity.IdentityId.ToString(), ClaimValueTypes.Integer)); if (identity.SubscriptionIdentityRoles.Any()) { //get first found subscription //TODO: update the databasee to be in line with the entity model code first foreach (int subscriptionId in identity.SubscriptionIdentityRoles.Select(x=>x.SubscriptionId).Distinct()) { userIdentity.AddClaim(new Claim(SpecialClaimTypes.Subscription, subscriptionId.ToString())); } } return userIdentity; }
private void AssigUserSubscriptionRoles() { using (var context = new ApplicationDbContext()) { var roles = context.SubscriptionIdentityRoles.Where(x => x.IdentityId == UnitOfWork.CurrentIdentity.IdentityId && x.SubscriptionId == UnitOfWork.ActiveSubscriptionId).Select(y => y.Role).ToList(); var email = context.Identities.Where(x => x.IdentityId == UnitOfWork.CurrentIdentity.IdentityId).Select(x => x.Email).First(); Session[String.Format("Roles{0}", email)] = roles; } }
// GET: Training public ActionResult Index() { using (var context = new ApplicationDbContext()) { var email = context.Identities.Where(x => x.IdentityId == UnitOfWork.CurrentIdentity.IdentityId).Select(x => x.Email).First(); var roles = Session[String.Format("Roles{0}", email)]; if (roles != null) { ViewBag.IsOwnerOrTrainer = ((List<string>)roles).Contains(RoleTypes.Owner) || ((List<string>)roles).Contains(RoleTypes.Trainer); } } return View(); }
public AzureTestController(ILogger logger, AzureFacadeFactory azureFacadeFactory) { _logger = logger; using (ApplicationDbContext context = new ApplicationDbContext()) { Subscription subscription = context.Subscriptions .Single(x => x.SubscriptionId == 1); _vmManagement = azureFacadeFactory.VMManagement(subscription.AzureSubscriptionId, subscription.Certificate, subscription.CertificateKey, subscription.BlobStorageName, subscription.BlobStorageKey); } }
public void End(EndSessionRequest request) { using (ApplicationDbContext context = new ApplicationDbContext()) { string version = request.Version.ToString(); //Session session = context.Sessions.Single(x => x.SessionId == request.SessionId); Session session = context.Sessions.Single(x => x.SessionId == request.SessionId); //check if the request is no longer valid if (session.Version != request.Version.ToString()) { _logger.InfoFormat("EndSessionRequest for Sessionid: {0} was ignored because Removed: {1} and Version: {2}", request.SessionId, session.Removed, request.Version); return; } _logger.InfoFormat("Deleting VMs for SessionId: {0} ({1} - {2})", session.SessionId, session.StartDate, session.EndDate); Subscription subscription = context.Subscriptions .Single(x => x.SubscriptionId == session.SubscriptionId); IVMManagement vmManagement = AzureFacadeFactory.VMManagement(subscription.AzureSubscriptionId, subscription.Certificate, subscription.CertificateKey, subscription.BlobStorageName, subscription.BlobStorageKey); //TODO: need to keep service name in the session string vmNameBase = "tn" + session.SessionId + "vm"; vmManagement.DeleteService(vmNameBase); foreach (VirtualMachine vm in session.VirtualMachines.Where(x => !x.Deleted)) { vm.Deleted = true; } context.SaveChanges(); _logger.InfoFormat("Deleted VMs for SessionId: {0} ({1} - {2})", session.SessionId, session.StartDate, session.EndDate); } }
public ActionResult Index(SubscriptionCreateModel model) { Subscription subscription = new Subscription { BlobStorageKey = model.BlobStorageKey, BlobStorageName = model.BlobStorageName, CertificateKey = model.CertificateKey, AzureSubscriptionId = model.AzureSubscriptionId }; BinaryReader r = new BinaryReader(Request.Files[0].InputStream); subscription.Certificate = r.ReadBytes(Request.Files[0].ContentLength); using (ApplicationDbContext context = new ApplicationDbContext()) { context.Subscriptions.Add(subscription); context.SaveChanges(); } return View(); }
public ActionResult Index() { ViewBag.IsSignedUser = false; ViewBag.IsMember = false; if (HttpContext.User.Identity.IsAuthenticated) { AssigUserSubscriptionRoles(); using (var context = new ApplicationDbContext()) { var email = context.Identities.Where(x => x.IdentityId == UnitOfWork.CurrentIdentity.IdentityId).Select(x => x.Email).First(); var roles = Session[String.Format("Roles{0}", email)]; if (roles != null) { ViewBag.IsSignedUser = true; ViewBag.IsMember = ((List<string>)roles).Contains(RoleTypes.Member); } } } return View(); }
public void AssignCertificate(int subscriptionId, int identityId) { //create subscription if doesn't exist, otherwise update with new certificate CertificateSet certificateSet = CreateCertificate(); //save the cer and pfx to local folder for debugging (si it me, or does that sound like a bad idea?) SaveCertificatesLocally(subscriptionId.ToString(), certificateSet); //TODO: finish implementation - send email using (ApplicationDbContext context = new ApplicationDbContext()) { Subscription subscription = context.Subscriptions.Single(x => x.SubscriptionId == subscriptionId); subscription.CertificateKey = certificateSet.Password; subscription.Certificate = certificateSet.PfxRawData; context.SaveChanges(); Identity identity = context.Identities.Single(x => x.IdentityId == identityId); Email.BuildAssignCertificateEmail(identity, subscription, certificateSet.CerRawData).Send(); } }
public bool AddUserSubscriptionRole(string role, string identityId) { var success = false; try { if (string.IsNullOrWhiteSpace(role) || string.IsNullOrWhiteSpace(identityId)) return false; if (role == RoleTypes.Trainer || role == RoleTypes.Owner) { using (var context = new ApplicationDbContext()) { var subscription = context.Subscriptions.Where(x => x.SubscriptionId == UnitOfWork.ActiveSubscriptionId).FirstOrDefault(); var identity = context.Identities.Where(x => x.IdentityId.ToString() == identityId).FirstOrDefault(); if (subscription != null && identity != null && !context.SubscriptionIdentityRoles.Any(x => x.Role == role && x.IdentityId == identity.IdentityId && x.SubscriptionId == subscription.SubscriptionId)) { context.SubscriptionIdentityRoles.Add(new SubscriptionIdentityRole() { SubscriptionId = subscription.SubscriptionId, IdentityId = identity.IdentityId, Role = role }); context.SaveChanges(); success = true; } } } return success; } catch (Exception) { return false; } }
public async Task<string> ReadyForCapture(string templateVmKey) { _logger.Info("Entering AzureManagement.ReadyForCapture"); string result = "OK"; try { using (ApplicationDbContext repository = new ApplicationDbContext()) { Guid key = new Guid(templateVmKey); TemplateVM templateVM = repository.TemplateVMs.Single(x => x.Key == key); templateVM.State = (int)TemplateVMStatusEnum.ReadyToCapture; templateVM.StateChangedTimestamp = DateTimeOffset.Now; repository.SaveChanges(); //schedule the check and capture in 5 minutes await Messaging.SendAsync(new VMReadyForCaptureRequest { TemplateVMId = templateVM.TemplateVMId }, DateTime.UtcNow.AddMinutes(5)); } } catch (Exception ex) { _logger.Fatal("Exception when marking VM for capture.", ex); result = "Error"; } _logger.Info("Exiting AzureManagement.ReadyForCapture"); return result; }
public PoRepository() { _context = new ApplicationDbContext(); }
private void SaveInvites(IList<string> emailList) { using (var context = new ApplicationDbContext()) { var identity = context.Identities.Where(x => x.IdentityId == UnitOfWork.CurrentIdentity.IdentityId).FirstOrDefault(); var subscription = context.Subscriptions.Where(x => x.SubscriptionId == UnitOfWork.ActiveSubscriptionId).FirstOrDefault(); if (identity != null && subscription != null) { foreach (var email in emailList) { if (!context.Invitations.Where(x => x.Identity.IdentityId == identity.IdentityId && x.Subscription.SubscriptionId == subscription.SubscriptionId && x.Email == email).Any()) { context.Invitations.Add(new Invitation() { Email = email, Identity = identity, Subscription = subscription, IdentityId = identity.IdentityId, SubscriptionId = subscription.SubscriptionId, Processed = false }); context.SaveChanges(); } } } } }
public IEnumerable<VirtualMachineImageModel> AvailableTemplateImages() { Subscription subscription; List<string> preferredVmFamilies; using (ApplicationDbContext context = new ApplicationDbContext()) { subscription = context.Subscriptions.Single(x => x.SubscriptionId == UnitOfWork.ActiveSubscriptionId); preferredVmFamilies = context.RecommendedVMImages.Select(x => x.ImageFamily).ToList(); } IVMManagement management = AzureFacadeFactory.VMManagement(subscription.AzureSubscriptionId, subscription.Certificate, subscription.CertificateKey, subscription.BlobStorageName, subscription.BlobStorageKey); List<VirtualMachineImageModel> vmImageList = management.GetAvailableTemplateImages(VmImageSourceEnum.All, preferredVmFamilies); // Filter the image list: // User images must check if are for the current subscription // also enrich the user images with a friendly description using (ApplicationDbContext context = new ApplicationDbContext()) { int subscriptionId = UnitOfWork.ActiveSubscriptionId; List<TemplateVM> subscriptionTemplates = context.TemplateVMs .Where(x=>x.SubscriptionId == subscriptionId).ToList(); List<string> subscriptionImageNames = subscriptionTemplates.Select(x=>x.ImageName).ToList(); vmImageList = vmImageList.Where(x => !x.IsUserImage || subscriptionImageNames.Contains(x.Name)) .ToList(); foreach(VirtualMachineImageModel image in vmImageList.Where(x=>x.IsUserImage)) { image.Description = subscriptionTemplates.Single(x => x.ImageName == image.Name).Description; } } return vmImageList; }
public IEnumerable<object> AvailableSubscriptions() { using (ApplicationDbContext context = new ApplicationDbContext()) { int activeSubscriptionId = UnitOfWork.CurrentIdentity.ActiveSubscriptionId; var availableSubscriptions = context.Subscriptions.Where(x => x.SubscriptionIdentityRoles.Any(y => y.SubscriptionId == activeSubscriptionId)).Distinct().ToList() .Select(x=> new { SubscriptionId = x.SubscriptionId, SubscriptionName = x.Name, Active = x.SubscriptionId == UnitOfWork.ActiveSubscriptionId }); return availableSubscriptions; } }
public void Start(StartSessionRequest request) { using (ApplicationDbContext context = new ApplicationDbContext()) { Session session = context.Sessions.Single(x => x.SessionId == request.SessionId); //Session session = context.Sessions.Single(x => x.Version == version); //check if the session is canceled or the request is no longer valid if (session.Removed || (session.Version != request.Version.ToString())) { _logger.InfoFormat("StartSessionRequest for Sessionid: {0} was ignored because Removed: {1} and Version: {2}", request.SessionId, session.Removed, request.Version); return; } _logger.InfoFormat("Spawning VMs for SessionId: {0} ({1} - {2})", session.SessionId, session.StartDate, session.EndDate); Subscription subscription = context.Subscriptions .Single(x => x.SubscriptionId == session.SubscriptionId); IVMManagement vmManagement = AzureFacadeFactory.VMManagement(subscription.AzureSubscriptionId, subscription.Certificate, subscription.CertificateKey, subscription.BlobStorageName, subscription.BlobStorageKey); //TODO: remove the hardcoding at some point in time string NorthEurope = "North Europe"; VMConfigModel vmConfig = new VMConfigModel(session.Lab.ImageName, NorthEurope) { VmSize = (VmSizeEnum)Enum.Parse(typeof(VmSizeEnum), session.VmSize) }; var sessionUsers = session.SessionUsers.ToList(); var vmUsers = new List<VMUserModel>(); sessionUsers.ForEach(x => { //TODO: wrong logic.. not all sessions are based on templates var templateVM = context.TemplateVMs.Where(y => y.IdentityId == x.IdentityId && y.SubscriptionId == subscription.SubscriptionId).FirstOrDefault(); if (templateVM != null) { vmUsers.Add(new VMUserModel { IdentityId = x.IdentityId, Username = templateVM.VMAdminUser, Password = templateVM.VMAdminPass }); } }); //figure out a URL friendly name for the vm names string vmNameBase = "tn" + session.SessionId + "vm"; var assignedVMs = vmManagement.GenerateVMsForUsers(vmNameBase, vmConfig, vmUsers); foreach (var assignedVM in assignedVMs) { VirtualMachine virtualMachine = new VirtualMachine { IdentityId = assignedVM.UserId, VmAdminPass = assignedVM.Password, VmAdminUser = assignedVM.UserName, VmName = assignedVM.VmName, VmRdpPort = assignedVM.VmRdpPort }; session.VirtualMachines.Add(virtualMachine); context.SaveChanges(); } _logger.InfoFormat("Spawned VMs for SessionId: {0} ({1} - {2})", session.SessionId, session.StartDate, session.EndDate); _logger.InfoFormat("Sending emails for SessionId: {0} ({1} - {2})", session.SessionId, session.StartDate, session.EndDate); //well.. this is a hack //TODO: send the correct service name, that should be returned from the Azure Facade Email.BuildSessionEmails(session, vmNameBase).Send(); } }
public bool RemoveUserFromSubscription(string identityId) { var success = false; try { if (string.IsNullOrWhiteSpace(identityId)) return false; using (var context = new ApplicationDbContext()) { var subscription = context.Subscriptions.Where(x => x.SubscriptionId == UnitOfWork.ActiveSubscriptionId).FirstOrDefault(); var identity = context.Identities.Where(x => x.IdentityId.ToString() == identityId).FirstOrDefault(); if (subscription == null || identity == null) return false; var subscriptionRoles = context.SubscriptionIdentityRoles.Where(x => x.IdentityId == identity.IdentityId && x.SubscriptionId == subscription.SubscriptionId); foreach (var subscriptionRole in subscriptionRoles.ToList()) { context.SubscriptionIdentityRoles.Remove(context.SubscriptionIdentityRoles.Where(x => x.SubscriptionIdentityRoleId == subscriptionRole.SubscriptionIdentityRoleId).FirstOrDefault()); context.SaveChanges(); success = true; } } return success; } catch (Exception) { return false; } }
public List<string> GetLoggedInUserSubscriptionRoles() { var loggedInUserRoles = new List<string>(); using (var context = new ApplicationDbContext()) { var identity = context.Identities.Where(x => x.IdentityId == UnitOfWork.CurrentIdentity.IdentityId).FirstOrDefault(); var subscription = context.Subscriptions.Where(x => x.SubscriptionId == UnitOfWork.ActiveSubscriptionId).FirstOrDefault(); if (identity != null && subscription != null) { var roles = context.SubscriptionIdentityRoles.Where(x => x.IdentityId == identity.IdentityId && x.SubscriptionId == subscription.SubscriptionId); if (roles.Any()) roles.ToList().ForEach(x => loggedInUserRoles.Add(x.Role)); } } return loggedInUserRoles; }
private void CreateSubscriptionIdentityMap(Subscription subscription, int identityId) { using (ApplicationDbContext context = new ApplicationDbContext()) { CreateSubscriptionIdentityMap(subscription, context, RoleTypes.Member); CreateSubscriptionIdentityMap(subscription, context, RoleTypes.Owner); CreateSubscriptionIdentityMap(subscription, context, RoleTypes.Trainer); context.SaveChanges(); } }
private int GetIdentityIdByUserId(string userId) { try { var identityId = 0; using (var context = new ApplicationDbContext()) { identityId = context.Identities.Single(x => x.NameIdentifier == userId).IdentityId; } return identityId; } catch(Exception) { return 0; } }
private bool CheckAndHandleUserInvites(int identityId, string email) { try { using (var context = new ApplicationDbContext()) { var invitations = context.Invitations.Where(x => x.Email == email && x.Processed == false); var identity = context.Identities.Where(x => x.IdentityId == identityId).FirstOrDefault(); if (!invitations.Any() || identity == null) return false; foreach (var invitation in invitations.ToList()) { var subscription = context.Subscriptions.Where(x => x.SubscriptionId == invitation.SubscriptionId).FirstOrDefault(); if (subscription != null) { if (!context.SubscriptionIdentityRoles.Any(x => x.IdentityId == identityId && x.Subscription.SubscriptionId == invitation.SubscriptionId && x.Role == RoleTypes.Member)) { context.SubscriptionIdentityRoles.Add(new SubscriptionIdentityRole() { Subscription = subscription, IdentityId = identity.IdentityId, Role = RoleTypes.Member }); } invitation.Processed = true; context.Entry(invitation).State = EntityState.Modified; context.SaveChanges(); } } } return true; } catch (Exception) { return false; } }
public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl) { if (User.Identity.IsAuthenticated) { return RedirectToAction("Index", "Manage"); } if (ModelState.IsValid) { // Get the information about the user from the external login provider var info = await AuthenticationManager.GetExternalLoginInfoAsync(); if (info == null) { return View("ExternalLoginFailure"); } var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user); if (result.Succeeded) { result = await UserManager.AddLoginAsync(user.Id, info.Login); if (result.Succeeded) { ApplicationDbContext context = new ApplicationDbContext(); Core.Repository.Identity identity = new Identity { IdentityProvider = "", NameIdentifier = user.Id, Email = model.Email, DisplayName = "", FirstName = model.FirstName, LastName = model.LastName }; context.Identities.Add(identity); context.SaveChanges(); Email.BuildSignUpEmail(identity).Send(); CheckAndHandleUserInvites(identity.IdentityId, model.Email); await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); return RedirectToLocal(returnUrl); } } AddErrors(result); } ViewBag.ReturnUrl = returnUrl; return View(model); }
public void Start(StartSessionRequest request) { using (ApplicationDbContext context = new ApplicationDbContext()) { Session session = context.Sessions.Single(x => x.SessionId == request.SessionId); //Session session = context.Sessions.Single(x => x.Version == version); Identity trainer = session.TrainerId != 0 ? context.Identities.Where(x => x.IdentityId == session.TrainerId).FirstOrDefault() : context.Identities.Where(x => x.IdentityId == (context.SubscriptionIdentityRoles.Where(y => y.SubscriptionId == session.SubscriptionId && y.Role == "Owner").FirstOrDefault()).IdentityId).FirstOrDefault(); //figure out a URL friendly name for the vm names string vmNameBase = "tn" + session.SessionId + "vm"; try { //check if the session is canceled or the request is no longer valid if (session.Removed || (session.Version != request.Version.ToString())) { _logger.InfoFormat("StartSessionRequest for Sessionid: {0} was ignored because Removed: {1} and Version: {2}", request.SessionId, session.Removed, request.Version); return; } _logger.InfoFormat("Spawning VMs for SessionId: {0} ({1} - {2})", session.SessionId, session.StartDate, session.EndDate); Subscription subscription = context.Subscriptions.Single(x => x.SubscriptionId == session.SubscriptionId); IVMManagement vmManagement = AzureFacadeFactory.VMManagement(subscription.AzureSubscriptionId, subscription.Certificate, subscription.CertificateKey, subscription.BlobStorageName, subscription.BlobStorageKey); //TODO: remove the hardcoding at some point in time string NorthEurope = "North Europe"; VMConfigModel vmConfig = new VMConfigModel(session.Lab.ImageName, NorthEurope) { VmSize = (VmSizeEnum)Enum.Parse(typeof(VmSizeEnum), session.VmSize) }; var sessionUsers = session.SessionUsers.ToList(); var vmUsers = new List<VMUserModel>(); RandomProvider randomProvider = new RandomProvider(); sessionUsers.ForEach(x => { vmUsers.Add(new VMUserModel { IdentityId = x.IdentityId, Username = x.Identity != null ? string.Format("{0}.{1}", x.Identity.FirstName, x.Identity.LastName) : string.Empty, Password = randomProvider.SecurePassword(8) }); }); Email.BuildSessionStartVmsEmails(trainer.FirstName, trainer.Email, session, vmNameBase, vmUsers.Count).Send(); var assignedVMs = vmManagement.GenerateVMsForUsers(vmNameBase, vmConfig, vmUsers); foreach (var assignedVM in assignedVMs) { VirtualMachine virtualMachine = new VirtualMachine { IdentityId = assignedVM.UserId, VmAdminPass = assignedVM.Password, VmAdminUser = assignedVM.UserName, VmName = assignedVM.VmName, VmRdpPort = assignedVM.VmRdpPort }; session.VirtualMachines.Add(virtualMachine); context.SaveChanges(); } _logger.InfoFormat("Spawned VMs for SessionId: {0} ({1} - {2})", session.SessionId, session.StartDate, session.EndDate); _logger.InfoFormat("Sending emails for SessionId: {0} ({1} - {2})", session.SessionId, session.StartDate, session.EndDate); //well.. this is a hack //TODO: send the correct service name, that should be returned from the Azure Facade Email.BuildSessionEndVmsEmails(trainer.FirstName, trainer.Email, session.SessionName, vmNameBase, vmUsers.Count, assignedVMs.Count).Send(); Email.BuildSessionEmails(session, vmNameBase).Send(); } catch(Exception ex) { Email.BuildProblemStartingVmsEmails(trainer.FirstName, trainer.Email, session.SessionName, vmNameBase, ex.InnerException != null ? ex.InnerException.Message : "Error in starting the virtual machine(s).").Send(); throw ex; } } }
private void CreateSubscriptionIdentityMap(Subscription subscription, ApplicationDbContext context, string role) { SubscriptionIdentityRole subscriptionIdentity = new SubscriptionIdentityRole { Subscription = subscription, IdentityId = UnitOfWork.CurrentIdentity.IdentityId, Role = role }; context.SubscriptionIdentityRoles.Add(subscriptionIdentity); }
public string BaseVmProvisionedWithExtensions(string templateVmKey) { _logger.Info("Entering AzureManagement.BaseVmProvisionedWithExtensions"); string result = "OK"; try { using (ApplicationDbContext repository = new ApplicationDbContext()) { Guid key = new Guid(templateVmKey); TemplateVM templateVm = repository.TemplateVMs.Single(x => x.Key == key); Email.BuildTemplateVMReady(templateVm).Send(); } } catch (Exception ex) { _logger.Fatal("Exception when marking VM provisioned.", ex); result = "Error"; } _logger.Info("Exiting AzureManagement.BaseVmProvisionedWithExtensions"); return result; }
public int CheckForAvailableResources(int subscriptionId, DateTimeOffset sessionStart, DateTimeOffset sessionEnd) { int availableCPUs; using (ApplicationDbContext context = new ApplicationDbContext()) { //TODO: move warmUP and coolDown into the config TimeSpan warmUp = new TimeSpan(0, 20, 0); //there is an extra +5 as this is a safe assumption as how long will it take for azure to //delete the VMs TimeSpan coolDown = new TimeSpan(0, 30 + 5, 0); DateTimeOffset start = sessionStart.Subtract(warmUp); DateTimeOffset end = sessionEnd.Add(coolDown); var sameWindowSessions = context.Sessions.Where(x => x.SubscriptionId == subscriptionId && x.StartDate <= end && x.EndDate >= start && !x.Removed).ToList(); //int projectedCPUs = sameWindowSessions.Sum(x => Sessions.CalculateSessionCPUs(x)); int projectedCPUs = MaxOverlappingCPUs(sameWindowSessions); //now check how many VMs programmed are running at the moment List<VmSizeEnum> runningVMs = context.VirtualMachines .Where(x => !x.Deleted && !x.Stopped && x.Session.SubscriptionId == subscriptionId) .Select(x => x.Session.VmSize).ToList() .Select(x => (VmSizeEnum)Enum.Parse(typeof(VmSizeEnum), x)).ToList(); int currentPlannedCPUs = runningVMs.Sum(x => (int)x); Subscription subscription = context.Subscriptions .Single(x => x.SubscriptionId == subscriptionId); IVMManagement management = AzureFacadeFactory.VMManagement(subscription.AzureSubscriptionId, subscription.Certificate, subscription.CertificateKey, subscription.BlobStorageName, subscription.BlobStorageKey); SubscriptionDetails subscriptionDetails = management.GetSubscriptionDetails(); int unknownCPUs = subscriptionDetails.MaxCoreCount - subscriptionDetails.AvailableCoreCount - currentPlannedCPUs; unknownCPUs = Math.Max(unknownCPUs, 0); availableCPUs = subscriptionDetails.MaxCoreCount - unknownCPUs - projectedCPUs; } return availableCPUs; }