/// <summary>
/// Initializes a new instance of the BrokerNodeItem class.
/// </summary>
/// <param name="name">the node name.</param>
/// <param name="domainName">the node domain name.</param>
/// <param name="state">the node state.</param>
/// <param name="reachable">a value indicating whether the node is reachable.</param>
public BrokerNodeItem(string name, string domainName, bool reachable)
{
ParamCheckUtility.ThrowIfNullOrEmpty(name, "name");
// Make sure the name is saved in upper case so it can be easily looked up later
this.nameField = name.ToUpper();
if (!string.IsNullOrEmpty(domainName))
{
this.domainNameField = domainName.ToUpper();
}
this.isReachableField = reachable;
}
/// <summary>
/// Allocate a new durable or non-durable session
/// </summary>
/// <param name="startInfo">session start info</param>
/// <param name="durable">whether session should be durable</param>
/// <param name="endpointPrefix">the endpoint prefix, net.tcp:// or https:// </param>
/// <returns>the Broker Launcher EPRs, sorted by the preference.</returns>
protected virtual async Task <SessionAllocateInfoContract> AllocateInternalAsync(SessionStartInfoContract startInfo, string endpointPrefix, bool durable)
{
TraceHelper.TraceEvent(TraceEventType.Verbose, "[SessionLauncher] Begin: AllocateInternalAsync");
SessionAllocateInfoContract sessionAllocateInfo = new SessionAllocateInfoContract();
ParamCheckUtility.ThrowIfNull(startInfo, "startInfo");
ParamCheckUtility.ThrowIfNullOrEmpty(startInfo.ServiceName, "startInfo.ServiceName");
ParamCheckUtility.ThrowIfNullOrEmpty(endpointPrefix, "endpointPrefix");
#if HPCPACK
// check client api version, 4.3 or older client is not supported by 4.4 server for the broken changes
if (startInfo.ClientVersion == null || startInfo.ClientVersion < new Version(4, 4))
{
TraceHelper.TraceEvent(TraceEventType.Error,
"[SessionLauncher] .AllocateInternalAsync: ClientVersion {0} does not match ServerVersion {1}.", startInfo.ClientVersion, ServerVersion);
ThrowHelper.ThrowSessionFault(SOAFaultCode.ClientServerVersionMismatch,
SR.SessionLauncher_ClientServerVersionMismatch,
startInfo.ClientVersion == null ? "NULL" : startInfo.ClientVersion.ToString(),
ServerVersion.ToString());
}
#endif
// Init service version to the service version passed in
if (startInfo.ServiceVersion != null)
{
sessionAllocateInfo.ServiceVersion = startInfo.ServiceVersion;
TraceHelper.TraceEvent(TraceEventType.Verbose, "[SessionLauncher] .AllocateInternalAsync: Original service version is {0}", sessionAllocateInfo.ServiceVersion);
}
else
{
sessionAllocateInfo.ServiceVersion = null;
TraceHelper.TraceEvent(TraceEventType.Verbose, "[SessionLauncher] .AllocateInternalAsync: Original service version is null.");
}
string callId = Guid.NewGuid().ToString();
this.CheckAccess();
SecureString securePassword = CreateSecureString(startInfo.Password);
startInfo.Password = null;
// BUG 4522 : Use CCP_SCHEDULER when referencing service registration file share so HA HN virtual name is used when needed
//var reliableRegistry = new ReliableRegistry(this.fabricClient.PropertyManager);
//string defaultServiceRegistrationServerName = await reliableRegistry.GetValueAsync<string>(HpcConstants.HpcFullKeyName, HpcConstants.FileShareServerRegVal, this.token);
//if (String.IsNullOrEmpty(defaultServiceRegistrationServerName))
//{
// defaultServiceRegistrationServerName = "localhost";
//}
// the reg repo path is from scheduler environments, defaultServiceRegistrationServerName is actually not used
string serviceConfigFile;
ServiceRegistrationRepo serviceRegistration = this.GetRegistrationRepo(callId);
serviceConfigFile = serviceRegistration.GetServiceRegistrationPath(startInfo.ServiceName, startInfo.ServiceVersion);
// If the serviceConfigFile wasnt found and serviceversion isnt specified, try getitng the service config based on the service's latest version
if (string.IsNullOrEmpty(serviceConfigFile) && (startInfo.ServiceVersion == null))
{
TraceHelper.TraceEvent(TraceEventType.Verbose, "[SessionLauncher] .AllocateInternalAsync: Try to find out versioned service.");
// Get service version in ServiceRegistrationRepo
Version dynamicServiceVersion = serviceRegistration.GetServiceVersionInternal(startInfo.ServiceName, false);
if (dynamicServiceVersion != null)
{
TraceHelper.TraceEvent(TraceEventType.Verbose, "[SessionLauncher] .AllocateInternalAsync: Selected dynamicServiceVersion is {0}.", dynamicServiceVersion.ToString());
}
serviceConfigFile = serviceRegistration.GetServiceRegistrationPath(startInfo.ServiceName, dynamicServiceVersion);
// If a config file is found, update the serviceVersion that is returned to client and stored in recovery info
if (!string.IsNullOrEmpty(serviceConfigFile))
{
TraceHelper.TraceEvent(TraceEventType.Verbose, "[SessionLauncher] .AllocateInternalAsync: serviceConfigFile is {0}.", serviceConfigFile);
startInfo.ServiceVersion = dynamicServiceVersion;
if (dynamicServiceVersion != null)
{
sessionAllocateInfo.ServiceVersion = dynamicServiceVersion;
}
}
}
string serviceName = ServiceRegistrationRepo.GetServiceRegistrationFileName(startInfo.ServiceName, startInfo.ServiceVersion);
TraceHelper.TraceEvent(TraceEventType.Verbose, "[SessionLauncher] .AllocateInternalAsync: Service name = {0}, Configuration file = {1}", serviceName, serviceConfigFile);
// If the service is not found and user code doesn't specify
// version, we will use the latest version.
if (string.IsNullOrEmpty(serviceConfigFile))
{
if (startInfo.ServiceVersion != null)
{
ThrowHelper.ThrowSessionFault(SOAFaultCode.ServiceVersion_NotFound, SR.SessionLauncher_ServiceVersionNotFound, startInfo.ServiceName, startInfo.ServiceVersion.ToString());
}
else
{
ThrowHelper.ThrowSessionFault(SOAFaultCode.Service_NotFound, SR.SessionLauncher_ServiceNotFound, startInfo.ServiceName);
}
}
ExeConfigurationFileMap map = new ExeConfigurationFileMap();
map.ExeConfigFilename = serviceConfigFile;
ServiceRegistration registration = null;
BrokerConfigurations brokerConfigurations = null;
string hostpath = null;
string traceSwitchValue = null;
try
{
Configuration config = null;
RetryManager.RetryOnceAsync(
() => config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None),
TimeSpan.FromSeconds(1),
ex => ex is ConfigurationErrorsException).GetAwaiter().GetResult();
Debug.Assert(config != null, "Configuration is not opened properly.");
registration = ServiceRegistration.GetSectionGroup(config);
brokerConfigurations = BrokerConfigurations.GetSectionGroup(config);
if (registration != null && registration.Host != null && registration.Host.Path != null)
{
hostpath = registration.Host.Path;
}
else
{
// x86 or x64
hostpath = registration.Service.Architecture == ServiceArch.X86 ? TaskCommandLine32 : TaskCommandLine64;
}
traceSwitchValue = registration.Service.SoaDiagTraceLevel;
// TODO: should deprecate the previous settings
if (string.IsNullOrEmpty(traceSwitchValue))
{
traceSwitchValue = ConfigurationHelper.GetTraceSwitchValue(config);
}
}
catch (ConfigurationErrorsException e)
{
ThrowHelper.ThrowSessionFault(SOAFaultCode.ConfigFile_Invalid, SR.SessionLauncher_ConfigFileInvalid, e.ToString());
}
catch (Exception ex)
{
TraceHelper.TraceEvent(TraceEventType.Error, ex.ToString());
throw;
}
// after figuring out the service and version, and the session pool size, we check if the service pool already has the instance.
sessionAllocateInfo.Id = "0";
sessionAllocateInfo.SessionInfo = null;
if (startInfo.UseSessionPool)
{
if (this.TryGetSessionAllocateInfoFromPooled(endpointPrefix, durable, sessionAllocateInfo, serviceConfigFile, registration, out var allocateInternal))
{
return(allocateInternal);
}
}
// for sessions to add in session pool
try
{
var sessionAllocateInfoContract = await this.CreateAndSubmitSessionJob(
startInfo,
endpointPrefix,
durable,
callId,
securePassword,
registration,
sessionAllocateInfo,
traceSwitchValue,
serviceName,
brokerConfigurations,
hostpath);
if (sessionAllocateInfoContract != null)
{
return(sessionAllocateInfoContract);
}
}
finally
{
// Add the submitted job to the session pool.
if (startInfo.UseSessionPool)
{
this.AddSessionToPool(Path.GetFileNameWithoutExtension(serviceConfigFile), durable, sessionAllocateInfo.Id, registration.Service.MaxSessionPoolSize);
}
}
return(null);
}
public override async Task <SessionInfoContract> GetInfoAsync(string endpointPrefix, string sessionId)
{
SessionInfoContract sessionInfo = null;
this.CheckAccess();
ParamCheckUtility.ThrowIfNullOrEmpty(endpointPrefix, "endpointPrefix");
TraceHelper.TraceEvent(
sessionId,
TraceEventType.Information,
"[SessionLauncher] .GetInfo: headnode={0}, endpointPrefix={1}, sessionId={2}",
Environment.MachineName,
endpointPrefix,
sessionId);
if (!IsEndpointPrefixSupported(endpointPrefix))
{
TraceHelper.TraceEvent(sessionId, TraceEventType.Error, "[SessionLauncher] .GetInfo: {0} is not a supported endpoint prefix.", endpointPrefix);
ThrowHelper.ThrowSessionFault(SOAFaultCode.InvalidArgument, SR.SessionLauncher_EndpointNotSupported, endpointPrefix);
}
try
{
using (var batchClient = AzureBatchConfiguration.GetBatchClient())
{
var jobId = AzureBatchSessionJobIdConverter.ConvertToAzureBatchJobId(sessionId);
var sessionJob = await batchClient.JobOperations.GetJobAsync(jobId).ConfigureAwait(false);
if (sessionJob == null)
{
throw new InvalidOperationException($"[{nameof(AzureBatchSessionLauncher)}] .{nameof(this.GetInfoAsync)} Failed to get batch job for session {sessionId}");
}
TraceHelper.TraceEvent(
sessionId,
TraceEventType.Information,
$"[{nameof(AzureBatchSessionLauncher)}] .{nameof(this.GetInfoAsync)}: try to get the job properties(Secure, TransportScheme, BrokerEpr, BrokerNode, ControllerEpr, ResponseEpr) for the job, jobid={sessionId}.");
sessionInfo = new SessionInfoContract();
sessionInfo.Id = AzureBatchSessionJobIdConverter.ConvertToSessionId(sessionJob.Id);
// TODO: sessionInfo.JobState
var metadata = sessionJob.Metadata;
if (metadata != null)
{
string brokerNodeString = null;
foreach (var pair in metadata)
{
if (pair.Name.Equals(BrokerSettingsConstants.Secure, StringComparison.OrdinalIgnoreCase))
{
string secureString = pair.Value;
Debug.Assert(secureString != null, "BrokerSettingsConstants.Secure value should be a string.");
bool secure;
if (bool.TryParse(secureString, out secure))
{
sessionInfo.Secure = secure;
TraceHelper.TraceEvent(sessionId, TraceEventType.Information, "[SessionLauncher] .GetInfo: get the job secure property, Secure={0}.", secure);
}
else
{
TraceHelper.TraceEvent(sessionId, TraceEventType.Error, "Illegal secure value[{0}] for job's " + BrokerSettingsConstants.Secure + " property", secureString);
}
}
else if (pair.Name.Equals(BrokerSettingsConstants.TransportScheme, StringComparison.OrdinalIgnoreCase))
{
string schemeString = pair.Value;
Debug.Assert(schemeString != null, "BrokerSettingsConstants.TransportScheme value should be a string.");
int scheme;
if (int.TryParse(schemeString, out scheme))
{
sessionInfo.TransportScheme = (TransportScheme)scheme;
TraceHelper.TraceEvent(
sessionId,
TraceEventType.Information,
"[SessionLauncher] .GetInfo: get the job TransportScheme property, TransportScheme={0}.",
sessionInfo.TransportScheme);
}
else
{
TraceHelper.TraceEvent(
sessionId,
TraceEventType.Error,
"Illegal transport scheme value[{0}] for job's " + BrokerSettingsConstants.TransportScheme + " property",
schemeString);
}
}
else if (pair.Name.Equals(BrokerSettingsConstants.BrokerNode, StringComparison.OrdinalIgnoreCase))
{
brokerNodeString = pair.Value;
Debug.Assert(brokerNodeString != null, "BrokerSettingsConstants.BrokerNode value should be a string.");
TraceHelper.TraceEvent(
sessionId,
TraceEventType.Information,
"[SessionLauncher] .GetInfo: get the job BrokerLauncherEpr property, BrokerLauncherEpr={0}.",
sessionInfo.BrokerLauncherEpr);
}
else if (pair.Name.Equals(BrokerSettingsConstants.Durable, StringComparison.OrdinalIgnoreCase))
{
string durableString = pair.Value;
Debug.Assert(durableString != null, "BrokerSettingsConstants.Durable value should be a string.");
bool durable;
if (bool.TryParse(durableString, out durable))
{
sessionInfo.Durable = durable;
TraceHelper.TraceEvent(sessionId, TraceEventType.Information, "[SessionLauncher] .GetInfo: get the job Durable property, Durable={0}.", sessionInfo.Durable);
}
else
{
TraceHelper.TraceEvent(sessionId, TraceEventType.Error, "Illegal secure value[{0}] for job's " + BrokerSettingsConstants.Durable + " property", durableString);
}
}
else if (pair.Name.Equals(BrokerSettingsConstants.ServiceVersion, StringComparison.OrdinalIgnoreCase))
{
if (pair.Value != null)
{
try
{
sessionInfo.ServiceVersion = new Version(pair.Value);
TraceHelper.TraceEvent(
sessionId,
TraceEventType.Information,
"[SessionLauncher] .GetInfo: get the job ServiceVersion property, ServiceVersion={0}.",
(sessionInfo.ServiceVersion != null) ? sessionInfo.ServiceVersion.ToString() : string.Empty);
}
catch (Exception e)
{
TraceHelper.TraceEvent(
sessionId,
TraceEventType.Error,
"Illegal secure value[{0}] for job's " + BrokerSettingsConstants.ServiceVersion + " property. Exception = {1}",
pair.Value,
e);
}
}
}
}
if (!string.IsNullOrEmpty(brokerNodeString))
{
if (brokerNodeString != Constant.InprocessBrokerNode)
{
sessionInfo.BrokerLauncherEpr = BrokerNodesManager.GenerateBrokerLauncherEpr(endpointPrefix, brokerNodeString, sessionInfo.TransportScheme);
}
}
else
{
sessionInfo.UseInprocessBroker = true;
}
TraceHelper.TraceEvent(
sessionId,
TraceEventType.Information,
"[SessionLauncher] .GetInfo: get the job BrokerLauncherEpr property, BrokerLauncherEpr={0}.",
sessionInfo.BrokerLauncherEpr);
}
}
}
catch (Exception e)
{
TraceHelper.TraceEvent(sessionId, TraceEventType.Error, "[SessionLauncher] .GetInfo: Failed to get all properties from job[{0}], Exception:{1}", sessionId, e);
ThrowHelper.ThrowSessionFault(SOAFaultCode.GetJobPropertyFailure, SR.SessionLauncher_FailToGetJobProperty, e.ToString());
}
if (sessionInfo.SessionOwner == null)
{
sessionInfo.SessionOwner = "Everyone";
}
if (sessionInfo.SessionACL == null)
{
sessionInfo.SessionACL = new string[0];
}
if (sessionInfo.JobState == 0)
{
// TODO: apply job state converting
sessionInfo.JobState = JobState.Running;
}
TraceHelper.TraceEvent(
sessionId,
TraceEventType.Information,
"[SessionLauncher] .GetInfo: return the sessionInfo, BrokerEpr={0}, BrokerLauncherEpr={1}, ControllerEpr={2}, Id={3}, JobState={4}, ResponseEpr={5}, Secure={6}, TransportScheme={7}, sessionOwner={8}, sessionACL={9}",
sessionInfo.BrokerEpr,
sessionInfo.BrokerLauncherEpr,
sessionInfo.ControllerEpr,
sessionInfo.Id,
sessionInfo.JobState,
sessionInfo.ResponseEpr,
sessionInfo.Secure,
sessionInfo.TransportScheme,
sessionInfo.SessionOwner ?? "null",
sessionInfo.SessionACL?.Length.ToString() ?? "null");
return(sessionInfo);
}