public AmqpServiceClient(AmqpEventHubClient eventHubClient, string address)
: base("AmqpServiceClient-" + StringUtility.GetRandomString())
{
this.eventHubClient = eventHubClient;
Address = address;
link = new FaultTolerantAmqpObject <RequestResponseAmqpLink>(OpenLinkAsync, rrlink => rrlink.CloseAsync(TimeSpan.FromSeconds(10)));
}
/// <summary>
/// Creates a new instance of the Event Hubs client using the specified endpoint, entity path, and token provider.
/// </summary>
/// <param name="endpointAddress">Fully qualified domain name for Event Hubs. Most likely, {yournamespace}.servicebus.windows.net</param>
/// <param name="entityPath">Event Hub path</param>
/// <param name="tokenProvider">Token provider which will generate security tokens for authorization.</param>
/// <param name="operationTimeout">Operation timeout for Event Hubs operations.</param>
/// <param name="transportType">Transport type on connection.</param>
/// <returns></returns>
public static EventHubClient Create(
Uri endpointAddress,
string entityPath,
ITokenProvider tokenProvider,
TimeSpan?operationTimeout = null,
TransportType transportType = TransportType.Amqp)
{
if (endpointAddress == null)
{
throw Fx.Exception.ArgumentNull(nameof(endpointAddress));
}
if (string.IsNullOrWhiteSpace(entityPath))
{
throw Fx.Exception.ArgumentNullOrWhiteSpace(nameof(entityPath));
}
if (tokenProvider == null)
{
throw Fx.Exception.ArgumentNull(nameof(tokenProvider));
}
EventHubsEventSource.Log.EventHubClientCreateStart(endpointAddress.Host, entityPath);
EventHubClient eventHubClient = new AmqpEventHubClient(
endpointAddress,
entityPath,
tokenProvider,
operationTimeout ?? ClientConstants.DefaultOperationTimeout,
transportType);
EventHubsEventSource.Log.EventHubClientCreateStop(eventHubClient.ClientId);
return(eventHubClient);
}
public AmqpServiceClient(AmqpEventHubClient eventHubClient, string address)
: base("AmqpServiceClient-" + StringUtility.GetRandomString())
{
this.eventHubClient = eventHubClient;
this.Address = address;
this.link = new FaultTolerantAmqpObject <RequestResponseAmqpLink>(t => this.OpenLinkAsync(t), rrlink => rrlink.CloseAsync(TimeSpan.FromSeconds(10)));
this.clientLinkManager = new ActiveClientLinkManager(this.eventHubClient);
}
public void GetPartitionPropertiesAsyncValidatesThePartition(string partition)
{
ExactTypeConstraint typeConstraint = partition is null ? Throws.ArgumentNullException : Throws.ArgumentException;
var client = new AmqpEventHubClient("my.eventhub.com", "somePath", Mock.Of <TokenCredential>(), new EventHubClientOptions(), Mock.Of <EventHubRetryPolicy>());
Assert.That(async() => await client.GetPartitionPropertiesAsync(partition, CancellationToken.None), typeConstraint);
}
public void CloseRespectsTheCancellationToken()
{
var client = new AmqpEventHubClient("my.eventhub.com", "somePath", Mock.Of <TokenCredential>(), new EventHubClientOptions(), Mock.Of <EventHubRetryPolicy>());
var cancellationSource = new CancellationTokenSource();
cancellationSource.Cancel();
Assert.That(async() => await client.CloseAsync(cancellationSource.Token), Throws.InstanceOf <TaskCanceledException>());
}
public async Task GetPartitionPropertiesAsyncValidatesClosed()
{
using var cancellationSource = new CancellationTokenSource();
var client = new AmqpEventHubClient("my.eventhub.com", "somePath", Mock.Of <TokenCredential>(), new EventHubClientOptions(), Mock.Of <EventHubRetryPolicy>());
await client.CloseAsync(cancellationSource.Token);
Assert.That(async() => await client.GetPartitionPropertiesAsync("Fred", cancellationSource.Token), Throws.InstanceOf <EventHubsObjectClosedException>());
}
public void GetPartitionPropertiesAsyncRespectsTheCancellationTokenIfSetWhenCalled()
{
using var cancellationSource = new CancellationTokenSource();
cancellationSource.Cancel();
var client = new AmqpEventHubClient("my.eventhub.com", "somePath", Mock.Of <TokenCredential>(), new EventHubClientOptions(), Mock.Of <EventHubRetryPolicy>());
Assert.That(async() => await client.GetPartitionPropertiesAsync("Fred", cancellationSource.Token), Throws.InstanceOf <TaskCanceledException>());
}
public async Task CloseMarksTheClientAsClosed()
{
var client = new AmqpEventHubClient("my.eventhub.com", "somePath", Mock.Of <TokenCredential>(), new EventHubClientOptions(), Mock.Of <EventHubRetryPolicy>());
Assert.That(client.Closed, Is.False, "The client should not be closed on creation");
await client.CloseAsync(CancellationToken.None);
Assert.That(client.Closed, Is.True, "The client should be marked as closed after closing");
}
public async Task DisposeClosesTheClient()
{
var client = new AmqpEventHubClient("my.eventhub.com", "somePath", Mock.Of <TokenCredential>(), new EventHubClientOptions(), Mock.Of <EventHubRetryPolicy>());
Assert.That(client.Closed, Is.False, "The client should not be closed on creation");
await client.DisposeAsync();
Assert.That(client.Closed, Is.True, "The client should be closed after disposal");
}
public async Task CreateConsumerValidatesClosed()
{
using var cancellationSource = new CancellationTokenSource();
var mockRetryPolicy = Mock.Of <EventHubRetryPolicy>();
var client = new AmqpEventHubClient("my.eventhub.com", "somePath", Mock.Of <TokenCredential>(), new EventHubClientOptions(), mockRetryPolicy);
await client.CloseAsync(cancellationSource.Token);
Assert.That(() => client.CreateConsumer("group", "0", EventPosition.Earliest, new EventHubConsumerOptions(), mockRetryPolicy), Throws.InstanceOf <EventHubsObjectClosedException>());
}
/// <summary>
/// Creates a new instance of the Event Hubs client using the specified connection string builder.
/// </summary>
/// <param name="csb"></param>
/// <returns></returns>
public static EventHubClient Create(EventHubsConnectionStringBuilder csb)
{
Guard.ArgumentNotNull(nameof(csb), csb);
Guard.ArgumentNotNullOrWhiteSpace(nameof(csb.EntityPath), csb.EntityPath);
EventHubsEventSource.Log.EventHubClientCreateStart(csb.Endpoint.Host, csb.EntityPath);
EventHubClient eventHubClient = new AmqpEventHubClient(csb);
EventHubsEventSource.Log.EventHubClientCreateStop(eventHubClient.ClientId);
return(eventHubClient);
}
public void UpdateRetryPolicyUpdatesTheRetryPolicy()
{
var newPolicy = new BasicRetryPolicy(new RetryOptions {
Delay = TimeSpan.FromMilliseconds(50)
});
var client = new AmqpEventHubClient("my.eventhub.com", "somePath", Mock.Of <TokenCredential>(), new EventHubClientOptions(), Mock.Of <EventHubRetryPolicy>());
Assert.That(GetActiveRetryPolicy(client), Is.Not.SameAs(newPolicy), "The initial policy should be a unique instance");
client.UpdateRetryPolicy(newPolicy);
Assert.That(GetActiveRetryPolicy(client), Is.SameAs(newPolicy), "The updated policy should match");
}
static EventHubClient Create(EventHubsConnectionStringBuilder csb)
{
if (string.IsNullOrWhiteSpace(csb.EntityPath))
{
throw Fx.Exception.ArgumentNullOrWhiteSpace(nameof(csb.EntityPath));
}
EventHubsEventSource.Log.EventHubClientCreateStart(csb.Endpoint.Host, csb.EntityPath);
EventHubClient eventHubClient = new AmqpEventHubClient(csb);
EventHubsEventSource.Log.EventHubClientCreateStop(eventHubClient.ClientId);
return(eventHubClient);
}
public AmqpServiceClient(AmqpEventHubClient eventHubClient, string address)
: base(nameof(AmqpServiceClient <T>) + StringUtility.GetRandomString())
{
if (!typeof(T).GetTypeInfo().IsInterface)
{
throw new NotSupportedException("Not an interface");
}
this.eventHubClient = eventHubClient;
this.Address = address;
this.Channel = new AmqpClientProxy(this, typeof(T)).GetChannel();
this.link = new FaultTolerantAmqpObject <RequestResponseAmqpLink>(t => this.OpenLinkAsync(t), rrlink => rrlink.CloseAsync(TimeSpan.FromSeconds(10)));
this.clientLinkManager = new ActiveClientLinkManager(this.eventHubClient);
}
public void UpdateRetryPolicyUpdatesTheOperationTimeout()
{
var initialPolicy = new BasicRetryPolicy(new RetryOptions {
TryTimeout = TimeSpan.FromSeconds(17)
});
TimeSpan initialTimeout = initialPolicy.CalculateTryTimeout(0);
var client = new AmqpEventHubClient("my.eventhub.com", "somePath", Mock.Of <TokenCredential>(), new EventHubClientOptions(), initialPolicy);
Assert.That(GetTimeout(client), Is.EqualTo(initialTimeout), "The initial timeout should match");
var newPolicy = new BasicRetryPolicy(new RetryOptions {
TryTimeout = TimeSpan.FromMilliseconds(50)
});
TimeSpan newTimeout = newPolicy.CalculateTryTimeout(0);
client.UpdateRetryPolicy(newPolicy);
Assert.That(GetTimeout(client), Is.EqualTo(newTimeout), "The updated timeout should match");
}
/// <summary>
/// Creates a new instance of the Event Hubs client using the specified endpoint, entity path, and token provider.
/// </summary>
/// <param name="endpointAddress">Fully qualified domain name for Event Hubs. Most likely, {yournamespace}.servicebus.windows.net</param>
/// <param name="entityPath">Event Hub path</param>
/// <param name="tokenProvider">Token provider which will generate security tokens for authorization.</param>
/// <param name="operationTimeout">Operation timeout for Event Hubs operations.</param>
/// <param name="transportType">Transport type on connection.</param>
/// <returns></returns>
public static EventHubClient CreateWithTokenProvider(
Uri endpointAddress,
string entityPath,
ITokenProvider tokenProvider,
TimeSpan?operationTimeout = null,
TransportType transportType = TransportType.Amqp)
{
Guard.ArgumentNotNull(nameof(endpointAddress), endpointAddress);
Guard.ArgumentNotNull(nameof(tokenProvider), tokenProvider);
Guard.ArgumentNotNullOrWhiteSpace(nameof(entityPath), entityPath);
EventHubsEventSource.Log.EventHubClientCreateStart(endpointAddress.Host, entityPath);
EventHubClient eventHubClient = new AmqpEventHubClient(
endpointAddress,
entityPath,
tokenProvider,
operationTimeout ?? ClientConstants.DefaultOperationTimeout,
transportType);
EventHubsEventSource.Log.EventHubClientCreateStop(eventHubClient.ClientId);
return(eventHubClient);
}
/// <summary>
/// Gets the active operation timeout for the given client, using the
/// private field.
/// </summary>
///
private static TimeSpan GetTimeout(AmqpEventHubClient target) =>
(TimeSpan)
typeof(AmqpEventHubClient)
.GetField("_tryTimeout", BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(target);
/// <summary>
/// Gets the active retry policy for the given client, using the
/// private field.
/// </summary>
///
private static EventHubRetryPolicy GetActiveRetryPolicy(AmqpEventHubClient target) =>
(EventHubRetryPolicy)
typeof(AmqpEventHubClient)
.GetField("_retryPolicy", BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(target);
public void UpdateRetryPolicyValidatesTheRetryPolicy()
{
var client = new AmqpEventHubClient("my.eventhub.com", "somePath", Mock.Of <TokenCredential>(), new EventHubClientOptions(), Mock.Of <EventHubRetryPolicy>());
Assert.That(() => client.UpdateRetryPolicy(null), Throws.ArgumentNullException);
}
