/// <summary> /// Resolve session launcher node on IaaS /// </summary> /// <param name="context"></param> /// <param name="headnode"></param> /// <returns></returns> public static async Task <string> ResolveSessionLauncherNodeOnIaasAsync(this ITelepathyContext context, string headnode) { string sessionLauncher = await context.ResolveSessionLauncherNodeAsync().ConfigureAwait(false); if (SoaHelper.IsSchedulerOnIaaS(headnode)) { string suffix = SoaHelper.GetSuffixFromHeadNodeEpr(headnode); sessionLauncher += suffix; } return(sessionLauncher); }
/// <summary> /// Create session /// </summary> /// <param name="startInfo">indicating session start information</param> /// <param name="durable">indicating a value whether a durable session is to be created</param> /// <param name="timeoutMilliseconds">indicating the timeout</param> /// <param name="binding">indicating the binding</param> /// <returns>returns session instance</returns> public override async Task <SessionBase> CreateSession(SessionStartInfo startInfo, bool durable, int timeoutMilliseconds, Binding binding) { SessionBase.CheckSessionStartInfo(startInfo); DateTime targetTimeout = DateTime.Now.AddMilliseconds(Constant.DefaultCreateSessionTimeout); // if following env variable is set, we will launch the service host in an admin job. string adminJobEnv = Environment.GetEnvironmentVariable(SessionBase.EnvVarNameForAdminJob, EnvironmentVariableTarget.Process); if (!string.IsNullOrEmpty(adminJobEnv) && adminJobEnv.Equals("1", StringComparison.InvariantCultureIgnoreCase)) { startInfo.AdminJobForHostInDiag = true; } SessionAllocateInfoContract sessionAllocateInfo = null; CredType typeOfExpectedCred = CredType.None; IResourceProvider resourceProvider = null; IList <string> newDataClients = null; try { int retry = 0; bool askForCredential = false; // allow users to try credential at most MaxRetryCount times int askForCredentialTimes = 0; while (Utility.CanRetry(retry, askForCredential, askForCredentialTimes)) { retry++; try { SessionBase.TraceSource.TraceEvent(TraceEventType.Verbose, 0, "[Session:Unknown] Start to create session for on-premise cluster. IsDurable = {0}, RetryCount = {1}, AskForCredentialTimes = {2}, TimeCost = {3}", durable, retry, askForCredentialTimes, targetTimeout); Stopwatch watch = new Stopwatch(); watch.Start(); if (startInfo.UseAad) { // Authentication handled by AADUtil } else if (SoaHelper.IsSchedulerOnAzure(startInfo.Headnode) || SoaHelper.IsSchedulerOnIaaS(startInfo.Headnode) || (startInfo.TransportScheme & TransportScheme.Http) == TransportScheme.Http || (startInfo.TransportScheme & TransportScheme.NetHttp) == TransportScheme.NetHttp) { askForCredential = HpcSessionCredUtil.RetrieveCredentialOnAzure(startInfo); if (askForCredential) { askForCredentialTimes++; } } else { askForCredential = await HpcSessionCredUtil.RetrieveCredentialOnPremise(startInfo, typeOfExpectedCred, binding).ConfigureAwait(false); if (askForCredential) { askForCredentialTimes++; } HpcSessionCredUtil.CheckCredential(startInfo); } resourceProvider = BuildResourceProvider(startInfo, durable, binding); if (((newDataClients == null) || (newDataClients.Count == 0)) && (startInfo.DependFiles != null) && (startInfo.DependFiles.Count > 0)) { // Upload the data files required for this session newDataClients = this.UploadAzureFiles(startInfo); } watch.Stop(); // re-calculate the timeout to exclude the timespan for getting credential targetTimeout = targetTimeout.AddMilliseconds(watch.ElapsedMilliseconds); sessionAllocateInfo = await resourceProvider.AllocateResource(startInfo, durable, SessionBase.GetTimeout(targetTimeout)).ConfigureAwait(false); SessionBase.TraceSource.TraceEvent(TraceEventType.Verbose, 0, "[Session:{0}] Successfully allocated resource.", sessionAllocateInfo.Id); if (sessionAllocateInfo.BrokerLauncherEpr != null) { if (SoaHelper.IsSchedulerOnIaaS(startInfo.Headnode)) { string suffix = SoaHelper.GetSuffixFromHeadNodeEpr(startInfo.Headnode); for (int i = 0; i < sessionAllocateInfo.BrokerLauncherEpr.Length; i++) { sessionAllocateInfo.BrokerLauncherEpr[i] = SoaHelper.UpdateEprWithCloudServiceName(sessionAllocateInfo.BrokerLauncherEpr[i], suffix); } } HpcSessionCredUtil.SaveCrendential(startInfo, binding); SessionBase.TraceSource.TraceInformation("Get the EPR list from headnode. number of eprs={0}", sessionAllocateInfo.BrokerLauncherEpr.Length); break; } } catch (EndpointNotFoundException e) { this.CleanUpDataClients(startInfo, newDataClients); SessionBase.TraceSource.TraceEvent(TraceEventType.Error, 0, "[Session:Unknown] EndpointNotFoundException occured while allocating resource: {0}", e); SessionBase.HandleEndpointNotFoundException(startInfo.Headnode); } catch (AuthenticationException e) { SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[Session:Unknown] AuthenticationException occured while allocating resource: {0}", e); startInfo.ClearCredential(); SessionBase.PurgeCredential(startInfo); if (Utility.CanRetry(retry, askForCredential, askForCredentialTimes)) { if (typeOfExpectedCred == CredType.None) { typeOfExpectedCred = await CredUtil.GetCredTypeFromClusterAsync(startInfo, binding).ConfigureAwait(false); } if (resourceProvider is IDisposable) { ((IDisposable)resourceProvider).Dispose(); } continue; } else { if (sessionAllocateInfo != null) { await resourceProvider.FreeResource(startInfo, sessionAllocateInfo.Id).ConfigureAwait(false); } throw; } } catch (MessageSecurityException e) { SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[Session:Unknown] MessageSecurityException occured while allocating resource: {0}", e); startInfo.ClearCredential(); SessionBase.PurgeCredential(startInfo); if (Utility.CanRetry(retry, askForCredential, askForCredentialTimes)) { if (typeOfExpectedCred == CredType.None) { typeOfExpectedCred = await CredUtil.GetCredTypeFromClusterAsync(startInfo, binding).ConfigureAwait(false); } if (resourceProvider is IDisposable) { ((IDisposable)resourceProvider).Dispose(); } continue; } else { if (sessionAllocateInfo != null) { await resourceProvider.FreeResource(startInfo, sessionAllocateInfo.Id).ConfigureAwait(false); } throw; } } catch (FaultException <SessionFault> ex) { typeOfExpectedCred = Utility.CanRetry(retry, askForCredential, askForCredentialTimes) ? CredUtil.GetCredTypeFromFaultCode(ex.Detail.Code) : CredType.None; SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[Session:Unknown] Fault exception occured while allocating resource. FaultCode = {0}. Exception = {1}", ex.Detail.Code, ex.ToString()); if (typeOfExpectedCred == CredType.None) { this.CleanUpDataClients(startInfo, newDataClients); if (sessionAllocateInfo != null) { await resourceProvider.FreeResource(startInfo, sessionAllocateInfo.Id).ConfigureAwait(false); } throw Utility.TranslateFaultException(ex); } else { startInfo.ClearCredential(); if (resourceProvider is IDisposable) { ((IDisposable)resourceProvider).Dispose(); } continue; } } catch (CommunicationException e) { this.CleanUpDataClients(startInfo, newDataClients); if (sessionAllocateInfo != null) { await resourceProvider.FreeResource(startInfo, sessionAllocateInfo.Id).ConfigureAwait(false); } throw new SessionException(SOAFaultCode.ConnectSessionLauncherFailure, SR.ConnectSessionLauncherFailure, e); } catch (TimeoutException e) { SessionBase.TraceSource.TraceInformation(e.ToString()); this.CleanUpDataClients(startInfo, newDataClients); if (sessionAllocateInfo != null) { await resourceProvider.FreeResource(startInfo, sessionAllocateInfo.Id).ConfigureAwait(false); } throw new TimeoutException(string.Format(SR.ConnectSessionLauncherTimeout, Constant.DefaultCreateSessionTimeout), e); } catch (Exception e) { SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[Session:Unknown] Exception occured while allocating resource: {0}", e); this.CleanUpDataClients(startInfo, newDataClients); if (sessionAllocateInfo != null) { await resourceProvider.FreeResource(startInfo, sessionAllocateInfo.Id).ConfigureAwait(false); } throw; } if (sessionAllocateInfo.BrokerLauncherEpr == null && startInfo.UseSessionPool) { // If the session launcher picks a session from the pool, it returns the seesion id. // eprs is null at this case. Try to attach to the session. try { if (sessionAllocateInfo.SessionInfo == null) { SessionBase.TraceSource.TraceInformation("[Session:{0}] Attempt to attach to session {0} which is part of the session pool.", sessionAllocateInfo.Id); return(await AttachSession(new SessionAttachInfo(startInfo.Headnode, sessionAllocateInfo.Id), durable, timeoutMilliseconds, binding).ConfigureAwait(false)); } else { SessionBase.TraceSource.TraceInformation("[Session:{0}] Attempt to attach to broker of the session {0} which is part of the session pool.", sessionAllocateInfo.Id); return(await AttachBroker(startInfo, sessionAllocateInfo.SessionInfo, durable, timeoutMilliseconds, binding).ConfigureAwait(false)); } } catch (Exception e) { SessionBase.TraceSource.TraceEvent(TraceEventType.Error, 0, "Failed to attach to the session {0}. {1}", sessionAllocateInfo.Id, e); if (Utility.CanRetry(retry, askForCredential, askForCredentialTimes)) { if (resourceProvider is IDisposable) { ((IDisposable)resourceProvider).Dispose(); } continue; } else { throw; } } } } IBrokerFactory brokerFactory = BuildBrokerFactory(startInfo, durable); try { return(await brokerFactory.CreateBroker(startInfo, sessionAllocateInfo.Id, targetTimeout, sessionAllocateInfo.BrokerLauncherEpr, binding).ConfigureAwait(false)); } catch { // Free resource if failed to create broker or create session this.CleanUpDataClients(startInfo, newDataClients); await resourceProvider.FreeResource(startInfo, sessionAllocateInfo.Id).ConfigureAwait(false); throw; } finally { if (brokerFactory is IDisposable) { ((IDisposable)brokerFactory).Dispose(); } } } finally { if (resourceProvider != null) { if (resourceProvider is IDisposable) { ((IDisposable)resourceProvider).Dispose(); } } } }
/// <summary> /// Attach to a broker, returns session instance /// </summary> /// <param name="attachInfo">indicating the attach information</param> /// <param name="info">indicating the session info to be updated</param> /// <param name="timeout">indicating the timeout</param> /// <param name="binding">indicting the binding</param> /// <returns>returns the session instance</returns> public Task <SessionBase> AttachBroker(SessionAttachInfo attachInfo, SessionInfo info, TimeSpan timeout, Binding binding) { SessionBase.TraceSource.TraceInformation("[Session:{0}] Try to attach broker...", attachInfo.SessionId); BrokerLauncherClient broker = new BrokerLauncherClient(new Uri(info.BrokerLauncherEpr), attachInfo, binding); broker.InnerChannel.OperationTimeout = timeout; try { BrokerInitializationResult result = broker.Attach(info.Id); info.BrokerEpr = result.BrokerEpr; info.ControllerEpr = result.ControllerEpr; info.ResponseEpr = result.ResponseEpr; info.ServiceOperationTimeout = result.ServiceOperationTimeout; info.MaxMessageSize = result.MaxMessageSize; info.ClientBrokerHeartbeatInterval = result.ClientBrokerHeartbeatInterval; info.ClientBrokerHeartbeatRetryCount = result.ClientBrokerHeartbeatRetryCount; info.BrokerUniqueId = result.BrokerUniqueId; info.UseAzureQueue = result.UseAzureQueue; info.AzureRequestQueueUris = result.AzureRequestQueueUris; info.AzureRequestBlobUri = result.AzureRequestBlobUri; info.Username = attachInfo.Username; info.InternalPassword = attachInfo.InternalPassword; info.Headnode = attachInfo.Headnode; info.UseWindowsClientCredential = attachInfo.UseWindowsClientCredential; } catch (FaultException <SessionFault> e) { SessionBase.TraceSource.TraceEvent(TraceEventType.Error, 0, "[Session:{0}] Fault exception occured while attaching broker: {1}. FaultCode = {2}", attachInfo.SessionId, e, e.Detail.Code); throw Utility.TranslateFaultException(e); } catch (CommunicationException e) { SessionBase.TraceSource.TraceEvent(TraceEventType.Error, 0, "[Session:{0}] Failed to attach to broker: {1}", attachInfo.SessionId, e); throw new SessionException(SOAFaultCode.ConnectBrokerLauncherFailure, SR.ConnectBrokerLauncherFailure, e); } catch (Exception e) { SessionBase.TraceSource.TraceEvent(TraceEventType.Error, 0, "[Session:{0}] Failed to attach to broker: {1}", attachInfo.SessionId, e); throw new SessionException(SOAFaultCode.UnknownError, e.ToString()); } finally { Utility.SafeCloseCommunicateObject(broker); } if (SoaHelper.IsSchedulerOnIaaS(attachInfo.Headnode)) { string suffix = SoaHelper.GetSuffixFromHeadNodeEpr(attachInfo.Headnode); if (info.BrokerEpr != null) { SoaHelper.UpdateEprWithCloudServiceName(info.BrokerEpr, suffix); } if (info.ControllerEpr != null) { SoaHelper.UpdateEprWithCloudServiceName(info.ControllerEpr, suffix); } if (info.ResponseEpr != null) { SoaHelper.UpdateEprWithCloudServiceName(info.ResponseEpr, suffix); } } if (this.durable) { if (!info.Durable) { throw new SessionException(SOAFaultCode.InvalidAttachInteractiveSession, SR.InvalidAttachInteractiveSession); } #if net40 return(TaskEx.FromResult <SessionBase>(new DurableSession(info, attachInfo.Headnode, binding))); #else return(Task.FromResult <SessionBase>(new DurableSession(info, attachInfo.Headnode, binding))); #endif } else { if (info.Durable) { throw new SessionException(SOAFaultCode.InvalidAttachDurableSession, SR.InvalidAttachDurableSession); } #if net40 return(TaskEx.FromResult <SessionBase>(new V3Session(info, attachInfo.Headnode, true, binding))); #else return(Task.FromResult <SessionBase>(new V3Session(info, attachInfo.Headnode, true, binding))); #endif } }
/// <summary> /// Attach to an existing session /// </summary> /// <param name="attachInfo">indicating the session attach information</param> /// <param name="durable">indicating a value whether a durable session is to be created</param> /// <param name="timeoutMilliseconds">indicating the timeout</param> /// <param name="binding">indicating the binding</param> /// <returns>returns session instance</returns> public override async Task <SessionBase> AttachSession(SessionAttachInfo attachInfo, bool durable, int timeoutMilliseconds, Binding binding) { Debug.Assert(attachInfo is SessionAttachInfo, "[OnPremiseSessionFactory].AttachSession: attachInfo's type must be SessionAttachInfo."); DateTime targetTimeout; Utility.ThrowIfNull(attachInfo, "attachInfo"); Utility.ThrowIfInvalidTimeout(timeoutMilliseconds, "timeoutMilliseconds"); if (timeoutMilliseconds == Timeout.Infinite) { targetTimeout = DateTime.MaxValue; } else { targetTimeout = DateTime.Now.AddMilliseconds(timeoutMilliseconds); } SessionBase.TraceSource.TraceEvent(TraceEventType.Information, 0, "[Session:{0}] Start to attach session...", attachInfo.SessionId); IResourceProvider resourceProvider = null; SessionInfo info = null; CredType typeOfExpectedCred = CredType.None; try { int retry = 0; bool askForCredential = false; // allow users to try credential at most MaxRetryCount times int askForCredentialTimes = 0; while (Utility.CanRetry(retry, askForCredential, askForCredentialTimes)) { retry++; try { SessionBase.TraceSource.TraceEvent(TraceEventType.Verbose, 0, "[Session:{0}] Start to attach session.", attachInfo.SessionId); Stopwatch watch = new Stopwatch(); watch.Start(); if (attachInfo.UseAad) { // Authentication handled by AADUtil } else if (SoaHelper.IsSchedulerOnAzure(attachInfo.Headnode) || SoaHelper.IsSchedulerOnIaaS(attachInfo.Headnode) || (attachInfo.TransportScheme & TransportScheme.Http) == TransportScheme.Http) { askForCredential = HpcSessionCredUtil.RetrieveCredentialOnAzure(attachInfo); if (askForCredential) { askForCredentialTimes++; } } else { askForCredential = await HpcSessionCredUtil.RetrieveCredentialOnPremise(attachInfo, typeOfExpectedCred, binding).ConfigureAwait(false); if (askForCredential) { askForCredentialTimes++; } HpcSessionCredUtil.CheckCredential(attachInfo); HpcSessionCredUtil.CheckCredential(attachInfo); } resourceProvider = BuildResourceProvider(attachInfo, durable, binding); watch.Stop(); // re-calculate the timeout to exclude the timespan for getting credential try { targetTimeout = targetTimeout.AddMilliseconds(watch.ElapsedMilliseconds); } catch (ArgumentOutOfRangeException) { } info = await resourceProvider.GetResourceInfo(attachInfo, SessionBase.GetTimeout(targetTimeout)).ConfigureAwait(false); SessionBase.TraceSource.TraceEvent(TraceEventType.Verbose, 0, "[Session:{0}] Successfully got resource info. BrokerLauncherEpr = {1}", attachInfo.SessionId, info.BrokerLauncherEpr); // If the session is an inprocess broker session, info.UseInprocessBroker will be set // to true by HpcSession service. Need to set attachInfo.UseInprocessBroker to true // in order to build correct broker factory instance. if (info.UseInprocessBroker) { attachInfo.UseInprocessBroker = true; } // If debug mode is enabled, need to set info.UseInprocessBroker to true in order to // build correct broker factory instance. if (attachInfo.DebugModeEnabled) { info.UseInprocessBroker = true; } if (SoaHelper.IsSchedulerOnIaaS(attachInfo.Headnode)) { string suffix = SoaHelper.GetSuffixFromHeadNodeEpr(attachInfo.Headnode); info.BrokerLauncherEpr = SoaHelper.UpdateEprWithCloudServiceName(info.BrokerLauncherEpr, suffix); if (info.BrokerEpr != null) { SoaHelper.UpdateEprWithCloudServiceName(info.BrokerEpr, suffix); } if (info.ControllerEpr != null) { SoaHelper.UpdateEprWithCloudServiceName(info.ControllerEpr, suffix); } if (info.ResponseEpr != null) { SoaHelper.UpdateEprWithCloudServiceName(info.ResponseEpr, suffix); } } HpcSessionCredUtil.SaveCrendential(attachInfo); break; } catch (SessionException) { throw; } catch (EndpointNotFoundException) { SessionBase.TraceSource.TraceEvent(TraceEventType.Error, 0, "[Session:{0}] EndpointNotFoundException occured while getting resource info.", attachInfo.SessionId); SessionBase.HandleEndpointNotFoundException(attachInfo.Headnode); } catch (AuthenticationException e) { SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[Session:{0}] AuthenticationException occured while attaching session: {1}", attachInfo.SessionId, e); attachInfo.ClearCredential(); SessionBase.PurgeCredential(attachInfo); if (Utility.CanRetry(retry, askForCredential, askForCredentialTimes)) { if (typeOfExpectedCred == CredType.None) { typeOfExpectedCred = await CredUtil.GetCredTypeFromClusterAsync(attachInfo, binding).ConfigureAwait(false); } if (resourceProvider is IDisposable) { ((IDisposable)resourceProvider).Dispose(); } continue; } else { throw; } } catch (MessageSecurityException e) { SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[Session:{0}] MessageSecurityException occured while attaching session: {1}", attachInfo.SessionId, e); attachInfo.ClearCredential(); SessionBase.PurgeCredential(attachInfo); if (Utility.CanRetry(retry, askForCredential, askForCredentialTimes)) { if (typeOfExpectedCred == CredType.None) { typeOfExpectedCred = await CredUtil.GetCredTypeFromClusterAsync(attachInfo, binding).ConfigureAwait(false); } if (resourceProvider is IDisposable) { ((IDisposable)resourceProvider).Dispose(); } continue; } else { throw; } } catch (FaultException <SessionFault> ex) { typeOfExpectedCred = Utility.CanRetry(retry, askForCredential, askForCredentialTimes) ? CredUtil.GetCredTypeFromFaultCode(ex.Detail.Code) : CredType.None; SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[Session:{0}] Fault exception occured while allocating resource. FaultCode = {1}", attachInfo.SessionId, ex.Detail.Code); if (typeOfExpectedCred == CredType.None) { throw Utility.TranslateFaultException(ex); } else { attachInfo.ClearCredential(); if (resourceProvider is IDisposable) { ((IDisposable)resourceProvider).Dispose(); } continue; } } catch (CommunicationException e) { throw new SessionException(SOAFaultCode.ConnectSessionLauncherFailure, SR.ConnectSessionLauncherFailure, e); } catch (TimeoutException e) { throw new TimeoutException(string.Format(SR.ConnectSessionLauncherTimeout, Constant.DefaultCreateSessionTimeout), e); } catch (Exception e) { throw new SessionException(SOAFaultCode.UnknownError, e.ToString()); } } // while } finally { IDisposable disposableObject = resourceProvider as IDisposable; if (disposableObject != null) { disposableObject.Dispose(); } } if (String.IsNullOrEmpty(info.BrokerLauncherEpr) && !info.UseInprocessBroker) { if ((info.JobState & (JobState.Configuring | JobState.ExternalValidation | JobState.Queued | JobState.Running | JobState.Submitted | JobState.Validating)) != 0) { throw new SessionException(string.Format(SR.AttachConfiguringSession, attachInfo.SessionId)); } else { throw new SessionException(string.Format(SR.AttachNoBrokerSession, attachInfo.SessionId)); } } IBrokerFactory brokerFactory = BuildBrokerFactory(attachInfo, durable); try { return(await brokerFactory.AttachBroker(attachInfo, info, SessionBase.GetTimeout(targetTimeout), binding).ConfigureAwait(false)); } finally { IDisposable disposableObject = brokerFactory as IDisposable; if (disposableObject != null) { disposableObject.Dispose(); } } }
/// <summary> /// The callback function for the allocate operation to session launcher /// </summary> /// <param name="ar">the async result</param> private void AllocateCallback(IAsyncResult ar) { SessionLauncherClient client = (SessionLauncherClient)ar.AsyncState; SessionInfoContract sessionInfo; try { try { bool durable = (GetType() == typeof(DurableSessionAsyncResult)); if (durable) { this.eprCanidates = client.EndAllocateDurable(out this.sessionid, out serviceVersion, out sessionInfo, ar); } else { this.eprCanidates = client.EndAllocate(out this.sessionid, out serviceVersion, out sessionInfo, ar); } SessionBase.TraceSource.TraceEvent(TraceEventType.Verbose, 0, "[Session:{0}] Successfully allocated resource. ServiceVersion = {1}", this.sessionid, serviceVersion); this.eprPtr = 0; // If HpcSession returns a version, pass it to HpcBroker if (!String.IsNullOrEmpty(serviceVersion)) { try { this.StartInfo.Data.ServiceVersion = new Version(serviceVersion); } catch { throw new SessionException(SR.InvalidServiceVersionReturned); } } SessionBase.SaveCrendential(this.StartInfo, this.binding); if (this.eprCanidates == null || this.eprCanidates.Length == 0) { throw new SessionException(SR.NoBrokerNodeFound); } if (SoaHelper.IsSchedulerOnIaaS(this.StartInfo.Headnode)) { string suffix = SoaHelper.GetSuffixFromHeadNodeEpr(this.StartInfo.Headnode); for (int i = 0; i < this.eprCanidates.Length; i++) { this.eprCanidates[i] = SoaHelper.UpdateEprWithCloudServiceName(this.eprCanidates[i], suffix); } } SessionBase.TraceSource.TraceInformation("Get the EPR list from headnode. number of eprCanidates={0}", this.eprCanidates.Length); if (!this.Canceled) { this.ConnectToNextBroker(); } else { // Bug 11765: If the operation is canceled, when allocating // resource, do cleanup the resource this.CleanupOnFailure().GetAwaiter().GetResult(); } } catch (AuthenticationException ex) { SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[Session:Unknown] AuthenticationException occured while allocating resource: {0}", ex); this.StartInfo.ClearCredential(); SessionBase.PurgeCredential(this.StartInfo); if (retry > 0) { //TODO: remove sync wait BeginAllocate(this.StartInfo, CredType.None).GetAwaiter().GetResult(); } else { this.MarkFinish(new AuthenticationException(SR.AuthenticationFailed, ex)); } } catch (MessageSecurityException ex) { SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[Session:Unknown] MessageSecurityException occured while allocating resource: {0}", ex); this.StartInfo.ClearCredential(); SessionBase.PurgeCredential(this.StartInfo); if (retry > 0) { //TODO: remove sync wait BeginAllocate(this.StartInfo, CredType.None).GetAwaiter().GetResult(); } else { this.MarkFinish(new AuthenticationException(SR.AuthenticationFailed, ex)); } } catch (FaultException <SessionFault> ex) { int faultCode = (ex as FaultException <SessionFault>).Detail.Code; CredType type = CredUtil.GetCredTypeFromFaultCode(faultCode); SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[Session:Unknown] Fault exception occured while allocating resource. FaultCode = {0}, CredType = {1}", faultCode, type); if (type != CredType.None) { this.StartInfo.ClearCredential(); if (retry > 0) { //TODO: remove sync wait BeginAllocate(this.StartInfo, type).GetAwaiter().GetResult(); } else { this.MarkFinish(new AuthenticationException(SR.AuthenticationFailed, ex)); } } else { throw; } } } catch (FaultException <SessionFault> ex) { this.MarkFinish(Utility.TranslateFaultException(ex)); } catch (Exception ex) { this.MarkFinish(ex); } finally { Utility.SafeCloseCommunicateObject(client); } }