internal static async Task <ReceivingAmqpLink> OpenReceivingAmqpLinkAsync(
DeviceIdentity deviceIdentity,
AmqpSession amqpSession,
byte?senderSettleMode,
byte?receiverSettleMode,
string deviceTemplate,
string moduleTemplate,
string linkSuffix,
string CorrelationId,
TimeSpan timeout
)
{
if (Logging.IsEnabled)
{
Logging.Enter(typeof(AmqpLinkHelper), deviceIdentity, $"{nameof(OpenReceivingAmqpLinkAsync)}");
}
uint prefetchCount = deviceIdentity.AmqpTransportSettings.PrefetchCount;
AmqpLinkSettings amqpLinkSettings = new AmqpLinkSettings
{
LinkName = CommonResources.GetNewStringGuid(linkSuffix),
Role = true,
TotalLinkCredit = prefetchCount,
AutoSendFlow = prefetchCount > 0,
Source = new Source()
{
Address = BuildLinkAddress(deviceIdentity, deviceTemplate, moduleTemplate)
},
Target = new Target()
{
Address = deviceIdentity.IotHubConnectionString.DeviceId
}
};
amqpLinkSettings.SndSettleMode = senderSettleMode;
amqpLinkSettings.RcvSettleMode = receiverSettleMode;
amqpLinkSettings.AddProperty(IotHubAmqpProperty.TimeoutName, timeout.TotalMilliseconds);
amqpLinkSettings.AddProperty(IotHubAmqpProperty.ClientVersion, deviceIdentity.ProductInfo.ToString());
amqpLinkSettings.AddProperty(IotHubAmqpProperty.ApiVersion, ClientApiVersionHelper.ApiVersionString);
if (CorrelationId != null)
{
amqpLinkSettings.AddProperty(IotHubAmqpProperty.ChannelCorrelationId, CorrelationId);
}
ReceivingAmqpLink receivingLink = new ReceivingAmqpLink(amqpLinkSettings);
receivingLink.AttachTo(amqpSession);
await receivingLink.OpenAsync(timeout).ConfigureAwait(false);
if (Logging.IsEnabled)
{
Logging.Exit(typeof(AmqpLinkHelper), deviceIdentity, $"{nameof(OpenReceivingAmqpLinkAsync)}");
}
return(receivingLink);
}
private void StartReceiver()
{
Task.Run(async() =>
{
var tfactory = new AmqpConnectionFactory();
var connection = await tfactory.OpenConnectionAsync("amqp://localhost:5672", TimeSpan.FromSeconds(10));
var session = connection.CreateSession(CreateSessionSettings());
var receicerSettings = new AmqpLinkSettings
{
LinkName = $"receiver-{DateTime.UtcNow.Ticks}",
Role = true,
Source = new Source
{
Address = QueueName,
//DynamicNodeProperties = CreateProperties(),
//Value = "sourceValue",
Durable = 1
},
Properties = CreateProperties()
};
var receiver = new ReceivingAmqpLink(session, receicerSettings);
await Task.WhenAll(
session.OpenAsync(session.DefaultOpenTimeout),
receiver.OpenAsync(receiver.DefaultOpenTimeout));
while (true)
{
AmqpMessage message = await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(20));
if (message != null)
{
receiver.DisposeDelivery(message, true, AmqpConstants.AcceptedOutcome);
ReceiveMessage(message);
}
}
});
}
async Task RunClientAsync(string address)
{
AmqpConnectionFactory factory = new AmqpConnectionFactory();
factory.Settings.TransportProviders.Add(
new TlsTransportProvider(
new TlsTransportSettings()
{
CertificateValidationCallback = (a, b, c, d) => true
},
AmqpVersion.V100));
AmqpConnection connection = await factory.OpenConnectionAsync(address);
AmqpSession session = connection.CreateSession(new AmqpSessionSettings());
await session.OpenAsync(TimeSpan.FromSeconds(20));
SendingAmqpLink sLink = new SendingAmqpLink(session, AmqpUtils.GetLinkSettings(true, queue, SettleMode.SettleOnSend));
await sLink.OpenAsync(TimeSpan.FromSeconds(20));
AmqpMessage message = AmqpMessage.Create(new AmqpValue()
{
Value = "AmqpConnectionFactoryTest"
});
Outcome outcome = await sLink.SendMessageAsync(message, EmptyBinary, NullBinary, TimeSpan.FromSeconds(10));
Assert.Equal(Accepted.Code, outcome.DescriptorCode);
ReceivingAmqpLink rLink = new ReceivingAmqpLink(session, AmqpUtils.GetLinkSettings(false, queue, SettleMode.SettleOnDispose, 10));
await rLink.OpenAsync(TimeSpan.FromSeconds(20));
var receivedMessage = await rLink.ReceiveMessageAsync(TimeSpan.FromSeconds(20));
Assert.NotNull(receivedMessage);
outcome = await rLink.DisposeMessageAsync(receivedMessage.DeliveryTag, new Accepted(), false, TimeSpan.FromSeconds(20));
Assert.Equal(Accepted.Code, outcome.DescriptorCode);
await connection.CloseAsync(TimeSpan.FromSeconds(20));
}
private static void TestLocalReceiver()
{
var tfactory = new AmqpConnectionFactory();
var connection = tfactory.OpenConnectionAsync("amqp://localhost:5672", TimeSpan.FromSeconds(10)).Result;
var session = connection.CreateSession(new AmqpSessionSettings());
var receicerSettings = new AmqpLinkSettings
{
LinkName = $"receiver-{DateTime.UtcNow.Ticks}",
Role = true,
TotalLinkCredit = 300,
Source = new Source
{
Address = QueueName
},
Target = new Target()
};
var receiver = new ReceivingAmqpLink(session, receicerSettings);
Task.WhenAll(
session.OpenAsync(TimeSpan.FromSeconds(30)),
receiver.OpenAsync(TimeSpan.FromSeconds(30))).Wait();
Console.WriteLine("Listening");
while (true)
{
AmqpMessage message = receiver.ReceiveMessageAsync(receiver.DefaultOpenTimeout).Result;
if (message != null)
{
receiver.DisposeDelivery(message, true, AmqpConstants.AcceptedOutcome);
DisplayMessage(new StreamReader(message.BodyStream).ReadToEnd());
}
}
}
private static async Task <AmqpIoTReceivingLink> OpenReceivingAmqpLinkAsync(
DeviceIdentity deviceIdentity,
AmqpSession amqpSession,
byte?senderSettleMode,
byte?receiverSettleMode,
string deviceTemplate,
string moduleTemplate,
string linkSuffix,
string correlationId,
TimeSpan timeout)
{
if (Logging.IsEnabled)
{
Logging.Enter(typeof(AmqpIoTSession), deviceIdentity, $"{nameof(OpenReceivingAmqpLinkAsync)}");
}
uint prefetchCount = deviceIdentity.AmqpTransportSettings.PrefetchCount;
AmqpLinkSettings amqpLinkSettings = new AmqpLinkSettings
{
LinkName = linkSuffix,
Role = true,
TotalLinkCredit = prefetchCount,
AutoSendFlow = prefetchCount > 0,
Source = new Source()
{
Address = BuildLinkAddress(deviceIdentity, deviceTemplate, moduleTemplate)
},
Target = new Target()
{
Address = deviceIdentity.IotHubConnectionString.DeviceId
}
};
amqpLinkSettings.SndSettleMode = senderSettleMode;
amqpLinkSettings.RcvSettleMode = receiverSettleMode;
amqpLinkSettings.AddProperty(AmqpIoTErrorAdapter.TimeoutName, timeout.TotalMilliseconds);
amqpLinkSettings.AddProperty(AmqpIoTErrorAdapter.ClientVersion, deviceIdentity.ProductInfo.ToString());
amqpLinkSettings.AddProperty(AmqpIoTErrorAdapter.ApiVersion, ClientApiVersionHelper.ApiVersionString);
if (!deviceIdentity.AmqpTransportSettings.AuthenticationChain.IsNullOrWhiteSpace())
{
amqpLinkSettings.AddProperty(AmqpIoTErrorAdapter.AuthChain, deviceIdentity.AmqpTransportSettings.AuthenticationChain);
}
if (correlationId != null)
{
amqpLinkSettings.AddProperty(AmqpIoTErrorAdapter.ChannelCorrelationId, correlationId);
}
try
{
ReceivingAmqpLink receivingLink = new ReceivingAmqpLink(amqpLinkSettings);
receivingLink.AttachTo(amqpSession);
await receivingLink.OpenAsync(timeout).ConfigureAwait(false);
return(new AmqpIoTReceivingLink(receivingLink));
}
catch (Exception e) when(!e.IsFatal())
{
Exception ex = AmqpIoTExceptionAdapter.ConvertToIoTHubException(e, amqpSession);
if (ReferenceEquals(e, ex))
{
throw;
}
else
{
if (ex is AmqpIoTResourceException)
{
amqpSession.SafeClose();
throw new IotHubCommunicationException(ex.Message, ex);
}
throw ex;
}
}
finally
{
if (Logging.IsEnabled)
{
Logging.Exit(typeof(AmqpIoTSession), deviceIdentity, $"{nameof(OpenReceivingAmqpLinkAsync)}");
}
}
}
async Task <ReceivingAmqpLink> CreateLinkAsync(TimeSpan timeout)
{
var amqpEventHubClient = ((AmqpEventHubClient)this.EventHubClient);
var timeoutHelper = new TimeoutHelper(timeout);
AmqpConnection connection = await amqpEventHubClient.ConnectionManager.GetOrCreateAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
// Authenticate over CBS
var cbsLink = connection.Extensions.Find <AmqpCbsLink>();
ICbsTokenProvider cbsTokenProvider = amqpEventHubClient.CbsTokenProvider;
Uri address = new Uri(amqpEventHubClient.ConnectionStringBuilder.Endpoint, this.Path);
string audience = address.AbsoluteUri;
string resource = address.AbsoluteUri;
var expiresAt = await cbsLink.SendTokenAsync(cbsTokenProvider, address, audience, resource, new[] { ClaimConstants.Listen }, timeoutHelper.RemainingTime()).ConfigureAwait(false);
AmqpSession session = null;
try
{
// Create our Session
var sessionSettings = new AmqpSessionSettings {
Properties = new Fields()
};
session = connection.CreateSession(sessionSettings);
await session.OpenAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
FilterSet filterMap = null;
var filters = this.CreateFilters();
if (filters != null && filters.Count > 0)
{
filterMap = new FilterSet();
foreach (var filter in filters)
{
filterMap.Add(filter.DescriptorName, filter);
}
}
// Create our Link
var linkSettings = new AmqpLinkSettings
{
Role = true,
TotalLinkCredit = (uint)this.PrefetchCount,
AutoSendFlow = this.PrefetchCount > 0
};
linkSettings.AddProperty(AmqpClientConstants.EntityTypeName, (int)MessagingEntityType.ConsumerGroup);
linkSettings.Source = new Source {
Address = address.AbsolutePath, FilterSet = filterMap
};
linkSettings.Target = new Target {
Address = this.ClientId
};
linkSettings.SettleType = SettleMode.SettleOnSend;
// Receiver metrics enabled?
if (this.ReceiverRuntimeMetricEnabled)
{
linkSettings.DesiredCapabilities = new Multiple <AmqpSymbol>(new List <AmqpSymbol>
{
AmqpClientConstants.EnableReceiverRuntimeMetricName
});
}
if (this.Epoch.HasValue)
{
linkSettings.AddProperty(AmqpClientConstants.AttachEpoch, this.Epoch.Value);
}
if (!string.IsNullOrWhiteSpace(this.Identifier))
{
linkSettings.AddProperty(AmqpClientConstants.ReceiverIdentifierName, this.Identifier);
}
var link = new ReceivingAmqpLink(linkSettings);
linkSettings.LinkName = $"{amqpEventHubClient.ContainerId};{connection.Identifier}:{session.Identifier}:{link.Identifier}";
link.AttachTo(session);
await link.OpenAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
var activeClientLink = new ActiveClientLink(
link,
audience, // audience
this.EventHubClient.ConnectionStringBuilder.Endpoint.AbsoluteUri, // endpointUri
new[] { ClaimConstants.Listen },
true,
expiresAt);
this.clientLinkManager.SetActiveLink(activeClientLink);
return(link);
}
catch
{
// Cleanup any session (and thus link) in case of exception.
session?.SafeClose();
throw;
}
}