protected void wizard_FinishButtonClick(object sender, WizardNavigationEventArgs e)
{
if (!Page.IsValid)
{
return;
}
try
{
VirtualMachine virtualMachine = new VirtualMachine();
// the user controls
this.SaveSettingsControls(ref virtualMachine);
// collect and prepare data
string hostname = String.Format("{0}.{1}", txtHostname.Text.Trim(), txtDomain.Text.Trim());
string adminPassword = (string)ViewState["Password"];
// external IPs
List <int> extIps = new List <int>();
foreach (ListItem li in listExternalAddresses.Items)
{
if (li.Selected)
{
extIps.Add(Utils.ParseInt(li.Value));
}
}
// private IPs
string[] privIps = Utils.ParseDelimitedString(txtPrivateAddressesList.Text, '\n', '\r', ' ', '\t');
string summaryEmail = chkSendSummary.Checked ? txtSummaryEmail.Text.Trim() : null;
// create virtual machine
IntResult res = ES.Services.VPS2012.CreateVirtualMachine(PanelSecurity.PackageId,
hostname, listOperatingSystems.SelectedValue, adminPassword, summaryEmail,
Utils.ParseInt(ddlCpu.SelectedValue), Utils.ParseInt(txtRam.Text.Trim()),
Utils.ParseInt(txtHdd.Text.Trim()), Utils.ParseInt(txtSnapshots.Text.Trim()),
chkDvdInstalled.Checked, chkBootFromCd.Checked, chkNumLock.Checked,
chkStartShutdown.Checked, chkPauseResume.Checked, chkReboot.Checked, chkReset.Checked, chkReinstall.Checked,
chkExternalNetworkEnabled.Checked, Utils.ParseInt(txtExternalAddressesNumber.Text.Trim()), radioExternalRandom.Checked, extIps.ToArray(),
chkPrivateNetworkEnabled.Checked, Utils.ParseInt(txtPrivateAddressesNumber.Text.Trim()), radioPrivateRandom.Checked, privIps,
virtualMachine);
if (res.IsSuccess)
{
Response.Redirect(EditUrl("ItemID", res.Value.ToString(), "vps_general",
"SpaceID=" + PanelSecurity.PackageId.ToString()));
}
else
{
messageBox.ShowMessage(res, "VPS_ERROR_CREATE", "VPS");
}
}
catch (Exception ex)
{
messageBox.ShowErrorMessage("VPS_ERROR_CREATE", ex);
}
}
public void EqualsIsCommunitive()
{
var x = IntResult.Ok(22);
var y = IntResult.Ok(22);
Assert.AreEqual(x.Equals(y), y.Equals(x));
}
protected bool SaveTags(int ItemId, int planId)
{
ExchangeMailboxPlanRetentionPolicyTag[] currenttags = ES.Services.ExchangeServer.GetExchangeMailboxPlanRetentionPolicyTags(planId);
foreach (ExchangeMailboxPlanRetentionPolicyTag tag in currenttags)
{
ResultObject res = ES.Services.ExchangeServer.DeleteExchangeMailboxPlanRetentionPolicyTag(ItemId, planId, tag.PlanTagID);
if (!res.IsSuccess)
{
messageBox.ShowMessage(res, "EXCHANGE_UPDATEPLANS", null);
return(false);
}
}
List <ExchangeMailboxPlanRetentionPolicyTag> tags = ViewState["Tags"] as List <ExchangeMailboxPlanRetentionPolicyTag>;
if (tags != null)
{
foreach (ExchangeMailboxPlanRetentionPolicyTag tag in tags)
{
tag.MailboxPlanId = planId;
IntResult res = ES.Services.ExchangeServer.AddExchangeMailboxPlanRetentionPolicyTag(ItemId, tag);
if (!res.IsSuccess)
{
messageBox.ShowMessage(res, "EXCHANGE_UPDATEPLANS", null);
return(false);
}
}
}
return(true);
}
private int AddIpAddress(string ip, int serverId)
{
try
{
Log.WriteStart("Adding IP address");
IntResult res = ES.Services.Servers.AddIPAddress(IPAddressPool.General, serverId, ip, String.Empty, String.Empty, String.Empty, String.Empty);
if (res.IsSuccess && res.Value > 0)
{
Log.WriteEnd("Added IP address");
}
else
{
Log.WriteError(string.Format("Enterprise Server error: {0}", res.Value));
}
return(res.Value);
}
catch (Exception ex)
{
if (!Utils.IsThreadAbortException(ex))
{
Log.WriteError("IP address configuration error", ex);
}
return(-1);
}
}
private static BoolResult CheckQuota(int packageId, int itemId)
{
BoolResult res = StartTask <BoolResult>("CRM", "CHECK_QUOTA");
try
{
PackageContext cntx = PackageController.GetPackageContext(packageId);
IntResult tmp = GetCRMUsersCount(itemId, string.Empty, string.Empty);
res.ErrorCodes.AddRange(tmp.ErrorCodes);
if (!tmp.IsSuccess)
{
CompleteTask(res);
return(res);
}
int allocatedCrmUsers = cntx.Quotas[Quotas.CRM_USERS].QuotaAllocatedValue;
res.Value = allocatedCrmUsers == -1 || allocatedCrmUsers >= tmp.Value;
}
catch (Exception ex)
{
CompleteTask(res, CrmErrorCodes.CHECK_QUOTA, ex);
return(res);
}
CompleteTask();
return(res);
}
protected void createOrganization_Click(object sender, EventArgs e)
{
if (!Page.IsValid)
{
return;
}
try
{
string orgDomain = domain.Text.Trim();
string adminEmail = administratorEmail.Text.Trim() + "@" + orgDomain;
IntResult result = ES.Services.ExchangeHostedEdition.CreateExchangeOrganization(PanelSecurity.PackageId,
organizationName.Text.Trim(),
orgDomain,
administratorName.Text.Trim(),
adminEmail,
administratorPassword.Password);
if (result.IsSuccess)
{
// navigate to details
Response.Redirect(NavigateURL("SpaceID", PanelSecurity.PackageId.ToString(), "ItemID=" + result.Value.ToString()));
}
else
{
// display message
messageBox.ShowMessage(result, "EXCHANGE_HOSTED_CREATE_ORGANIZATION", "ExchangeHostedEdition");
}
}
catch (Exception ex)
{
messageBox.ShowErrorMessage("EXCHANGE_HOSTED_CREATE_ORGANIZATION", ex);
}
}
public void btnAddPolicy_Click(object sender, EventArgs e)
{
Page.Validate("CreatePolicy");
if (!Page.IsValid)
{
return;
}
WebsitePanel.Providers.HostedSolution.ExchangeRetentionPolicyTag tag = new Providers.HostedSolution.ExchangeRetentionPolicyTag();
tag.TagName = txtPolicy.Text;
tag.TagType = Convert.ToInt32(ddTagType.SelectedValue);
tag.AgeLimitForRetention = ageLimitForRetention.QuotaValue;
tag.RetentionAction = Convert.ToInt32(ddRetentionAction.SelectedValue);
IntResult result = ES.Services.ExchangeServer.AddExchangeRetentionPolicyTag(PanelRequest.ItemID, tag);
if (!result.IsSuccess)
{
messageBox.ShowMessage(result, "EXCHANGE_UPDATERETENTIONPOLICY", null);
return;
}
else
{
messageBox.ShowSuccessMessage("EXCHANGE_UPDATERETENTIONPOLICY");
}
BindRetentionPolicy();
ClearEditValues();
}
public void ComprehensionsWork()
{
var result =
from x in IntResult.Ok(2)
select x + 1;
Assert.AreEqual(IntResult.Ok(3), result);
var error =
from x in IntResult.Err("boom")
select x + 1;
Assert.AreEqual(IntResult.Err("boom"), error);
var error2 =
from x in IntResult.Ok(3)
from y in IntResult.Err("boom")
select x + y;
Assert.AreEqual(IntResult.Err("boom"), error2);
var result2 =
from x in IntResult.Ok(3)
from y in IntResult.Ok(4)
select x + y;
Assert.AreEqual(result2, IntResult.Ok(7));
}
public void SatisfiesMonadRightIdentityLaw()
{
var m = IntResult.Ok(2);
// m >>= return === m
Assert.AreEqual(m.Bind(IntResult.Ok), m);
}
public void EqualsAnotherOk()
{
var x = IntResult.Ok(22);
var y = IntResult.Ok(22);
Assert.AreEqual(x, y);
}
private void TryToReinstall()
{
try
{
VirtualMachine vm = VirtualMachines2012Helper.GetCachedVirtualMachine(PanelRequest.ItemID);
// create virtual machine
vm.OperatingSystemTemplate = listOperatingSystems.SelectedValue;
vm.Name = String.Format("{0}.{1}", txtHostname.Text.Trim(), txtDomain.Text.Trim());
//vm.PackageId = PanelSecurity.PackageId; //TODO: An idea to change HyperV logic of showing VMs (maybe in 2019?).
string adminPassword = password.Password;
string[] privIps = Utils.ParseDelimitedString(litPrivateAddresses.Text, '\n', '\r', ' ', '\t'); //possible doesn't work :)
IntResult reinstallResult = ES.Services.VPS2012.ReinstallVirtualMachine(PanelRequest.ItemID, vm, adminPassword, privIps, false, false, "");
if (reinstallResult.IsSuccess)
{
//Response.Redirect(EditUrl("SpaceID", PanelSecurity.PackageId.ToString(), ""));
Response.Redirect(EditUrl("ItemID", PanelRequest.ItemID.ToString(), "vps_general",
"SpaceID=" + PanelSecurity.PackageId.ToString()));
return;
}
else
{
messageBox.ShowMessage(reinstallResult, "VPS_ERROR_CREATE", "VPS");
}
}
catch (Exception ex)
{
messageBox.ShowErrorMessage("VPS_ERROR_CREATE", ex);
}
}
public static OrganizationUsersPagedResult GetBlackBerryUsers(int itemId, string sortColumn, string sortDirection, string name, string email, int startRow, int count)
{
OrganizationUsersPagedResult res = TaskManager.StartResultTask <OrganizationUsersPagedResult>("BLACKBERRY", "GET_BLACKBERRY_USERS");
try
{
IDataReader reader =
DataProvider.GetBlackBerryUsers(itemId, sortColumn, sortDirection, name, email, startRow, count);
List <OrganizationUser> accounts = new List <OrganizationUser>();
ObjectUtils.FillCollectionFromDataReader(accounts, reader);
res.Value = new OrganizationUsersPaged {
PageUsers = accounts.ToArray()
};
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, CrmErrorCodes.GET_CRM_USERS, ex);
return(res);
}
IntResult intRes = GetBlackBerryUsersCount(itemId, name, email);
res.ErrorCodes.AddRange(intRes.ErrorCodes);
if (!intRes.IsSuccess)
{
TaskManager.CompleteResultTask(res);
return(res);
}
res.Value.RecordsCount = intRes.Value;
TaskManager.CompleteResultTask();
return(res);
}
public void OkDoesNotEqualError()
{
var x = IntResult.Ok(1);
var y = IntResult.Err("bar");
Assert.AreNotEqual(x, y);
}
public void ErrorEqualsError()
{
var x = IntResult.Err("boom");
var y = IntResult.Err("boom");
Assert.AreEqual(x, y);
}
public void ErrorDoesNotEqualDifferentError()
{
var x = IntResult.Err("foo");
var y = IntResult.Err("bar");
Assert.AreNotEqual(x, y);
}
public void OkDoesNotEqualDifferentOk()
{
var x = IntResult.Ok(22);
var y = IntResult.Ok(1);
Assert.AreNotEqual(x, y);
}
public static LyncUsersPagedResult GetLyncUsersPaged(int itemId, string sortColumn, string sortDirection, int startRow, int count)
{
LyncUsersPagedResult res = TaskManager.StartResultTask <LyncUsersPagedResult>("LYNC", "GET_LYNC_USERS");
try
{
IDataReader reader =
DataProvider.GetLyncUsers(itemId, sortColumn, sortDirection, startRow, count);
List <LyncUser> accounts = new List <LyncUser>();
ObjectUtils.FillCollectionFromDataReader(accounts, reader);
res.Value = new LyncUsersPaged {
PageUsers = accounts.ToArray()
};
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, LyncErrorCodes.GET_LYNC_USERS, ex);
return(res);
}
IntResult intRes = GetLyncUsersCount(itemId);
res.ErrorCodes.AddRange(intRes.ErrorCodes);
if (!intRes.IsSuccess)
{
TaskManager.CompleteResultTask(res);
return(res);
}
res.Value.RecordsCount = intRes.Value;
TaskManager.CompleteResultTask();
return(res);
}
public void MapErrPassesThroughOks()
{
var actual =
IntResult.Ok(2)
.MapErr(e => new SomeError(e));
Assert.AreEqual(Result <int, SomeError> .Ok(2), actual);
}
public void SatisfiesFunctorIdentityLaw()
{
int identity(int a) => a;
var result = IntResult.Ok(23);
Assert.AreEqual(result, result.Map(identity));
}
public void SatisfiesMonadLeftidentityLaw()
{
IntResult add1(int a) => IntResult.Ok(a + 1);
var a = 1;
// return a >>= f === f a
Assert.AreEqual(IntResult.Ok(a).Bind(add1), add1(a));
}
public void BindMapsFromOneResultTypeToAnother()
{
var result = IntResult.Ok(21);
var actual =
result
.Bind(r => DoubleResult.Ok(r + 1.0));
Assert.AreEqual(22.0, actual.Unwrap());
}
public void IsAFunctor()
{
var a = IntResult.Ok(2);
var b = IntResult.Ok(3);
var actual = a.Map((a) => a + 3);
Assert.AreEqual(IntResult.Ok(5), actual);
}
public void BindRailroadsErrors()
{
var result = IntResult.Ok(21);
var actual =
result
.Bind(r => IntResult.Err("boom"))
.Bind(r => IntResult.Ok(r + 1));
Assert.AreEqual("boom", actual.Error());
}
public void EqualsIsAssociative()
{
var x = IntResult.Ok(22);
var y = IntResult.Ok(22);
var z = IntResult.Ok(22);
var left = x.Equals(y) && y.Equals(z);
Assert.AreEqual(left, x.Equals(z));
}
public IntResult LoginStudent(string username, string password)
{
var encrypt_key = configuration.GetEncryptPassword();
var encodedPassword = FMCW.Seguridad.Encriptador.Encriptar(password, encrypt_key);
var user = context.Student.FirstOrDefault(s => s.Username == username && s.Password == encodedPassword);
return(user != null?
IntResult.Ok(user.IdStudent) :
IntResult.Error(new Exception("Wrong user or password")));
}
private static bool CheckQuota(int itemId)
{
Organization org = OrganizationController.GetOrganization(itemId);
PackageContext cntx = PackageController.GetPackageContext(org.PackageId);
IntResult userCount = GetLyncUsersCount(itemId);
int allocatedUsers = cntx.Quotas[Quotas.LYNC_USERS].QuotaAllocatedValuePerOrganization;
return(allocatedUsers == -1 || allocatedUsers > userCount.Value);
}
public void MapErrMapsToANewErrorType()
{
var expected =
Result <int, SomeError> .Err(new SomeError("boom"));
var actual =
IntResult.Err("boom")
.MapErr(e => new SomeError(e));
Assert.AreEqual(expected, actual);
}
private static bool CheckQuota(int itemId)
{
Organization org = OrganizationController.GetOrganization(itemId);
PackageContext cntx = PackageController.GetPackageContext(org.PackageId);
IntResult userCount = GetBlackBerryUsersCount(itemId, string.Empty, string.Empty);
int allocatedBlackBerryUsers = cntx.Quotas[Quotas.BLACKBERRY_USERS].QuotaAllocatedValuePerOrganization;
return(allocatedBlackBerryUsers == -1 || allocatedBlackBerryUsers > userCount.Value);
}
protected void btnImport_Click(object sender, EventArgs e)
{
try
{
// external IPs
List <int> extIps = new List <int>();
foreach (ListItem li in ExternalAddresses.Items)
{
if (li.Selected)
{
extIps.Add(Utils.ParseInt(li.Value));
}
}
// management IPs
int manIp = 0;
foreach (ListItem li in ManagementAddresses.Items)
{
if (li.Selected)
{
manIp = Utils.ParseInt(li.Value);
break;
}
}
// create virtual machine
IntResult res = ES.Services.VPS2012.ImportVirtualMachine(PanelSecurity.PackageId,
Utils.ParseInt(HyperVServices.SelectedValue),
VirtualMachines.SelectedValue,
OsTemplates.SelectedValue, adminPassword.Text,
chkBootFromCd.Checked, chkDvdInstalled.Checked,
AllowStartShutdown.Checked, AllowPause.Checked, AllowReboot.Checked, AllowReset.Checked, AllowReinstall.Checked,
ExternalAdapters.SelectedValue, extIps.ToArray(),
ManagementAdapters.SelectedValue, manIp,
Utils.ParseInt(txtSnapshots.Text.Trim()),
chkIgnoreCheckes.Checked);
if (res.IsSuccess)
{
Response.Redirect(EditUrl("ItemID", res.Value.ToString(), "vps_general",
"SpaceID=" + PanelSecurity.PackageId.ToString()));
}
else
{
messageBox.ShowMessage(res, "VPS_ERROR_IMPORT", "VPS");
ShowCheckBoxes(true);
}
}
catch (Exception ex)
{
messageBox.ShowErrorMessage("VPS_ERROR_IMPORT", ex);
}
}
public void SatisfiesFunctorCompositionLaw()
{
int add1(int a) => a;
int mult2(int a) => a;
var result = IntResult.Ok(3);
Assert.AreEqual(
result.Map(x => add1(mult2(x))),
result.Map(add1).Map(mult2)
);
}
public ActionResult SightRadius(Guid userId)
{
IntResult result = new IntResult { Value = _userSightRadiusProvider.GetUserSightRadius(userId, DateTime.Now) };
return Json(result, JsonRequestBehavior.AllowGet);
}
private IntResult GetMoney(Guid userId)
{
IntResult result = new IntResult { Value = _userRetriever.GetCurrentMoney(userId) };
return result;
}
public static IntResult CreateVirtualMachine(int packageId,
string hostname, string osTemplateFile, string password, string summaryLetterEmail,
int cpuCores, int ramMB, int hddGB, int snapshots,
bool dvdInstalled, bool bootFromCD, bool numLock,
bool startShutdownAllowed, bool pauseResumeAllowed, bool rebootAllowed, bool resetAllowed, bool reinstallAllowed,
bool externalNetworkEnabled, int externalAddressesNumber, bool randomExternalAddresses, int[] externalAddresses,
bool privateNetworkEnabled, int privateAddressesNumber, bool randomPrivateAddresses, string[] privateAddresses, VirtualMachine otherSettings)
{
// result object
IntResult res = new IntResult();
// meta item
VirtualMachine vm = null;
try
{
#region Check account and space statuses
// check account
if (!SecurityContext.CheckAccount(res, DemandAccount.NotDemo | DemandAccount.IsActive))
return res;
// check package
if (!SecurityContext.CheckPackage(res, packageId, DemandPackage.IsActive))
return res;
#endregion
#region Check if host name is already used
try
{
ServiceProviderItem item = PackageController.GetPackageItemByName(packageId, hostname,
typeof (VirtualMachine));
if (item != null)
{
res.ErrorCodes.Add(VirtualizationErrorCodes.HOST_NAMER_IS_ALREADY_USED);
return res;
}
}
catch(Exception ex)
{
res.AddError(VirtualizationErrorCodes.CANNOT_CHECK_HOST_EXISTS, ex);
return res;
}
#endregion
#region Check Quotas
// check quotas
List<string> quotaResults = new List<string>();
PackageContext cntx = PackageController.GetPackageContext(packageId);
// dynamic memory
var newRam = ramMB;
if (otherSettings.DynamicMemory != null && otherSettings.DynamicMemory.Enabled)
{
newRam = otherSettings.DynamicMemory.Maximum;
if (ramMB > otherSettings.DynamicMemory.Maximum || ramMB < otherSettings.DynamicMemory.Minimum)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_NOT_IN_DYNAMIC_RAM);
}
QuotaHelper.CheckListsQuota(cntx, quotaResults, Quotas.VPS2012_SERVERS_NUMBER, VirtualizationErrorCodes.QUOTA_EXCEEDED_SERVERS_NUMBER);
QuotaHelper.CheckNumericQuota(cntx, quotaResults, Quotas.VPS2012_CPU_NUMBER, cpuCores, VirtualizationErrorCodes.QUOTA_EXCEEDED_CPU);
QuotaHelper.CheckNumericQuota(cntx, quotaResults, Quotas.VPS2012_RAM, newRam, VirtualizationErrorCodes.QUOTA_EXCEEDED_RAM);
QuotaHelper.CheckNumericQuota(cntx, quotaResults, Quotas.VPS2012_HDD, hddGB, VirtualizationErrorCodes.QUOTA_EXCEEDED_HDD);
QuotaHelper.CheckNumericQuota(cntx, quotaResults, Quotas.VPS2012_SNAPSHOTS_NUMBER, snapshots, VirtualizationErrorCodes.QUOTA_EXCEEDED_SNAPSHOTS);
QuotaHelper.CheckBooleanQuota(cntx, quotaResults, Quotas.VPS2012_DVD_ENABLED, dvdInstalled, VirtualizationErrorCodes.QUOTA_EXCEEDED_DVD_ENABLED);
QuotaHelper.CheckBooleanQuota(cntx, quotaResults, Quotas.VPS2012_BOOT_CD_ALLOWED, bootFromCD, VirtualizationErrorCodes.QUOTA_EXCEEDED_CD_ALLOWED);
QuotaHelper.CheckBooleanQuota(cntx, quotaResults, Quotas.VPS2012_START_SHUTDOWN_ALLOWED, startShutdownAllowed, VirtualizationErrorCodes.QUOTA_EXCEEDED_START_SHUTDOWN_ALLOWED);
QuotaHelper.CheckBooleanQuota(cntx, quotaResults, Quotas.VPS2012_PAUSE_RESUME_ALLOWED, pauseResumeAllowed, VirtualizationErrorCodes.QUOTA_EXCEEDED_PAUSE_RESUME_ALLOWED);
QuotaHelper.CheckBooleanQuota(cntx, quotaResults, Quotas.VPS2012_REBOOT_ALLOWED, rebootAllowed, VirtualizationErrorCodes.QUOTA_EXCEEDED_REBOOT_ALLOWED);
QuotaHelper.CheckBooleanQuota(cntx, quotaResults, Quotas.VPS2012_RESET_ALOWED, resetAllowed, VirtualizationErrorCodes.QUOTA_EXCEEDED_RESET_ALOWED);
QuotaHelper.CheckBooleanQuota(cntx, quotaResults, Quotas.VPS2012_REINSTALL_ALLOWED, reinstallAllowed, VirtualizationErrorCodes.QUOTA_EXCEEDED_REINSTALL_ALLOWED);
QuotaHelper.CheckBooleanQuota(cntx, quotaResults, Quotas.VPS2012_EXTERNAL_NETWORK_ENABLED, externalNetworkEnabled, VirtualizationErrorCodes.QUOTA_EXCEEDED_EXTERNAL_NETWORK_ENABLED);
QuotaHelper.CheckBooleanQuota(cntx, quotaResults, Quotas.VPS2012_PRIVATE_NETWORK_ENABLED, privateNetworkEnabled, VirtualizationErrorCodes.QUOTA_EXCEEDED_PRIVATE_NETWORK_ENABLED);
// check external addresses number
if (!randomExternalAddresses && externalAddresses != null)
externalAddressesNumber = externalAddresses.Length;
int maxAddresses = ServerController.GetPackageUnassignedIPAddresses(packageId, IPAddressPool.VpsExternalNetwork).Count;
if (externalNetworkEnabled && externalAddressesNumber > maxAddresses)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_EXCEEDED_EXTERNAL_ADDRESSES_NUMBER + ":" + maxAddresses.ToString());
// check private addresses number
if (!randomPrivateAddresses && privateAddresses != null)
privateAddressesNumber = privateAddresses.Length;
QuotaHelper.CheckNumericQuota(cntx, quotaResults, Quotas.VPS2012_PRIVATE_IP_ADDRESSES_NUMBER, privateAddressesNumber, VirtualizationErrorCodes.QUOTA_EXCEEDED_PRIVATE_ADDRESSES_NUMBER);
// check management network parameters
NetworkAdapterDetails manageNic = GetManagementNetworkDetails(packageId);
if (!String.IsNullOrEmpty(manageNic.NetworkId))
{
// network enabled - check management IPs pool
int manageIpsNumber = ServerController.GetUnallottedIPAddresses(
packageId, ResourceGroups.VPS2012, IPAddressPool.VpsManagementNetwork).Count;
if (manageIpsNumber == 0)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_EXCEEDED_MANAGEMENT_NETWORK);
}
// check acceptable values
if (ramMB <= 0)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_WRONG_RAM);
if (hddGB <= 0)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_WRONG_HDD);
if (snapshots < 0)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_WRONG_SNAPSHOTS);
if (quotaResults.Count > 0)
{
res.ErrorCodes.AddRange(quotaResults);
return res;
}
#endregion
#region Check input parameters
// check private network IP addresses if they are specified
List<string> checkResults = CheckPrivateIPAddresses(packageId, privateAddresses);
if (checkResults.Count > 0)
{
res.ErrorCodes.AddRange(checkResults);
return res;
}
#endregion
#region Context variables
// service ID
int serviceId = GetServiceId(packageId);
// load service settings
StringDictionary settings = ServerController.GetServiceSettings(serviceId);
#endregion
#region Create meta item
// create meta item
vm = new VirtualMachine();
vm.Name = hostname;
vm.AdministratorPassword = CryptoUtils.Encrypt(password);
vm.PackageId = packageId;
vm.VirtualMachineId = null; // from service
vm.ServiceId = serviceId;
vm.CurrentTaskId = Guid.NewGuid().ToString("N"); // generate creation task id
vm.ProvisioningStatus = VirtualMachineProvisioningStatus.InProgress;
vm.Generation = otherSettings.Generation;
vm.CpuCores = cpuCores;
vm.RamSize = ramMB;
vm.HddSize = hddGB;
vm.SnapshotsNumber = snapshots;
vm.DvdDriveInstalled = dvdInstalled;
vm.BootFromCD = bootFromCD;
vm.NumLockEnabled = numLock;
vm.StartTurnOffAllowed = startShutdownAllowed;
vm.PauseResumeAllowed = pauseResumeAllowed;
vm.RebootAllowed = rebootAllowed;
vm.ResetAllowed = resetAllowed;
vm.ReinstallAllowed = reinstallAllowed;
// dynamic memory
if (otherSettings.DynamicMemory != null && otherSettings.DynamicMemory.Enabled)
vm.DynamicMemory = otherSettings.DynamicMemory;
else
vm.DynamicMemory = null;
// networking
vm.ExternalNetworkEnabled = externalNetworkEnabled;
vm.PrivateNetworkEnabled = privateNetworkEnabled;
vm.ManagementNetworkEnabled = !String.IsNullOrEmpty(manageNic.NetworkId);
// load OS templates
LibraryItem osTemplate = null;
try
{
LibraryItem[] osTemplates = GetOperatingSystemTemplates(vm.PackageId);
foreach (LibraryItem item in osTemplates)
{
if (String.Compare(item.Path, osTemplateFile, true) == 0)
{
osTemplate = item;
// check minimal disk size
if (osTemplate.DiskSize > 0 && vm.HddSize < osTemplate.DiskSize)
{
TaskManager.CompleteResultTask(res, VirtualizationErrorCodes.QUOTA_TEMPLATE_DISK_MINIMAL_SIZE + ":" + osTemplate.DiskSize);
return res;
}
vm.OperatingSystemTemplate = osTemplate.Name;
vm.LegacyNetworkAdapter = osTemplate.LegacyNetworkAdapter;
vm.RemoteDesktopEnabled = osTemplate.RemoteDesktop;
break;
}
}
}
catch (Exception ex)
{
res.AddError(VirtualizationErrorCodes.GET_OS_TEMPLATES_ERROR, ex);
return res;
}
// setup VM paths
string templatesPath = settings["OsTemplatesPath"];
string rootFolderPattern = settings["RootFolder"];
if(rootFolderPattern.IndexOf("[") == -1)
{
// no pattern has been specified
if(!rootFolderPattern.EndsWith("\\"))
rootFolderPattern += "\\";
rootFolderPattern += "[username]\\[vps_hostname]";
}
vm.RootFolderPath = EvaluateItemVariables(rootFolderPattern, vm);
var correctVhdPath = GetCorrectTemplateFilePath(templatesPath, osTemplateFile);
vm.OperatingSystemTemplatePath = correctVhdPath;
vm.VirtualHardDrivePath = Path.Combine(vm.RootFolderPath, hostname + Path.GetExtension(correctVhdPath));
// save meta-item
try
{
vm.Id = PackageController.AddPackageItem(vm);
}
catch (Exception ex)
{
res.AddError(VirtualizationErrorCodes.CREATE_META_ITEM_ERROR, ex);
return res;
}
#endregion
#region Start Asynchronous task
try
{
// asynchronous process starts here
CreateServerAsyncWorker2012 worker = new CreateServerAsyncWorker2012();
worker.TaskId = vm.CurrentTaskId; // async task ID
worker.ThreadUserId = SecurityContext.User.UserId;
worker.Item = vm;
worker.OsTemplate = osTemplate;
worker.ExternalAddressesNumber = externalAddressesNumber;
worker.RandomExternalAddresses = randomExternalAddresses;
worker.ExternalAddresses = externalAddresses;
worker.PrivateAddressesNumber = privateAddressesNumber;
worker.RandomPrivateAddresses = randomPrivateAddresses;
worker.PrivateAddresses = privateAddresses;
worker.SummaryLetterEmail = summaryLetterEmail;
worker.CreateAsync();
}
catch (Exception ex)
{
// delete meta item
PackageController.DeletePackageItem(vm.Id);
// return from method
res.AddError(VirtualizationErrorCodes.CREATE_TASK_START_ERROR, ex);
return res;
}
#endregion
}
catch (Exception ex)
{
res.AddError(VirtualizationErrorCodes.CREATE_ERROR, ex);
return res;
}
res.Value = vm.Id;
res.IsSuccess = true;
return res;
}
public static IntResult CreateDefaultVirtualMachine(int packageId,
string hostname, string osTemplate, string password, string summaryLetterEmail)
{
if (String.IsNullOrEmpty(osTemplate))
throw new ArgumentNullException("osTemplate");
IntResult res = new IntResult();
// load package info
PackageInfo package = PackageController.GetPackage(packageId);
if (package == null)
{
res.ErrorCodes.Add("VPS_CREATE_PACKAGE_NOT_FOUND");
return res;
}
// generate host name if not specified
if (String.IsNullOrEmpty(hostname))
{
// load hostname pattern
PackageSettings spaceSettings = PackageController.GetPackageSettings(packageId, PackageSettings.VIRTUAL_PRIVATE_SERVERS_2012);
string hostnamePattern = spaceSettings["HostnamePattern"];
if (String.IsNullOrEmpty(hostnamePattern))
{
res.ErrorCodes.Add("VPS_CREATE_EMPTY_HOSTNAME_PATTERN");
return res;
}
hostname = EvaluateSpaceVariables(hostnamePattern, packageId);
}
// generate password if not specified
if (String.IsNullOrEmpty(password))
{
int passwordLength = DEFAULT_PASSWORD_LENGTH; // default length
// load password policy
UserSettings userSettings = UserController.GetUserSettings(package.UserId, UserSettings.VPS_POLICY);
string passwordPolicy = userSettings["AdministratorPasswordPolicy"];
if (!String.IsNullOrEmpty(passwordPolicy))
{
// get second parameter - max length
passwordLength = Utils.ParseInt(passwordPolicy.Split(';')[1].Trim(), passwordLength);
}
// generate password
password = Utils.GetRandomString(passwordLength);
}
// load quotas
PackageContext cntx = PackageController.GetPackageContext(packageId);
if (cntx.Groups.ContainsKey(ResourceGroups.VPS2012))
{
res.ErrorCodes.Add("VPS_CREATE_VPS_GROUP_DISABLED");
return res;
}
// CPU cores
int cpuCores = cntx.Quotas[Quotas.VPS2012_CPU_NUMBER].QuotaAllocatedValue;
if (cpuCores == -1) // unlimited is not possible
cpuCores = GetMaximumCpuCoresNumber(packageId);
// RAM
int ramMB = cntx.Quotas[Quotas.VPS2012_RAM].QuotaAllocatedValue;
if (ramMB == -1) // unlimited is not possible
ramMB = DEFAULT_RAM_SIZE;
// HDD
int hddGB = cntx.Quotas[Quotas.VPS2012_HDD].QuotaAllocatedValue;
if (hddGB == -1) // unlimited is not possible
hddGB = DEFAULT_HDD_SIZE;
// snapshots
int snapshots = cntx.Quotas[Quotas.VPS2012_SNAPSHOTS_NUMBER].QuotaAllocatedValue;
if (snapshots == -1) // unlimited is not possible
snapshots = DEFAULT_SNAPSHOTS_NUMBER;
bool dvdInstalled = !cntx.Quotas[Quotas.VPS2012_DVD_ENABLED].QuotaExhausted;
bool bootFromCD = !cntx.Quotas[Quotas.VPS2012_BOOT_CD_ENABLED].QuotaExhausted;
bool numLock = true;
bool startShutdownAllowed = !cntx.Quotas[Quotas.VPS2012_START_SHUTDOWN_ALLOWED].QuotaExhausted;
bool pauseResumeAllowed = !cntx.Quotas[Quotas.VPS2012_PAUSE_RESUME_ALLOWED].QuotaExhausted;
bool rebootAllowed = !cntx.Quotas[Quotas.VPS2012_REBOOT_ALLOWED].QuotaExhausted;
bool resetAllowed = !cntx.Quotas[Quotas.VPS2012_RESET_ALOWED].QuotaExhausted;
bool reinstallAllowed = !cntx.Quotas[Quotas.VPS2012_REINSTALL_ALLOWED].QuotaExhausted;
bool externalNetworkEnabled = !cntx.Quotas[Quotas.VPS2012_EXTERNAL_NETWORK_ENABLED].QuotaExhausted;
int externalAddressesNumber = cntx.Quotas[Quotas.VPS2012_EXTERNAL_IP_ADDRESSES_NUMBER].QuotaAllocatedValue;
bool randomExternalAddresses = true;
int[] externalAddresses = new int[0]; // empty array
if (externalNetworkEnabled)
{
int maxExternalAddresses = ServerController.GetPackageUnassignedIPAddresses(packageId, IPAddressPool.VpsExternalNetwork).Count;
if (externalAddressesNumber == -1
|| externalAddressesNumber > maxExternalAddresses)
externalAddressesNumber = maxExternalAddresses;
}
bool privateNetworkEnabled = !cntx.Quotas[Quotas.VPS2012_PRIVATE_NETWORK_ENABLED].QuotaExhausted;
int privateAddressesNumber = cntx.Quotas[Quotas.VPS2012_PRIVATE_IP_ADDRESSES_NUMBER].QuotaAllocatedValue;
bool randomPrivateAddresses = true;
string[] privateAddresses = new string[0]; // empty array
if (privateAddressesNumber == -1) // unlimited is not possible
{
privateAddressesNumber = DEFAULT_PRIVATE_IPS_NUMBER;
}
// create server and return result
return CreateVirtualMachine(packageId, hostname, osTemplate, password, summaryLetterEmail,
cpuCores, ramMB, hddGB, snapshots,
dvdInstalled, bootFromCD, numLock,
startShutdownAllowed, pauseResumeAllowed, rebootAllowed, resetAllowed, reinstallAllowed,
externalNetworkEnabled, externalAddressesNumber, randomExternalAddresses, externalAddresses,
privateNetworkEnabled, privateAddressesNumber, randomPrivateAddresses, privateAddresses, new VirtualMachine());
}
public static IntResult ImportVirtualMachine(int packageId,
int serviceId, string vmId,
string osTemplateFile, string adminPassword,
bool startShutdownAllowed, bool pauseResumeAllowed, bool rebootAllowed, bool resetAllowed, bool reinstallAllowed,
string externalNicMacAddress, int[] externalAddresses,
string managementNicMacAddress, int managementAddress)
{
// result object
IntResult res = new IntResult();
// meta item
VirtualMachine item = null;
try
{
#region Check account and space statuses
// check account
if (!SecurityContext.CheckAccount(res, DemandAccount.NotDemo | DemandAccount.IsActive | DemandAccount.IsAdmin))
return res;
// check package
if (!SecurityContext.CheckPackage(res, packageId, DemandPackage.IsActive))
return res;
#endregion
// load package context
PackageContext cntx = PackageController.GetPackageContext(packageId);
item = new VirtualMachine();
item.ServiceId = serviceId;
item.PackageId = packageId;
item.VirtualMachineId = vmId;
// load service settings
StringDictionary settings = ServerController.GetServiceSettings(serviceId);
// load virtual machine info from service
VirtualizationServer2012 vs = GetVirtualizationProxy(serviceId);
VirtualMachine vm = vs.GetVirtualMachineEx(vmId);
// set VM properties
item.Name = vm.Name;
item.ProvisioningStatus = VirtualMachineProvisioningStatus.OK;
item.Generation = vm.Generation;
item.CpuCores = vm.CpuCores;
item.RamSize = vm.RamSize;
item.DynamicMemory = vm.DynamicMemory;
item.HddSize = vm.HddSize;
item.VirtualHardDrivePath = vm.VirtualHardDrivePath;
item.RootFolderPath = Path.GetDirectoryName(vm.VirtualHardDrivePath);
item.SnapshotsNumber = cntx.Quotas[Quotas.VPS2012_SNAPSHOTS_NUMBER].QuotaAllocatedValue;
item.DvdDriveInstalled = vm.DvdDriveInstalled;
item.BootFromCD = vm.BootFromCD;
item.NumLockEnabled = vm.NumLockEnabled;
item.StartTurnOffAllowed = startShutdownAllowed;
item.PauseResumeAllowed = pauseResumeAllowed;
item.RebootAllowed = rebootAllowed;
item.ResetAllowed = resetAllowed;
item.ReinstallAllowed = reinstallAllowed;
// remote desktop
if(!String.IsNullOrEmpty(adminPassword))
{
item.RemoteDesktopEnabled = true;
item.AdministratorPassword = CryptoUtils.Encrypt(adminPassword);
}
// set OS template
string templatesPath = settings["OsTemplatesPath"];
var correctVhdPath = GetCorrectTemplateFilePath(templatesPath, osTemplateFile);
item.OperatingSystemTemplatePath = correctVhdPath;
try
{
LibraryItem[] osTemplates = GetOperatingSystemTemplatesByServiceId(serviceId);
foreach (LibraryItem osTemplate in osTemplates)
{
if (String.Compare(osTemplate.Path, osTemplateFile, true) == 0)
{
item.OperatingSystemTemplate = osTemplate.Name;
item.LegacyNetworkAdapter = osTemplate.LegacyNetworkAdapter;
break;
}
}
}
catch (Exception ex)
{
res.AddError(VirtualizationErrorCodes.GET_OS_TEMPLATES_ERROR, ex);
return res;
}
// save item
int itemId = PackageController.AddPackageItem(item);
item.Id = itemId;
res.Value = itemId;
#region Setup external network
// setup external network
if (!String.IsNullOrEmpty(externalNicMacAddress))
{
item.ExternalNetworkEnabled = true;
item.ExternalNicMacAddress = externalNicMacAddress;
item.ExternalSwitchId = settings["ExternalNetworkId"];
// assign selected IP addresses to package
ServerController.AllocatePackageIPAddresses(packageId, externalAddresses);
// re-read package IPs
List<PackageIPAddress> packageIPs = ServerController.GetPackageUnassignedIPAddresses(
packageId, IPAddressPool.VpsExternalNetwork);
// assign IP addresses to VM
for(int i = 0; i < externalAddresses.Length; i++)
{
foreach (PackageIPAddress ip in packageIPs)
{
if (ip.AddressID == externalAddresses[i])
{
// assign to the item
ServerController.AddItemIPAddress(itemId, ip.PackageAddressID);
// set primary IP address
if(i == 0)
ServerController.SetItemPrimaryIPAddress(itemId, ip.PackageAddressID);
break;
}
}
}
}
#endregion
#region Setup management network
// setup management network
if (!String.IsNullOrEmpty(managementNicMacAddress))
{
item.ManagementNetworkEnabled = true;
item.ManagementNicMacAddress = managementNicMacAddress;
item.ManagementSwitchId = settings["ManagementNetworkId"];
// assign selected IP addresses to package
ServerController.AllocatePackageIPAddresses(packageId, new int[] { managementAddress });
// re-read package IPs
List<PackageIPAddress> packageIPs = ServerController.GetPackageUnassignedIPAddresses(
packageId, IPAddressPool.VpsManagementNetwork);
// assign IP addresses to VM
foreach (PackageIPAddress ip in packageIPs)
{
if (ip.AddressID == managementAddress)
{
// assign to the item
ServerController.AddItemIPAddress(itemId, ip.PackageAddressID);
break;
}
}
}
#endregion
// save item once again
PackageController.UpdatePackageItem(item);
}
catch (Exception ex)
{
res.AddError(VirtualizationErrorCodes.IMPORT_ERROR, ex);
return res;
}
res.IsSuccess = true;
return res;
}
public static IntResult AddIPAddress(IPAddressPool pool, int serverId,
string externalIP, string internalIP, string subnetMask, string defaultGateway, string comments)
{
IntResult res = new IntResult();
#region Check account statuses
// check account
if (!SecurityContext.CheckAccount(res, DemandAccount.NotDemo | DemandAccount.IsAdmin | DemandAccount.IsActive))
return res;
#endregion
// start task
res = TaskManager.StartResultTask<IntResult>("IP_ADDRESS", "ADD");
TaskManager.ItemName = externalIP;
TaskManager.WriteParameter("IP Address", externalIP);
TaskManager.WriteParameter("NAT Address", internalIP);
try
{
res.Value = DataProvider.AddIPAddress((int)pool, serverId, externalIP, internalIP,
subnetMask, defaultGateway, comments);
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, "IP_ADDRESS_ADD_ERROR", ex);
return res;
}
TaskManager.CompleteResultTask();
return res;
}
public static IntResult CreateVirtualMachine(int packageId,
string hostname, string domain, string osTemplateFile, string vmName, string password, string summaryLetterEmail,
int cpuCores, int ramMB, int hddGB, int snapshots,
bool dvdInstalled, bool bootFromCD, bool numLock,
bool startShutdownAllowed, bool pauseResumeAllowed, bool rebootAllowed, bool resetAllowed, bool reinstallAllowed,
bool externalNetworkEnabled, string externalNetworkLocation, string externalNicMacAddress, string externalVirtualNetwork,
bool privateNetworkEnabled, string privateNetworkLocation, string privateNicMacAddress, string privateVirtualNetwork, ushort privateVLanID)
{
// result object
IntResult res = new IntResult();
//Create Task
res = TaskManager.StartResultTask<IntResult>("VPSForPC", "CREATE");
TaskManager.PackageId = packageId;
TaskManager.ItemName = vmName;
// meta item
VMInfo vmInfo = null;
try
{
#region Check account and space statuses
// check account
if (!SecurityContext.CheckAccount(res, DemandAccount.NotDemo | DemandAccount.IsActive))
{
res.ErrorCodes.Add(VirtualizationErrorCodes.CREATE_ERROR);
TaskManager.CompleteResultTask(res);
return res;
}
// check package
if (!SecurityContext.CheckPackage(res, packageId, DemandPackage.IsActive))
{
res.ErrorCodes.Add(VirtualizationErrorCodes.CREATE_ERROR);
TaskManager.CompleteResultTask(res);
return res;
}
#endregion
#region Check if host name is already used
try
{
string itemName = (String.IsNullOrEmpty(hostname) && String.IsNullOrEmpty(domain) ? vmName: String.Format("{0}.{1}", hostname, domain));
ServiceProviderItem item = PackageController.GetPackageItemByName(packageId, itemName,
typeof (VMInfo));
if (item != null)
{
res.ErrorCodes.Add(VirtualizationErrorCodes.HOST_NAMER_IS_ALREADY_USED);
TaskManager.CompleteResultTask(res);
return res;
}
}
catch(Exception ex)
{
res.AddError(VirtualizationErrorCodes.CANNOT_CHECK_HOST_EXISTS, ex);
TaskManager.CompleteResultTask(res);
return res;
}
#endregion
#region Check Quotas
// check quotas
List<string> quotaResults = new List<string>();
PackageContext cntx = PackageController.GetPackageContext(packageId);
CheckListsQuota(cntx, quotaResults, Quotas.VPSForPC_SERVERS_NUMBER, VirtualizationErrorCodes.QUOTA_EXCEEDED_SERVERS_NUMBER);
CheckNumericQuota(cntx, quotaResults, Quotas.VPSForPC_CPU_NUMBER, cpuCores, VirtualizationErrorCodes.QUOTA_EXCEEDED_CPU);
CheckNumericQuota(cntx, quotaResults, Quotas.VPSForPC_RAM, ramMB, VirtualizationErrorCodes.QUOTA_EXCEEDED_RAM);
CheckNumericQuota(cntx, quotaResults, Quotas.VPSForPC_HDD, hddGB, VirtualizationErrorCodes.QUOTA_EXCEEDED_HDD);
CheckNumericQuota(cntx, quotaResults, Quotas.VPSForPC_SNAPSHOTS_NUMBER, snapshots, VirtualizationErrorCodes.QUOTA_EXCEEDED_SNAPSHOTS);
CheckBooleanQuota(cntx, quotaResults, Quotas.VPSForPC_DVD_ENABLED, dvdInstalled, VirtualizationErrorCodes.QUOTA_EXCEEDED_DVD_ENABLED);
CheckBooleanQuota(cntx, quotaResults, Quotas.VPSForPC_BOOT_CD_ALLOWED, bootFromCD, VirtualizationErrorCodes.QUOTA_EXCEEDED_CD_ALLOWED);
CheckBooleanQuota(cntx, quotaResults, Quotas.VPSForPC_START_SHUTDOWN_ALLOWED, startShutdownAllowed, VirtualizationErrorCodes.QUOTA_EXCEEDED_START_SHUTDOWN_ALLOWED);
CheckBooleanQuota(cntx, quotaResults, Quotas.VPSForPC_PAUSE_RESUME_ALLOWED, pauseResumeAllowed, VirtualizationErrorCodes.QUOTA_EXCEEDED_PAUSE_RESUME_ALLOWED);
CheckBooleanQuota(cntx, quotaResults, Quotas.VPSForPC_REBOOT_ALLOWED, rebootAllowed, VirtualizationErrorCodes.QUOTA_EXCEEDED_REBOOT_ALLOWED);
CheckBooleanQuota(cntx, quotaResults, Quotas.VPSForPC_RESET_ALOWED, resetAllowed, VirtualizationErrorCodes.QUOTA_EXCEEDED_RESET_ALOWED);
CheckBooleanQuota(cntx, quotaResults, Quotas.VPSForPC_REINSTALL_ALLOWED, reinstallAllowed, VirtualizationErrorCodes.QUOTA_EXCEEDED_REINSTALL_ALLOWED);
CheckBooleanQuota(cntx, quotaResults, Quotas.VPSForPC_EXTERNAL_NETWORK_ENABLED, externalNetworkEnabled, VirtualizationErrorCodes.QUOTA_EXCEEDED_EXTERNAL_NETWORK_ENABLED);
CheckBooleanQuota(cntx, quotaResults, Quotas.VPSForPC_PRIVATE_NETWORK_ENABLED, privateNetworkEnabled, VirtualizationErrorCodes.QUOTA_EXCEEDED_PRIVATE_NETWORK_ENABLED);
// check management network parameters
NetworkAdapterDetails manageNic = GetManagementNetworkDetails(packageId);
if (!String.IsNullOrEmpty(manageNic.NetworkId))
{
// network enabled - check management IPs pool
int manageIpsNumber = ServerController.GetUnallottedIPAddresses(
packageId, ResourceGroups.VPSForPC, IPAddressPool.VpsManagementNetwork).Count;
if (manageIpsNumber == 0)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_EXCEEDED_MANAGEMENT_NETWORK);
}
// check acceptable values
if (ramMB <= 0)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_WRONG_RAM);
if (hddGB <= 0)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_WRONG_HDD);
if (snapshots < 0)
quotaResults.Add(VirtualizationErrorCodes.QUOTA_WRONG_SNAPSHOTS);
if (quotaResults.Count > 0)
{
res.ErrorCodes.AddRange(quotaResults);
TaskManager.CompleteResultTask(res);
return res;
}
#endregion
#region Context variables
// service ID
int serviceId = GetServiceId(packageId);
// load service settings
StringDictionary settings = ServerController.GetServiceSettings(serviceId);
PackageInfo pk = PackageController.GetPackage(packageId);
UserInfo user = UserController.GetUser(pk.UserId);
#endregion
#region Create meta item
// create meta item
vmInfo = new VMInfo();
// vmInfo.AdminUserName = user.Username;
vmInfo.AdminUserName = null;
vmInfo.AdminPassword = password;
vmInfo.DvdDriver = dvdInstalled;
vmInfo.HostName = hostname;
vmInfo.CPUCount = cpuCores;
vmInfo.JoinDomain = (String.IsNullOrWhiteSpace(domain) ? null : domain);
vmInfo.JoinDomainPassword = null;
vmInfo.JoinDomainUserName = null;
vmInfo.Memory = ramMB;
vmInfo.NumLockEnabled = numLock;
vmInfo.HddSize = hddGB;
vmInfo.ProductKey = null;
vmInfo.TemplateId = new Guid(osTemplateFile);
vmInfo.VmPath = settings["RootFolder"];
vmInfo.ComputerName = vmName;
vmInfo.Owner = null;
vmInfo.PackageId = packageId;
vmInfo.ServiceId = serviceId;
vmInfo.Name = vmName;
vmInfo.StartTurnOffAllowed = startShutdownAllowed;
vmInfo.PauseResumeAllowed = pauseResumeAllowed;
vmInfo.RebootAllowed = rebootAllowed;
vmInfo.ResetAllowed = resetAllowed;
vmInfo.ReinstallAllowed = reinstallAllowed;
vmInfo.BootFromCD = bootFromCD;
//vmInfo.CurrentTaskId = Guid.NewGuid().ToString("N"); // generate creation task id
vmInfo.ProvisioningStatus = VirtualMachineProvisioningStatus.InProgress;
// networking
vmInfo.ExternalNetworkEnabled = externalNetworkEnabled;
vmInfo.ExternalNetworkLocation = externalNetworkLocation;
vmInfo.ExternalNicMacAddress = externalNicMacAddress;
vmInfo.ExternalVirtualNetwork = string.IsNullOrEmpty(externalVirtualNetwork) ? settings["ExternalNetworkName"] : externalVirtualNetwork;
vmInfo.PrivateNetworkEnabled = privateNetworkEnabled;
vmInfo.PrivateNetworkLocation = privateNetworkLocation;
vmInfo.PrivateNicMacAddress = privateNicMacAddress;
vmInfo.PrivateVLanID = privateVLanID;
vmInfo.PrivateVirtualNetwork = string.IsNullOrEmpty(privateVirtualNetwork) ? settings["PrivateNetworkName"] : privateVirtualNetwork;
// save meta-item
try
{
vmInfo.VmId = PackageController.AddPackageItem(vmInfo);
vmInfo.Id = vmInfo.VmId;
TaskManager.ItemId = vmInfo.VmId;
}
catch (Exception ex)
{
res.AddError(VirtualizationErrorCodes.CREATE_META_ITEM_ERROR, ex);
TaskManager.CompleteResultTask(res);
return res;
}
#endregion
#region Start Asynchronous task
try
{
// CreateServerAsyncWorkerForPrivateCloud worker = new CreateServerAsyncWorkerForPrivateCloud();
CreateVMAsyncWorker worker = new CreateVMAsyncWorker();
worker.vmTemplate = vmInfo;
worker.ThreadUserId = SecurityContext.User.UserId;
worker.CreateAsync();
// CreateServerAsyncWorkerForPrivateCloud.Run(vmInfo);
// worker.Run(vmInfo);
}
catch (Exception ex)
{
// delete meta item
PackageController.DeletePackageItem(vmInfo.VmId);
// return from method
res.AddError(VirtualizationErrorCodes.CREATE_TASK_START_ERROR, ex);
TaskManager.CompleteResultTask(res);
return res;
}
#endregion
}
catch (Exception ex)
{
res.AddError(VirtualizationErrorCodes.CREATE_ERROR, ex);
TaskManager.CompleteResultTask(res);
return res;
}
res.Value = vmInfo.VmId;
res.IsSuccess = true;
TaskManager.CompleteTask();
return res;
}
private IntResult GetAttackPower(Guid userId)
{
IntResult intResult = new IntResult { Value = _userAttackPowerProvider.GetAttackPower(userId) };
return intResult;
}
