/// <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();
                    }
                }
            }
        }
Ejemplo n.º 2
0
        public override async Task <SessionBase> CreateSession(SessionStartInfo startInfo, bool durable, int timeoutMilliseconds, Binding binding)
        {
            SessionBase.CheckSessionStartInfo(startInfo);
            DateTime targetTimeout = DateTime.Now.AddMilliseconds(Constant.DefaultCreateSessionTimeout);
            SessionAllocateInfoContract sessionAllocateInfo = null;
            IResourceProvider           resourceProvider    = null;

            try
            {
                try
                {
                    resourceProvider = this.BuildResourceProvider(startInfo, binding);
                    // re-calculate the timeout to exclude the timespan for getting credential
                    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 &&
                        sessionAllocateInfo.BrokerLauncherEpr.Count() == 1 &&
                        sessionAllocateInfo.BrokerLauncherEpr[0] == SessionInternalConstants.BrokerConnectionStringToken)
                    {
                        if (!startInfo.UseAzureStorage)
                        {
                            SessionBase.TraceSource.TraceEvent(
                                TraceEventType.Error,
                                0,
                                "[Session:{0}] Server side only supports communication via AzureStorageQueue while client doesn't specify UseAzureQueue property and not using AzureStorage scheme.",
                                sessionAllocateInfo.Id);
                            throw new InvalidOperationException("Server side only supports communication via AzureStorageQueue while client doesn't specify UseAzureQueue property.");
                        }
                    }
                }
                catch (Exception e)
                {
                    SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[Session:Unknown] Exception occured while allocating resource: {0}", e);
                    if (sessionAllocateInfo != null)
                    {
                        await resourceProvider.FreeResource(startInfo, sessionAllocateInfo.Id).ConfigureAwait(false);
                    }

                    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
                    await resourceProvider.FreeResource(startInfo, sessionAllocateInfo.Id).ConfigureAwait(false);

                    throw;
                }
                finally
                {
                    if (brokerFactory != null && brokerFactory is IDisposable disposable)
                    {
                        disposable.Dispose();
                    }
                }
            }
            finally
            {
                if (resourceProvider != null && resourceProvider is IDisposable disposable)
                {
                    disposable.Dispose();
                }
            }
        }