Skip to content
Snippets Groups Projects
Select Git revision
  • v2
  • Coscine/FederationAdaption default
  • gitkeep
  • dev protected
  • Sprint/2022-01
  • fixmerge
  • master
  • develop protected
  • dependabot/nuget/Samples/SampleMvcApplication/bootstrap-3.4.1
  • dependabot/nuget/Samples/SampleOwinApplication/bootstrap-3.4.1
  • v1
  • netcore-cookiemanager
  • limitingcookiemanager
  • owin-cookiemanager
  • owin-cookiemanger-changeinterface
  • excess-cookies
  • missing_nodes_exceptions
  • empty_ref_exception
  • fix_shared_options
  • csphashsupport
  • v2.7.0
  • v1.0.2
  • v2.6.0
  • v2.5.0
  • v1.0.1
  • v2.4.0
  • v2.3.0
  • v2.2.0
  • v2.1.0
  • v2.0.0
  • v1.0.0
  • v0.24.0
  • v0.23.0
  • v2.0.0-preview01
  • v0.22.0
  • v0.21.2
  • v0.21.1
  • v0.21.0
  • v0.20.0
  • v0.19.0
40 results

Saml2Namespaces.cs

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    Program.cs 11.68 KiB
    using CommandLine;
    using Coscine.ApiClient.Core.Api;
    using Coscine.ApiClient.Core.Client;
    using Coscine.KpiGenerator.Logging;
    using Coscine.KpiGenerator.Models.ConfigurationModels;
    using Coscine.KpiGenerator.Reportings.ApplicationProfile;
    using Coscine.KpiGenerator.Reportings.Complete;
    using Coscine.KpiGenerator.Reportings.Project;
    using Coscine.KpiGenerator.Reportings.Resource;
    using Coscine.KpiGenerator.Reportings.System;
    using Coscine.KpiGenerator.Reportings.User;
    using Coscine.KpiGenerator.Utils;
    using Microsoft.Extensions.Configuration;
    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.Extensions.Logging;
    using NLog;
    using NLog.Extensions.Logging;
    using Winton.Extensions.Configuration.Consul;
    using static KPIGenerator.Utils.CommandLineOptions;
    using LogLevel = Microsoft.Extensions.Logging.LogLevel;
    
    namespace Coscine.KpiGenerator;
    
    public class Program
    {
        private static IServiceProvider _serviceProvider = null!;
        private static string? _environmentName;
    
        public static async Task<int> Main(string[] args)
        {
            _environmentName = Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT");
    
            Console.WriteLine($"Running in environment: {_environmentName ?? "environment is null"}");
    
            InitializeServices();
    
            var logger = _serviceProvider.GetRequiredService<ILogger<Program>>();
    
            try
            {
                var parserResult = Parser.Default.ParseArguments<
                    CompleteReportingOptions,
                    ProjectReportingOptions,
                    ResourceReportingOptions,
                    UserReportingOptions,
                    ApplicationProfileReportingOptions,
                    SystemReportingOptions
                >(args);
    
                var result = await parserResult.MapResult(
                    (CompleteReportingOptions opts) => _serviceProvider.GetRequiredService<CompleteReporting>().RunAsync(opts),
                    (ProjectReportingOptions opts) => _serviceProvider.GetRequiredService<ProjectReporting>().RunAsync(opts),
                    (ResourceReportingOptions opts) => _serviceProvider.GetRequiredService<ResourceReporting>().RunAsync(opts),
                    (UserReportingOptions opts) => _serviceProvider.GetRequiredService<UserReporting>().RunAsync(opts),
                    (ApplicationProfileReportingOptions opts) => _serviceProvider.GetRequiredService<ApplicationProfileReporting>().RunAsync(opts),
                    (SystemReportingOptions opts) => _serviceProvider.GetRequiredService<SystemReporting>().RunAsync(opts),
                    HandleParseError
                );
    
                if (result)
                {
                    logger.LogInformation("Finished.");
                    return 0; // Exit Code 0 for Success
                }
                else
                {
                    logger.LogInformation("Program execution was interrupted.");
                    return -1; // Exit Code -1 for Failure
                }
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "Exception: {message}", ex.Message);
                return -1; // Exit Code -1 for Failure
            }
            finally
            {
                DisposeServices();
            }
        }
    
        private static void InitializeServices()
        {
            // Register custom layout renderers for NLog
            LogManager.Setup().SetupExtensions(s =>
            {
                s.RegisterLayoutRenderer<AssemblyNameLayoutRenderer>("assembly-name");
                s.RegisterLayoutRenderer<AssemblyVersionLayoutRenderer>("assembly-version");
            });
    
            // Create a new instance of ConfigurationBuilder
            var configBuilder = new ConfigurationBuilder();
    
            // Define the Consul URL
            var consulUrl = Environment.GetEnvironmentVariable("CONSUL_URL") ?? "http://localhost:8500";
    
            // Remove the default sources
            configBuilder.Sources.Clear();
    
            // Add Consul as a configuration source
            var configuration = configBuilder
                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                .AddJsonFile($"appsettings.{_environmentName}.json", optional: true, reloadOnChange: true)
                            .AddConsul(
                    "coscine/Coscine.Infrastructure/KpiGenerator/appsettings",
                    options =>
                    {
                        options.ConsulConfigurationOptions =
                            cco => cco.Address = new Uri(consulUrl);
                        options.Optional = true;
                        options.ReloadOnChange = true;
                        options.PollWaitTime = TimeSpan.FromSeconds(5);
                        options.OnLoadException = exceptionContext => exceptionContext.Ignore = true;
                    }
                )
                .AddConsul(
                    $"coscine/Coscine.Infrastructure/KpiGenerator/appsettings.{_environmentName}.json",
                    options =>
                    {
                        options.ConsulConfigurationOptions =
                            cco => cco.Address = new Uri(consulUrl);
                        options.Optional = true;
                        options.ReloadOnChange = true;
                        options.PollWaitTime = TimeSpan.FromSeconds(5);
                        options.OnLoadException = exceptionContext => exceptionContext.Ignore = true;
                    }
                )
                .AddEnvironmentVariables()
                .Build();
    
            var services = new ServiceCollection()
                .AddSingleton<IConfiguration>(configuration);
    
            // Add the configuration to the service collection
            services.Configure<KpiConfiguration>(settings =>
            {
                configuration.GetSection(KpiConfiguration.Section).Bind(settings);
            });
            services.Configure<ReportingConfiguration>(settings =>
            {
                configuration.GetSection(ReportingConfiguration.Section).Bind(settings);
            });
    
            // Add logging
            services.AddLogging(builder =>
            {
                builder.ClearProviders();
                builder.SetMinimumLevel(LogLevel.Trace);
                builder.AddNLog();
            });
    
            var reportingConfiguration = new ReportingConfiguration();
            configuration.Bind(ReportingConfiguration.Section, reportingConfiguration);
    
            // Set the default LogLevel
            LogManager.Configuration.Variables["logLevel"] = reportingConfiguration.Logger?.LogLevel ?? "Trace";
            // Set the log location
            LogManager.Configuration.Variables["logHome"] = reportingConfiguration.Logger?.LogHome ?? Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Logs");
    
            // Add AutoMapper
            services.AddAutoMapper(typeof(Program));
    
            // Register the in-memory cache service
            services.AddMemoryCache();
    
            // Register the storage services
            services.AddKeyedSingleton<IStorageService, GitLabStorageService>("gitlab");
            services.AddKeyedSingleton<IStorageService, FileSystemStorageService>("local");
    
            // Register the HTTP client
            services.AddHttpClient();
    
            // Add the API clients
            var apiConfiguration = new Configuration()
            {
                BasePath = $"{reportingConfiguration.Endpoint.TrimEnd('/')}/coscine",
                ApiKeyPrefix = { { "Authorization", "Bearer" } },
                ApiKey = { { "Authorization", reportingConfiguration.ApiKey } },
                Timeout = TimeSpan.FromSeconds(300), // 5 minutes
            };
            services.AddSingleton<IAdminApi>(new AdminApi(apiConfiguration));
            services.AddSingleton<IApplicationProfileApi>(new ApplicationProfileApi(apiConfiguration));
            services.AddSingleton<IProjectApi>(new ProjectApi(apiConfiguration));
            services.AddSingleton<IProjectQuotaApi>(new ProjectQuotaApi(apiConfiguration));
            services.AddSingleton<IProjectResourceQuotaApi>(new ProjectResourceQuotaApi(apiConfiguration));
            services.AddSingleton<IRoleApi>(new RoleApi(apiConfiguration));
            services.AddSingleton<IUserApi>(new UserApi(apiConfiguration));
    
            // Add services for reporting
            services.AddTransient<CompleteReporting>();
            services.AddTransient<ProjectReporting>();
            services.AddTransient<ResourceReporting>();
            services.AddTransient<UserReporting>();
            services.AddTransient<SystemReporting>();
            services.AddTransient<ApplicationProfileReporting>();
    
            _serviceProvider = services.BuildServiceProvider();
        }
    
        private static void DisposeServices()
        {
            if (_serviceProvider == null)
            {
                return;
            }
            if (_serviceProvider is IDisposable disposable)
            {
                disposable.Dispose();
            }
        }
    
        private static Task<bool> HandleParseError(IEnumerable<Error> errs)
        {
            var logger = _serviceProvider.GetService<ILogger<Program>>();
    
            foreach (var err in errs)
            {
                if (err is HelpRequestedError || err is VersionRequestedError)
                {
                    // Handle the display of help or version information
                    // Usually, the library will automatically display the help/version info,
                    // but you can customize it if needed.
                }
                else
                {
                    // For other types of errors, you can log them or write them to the console
                    logger?.LogError("Error encountered parsing command-line options: {Error}", err.ToString());
                    Console.Error.WriteLine($"Error: {err}");
                }
            }
    
            // Since there were errors, we typically return false to indicate that the program should not proceed
            return Task.FromResult(false);
        }
    
        public static TResult SanitizeOptions<TResult>(TResult unsanitizedOptions)
        {
            // Sanitize all input that accepts an array or is a list of inputs.
            if (unsanitizedOptions is not null)
            {
                var type = unsanitizedOptions.GetType();
                if (type == typeof(CompleteReportingOptions))
                {
                    var options = unsanitizedOptions as CompleteReportingOptions;
                    if (options is not null)
                    {
                        // Sanitize options here
                        return (TResult)(object)options;
                    }
                }
                else if (type == typeof(ProjectReportingOptions))
                {
                    var options = unsanitizedOptions as ProjectReportingOptions;
                    if (options is not null)
                    {
                        // Sanitize options here
                        return (TResult)(object)options;
                    }
                }
                else if (type == typeof(ResourceReportingOptions))
                {
                    var options = unsanitizedOptions as ResourceReportingOptions;
                    if (options is not null)
                    {
                        // Sanitize options here
                        return (TResult)(object)options;
                    }
                }
                else if (type == typeof(UserReportingOptions))
                {
                    var options = unsanitizedOptions as UserReportingOptions;
                    if (options is not null)
                    {
                        // Sanitize options here
                        return (TResult)(object)options;
                    }
                }
                else if (type == typeof(ApplicationProfileReportingOptions))
                {
                    var options = unsanitizedOptions as ApplicationProfileReportingOptions;
                    if (options is not null)
                    {
                        // Sanitize options here
                        return (TResult)(object)options;
                    }
                }
                else if (type == typeof(SystemReportingOptions))
                {
                    var options = unsanitizedOptions as SystemReportingOptions;
                    if (options is not null)
                    {
                        // Sanitize options here
                        return (TResult)(object)options;
                    }
                }
            }
            return unsanitizedOptions;
        }
    }