protected override void LoadUserPools() { userPool_ComboBox.DisplayMember = "Description"; DomainAccountPool selectedPool = null; List <DomainAccountPool> userPools = null; using (AssetInventoryContext context = DbConnect.AssetInventoryContext()) { userPools = context.DomainAccountPools.OrderBy(x => x.Description).ToList(); } if (userPools.Count > 0) { bool testerHasUserPool = !string.IsNullOrEmpty(_tester.UserPool); if (testerHasUserPool) { //If tester has a User Pool setting, select it if it's in the list if (userPools.Any(x => x.DomainAccountKey.Equals(_tester.UserPool))) { selectedPool = userPools.First(x => x.DomainAccountKey.Equals(_tester.UserPool)); } } else { selectedPool = userPools.First(); } } userPool_ComboBox.DataSource = userPools; userPool_ComboBox.SelectedItem = selectedPool; }
private DomainAccountReservationSet GetReservedAccounts(bool mockReserve = false) { DomainAccountReservationSet result = new DomainAccountReservationSet(Ticket.SessionId); using (AssetInventoryContext context = DbConnect.AssetInventoryContext()) { if (mockReserve) { //Build a mock reservation foreach (var poolType in Quantities.DomainAccountQuantity.Keys) { DomainAccountPool pool = DomainAccountService.SelectPool(context, poolType); result.Add(poolType, pool, 0, Quantities.DomainAccountQuantity[poolType]); } } else { foreach (DomainAccountReservation reservation in DomainAccountService.SelectReservationsBySession(context, Ticket.SessionId)) { DomainAccountPool pool = DomainAccountService.SelectPool(context, reservation.DomainAccountKey); result.Add(reservation.DomainAccountKey, pool, reservation.StartIndex, reservation.Count); } } } return(result); }
private void add_Button_Click(object sender, EventArgs e) { var pool = new DomainAccountPool(); if (EditEntry(pool) == DialogResult.OK) { AddPool(pool); } }
/// <summary> /// Initializes a new instance of the <see cref="DomainAccountReservationListForm"/> class. /// </summary> public DomainAccountReservationListForm(DomainAccountPool pool) { InitializeComponent(); UserInterfaceStyler.Configure(this, FormStyle.SizeableDialog); UserInterfaceStyler.Configure(radGridViewDomainAccountReservation, GridViewStyle.ReadOnly); ShowIcon = true; radGridViewDomainAccountReservation.AutoGenerateColumns = false; _domainAccountReservations = new SortableBindingList <DomainAccountReservation>(); _pool = pool; }
/// <summary> /// Initializes a new instance of the <see cref="VirtualPrinterEditForm"/> class. /// </summary> /// <param name="pool">The account pool.</param> /// <param name="context">The context.</param> public DomainAccountEditForm(DomainAccountPool pool, AssetInventoryContext context) { InitializeComponent(); UserInterfaceStyler.Configure(this, FormStyle.FixedDialog); ShowIcon = true; _provider = new ErrorProvider(); _provider.BlinkStyle = ErrorBlinkStyle.NeverBlink; _provider.SetIconAlignment(poolNameTextBox, ErrorIconAlignment.MiddleLeft); _provider.SetIconAlignment(formatTextBox, ErrorIconAlignment.MiddleLeft); _provider.SetIconAlignment(startTextBox, ErrorIconAlignment.MiddleLeft); _provider.SetIconAlignment(endTextBox, ErrorIconAlignment.MiddleLeft); _pool = pool; _context = context; }
private DialogResult EditEntry(DomainAccountPool pool) { DialogResult result = DialogResult.None; using (DomainAccountEditForm form = new DomainAccountEditForm(pool, _context)) { result = form.ShowDialog(); if (result == DialogResult.OK) { _bindingSource.ResetBindings(false); //SetDefault(); _unsavedChanges = true; } } return(result); }
/// <summary> /// Reserves a block of users. This MUST be called before being able to get user credentials. /// </summary> /// <param name="sessionId">The session id.</param> /// <param name="accountQuantity">The account quantity which is separated by account pool.</param> /// <returns>A <see cref="DomainAccountReservationSet"/> containing information on the reserved accounts.</returns> /// <exception cref="System.ArgumentNullException">accountQuantity</exception> /// <exception cref="System.InvalidOperationException">Domain accounts have already been reserved for this Session Id</exception> public static DomainAccountReservationSet Reserve(string sessionId, DomainAccountQuantityDictionary accountQuantity) { if (accountQuantity == null) { throw new ArgumentNullException("accountQuantity"); } DomainAccountReservationSet reservedBlock = new DomainAccountReservationSet(sessionId); Action action = new Action(() => { try { using (AssetInventoryContext context = DbConnect.AssetInventoryContext()) { if (context.DomainAccountReservations.Any(e => e.SessionId.Equals(sessionId, StringComparison.OrdinalIgnoreCase))) { //This could be a subsequent call to reserve. Clear all reservations before proceeding. Release(sessionId); } foreach (var poolType in accountQuantity.Keys) { int userCount = accountQuantity[poolType]; DomainAccountPool pool = SelectPool(context, poolType); int startIndex = ReserveBlock(context, sessionId, pool, userCount); TraceFactory.Logger.Debug($"New pool reserved: StartIndex: {startIndex}, UserCount: {userCount}, PoolName: {pool.DomainAccountKey}"); reservedBlock.Add(poolType, pool, startIndex, userCount); } } } catch (InsufficientDomainAccountsException) { ReleaseSessionReservations(sessionId); throw; } }); var token = new GlobalLockToken("DomainAccountReservation", TimeSpan.FromMinutes(11), TimeSpan.FromMinutes(2)); ExecutionServices.CriticalSection.Run(token, action); return(reservedBlock); }
private void ValidateUserPool() { List <DomainAccountPool> userPools = (List <DomainAccountPool>)userPool_ComboBox.DataSource; DomainAccountPool selectedPool = null; if (userPools.Any(x => x.DomainAccountKey.Equals(_tester.UserPool, StringComparison.OrdinalIgnoreCase))) { selectedPool = userPools.First(x => x.DomainAccountKey.Equals(_tester.UserPool, StringComparison.OrdinalIgnoreCase)); userPool_ComboBox.SelectedItem = selectedPool; } else if (userPools.Count > 0) //No user pools match the tester's pool, but there are pools available. Assign the first one. { selectedPool = userPools.First(); userPool_ComboBox.SelectedItem = selectedPool; } // We're not worried about the case of no pools in the database because the User Pools radio button // is not enabled unless there is at least one pool in the system. }
private void AddPool(DomainAccountPool pool) { if (!_context.DomainAccountPools.Any(x => x.DomainAccountKey.Equals(pool.DomainAccountKey, StringComparison.OrdinalIgnoreCase))) { _context.DomainAccountPools.Add(pool); _userPools.Add(pool); int index = domainAccount_RadGridView.Rows.Count - 1; domainAccount_RadGridView.Rows[index].IsSelected = true; //In case if you want to scroll down as well. domainAccount_RadGridView.TableElement.ScrollToRow(index); } else { MessageBox.Show("A user pool with the name '{0}' already exists in the database.".FormatWith(pool.DomainAccountKey), "Unable to Add", MessageBoxButtons.OK, MessageBoxIcon.Stop); } }
/// <summary> /// Reserves a block of User Ids for the given session. /// </summary> /// <param name="context">The data context.</param> /// <param name="sessionId">The session id.</param> /// <param name="accountPool">The account pool.</param> /// <param name="requestedSize">The size of reservation block being requested.</param> /// <returns>The start index for the reserved block</returns> private static int ReserveBlock(AssetInventoryContext context, string sessionId, DomainAccountPool accountPool, int requestedSize) { if (accountPool == null) { throw new ArgumentNullException("accountPool"); } // Calculate the start index of the new block int startIndex = accountPool.MinimumUserNumber; foreach (DomainAccountReservation reservation in SelectReservationsByKey(context, accountPool.DomainAccountKey)) { // Check to see if there are any users between reservations that we can utilize. // For example, say there were 2 reservations against this DomainAccountKey, but the first one got released // Now there is a gap between the minimum user number and the start index of the reservation we are looking at. // We want to utilize that block, if possible. if ((reservation.StartIndex - startIndex) >= requestedSize) { break; } // Not enough space for the requested size, so check the next one. startIndex = reservation.StartIndex + reservation.Count; } // Now that we have the start index for our new block, we need to see if there is enough room // for the block before we hit the "ceiling" of our domain users. int available = accountPool.MaximumUserNumber - startIndex + 1; if (available < requestedSize) { throw new InsufficientDomainAccountsException($"There were not enough domain accounts available to run this scenario. PoolName: {accountPool.DomainAccountKey} Available: {available} Number Requested: {requestedSize}"); } DomainAccountReservation newReservation = new DomainAccountReservation { SessionId = sessionId, DomainAccountKey = accountPool.DomainAccountKey, StartIndex = startIndex, Count = requestedSize }; context.DomainAccountReservations.Add(newReservation); context.SaveChanges(); return(startIndex); }
/// <summary> /// Creates a reservation entry for the specified account pool. /// </summary> /// <param name="userPool">The account pool type.</param> /// <param name="accountPool">The account pool.</param> /// <param name="startIndex">The start index.</param> /// <param name="userCount">The number of user accounts to reserve.</param> public void Add(string userPool, DomainAccountPool accountPool, int startIndex, int userCount) { _accounts.Add(userPool, new DomainAccount(startIndex, userCount, accountPool)); }
public DomainAccount(int startIndex, int userCount, DomainAccountPool accountPool) { TotalAccounts = _userCount = userCount; StartIndex = _currentIndex = startIndex; _accountPool = accountPool; }