public void AddsVolumesFromCreateOptionsToContainerSpecEvenIfTheyOverrideExistingOnes()
{
var identity = new ModuleIdentity("hostname", "gatewayhost", "deviceid", "Module1", Mock.Of <ICredentials>());
var docker = new DockerModule("module1", "v1", ModuleStatus.Running, RestartPolicy.Always, Config1, ImagePullPolicy.OnCreate, Constants.DefaultPriority, DefaultConfigurationInfo, EnvVarsDict);
var volumes = new[]
{
new KubernetesModuleVolumeSpec(
new V1Volume("homeblah", configMap: new V1ConfigMapVolumeSource(name: "additional-config-map")),
new[] { new V1VolumeMount(name: "homeblah", mountPath: "/home/blah") })
};
var hostConfig = new HostConfig {
Binds = new List <string> {
"/home/blah:/home/blah2:ro"
}
};
var config = new KubernetesConfig("image", CreatePodParameters.Create(volumes: volumes, hostConfig: hostConfig), Option.None <AuthConfig>());
var module = new KubernetesModule(docker, config, EdgeletModuleOwner);
var labels = new Dictionary <string, string>();
var mapper = CreateMapper();
var deployment = mapper.CreateDeployment(identity, module, labels);
// Validate module volume mounts
var moduleContainer = deployment.Spec.Template.Spec.Containers.Single(container => container.Name == "module1");
Assert.Equal(2, moduleContainer.VolumeMounts.Count(vm => vm.Name.Equals("homeblah")));
// Validate proxy volume mounts
var proxyContainer = deployment.Spec.Template.Spec.Containers.Single(p => p.Name == "proxy");
Assert.Equal(2, proxyContainer.VolumeMounts.Count);
Assert.Contains(proxyContainer.VolumeMounts, vm => vm.Name.Equals("configVolumeName"));
Assert.Contains(proxyContainer.VolumeMounts, vm => vm.Name.Equals("trustBundleVolumeName"));
// Validate pod volumes
Assert.Equal(4, deployment.Spec.Template.Spec.Volumes.Count);
Assert.Equal(2, deployment.Spec.Template.Spec.Volumes.Count(v => v.Name.Equals("homeblah")));
Assert.Contains(deployment.Spec.Template.Spec.Volumes, v => v.Name.Equals("configVolumeName"));
Assert.Contains(deployment.Spec.Template.Spec.Volumes, v => v.Name.Equals("trustBundleVolumeName"));
}
public async Task DoesNotSendToModule()
{
var connector = GetConnector();
var connectionRegistry = GetConnectionRegistry();
var identity = new ModuleIdentity("hub", "device_id", "module_id");
var message = new EdgeMessage
.Builder(new byte[] { 0x01, 0x02, 0x03 })
.SetSystemProperties(new Dictionary <string, string>()
{
[SystemProperties.LockToken] = "12345"
})
.Build();
var sut = new Cloud2DeviceMessageHandler(connectionRegistry);
sut.SetConnector(connector);
await sut.SendC2DMessageAsync(message, identity, true);
Mock.Get(connector)
.Verify(c => c.SendAsync(It.IsAny <string>(), It.IsAny <byte[]>(), It.IsAny <bool>()), Times.Never());
}
public async Task SendsMessageDataAsPayload()
{
var capture = new SendCapture();
var connector = GetConnector(capture);
var connectionRegistry = GetConnectionRegistry();
var identityProvider = new IdentityProvider("hub");
var identity = new ModuleIdentity("hub", "device_id", "module_id");
var message = new EdgeMessage
.Builder(new byte[] { 0x01, 0x02, 0x03 })
.SetSystemProperties(new Dictionary <string, string>()
{
[SystemProperties.LockToken] = "12345"
})
.Build();
using var sut = new ModuleToModuleMessageHandler(connectionRegistry, identityProvider, GetAckTimeout());
sut.SetConnector(connector);
await sut.SendModuleToModuleMessageAsync(message, "some_input", identity, true);
Assert.Equal(new byte[] { 0x01, 0x02, 0x03 }, capture.Content);
}
public async void TestAuthSucceeds()
{
var authenticator = Mock.Of <IAuthenticator>();
var clientCredentialsFactory = Mock.Of <IClientCredentialsFactory>();
var saslAuthenticator = new EdgeHubSaslPlainAuthenticator(authenticator, clientCredentialsFactory, "hub1");
var identity = new ModuleIdentity("hub1", "dev1", "mod1");
var clientCredentials = Mock.Of <IClientCredentials>(c => c.Identity == identity);
const string UserId = "dev1/modules/[email protected]";
const string Password = "******";
Mock.Get(clientCredentialsFactory).Setup(f => f.GetWithSasToken("dev1", "mod1", string.Empty, Password))
.Returns(clientCredentials);
Mock.Get(authenticator).Setup(a => a.AuthenticateAsync(clientCredentials))
.ReturnsAsync(true);
var principal = await saslAuthenticator.AuthenticateAsync(UserId, Password) as SaslPrincipal;
Assert.NotNull(principal);
Assert.NotNull(principal.Identity);
Assert.NotNull(principal.AmqpAuthentication);
Assert.Equal(identity, principal.AmqpAuthentication.ClientCredentials.OrDefault().Identity);
}
/// <summary>
/// Get a module identity.
/// </summary>
/// <param name="deviceId">Unique identifier of the device the module belongs to.</param>
/// <param name="moduleId">Unique identifier of the module to get.</param>
public async Task <ModuleIdentity> GetModuleIdentityAsync(string deviceId, string moduleId)
{
SampleLogger.PrintHeader("GET A MODULE");
try
{
Console.WriteLine($"Getting module identity with Id: '{moduleId}'\n");
Response <ModuleIdentity> response = await IoTHubServiceClient.Modules.GetIdentityAsync(deviceId, moduleId);
ModuleIdentity moduleIdentity = response.Value;
SampleLogger.PrintSuccess($"\t- Device Id: '{moduleIdentity.DeviceId}', Module Id: '{moduleIdentity.ModuleId}', ETag: '{moduleIdentity.Etag}'");
return(moduleIdentity);
}
catch (Exception ex)
{
SampleLogger.FatalError($"Failed to get a module identity due to:\n{ex}");
throw;
}
}
public void EmptyDirMappingForVolume()
{
var identity = new ModuleIdentity("hostname", "gatewayhost", "deviceid", "ModuleId", Mock.Of <ICredentials>());
var labels = new Dictionary <string, string>();
var hostConfig = VolumeMountHostConfig;
var config = new KubernetesConfig("image", CreatePodParameters.Create(labels: labels, hostConfig: hostConfig), Option.None <AuthConfig>());
var docker = new DockerModule("module1", "v1", ModuleStatus.Running, RestartPolicy.Always, Config1, ImagePullPolicy.OnCreate, DefaultConfigurationInfo, EnvVarsDict);
var module = new KubernetesModule(docker, config);
var mapper = new KubernetesDeploymentMapper("namespace", "edgehub", "proxy", "configPath", "configVolumeName", "configMapName", "trustBundlePAth", "trustBundleVolumeName", "trustBundleConfigMapName", string.Empty, null, "apiVersion", new Uri("http://workload"), new Uri("http://management"));
var deployment = mapper.CreateDeployment(identity, module, labels);
var pod = deployment.Spec.Template;
Assert.True(pod != null);
var podVolume = pod.Spec.Volumes.Single(v => v.Name == "a-volume");
Assert.NotNull(podVolume.EmptyDir);
var podVolumeMount = pod.Spec.Containers.Single(p => p.Name != "proxy").VolumeMounts.Single(vm => vm.Name == "a-volume");
Assert.Equal("/tmp/volume", podVolumeMount.MountPath);
Assert.True(podVolumeMount.ReadOnlyProperty);
}
public void SimpleServiceCreationHappyPath()
{
var exposedPorts = new Dictionary <string, EmptyStruct> {
["10/TCP"] = default(EmptyStruct)
};
var createOptions = CreatePodParameters.Create(exposedPorts: exposedPorts);
var config = new KubernetesConfig("image", createOptions, Option.None <AuthConfig>());
var docker = new DockerModule("module1", "v1", ModuleStatus.Running, RestartPolicy.Always, Config1, ImagePullPolicy.OnCreate, Constants.DefaultPriority, DefaultConfigurationInfo, EnvVars);
var module = new KubernetesModule(docker, config, EdgeletModuleOwner);
var moduleLabels = new Dictionary <string, string>();
var mapper = new KubernetesServiceMapper(PortMapServiceType.ClusterIP);
var moduleId = new ModuleIdentity("hostname", "gatewayhost", "deviceid", "moduleid", Mock.Of <ICredentials>());
var service = mapper.CreateService(moduleId, module, moduleLabels).OrDefault();
Assert.NotNull(service);
Assert.Equal(1, service.Metadata.OwnerReferences.Count);
Assert.Equal(V1Deployment.KubeKind, service.Metadata.OwnerReferences[0].Kind);
Assert.Equal(EdgeletModuleOwner.Name, service.Metadata.OwnerReferences[0].Name);
Assert.Equal(1, service.Spec.Ports.Count);
Assert.Equal(0, service.Spec.Selector.Count);
}
public void ExposingPortsCreatesAServiceWithPorts()
{
var createOptions = new Docker.Models.CreateContainerParameters
{
// Add a port to be exposed
ExposedPorts = new Dictionary <string, EmptyStruct>
{
["10/TCP"] = default(EmptyStruct)
}
};
var config = new CombinedDockerConfig("image", createOptions, Option.None <AuthConfig>());
var docker = new DockerModule("module1", "v1", ModuleStatus.Running, Core.RestartPolicy.Always, Config1, ImagePullPolicy.OnCreate, DefaultConfigurationInfo, EnvVars);
var module = new KubernetesModule(docker, config);
var moduleLabels = new Dictionary <string, string>();
var mapper = new KubernetesServiceMapper(PortMapServiceType.ClusterIP);
var moduleId = new ModuleIdentity("hostname", "gatewayhost", "deviceid", "moduleid", Mock.Of <ICredentials>());
var service = mapper.CreateService(moduleId, module, moduleLabels).OrDefault();
Assert.Equal(1, service.Spec.Ports.Count);
AssertPort(new V1ServicePort(10, "exposedport-10-tcp", null, "TCP"), service.Spec.Ports.First());
Assert.Equal("ClusterIP", service.Spec.Type);
}
public void PvcMappingByDefault()
{
var identity = new ModuleIdentity("hostname", "gatewayhost", "deviceid", "ModuleId", Mock.Of <ICredentials>());
var labels = new Dictionary <string, string>();
var hostConfig = VolumeMountHostConfig;
var config = new KubernetesConfig("image", CreatePodParameters.Create(labels: labels, hostConfig: hostConfig), Option.None <AuthConfig>());
var docker = new DockerModule("module1", "v1", ModuleStatus.Running, RestartPolicy.Always, Config1, ImagePullPolicy.OnCreate, Constants.DefaultPriority, DefaultConfigurationInfo, EnvVarsDict);
var module = new KubernetesModule(docker, config, EdgeletModuleOwner);
var mapper = CreateMapper(storageClassName: null);
var deployment = mapper.CreateDeployment(identity, module, labels);
var pod = deployment.Spec.Template;
Assert.True(pod != null);
var podVolume = pod.Spec.Volumes.Single(v => v.Name == "a-volume");
Assert.NotNull(podVolume.PersistentVolumeClaim);
Assert.Equal("a-volume", podVolume.PersistentVolumeClaim.ClaimName);
Assert.True(podVolume.PersistentVolumeClaim.ReadOnlyProperty);
var podVolumeMount = pod.Spec.Containers.Single(p => p.Name != "proxy").VolumeMounts.Single(vm => vm.Name == "a-volume");
Assert.Equal("/tmp/volume", podVolumeMount.MountPath);
Assert.True(podVolumeMount.ReadOnlyProperty);
}
/// <summary>
/// Deletes a module identity.
/// </summary>
/// <param name="deviceId">Unique identifier of the device the module belongs to.</param>
/// <param name="moduleId">Unique identifier of the module to be updated.</param>
public async Task DeleteModuleIdentityAsync(string deviceId, string moduleId)
{
SampleLogger.PrintHeader("DELETE MODULE IDENTITY");
try
{
// Get the module identity first.
Response <ModuleIdentity> getResponse = await IoTHubServiceClient.Modules.GetIdentityAsync(deviceId, moduleId);
ModuleIdentity moduleIdentity = getResponse.Value;
Console.WriteLine($"Deleting module identity: DeviceId: '{moduleIdentity.DeviceId}', ModuleId: '{moduleIdentity.ModuleId}', ETag: '{moduleIdentity.Etag}'");
// We use UnconditionalIfMatch to force delete the Module Identity (disregard the IfMatch ETag).
Response response = await IoTHubServiceClient.Modules.DeleteIdentityAsync(moduleIdentity);
SampleLogger.PrintSuccess($"Successfully deleted module identity: DeviceId: '{deviceId}', ModuleId: '{moduleId}'");
}
catch (Exception ex)
{
SampleLogger.FatalError($"Failed to delete module identity due to:\n{ex}");
}
}
public async Task EncodesModuleNameInTopic()
{
var capture = new SendCapture();
var connector = GetConnector(capture);
var connectionRegistry = GetConnectionRegistry();
var identityProvider = new IdentityProvider("hub");
var identity = new ModuleIdentity("hub", "device_id", "module_id");
var message = new EdgeMessage
.Builder(new byte[] { 0x01, 0x02, 0x03 })
.SetSystemProperties(new Dictionary <string, string>()
{
[SystemProperties.LockToken] = "12345"
})
.Build();
var sut = new ModuleToModuleMessageHandler(connectionRegistry, identityProvider);
sut.SetConnector(connector);
await sut.SendModuleToModuleMessageAsync(message, "some_input", identity, true);
Assert.Equal("$edgehub/device_id/module_id/inputs/some_input/", capture.Topic);
}
public void TestHandleEdgeHubServiceIdentityUpdateSuccess()
{
// Arrange
var connectionManager = new Mock <IConnectionManager>(MockBehavior.Strict);
var authenticator = new Mock <IAuthenticator>(MockBehavior.Strict);
var credentialsStore = new Mock <ICredentialsCache>(MockBehavior.Strict);
var deviceScopeIdentitiesCache = new Mock <IDeviceScopeIdentitiesCache>(MockBehavior.Strict);
TimeSpan reauthFrequency = TimeSpan.FromSeconds(3);
var edgeHubIdentity = new ModuleIdentity(IoTHubHostName, "d1", "$edgeHub");
var edgeHubCredentials = Mock.Of <IClientCredentials>(c => c.Identity == edgeHubIdentity && c.AuthenticationType == AuthenticationType.SasKey);
credentialsStore.Setup(c => c.Get(edgeHubIdentity)).ReturnsAsync(Option.Some(edgeHubCredentials));
var edgeHubProxy = Mock.Of <IDeviceProxy>(d => d.IsActive && d.Identity == edgeHubIdentity);
connectionManager.Setup(c => c.GetDeviceConnection("d1/$edgeHub")).Returns(Option.Some(edgeHubProxy));
connectionManager.Setup(c => c.RemoveDeviceConnection("d1/$edgeHub")).Returns(Task.CompletedTask);
authenticator.Setup(a => a.ReauthenticateAsync(edgeHubCredentials)).ReturnsAsync(true);
var serviceAuthentication = new ServiceAuthentication(ServiceAuthenticationType.None);
var edgeHubServiceIdentity = new ServiceIdentity("d1/$edgeHub", "1234", Enumerable.Empty <string>(), serviceAuthentication, ServiceIdentityStatus.Enabled);
// Act
var connectionReauthenticator = new ConnectionReauthenticator(connectionManager.Object, authenticator.Object, credentialsStore.Object, deviceScopeIdentitiesCache.Object, reauthFrequency, Mock.Of <IIdentity>(i => i.Id == "d1/$edgeHub"));
deviceScopeIdentitiesCache.Raise(d => d.ServiceIdentityUpdated += null, null, edgeHubServiceIdentity);
// Assert
Assert.NotNull(connectionReauthenticator);
connectionManager.Verify(c => c.RemoveDeviceConnection("d1"), Times.Never);
connectionManager.Verify(c => c.RemoveDeviceConnection("d1/$edgeHub"), Times.Never);
connectionManager.Verify(c => c.GetDeviceConnection("d1/$edgeHub"), Times.Never);
authenticator.Verify(a => a.ReauthenticateAsync(edgeHubCredentials), Times.Never);
credentialsStore.Verify(c => c.Get(edgeHubIdentity), Times.Never);
deviceScopeIdentitiesCache.VerifyAll();
}
public void AppliesVolumesFromCreateOptionsToContainerSpec()
{
var identity = new ModuleIdentity("hostname", "deviceid", "Module1", Mock.Of <ICredentials>());
var docker = new DockerModule("module1", "v1", ModuleStatus.Running, Core.RestartPolicy.Always, Config1, ImagePullPolicy.OnCreate, Constants.DefaultStartupOrder, DefaultConfigurationInfo, EnvVarsDict);
var volumes = new[]
{
new KubernetesModuleVolumeSpec(
new V1Volume("additional-volume", configMap: new V1ConfigMapVolumeSource(name: "additional-config-map")),
new[] { new V1VolumeMount(name: "additional-volume", mountPath: "/etc") })
};
var config = new KubernetesConfig("image", CreatePodParameters.Create(volumes: volumes), Option.None <AuthConfig>());
var module = new KubernetesModule(docker, config, EdgeletModuleOwner);
var labels = new Dictionary <string, string>();
var mapper = CreateMapper();
var deployment = mapper.CreateDeployment(identity, module, labels);
// Validate module volume mounts
var moduleContainer = deployment.Spec.Template.Spec.Containers.Single(container => container.Name == "module1");
Assert.Equal(1, moduleContainer.VolumeMounts.Count);
Assert.Contains(moduleContainer.VolumeMounts, vm => vm.Name.Equals("additional-volume"));
// Validate proxy volume mounts
var proxyContainer = deployment.Spec.Template.Spec.Containers.Single(p => p.Name == "proxy");
Assert.Equal(2, proxyContainer.VolumeMounts.Count);
Assert.Contains(proxyContainer.VolumeMounts, vm => vm.Name.Equals("configVolumeName"));
Assert.Contains(proxyContainer.VolumeMounts, vm => vm.Name.Equals("trustBundleVolumeName"));
// Validate pod volumes
Assert.Equal(3, deployment.Spec.Template.Spec.Volumes.Count);
Assert.Contains(deployment.Spec.Template.Spec.Volumes, v => v.Name.Equals("additional-volume"));
Assert.Contains(deployment.Spec.Template.Spec.Volumes, v => v.Name.Equals("configVolumeName"));
Assert.Contains(deployment.Spec.Template.Spec.Volumes, v => v.Name.Equals("trustBundleVolumeName"));
}
/*^
#pragma warning disable 2666, 2669, 2677, 2674
^*/
internal PEFileToObjectModel(
PeReader peReader,
PEFileReader peFileReader,
ModuleIdentity moduleIdentity,
Assembly/*?*/ containingAssembly,
byte pointerSize
)
//^ requires peFileReader.IsAssembly ==> moduleIdentity.ContainingAssembly != null;
//^ requires peFileReader.IsAssembly ==> containingAssembly == null;
//^ requires !(moduleIdentity.Location != null && moduleIdentity.Location.Length != 0);
{
this.pointerSize = pointerSize;
this.document = new MetadataObjectDocument(this);
this.ModuleReader = peReader;
this.PEFileReader = peFileReader;
this.NameTable = peReader.metadataReaderHost.NameTable;
this.InternFactory = peReader.metadataReaderHost.InternFactory;
this.StringIndexToNameTable = new Hashtable<IName>();
this.StringIndexToUnmangledNameTable = new Hashtable<IName>();
this.typeCache = new TypeCache(this);
uint moduleNameOffset = peFileReader.ModuleTable.GetName(1);
IName moduleName = this.GetNameFromOffset(moduleNameOffset);
AssemblyIdentity/*?*/ assemblyIdentity = moduleIdentity as AssemblyIdentity;
if (peFileReader.IsAssembly) {
//^ assert assemblyIdentity != null;
AssemblyRow assemblyRow = peFileReader.AssemblyTable[1];
IName assemblyName = this.GetNameFromOffset(assemblyRow.Name);
byte[] publicKeyArray = TypeCache.EmptyByteArray;
if (assemblyRow.PublicKey != 0) {
publicKeyArray = peFileReader.BlobStream[assemblyRow.PublicKey];
}
uint internedModuleId = (uint)peReader.metadataReaderHost.InternFactory.GetAssemblyInternedKey(assemblyIdentity);
Assembly assem = new Assembly(this, moduleName, peFileReader.COR20Header.COR20Flags, internedModuleId, assemblyIdentity, assemblyName, assemblyRow.Flags, publicKeyArray);
this.ContainingAssembly = assem;
this.Module = assem;
} else {
uint internedModuleId = (uint)peReader.metadataReaderHost.InternFactory.GetModuleInternedKey(moduleIdentity);
this.ContainingAssembly = containingAssembly;
this.Module = new Module(this, moduleName, peFileReader.COR20Header.COR20Flags, internedModuleId, moduleIdentity);
}
this.LoadAssemblyReferences();
this.LoadModuleReferences();
this.RootModuleNamespace = new RootNamespace(this);
this.NamespaceINameHashtable = new Hashtable<Namespace>();
this.LoadNamespaces();
this.NamespaceReferenceINameHashtable = new DoubleHashtable<NamespaceReference>();
this.NamespaceTypeTokenTable = new DoubleHashtable(peFileReader.TypeDefTable.NumberOfRows + peFileReader.ExportedTypeTable.NumberOfRows);
this.NestedTypeTokenTable = new DoubleHashtable(peFileReader.NestedClassTable.NumberOfRows + peFileReader.ExportedTypeTable.NumberOfRows);
this.PreLoadTypeDefTableLookup();
this.ModuleTypeDefArray = new TypeBase/*?*/[peFileReader.TypeDefTable.NumberOfRows + 1];
this.ModuleTypeDefLoadState = new LoadState[peFileReader.TypeDefTable.NumberOfRows + 1];
this.RedirectedTypeDefArray = new INamedTypeReference/*?*/[peFileReader.TypeDefTable.NumberOfRows + 1];
this.ModuleTypeDefLoadState[0] = LoadState.Loaded;
this.ExportedTypeArray = new ExportedTypeAliasBase/*?*/[peFileReader.ExportedTypeTable.NumberOfRows + 1];
this.ExportedTypeLoadState = new LoadState[peFileReader.ExportedTypeTable.NumberOfRows + 1];
this.ExportedTypeLoadState[0] = LoadState.Loaded;
this.ModuleGenericParamArray = new GenericParameter[peFileReader.GenericParamTable.NumberOfRows + 1];
if (peFileReader.MethodSpecTable.NumberOfRows > 0) {
this.ModuleMethodSpecHashtable = new DoubleHashtable<IGenericMethodInstanceReference>(peFileReader.MethodSpecTable.NumberOfRows + 1);
}
this.ModuleTypeRefReferenceArray = new INamedTypeReference[peFileReader.TypeRefTable.NumberOfRows + 1];
this.ModuleTypeRefReferenceLoadState = new LoadState[peFileReader.TypeRefTable.NumberOfRows + 1];
this.ModuleTypeRefReferenceLoadState[0] = LoadState.Loaded;
if (peFileReader.TypeSpecTable.NumberOfRows > 0) {
this.ModuleTypeSpecHashtable = new DoubleHashtable<TypeSpecReference>(peFileReader.TypeSpecTable.NumberOfRows + 1);
}
this.ModuleFieldArray = new FieldDefinition[peFileReader.FieldTable.NumberOfRows + 1];
this.ModuleMethodArray = new IMethodDefinition[peFileReader.MethodTable.NumberOfRows + 1];
this.ModuleEventArray = new EventDefinition[peFileReader.EventTable.NumberOfRows + 1];
this.ModulePropertyArray = new PropertyDefinition[peFileReader.PropertyTable.NumberOfRows + 1];
this.ModuleMemberReferenceArray = new MemberReference/*?*/[peFileReader.MemberRefTable.NumberOfRows + 1];
this.UnspecializedMemberReferenceArray = new MemberReference/*?*/[peFileReader.MemberRefTable.NumberOfRows + 1];
this.SpecializedFieldHashtable = new DoubleHashtable<ISpecializedFieldReference>();
this.SpecializedMethodHashtable = new DoubleHashtable<ISpecializedMethodReference>();
this.CustomAttributeArray = new ICustomAttribute/*?*/[peFileReader.CustomAttributeTable.NumberOfRows + 1];
this.DeclSecurityArray = new ISecurityAttribute/*?*/[peFileReader.DeclSecurityTable.NumberOfRows + 1];
this._Module_ = this.Create_Module_Type();
}
/// <summary>
/// Populates the list of module references.
/// </summary>
void LoadModuleReferences()
//^ ensures this.ModuleReferenceArray != null;
{
uint numberOfModuleReferences = this.PEFileReader.ModuleRefTable.NumberOfRows;
ModuleReference[] moduleRefList = new ModuleReference[numberOfModuleReferences + 1];
for (uint i = 1; i <= numberOfModuleReferences; ++i) {
ModuleRefRow moduleRefRow = this.PEFileReader.ModuleRefTable[i];
IName moduleRefName = this.GetNameFromOffset(moduleRefRow.Name);
ModuleIdentity moduleIdentity;
if (this.ContainingAssembly == null) {
moduleIdentity = new ModuleIdentity(moduleRefName, string.Empty);
} else {
moduleIdentity = new ModuleIdentity(moduleRefName, string.Empty, this.ContainingAssembly.AssemblyIdentity);
}
ModuleIdentity probedModuleIdentity = this.ModuleReader.metadataReaderHost.ProbeModuleReference(this.Module, moduleIdentity);
uint internedModuleId = (uint)this.ModuleReader.metadataReaderHost.InternFactory.GetModuleInternedKey(probedModuleIdentity);
ModuleReference moduleReference = new ModuleReference(this, i, internedModuleId, probedModuleIdentity);
moduleRefList[i] = moduleReference;
}
//^ NonNullType.AssertInitialized(moduleRefList);
this.ModuleReferenceArray = moduleRefList;
}
private bool IsModuleRegistered(ModuleIdentity moduleIdentity)
{
return(Directory.Exists(Path.Combine(BasePath, moduleIdentity.ToString())));
}
public async Task ModulesClient_BulkUpdate()
{
string testDevicePrefix = $"bulkDeviceUpdate";
string testModulePrefix = $"bulkModuleUpdate";
IotHubServiceClient client = GetClient();
string deviceId = $"{testDevicePrefix}{GetRandom()}";
var deviceIdentity = new DeviceIdentity()
{
DeviceId = deviceId
};
IList <ModuleIdentity> listOfModulesToUpdate = new List <ModuleIdentity>();
try
{
// Create the device to house two modules
await client.Devices.CreateOrUpdateIdentityAsync(deviceIdentity).ConfigureAwait(false);
AuthenticationMechanismType initialAuthenticationType = AuthenticationMechanismType.Sas;
AuthenticationMechanismType updatedAuthenticationType = AuthenticationMechanismType.SelfSigned;
for (int moduleIndex = 0; moduleIndex < BULK_MODULE_COUNT; moduleIndex++)
{
// Create modules on that device
ModuleIdentity createdModule = (await client.Modules.CreateOrUpdateIdentityAsync(
new ModuleIdentity
{
DeviceId = deviceId,
ModuleId = $"{testModulePrefix}{GetRandom()}",
Authentication = new AuthenticationMechanism()
{
Type = initialAuthenticationType
},
}).ConfigureAwait(false)).Value;
// Update the authentication field so that we can test updating this identity later
createdModule.Authentication = new AuthenticationMechanism()
{
Type = AuthenticationMechanismType.SelfSigned
};
listOfModulesToUpdate.Add(createdModule);
}
// Make the API call to update the modules.
Response <BulkRegistryOperationResponse> updateResponse =
await client.Modules.UpdateIdentitiesAsync(listOfModulesToUpdate, BulkIfMatchPrecondition.Unconditional)
.ConfigureAwait(false);
// TODO: (azabbasi) Once the issue with the error parsing is resolved, include the error message in the message of the assert statement.
Assert.IsTrue(updateResponse.Value.IsSuccessful, "Bulk module update ended with errors");
// Verify that each module successfully updated its authentication field
foreach (ModuleIdentity module in listOfModulesToUpdate)
{
var updatedModule = (await client.Modules.GetIdentityAsync(module.DeviceId, module.ModuleId).ConfigureAwait(false)).Value;
updatedModule.Authentication.Type.Should().Be(updatedAuthenticationType, "Module should have been updated");
}
}
finally
{
await CleanupAsync(client, deviceIdentity).ConfigureAwait(false);
}
}
public async Task ModulesClient_UpdateModuleTwin_EtagDoesNotMatch()
{
string testDeviceId = $"TwinLifecycleDevice{GetRandom()}";
string testModuleId = $"TwinLifecycleModule{GetRandom()}";
DeviceIdentity device = null;
ModuleIdentity module = null;
IotHubServiceClient client = GetClient();
try
{
// Create a device
device = (await client.Devices.CreateOrUpdateIdentityAsync(
new DeviceIdentity
{
DeviceId = testDeviceId
}).ConfigureAwait(false)).Value;
// Create a module on that device. Note that this implicitly creates the module twin
module = (await client.Modules.CreateOrUpdateIdentityAsync(
new ModuleIdentity
{
DeviceId = testDeviceId,
ModuleId = testModuleId
}).ConfigureAwait(false)).Value;
// Get the module twin
TwinData moduleTwin = (await client.Modules.GetTwinAsync(testDeviceId, testModuleId).ConfigureAwait(false)).Value;
moduleTwin.ModuleId.Should().BeEquivalentTo(testModuleId, "ModuleId on the Twin should match that of the module identity.");
// Update device twin
string propName = "username";
string propValue = "userA";
moduleTwin.Properties.Desired.Add(new KeyValuePair <string, object>(propName, propValue));
// TODO: (azabbasi) We should leave the IfMatchPrecondition to be the default value once we know more about the fix.
Response <TwinData> updateResponse = await client.Modules.UpdateTwinAsync(moduleTwin, IfMatchPrecondition.UnconditionalIfMatch).ConfigureAwait(false);
updateResponse.Value.Properties.Desired.Where(p => p.Key == propName).First().Value.Should().Be(propValue, "Desired property value is incorrect.");
// Perform another update using the old device object to verify precondition fails.
try
{
// Try to update the twin with the previously up-to-date twin
await client.Modules.UpdateTwinAsync(moduleTwin, IfMatchPrecondition.IfMatch).ConfigureAwait(false);
Assert.Fail($"Update call with outdated ETag should fail with 412 (PreconditionFailed)");
}
// We will catch the exception and verify status is 412 (PreconditionfFailed)
catch (RequestFailedException ex)
{
Assert.AreEqual(412, ex.Status, $"Expected the update to fail with http status code 412 (PreconditionFailed)");
}
// Delete the module
// Deleting the module happens in the finally block as cleanup.
}
finally
{
await CleanupAsync(client, device).ConfigureAwait(false);
}
}
public HttpResponseMessage RemoveModule(ModuleIdentity module)
{
return(_proxy.RemoveModuleAsync(module.Wrap()).Result);
}
private static void Remove(HttpModules modules, RemoveOptions opts)
{
var r = modules.RemoveModule(ModuleIdentity.Parse($"{opts.Name} {opts.Version} {opts.Type}"));
Console.WriteLine(r.IsSuccessStatusCode ? "success" : $"error {r.StatusCode} : {r.Content.ReadAsStringAsync().Result}");
}
public ModuleMissedException(ModuleIdentity module, string message) : base(message)
{
Missed = new[] { module };
}
public ModuleMissedException(ModuleIdentity module) : base()
{
Missed = new[] { module };
}
public ModuleInfo(ModuleIdentity identity, ModuleIdentity[] dependencies)
{
ModuleIdentity = identity;
Dependencies = dependencies;
}
/// <summary>
/// Allocates a reference to a .NET module.
/// </summary>
/// <param name="host">Provides a standard abstraction over the applications that host components that provide or consume objects from the metadata model.</param>
/// <param name="moduleIdentity"></param>
public ModuleReference(IMetadataHost host, ModuleIdentity moduleIdentity)
{
this.host = host;
this.moduleIdentity = moduleIdentity;
}
/// <summary>
/// Returns module by it's identity
/// </summary>
public virtual IModule GetModule(ModuleIdentity moduleIdentity)
{
return(_modulesRepository.GetModule(moduleIdentity));
}
//^ requires peFileReader.IsAssembly ==> moduleIdentity.ContainingAssembly != null;
//^ requires peFileReader.IsAssembly ==> containingAssembly == null;
//^ requires !(moduleIdentity.Location != null && moduleIdentity.Location.Length != 0);
/*^
#pragma warning disable 2666, 2669, 2677, 2674
^*/
internal PEFileToObjectModel(
PeReader peReader,
PEFileReader peFileReader,
ModuleIdentity moduleIdentity,
Assembly/*?*/ containingAssembly,
byte pointerSize
)
{
this.pointerSize = pointerSize;
this.ModuleReader = peReader;
this.PEFileReader = peFileReader;
this.NameTable = peReader.metadataReaderHost.NameTable;
this.StringIndexToNameTable = new Hashtable<IName>();
this.StringIndexToUnmangledNameTable = new Hashtable<IName>();
this.typeCache = new TypeCache(this);
uint moduleNameOffset = peFileReader.ModuleTable.GetName(1);
IName moduleName = this.GetNameFromOffset(moduleNameOffset);
AssemblyIdentity/*?*/ assemblyIdentity = moduleIdentity as AssemblyIdentity;
if (peFileReader.IsAssembly) {
//^ assert assemblyIdentity != null;
AssemblyRow assemblyRow = peFileReader.AssemblyTable[1];
IName assemblyName = this.GetNameFromOffset(assemblyRow.Name);
byte[] publicKeyArray = TypeCache.EmptyByteArray;
if (assemblyRow.PublicKey != 0) {
publicKeyArray = peFileReader.BlobStream[assemblyRow.PublicKey];
}
uint internedModuleId = (uint)peReader.metadataReaderHost.InternFactory.GetAssemblyInternedKey(assemblyIdentity);
Assembly assem = new Assembly(this, moduleName, peFileReader.COR20Header.COR20Flags, internedModuleId, assemblyIdentity, assemblyName, assemblyRow.Flags, publicKeyArray);
this.ContainingAssembly = assem;
this.Module = assem;
} else {
uint internedModuleId = (uint)peReader.metadataReaderHost.InternFactory.GetModuleInternedKey(moduleIdentity);
this.ContainingAssembly = containingAssembly;
this.Module = new Module(this, moduleName, peFileReader.COR20Header.COR20Flags, internedModuleId, moduleIdentity);
}
this.LoadAssemblyReferences();
this.LoadModuleReferences();
this.RootModuleNamespace = new RootNamespace(this);
this.NamespaceINameHashtable = new Hashtable<Namespace>();
this.LoadNamespaces();
this.NamespaceReferenceINameHashtable = new DoubleHashtable<NamespaceReference>();
this.NamespaceTypeTokenTable = new DoubleHashtable(peFileReader.TypeDefTable.NumberOfRows + peFileReader.ExportedTypeTable.NumberOfRows);
this.NestedTypeTokenTable = new DoubleHashtable(peFileReader.NestedClassTable.NumberOfRows + peFileReader.ExportedTypeTable.NumberOfRows);
this.PreLoadTypeDefTableLookup();
this.ModuleTypeDefArray = new TypeBase/*?*/[peFileReader.TypeDefTable.NumberOfRows + 1];
this.ModuleTypeDefLoadState = new LoadState[peFileReader.TypeDefTable.NumberOfRows + 1];
this.ModuleTypeDefLoadState[0] = LoadState.Loaded;
this.ExportedTypeArray = new ExportedTypeAliasBase/*?*/[peFileReader.ExportedTypeTable.NumberOfRows + 1];
this.ExportedTypeLoadState = new LoadState[peFileReader.ExportedTypeTable.NumberOfRows + 1];
this.ExportedTypeLoadState[0] = LoadState.Loaded;
this.ModuleGenericParamArray = new GenericParameter[peFileReader.GenericParamTable.NumberOfRows + 1];
if (peFileReader.MethodSpecTable.NumberOfRows > 0) {
this.ModuleMethodSpecHashtable = new DoubleHashtable<GenericMethodInstanceReference>(peFileReader.MethodSpecTable.NumberOfRows + 1);
}
this.ModuleTypeRefReferenceArray = new TypeRefReference[peFileReader.TypeRefTable.NumberOfRows + 1];
this.ModuleTypeRefReferenceLoadState = new LoadState[peFileReader.TypeRefTable.NumberOfRows + 1];
this.ModuleTypeRefReferenceLoadState[0] = LoadState.Loaded;
if (peFileReader.TypeSpecTable.NumberOfRows > 0) {
this.ModuleTypeSpecHashtable = new DoubleHashtable<TypeSpecReference>(peFileReader.TypeSpecTable.NumberOfRows + 1);
}
this.ModuleFieldArray = new FieldDefinition[peFileReader.FieldTable.NumberOfRows + 1];
this.ModuleMethodArray = new MethodDefinition[peFileReader.MethodTable.NumberOfRows + 1];
this.ModuleEventArray = new EventDefinition[peFileReader.EventTable.NumberOfRows + 1];
this.ModulePropertyArray = new PropertyDefinition[peFileReader.PropertyTable.NumberOfRows + 1];
this.ModuleMemberReferenceArray = new MemberReference/*?*/[peFileReader.MemberRefTable.NumberOfRows + 1];
this.CustomAttributeArray = new ICustomAttribute/*?*/[peFileReader.CustomAttributeTable.NumberOfRows + 1];
this.DeclSecurityArray = new ISecurityAttribute/*?*/[peFileReader.DeclSecurityTable.NumberOfRows + 1];
uint moduleClassTypeDefToken = this.NamespaceTypeTokenTable.Find((uint)this.NameTable.EmptyName.UniqueKey, (uint)peReader._Module_.UniqueKey);
_Module_Type/*?*/ _module_ = null;
if (moduleClassTypeDefToken != 0 && ((TokenTypeIds.TokenTypeMask & moduleClassTypeDefToken) == TokenTypeIds.TypeDef)) {
_module_ = this.Create_Module_Type(moduleClassTypeDefToken & TokenTypeIds.RIDMask);
}
if (_module_ == null) {
// Error
throw new MetadataReaderException("<Module> Type not present");
}
this._Module_ = _module_;
//^ NonNullType.AssertInitialized(this.ModuleGenericParamArray);
//^ NonNullType.AssertInitialized(this.ModuleTypeRefReferenceArray);
//^ NonNullType.AssertInitialized(this.ModuleFieldArray);
//^ NonNullType.AssertInitialized(this.ModuleMethodArray);
//^ NonNullType.AssertInitialized(this.ModuleEventArray);
//^ NonNullType.AssertInitialized(this.ModulePropertyArray);
}
public CheckDependenciesResult(ModuleIdentity sourceModule, Dictionary <ModuleIdentity, Exception> failedModules)
{
SourceModule = sourceModule;
_failedModules = failedModules;
}
async Task <(IMessageConsumer, IMessageConsumer, NullBrokerConnector)> SetupEnvironment()
{
Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance;
Routing.PerfCounter = NullRoutingPerfCounter.Instance;
Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance;
var defaultRetryStrategy = new FixedInterval(5, TimeSpan.FromSeconds(5));
var defaultRevivePeriod = TimeSpan.FromHours(1);
var defaultTimeout = TimeSpan.FromSeconds(60);
var endpointExecutorConfig = new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true);
var cloudProxyDispatcher = new BrokeredCloudProxyDispatcher();
var cloudConnectionProvider = new BrokeredCloudConnectionProvider(cloudProxyDispatcher);
var identityProvider = new IdentityProvider(iotHubName);
var deviceConnectivityManager = new BrokeredDeviceConnectivityManager(cloudProxyDispatcher);
var connectionManager = new ConnectionManager(cloudConnectionProvider, Mock.Of <ICredentialsCache>(), new IdentityProvider(iotHubName), deviceConnectivityManager);
var routingMessageConverter = new RoutingMessageConverter();
var routeFactory = new EdgeRouteFactory(new EndpointFactory(connectionManager, routingMessageConverter, edgeDeviceId, 10, 10));
var routesList = new[] { routeFactory.Create("FROM /messages INTO $upstream") };
var endpoints = routesList.Select(r => r.Endpoint);
var routerConfig = new RouterConfig(endpoints, routesList);
var dbStoreProvider = new InMemoryDbStoreProvider();
var storeProvider = new StoreProvider(dbStoreProvider);
var messageStore = new MessageStore(storeProvider, CheckpointStore.Create(storeProvider), TimeSpan.MaxValue, false, 1800);
var endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(1, TimeSpan.FromMilliseconds(10)), messageStore);
var router = await Router.CreateAsync(Guid.NewGuid().ToString(), iotHubName, routerConfig, endpointExecutorFactory);
var messageConverterProvider = new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Twin), new TwinMessageConverter() },
{ typeof(TwinCollection), new TwinCollectionMessageConverter() }
});
var twinManager = TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.None <IStoreProvider>());
var invokeMethodHandler = Mock.Of <IInvokeMethodHandler>();
var subscriptionProcessor = new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager);
var edgeHub = new RoutingEdgeHub(router, routingMessageConverter, connectionManager, twinManager, edgeDeviceId, edgeModuleName, invokeMethodHandler, subscriptionProcessor, Mock.Of <IDeviceScopeIdentitiesCache>());
var brokerConnector = new NullBrokerConnector(cloudProxyDispatcher);
cloudProxyDispatcher.SetConnector(brokerConnector);
cloudProxyDispatcher.BindEdgeHub(edgeHub);
var connectionProvider = new ConnectionProvider(connectionManager, edgeHub, TimeSpan.FromSeconds(30));
var authenticator = new NullAuthenticator();
var edgeHubIdentity = new ModuleIdentity(iotHubName, edgeDeviceId, edgeModuleName);
var tokenCredentials = new TokenCredentials(edgeHubIdentity, "qwerty", "test-product", Option.Some("test-model"), Option.None <string>(), false);
var systemComponentProvider = new SystemComponentIdProvider(tokenCredentials);
var connectionHandler = default(ConnectionHandler);
connectionHandler = new ConnectionHandler(
Task.FromResult <IConnectionProvider>(connectionProvider),
Task.FromResult <IAuthenticator>(authenticator),
identityProvider,
systemComponentProvider,
DeviceProxyFactory);
DeviceProxy DeviceProxyFactory(IIdentity identity, bool isDirectClient)
{
return(new DeviceProxy(identity, isDirectClient, connectionHandler, Mock.Of <ITwinHandler>(), Mock.Of <IModuleToModuleMessageHandler>(), Mock.Of <ICloud2DeviceMessageHandler>(), Mock.Of <IDirectMethodHandler>()));
}
var cloud2DeviceMessageHandler = new Cloud2DeviceMessageHandler(connectionHandler);
var moduleToModuleMessageHandler = new ModuleToModuleMessageHandler(connectionHandler, identityProvider, new ModuleToModuleResponseTimeout(TimeSpan.FromSeconds(10)));
var directMethodHandler = new DirectMethodHandler(connectionHandler, identityProvider);
var twinHandler = new TwinHandler(connectionHandler, identityProvider);
var subscriptionChangeHandler = new SubscriptionChangeHandler(
cloud2DeviceMessageHandler,
moduleToModuleMessageHandler,
directMethodHandler,
twinHandler,
connectionHandler,
identityProvider);
return(subscriptionChangeHandler, cloudProxyDispatcher, brokerConnector);
}
public void ModuleOpened(IModule module, ModuleIdentity moduleIdentity, uint size)
{
ModuleOpened(module.Name.Value, moduleIdentity == null ? "" : moduleIdentity.Location, module.GetHashCode(), (int)size);
}
public void ValidatePodPropertyTranslation()
{
var identity = new ModuleIdentity("hostname", "gatewayhost", "deviceid", "Module1", Mock.Of <ICredentials>());
var labels = new Dictionary <string, string>
{
// Add a label
{ "demo", "test" }
};
var hostConfig = new HostConfig
{
// Make container privileged
Privileged = true,
// Add a readonly mount
Binds = new List <string> {
"/home/blah:/home/blah2:ro"
}
};
var config = new KubernetesConfig("image", CreatePodParameters.Create(labels: labels, hostConfig: hostConfig), Option.None <AuthConfig>());
var docker = new DockerModule("module1", "v1", ModuleStatus.Running, RestartPolicy.Always, Config1, ImagePullPolicy.OnCreate, DefaultConfigurationInfo, EnvVarsDict);
var module = new KubernetesModule(docker, config, EdgeletModuleOwner);
var moduleLabels = new Dictionary <string, string>();
var mapper = CreateMapper();
var deployment = mapper.CreateDeployment(identity, module, moduleLabels);
var pod = deployment.Spec.Template;
Assert.NotNull(pod);
// Validate annotation
Assert.True(pod.Metadata.Annotations.ContainsKey("demo"));
// Two containers should exist - proxy and the module
Assert.Equal(2, pod.Spec.Containers.Count);
// There should only be one module container
var moduleContainer = pod.Spec.Containers.Single(p => p.Name != "proxy");
// We made this container privileged
Assert.True(moduleContainer.SecurityContext.Privileged);
// Validate that there are 1 mounts for module container
Assert.Equal(1, moduleContainer.VolumeMounts.Count);
// Validate the custom mount that we added
Assert.Contains(moduleContainer.VolumeMounts, vm => vm.Name.Equals("homeblah"));
var mount = moduleContainer.VolumeMounts.Single(vm => vm.Name.Equals("homeblah"));
// Lets make sure that it is read only
Assert.True(mount.ReadOnlyProperty);
// Validate proxy container
var proxyContainer = pod.Spec.Containers.Single(p => p.Name == "proxy");
// Validate that there are 2 mounts for proxy container: config and trust-bundle
Assert.Equal(2, proxyContainer.VolumeMounts.Count);
Assert.Contains(proxyContainer.VolumeMounts, vm => vm.Name.Equals("configVolumeName"));
Assert.Contains(proxyContainer.VolumeMounts, vm => vm.Name.Equals("trustBundleVolumeName"));
// Validate pod volumes
Assert.Equal(3, pod.Spec.Volumes.Count);
Assert.Contains(pod.Spec.Volumes, v => v.Name.Equals("homeblah"));
Assert.Contains(pod.Spec.Volumes, v => v.Name.Equals("configVolumeName"));
Assert.Contains(pod.Spec.Volumes, v => v.Name.Equals("trustBundleVolumeName"));
// Validate no image pull secrets for public images
Assert.Null(pod.Spec.ImagePullSecrets);
// Validate null pod security context by default
Assert.Null(pod.Spec.SecurityContext);
}
public async Task ModulesClient_InvokeMethodOnModule()
{
if (!this.IsAsync)
{
// TODO: Tim: The module client doesn't appear to open a connection to iothub or start
// listening for method invocations when this test is run in Sync mode. Not sure why though.
// calls to track 1 library don't throw, but seem to silently fail
return;
}
string testDeviceId = $"InvokeMethodDevice{GetRandom()}";
string testModuleId = $"InvokeMethodModule{GetRandom()}";
DeviceIdentity device = null;
ModuleIdentity module = null;
ModuleClient moduleClient = null;
IotHubServiceClient serviceClient = GetClient();
try
{
// Create a device to house the modules
device = (await serviceClient.Devices
.CreateOrUpdateIdentityAsync(
new DeviceIdentity
{
DeviceId = testDeviceId
})
.ConfigureAwait(false))
.Value;
// Create the module on the device
module = (await serviceClient.Modules.CreateOrUpdateIdentityAsync(
new ModuleIdentity
{
DeviceId = testDeviceId,
ModuleId = testModuleId
}).ConfigureAwait(false)).Value;
// Method expectations
string expectedMethodName = "someMethodToInvoke";
int expectedStatus = 222;
object expectedRequestPayload = null;
// Create module client instance to receive the method invocation
string moduleClientConnectionString = $"HostName={GetHostName()};DeviceId={testDeviceId};ModuleId={testModuleId};SharedAccessKey={module.Authentication.SymmetricKey.PrimaryKey}";
moduleClient = ModuleClient.CreateFromConnectionString(moduleClientConnectionString, TransportType.Mqtt_Tcp_Only);
// These two methods are part of our track 1 device client. When the test fixture runs when isAsync = true,
// these methods work. When isAsync = false, these methods silently don't work.
await moduleClient.OpenAsync().ConfigureAwait(false);
await moduleClient.SetMethodHandlerAsync(
expectedMethodName,
(methodRequest, userContext) =>
{
return(Task.FromResult(new MethodResponse(expectedStatus)));
},
null).ConfigureAwait(false);
// Invoke the method on the module
CloudToDeviceMethodRequest methodRequest = new CloudToDeviceMethodRequest()
{
MethodName = expectedMethodName,
Payload = expectedRequestPayload,
ConnectTimeoutInSeconds = 5,
ResponseTimeoutInSeconds = 5
};
var methodResponse = (await serviceClient.Modules.InvokeMethodAsync(testDeviceId, testModuleId, methodRequest).ConfigureAwait(false)).Value;
Assert.AreEqual(expectedStatus, methodResponse.Status);
}
finally
{
if (moduleClient != null)
{
await moduleClient.CloseAsync().ConfigureAwait(false);
}
await CleanupAsync(serviceClient, device).ConfigureAwait(false);
}
}
internal override InitializationResult _Init(IConfigurationRoot configuration, IContainer container)
{
_dockerClient = new DockerClientConfiguration(new Uri(configuration.GetValue <string>("DockerUri")))
.CreateClient();
var configSource = new EmulatorConfigSource(configuration);
var dockerLoggingOptions = new Dictionary <string, string>
{
{ "max-size", "1m" },
{ "max-file", "1" }
};
var loggingConfig = new DockerLoggingConfig("json-file", dockerLoggingOptions);
var dockerAuthConfig = configuration.GetSection("DockerRegistryAuth").Get <List <AuthConfig> >() ??
new List <AuthConfig>();
var combinedDockerConfigProvider = new CombinedDockerConfigProvider(dockerAuthConfig);
//var runtimeInfoProvider = RuntimeInfoProvider.CreateAsync(_dockerClient);
var dockerModule = new Devices.Edge.Agent.Docker.DockerModule(
Name,
DockerHostingSettings.Version,
DockerHostingSettings.DesiredStatus.Value,
DockerHostingSettings.RestartPolicy.Value,
DockerHostingSettings.Config,
null,
null
);
var connectionString =
configuration.GetValue <string>(Devices.Edge.Agent.Core.Constants.EdgeHubConnectionStringKey);
var connectionStringBuilder = IotHubConnectionStringBuilder.Create(connectionString);
var moduleIdentity = new ModuleIdentity(connectionStringBuilder.IotHubName,
Environment.MachineName,
connectionStringBuilder.DeviceId,
connectionStringBuilder.ModuleId,
new ConnectionStringCredentials(connectionString));
_moduleWithIdentity = new ModuleWithIdentity(dockerModule, moduleIdentity);
//var combinedDockerConfig = combinedDockerConfigProvider.GetCombinedConfig(dockerModule, runtimeInfo);
_dockerFactory = new LoggingCommandFactory(new DockerCommandFactory(_dockerClient,
loggingConfig,
configSource,
combinedDockerConfigProvider),
Devices.Edge.Util.Logger.Factory);
//var updateCommand = new GroupCommand(
// new RemoveCommand(_dockerClient, dockerModule),
// new GroupCommand(
// new PullCommand(_dockerClient, combinedDockerConfig),
// CreateCommand.BuildAsync(_dockerClient,
// dockerModule,
// dockerModuleWithIdentity.ModuleIdentity,
// loggingConfig,
// configSource,
// false).Result));
//_createCommand = new GroupCommand(
// new PullCommand(_dockerClient, combinedDockerConfig),
// CreateCommand.BuildAsync(_dockerClient,
// dockerModule,
// dockerModuleWithIdentity.ModuleIdentity,
// loggingConfig,
// configSource,
// false).Result);
//_startCommand = dockerFactory.StartAsync(dockerModule).Result;
return(base._Init(configuration, container));
}
public WrongModuleTypeException(ModuleIdentity module, IEnumerable <ModuleType> allowedTypes = null)
{
Module = module;
AllowedTypes = allowedTypes;
}
public ModuleIsRequiredException(ModuleIdentity module, IEnumerable <ModuleIdentity> dependentModules) :
base($"Module {module} is required for {string.Concat(dependentModules.Select(x => x.ToString() + "; "))}.")
{
ModuleIdentity = module;
DependentModules = dependentModules;
}
