internal static UdpBindingCollectionElement GetBindingCollectionElement()
{
return((UdpBindingCollectionElement)ConfigurationHelpers.GetBindingCollectionElement(UdpTransportConfigurationStrings.UdpBindingElementName));
}
/// <summary>
/// Override to add registrations to the container.
/// </summary>
/// <param name="builder">The builder through which components can be registered.</param>
/// <remarks>
/// Note that the ContainerBuilder parameter is not the same one
/// that the module is being registered by (i.e. it can have its own defaults).
/// </remarks>
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
// Register the global application objects
{
builder.Register(c => new DependencyInjectionProxy(
c.Resolve <IContainer>()))
.As <IDependencyInjectionProxy>();
builder.Register(c => new FeedbackReportCollector(
c.Resolve <IFileSystem>()))
.As <ICollectFeedbackReports>();
builder.Register(c => new FeedbackReportTransmitter(
c.Resolve <IReportSender>()))
.As <ISendFeedbackReports>();
builder.Register(c => new TimingReportCollection())
.SingleInstance();
builder.Register(
c =>
{
Func <string, IDisposable> result = description => null;
if (ConfigurationHelpers.ShouldBeProfiling())
{
// Autofac 2.4.5 forces the 'c' variable to disappear. See here:
// http://stackoverflow.com/questions/5383888/autofac-registration-issue-in-release-v2-4-5-724
var ctx = c.Resolve <IComponentContext>();
Func <TimingReport, string> reportBuilder =
report =>
{
var stream = new MemoryStream();
Func <Stream> streamFactory = () => stream;
var transformer = ctx.Resolve <TextReporter>(
new Autofac.Core.Parameter[]
{
new TypedParameter(typeof(Func <Stream>), streamFactory)
});
transformer.Transform(report);
// normally you can't touch the stream anymore, but it turns out you
// can touch the actual buffer
var buffer = stream.GetBuffer();
var outputString = Encoding.Unicode.GetString(buffer, 0, buffer.Length);
// Note that the result may have terminating characters, multiple of them
// because we don't know the amount of data written to the buffer.
return(outputString.Replace("\0", string.Empty));
};
result =
description =>
new TimingIntervalHelper(
ctx.Resolve <SystemDiagnostics>(),
ctx.Resolve <IGenerateTimingReports>(),
ctx.Resolve <TimingReportCollection>(),
reportBuilder,
description);
}
return(result);
})
.SingleInstance();
builder.Register(c => new FileSystem())
.As <IFileSystem>();
}
}
private static ITaskProcessorClientConfiguration GetClientConfiguration(string configFileName)
{
string configFilePath = Path.Combine("Configuration", "Client", configFileName + ".config");
return(ConfigurationHelpers.Load <ClientConfigurationSection>(ClientConfigurationSection.SectionName, configFilePath));
}
internal static NetMsmqBindingCollectionElement GetBindingCollectionElement()
{
return((NetMsmqBindingCollectionElement)ConfigurationHelpers.GetBindingCollectionElement("netMsmqBinding"));
}
private static void Main(string[] args)
{
Console.WriteLine("=======================================================================");
Console.WriteLine(AssemblyInformationHelper.HeaderMessage);
Console.WriteLine("=======================================================================");
Console.WriteLine(">> Loading configurations....");
try
{
//Configuration
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.AddJsonFile("devicesettings.json", optional: false, reloadOnChange: true)
.AddJsonFile("modulessettings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables();
_environmentName = Environment.GetEnvironmentVariable("ENVIRONMENT");
if (string.IsNullOrWhiteSpace(_environmentName))
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("No environment platform has been found. Default setting: Development.");
_environmentName = "Development";
Console.ResetColor();
}
try
{
ConfigurationHelpers.CheckEnvironmentConfigurationFiles(_environmentName);
}
catch (MissingEnvironmentConfigurationFileException ex)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(ex.Message);
Console.ResetColor();
Console.WriteLine("Execution will continue with default settings in appsettings.json, devicesettings.json and modulessettings.json.");
}
builder.AddJsonFile($"appsettings.{_environmentName}.json", optional: true, reloadOnChange: true);
builder.AddJsonFile($"devicesettings.{_environmentName}.json", optional: true, reloadOnChange: true);
builder.AddJsonFile($"modulessettings.{_environmentName}.json", optional: true, reloadOnChange: true);
Configuration = builder.Build();
//Service provider and DI
IServiceCollection services = new ServiceCollection();
ConfigureServices(services);
var deviceSettings = Configuration.Get <DeviceSettings>();
if (deviceSettings == null)
{
throw new ArgumentException("No device settings have been configured.");
}
if (deviceSettings.SimulationSettings == null)
{
throw new ArgumentException("No device simulation settings have been configured.");
}
if (deviceSettings.SimulationSettings.EnableDevice || deviceSettings.SimulationSettings.EnableModules)
{
//If any of the simulators is enabled, messaging services will be required to build the messages.
RegisterMessagingServices(services);
}
if (deviceSettings.SimulationSettings.EnableDevice)
{
RegisterDeviceSimulators(services);
}
if (deviceSettings.SimulationSettings.EnableModules)
{
RegisterModuleSimulators(deviceSettings, services);
}
IServiceProvider serviceProvider = services.BuildServiceProvider();
//Logger
var logger = serviceProvider.GetService <ILoggerFactory>().CreateLogger <Program>();
logger.LogDebug("PROGRAM::Settings, DI and logger configured and ready to use.");
//Simulators
if (!deviceSettings.SimulationSettings.EnableDevice && !deviceSettings.SimulationSettings.EnableModules)
{
logger.LogDebug("PROGRAM::No simulator has been configured.");
}
else
{
if (deviceSettings.SimulationSettings.EnableDevice)
{
StartDevicesSimulators(serviceProvider, logger);
}
if (deviceSettings.SimulationSettings.EnableModules)
{
StartModulesSimulators(serviceProvider, logger);
}
}
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(ex.Message);
Console.ResetColor();
}
finally
{
Console.ReadLine();
}
}
public async Task InitiateSimulationAsync()
{
string logPrefix = "system".BuildLogPrefix();
//Connectivity tests
//Control if a connection string exists (ideally, stored in TPM/HSM or any secured location.
//If there is no connection string, check if the DPS settings are provided.
//If so, provision the device and persist the connection string for upcoming boots.
if (string.IsNullOrEmpty(_deviceSettingsDelegate.CurrentValue.ConnectionString))
{
string connectionString = await _provisioningService.ProvisionDevice();
if (!string.IsNullOrEmpty(connectionString))
{
_deviceSettingsDelegate.CurrentValue.ConnectionString = connectionString;
}
else
{
throw new Exception($"{logPrefix}::{_deviceSettingsDelegate.CurrentValue.ArtifactId}::An issue occured during the provisioning process or the connetion string building process.");
}
_logger.LogWarning($"{logPrefix}::{_deviceSettingsDelegate.CurrentValue.ArtifactId}::Device connection string being persisted.");
await ConfigurationHelpers.WriteDeviceSettings(_deviceSettingsDelegate.CurrentValue, _environmentName);
}
//At this stage, the connection string should be set properly and the device client should be able to communicate with the IoT Hub with no issues.
try
{
IoTTools.CheckDeviceConnectionStringData(_deviceSettingsDelegate.CurrentValue.ConnectionString, _logger);
// Connect to the IoT hub using the MQTT protocol
if (_dpsSettings.GroupEnrollment != null)
{
if (_dpsSettings.GroupEnrollment.SecurityType == SecurityType.SymmetricKey)
{
_deviceClient = DeviceClient.CreateFromConnectionString(
_deviceSettingsDelegate.CurrentValue.ConnectionString,
_dpsSettings.GroupEnrollment.SymmetricKeySettings.TransportType);
}
else if (_dpsSettings.GroupEnrollment.SecurityType == SecurityType.X509CA)
{
string deviceCertificateFullPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, _dpsSettings.GroupEnrollment.CAX509Settings.DeviceX509Path);
X509Certificate2 deviceLeafProvisioningCertificate = new X509Certificate2(deviceCertificateFullPath, _dpsSettings.GroupEnrollment.CAX509Settings.Password);
IAuthenticationMethod auth = new DeviceAuthenticationWithX509Certificate(_deviceSettingsDelegate.CurrentValue.DeviceId, deviceLeafProvisioningCertificate);
_deviceClient = DeviceClient.Create(_deviceSettingsDelegate.CurrentValue.HostName, auth, _dpsSettings.GroupEnrollment.CAX509Settings.TransportType);
}
else
{
_logger.LogError($"{logPrefix}::{_deviceSettingsDelegate.CurrentValue.ArtifactId}::Feature not implemented.");
}
_logger.LogDebug($"{logPrefix}::{_deviceSettingsDelegate.CurrentValue.ArtifactId}::Device client created.");
if (_simulationSettings.EnableTwinPropertiesDesiredChangesNotifications)
{
await _deviceClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChange, null);
_logger.LogDebug($"{logPrefix}::{_deviceSettingsDelegate.CurrentValue.ArtifactId}::Twin Desired Properties update callback handler registered.");
}
//Configuration
if (_simulationSettings.EnableC2DDirectMethods)
{
//Register C2D Direct methods handlers
await RegisterC2DDirectMethodsHandlersAsync();
}
if (_simulationSettings.EnableC2DMessages)
{
//Start receiving C2D messages
ReceiveC2DMessagesAsync();
}
//Messages
if (_simulationSettings.EnableLatencyTests)
{
SendDeviceToCloudLatencyTestAsync(_deviceSettingsDelegate.CurrentValue.DeviceId, _simulationSettings.LatencyTestsFrecuency);
}
if (_simulationSettings.EnableTelemetryMessages)
{
SendDeviceToCloudMessagesAsync(_deviceSettingsDelegate.CurrentValue.DeviceId); //interval is a global variable changed by processes
}
if (_simulationSettings.EnableErrorMessages)
{
SendDeviceToCloudErrorAsync(_deviceSettingsDelegate.CurrentValue.DeviceId, _simulationSettings.ErrorFrecuency);
}
if (_simulationSettings.EnableCommissioningMessages)
{
SendDeviceToCloudCommissioningAsync(_deviceSettingsDelegate.CurrentValue.DeviceId, _simulationSettings.CommissioningFrecuency);
}
if (_simulationSettings.EnableReadingTwinProperties)
{
//Twins
_logger.LogDebug($"{logPrefix}::{_deviceSettingsDelegate.CurrentValue.ArtifactId}::INITIALIZATION::Retrieving twin.");
Twin twin = await _deviceClient.GetTwinAsync();
if (twin != null)
{
_logger.LogDebug($"{logPrefix}::{_deviceSettingsDelegate.CurrentValue.ArtifactId}::INITIALIZATION::Device twin: {JsonConvert.SerializeObject(twin, Formatting.Indented)}.");
}
else
{
_logger.LogDebug($"{logPrefix}::{_deviceSettingsDelegate.CurrentValue.ArtifactId}::INITIALIZATION::No device twin.");
}
}
if (_simulationSettings.EnableFileUpload)
{
throw new NotImplementedException("File upload feature has not been implemented yet.");
}
_deviceClient.SetConnectionStatusChangesHandler(new ConnectionStatusChangesHandler(ConnectionStatusChanged));
}
else
{
_logger.LogWarning($"{logPrefix}::{_deviceSettingsDelegate.CurrentValue.ArtifactId}::No enrollment group has been found.");
}
}
catch (Exception ex)
{
_logger.LogError($"{logPrefix}::{_deviceSettingsDelegate.CurrentValue.ArtifactId}::ERROR::InitiateSimulationAsync:{ex.Message}.");
}
}
internal static BasicHttpBindingCollectionElement GetBindingCollectionElement()
{
return((BasicHttpBindingCollectionElement)ConfigurationHelpers.GetBindingCollectionElement("basicHttpBinding"));
}
/// <summary>
/// Constructor.
/// </summary>
public TestHarness(BuildXLContext context, AbsolutePath configFile)
{
m_context = context;
Configuration = ConfigurationHelpers.GetDefaultForTesting(context.PathTable, configFile);
}
private static async Task <bool> CreateAndRunPip(
PipProgram program,
string tempDirectory,
string outFile,
IEnumerable <string> restInstructions,
bool is64Bit)
{
Contract.Requires(restInstructions != null);
Contract.Requires(tempDirectory != null);
Contract.Requires(!string.IsNullOrEmpty(outFile));
BuildXLContext context = BuildXLContext.CreateInstanceForTesting();
using (var fileAccessListener = new FileAccessListener(Events.Log))
{
fileAccessListener.RegisterEventSource(BuildXL.Processes.ETWLogger.Log);
var loggingContext = BuildXLTestBase.CreateLoggingContextForTest();
var fileContentTable = FileContentTable.CreateNew(loggingContext);
var config = ConfigurationHelpers.GetDefaultForTesting(context.PathTable, AbsolutePath.Create(context.PathTable, Path.Combine(tempDirectory, "config.dc")));
config.Sandbox.LogObservedFileAccesses = true;
Pip pip = null;
var instructions = restInstructions as string[] ?? restInstructions.ToArray();
switch (program)
{
case PipProgram.Cmd:
pip = CreateCmdPip(context, tempDirectory, outFile, is64Bit);
break;
case PipProgram.Self:
pip = CreateSelfPip(context, tempDirectory, outFile, instructions, is64Bit);
break;
}
Contract.Assume(pip != null);
var isSubstUsed = FileUtilities.TryGetSubstSourceAndTarget(tempDirectory, out var substSource, out var substTarget, out var errorMessage);
XAssert.IsFalse(!isSubstUsed && errorMessage != null, errorMessage);
PipResult executeResult = await Execute(
context,
fileContentTable,
config,
pip,
isSubstUsed
?(substSource, substTarget)
: default((string, string)?));
bool valid = false;
switch (program)
{
case PipProgram.Cmd:
valid = ValidateCmd(fileAccessListener.FileAccesses, outFile, is64Bit);
break;
case PipProgram.Self:
valid = ValidateSelf(
fileAccessListener.FileAccesses,
instructions.Length > 0 ? instructions[0] : string.Empty,
outFile,
is64Bit);
break;
}
return(executeResult.Status == PipResultStatus.Succeeded && valid);
}
}
public void Initialize()
{
ConfigurationHelpers.ConfigureNet45();
}
public async Task InitiateSimulationAsync()
{
string logPrefix = "system".BuildLogPrefix();
try
{
//Connectivity tests
//Control if a connection string exists (ideally, stored in TPM/HSM or any secured location.
//If there is no connection string, check if the DPS settings are provided.
//If so, provision the device and persist the connection string for upcoming boots.
if (string.IsNullOrEmpty(ModuleSettings.ConnectionString))
{
ModuleSettings.ConnectionString = await _provisioningService.AddModuleIdentityToDevice(ModuleSettings.ModuleId);
if (string.IsNullOrEmpty(ModuleSettings.ConnectionString))
{
_logger.LogWarning($"{logPrefix}::{ModuleSettings.ArtifactId}::No module connection string has been created.");
}
else
{
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::Module connection string being persisted.");
await ConfigurationHelpers.WriteModulesSettings(ModuleSettings, _environmentName);
}
}
IoTTools.CheckModuleConnectionStringData(ModuleSettings.ConnectionString, _logger);
// Connect to the IoT hub using the MQTT protocol
_moduleClient = ModuleClient.CreateFromConnectionString(ModuleSettings.ConnectionString, Microsoft.Azure.Devices.Client.TransportType.Mqtt);
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::Module client created.");
if (SimulationSettings.EnableTwinPropertiesDesiredChangesNotifications)
{
await _moduleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChange, null);
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::Twin Desired Properties update callback handler registered.");
}
//Configuration
if (SimulationSettings.EnableC2DDirectMethods)
{
//Register C2D Direct methods handlers
await RegisterC2DDirectMethodsHandlersAsync(_moduleClient, ModuleSettings, _logger);
}
if (SimulationSettings.EnableC2DMessages)
{
//Start receiving C2D messages
ReceiveC2DMessagesAsync(_moduleClient, ModuleSettings, _logger);
}
//Messages
if (SimulationSettings.EnableTelemetryMessages)
{
SendDeviceToCloudMessagesAsync(_moduleClient, ModuleSettings.DeviceId, ModuleSettings.ModuleId, _logger); //interval is a global variable changed by processes
}
if (SimulationSettings.EnableErrorMessages)
{
SendDeviceToCloudErrorAsync(_moduleClient, ModuleSettings.DeviceId, ModuleSettings.ModuleId, SimulationSettings.ErrorFrecuency, _logger);
}
if (SimulationSettings.EnableCommissioningMessages)
{
SendDeviceToCloudCommissioningAsync(_moduleClient, ModuleSettings.DeviceId, ModuleSettings.ModuleId, SimulationSettings.CommissioningFrecuency, _logger);
}
if (SimulationSettings.EnableReadingTwinProperties)
{
//Twins
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::INITIALIZATION::Retrieving twin.");
Twin twin = await _moduleClient.GetTwinAsync();
if (twin != null)
{
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::INITIALIZATION::Device twin: {JsonConvert.SerializeObject(twin, Formatting.Indented)}.");
}
else
{
_logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::INITIALIZATION::No device twin.");
}
}
_moduleClient.SetConnectionStatusChangesHandler(new ConnectionStatusChangesHandler(ConnectionStatusChanged));
}
catch (ConnectionStringException ex)
{
_logger.LogError($"{logPrefix}::{ModuleSettings.ArtifactId}::ConnectionStringException:{ex.Message}");
}
catch (Exception ex)
{
_logger.LogError($"{logPrefix}::{ModuleSettings.ArtifactId}::{ex.Message}");
}
}
internal static NetHttpsBindingCollectionElement GetBindingCollectionElement()
{
return((NetHttpsBindingCollectionElement)ConfigurationHelpers.GetBindingCollectionElement(ConfigurationStrings.NetHttpsBindingCollectionElementName));
}
static ConnectivityModeHelper()
{
ConnectivityModeHelper.OverrideInternalConnectivityMode = ConfigurationHelpers.GetOverrideConnectivityMode();
}
public async Task <TokenIssueResponse> IssueToken(TokenIssueRequest request)
{
// Login to CaaS
IAccount account = await _computeClient.LoginAsync(
new NetworkCredential(
request.Message.Credentials.UserName,
request.Message.Credentials.Password));
// Get available clouds
IEnumerable <DatacenterWithMaintenanceStatusType> dataCenters =
await _computeClient.GetDataCentersWithMaintenanceStatuses();
string loginToken = request.Message.Credentials.UserName + ":" + request.Message.Credentials.Password;
byte[] buffer = new byte[loginToken.Length];
string loginTokenEncoded = Convert.ToBase64String(Encoding.UTF8.GetBytes(loginToken));
List <Endpoint> endPoints = new List <Endpoint>();
endPoints.Add(new Endpoint()
{
Url = ConfigurationHelpers.GetTenantUrl(Request.RequestUri.Host, request.Message.TenantName),
Id = "AU1", // TODO: Map to cloud id?
InternalURL = ConfigurationHelpers.GetTenantUrl(Request.RequestUri.Host, request.Message.TenantName),
PublicURL = ConfigurationHelpers.GetTenantUrl(Request.RequestUri.Host, request.Message.TenantName),
Region = "RegionOne"
});
foreach (var dataCenter in dataCenters)
{
endPoints.Add(new Endpoint()
{
Url = ConfigurationHelpers.GetTenantUrl(Request.RequestUri.Host, request.Message.TenantName),
Id = dataCenter.location, // TODO: Map to cloud id?
InternalURL = ConfigurationHelpers.GetTenantUrl(Request.RequestUri.Host, request.Message.TenantName),
PublicURL = ConfigurationHelpers.GetTenantUrl(Request.RequestUri.Host, request.Message.TenantName),
Region = "Dimension Data " + dataCenter.displayName
});
}
TokenIssueResponse response = new TokenIssueResponse()
{
AccessToken = new AccessToken()
{
Token = new Token(request.Message.TenantName, request.Message.TenantName, loginTokenEncoded),
Catalog = new ServiceCatalogEntry[]
{
new ServiceCatalogEntry()
{
Endpoints = endPoints.ToArray(),
EndpointsLinks = new string[]
{
ConfigurationHelpers.GetTenantUrl(Request.RequestUri.Host, request.Message.TenantName)
},
Name = "nova",
Type = EndpointType.compute
},
new ServiceCatalogEntry()
{
Endpoints = endPoints.ToArray(),
EndpointsLinks = new string[]
{
ConfigurationHelpers.GetTenantUrl(Request.RequestUri.Host, request.Message.TenantName)
},
Name = "keystone",
Type = EndpointType.identity
}
},
User = new User()
{
Id = Guid.NewGuid().ToString(),
Name = account.FullName,
Roles = new User.Role[] { },
RolesLinks = new string[] {},
UserName = request.Message.Credentials.UserName
}
}
};
return(response);
}
private void ConnectionStringProtection(bool protect)
{
try
{
var oConfiguration = ConfigurationHelpers.GetCurrentConfiguration();
if (oConfiguration != null)
{
//var blnChanged = false;
var oSection = oConfiguration.GetSection("connectionStrings") as ConnectionStringsSection;
if (oSection != null)
{
if ((!(oSection.ElementInformation.IsLocked)) && (!(oSection.SectionInformation.IsLocked)))
{
if (protect)
{
if (!(oSection.SectionInformation.IsProtected))
{
oSection.SectionInformation.ProtectSection(DATA_PROTECTION_PROVIDER);
}
}
else
{
if (oSection.SectionInformation.IsProtected)
{
oSection.SectionInformation.UnprotectSection();
ConnectionString = oSection.ConnectionStrings["LexyEntities"].ConnectionString;
}
else
{
ConnectionString = oSection.ConnectionStrings["LexyEntities"].ConnectionString;
//oSection.SectionInformation.ProtectSection(DATA_PROTECTION_PROVIDER);
//oSection.SectionInformation.ForceSave = true;
//oConfiguration.Save();
//var isweb = ConfigurationManager.AppSettings["IsWebApps"];
//if (isweb.Equals("0"))
//{
// oSection.SectionInformation.ProtectSection(DATA_PROTECTION_PROVIDER);
// oSection.SectionInformation.ForceSave = true;
// oConfiguration.Save();
//}
}
}
}
else
{
throw new Exception("File Configuration is locked");
}
//if (blnChanged)
//{
// oSection.SectionInformation.ForceSave = true;
// oConfiguration.Save();
//}
}
}
}
catch (Exception ex)
{
// TODO ERROR User Privilages
ConnectionString = ConfigurationManager.ConnectionStrings["lexyEntities"].ConnectionString;
}
}
public CaaSAuthenticationMiddleWare(OwinMiddleware next, Func <Uri, IComputeApiClient> apiClient)
: base(next)
{
_apiClient = apiClient(ConfigurationHelpers.GetApiUri());
}
public void OneTimeSetup() => _configuration = ConfigurationHelpers.GetMyConfiguration("appsettings.Production.json");
public void UnescapedStringToCharsArray_NullProvided_ThrowsException()
{
Action action = () => ConfigurationHelpers.UnescapedStringToCharsArray(null);
action.Should().Throw <ArgumentNullException>();
}
protected override void ConfigureExternalServices(IServiceCollection services)
{
services.AddScoped(provider => Mock.Of <IAmazonCognitoIdentityProvider>());
ConfigurationHelpers.ConfigureExternalServices(services);
}
/// <inheritdoc />
public ITaskProcessorConfiguration GetTaskProcessorConfiguration()
{
return(ConfigurationHelpers.Load <TaskProcessorConfigurationSection>(TaskProcessorConfigurationSection.SectionName));
}
private async Task TestDownloadResolver(DownloadData data, Func <DownloadResolver, Task> performTest, bool useHttpServer = true)
{
var dummyConfigFile = Path.Combine(TemporaryDirectory, m_uniqueTestFolder, "config.dsc");
var statistics = new Statistics();
var moduleRegistry = new ModuleRegistry(FrontEndContext.SymbolTable);
var workspaceFactory = CreateWorkspaceFactoryForTesting(FrontEndContext, ParseAndEvaluateLogger);
var configuration = ConfigurationHelpers.GetDefaultForTesting(FrontEndContext.PathTable, AbsolutePath.Create(FrontEndContext.PathTable, dummyConfigFile));
var resolverSettings = new ResolverSettings();
var frontEndFactory = new FrontEndFactory();
frontEndFactory.AddFrontEnd(new DownloadFrontEnd());
frontEndFactory.TrySeal(new LoggingContext("UnitTest"));
using (var host = new FrontEndHostController(
frontEndFactory,
workspaceFactory,
new EvaluationScheduler(degreeOfParallelism: 1),
moduleRegistry,
new FrontEndStatistics(),
global::BuildXL.FrontEnd.Core.Tracing.Logger.CreateLogger(),
collector: null,
collectMemoryAsSoonAsPossible: false))
{
var frontEndEngineAbstraction = new BasicFrontEndEngineAbstraction(
FrontEndContext.PathTable,
FrontEndContext.FileSystem,
configuration);
((IFrontEndController)host).InitializeHost(FrontEndContext, configuration);
host.SetState(frontEndEngineAbstraction, new TestEnv.TestPipGraph(), configuration);
var resolver = new DownloadResolver(
statistics,
host,
FrontEndContext,
Logger.Log,
"TestFrontEnd"
);
var workspaceResolver = new DownloadWorkspaceResolver();
workspaceResolver.UpdateDataForDownloadData(data, FrontEndContext);
await resolver.InitResolverAsync(resolverSettings, workspaceResolver);
if (useHttpServer)
{
using (var listener = new HttpListener())
{
// This test relies on the mutex in the build engine to only run one unittest at a time and this assembly to be single thread
// if any of those assumptions will be broken we will have to either dynamically (remind you globally) get unique ports.
// HttpListner doesn't have this built-in so there will always be a race. Just spam the ports utnill one doesn't fail
// use a global mutex (This is not honored by qtest since it can run in a different session on cloudbuild).
listener.Prefixes.Add(TestServer);
listener.Start();
StartRequestHandler(listener);
await performTest(resolver);
listener.Stop();
listener.Close();
}
}
else
{
await performTest(resolver);
}
}
}
/// <inheritdoc />
public ITaskProcessorClientConfiguration GetClientConfiguration()
{
return(ConfigurationHelpers.Load <ClientConfigurationSection>(ClientConfigurationSection.SectionName));
}
/// <summary>
/// Initializes a new instance of the <see cref="ServerController"/> class.
/// </summary>
/// <param name="apiClient">The API client.</param>
public ServerController(Func <Uri, IComputeApiClient> apiClient)
{
_computeClient = apiClient(ConfigurationHelpers.GetApiUri());
}
/// <inheritdoc />
public ITaskProcessorSerializationConfiguration GetSerializationConfiguration()
{
return(ConfigurationHelpers.Load <SerializationConfigurationSection>(SerializationConfigurationSection.SectionName));
}
internal static WSHttpBindingCollectionElement GetBindingCollectionElement()
{
return((WSHttpBindingCollectionElement)ConfigurationHelpers.GetBindingCollectionElement("wsHttpBinding"));
}
/// <inheritdoc />
public ITaskSchedulerConfiguration GetTaskSchedulerConfiguration()
{
return(ConfigurationHelpers.Load <TaskSchedulerConfigurationSection>(TaskSchedulerConfigurationSection.SectionName));
}
private static ITaskWorkersConfiguration GetTaskWorkerConfiguration(string configFileName)
{
string configFilePath = Path.Combine("Configuration", "TaskWorker", configFileName + ".config");
return(ConfigurationHelpers.Load <TaskWorkerConfigurationSection>(TaskWorkerConfigurationSection.SectionName, configFilePath));
}
internal override void Interpret()
{
if (Offset + 1 >= TopInterpreter.Args.Length || IsParameterEqual("help", TopInterpreter.Args[Offset + 1], "?"))
{
_root.Load(_typeInfoOfConfiguration);
HelpGenerators.PrintConfigurationContextHelp(_root, this, true);
return;
}
bool ro = false;
IncreaseOffset();
object requiredObject = _referenceToObject;
(PropertyInfo prop, object[] indexers, PropertyInfo lastNonIndexer) =
ConfigurationHelpers.ResolvePathRecursive(TopInterpreter.Args[Offset], _typeInfoOfConfiguration, ref requiredObject,
ref ro);
IncreaseOffset();
string Operator = TopInterpreter.Args[Offset];
if (IsParameterEqual("Help", Operator, allowPrefixFree: true))
{
var contextAttribute = lastNonIndexer.PropertyType.GetCustomAttribute <CmdConfigurationNamespaceAttribute>();
if (contextAttribute is null)
{
var valueAttribute = lastNonIndexer.GetCustomAttribute <CmdConfigurationFieldAttribute>();
valueAttribute.Load(new PropertyOrFieldInfo(lastNonIndexer));
HelpGenerators.PrintConfigurationFieldHelp(valueAttribute, this);
return;
}
else
{
HelpGenerators.PrintConfigurationContextHelp(contextAttribute, this);
}
}
if (IsParameterEqual("Get", Operator, allowPrefixFree: true))
{
object currentValue;
try {
currentValue = indexers is null?prop.GetValue(requiredObject) : prop.GetValue(requiredObject, indexers);
}
catch (Exception e) {
throw new CLIUsageException("An error occurred while obtaining the value requested:", e);
}
Console.WriteLine(JsonConvert.SerializeObject(currentValue));
return;
}
if (IsParameterEqual("Set", Operator, allowPrefixFree: true))
{
var valueAttribute = prop.GetCustomAttribute <CmdConfigurationFieldAttribute>();
if (ro || !prop.CanWrite)
{
throw new CLIUsageException("The given property is read only");
}
if (IncreaseOffset())
{
throw new CLIUsageException("Please supply a value to set the given value to!");
}
if (!CommandlineMethods.GetValueFromString(TopInterpreter.Args[Offset], prop.PropertyType, out object newValue))
{
throw new CLIUsageException(
$"The given string (TopInterpreter.Args[Offset]) couldn't be parsed to {prop.PropertyType}!");
}
try {
if (indexers is null)
{
prop.SetValue(requiredObject, newValue);
}
else
{
prop.SetValue(requiredObject, newValue, indexers);
}
}
catch (Exception e) {
throw new CLIUsageException("An error occurred while writing the value:", e);
}
if (_referenceToObject is IConfigurationRoot iCfgRoot)
{
iCfgRoot.Save(Enumerable.Repeat(new PropertyOrFieldInfo(lastNonIndexer), 1));
}
return;
}
if (IsParameterEqual("RemoveAt", Operator, allowPrefixFree: true))
{
var valueAttribute = prop.GetCustomAttribute <CmdConfigurationFieldAttribute>();
if (ro || !prop.CanWrite)
{
throw new CLIUsageException("The given value is not writable");
}
if (!typeof(ICollection).IsAssignableFrom(prop.PropertyType))
{
throw new CLIUsageException("The object that you try to remove an element from is no collection.");
}
if (IncreaseOffset())
{
throw new CLIUsageException("Please supply a value to set the given value to!");
}
if (!CommandlineMethods.GetValueFromString(TopInterpreter.Args[Offset], out int removalIndex))
{
throw new CLIUsageException($"The given string couldn't be parsed to {prop.PropertyType}!");
}
try {
((IList)(indexers is null ? prop.GetValue(requiredObject) : prop.GetValue(requiredObject, indexers)))
.RemoveAt(removalIndex); //Safe due to previous assignability check
}
catch (Exception e) {
throw new CLIUsageException("An error occurred while removing an object:", e);
}
}
throw new CLIUsageException("Could not resolve the operator provided");
//TODO Remove and Add missing
//_root.Interpret(printErrors);
}
private static ITaskProcessorSerializationConfiguration GetSerializationtConfiguration(string configFileName)
{
string configFilePath = Path.Combine("Configuration", "Serialization", configFileName + ".config");
return(ConfigurationHelpers.Load <SerializationConfigurationSection>(SerializationConfigurationSection.SectionName, configFilePath));
}
private void Add(ServiceModelOptions options, IEnumerable endpoints)
{
if (endpoints is null)
{
return;
}
foreach (var endpoint in endpoints.OfType <IEndpoint>())
{
options.Services.Add(_mapper.ResolveContract(endpoint.Contract), o =>
{
o.Endpoint = new EndpointAddress(endpoint.Address);
if (!string.IsNullOrEmpty(endpoint.Binding) || !string.IsNullOrEmpty(endpoint.BindingConfiguration))
{
o.Binding = ConfigLoader.LookupBinding(endpoint.Binding, endpoint.BindingConfiguration, ConfigurationHelpers.GetEvaluationContext(endpoint));
}
});
}
}
