public void RemoveAmqpUnit(AmqpUnit amqpUnit)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, amqpUnit, nameof(RemoveAmqpUnit));
}
IDeviceIdentity deviceIdentity = amqpUnit.GetDeviceIdentity();
if (deviceIdentity.IsPooling())
{
AmqpConnectionHolder amqpConnectionHolder;
lock (_lock)
{
AmqpConnectionHolder[] amqpConnectionHolders = ResolveConnectionGroup(deviceIdentity);
amqpConnectionHolder = ResolveConnectionByHashing(amqpConnectionHolders, deviceIdentity);
amqpConnectionHolder.RemoveAmqpUnit(amqpUnit);
// If the connection holder does not have any more units, the entry needs to be nullified.
if (amqpConnectionHolder.IsEmpty())
{
int index = GetDeviceIdentityIndex(deviceIdentity, amqpConnectionHolders.Length);
amqpConnectionHolders[index] = null;
amqpConnectionHolder?.Dispose();
}
}
}
if (Logging.IsEnabled)
{
Logging.Exit(this, amqpUnit, nameof(RemoveAmqpUnit));
}
}
internal async Task <IAmqpAuthenticationRefresher> CreateRefresherAsync(IDeviceIdentity deviceIdentity, CancellationToken cancellationToken)
{
if (_amqpConnection.IsClosing())
{
throw new IotHubCommunicationException("Amqp connection is disconnected.");
}
try
{
IAmqpAuthenticationRefresher amqpAuthenticator = new AmqpAuthenticationRefresher(deviceIdentity, _amqpIotCbsLink);
await amqpAuthenticator.InitLoopAsync(cancellationToken).ConfigureAwait(false);
return(amqpAuthenticator);
}
catch (Exception e) when(!e.IsFatal())
{
Exception ex = AmqpIotExceptionAdapter.ConvertToIotHubException(e, _amqpConnection);
if (ReferenceEquals(e, ex))
{
throw;
}
else
{
throw ex;
}
}
}
public async Task GetDeviceIdentityTest(
string iotHubHostName,
string clientId,
string username,
string password,
X509Certificate2 certificate,
IList <X509Certificate2> chain,
bool authRetVal,
Type expectedType)
{
var authenticator = new Mock <IAuthenticator>();
var productInfoStore = Mock.Of <IProductInfoStore>();
authenticator.Setup(a => a.AuthenticateAsync(It.IsAny <IClientCredentials>())).ReturnsAsync(authRetVal);
var deviceIdentityProvider = new DeviceIdentityProvider(authenticator.Object, new ClientCredentialsFactory(new IdentityProvider(iotHubHostName)), productInfoStore, true);
if (certificate != null)
{
deviceIdentityProvider.RegisterConnectionCertificate(certificate, chain);
}
IDeviceIdentity deviceIdentity = await deviceIdentityProvider.GetAsync(clientId, username, password, null);
Assert.IsAssignableFrom(expectedType, deviceIdentity);
}
async void Connect(IChannelHandlerContext context, ConnectPacket packet)
{
try
{
this.stateFlags = StateFlags.ProcessingConnect;
this.identity = await this.authProvider.GetAsync(
packet.DeviceId, packet.Username, packet.Password, this.capturedContext.Channel.RemoteAddress);
if (!this.identity.IsAuthenticated)
{
Console.WriteLine("ClientNotAuthenticated", $"Client ID: {packet.DeviceId}; Username: {packet.Username}", this.ChannelId);
ShutdownOnError(context, ConnectProcessingScope, new SocketIoTGatewayException(ErrorCode.AuthenticationFailed, "Authentication failed."));
return;
}
Console.WriteLine("ClientAuthenticated", this.identity.ToString(), this.ChannelId);
this.messagingBridge = await this.messagingBridgeFactory(this.identity);
this.keepAliveTimeout = this.DeriveKeepAliveTimeout(context, packet);
this.CompleteConnect(context);
}
catch (Exception e)
{
SocketIoTHubAdapter.ShutdownOnError(context, ConnectProcessingScope, e);
}
}
public AmqpUnit CreateAmqpUnit(
IDeviceIdentity deviceIdentity,
Func <MethodRequestInternal, Task> onMethodCallback,
Action <Twin, string, TwinCollection, IotHubException> twinMessageListener,
Func <string, Message, Task> onModuleMessageReceivedCallback,
Func <Message, Task> onDeviceMessageReceivedCallback,
Action onUnitDisconnected)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, deviceIdentity, nameof(CreateAmqpUnit));
}
var amqpUnit = new AmqpUnit(
deviceIdentity,
this,
onMethodCallback,
twinMessageListener,
onModuleMessageReceivedCallback,
onDeviceMessageReceivedCallback,
onUnitDisconnected);
lock (_unitsLock)
{
_amqpUnits.Add(amqpUnit);
}
if (Logging.IsEnabled)
{
Logging.Exit(this, deviceIdentity, nameof(CreateAmqpUnit));
}
return(amqpUnit);
}
public async Task SetAsync(IDeviceIdentity identity, ISessionState sessionState)
{
var state = sessionState as BlobSessionState;
if (state == null)
{
throw new ArgumentException("Cannot set Session State object that hasn't been acquired from provider.", "sessionState");
}
if (state.IsTransient)
{
return;
}
CloudBlockBlob blob = this.container.GetBlockBlobReference(identity.Id);
using (var memoryStream = new MemoryStream())
using (var streamWriter = new StreamWriter(memoryStream))
{
JsonSerializer serializer = JsonSerializer.Create(SerializerSettings);
serializer.Serialize(streamWriter, state);
streamWriter.Flush();
memoryStream.Position = 0;
AccessCondition accessCondition = state.ETag == null
? AccessCondition.GenerateIfNoneMatchCondition("*") // create
: AccessCondition.GenerateIfMatchCondition(state.ETag); // update
await blob.UploadFromStreamAsync(memoryStream, accessCondition, null, null);
state.ETag = blob.Properties.ETag;
}
}
public AmqpConnectionHolder(IDeviceIdentity deviceIdentity)
{
_deviceIdentity = deviceIdentity;
_amqpIotConnector = new AmqpIotConnector(deviceIdentity.AmqpTransportSettings, deviceIdentity.IotHubConnectionString.HostName);
if (Logging.IsEnabled)
{
Logging.Associate(this, _deviceIdentity, nameof(_deviceIdentity));
}
}
public async Task<IQos2MessageDeliveryState> GetMessageAsync(IDeviceIdentity deviceIdentity, int packetId)
{
string rowKey = CalculateRowKey(deviceIdentity.Id, packetId);
TableQuery<TableMessageDeliveryState> query = new TableQuery<TableMessageDeliveryState>()
.Where(TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, CalculatePartitionKey(rowKey)),
TableOperators.And,
TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rowKey)));
return await this.ReadRowAsync(query, CancellationToken.None);
}
public async Task OpenAsync(string deviceId, string deviceKey)
{
this.deviceIdentity = this.GetDeviceIdentity(deviceId, deviceKey);
if (this.deviceIdentity != UnauthenticatedDeviceIdentity.Instance)
{
this.deviceClient = await this.deviceClientFactory(this.deviceIdentity);
this.deviceClient.BindMessagingChannel(this);
}
}
public override async Task SetAsync(IDeviceIdentity identity, ISessionState sessionState)
{
using (await this.setLock.LockAsync())
{
await base.SetAsync(identity, sessionState);
await this.PersistToStore(identity.Id, sessionState);
Events.SetSessionStateSuccess(identity);
}
}
public async Task <IQos2MessageDeliveryState> GetMessageAsync(IDeviceIdentity deviceIdentity, int packetId)
{
string rowKey = CalculateRowKey(deviceIdentity.Id, packetId);
TableQuery <TableMessageDeliveryState> query = new TableQuery <TableMessageDeliveryState>()
.Where(TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, CalculatePartitionKey(rowKey)),
TableOperators.And,
TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, rowKey)));
return(await this.ReadRowAsync(query, CancellationToken.None));
}
public AmqpUnit CreateAmqpUnit(
IDeviceIdentity deviceIdentity,
Func <MethodRequestInternal, Task> onMethodCallback,
Action <Twin, string, TwinCollection, IotHubException> twinMessageListener,
Func <string, Message, Task> onModuleMessageReceivedCallback,
Func <Message, Task> onDeviceMessageReceivedCallback,
Action onUnitDisconnected)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, deviceIdentity, nameof(CreateAmqpUnit));
}
if (deviceIdentity.IsPooling())
{
AmqpConnectionHolder amqpConnectionHolder;
lock (_lock)
{
AmqpConnectionHolder[] amqpConnectionHolders = ResolveConnectionGroup(deviceIdentity);
amqpConnectionHolder = ResolveConnectionByHashing(amqpConnectionHolders, deviceIdentity);
}
if (Logging.IsEnabled)
{
Logging.Exit(this, deviceIdentity, nameof(CreateAmqpUnit));
}
return(amqpConnectionHolder.CreateAmqpUnit(
deviceIdentity,
onMethodCallback,
twinMessageListener,
onModuleMessageReceivedCallback,
onDeviceMessageReceivedCallback,
onUnitDisconnected));
}
else
{
if (Logging.IsEnabled)
{
Logging.Exit(this, deviceIdentity, nameof(CreateAmqpUnit));
}
return(new AmqpConnectionHolder(deviceIdentity)
.CreateAmqpUnit(
deviceIdentity,
onMethodCallback,
twinMessageListener,
onModuleMessageReceivedCallback,
onDeviceMessageReceivedCallback,
onUnitDisconnected));
}
}
public Task DeleteMessageAsync(IDeviceIdentity deviceIdentity, int packetId, IQos2MessageDeliveryState message)
{
Contract.Requires(message != null);
TableMessageDeliveryState tableMessage = ValidateMessageType(message);
if (tableMessage.ETag == null)
{
throw new ArgumentException("Transient message cannot be deleted.");
}
return(this.table.ExecuteAsync(TableOperation.Delete(tableMessage)));
}
internal AmqpAuthenticationRefresher(IDeviceIdentity deviceIdentity, AmqpIotCbsLink amqpCbsLink)
{
_amqpIotCbsLink = amqpCbsLink;
_connectionString = deviceIdentity.IotHubConnectionString;
_audience = deviceIdentity.Audience;
_amqpIotCbsTokenProvider = new AmqpIotCbsTokenProvider(_connectionString);
if (Logging.IsEnabled)
{
Logging.Associate(this, deviceIdentity, nameof(DeviceIdentity));
Logging.Associate(this, amqpCbsLink, nameof(_amqpIotCbsLink));
}
}
public Task DeleteMessageAsync(IDeviceIdentity deviceIdentity, int packetId, IQos2MessageDeliveryState message)
{
Contract.Requires(message != null);
TableMessageDeliveryState tableMessage = ValidateMessageType(message);
if (tableMessage.ETag == null)
{
throw new ArgumentException("Transient message cannot be deleted.");
}
return this.table.ExecuteAsync(TableOperation.Delete(tableMessage));
}
private static string BuildLinkAddress(IDeviceIdentity deviceIdentity, string deviceTemplate, string moduleTemplate)
{
string path = string.IsNullOrEmpty(deviceIdentity.IotHubConnectionString.ModuleId)
? string.Format(
CultureInfo.InvariantCulture,
deviceTemplate,
WebUtility.UrlEncode(deviceIdentity.IotHubConnectionString.DeviceId))
: string.Format(
CultureInfo.InvariantCulture,
moduleTemplate,
WebUtility.UrlEncode(deviceIdentity.IotHubConnectionString.DeviceId), WebUtility.UrlEncode(deviceIdentity.IotHubConnectionString.ModuleId));
return(deviceIdentity.IotHubConnectionString.BuildLinkAddress(path).AbsoluteUri);
}
internal async Task <AmqpIotReceivingLink> OpenEventsReceiverLinkAsync(
IDeviceIdentity deviceIdentity,
CancellationToken cancellationToken)
{
return(await OpenReceivingAmqpLinkAsync(
deviceIdentity,
_amqpSession,
null,
(byte)ReceiverSettleMode.First,
CommonConstants.DeviceEventPathTemplate,
CommonConstants.ModuleEventPathTemplate,
AmqpIotConstants.EventsReceiverLinkSuffix,
null,
cancellationToken)
.ConfigureAwait(false));
}
internal async Task <AmqpIotReceivingLink> OpenMessageReceiverLinkAsync(
IDeviceIdentity deviceIdentity,
CancellationToken cancellationToken)
{
return(await OpenReceivingAmqpLinkAsync(
deviceIdentity,
_amqpSession,
null,
(byte)ReceiverSettleMode.Second,
CommonConstants.DeviceBoundPathTemplate,
CommonConstants.ModuleBoundPathTemplate,
AmqpIotConstants.TelemetryReceiveLinkSuffix,
null,
cancellationToken)
.ConfigureAwait(false));
}
internal async Task <AmqpIotSendingLink> OpenTelemetrySenderLinkAsync(
IDeviceIdentity deviceIdentity,
CancellationToken cancellationToken)
{
return(await OpenSendingAmqpLinkAsync(
deviceIdentity,
_amqpSession,
null,
null,
CommonConstants.DeviceEventPathTemplate,
CommonConstants.ModuleEventPathTemplate,
AmqpIotConstants.TelemetrySenderLinkSuffix,
null,
cancellationToken)
.ConfigureAwait(false));
}
public async Task GetDeviceIdentityTest(
string iotHubHostName,
string clientId,
string username,
string password,
bool authRetVal,
Type expectedType)
{
var authenticator = new Mock <IAuthenticator>();
authenticator.Setup(a => a.AuthenticateAsync(It.IsAny <IClientCredentials>())).ReturnsAsync(authRetVal);
IDeviceIdentityProvider deviceIdentityProvider = new DeviceIdentityProvider(authenticator.Object, new ClientCredentialsFactory(iotHubHostName), false);
IDeviceIdentity deviceIdentity = await deviceIdentityProvider.GetAsync(clientId, username, password, null);
Assert.IsAssignableFrom(expectedType, deviceIdentity);
}
internal async Task <AmqpIotSendingLink> OpenTwinSenderLinkAsync(
IDeviceIdentity deviceIdentity,
string correlationIdSuffix,
CancellationToken cancellationToken)
{
return(await OpenSendingAmqpLinkAsync(
deviceIdentity,
_amqpSession,
(byte)SenderSettleMode.Settled,
(byte)ReceiverSettleMode.First,
CommonConstants.DeviceTwinPathTemplate,
CommonConstants.ModuleTwinPathTemplate,
AmqpIotConstants.TwinSenderLinkSuffix,
AmqpIotConstants.TwinCorrelationIdPrefix + correlationIdSuffix,
cancellationToken)
.ConfigureAwait(false));
}
public AmqpUnit CreateAmqpUnit(
IDeviceIdentity deviceIdentity,
Func <MethodRequestInternal, Task> onMethodCallback,
Action <Twin, string, TwinCollection, IotHubException> twinMessageListener,
Func <string, Message, Task> onModuleMessageReceivedCallback,
Func <Message, Task> onDeviceMessageReceivedCallback,
Action onUnitDisconnected)
{
IAmqpUnitManager amqpConnectionPool = ResolveConnectionPool(deviceIdentity.IotHubConnectionString.HostName);
return(amqpConnectionPool.CreateAmqpUnit(
deviceIdentity,
onMethodCallback,
twinMessageListener,
onModuleMessageReceivedCallback,
onDeviceMessageReceivedCallback,
onUnitDisconnected));
}
public async Task <AmqpIotSession> OpenSessionAsync(IDeviceIdentity deviceIdentity, CancellationToken cancellationToken)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, deviceIdentity, nameof(OpenSessionAsync));
}
AmqpIotConnection amqpIotConnection = await EnsureConnectionAsync(cancellationToken).ConfigureAwait(false);
AmqpIotSession amqpIotSession = await amqpIotConnection.OpenSessionAsync(cancellationToken).ConfigureAwait(false);
if (Logging.IsEnabled)
{
Logging.Associate(amqpIotConnection, amqpIotSession, nameof(OpenSessionAsync));
Logging.Exit(this, deviceIdentity, nameof(OpenSessionAsync));
}
return(amqpIotSession);
}
public async Task DeleteAsync(IDeviceIdentity identity, ISessionState sessionState)
{
var state = sessionState as BlobSessionState;
if (state == null)
{
throw new ArgumentException("Cannot set Session State object that hasn't been acquired from provider.", "sessionState");
}
CloudBlockBlob blob = this.container.GetBlockBlobReference(identity.Id);
await blob.DeleteAsync(
DeleteSnapshotsOption.None,
new AccessCondition
{
IfMatchETag = state.ETag
},
null,
null);
}
public async Task GetIdentityCertAuthNotEnabled()
{
string iotHubHostName = "foo.azure-devices.net";
var authenticator = new Mock <IAuthenticator>();
authenticator.Setup(a => a.AuthenticateAsync(It.IsAny <IClientCredentials>())).ReturnsAsync(true);
var deviceIdentityProvider = new DeviceIdentityProvider(authenticator.Object, new ClientCredentialsFactory(new IdentityProvider(iotHubHostName)), false);
deviceIdentityProvider.RegisterConnectionCertificate(new X509Certificate2(), new List <X509Certificate2> {
new X509Certificate2()
});
IDeviceIdentity deviceIdentity = await deviceIdentityProvider.GetAsync(
"Device_2",
$"127.0.0.1/Device_2/api-version=2016-11-14&DeviceClientType={Uri.EscapeDataString("Microsoft.Azure.Devices.Client/1.2.2")}",
null,
null);
Assert.Equal(UnauthenticatedDeviceIdentity.Instance, deviceIdentity);
}
public void AmqpConnectionPool_Add_Remove_ConnectionHolderIsRemoved()
{
string sharedAccessKeyName = "HubOwner";
uint poolSize = 10;
IDeviceIdentity testDevice = CreatePooledSasGroupedDeviceIdentity(sharedAccessKeyName, poolSize);
IDictionary <string, AmqpConnectionHolder[]> injectedDictionary = new Dictionary <string, AmqpConnectionHolder[]>();
AmqpConnectionPoolTest pool = new AmqpConnectionPoolTest(injectedDictionary);
AmqpUnit addedUnit = pool.CreateAmqpUnit(testDevice, null, null, null, null, null);
injectedDictionary[sharedAccessKeyName].Count().Should().Be((int)poolSize);
pool.RemoveAmqpUnit(addedUnit);
foreach (object item in injectedDictionary[sharedAccessKeyName])
{
item.Should().BeNull();
}
}
public async Task <IAmqpAuthenticationRefresher> CreateRefresherAsync(IDeviceIdentity deviceIdentity, CancellationToken cancellationToken)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, deviceIdentity, nameof(CreateRefresherAsync));
}
AmqpIotConnection amqpIotConnection = await EnsureConnectionAsync(cancellationToken).ConfigureAwait(false);
IAmqpAuthenticationRefresher amqpAuthenticator = await amqpIotConnection
.CreateRefresherAsync(deviceIdentity, cancellationToken)
.ConfigureAwait(false);
if (Logging.IsEnabled)
{
Logging.Exit(this, deviceIdentity, nameof(CreateRefresherAsync));
}
return(amqpAuthenticator);
}
public Task SetMessageAsync(IDeviceIdentity deviceIdentity, int packetId, IQos2MessageDeliveryState message)
{
Contract.Requires(message != null);
TableMessageDeliveryState tableMessage = ValidateMessageType(message);
TableOperation tableOperation;
if (tableMessage.ETag == null)
{
string rowKey = CalculateRowKey(deviceIdentity.Id, packetId);
tableMessage.PartitionKey = CalculatePartitionKey(rowKey);
tableMessage.RowKey = rowKey;
tableOperation = TableOperation.Insert(tableMessage);
}
else
{
tableOperation = TableOperation.Replace(tableMessage);
}
return(this.table.ExecuteAsync(tableOperation));
}
public async Task <ISessionState> GetAsync(IDeviceIdentity identity)
{
// todo: handle server busy (throttle?)
CloudBlockBlob blob = this.container.GetBlockBlobReference(identity.Id);
JsonSerializer serializer = JsonSerializer.Create(SerializerSettings);
try
{
using (Stream stream = await blob.OpenReadAsync())
{
using (var memoryStream = new MemoryStream(new byte[blob.Properties.Length])) // we don't expect it to be big (i.e. bigger than 85KB leading to LOH alloc)
{
await stream.CopyToAsync(memoryStream);
memoryStream.Position = 0;
using (var streamReader = new StreamReader(memoryStream))
using (var jsonReader = new JsonTextReader(streamReader))
{
var sessionState = serializer.Deserialize <BlobSessionState>(jsonReader);
sessionState.ETag = blob.Properties.ETag;
return(sessionState);
}
}
}
}
catch (StorageException ex)
{
if (ex.RequestInformation.HttpStatusCode == 404)
{
return(null);
}
else
{
throw;
}
}
}
public AmqpUnit(
IDeviceIdentity deviceIdentity,
IAmqpConnectionHolder amqpConnectionHolder,
Func <MethodRequestInternal, Task> onMethodCallback,
Action <Twin, string, TwinCollection, IotHubException> twinMessageListener,
Func <string, Message, Task> onModuleMessageReceivedCallback,
Func <Message, Task> onDeviceMessageReceivedCallback,
Action onUnitDisconnected)
{
_deviceIdentity = deviceIdentity;
_onMethodCallback = onMethodCallback;
_twinMessageListener = twinMessageListener;
_onModuleMessageReceivedCallback = onModuleMessageReceivedCallback;
_onDeviceMessageReceivedCallback = onDeviceMessageReceivedCallback;
_amqpConnectionHolder = amqpConnectionHolder;
_onUnitDisconnected = onUnitDisconnected;
if (Logging.IsEnabled)
{
Logging.Associate(this, _deviceIdentity, nameof(_deviceIdentity));
}
}
private AmqpConnectionHolder[] ResolveConnectionGroup(IDeviceIdentity deviceIdentity)
{
if (deviceIdentity.AuthenticationModel == AuthenticationModel.SasIndividual)
{
if (_amqpSasIndividualPool == null)
{
_amqpSasIndividualPool = new AmqpConnectionHolder[deviceIdentity.AmqpTransportSettings.AmqpConnectionPoolSettings.MaxPoolSize];
}
return(_amqpSasIndividualPool);
}
else
{
string scope = deviceIdentity.IotHubConnectionString.SharedAccessKeyName;
GetAmqpSasGroupedPoolDictionary().TryGetValue(scope, out AmqpConnectionHolder[] amqpConnectionHolders);
if (amqpConnectionHolders == null)
{
amqpConnectionHolders = new AmqpConnectionHolder[deviceIdentity.AmqpTransportSettings.AmqpConnectionPoolSettings.MaxPoolSize];
GetAmqpSasGroupedPoolDictionary().Add(scope, amqpConnectionHolders);
}
return(amqpConnectionHolders);
}
}
public async Task <ISessionState> GetAsync(IDeviceIdentity identity)
{
// todo: handle server busy (throttle?)
CloudBlockBlob blob = this.container.GetBlockBlobReference(identity.Id);
JsonSerializer serializer = JsonSerializer.Create(SerializerSettings);
try
{
using (var stream = new RecyclableMemoryStream(StreamMemoryManager))
{
await blob.DownloadToStreamAsync(stream);
stream.Position = 0;
using (var streamReader = new StreamReader(stream))
using (var jsonReader = new JsonTextReader(streamReader))
{
var sessionState = serializer.Deserialize <BlobSessionState>(jsonReader);
sessionState.ETag = blob.Properties.ETag;
return(sessionState);
}
}
}
catch (StorageException ex)
{
if (ex.RequestInformation.HttpStatusCode == 404)
{
return(null);
}
else
{
throw;
}
}
}
public Task DeleteAsync(IDeviceIdentity identity, ISessionState sessionState)
{
return TaskEx.Completed;
}
public Task<ISessionState> GetAsync(IDeviceIdentity identity)
{
return Task.FromResult((ISessionState)null);
}
public Task SetMessageAsync(IDeviceIdentity deviceIdentity, int packetId, IQos2MessageDeliveryState message)
{
Contract.Requires(message != null);
TableMessageDeliveryState tableMessage = ValidateMessageType(message);
TableOperation tableOperation;
if (tableMessage.ETag == null)
{
string rowKey = CalculateRowKey(deviceIdentity.Id, packetId);
tableMessage.PartitionKey = CalculatePartitionKey(rowKey);
tableMessage.RowKey = rowKey;
tableOperation = TableOperation.Insert(tableMessage);
}
else
{
tableOperation = TableOperation.Replace(tableMessage);
}
return this.table.ExecuteAsync(tableOperation);
}
/// <summary>
/// Performs complete initialization of <see cref="MqttIotHubAdapter" /> based on received CONNECT packet.
/// </summary>
/// <param name="context"><see cref="IChannelHandlerContext" /> instance.</param>
/// <param name="packet">CONNECT packet.</param>
async void Connect(IChannelHandlerContext context, ConnectPacket packet)
{
bool connAckSent = false;
Exception exception = null;
try
{
if (!this.IsInState(StateFlags.WaitingForConnect))
{
ShutdownOnError(context, "CONNECT has been received in current session already. Only one CONNECT is expected per session.");
return;
}
this.stateFlags = StateFlags.ProcessingConnect;
this.identity = await this.authProvider.GetAsync(packet.ClientId,
packet.Username, packet.Password, context.Channel.RemoteAddress);
if (!this.identity.IsAuthenticated)
{
connAckSent = true;
await Util.WriteMessageAsync(context, new ConnAckPacket
{
ReturnCode = ConnectReturnCode.RefusedNotAuthorized
});
PerformanceCounters.ConnectionFailedAuthPerSecond.Increment();
ShutdownOnError(context, "Authentication failed.");
return;
}
this.messagingServiceClient = await this.messagingFactory.CreateIotHubClientAsync(this.identity);
bool sessionPresent = await this.EstablishSessionStateAsync(packet.CleanSession);
this.keepAliveTimeout = this.DeriveKeepAliveTimeout(packet);
if (packet.HasWill)
{
var will = new PublishPacket(packet.WillQualityOfService, false, packet.WillRetain);
will.TopicName = packet.WillTopicName;
will.Payload = packet.WillMessage;
this.willPacket = will;
}
connAckSent = true;
await Util.WriteMessageAsync(context, new ConnAckPacket
{
SessionPresent = sessionPresent,
ReturnCode = ConnectReturnCode.Accepted
});
this.CompleteConnect(context);
}
catch (Exception ex)
{
exception = ex;
}
if (exception != null)
{
if (!connAckSent)
{
try
{
await Util.WriteMessageAsync(context, new ConnAckPacket
{
ReturnCode = ConnectReturnCode.RefusedServerUnavailable
});
}
catch (Exception ex)
{
if (MqttIotHubAdapterEventSource.Log.IsVerboseEnabled)
{
MqttIotHubAdapterEventSource.Log.Verbose("Error sending 'Server Unavailable' CONNACK.", ex.ToString());
}
}
}
ShutdownOnError(context, "CONNECT", exception);
}
}