public ConfigurationResult Build(Action <IConfigurationBuilder> additionalSetup = null)
{
try
{
var configBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
.SetBasePath(AppContext.BaseDirectory)
.AddEnvironmentVariables("OMNISHARP_");
if (_environment.AdditionalArguments?.Length > 0)
{
configBuilder.AddCommandLine(_environment.AdditionalArguments);
}
// Use the global omnisharp config if there's any in the shared path
configBuilder.CreateAndAddGlobalOptionsFile(_environment);
// Use the local omnisharp config if there's any in the root path
configBuilder.AddJsonFile(
new PhysicalFileProvider(_environment.TargetDirectory).WrapForPolling(),
Constants.OptionsFile,
optional: true,
reloadOnChange: true);
// bootstrap additional host configuration at the end
additionalSetup?.Invoke(configBuilder);
var config = configBuilder.Build();
return(new ConfigurationResult(config));
}
catch (Exception ex)
{
return(new ConfigurationResult(ex));
}
}
private static IWebHost BuildWebHost(string[] args)
{
var configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile("appsettings.Development.json", true, false)
.AddJsonFile("appsettings.Production.json", true, false)
.AddEnvironmentVariables()
.AddCommandLine(args);
if (args != null)
{
configurationBuilder.AddCommandLine(args);
}
var hostingconfig = configurationBuilder.Build();
var url = hostingconfig[addressKey] ?? defaultAddress;
return(WebHost.CreateDefaultBuilder(args)
.ConfigureAppConfiguration(config =>
{
config.AddJsonFile("appsettings.json", false, true);
})
.UseConfiguration(hostingconfig)
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseUrls(url)
.UseStartup <Startup>()
.Build());
}
public static void Main(string[] args)
{
var configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile("appsettings.Development.json", true, false)
.AddJsonFile("appsettings.Production.json", true, false)
.AddEnvironmentVariables()
.AddCommandLine(args);
if (args != null)
{
configurationBuilder.AddCommandLine(args);
}
var hostingconfig = configurationBuilder.Build();
var url = hostingconfig[addressKey] ?? defaultAddress;
IWebHostBuilder builder = new WebHostBuilder();
builder.ConfigureServices(s => {
s.AddSingleton(builder);
});
builder.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseConfiguration(hostingconfig)
.UseIISIntegration()
.UseUrls(url)
.UseStartup <Startup>();
var host = builder.Build();
host.Run();
}
public static IConfiguration GetDefault(string[] args)
{
var configBuilder = new ConfigurationBuilder()
.AddEnvironmentVariables();
if (args != null)
{
configBuilder.AddCommandLine(args);
}
return configBuilder.Build();
}
public static void Main(string[] args)
{
var configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile("ocelot.json", true, false)
.AddEnvironmentVariables()
.AddCommandLine(args);
if (args != null)
{
configurationBuilder.AddCommandLine(args);
}
var hostingconfig = configurationBuilder.Build();
var url = hostingconfig[addressKey] ?? defaultAddress;
IWebHostBuilder builder = new WebHostBuilder();
builder.ConfigureServices(s =>
{
s.AddSingleton(builder);
});
builder.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseConfiguration(hostingconfig)
//.ConfigureAppConfiguration((hostingContext, config) =>
//{
// config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
// var env = hostingContext.HostingEnvironment;
// //config.AddOcelot();
// config.AddEnvironmentVariables();
//})
.ConfigureLogging((hostingContext, logging) =>
{
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
//add NLog to ASP.NET Core
logging.AddNLog($"{hostingContext.HostingEnvironment.ContentRootPath}{ Path.DirectorySeparatorChar}nlog.config");
})
.UseIISIntegration()
//.UseIIS()
.UseMetricsWebTracking()
.UseMetricsEndpoints()
.UseNLog()
.UseUrls(url)
.UseStartup <Startup>();
var host = builder.Build();
host.Run();
}
public static void Main(string[] args)
{
var builder = new ConfigurationBuilder();
builder.AddCommandLine(args);
var config = builder.Build();
using(var app = CreateWebHost(config))
{
var serverAddresses = app.ServerFeatures.Get<IServerAddressesFeature>();
Console.BackgroundColor = ConsoleColor.Black;
Console.WriteLine("I'm running... listen on {0}", string.Join(",", serverAddresses.Addresses));
Console.ReadLine();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Startup"/> class.
/// </summary>
/// <param name="env"><see cref="IHostingEnvironment"/> instance.</param>
/// <param name="args">List of arguments from the command line.</param>
public Startup(IHostingEnvironment env, string[] args)
{
this.HostingEnvironment = env;
var builder = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.AddEnvironmentVariables();
if (args != null && args.Length > 0)
{
builder.AddCommandLine(args);
}
this.Configuration = builder.Build();
}
public static IConfiguration GetDefault(string[] args)
{
// We are adding all environment variables first and then adding the ASPNET_ ones
// with the prefix removed to unify with the command line and config file formats
var configBuilder = new ConfigurationBuilder()
.AddJsonFile(HostingJsonFile, optional: true)
.AddEnvironmentVariables()
.AddEnvironmentVariables(prefix: EnvironmentVariablesPrefix);
if (args != null)
{
configBuilder.AddCommandLine(args);
}
return configBuilder.Build();
}
//https://github.com/aspnet/Hosting/blob/dev/src/Microsoft.AspNet.Hosting/Program.cs
public Task<int> Main(string[] args)
{
//Add command line configuration source to read command line parameters.
var builder = new ConfigurationBuilder();
builder.AddCommandLine(args);
var config = builder.Build();
var webhost = new WebHostBuilder(_serviceProvider, config)
.UseServer("Microsoft.AspNet.Server.WebListener")
.Build();
using (var host = webhost.Start()) {
var orchardHost = new OrchardHost(webhost.ApplicationServices, System.Console.In, System.Console.Out, args);
return Task.FromResult(
(int)orchardHost.Run());
}
}
public static void Main(string[] args)
{
//Add command line configuration source to read command line parameters.
var builder = new ConfigurationBuilder();
builder.AddCommandLine(args);
var config = builder.Build();
using (new WebHostBuilder(config)
.UseServer("Microsoft.AspNet.Server.WebListener")
.Build()
.Start())
{
Console.WriteLine("Started the server..");
Console.WriteLine("Press any key to stop the server");
Console.ReadLine();
}
}
public Task<int> Main(string[] args)
{
//Add command line configuration source to read command line parameters.
var builder = new ConfigurationBuilder();
builder.AddCommandLine(args);
var config = builder.Build();
using (new WebHostBuilder(config)
.UseServer("Microsoft.AspNet.Server.Kestrel")
.Build()
.Start())
{
Console.WriteLine("Started the server..");
Console.WriteLine("Press any key to stop the server");
Console.ReadLine();
}
return Task.FromResult(0);
}
public void Main(string[] args)
{
var builder = new ConfigurationBuilder();
Console.WriteLine("Initial Config Providers: " + builder.Providers.Count());
var defaultSettings = new MemoryConfigurationProvider();
defaultSettings.Set("username", "Guest");
builder.Add(defaultSettings);
Console.WriteLine("Added Memory Provider. Providers: " + builder.Providers.Count());
builder.AddCommandLine(args);
Console.WriteLine("Added Command Line Provider. Providers: " + builder.Providers.Count());
var config = builder.Build();
string username = config["username"];
Console.WriteLine($"Hello, {username}!");
}
/// <summary>
/// Builds the configuration.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="builderAction">The builder action.</param>
/// <returns>IConfigurationRoot.</returns>
public static IConfigurationRoot BuildConfiguration(
ConfigurationBuilderOptions options = null,
Action <IConfigurationBuilder> builderAction = null)
{
options = options ?? new ConfigurationBuilderOptions();
if (options.BasePath.IsNullOrEmpty())
{
options.BasePath = Directory.GetCurrentDirectory();
}
var builder = new ConfigurationBuilder()
.SetBasePath(options.BasePath)
.AddJsonFile(options.FileName + ".json", optional: true, reloadOnChange: true);
if (!options.EnvironmentName.IsNullOrEmpty())
{
builder = builder.AddJsonFile($"{options.FileName}.{options.EnvironmentName}.json", optional: true, reloadOnChange: true);
}
if (options.EnvironmentName == "Development")
{
if (options.UserSecretsId != null)
{
builder.AddUserSecrets(options.UserSecretsId);
}
else if (options.UserSecretsAssembly != null)
{
builder.AddUserSecrets(options.UserSecretsAssembly, true);
}
}
builder = builder.AddEnvironmentVariables(options.EnvironmentVariablesPrefix);
if (options.CommandLineArgs != null)
{
builder = builder.AddCommandLine(options.CommandLineArgs);
}
builderAction?.Invoke(builder);
return(builder.Build());
}
private static IWebHost BuildWebHost(string[] args)
{
var configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile("appsettings.Development.json", true, false)
.AddJsonFile("appsettings.Production.json", true, false)
.AddEnvironmentVariables()
.AddCommandLine(args);
if (args != null)
{
configurationBuilder.AddCommandLine(args);
}
var hostingconfig = configurationBuilder.Build();
var url = hostingconfig[addressKey] ?? defaultAddress;
return(WebHost.CreateDefaultBuilder(args)
.ConfigureAppConfiguration((hostingContext, config) =>
{
config
.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
.AddJsonFile("appsettings.json", true, true)
.AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", true, true)
.AddEnvironmentVariables();
})
.ConfigureLogging((hostingContext, logging) =>
{
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
//add NLog to ASP.NET Core
logging.AddNLog($"{hostingContext.HostingEnvironment.ContentRootPath}{ Path.DirectorySeparatorChar}NLog.config");
})
.UseConfiguration(hostingconfig)
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
//.UseIIS()
.UseUrls(url)
.UseStartup <Startup>()
.Build());
}
public Startup(IApplicationEnvironment applicationEnvironment)
{
var configBuilder = new ConfigurationBuilder()
.SetBasePath(applicationEnvironment.ApplicationBasePath)
.AddJsonFile("config.json", optional: true)
.AddEnvironmentVariables();
if (Program.Environment.OtherArgs != null)
{
configBuilder.AddCommandLine(Program.Environment.OtherArgs);
}
// Use the local omnisharp config if there's any in the root path
if (File.Exists(Program.Environment.ConfigurationPath))
{
configBuilder.AddJsonFile(Program.Environment.ConfigurationPath);
}
Configuration = configBuilder.Build();
}
public static void Main(string[] args)
{
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddJsonFile("appsettings.json");
configurationBuilder.AddCommandLine(args);
configurationBuilder.AddEnvironmentVariables();
var configuration = configurationBuilder.Build();
var backgroundColor = (ConsoleColor) short.Parse(configuration["Console:Background:Color"]);
var foregroundColor = (ConsoleColor) short.Parse(configuration["Console:Foreground:Color"]);
Console.BackgroundColor = backgroundColor;
Console.ForegroundColor = foregroundColor;
Console.WriteLine($"The foreground color is {foregroundColor}");
Console.WriteLine($"The background color is {backgroundColor}");
Console.WriteLine(Environment.NewLine);
Console.WriteLine("Press 'Enter' to exit...");
Console.ReadLine();
}
public static void Main(string[] args)
{
var builder = new ConfigurationBuilder();
Console.WriteLine("Initial Config Sources: " + builder.Sources.Count());
builder.AddInMemoryCollection(new Dictionary<string, string>
{
{ "username", "Guest" }
});
Console.WriteLine("Added Memory Source. Sources: " + builder.Sources.Count());
builder.AddCommandLine(args);
Console.WriteLine("Added Command Line Source. Sources: " + builder.Sources.Count());
var config = builder.Build();
string username = config["username"];
Console.WriteLine($"Hello, {username}!");
}
public void AddConfigServer_CommandLineAppSettingsConfiguresClient()
{
// Arrange
var appsettings = new string[]
{
"spring:cloud:config:enabled=false",
"--spring:cloud:config:failFast=false",
"/spring:cloud:config:uri=http://foo.com:9999",
"--spring:cloud:config:name", "myName",
"/spring:cloud:config:label", "myLabel",
"--spring:cloud:config:username", "myUsername",
"--spring:cloud:config:password", "myPassword"
};
var configurationBuilder = new ConfigurationBuilder();
var environment = new HostingEnvironment();
configurationBuilder.AddCommandLine(appsettings);
// Act and Assert
configurationBuilder.AddConfigServer(environment);
ConfigServerConfigurationProvider configServerProvider = null;
foreach (IConfigurationProvider provider in configurationBuilder.Providers)
{
configServerProvider = provider as ConfigServerConfigurationProvider;
if (configServerProvider != null)
break;
}
Assert.NotNull(configServerProvider);
ConfigServerClientSettings settings = configServerProvider.Settings;
Assert.False(settings.Enabled);
Assert.False(settings.FailFast);
Assert.Equal("http://foo.com:9999", settings.Uri);
Assert.Equal(ConfigServerClientSettings.DEFAULT_ENVIRONMENT, settings.Environment);
Assert.Equal("myName", settings.Name );
Assert.Equal("myLabel", settings.Label );
Assert.Equal("myUsername", settings.Username);
Assert.Equal("myPassword", settings.Password );
}
public IConfigurationRoot Build()
{
var configBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
.SetBasePath(AppContext.BaseDirectory)
.AddEnvironmentVariables("OMNISHARP_");
if (_environment.AdditionalArguments?.Length > 0)
{
configBuilder.AddCommandLine(_environment.AdditionalArguments);
}
// Use the global omnisharp config if there's any in the shared path
configBuilder.CreateAndAddGlobalOptionsFile(_environment);
// Use the local omnisharp config if there's any in the root path
configBuilder.AddJsonFile(
new PhysicalFileProvider(_environment.TargetDirectory).WrapForPolling(),
Constants.OptionsFile,
optional: true,
reloadOnChange: true);
return(configBuilder.Build());
}
public static void Main(string[] args)
{
var baseConfigBuilder = new ConfigurationBuilder();
baseConfigBuilder.SetBasePath(Directory.GetCurrentDirectory());
baseConfigBuilder.AddCommandLine(args);
baseConfigBuilder.AddEnvironmentVariables();
var configFile = baseConfigBuilder.Build()["config"];
if (string.IsNullOrEmpty(configFile))
{
Console.WriteLine("No Config File");
Console.WriteLine("Need Parameter \"--config path\"");
return;
}
baseConfigBuilder.AddJsonFile(configFile, true, true);
var baseConfig = baseConfigBuilder.Build();
var logConfigFile = baseConfig["Data:LogConfig"];
var notifyAppsConfigFile = baseConfig["Data:NotifyAppsConfig"];
var appChannelConfigFile = baseConfig["Data:AppChannelConfig"];
baseConfigBuilder
.AddJsonFile(logConfigFile, true, true)
.AddJsonFile(notifyAppsConfigFile, true, true)
.AddJsonFile(appChannelConfigFile, true, true);
Configuration = baseConfigBuilder.Build();
//Nlog
var nlogConfig = new NLog.Config.LoggingConfiguration();
BahamutCommon.LoggerLoaderHelper.LoadLoggerToLoggingConfig(nlogConfig, Configuration, "Logger:fileLoggers");
#if DEBUG
BahamutCommon.LoggerLoaderHelper.AddConsoleLoggerToLogginConfig(nlogConfig);
#endif
LogManager.Configuration = nlogConfig;
try
{
//CSServer
var server = new ChicagoServer();
Server = server;
server.UseNetConfig(new NetConfigReader());
server.UseServerConfig(new ServerConfigReader());
server.UseLogger(new FileLogger(Configuration["ServerLog"]));
#if DEBUG
server.UseLogger(ConsoleLogger.Instance);
#endif
server.UseMessageRoute(new JsonRouteFilter());
server.UseExtension(new BahamutUserValidationExtension());
server.UseExtension(new SharelinkerValidateExtension());
server.UseExtension(new BahamutAppValidateExtension());
//NotificationCenter Extension
var notificationExt = new NotificaionCenterExtension();
server.UseExtension(notificationExt);
server.UseExtension(new HeartBeatExtension());
server.StartServer();
#if DEBUG
DebugConsole();
#else
Thread.Sleep(Timeout.Infinite);
#endif
}
catch (Exception ex)
{
LogManager.GetLogger("Chicago").Fatal(ex);
throw;
}
}
