protected Page()
{
if (EnvironmentReader.get(GetType().Name) != null)
{
Url = EnvironmentReader.get(GetType().Name).Url;
PageTitle = EnvironmentReader.get(GetType().Name).PageTitle;
}
}
public static void Start()
{
var muxer = ConnectionMultiplexer.Connect(EnvironmentReader.FromEnvironment().RedisConnectionString);
var timerProvider = new RealTimerProvider();
var worker = new BackgroundWorker(muxer, timerProvider,
new JobQueueFactory(muxer.GetDatabase(Constants.Redis.PACKAGES_DB))
.ForQueueName(Constants.Redis.PackageCrawlerJobQueueName));
worker.Run();
}
private static async Task RunBot()
{
var environmentReader = new EnvironmentReader();
var botConfiguration = new BotConfiguration(environmentReader);
var containerFactory = new ContainerFactory(botConfiguration, environmentReader, GetLogger());
var container = containerFactory.CreateContainer();
_noobotCore = container.GetNoobotCore();
await _noobotCore.Connect();
}
public void TestReadUseAutoReWrite()
{
var org = Environment.GetEnvironmentVariable(EnvironmentReader.Usetestautorewrite, EnvironmentVariableTarget.User);
try
{
Environment.SetEnvironmentVariable(EnvironmentReader.Usetestautorewrite, "false", EnvironmentVariableTarget.User);
var reader = new EnvironmentReader();
Assert.AreEqual(false, reader.UseTestAutoRewrite());
Environment.SetEnvironmentVariable(EnvironmentReader.Usetestautorewrite, "true", EnvironmentVariableTarget.User);
Assert.AreEqual(true, reader.UseTestAutoRewrite());
}
finally
{
Environment.SetEnvironmentVariable(EnvironmentReader.Usetestautorewrite, org, EnvironmentVariableTarget.User);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddMvc().AddJsonOptions(json =>
{
json.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
});
var builder = new ContainerBuilder();
builder.Register(_ => EnvironmentReader.FromEnvironment());
builder.RegisterType <LatestPackagesQuery>().As <ILatestPackagesIndex>();
builder.RegisterType <Nuget.NugetApi>().As <Nuget.INugetApi>().InstancePerLifetimeScope();
builder.RegisterType <JobQueueFactory>().As <IJobQueueFactory>();
builder.Register((Func <IComponentContext, Query.RedisGetSetQuery <Package> >)(cc => new RedisGetSetQuery <Package>(cc.Resolve <IDatabase>(), api.Env.Constants.Redis.PackageKeyForName))).As <IGetSetQuerier <Package> >();
builder.Register(BuildConnectionMultiplexer).As <ConnectionMultiplexer>().SingleInstance();
builder.Register(componentContext => componentContext.Resolve <ConnectionMultiplexer>().GetDatabase(api.Env.Constants.Redis.PACKAGES_DB)).As <IDatabase>().InstancePerLifetimeScope();
builder.Populate(services);
var container = builder.Build();
return(container.Resolve <IServiceProvider>());
}
public Page(BrowserSession browserSession)
{
Url = EnvironmentReader.get(GetType().Name).Url;
PageTitle = EnvironmentReader.get(GetType().Name).PageTitle;
_browserSession = browserSession;
}
/// <summary>
/// Starts a background task for each test and role that needs to be run in this process, and waits for all
/// test runs to completed before finishing the run.
/// </summary>
///
/// <param name="opts">The parsed command line inputs.</param>
///
private static async Task RunOptions(Options opts)
{
// See if there are environment variables available to use in the .env file
var environment = new Dictionary <string, string>();
var appInsightsKey = String.Empty;
var eventHubsConnectionString = String.Empty;
var environmentFile = Environment.GetEnvironmentVariable("ENV_FILE");
if (!(string.IsNullOrEmpty(environmentFile)))
{
environment = EnvironmentReader.LoadFromFile(environmentFile);
}
environment.TryGetValue(EnvironmentVariables.ApplicationInsightsKey, out appInsightsKey);
environment.TryGetValue(EnvironmentVariables.EventHubsConnectionString, out eventHubsConnectionString);
// If not, and this is an interactive run, try and get them from the user.
eventHubsConnectionString = PromptForResources("Event Hubs Connection String", "all test runs", eventHubsConnectionString, opts.Interactive);
appInsightsKey = PromptForResources("Application Insights Instrumentation Key", "all test runs", appInsightsKey, opts.Interactive);
// If a job index is provided, a single role is started, otherwise, all specified roles within the
// test scenario runs are run in parallel.
var roleConfiguration = new RoleConfiguration();
var testScenarioTasks = new List <Task>();
var metrics = new Metrics(appInsightsKey);
var testConfiguration = new TestConfiguration();
testConfiguration.EventHubsConnectionString = eventHubsConnectionString;
var cancellationSource = new CancellationTokenSource();
var runDuration = TimeSpan.FromHours(testConfiguration.DurationInHours);
cancellationSource.CancelAfter(runDuration);
using var azureEventListener = new AzureEventSourceListener((args, level) => metrics.Client.TrackTrace($"EventWritten: {args.ToString()} Level: {level}."), EventLevel.Warning);
// If running the Event Producer Test scenario, gather resources and add a scenario run to the task list.
if (opts.Test == RoleConfiguration.EventProducerTest || opts.Test == RoleConfiguration.EventProducerTestShort || opts.All)
{
// Get the needed resources for the event producer test: an event hub
var eventHubName = String.Empty;
environment.TryGetValue(EnvironmentVariables.EventHubEventProducerTest, out eventHubName);
eventHubName = PromptForResources("Event Hub", RoleConfiguration.EventProducerTest, eventHubName, opts.Interactive);
testConfiguration.EventHub = eventHubName;
roleConfiguration.TestScenarioRoles.TryGetValue(RoleConfiguration.EventProducerTest, out var roleList);
testScenarioTasks.Add(RunScenario(roleList, testConfiguration, roleConfiguration, metrics, opts.Role, RoleConfiguration.EventProducerTest, cancellationSource.Token));
}
// If running the Buffered Producer Test scenario, gather resources and add a scenario run to the task list.
if (opts.Test == RoleConfiguration.BufferedProducerTest || opts.Test == RoleConfiguration.BufferedProducerTestShort || opts.All)
{
// Get the needed resources for the buffered producer test: an event hub
var eventHubName = String.Empty;
environment.TryGetValue(EnvironmentVariables.EventHubBufferedProducerTest, out eventHubName);
eventHubName = PromptForResources("Event Hub", RoleConfiguration.BufferedProducerTest, eventHubName, opts.Interactive);
testConfiguration.EventHub = eventHubName;
roleConfiguration.TestScenarioRoles.TryGetValue(RoleConfiguration.BufferedProducerTest, out var roleList);
testScenarioTasks.Add(RunScenario(roleList, testConfiguration, roleConfiguration, metrics, opts.Role, RoleConfiguration.BufferedProducerTest, cancellationSource.Token));
}
// If running the Burst Buffered Producer Test scenario, gather resources and add a scenario run to the task list.
if (opts.Test == RoleConfiguration.BurstBufferedProducerTest || opts.Test == RoleConfiguration.BurstBufferedProducerTestShort || opts.All)
{
// Get the needed resources for the buffered producer test: an event hub
var eventHubName = String.Empty;
environment.TryGetValue(EnvironmentVariables.EventHubBurstBufferedProducerTest, out eventHubName);
eventHubName = PromptForResources("Event Hub", "Burst Buffered Producer Test", eventHubName, opts.Interactive);
testConfiguration.EventHub = eventHubName;
roleConfiguration.TestScenarioRoles.TryGetValue(RoleConfiguration.BurstBufferedProducerTest, out var roleList);
testScenarioTasks.Add(RunScenario(roleList, testConfiguration, roleConfiguration, metrics, opts.Role, RoleConfiguration.BurstBufferedProducerTest, cancellationSource.Token));
}
// If running the Processor Test scenario, gather resources and add a scenario run to the task list.
if (opts.Test == RoleConfiguration.EventProcessorTest || opts.Test == RoleConfiguration.EventProcessorTestShort || opts.All)
{
// Get the needed resources for the processor test: an event hub, storage account, and blob container name
var eventHubName = String.Empty;
var storageBlob = String.Empty;
var storageConnectionString = String.Empty;
environment.TryGetValue(EnvironmentVariables.EventHubProcessorTest, out eventHubName);
eventHubName = PromptForResources("Event Hub", RoleConfiguration.EventProcessorTest, eventHubName, opts.Interactive);
testConfiguration.EventHub = eventHubName;
environment.TryGetValue(EnvironmentVariables.StorageBlobProcessorTest, out storageBlob);
storageBlob = PromptForResources("Storage Blob Name", RoleConfiguration.EventProcessorTest, storageBlob, opts.Interactive);
testConfiguration.BlobContainer = storageBlob;
environment.TryGetValue(EnvironmentVariables.StorageAccountProcessorTest, out storageConnectionString);
storageConnectionString = PromptForResources("Storage Account Connection String", RoleConfiguration.EventProcessorTest, storageConnectionString, opts.Interactive);
testConfiguration.StorageConnectionString = storageConnectionString;
roleConfiguration.TestScenarioRoles.TryGetValue(RoleConfiguration.EventProcessorTest, out var roleList);
testScenarioTasks.Add(RunScenario(roleList, testConfiguration, roleConfiguration, metrics, opts.Role, RoleConfiguration.BurstBufferedProducerTest, cancellationSource.Token));
}
// Wait for all scenario runs to finish before returning.
await Task.WhenAll(testScenarioTasks).ConfigureAwait(false);
}
protected Page()
{
Url = EnvironmentReader.Get(GetType().Name).Url;
PageTitle = EnvironmentReader.Get(GetType().Name).PageTitle;
}
/// <summary>
/// Starts a background task for each test that needs to be run, and waits for all
/// test runs to completed before returning.
/// </summary>
///
/// <param name="opts">The parsed command line inputs.</param>
///
private static async Task RunOptions(Options opts)
{
var environment = new Dictionary <string, string>();
var appInsightsKey = String.Empty;
var eventHubsConnectionString = String.Empty;
var eventProducerTestConfig = new EventProducerTestConfig();
var bufferedProducerTestConfig = new BufferedProducerTestConfig();
var burstBufferedProducerTestConfig = new BufferedProducerTestConfig();
var concurrentBufferedProducerTestConfig = new BufferedProducerTestConfig();
var testRunTasks = new List <Task>();
// Determine which tests should be run based on the command line args
if (opts.All)
{
eventProducerTestConfig.Run = true;
bufferedProducerTestConfig.Run = true;
burstBufferedProducerTestConfig.Run = true;
concurrentBufferedProducerTestConfig.Run = true;
}
foreach (var testRun in opts.Tests)
{
if (testRun == "EventProd" || testRun == "EventProducerTest")
{
eventProducerTestConfig.Run = true;
}
if (testRun == "BuffProd" || testRun == "BufferedProducerTest")
{
bufferedProducerTestConfig.Run = true;
}
if (testRun == "BurstBuffProd" || testRun == "BurstBufferedProducerTest")
{
burstBufferedProducerTestConfig.Run = true;
}
if (testRun == "ConcurBuffProd" || testRun == "ConcurrentBufferedProducerTest")
{
concurrentBufferedProducerTestConfig.Run = true;
}
}
// See if there are environment variables available to use in the .env file
var environmentFile = Environment.GetEnvironmentVariable("ENV_FILE");
if (!(string.IsNullOrEmpty(environmentFile)))
{
environment = EnvironmentReader.LoadFromFile(environmentFile);
}
environment.TryGetValue(EnvironmentVariables.ApplicationInsightsKey, out appInsightsKey);
environment.TryGetValue(EnvironmentVariables.EventHubsConnectionString, out eventHubsConnectionString);
// Prompt for needed resources if interactive mode is enabled
if (opts.Interactive)
{
eventHubsConnectionString = _promptForResources("Event Hubs connection string", "all test runs", eventHubsConnectionString);
appInsightsKey = _promptForResources("Application Insights key", "all test runs", appInsightsKey);
}
// Run the event producer test
if (eventProducerTestConfig.Run)
{
eventProducerTestConfig.InstrumentationKey = appInsightsKey;
eventProducerTestConfig.EventHubsConnectionString = eventHubsConnectionString;
environment.TryGetValue(EnvironmentVariables.EventHubEventProducerTest, out eventProducerTestConfig.EventHub);
if (opts.Interactive)
{
eventProducerTestConfig.EventHub = _promptForResources("Event Hub name", "event producer test", eventProducerTestConfig.EventHub);
}
var testRun = new EventProducerTest(eventProducerTestConfig);
testRunTasks.Add(testRun.Run());
}
// Run the buffered producer test
if (bufferedProducerTestConfig.Run)
{
bufferedProducerTestConfig.InstrumentationKey = appInsightsKey;
bufferedProducerTestConfig.EventHubsConnectionString = eventHubsConnectionString;
environment.TryGetValue(EnvironmentVariables.EventHubBufferedProducerTest, out bufferedProducerTestConfig.EventHub);
if (opts.Interactive)
{
bufferedProducerTestConfig.EventHub = _promptForResources("Event Hub name", "buffered producer test", bufferedProducerTestConfig.EventHub);
}
bufferedProducerTestConfig.ConcurrentSends = 1;
var testRun = new BufferedProducerTest(bufferedProducerTestConfig);
testRunTasks.Add(testRun.Run());
}
// Run the burst buffered producer test
if (burstBufferedProducerTestConfig.Run)
{
burstBufferedProducerTestConfig.InstrumentationKey = appInsightsKey;
burstBufferedProducerTestConfig.EventHubsConnectionString = eventHubsConnectionString;
environment.TryGetValue(EnvironmentVariables.EventHubBurstBufferedProducerTest, out burstBufferedProducerTestConfig.EventHub);
if (opts.Interactive)
{
burstBufferedProducerTestConfig.EventHub = _promptForResources("Event Hub name", "burst buffered producer test", burstBufferedProducerTestConfig.EventHub);
}
burstBufferedProducerTestConfig.ConcurrentSends = 5;
burstBufferedProducerTestConfig.ProducerPublishingDelay = TimeSpan.FromMinutes(15);
var testRun = new BufferedProducerTest(burstBufferedProducerTestConfig);
testRunTasks.Add(testRun.Run());
}
// Run the concurrent buffered producer test
if (concurrentBufferedProducerTestConfig.Run)
{
concurrentBufferedProducerTestConfig.InstrumentationKey = appInsightsKey;
concurrentBufferedProducerTestConfig.EventHubsConnectionString = eventHubsConnectionString;
environment.TryGetValue(EnvironmentVariables.EventHubConcurrentBufferedProducerTest, out concurrentBufferedProducerTestConfig.EventHub);
if (opts.Interactive)
{
concurrentBufferedProducerTestConfig.EventHub = _promptForResources("Event Hub name", "concurrent buffered producer test", concurrentBufferedProducerTestConfig.EventHub);
}
concurrentBufferedProducerTestConfig.ConcurrentSends = 5;
var testRun = new BufferedProducerTest(concurrentBufferedProducerTestConfig);
testRunTasks.Add(testRun.Run());
}
// Wait for all test runs to complete
await Task.WhenAll(testRunTasks).ConfigureAwait(false);
}
public ConfigurationReader()
{
this.environmentReader = new EnvironmentReader();
this.jsonSerializer = new ApolloJsonSerializer();
}
