protected virtual LoggingConfiguration SetupLogging(EndpointConfiguration endpointConfiguration)
{
var logDir = ".\\logfiles\\";
Directory.CreateDirectory(logDir);
var logFile = Path.Combine(logDir, endpointConfiguration.EndpointName + ".txt");
if (File.Exists(logFile))
{
File.Delete(logFile);
}
var logLevel = "INFO";
var nlogConfig = new LoggingConfiguration();
var fileTarget = new FileTarget
{
FileName = logFile,
Layout = "${longdate}|${level:uppercase=true}|${threadid}|${logger}|${message}${onexception:inner=${newline}${exception}${newline}${stacktrace:format=DetailedFlat}}"
};
nlogConfig.LoggingRules.Add(new LoggingRule("Raven.*", LogLevel.Warn, fileTarget) { Final = true });
nlogConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.FromString(logLevel), fileTarget));
nlogConfig.AddTarget("debugger", fileTarget);
NLogConfigurator.Configure(new object[] {fileTarget}, logLevel);
return nlogConfig;
}
protected override LoggingConfiguration SetupLogging(EndpointConfiguration endpointConfiguration)
{
var logDir = ".\\logfiles\\";
Directory.CreateDirectory(logDir);
var logFile = Path.Combine(logDir, endpointConfiguration.EndpointName + ".txt");
if (File.Exists(logFile))
{
File.Delete(logFile);
}
var logLevel = "ERROR";
var nlogConfig = new LoggingConfiguration();
var fileTarget = new FileTarget
{
FileName = logFile,
};
nlogConfig.LoggingRules.Add(new LoggingRule("Raven.*", LogLevel.Warn, fileTarget) { Final = true });
nlogConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.FromString(logLevel), fileTarget));
nlogConfig.LoggingRules.Add(new LoggingRule("ServiceControl.ExternalIntegrations.*", LogLevel.Debug, fileTarget));
nlogConfig.AddTarget("debugger", fileTarget);
NLogConfigurator.Configure(new object[] { fileTarget }, logLevel);
return nlogConfig;
}
public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration,
IConfigurationSource configSource)
{
Configure.ScaleOut(_ => _.UseSingleBrokerQueue());
new Bootstrapper();
//We need this hack here because by default we include all assemblies minus Plugins but for these tests we need to exclude other tests!
for (var index = 0; index < Configure.TypesToScan.Count;)
{
var type = Configure.TypesToScan[index];
if (type.Assembly != Assembly.GetExecutingAssembly())
{
index++;
continue;
}
if (!(type.DeclaringType == endpointConfiguration.BuilderType.DeclaringType ||
type.DeclaringType == endpointConfiguration.BuilderType))
{
Configure.TypesToScan.RemoveAt(index);
}
else
{
index++;
}
}
LogManager.Configuration = SetupLogging(endpointConfiguration);
return Configure.Instance;
}
public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration,
IConfigurationSource configSource)
{
var settings = runDescriptor.Settings;
var types = GetTypesToUse(endpointConfiguration);
var transportToUse = settings.GetOrNull("Transport");
SetupLogging(endpointConfiguration);
Configure.Features.Enable<Sagas>();
var config = Configure.With(types)
.DefineEndpointName(endpointConfiguration.EndpointName)
.DefineBuilder(settings.GetOrNull("Builder"))
.CustomConfigurationSource(configSource)
.DefineSerializer(settings.GetOrNull("Serializer"))
.DefineTransport(transportToUse)
.InMemorySagaPersister();
if (transportToUse == null || transportToUse.Contains("Msmq") || transportToUse.Contains("SqlServer") ||
transportToUse.Contains("RabbitMq"))
config.UseInMemoryTimeoutPersister();
if (transportToUse == null || transportToUse.Contains("Msmq") || transportToUse.Contains("SqlServer"))
config.InMemorySubscriptionStorage();
config.InMemorySagaPersister();
return config.UnicastBus();
}
static void SetupLogging(EndpointConfiguration endpointConfiguration)
{
var logDir = ".\\logfiles\\";
Directory.CreateDirectory(logDir);
var logFile = Path.Combine(logDir, endpointConfiguration.EndpointName + ".txt");
if (File.Exists(logFile))
{
File.Delete(logFile);
}
var logLevel = "INFO";
var nlogConfig = new LoggingConfiguration();
var fileTarget = new FileTarget
{
FileName = logFile,
};
nlogConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.FromString(logLevel), fileTarget));
nlogConfig.AddTarget("debugger", fileTarget);
NLogConfigurator.Configure(new object[] {fileTarget}, logLevel);
LogManager.Configuration = nlogConfig;
}
public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration,
IConfigurationSource configSource)
{
var settings = runDescriptor.Settings;
var types = GetTypesScopedByTestClass(endpointConfiguration);
var transportToUse = AcceptanceTest.GetTransportIntegrationFromEnvironmentVar();
SetupLogging(endpointConfiguration);
Configure.Features.Enable<Sagas>();
Configure.ScaleOut(_ => _.UseSingleBrokerQueue());
AddMoreConfig();
var config = Configure.With(types)
.DefiningEventsAs(t => typeof(IEvent).IsAssignableFrom(t) || IsExternalContract(t))
.DefineEndpointName(endpointConfiguration.EndpointName)
.CustomConfigurationSource(configSource)
.DefineBuilder(settings.GetOrNull("Builder"));
SetSerializer(config);
config
.DefineTransport(transportToUse)
.InMemorySagaPersister()
.UseInMemoryTimeoutPersister();
if (transportToUse == null || transportToUse is MsmqTransportIntegration || transportToUse is SqlServerTransportIntegration || transportToUse is AzureStorageQueuesTransportIntegration)
{
config.InMemorySubscriptionStorage();
}
return config.UnicastBus();
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings)
{
queueBindings = configuration.GetSettings().Get<QueueBindings>();
var connectionString = settings.Get<string>("Transport.ConnectionString");
configuration.UseTransport<MsmqTransport>().ConnectionString(connectionString);
return Task.FromResult(0);
}
public BusConfiguration GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration, IConfigurationSource configSource, Action<BusConfiguration> configurationBuilderCustomization)
{
var settings = runDescriptor.Settings;
var types = GetTypesToUse(endpointConfiguration);
var config = new BusConfiguration();
config.EndpointName(endpointConfiguration.EndpointName);
config.TypesToScan(types);
config.CustomConfigurationSource(configSource);
config.UsePersistence<InMemoryPersistence>();
config.PurgeOnStartup(true);
// Plugin a behavior that listens for subscription messages
config.Pipeline.Register<SubscriptionBehavior.Registration>();
config.RegisterComponents(c => c.ConfigureComponent<SubscriptionBehavior>(DependencyLifecycle.InstancePerCall));
// Important: you need to make sure that the correct ScenarioContext class is available to your endpoints and tests
config.RegisterComponents(r =>
{
r.RegisterSingleton(runDescriptor.ScenarioContext.GetType(), runDescriptor.ScenarioContext);
r.RegisterSingleton(typeof(ScenarioContext), runDescriptor.ScenarioContext);
});
// Call extra custom action if provided
if (configurationBuilderCustomization != null)
{
configurationBuilderCustomization(config);
}
return config;
}
public override Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings)
{
var persistence = configuration.UsePersistence<SqlPersistence>();
persistence.ConnectionBuilder(() => new SqlConnection(ConnectionString));
persistence.TablePrefix("AcceptanceTests");
return Task.FromResult(0);
}
public Result Initialize(RunDescriptor run, EndpointBehaviour endpointBehaviour, IDictionary<Type, string> routingTable, string endpointName)
{
try
{
behaviour = endpointBehaviour;
scenarioContext = run.ScenarioContext;
configuration = ((IEndpointConfigurationFactory)Activator.CreateInstance(endpointBehaviour.EndpointBuilderType)).Get();
configuration.EndpointName = endpointName;
if (!string.IsNullOrEmpty(configuration.CustomMachineName))
{
NServiceBus.Support.RuntimeEnvironment.MachineNameAction = () => configuration.CustomMachineName;
}
//apply custom config settings
endpointBehaviour.CustomConfig.ForEach(customAction => customAction(config));
config = configuration.GetConfiguration(run, routingTable);
if (scenarioContext != null)
{
config.Configurer.RegisterSingleton(scenarioContext.GetType(), scenarioContext);
scenarioContext.ContextPropertyChanged += scenarioContext_ContextPropertyChanged;
}
bus = config.CreateBus();
Configure.Instance.ForInstallationOn<Windows>().Install();
Task.Factory.StartNew(() =>
{
while (!stopped)
{
contextChanged.WaitOne(TimeSpan.FromSeconds(5)); //we spin around each 5 s since the callback mechanism seems to be shaky
lock (behaviour)
{
foreach (var when in behaviour.Whens)
{
if (executedWhens.Contains(when.Id))
continue;
if(when.ExecuteAction(scenarioContext, bus))
executedWhens.Add(when.Id);
}
}
}
});
return Result.Success();
}
catch (Exception ex)
{
Logger.Error("Failed to initalize endpoint " + endpointName, ex);
return Result.Failure(ex);
}
}
public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration, IConfigurationSource configSource)
{
Configure.Serialization.Xml();
return Configure.With(AllAssemblies.Except(Assembly.GetExecutingAssembly().FullName))
.DefaultBuilder()
.UseTransport<Msmq>()
.UnicastBus();
}
static IEnumerable<Type> GetTypesToUse(EndpointConfiguration endpointConfiguration)
{
var assemblies = AssemblyScanner.GetScannableAssemblies().Assemblies
.Where(a =>a != typeof (Message).Assembly).ToList();
var types = assemblies
.SelectMany(a => a.GetTypes())
.Where(
t =>
t.Assembly != Assembly.GetExecutingAssembly() || //exlude all test types by default
t.DeclaringType == endpointConfiguration.BuilderType.DeclaringType || //but include types on the test level
t.DeclaringType == endpointConfiguration.BuilderType); //and the specific types for this endpoint
return types;
}
static IEnumerable<Type> GetTypesToUse(EndpointConfiguration endpointConfiguration)
{
var assemblies = new AssemblyScanner().GetScannableAssemblies();
var types = assemblies.Assemblies
//exclude all test types by default
.Where(a => a != Assembly.GetExecutingAssembly())
.SelectMany(a => a.GetTypes());
types = types.Union(GetNestedTypeRecursive(endpointConfiguration.BuilderType.DeclaringType, endpointConfiguration.BuilderType));
types = types.Union(endpointConfiguration.TypesToInclude);
return types.Where(t => !endpointConfiguration.TypesToExclude.Contains(t)).ToList();
}
public async Task Initialize(RunDescriptor run, EndpointBehavior endpointBehavior,
IDictionary<Type, string> routingTable, string endpointName)
{
try
{
behavior = endpointBehavior;
scenarioContext = run.ScenarioContext;
runSettings = run.Settings;
var endpointConfigurationFactory = (IEndpointConfigurationFactory)Activator.CreateInstance(endpointBehavior.EndpointBuilderType);
endpointConfigurationFactory.ScenarioContext = run.ScenarioContext;
configuration = endpointConfigurationFactory.Get();
configuration.EndpointName = endpointName;
if (!string.IsNullOrEmpty(configuration.CustomMachineName))
{
RuntimeEnvironment.MachineNameAction = () => configuration.CustomMachineName;
}
//apply custom config settings
if (configuration.GetConfiguration == null)
{
throw new Exception($"Missing EndpointSetup<T> in the constructor of {endpointName} endpoint.");
}
endpointConfiguration = await configuration.GetConfiguration(run, routingTable).ConfigureAwait(false);
RegisterInheritanceHierarchyOfContextInSettings(scenarioContext);
endpointBehavior.CustomConfig.ForEach(customAction => customAction(endpointConfiguration, scenarioContext));
if (configuration.SendOnly)
{
endpointConfiguration.SendOnly();
}
startable = await Endpoint.Create(endpointConfiguration).ConfigureAwait(false);
if (!configuration.SendOnly)
{
var transportInfrastructure = endpointConfiguration.GetSettings().Get<TransportInfrastructure>();
scenarioContext.HasNativePubSubSupport = transportInfrastructure.OutboundRoutingPolicy.Publishes == OutboundRoutingType.Multicast;
}
}
catch (Exception ex)
{
Logger.Error("Failed to initialize endpoint " + endpointName, ex);
throw;
}
}
static void SetupLogging(EndpointConfiguration endpointConfiguration)
{
var logDir = ".\\logfiles\\";
Directory.CreateDirectory(logDir);
var logFile = Path.Combine(logDir, endpointConfiguration.EndpointName + ".txt");
if (File.Exists(logFile))
{
File.Delete(logFile);
}
var logLevel = "INFO";
SetLoggingLibrary.Log4Net(null, Log4NetAppenderFactory.CreateRollingFileAppender(logLevel, logFile));
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings)
{
var documentStore = GetDocumentStore();
databaseName = documentStore.DefaultDatabase;
configuration.GetSettings().Set(DefaultDocumentStoreKey, documentStore);
var persistenceExtensions = configuration.UsePersistence<RavenDBPersistence>()
.DoNotSetupDatabasePermissions()
.SetDefaultDocumentStore(documentStore);
configuration.GetSettings().Set(DefaultPersistenceExtensionsKey, persistenceExtensions);
Console.WriteLine("Created '{0}' database", documentStore.DefaultDatabase);
return Task.FromResult(0);
}
public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration,
IConfigurationSource configSource)
{
Configure.ScaleOut(_ => _.UseSingleBrokerQueue());
var configure = Configure.With(GetTypesScopedByTestClass(endpointConfiguration));
var transportToUse = AcceptanceTest.GetTransportIntegrationFromEnvironmentVar();
Action action = transportToUse.OnEndpointShutdown;
SettingsHolder.Set("CleanupTransport", action);
new Bootstrapper(configure: configure);
LogManager.Configuration = SetupLogging(endpointConfiguration);
return Configure.Instance;
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
queueBindings = configuration.GetSettings().Get<QueueBindings>();
var connectionString = settings.Get<string>("Transport.ConnectionString");
var transportConfig = configuration.UseTransport<MsmqTransport>();
transportConfig.ConnectionString(connectionString);
var routingConfig = transportConfig.Routing();
foreach (var publisher in publisherMetadata.Publishers)
{
foreach (var eventType in publisher.Events)
{
routingConfig.RegisterPublisher(eventType, publisher.PublisherName);
}
}
return Task.FromResult(0);
}
public Configure GetConfiguration(RunDescriptor runDescriptor, EndpointConfiguration endpointConfiguration,
IConfigurationSource configSource)
{
var settings = runDescriptor.Settings;
var types = GetTypesToUse(endpointConfiguration);
var transportToUse = AcceptanceTest.GetTransportIntegrationFromEnvironmentVar();
SetupLogging(endpointConfiguration);
Configure.Features.Enable<Sagas>();
Configure.ScaleOut(_ => _.UseSingleBrokerQueue());
AddMoreConfig();
var config = Configure.With(types)
.DefineEndpointName(endpointConfiguration.EndpointName)
.CustomConfigurationSource(configSource)
.DefineBuilder(settings.GetOrNull("Builder"))
.DefineSerializer(settings.GetOrNull("Serializer"))
.DefineTransport(transportToUse)
.InMemorySagaPersister();
if (transportToUse == null || transportToUse is MsmqTransportIntegration || transportToUse is SqlServerTransportIntegration ||
transportToUse is RabbitMqTransportIntegration)
{
config.UseInMemoryTimeoutPersister();
}
if (transportToUse == null || transportToUse is MsmqTransportIntegration || transportToUse is SqlServerTransportIntegration)
{
config.InMemorySubscriptionStorage();
}
config.InMemorySagaPersister();
return config.UnicastBus();
}
public Result Initialize(RunDescriptor run, EndpointBehavior endpointBehavior,
IDictionary<Type, string> routingTable, string endpointName)
{
try
{
behavior = endpointBehavior;
scenarioContext = run.ScenarioContext;
configuration =
((IEndpointConfigurationFactory) Activator.CreateInstance(endpointBehavior.EndpointBuilderType))
.Get();
configuration.EndpointName = endpointName;
if (!string.IsNullOrEmpty(configuration.CustomMachineName))
{
RuntimeEnvironment.MachineNameAction = () => configuration.CustomMachineName;
}
//apply custom config settings
endpointBehavior.CustomConfig.ForEach(customAction => customAction(config));
config = configuration.GetConfiguration(run, routingTable);
if (scenarioContext != null)
{
config.Configurer.RegisterSingleton(scenarioContext.GetType(), scenarioContext);
scenarioContext.ContextPropertyChanged += scenarioContext_ContextPropertyChanged;
}
bus = config.CreateBus();
Configure.Instance.ForInstallationOn<Windows>().Install();
stopToken = stopSource.Token;
if (behavior.Whens.Count == 0)
{
executeWhens = Task.FromResult(0);
}
else
{
executeWhens = Task.Factory.StartNew(async () =>
{
var executedWhens = new List<Guid>();
while (!stopToken.IsCancellationRequested)
{
if (executedWhens.Count == behavior.Whens.Count)
{
break;
}
//we spin around each 5s since the callback mechanism seems to be shaky
await contextChanged.WaitAsync(TimeSpan.FromSeconds(5), stopToken);
if (stopToken.IsCancellationRequested)
break;
foreach (var when in behavior.Whens)
{
if (executedWhens.Contains(when.Id))
{
continue;
}
if (when.ExecuteAction(scenarioContext, bus))
{
executedWhens.Add(when.Id);
}
}
}
}, stopToken).Unwrap();
}
return Result.Success();
}
catch (Exception ex)
{
Logger.Error("Failed to initialize endpoint " + endpointName, ex);
return Result.Failure(ex);
}
}
static IEnumerable<Type> GetTypesScopedByTestClass(EndpointConfiguration endpointConfiguration)
{
var assemblies = new AssemblyScanner().GetScannableAssemblies();
var types = assemblies.Assemblies
//exclude all test types by default
.Where(a => a != Assembly.GetExecutingAssembly())
.Where(a => !a.GetName().Name.StartsWith("ServiceControl.Plugin"))
.SelectMany(a => a.GetTypes());
types = types.Union(GetNestedTypeRecursive(endpointConfiguration.BuilderType.DeclaringType, endpointConfiguration.BuilderType));
types = types.Union(endpointConfiguration.TypesToInclude);
return types;
}
public ScenarioConfigSource(EndpointConfiguration configuration, IDictionary <Type, string> routingTable)
{
this.configuration = configuration;
this.routingTable = routingTable;
}
public Result Initialize(RunDescriptor run, EndpointBehavior endpointBehavior,
IDictionary <Type, string> routingTable, string endpointName)
{
try
{
runDescriptor = run;
behavior = endpointBehavior;
scenarioContext = run.ScenarioContext;
configuration =
((IEndpointConfigurationFactory)Activator.CreateInstance(endpointBehavior.EndpointBuilderType))
.Get();
configuration.EndpointName = endpointName;
if (!string.IsNullOrEmpty(configuration.CustomMachineName))
{
RuntimeEnvironment.MachineNameAction = () => configuration.CustomMachineName;
}
//apply custom config settings
var busConfiguration = configuration.GetConfiguration(run, routingTable);
scenarioContext.ContextPropertyChanged += scenarioContext_ContextPropertyChanged;
endpointBehavior.CustomConfig.ForEach(customAction => customAction(busConfiguration));
if (configuration.SendOnly)
{
sendOnlyBus = Bus.CreateSendOnly(busConfiguration);
}
else
{
bus = Bus.Create(busConfiguration);
var transportDefinition = ((UnicastBus)bus).Settings.Get <TransportDefinition>();
scenarioContext.HasNativePubSubSupport = transportDefinition.HasNativePubSubSupport;
}
executeWhens = Task.Factory.StartNew(() =>
{
while (!stopped)
{
//we spin around each 5s since the callback mechanism seems to be shaky
contextChanged.Wait(TimeSpan.FromSeconds(5));
lock (behavior)
{
foreach (var when in behavior.Whens)
{
if (executedWhens.Contains(when.Id))
{
continue;
}
if (when.ExecuteAction(scenarioContext, bus))
{
executedWhens.Add(when.Id);
}
}
}
}
});
return(Result.Success());
}
catch (Exception ex)
{
Logger.Error("Failed to initialize endpoint " + endpointName, ex);
return(Result.Failure(ex));
}
}
public Result Initialize(RunDescriptor run, EndpointBehavior endpointBehavior,
IDictionary<Type, string> routingTable, string endpointName)
{
try
{
runDescriptor = run;
behavior = endpointBehavior;
scenarioContext = run.ScenarioContext;
configuration =
((IEndpointConfigurationFactory)Activator.CreateInstance(endpointBehavior.EndpointBuilderType))
.Get();
configuration.EndpointName = endpointName;
if (!string.IsNullOrEmpty(configuration.CustomMachineName))
{
RuntimeEnvironment.MachineNameAction = () => configuration.CustomMachineName;
}
//apply custom config settings
var busConfiguration = configuration.GetConfiguration(run, routingTable);
scenarioContext.ContextPropertyChanged += scenarioContext_ContextPropertyChanged;
endpointBehavior.CustomConfig.ForEach(customAction => customAction(busConfiguration));
if (configuration.SendOnly)
{
sendOnlyBus = Bus.CreateSendOnly(busConfiguration);
}
else
{
bus = Bus.Create(busConfiguration);
var transportDefinition = ((UnicastBus)bus).Settings.Get<TransportDefinition>();
scenarioContext.HasNativePubSubSupport = transportDefinition.HasNativePubSubSupport;
}
executeWhens = Task.Factory.StartNew(() =>
{
while (!stopped)
{
//we spin around each 5s since the callback mechanism seems to be shaky
contextChanged.Wait(TimeSpan.FromSeconds(5));
lock (behavior)
{
foreach (var when in behavior.Whens)
{
if (executedWhens.Contains(when.Id))
{
continue;
}
if (when.ExecuteAction(scenarioContext, bus))
{
executedWhens.Add(when.Id);
}
}
}
}
});
return Result.Success();
}
catch (Exception ex)
{
Logger.Error("Failed to initialize endpoint " + endpointName, ex);
return Result.Failure(ex);
}
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings)
{
configuration.UsePersistence<InMemoryPersistence>();
return Task.FromResult(0);
}
public abstract Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings);