DockerEnvironmentProvider(IRuntimeInfoProvider runtimeInfoProvider, IEntityStore<string, ModuleState> store, IRestartPolicyManager restartPolicyManager, string operatingSystemType, string architecture)
{
this.moduleStatusProvider = runtimeInfoProvider;
this.store = Preconditions.CheckNotNull(store, nameof(store));
this.operatingSystemType = operatingSystemType;
this.architecture = architecture;
this.restartPolicyManager = Preconditions.CheckNotNull(restartPolicyManager, nameof(restartPolicyManager));
}
public static async Task <DockerEnvironmentProvider> CreateAsync(IRuntimeInfoProvider runtimeInfoProvider, IEntityStore <string, ModuleState> store,
IRestartPolicyManager restartPolicyManager)
{
SystemInfo systemInfo = await Preconditions.CheckNotNull(runtimeInfoProvider, nameof(runtimeInfoProvider)).GetSystemInfo();
return(new DockerEnvironmentProvider(
runtimeInfoProvider, store, restartPolicyManager,
systemInfo.OperatingSystemType, systemInfo.Architecture,
systemInfo.Version));
}
KubernetesEnvironmentProvider(
IRuntimeInfoProvider runtimeInfoProvider,
IEntityStore <string, ModuleState> store,
string operatingSystemType,
string architecture,
string version)
{
this.moduleStatusProvider = runtimeInfoProvider;
this.store = Preconditions.CheckNotNull(store, nameof(store));
this.operatingSystemType = operatingSystemType;
this.architecture = architecture;
this.version = version;
}
public static async Task <KubernetesEnvironmentProvider> CreateAsync(
IRuntimeInfoProvider runtimeInfoProvider,
IEntityStore <string, ModuleState> store,
CancellationToken token)
{
SystemInfo systemInfo = await Preconditions.CheckNotNull(runtimeInfoProvider, nameof(runtimeInfoProvider)).GetSystemInfo(token);
return(new KubernetesEnvironmentProvider(
runtimeInfoProvider,
store,
systemInfo.OperatingSystemType,
systemInfo.Architecture,
systemInfo.Version));
}
public DockerEnvironment(IRuntimeInfoProvider moduleStatusProvider,
DeploymentConfig deploymentConfig,
IEntityStore <string, ModuleState> moduleStateStore,
IRestartPolicyManager restartManager,
string operatingSystemType,
string architecture)
{
this.moduleStatusProvider = moduleStatusProvider;
this.deploymentConfig = deploymentConfig;
this.moduleStateStore = moduleStateStore;
this.restartManager = restartManager;
this.operatingSystemType = operatingSystemType;
this.architecture = architecture;
}
public KubernetesEnvironment(
IRuntimeInfoProvider moduleStatusProvider,
DeploymentConfig deploymentConfig,
IEntityStore <string, ModuleState> moduleStateStore,
string operatingSystemType,
string architecture,
string version)
{
this.moduleStatusProvider = moduleStatusProvider;
this.deploymentConfig = deploymentConfig;
this.moduleStateStore = moduleStateStore;
this.operatingSystemType = operatingSystemType;
this.architecture = architecture;
this.version = version;
}
public LogsRequestToOptionsMapper(
IRuntimeInfoProvider runtimeInfoProvider,
LogsContentEncoding contentEncoding,
LogsContentType contentType,
LogOutputFraming outputFraming,
Option <LogsOutputGroupingConfig> outputGroupingConfig,
bool follow)
{
this.runtimeInfoProvider = Preconditions.CheckNotNull(runtimeInfoProvider, nameof(runtimeInfoProvider));
this.contentType = contentType;
this.contentEncoding = contentEncoding;
this.outputFraming = outputFraming;
this.outputGroupingConfig = outputGroupingConfig;
this.follow = follow;
}
protected override void Load(ContainerBuilder builder)
{
// IKubernetesClient
builder.Register(
c =>
{
if (this.enableServiceCallTracing)
{
// enable tracing of k8s requests made by the client
var loggerFactory = c.Resolve <ILoggerFactory>();
ILogger logger = loggerFactory.CreateLogger(typeof(Kubernetes));
ServiceClientTracing.IsEnabled = true;
ServiceClientTracing.AddTracingInterceptor(new DebugTracer(logger));
}
// load the k8s config from KUBECONFIG or $HOME/.kube/config or in-cluster if its available
KubernetesClientConfiguration kubeConfig = Option.Maybe(Environment.GetEnvironmentVariable("KUBECONFIG"))
.Else(() => Option.Maybe(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".kube", "config")))
.Filter(File.Exists)
.Map(path => KubernetesClientConfiguration.BuildConfigFromConfigFile(path))
.GetOrElse(KubernetesClientConfiguration.InClusterConfig);
return(new Kubernetes(kubeConfig));
})
.As <IKubernetes>()
.SingleInstance();
// IModuleClientProvider
builder.Register(
c => new ModuleClientProvider(
c.Resolve <ISdkModuleClientProvider>(),
this.upstreamProtocol,
this.proxy,
this.productInfo.OrDefault(),
this.closeOnIdleTimeout,
this.idleTimeout))
.As <IModuleClientProvider>()
.SingleInstance();
// IModuleManager
builder.Register(c => new ModuleManagementHttpClient(this.managementUri, this.apiVersion, Core.Constants.EdgeletClientApiVersion))
.As <IModuleManager>()
.As <IIdentityManager>()
.SingleInstance();
// IModuleIdentityLifecycleManager
var identityBuilder = new ModuleIdentityProviderServiceBuilder(this.resourceName.Hostname, this.resourceName.DeviceId, this.edgeDeviceHostName);
builder.Register(c => new KubernetesModuleIdentityLifecycleManager(c.Resolve <IIdentityManager>(), identityBuilder, this.workloadUri))
.As <IModuleIdentityLifecycleManager>()
.SingleInstance();
// CombinedKubernetesConfigProvider
builder.Register(
c =>
{
bool enableKubernetesExtensions = this.experimentalFeatures.Enabled && this.experimentalFeatures.EnableExtensions;
return(new CombinedKubernetesConfigProvider(this.dockerAuthConfig, this.workloadUri, this.managementUri, enableKubernetesExtensions));
})
.As <ICombinedConfigProvider <CombinedKubernetesConfig> >()
.SingleInstance();
// ICommandFactory
builder.Register(
c =>
{
var loggerFactory = c.Resolve <ILoggerFactory>();
var kubernetesCommandFactory = new KubernetesCommandFactory();
ICommandFactory factory = new LoggingCommandFactory(kubernetesCommandFactory, loggerFactory);
return(Task.FromResult(factory));
})
.As <Task <ICommandFactory> >()
.SingleInstance();
// IPlanner
builder.Register(
async c =>
{
var configProvider = c.Resolve <ICombinedConfigProvider <CombinedKubernetesConfig> >();
ICommandFactory commandFactory = await c.Resolve <Task <ICommandFactory> >();
IPlanner planner = new KubernetesPlanner(this.deviceNamespace, this.resourceName, c.Resolve <IKubernetes>(), commandFactory, configProvider);
return(planner);
})
.As <Task <IPlanner> >()
.SingleInstance();
// KubernetesRuntimeInfoProvider
builder.Register(c => new KubernetesRuntimeInfoProvider(this.deviceNamespace, c.Resolve <IKubernetes>(), c.Resolve <IModuleManager>()))
.As <IRuntimeInfoProvider>()
.As <IRuntimeInfoSource>()
.SingleInstance();
// KubernetesDeploymentProvider
builder.Register(
c => new KubernetesDeploymentMapper(
this.deviceNamespace,
this.edgeDeviceHostName,
this.proxyImage,
this.proxyConfigPath,
this.proxyConfigVolumeName,
this.proxyConfigMapName,
this.proxyTrustBundlePath,
this.proxyTrustBundleVolumeName,
this.proxyTrustBundleConfigMapName,
this.persistentVolumeName,
this.storageClassName,
this.apiVersion,
this.workloadUri,
this.managementUri))
.As <IKubernetesDeploymentMapper>();
// KubernetesServiceMapper
builder.Register(c => new KubernetesServiceMapper(this.defaultMapServiceType))
.As <IKubernetesServiceMapper>();
// KubernetesPvcMapper
builder.Register(c => new KubernetesPvcMapper(this.persistentVolumeName, this.storageClassName, this.persistentVolumeClaimSizeMb))
.As <IKubernetesPvcMapper>();
// KubernetesServiceAccountProvider
builder.Register(c => new KubernetesServiceAccountMapper())
.As <IKubernetesServiceAccountMapper>();
// EdgeDeploymentController
builder.Register(
c =>
{
var deploymentSelector = $"{Constants.K8sEdgeDeviceLabel}={KubeUtils.SanitizeK8sValue(this.resourceName.DeviceId)},{Constants.K8sEdgeHubNameLabel}={KubeUtils.SanitizeK8sValue(this.resourceName.Hostname)}";
IEdgeDeploymentController watchOperator = new EdgeDeploymentController(
this.resourceName,
deploymentSelector,
this.deviceNamespace,
c.Resolve <IKubernetes>(),
c.Resolve <IModuleIdentityLifecycleManager>(),
c.Resolve <IKubernetesServiceMapper>(),
c.Resolve <IKubernetesDeploymentMapper>(),
c.Resolve <IKubernetesPvcMapper>(),
c.Resolve <IKubernetesServiceAccountMapper>());
return(watchOperator);
})
.As <IEdgeDeploymentController>()
.SingleInstance();
// IEdgeDeploymentOperator
builder.Register(
c =>
{
IEdgeDeploymentOperator watchOperator = new EdgeDeploymentOperator(
this.resourceName,
this.deviceNamespace,
c.Resolve <IKubernetes>(),
c.Resolve <IEdgeDeploymentController>());
return(watchOperator);
})
.As <IEdgeDeploymentOperator>()
.SingleInstance();
// IKubernetesEnvironmentOperator
builder.Register(
c =>
{
IKubernetesEnvironmentOperator watchOperator = new KubernetesEnvironmentOperator(
this.deviceNamespace,
c.Resolve <IRuntimeInfoSource>(),
c.Resolve <IKubernetes>());
return(watchOperator);
})
.As <IKubernetesEnvironmentOperator>()
.SingleInstance();
// Task<IEnvironmentProvider>
builder.Register(
async c =>
{
var moduleStateStore = c.Resolve <IEntityStore <string, ModuleState> >();
var restartPolicyManager = c.Resolve <IRestartPolicyManager>();
IRuntimeInfoProvider runtimeInfoProvider = c.Resolve <IRuntimeInfoProvider>();
IEnvironmentProvider dockerEnvironmentProvider = await DockerEnvironmentProvider.CreateAsync(runtimeInfoProvider, moduleStateStore, restartPolicyManager);
return(dockerEnvironmentProvider);
})
.As <Task <IEnvironmentProvider> >()
.SingleInstance();
}
public CodeCompletionProvider(IScriptParser parser, IRuntimeInfoProvider infoProvider)
{
this.parser = parser;
this.infoProvider = infoProvider;
}
public ModuleLogsRequestHandler(ILogsProvider logsProvider, IRuntimeInfoProvider runtimeInfoProvider)
{
this.logsProvider = Preconditions.CheckNotNull(logsProvider, nameof(logsProvider));
this.runtimeInfoProvider = Preconditions.CheckNotNull(runtimeInfoProvider, nameof(runtimeInfoProvider));
}
public LogsProvider(IRuntimeInfoProvider runtimeInfoProvider, ILogsProcessor logsProcessor)
{
this.runtimeInfoProvider = Preconditions.CheckNotNull(runtimeInfoProvider, nameof(runtimeInfoProvider));
this.logsProcessor = Preconditions.CheckNotNull(logsProcessor, nameof(logsProcessor));
}
protected override void Load(ContainerBuilder builder)
{
// ILogsUploader
builder.Register(c => new AzureBlobLogsUploader(this.iotHubHostName, this.deviceId))
.As <ILogsUploader>()
.SingleInstance();
// Task<ILogsProvider>
builder.Register(
async c =>
{
var logsProcessor = new LogsProcessor(new LogMessageParser(this.iotHubHostName, this.deviceId));
IRuntimeInfoProvider runtimeInfoProvider = await c.Resolve <Task <IRuntimeInfoProvider> >();
return(new LogsProvider(runtimeInfoProvider, logsProcessor) as ILogsProvider);
})
.As <Task <ILogsProvider> >()
.SingleInstance();
// IRequestManager
builder.Register(
c =>
{
var requestHandlers = new List <IRequestHandler>
{
new PingRequestHandler(),
new TaskStatusRequestHandler()
};
return(new RequestManager(requestHandlers, this.requestTimeout) as IRequestManager);
})
.As <IRequestManager>()
.SingleInstance();
if (this.experimentalFeatures.EnableUploadLogs)
{
// Task<IRequestHandler> - LogsUploadRequestHandler
builder.Register(
async c =>
{
var logsUploader = c.Resolve <ILogsUploader>();
var runtimeInfoProviderTask = c.Resolve <Task <IRuntimeInfoProvider> >();
var logsProviderTask = c.Resolve <Task <ILogsProvider> >();
IRuntimeInfoProvider runtimeInfoProvider = await runtimeInfoProviderTask;
ILogsProvider logsProvider = await logsProviderTask;
return(new LogsUploadRequestHandler(logsUploader, logsProvider, runtimeInfoProvider) as IRequestHandler);
})
.As <Task <IRequestHandler> >()
.SingleInstance();
}
if (this.experimentalFeatures.EnableGetLogs)
{
// Task<IRequestHandler> - LogsRequestHandler
builder.Register(
async c =>
{
var runtimeInfoProviderTask = c.Resolve <Task <IRuntimeInfoProvider> >();
var logsProviderTask = c.Resolve <Task <ILogsProvider> >();
IRuntimeInfoProvider runtimeInfoProvider = await runtimeInfoProviderTask;
ILogsProvider logsProvider = await logsProviderTask;
return(new LogsRequestHandler(logsProvider, runtimeInfoProvider) as IRequestHandler);
})
.As <Task <IRequestHandler> >()
.SingleInstance();
}
// Task<IRequestHandler> - RestartRequestHandler
builder.Register(
async c =>
{
var environmentProviderTask = c.Resolve <Task <IEnvironmentProvider> >();
var commandFactoryTask = c.Resolve <Task <ICommandFactory> >();
var configSourceTask = c.Resolve <Task <IConfigSource> >();
IEnvironmentProvider environmentProvider = await environmentProviderTask;
ICommandFactory commandFactory = await commandFactoryTask;
IConfigSource configSource = await configSourceTask;
return(new RestartRequestHandler(environmentProvider, configSource, commandFactory) as IRequestHandler);
})
.As <Task <IRequestHandler> >()
.SingleInstance();
// ISdkModuleClientProvider
builder.Register(c => new SdkModuleClientProvider())
.As <ISdkModuleClientProvider>()
.SingleInstance();
// IEdgeAgentConnection
builder.Register(
c =>
{
var serde = c.Resolve <ISerde <DeploymentConfig> >();
var deviceClientprovider = c.Resolve <IModuleClientProvider>();
var requestManager = c.Resolve <IRequestManager>();
var deviceManager = c.Resolve <IDeviceManager>();
bool enableSubscriptions = !this.experimentalFeatures.DisableCloudSubscriptions;
IEdgeAgentConnection edgeAgentConnection = new EdgeAgentConnection(deviceClientprovider, serde, requestManager, deviceManager, enableSubscriptions, this.configRefreshFrequency);
return(edgeAgentConnection);
})
.As <IEdgeAgentConnection>()
.SingleInstance();
// Task<IStreamRequestListener>
builder.Register(
async c =>
{
if (this.enableStreams)
{
var runtimeInfoProviderTask = c.Resolve <Task <IRuntimeInfoProvider> >();
var logsProviderTask = c.Resolve <Task <ILogsProvider> >();
var edgeAgentConnection = c.Resolve <IEdgeAgentConnection>();
IRuntimeInfoProvider runtimeInfoProvider = await runtimeInfoProviderTask;
ILogsProvider logsProvider = await logsProviderTask;
var streamRequestHandlerProvider = new StreamRequestHandlerProvider(logsProvider, runtimeInfoProvider);
return(new StreamRequestListener(streamRequestHandlerProvider, edgeAgentConnection) as IStreamRequestListener);
}
else
{
return(new NullStreamRequestListener() as IStreamRequestListener);
}
})
.As <Task <IStreamRequestListener> >()
.SingleInstance();
// Task<IConfigSource>
builder.Register(
async c =>
{
var edgeAgentConnection = c.Resolve <IEdgeAgentConnection>();
var twinConfigSource = new TwinConfigSource(edgeAgentConnection, this.configuration);
var backupSourceTask = c.Resolve <Task <IDeploymentBackupSource> >();
IConfigSource backupConfigSource = new BackupConfigSource(await backupSourceTask, twinConfigSource);
return(backupConfigSource);
})
.As <Task <IConfigSource> >()
.SingleInstance();
// IReporter
builder.Register(
c =>
{
var runtimeInfoDeserializerTypes = new Dictionary <string, Type>
{
[DockerType] = typeof(DockerReportedRuntimeInfo),
[Constants.Unknown] = typeof(UnknownRuntimeInfo)
};
var edgeAgentDeserializerTypes = new Dictionary <string, Type>
{
[DockerType] = typeof(EdgeAgentDockerRuntimeModule),
[Constants.Unknown] = typeof(UnknownEdgeAgentModule)
};
var edgeHubDeserializerTypes = new Dictionary <string, Type>
{
[DockerType] = typeof(EdgeHubDockerRuntimeModule),
[Constants.Unknown] = typeof(UnknownEdgeHubModule)
};
var moduleDeserializerTypes = new Dictionary <string, Type>
{
[DockerType] = typeof(DockerRuntimeModule)
};
var deserializerTypesMap = new Dictionary <Type, IDictionary <string, Type> >
{
{ typeof(IRuntimeInfo), runtimeInfoDeserializerTypes },
{ typeof(IEdgeAgentModule), edgeAgentDeserializerTypes },
{ typeof(IEdgeHubModule), edgeHubDeserializerTypes },
{ typeof(IModule), moduleDeserializerTypes }
};
var edgeAgentConnection = c.Resolve <IEdgeAgentConnection>();
return(new IoTHubReporter(
edgeAgentConnection,
new TypeSpecificSerDe <AgentState>(deserializerTypesMap),
this.versionInfo) as IReporter);
})
.As <IReporter>()
.SingleInstance();
base.Load(builder);
}
protected override void Load(ContainerBuilder builder)
{
// ILogsUploader
builder.Register(c => new AzureBlobLogsUploader(this.iotHubHostName, this.deviceId))
.As <ILogsUploader>()
.SingleInstance();
// Task<ILogsProvider>
builder.Register(
async c =>
{
var logsProcessor = new LogsProcessor(new LogMessageParser(this.iotHubHostName, this.deviceId));
IRuntimeInfoProvider runtimeInfoProvider = await c.Resolve <Task <IRuntimeInfoProvider> >();
return(new LogsProvider(runtimeInfoProvider, logsProcessor) as ILogsProvider);
})
.As <Task <ILogsProvider> >()
.SingleInstance();
// Task<IStreamRequestListener>
builder.Register(
async c =>
{
if (this.enableStreams)
{
var runtimeInfoProviderTask = c.Resolve <Task <IRuntimeInfoProvider> >();
var logsProviderTask = c.Resolve <Task <ILogsProvider> >();
IRuntimeInfoProvider runtimeInfoProvider = await runtimeInfoProviderTask;
ILogsProvider logsProvider = await logsProviderTask;
var streamRequestHandlerProvider = new StreamRequestHandlerProvider(logsProvider, runtimeInfoProvider);
return(new StreamRequestListener(streamRequestHandlerProvider) as IStreamRequestListener);
}
else
{
return(new NullStreamRequestListener() as IStreamRequestListener);
}
})
.As <Task <IStreamRequestListener> >()
.SingleInstance();
// Task<IRequestManager>
builder.Register(
async c =>
{
var logsUploader = c.Resolve <ILogsUploader>();
var runtimeInfoProviderTask = c.Resolve <Task <IRuntimeInfoProvider> >();
var logsProviderTask = c.Resolve <Task <ILogsProvider> >();
IRuntimeInfoProvider runtimeInfoProvider = await runtimeInfoProviderTask;
ILogsProvider logsProvider = await logsProviderTask;
var requestHandlers = new List <IRequestHandler>
{
new PingRequestHandler(),
new LogsUploadRequestHandler(logsUploader, logsProvider, runtimeInfoProvider)
};
return(new RequestManager(requestHandlers, this.requestTimeout) as IRequestManager);
})
.As <Task <IRequestManager> >()
.SingleInstance();
// Task<IEdgeAgentConnection>
builder.Register(
async c =>
{
var serde = c.Resolve <ISerde <DeploymentConfig> >();
var deviceClientprovider = c.Resolve <IModuleClientProvider>();
var streamRequestListenerTask = c.Resolve <Task <IStreamRequestListener> >();
var requestManagerTask = c.Resolve <Task <IRequestManager> >();
IStreamRequestListener streamRequestListener = await streamRequestListenerTask;
IRequestManager requestManager = await requestManagerTask;
IEdgeAgentConnection edgeAgentConnection = new EdgeAgentConnection(deviceClientprovider, serde, requestManager, streamRequestListener, this.configRefreshFrequency);
return(edgeAgentConnection);
})
.As <Task <IEdgeAgentConnection> >()
.SingleInstance();
// Task<IConfigSource>
builder.Register(
async c =>
{
var serde = c.Resolve <ISerde <DeploymentConfigInfo> >();
var edgeAgentConnectionTask = c.Resolve <Task <IEdgeAgentConnection> >();
IEncryptionProvider encryptionProvider = await c.Resolve <Task <IEncryptionProvider> >();
IEdgeAgentConnection edgeAgentConnection = await edgeAgentConnectionTask;
var twinConfigSource = new TwinConfigSource(edgeAgentConnection, this.configuration);
IConfigSource backupConfigSource = new FileBackupConfigSource(this.backupConfigFilePath, twinConfigSource, serde, encryptionProvider);
return(backupConfigSource);
})
.As <Task <IConfigSource> >()
.SingleInstance();
// Task<IReporter>
builder.Register(
async c =>
{
var runtimeInfoDeserializerTypes = new Dictionary <string, Type>
{
[DockerType] = typeof(DockerReportedRuntimeInfo),
[Constants.Unknown] = typeof(UnknownRuntimeInfo)
};
var edgeAgentDeserializerTypes = new Dictionary <string, Type>
{
[DockerType] = typeof(EdgeAgentDockerRuntimeModule),
[Constants.Unknown] = typeof(UnknownEdgeAgentModule)
};
var edgeHubDeserializerTypes = new Dictionary <string, Type>
{
[DockerType] = typeof(EdgeHubDockerRuntimeModule),
[Constants.Unknown] = typeof(UnknownEdgeHubModule)
};
var moduleDeserializerTypes = new Dictionary <string, Type>
{
[DockerType] = typeof(DockerRuntimeModule)
};
var deserializerTypesMap = new Dictionary <Type, IDictionary <string, Type> >
{
{ typeof(IRuntimeInfo), runtimeInfoDeserializerTypes },
{ typeof(IEdgeAgentModule), edgeAgentDeserializerTypes },
{ typeof(IEdgeHubModule), edgeHubDeserializerTypes },
{ typeof(IModule), moduleDeserializerTypes }
};
var edgeAgentConnectionTask = c.Resolve <Task <IEdgeAgentConnection> >();
IEdgeAgentConnection edgeAgentConnection = await edgeAgentConnectionTask;
return(new IoTHubReporter(
edgeAgentConnection,
new TypeSpecificSerDe <AgentState>(deserializerTypesMap),
this.versionInfo) as IReporter);
})
.As <Task <IReporter> >()
.SingleInstance();
base.Load(builder);
}
public CodeCompletionProvider(IScriptParser parser, IRuntimeInfoProvider infoProvider)
{
this.parser = parser;
this.infoProvider = infoProvider;
}
protected override void Load(ContainerBuilder builder)
{
// IModuleClientProvider
builder.Register(
c => new ModuleClientProvider(
c.Resolve <ISdkModuleClientProvider>(),
this.upstreamProtocol,
this.proxy,
this.productInfo,
this.closeOnIdleTimeout,
this.idleTimeout))
.As <IModuleClientProvider>()
.SingleInstance();
// IModuleManager
builder.Register(c => new ModuleManagementHttpClient(this.managementUri, this.apiVersion, Constants.EdgeletClientApiVersion))
.As <IModuleManager>()
.As <IIdentityManager>()
.As <IDeviceManager>()
.SingleInstance();
// IModuleIdentityLifecycleManager
var identityBuilder = new ModuleIdentityProviderServiceBuilder(this.iotHubHostName, this.deviceId, this.gatewayHostName);
builder.Register(c => new ModuleIdentityLifecycleManager(c.Resolve <IIdentityManager>(), identityBuilder, this.workloadUri))
.As <IModuleIdentityLifecycleManager>()
.SingleInstance();
// ICombinedConfigProvider<CombinedDockerConfig>
builder.Register(
async c =>
{
IConfigSource configSource = await c.Resolve <Task <IConfigSource> >();
return(new CombinedEdgeletConfigProvider(this.dockerAuthConfig, configSource) as ICombinedConfigProvider <CombinedDockerConfig>);
})
.As <Task <ICombinedConfigProvider <CombinedDockerConfig> > >()
.SingleInstance();
// ICommandFactory
builder.Register(
async c =>
{
var moduleManager = c.Resolve <IModuleManager>();
var combinedDockerConfigProviderTask = c.Resolve <Task <ICombinedConfigProvider <CombinedDockerConfig> > >();
var configSourceTask = c.Resolve <Task <IConfigSource> >();
var metricsProvider = c.Resolve <IMetricsProvider>();
var loggerFactory = c.Resolve <ILoggerFactory>();
IConfigSource configSource = await configSourceTask;
ICombinedConfigProvider <CombinedDockerConfig> combinedDockerConfigProvider = await combinedDockerConfigProviderTask;
ICommandFactory factory = new EdgeletCommandFactory <CombinedDockerConfig>(moduleManager, configSource, combinedDockerConfigProvider);
factory = new MetricsCommandFactory(factory, metricsProvider);
return(new LoggingCommandFactory(factory, loggerFactory) as ICommandFactory);
})
.As <Task <ICommandFactory> >()
.SingleInstance();
// Task<IRuntimeInfoProvider>
builder.Register(c => Task.FromResult(new RuntimeInfoProvider <DockerReportedConfig>(c.Resolve <IModuleManager>()) as IRuntimeInfoProvider))
.As <Task <IRuntimeInfoProvider> >()
.SingleInstance();
// Task<IEnvironmentProvider>
builder.Register(
async c =>
{
var moduleStateStore = await c.Resolve <Task <IEntityStore <string, ModuleState> > >();
var restartPolicyManager = c.Resolve <IRestartPolicyManager>();
IRuntimeInfoProvider runtimeInfoProvider = await c.Resolve <Task <IRuntimeInfoProvider> >();
IEnvironmentProvider dockerEnvironmentProvider = await DockerEnvironmentProvider.CreateAsync(runtimeInfoProvider, moduleStateStore, restartPolicyManager, CancellationToken.None);
return(dockerEnvironmentProvider);
})
.As <Task <IEnvironmentProvider> >()
.SingleInstance();
// SystemResourcesMetrics
builder.Register(c => new SystemResourcesMetrics(c.Resolve <IMetricsProvider>(), c.Resolve <IModuleManager>().GetSystemResourcesAsync, this.apiVersion, this.performanceMetricsUpdateFrequency))
.SingleInstance();
}
public async Task AgentStartsUpModules(TestConfig testConfig)
{
// Build the docker host URL.
string dockerHostUrl = ConfigHelper.TestConfig["dockerHostUrl"];
DockerClient client = new DockerClientConfiguration(new Uri(dockerHostUrl)).CreateClient();
try
{
// Remove any running containers with the same name that may be a left-over
// from previous test runs.
await RemoveContainer(client, testConfig);
// Initialize docker configuration for this module.
DockerConfig dockerConfig = testConfig.ImageCreateOptions != null
? new DockerConfig(testConfig.Image, testConfig.ImageCreateOptions)
: new DockerConfig(testConfig.Image);
// Initialize an Edge Agent module object.
var dockerModule = new DockerModule(
testConfig.Name,
testConfig.Version,
ModuleStatus.Running,
global::Microsoft.Azure.Devices.Edge.Agent.Core.RestartPolicy.OnUnhealthy,
dockerConfig,
null,
null);
var modules = new Dictionary <string, IModule> {
[testConfig.Name] = dockerModule
};
var systemModules = new SystemModules(null, null);
// Start up the agent and run a "reconcile".
var dockerLoggingOptions = new Dictionary <string, string>
{
{ "max-size", "1m" },
{ "max-file", "1" }
};
var loggingConfig = new DockerLoggingConfig("json-file", dockerLoggingOptions);
string sharedAccessKey = Convert.ToBase64String(Encoding.UTF8.GetBytes("test"));
IConfigurationRoot configRoot = new ConfigurationBuilder().AddInMemoryCollection(
new Dictionary <string, string>
{
{ "DeviceConnectionString", $"Hostname=fakeiothub;Deviceid=test;SharedAccessKey={sharedAccessKey}" }
}).Build();
var runtimeConfig = new DockerRuntimeConfig("1.24.0", "{}");
var runtimeInfo = new DockerRuntimeInfo("docker", runtimeConfig);
var deploymentConfigInfo = new DeploymentConfigInfo(1, new DeploymentConfig("1.0", runtimeInfo, systemModules, modules));
var configSource = new Mock <IConfigSource>();
configSource.Setup(cs => cs.Configuration).Returns(configRoot);
configSource.Setup(cs => cs.GetDeploymentConfigInfoAsync()).ReturnsAsync(deploymentConfigInfo);
// TODO: Fix this up with a real reporter. But before we can do that we need to use
// the real configuration source that talks to IoT Hub above.
NullReporter reporter = NullReporter.Instance;
var restartStateStore = Mock.Of <IEntityStore <string, ModuleState> >();
var configStore = Mock.Of <IEntityStore <string, string> >();
var deploymentConfigInfoSerde = Mock.Of <ISerde <DeploymentConfigInfo> >();
IRestartPolicyManager restartManager = new Mock <IRestartPolicyManager>().Object;
var dockerCommandFactory = new DockerCommandFactory(client, loggingConfig, configSource.Object, new CombinedDockerConfigProvider(Enumerable.Empty <AuthConfig>()));
IRuntimeInfoProvider runtimeInfoProvider = await RuntimeInfoProvider.CreateAsync(client);
IEnvironmentProvider environmentProvider = await DockerEnvironmentProvider.CreateAsync(runtimeInfoProvider, restartStateStore, restartManager);
var logFactoryMock = new Mock <ILoggerFactory>();
var logMock = new Mock <ILogger <LoggingCommandFactory> >();
logFactoryMock.Setup(l => l.CreateLogger(It.IsAny <string>()))
.Returns(logMock.Object);
var commandFactory = new LoggingCommandFactory(dockerCommandFactory, logFactoryMock.Object);
var credential = new ConnectionStringCredentials("fake");
var identity = new Mock <IModuleIdentity>();
identity.Setup(id => id.Credentials).Returns(credential);
identity.Setup(id => id.ModuleId).Returns(testConfig.Name);
IImmutableDictionary <string, IModuleIdentity> identities = new Dictionary <string, IModuleIdentity>()
{
[testConfig.Name] = identity.Object
}.ToImmutableDictionary();
var moduleIdentityLifecycleManager = new Mock <IModuleIdentityLifecycleManager>();
moduleIdentityLifecycleManager.Setup(m => m.GetModuleIdentitiesAsync(It.IsAny <ModuleSet>(), It.IsAny <ModuleSet>())).Returns(Task.FromResult(identities));
Agent agent = await Agent.Create(
configSource.Object,
new RestartPlanner(commandFactory),
new OrderedPlanRunner(),
reporter,
moduleIdentityLifecycleManager.Object,
environmentProvider,
configStore,
deploymentConfigInfoSerde,
NullEncryptionProvider.Instance);
await agent.ReconcileAsync(CancellationToken.None);
// Sometimes the container is still not ready by the time we run the validator.
// So we attempt validation multiple times and bail only if all of them fail.
bool validated = false;
int attempts = 0;
const int MaxAttempts = 5;
while (!validated && attempts < MaxAttempts)
{
validated = testConfig.Validator.Validate();
if (!validated)
{
Thread.Sleep(TimeSpan.FromSeconds(5));
}
++attempts;
}
Assert.Equal(true, validated);
}
finally
{
await RemoveContainer(client, testConfig);
}
}
protected override void Load(ContainerBuilder builder)
{
// IModuleClientProvider
string edgeAgentConnectionString = $"{this.edgeDeviceConnectionString};{Constants.ModuleIdKey}={Constants.EdgeAgentModuleIdentityName}";
builder.Register(
c => new ModuleClientProvider(
edgeAgentConnectionString,
c.Resolve <ISdkModuleClientProvider>(),
this.upstreamProtocol,
this.proxy,
this.productInfo,
this.closeOnIdleTimeout,
this.idleTimeout))
.As <IModuleClientProvider>()
.SingleInstance();
// IServiceClient
builder.Register(c => new RetryingServiceClient(new ServiceClient(this.edgeDeviceConnectionString, this.deviceId)))
.As <IServiceClient>()
.SingleInstance();
// IModuleIdentityLifecycleManager
builder.Register(c => new ModuleIdentityLifecycleManager(c.Resolve <IServiceClient>(), this.iotHubHostName, this.deviceId, this.gatewayHostName))
.As <IModuleIdentityLifecycleManager>()
.SingleInstance();
// IDockerClient
builder.Register(c => new DockerClientConfiguration(this.dockerHostname).CreateClient())
.As <IDockerClient>()
.SingleInstance();
// ICombinedConfigProvider<CombinedDockerConfig>
builder.Register(c => new CombinedDockerConfigProvider(this.dockerAuthConfig))
.As <ICombinedConfigProvider <CombinedDockerConfig> >()
.SingleInstance();
// ICommandFactory
builder.Register(
async c =>
{
var dockerClient = c.Resolve <IDockerClient>();
var dockerLoggingConfig = c.Resolve <DockerLoggingConfig>();
var combinedDockerConfigProvider = c.Resolve <ICombinedConfigProvider <CombinedDockerConfig> >();
IConfigSource configSource = await c.Resolve <Task <IConfigSource> >();
var dockerFactory = new DockerCommandFactory(dockerClient, dockerLoggingConfig, configSource, combinedDockerConfigProvider);
return(new LoggingCommandFactory(dockerFactory, c.Resolve <ILoggerFactory>()) as ICommandFactory);
})
.As <Task <ICommandFactory> >()
.SingleInstance();
// IRuntimeInfoProvider
builder.Register(
async c =>
{
IRuntimeInfoProvider runtimeInfoProvider = await RuntimeInfoProvider.CreateAsync(c.Resolve <IDockerClient>());
return(runtimeInfoProvider);
})
.As <Task <IRuntimeInfoProvider> >()
.SingleInstance();
// Task<IEnvironmentProvider>
builder.Register(
async c =>
{
var moduleStateStore = await c.Resolve <Task <IEntityStore <string, ModuleState> > >();
var restartPolicyManager = c.Resolve <IRestartPolicyManager>();
IRuntimeInfoProvider runtimeInfoProvider = await c.Resolve <Task <IRuntimeInfoProvider> >();
IEnvironmentProvider dockerEnvironmentProvider = await DockerEnvironmentProvider.CreateAsync(runtimeInfoProvider, moduleStateStore, restartPolicyManager);
return(dockerEnvironmentProvider);
})
.As <Task <IEnvironmentProvider> >()
.SingleInstance();
// IDeviceManager
builder.Register(c => new NullDeviceManager())
.As <IDeviceManager>()
.SingleInstance();
}
protected override void Load(ContainerBuilder builder)
{
// IModuleClientProvider
builder.Register(c => new EnvironmentModuleClientProvider(this.upstreamProtocol, this.proxy, this.productInfo))
.As <IModuleClientProvider>()
.SingleInstance();
// IModuleManager
builder.Register(c => new ModuleManagementHttpClient(this.managementUri, this.apiVersion, Constants.EdgeletClientApiVersion))
.As <IModuleManager>()
.As <IIdentityManager>()
.SingleInstance();
// IModuleIdentityLifecycleManager
var identityBuilder = new ModuleIdentityProviderServiceBuilder(this.iotHubHostName, this.deviceId, this.gatewayHostName);
builder.Register(c => new ModuleIdentityLifecycleManager(c.Resolve <IIdentityManager>(), identityBuilder, this.workloadUri))
.As <IModuleIdentityLifecycleManager>()
.SingleInstance();
// ICombinedConfigProvider<CombinedDockerConfig>
builder.Register(
async c =>
{
IConfigSource configSource = await c.Resolve <Task <IConfigSource> >();
return(new CombinedEdgeletConfigProvider(this.dockerAuthConfig, configSource) as ICombinedConfigProvider <CombinedDockerConfig>);
})
.As <Task <ICombinedConfigProvider <CombinedDockerConfig> > >()
.SingleInstance();
// ICommandFactory
builder.Register(
async c =>
{
var moduleManager = c.Resolve <IModuleManager>();
ICombinedConfigProvider <CombinedDockerConfig> combinedDockerConfigProvider = await c.Resolve <Task <ICombinedConfigProvider <CombinedDockerConfig> > >();
IConfigSource configSource = await c.Resolve <Task <IConfigSource> >();
var edgeletCommandFactory = new EdgeletCommandFactory <CombinedDockerConfig>(moduleManager, configSource, combinedDockerConfigProvider);
return(new LoggingCommandFactory(edgeletCommandFactory, c.Resolve <ILoggerFactory>()) as ICommandFactory);
})
.As <Task <ICommandFactory> >()
.SingleInstance();
// Task<IRuntimeInfoProvider>
builder.Register(c => Task.FromResult(new RuntimeInfoProvider <DockerReportedConfig>(c.Resolve <IModuleManager>()) as IRuntimeInfoProvider))
.As <Task <IRuntimeInfoProvider> >()
.SingleInstance();
// Task<IEnvironmentProvider>
builder.Register(
async c =>
{
var moduleStateStore = c.Resolve <IEntityStore <string, ModuleState> >();
var restartPolicyManager = c.Resolve <IRestartPolicyManager>();
IRuntimeInfoProvider runtimeInfoProvider = await c.Resolve <Task <IRuntimeInfoProvider> >();
IEnvironmentProvider dockerEnvironmentProvider = await DockerEnvironmentProvider.CreateAsync(runtimeInfoProvider, moduleStateStore, restartPolicyManager);
return(dockerEnvironmentProvider);
})
.As <Task <IEnvironmentProvider> >()
.SingleInstance();
}