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