public async Task TestEndToEnd() { string flowName = "localconfiggentest"; // Point these two settings to your filesystem locations InitialConfiguration.Set(LocalSparkClient.ConfigSettingName_SparkHomeFolder, @"<LOCAL SPARK HOME FOLDER>"); InitialConfiguration.Set(Constants.ConfigSettingName_LocalRoot, @"<LOCAL ROOT>"); var input = await File.ReadAllTextAsync(@"Resource\guiInputLocal.json"); var inputJson = JsonConfig.From(input); var result = await this.FlowOperation.SaveFlowConfig(FlowGuiConfig.From(inputJson)); Assert.IsTrue(result.IsSuccess, result.Message); var result2 = await this.RuntimeConfigGeneration.GenerateRuntimeConfigs(flowName); var runtimeConfigFolderUri = result2.Properties?.GetValueOrDefault(PrepareJobConfigVariables.ResultPropertyName_RuntimeConfigFolder, null); _runtimeConfigFolder = new System.Uri(runtimeConfigFolderUri.ToString()).AbsolutePath; var jobResult1 = await JobOperation.StartJob(flowName); Assert.IsTrue(jobResult1.IsSuccess); // Wait for few seconds for the job to do some work System.Threading.Thread.Sleep(5000); var jobResult2 = await JobOperation.StopJob(flowName); Assert.IsTrue(jobResult2.IsSuccess); }
public async Task <IActionResult> CompleteSetupAsync() { // Block request when setup was completed before if (_appSettingsManager.AppSettings != null) { return(BadRequest()); } // Read POST body to SmtpMailTest object InitialConfiguration config; using (var reader = new StreamReader(Request.Body)) { string body = await reader.ReadToEndAsync(); if (string.IsNullOrWhiteSpace(body)) { return(BadRequest()); } config = await InitialConfiguration.ParseJsonAsync(body); } // Validate data if (config == null || !config.Validate()) { return(Ok(new FailureResponse("Configuration data not valid"))); } // Create admin user var adminUser = new User(config.AdminUsername) { Email = config.AdminEmail, EmailConfirmed = true }; var result = await _userManager.CreateAsync(adminUser, config.AdminPw); if (!result.Succeeded) { return(Ok(new FailureResponse(string.Join(' ', result.Errors.Select(err => err.Description))))); } // Create roles await AddBuildInUserRole(Roles.AdminRole); await AddBuildInUserRole(Roles.CoordinatorRole); await AddBuildInUserRole(Roles.UserRole); // Add admin role to admin user await _userManager.AddToRoleAsync(adminUser, Roles.AdminRole); // Also add user role await _userManager.AddToRoleAsync(adminUser, Roles.UserRole); // Store basic app settings await _appSettingsManager.SaveSettingsAsync(config.BaseUrl, true, DefaultTemplate.Html); // Store SMTP notifier await _notifierManager.AddNotifierAsync(SmtpNotifierData.CreateFrom(config.Smtp)); return(Ok(new SuccessResponse())); }
// Get the required settings to bootstrap the config gen private void InitConfigSettings() { InitialConfiguration.Set(Constants.ConfigSettingName_EnableOneBox, Settings.EnableOneBox.ToString()); if (!Settings.EnableOneBox) { InitialConfiguration.Set(CosmosDbConfigurationProvider.ConfigSettingName_CosmosDBConfig_ConnectionString, Settings.CosmosDBConfigConnectionString); InitialConfiguration.Set(CosmosDbConfigurationProvider.ConfigSettingName_CosmosDBConfig_DatabaseName, Settings.CosmosDBConfigDatabaseName); InitialConfiguration.Set(CosmosDbConfigurationProvider.ConfigSettingName_CosmosDBConfig_CollectionName, Settings.CosmosDBConfigCollectionName); InitialConfiguration.Set(Constants.ConfigSettingName_ServiceKeyVaultName, Settings.ServiceKeyVaultName); } else { // Local settings var metricsHttpEndpoint = Settings.MetricsHttpEndpoint.TrimEnd('/') + _MetricsHttpEndpointRelativeUri; InitialConfiguration.Set(Constants.ConfigSettingName_LocalRoot, Settings.LocalRoot); InitialConfiguration.Set(LocalSparkClient.ConfigSettingName_SparkHomeFolder, Settings.SparkHome); InitialConfiguration.Set(Constants.ConfigSettingName_ClusterName, "localCluster"); InitialConfiguration.Set(Constants.ConfigSettingName_ServiceKeyVaultName, "local"); InitialConfiguration.Set(Constants.ConfigSettingName_RuntimeKeyVaultName, "local"); InitialConfiguration.Set(Constants.ConfigSettingName_MetricEventHubConnectionKey, "local"); InitialConfiguration.Set(Constants.ConfigSettingName_ConfigFolderContainerPath, ""); InitialConfiguration.Set(Constants.ConfigSettingName_ConfigFolderHost, new Uri(Environment.CurrentDirectory).AbsoluteUri); InitialConfiguration.Set(Constants.ConfigSettingName_LocalMetricsHttpEndpoint, metricsHttpEndpoint); } }
public ExperimentSetup(System.Type redirector, System.Type resetter, VirtualPathGenerator.PathSeed pathSeed, TrackingSizeShape trackingSizeShape, InitialConfiguration initialConfiguration, Vector3 gainScaleFactor) { this.redirector = redirector; this.resetter = resetter; this.pathSeed = pathSeed; this.trackingSizeShape = trackingSizeShape; this.initialConfiguration = initialConfiguration; this.gainScaleFactor = gainScaleFactor; }
public static void Cleanup() { if (CompositionHost != null) { CompositionHost.Dispose(); CompositionHost = null; } InitialConfiguration.Clear(); }
// Get the required settings to bootstrap the config gen private void InitConfigSettings() { var cosmosDBConfigConnectionString = ServiceFabricUtil.GetServiceFabricConfigSetting("cosmosDBConfigConnectionString").Result.ToString(); var cosmosDBConfigDatabaseName = ServiceFabricUtil.GetServiceFabricConfigSetting("cosmosDBConfigDatabaseName").Result.ToString(); var cosmosDBConfigCollectionName = ServiceFabricUtil.GetServiceFabricConfigSetting("cosmosDBConfigCollectionName").Result.ToString(); InitialConfiguration.Set(CosmosDbConfigurationProvider.ConfigSettingName_CosmosDBConfig_ConnectionString, cosmosDBConfigConnectionString); InitialConfiguration.Set(CosmosDbConfigurationProvider.ConfigSettingName_CosmosDBConfig_DatabaseName, cosmosDBConfigDatabaseName); InitialConfiguration.Set(CosmosDbConfigurationProvider.ConfigSettingName_CosmosDBConfig_CollectionName, cosmosDBConfigCollectionName); InitialConfiguration.Set(DataX.Config.ConfigDataModel.Constants.ConfigSettingName_ServiceKeyVaultName, _serviceKeyVaultName); }
public static void Initialize(TestContext tc) { InitialConfiguration.Set(Constants.ConfigSettingName_RuntimeKeyVaultName, "somekeyvault"); var conf = new ContainerConfiguration() .WithAssembly(typeof(ConfigGenConfiguration).Assembly) .WithAssembly(typeof(MockBase).Assembly) .WithAssembly(Assembly.GetExecutingAssembly()); CompositionHost = conf.CreateContainer(); }
public ActionResult <Configuration> PostConfiguration([FromBody] InitialConfiguration initialConfig) { var configuration = _configurationRepository.GetConfiguration(); if (configuration != null) { return(BadRequest("DevOps service has already been configured.")); } configuration = _configurationLogic.InitialConfiguration(initialConfig); return(Ok(configuration)); }
public static void Initialize(TestContext tc) { InitialConfiguration.Set(Constants.ConfigSettingName_RuntimeKeyVaultName, "somekeyvault"); var conf = new ContainerConfiguration() .WithAssembly(typeof(ConfigGenConfiguration).Assembly) .WithAssembly(typeof(MockBase).Assembly) .WithAssembly(Assembly.GetExecutingAssembly()) .WithProvider(new LoggerAndInstanceExportDescriptorProvider <object>(null, new LoggerFactory())); CompositionHost = conf.CreateContainer(); }
// Use this for initialization void Start() { initialConfiguration = new InitialConfiguration(); ball = initialConfiguration.field.getBall(); player = initialConfiguration.field.getPlayer(); goalKepperBehavior = new GoalKepperBehavior(); goalKepperBehavior.setField(initialConfiguration.field); // Initialize all game objects goalKepperGameObject = GameObject.Find("GoalKepper"); ballGameObject = GameObject.Find("Football"); Debug.Log("Goaly position : " + goalKepperGameObject.transform.position + " ball position" + ballGameObject.transform.position); }
public static void Initialize(TestContext tc) { InitialConfiguration.Set(Constants.ConfigSettingName_ClusterName, "somecluster"); InitialConfiguration.Set(Constants.ConfigSettingName_ServiceKeyVaultName, "someservicekeyvault"); InitialConfiguration.Set(Constants.ConfigSettingName_RuntimeKeyVaultName, "somekeyvault"); InitialConfiguration.Set(Constants.ConfigSettingName_MetricEventHubConnectionKey, "metric-eventhubconnectionstring"); var conf = new ContainerConfiguration() .WithAssembly(typeof(ConfigGenConfiguration).Assembly) .WithAssembly(typeof(MockBase).Assembly) .WithAssembly(Assembly.GetExecutingAssembly()); CompositionHost = conf.CreateContainer(); }
public static void Initialize(TestContext tc) { InitialConfiguration.Set(Constants.ConfigSettingName_ClusterName, "somecluster"); InitialConfiguration.Set(Constants.ConfigSettingName_ServiceKeyVaultName, "someservicekeyvault"); InitialConfiguration.Set(Constants.ConfigSettingName_RuntimeKeyVaultName, "somekeyvault"); InitialConfiguration.Set(Constants.ConfigSettingName_MetricEventHubConnectionKey, "metric-eventhubconnectionstring"); InitialConfiguration.Set(Constants.ConfigSettingName_SparkType, "databricks"); var conf = new ContainerConfiguration() .WithAssembly(typeof(ConfigGenConfiguration).Assembly) .WithAssembly(typeof(MockBase).Assembly) .WithAssembly(Assembly.GetExecutingAssembly()) .WithProvider(new LoggerAndInstanceExportDescriptorProvider(null, new LoggerFactory())); CompositionHost = conf.CreateContainer(); }
public static void Initialize(TestContext tc) { InitialConfiguration.Set(Constants.ConfigSettingName_ServiceKeyVaultName, "someservicekeyvault"); InitialConfiguration.Set(Constants.ConfigSettingName_RuntimeKeyVaultName, "somekeyvault"); InitialConfiguration.Set(Constants.ConfigSettingName_MetricEventHubConnectionKey, "metric-eventhubconnectionstring"); InitialConfiguration.Set(Constants.ConfigSettingName_EnableOneBox, "true"); InitialConfiguration.Set(Constants.ConfigSettingName_ClusterName, "localCluster"); InitialConfiguration.Set(Constants.ConfigSettingName_ConfigFolderContainerPath, ""); InitialConfiguration.Set(Constants.ConfigSettingName_ConfigFolderHost, new System.Uri(Environment.CurrentDirectory).AbsoluteUri); InitialConfiguration.Set(Constants.ConfigSettingName_LocalMetricsHttpEndpoint, "http://localhost:2020/api/data/upload"); var conf = new ContainerConfiguration() .WithAssembly(typeof(ConfigGenConfiguration).Assembly) .WithAssembly(typeof(DataX.Config.Local.LocalDesignTimeStorage).Assembly); CompositionHost = conf.CreateContainer(); _TestContext = tc; }
// Get the required settings to bootstrap the config gen private void InitConfigSettings() { var settings = new DataXSettings(); Configuration.GetSection("DataX").Bind(settings); // Local settings var httpEndpoint = settings.MetricsHttpEndpoint.TrimEnd('/') + _MetricsHttpEndpointRelativeUri; InitialConfiguration.Set(DataX.Config.ConfigDataModel.Constants.ConfigSettingName_EnableOneBox, settings.EnableOneBox); InitialConfiguration.Set(DataX.Config.ConfigDataModel.Constants.ConfigSettingName_LocalRoot, settings.LocalRoot); InitialConfiguration.Set(DataX.Config.Local.LocalSparkClient.ConfigSettingName_SparkHomeFolder, settings.SparkHome); InitialConfiguration.Set(DataX.Config.ConfigDataModel.Constants.ConfigSettingName_ClusterName, "localCluster"); InitialConfiguration.Set(DataX.Config.ConfigDataModel.Constants.ConfigSettingName_ServiceKeyVaultName, "local"); InitialConfiguration.Set(DataX.Config.ConfigDataModel.Constants.ConfigSettingName_RuntimeKeyVaultName, "local"); InitialConfiguration.Set(DataX.Config.ConfigDataModel.Constants.ConfigSettingName_MetricEventHubConnectionKey, "local"); InitialConfiguration.Set(DataX.Config.ConfigDataModel.Constants.ConfigSettingName_ConfigFolderContainerPath, ""); InitialConfiguration.Set(DataX.Config.ConfigDataModel.Constants.ConfigSettingName_ConfigFolderHost, new System.Uri(Environment.CurrentDirectory).AbsoluteUri); InitialConfiguration.Set(DataX.Config.ConfigDataModel.Constants.ConfigSettingName_LocalMetricsHttpEndpoint, httpEndpoint); }
public CosmosDbConfigurationProvider(IKeyVaultClient kv) { async Task <string> resolveKey(string configSettingName) { var key = InitialConfiguration.Get(configSettingName); Ensure.NotNull(key, configSettingName); var value = await kv.ResolveSecretUriAsync(key); Ensure.NotNull(value, "resolved_" + configSettingName); return(value); } var connectionString = resolveKey(ConfigSettingName_CosmosDBConfig_ConnectionString).Result; var dbName = resolveKey(ConfigSettingName_CosmosDBConfig_DatabaseName).Result; var collectionName = resolveKey(ConfigSettingName_CosmosDBConfig_CollectionName).Result; var cosmosDBUtil = new CosmosDBUtility(connectionString, dbName); var settings = cosmosDBUtil.FindOne(collectionName).Result; var settingsDictionary = DeserializeToDictionary(settings); _settings = new Dictionary <string, string>(settingsDictionary.Select(x => KeyValuePair.Create <string, string>(x.Key, x.Value.ToString()))); }
public void ConfigureServices(IServiceCollection services) { services.AddRazorPages(); services.AddScoped <IDbConnection, SqlConnection>(db => new SqlConnection(Configuration.GetConnectionString("GlobomanticsDb"))); services.AddAuthentication(options => { options.DefaultScheme = IdentityConstants.ApplicationScheme; options.DefaultSignInScheme = IdentityConstants.ExternalScheme; options.DefaultChallengeScheme = IdentityConstants.ExternalScheme; }).AddIdentityCookies(o => { o.ApplicationCookie.Configure(opts => { opts.LoginPath = "/Account/Login"; opts.AccessDeniedPath = "/Identity/Account/AccessDenied"; opts.LogoutPath = "/Account/Logout"; }); o.ExternalCookie.Configure(opts => { opts.LoginPath = "/Account/Login"; opts.AccessDeniedPath = "/Identity/Account/AccessDenied"; opts.LogoutPath = "/Account/Logout"; }); }); const int considerPwned = 1000; services.AddPwnedPasswordHttpClient(minimumFrequencyToConsiderPwned: considerPwned) .AddTransientHttpErrorPolicy(p => p.RetryAsync(3)) .AddPolicyHandler(Policy.TimeoutAsync <HttpResponseMessage>(TimeSpan.FromSeconds(1))); services.AddScoped <IPasswordHasher <CustomUser>, CustomPasswordHasher>(); services.AddTransient <IConfigureOptions <IdentityOptions>, CustomIdentityOptions>(); services.AddIdentityCore <CustomUser>() .AddSignInManager <SignInManager <CustomUser> >() //.AddUserManager<UserManager<CustomUser>>() .AddUserManager <CustomUserManager>() .AddUserStore <CustomUserStore>() // not including phone number provider .AddTokenProvider <DataProtectorTokenProvider <CustomUser> >(TokenOptions.DefaultProvider) .AddTokenProvider <EmailTokenProvider <CustomUser> >(TokenOptions.DefaultEmailProvider) .AddTokenProvider <AuthenticatorTokenProvider <CustomUser> >(TokenOptions.DefaultAuthenticatorProvider) .AddDefaultUI() .AddPwnedPasswordValidator <CustomUser>(options => { options.ErrorMessage = $"Cannot use passwords that have been pwned more than {considerPwned} times."; }) .AddPasswordValidator <CustomPasswordValidator>() .AddUserValidator <CustomUserValidator>(); var connStr = Configuration.GetConnectionString("IS4DbConnection"); var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name; services.AddIdentityServer(options => { options.Events.RaiseErrorEvents = true; options.Events.RaiseInformationEvents = true; options.Events.RaiseFailureEvents = true; options.Events.RaiseSuccessEvents = true; options.AccessTokenJwtType = string.Empty; options.EmitStaticAudienceClaim = true; options.UserInteraction.LoginUrl = "/Account/Login"; options.UserInteraction.LogoutUrl = "/Account/Logout"; }) .AddInMemoryApiResources(InitialConfiguration.GetApis()) .AddInMemoryApiScopes(InitialConfiguration.GetApiScopes()) .AddInMemoryIdentityResources(InitialConfiguration.GetIdentityResources()) .AddInMemoryClients(InitialConfiguration.GetClients()) //.AddConfigurationStore(options => //{ // options.ConfigureDbContext = b => // b.UseSqlServer(connStr, sql => sql.MigrationsAssembly(migrationsAssembly)); //}) //.AddOperationalStore(options => //{ // options.ConfigureDbContext = b => // b.UseSqlServer(connStr, sql => sql.MigrationsAssembly(migrationsAssembly)); //}) .AddDeveloperSigningCredential() .AddAspNetIdentity <CustomUser>(); services.AddTransient <IEmailSender>(s => new EmailSender(Configuration)); }
public Configuration InitialConfiguration(InitialConfiguration initialConfig) { //TODO: Create a new configuration element here //TODO: Check to see if there is already a configuration. If so, throw. //TODO: Get the registration and store the configuration in the database if (initialConfig == null) { throw new Exception("The initial configuration cannot be null."); } if (initialConfig.CertificateUserThumbprint == null) { throw new Exception("The user certificate thumbprint cannot be null."); } if (initialConfig.SppAddress == null) { throw new Exception("The SPP network address cannot be null."); } ISafeguardConnection connection = null; try { connection = Safeguard.Connect(initialConfig.SppAddress, initialConfig.CertificateUserThumbprint, _safeguardApiVersion, _safeguardIgnoreSsl); var rawJson = connection.InvokeMethod(Service.Core, Method.Get, "A2ARegistrations"); var registrations = JsonHelper.DeserializeObject <IEnumerable <SppRegistration> >(rawJson); // TODO: Assume that we only have one registration that belongs to the cert user var registration = registrations?.FirstOrDefault(); if (registration != null) { var configuration = new Configuration { SppAddress = initialConfig.SppAddress, A2ARegistrationId = registration.Id, A2ARegistrationName = registration.AppName, CertificateUser = registration.CertificateUser, CertificateUserThumbPrint = registration.CertificateUserThumbPrint, CreatedByUserId = registration.CreatedByUserId, CreatedByUserDisplayName = registration.CreatedByUserDisplayName, CreatedDate = registration.CreatedDate, AccountMapping = new List <AccountMapping>() }; _configurationRepository.SaveConfiguration(configuration); return(configuration); } else { _logger.Error("No A2A registrations were found for the configured certificate user"); } } catch (Exception ex) { _logger.Error($"Failed to initialize the DevOps Serivce: {ex.Message}"); } finally { connection?.Dispose(); } throw new Exception("Failed to configure devops."); }
/// <summary> /// This method will create an initialize a generic Host Builder /// </summary> /// <typeparam name="TApp">Main application type. Used to access user secrets</typeparam> /// <param name="args">Application arguments</param> /// <param name="localServiceConfiguration">Delegate to be executed to add any non-standard configuration needs</param> /// <returns>Configured IHostBuilder</returns> public static IHostBuilder CreateHostBuilder <TApp>(string[] args, ConfigureLocalServices <TApp> localServiceConfiguration = null) where TApp : class { IHostBuilder hostBuilder = Host.CreateDefaultBuilder(args) .ConfigureAppConfiguration((hostingContext, builder) => { Assembly CurrentAssembly = typeof(TApp).GetTypeInfo().Assembly; // Set up configuration to read appsettings.json and override with secrets.json builder.AddUserSecrets(CurrentAssembly); // Bind the configuration properties to the properties in the SettingsConfig object IConfiguration initialConfig = builder.Build(); IConfigurationSection myInitialConfig = initialConfig.GetSection(InitialConfigurationSectionName); _appSetupConfig = new InitialConfiguration(); myInitialConfig.Bind(_appSetupConfig); if (!string.IsNullOrEmpty(_appSetupConfig.KeyVaultName) && !string.IsNullOrEmpty(_appSetupConfig.KeyVaultKey)) { // Use the environment variable "InitialConfiguration:RTE" instead of the value in the configuration file // if the environment value is available. // Substitute the runtime environment name in the keyvault properties _appSetupConfig.KeyVaultName = _appSetupConfig.KeyVaultName.Replace("{RTE}", _appSetupConfig.RTE); _appSetupConfig.KeyVaultKey = _appSetupConfig.KeyVaultKey.Replace("{RTE}", _appSetupConfig.RTE); builder.AddAzureKeyVaultClient(_appSetupConfig.KeyVaultName); } // Build the final configuration _baseConfiguration = builder.Build(); // Get all the secrets from KeyVault _secrets = _baseConfiguration.InitializeApplicationSecrets(_appSetupConfig); // Use the KeyVault secrets connect to redis cache _cache = _baseConfiguration.InitializeRedisCache(_secrets); // Set up automated refresh from redis cache. "TimedCacheRefresh" configuration // setting determines which keys are read from the cache and how often they are read. // These values are then placed as regular values that can be read from IConfiguration _cache?.RefreshConfigurationFromCache(_secrets, _baseConfiguration); }) .ConfigureServices((hostingContext, services) => { localServiceConfiguration?.Invoke(hostingContext, services, _appSetupConfig); services .AddTransient <TApp>() .AddSingleton <IApplicationSetupConfiguration>(sp => { return(_appSetupConfig); }) .AddSingleton <IApplicationSecrets>(sp => { return(_secrets); }) .AddSingleton <IRedisCache>(sp => { return(_cache); }) .AddSingleton <IHostEnvironment>(sp => { return(hostingContext.HostingEnvironment); }); _serviceProvider = services.BuildServiceProvider(); }) .ConfigureLogging((hostingContext, logging) => { ConfigureCustomLogging(hostingContext, logging, _secrets, _appSetupConfig); }); return(hostBuilder); }
public LocalSparkClient(ILogger logger) { _sparkHomeFolder = InitialConfiguration.Get(ConfigSettingName_SparkHomeFolder); _sparkSubmitCmd = Path.Combine(_sparkHomeFolder, "bin", "spark-submit"); _logger = logger; }