/// <summary>
/// Initializes a new instance of the <see cref="WizardConfiguration"/> class.
/// </summary>
public WizardConfiguration()
{
Ticket = new SessionTicket()
{
SessionOwner = UserManager.CurrentUser
};
SessionAssets = new AssetDetailCollection();
}
/// <summary>
/// Reserves all assets associated with this session using the specified key.
/// </summary>
/// <param name="sessionId">The session unique identifier.</param>
/// <param name="reservationKey">The reservation key.</param>
/// <returns></returns>
/// <exception cref="System.ServiceModel.EndpointNotFoundException"></exception>
public AssetDetailCollection Reserve(string sessionId, string reservationKey)
{
SetTraceSessionContext(sessionId);
AssetDetailCollection assetDetails = new AssetDetailCollection();
foreach (var item in assetDetails)
{
TraceFactory.Logger.Debug("Item availability:" + item.Availability);
}
if (!_proxyControllers.Contains(sessionId))
{
var msg = "Proxy not found for Session Id {0}".FormatWith(sessionId);
TraceFactory.Logger.Debug(msg);
throw new EndpointNotFoundException(msg);
}
var controller = _proxyControllers[sessionId];
if (controller.ProxyProcessStarted)
{
TraceFactory.Logger.Debug("CallProxy -> Reserve({0})".FormatWith(sessionId));
Action retryAction = () => assetDetails = controller.Channel.Reserve(reservationKey);
TraceFactory.Logger.Debug("Returned Reservation");
try
{
Retry.WhileThrowing
(
retryAction,
10,
TimeSpan.FromSeconds(1),
new List <Type>()
{
typeof(EndpointNotFoundException)
}
);
}
catch (Exception ex)
{
var msg = "Error communicating with session proxy for {0} - 1".FormatWith(sessionId);
TraceFactory.Logger.Error(msg, ex);
var exception = new ApplicationException(msg, ex);
EventPublisher.PublishDispatcherException(exception);
}
}
else
{
var msg = "Proxy service not started for session {0} (1)".FormatWith(sessionId);
var exception = new ApplicationException(msg);
EventPublisher.PublishDispatcherException(exception);
}
TraceFactory.Logger.Debug("Returning asset details");
return(assetDetails);
}
/// <summary>
/// Initializes the wizard page with the specified <see cref="WizardConfiguration"/>.
/// </summary>
/// <param name="configuration">The configuration.</param>
public bool Initialize(WizardConfiguration configuration)
{
_assets = configuration.SessionAssets;
AvailableDeviceSet <AssetDetail> assetSet = new AvailableDeviceSet <AssetDetail>(_assets);
var printDevices = assetSet.Devices.OfType <PrintDeviceDetail>().ToList();
deviceSetup_GridView.DataSource = printDevices;
//deviceSetup_GridView.BestFitColumns();
return(printDevices.Any());
}
private bool AllAssetsAvailable(AssetDetailCollection assetDetails)
{
bool result = true;
string display = string.Empty;
foreach (AssetDetail asset in assetDetails)
{
display = "{0} - {1}".FormatWith(asset.AssetId, asset.Availability);
UpdateStatus(display);
TraceFactory.Logger.Debug(display);
result = result && (asset.Availability == AssetAvailability.Available);
}
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 RefreshReservations(string reservationKey)
{
// Call the dispatcher service to make reservations
AssetDetailCollection assets = null;
if (!string.IsNullOrWhiteSpace(reservationKey))
{
assets = SessionClient.Instance.Reserve(_configuration.Ticket.SessionId, reservationKey);
}
else
{
assets = SessionClient.Instance.Reserve(_configuration.Ticket.SessionId);
}
_configuration.SessionAssets.Replace(assets);
// Display the results
assetReservation_GridView.DataSource = null;
assetReservation_GridView.DataSource = assets.Select(n => new AssetReservationRow(n));
assetReservation_GridView.BestFitColumns();
}
/// <summary>
/// adc is the active list. Returns true if the AssetDetail is already in the list. Will
/// check to see if the asset detail is active or not. If not active in list and the given is active,
/// will reset the list.
/// </summary>
/// <param name="adc">AssetDetailCollection</param>
/// <param name="ad">AssetDetail</param>
/// <returns>bool</returns>
private bool FoundAssetDetail(AssetDetailCollection adc, AssetDetail ad)
{
bool bFound = false;
foreach (AssetDetail item in adc)
{
if (item.AssetId.Equals(ad.AssetId))
{
bFound = true;
if (!AssetAvailable(item) && AssetAvailable(ad))
{
// ID's and descriptions are the same so just reset the availability information for the device in the primary list.
item.Availability = ad.Availability;
item.AvailabilityStartTime = ad.AvailabilityStartTime;
item.AvailabilityEndTime = ad.AvailabilityEndTime;
break;
}
}
}
return(bFound);
}
/// <summary>
/// Reserves all assets associated with this session using the specified key.
/// If the reservationKey is a comma separated list, will process multiple values but only
/// returns one Asset ID in the collection with priority being Available.
/// </summary>
/// <param name="sessionId">The session unique identifier.</param>
/// <param name="reservationKey">The reservation key.</param>
/// <returns>AssetDetailCollection</returns>
public AssetDetailCollection Reserve(string sessionId, string reservationKey)
{
TraceFactory.Logger.Debug("SessionId: {0}, Key: {1}".FormatWith(sessionId, reservationKey));
AssetDetailCollection scenarioAssets = new AssetDetailCollection();
List <string> rkList = new List <string> {
reservationKey
};
if (reservationKey.IndexOf(',') > 0)
{
rkList = reservationKey.Split(',').Select(r => r.Trim()).ToList();
}
foreach (string rk in rkList)
{
AssetDetailCollection adcTemp = GetConnection().Channel.Reserve(sessionId, rk);
if (scenarioAssets.Count.Equals(0))
{
scenarioAssets = adcTemp;
}
else
{
foreach (AssetDetail ad in adcTemp)
{
if (!FoundAssetDetail(scenarioAssets, ad))
{
scenarioAssets.Add(ad);
}
}
}
}
TraceFactory.Logger.Debug("Returning...");
return(scenarioAssets);
}
/// <summary>
/// Starts the session.
/// If the startup args were not successfully validated, an exception is thrown.
/// </summary>
/// <exception cref="System.InvalidOperationException">Invalid State. Unable to start session.</exception>
public void StartSession()
{
if (_state != SessionState.Available)
{
throw new InvalidOperationException("Unable to start session. State: {0}.".FormatWith(_state));
}
if (HandleSessionClientEvents)
{
SessionClient.Instance.DispatcherExceptionReceived += SessionClient_DispatcherErrorReceived;
SessionClient.Instance.SessionStateReceived += SessionClient_StateChanged;
SessionClient.Instance.SessionStartupTransitionReceived += SessionClient_StartupTransitionReceived;
SessionClient.Instance.SessionMapElementReceived += SessionClient_MapElementReceived;
}
else
{
FreeConsole();
}
string reservationKey = _arguments["reservation"]?.ToString();
UpdateStatus(string.Empty);
UpdateStatus($"Starting session '{_ticket.SessionName}'");
UpdateStatus(string.Empty);
UpdateStatus("Created ticket {0}".FormatWith(_ticket.SessionId));
TraceFactory.Logger.Debug("Initializing");
SessionClient.Instance.Initialize(_arguments["dispatcher"]);
SessionClient.Instance.InitiateSession(_ticket);
UpdateStatus("Reserving Assets...");
AssetDetailCollection assetDetails = null;
if (string.IsNullOrEmpty(reservationKey))
{
assetDetails = SessionClient.Instance.Reserve(_ticket.SessionId);
}
else
{
UpdateStatus("Reservation Key: {0}".FormatWith(reservationKey));
assetDetails = SessionClient.Instance.Reserve(_ticket.SessionId, reservationKey);
}
//Check asset availability
if (!AllAssetsAvailable(assetDetails))
{
string message = "Not all assets are available. Unable to continue.";
UpdateStatus(message);
TraceFactory.Logger.Error(message);
ShutDown();
return;
}
// 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);
UpdateStatus("Staged...{0}".FormatWith(_ticket.SessionId));
if (HandleSessionClientEvents)
{
//Keep the console open
Console.ReadLine();
}
}
/// <summary>
/// Starts the enterprise scenario based on the provided configuration.
/// </summary>
/// <param name="sessionId">The session unique identifier.</param>
/// <param name="assets">The assets.</param>
public void Stage(string sessionId, AssetDetailCollection assets)
{
SetTraceSessionContext(sessionId);
TraceFactory.Logger.Debug("CallProxy -> Stage({0})".FormatWith(sessionId));
CallSessionProxy(sessionId, (c) => c.Stage(assets));
}
/// <summary>
/// Starts the enterprise scenario based on the provided configuration.
/// </summary>
/// <param name="sessionId">The session id.</param>
/// <param name="assets">The assets.</param>
public void Stage(string sessionId, AssetDetailCollection assets)
{
TraceFactory.Logger.Debug("SessionId: {0}".FormatWith(sessionId));
CallDispatcher((c) => c.Stage(sessionId, assets));
}
