public static async Task <Option <EdgeDevice> > GetIdentityAsync(
string deviceId,
IotHub iotHub,
CancellationToken token,
bool takeOwnership = false,
NestedEdgeConfig nestedEdgeConfig = default(NestedEdgeConfig))
{
Device device = await iotHub.GetDeviceIdentityAsync(deviceId, token);
if (device != null)
{
if (nestedEdgeConfig != default(NestedEdgeConfig))
{
await nestedEdgeConfig.ParentDeviceId.ForEachAsync(async p =>
{
Device parentDevice = await iotHub.GetDeviceIdentityAsync(p, token);
device.ParentScopes.Add(parentDevice.Scope);
});
}
if (!device.Capabilities.IotEdge)
{
throw new InvalidOperationException($"Device '{device.Id}' exists, but is not an edge device");
}
return(Option.Some(new EdgeDevice(device, takeOwnership, iotHub, nestedEdgeConfig)));
}
else
{
return(Option.None <EdgeDevice>());
}
}
public static async Task <EdgeDevice> GetOrCreateIdentityAsync(
string deviceId,
IotHub iotHub,
CancellationToken token)
{
Device device = await iotHub.GetDeviceIdentityAsync(deviceId, token);
if (device != null)
{
if (!device.Capabilities.IotEdge)
{
throw new InvalidOperationException($"Device '{device.Id}' exists, but is not an edge device");
}
Log.Information(
"Device '{Device}' already exists on hub '{IotHub}'",
device.Id,
iotHub.Hostname);
return(new EdgeDevice(device, false, iotHub));
}
else
{
return(await CreateIdentityAsync(deviceId, iotHub, token));
}
}
EdgeDevice(Device device, bool owned, IotHub iotHub, NestedEdgeConfig nestedEdgeConfig)
{
this.device = device;
this.iotHub = iotHub;
this.owned = owned;
this.nestedEdgeConfig = nestedEdgeConfig;
}
LeafDevice(Device device, DeviceClient client, IotHub iotHub)
{
this.client = client;
this.device = device;
this.iotHub = iotHub;
this.messageId = Guid.NewGuid().ToString();
}
public EdgeRuntime(string deviceId, Option <string> agentImage, Option <string> hubImage, Option <Uri> proxy, IEnumerable <Registry> registries, bool optimizeForPerformance, IotHub iotHub)
{
this.agentImage = agentImage;
this.hubImage = hubImage;
this.iotHub = iotHub;
this.optimizeForPerformance = optimizeForPerformance;
this.proxy = proxy;
this.registries = registries;
this.DeviceId = deviceId;
}
static async Task <LeafDevice> CreateWithSasAsync(
string leafDeviceId,
Option <string> parentId,
IotHub iotHub,
ITransportSettings transport,
string edgeHostname,
CancellationToken token,
ClientOptions options,
bool nestedEdge)
{
Device leaf = new Device(leafDeviceId)
{
Authentication = new AuthenticationMechanism
{
Type = AuthenticationType.Sas
}
};
await parentId.ForEachAsync(
async p =>
{
Device edge = await GetEdgeDeviceIdentityAsync(p, iotHub, token);
leaf.Scope = edge.Scope;
});
// @To Remove this is a hack to be able to create lea. See PBI: 9171870
string hostname = iotHub.Hostname;
if (nestedEdge)
{
hostname = edgeHostname;
}
leaf = await iotHub.CreateDeviceIdentityAsync(leaf, token);
return(await DeleteIdentityIfFailedAsync(
leaf,
iotHub,
token,
() =>
{
string connectionString =
$"HostName={hostname};" +
$"DeviceId={leaf.Id};" +
$"SharedAccessKey={leaf.Authentication.SymmetricKey.PrimaryKey};" +
$"GatewayHostName={edgeHostname}";
return CreateLeafDeviceAsync(
leaf,
() => DeviceClient.CreateFromConnectionString(connectionString, new[] { transport }, options),
iotHub,
token);
}));
}
public static Task <EdgeDevice> CreateIdentityAsync(
string deviceId,
IotHub iotHub,
CancellationToken token)
{
return(Profiler.Run(
$"Creating edge device '{deviceId}' on hub '{iotHub.Hostname}'",
async() =>
{
Device device = await iotHub.CreateEdgeDeviceIdentityAsync(deviceId, token);
return new EdgeDevice(device, true, iotHub);
}));
}
static async Task <LeafDevice> CreateWithCaCertAsync(
string leafDeviceId,
string parentId,
CertificateAuthority ca,
IotHub iotHub,
ITransportSettings transport,
string edgeHostname,
CancellationToken token,
ClientOptions options)
{
Device edge = await GetEdgeDeviceIdentityAsync(parentId, iotHub, token);
Device leaf = new Device(leafDeviceId)
{
Authentication = new AuthenticationMechanism
{
Type = AuthenticationType.CertificateAuthority
},
Scope = edge.Scope
};
leaf = await iotHub.CreateDeviceIdentityAsync(leaf, token);
return(await DeleteIdentityIfFailedAsync(
leaf,
iotHub,
token,
async() =>
{
IdCertificates certFiles = await ca.GenerateIdentityCertificatesAsync(leafDeviceId, token);
(X509Certificate2 leafCert, IEnumerable <X509Certificate2> trustedCerts) =
CertificateHelper.GetServerCertificateAndChainFromFile(certFiles.CertificatePath, certFiles.KeyPath);
// .NET runtime requires that we install the chain of CA certs, otherwise it can't
// provide them to a server during authentication.
OsPlatform.Current.InstallTrustedCertificates(trustedCerts);
return await CreateLeafDeviceAsync(
leaf,
() => DeviceClient.Create(
iotHub.Hostname,
edgeHostname,
new DeviceAuthenticationWithX509Certificate(leaf.Id, leafCert),
new[] { transport },
options),
iotHub,
token);
}));
public NestedEdgeConfig(IotHub iotHub, bool isNestedEdge, Option <string> parentDeviceId, Option <string> parentHostname, Option <string> deviceHostname)
{
this.IsNestedEdge = isNestedEdge;
// Since the Nested Edge Identity of the Edge Device is not managed by the E2E test framework,
// the value needs be passed in from the pipeline. Thus, it cannot be empty.
if (this.IsNestedEdge)
{
parentDeviceId.Expect <ArgumentException>(() => throw new ArgumentException($"Expected {nameof(parentDeviceId)} for the Nested Edge"));
}
this.ParentDeviceId = parentDeviceId;
this.ParentHostname = parentHostname.GetOrElse(iotHub.Hostname);
this.DeviceHostname = deviceHostname.GetOrElse(Dns.GetHostName().ToLower());
}
public static async Task <EdgeDevice> GetOrCreateIdentityAsync(
string deviceId,
IotHub iotHub,
CancellationToken token)
{
Option <EdgeDevice> device = await GetIdentityAsync(deviceId, iotHub, token);
return(await device.Match(
d =>
{
Log.Information(
"Device '{Device}' already exists on hub '{IotHub}'",
d.Id,
iotHub.Hostname);
return Task.FromResult(d);
},
() => CreateIdentityAsync(deviceId, iotHub, token)));
}
public static async Task <Option <EdgeDevice> > GetIdentityAsync(
string deviceId,
IotHub iotHub,
CancellationToken token)
{
Device device = await iotHub.GetDeviceIdentityAsync(deviceId, token);
if (device != null)
{
if (!device.Capabilities.IotEdge)
{
throw new InvalidOperationException($"Device '{device.Id}' exists, but is not an edge device");
}
return(Option.Some(new EdgeDevice(device, false, iotHub)));
}
else
{
return(Option.None <EdgeDevice>());
}
}
public static Task <EdgeDevice> CreateIdentityAsync(
string deviceId,
IotHub iotHub,
AuthenticationType authType,
X509Thumbprint x509Thumbprint,
CancellationToken token)
{
if (authType == AuthenticationType.SelfSigned && x509Thumbprint == null)
{
throw new ArgumentException("A device created with self-signed mechanism must provide an x509 thumbprint.");
}
return(Profiler.Run(
async() =>
{
Device device = await iotHub.CreateEdgeDeviceIdentityAsync(deviceId, authType, x509Thumbprint, token);
return new EdgeDevice(device, true, iotHub);
},
"Created edge device '{Device}' on hub '{IotHub}'",
deviceId,
iotHub.Hostname));
}
public static async Task <EdgeDevice> GetOrCreateIdentityAsync(
string deviceId,
NestedEdgeConfig nestedEdgeConfig,
IotHub iotHub,
AuthenticationType authType,
X509Thumbprint x509Thumbprint,
CancellationToken token)
{
Option <EdgeDevice> device = await GetIdentityAsync(deviceId, iotHub, token, nestedEdgeConfig : nestedEdgeConfig);
EdgeDevice edgeDevice = await device.Match(
d =>
{
Log.Information(
"Device '{Device}' already exists on hub '{IotHub}'",
d.Id,
iotHub.Hostname);
return(Task.FromResult(d));
},
() => CreateIdentityAsync(deviceId, nestedEdgeConfig, iotHub, authType, x509Thumbprint, token));
return(edgeDevice);
}
public ModuleTwin(string moduleId, string deviceId, IotHub iotHub)
{
this.deviceId = deviceId;
this.iotHub = iotHub;
this.moduleId = moduleId;
}
public static Task <LeafDevice> CreateAsync(
string leafDeviceId,
Protocol protocol,
AuthenticationType auth,
Option <string> parentId,
bool useSecondaryCertificate,
CertificateAuthority ca,
IotHub iotHub,
CancellationToken token)
{
return(Profiler.Run(
async() =>
{
ITransportSettings transport = protocol.ToTransportSettings();
OsPlatform.Current.InstallEdgeCertificates(ca.Certificates.TrustedCertificates, transport);
string edgeHostname = Dns.GetHostName().ToLower();
switch (auth)
{
case AuthenticationType.Sas:
return await CreateWithSasAsync(
leafDeviceId,
parentId,
iotHub,
transport,
edgeHostname,
token);
case AuthenticationType.CertificateAuthority:
{
string p = parentId.Expect(() => new ArgumentException());
return await CreateWithCaCertAsync(
leafDeviceId,
p,
ca,
iotHub,
transport,
edgeHostname,
token);
}
case AuthenticationType.SelfSigned:
{
string p = parentId.Expect(() => new ArgumentException());
return await CreateWithSelfSignedCertAsync(
leafDeviceId,
p,
useSecondaryCertificate,
ca,
iotHub,
transport,
edgeHostname,
token);
}
default:
throw new InvalidEnumArgumentException();
}
},
"Created leaf device '{Device}' on hub '{IotHub}'",
leafDeviceId,
iotHub.Hostname));
}
public EdgeConfiguration(string deviceId, string agentImage, IotHub iotHub)
{
this.config = GetBaseConfig(agentImage);
this.iotHub = iotHub;
this.deviceId = deviceId;
}
public EdgeModule(string id, string deviceId, IotHub iotHub)
{
this.deviceId = deviceId;
this.Id = id;
this.iotHub = iotHub;
}
public EdgeAgent(string deviceId, IotHub iotHub)
: base("edgeAgent", deviceId, iotHub)
{
}
EdgeDevice(Device device, bool owned, IotHub iotHub)
{
this.device = device;
this.iotHub = iotHub;
this.owned = owned;
}
public static Task <LeafDevice> CreateAsync(
string leafDeviceId,
Protocol protocol,
AuthenticationType auth,
Option <string> parentId,
bool useSecondaryCertificate,
CertificateAuthority ca,
IotHub iotHub,
string edgeHostname,
CancellationToken token,
Option <string> modelId,
bool nestedEdge)
{
ClientOptions options = new ClientOptions();
modelId.ForEach(m => options.ModelId = m);
return(Profiler.Run(
async() =>
{
ITransportSettings transport = protocol.ToTransportSettings();
OsPlatform.Current.InstallCaCertificates(ca.EdgeCertificates.TrustedCertificates, transport);
switch (auth)
{
case AuthenticationType.Sas:
return await CreateWithSasAsync(
leafDeviceId,
parentId,
iotHub,
transport,
edgeHostname,
token,
options,
nestedEdge);
case AuthenticationType.CertificateAuthority:
{
string p = parentId.Expect(() => new ArgumentException("Missing parent ID"));
return await CreateWithCaCertAsync(
leafDeviceId,
p,
ca,
iotHub,
transport,
edgeHostname,
token,
options);
}
case AuthenticationType.SelfSigned:
{
string p = parentId.Expect(() => new ArgumentException("Missing parent ID"));
return await CreateWithSelfSignedCertAsync(
leafDeviceId,
p,
useSecondaryCertificate,
ca,
iotHub,
transport,
edgeHostname,
token,
options);
}
default:
throw new InvalidEnumArgumentException();
}
},
"Created leaf device '{Device}' on hub '{IotHub}'",
leafDeviceId,
iotHub.Hostname));
}
public EdgeAgent(string deviceId, IotHub iotHub)
: base(ModuleName.EdgeAgent, deviceId, iotHub)
{
}