/// <summary>
        /// Creates and configures the application configuration, where key value pair settings are stored. See
        /// http://docs.asp.net/en/latest/fundamentals/configuration.html
        /// http://weblog.west-wind.com/posts/2015/Jun/03/Strongly-typed-AppSettings-Configuration-in-ASPNET-5
        /// </summary>
        /// <param name="hostingEnvironment">The environment the application is running under. This can be Development, 
        /// Staging or Production by default.</param>
        /// <returns>A collection of key value pair settings.</returns>
        private static IConfiguration ConfigureConfiguration(IHostingEnvironment hostingEnvironment)
        {
            IConfigurationBuilder configurationBuilder = new ConfigurationBuilder();

            // Add configuration from the config.json file.
            configurationBuilder.AddJsonFile("config.json");

            // Add configuration from an optional config.development.json, config.staging.json or 
            // config.production.json file, depending on the environment. These settings override the ones in the 
            // config.json file.
            configurationBuilder.AddJsonFile($"config.{hostingEnvironment.EnvironmentName}.json", optional: true);

            // This reads the configuration keys from the secret store. This allows you to store connection strings
            // and other sensitive settings, so you don't have to check them into your source control provider. See 
            // http://go.microsoft.com/fwlink/?LinkID=532709 and
            // http://docs.asp.net/en/latest/security/app-secrets.html
            configurationBuilder.AddUserSecrets();

            // Add configuration specific to the Development, Staging or Production environments. This config can 
            // be stored on the machine being deployed to or if you are using Azure, in the cloud. These settings 
            // override the ones in all of the above config files.
            // Note: To set environment variables for debugging navigate to:
            // Project Properties -> Debug Tab -> Environment Variables
            // Note: To get environment variables for the machine use the following command in PowerShell:
            // $env:[VARIABLE_NAME]
            // Note: To set environment variables for the machine use the following command in PowerShell:
            // $env:[VARIABLE_NAME]="[VARIABLE_VALUE]"
            // Note: Environment variables use a colon separator e.g. You can override the site title by creating a 
            // variable named AppSettings:SiteTitle. See 
            // http://docs.asp.net/en/latest/security/app-secrets.html
            configurationBuilder.AddEnvironmentVariables();

            return configurationBuilder.Build();
        }
        public void ConfigureConfigServerClientSettingsOptions_WithDefaults()
        {
            // Arrange
            var services = new ServiceCollection().AddOptions();
            var environment = new HostingEnvironment();

            // Act and Assert
            var builder = new ConfigurationBuilder().AddConfigServer(environment);
            var config = builder.Build();

            services.Configure<ConfigServerClientSettingsOptions>(config);
            var service = services.BuildServiceProvider().GetService<IOptions<ConfigServerClientSettingsOptions>>();
            Assert.NotNull(service);
            var options = service.Value;
            Assert.NotNull(options);
            ConfigServerTestHelpers.VerifyDefaults(options.Settings);

            Assert.Equal(ConfigServerClientSettings.DEFAULT_PROVIDER_ENABLED, options.Enabled);
            Assert.Equal(ConfigServerClientSettings.DEFAULT_FAILFAST, options.FailFast);
            Assert.Equal(ConfigServerClientSettings.DEFAULT_URI, options.Uri);
            Assert.Equal(ConfigServerClientSettings.DEFAULT_ENVIRONMENT, options.Environment);
            Assert.Equal(ConfigServerClientSettings.DEFAULT_CERTIFICATE_VALIDATION, options.ValidateCertificates);
            Assert.Null(options.Name);
            Assert.Null(options.Label);
            Assert.Null(options.Username);
            Assert.Null(options.Password);
        }
Exemplo n.º 3
1
        //<inheritdoc/>
        public IEnumerable<Tenant> GetEnabledTenants()
        { 
            var fileProvider = _hostingEnvironment.ContentRootFileProvider;

            var tenantFolders = fileProvider
                .GetDirectoryContents("tenants")
                .Where(info => info.IsDirectory);

            foreach (var tenantFolder in tenantFolders)
            {
                var tenantFileName = "tenant.json";
                var tenantDirectoryPath = Path.Combine("tenants", tenantFolder.Name);
                var tenantFilePath = Path.Combine(tenantDirectoryPath, tenantFileName);
                var tenantFileInfo = fileProvider.GetFileInfo(tenantFilePath);
                if (tenantFileInfo.Exists)
                {
                    var builder = new ConfigurationBuilder();
                    builder.SetFileProvider(fileProvider);
                    builder.AddJsonFile(tenantFilePath);
                    var config = builder.Build();

                    var tenant = new Tenant
                    {
                        TenantId = tenantFolder.Name,
                        Configuration = config,
                        Identities = config.GetSection("Identities").GetChildren().Select(t => t.Value),
                        Extensions = config.GetSection("Extensions").GetChildren().Select(t => t.Value),
                        Path = tenantFolder.PhysicalPath
                    };

                    yield return tenant;
                }
            }
        }
Exemplo n.º 4
0
        public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
        {
            // Setup configuration sources.
            var builder = new ConfigurationBuilder()
                .AddJsonFile("appsettings.json")
                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);

            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
            appBasePath = appEnv.ApplicationBasePath;
        }
Exemplo n.º 5
0
        protected override void OnStart(string[] args)
        {
            try
            {
                var configProvider = new MemoryConfigurationProvider();
                configProvider.Add("server.urls", "http://localhost:5000");

                var config = new ConfigurationBuilder()
                    .Add(configProvider)
                    .Build();

                var builder = new WebHostBuilder(config);
                builder.UseServer("Microsoft.AspNet.Server.Kestrel");
                builder.UseServices(services => services.AddMvc());
                builder.UseStartup(appBuilder =>
                {
                    appBuilder.UseDefaultFiles();
                    appBuilder.UseStaticFiles();
                    appBuilder.UseMvc();
                });

                var hostingEngine = builder.Build();
                _application = hostingEngine.Start();
            }
            catch (Exception ex)
            {
                Debug.WriteLine("error in OnStart: " + ex);
                throw;
            }
        }
