public EdgeRuntimeDiagnosticsUploadTest()
{
var connectionMock = new Mock <IEdgeAgentConnection>();
connectionMock.Setup(c => c.SendEventAsync(It.IsAny <Message>())).Callback((Action <Message>)(message => this.lastUploadResult.Add(message))).Returns(Task.CompletedTask);
this.mockConnection = connectionMock.Object;
}
public EdgeRuntimeDiagnosticsUploadTest()
{
var connectionMock = new Mock <IEdgeAgentConnection>();
connectionMock.Setup(c => c.SendEventBatchAsync(It.IsAny <IEnumerable <Message> >())).Callback((Action <IEnumerable <Message> >)(data => this.lastUploadResult = data.ToArray())).Returns(Task.CompletedTask);
this.mockConnection = connectionMock.Object;
}
public IoTHubReporter(
IEdgeAgentConnection edgeAgentConnection,
ISerde <AgentState> agentStateSerde,
VersionInfo versionInfo)
{
this.edgeAgentConnection = Preconditions.CheckNotNull(edgeAgentConnection, nameof(edgeAgentConnection));
this.agentStateSerde = Preconditions.CheckNotNull(agentStateSerde, nameof(agentStateSerde));
this.versionInfo = Preconditions.CheckNotNull(versionInfo, nameof(versionInfo));
this.sync = new AsyncLock();
this.reportedState = Option.None <AgentState>();
}
public TwinConfigSource(IEdgeAgentConnection edgeAgentConnection, IConfiguration configuration)
{
this.Configuration = Preconditions.CheckNotNull(configuration, nameof(configuration));
this.edgeAgentConnection = Preconditions.CheckNotNull(edgeAgentConnection, nameof(edgeAgentConnection));
Events.Created();
}
public StreamRequestListener(IStreamRequestHandlerProvider streamRequestHandlerProvider, IEdgeAgentConnection edgeAgentConnection, int maxConcurrentStreams = 10)
{
this.streamRequestHandlerProvider = Preconditions.CheckNotNull(streamRequestHandlerProvider, nameof(streamRequestHandlerProvider));
this.streamLock = new SemaphoreSlim(maxConcurrentStreams);
this.maxConcurrentStreams = maxConcurrentStreams;
this.moduleConnection = Preconditions.CheckNotNull(edgeAgentConnection, nameof(edgeAgentConnection)).ModuleConnection;
}
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<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),
new LogsRequestHandler(logsProvider, runtimeInfoProvider),
new TaskStatusRequestHandler()
};
return(new RequestManager(requestHandlers, this.requestTimeout) as IRequestManager);
})
.As <Task <IRequestManager> >()
.SingleInstance();
// ISdkModuleClientProvider
builder.Register(c => new SdkModuleClientProvider())
.As <ISdkModuleClientProvider>()
.SingleInstance();
// Task<IEdgeAgentConnection>
builder.Register(
async c =>
{
var serde = c.Resolve <ISerde <DeploymentConfig> >();
var deviceClientprovider = c.Resolve <IModuleClientProvider>();
var requestManagerTask = c.Resolve <Task <IRequestManager> >();
IRequestManager requestManager = await requestManagerTask;
IEdgeAgentConnection edgeAgentConnection = new EdgeAgentConnection(deviceClientprovider, serde, requestManager, this.enableSubscriptions, this.configRefreshFrequency);
return(edgeAgentConnection);
})
.As <Task <IEdgeAgentConnection> >()
.SingleInstance();
// Task<IStreamRequestListener>
builder.Register(
async c =>
{
if (this.enableStreams)
{
var runtimeInfoProviderTask = c.Resolve <Task <IRuntimeInfoProvider> >();
var logsProviderTask = c.Resolve <Task <ILogsProvider> >();
var edgeAgentConnectionTask = c.Resolve <Task <IEdgeAgentConnection> >();
IRuntimeInfoProvider runtimeInfoProvider = await runtimeInfoProviderTask;
ILogsProvider logsProvider = await logsProviderTask;
IEdgeAgentConnection edgeAgentConnection = await edgeAgentConnectionTask;
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 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 EdgeRuntimeDiagnosticsUpload(IEdgeAgentConnection edgeAgentConnection)
{
this.edgeAgentConnection = Preconditions.CheckNotNull(edgeAgentConnection, nameof(edgeAgentConnection));
}
