public static IConfigurationBuilder AddCubesConfiguration(
this IConfigurationBuilder config,
ICubesEnvironment cubesEnvironment)
{
config.AddCubesConfigurationProvider(cubesEnvironment);
config.AddYamlFile(
cubesEnvironment.GetFileOnPath(CubesFolderKind.Config, CubesConstants.Files_DataAccess),
optional: true,
reloadOnChange: true);
config.AddYamlFile(
cubesEnvironment.GetFileOnPath(CubesFolderKind.Config, CubesConstants.Files_StaticContent),
optional: true,
reloadOnChange: true);
config.AddYamlFile(
cubesEnvironment.GetFileOnPath(CubesFolderKind.Config, CubesConstants.Files_SmtpSettings),
optional: true,
reloadOnChange: true);
// Installation specific application settings
config.AddJsonFile(
cubesEnvironment.GetFileOnPath(CubesFolderKind.Config, CubesConstants.Files_AppSettings),
optional: true,
reloadOnChange: true);
return(config);
}
public static IConfigurationBuilder AddCubesConfigurationProvider(this IConfigurationBuilder configuration,
ICubesEnvironment cubes)
{
const string section = CubesConstants.Configuration_Section;
var cubesConfig = new Dictionary <string, string>
{
{ $"{section}:Version", cubes.GetEnvironmentInformation().FullVersion },
{ $"{section}:RootFolder", cubes.GetRootFolder() },
{ $"{section}:AdminPath", cubes.GetAdminPath() },
{ $"{section}:ContentFolder", cubes.GetFolder(CubesFolderKind.Content) },
{ $"{section}:LibrariesFolder", cubes.GetFolder(CubesFolderKind.Libraries) },
{ $"{section}:LogsFolder", cubes.GetFolder(CubesFolderKind.Logs) },
{ $"{section}:ConfigFolder", cubes.GetConfigurationFolder() },
{ $"{section}:StorageFolder", cubes.GetStorageFolder() },
{ $"{section}:TempFolder", cubes.GetFolder(CubesFolderKind.Temp) },
{ $"{section}:WebRootFolder", cubes.GetFolder(CubesFolderKind.WebRoot) },
{ $"{section}:BinariesFolder", cubes.GetBinariesFolder() },
};
var swaggerFiles = cubes
.GetSwaggerXmlFiles()
.Select((f, i) => new KeyValuePair <string, string>($"{section}:SwaggerXMLFiles:{i}", f))
.ToList();
foreach (var item in swaggerFiles)
{
cubesConfig.Add(item.Key, item.Value);
}
configuration.AddInMemoryCollection(cubesConfig);
return(configuration);
}
public ConfigurationWriter(ITypeResolver typeResolver,
ICubesEnvironment cubesEnvironment,
IEnumerable <ISerializer> serializers)
{
_typeResolver = typeResolver;
_cubesEnvironment = cubesEnvironment;
_serializers = serializers.ToList();
}
public static IConfigurationBuilder AddApplicationsConfiguration(this IConfigurationBuilder configuration,
ICubesEnvironment cubes)
{
foreach (var application in cubes.GetActivatedApplications())
{
application.ConfigureAppConfiguration(configuration);
}
return(configuration);
}
public static IServiceCollection AddApplicationsServices(this IServiceCollection services,
ICubesEnvironment cubes)
{
services.AddSingleton(cubes);
foreach (var application in cubes.GetActivatedApplications())
{
application.ConfigureServices(services);
}
return(services);
}
public UIController(IConfiguration configuration,
ILookupManager lookupManager,
ITypeResolver typeResolver,
ISchemaManager schemaManager,
ICubesEnvironment cubesEnvironment,
IServiceScopeFactory scopeFactory)
{
this.configuration = configuration;
this.schemaManager = schemaManager;
this.typeResolver = typeResolver;
this.lookupManager = lookupManager;
this.cubesEnvironment = cubesEnvironment;
this.scopeFactory = scopeFactory;
}
public LiteDbExecutionHistoryManager(ICubesEnvironment cubesEnvironment,
IConfiguration configuration,
ILogger <LiteDbExecutionHistoryManager> logger)
{
var retentionString = configuration.GetValue(CubesConstants.Config_JobsHistoryRetention, "LastWeek");
_defaultRetention = Retention.FromString(retentionString);
var path = Path.Combine(cubesEnvironment.GetStorageFolder(), CubesConstants.ExecutionHistory_File);
_liteDb = new LiteDatabase(path);
_cleanup = new Timer(CleanupCallback, null, 3 * 1000, _cleanupIntervalSeconds * 1000);
_logger = logger;
_logger.LogInformation($"Execution history manager with retention {_defaultRetention}");
}
public static IHostBuilder CreateHostBuilder(string[] args, ICubesEnvironment cubes)
{
var configuration = new ConfigurationBuilder()
.SetBasePath(cubes.GetBinariesFolder())
.AddJsonFile(CubesConstants.Config_AppSettings, optional: false)
.AddCommandLine(args)
.Build();
var urls = configuration.GetValue <string>(CubesConstants.Config_HostURLs, "http://localhost:3001");
return(Microsoft.Extensions.Hosting.Host
.CreateDefaultBuilder(args)
.UseServiceProviderFactory(new AutofacServiceProviderFactory())
.UseWindowsService()
.UseContentRoot(cubes.GetRootFolder())
.ConfigureAppConfiguration((builder, config) =>
{
config.SetBasePath(cubes.GetBinariesFolder());
config.AddCubesConfiguration(cubes);
config.AddApplicationsConfiguration(cubes);
})
.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.AddNLog();
})
.ConfigureContainer <ContainerBuilder>(builder =>
{
builder
.RegisterCubeServices()
.RegisterApplicationServices(cubes);
})
.ConfigureServices((builder, services) =>
{
services.AddSingleton(cubes);
services.AddCubesCore(builder.Configuration);
services.AddApplicationsServices(cubes);
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>();
webBuilder.UseUrls(urls);
webBuilder.UseWebRoot(cubes.GetFolder(CubesFolderKind.Content));
}));
}
public Scheduler(
IJobFactory jobFactory,
ISchedulerFactory schedulerFactory,
ILogger <Scheduler> logger,
IExecutionHistoryManager historyManager,
ICubesEnvironment cubesEnvironment)
{
_schedulerFactory = schedulerFactory;
_jobFactory = jobFactory;
_logger = logger;
_historyManager = historyManager;
var configurationPath = cubesEnvironment
.GetFileOnPath(CubesFolderKind.Config, CubesConstants.Files_Scheduling);
_schedulerConfiguration = new ConfigurationBuilder()
.AddYamlFile(configurationPath, optional: true, reloadOnChange: true)
.Build();
}
public Scheduler(
IJobFactory jobFactory,
ISchedulerFactory schedulerFactory,
ILogger <Scheduler> logger,
ICubesEnvironment cubesEnvironment)
{
this.schedulerFactory = schedulerFactory;
this.jobFactory = jobFactory;
this.logger = logger;
var configurationPath = cubesEnvironment
.GetFileOnPath(CubesFolderKind.Settings, CubesConstants.Files_Scheduling);
schedulerConfiguration = new ConfigurationBuilder()
.AddYamlFile(configurationPath, optional: true, reloadOnChange: true)
.Build();
schedulerConfiguration.OnChange(async() => await Reload());
}
public static IConfigurationBuilder AddCubesConfigurationProvider(this IConfigurationBuilder configuration,
ICubesEnvironment cubes)
{
var cubesConfig = new Dictionary <string, string>
{
{ $"{CubesConstants.Configuration_Section}:Version", cubes.GetEnvironmentInformation().FullVersion },
{ $"{CubesConstants.Configuration_Section}:RootFolder", cubes.GetRootFolder() },
{ $"{CubesConstants.Configuration_Section}:AppsFolder", cubes.GetAppsFolder() },
{ $"{CubesConstants.Configuration_Section}:LogsFolder", cubes.GetFolder(CubesFolderKind.Logs) },
{ $"{CubesConstants.Configuration_Section}:SettingsFolder", cubes.GetSettingsFolder() },
{ $"{CubesConstants.Configuration_Section}:StorageFolder", cubes.GetStorageFolder() },
{ $"{CubesConstants.Configuration_Section}:TempFolder", cubes.GetFolder(CubesFolderKind.Temp) },
{ $"{CubesConstants.Configuration_Section}:StaticContentFolder", cubes.GetFolder(CubesFolderKind.Content) },
{ $"{CubesConstants.Configuration_Section}:BinariesFolder", cubes.GetBinariesFolder() },
};
var swaggerFiles = cubes
.GetSwaggerFiles()
.Select((f, i) => new KeyValuePair <string, string>($"{CubesConstants.Configuration_Section}:SwaggerFiles:{i}", f))
.ToList();
foreach (var item in swaggerFiles)
{
cubesConfig.Add(item.Key, item.Value);
}
var allAssembliesWithControllers = cubes
.GetActivatedApplications()
.SelectMany(app => app.AssembliesWithControllers.ToList())
.Select((f, i) => new KeyValuePair <string, string>($"{CubesConstants.Configuration_Section}:AssembliesWithControllers:{i}", f))
.ToList();
foreach (var item in allAssembliesWithControllers)
{
cubesConfig.Add(item.Key, item.Value);
}
configuration.AddInMemoryCollection(cubesConfig);
return(configuration);
}
private static IHostBuilder CreateHostBuilder(string[] args, ICubesEnvironment cubes)
=> Microsoft.Extensions.Hosting.Host
.CreateDefaultBuilder(args)
.UseServiceProviderFactory(new AutofacServiceProviderFactory())
.UseWindowsService()
.UseContentRoot(cubes.GetRootFolder())
.ConfigureAppConfiguration((_, configBuilder) =>
{
configBuilder
.SetBasePath(cubes.GetBinariesFolder())
.AddCubesConfiguration(cubes)
.AddApplicationsConfiguration(cubes);
})
.ConfigureLogging(logging =>
{
logging
.ClearProviders()
.AddNLog();
})
.ConfigureContainer <ContainerBuilder>(builder =>
{
builder
.RegisterCubeServices()
.RegisterApplicationServices(cubes);
})
.ConfigureServices((builder, services) =>
{
services
.AddSingleton(cubes)
.AddCubesCore(builder.Configuration)
.AddApplicationsServices(builder.Configuration, cubes);
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder
.UseStartup <Startup>()
.UseWebRoot(cubes.GetFolder(CubesFolderKind.WebRoot));
});
public static ContainerBuilder RegisterApplicationServices(this ContainerBuilder builder, ICubesEnvironment cubes)
{
foreach (var application in cubes.GetApplicationInstances())
{
application.RegisterServices(builder);
}
return(builder);
}
public static string GetRootFolder(this ICubesEnvironment cubesEnvironment) => cubesEnvironment.GetFolder(CubesFolderKind.Root);
public static string GetAppsFolder(this ICubesEnvironment cubesEnvironment) => cubesEnvironment.GetFolder(CubesFolderKind.Apps);
public SystemController(ICubesEnvironment cubesEnvironment,
IApiDescriptionGroupCollectionProvider apiExplorer)
{
this.cubesEnvironment = cubesEnvironment;
this.apiExplorer = apiExplorer;
}
public static string GetSettingsFolder(this ICubesEnvironment cubesEnvironment) => cubesEnvironment.GetFolder(CubesFolderKind.Settings);
public ArchiveFilesHandler(ICubesEnvironment cubesEnvironment) => this.cubesEnvironment = cubesEnvironment;
public static string GetStorageFolder(this ICubesEnvironment cubesEnvironment) => cubesEnvironment.GetFolder(CubesFolderKind.Storage);
public ArchiveFilesSampleProvider(ICubesEnvironment environment) => _environment = environment;
public static string GetConfigurationFolder(this ICubesEnvironment cubesEnvironment) => cubesEnvironment.GetFolder(CubesFolderKind.Config);
public virtual IConfigurationBuilder ConfigureAppConfiguration(
IConfigurationBuilder configuration,
ICubesEnvironment cubes) => configuration;
public override IConfigurationBuilder ConfigureAppConfiguration(IConfigurationBuilder configuration, ICubesEnvironment cubes)
{
return(configuration.AddYamlFile(
cubes.GetFileOnPath(CubesFolderKind.Config, SampleApplication.OptionsFile),
optional: true,
reloadOnChange: true));
}
public static string GetFileOnPath(this ICubesEnvironment cubesEnvironment,
CubesFolderKind folderKind,
string fileName)
=> Path.Combine(cubesEnvironment.GetFolder(folderKind), fileName);