Exemplo n.º 6
0
        public int Main(string[] args)
        {
            var builder = new ConfigurationBuilder();
            //builder.Add(new JsonConfigurationSource("config.json"));
            builder.AddJsonFile("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;
        }
Exemplo n.º 7
0
        private static DungeonParameters GatherParameters()
        {
            var builder = new ConfigurationBuilder()
                    .AddJsonFile("AppSettings.json")
                    .AddEnvironmentVariables();

            var configuration = builder.Build();

            return new DungeonParameters
            {
                Width = configuration.GetValue<int>("Map:Width"),
                Height = configuration.GetValue<int>("Map:Height"),
                CellSparseFactor = configuration.GetValue<int>("Map:CellSparseFactor"),
                DeadEndSparseFactor = configuration.GetValue<int>("Map:DeadEndSparseFactor"),
                TwistFactor = configuration.GetValue<int>("Map:TwistFactor"),
                RoomParameters = new RoomParameters
                {
                    Count = configuration.GetValue<int>("Map:Room:Count"),
                    MinWidth = configuration.GetValue<int>("Map:Room:MinWidth"),
                    MaxWidth = configuration.GetValue<int>("Map:Room:MaxWidth"),
                    MinHeight = configuration.GetValue<int>("Map:Room:MinHeight"),
                    MaxHeight = configuration.GetValue<int>("Map:Room:MaxHeight")
                }
            };
        }
 public Startup()
 {
     var builder = new ConfigurationBuilder()
                 .AddJsonFile("Config.json")
                 .AddEnvironmentVariables();
     Configuration = builder.Build();
 }
Exemplo n.º 9
0
        public void Run()
        {
            try
              {
            Console.WriteLine("Reading Configuration");
            var builder = new ConfigurationBuilder()
             .SetBasePath(PlatformServices.Default.Application.ApplicationBasePath)
             .AddJsonFile("config.json")
             .AddEnvironmentVariables();

            _config = builder.Build();
            _ctx = new OldWilderContext(_config);
            _newCtx = new WilderContext(_config);
            _repo = new WilderRepository(_config, _newCtx);

            Console.WriteLine("Migrating Stories");
            MigrateStories();

            //TODO More migration

              }
              catch (Exception ex)
              {
            Console.WriteLine(ex.ToString());
            Console.ReadKey();
              }
        }
Exemplo n.º 10
0
        IEnumerable<ShellSettings> IShellSettingsManager.LoadSettings()
        {
            var shellSettings = new List<ShellSettings>();

            foreach (var tenant in _appDataFolder.ListDirectories(_optionsAccessor.Value.Location))
            {
                if (_logger.IsEnabled(LogLevel.Information))
                {
                    _logger.LogInformation("ShellSettings found in '{0}', attempting to load.", tenant.Name);
                }
                var configurationContainer =
                    new ConfigurationBuilder()
                        .SetBasePath(_appDataFolder.RootPath)
                        .AddJsonFile(_appDataFolder.Combine(tenant.FullName, string.Format(SettingsFileNameFormat, "json")),
                            true)
                        .AddXmlFile(_appDataFolder.Combine(tenant.FullName, string.Format(SettingsFileNameFormat, "xml")),
                            true)
                        .AddYamlFile(_appDataFolder.Combine(tenant.FullName, string.Format(SettingsFileNameFormat, "txt")),
                            false);

                var config = configurationContainer.Build();
                var shellSetting = ShellSettingsSerializer.ParseSettings(config);
                shellSettings.Add(shellSetting);

                if (_logger.IsEnabled(LogLevel.Information))
                {
                    _logger.LogInformation("Loaded ShellSettings for tenant '{0}'", shellSetting.Name);
                }
            }

            return shellSettings;
        }
Exemplo n.º 11
0
    public void Configure(IApplicationBuilder app)
    {
        var builder = new ConfigurationBuilder();
        builder.Add(new MemoryConfigurationProvider {
                {"MySettings:RetryCount", "42"},
                {"MySettings:DefaultAdBlock", "House"},
                {"MySettings:AdBlock:House:ProductCode", "123"},
                {"MySettings:AdBlock:House:Origin", "blob-456"},
                {"MySettings:AdBlock:Contoso:ProductCode", "contoso2014"},
                {"MySettings:AdBlock:Contoso:Origin", "sql-789"},
            });
        var config = builder.Build();

        var mySettings = new MySettings();
        mySettings.Read(config.GetSection("MySettings"));

        app.Run(async ctx =>
        {
            ctx.Response.ContentType = "text/plain";

            await ctx.Response.WriteAsync(string.Format("Retry Count {0}\r\n", mySettings.RetryCount));
            await ctx.Response.WriteAsync(string.Format("Default Ad Block {0}\r\n", mySettings.DefaultAdBlock));
            foreach (var adBlock in mySettings.AdBlocks.Values)
            {
                await ctx.Response.WriteAsync(string.Format(
                    "Ad Block {0} Origin {1} Product Code {2}\r\n", 
                    adBlock.Name, adBlock.Origin, adBlock.ProductCode));                
            }
        });
    }
Exemplo n.º 12
0
        public static void Main(string[] args) {
            var configBuilder = new ConfigurationBuilder().AddCommandLine(args);
            Configuration = configBuilder.Build();

            string configFile = Configuration["config"];
            if (configFile != null) {
                configBuilder.AddJsonFile(configFile, optional: false);
                Configuration = configBuilder.Build();
            }

            ConfigurationBinder.Bind(Configuration.GetSection("startup"), _startupOptions);
            ConfigurationBinder.Bind(Configuration.GetSection("security"), _securityOptions);

            _loggerFactory
                .AddDebug()
                .AddConsole(LogLevel.Trace)
                .AddProvider(new FileLoggerProvider(_startupOptions.Name));
            _logger = _loggerFactory.CreateLogger<Program>();

            if (_startupOptions.Name != null) {
                _logger.LogInformation(Resources.Info_BrokerName, _startupOptions.Name);
            }

            var tlsConfig = new TlsConfiguration(_logger, _securityOptions);
            var httpsOptions = tlsConfig.GetHttpsOptions(Configuration);

            Uri uri = GetServerUri(Configuration);
            try {
                CreateWebHost(httpsOptions).Run();
            } catch(AggregateException ex) when (ex.IsPortInUseException()) {
                _logger.LogError(0, ex.InnerException, Resources.Error_ConfiguredPortNotAvailable, uri?.Port);
            }
        }
Exemplo n.º 13
0
 // ReSharper disable once UnusedParameter.Local
 public Startup(IHostingEnvironment env)
 {
     var builder = new ConfigurationBuilder()
         .AddJsonFile("config.json")
         .AddEnvironmentVariables("Dorothy:");
     Configuration = builder.Build();
 }
Exemplo n.º 14
0
        public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
        {
            //Setting up configuration builder
            var builder = new ConfigurationBuilder()
                .SetBasePath(appEnv.ApplicationBasePath)
                .AddEnvironmentVariables();

            if (!env.IsProduction())
            {
                builder.AddUserSecrets();
            }
            else
            {

            }

            Configuration = builder.Build();

            //Setting up configuration
            if (!env.IsProduction())
            {
                var confConnectString = Configuration.GetSection("Data:DefaultConnection:ConnectionString");
                confConnectString.Value = @"Server=(localdb)\mssqllocaldb;Database=GetHabitsAspNet5;Trusted_Connection=True;";

                var identityConnection = Configuration.GetSection("Data:IdentityConnection:ConnectionString");
                identityConnection.Value = @"Server=(localdb)\mssqllocaldb;Database=GetHabitsIdentity;Trusted_Connection=True;";
            }
            else
            {

            }
        }
        protected override void OnStart(string[] args)
        {
            try
            {
                var temp = new ConfigurationBuilder()
                    .AddJsonFile("config.json")
                    .AddJsonFile("hosting.json", true)
                    .Build();

                var configProvider = new MemoryConfigurationProvider();
                configProvider.Add("server.urls", temp["WebServerAddress"]);
                configProvider.Add("webroot", temp.Get<string>("webroot", "wwwroot"));

                var config = new ConfigurationBuilder()
                    .Add(configProvider)
                    .Build();

                var builder = new WebHostBuilder(config);
                builder.UseServer("Microsoft.AspNet.Server.Kestrel");
                builder.UseStartup<Startup>();
                
                var hostingEngine = builder.Build();
                _application = hostingEngine.Start();
            }
            catch (Exception ex)
            {
                Debug.WriteLine("error in OnStart: " + ex);
                throw;
            }
        }
Exemplo n.º 16
0
		public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
		{
            // Setup configuration sources.
            var builder = new ConfigurationBuilder().AddEnvironmentVariables();

            Configuration = builder.Build();
		}
Exemplo n.º 17
0
        public Startup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                .AddJsonFile("appsettings.json");

            Configuration = builder.Build();
        }
Exemplo n.º 18
0
        public Startup(
            IHostingEnvironment env,
            IApplicationEnvironment appEnv)
        {
            _env = env;

            // Setup configuration sources.
            var builder = new ConfigurationBuilder()
                .SetBasePath(appEnv.ApplicationBasePath)
                // standard config file
                .AddJsonFile("config.json")
                // environment specific config.<environment>.json file
                .AddJsonFile($"config.{env.EnvironmentName}.json", true /* override if exists */)
                // standard Windows environment variables
                .AddEnvironmentVariables();

            if (env.IsDevelopment())
            {
                // this one adds not using directive to keep it secret, only a dnx reference
                // the focus is not on Secrets but on User, so these are User specific settings
                // we can also make it available only for developers
                builder.AddUserSecrets();
            }

            Configuration = builder.Build();
        }
Exemplo n.º 19
0
 public Startup(IHostingEnvironment env)
 {
     // Set up configuration sources.
     Configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json")
                                               .AddEnvironmentVariables()
                                               .Build();
 }
Exemplo n.º 20
0
        public static void Main(string[] args)
        {
            if (Debugger.IsAttached)
            {
                Environment.SetEnvironmentVariable(
                    "ASPNETCORE_ENVIRONMENT", 
                    EnvironmentName.Development);
            }	    
	    
            var config = new ConfigurationBuilder()
                	  .AddJsonFile("hosting.json", optional: true)
        		  .AddEnvironmentVariables("ASPNETCORE_")
                	  .AddCommandLine(args)
                	  .Build();

            var host = new WebHostBuilder()
                        .UseKestrel()
                        .UseContentRoot(Directory.GetCurrentDirectory())
                        .UseConfiguration(config)
                        .UseIISIntegration()
                        .UseStartup<Startup>()
                        .Build();

            host.Run();
        }
 public Startup(IHostingEnvironment env)
 {
     // Setup configuration sources.
     Configuration = new ConfigurationBuilder()
         .AddJsonFile("config.json")
         .Build();
 }
Exemplo n.º 22
0
		public Startup(IHostingEnvironment hostingEnvironment, IApplicationEnvironment applicationEnvironment)
		{
			Configuration = new ConfigurationBuilder()
				.SetBasePath(applicationEnvironment.ApplicationBasePath)
				.AddJsonFile("config.json")
				.Build();
		}
Exemplo n.º 23
0
 public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
 {
     Configuration = new ConfigurationBuilder()
         .AddJsonFile(ConfigFilename)
         .AddEnvironmentVariables()
         .Build();
 }
Exemplo n.º 24
0
        public Startup(IHostingEnvironment env, IApplicationEnvironment appEnvironment)
        {
            _appEnvironment = appEnvironment;
            _hostingEnvironment = env;

            var RollingPath = Path.Combine(appEnvironment.ApplicationBasePath, "logs/myapp-{Date}.txt");
            Log.Logger = new LoggerConfiguration()
                .WriteTo.RollingFile(RollingPath)
                .CreateLogger();
            Log.Information("Ah, there you are!");

            // Set up configuration sources.
            var builder = new ConfigurationBuilder()
                .AddJsonFile("appsettings.json")
                .AddJsonFile("appsettings-filters.json")
                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);

            if (env.IsDevelopment())
            {
                // For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709
                builder.AddUserSecrets();
            }

            builder.AddEnvironmentVariables();
            Configuration = builder.Build();

            // Initialize the global configuration static
            GlobalConfigurationRoot.Configuration = Configuration;
        }
Exemplo n.º 25
0
        public static void Main(string[] args)
        {
            var config = new ConfigurationBuilder()
                .AddCommandLine(args)
                .AddEnvironmentVariables(prefix: "ASPNETCORE_")
                .AddJsonFile("hosting.json", optional: true)
                .Build();

            var host = new WebHostBuilder()
                .UseConfiguration(config) // Default set of configurations to use, may be subsequently overridden 
              //.UseKestrel()
                .UseContentRoot(Directory.GetCurrentDirectory()) // Override the content root with the current directory
                .UseUrls("http://*:1000", "https://*:902")
                .UseEnvironment("Development")
                .UseWebRoot("public")
                .ConfigureServices(services =>
                {
                    // Configure services that the application can see
                    services.AddSingleton<IMyCustomService, MyCustomService>();
                })
                .Configure(app =>
                {
                    // Write the application inline, this won't call any startup class in the assembly

                    app.Use(next => context =>
                    {
                        return next(context);
                    });
                })
                .Build();

            host.Run();
        }
Exemplo n.º 26
0
        public Startup(IHostingEnvironment env)
        {
            // Set up configuration sources.
            var builder = new ConfigurationBuilder()
                .AddJsonFile("appsettings.json");


#if DEBUG
            URLS.Api_url = "http://localhost:58517/";
            URLS.Html_url = "http://localhost:7079/oauth.html";
            URLS.Idt_url = "http://localhost:58058/";
            URLS.Mvc_url = "http://localhost:7079/signin-oidc";
#endif

#if RELEASE
            

            URLS.Api_url = "http://it4govwebapi.azurewebsites.net/";
            URLS.Html_url = "http://it4govwebapp.azurewebsites.net/oauth.html";
            URLS.Idt_url = "http://it4govidentityserver.azurewebsites.net";
            URLS.Mvc_url = "http://it4govwebapp.azurewebsites.net/signin-oidc";
#endif

            
                // This will push telemetry data through Application Insights pipeline faster, allowing you to view results immediately.
                builder.AddApplicationInsightsSettings(developerMode: true);
            

            builder.AddEnvironmentVariables();
            Configuration = builder.Build().ReloadOnChanged("appsettings.json");
        }
        public ProviderServices(IApplicationEnvironment env)
        {
            var configuration = new ConfigurationBuilder()
                .BuildConfiguration(env);

            _serviceProvider = new ServiceCollection()
            .AddLogging()

            .AddOptions()
            .Configure<MailConfiguration>(configuration)
            .Configure<TestOptions>(configuration)

            .AddSingleton<TestConfiguration>()
            .AddInstance(configuration)
            .AddProceesProviderServices()

            .AddTransient<IModifiedCodeTestsFinder, ModifiedCodeTestsFinder>()
            .AddTransient<IDnxTestRunner, DnxTestRunner>()
            .AddTransient<ITestRunner, TestRunner>()
            .AddTransient<IMailServiceFactory, MailServiceFactory>()

            .AddInstance(env)

            .BuildServiceProvider();

            _serviceProvider.GetService<ILoggerFactory>().AddConsole(LogLevel.Information);
        }
Exemplo n.º 28
0
        public static void Main(string[] args)
        {
            var configBuilder = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("hosting.json");

            var configuration = configBuilder.Build();

            var hostBuilder = new WebHostBuilder();

            // set urls and environment
            hostBuilder
                .UseUrls(configuration["urls"])
                .UseEnvironment(configuration["environment"]);

            // set other common things
            hostBuilder
                .UseKestrel()
                .UseContentRoot(Directory.GetCurrentDirectory())
                .UseIISIntegration()
                .UseStartup<Startup>();

            var host = hostBuilder.Build();

            host.Run();
        }
Exemplo n.º 29
0
        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 async Task RegisterAddresses_Success(string addressInput, string[] testUrls)
        {
            var config = new ConfigurationBuilder()
                .AddInMemoryCollection(new Dictionary<string, string>
                {
                    { "server.urls", addressInput }
                })
                .Build();

            var applicationBuilder = new WebApplicationBuilder()
                .UseConfiguration(config)
                .UseServerFactory("Microsoft.AspNet.Server.Kestrel")
                .Configure(ConfigureEchoAddress);

            using (var app = applicationBuilder.Build().Start())
            {
                using (var client = new HttpClient())
                {
                    foreach (var testUrl in testUrls)
                    {
                        var responseText = await client.GetStringAsync(testUrl);
                        Assert.Equal(testUrl, responseText);
                    }
                }
            }
        }
        public void Given_The_system_has_version_P0(String P0)
        {
            var config = new Dictionary <string, string>()
            {
                ["version"] = P0
            };
            var configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder();

            configurationBuilder.AddInMemoryCollection(config);
            _config = configurationBuilder.Build();
        }
        public LiteSmallEventPublisher(IHostingEnvironment env /*, AMQPEventSubscriber aMQPEventSubscriber*/)
        {
            connectionFactory = new ConnectionFactory();

            var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                          .SetBasePath(env.ContentRootPath)
                          .AddJsonFile("appsettings.json", optional: false, reloadOnChange: false)
                          .AddEnvironmentVariables();

            builder.Build().GetSection("RabbitMqSetting").Bind(connectionFactory);
        }
