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>
/// 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));
}
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>
/// Resolve the session node from the context with infinite retries
/// </summary>
/// <returns>The resolved session node name</returns>
private async Task <string> ResolveSessionNodeWithRetries()
{
RetryManager retry = SoaHelper.GetDefaultInfinitePeriodRertyManager();
return(await RetryHelper <string> .InvokeOperationAsync(
async() => await this.context.ResolveSessionLauncherNodeAsync(),
async (e, r) =>
{
TraceHelper.TraceWarning("0", "[SchedulerHelper] Failed to ResolveSessionLauncherNodeAsync: {0}\nRetryCount = {1}", e, r.RetryCount);
await Task.CompletedTask;
},
retry));
}
/// <summary>
/// Fail a service job with the reason
/// </summary>
/// <param name="jobid">the job id</param>
/// <param name="reason">the reason string</param>
public async Task FailJob(string jobid, string reason)
{
RetryManager retry = SoaHelper.GetDefaultExponentialRetryManager();
await RetryHelper <object> .InvokeOperationAsync(
async() =>
{
await this.schedulerClient.Value.FailJobAsync(jobid, reason);
return(null);
},
async (e, r) =>
{
TraceHelper.TraceEvent(jobid, System.Diagnostics.TraceEventType.Error, "[SchedulerHelper] Exception throwed while failing job: {0}\nRetryCount = {1}", e, r.RetryCount);
await this.RenewSchedulerAdapterClientAsync();
},
retry);
}
/// <summary>
/// Gets cluster info
/// </summary>
/// <param name="keys">indicating the keys</param>
/// <returns>returns the values</returns>
public async Task <ClusterInfoContract> GetClusterInfoAsync()
{
RetryManager retry = SoaHelper.GetDefaultExponentialRetryManager();
return(await RetryHelper <ClusterInfoContract> .InvokeOperationAsync(
async() =>
{
using (BrokerIdentity identity = new BrokerIdentity())
{
identity.Impersonate();
return await this.sessionLauncherClient.Value.GetClusterInfoAsync();
}
},
async (e, r) =>
{
TraceHelper.TraceEvent(TraceEventType.Warning, "[SchedulerHelper] Failed to get cluster info, Retry:{0}, Error:{1}", r.RetryCount, e);
await this.RenewSessionLauncherClientAsync();
},
retry));
}
/// <summary>
/// Query task info
/// </summary>
private async Task StartMonitorAsync()
{
try
{
TraceHelper.TraceEvent(this.sessionid, TraceEventType.Verbose, "[AzureBatchJobMonitorEntry] Start Azure Batch Job Monitor.");
// RetryManager mgr = new RetryManager(new ExponentialRandomBackoffRetryTimer(1 * 1000, 10 * 1000));
// await mgr.InvokeWithRetryAsync(() => await batchJobMonitor.StartAsync(), ex => true);
RetryManager retry = SoaHelper.GetDefaultExponentialRetryManager();
await RetryHelper <Task> .InvokeOperationAsync(
async() =>
{
await this.batchJobMonitor.StartAsync();
return(null);
},
async (e, r) => await Task.FromResult <object>(new Func <object>(() => { TraceHelper.TraceEvent(this.sessionid, TraceEventType.Warning, "[AzureBatchJobMonitorEntry] Exception thrown when trigger start Azure Batch Job Monitor: {0} ", e, r.RetryCount); return(null); }).Invoke()),
retry);
}
catch (Exception e)
{
TraceHelper.TraceEvent(this.sessionid, TraceEventType.Warning, "[AzureBatchJobMonitorEntry] Exception thrown when trigger start Azure Batch Job Monitor: {0}", e);
}
}
/// <summary>
/// Update broker info
/// </summary>
/// <param name="sessionId">indicating the session id</param>
/// <param name="properties">indicating the key value pairs to be updated</param>
private async Task UpdateBrokerInfoInternalAsync(string sessionId, Dictionary <string, object> properties)
{
RetryManager retry = SoaHelper.GetDefaultExponentialRetryManager();
await RetryHelper <object> .InvokeOperationAsync(
async() =>
{
if (await this.schedulerClient.Value.UpdateBrokerInfoAsync(sessionId, properties).ConfigureAwait(false))
{
return(null);
}
else
{
throw new InvalidOperationException("Can not update the properties in the scheduler database for EPRs");
}
},
async (e, r) =>
{
TraceHelper.TraceEvent(sessionId, TraceEventType.Error, "[BrokerLauncher.SchedulerHelper] UpdateBrokerInfo failed: Exception = {0}\nRetryCount = {1}", e, r.RetryCount);
await this.RenewSchedulerAdapterClientAsync().ConfigureAwait(false);
},
retry).ConfigureAwait(false);
}
public async Task <SessionAllocateInfoContract> AllocateResource(SessionStartInfo startInfo, bool durable, TimeSpan timeout)
{
SessionAllocateInfoContract sessionAllocateInfo = new SessionAllocateInfoContract();
this.client.InnerChannel.OperationTimeout = timeout;
RetryManager retry = SoaHelper.GetDefaultExponentialRetryManager();
SessionBase.TraceSource.TraceEvent(TraceEventType.Verbose, 0, "[Session:Unknown] Allocating resource... IsDurable = {0}, is LocalUser = {1}", durable, startInfo.LocalUser);
DateTime startTime = DateTime.Now;
if (durable)
{
sessionAllocateInfo = await RetryHelper <SessionAllocateInfoContract> .InvokeOperationAsync(
async() => await this.client.AllocateDurableAsync(startInfo.Data, this.endpointPrefix).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(startInfo, this.binding);
this.client.InnerChannel.OperationTimeout = remainingTime;
}
else
{
r.MaxRetryCount = 0;
}
return(Task.CompletedTask);
},
retry).ConfigureAwait(false);
}
else
{
sessionAllocateInfo = await RetryHelper <SessionAllocateInfoContract> .InvokeOperationAsync(
async() => await this.client.AllocateAsync(startInfo.Data, this.endpointPrefix).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(startInfo, this.binding);
this.client.InnerChannel.OperationTimeout = remainingTime;
}
else
{
r.MaxRetryCount = 0;
}
return(Task.CompletedTask);
},
retry).ConfigureAwait(false);
}
SessionBase.TraceSource.TraceEvent(TraceEventType.Verbose, 0, "[Session:{0}] Successfully allocated resource. Eprs = {1}", sessionAllocateInfo.Id, sessionAllocateInfo.BrokerLauncherEpr == null ? string.Empty : string.Join(",", sessionAllocateInfo.BrokerLauncherEpr));
if (sessionAllocateInfo.ServiceVersion != null)
{
try
{
startInfo.Data.ServiceVersion = sessionAllocateInfo.ServiceVersion;
}
catch
{
throw new SessionException(SR.InvalidServiceVersionReturned);
}
}
if (startInfo.UseSessionPool)
{
return(sessionAllocateInfo);
}
else
{
if (!startInfo.UseInprocessBroker && (sessionAllocateInfo.BrokerLauncherEpr == null || sessionAllocateInfo.BrokerLauncherEpr.Length == 0))
{
throw new SessionException(SR.NoBrokerNodeFound);
}
return(sessionAllocateInfo);
}
}
/// <summary>
/// Build broker start information
/// </summary>
/// <param name="serviceName">indicating service name</param>
/// <param name="serviceVersion">indicating service version</param>
/// <param name="sessionId">indicating session id</param>
/// <param name="durable">indicating whether the session is durable</param>
/// <param name="attached">indicating whether the session is raised up by attaching</param>
private async Task BuildBrokerStartInfo(string serviceName, Version serviceVersion, string sessionId, bool durable, bool attached)
{
this.brokerInfo = new BrokerStartInfo();
this.brokerInfo.Headnode = this.startInfo.Headnode;
// Secure will be set to false and the following two settings are ignored
this.brokerInfo.JobOwnerSID = null;
this.brokerInfo.JobTemplateACL = null;
this.brokerInfo.PersistVersion = BrokerVersion.DefaultPersistVersion;
this.brokerInfo.SessionId = sessionId;
this.brokerInfo.Attached = attached;
this.brokerInfo.Durable = durable;
this.brokerInfo.NetworkPrefix = Constant.EnterpriseNetwork;
this.brokerInfo.ConfigurationFile = await this.FetchServiceRegistrationPath(serviceName, serviceVersion).ConfigureAwait(false);
// Bug 14892: Fetch AutoShrinkEnabled property from scheduler (via session launcher)
if (!this.isDebugModeEnabled)
{
SessionLauncherClient client = new SessionLauncherClient(await Utility.GetSessionLauncherAsync(this.startInfo, this.binding).ConfigureAwait(false), this.binding, this.startInfo.IsAadOrLocalUser);
try
{
this.brokerInfo.AutomaticShrinkEnabled = await RetryHelper <bool> .InvokeOperationAsync(
async() => Convert.ToBoolean(await client.GetSOAConfigurationAsync(Constant.AutomaticShrinkEnabled).ConfigureAwait(false)),
async (e, count) =>
{
SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[InprocBrokerAdapter] Failed to get AutomaticShrinkEnabled property via session launcher service: {0}\nRetryCount = {1}", e, count);
Utility.SafeCloseCommunicateObject(client);
client = new SessionLauncherClient(await Utility.GetSessionLauncherAsync(this.startInfo, this.binding).ConfigureAwait(false), this.binding, this.startInfo.IsAadOrLocalUser);
},
SoaHelper.GetDefaultExponentialRetryManager()).ConfigureAwait(false);
}
catch (Exception e)
{
SessionBase.TraceSource.TraceEvent(TraceEventType.Error, 0, "[InprocBrokerAdapter] Failed to get AutomaticShrinkEnabled property via session launcher service: {0}", e);
}
finally
{
Utility.SafeCloseCommunicateObject(client);
}
this.brokerInfo.EnableDiagTrace = false; // TODO: retrieve this from session
// SchedulerAdapterInternalClient schedulerAdapterClient = new SchedulerAdapterInternalClient(await this.startInfo.ResolveHeadnodeMachineAsync().ConfigureAwait(false));
/*
* ISchedulerAdapter schedulerAdapterClient = SessionServiceContainer.SchedulerAdapterInstance;
* try
* {
* this.brokerInfo.EnableDiagTrace = await RetryHelper<bool>.InvokeOperationAsync(
* async () => await
#if net40
* TaskEx.Run(
#else
* Task.Run(
#endif
* () => schedulerAdapterClient.IsDiagTraceEnabled(sessionId)).ConfigureAwait(false),
* async (e, count) =>
* {
* SessionBase.TraceSource.TraceEvent(TraceEventType.Warning, 0, "[InprocBrokerAdapter] Failed to get IsDiagTraceEnabled property via session launcher service: {0}\nRetryCount = {1}", e, count);
* var communicateObj = schedulerAdapterClient as ICommunicationObject;
* if (communicateObj != null)
* {
* Utility.SafeCloseCommunicateObject(communicateObj);
* }
*
* //schedulerAdapterClient = new SchedulerAdapterInternalClient(await this.startInfo.ResolveHeadnodeMachineAsync().ConfigureAwait(false));
* schedulerAdapterClient = SessionServiceContainer.SchedulerAdapterInstance;
* },
* SoaHelper.GetDefaultExponentialRetryManager()).ConfigureAwait(false);
* }
* catch (Exception e)
* {
* SessionBase.TraceSource.TraceEvent(TraceEventType.Error, 0, "[InprocBrokerAdapter] Failed to get IsDiagTraceEnabled property via session launcher service: {0}", e);
* }
* finally
* {
* var communicateObj = schedulerAdapterClient as ICommunicationObject;
* if (communicateObj != null)
* {
* Utility.SafeCloseCommunicateObject(communicateObj);
* }
*
* }
*/
}
}