public CommandSpec CreateCommandSpec(
string commandName,
IEnumerable<string> args,
string commandPath,
CommandResolutionStrategy resolutionStrategy,
IEnvironmentProvider environment)
{
var useCmdWrapper = false;
if (Path.GetExtension(commandPath).Equals(".cmd", StringComparison.OrdinalIgnoreCase))
{
var preferredCommandPath = environment.GetCommandPath(commandName, ".exe");
if (preferredCommandPath == null)
{
useCmdWrapper = true;
}
else
{
commandPath = preferredCommandPath;
}
}
return useCmdWrapper
? CreateCommandSpecWrappedWithCmd(commandPath, args, resolutionStrategy)
: CreateCommandSpecFromExecutable(commandPath, args, resolutionStrategy);
}
public PackageManager(IFileSystem fileSystem, IEnvironmentProvider environmentProvider)
{
_fileSystem = fileSystem;
_templateEngine = new TemplateEngine(fileSystem);
_logger = LogManager.GetLogger(GetType());
_pluginsLoader = new PluginLoader();
_environmentProvider = environmentProvider;
}
public DotnetFirstTimeUseConfigurer(
INuGetCachePrimer nugetCachePrimer,
INuGetCacheSentinel nugetCacheSentinel,
IEnvironmentProvider environmentProvider)
{
_nugetCachePrimer = nugetCachePrimer;
_nugetCacheSentinel = nugetCacheSentinel;
_environmentProvider = environmentProvider;
}
public CommandSpec CreateCommandSpec(
string commandName,
IEnumerable<string> args,
string commandPath,
CommandResolutionStrategy resolutionStrategy,
IEnvironmentProvider environment)
{
var escapedArgs = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(args);
return new CommandSpec(commandPath, escapedArgs, resolutionStrategy);
}
public static CompositeCommandResolver CreateScriptCommandResolver(
IEnvironmentProvider environment,
IPlatformCommandSpecFactory platformCommandSpecFactory)
{
var compositeCommandResolver = new CompositeCommandResolver();
compositeCommandResolver.AddCommandResolver(new RootedCommandResolver());
compositeCommandResolver.AddCommandResolver(new ProjectPathCommandResolver(environment, platformCommandSpecFactory));
compositeCommandResolver.AddCommandResolver(new AppBaseCommandResolver(environment, platformCommandSpecFactory));
compositeCommandResolver.AddCommandResolver(new PathCommandResolver(environment, platformCommandSpecFactory));
return compositeCommandResolver;
}
public static CompositeCommandResolver CreateDefaultCommandResolver(
IEnvironmentProvider environment,
IPackagedCommandSpecFactory packagedCommandSpecFactory,
IPlatformCommandSpecFactory platformCommandSpecFactory)
{
var compositeCommandResolver = new CompositeCommandResolver();
compositeCommandResolver.AddCommandResolver(new MuxerCommandResolver());
compositeCommandResolver.AddCommandResolver(new RootedCommandResolver());
compositeCommandResolver.AddCommandResolver(new ProjectToolsCommandResolver(packagedCommandSpecFactory));
compositeCommandResolver.AddCommandResolver(new AppBaseDllCommandResolver());
compositeCommandResolver.AddCommandResolver(new AppBaseCommandResolver(environment, platformCommandSpecFactory));
compositeCommandResolver.AddCommandResolver(new PathCommandResolver(environment, platformCommandSpecFactory));
return compositeCommandResolver;
}
public AbstractPathBasedCommandResolver(IEnvironmentProvider environment,
IPlatformCommandSpecFactory commandSpecFactory)
{
if (environment == null)
{
throw new ArgumentNullException(nameof(environment));
}
if (commandSpecFactory == null)
{
throw new ArgumentNullException(nameof(commandSpecFactory));
}
_environment = environment;
_commandSpecFactory = commandSpecFactory;
}
public ProjectDependenciesCommandResolver(
IEnvironmentProvider environment,
IPackagedCommandSpecFactory packagedCommandSpecFactory)
{
if (environment == null)
{
throw new ArgumentNullException("environment");
}
if (packagedCommandSpecFactory == null)
{
throw new ArgumentNullException("packagedCommandSpecFactory");
}
_environment = environment;
_packagedCommandSpecFactory = packagedCommandSpecFactory;
}
protected virtual void OnInitialization()
{
applicationDescription = CreateApplicationDescription();
LogManager.Configuration = CreateLoggingConfigurationBuilder().CreateConfiguration(applicationDescription);
environmentProvider = CreateEnvironmentProvider();
configurationDataProvider = CreateConfigurationProvider(applicationDescription);
log.Info("Starting cli application: {0}",applicationDescription.Name);
var assemblies = FilterAssemblies(applicationDescription.Assemblies);
log.Info("Building application container");
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterInstance(environmentProvider).As<IEnvironmentProvider>();
containerBuilder.RegisterInstance(configurationDataProvider).As<IConfigurationDataProvider>();
containerBuilder.RegisterInstance(applicationDescription).As<IApplicationDescription>();
containerBuilder.RegisterSource(new ConfigurationRegistrationSource(configurationDataProvider,environmentProvider.GetEnvironmentSequence()));
containerBuilder.RegisterAutofacModules(assemblies);
containerBuilder.RegisterDependencyModules(assemblies);
applicationLifetimeScope = containerBuilder.Build();
log.Info("Application container built successfully");
// Execute boottasks
foreach( var bootTask in applicationLifetimeScope.Resolve<IEnumerable<IBootTask>>().OrderByDependencies())
{
log.Info("Executing boottask: {0}",bootTask.GetType().Name.Replace("Boot",string.Empty).Replace("Task",string.Empty));
bootTask.Boot();
}
log.Info("Cli application initialization complete");
}
protected override void Load(ContainerBuilder builder)
{
// IModuleClientProvider
builder.Register(c => new ModuleClientProvider(
c.Resolve <ISdkModuleClientProvider>(),
this.disableDeviceAnalyticsTelemetry ?
Option.None <Task <IRuntimeInfoProvider> >() :
Option.Some(c.Resolve <Task <IRuntimeInfoProvider> >()),
this.upstreamProtocol,
this.proxy,
this.productInfo,
this.closeOnIdleTimeout,
this.idleTimeout,
this.useServerHeartbeat))
.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);
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,
this.checkImagePullBeforeModuleCreate);
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();
// Task<IBackupSource>
builder.Register(
async c =>
{
var serde = c.Resolve <ISerde <DeploymentConfigInfo> >();
var encryptionProviderTask = c.Resolve <Task <IEncryptionProvider> >();
IDeploymentBackupSource backupSource = new DeploymentFileBackup(this.backupConfigFilePath, serde, await encryptionProviderTask);
return(backupSource);
})
.As <Task <IDeploymentBackupSource> >()
.SingleInstance();
// SystemResourcesMetrics
builder.Register(c => new SystemResourcesMetrics(c.Resolve <IMetricsProvider>(), c.Resolve <IModuleManager>().GetSystemResourcesAsync, this.apiVersion, this.performanceMetricsUpdateFrequency))
.As <ISystemResourcesMetrics>()
.SingleInstance();
}
public PackageManager(IEnvironmentProvider environmentProvider)
: this(new PhysicalFileSystem(), environmentProvider)
{
}
public async Task AgentStartsUpModules(TestConfig testConfig)
{
ILoggerFactory loggerFactory = new LoggerFactory()
.AddConsole();
// 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,
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 commandFactory = new LoggingCommandFactory(dockerCommandFactory, loggerFactory);
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);
}
}
public ProjectFactory(IEnvironmentProvider environment)
{
_environment = environment;
}
public WindowsEnvironmentPath(string packageExecutablePath, IReporter reporter, IEnvironmentProvider environmentProvider)
{
_packageExecutablePath = packageExecutablePath ?? throw new ArgumentNullException(nameof(packageExecutablePath));
_reporter = reporter ?? throw new ArgumentNullException(nameof(reporter));
_environmentProvider = environmentProvider ?? throw new ArgumentNullException(nameof(environmentProvider));
}
public FolderBrowser(IEnvironmentProvider environment, string description, bool showNewFolderButton)
: this(environment, description, showNewFolderButton, environment.GetFolderPath(Environment.SpecialFolder.MyDocuments))
{
}
public BuildServiceBase(IEnvironmentProvider environmentProvider)
{
Environment = environmentProvider;
}
public SyslogMessage()
{
EnvironmentProvider = new EnvironmentProvider();
}
public CircleBuildService(IEnvironmentProvider environmentProvider) : base(environmentProvider)
{
}
public ConfigurationFactory(IEnvironmentProvider environmentProvider, IEnumerable <IAdditionalConfigurationSource> additionalConfigurations) : base(environmentProvider, additionalConfigurations, null)
{
}
public EnvironmentsController(IEnvironmentProvider provider)
{
_provider = provider;
}
public AdminService(IEnvironmentProvider envProvider)
{
_envProvider = envProvider;
}
public ReferenceConfigProvider(IPersistanceService <ReferenceSettings> persister, IEnvironmentProvider environment, IVBEEvents events)
{
_persister = persister;
_environment = environment;
_events = events;
var settings = Create();
_listening = settings.AddToRecentOnReferenceEvents;
if (_listening && _events != null)
{
_events.ProjectReferenceAdded += ReferenceAddedHandler;
}
}
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> >();
ICommandFactory factory = new DockerCommandFactory(dockerClient, dockerLoggingConfig, configSource, combinedDockerConfigProvider);
factory = new MetricsCommandFactory(factory, c.Resolve <IMetricsProvider>());
return(new LoggingCommandFactory(factory, 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, CancellationToken.None);
return(dockerEnvironmentProvider);
})
.As <Task <IEnvironmentProvider> >()
.SingleInstance();
// Task<IBackupSource>
builder.Register(
async c =>
{
var serde = c.Resolve <ISerde <DeploymentConfigInfo> >();
var encryptionProviderTask = c.Resolve <Task <IEncryptionProvider> >();
IDeploymentBackupSource backupSource = new DeploymentFileBackup(this.backupConfigFilePath, serde, await encryptionProviderTask);
return(backupSource);
})
.As <Task <IDeploymentBackupSource> >()
.SingleInstance();
// IDeviceManager
builder.Register(c => new NullDeviceManager())
.As <IDeviceManager>()
.SingleInstance();
}
private void OneTimeInitialization()
{
applicationDescription = CreateApplicationDescription();
LogManager.Configuration = CreateLoggingConfigurationBuilder().CreateConfiguration(applicationDescription);
environmentProvider = CreateEnvironmentProvider();
configurationDataProvider = CreateConfigurationProvider(applicationDescription);
log.Info("Starting web application: {0}",applicationDescription.Name);
var assemblies = FilterAssemblies(applicationDescription.Assemblies);
log.Info("Building application container");
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterInstance(environmentProvider).As<IEnvironmentProvider>();
containerBuilder.RegisterInstance(configurationDataProvider).As<IConfigurationDataProvider>();
containerBuilder.RegisterInstance(applicationDescription).As<IApplicationDescription>();
containerBuilder.RegisterInstance(GlobalConfiguration.Configuration).As<HttpConfiguration>();
containerBuilder.RegisterSource(new ConfigurationRegistrationSource(configurationDataProvider,environmentProvider.GetEnvironmentSequence()));
containerBuilder.RegisterAutofacModules(assemblies);
containerBuilder.RegisterDependencyModules(assemblies);
applicationLifetimeScope = containerBuilder.Build();
log.Info("Application container built successfully");
DependencyResolver.SetResolver(new AutofacDependencyResolver(applicationLifetimeScope));
GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(applicationLifetimeScope);
// Documentation provider:
var documentationFilename = Server.MapPath("~/bin/" + GetType().BaseType.Assembly.GetName().Name + ".xml");
if (File.Exists(documentationFilename))
{
GlobalConfiguration.Configuration.SetDocumentationProvider(
new XmlDocumentationProvider(documentationFilename));
}
else
{
log.Warn("Could not find documentation file: {0}",documentationFilename);
}
// Register areas
foreach( var areaRegistration in applicationLifetimeScope.Resolve<IEnumerable<AreaRegistration>>().OrderByDependencies())
{
log.Info("Registering area: {0}",areaRegistration.AreaName);
var areaRegistrationContext = new AreaRegistrationContext(areaRegistration.AreaName, RouteTable.Routes);
areaRegistration.RegisterArea(areaRegistrationContext);
}
// Register routes
foreach (var routeModule in applicationLifetimeScope.Resolve<IEnumerable<IRouteRegistrar>>().OrderByDependencies())
{
log.Info("Registering routes from registrar: {0}", routeModule.GetType().Name.Replace("Route", string.Empty).Replace("Registrar", string.Empty));
routeModule.RegisterRoutes(RouteTable.Routes);
}
// Execute boottasks
foreach( var bootTask in applicationLifetimeScope.Resolve<IEnumerable<IBootTask>>().OrderByDependencies())
{
log.Info("Executing boottask: {0}",bootTask.GetType().Name.Replace("Boot",string.Empty).Replace("Task",string.Empty));
bootTask.Boot();
}
log.Info("Web application initialization complete");
}
private IEnumerable<string> GetAllowedCommandExtensionsFromEnvironment(IEnvironmentProvider environment)
{
var allowedCommandExtensions = new List<string>();
allowedCommandExtensions.AddRange(environment.ExecutableExtensions);
allowedCommandExtensions.Add(FileNameSuffixes.DotNet.DynamicLib);
return allowedCommandExtensions;
}
public SyslogMessage()
{
EnvironmentProvider = DefaultEnvironment;
}
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>();
bool enableSubscriptions = !this.experimentalFeatures.DisableCloudSubscriptions;
IEdgeAgentConnection edgeAgentConnection = new EdgeAgentConnection(deviceClientprovider, serde, requestManager, 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 serde = c.Resolve <ISerde <DeploymentConfigInfo> >();
var edgeAgentConnection = c.Resolve <IEdgeAgentConnection>();
IEncryptionProvider encryptionProvider = await c.Resolve <Task <IEncryptionProvider> >();
var twinConfigSource = new TwinConfigSource(edgeAgentConnection, this.configuration);
IConfigSource backupConfigSource = new FileBackupConfigSource(this.backupConfigFilePath, twinConfigSource, serde, encryptionProvider);
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);
}
public ArchiveNameProvider(IFileProvider fileProvider, IEnvironmentProvider environmentProvider)
{
_fileProvider = fileProvider;
_environmentProvider = environmentProvider;
}
public FolderBrowser(IEnvironmentProvider environment, string description)
: this(environment, description, true)
{
}
public ConfigurationFactory(IEnvironmentProvider environmentProvider,
IEnumerable <IAdditionalConfigurationSource> additionalConfigurations)
{
_environmentProvider = environmentProvider;
_additionalConfigurations = additionalConfigurations;
}
protected override void Load(ContainerBuilder builder)
{
// IModuleClientProvider
builder.Register(c => new EnvironmentModuleClientProvider(this.upstreamProtocol, this.productInfo))
.As <IModuleClientProvider>()
.SingleInstance();
// IModuleManager
builder.Register(c => new ModuleManagementHttpClient(this.managementUri))
.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();
// IModuleRuntimeInfoProvider
builder.Register(c => new RuntimeInfoProvider <DockerReportedConfig>(c.Resolve <IModuleManager>()))
.As <IRuntimeInfoProvider>()
.SingleInstance();
// Task<IEnvironmentProvider>
builder.Register(
async c =>
{
var moduleStateStore = c.Resolve <IEntityStore <string, ModuleState> >();
var restartPolicyManager = c.Resolve <IRestartPolicyManager>();
var runtimeInfoProvider = c.Resolve <IRuntimeInfoProvider>();
IEnvironmentProvider dockerEnvironmentProvider = await DockerEnvironmentProvider.CreateAsync(runtimeInfoProvider, moduleStateStore, restartPolicyManager);
return(dockerEnvironmentProvider);
})
.As <Task <IEnvironmentProvider> >()
.SingleInstance();
}
public static async Task <Agent> Create(IConfigSource configSource, IPlanner planner, IPlanRunner planRunner, IReporter reporter,
IModuleIdentityLifecycleManager moduleIdentityLifecycleManager, IEnvironmentProvider environmentProvider,
IEntityStore <string, string> configStore, ISerde <DeploymentConfigInfo> deploymentConfigInfoSerde, IEncryptionProvider encryptionProvider)
{
Preconditions.CheckNotNull(deploymentConfigInfoSerde, nameof(deploymentConfigInfoSerde));
Preconditions.CheckNotNull(configStore, nameof(configStore));
Option <DeploymentConfigInfo> deploymentConfigInfo = Option.None <DeploymentConfigInfo>();
try
{
Option <string> deploymentConfigInfoJson = await Preconditions.CheckNotNull(configStore, nameof(configStore)).Get(StoreConfigKey);
await deploymentConfigInfoJson.ForEachAsync(async json =>
{
string decryptedJson = await encryptionProvider.DecryptAsync(json);
deploymentConfigInfo = Option.Some(deploymentConfigInfoSerde.Deserialize(decryptedJson));
});
}
catch (Exception ex) when(!ex.IsFatal())
{
Events.ErrorDeserializingConfig(ex);
}
var agent = new Agent(configSource, environmentProvider, planner, planRunner, reporter, moduleIdentityLifecycleManager,
configStore, deploymentConfigInfo.GetOrElse(DeploymentConfigInfo.Empty), deploymentConfigInfoSerde, encryptionProvider);
return(agent);
}
public CommonSettings()
{
_selectFolder = new RelayCommand(SelectFolder, x => true);
_environmentProvider = ServiceLocator.Current.GetInstance <IEnvironmentProvider>();
}
public OutputPathCommandResolver(IEnvironmentProvider environment,
IPlatformCommandSpecFactory commandSpecFactory) : base(environment, commandSpecFactory)
{ }
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>()
.As <IDeviceManager>()
.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 metricsProvider = c.Resolve <IMetricsProvider>();
var loggerFactory = c.Resolve <ILoggerFactory>();
ICommandFactory factory = new KubernetesCommandFactory();
factory = new MetricsCommandFactory(factory, metricsProvider);
factory = new LoggingCommandFactory(factory, 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.resourceName,
this.deviceSelector,
this.deviceNamespace,
c.Resolve <IKubernetes>(),
commandFactory,
configProvider,
this.moduleOwner);
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();
// Task<IDeploymentBackupSource>
builder.Register(
c =>
{
var serde = c.Resolve <ISerde <DeploymentConfigInfo> >();
IDeploymentBackupSource backupSource = new DeploymentSecretBackup(Constants.EdgeAgentBackupName, this.deviceNamespace, this.moduleOwner, serde, c.Resolve <IKubernetes>());
return(Task.FromResult(backupSource));
})
.As <Task <IDeploymentBackupSource> >()
.SingleInstance();
// KubernetesDeploymentProvider
builder.Register(
c => new KubernetesDeploymentMapper(
this.deviceNamespace,
this.edgeDeviceHostName,
this.proxyImage,
this.proxyImagePullSecretName,
this.proxyConfigPath,
this.proxyConfigVolumeName,
this.proxyConfigMapName,
this.proxyTrustBundlePath,
this.proxyTrustBundleVolumeName,
this.proxyTrustBundleConfigMapName,
this.defaultMapServiceType,
this.persistentVolumeName,
this.storageClassName,
this.persistentVolumeClaimSizeMb,
this.apiVersion,
this.workloadUri,
this.managementUri,
this.runAsNonRoot,
this.enableServiceCallTracing,
this.experimentalFeatures.GetEnvVars()))
.As <IKubernetesDeploymentMapper>();
// KubernetesServiceMapper
builder.Register(c => new KubernetesServiceMapper(this.defaultMapServiceType))
.As <IKubernetesServiceMapper>();
// KubernetesPvcMapper
builder.Register(c => new KubernetesPvcMapper(this.persistentVolumeName, this.storageClassName, this.persistentVolumeClaimSizeMb.OrDefault()))
.As <IKubernetesPvcMapper>();
// KubernetesServiceAccountProvider
builder.Register(c => new KubernetesServiceAccountMapper())
.As <IKubernetesServiceAccountMapper>();
// EdgeDeploymentController
builder.Register(
c =>
{
IEdgeDeploymentController watchOperator = new EdgeDeploymentController(
this.resourceName,
this.deviceSelector,
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 =>
{
CancellationTokenSource tokenSource = new CancellationTokenSource(SystemInfoTimeout);
var moduleStateStore = await c.Resolve <Task <IEntityStore <string, ModuleState> > >();
IRuntimeInfoProvider runtimeInfoProvider = c.Resolve <IRuntimeInfoProvider>();
IEnvironmentProvider kubernetesEnvironmentProvider = await KubernetesEnvironmentProvider.CreateAsync(runtimeInfoProvider, moduleStateStore, tokenSource.Token);
return(kubernetesEnvironmentProvider);
})
.As <Task <IEnvironmentProvider> >()
.SingleInstance();
}
private ProjectPathCommandResolver SetupPlatformProjectPathCommandResolver(
IEnvironmentProvider environment = null,
bool forceGeneric = false)
{
environment = environment ?? new EnvironmentProvider();
IPlatformCommandSpecFactory platformCommandSpecFactory = new GenericPlatformCommandSpecFactory();
if (RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows
&& !forceGeneric)
{
platformCommandSpecFactory = new WindowsExePreferredCommandSpecFactory();
}
var projectPathCommandResolver = new ProjectPathCommandResolver(environment, platformCommandSpecFactory);
return projectPathCommandResolver;
}
protected override void Load(ContainerBuilder builder)
{
// IDeviceClientProvider
string edgeAgentConnectionString = $"{this.edgeDeviceConnectionString};{Constants.ModuleIdKey}={Constants.EdgeAgentModuleIdentityName}";
builder.Register(c => new ModuleClientProvider(edgeAgentConnectionString, this.upstreamProtocol, this.productInfo))
.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 = 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();
}
/// <summary>
/// Request the test agent environment for the job
/// </summary>
/// <param name="job">job</param>
/// <param name="provider">environment provider</param>
public void RequestTestAgentEnvironmentForJob(AutomationJob job, IEnvironmentProvider provider)
{
SupportedEnvironment supportEnvironment = job.GetSupportedEnv();
AutomationTask task = JobManagement.GetAutomationTaskOfJob(job);
string templateName = new TestEnvironmentConfigHelper(supportEnvironment.Config).TestAgentConfiguration.Name;
string environmentName = string.Format("{0}_{1}_{2}_{3}", task.Name, job.JobId, "TestAgent", Guid.NewGuid());
TestEnvironmentConfigHelper sutConfig = new TestEnvironmentConfigHelper(supportEnvironment.Config);
// Get the avaliable permenent agent, typically we maintain a pool of machines act as the test agent, no need to deploy new vApps
// If no available agents in the pool now, we'll create a new vApp from the template with name of templateName
TestEnvironment availableReadyStaticAgent = TestEnvironment.GetAvalibleStaticTestAgent4SupportedEnvironment(supportEnvironment);
EnvironmentDeploymentType deployType = new TestEnvironmentConfigHelper(supportEnvironment.Config).TestAgentConfiguration.DeploymentType;
if (deployType == EnvironmentDeploymentType.Existing )
{
if (availableReadyStaticAgent != null)
{
string info = string.Format("Find one avaliable permanent test agent [{0}:{1}] for job [{2}]", availableReadyStaticAgent.EnvironmentId, availableReadyStaticAgent.Name, job.Name);
availableReadyStaticAgent.SetEnvironmentStatus(EnvironmentStatus.MachinesReady);
ATFEnvironment.Log.logger.Info(info);
job.AddJobProgressInformation(info);
// set SUT information to test agent's config
// set test agent type to TestAgentAlone
/*
TestEnvironmentConfigHelper testAgentConfig = new TestEnvironmentConfigHelper(availableReadyStaticAgent.Config);
testAgentConfig.SUTConfiguration = sutConfig.SUTConfiguration;
testAgentConfig.Type = EnvironmentType.TestAgentAlone;
availableReadyStaticAgent.Config = testAgentConfig.ToXML();
info = string.Format("Change the permanent agent's status, AgentServiceInstalledAndReady -> Ocuppied");
ATFEnvironment.Log.logger.Info(info);
job.AddJobProgressInformation(info);
// Set this permanent agent to occuppied
//availableReadyStaticAgent.Status = (int)EnvironmentStatus.Ocuppied;
//availableReadyStaticAgent.Update();
TestEnvironmentConfigHelper config = new TestEnvironmentConfigHelper(availableReadyStaticAgent.Config);
//clear the finished job information
config.TestAgentConfiguration.Categories.Clear();
//add the jobId into the configuration file to let the Test Agent know which job the test agent is for.
config.TestAgentConfiguration.Categories.Add("JobId=" + job.JobId.ToString());
availableReadyStaticAgent.Config = config.ToXML();
availableReadyStaticAgent.Update();
//copy the config file to the test agent
List<Machine> testAgents = GetMachinesNeedTestAgentInstalledOn(config);
string ip = testAgents.Count() > 0 ? testAgents[0].ExternalIP : string.Empty;
string domain = config.TestAgentConfiguration.TestAgentDomainConfig.Name;
string administrator = config.TestAgentConfiguration.TestAgentDomainConfig.Adminstrator;
string password = config.TestAgentConfiguration.TestAgentDomainConfig.Password;
string targetPath = @"\\" + ip + @"\C$\SaberAgent";
string targetEnvironmentConfigFolder = targetPath + @"\Config";
string targetEnvironmentConfigFile = targetEnvironmentConfigFolder + @"\Environment.xml";
if (!NetUseHelper.NetUserMachine(ip, domain + @"\" + administrator, password))
{
ATFEnvironment.Log.logger.Error(string.Format("Net use the machine [{0}] failed.", ip));
}
Common.ScriptCommon.CMDScript.FlushDNSRemotely(ip, domain + @"\" + administrator, password);
if (!FileHelper.IsExistsFolder(targetEnvironmentConfigFolder))
{
FileHelper.CreateFolder(targetEnvironmentConfigFolder);
}
TXTHelper.ClearTXTContent(targetEnvironmentConfigFile);
TXTHelper.WriteNewLine(targetEnvironmentConfigFile, config.ToXML(), System.Text.Encoding.Default);
info = string.Format("Copy the file[{0}] to permanent agent", targetEnvironmentConfigFile);
ATFEnvironment.Log.logger.Info(info);
job.AddJobProgressInformation(info);
*/
job.SetTestAgentEnvironment(availableReadyStaticAgent.EnvironmentId);
}
else
{
string info = string.Format("There's no available test agents right now, please wait other tasks to free some environments.");
ATFEnvironment.Log.logger.Info(info);
job.AddJobProgressInformation(info);
}
}
else
{
//create a new record in DB for Test Agent, and Galaxy will handle the environment later(install, config and so on)
sutConfig.TestAgentConfiguration.DeploymentType = EnvironmentDeploymentType.ToBeCreated;
sutConfig.Type = EnvironmentType.TestAgentAlone;
string config = sutConfig.ToXML();
try
{
var testEnvironment = new TestEnvironment
{
ProviderId = provider.Provider.ProviderId,
Name = environmentName,
Type = provider.Provider.Name,
Status = (int)EnvironmentStatus.New,
CreateDate = DateTime.UtcNow,
ModifyDate = DateTime.UtcNow,
//Config = EnvironmentConfigHelper.SetResidenceType(supportEnvironment.Config, EnvironmentType.TestAgentAlone),
Config = config,
Description = templateName,
};
if (job.JobStatus == JobStatus.Cancelled || job.JobStatus == JobStatus.End)
{
testEnvironment.SetEnvironmentStatus(EnvironmentStatus.Discard);
}
TestEnvironment.Add(testEnvironment);
job.SetTestAgentEnvironment(testEnvironment.EnvironmentId);
}
catch (Exception ex)
{
job.SetJobsStatus(JobStatus.Failed);
string info = string.Format("Failed to request Test Agent environment {0}, Exception: {1}", environmentName, ex.Message);
job.AddJobProgressInformation(info);
ATFEnvironment.Log.logger.Error(info, ex);
}
}
}
public ReferenceConfigProvider(IPersistenceService <ReferenceSettings> persister, IEnvironmentProvider environment, IVbeEvents events)
: base(persister, new DefaultSettings <ReferenceSettings, Properties.Settings>())
{
_environment = environment;
_events = events;
var settings = Read();
_listening = settings.AddToRecentOnReferenceEvents;
if (_listening && _events != null)
{
_events.ProjectReferenceAdded += ReferenceAddedHandler;
}
}
public static IEnvironmentPathInstruction CreateEnvironmentPathInstruction(
CliFolderPathCalculator cliFolderPathCalculator = null,
IEnvironmentProvider environmentProvider = null)
{
return(CreateEnvironmentPath(cliFolderPathCalculator, true, environmentProvider));
}
public MetricsLogger(IEnvironmentProvider environmentProvider, MetricsContext metricsContext)
{
_context = metricsContext;
_environment = environmentProvider.ResolveEnvironment();
_environmentProvider = environmentProvider;
}
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))
.SingleInstance();
}
public ProjectPathCommandResolver(IEnvironmentProvider environment,
IPlatformCommandSpecFactory commandSpecFactory) : base(environment, commandSpecFactory)
{
}
public PackageManager(IEnvironmentProvider environmentProvider)
: this(new PhysicalFileSystem(), environmentProvider)
{
}
private AppBaseCommandResolver SetupPlatformAppBaseCommandResolver(
IEnvironmentProvider environment = null,
bool forceGeneric = false)
{
environment = environment ?? new EnvironmentProvider();
IPlatformCommandSpecFactory platformCommandSpecFactory = new GenericPlatformCommandSpecFactory();
if (PlatformServices.Default.Runtime.OperatingSystemPlatform == Platform.Windows
&& !forceGeneric)
{
platformCommandSpecFactory = new WindowsExePreferredCommandSpecFactory();
}
var appBaseCommandResolver = new AppBaseCommandResolver(environment, platformCommandSpecFactory);
return appBaseCommandResolver;
}
public EnvironmentController(IEnvironmentProvider provider, JwtTokenProvider tokenProvider)
{
EnvProvider = provider;
TokenProvider = tokenProvider;
}
private ProjectDependenciesCommandResolver SetupProjectDependenciesCommandResolver(
IEnvironmentProvider environment = null,
IPackagedCommandSpecFactory packagedCommandSpecFactory = null)
{
environment = environment ?? new EnvironmentProvider();
packagedCommandSpecFactory = packagedCommandSpecFactory ?? new PackagedCommandSpecFactory();
var projectDependenciesCommandResolver = new ProjectDependenciesCommandResolver(environment, packagedCommandSpecFactory);
return projectDependenciesCommandResolver;
}
/// <summary>
/// Request the sut environment for job
/// </summary>
/// <param name="job">job</param>
/// <param name="provider">environment provider</param>
public void RequestSUTEnvironmentForJob(AutomationJob job, IEnvironmentProvider provider)
{
SupportedEnvironment supportEnvironment = job.GetSupportedEnv();
TestEnvironmentConfigHelper config = new TestEnvironmentConfigHelper(supportEnvironment.Config);
string templateName = config.SUTConfiguration.Name;
string sutConfig = string.Empty;
if (config.Type == EnvironmentType.Residence_Seperate)
{
sutConfig = EnvironmentConfigHelper.SetResidenceType(supportEnvironment.Config, EnvironmentType.SUTAlone);
}
else if (config.Type == EnvironmentType.Residence_Together)
{
sutConfig = EnvironmentConfigHelper.SetResidenceType(supportEnvironment.Config, EnvironmentType.Residence_Together);
}
AutomationTask task = JobManagement.GetAutomationTaskOfJob(job);
if (config.SUTConfiguration.DeploymentType == EnvironmentDeploymentType.Existing)
{
//Note: the existing SUT environments are distinguished by it's name, two environments with same name are considered as the same one
var sutEnvironment = TestEnvironment.GetAvalibleStaticSUT4SupportedEnvironment(supportEnvironment);
if (sutEnvironment == null)//wait untill another environment is freed
{
string info = string.Format("There's no SUT environment in the pool available now, please wait for other tasks to free any environment.");
ATFEnvironment.Log.logger.Info(info);
job.AddJobProgressInformation(info);
}
else//reuse the record
{
string message = string.Format("Get an available SUT environment [{0}] for the job [{1}:{2}]", sutEnvironment.Name, job.JobId, job.Name);
job.AddJobProgressInformation(message);
message = string.Format("Change environment [{0}:{1}] status from {2} to {3}", sutEnvironment.EnvironmentId, sutEnvironment.Name, sutEnvironment.Status, "MachinesReady");
job.AddJobProgressInformation(message);
sutEnvironment.SetEnvironmentStatus(EnvironmentStatus.MachinesReady);
job.SetSUTEnvironment(sutEnvironment.EnvironmentId);
}
}
else
{
string environmentName = string.Format("{0}_{1}_{2}_{3}", task.Name, job.JobId, "SUT", Guid.NewGuid());
try
{
var testEnvironment = new TestEnvironment
{
ProviderId = provider.Provider.ProviderId,
Name = environmentName,
Type = provider.Provider.Name,
CreateDate = DateTime.UtcNow,
ModifyDate = DateTime.UtcNow,
Config = sutConfig,
Description = templateName,
};
if (job.JobStatus == JobStatus.Cancelled || job.JobStatus == JobStatus.End)
testEnvironment.SetEnvironmentStatus(EnvironmentStatus.Discard);
TestEnvironment.Add(testEnvironment);
string message = string.Format("Environment [{0}:{1} is created for job [{2}:{3}]]", testEnvironment.EnvironmentId, testEnvironment.Name, job.JobId, job.Name);
job.AddJobProgressInformation(message);
job.SetSUTEnvironment(testEnvironment.EnvironmentId);
}
catch (Exception ex)
{
string info = string.Format("Failed to assign {0}, Exception: {1}", environmentName, ex.Message);
job.SetJobsStatus(JobStatus.Failed);
job.AddJobProgressInformation(info);
ATFEnvironment.Log.logger.Error(info, ex);
}
}
}