Exemplo n.º 33
0
        public IntegrationTestsStartup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                          .SetBasePath(env.ContentRootPath)
                          .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                          .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                          .AddJsonFile("configuration.json")
                          .AddEnvironmentVariables();

            Configuration = builder.Build();
        }
Exemplo n.º 34
0
        private static void Configure(string profile, bool ignoreCertificateErrors, bool noProtection)
        {
            // read configuration values
            var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                          .SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
                          .AddJsonFile("appsettings.json", false)
                          .AddJsonFile($"{profile}.json", false);
            var configurationRoot = builder.Build();

            // configure logging
            _loggerFactory = new LoggerFactory();
            _loggerFactory.AddConsole(configurationRoot.GetSection("Logging"));
            _logger = _loggerFactory.CreateLogger("TestClient");

            // configure caching
            var distributedCache = DistributedCacheFactory.Create();

            // set up address registry
            var addressRegistrySettings = new AddressRegistrySettings();

            configurationRoot.GetSection("AddressRegistrySettings").Bind(addressRegistrySettings);
            addressRegistrySettings.WcfConfiguration = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            var addressRegistry = new AddressRegistry(addressRegistrySettings, distributedCache);

            // set up collaboration registry
            var collaborationProtocolRegistrySettings = new CollaborationProtocolRegistrySettings();

            configurationRoot.GetSection("CollaborationProtocolRegistrySettings").Bind(collaborationProtocolRegistrySettings);
            collaborationProtocolRegistrySettings.WcfConfiguration =
                ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);

            var collaborationProtocolRegistry = new CollaborationProtocolRegistry(collaborationProtocolRegistrySettings,
                                                                                  distributedCache, addressRegistry);

            _clientSettings = new ClientSettings();
            configurationRoot.GetSection("ClientSettings").Bind(_clientSettings);

            // set up messaging
            var messagingSettings = new MessagingSettings();

            configurationRoot.GetSection("MessagingSettings").Bind(messagingSettings);

            messagingSettings.IgnoreCertificateErrorOnSend = ignoreCertificateErrors;
            messagingSettings.LogPayload = true;

            if (noProtection)
            {
                _messagingClient = new MessagingClient(messagingSettings, collaborationProtocolRegistry, addressRegistry, null, null, new NoMessageProtection());
            }
            else
            {
                _messagingClient = new MessagingClient(messagingSettings, collaborationProtocolRegistry, addressRegistry);
            }
        }
Exemplo n.º 35
0
        public Startup(IHostingEnvironment env)
        {
            var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder();

            builder.SetBasePath(env.ContentRootPath)
            .AddJsonFile("configuration.json", optional: false, reloadOnChange: true)
            .AddEnvironmentVariables();


            Configuration = builder.Build();
        }
Exemplo n.º 36
0
        public Startup(IHostingEnvironment env)
        {
            var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                          .SetBasePath(env.ContentRootPath)
                          .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                          .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                          .AddEnvironmentVariables();

            this.Configuration = builder.Build();
            Configuration      = builder.Build();
        }
Exemplo n.º 37
0
        public static void Main(string[] args)
        {
            Microsoft.Extensions.Configuration.ConfigurationBuilder bconfig = (Microsoft.Extensions.Configuration.ConfigurationBuilder)(new Microsoft.Extensions.Configuration.ConfigurationBuilder());
            //if (args != null)bconfig.AddCommandLine(args).Build();
            bconfig.SetBasePath(BasePath);
            bconfig.AddJsonFile(AppName + ".json", optional: true, reloadOnChange: true);
            _Config = bconfig.Build();

            Start(args);
            Config_OnChanged = Config.GetReloadToken().RegisterChangeCallback(Call_Config_OnChanged, new object[] { Config });
        }
Exemplo n.º 38
0
        private static void LoadConfiguration(string[] args)
        {
            System.Console.WriteLine("Loading Configuration...");

            var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                          .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                          .AddCommandLine(args)
                          .AddEnvironmentVariables();

            Configuration = builder.Build();
            System.Console.WriteLine("Finished Loading Configuration.");
        }
Exemplo n.º 39
0
        /// <summary>
        /// Start code for ASP.NET Core >= 2.0, see https://docs.microsoft.com/en-us/aspnet/core/migration/1x-to-2x/
        /// </summary>
        /// <param name="args"></param>
        public static void Main(string[] args)
        {
            //BL.DataGenerator.Run();

            CUI.MainHeadline("MiracleList Backend v" + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString());
            Console.WriteLine();

            CUI.Headline("Main");
            CUI.Print("OS: " + System.Environment.OSVersion);
            CUI.Print("Runtime: " + ITVisions.CLRInfo.GetClrVersion());
            CUI.Print("Webframework: ASP.NET Core v" + typeof(WebHost).Assembly.GetName().Version.ToString());

            var configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                                .AddCommandLine(args)
                                .Build();

            var hostUrl = configuration["hosturl"];

            if (string.IsNullOrEmpty(hostUrl))
            {
                hostUrl = "http://localhost:6000";
            }

            CUI.Print("HostURL: " + hostUrl);

            var builder = WebHost.CreateDefaultBuilder(args)
                          .UseUrls(hostUrl)
                          .UseSetting("detailedErrors", "true")
                          .UseStartup <Startup>()
                          .CaptureStartupErrors(true)
                          .ConfigureLogging((hostingContext, logging) =>
            {
                logging.AddConsole();
            })
                          .Build();


            CUI.H2("Server Features:");
            foreach (var sf in builder.ServerFeatures)
            {
                Console.WriteLine(sf.Key + "=" + sf.Value);
                if (sf.Value is IServerAddressesFeature)
                {
                    var saf = sf.Value as IServerAddressesFeature;
                    foreach (var a in saf.Addresses)
                    {
                        Console.WriteLine(a);
                    }
                }
            }

            builder.Run();
        }
