/// <summary>
/// Acquires a JWT token for use with the Event Hubs management client.
/// </summary>
///
/// <returns>The token to use for management operations against the Event Hubs Live test namespace.</returns>
///
public async Task <string> AquireManagementTokenAsync()
{
ManagementToken token = s_managementToken;
// If there was no current token, or it is within the buffer for expiration, request a new token.
// There is a benign race condition here, where there may be multiple requests in-flight for a new token. Since
// this is test infrastructure, just allow the acquired token to replace the current one without attempting to
// coordinate or ensure that the most recent is kept.
if ((token == null) || (token.ExpiresOn <= DateTimeOffset.UtcNow.Add(CredentialRefreshBuffer)))
{
var credential = new ClientCredential(TestEnvironment.EventHubsClient, TestEnvironment.EventHubsSecret);
var context = new AuthenticationContext($"https://login.windows.net/{ TestEnvironment.EventHubsTenant }");
AuthenticationResult result = await context.AcquireTokenAsync("https://management.core.windows.net/", credential).ConfigureAwait(false);
if ((string.IsNullOrEmpty(result?.AccessToken)))
{
throw new AuthenticationException("Unable to acquire an Active Directory token for the Event Hubs management client.");
}
token = new ManagementToken(result.AccessToken, result.ExpiresOn);
Interlocked.Exchange(ref s_managementToken, token);
}
return(token.Token);
}
/// <summary>
/// Acquires a JWT token for use with the Service Bus management client.
/// </summary>
///
/// <returns>The token to use for management operations against the Service Bus Live test namespace.</returns>
///
private static async Task <string> AquireManagementTokenAsync()
{
ManagementToken token = s_managementToken;
// If there was no current token, or it is within the buffer for expiration, request a new token.
// There is a benign race condition here, where there may be multiple requests in-flight for a new token. Since
// this is test infrastructure, just allow the acquired token to replace the current one without attempting to
// coordinate or ensure that the most recent is kept.
if ((token == null) || (token.ExpiresOn <= DateTimeOffset.UtcNow.Add(CredentialRefreshBuffer)))
{
var credential = new ClientCredential(ServiceBusTestEnvironment.Instance.ClientId, ServiceBusTestEnvironment.Instance.ClientSecret);
var context = new AuthenticationContext($"{ ServiceBusTestEnvironment.Instance.AuthorityHostUrl }{ ServiceBusTestEnvironment.Instance.TenantId }");
var result = await context.AcquireTokenAsync(ServiceBusTestEnvironment.Instance.ServiceManagementUrl, credential);
if ((string.IsNullOrEmpty(result?.AccessToken)))
{
throw new AuthenticationException("Unable to acquire an Active Directory token for the Service Bus management client.");
}
token = new ManagementToken(result.AccessToken, result.ExpiresOn);
Interlocked.Exchange(ref s_managementToken, token);
}
return(token.Token);
}
/// <summary>
/// Maps the OData service.
/// </summary>
/// <param name="config">The current HTTP configuration.</param>
/// <param name="builder">The EDM model builder.</param>
/// <param name="routeName">The name of the route (<see cref="DataObjectRoutingConventions.DefaultRouteName"/> be default).</param>
/// <param name="routePrefix">The route prefix (<see cref="DataObjectRoutingConventions.DefaultRoutePrefix"/> be default).</param>
/// <returns>OData service registration token.</returns>
public static ManagementToken MapODataServiceDataObjectRoute(
this HttpConfiguration config,
IDataObjectEdmModelBuilder builder,
string routeName = DataObjectRoutingConventions.DefaultRouteName,
string routePrefix = DataObjectRoutingConventions.DefaultRoutePrefix)
{
Contract.Requires <ArgumentNullException>(config != null);
Contract.Requires <ArgumentNullException>(builder != null);
Contract.Requires <ArgumentNullException>(routeName != null);
Contract.Requires <ArgumentException>(routeName != string.Empty);
Contract.Requires <ArgumentNullException>(routePrefix != null);
Contract.Requires <ArgumentException>(routePrefix != string.Empty);
// Model.
var model = builder.Build();
// Routing.
var pathHandler = new ExtendedODataPathHandler();
var routingConventions = DataObjectRoutingConventions.CreateDefault();
var route = config.MapODataServiceRoute(routeName, routePrefix, model, pathHandler, routingConventions);
// Controllers.
var registeredActivator = (IHttpControllerActivator)config.Services.GetService(typeof(IHttpControllerActivator));
var fallbackActivator = registeredActivator ?? new DefaultHttpControllerActivator();
config.Services.Replace(typeof(IHttpControllerActivator), new DataObjectControllerActivator(fallbackActivator));
// Formatters.
var customODataSerializerProvider = new CustomODataSerializerProvider();
var extendedODataDeserializerProvider = new ExtendedODataDeserializerProvider();
var odataFormatters = ODataMediaTypeFormatters.Create(customODataSerializerProvider, extendedODataDeserializerProvider);
config.Formatters.InsertRange(0, odataFormatters);
config.Properties[typeof(CustomODataSerializerProvider)] = customODataSerializerProvider;
// Token.
var token = new ManagementToken(route, model);
config.SetODataServiceToken(token);
// Handlers.
if (config.MessageHandlers.FirstOrDefault(h => h is PostPatchHandler) == null)
{
config.MessageHandlers.Add(new PostPatchHandler());
}
return(token);
}
/// <summary>
/// Initializes a new instance of the <see cref="PerRequestUpdateEdmModelHandler"/> class.
/// </summary>
/// <param name="token">The OData Service management token.</param>
/// <param name="modelBuilder">
/// The model builder for updating model.
/// Each request EDM model associated with <paramref name="token"/> will be updated.
/// </param>
public PerRequestUpdateEdmModelHandler(ManagementToken token, IDataObjectEdmModelBuilder modelBuilder)
{
Contract.Requires <ArgumentNullException>(token != null);
Contract.Requires <ArgumentNullException>(modelBuilder != null);
// In current Microsoft implementation of OData for WebAPI, EDM model is stored
// in ODataPathRouteConstraint, but doesn't have public setter.
// In order to rebuild EDM model for different requests (e.g. authorized users),
// this handler uses reflection for private setter calling.
_edmModelProperty = typeof(ODataPathRouteConstraint).GetProperty("EdmModel");
if (_edmModelProperty == null)
{
throw new InvalidOperationException("Current OData API cannot be used for editing EDM model.");
}
_token = token;
_modelBuilder = modelBuilder;
}
private static async Task <string> AquireManagementTokenAsync()
{
var token = s_managementToken;
if ((token == null) || (token.ExpiresOn <= DateTimeOffset.UtcNow.Add(CredentialRefreshBuffer)))
{
var credential = new ClientCredential(TestUtility.EventHubsClient, TestUtility.EventHubsSecret);
var context = new AuthenticationContext($"{ TestUtility.AuthorityHost }{ TestUtility.EventHubsTenant }");
var result = await context.AcquireTokenAsync(TestUtility.ServiceManagementUrl, credential).ConfigureAwait(false);
if ((String.IsNullOrEmpty(result?.AccessToken)))
{
throw new AuthenticationException("Unable to acquire an Active Directory token for the Event Hubs management client.");
}
token = new ManagementToken(result.AccessToken, result.ExpiresOn);
Interlocked.Exchange(ref s_managementToken, token);
}
return(token.Token);
}
/// <summary>
/// Initializes a new instance of the <see cref="FunctionContainer"/> class.
/// </summary>
/// <param name="token">The OData Service token.</param>
public FunctionContainer(ManagementToken token)
{
Contract.Requires <ArgumentNullException>(token != null);
_token = token;
}
/// <summary>
/// Sets the OData Service token to the configuration for internal purposes.
/// </summary>
/// <param name="config">The current HTTP configuration.</param>
/// <param name="token">The OData Service token.</param>
private static void SetODataServiceToken(this HttpConfiguration config, ManagementToken token)
{
config.Properties[token.Route] = token;
}
