private void ExecuteSTB(string scenarioName) { string[] args = new string[8]; args[0] = "-dispatcher"; args[1] = Environment.MachineName; args[2] = "-database"; args[3] = _currentDatabase; args[4] = "-scenario"; args[5] = scenarioName; args[6] = "-owner"; args[7] = UserManager.CurrentUser; WriteLine("Starting session..."); using (CommandLineExec commandLine = new CommandLineExec(args)) { try { _ticket = commandLine.Ticket; commandLine.HandleSessionClientEvents = false; commandLine.StatusChanged += CommandLine_StatusChanged; FrameworkServicesInitializer.InitializeExecution(); commandLine.StartSession(); } catch (Exception ex) { UpdateStatus($"Error: {ex.Message}"); WriteLine(ex.ToString()); } } }
/// <summary> /// start the execution of the scenario /// </summary> /// <param name="scenarioId">the scenario ID</param> public void StartSession(Guid scenarioId) { using (SessionConfigurationWizard wizard = new SessionConfigurationWizard(scenarioId)) { if (wizard.ShowDialog(this) == DialogResult.OK) { SessionTicket ticket = wizard.Ticket; SessionId = ticket.SessionId; // Set the display details from the ticket sessionId_Label.Text = ticket.SessionId; sessionName_Label.Text = ticket.SessionName; sessionOwner_Label.Text = ticket.SessionOwner.UserName; // Start the session start_ToolStripButton.Enabled = false; SessionClient.Instance.PowerUp(SessionId); } else { if (_transition != SessionStartupTransition.ReadyToStart && _transition != SessionStartupTransition.None) { ShutdownOptions options = new ShutdownOptions(); options.ShutdownDeviceSimulators = false; SessionClient.Instance.Shutdown(wizard.Ticket.SessionId, options); } } } }
public void UpdateFromTicket(SessionTicket ticket) { Name = ticket.SessionName; if (ticket.SessionOwner != null) { Owner = ticket.SessionOwner.UserName; } }
/// <summary> /// Initializes the wizard page with the specified <see cref="WizardConfiguration"/>. /// </summary> /// <param name="configuration">The configuration.</param> public virtual bool Initialize(WizardConfiguration configuration) { Ticket = configuration.Ticket; Guid scenarioId = Ticket.ScenarioIds.FirstOrDefault(); if (STFDispatcherManager.Dispatcher == null && STFDispatcherManager.ConnectToDispatcher() == false) { //The user canceled the connect dialog return(false); } using (EnterpriseTestContext context = new EnterpriseTestContext()) { // Load the specified scenario (if there is one) if (scenarioId != Guid.Empty) { LoadScenario(scenarioId, context); LoadComboBoxes(context); } } // If this is not the first time we have entered this step, the user // must have come back from some point later in the wizard. // Make sure the dispatcher doesn't hang onto configuration from the previous try. if (!_initial) { SessionClient.Instance.Close(Ticket.SessionId); } if (_scenario != null && Ticket.SessionId != null && Ticket.AssociatedProductList.Count != 0) { foreach (var item in Ticket.AssociatedProductList) { _scenarioProducts.Where(n => n.ProductId == item.AssociatedProductId && n.Vendor == item.Vendor && n.Version == item.Version).FirstOrDefault().Active = item.Active; } scenarioProductBindingSource.Clear(); scenarioProductBindingSource.DataSource = _scenarioProducts; scenarioProductBindingSource.ResetBindings(true); } deviceOffline_CheckBox.Checked = Ticket.RemoveUnresponsiveDevices; environment_Label.Text = "{0} {1} Environment".FormatWith(GlobalSettings.Items[Setting.Organization], GlobalSettings.Items[Setting.Environment]); if (string.IsNullOrEmpty(logLocation_TextBox.Text)) { logLocation_TextBox.Text = GlobalSettings.WcfHosts[WcfService.DataLog]; } _initial = false; dispatcher_Label.Text = STFDispatcherManager.Dispatcher.HostName; if (!GlobalSettings.IsDistributedSystem) { this.settings_TabControl.TabPages.Remove(this.virtualMachineSelection_TabPage); } return(true); }
/// <summary> /// Initializes a new instance of the <see cref="WizardConfiguration"/> class. /// </summary> public WizardConfiguration() { Ticket = new SessionTicket() { SessionOwner = UserManager.CurrentUser }; SessionAssets = new AssetDetailCollection(); }
/// <summary> /// Initializes the wizard page with the specified <see cref="WizardConfiguration"/>. /// </summary> /// <param name="configuration">The <see cref="WizardConfiguration"/>.</param> public bool Initialize(WizardConfiguration configuration) { Ticket = configuration.Ticket; _scenarios = new BindingList <ScenarioSelectionItem>(); scenarios_DataGridView.DataSource = null; if (STFDispatcherManager.Dispatcher == null && STFDispatcherManager.ConnectToDispatcher() == false) { //The user canceled the connect dialog return(false); } using (new BusyCursor()) { using (EnterpriseTestContext context = new EnterpriseTestContext()) { foreach (EnterpriseScenario scenario in EnterpriseScenario.Select(context, Ticket.ScenarioIds)) { _scenarios.Add(new ScenarioSelectionItem(scenario)); } LoadComboBoxes(context); } _bindingSource = new BindingSource(_scenarios, string.Empty); scenarios_DataGridView.DataSource = _bindingSource; } //Set data from Ticket if (Ticket.SessionId != null) { SetEstimatedRunTime(); sessionName_ComboBox.Text = string.IsNullOrEmpty(Ticket.SessionName) ? "Multiple Scenarios" : Ticket.SessionName; } if (!_initial) { SessionClient.Instance.Close(Ticket.SessionId); sessionType_ComboBox.SelectedText = Ticket.SessionType; if (!string.IsNullOrEmpty(Ticket.EmailAddresses)) { runtime_NumericUpDown.Value = Math.Min(Ticket.DurationHours, runtime_NumericUpDown.Maximum); } } environment_Label.Text = "{0} {1} Environment".FormatWith(GlobalSettings.Items[Setting.Organization], GlobalSettings.Items[Setting.Environment]); dispatcher_Label.Text = STFDispatcherManager.Dispatcher.HostName; _initial = false; return(true); }
/// <summary> /// Starts the session. /// </summary> /// <param name="wizard">The wizard form.</param> /// <param name="ticket">The ticket.</param> /// <returns><c>true</c> if start operation successful, <c>false</c> otherwise.</returns> public bool StartSession(Form wizard, SessionTicket ticket) { bool result = false; var activeSessions = GetActiveSessions().Count(); if (AbleToStartNewSession == false || activeSessions >= MAX_ACTIVE_SESSIONS) { MessageBox.Show(_treeView, "{0} active sessions out of {1} allowed".FormatWith(activeSessions, MAX_ACTIVE_SESSIONS), "Unable To Start Session"); return(result); } if (EnsureDispatcherConnected()) { try { AbleToStartNewSession = false; using (wizard) { var newSession = GetNewExecutingSessionInfo(ticket); if (wizard.ShowDialog(_sessionControl) == DialogResult.OK) { //SessionClient.Instance.PowerUp(newSession.SessionId); newSession.UpdateFromTicket(ticket); result = true; UpdateSessionInfoFromDatabaseAsynch(newSession, false); } else { var transition = newSession.StartupTransition; if (transition != SessionStartupTransition.ReadyToStart && transition != SessionStartupTransition.None) { ShutdownOptions options = new ShutdownOptions(); options.ShutdownDeviceSimulators = false; SessionClient.Instance.Shutdown(newSession.SessionId, options); newSession.State = SessionState.ShutdownComplete; } else { newSession.State = SessionState.Canceled; RemoveManagedSession(newSession); } } } } finally { AbleToStartNewSession = true; } } return(result); }
/// <summary> /// Initializes a new instance of the <see cref="WizardConfiguration"/> class. /// </summary> public WizardConfiguration() { // Add the user credentials to the ticket which will be used to interact with VCenter // for VM operations. The assumption is that the user has a VCenter login with the same // username as their HP LR0 domain username. var credential = new UserCredential(UserManager.LoggedInUser.UserName, UserManager.LoggedInUser.Domain) { Role = UserManager.LoggedInUser.Role, Password = UserManager.LoggedInUser.Password }; Ticket = new SessionTicket() { SessionOwner = credential }; SessionAssets = new AssetDetailCollection(); }
private void ExecuteSTF(string scenario, string holdId) { WriteLine("Starting session..."); _ticket = SessionTicket.Create(scenario); _ticket.SessionOwner = new UserCredential(UserManager.CurrentUser, UserManager.CurrentUserCredential.Password, UserManager.CurrentUserCredential.Domain) { Role = UserManager.CurrentUserRole }; if (!string.IsNullOrEmpty(holdId)) { _ticket.RequestedVMs.Add("BY_HOLDID", (from vm in SelectMachinesByHoldId(holdId) select vm.Name).ToList()); } _ticket.ExpirationDate = _sessionRetention.GetExpirationDate(DateTime.Now); WriteLine("Created ticket {0}".FormatWith(_ticket.SessionId)); _scenarioList.ElementAt(_currentScenarioIndex).SessionId = _ticket.SessionId; _startTime = DateTime.Now; LogSessionExecution(); WriteLine("Initializing"); SessionClient.Instance.Initialize(_currentDispatcher); SessionClient.Instance.InitiateSession(_ticket); UpdateStatus("Initialized"); var assetDetails = SessionClient.Instance.Reserve(_ticket.SessionId); WriteLine("Reserved...{0}".FormatWith(_ticket.SessionId)); UpdateStatus("Reserved"); foreach (var asset in assetDetails.Where(x => x.Availability == AssetAvailability.NotAvailable)) { WriteLine("Unavailable: {0}".FormatWith(asset.AssetId)); } // This call to Stage() will kick off the process and as each event arrives to indicate // a step in the process has completed, the next step will automatically continue. SessionClient.Instance.Stage(_ticket.SessionId, assetDetails); WriteLine("Staged...{0}".FormatWith(_ticket.SessionId)); UpdateStatus("Staged"); }
private ExecutingSessionInfo GetNewExecutingSessionInfo(SessionTicket ticket) { if (IsManagedSession(ticket.SessionId)) { throw new Exception("Session {0} already exists".FormatWith(ticket.SessionId)); } var result = new ExecutingSessionInfo() { SessionId = ticket.SessionId, Name = ticket.SessionName, Owner = ticket.SessionOwner.UserName, MapElement = null, State = SessionState.Available, StartupTransition = SessionStartupTransition.None, Dispatcher = Dispatcher, }; AddManagedSession(result); SetCurrentSession(result.SessionId); return(result); }
public void StartSession(StfSessionTicket sessionTicket) { _isSessionExecuting = true; try { var ticket = SessionTicket.Create(new[] { Guid.Parse(sessionTicket.ScenarioId) }, sessionTicket.SessionName, sessionTicket.Duration); ticket.ExpirationDate = DateTime.Now + TimeSpan.FromDays(180.0); if (GlobalSettings.IsDistributedSystem) { ticket.SessionOwner = new UserCredential(GlobalSettings.Items.DomainAdminCredential.UserName, GlobalSettings.Items.DomainAdminCredential.Password, GlobalSettings.Items.DomainAdminCredential.Domain); } SessionClient.Instance.InitiateSession(ticket); var assetDetails = SessionClient.Instance.Reserve(ticket.SessionId); if (assetDetails.Any(x => x.Availability != AssetAvailability.Available)) { SessionClient.Instance.Close(ticket.SessionId); TraceFactory.Logger.Error($"One or more assets are unavailable for session {ticket.SessionId}"); _isSessionExecuting = false; return; } foreach (var printDeviceDetail in assetDetails.OfType <PrintDeviceDetail>()) { printDeviceDetail.UseCrc = false; } SessionClient.Instance.Stage(ticket.SessionId, assetDetails); lock (ticket.SessionId) { SessionExecutionDictionary.TryAdd(ticket.SessionId, sessionTicket); } } catch (Exception e) { TraceFactory.Logger.Error(e.JoinAllErrorMessages()); _isSessionExecuting = false; } }
public ExecutingSessionInfo(SessionTicket ticket) : this() { SessionId = ticket.SessionId; UpdateFromTicket(ticket); }
/// <summary> /// Initializes a new instance of the <see cref="CommandLineExec"/> class. /// Validates the App Config key-value entries. /// </summary> /// <param name="appConfig">The App Config arguments.</param> public CommandLineExec(NameValueCollection appConfig) { AllocConsole(); TraceFactory.SetThreadContextProperty("PID", Process.GetCurrentProcess().Id.ToString(), false); _arguments = appConfig; _state = SessionState.Available; string dispatcher = string.Empty; string database = string.Empty; string sessionName = string.Empty; int durationHours = 2; IEnumerable <string> scenarios = null; if (_arguments != null) { scenarios = _arguments["scenarios"].ToString().Split(';'); dispatcher = string.IsNullOrEmpty(_arguments["dispatcher"]) ? Environment.MachineName : _arguments["dispatcher"].ToString(); database = _arguments["database"].ToString(); sessionName = _arguments["sessionName"].ToString(); durationHours = string.IsNullOrEmpty(_arguments["durationHours"]) ? 2 : Convert.ToInt32(_arguments["durationHours"]); } if (string.IsNullOrEmpty(dispatcher)) { _state = SessionState.Error; throw new ArgumentException("Dispatcher is required.", "dispatcher"); } TraceFactory.SetThreadContextProperty("Dispatcher", dispatcher, false); if (string.IsNullOrEmpty(sessionName)) { _state = SessionState.Error; throw new ArgumentException("Session Name is required.", "sessionName"); } if (string.IsNullOrEmpty(database)) { _state = SessionState.Error; throw new ArgumentException("Database Host is required.", "database"); } if (string.IsNullOrEmpty(_arguments["owner"].ToString())) { _state = SessionState.Error; throw new ArgumentException("Session Owner User name is required.", "owner"); } if (GlobalSettings.IsDistributedSystem) { //We only care about password and domain if it's STF if (string.IsNullOrEmpty(_arguments["password"])) { _state = SessionState.Error; throw new ArgumentException("Session owner Password is required.", "password"); } if (string.IsNullOrEmpty(_arguments["domain"])) { _state = SessionState.Error; throw new ArgumentException("User Domain is required.", "domain"); } } // No need to check optional args. They will be handled later. //Initialize the environment and create a ticket. GlobalSettings.SetDispatcher(dispatcher); GlobalSettings.Load(database); _ticket = SessionTicket.Create(scenarios, sessionName, durationHours); _ticket.SessionOwner = GetSessionOwner(_arguments["owner"], _arguments["password"], _arguments["domain"] ?? Environment.UserDomainName); _ticket.ExpirationDate = SessionLogRetention.Month.GetExpirationDate(DateTime.Now); }
public static bool Start(string dispatcher, string database, string scenario, out string clientVM, out string sessionId, out string result) { _clientVM = string.Empty; _errorDetails = string.Empty; _isSessionCompleted = false; _sessionError = false; Console.WriteLine("Starting session..."); GlobalSettings.SetDispatcher(dispatcher); GlobalSettings.Load(database); _ticket = SessionTicket.Create(scenario); _ticket.SessionOwner = new UserCredential("youngmak", "AMERICAS.CPQCORP.NET"); Console.WriteLine("Created ticket {0}".FormatWith(_ticket.SessionId)); SessionClient.Instance.DispatcherExceptionReceived += DispatcherErrorReceived; SessionClient.Instance.SessionStateReceived += SessionStateChanged; SessionClient.Instance.SessionStartupTransitionReceived += SessionStartupTransitionReceived; SessionClient.Instance.SessionMapElementReceived += Instance_SessionMapElementReceived; TraceFactory.Logger.Debug("Initializing"); SessionClient.Instance.Initialize(dispatcher); SessionClient.Instance.InitiateSession(_ticket); var assetDetails = SessionClient.Instance.Reserve(_ticket.SessionId); Console.WriteLine("Reserved...{0}".FormatWith(_ticket.SessionId)); foreach (var asset in assetDetails.Where(x => x.Availability == AssetAvailability.NotAvailable)) { Console.WriteLine("Unavailable: {0}".FormatWith(asset.AssetId)); } // This call to Stage() will kick off the process and as each event arrives to indicate // a step in the process has completed, the next step will automatically continue. SessionClient.Instance.Stage(_ticket.SessionId, assetDetails); Console.WriteLine("Staged...{0}".FormatWith(_ticket.SessionId)); _isSessionCompleted = false; while (!_isSessionCompleted) { // block till the session completed or throws error } sessionId = _ticket.SessionId; clientVM = _clientVM; if (_sessionError) { result = _errorDetails; return(false); } else { result = "Executed Successful"; return(true); } }