Exemplo n.º 40
0
        public Startup(Microsoft.AspNetCore.Hosting.IWebHostEnvironment env)
        {
            var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder();

            builder.SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json")
            //add configuration.json
            .AddJsonFile("configuration.json", optional: false, reloadOnChange: true)
            .AddEnvironmentVariables();

            Configuration = builder.Build();
        }
Exemplo n.º 41
0
        private void _getConnectionString()
        {
            // Create Builder
            var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                          //.SetBasePath(env.ContentRootPath)
                          .AddJsonFile("appsettings.json")
                          .AddEnvironmentVariables();
            var config = builder.Build();

            // Get Connection string from the build
            var connectionString = config.GetConnectionString("(default)");
        }
Exemplo n.º 42
0
        public void Start()
        {
            var config = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                         .AddCommandLine(new[] { "--server.urls", $"http://{_serverInterface}:{_serverPort}" });

            var builder = new WebHostBuilder()
                          .UseKestrel()
                          .ConfigureServices(serviceCollection =>
            {
                serviceCollection.AddSingleton(_environment);
                serviceCollection.AddSingleton(_sharedTextWriter);
                serviceCollection.AddSingleton(NullEventEmitter.Instance);
                serviceCollection.AddSingleton(_pluginAssemblies);
                serviceCollection.AddSingleton(new HttpEnvironment {
                    Port = _serverPort
                });
            })
                          .UseUrls($"http://{_serverInterface}:{_serverPort}")
                          .UseConfiguration(config.Build())
                          .UseEnvironment("OmniSharp")
                          .UseStartup(typeof(Startup));

            using (var app = builder.Build())
            {
                app.Start();

                var appLifeTime = app.Services.GetRequiredService <IApplicationLifetime>();

                Console.CancelKeyPress += (sender, e) =>
                {
                    appLifeTime.StopApplication();
                    e.Cancel = true;
                };

                if (_environment.HostProcessId != -1)
                {
                    try
                    {
                        var hostProcess = Process.GetProcessById(_environment.HostProcessId);
                        hostProcess.EnableRaisingEvents = true;
                        hostProcess.OnExit(() => appLifeTime.StopApplication());
                    }
                    catch
                    {
                        // If the process dies before we get here then request shutdown
                        // immediately
                        appLifeTime.StopApplication();
                    }
                }

                appLifeTime.ApplicationStopping.WaitHandle.WaitOne();
            }
        }
Exemplo n.º 43
0
        public virtual void LoadConfiguration()
        {
            if (String.IsNullOrEmpty(FullLoadedFileName))
            {
                throw new Exception("The file hasn't been defined, yet, so we can't load an empty definition");
            }

            IConfigurationBuilder configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder().SetBasePath(@Directory.GetCurrentDirectory());

            LoadedConfiguration = configurationBuilder
                                  .AddJsonFile(FullLoadedFileName, optional: true, reloadOnChange: true).Build();
        }
Exemplo n.º 44
0
        public Startup(IHostingEnvironment env)
        {
            var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                          .SetBasePath(env.ContentRootPath)
                          .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                          .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
                          // adding cache.json which contains cachemanager configuration(s)
                          .AddJsonFile("cache.json", optional: false)
                          .AddEnvironmentVariables();

            Configuration = builder.Build();
        }
Exemplo n.º 45
0
        public Startup(IHostingEnvironment env)
        {
            var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder();

            builder.SetBasePath(env.ContentRootPath)
            .AddJsonFile($"appsettings.{env.EnvironmentName}.json")
            //add configuration.json
            .AddJsonFile($"configuration.{env.EnvironmentName}.json")
            .AddEnvironmentVariables();

            Configuration = builder.Build();
        }
Exemplo n.º 46
0
        static BaseTest()
        {
            ConfigurationBuilder builder = new ConfigurationBuilder();

            builder.AddInMemoryCollection(DefaultConfigurationStrings);
            Configuration = builder.Build();

            //LogManager.Adapter = new ConsoleOutLoggerFA(new NameValueCollection());

            ScriptDirectory = Path.Combine(Path.Combine(Path.Combine(Path.Combine(Path.Combine(TestContext.CurrentContext.TestDirectory, ".."), ".."), ".."), "Scripts"),
                                           Configuration["database"]) + Path.DirectorySeparatorChar;
        }
Exemplo n.º 47
0
        /// <summary>
        /// Build the configuration and populate the service collection based on the input environment.
        /// </summary>
        private (IConfigurationRoot Configuration, ServicesBuilder ServicesBuilder) Init()
        {
            var configurationOptions = this.GetOrAdd(() => new ConfigurationOptions());
            var configurationBuilder = new ConfigurationBuilder()
                                       .SetFileProvider(_environment.ContentRootFileProvider)
                                       .Apply(configurationOptions.ApplicationConfiguration)
                                       .Apply(configurationOptions.EnvironmentConfiguration, _environment.EnvironmentName)
                                       .Apply(configurationOptions.EnvironmentConfiguration, "local");

#pragma warning disable CA2000
            var cb = new Extensions.Configuration.ConfigurationBuilder(
                Scanner,
                _environment,
                new ConfigurationRoot(new List <IConfigurationProvider>()),
                configurationBuilder,
                _logger,
                ServiceProperties
                );
#pragma warning restore CA2000

            var configuration = configurationBuilder
                                .AddConfiguration(cb.Build())
                                .Build();

            var serviceCollection = new ServiceCollection();
            var servicesBuilder   = new ServicesBuilder(
                Scanner,
                AssemblyProvider,
                AssemblyCandidateFinder,
                serviceCollection,
                configuration,
                _environment,
                _logger,
                ServiceProperties
                );

            servicesBuilder.Services.AddLogging(
                builder =>
            {
                builder.ClearProviders();
                builder.Services.AddSingleton(_loggerFactory);
            }
                );

            Composer.Register(
                servicesBuilder.Scanner,
                servicesBuilder,
                typeof(IServiceConvention),
                typeof(ServiceConventionDelegate)
                );

            return(configuration, servicesBuilder);
        }
