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