/// <summary> /// Initializes a new instance of the SchedulerAdapterClientFactory class /// </summary> /// <param name="sharedData">indicating the shared data</param> /// <param name="monitor">indicating the monitor</param> /// <param name="dispatcherManager">indicating the dispatcher manager</param> public SchedulerAdapterClientFactory(SharedData sharedData, ServiceJobMonitorBase monitor, DispatcherManager dispatcherManager, ITelepathyContext context) { this.sharedData = sharedData; this.monitor = monitor; this.dispatcherManager = dispatcherManager; this.context = context; }
/// <summary> /// Initializes a new instance of the BrokerManager class /// </summary> public BrokerManager(bool needRecover, ITelepathyContext context) { TraceHelper.TraceEvent(TraceEventType.Verbose, "[BrokerManager] Constructor: needRecover={0}", needRecover); this.headnode = SoaHelper.GetSchedulerName(); this.context = context; this.brokerDic = new Dictionary <string, BrokerInfo>(); this.staleSessionCleanupTimer = new Timer(this.CleanStaleSessionData, null, Timeout.Infinite, Timeout.Infinite); #if HPCPACK if (!SoaHelper.IsOnAzure()) { // TODO: on azure, about the MSMQ. Don't use the MSMQ in the Azure cluster. this.updateQueueLengthTimer = new Timer(this.CallbackToUpdateMSMQLength, null, Timeout.Infinite, Timeout.Infinite); } #endif this.pool = new BrokerProcessPool(); // TODO: enable recovery in Telepathy #if HPCPACK if (needRecover && !BrokerLauncherEnvironment.Standalone) { this.ts = new CancellationTokenSource(); CancellationToken ct = ts.Token; this.RecoverTask = Task.Run(async() => await this.RecoverThreadProc(ct), ct); } #endif }
/// <summary> /// Initializes a new instance of the LauncherHostService class /// This will be called when run in debug mode /// </summary> /// <param name="launcherChoose">launcher choose</param> internal LauncherHostService(bool console, ITelepathyContext context) { this.context = context; isConsoleApplication = console; InitializeComponent(); this.OpenService(); }
public static ISchedulerHelper GetSchedulerHelper(ITelepathyContext context) { if (BrokerLauncherEnvironment.Standalone) { return(new DummySchedulerHelper()); } else { return(new SchedulerHelper(context)); } }
/// <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); }
public static async Task <ServiceHost> SetupInternalWcfChannelAsync <T>(ITelepathyContext context, object singletonInstance, string serviceUri, ServiceAuthorizationManager manager = null) { var thumbPrint = await context.GetSSLThumbprint().ConfigureAwait(false); Trace.TraceInformation("[WcfHost] Begin to setup WCF channel on {0}, thumbprint is {1}", serviceUri, thumbPrint); var tcpBinding = NetTcpBindingWithCertFactory(); var internalWcfHost = CreateWcfChannel <T>(singletonInstance, tcpBinding, serviceUri, thumbPrint, manager, PrincipalPermissionMode.None, DefaultServiceThrottlingBehavior()); await Task.Factory.FromAsync(internalWcfHost.BeginOpen(null, null), internalWcfHost.EndOpen).ConfigureAwait(false); Trace.TraceInformation("[WcfHost] End to setup internal WCF channel"); return(internalWcfHost); }
/// <summary> /// Initializes a new instance of the SchedulerHelper class /// </summary> public SchedulerHelper(ITelepathyContext context) { this.context = context; this.sessionNode = new Lazy <string>(() => this.ResolveSessionNodeWithRetries().GetAwaiter().GetResult(), LazyThreadSafetyMode.ExecutionAndPublication); this.certThumbprint = new Lazy <string>(() => this.context.GetSSLThumbprint().GetAwaiter().GetResult(), LazyThreadSafetyMode.ExecutionAndPublication); this.schedulerClient = new Lazy <SchedulerAdapterClient>( () => new SchedulerAdapterClient(BindingHelper.HardCodedUnSecureNetTcpBinding, new EndpointAddress(SoaHelper.GetSchedulerDelegationAddress(this.sessionNode.Value)), new InstanceContext(new TraceOnlyServiceJobMonitor())), LazyThreadSafetyMode.ExecutionAndPublication); this.sessionLauncherClient = new Lazy <SessionLauncherClient>( () => new SessionLauncherClient(this.sessionNode.Value, this.certThumbprint.Value), LazyThreadSafetyMode.ExecutionAndPublication); }
public BrokerLauncher(bool managementOperationsOnly, ITelepathyContext context) { this.context = context; // Initializes the job object this.job = new JobObject(); // Assign broker launcher process to the job object this.job.Assign(Process.GetCurrentProcess()); // If this instance of HpcBroker service should handle mgmt and app operations if (!managementOperationsOnly) { // Force the broker mananger to intialize when the service is online this.brokerManager = new BrokerManager(this.IsOnline, context); } }
/// <summary> /// Initializes a new instance of the DispatcherManager class /// </summary> /// <param name="bindings">indicating the bindings section</param> /// <param name="observer">indicating the observer</param> /// <param name="queueFactory">indicating the queue factory</param> /// <param name="sharedData">indicating the shared data</param> /// <param name="frontendResult">indicating the frontend result</param> public DispatcherManager(BindingsSection bindings, SharedData sharedData, BrokerObserver observer, ServiceJobMonitorBase monitor, BrokerQueueFactory queueFactory, ITelepathyContext context) { this.dispatcherDic = new Dictionary <string, Dispatcher>(); this.failedDispatcherList = new List <string>(); this.blockedDispatcherDic = new Dictionary <string, DispatcherInfo>(); this.blockedDispatcherQueue = new Queue <DispatcherInfo>(); this.sharedData = sharedData; this.observer = observer; this.monitor = monitor; this.queueFactory = queueFactory; this.context = context; this.defaultCapacity = this.sharedData.ServiceConfig.MaxConcurrentCalls; this.blockTimeSpan = TimeSpan.FromMilliseconds(this.sharedData.Config.LoadBalancing.EndpointNotFoundRetryPeriod); this.unblockTimer = new Timer(new ThreadHelper <object>(new TimerCallback(this.CallbackToQueryBlockedDispatcherList)).CallbackRoot, null, -1, -1); this.defaultBinding = BindingHelper.GetBackEndBinding(bindings); this.isHttp = this.defaultBinding.CreateBindingElements().Find <HttpTransportBindingElement>() != null; // Update binding's maxMessageSize settings with global maxMessageSize if its enabled (> 0) int maxMessageSize = sharedData.ServiceConfig.MaxMessageSize; if (maxMessageSize > 0) { BindingHelper.ApplyMaxMessageSize(this.defaultBinding, maxMessageSize); } // get soa burst protocol info this.httpsBurst = sharedData.BrokerInfo.HttpsBurst; if (this.httpsBurst) { this.azureQueueManager = new AzureQueueManager(sharedData.BrokerInfo.SessionId, this.sharedData.BrokerInfo.ClusterName, this.sharedData.BrokerInfo.ClusterId); } this.supportsMessageDetails = this.defaultBinding.MessageVersion.Addressing != AddressingVersion.None || this.defaultBinding is BasicHttpBinding; BrokerTracing.TraceEvent(TraceEventType.Information, 0, "[DispatcherManager] Init backend binding: OperatiomTimeout = {0}, DefaultCapacity = {1}", this.sharedData.Config.LoadBalancing.ServiceOperationTimeout, this.defaultCapacity); BrokerTracing.EtwTrace.LogBackendBindingLoaded( sharedData.BrokerInfo.SessionId, "Backend", maxMessageSize, this.defaultBinding.ReceiveTimeout.Ticks, this.defaultBinding.SendTimeout.Ticks, this.defaultBinding.MessageVersion.ToString(), this.defaultBinding.Scheme); }
/// <summary> /// Initializes a new instance of the LauncherHostService class /// </summary> public LauncherHostService(ITelepathyContext context) { Trace.TraceInformation("LauncherHostService init."); this.context = context; InitializeComponent(); }
/// <summary> /// Initializes a new instance of the ServiceJobMonitor class /// </summary> /// <param name="sharedData">indicating the shared data</param> /// <param name="stateManager">indicating the state manager</param> public ServiceJobMonitor(SharedData sharedData, BrokerStateManager stateManager, NodeMappingData nodeMappingData, ITelepathyContext context) : base(sharedData, stateManager, nodeMappingData, context) { }
public static async Task <string> GetSSLThumbprint(this ITelepathyContext context) { return(await context.Registry.GetSSLThumbprint(context.CancellationToken).ConfigureAwait(false)); }
public static async Task <string> ResolveSessionLauncherNodeAsync(this ITelepathyContext context) { return(await context.FabricContext.ResolveSingletonServicePrimaryAsync(SessionLauncherStatefulService, context.CancellationToken).ConfigureAwait(false)); }