Exemplo n.º 48
0
        public static OmniSharpTestHost Create(string path = null, ITestOutputHelper testOutput = null, IEnumerable <KeyValuePair <string, string> > configurationData = null, DotNetCliVersion dotNetCliVersion = DotNetCliVersion.Current)
        {
            var environment      = new OmniSharpEnvironment(path, logLevel: LogLevel.Trace);
            var loggerFactory    = new LoggerFactory().AddXunit(testOutput);
            var logger           = loggerFactory.CreateLogger <OmniSharpTestHost>();
            var sharedTextWriter = new TestSharedTextWriter(testOutput);

            var dotNetCliService = CreateTestDotNetCliService(dotNetCliVersion, loggerFactory);

            var info = dotNetCliService.GetInfo();

            logger.LogInformation($"Using .NET CLI: {info.Version}");

            var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder();

            builder.AddInMemoryCollection(configurationData);

            // We need to set the "UseLegacySdkResolver" for tests because
            // MSBuild's SDK resolver will not be able to locate the .NET Core SDKs
            // that we install locally in the ".dotnet" and ".dotnet-legacy" directories.
            // This property will cause the MSBuild project loader to set the
            // MSBuildSDKsPath environment variable to the correct path "Sdks" folder
            // within the appropriate .NET Core SDK.
            var msbuildProperties = new Dictionary <string, string>()
            {
                [$"MSBuild:{nameof(MSBuildOptions.UseLegacySdkResolver)}"] = "true",
                [$"MSBuild:{nameof(MSBuildOptions.MSBuildSDKsPath)}"]      = Path.Combine(info.BasePath, "Sdks")
            };

            builder.AddInMemoryCollection(msbuildProperties);

            var configuration = builder.Build();

            var serviceProvider = new TestServiceProvider(environment, loggerFactory, sharedTextWriter, configuration, NullEventEmitter.Instance, dotNetCliService);

            var compositionHost = new CompositionHostBuilder(serviceProvider)
                                  .WithAssemblies(s_lazyAssemblies.Value)
                                  .Build();

            var workspace = compositionHost.GetExport <OmniSharpWorkspace>();

            WorkspaceInitializer.Initialize(serviceProvider, compositionHost, configuration, logger);

            var host = new OmniSharpTestHost(serviceProvider, loggerFactory, workspace, compositionHost);

            // Force workspace to be updated
            var service = host.GetWorkspaceInformationService();

            service.Handle(new WorkspaceInformationRequest()).Wait();

            return(host);
        }
Exemplo n.º 49
0
        /// <inheritdoc />
        public ApplicationDbContext CreateDbContext(string[] args)
        {
            var configuration = new ConfigurationBuilder()
                                .SetBasePath(Directory.GetCurrentDirectory())
                                .AddJsonFile("appsettings.json")
                                .Build();
            var builder          = new DbContextOptionsBuilder <ApplicationDbContext>();
            var connectionString = configuration.GetConnectionString(ConfigurationVariables.DefaultConnection);

            builder.UseSqlServer(connectionString, sqlServerOptions =>
                                 sqlServerOptions.MigrationsAssembly(ConfigurationVariables.MigrationAssembly));
            return(new ApplicationDbContext(builder.Options));
        }
Exemplo n.º 50
0
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            var config = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                         .SetBasePath(Environment.CurrentDirectory)
                         .AddJsonFile("appsettings.json", optional: true)
                         .Build();

            InitConfigValues(config);
            //int result = GetNumberOfCalendars().Result;
            //int result = Calendar.API.CalendarApi.GetEvents(CalendarId).Result;
            //Event result = Calendar.API.CalendarApi.CreateEvent(CalendarId).Result;
        }
Exemplo n.º 51
0
        public Startup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                          .SetBasePath(env.ContentRootPath)
                          .AddJsonFile("appsettings.json", true, true)
                          .AddEnvironmentVariables();

            Configuration = builder.Build();

            Log.Logger = new LoggerConfiguration()
                         .ReadFrom.Configuration(Configuration)
                         .CreateLogger();
        }
Exemplo n.º 52
0
        public void CreateDefault_UseBundledOnly_True_LocatesOnlyStandAloneInstance()
        {
            var configBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder().AddInMemoryCollection(new Dictionary <string, string>()
            {
                ["useBundledOnly"] = "true"
            });
            var loggerFactory = new LoggerFactory();
            var locator       = MSBuildLocator.CreateDefault(loggerFactory, new AssemblyLoader(loggerFactory), configBuilder.Build());
            var instances     = locator.GetInstances();

            Assert.Single(instances);
            Assert.Equal(DiscoveryType.StandAlone, instances[0].DiscoveryType);
        }
Exemplo n.º 53
0
        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();
        }
