public async Task <IAuthorization> LoadAuthorization()
{
if (_cache != null)
{
if (await _cache.Exists(KnownCacheKeys.AuthenticationToken))
{
var auth = await _cache.Get <IAuthorization>(KnownCacheKeys.AuthenticationToken);
if (!string.IsNullOrEmpty(auth?.Item?.AccessToken))
{
if (auth.Item.HasExpired)
{
await _cache.Delete(KnownCacheKeys.AuthenticationToken);
return(null);
}
_container.RegisterInstance <IAuthorization>(auth.Item, "Session");
var client = _container.Resolve <IClient>();
client.Authorization = auth.Item;
_container.RegisterInstance <IClient>(client, "Session");
auth.Item.Refreshed = false;
_log.Debug("Authorization was loaded");
return(auth.Item);
}
}
}
return(null);
}
public void Register(IDIContainer container)
{
container.RegisterInstance(container, typeof(IDIContainer));
container.RegisterInstance(container, typeof(IRegister));
container.RegisterInstance(container, typeof(IResolve));
container.Register <ISerializerFactory, SerializerFactory>();
container.Register <ISerialize, JsonSerializer>();
container.Register <ISerializer, JsonSerializer>();
container.Register <IDeserialize, JsonSerializer>();
JsonConvert.DefaultSettings = () =>
{
var settings = new JsonSerializerSettings();
settings.ContractResolver = new ContractResolver(container);
// do something with settings
return(settings);
};
container.Register <ISerialize, JsonSerializer>(KnownSerializerFormats.JSON.ToString());
container.Register <ISerializer, JsonSerializer>(KnownSerializerFormats.JSON.ToString());
container.Register <IDeserialize, JsonSerializer>(KnownSerializerFormats.JSON.ToString());
container.Register <ISerialize, JsonSerializer>(KnownSerializerIntents.Logging.ToString());
container.Register <ISerializer, JsonSerializer>(KnownSerializerIntents.Logging.ToString());
container.Register <IDeserialize, JsonSerializer>(KnownSerializerIntents.Logging.ToString());
container.Register <IEncryptionFactory, BasicEncryptionFactory>();
container.Register <IEncryption, BasicEncryption>();
container.Register <IEncrypter, BasicEncryption>();
container.RegisterInstance(EncryptionAlgorithm.Rijndael, typeof(EncryptionAlgorithm));
container.Register <IDecrypter, BasicEncryption>();
container.Register <IEncryptionKeyReadProvider, ConfigurationBasedEncryptionKeyProvider>();
container.Register <IEncryptionKey, EncryptionKey>();
container.Register <IValidateEncryptionKeys, ValidateEncryptionKeys>();
container.RegisterSingleton <IVersionProvider, AssemblyInfoVersionProvider>();
container.Register <IContractResolver, ContractResolver>();
container.Register <ICompressionFactory, CompressionFactory>();
container.Register <ICompression, Compression>();
container.Register <ICharacterEncodingConverter, CharacterEncodingConverter>();
container.Register(typeof(IProgress <>), typeof(Progress <>));
container.Register(typeof(ITimedBufferBatch <>), typeof(TimedBufferBatch <>));
container.Register(typeof(ITimedBufferBatchWithErrorRetries <>), typeof(TimedBufferBatchWithErrorRetries <>));
container.Register <IFeatureFlagProvider, ConfigurationBasedFeatureFlagProvider>();
container.Register <IDomainDataLoader, DomainDataLoader>();
container.Register <IUser, User>();
RegisterActorMessageTypes(container);
}
protected override void Initialize(IDIContainer container)
{
base.Initialize(container);
var cm = container.GetInstance<IConfigurationManager<IStepMapConfig>>();
cm.LoadConfiguation();
container.RegisterInstance(cm.Config);
}
public void Register(IDIContainer container)
{
if (!container.IsRegistered <IConfiguration>())
{
container.Register <IConfiguration, Configuration>();
var config = container.Resolve <IConfiguration>();
config.Build();
container.RegisterInstance(config, typeof(IConfiguration));
}
}
public ICache <TKey, TValue> CreateCache <TKey, TValue>(string name)
{
KnownCaches cacheName;
if (Enum.TryParse(name, true, out cacheName))
{
return(CreateCache <TKey, TValue>(cacheName));
}
var cache = GetCache <TKey, TValue>(name);
if (cache == null)
{
cache = _container.Resolve <ICache <TKey, TValue> >("DEFAULT");
_container.RegisterInstance(cache, typeof(ICache <TKey, TValue>), name);
}
return(cache);
}
public Task ExecutePostRegistrationStep(IDIContainer container, CancellationToken cancellationToken = default(CancellationToken))
{
var config = container.Resolve <IConfiguration>();
var actorSystemName = config.GetValueOrDefault("Actor:System:Name", "NeonTetra");
var actorCore = new ActorSystemCore(container, actorSystemName);
var resolver = new NeonTetraDIBridge(container, actorCore);
actorCore.RootActorSystem.AddDependencyResolver(resolver);
container.RegisterInstance(resolver, typeof(IDependencyResolver));
container.RegisterInstance(actorCore);
container.RegisterInstance(actorCore.RootActorSystem);
var _userManagerActorRef = actorCore.RootActorSystem.ActorOf(actorCore.RootActorSystem.DI().Props(typeof(IUserManagerActor)), "UserManagerActor");
container.RegisterInstance(_userManagerActorRef, "UserManagerActor");
return(Task.CompletedTask);
}
private void RegisterUIComponents()
{
DiContainer = DIContainer.Current;
var uiRegistration = new UIRegistrationContainer();
uiRegistration.Register(DiContainer);
var sharedRegistration = new SharedRegistrationContainer();
sharedRegistration.Register(DiContainer);
DiContainer.RegisterInstance(Window.Current.CoreWindow.Dispatcher);
_log = DiContainer.Resolve <ILog>();
}
public async Task ExecutePostRegistrationStep(IDIContainer container, CancellationToken cancellationToken = default(CancellationToken))
{
var config = container.Resolve <IConfiguration>();
var enabled = config.GetValueOrDefault("MQTT:Server:Enabled", true);
if (enabled)
{
var port = config.GetValueOrDefault("MQTT:Server:Port", 1889);
var broker = new MqttBroker();
await broker.StartAsync(container.Resolve <IAccountManager>(), port);
container.RegisterInstance(broker);
}
}
private void Setup(IDIContainer container)
{
var factory = DIContainer.Current.Resolve <IEnvironmentFactory>();
var environment = factory.GetEnvironment(Environments.Production);
DIContainer.Current.RegisterInstance(environment);
container.RegisterInstance(new HardCodedConfiguration
{
ClientId = "f1b18a19-f810-4f16-8a39-d6135f5ec052",
ClientSecret = "aead4980-c966-4a26-abee-6bdb1ea23e5c",
RedirectUri = "https://accounts.moj.io",
Environment = DIContainer.Current.Resolve <IEnvironment>()
} as IConfiguration);
DIContainer.Current.Register <ILog, DebugLogger>("Debug");
}
public void Register(IDIContainer container)
{
container.Register <IAttachment, Attachment>();
container.Register <IBotClient, BotClient>();
container.Register <IChannelAccount, ChannelAccount>();
container.Register <ILocation, Location>();
container.Register <IMention, Mention>();
container.Register <IMessage, Message>();
container.Register <IMojioConversationData, MojioConversationData>();
container.Register <IEntity, Entity>();
container.Register <IIntent, Intent>();
var botAccount = container.Resolve <IChannelAccount>();
botAccount.Id = "kitt-mojio-1";
botAccount.Address = "1080 Howe Street, Vancouver, BC Canada";
botAccount.IsBot = true;
botAccount.Name = "Kitt";
container.RegisterInstance(botAccount, "bot");
}
public Task ExecutePostRegistrationStep(IDIContainer container,
CancellationToken cancellationToken = default(CancellationToken))
{
Dictionary <string, string> loggingContext;
if (container.IsRegistered <Dictionary <string, string> >("LoggingContext"))
{
loggingContext = container.Resolve <Dictionary <string, string> >("LoggingContext");
}
else
{
loggingContext = new Dictionary <string, string>();
container.RegisterInstance(loggingContext, "LoggingContext");
}
loggingContext["Command Line"] = Environment.CommandLine;
loggingContext["Current Directory"] = Environment.CurrentDirectory;
loggingContext["User Domain Name"] = Environment.UserDomainName;
loggingContext["User Name"] = Environment.UserName;
loggingContext["OS Version"] = Environment.OSVersion.ToString();
loggingContext["Machine Name"] = Environment.MachineName;
var host = Environment.GetEnvironmentVariable("Host");
loggingContext["Host"] = host;
if (container.IsRegistered <IConfiguration>())
{
var config = container.Resolve <IConfiguration>();
loggingContext["Host Environment"] = config.HostEnvironment;
loggingContext["Entry Point"] = config.EntryPoint;
loggingContext["Environment"] = config.Environment;
loggingContext["Version"] = config.Version;
loggingContext["App Data Directory"] = config.AppDataDirectory.ToString();
loggingContext["Debug Mode"] = config.DebugMode.ToString().ToLowerInvariant();
loggingContext["Root Directory"] = config.RootDirectory.ToString();
}
return(Task.CompletedTask);
}
public Task ExecutePostRegistrationStep(IDIContainer container,
CancellationToken cancellationToken = default(CancellationToken))
{
var configuration = container.Resolve <IConfiguration>();
var knownCaches = configuration.GetValues <IKnownCacheSetup>("Cache:KnownCaches");
if (knownCaches != null)
{
IDictionary <KnownCaches, IKnownCacheSetup> configValues =
new Dictionary <KnownCaches, IKnownCacheSetup>();
foreach (var k in knownCaches)
{
configValues.Add(k.CacheName, k);
}
var knownConfig = container.Resolve <IKnownCacheConfiguration>();
knownConfig.CacheSetups = configValues.ToImmutableDictionary();
container.RegisterInstance(knownConfig, typeof(IKnownCacheConfiguration));
}
return(Task.CompletedTask);
}
public async Task <IPlatformResponse <T> > Request <T>(ApiEndpoint endpoint, string relativePath, CancellationToken cancellationToken, IProgress <ISDKProgress> progress = null, HttpMethod method = null, string body = null, byte[] rawData = null, string contentType = "application/json", IDictionary <string, string> headers = null)
{
var monitor = _container.Resolve <IProgressMonitor>();
if (progress != null)
{
monitor.Progress = progress;
monitor.Start();
}
monitor.Report("Initializing Http Request", 0);
var _method = HttpMethod.Get;
if (method != null)
{
_method = method;
}
var platformResponse = new PlatformResponse <T>
{
Success = false
};
if (headers != null && headers.Count > 0)
{
if (headers.ContainsKey("Authorization"))
{
var h = headers["Authorization"];
if (h.IndexOf(" ", StringComparison.Ordinal) > 0)
{
var type = h.Substring(0, h.IndexOf(" ", StringComparison.Ordinal)).Trim();
var token = h.Substring(h.IndexOf(" ", StringComparison.Ordinal)).Trim();
AuthorizationType = type;
Authorization.MojioApiToken = token;
headers.Remove("Authorization");
}
}
}
HttpClient client;
switch (endpoint)
{
case ApiEndpoint.Accounts:
client = AccountsClient(contentType);
break;
case ApiEndpoint.Images:
client = ImagesClient(contentType);
break;
case ApiEndpoint.Push:
client = PushClient(contentType);
break;
default:
client = ApiClient(contentType);
break;
}
var request = new HttpRequestMessage(_method, relativePath);
monitor.Report("Setting HttpContent Body", 0.1);
if (!string.IsNullOrEmpty(body))
{
Debug.WriteLine($"Request Content:{body}");
request.Content = new StringContent(body, Encoding.UTF8, contentType);
}
monitor.Report("Set HttpContent Body", 0.2);
if (rawData != null)
{
monitor.Report("Creating MultiPart Form Content", 0.2);
var requestContent = new MultipartFormDataContent(); //"Upload----" + DateTime.Now.ToString(CultureInfo.InvariantCulture));
var imageContent = new ByteArrayContent(rawData);
var fileName = "image.png";
var type = "image/png";
if (headers != null && headers.Count > 0)
{
type = (from x in headers where x.Key == "Content-Type" select x.Value).FirstOrDefault();
fileName = (from x in headers where x.Key == "Filename" select x.Value).FirstOrDefault();
if (!string.IsNullOrEmpty(type))
{
headers.Remove("Content-Type");
}
if (!string.IsNullOrEmpty(fileName))
{
headers.Remove("Filename");
}
}
imageContent.Headers.ContentDisposition = ContentDispositionHeaderValue.Parse("form-data");
imageContent.Headers.ContentDisposition.Name = "\"file\"";
imageContent.Headers.ContentDisposition.FileName = fileName;
imageContent.Headers.ContentDisposition.Size = rawData.Length;
imageContent.Headers.ContentType = MediaTypeHeaderValue.Parse(type);
requestContent.Add(imageContent);
request.Content = requestContent;
monitor.Report("Created MultiPart Form Content", 0.3);
}
monitor.Report("Adding Headers", 0.4);
if (headers != null && headers.Count > 0)
{
foreach (var h in headers)
{
request.Headers.Add(h.Key, h.Value);
}
}
request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
request.Headers.AcceptEncoding.Add(new StringWithQualityHeaderValue("deflate"));
if (DisableSessionAffinity)
{
request.Headers.Add("Arr-Disable-Session-Affinity", "True");
}
monitor.Report("Added Headers", 0.4);
if (cancellationToken.IsCancellationRequested)
{
platformResponse.WasCancelled = true;
monitor.Report("Operation Cancelled", 0.5);
return(platformResponse);
}
monitor.Report("Sending Http Request", 0.6);
var requestSw = new Stopwatch();
requestSw.Start();
Debug.WriteLine($"Pre-flight request URL: {request.RequestUri}");
using (var sendResult = await client.SendAsync(request, cancellationToken))
{
platformResponse.RequestDurationMS = requestSw.ElapsedMilliseconds;
monitor.Report("Received Response from Http Request", 0.7);
requestSw.Stop();
platformResponse.Url = sendResult.RequestMessage.RequestUri.ToString();
Debug.WriteLine($"Post-flight request URL: {platformResponse.Url}");
platformResponse.Timestamp = DateTimeOffset.UtcNow;
platformResponse.HttpStatusCode = sendResult.StatusCode;
Debug.WriteLine($"Status Code: {platformResponse.HttpStatusCode}");
try
{
var cookie = (from h in sendResult.Headers where h.Key == "Set-Cookie" select h.Value.FirstOrDefault()).FirstOrDefault();
if (cookie != null)
{
platformResponse.ARRAffinityInstance = (from c in cookie.Split(';') where c.StartsWith("") select c.Split('=').LastOrDefault()).FirstOrDefault();
}
}
catch (Exception)
{
}
if (sendResult.IsSuccessStatusCode)
{
monitor.Report("Received Successful StatusCode", 0.8);
if (cancellationToken.IsCancellationRequested)
{
platformResponse.WasCancelled = true;
monitor.Report("Operation Cancelled", 0.9);
return(platformResponse);
}
monitor.Report("Reading data from Response", 0.9);
var json = await sendResult.Content.ReadAsStringAsync();
monitor.Report("Deserializing data", 0.95);
try
{
platformResponse.Response = _serializer.Deserialize <T>(json);
if (platformResponse.Response != null)
{
platformResponse.Success = true;
}
}
catch (Exception e)
{
_log.Error(e, "Invalid response from the server. Received:{0}, expected:{1}. Will continue.", json, typeof(T));
}
if (typeof(T) == typeof(IAuthorization))
{
monitor.Report("Setting internal auth token", 0.99);
Authorization.MojioApiToken = (platformResponse.Response as IAuthorization).AccessToken;
_container.RegisterInstance(Authorization, "Session");
}
}
else
{
monitor.Report("Received Unsuccessful StatusCode", 0.8);
platformResponse.Success = false;
platformResponse.ErrorCode = sendResult.StatusCode.ToString();
platformResponse.ErrorMessage = sendResult.ReasonPhrase;
monitor.Report("Reading data from Response", 0.9);
var content = await sendResult.Content.ReadAsStringAsync();
Debug.WriteLine(content);
Debug.WriteLine(_serializer.SerializeToString(request));
if (!string.IsNullOrEmpty(content))
{
try
{
monitor.Report("Deserializing data", 0.95);
dynamic result = _serializer.Deserialize(content);
if (result != null)
{
if (result.Message != null)
{
platformResponse.ErrorMessage = platformResponse.ErrorMessage + ", " + result.Message;
}
else
{
platformResponse.ErrorMessage = platformResponse.ErrorMessage + ", " + content;
}
}
}
catch (Exception)
{
}
}
}
}
monitor.Report("Finished", 1);
monitor.Stop();
return(platformResponse);
}
public async Task <IDeployment> Start(IDIContainer rootContainer, IDictionary <string, object> environment = null)
{
var id = Guid.NewGuid().ToString();
if (environment != null)
{
if (environment.ContainsKey("id"))
{
id = environment["id"].ToString();
}
}
rootContainer.RegisterInstance(rootContainer);
rootContainer.RegisterInstance(rootContainer as IRegister);
rootContainer.RegisterInstance(rootContainer as IResolve);
if (environment != null)
{
rootContainer.RegisterInstance(environment, "environment");
foreach (var key in environment.Keys)
{
rootContainer.RegisterInstance(environment[key], "environment." + key);
}
}
IDeployment deployment = null;
if (environment != null && environment.ContainsKey("Deployment"))
{
deployment = environment["Deployment"] as IDeployment;
}
else if (rootContainer.IsRegistered <IConfiguration>())
{
var config = rootContainer.Resolve <IConfiguration>();
var deployConfig = config.GetValue <string>("Deployment");
if (!string.IsNullOrEmpty(deployConfig))
{
var type = rootContainer.GetTypeByModuleName(deployConfig);
if (type != null)
{
deployment = type.Assembly.CreateInstance(type.FullName, false) as IDeployment;
}
}
}
if (deployment == null)
{
deployment = new DefaultDeployment();
}
await deployment.Start(rootContainer, environment);
while (!_activeDeployments.TryAdd(id, deployment))
{
await Task.Delay(1);
}
rootContainer.RegisterInstance(deployment);
Started = true;
return(deployment);
}
private void RegisterSDKDomain(IDIContainer container)
{
container.Register<IUser, User>();
container.Register<ITelephoneNumber, TelephoneNumber>();
container.Register<IVehicle, Vehicle>();
container.Register<IClient, Client>();
container.Register<IClientApp, Client>();
container.Register<IClientLogin, Client>();
container.Register<IClientMe, Client>();
container.Register<IClientTrip, Client>();
container.Register<IClientMojio, Client>();
container.Register<IClientVehicle, Client>();
container.Register<IMachineRequest, MachineRequest>();
container.Register<IImage, Image>();
container.Register<IEmail, Email>();
container.Register<IAccelerometer, Accelerometer>();
container.Register<IAddress, Address>();
container.Register<IBattery, Battery>();
container.Register<IDiagnosticCode, DiagnosticCode>();
container.Register<IHeading, Heading>();
container.Register<ILocation, Location>();
container.Register<IVirtualodometer, VirtualOdometer>();
container.Register<IMeasurement, Measurement>();
container.Register<IOdometer, Odometer>();
container.Register<IRiskMeasurement, RiskMeasurement>();
container.Register<IState, State>();
container.Register<IVehiclesResponse, VehiclesResponse>();
container.Register<IVinCommon, VinCommon>();
container.Register<IVinDetails, VinDetails>();
container.Register<IVinSummary, VinSummary>();
container.Register<ITransmission, Transmission>();
container.Register<ITripsResponse, TripsResponse>();
container.Register<ITrip, Trip>();
container.Register<IMojioResponse, MojioResponse>();
container.Register<IMojio, Mojio>();
container.Register<IEngine, Engine>();
container.Register<IEngine, Engine>();
container.Register<IWarranty, Warranty>();
container.Register<IServiceBulletin, ServiceBulletin>();
container.Register<IRecall, Recall>();
container.Register<IServiceScheduleResponse, ServiceScheduleResponse>();
container.Register<IService, Service>();
container.Register<IApp, App>();
container.Register<IAppResponse, AppResponse>();
container.Register<IMessageResponse, MessageResponse>();
container.Register<IVehicleLocationResponse, VehicleLocationResponse>();
container.Register<IMachineStates, MachineStates>();
container.Register<IMinMax, MinMax>();
container.Register<IPoints, Points>();
container.Register<IVehicleState, VehicleState>();
container.Register<IMachineTelematicDevice, MachineTelematicDevice>();
container.Register<IMachine, HttpMachine>();
container.Register<ITransport, BaseTransport>();
container.Register<ITransport, AndroidTransport>("Android");
container.Register<ITransport, AppleTransport>("Apple");
container.Register<ITransport, HttpPostTransport>("HttpPost");
container.Register<ITransport, MongoDBTransport>("MongoDB");
container.Register<ITransport, MqttTransport>("Mqtt");
container.Register<ITransport, SignalRTransport>("SignalR");
container.Register<ITransport, EventHubTransport>("EventHub");
container.Register<ITransport, ServiceBusQueueTransport>("ServiceBusQueue");
container.Register<AndroidTransport, AndroidTransport>();
container.Register<AppleTransport, AppleTransport>();
container.Register<HttpPostTransport, HttpPostTransport>();
container.Register<MongoDBTransport, MongoDBTransport>();
container.Register<MqttTransport, MqttTransport>();
container.Register<SignalRTransport, SignalRTransport>();
container.Register<EventHubTransport, EventHubTransport>();
container.Register<ServiceBusQueueTransport, ServiceBusQueueTransport>();
container.Register<IAndroidTransport, AndroidTransport>();
container.Register<IAppleTransport, AppleTransport>();
container.Register<IHttpPostTransport, HttpPostTransport>();
container.Register<IMongoDBTransport, MongoDBTransport>();
container.Register<IMqttTransport, MqttTransport>();
container.Register<ISignalRTransport, SignalRTransport>();
container.Register<IEventHubTransport, EventHubTransport>();
container.Register<IServiceBusQueueTransport, ServiceBusQueueTransport>();
container.Register<ITransportFactory, TransportFactory>();
container.Register<IPushObserverResponse, PushObserverResponse>();
container.Register<IPushObserver, PushObserverRequest>();
container.Register<IGroup, Group>();
container.Register<IGroupResponse, GroupResponse>();
container.Register(typeof(IObservable<>), typeof(SimpleObservable<>));
var vehicles = container.Resolve<IObservable<IVehicle>>();
container.RegisterInstance<IObservable<IVehicle>>(vehicles);
var activities = container.Resolve<IObservable<IActivity>>();
container.RegisterInstance<IObservable<IActivity>>(activities);
var mojios = container.Resolve<IObservable<IMojio>>();
container.RegisterInstance<IObservable<IMojio>>(mojios);
RegisterActivityStreams(container);
}
private void BuildConfiguration(string root)
{
var builder = new ConfigurationBuilder();
builder.SetBasePath(root);
#if TRACE
Trace.WriteLine(EntryPoint + ": " + "SetBasePath:" + root);
#endif
//stage 2.4
builder.AddEnvironmentVariables();
builder.AddJsonFile(System.IO.Path.Combine(root, "appsettings.json"), true, false); //appsettings.json
//stage 2.5
builder.AddJsonFile(GetConfigFile(null), true, false); //appsettings.json
//stage 2.6
builder.AddJsonFile(GetConfigFile(Environment), true, false); //appsettings.%ENVIRONMENT%.json
//stage 2.7
builder.AddJsonFile(GetConfigFile(Environment, cloudServices: true), true,
false); //appsettings.CloudServices.%ENVIRONMENT%.json
//stage 2.8
builder.AddJsonFile(GetConfigFile(Environment, HostEnvironment), true,
false); //appsettings.%HOSTINGENVIRONMENT%.json
//stage 2.9
builder.AddJsonFile(GetConfigFile(Environment, HostEnvironment, true), true,
false); //appsettings.CloudServices.%HOSTINGENVIRONMENT%.json
//stage 2.10
var host = System.Environment.GetEnvironmentVariable("Host");
if (!string.IsNullOrEmpty(host))
{
builder.AddJsonFile(GetConfigForHost(host), true, false); //appsettings.%HOST%.json
builder.AddJsonFile(GetConfigForHost(host, Environment), true, false); //appsettings.%HOST%.json
builder.AddJsonFile(GetConfigForHost(host, Environment, HostEnvironment), true,
false); //appsettings.%HOST%.json
}
//stage 2.11
builder.AddJsonFile(GetConfigFile("machine." + System.Environment.MachineName, isEnvironmentName: false),
true, false); //appsettings.machine.%MACHINENAME%.json
SetupVersion();
SetupUnitTest();
SetupAppDataDirectory();
InitializeUnitTestAppSettings(builder);
InitializeAdditionalSettings(builder, root);
ConfigurationRoot = builder.Build();
#if TRACE
BuildAndDumpConfig(ConfigurationRoot);
#endif
_container.RegisterInstance(ConfigurationRoot, typeof(IConfigurationRoot));
IsReady = true;
}
