/// <summary>
/// This mimics the approach taking in NuGet.Job's JsonConfigurationJob. We add common infrastructure to the
/// dependency injection container and load Autofac modules in the current assembly. This gives us a hook to
/// customize the initialization of this program. Today this service provider is only used for modifying
/// telemetry configuration but it could eventually be used in the <see cref="NgJobFactory"/>.
/// </summary>
private static IServiceProvider InitializeServiceProvider(
IDictionary <string, string> arguments,
ISecretInjector secretInjector,
ApplicationInsightsConfiguration applicationInsightsConfiguration,
ITelemetryClient telemetryClient,
ILoggerFactory loggerFactory)
{
var configurationBuilder = new ConfigurationBuilder()
.AddInMemoryCollection(arguments);
IServiceCollection services = new ServiceCollection();
services.AddSingleton(secretInjector);
services.AddSingleton(applicationInsightsConfiguration.TelemetryConfiguration);
services.AddSingleton <IConfiguration>(configurationBuilder.Build());
services.Add(ServiceDescriptor.Scoped(typeof(IOptionsSnapshot <>), typeof(NonCachingOptionsSnapshot <>)));
services.AddSingleton(loggerFactory);
services.AddLogging();
services.AddSingleton(telemetryClient);
var containerBuilder = new ContainerBuilder();
containerBuilder.Populate(services);
containerBuilder.RegisterAssemblyModules(typeof(Program).Assembly);
return(new AutofacServiceProvider(containerBuilder.Build()));
}
public DiscoveryController(
IOptions <WebApp.Models.ApplicationDetail> applicationDetail,
IOptions <OAuthEndpoints> oAuthConfig,
IOptions <ApplicationInsightsConfiguration> applicationInsights)
{
_oAuthConfig = oAuthConfig.Value;
_applicationInsights = applicationInsights.Value;
_applicationDetail = applicationDetail.Value;
_applicationDetail.ApplicationInsights = _applicationInsights;
}
public ConfigSettingsController(
IOptions <AzureAdConfiguration> azureAdConfiguration,
IOptions <KinlyConfiguration> kinlyConfiguration,
IOptions <ApplicationInsightsConfiguration> applicationInsightsConfiguration,
IOptions <TestUserSecrets> testSettings)
{
_azureAdConfiguration = azureAdConfiguration.Value;
_kinlyConfiguration = kinlyConfiguration.Value;
_applicationInsightsConfiguration = applicationInsightsConfiguration.Value;
_testUserSecrets = testSettings.Value;
}
public void Should_return_response_with_settings()
{
var azureAdConfiguration = new AzureAdConfiguration
{
ClientId = "ClientId",
TenantId = "TenantId",
ClientSecret = "ClientSecret",
Authority = "Authority",
RedirectUri = "https://vh-admin-web.com",
PostLogoutRedirectUri = "https://vh-admin-web.com/"
};
var testSettings = new TestUserSecrets
{
TestUsernameStem = "@hmcts.net"
};
var kinlyConfiguration = new KinlyConfiguration {
ConferencePhoneNumber = "1111111", JoinByPhoneFromDate = "2021-02-03"
};
var applicationInsightsConfiguration = new ApplicationInsightsConfiguration();
var httpContext = new DefaultHttpContext();
httpContext.Request.Scheme = "https";
httpContext.Request.Host = new HostString("vh-admin-web.com");
httpContext.Request.PathBase = "";
var controllerContext = new ControllerContext {
HttpContext = httpContext
};
var configSettingsController = new ConfigSettingsController(
Options.Create(azureAdConfiguration),
Options.Create(kinlyConfiguration),
Options.Create(applicationInsightsConfiguration),
Options.Create(testSettings))
{
ControllerContext = controllerContext
};
var actionResult = (OkObjectResult)configSettingsController.Get().Result;
var clientSettings = (ClientSettingsResponse)actionResult.Value;
clientSettings.ClientId.Should().Be(azureAdConfiguration.ClientId);
clientSettings.TenantId.Should().Be(azureAdConfiguration.TenantId);
clientSettings.RedirectUri.Should().Be(azureAdConfiguration.RedirectUri);
clientSettings.PostLogoutRedirectUri.Should().Be(azureAdConfiguration.PostLogoutRedirectUri);
clientSettings.ConferencePhoneNumber.Should().Be(kinlyConfiguration.ConferencePhoneNumber);
clientSettings.JoinByPhoneFromDate.Should().Be(kinlyConfiguration.JoinByPhoneFromDate);
clientSettings.TestUsernameStem.Should().Be(testSettings.TestUsernameStem);
}
private static ILoggerFactory ConfigureLoggerFactory(ApplicationInsightsConfiguration applicationInsightsConfiguration)
{
var loggerConfiguration = LoggingSetup.CreateDefaultLoggerConfiguration(withConsoleLogger: true);
loggerConfiguration.WriteTo.File("Log.txt", retainedFileCountLimit: 3, fileSizeLimitBytes: 1000000, rollOnFileSizeLimit: true);
var loggerFactory = LoggingSetup.CreateLoggerFactory(
loggerConfiguration,
LogEventLevel.Debug,
applicationInsightsConfiguration.TelemetryConfiguration);
// Create a logger that is scoped to this class (only)
_logger = loggerFactory.CreateLogger <Program>();
return(loggerFactory);
}
private static TelemetryConfiguration GenerateTelemetryConfiguration(ContainerLogConfiguration containerLogConfiguration, ApplicationInsightsConfiguration applicationInsightsConfiguration)
{
var telemetryConfiguration = new Faker <TelemetryConfiguration>()
.StrictMode(true)
.RuleFor(telemetry => telemetry.DefaultVerbosity, faker => LogLevel.Error)
.RuleFor(telemetry => telemetry.ContainerLogs, faker => containerLogConfiguration)
.RuleFor(telemetry => telemetry.ApplicationInsights, faker => applicationInsightsConfiguration)
.Generate();
return(telemetryConfiguration);
}
public ApplicationInsightsDependencyDataSource(ApplicationInsightsConfiguration configuration) : base(configuration)
{
}
private static async Task <int> Run(JobBase job, string[] commandLineArgs, bool?runContinuously)
{
if (commandLineArgs.Length > 0 && string.Equals(commandLineArgs[0], "-" + JobArgumentNames.Dbg, StringComparison.OrdinalIgnoreCase))
{
commandLineArgs = commandLineArgs.Skip(1).ToArray();
Debugger.Launch();
}
// Configure logging before Application Insights is enabled.
// This is done so, in case Application Insights fails to initialize, we still see output.
var loggerFactory = ConfigureLogging(job, telemetryConfiguration: null);
int exitCode;
try
{
_logger.LogInformation("Started...");
// Get the args passed in or provided as an env variable based on jobName as a dictionary of <string argName, string argValue>
var jobArgsDictionary = JobConfigurationManager.GetJobArgsDictionary(
ServiceContainer,
loggerFactory.CreateLogger(typeof(JobConfigurationManager)),
commandLineArgs);
// Setup logging
_applicationInsightsConfiguration = ConfigureApplicationInsights(job, jobArgsDictionary);
// Configure our logging again with Application Insights initialized.
loggerFactory = ConfigureLogging(job, _applicationInsightsConfiguration.TelemetryConfiguration);
var hasOnceArgument = JobConfigurationManager.TryGetBoolArgument(jobArgsDictionary, JobArgumentNames.Once);
if (runContinuously.HasValue && hasOnceArgument)
{
_logger.LogWarning(
$"This job is designed to {(runContinuously.Value ? "run continuously" : "run once")} so " +
$"the -{JobArgumentNames.Once} argument is {(runContinuously.Value ? "ignored" : "redundant")}.");
}
runContinuously = runContinuously ?? !hasOnceArgument;
var reinitializeAfterSeconds = JobConfigurationManager.TryGetIntArgument(jobArgsDictionary, JobArgumentNames.ReinitializeAfterSeconds);
var sleepDuration = JobConfigurationManager.TryGetIntArgument(jobArgsDictionary, JobArgumentNames.Sleep); // sleep is in milliseconds
if (!sleepDuration.HasValue)
{
sleepDuration = JobConfigurationManager.TryGetIntArgument(jobArgsDictionary, JobArgumentNames.Interval);
if (sleepDuration.HasValue)
{
sleepDuration = sleepDuration.Value * 1000; // interval is in seconds
}
}
if (!sleepDuration.HasValue)
{
if (runContinuously.Value)
{
_logger.LogInformation("SleepDuration is not provided or is not a valid integer. Unit is milliSeconds. Assuming default of 5000 ms...");
}
sleepDuration = 5000;
}
else if (!runContinuously.Value)
{
_logger.LogWarning(
$"The job is designed to run once so the -{JobArgumentNames.Sleep} and " +
$"-{JobArgumentNames.Interval} arguments are ignored.");
}
if (!reinitializeAfterSeconds.HasValue)
{
_logger.LogInformation(
$"{JobArgumentNames.ReinitializeAfterSeconds} command line argument is not provided or is not a valid integer. " +
"The job will reinitialize on every iteration");
}
else if (!runContinuously.Value)
{
_logger.LogWarning(
$"The job is designed to run once so the -{JobArgumentNames.ReinitializeAfterSeconds} " +
$"argument is ignored.");
}
// Ensure that SSLv3 is disabled and that Tls v1.2 is enabled.
ServicePointManager.SecurityProtocol &= ~SecurityProtocolType.Ssl3;
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12;
// Run the job loop
exitCode = await JobLoop(job, runContinuously.Value, sleepDuration.Value, reinitializeAfterSeconds, jobArgsDictionary);
}
catch (Exception ex)
{
exitCode = 1;
_logger.LogError("Job runner threw an exception: {Exception}", ex);
}
Trace.Close();
_applicationInsightsConfiguration.TelemetryConfiguration.TelemetryChannel.Flush();
_applicationInsightsConfiguration.Dispose();
return(exitCode);
}
public static async Task MainAsync(string[] args)
{
if (args.Length > 0 && string.Equals("dbg", args[0], StringComparison.OrdinalIgnoreCase))
{
args = args.Skip(1).ToArray();
Debugger.Launch();
}
NgJob job = null;
ApplicationInsightsConfiguration applicationInsightsConfiguration = null;
int exitCode = 0;
try
{
// Get arguments
var arguments = CommandHelpers.GetArguments(args, 1, out var secretInjector);
// Ensure that SSLv3 is disabled and that Tls v1.2 is enabled.
ServicePointManager.SecurityProtocol &= ~SecurityProtocolType.Ssl3;
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12;
// Determine the job name
if (args.Length == 0)
{
throw new ArgumentException("Missing job name argument.");
}
var jobName = args[0];
var instanceName = arguments.GetOrDefault(Arguments.InstanceName, jobName);
var instrumentationKey = arguments.GetOrDefault <string>(Arguments.InstrumentationKey);
var heartbeatIntervalSeconds = arguments.GetOrDefault <int>(Arguments.HeartbeatIntervalSeconds);
applicationInsightsConfiguration = ConfigureApplicationInsights(
instrumentationKey,
heartbeatIntervalSeconds,
jobName,
instanceName,
out var telemetryClient,
out var telemetryGlobalDimensions);
var loggerFactory = ConfigureLoggerFactory(applicationInsightsConfiguration);
InitializeServiceProvider(
arguments,
secretInjector,
applicationInsightsConfiguration,
telemetryClient,
loggerFactory);
job = NgJobFactory.GetJob(jobName, loggerFactory, telemetryClient, telemetryGlobalDimensions);
job.SetSecretInjector(secretInjector);
// This tells Application Insights that, even though a heartbeat is reported,
// the state of the application is unhealthy when the exitcode is different from zero.
// The heartbeat metadata is enriched with the job loop exit code.
applicationInsightsConfiguration.DiagnosticsTelemetryModule?.AddOrSetHeartbeatProperty(
HeartbeatProperty_JobLoopExitCode,
exitCode.ToString(),
isHealthy: exitCode == 0);
var cancellationTokenSource = new CancellationTokenSource();
await job.RunAsync(arguments, cancellationTokenSource.Token);
exitCode = 0;
}
catch (ArgumentException ae)
{
exitCode = 1;
_logger?.LogError("A required argument was not found or was malformed/invalid: {Exception}", ae);
Console.WriteLine(job != null ? job.GetUsage() : NgJob.GetUsageBase());
}
catch (KeyNotFoundException knfe)
{
exitCode = 1;
_logger?.LogError("An expected key was not found. One possible cause of this is required argument has not been provided: {Exception}", knfe);
Console.WriteLine(job != null ? job.GetUsage() : NgJob.GetUsageBase());
}
catch (Exception e)
{
exitCode = 1;
_logger?.LogCritical("A critical exception occured in ng.exe! {Exception}", e);
}
applicationInsightsConfiguration.DiagnosticsTelemetryModule?.SetHeartbeatProperty(
HeartbeatProperty_JobLoopExitCode,
exitCode.ToString(),
isHealthy: exitCode == 0);
Trace.Close();
applicationInsightsConfiguration?.TelemetryConfiguration.TelemetryChannel.Flush();
}
public ApplicationInsightsRequestDataSource(ApplicationInsightsConfiguration configuration) : base(configuration)
{
}
protected ApplicationInsightsDataSource(ApplicationInsightsConfiguration configuration)
{
_configuration = configuration;
}
internal void SetApplicationInsightsConfiguration(ApplicationInsightsConfiguration applicationInsightsConfiguration)
{
ApplicationInsightsConfiguration = applicationInsightsConfiguration ?? throw new ArgumentNullException(nameof(applicationInsightsConfiguration));
}