Exemplo n.º 54
0
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            // Add framework services.
            services.AddMvc();

            services.AddSingleton <HttpClient>();

            var configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder();

            configurationBuilder.SetBasePath(_env.ContentRootPath);
            configurationBuilder.AddJsonFile("urls.json");
            configurationBuilder.AddJsonFile("appsettings.json");
            var config       = configurationBuilder.Build();
            var gameStateUrl = config.GetSection("urls")["GameStateApi"];

            services.AddOptions();
            services.Configure <DemoOptions>(config);
            services.Configure <GameDuration>(config);

            services.AddSingleton <IGameStateClient, NullGameClient>();
            services.AddTransient <INewGameFactory, HardCodedGameFactory>();
            services.AddTransient <INewRegionsFactory, HardCodedRegionsFactory>();

            services.AddSignalR(
                o =>
            {
                o.Hubs.EnableDetailedErrors = true;
            });

            services.AddSingleton <ActorSystem>(
                x =>
            {
                var system = ActorSystem.Create("BlockWars");
                system.AddDependencyResolver(new ActorContainer(x, system));
                return(system);
            });

            services.AddSingleton <IServerManager, AkkaAdapter>();
            services.AddTransient <AccomplishmentManager, AccomplishmentManager>();

            services.AddTransient <GameActor, GameActor>();
            services.AddSingleton <ServerSupervisor, ServerSupervisor>();
            services.AddSingleton <Broadcaster, Broadcaster>();
            services.AddTransient <DemoActor, DemoActor>();
            services.AddTransient <GamePersistenceActor, GamePersistenceActor>();
            services.AddTransient <PlayerStatsActor, PlayerStatsActor>();
            services.AddSingleton <PlayerSupervisor, PlayerSupervisor>();
            services.AddTransient <PlayerActor, PlayerActor>();
            services.AddSingleton <LeaderboardActor, LeaderboardActor>();
            services.AddSingleton <LeaderboardBuffer, LeaderboardBuffer>();
        }
Exemplo n.º 55
0
        public static IServiceProvider GetConfiguredContextServiceProvider(
            TestCacheProvider cacheProvider,
            LogLevel logLevel,
            bool cacheAllQueries)
        {
            var services = new ServiceCollection();

            services.AddOptions();
            var basePath = Directory.GetCurrentDirectory();

            Console.WriteLine($"Using `{basePath}` as the ContentRootPath");
            var configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                                .SetBasePath(basePath)
                                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                                .Build();

            services.AddSingleton(_ => configuration);

            var loggerProvider = new DebugLoggerProvider();

            services.AddLogging(cfg => cfg.AddConsole().AddDebug().AddProvider(loggerProvider).SetMinimumLevel(logLevel));

            services.AddEFSecondLevelCache(options =>
            {
                switch (cacheProvider)
                {
                case TestCacheProvider.BuiltInInMemory:
                    options.UseMemoryCacheProvider();
                    break;

                case TestCacheProvider.CacheManagerCoreInMemory:
                    options.UseCacheManagerCoreProvider();
                    addCacheManagerCoreInMemory(services);
                    break;

                case TestCacheProvider.CacheManagerCoreRedis:
                    options.UseCacheManagerCoreProvider();
                    addCacheManagerCoreRedis(services);
                    break;
                }

                if (cacheAllQueries)
                {
                    options.CacheAllQueries(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(30));
                }
            });

            services.AddConfiguredMsSqlDbContext(GetConnectionString(basePath, configuration));

            return(services.BuildServiceProvider());
        }
Exemplo n.º 56
0
        /// <summary>
        /// Read configuration files and build application configuration
        /// </summary>
        /// <param name="envName"></param>
        /// <returns></returns>
        protected virtual IConfiguration BuildConfiguration(string envName)
        {
            IConfigurationBuilder builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                                            .SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
                                            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);

            if (!String.IsNullOrEmpty(envName))
            {
                string cfgName = $"appsettings.{envName}.json";
                builder.AddJsonFile(cfgName, optional: true, reloadOnChange: true);
            }

            return(builder.Build());
        }
Exemplo n.º 57
0
        public static string GetConnectionString()
        {
            string environmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");

            IConfigurationRoot configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                                               .SetBasePath(Directory.GetCurrentDirectory())
                                               .AddJsonFile("appsettings.json")
                                               .AddJsonFile($"appsettings.{environmentName}.json", true)
                                               .AddEnvironmentVariables().Build();

            string connectionString = configuration.GetConnectionString("DefaultConnection");

            return(connectionString);
        }
Exemplo n.º 58
0
        public Appsettings(string contentPath)
        {
            string Path = "appsettings.json";

            //如果你把配置文件 是 根据环境变量来分开了,可以这样写
            //Path = $"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json";

            Configuration = new ConfigurationBuilder()
                            .SetBasePath(contentPath)
                            .Add(new JsonConfigurationSource {
                Path = Path, Optional = false, ReloadOnChange = true
            })                                                                                           //这样的话,可以直接读目录里的json文件,而不是 bin 文件夹下的,所以不用修改复制属性
                            .Build();
        }
Exemplo n.º 59
0
        public WebAppContext CreateDbContext(string[] args)
        {
            Microsoft.Extensions.Configuration.IConfigurationRoot configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                                                                                  .SetBasePath(Directory.GetCurrentDirectory())
                                                                                  .AddJsonFile("appsettings.json")
                                                                                  .Build();

            var builder = new DbContextOptionsBuilder <WebAppContext>();

            var connectionString = configuration.GetConnectionString("DefaultConnection");

            builder.UseSqlServer(connectionString);

            return(new WebAppContext(builder.Options));
        }
Exemplo n.º 60
0
        public static IConfigurationRoot GetConfiguration()
        {
            var environmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");

            //Set configurations
            var di            = Directory.GetCurrentDirectory();
            var configBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                                .SetBasePath(di)
                                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
                                .AddJsonFile($"appsettings.{environmentName}.json", optional: true, reloadOnChange: false)
                                .AddEnvironmentVariables();
            var configuration = configBuilder.Build();

            return(configuration);
        }