public static ReplicationServerInfo GetReplicaInfoForService(int serviceId, ref ResultObject result) { // Get service id of replica server StringDictionary vsSesstings = ServerController.GetServiceSettings(serviceId); string replicaServiceId = vsSesstings["ReplicaServerId"]; if (string.IsNullOrEmpty(replicaServiceId)) { result.ErrorCodes.Add(VirtualizationErrorCodes.NO_REPLICA_SERVER_ERROR); return null; } // get replica server info for replica service id VirtualizationServer2012 vsReplica = VirtualizationHelper.GetVirtualizationProxy(Convert.ToInt32(replicaServiceId)); StringDictionary vsReplicaSesstings = ServerController.GetServiceSettings(Convert.ToInt32(replicaServiceId)); string computerName = vsReplicaSesstings["ServerName"]; var replicaServerInfo = vsReplica.GetReplicaServer(computerName); if (!replicaServerInfo.Enabled) { result.ErrorCodes.Add(VirtualizationErrorCodes.NO_REPLICA_SERVER_ERROR); return null; } return replicaServerInfo; }
protected void gvStorageSpaces_RowCommand(object sender, GridViewCommandEventArgs e) { if (e.CommandName == "DeleteItem") { int id; bool hasValue = int.TryParse(e.CommandArgument.ToString(), out id); ResultObject result = new ResultObject(); result.IsSuccess = false; if (hasValue) { result = ES.Services.StorageSpaces.RemoveStorageSpace(id); } messageBox.ShowMessage(result, "STORAGE_SPACES_LEVEL_REMOVE", null); if (!result.IsSuccess) { return; } gvStorageSpaces.DataBind(); } else if (e.CommandName == "EditStorageSpace") { EditStorageSpace(e.CommandArgument.ToString()); } }
public static void CheckReplicationQuota(int packageId, ref ResultObject result) { List<string> quotaResults = new List<string>(); PackageContext cntx = PackageController.GetPackageContext(packageId); QuotaHelper.CheckBooleanQuota(cntx, quotaResults, Quotas.VPS2012_REPLICATION_ENABLED, true, VirtualizationErrorCodes.QUOTA_REPLICATION_ENABLED); if (quotaResults.Count > 0) result.ErrorCodes.AddRange(quotaResults); }
public static VirtualizationServer2012 GetReplicaForService(int serviceId, ref ResultObject result) { // Get service id of replica server StringDictionary vsSesstings = ServerController.GetServiceSettings(serviceId); string replicaServiceId = vsSesstings["ReplicaServerId"]; if (string.IsNullOrEmpty(replicaServiceId)) { result.ErrorCodes.Add(VirtualizationErrorCodes.NO_REPLICA_SERVER_ERROR); return null; } // get replica server for replica service id return VirtualizationHelper.GetVirtualizationProxy(Convert.ToInt32(replicaServiceId)); }
public static void CleanUpReplicaServer(VirtualMachine originalVm) { try { ResultObject result = new ResultObject(); // Get replica server var replicaServer = GetReplicaForService(originalVm.ServiceId, ref result); // Clean up replica server var replicaVm = replicaServer.GetVirtualMachines().FirstOrDefault(m => m.Name == originalVm.Name); if (replicaVm != null) { replicaServer.DisableVmReplication(replicaVm.VirtualMachineId); replicaServer.ShutDownVirtualMachine(replicaVm.VirtualMachineId, true, "ReplicaDelete"); replicaServer.DeleteVirtualMachine(replicaVm.VirtualMachineId); } } catch { /* skip */ } }
private static void SetMailBoxRetentionPolicyAndArchiving(int itemId, int mailboxPlanId, int retentionPolicyId, string accountName, ExchangeServer exchange, string orgId, ResultObject result, bool EnableArchiving) { long archiveQuotaKB = 0; long archiveWarningQuotaKB = 0; string RetentionPolicy = ""; ExchangeMailboxPlan mailboxPlan = GetExchangeMailboxPlan(itemId, mailboxPlanId); if ( mailboxPlan != null) { archiveQuotaKB = mailboxPlan.ArchiveSizeMB != -1 ? ((long)mailboxPlan.ArchiveSizeMB * 1024) : -1; archiveWarningQuotaKB = mailboxPlan.ArchiveSizeMB != -1 ? (((long)mailboxPlan.ArchiveWarningPct * (long) mailboxPlan.ArchiveSizeMB * 1024) / 100) : -1; } if (retentionPolicyId > 0) { ExchangeMailboxPlan retentionPolicy = GetExchangeMailboxPlan(itemId, retentionPolicyId); if (retentionPolicy != null) { UpdateExchangeRetentionPolicy(itemId, retentionPolicyId, result); } } ResultObject res = exchange.SetMailBoxArchiving(orgId, accountName, EnableArchiving, archiveQuotaKB, archiveWarningQuotaKB, RetentionPolicy); if (res != null) { result.ErrorCodes.AddRange(res.ErrorCodes); result.IsSuccess = result.IsSuccess && res.IsSuccess; } }
public static int CreateMailbox(int itemId, int accountId, ExchangeAccountType accountType, string accountName, string displayName, string name, string domain, string password, bool sendSetupInstructions, string setupInstructionMailAddress, int mailboxPlanId, int archivedPlanId, string subscriberNumber, bool EnableArchiving) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) return accountCheck; // check mailbox quota OrganizationStatistics orgStats = GetOrganizationStatisticsByOrganization(itemId); if (accountType == ExchangeAccountType.SharedMailbox) { if ((orgStats.AllocatedSharedMailboxes > -1) && (orgStats.CreatedSharedMailboxes >= orgStats.AllocatedSharedMailboxes)) return BusinessErrorCodes.ERROR_EXCHANGE_MAILBOXES_QUOTA_LIMIT; } else if ((accountType == ExchangeAccountType.Room) || (accountType == ExchangeAccountType.Equipment)) { if ((orgStats.AllocatedResourceMailboxes > -1) && (orgStats.CreatedResourceMailboxes >= orgStats.AllocatedResourceMailboxes)) return BusinessErrorCodes.ERROR_EXCHANGE_MAILBOXES_QUOTA_LIMIT; } else { if ((orgStats.AllocatedMailboxes > -1) && (orgStats.CreatedMailboxes >= orgStats.AllocatedMailboxes)) return BusinessErrorCodes.ERROR_EXCHANGE_MAILBOXES_QUOTA_LIMIT; } // place log record TaskManager.StartTask("EXCHANGE", "CREATE_MAILBOX", displayName, itemId); // Log Extension LogExtension.WriteVariables(new {accountName, displayName}); bool userCreated = false; Organization org = null; try { accountName = accountName.Trim(); displayName = displayName.Trim(); name = name.Trim(); domain = domain.Trim(); // load organization org = GetOrganization(itemId); if (org == null) return -1; // e-mail string email = name + "@" + domain; bool enabled = (accountType == ExchangeAccountType.Mailbox); // string accountName = string.Empty; //Create AD user if needed if (accountId == 0) { accountId = OrganizationController.CreateUser(org.Id, displayName, name, domain, password, subscriberNumber, enabled, false, string.Empty, out accountName); if (accountId > 0) userCreated = true; } if (accountId < 0) return accountId; // get mailbox settings Organizations orgProxy = OrganizationController.GetOrganizationProxy(org.ServiceId); OrganizationUser retUser = orgProxy.GetUserGeneralSettings(accountName, org.OrganizationId); int exchangeServiceId = PackageController.GetPackageServiceId(org.PackageId, ResourceGroups.Exchange); ExchangeServer exchange = GetExchangeServer(exchangeServiceId, org.ServiceId); //Create Exchange Organization if (string.IsNullOrEmpty(org.GlobalAddressList)) { ExtendToExchangeOrganization(ref org); PackageController.UpdatePackageItem(org); } // check package int packageCheck = SecurityContext.CheckPackage(org.PackageId, DemandPackage.IsActive); if (packageCheck < 0) return packageCheck; //verify if the mailbox fits in the storage quota int maxDiskSpace = -1; int quotaUsed = 0; if (orgStats.AllocatedDiskSpace > 0) { maxDiskSpace = orgStats.AllocatedDiskSpace; quotaUsed = orgStats.UsedDiskSpace; } ExchangeMailboxPlan plan = GetExchangeMailboxPlan(itemId, mailboxPlanId); if (maxDiskSpace != -1) { if (plan.MailboxSizeMB == -1) return BusinessErrorCodes.ERROR_EXCHANGE_STORAGE_QUOTAS_EXCEED_HOST_VALUES; if ((quotaUsed + plan.MailboxSizeMB) > (maxDiskSpace)) return BusinessErrorCodes.ERROR_EXCHANGE_STORAGE_QUOTAS_EXCEED_HOST_VALUES; } if (plan.AllowLitigationHold) { int maxRecoverableItemsSpace = -1; int quotaRecoverableItemsUsed = 0; if (orgStats.AllocatedLitigationHoldSpace > 0) { maxRecoverableItemsSpace = orgStats.AllocatedLitigationHoldSpace; quotaRecoverableItemsUsed = orgStats.UsedLitigationHoldSpace; } if (maxRecoverableItemsSpace != -1) { if (plan.RecoverableItemsSpace == -1) return BusinessErrorCodes.ERROR_EXCHANGE_STORAGE_QUOTAS_EXCEED_HOST_VALUES; if (plan.RecoverableItemsSpace < 6144) return BusinessErrorCodes.ERROR_EXCHANGE_INVALID_RECOVERABLEITEMS_QUOTA; if ((quotaRecoverableItemsUsed + plan.RecoverableItemsSpace) > (maxRecoverableItemsSpace)) return BusinessErrorCodes.ERROR_EXCHANGE_STORAGE_QUOTAS_EXCEED_HOST_VALUES; } } if (plan.EnableArchiving) { int maxArchivingStorage = -1; int quotaArchivingStorageUsed = 0; if (orgStats.AllocatedArchingStorage > 0) { maxArchivingStorage = orgStats.AllocatedArchingStorage; quotaArchivingStorageUsed = orgStats.UsedArchingStorage; } if (maxArchivingStorage != -1) { if (plan.ArchiveSizeMB == -1) return BusinessErrorCodes.ERROR_EXCHANGE_STORAGE_QUOTAS_EXCEED_HOST_VALUES; if ((quotaArchivingStorageUsed + plan.ArchiveSizeMB) > (maxArchivingStorage)) return BusinessErrorCodes.ERROR_EXCHANGE_STORAGE_QUOTAS_EXCEED_HOST_VALUES; } } //GetServiceSettings StringDictionary primSettings = ServerController.GetServiceSettings(exchangeServiceId); PackageContext cntx = PackageController.GetPackageContext(org.PackageId); string samAccountName = exchange.CreateMailEnableUser(email, org.OrganizationId, org.DistinguishedName, org.SecurityGroup, org.DefaultDomain, accountType, primSettings["mailboxdatabase"], org.OfflineAddressBook, org.AddressBookPolicy, retUser.SamAccountName, plan.EnablePOP, plan.EnableIMAP, plan.EnableOWA, plan.EnableMAPI, plan.EnableActiveSync, plan.MailboxSizeMB != -1 ? (((long)plan.IssueWarningPct * (long)plan.MailboxSizeMB * 1024) / 100) : -1, plan.MailboxSizeMB != -1 ? (((long)plan.ProhibitSendPct * (long)plan.MailboxSizeMB * 1024) / 100) : -1, plan.MailboxSizeMB != -1 ? (((long)plan.ProhibitSendReceivePct * (long)plan.MailboxSizeMB * 1024) / 100) : -1, plan.KeepDeletedItemsDays, plan.MaxRecipients, plan.MaxSendMessageSizeKB, plan.MaxReceiveMessageSizeKB, plan.HideFromAddressBook, Convert.ToBoolean(cntx.Quotas[Quotas.EXCHANGE2007_ISCONSUMER].QuotaAllocatedValue), plan.AllowLitigationHold, plan.RecoverableItemsSpace != -1 ? (plan.RecoverableItemsSpace * 1024) : -1, plan.RecoverableItemsSpace != -1 ? (((long)plan.RecoverableItemsWarningPct * (long)plan.RecoverableItemsSpace * 1024) / 100) : -1); MailboxManagerActions pmmActions = MailboxManagerActions.GeneralSettings | MailboxManagerActions.MailFlowSettings | MailboxManagerActions.AdvancedSettings | MailboxManagerActions.EmailAddresses; UpdateExchangeAccount(accountId, accountName, accountType, displayName, email, false, pmmActions.ToString(), samAccountName, password, mailboxPlanId, archivedPlanId, subscriberNumber, EnableArchiving); ResultObject resPolicy = new ResultObject() { IsSuccess = true }; SetMailBoxRetentionPolicyAndArchiving(itemId, mailboxPlanId, archivedPlanId, accountName, exchange, org.OrganizationId, resPolicy, EnableArchiving); if (!resPolicy.IsSuccess) { TaskManager.WriteError("Error SetMailBoxRetentionPolicy: " + string.Join(", ", resPolicy.ErrorCodes.ToArray())); } // send setup instructions if (sendSetupInstructions) { try { // send setup instructions int sendResult = SendMailboxSetupInstructions(itemId, accountId, true, setupInstructionMailAddress, null); if (sendResult < 0) TaskManager.WriteWarning("Setup instructions were not sent. Error code: " + sendResult); } catch (Exception ex) { TaskManager.WriteError(ex); } } try { // update OAB // check if this is the first mailbox within the organization if (GetAccounts(itemId, ExchangeAccountType.Mailbox).Count == 1) exchange.UpdateOrganizationOfflineAddressBook(org.OfflineAddressBook); } catch (Exception ex) { TaskManager.WriteError(ex); } // Log Extension LogExtension.WriteVariables(new {email, samAccountName, accountId}); return accountId; } catch (Exception ex) { //rollback AD user if (userCreated) { try { OrganizationController.DeleteUser(org.Id, accountId); } catch (Exception rollbackException) { TaskManager.WriteError(rollbackException); } } throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public override ResultObject SetPicture(string accountName, byte[] picture) { ExchangeLog.LogStart("SetPicture"); ResultObject res = new ResultObject() { IsSuccess = true }; Runspace runSpace = null; try { runSpace = OpenRunspace(); Command cmd; if (picture == null) { cmd = new Command("Set-Mailbox"); cmd.Parameters.Add("Identity", accountName); cmd.Parameters.Add("RemovePicture", true); } else { cmd = new Command("Import-RecipientDataProperty"); cmd.Parameters.Add("Identity", accountName); cmd.Parameters.Add("Picture", true); cmd.Parameters.Add("FileData", picture); } ExecuteShellCommand(runSpace, cmd, res, true); } finally { CloseRunspace(runSpace); } ExchangeLog.LogEnd("SetPicture"); return res; }
public static ResultObject GrantWebManagementAccess(int siteItemId, string accountName, string accountPassword) { ResultObject result = new ResultObject { IsSuccess = true }; try { TaskManager.StartTask(LOG_SOURCE_WEB, "GrantWebManagementAccess"); TaskManager.WriteParameter("SiteItemId", siteItemId); // WebSite item = GetWebSite(siteItemId); // if (item == null) { TaskManager.WriteError("Web site not found"); // result.AddError("WEBSITE_NOT_FOUND", null); result.IsSuccess = false; return result; } // int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { TaskManager.WriteWarning("Current user is either demo or inactive"); // result.AddError("DEMO_USER", null); result.IsSuccess = false; return result; } // check package int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive"); // result.AddError("NOT_ALLOWED", null); result.IsSuccess = false; return result; } // WebServer server = GetWebServer(item.ServiceId); // if (server.CheckWebManagementAccountExists(accountName)) { TaskManager.WriteWarning("Account name specified already exists"); // result.AddError("ACCOUNTNAME_PROHIBITED", null); result.IsSuccess = false; return result; } // ResultObject passwResult = server.CheckWebManagementPasswordComplexity(accountPassword); if (!passwResult.IsSuccess) { TaskManager.WriteWarning("Account password does not meet complexity requirements"); // result.ErrorCodes.AddRange(passwResult.ErrorCodes); result.IsSuccess = false; // return result; } // server.GrantWebManagementAccess(item.SiteId, accountName, accountPassword); } catch (Exception ex) { TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } // return result; }
public static ResultObject GrantWebDeployPublishingAccess(int siteItemId, string accountName, string accountPassword) { ResultObject result = new ResultObject { IsSuccess = true }; try { TaskManager.StartTask(LOG_SOURCE_WEB, "GrantWeDeployPublishingAccess"); TaskManager.WriteParameter("SiteItemId", siteItemId); // load site item var item = (WebSite)PackageController.GetPackageItem(siteItemId); // if (item == null) { TaskManager.WriteError("Web site not found"); // result.AddError("WEBSITE_NOT_FOUND", null); result.IsSuccess = false; return result; } // int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { TaskManager.WriteWarning("Current user is either demo or inactive"); // result.AddError("DEMO_USER", null); result.IsSuccess = false; return result; } // check package int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive"); // result.AddError("NOT_ALLOWED", null); result.IsSuccess = false; return result; } // WebServer server = GetWebServer(item.ServiceId); // Most part of the functionality used to enable Web Deploy publishing correspond to those created for Web Management purposes, // so we can re-use the existing functionality to deliver seamless development experience. if (server.CheckWebManagementAccountExists(accountName)) { TaskManager.WriteWarning("Account name specified already exists"); // result.AddError("ACCOUNTNAME_PROHIBITED", null); result.IsSuccess = false; return result; } // Most part of the functionality used to enable Web Deploy publishing correspond to those created for Web Management purposes, // so we can re-use the existing functionality to deliver seamless development experience. ResultObject passwResult = server.CheckWebManagementPasswordComplexity(accountPassword); if (!passwResult.IsSuccess) { TaskManager.WriteWarning("Account password does not meet complexity requirements"); // result.ErrorCodes.AddRange(passwResult.ErrorCodes); result.IsSuccess = false; // return result; } // Execute a call to remote server to enable Web Deploy publishing access for the specified user account server.GrantWebDeployPublishingAccess(item.SiteId, accountName, accountPassword); // Enable Web Deploy flag for the web site item.WebDeploySitePublishingEnabled = true; // Remember Web Deploy publishing account item.WebDeployPublishingAccount = accountName; // Remember Web Deploy publishing password item.WebDeployPublishingPassword = CryptoUtils.Encrypt(accountPassword); // Put changes in effect PackageController.UpdatePackageItem(item); } catch (Exception ex) { TaskManager.WriteError(ex); // result.IsSuccess = false; } finally { TaskManager.CompleteTask(); } // return result; }
public new ResultObject CheckWebManagementPasswordComplexity(string accountPassword) { // Preserve setting to restore it back bool adEnabled = ServerSettings.ADEnabled; // !!! Bypass AD for WMSVC as it requires full-qualified username to authenticate user // against the web server ServerSettings.ADEnabled = false; // ResultObject result = new ResultObject { IsSuccess = true }; // if (IdentityCredentialsMode == "IISMNGR") { InvalidPasswordReason reason = ManagementAuthentication.IsPasswordStrongEnough(accountPassword); // if (reason != InvalidPasswordReason.NoError) { result.IsSuccess = false; result.AddError(reason.ToString(), new Exception("Password complexity check failed")); } } // Restore setting back ServerSettings.ADEnabled = adEnabled; // return result; }
public static ResultObject AddVirtualMachinePrivateIPAddresses(int itemId, bool selectRandom, int addressesNumber, string[] addresses, bool provisionKvp) { // trace info Trace.TraceInformation("Entering AddVirtualMachinePrivateIPAddresses()"); Trace.TraceInformation("Item ID: {0}", itemId); Trace.TraceInformation("SelectRandom: {0}", selectRandom); Trace.TraceInformation("AddressesNumber: {0}", addressesNumber); if (addresses != null) { foreach(var address in addresses) Trace.TraceInformation("addresses[n]: {0}", address); } ResultObject res = new ResultObject(); // load service item VirtualMachine vm = (VirtualMachine)PackageController.GetPackageItem(itemId); if (vm == null) { res.ErrorCodes.Add(VirtualizationErrorCodes.CANNOT_FIND_VIRTUAL_MACHINE_META_ITEM); return res; } #region Check account and space statuses // check account if (!SecurityContext.CheckAccount(res, DemandAccount.NotDemo | DemandAccount.IsActive)) return res; // check package if (!SecurityContext.CheckPackage(res, vm.PackageId, DemandPackage.IsActive)) return res; #endregion // start task res = TaskManager.StartResultTask<ResultObject>("VPS", "ADD_PRIVATE_IP", vm.Id, vm.Name, vm.PackageId); try { // load network adapter NetworkAdapterDetails nic = GetPrivateNetworkAdapterDetails(itemId); bool wasEmptyList = (nic.IPAddresses.Length == 0); if(wasEmptyList) Trace.TraceInformation("NIC IP addresses list is empty"); // check IP addresses if they are specified List<string> checkResults = CheckPrivateIPAddresses(vm.PackageId, addresses); if (checkResults.Count > 0) { res.ErrorCodes.AddRange(checkResults); res.IsSuccess = false; TaskManager.CompleteResultTask(); return res; } // load all existing private IP addresses List<PrivateIPAddress> ips = GetPackagePrivateIPAddresses(vm.PackageId); // sort them SortedList<IPAddress, string> sortedIps = GetSortedNormalizedIPAddresses(ips, nic.SubnetMask); if (selectRandom) { // generate N number of IP addresses addresses = new string[addressesNumber]; for (int i = 0; i < addressesNumber; i++) addresses[i] = GenerateNextAvailablePrivateIP(sortedIps, nic.SubnetMask, nic.NetworkFormat); } PackageContext cntx = PackageController.GetPackageContext(vm.PackageId); QuotaValueInfo quota = cntx.Quotas[Quotas.VPS2012_PRIVATE_IP_ADDRESSES_NUMBER]; if (quota.QuotaAllocatedValue != -1) { int maxAddresses = quota.QuotaAllocatedValue - nic.IPAddresses.Length; if (addresses.Length > maxAddresses) { TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.QUOTA_EXCEEDED_PRIVATE_ADDRESSES_NUMBER + ":" + maxAddresses); return res; } } // add addresses to database foreach (string address in addresses) DataProvider.AddItemPrivateIPAddress(SecurityContext.User.UserId, itemId, address); // set primary IP address if (wasEmptyList) { nic = GetPrivateNetworkAdapterDetails(itemId); if (nic.IPAddresses.Length > 0) SetVirtualMachinePrimaryPrivateIPAddress(itemId, nic.IPAddresses[0].AddressId, false); } // send KVP config items if(provisionKvp) SendNetworkAdapterKVP(itemId, "Private"); } catch (Exception ex) { TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.ADD_VIRTUAL_MACHINE_PRIVATE_IP_ADDRESS_ERROR, ex); return res; } TaskManager.CompleteResultTask(); return res; }
public static ResultObject SetVirtualMachinePrimaryExternalIPAddress(int itemId, int packageAddressId, bool provisionKvp) { ResultObject res = new ResultObject(); // load service item VirtualMachine vm = (VirtualMachine)PackageController.GetPackageItem(itemId); if (vm == null) { res.ErrorCodes.Add(VirtualizationErrorCodes.CANNOT_FIND_VIRTUAL_MACHINE_META_ITEM); return res; } #region Check account and space statuses // check account if (!SecurityContext.CheckAccount(res, DemandAccount.NotDemo | DemandAccount.IsActive)) return res; // check package if (!SecurityContext.CheckPackage(res, vm.PackageId, DemandPackage.IsActive)) return res; #endregion // start task res = TaskManager.StartResultTask<ResultObject>("VPS", "SET_PRIMARY_EXTERNAL_IP", vm.Id, vm.Name, vm.PackageId); try { // call database ServerController.SetItemPrimaryIPAddress(itemId, packageAddressId); // send KVP config items if(provisionKvp) SendNetworkAdapterKVP(itemId, "External"); } catch (Exception ex) { TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.SET_VIRTUAL_MACHINE_PRIMARY_EXTERNAL_IP_ADDRESS_ERROR, ex); return res; } TaskManager.CompleteResultTask(); return res; }
public static ResultObject AddVirtualMachineExternalIPAddresses(int itemId, bool selectRandom, int addressesNumber, int[] addressIds, bool provisionKvp) { if (addressIds == null) throw new ArgumentNullException("addressIds"); ResultObject res = new ResultObject(); // load service item VirtualMachine vm = (VirtualMachine)PackageController.GetPackageItem(itemId); if (vm == null) { res.ErrorCodes.Add(VirtualizationErrorCodes.CANNOT_FIND_VIRTUAL_MACHINE_META_ITEM); return res; } #region Check account and space statuses // check account if (!SecurityContext.CheckAccount(res, DemandAccount.NotDemo | DemandAccount.IsActive)) return res; // check package if (!SecurityContext.CheckPackage(res, vm.PackageId, DemandPackage.IsActive)) return res; #endregion // start task res = TaskManager.StartResultTask<ResultObject>("VPS", "ADD_EXTERNAL_IP", vm.Id, vm.Name, vm.PackageId); try { if (selectRandom) { List<PackageIPAddress> ips = ServerController.GetPackageUnassignedIPAddresses(vm.PackageId, IPAddressPool.VpsExternalNetwork); if (addressesNumber > ips.Count) { TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.NOT_ENOUGH_PACKAGE_IP_ADDRESSES); return res; } // get next N unassigned addresses addressIds = new int[addressesNumber]; for (int i = 0; i < addressesNumber; i++) addressIds[i] = ips[i].PackageAddressID; } // add addresses foreach (int addressId in addressIds) ServerController.AddItemIPAddress(itemId, addressId); // send KVP config items if(provisionKvp) SendNetworkAdapterKVP(itemId, "External"); } catch (Exception ex) { TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.ADD_VIRTUAL_MACHINE_EXTERNAL_IP_ADDRESS_ERROR, ex); return res; } TaskManager.CompleteResultTask(); return res; }
public static ResultObject DeleteSnapshotSubtree(int itemId, string snapshotId) { ResultObject res = new ResultObject(); // load service item VirtualMachine vm = (VirtualMachine)PackageController.GetPackageItem(itemId); if (vm == null) { res.ErrorCodes.Add(VirtualizationErrorCodes.CANNOT_FIND_VIRTUAL_MACHINE_META_ITEM); return res; } #region Check account and space statuses // check account if (!SecurityContext.CheckAccount(res, DemandAccount.NotDemo | DemandAccount.IsActive)) return res; // check package if (!SecurityContext.CheckPackage(res, vm.PackageId, DemandPackage.IsActive)) return res; #endregion // start task res = TaskManager.StartResultTask<ResultObject>("VPS", "DELETE_SNAPSHOT_SUBTREE", vm.Id, vm.Name, vm.PackageId); try { // get proxy VirtualizationServer2012 vs = GetVirtualizationProxy(vm.ServiceId); // take snapshot JobResult result = vs.DeleteSnapshotSubtree(snapshotId); if (result.ReturnValue != ReturnCode.JobStarted) { LogReturnValueResult(res, result); TaskManager.CompleteResultTask(res); return res; } if (!JobCompleted(vs, result.Job)) { LogJobResult(res, result.Job); TaskManager.CompleteResultTask(res); return res; } } catch (Exception ex) { TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.DELETE_SNAPSHOT_SUBTREE_ERROR, ex); return res; } TaskManager.CompleteResultTask(); return res; }
public static ResultObject SetVmReplication(int itemId, VmReplication replication) { TaskManager.StartTask("VPS2012", "SetVmReplication"); ResultObject result = new ResultObject(); try { VirtualMachine vm = GetVirtualMachineByItemId(itemId); // Check Quotas ReplicationHelper.CheckReplicationQuota(vm.PackageId, ref result); if (result.ErrorCodes.Count > 0) return result; VirtualizationServer2012 vs = GetVirtualizationProxy(vm.ServiceId); // Get replica server var replicaServerInfo = ReplicationHelper.GetReplicaInfoForService(vm.ServiceId, ref result); if (result.ErrorCodes.Count > 0) return result; // We should use enable replication or set replication? var vmReplica = vs.GetReplication(vm.VirtualMachineId); if (vmReplica == null) // need enable { vs.EnableVmReplication(vm.VirtualMachineId, replicaServerInfo.ComputerName, replication); vs.StartInitialReplication(vm.VirtualMachineId); } else // need set { vs.SetVmReplication(vm.VirtualMachineId, replicaServerInfo.ComputerName, replication); } result.IsSuccess = true; } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } TaskManager.WriteWarning("Organization with itemId '{0}' not found", itemId.ToString()); return result; }
public static ResultObject ResumeReplication(int itemId) { ResultObject result = new ResultObject(); try { VirtualMachine vm = GetVirtualMachineByItemId(itemId); // Check Quotas ReplicationHelper.CheckReplicationQuota(vm.PackageId, ref result); if (result.ErrorCodes.Count > 0) return result; VirtualizationServer2012 vs = GetVirtualizationProxy(vm.ServiceId); vs.ResumeReplication(vm.VirtualMachineId); result.IsSuccess = true; } catch (Exception ex) { result.AddError(VirtualizationErrorCodes.RESUME_REPLICATION_ERROR, ex); } return result; }
public static ResultObject DeleteVirtualMachinePrivateIPAddresses(int itemId, int[] addressIds, bool provisionKvp) { if (addressIds == null) throw new ArgumentNullException("addressIds"); ResultObject res = new ResultObject(); // load service item VirtualMachine vm = (VirtualMachine)PackageController.GetPackageItem(itemId); if (vm == null) { res.ErrorCodes.Add(VirtualizationErrorCodes.CANNOT_FIND_VIRTUAL_MACHINE_META_ITEM); return res; } #region Check account and space statuses // check account if (!SecurityContext.CheckAccount(res, DemandAccount.NotDemo | DemandAccount.IsActive)) return res; // check package if (!SecurityContext.CheckPackage(res, vm.PackageId, DemandPackage.IsActive)) return res; #endregion // start task res = TaskManager.StartResultTask<ResultObject>("VPS", "DELETE_PRIVATE_IP", vm.Id, vm.Name, vm.PackageId); try { // call data access layer foreach (int addressId in addressIds) DataProvider.DeleteItemPrivateIPAddress(SecurityContext.User.UserId, itemId, addressId); // send KVP config items if(provisionKvp) SendNetworkAdapterKVP(itemId, "Private"); } catch (Exception ex) { TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.DELETE_VIRTUAL_MACHINE_PRIVATE_IP_ADDRESS_ERROR, ex); return res; } TaskManager.CompleteResultTask(); return res; }
public static ResultObject SaveWebDeployPublishingProfile(int siteItemId, int[] serviceItemIds) { ResultObject result = new ResultObject { IsSuccess = true }; try { TaskManager.StartTask(LOG_SOURCE_WEB, "SaveWebDeployPublishingProfile"); TaskManager.WriteParameter("SiteItemId", siteItemId); // load site item var item = (WebSite)PackageController.GetPackageItem(siteItemId); // if (item == null) { TaskManager.WriteError("Web site not found"); // result.AddError("WEBSITE_NOT_FOUND", null); result.IsSuccess = false; return result; } // int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { TaskManager.WriteWarning("Current user is either demo or inactive"); // result.AddError("DEMO_USER", null); result.IsSuccess = false; return result; } // check package int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive"); // result.AddError("NOT_ALLOWED", null); result.IsSuccess = false; return result; } // Ensure all service items specified are within the same hosting space // This is a logcally correct and secure statement than the other one // TO-DO: Uncomment this line before demo! //var profileIntegritySucceeded = false; var profileIntegritySucceeded = true; // foreach (int itemId in serviceItemIds) { try { // PackageController.GetPackageItem(itemId); // profileIntegritySucceeded = true; } catch (Exception ex) { TaskManager.WriteError(ex); // profileIntegritySucceeded = false; // Exit from the loop break; } } // if (profileIntegritySucceeded == true) { // Build service items list item.WebDeploySitePublishingProfile = String.Join(",", Array.ConvertAll<int, string>(serviceItemIds, (int x) => { return x.ToString(); })); // Put changes in effect PackageController.UpdatePackageItem(item); } } catch (Exception ex) { TaskManager.WriteError(ex); // result.IsSuccess = false; } finally { TaskManager.CompleteTask(); } // return result; }
public static ResultObject DeleteVirtualMachine(int itemId, bool saveFiles, bool exportVps, string exportPath) { ResultObject res = new ResultObject(); // load service item VirtualMachine vm = (VirtualMachine)PackageController.GetPackageItem(itemId); if (vm == null) { res.ErrorCodes.Add(VirtualizationErrorCodes.CANNOT_FIND_VIRTUAL_MACHINE_META_ITEM); return res; } #region Check account and space statuses // check account if (!SecurityContext.CheckAccount(res, DemandAccount.NotDemo | DemandAccount.IsActive)) return res; // check package if (!SecurityContext.CheckPackage(res, vm.PackageId, DemandPackage.IsActive)) return res; #endregion // start task res = TaskManager.StartResultTask<ResultObject>("VPS", "DELETE", vm.Id, vm.Name, vm.PackageId); try { // get proxy VirtualizationServer2012 vs = GetVirtualizationProxy(vm.ServiceId); // check VM state VirtualMachine vps = vs.GetVirtualMachine(vm.VirtualMachineId); JobResult result = null; if (vps != null) { #region turn off machine (if required) // stop virtual machine if (vps.State != VirtualMachineState.Off) { TaskManager.Write("VPS_DELETE_TURN_OFF"); result = vs.ChangeVirtualMachineState(vm.VirtualMachineId, VirtualMachineRequestedState.TurnOff); // check result if (result.ReturnValue != ReturnCode.JobStarted) { LogReturnValueResult(res, result); TaskManager.CompleteResultTask(res); return res; } // wait for completion if (!JobCompleted(vs, result.Job)) { LogJobResult(res, result.Job); TaskManager.CompleteResultTask(res); return res; } } #endregion #region export machine if (exportVps && !String.IsNullOrEmpty(exportPath)) { TaskManager.Write("VPS_DELETE_EXPORT"); result = vs.ExportVirtualMachine(vm.VirtualMachineId, exportPath); // check result if (result.ReturnValue != ReturnCode.JobStarted) { LogReturnValueResult(res, result); TaskManager.CompleteResultTask(res); return res; } // wait for completion if (!JobCompleted(vs, result.Job)) { LogJobResult(res, result.Job); TaskManager.CompleteResultTask(res); return res; } } #endregion #region delete machine TaskManager.Write("VPS_DELETE_DELETE"); result = vs.DeleteVirtualMachine(vm.VirtualMachineId); // check result if (result.ReturnValue != ReturnCode.JobStarted) { LogReturnValueResult(res, result); TaskManager.CompleteResultTask(res); return res; } // wait for completion if (!JobCompleted(vs, result.Job)) { LogJobResult(res, result.Job); TaskManager.CompleteResultTask(res); return res; } #endregion } #region delete files if (!saveFiles) { TaskManager.Write("VPS_DELETE_FILES", vm.RootFolderPath); try { vs.DeleteRemoteFile(vm.RootFolderPath); } catch (Exception ex) { res.ErrorCodes.Add(VirtualizationErrorCodes.DELETE_VM_FILES_ERROR + ": " + ex.Message); } } #endregion // delete meta item PackageController.DeletePackageItem(itemId); } catch (Exception ex) { TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.DELETE_ERROR, ex); return res; } TaskManager.CompleteResultTask(); return res; }
public static ResultObject ChangeWebDeployPublishingPassword(int siteItemId, string newAccountPassword) { ResultObject result = new ResultObject { IsSuccess = true }; try { TaskManager.StartTask(LOG_SOURCE_WEB, "ChangeWebDeployPublishingPassword"); TaskManager.WriteParameter("SiteItemId", siteItemId); // var item = (WebSite)PackageController.GetPackageItem(siteItemId); // if (item == null) { TaskManager.WriteWarning("Web site not found"); // result.AddError("WEBSITE_NOT_FOUND", null); result.IsSuccess = false; return result; } // int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { TaskManager.WriteWarning("Current user is either demo or inactive"); result.AddError("DEMO_USER", null); result.IsSuccess = false; return result; } // check package int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive"); // result.AddError("NOT_ALLOWED", null); result.IsSuccess = false; return result; } // Revoke access first RevokeWebDeployPublishingAccess(siteItemId); // result = GrantWebDeployPublishingAccess(siteItemId, item.WebDeployPublishingAccount, newAccountPassword); } catch (Exception ex) { TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } // return result; }
public static ResultObject SendVirtualMachineSummaryLetter(int itemId, string to, string bcc, bool creation) { ResultObject res = new ResultObject(); // load service item VirtualMachine vm = (VirtualMachine)PackageController.GetPackageItem(itemId); if (vm == null) { res.ErrorCodes.Add(VirtualizationErrorCodes.CANNOT_FIND_VIRTUAL_MACHINE_META_ITEM); return res; } #region Check account and space statuses // check account if (!SecurityContext.CheckAccount(res, DemandAccount.NotDemo | DemandAccount.IsActive)) return res; // check package if (!SecurityContext.CheckPackage(res, vm.PackageId, DemandPackage.IsActive)) return res; #endregion // start task res = TaskManager.StartResultTask<ResultObject>("VPS", "SEND_SUMMARY_LETTER", vm.Id, vm.Name, vm.PackageId); try { // load user info UserInfo user = PackageController.GetPackageOwner(vm.PackageId); // get letter settings UserSettings settings = UserController.GetUserSettings(user.UserId, UserSettings.VPS_SUMMARY_LETTER); string from = settings["From"]; if (bcc == null) bcc = settings["CC"]; string subject = settings["Subject"]; string body = user.HtmlMail ? settings["HtmlBody"] : settings["TextBody"]; bool isHtml = user.HtmlMail; MailPriority priority = MailPriority.Normal; if (!String.IsNullOrEmpty(settings["Priority"])) priority = (MailPriority)Enum.Parse(typeof(MailPriority), settings["Priority"], true); if (String.IsNullOrEmpty(body)) { TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.SUMMARY_TEMPLATE_IS_EMPTY); return res; } // load user info if (to == null) to = user.Email; subject = EvaluateVirtualMachineTemplate(itemId, true, creation, subject); body = EvaluateVirtualMachineTemplate(itemId, true, creation, body); // send message int result = MailHelper.SendMessage(from, to, bcc, subject, body, priority, isHtml); if (result != 0) { TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.SEND_SUMMARY_LETTER_CODE + ":" + result); TaskManager.WriteWarning("VPS_SEND_SUMMARY_LETTER_ERROR_CODE", result.ToString()); return res; } } catch (Exception ex) { TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.SEND_SUMMARY_LETTER, ex); TaskManager.WriteWarning("VPS_SEND_SUMMARY_LETTER_ERROR", ex.Message); return res; } TaskManager.CompleteResultTask(); return res; }
public static ResultObject ChangeWebManagementAccessPassword(int siteItemId, string accountPassword) { ResultObject result = new ResultObject { IsSuccess = true }; try { TaskManager.StartTask(LOG_SOURCE_WEB, "ChangeWebManagementAccessPassword"); TaskManager.WriteParameter("SiteItemId", siteItemId); // WebSite item = GetWebSite(siteItemId) as WebSite; // if (item == null) { TaskManager.WriteWarning("Web site not found"); // result.AddError("WEBSITE_NOT_FOUND", null); result.IsSuccess = false; return result; } // int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { TaskManager.WriteWarning("Current user is either demo or inactive"); result.AddError("DEMO_USER", null); result.IsSuccess = false; return result; } // check package int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { TaskManager.WriteWarning("Current user is either not allowed to access the package or the package inactive"); // result.AddError("NOT_ALLOWED", null); result.IsSuccess = false; return result; } // string accountName = item.GetValue<string>(WebSite.WmSvcAccountName); // if (String.IsNullOrEmpty(accountName)) { TaskManager.WriteWarning("WebManagement Access account name is either not set or empty"); result.AddError("EMPTY_WMSVC_ACCOUNT", null); result.IsSuccess = false; return result; } // WebServer server = GetWebServer(item.ServiceId); // ResultObject passwResult = server.CheckWebManagementPasswordComplexity(accountPassword); if (!passwResult.IsSuccess) { TaskManager.WriteWarning("Account password does not meet complexity requirements"); // result.ErrorCodes.AddRange(passwResult.ErrorCodes); result.IsSuccess = false; // return result; } // server.ChangeWebManagementAccessPassword(accountName, accountPassword); } catch (Exception ex) { TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } // return result; }
private static void LogReturnValueResult(ResultObject res, JobResult job) { res.ErrorCodes.Add(VirtualizationErrorCodes.JOB_START_ERROR + ":" + job.ReturnValue); }
internal Collection<PSObject> ExecuteShellCommand(Runspace runSpace, Command cmd, ResultObject res, bool setIsSuccess) { object[] errors; Collection<PSObject> ret = ExecuteShellCommand(runSpace, cmd, out errors); if (errors.Length > 0) { foreach (object error in errors) res.ErrorCodes.Add(error.ToString()); if (setIsSuccess) res.IsSuccess = false; } return ret; }
private static void LogJobResult(ResultObject res, ConcreteJob job) { res.ErrorCodes.Add(VirtualizationErrorCodes.JOB_FAILED_ERROR + ":" + job.ErrorDescription); }
public static int SetExchangeMailboxPlan(int itemId, int accountId, int mailboxPlanId, int archivePlanId, bool EnableArchiving) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) return accountCheck; // place log record TaskManager.StartTask("EXCHANGE", "SET_MAILBOXPLAN", itemId); try { // load organization Organization org = GetOrganization(itemId); if (org == null) return -1; // check package int packageCheck = SecurityContext.CheckPackage(org.PackageId, DemandPackage.IsActive); if (packageCheck < 0) return packageCheck; // load account ExchangeAccount account = GetAccount(itemId, accountId); // load org quotas OrganizationStatistics orgStats = GetOrganizationStatisticsByOrganization(itemId); int maxDiskSpace = -1; int quotaUsed = 0; if (orgStats.AllocatedDiskSpace > 0) { maxDiskSpace = orgStats.AllocatedDiskSpace; quotaUsed = orgStats.UsedDiskSpace; } ExchangeMailboxPlan plan = GetExchangeMailboxPlan(itemId, mailboxPlanId); if (maxDiskSpace != -1) { if (plan.MailboxSizeMB == -1) return BusinessErrorCodes.ERROR_EXCHANGE_STORAGE_QUOTAS_EXCEED_HOST_VALUES; ExchangeAccount exchangeAccount = GetAccount(itemId, accountId); if (exchangeAccount.MailboxPlanId > 0) { ExchangeMailboxPlan oldPlan = GetExchangeMailboxPlan(itemId, exchangeAccount.MailboxPlanId); if (((quotaUsed - oldPlan.MailboxSizeMB) + plan.MailboxSizeMB) > (maxDiskSpace)) return BusinessErrorCodes.ERROR_EXCHANGE_STORAGE_QUOTAS_EXCEED_HOST_VALUES; } else { if ((quotaUsed + plan.MailboxSizeMB) > (maxDiskSpace)) return BusinessErrorCodes.ERROR_EXCHANGE_STORAGE_QUOTAS_EXCEED_HOST_VALUES; } } int maxRecoverableItemsSpace = -1; int quotaRecoverableItemsUsed = 0; if (orgStats.AllocatedLitigationHoldSpace > 0) { maxRecoverableItemsSpace = orgStats.AllocatedLitigationHoldSpace; quotaRecoverableItemsUsed = orgStats.UsedLitigationHoldSpace; } if (maxRecoverableItemsSpace != -1) { if (plan.RecoverableItemsSpace == -1) return BusinessErrorCodes.ERROR_EXCHANGE_STORAGE_QUOTAS_EXCEED_HOST_VALUES; if (plan.RecoverableItemsSpace < 6144) return BusinessErrorCodes.ERROR_EXCHANGE_INVALID_RECOVERABLEITEMS_QUOTA; if ((quotaRecoverableItemsUsed + plan.RecoverableItemsSpace) > (maxRecoverableItemsSpace)) return BusinessErrorCodes.ERROR_EXCHANGE_STORAGE_QUOTAS_EXCEED_HOST_VALUES; } // get mailbox settings int exchangeServiceId = GetExchangeServiceID(org.PackageId); ExchangeServer exchange = GetExchangeServer(exchangeServiceId, org.ServiceId); //TDMX exchange.SetMailboxAdvancedSettings( org.OrganizationId, account.UserPrincipalName, plan.EnablePOP, plan.EnableIMAP, plan.EnableOWA, plan.EnableMAPI, plan.EnableActiveSync, plan.MailboxSizeMB != -1 ? (((long)plan.IssueWarningPct * (long)plan.MailboxSizeMB * 1024) / 100) : -1, plan.MailboxSizeMB != -1 ? (((long)plan.ProhibitSendPct * (long)plan.MailboxSizeMB * 1024) / 100) : -1, plan.MailboxSizeMB != -1 ? (((long)plan.ProhibitSendReceivePct * (long)plan.MailboxSizeMB * 1024) / 100) : -1, plan.KeepDeletedItemsDays, plan.MaxRecipients, plan.MaxSendMessageSizeKB, plan.MaxReceiveMessageSizeKB, plan.AllowLitigationHold, plan.RecoverableItemsSpace != -1 ? (plan.RecoverableItemsSpace * 1024) : -1, plan.RecoverableItemsSpace != -1 ? (((long)plan.RecoverableItemsWarningPct * (long)plan.RecoverableItemsSpace * 1024) / 100) : -1, plan.LitigationHoldUrl, plan.LitigationHoldMsg); ResultObject resPolicy = new ResultObject() { IsSuccess = true }; SetMailBoxRetentionPolicyAndArchiving(itemId, mailboxPlanId, archivePlanId, account.UserPrincipalName, exchange, org.OrganizationId, resPolicy, EnableArchiving); if (!resPolicy.IsSuccess) { TaskManager.WriteError("Error SetMailBoxRetentionPolicy", resPolicy.ErrorCodes.ToArray()); } DataProvider.SetExchangeAccountMailboxPlan(accountId, mailboxPlanId, archivePlanId, EnableArchiving); return 0; } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static ResultObject SetReplicaServer(int serviceId, string remoteServer, string thumbprint, string storagePath) { ResultObject result = new ResultObject(); try { if (string.IsNullOrEmpty(storagePath)) throw new Exception("Please enter replication path"); VirtualizationServer2012 vs = GetVirtualizationProxy(serviceId); vs.SetReplicaServer(remoteServer, thumbprint, storagePath); result.IsSuccess = true; } catch (Exception ex) { result.AddError(VirtualizationErrorCodes.SET_REPLICA_SERVER_ERROR, ex); } return result; }
private static void UpdateExchangeRetentionPolicy(int itemID, int policyId, ResultObject result) { Organization org = GetOrganization(itemID); if (org == null) return; int exchangeServiceId = GetExchangeServiceID(org.PackageId); if (exchangeServiceId > 0) { ExchangeServer exchange = GetExchangeServer(exchangeServiceId, org.ServiceId); ExchangeMailboxPlan policy = GetExchangeMailboxPlan(itemID, policyId); if (policy != null) { List<ExchangeMailboxPlanRetentionPolicyTag> policytaglist = GetExchangeMailboxPlanRetentionPolicyTags(policyId); List<string> tagLinks = new List<string>(); foreach (ExchangeMailboxPlanRetentionPolicyTag policytag in policytaglist) { ExchangeRetentionPolicyTag tag = GetExchangeRetentionPolicyTag(itemID, policytag.TagID); tagLinks.Add(tag.WSPUniqueName); // update PlanRetentionPolicyTags ResultObject resItem = exchange.SetRetentionPolicyTag(tag.WSPUniqueName, (ExchangeRetentionPolicyTagType)tag.TagType, tag.AgeLimitForRetention, (ExchangeRetentionPolicyTagAction)tag.RetentionAction); result.ErrorCodes.AddRange(resItem.ErrorCodes); result.IsSuccess = result.IsSuccess && resItem.IsSuccess; } ResultObject res = exchange.SetRetentionPolicy(policy.WSPUniqueName, tagLinks.ToArray()); result.ErrorCodes.AddRange(res.ErrorCodes); result.IsSuccess = result.IsSuccess && res.IsSuccess; } } }
public static ResultObject UnsetReplicaServer(int serviceId, string remoteServer) { ResultObject result = new ResultObject(); try { VirtualizationServer2012 vs = GetVirtualizationProxy(serviceId); vs.UnsetReplicaServer(remoteServer); result.IsSuccess = true; } catch (Exception ex) { result.AddError(VirtualizationErrorCodes.UNSET_REPLICA_SERVER_ERROR, ex); } return result; }