/// <summary> /// Create request queue for specified Azure service. /// </summary> /// <param name="azureServiceName">azure service name</param> public void CreateRequestStorage(string azureServiceName) { this.requestStorage.GetOrAdd( azureServiceName, (key) => { string requestStorageName = SoaHelper.GetRequestStorageName(this.clusterId.ToString(), key); BrokerTracing.TraceVerbose( "[AzureQueueManager].CreateRequestStorage: Try to create the request storage {0} for Azure service {1}", requestStorageName, key); this.CreateStorageClient(RetryPolicyForRequestStorage); CloudQueue queue = this.queueClient.GetQueueReference(requestStorageName); AzureQueueManager.CreateQueueWithRetry(queue); CloudBlobContainer container = this.blobClient.GetContainerReference(requestStorageName); AzureQueueManager.CreateContainerWithRetry(container); if (Interlocked.CompareExchange(ref this.requestQueueExist, 1, 0) == 0) { BrokerTracing.EtwTrace.LogQueueCreatedOrExist(this.sessionId, requestStorageName); } return(new Tuple <CloudQueue, CloudBlobContainer>(queue, container)); }); }
/// <summary> /// Gets SOA configurations /// </summary> /// <param name="keys">indicating the keys</param> /// <returns>returns the values</returns> public async Task <Dictionary <string, string> > GetSOAConfigurations(List <string> keys) { RetryManager retry = SoaHelper.GetDefaultExponentialRetryManager(); return(await RetryHelper <Dictionary <string, string> > .InvokeOperationAsync( async() => { using (BrokerIdentity identity = new BrokerIdentity()) { identity.Impersonate(); return await this.sessionLauncherClient.Value.GetSOAConfigurationsAsync(keys); } }, async (e, r) => { TraceHelper.TraceEvent( TraceEventType.Warning, "[SchedulerHelper] Failed to get SOA configuration, Key:{0}, Retry:{1}, Error:{2}", string.Join(",", keys), r.RetryCount, e); await this.RenewSessionLauncherClientAsync(); }, retry)); }
private bool SetClientCredential(ClientCredentials clientCredentials) { if (this.schedulerOnIaaS || this.info.UseWindowsClientCredential) { string domainName; string userName; SoaHelper.ParseDomainUser(this.info.Username, out domainName, out userName); clientCredentials.Windows.ClientCredential.Domain = domainName; clientCredentials.Windows.ClientCredential.UserName = userName; clientCredentials.Windows.ClientCredential.Password = this.info.InternalPassword; return(true); } else if ((this.scheme & TransportScheme.NetHttp) == TransportScheme.NetHttp) { clientCredentials.UserName.UserName = this.info.Username; clientCredentials.UserName.Password = this.info.InternalPassword; return(true); } else if (this.info.LocalUser) { clientCredentials.UseInternalAuthenticationAsync().GetAwaiter().GetResult(); return(true); } else { return(false); } }
/// <summary> /// Get data service binding /// </summary> /// <returns>data service binding</returns> private static Binding GetBinding(string headNode) { Binding binding; if (SoaHelper.IsOnAzure()) { // Azure CN doesn't join domain. so secure binding cannot be used to authenticate non-system users // TODO: use secure binding and enhance security mechanism binding = BindingHelper.HardCodedUnsecureDataServiceNetTcpBinding; // At client side, SendTimeout is used to initialize OperationTimeout. It governs // the whole interaction for sending a message (including receiving a reply message). // ReceiveTimeout is actually not used. binding.SendTimeout = TimeSpan.FromMinutes(Constant.DataProxyOperationTimeoutInMinutes); binding.ReceiveTimeout = TimeSpan.FromMinutes(Constant.DataProxyOperationTimeoutInMinutes); } else if (SoaHelper.IsSchedulerOnIaaS(headNode)) { binding = BindingHelper.HardCodedDataServiceHttpsBinding; } else { binding = BindingHelper.HardCodedDataServiceNetTcpBinding; } return(binding); }
/// <summary> /// Initializes a new instance of the BrokerLauncherClient class. /// </summary> /// <param name="uri">The broker launcher EPR</param> /// <param name="info">The sesion info</param> /// <param name="binding">indicting the binding</param> public BrokerLauncherClient(Uri uri, SessionInfoBase info, Binding binding) : this(info, binding, uri) { if (info.UseAad) { } else if ((info.TransportScheme & TransportScheme.NetTcp) == TransportScheme.NetTcp) { SessionInfo sessionInfo = info as SessionInfo; if (SoaHelper.IsSchedulerOnIaaS(info.Headnode) || (sessionInfo != null && sessionInfo.UseWindowsClientCredential)) { string domainName; string userName; SoaHelper.ParseDomainUser(info.Username, out domainName, out userName); this.ClientCredentials.Windows.ClientCredential.Domain = domainName; this.ClientCredentials.Windows.ClientCredential.UserName = userName; this.ClientCredentials.Windows.ClientCredential.Password = info.InternalPassword; } } else if ((info.TransportScheme & TransportScheme.Http) == TransportScheme.Http || (info.TransportScheme & TransportScheme.NetHttp) == TransportScheme.NetHttp) { this.ClientCredentials.UserName.UserName = info.Username; this.ClientCredentials.UserName.Password = info.InternalPassword; } }
public async Task FreeResource(SessionStartInfo startInfo, string sessionId) { try { if (!sessionId.Equals("0")) { RetryManager retry = SoaHelper.GetDefaultExponentialRetryManager(); await RetryHelper <object> .InvokeOperationAsync( async() => { await this.client.TerminateAsync(sessionId).ConfigureAwait(false); return(null); }, (e, r) => { if (e is EndpointNotFoundException) { Utility.SafeCloseCommunicateObject(this.client); this.client = new SessionLauncherClient(startInfo, this.binding); } else { r.MaxRetryCount = 0; } return(Task.CompletedTask); }, retry).ConfigureAwait(false); } } catch { // if terminate the session failed, then do nothing here. } }
/// <summary> /// Get data service binding /// </summary> /// <returns>data service binding</returns> private static Binding GetBinding(Uri uri) { Binding binding; if (uri.Scheme.Equals(BindingHelper.HttpsScheme, StringComparison.OrdinalIgnoreCase)) { binding = BindingHelper.HardCodedDataServiceHttpsBinding; } else if (uri.Scheme.Equals(BindingHelper.NetTcpScheme)) { if (SoaHelper.IsOnAzure()) { // Azure CN doesn't join domain. so secure binding cannot be used to authenticate non-system users // TODO: use secure binding and enhance security mechanism binding = BindingHelper.HardCodedUnsecureDataServiceNetTcpBinding; // At client side, SendTimeout is used to initialize OperationTimeout. It governs // the whole interaction for sending a message (including receiving a reply message). // ReceiveTimeout is actually not used. binding.SendTimeout = TimeSpan.FromMinutes(Constant.DataProxyOperationTimeoutInMinutes); binding.ReceiveTimeout = TimeSpan.FromMinutes(Constant.DataProxyOperationTimeoutInMinutes); } else { binding = BindingHelper.HardCodedDataServiceNetTcpBinding; } } else { throw new NotImplementedException(string.Format("[DataServiceAgent] Not supported Uri scheme: {0}", uri)); } return(binding); }
/// <summary> /// Initializes a new instance of the BrokerNodeAuthManager class. /// </summary> /// <param name="jobId">job id of the soa session</param> internal BrokerNodeAuthManager(string jobId) { this.jobId = jobId; if (SoaHelper.IsCurrentUserLocal() || WindowsIdentity.GetCurrent().IsSystem) { this.enable = false; RuntimeTraceHelper.TraceEvent(this.jobId, TraceEventType.Information, "[HpcServiceHost]: BrokerNodeAuthManager is disabled in non-domain joined compute node."); } else { this.enable = true; this.allowedUser = WindowsIdentity.GetCurrent(); // If this environment does not exist, the jobOwnerUserName will remain null. // Thus the comparision will always fail so that HpcServiceHost will not authenticate job owner. this.jobOwnerUserName = Environment.GetEnvironmentVariable(Constant.JobOwnerNameEnvVar, EnvironmentVariableTarget.Process); RuntimeTraceHelper.TraceEvent( this.jobId, TraceEventType.Information, "[HpcServiceHost]: BrokerNodeAuthManager initialized. AllowerUser = {0}, JobOwner = {1}", this.allowedUser.Name, this.jobOwnerUserName); } }
/// <summary> /// Initializes a new instance of the HpcSchedulerAdapterClient class /// </summary> /// <param name="headnode">indicating the headnode</param> /// <param name="instanceContext">indicating the instance context</param> public HpcSchedulerAdapterClient(string headnode, string certThrumbprint, InstanceContext instanceContext) : base( instanceContext, BindingHelper.HardCodedInternalSchedulerDelegationBinding, SoaHelper.CreateInternalCertEndpointAddress(new Uri(SoaHelper.GetSchedulerDelegationAddress(headnode)), certThrumbprint)) { BrokerTracing.TraceVerbose("[HpcSchedulerAdapterClient] In constructor"); this.ClientCredentials.UseInternalAuthentication(certThrumbprint); if (BrokerIdentity.IsHAMode) { // Bug 10301 : Explicitly open channel when impersonating the resource group's account if running on failover cluster so identity flows correctly when // calling HpcSession. // NOTE: The patch we got from the WCF team (KB981001) only works when the caller is on a threadpool thread. // NOTE: Channel must be opened before setting OperationTimeout using (BrokerIdentity identity = new BrokerIdentity()) { identity.Impersonate(); this.Open(); } } this.InnerChannel.OperationTimeout = SchedulerAdapterTimeout; foreach (OperationDescription op in this.Endpoint.Contract.Operations) { DataContractSerializerOperationBehavior dataContractBehavior = op.Behaviors.Find <DataContractSerializerOperationBehavior>() as DataContractSerializerOperationBehavior; if (dataContractBehavior != null) { dataContractBehavior.MaxItemsInObjectGraph = int.MaxValue; } } }
/// <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> /// Apply session id to the uri /// </summary> /// <param name="baseUri">indicate the base uri</param> /// <param name="sessionId">indicate the session id</param> /// <param name="postfix">indicate the postfix</param> /// <param name="needFqdn">indicate if need FQDN</param> /// <returns>uri with session id</returns> private static Uri ApplySessionId(Uri baseUri, string sessionId, string postfix, bool needFqdn) { UriBuilder builder = new UriBuilder(baseUri); if (baseUri.IsLoopback) { #if PaaS if (SoaHelper.IsOnAzure()) { builder.Host = AzureRoleHelper.GetLocalMachineAddress(); } else #endif { if (needFqdn) { string domainName = IPGlobalProperties.GetIPGlobalProperties().DomainName; builder.Host = string.Format("{0}.{1}", Environment.MachineName, domainName); } else { builder.Host = Environment.MachineName; } } } return(new Uri(builder.Uri, String.Format(CultureInfo.InvariantCulture, "{0}/{1}", sessionId, postfix))); }
/// <summary> /// Save the credential at local Windows Vault, if /// (1) scheduler is on Azure (credential is needed by session service to run as that user) /// (2) debug mode (no scheduler) /// (3) scheduler version is before 3.1 (scheduler side credential cache is not supported before 3.1) /// </summary> /// <param name="info">it contians credential and targeted scheduler</param> /// <param name="binding">indicating the binding</param> public static void SaveCrendential(SessionStartInfo info, Binding binding) { if (info.SavePassword && info.InternalPassword != null) { Debug.Assert(!String.IsNullOrEmpty(info.Headnode), "The headnode can't be null or empty."); bool saveToLocal = false; if (SoaHelper.IsSchedulerOnAzure(info.Headnode) || SoaHelper.IsSchedulerOnIaaS(info.Headnode)) { saveToLocal = true; } else if (info.DebugModeEnabled) { saveToLocal = true; } if (saveToLocal) { SaveCrendential(info.Headnode, info.Username, info.InternalPassword); SessionBase.TraceSource.TraceInformation("Cached credential is saved to local Windows Vault."); } else { // the password is already sent to session service, which saves it to the scheduler. SessionBase.TraceSource.TraceInformation("Cached credential is expected to be saved to the scheduler by session service."); } } }
/// <summary> /// Build broker authorization /// </summary> /// <param name="sharedData">indicating the shared data</param> /// <param name="monitor">indicating the service job monitor</param> /// <returns>returns the broker autorization instance</returns> private static BrokerAuthorization BuildBrokerAuthorization(SharedData sharedData) { // No authorization for inprocess session if (sharedData.StartInfo.UseInprocessBroker) { return(null); } if (sharedData.StartInfo.Secure) { if (SoaHelper.IsOnAzure()) { return(null); } if (sharedData.StartInfo.ShareSession) { // TODO: Feature: share session throw new NotImplementedException(); // return new BrokerAuthorization(sharedData.BrokerInfo.JobTemplateACL, (int)JobTemplateRights.SubmitJob, (int)JobTemplateRights.Generic_Read, (int)JobTemplateRights.Generic_Write, (int)JobTemplateRights.Generic_Execute, (int)JobTemplateRights.Generic_All); } else { return(new BrokerAuthorization(new SecurityIdentifier(sharedData.BrokerInfo.JobOwnerSID))); } } else { // No authorization for nonsecure session return(null); } }
/// <summary> /// Generate endpoint address by scheme from epr list /// </summary> /// <param name="eprList">indicating the epr list</param> /// <param name="scheme">indicating the scheme</param> /// <returns>endpoint address</returns> private static EndpointAddress GenerateEndpointAddress(string[] eprList, TransportScheme scheme, bool secure, bool internalChannel) { int index = (int)Math.Log((int)scheme, 2); string epr = eprList[index]; return(SoaHelper.CreateEndpointAddress(new Uri(epr), secure, internalChannel)); }
/// <summary> /// Initializes a new instance of the HpcSchedulerAdapterInternalClient class /// </summary> /// <param name="headNodeMachine">indicating the headnode</param> public HpcSchedulerAdapterInternalClient(string headNodeMachine, string certThumbprint) : base( BindingHelper.HardCodedInternalSchedulerDelegationBinding, SoaHelper.CreateInternalCertEndpointAddress(new Uri(SoaHelper.GetSchedulerDelegationInternalAddress(headNodeMachine)), certThumbprint)) { #if BrokerLauncher BrokerTracing.TraceVerbose("[HpcSchedulerAdapterInternalClient] In constructor"); #endif // use certificate for cluster internal authentication this.ClientCredentials.UseInternalAuthentication(certThumbprint); if (BrokerIdentity.IsHAMode) { // Bug 10301 : Explicitly open channel when impersonating the resource group's account if running on failover cluster so identity flows correctly when // calling HpcSession. // NOTE: The patch we got from the WCF team (KB981001) only works when the caller is on a threadpool thread. // NOTE: Channel must be opened before setting OperationTimeout using (BrokerIdentity identity = new BrokerIdentity()) { identity.Impersonate(); this.Open(); } } this.InnerChannel.OperationTimeout = OperationTimeout; }
/// <summary> /// Process a collection of queue messages. /// </summary> /// <param name="messages">collection of the queue messages</param> private void ProcessMessages(IEnumerable <CloudQueueMessage> messages) { BrokerTracing.TraceInfo(SoaHelper.CreateTraceMessage("Proxy", "ProcessMessages", string.Format("Process {0} messages.", messages.Count <CloudQueueMessage>()))); messages.AsParallel <CloudQueueMessage>() .ForAll <CloudQueueMessage>( (requestQueueMessage) => { Message request = null; try { BrokerTracing.TraceInfo(string.Format("SOA broker proxy perf1 - {0}", DateTime.UtcNow.TimeOfDay.TotalSeconds)); request = this.requestStorageClients.First().GetWcfMessageFromQueueMessage(requestQueueMessage); this.requestMessageQueue.Add(request); // this.requestMessageQueue.Enqueue(request); UniqueId messageId = SoaHelper.GetMessageId(request); BrokerTracing.TraceInfo(SoaHelper.CreateTraceMessage("Proxy", "Request received inqueue", string.Empty, messageId, "Request message in queue")); } catch (Exception e) { BrokerTracing.TraceError(SoaHelper.CreateTraceMessage("Proxy", "ProcessMessages", string.Format("Error occurs {0}", e))); } }); this.semaphoreForWorker.Release(); }
/// <summary> /// Set the trace level according to the env var /// </summary> public static void SetTraceSwitchLevel() { SourceLevels level = Utility.GetTraceSwitchLevel(); ServiceContext.Logger.Switch.Level = level; if (level != SourceLevels.Off) { RuntimeTraceHelper.IsDiagTraceEnabled = x => true; RuntimeTraceHelper.TraceEvent( TraceEventType.Information, SoaHelper.CreateTraceMessage( "Utility", "SetTraceSwitchLevel", "Add the SoaDiagTraceListener.")); ServiceContext.Logger.Listeners.Add(new SoaDiagTraceListener(Utility.GetJobId())); } else { RuntimeTraceHelper.TraceEvent( TraceEventType.Information, SoaHelper.CreateTraceMessage( "Utility", "SetTraceSwitchLevel", "SoaDiagTrace is disabled.")); } }
public async Task <SessionInfo> GetResourceInfo(SessionAttachInfo attachInfo, TimeSpan timeout) { this.client.InnerChannel.OperationTimeout = timeout; RetryManager retry = SoaHelper.GetDefaultExponentialRetryManager(); SessionInfo info; DateTime startTime = DateTime.Now; if (attachInfo.TransportScheme == TransportScheme.Http) { info = Utility.BuildSessionInfoFromDataContract( await RetryHelper <SessionInfoContract> .InvokeOperationAsync( async() => await this.client.GetInfoAsync(SessionLauncherClient.HttpsEndpointPrefix, attachInfo.SessionId).ConfigureAwait(false), (e, r) => { var remainingTime = GetRemainingTime(timeout, startTime); if ((e is EndpointNotFoundException || (e is CommunicationException && !(e is FaultException <SessionFault>))) && remainingTime > TimeSpan.Zero) { Utility.SafeCloseCommunicateObject(this.client); this.client = new SessionLauncherClient(attachInfo, this.binding); this.client.InnerChannel.OperationTimeout = remainingTime; } else { r.MaxRetryCount = 0; } return(Task.CompletedTask); }, retry) .ConfigureAwait(false)); } else { info = Utility.BuildSessionInfoFromDataContract( await RetryHelper <SessionInfoContract> .InvokeOperationAsync( async() => await this.client.GetInfoAsync(SessionLauncherClient.EndpointPrefix, attachInfo.SessionId).ConfigureAwait(false), (e, r) => { var remainingTime = GetRemainingTime(timeout, startTime); if ((e is EndpointNotFoundException || (e is CommunicationException && !(e is FaultException <SessionFault>))) && remainingTime > TimeSpan.Zero) { Utility.SafeCloseCommunicateObject(this.client); this.client = new SessionLauncherClient(attachInfo, this.binding); this.client.InnerChannel.OperationTimeout = remainingTime; } else { r.MaxRetryCount = 0; } return(Task.CompletedTask); }, retry) .ConfigureAwait(false)); } return(info); }
/// <summary> /// Get requests from the local cache and spawn a thread to process /// them. /// </summary> /// <remarks> /// Can add throttling logic in the method, but now no need, because /// broker proxy doesn't hit limit of CPU, Memory or Network. /// </remarks> private void MessageProcessor() { try { while (true) { this.semaphoreForResponse.WaitOne(); IEnumerable <CloudQueueMessage> messages; if (this.responseCache.TryDequeue(out messages)) { this.semaphoreForWorker.WaitOne(); ThreadPool.QueueUserWorkItem((s) => { this.ProcessMessages(messages); }); } } } catch (Exception e) { SessionBase.TraceSource.TraceInformation( SoaHelper.CreateTraceMessage( "Proxy", "MessageProcessor", string.Format("Error occurs, {0}", e))); } }
/// <summary> /// Start the timer. /// </summary> private void TriggerTimer() { if (this.stop) { lock (this.timerStopLock) { if (this.stop) { this.timerStopped = true; BrokerTracing.TraceInfo( SoaHelper.CreateTraceMessage( "MessageSender.Worker", "TriggerTimer", "Worker stops.")); return; } else { this.timerStopped = false; } } } try { BrokerTracing.TraceInfo( SoaHelper.CreateTraceMessage( "MessageSender.Worker", "TriggerTimer", "Timer triggered with sleep time {0}.", this.sleepPeriod)); this.timer.Change(this.sleepPeriod, Timeout.Infinite); if (this.sleepPeriod == 0) { this.sleepPeriod = MinSleepTime; } else { this.sleepPeriod *= 2; if (this.sleepPeriod > MaxSleepTime) { this.sleepPeriod = MaxSleepTime; } } } catch (NullReferenceException) { TraceUtils.TraceWarning( "MessageSender.Worker", "TriggerTimer", "NullReferenceException occurs when timer is being disposed."); } catch (Exception e) { TraceUtils.TraceError("MessageSender.Worker", "TriggerTimer", "Error occurs, {0}", e); } }
/// <summary> /// Initializes a new instance of the SessionLauncherClient class. /// </summary> /// <param name="uri">the session launcher EPR</param> /// <param name="binding">indicating the binding</param> public SessionLauncherClient(Uri uri, Binding binding, bool useInternalChannel) : base(binding ?? GetBinding(useInternalChannel), GetEndpoint(uri, useInternalChannel)) { if (!SoaHelper.IsOnAzure()) { this.ClientCredentials.Windows.AllowedImpersonationLevel = TokenImpersonationLevel.Impersonation; } }
/// <summary> /// cleanup the stake session data. /// </summary> /// <param name="isStaleSessionCallback">the callback to judge whether </param> public static async Task CleanupStaleSessionData(IsStaleSessionCallback isStaleSessionCallback, string connectString) { if (!SoaHelper.IsOnAzure()) { // TODO: on azure, about MSMQ await BrokerQueueFactory.CleanupStalePersistedData("azurequeue", isStaleSessionCallback, connectString); } }
/// <summary> /// Process a collection of queue messages. /// </summary> /// <param name="messages">collection of the queue messages</param> private void ProcessMessages(IEnumerable <CloudQueueMessage> messages) { SessionBase.TraceSource.TraceInformation( SoaHelper.CreateTraceMessage( "Proxy", "ProcessMessages", string.Format("Process {0} messages.", messages.Count <CloudQueueMessage>()))); messages.AsParallel <CloudQueueMessage>().ForAll <CloudQueueMessage>( (responseQueueMessage) => { Message response = null; try { SessionBase.TraceSource.TraceInformation( string.Format("SOA broker proxy perf1 - {0}", DateTime.UtcNow.TimeOfDay.TotalSeconds)); response = this.responseStorageClient.GetWcfMessageFromQueueMessage(responseQueueMessage); var qkey = Tuple.Create(SoaHelper.GetClientDataHeaderFromMessage(response)); if (!this.responseMessageQueues.ContainsKey(qkey)) { lock (this.responseMessageQueues) { if (!this.responseMessageQueues.ContainsKey(qkey)) { this.responseMessageQueues.Add(qkey, new ConcurrentQueue <Message>()); } } } this.responseMessageQueues[qkey].Enqueue(response); UniqueId messageId = SoaHelper.GetMessageId(response); SessionBase.TraceSource.TraceInformation( SoaHelper.CreateTraceMessage( "Proxy", "Response received inqueue", string.Empty, messageId, "Response message in queue")); // do not delete the message from the queue here, depends on the long invisable timeout and hourly cleanup // this.responseStorageClient.DeleteMessageAsync(responseQueueMessage, messageId); } catch (Exception e) { SessionBase.TraceSource.TraceInformation( SoaHelper.CreateTraceMessage( "Proxy", "ProcessMessages", string.Format("Error occurs {0}", e))); } }); this.semaphoreForWorker.Release(); }
/// <summary> /// Initializes a new instance of the DataServiceAgent class /// </summary> /// <param name="uri">data service uri</param> public DataServiceAgent(Uri uri) : base(GetBinding(uri), GetEndpoint(uri)) { // For common data on Azure, none secure binding is used if (!SoaHelper.IsOnAzure()) { this.ClientCredentials.Windows.AllowedImpersonationLevel = TokenImpersonationLevel.Impersonation; } }
internal static string GenerateBrokerLauncherAadEpr(string endpointPrefix, string machineName) { if (endpointPrefix.Equals(NettcpPrefix, StringComparison.InvariantCultureIgnoreCase)) { return(SoaHelper.GetBrokerLauncherAadAddress(machineName)); } throw new ArgumentException("AAD only support net.tcp"); }
/// <summary> /// Check access for incoming call /// </summary> /// <param name="operationContext">indicating the operation context</param> /// <returns>returns if incoming user is system</returns> protected override bool CheckAccessCore(OperationContext operationContext) { if (SoaHelper.IsOnAzure()) { return(true); } // Bug 6152: Only allow system account to use this service return(operationContext.ServiceSecurityContext.WindowsIdentity.IsSystem); }
protected override bool CheckAccessCore(OperationContext operationContext) { if (SoaHelper.IsOnAzure()) { // Skip it in the Azure cluster. return(true); } return(ServiceSecurityContext.Current.WindowsIdentity.User == this.allowedUser); }
/// <summary> /// Creates a new client /// </summary> private BrokerManagementServiceClient CreateClient() { BrokerManagementServiceClient client = new BrokerManagementServiceClient( BindingHelper.HardCodedBrokerManagementServiceBinding, new EndpointAddress(SoaHelper.GetBrokerManagementServiceAddress(this.brokerProcess.Id))); client.InnerChannel.OperationTimeout = operationTimeoutForBrokerManagementService; return(client); }
public static Guid GetMessageIdFromMessage(Message message) { Guid guid = Guid.Empty; UniqueId id = SoaHelper.GetMessageId(message); if (id != null) { id.TryGetGuid(out guid); } return(guid); }
/// <summary> /// Get the endpoint Uri for session launcher /// </summary> /// <param name="headnode">the headnode name</param> /// <param name="binding">indicating the binding</param> /// <param name="useInternalChannel">If connect to Session Launcher via internal channel</param> /// <returns>the SessionLauncher EPR</returns> public static Uri GetSessionLauncher(string headnode, Binding binding, bool useInternalChannel) { if (LocalSession.LocalBroker) { return(new Uri(SessionLauncherNetPipeAddress)); } else { return(new Uri((useInternalChannel || SoaHelper.IsCurrentUserLocal()) ? SoaHelper.GetSessionLauncherInternalAddress(headnode, binding) : SoaHelper.GetSessionLauncherAddress(headnode, binding))); } }