public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddCaching();
services.AddSession();
services.AddMvc();
services.AddSingleton<PassThroughAttribute>();
services.AddSingleton<UserNameService>();
services.AddTransient<ITestService, TestService>();
services.ConfigureMvc(options =>
{
options.Filters.Add(typeof(PassThroughAttribute), order: 17);
options.AddXmlDataContractSerializerFormatter();
options.Filters.Add(new FormatFilterAttribute());
});
services.AddMvcLocalization(LanguageViewLocationExpanderOption.SubFolder);
#if DNX451
// Fully-qualify configuration path to avoid issues in functional tests. Just "config.json" would be fine
// but Configuration uses CallContextServiceLocator.Locator.ServiceProvider to get IApplicationEnvironment.
// Functional tests update that service but not in the static provider.
var applicationEnvironment = services.BuildServiceProvider().GetRequiredService<IApplicationEnvironment>();
var configurationPath = Path.Combine(applicationEnvironment.ApplicationBasePath, "config.json");
// Set up configuration sources.
var configBuilder = new ConfigurationBuilder()
.AddJsonFile(configurationPath)
.AddEnvironmentVariables();
var configuration = configBuilder.Build();
string diSystem;
if (configuration.TryGet("DependencyInjection", out diSystem) &&
diSystem.Equals("AutoFac", StringComparison.OrdinalIgnoreCase))
{
_autoFac = true;
// Create the autofac container
var builder = new ContainerBuilder();
// Create the container and use the default application services as a fallback
AutofacRegistration.Populate(
builder,
services);
builder.RegisterModule<MonitoringModule>();
var container = builder.Build();
return container.Resolve<IServiceProvider>();
}
else
#endif
{
return services.BuildServiceProvider();
}
}
public void Main(string[] args)
{
var builder = new ConfigurationBuilder(".");
builder.AddJsonFile("appsettings.json");
builder.AddEnvironmentVariables();
var config = builder.Build();
builder.AddEntityFramework(options => options.UseSqlServer(config["Data:DefaultConnection:ConnectionString"]));
config = builder.Build();
Console.WriteLine("key1={0}", config.Get("key1"));
Console.WriteLine("key2={0}", config.Get("key2"));
Console.WriteLine("key3={0}", config.Get("key3"));
}
public int Main(string[] args)
{
var builder = new ConfigurationBuilder();
builder.Add(new JsonConfigurationProvider("config.json"));
var config = builder.Build();
var webjobsConnectionString = config["Data:AzureWebJobsStorage:ConnectionString"];
var dbConnectionString = config["Data:DefaultConnection:ConnectionString"];
if (string.IsNullOrWhiteSpace(webjobsConnectionString))
{
Console.WriteLine("The configuration value for Azure Web Jobs Connection String is missing.");
return 10;
}
if (string.IsNullOrWhiteSpace(dbConnectionString))
{
Console.WriteLine("The configuration value for Database Connection String is missing.");
return 10;
}
var jobHostConfig = new JobHostConfiguration(config["Data:AzureWebJobsStorage:ConnectionString"]);
var host = new JobHost(jobHostConfig);
var methodInfo = typeof(Functions).GetMethods().First();
host.Call(methodInfo);
return 0;
}
public Functional()
{
var appEnv = CallContextServiceLocator.Locator.ServiceProvider.GetService(typeof(IApplicationEnvironment)) as IApplicationEnvironment;
Debug.Assert(appEnv != null, "appEnv != null");
var builder = new ConfigurationBuilder(appEnv.ApplicationBasePath);
builder.AddJsonFile("config.json");
builder.AddJsonFile("config.private.json", true);
var configuration = builder.Build();
var uri = new Uri(configuration["ServerCredentialUri"]);
var username = configuration["ServerCredentialUsername"];
var password = configuration["ServerCredentialPassword"];
_serverCredential = new ServerCredential(uri, username, password);
_freeMusicTorrentFile =
new HttpClient().GetByteArrayAsync(
new Uri("http://bt.etree.org/download.php/582271/hottuna2015-09-11.flac16.torrent")).Result;
_freeMusicTorrentHash = "9ecc7229ff971d27552dd399509e188847dbbbf1";
// Make sure there is no torrents before executing the tests
var api = new Api(_serverCredential);
var torrents = api.GetTorrents().Result;
if (torrents.Any())
{
var result = api.Perform(Action.Removedata, torrents.Select(t => t.InfoHash)).Result;
Assert.True(result);
}
}
public void Main(string[] args)
{
_serviceCollection.AddDaniel15();
var builder = new ConfigurationBuilder(_appEnv.ApplicationBasePath)
// This is extremely ugly, but the paths differ in dev vs in prod.
// Need to figure out a nicer way of doing this.
.AddJsonFile("..\\Daniel15.Web\\config.json", optional: true)
.AddJsonFile("../../../../../../site/approot/packages/Daniel15.Web/1.0.0/root/config.Production.json", optional: true)
.AddEnvironmentVariables();
_serviceCollection.AddDaniel15Config(builder.Build());
_serviceCollection.AddOptions();
_serviceProvider = _serviceCollection.BuildServiceProvider();
var operation = args[0];
switch (operation)
{
case "-disqus":
_serviceProvider.GetRequiredService<IDisqusComments>().Sync();
break;
case "-social":
ActivatorUtilities.CreateInstance<SocialShareUpdater>(_serviceProvider).Run();
break;
case "-projects":
ActivatorUtilities.CreateInstance<ProjectUpdater>(_serviceProvider).Run();
break;
default:
throw new Exception("Invalid operation '" + operation + "'");
}
}
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
var configurationBuilder = new ConfigurationBuilder(appEnv.ApplicationBasePath);
configurationBuilder.AddEnvironmentVariables("BinaryMash.ReleaseManager:");
configurationBuilder.AddJsonFile("Config.json");
_configuration = configurationBuilder.Build();
}
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
var configuration =
new ConfigurationBuilder(appEnv.ApplicationBasePath).AddJsonFile("config.json", false)
.AddEnvironmentVariables();
this.Configuration = configuration.Build();
}
public Startup(IApplicationEnvironment appEnv)
{
var configBuilder = new ConfigurationBuilder(appEnv.ApplicationBasePath);
configBuilder.AddUserSecrets();
configBuilder.AddEnvironmentVariables();
_configuration = configBuilder.Build();
}
public UmbracoConfig(IApplicationEnvironment appEnv)
{
var cfg = new ConfigurationBuilder()
.SetBasePath(appEnv.ApplicationBasePath)
.AddJsonFile("umbraco.json");
_config = cfg.Build();
}
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
// Setup configuration sources.
var builder = new ConfigurationBuilder(appEnv.ApplicationBasePath)
.AddJsonFile("config.json")
.AddJsonFile($"config.{env.EnvironmentName}.json", optional: true);
if (env.IsDevelopment())
{
// This reads the configuration keys from the secret store.
// For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709
builder.AddUserSecrets();
// todo: use Configuration with config.json instead of hardcoded URLs
AppSettings["WeatherApiDomain"] = "http://localhost:60583";
}
else
{
AppSettings["WeatherApiDomain"] = "http://nws-wapi-staging.azurewebsites.net:80";
}
builder.AddEnvironmentVariables();
Configuration = builder.Build();
}
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.WithMachineName()
.Enrich.FromLogContext()
.WriteTo.Console()
.WriteTo.Seq("http://localhost:5341")
.CreateLogger();
Log.Information("Starting up");
Metrics.Collector = new CollectorConfiguration()
.Batch.AtInterval(TimeSpan.FromSeconds(5))
.Tag.With("host", Environment.GetEnvironmentVariable("COMPUTERNAME"))
.WriteTo.InfluxDB("http://192.168.99.100:8086", "data")
.CreateCollector();
var builder = new ConfigurationBuilder(appEnv.ApplicationBasePath)
.AddJsonFile("config.json")
.AddJsonFile($"config.{env.EnvironmentName}.json", optional: true);
builder.AddEnvironmentVariables();
Configuration = builder.Build();
}
public Startup(IApplicationEnvironment env)
{
var builder = new ConfigurationBuilder(env.ApplicationBasePath)
.AddJsonFile("config.json");
config = builder.Build();
}
IEnumerable<ShellSettings> IShellSettingsManager.LoadSettings()
{
var shellSettings = new List<ShellSettings>();
foreach (var tenant in _appDataFolder.ListDirectories("Sites")) {
_logger.LogInformation("ShellSettings found in '{0}', attempting to load.", tenant.Name);
var configurationContainer =
new ConfigurationBuilder()
.AddJsonFile(_appDataFolder.Combine(tenant.PhysicalPath, string.Format(SettingsFileNameFormat, "json")),
true)
.AddXmlFile(_appDataFolder.Combine(tenant.PhysicalPath, string.Format(SettingsFileNameFormat, "xml")),
true)
.AddYamlFile(_appDataFolder.Combine(tenant.PhysicalPath, string.Format(SettingsFileNameFormat, "txt")),
false);
var config = configurationContainer.Build();
var shellSetting = new ShellSettings(config);
shellSettings.Add(shellSetting);
_logger.LogInformation("Loaded ShellSettings for tenant '{0}'", shellSetting.Name);
}
return shellSettings;
}
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
var builder = new ConfigurationBuilder(appEnv.ApplicationBasePath)
.AddJsonFile("config.json")
.AddEnvironmentVariables();
Configuration = builder.Build();
}
/// <summary>
/// Creates a store manager user who can manage the inventory.
/// </summary>
/// <param name="serviceProvider"></param>
/// <returns></returns>
public static async Task CreateAdminUser(IServiceProvider serviceProvider)
{
var appEnv = serviceProvider.GetService<IApplicationEnvironment>();
var builder = new ConfigurationBuilder()
.SetBasePath(appEnv.ApplicationBasePath)
.AddJsonFile("appsettings.json")
.AddEnvironmentVariables();
var configuration = builder.Build();
var userManager = serviceProvider.GetService<UserManager<ApplicationUser>>();
var roleManager = serviceProvider.GetService<RoleManager<ApplicationRole>>();
if (roleManager.Roles.Count<ApplicationRole>() == 0 || !await roleManager.RoleExistsAsync("Admin"))
{
await roleManager.CreateAsync(new ApplicationRole("Admin"));
}
var user = await userManager.FindByNameAsync(configuration.GetSection("AppSettings").GetSection("defaultAdminUserName").Value);
if (user == null)
{
user = new ApplicationUser { UserName = configuration.GetSection("AppSettings").GetSection("defaultAdminUserName").Value };
await userManager.CreateAsync(user, configuration.GetSection("AppSettings").GetSection("defaultAdminPassword").Value);
//await userManager.AddToRoleAsync(user, adminRole);
await userManager.AddClaimAsync(user, new Claim("ManageStore", "Allowed"));
}
}
public void Configure(IApplicationBuilder app)
{
ServiceProvider = app.ApplicationServices;
var applicationEnvironment = app.ApplicationServices.GetRequiredService<IApplicationEnvironment>();
var configurationFile = Path.Combine(applicationEnvironment.ApplicationBasePath, applicationEnvironment.ApplicationName) + ".json";
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddJsonFile(configurationFile);
Configuration = configurationBuilder.Build();
ConfigureLogging(app);
// Add site logging.
app.Use(async (request, next) => {
var accessLine = "<Unknown>";
try {
var remoteAddress = "";
var connectionFeature = request.GetFeature<IHttpConnectionFeature>();
if (connectionFeature != null) {
remoteAddress = connectionFeature.RemoteIpAddress.ToString();
}
if (string.IsNullOrWhiteSpace(remoteAddress)) {
remoteAddress = request.Request.Headers["HTTP_X_FORWARDED_FOR"];
}
if (string.IsNullOrWhiteSpace(remoteAddress)) {
remoteAddress = request.Request.Headers["REMOTE_ADDR"];
}
accessLine = string.Format(
"{0} {1} {2} {3}{4}{5}",
remoteAddress,
request.Request.Method,
request.Request.Protocol,
request.Request.Path,
request.Request.QueryString.HasValue ? "?" : "",
request.Request.QueryString);
var isHtml = Path.GetExtension(request.Request.Path).Equals(".html");
if (isHtml) {
HtmlAccessLog.LogInformation(accessLine);
}
AccessLog.LogInformation(accessLine);
await next();
} catch (Exception e) {
var message = string.Format("Exception processing request {0}", accessLine);
ApplicationLog.LogError(message, e);
}
});
ConfigureFileServer(app);
}
public void Main(string[] args)
{
// Setup configuration sources.
// The order in which Configuration is built
// is important
var builder = new ConfigurationBuilder(Options.ApplicationBaseDirectory)
.AddJsonFile("config.json")
.AddEnvironmentVariables()
.AddUserSecrets()
.AddCommandLine(args);
Configuration = builder.Build();
// Instantiate a new Twilio Rest Client
var client = new TwilioRestClient(
Configuration.Get("AccountSid"),
Configuration.Get("AuthToken")
);
// Select all calls from my account
var calls = client.ListCalls(new CallListRequest());
// Check for any exceptions
if (calls.RestException != null)
{
throw new FormatException(calls.RestException.Message);
}
// Loop through them and show information
foreach (var call in calls.Calls)
{
var callDetails = $"From: {call.From}, Day: {call.DateCreated}, Duration: {call.Duration}s";
WriteLine(callDetails);
}
ReadLine();
}
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
// Setup configuration sources.
var builder = new ConfigurationBuilder()
.SetBasePath(appEnv.ApplicationBasePath)
.AddJsonFile("appsettings.json")
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);
//appEnv.
//env.EnvironmentName = "Development";
if (env.IsEnvironment("Development"))
{
// This reads the configuration keys from the secret store.
// For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709
builder.AddUserSecrets();
}
// this file name is ignored by gitignore
// so you can create it and use on your local dev machine
// remember last config source added wins if it has the same settings
builder.AddJsonFile("appsettings.local.overrides.json", optional: true);
// most common use of environment variables would be in azure hosting
// since it is added last anything in env vars would trump the same setting in previous config sources
// so no risk of messing up settings if deploying a new version to azure
builder.AddEnvironmentVariables();
Configuration = builder.Build();
//env.MapPath
}
public void Main(string[] args)
{
// Allow the location of the ini file to be specified via a --config command line arg
var tempBuilder = new ConfigurationBuilder().AddCommandLine(args);
var tempConfig = tempBuilder.Build();
var configFilePath = tempConfig[ConfigFileKey] ?? HostingIniFile;
var appBasePath = _serviceProvider.GetRequiredService<IApplicationEnvironment>().ApplicationBasePath;
var builder = new ConfigurationBuilder(appBasePath);
builder.AddIniFile(configFilePath, optional: true);
builder.AddEnvironmentVariables();
builder.AddCommandLine(args);
var config = builder.Build();
var host = new WebHostBuilder(_serviceProvider, config).Build();
using (host.Start())
{
Console.WriteLine("Started");
var appShutdownService = host.ApplicationServices.GetRequiredService<IApplicationShutdown>();
Console.CancelKeyPress += (sender, eventArgs) =>
{
appShutdownService.RequestShutdown();
// Don't terminate the process immediately, wait for the Main thread to exit gracefully.
eventArgs.Cancel = true;
};
appShutdownService.ShutdownRequested.WaitHandle.WaitOne();
}
}
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
var builder = new ConfigurationBuilder(appEnv.ApplicationBasePath)
.AddJsonFile("config.json")
.AddJsonFile($"config.{env.EnvironmentName}.json", optional: true);
Configuration = builder.Build();
}
public int Main(string[] args)
{
var builder = new ConfigurationBuilder();
builder.Add(new JsonConfigurationSource("config.json"));
var config = builder.Build();
var webjobsConnectionString = config["Data:AzureWebJobsStorage:ConnectionString"];
var dbConnectionString = config["Data:DefaultConnection:ConnectionString"];
if (string.IsNullOrWhiteSpace(webjobsConnectionString))
{
Console.WriteLine("The configuration value for Azure Web Jobs Connection String is missing.");
return 10;
}
if (string.IsNullOrWhiteSpace(dbConnectionString))
{
Console.WriteLine("The configuration value for Database Connection String is missing.");
return 10;
}
var jobHostConfig = new JobHostConfiguration(webjobsConnectionString);
var host = new JobHost(jobHostConfig);
host.RunAndBlock();
return 0;
}
public ActivityApiControllerTest()
{
if (_serviceProvider == null)
{
var services = new ServiceCollection();
// Add Configuration to the Container
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddEnvironmentVariables();
IConfiguration configuration = builder.Build();
services.AddSingleton(x => configuration);
// Add EF (Full DB, not In-Memory)
services.AddEntityFramework()
.AddInMemoryDatabase()
.AddDbContext<AllReadyContext>(options => options.UseInMemoryDatabase());
// Setup hosting environment
IHostingEnvironment hostingEnvironment = new HostingEnvironment();
hostingEnvironment.EnvironmentName = "Development";
services.AddSingleton(x => hostingEnvironment);
_serviceProvider = services.BuildServiceProvider();
}
}
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
Env = env;
Env.Initialize(appEnv.ApplicationBasePath, "Development");
Env.Initialize(appEnv.ApplicationBasePath, "Production");
Env.Initialize(appEnv.ApplicationBasePath, "Staging");
#if DEBUG
Env.EnvironmentName = "Development";
#else
if (appEnv.ApplicationBasePath.ToLower().Contains("staging"))
{
Env.EnvironmentName = "Staging";
}
else
{
Env.EnvironmentName = "Production";
}
#endif
// Setup configuration sources.
var builder = new ConfigurationBuilder(appEnv.ApplicationBasePath)
.AddJsonFile("config.json")
.AddEnvironmentVariables();
Configuration = builder.Build();
}
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
// Setup configuration sources.
var builder = new ConfigurationBuilder(appEnv.ApplicationBasePath)
.AddEnvironmentVariables();
Configuration = builder.Build();
}
private static async Task Run(string[] args)
{
try
{
// This wont work...
// See https://github.com/aspnet/Configuration/issues/214
//var config = new ConfigurationBuilder();
//config.AddJsonFile("wiki.json");
var jsonConfig = new JsonConfigurationSource("wiki.json");
var config = new ConfigurationBuilder(jsonConfig);
var builder = new ContainerBuilder();
var module = new ConfigurationModule(config.Build());
builder.RegisterModule(module);
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(LogLevel.Information);
builder.RegisterInstance(loggerFactory).As<ILoggerFactory>().SingleInstance();
builder.RegisterType<GetDescriptionAction>().AsImplementedInterfaces().InstancePerDependency();
builder.RegisterType<AddValueToAlternativeKeysAction>().AsImplementedInterfaces().InstancePerDependency();
builder.Register(ctx => new CompositeDictEntryAction(ctx.Resolve<IEnumerable<IDictEntryAction>>()))
.Keyed<IDictEntryAction>(DictEntryActionKey);
builder.Register(
ctx =>
new Wiki.Wiki(ctx.Resolve<HttpClient>(),
ctx.ResolveOptionalKeyed<IDictEntryAction>(DictEntryActionKey),
ctx.Resolve<ILoggerFactory>()))
.AsImplementedInterfaces()
.InstancePerDependency();
builder.RegisterInstance(new DictConfig
{
FilePath = Path.Combine("..", "..", "resources", "kindle_dict.html"),
OpfFilePath = Path.Combine("..", "..", "resources"),
TemplateFilePath = Path.Combine("..", "..", "resources", "knidle_dict_template.html"),
EntryTemplateFilePath = Path.Combine("..", "..", "resources", "knidle_dict_entry_template.html"),
OpfTemplateFilePath = Path.Combine("..", "..", "resources", "kindle_dict_template.opf"),
}).SingleInstance();
builder.RegisterType<Dict>().AsImplementedInterfaces().SingleInstance();
var logger = loggerFactory.CreateLogger(typeof (Program).FullName);
var container = builder.Build();
var wiki = container.Resolve<IWiki>();
logger.LogInformation("Getting wiki description...");
var wikiDesc = await wiki.GetDescriptionAsync().ConfigureAwait(false);
logger.LogInformation("Getting entries...");
var entries = await wiki.GetEntriesAsync().ConfigureAwait(false);
var dict = container.Resolve<IDict>();
logger.LogInformation("Saving dictionary...");
await dict.SaveAsync(wikiDesc, entries).ConfigureAwait(false);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
}
private void BuildConfiguration(string[] args)
{
var builder = new ConfigurationBuilder()
.AddJsonFile("config.json")
.AddCommandLine(args);
Configuration = builder.Build();
}
public Startup(IApplicationEnvironment appEnv)
{
var configBuilder = new Microsoft.Framework.Configuration.ConfigurationBuilder(appEnv.ApplicationBasePath)
.AddJsonFile("config.json");
Configuration = configBuilder.Build();
var connString = Configuration.Get("Data:DefaultConnection:ConnectionString");
}
public Program(IApplicationEnvironment appEnv)
{
var builder = new ConfigurationBuilder(appEnv.ApplicationBasePath)
.AddJsonFile("config.json")
.AddJsonFile("config.Development.json", optional: true)
.AddEnvironmentVariables();
Configuration = builder.Build();
}
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
var builder = new ConfigurationBuilder()
.SetBasePath(appEnv.ApplicationBasePath)
.AddJsonFile("appsettings.json");
Configuration = builder.Build();
}
public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
{
var Path = appEnv.ApplicationBasePath;
var confgienv=new ConfigurationBuilder(appEnv.ApplicationBasePath).AddJsonFile("config.json")
. AddEnvironmentVariables();
Startup. Configuration = confgienv.Build();
}
private void UseBinder()
{
var builder = new ConfigurationBuilder();
var current = Environment.CurrentDirectory;
builder.AddXmlFile(current + "\\ConfigurationExperiments.exe.config");
var configuration = builder.Build();
//var converter2 = TypeDescriptor.GetConverter(typeof (Type));
//var converter = new TypeNameConverter();
//var d = typeof (double);
TypeDescriptor.AddAttributes(typeof(Type), new TypeConverterAttribute(typeof(TypeNameConverter)));
var converter = TypeDescriptor.GetConverter(typeof(Type));
var a = converter.ConvertFromInvariantString("System.Double");
var model = new Configuration();
configuration.Bind(model);
}
/// <summary>
/// The application entry point (main).
/// </summary>
public void Main()
{
// Get the connection string from config.json file
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddJsonFile("config.json");
var configuration = configurationBuilder.Build();
var connectionString = configuration["Data:DefaultConnection:ConnectionString"];
// Create an instance of a SQL Server DBContext
var options = new DbContextOptionsBuilder();
options.UseSqlServer(connectionString);
var context = new MyDbContext(options.Options);
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
// Create a graph entity
var parent = new Parent
{
Data = "Yanal",
ChildA = new ChildA { Data = "1234" }
};
// Add the graph entity to context
context.Parents.Add(parent, GraphBehavior.IncludeDependents);
// Save change to the storage
// Bug: ChildA is not going to be saved on the database on EF7.
// On EF6 both ChildA gets stored in database when calling context.SaveChanges().
context.SaveChanges();
}
