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;
}
