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;
}
