public void ConfigurePersistence(PersistenceExtensions <SqlPersistence> persistence)
{
persistence.TablePrefix("");
var subscriptions = persistence.SubscriptionSettings();
subscriptions.CacheFor(TimeSpan.FromMinutes(1));
}
public static EndpointConfiguration CreateCommonConfiguration(string name)
{
string connectionString = @"Server=192.168.0.114;Database=ServiceControlSql;User Id=sa;Password=GQI1qNeq0oEHlL;";
EndpointConfiguration cfg = new EndpointConfiguration(name);
PersistenceExtensions <SqlPersistence> persistence = cfg.UsePersistence <SqlPersistence>();
TransportExtensions <SqlServerTransport> transport = cfg.UseTransport <SqlServerTransport>();
SerializationExtensions <NewtonsoftSerializer> ser = cfg.UseSerialization <NewtonsoftSerializer>();
cfg.AuditSagaStateChanges(serviceControlQueue: "Particular.ServiceControl.Sql");
cfg.AuditProcessedMessagesTo("audit");
cfg.SendFailedMessagesTo("error");
cfg.EnableInstallers();
cfg.DefineCriticalErrorAction(OnCriticalError);
persistence.SqlDialect <SqlDialect.MsSqlServer>();
persistence.ConnectionBuilder(() => new SqlConnection(connectionString));
persistence.SubscriptionSettings().DisableCache();
transport.ConnectionString(connectionString);
transport.Transactions(TransportTransactionMode.SendsAtomicWithReceive);
transport.Routing().ApplyRouting();
RecoverabilitySettings recoverabilityConfig = cfg.Recoverability();
recoverabilityConfig.Immediate(delegate(ImmediateRetriesSettings config)
{
config.NumberOfRetries(3);
});
recoverabilityConfig.Delayed(delegate(DelayedRetriesSettings config)
{
config.NumberOfRetries(3);
});
return(cfg);
}
/// <summary>
/// Configures the queue used to store subscriptions.
/// </summary>
/// <param name="persistenceExtensions">The settings to extend.</param>
/// <param name="queue">The queue name.</param>
public static void SubscriptionQueue(this PersistenceExtensions <MsmqPersistence> persistenceExtensions, string queue)
{
Guard.AgainstNull(nameof(persistenceExtensions), persistenceExtensions);
Guard.AgainstNull(nameof(queue), queue);
persistenceExtensions.Settings.Set(msmqPersistenceQueueConfigurationKey, queue);
}
public void Persist_TypeOfIOperableOnlyNotIDeclaration_ThrowsException()
{
var operableOnly = Substitute.For <IOperable <MyClass> >();
{
Should.Throw <ArgumentException>(() => PersistenceExtensions.Persist(operableOnly));
}
}
public static void HandleEvent(Event @event)
{
IEventEmitter eventEmitter = DIExtensions.Container.GetInstance <IEventEmitter>();
eventEmitter.EmitEvent(@event);
PersistenceExtensions.OpenTransaction();
DIExtensions.Container.GetInstance <EventDispatcher>().DispatchEvents();
PersistenceExtensions.CommitTransaction();
}
public void SetConnectionString(PersistenceExtensions <MongoDBPersistence> config)
{
config.SetConnectionString("mongodb://ultratinef:27017");
config.GetSettings()
.Get <string>(MongoPersistenceConstants.ConnectionStringKey)
.Should()
.Be("mongodb://ultratinef:27017");
config.GetSettings().HasSetting(MongoPersistenceConstants.DatabaseNameKey).Should().BeFalse();
}
public void SetDatabaseName(PersistenceExtensions <MongoDBPersistence> config)
{
config.SetDatabaseName("MyDatabase");
config.GetSettings()
.Get <string>(MongoPersistenceConstants.DatabaseNameKey)
.Should()
.Be("MyDatabase");
config.GetSettings().HasSetting(MongoPersistenceConstants.ConnectionStringKey).Should().BeFalse();
}
public void Should_have_configured_storage_maxsize()
{
var settings = new SettingsHolder();
var persistenceSettings = new PersistenceExtensions <InMemoryPersistence>(settings);
#pragma warning disable 0618
persistenceSettings.GatewayDeduplicationCacheSize(42);
Assert.AreEqual(42, settings.Get <int>(InMemoryGatewayPersistence.MaxSizeKey));
#pragma warning restore 0618
}
/// <summary>
/// The set database name.
/// </summary>
/// <param name="config">
/// The config.
/// </param>
/// <param name="databaseName">
/// The database name.
/// </param>
/// <returns>
/// The <see cref="PersistenceExtensions"/>.
/// </returns>
public static PersistenceExtensions <MongoDBPersistence> SetDatabaseName(
this PersistenceExtensions <MongoDBPersistence> config,
string databaseName)
{
Contract.Requires <ArgumentNullException>(config != null, "config != null");
Contract.Requires <ArgumentNullException>(databaseName != null, "databaseName != null");
Contract.Ensures(Contract.Result <PersistenceExtensions <MongoDBPersistence> >() != null);
config.GetSettings().Set(MongoPersistenceConstants.DatabaseNameKey, databaseName);
return(config);
}
/// <summary>
/// The set connection string.
/// </summary>
/// <param name="config">
/// The config.
/// </param>
/// <param name="connectionString">
/// The database name.
/// </param>
/// <returns>
/// The <see cref="PersistenceExtensions"/>.
/// </returns>
public static PersistenceExtensions <MongoDBPersistence> SetConnectionString(
this PersistenceExtensions <MongoDBPersistence> config,
string connectionString)
{
Contract.Requires <ArgumentNullException>(config != null, "config != null");
Contract.Requires <ArgumentNullException>(connectionString != null, "connectionString != null");
Contract.Ensures(Contract.Result <PersistenceExtensions <MongoDBPersistence> >() != null);
config.GetSettings().Set(MongoPersistenceConstants.ConnectionStringKey, connectionString);
return(config);
}
public void Customize(IFixture fixture)
{
var settings = new SettingsHolder();
settings.Set("NServiceBus.Routing.EndpointName", "UnitTests");
var config = new PersistenceExtensions <MongoDBPersistence>(settings);
fixture.Register(() => settings);
fixture.Register(() => config);
fixture.Customize <TimeoutData>(
c => c.With(t => t.OwningTimeoutManager, config.GetSettings().EndpointName()));
}
public void ShouldBeAbleToPersistUsingListBuilder()
{
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.Build()).Return(theList);
persistenceService.Expect(x => x.Create(theList));
}
BuilderSetup.SetPersistenceService(persistenceService);
using (mocks.Playback())
{
PersistenceExtensions.Persist(listBuilderImpl);
}
}
public void Persist_TypeOfIOperableOnlyNotIDeclaration_ThrowsException()
{
var operableOnly = mocks.DynamicMock <IOperable <MyClass> >();
using (mocks.Record())
{}
using (mocks.Playback())
{
// TODO FIX
#if !SILVERLIGHT
Assert.Throws <ArgumentException>(() => PersistenceExtensions.Persist(operableOnly));
#endif
}
}
public void Should_have_configured_maxsize()
{
var feature = new InMemoryGatewayPersistence();
var settings = new SettingsHolder();
var container = new CommonObjectBuilder(new LightInjectObjectBuilder());
var persistenceSettings = new PersistenceExtensions <InMemoryPersistence>(settings);
persistenceSettings.GatewayDeduplicationCacheSize(42);
feature.Setup(new FeatureConfigurationContext(settings, container, null, null, null));
var implementation = (InMemoryGatewayDeduplication)container.Build <IDeduplicateMessages>();
Assert.AreEqual(42, implementation.maxSize);
}
public void ShouldBeAbleToPersistFromADeclaration()
{
using (mocks.Record())
{
listBuilderImpl.Expect(x => x.Build()).Return(theList);
persistenceService.Expect(x => x.Create(theList));
((IDeclaration <MyClass>)operable).Expect(x => x.ListBuilderImpl).Return(listBuilderImpl);
}
BuilderSetup.SetPersistenceService(persistenceService);
using (mocks.Playback())
{
PersistenceExtensions.Persist(operable);
}
}
public void ShouldBeAbleToPersistUsingListBuilder()
{
var builderSetup = new BuilderSettings();
{
listBuilderImpl.BuilderSettings.Returns(builderSetup);
listBuilderImpl.Build().Returns(theList);
persistenceService.Create(theList);
}
{
builderSetup.SetPersistenceService(persistenceService);
PersistenceExtensions.Persist(listBuilderImpl);
}
}
public void ShouldBeAbleToPersistUsingSingleObjectBuilder()
{
var obj = new MyClass();
using (mocks.Record())
{
singleObjectBuilder.Expect(x => x.Build()).Return(obj);
persistenceService.Expect(x => x.Create(obj));
}
BuilderSetup.SetPersistenceService(persistenceService);
using (mocks.Playback())
{
PersistenceExtensions.Persist(singleObjectBuilder);
}
}
public void ShouldBeAbleToPersistFromADeclaration()
{
var builderSetup = new BuilderSettings();
{
listBuilderImpl.BuilderSettings.Returns(builderSetup);
listBuilderImpl.Build().Returns(theList);
listBuilderImpl.BuilderSettings.Returns(builderSetup);
persistenceService.Create(theList);
((IDeclaration <MyClass>)operable).ListBuilderImpl.Returns(listBuilderImpl);
}
{
builderSetup.SetPersistenceService(persistenceService);
PersistenceExtensions.Persist(operable);
}
}
public void ShouldBeAbleToPersistUsingListBuilder()
{
var builderSetup = new BuilderSettings();
using (mocks.Record())
{
listBuilderImpl.Stub(x => x.BuilderSettings).Return(builderSetup);
listBuilderImpl.Expect(x => x.Build()).Return(theList);
persistenceService.Expect(x => x.Create(theList));
}
using (mocks.Playback())
{
builderSetup.SetPersistenceService(persistenceService);
PersistenceExtensions.Persist(listBuilderImpl);
}
}
public void ShouldBeAbleToPersistUsingSingleObjectBuilder()
{
var builderSetup = new BuilderSettings();
var obj = new MyClass();
{
singleObjectBuilder.BuilderSettings.Returns(builderSetup);
singleObjectBuilder.Build().Returns(obj);
persistenceService.Create(obj);
}
{
builderSetup.SetPersistenceService(persistenceService);
PersistenceExtensions.Persist(singleObjectBuilder);
}
}
/// <summary>
/// Enables Subscription Storage to use caching.
/// </summary>
/// <param name="persistenceConfiguration"></param>
/// <param name="expiration">The period of time to cache subscriptions list for.</param>
public static PersistenceExtensions <NHibernatePersistence> EnableCachingForSubscriptionStorage(this PersistenceExtensions <NHibernatePersistence> persistenceConfiguration, TimeSpan expiration)
{
persistenceConfiguration.GetSettings().Set(NHibernateSubscriptionStorage.CacheExpirationSettingsKey, expiration);
return(persistenceConfiguration);
}
/// <summary>
/// Configures Subscription Storage to use the <paramref name="configuration"/>.
/// </summary>
/// <param name="persistenceConfiguration"></param>
/// <param name="configuration">The <see cref="Configuration"/> object.</param>
public static PersistenceExtensions <NHibernatePersistence> UseSubscriptionStorageConfiguration(this PersistenceExtensions <NHibernatePersistence> persistenceConfiguration, Configuration configuration)
{
persistenceConfiguration.GetSettings().Set("NHibernate.Subscriptions.Configuration", configuration);
return(persistenceConfiguration);
}
/// <summary>
/// Disables automatic schema update.
/// </summary>
/// <param name="persistenceConfiguration"></param>
public static PersistenceExtensions <NHibernatePersistence> DisableSubscriptionStorageSchemaUpdate(this PersistenceExtensions <NHibernatePersistence> persistenceConfiguration)
{
persistenceConfiguration.GetSettings().Set(NHibernateSubscriptionStorage.AutoupdateschemaSettingsKey, false);
return(persistenceConfiguration);
}
public static PersistenceExtensions <RavenDBPersistence> DoNotUseLegacyConventionsWhichIsOnlySafeForNewEndpoints(this PersistenceExtensions <RavenDBPersistence> config)
{
throw new NotImplementedException();
}
/// <summary>
/// Configures Subscription Storage to use the <paramref name="configuration"/>.
/// </summary>
/// <param name="persistenceConfiguration"></param>
/// <param name="configuration">The <see cref="Configuration"/> object.</param>
public static PersistenceExtensions <NHibernatePersistence> UseGatewayDeduplicationConfiguration(this PersistenceExtensions <NHibernatePersistence> persistenceConfiguration, Configuration configuration)
{
persistenceConfiguration.GetSettings().Set("NHibernate.GatewayDeduplication.Configuration", configuration);
return(persistenceConfiguration);
}
public static PersistenceExtensions <RavenDBPersistence> ResetDocumentStoreSettings(this PersistenceExtensions <RavenDBPersistence> cfg, out TestDatabaseInfo dbInfo)
{
var settings = cfg.GetSettings();
var docStore = ConfigureEndpointRavenDBPersistence.GetDefaultDocumentStore(settings);
settings.Set("RavenDbDocumentStore", null);
dbInfo = new TestDatabaseInfo
{
Urls = docStore.Urls,
Database = docStore.Database
};
return(cfg);
}
/// <summary>
/// Disables automatic schema update.
/// </summary>
/// <param name="persistenceConfiguration"></param>
public static PersistenceExtensions <NHibernatePersistence> DisableGatewayDeduplicationSchemaUpdate(this PersistenceExtensions <NHibernatePersistence> persistenceConfiguration)
{
persistenceConfiguration.GetSettings().Set("NHibernate.GatewayDeduplication.AutoUpdateSchema", false);
return(persistenceConfiguration);
}
/// <summary>
/// Configures the given document store to be used when storing sagas
/// </summary>
/// <param name="cfg">Object to attach to</param>
/// <param name="documentStore">The document store to be used</param>
public static PersistenceExtensions <MartenPersistence> UseDocumentStoreForSagas(this PersistenceExtensions <MartenPersistence> cfg, IDocumentStore documentStore)
{
DocumentStoreManager.SetDocumentStore <StorageType.Sagas>(cfg.GetSettings(), documentStore);
return(cfg);
}
public static void UseStorage(this PersistenceExtensions <TestingInMemoryPersistence> extensions, TestingInMemorySubscriptionStorage storageInstance)
{
extensions.GetSettings().Set("InMemoryPersistence.StorageInstance", storageInstance);
}
/// <summary>
/// Configures the given document store to be used when storing sagas
/// </summary>
/// <param name="cfg">Object to attach to</param>
/// <param name="storeCreator">A Func that will create the document store on NServiceBus initialization.</param>
public static PersistenceExtensions <MartenPersistence> UseDocumentStoreForSagas(this PersistenceExtensions <MartenPersistence> cfg, Func <ReadOnlySettings, IDocumentStore> storeCreator)
{
DocumentStoreManager.SetDocumentStore <StorageType.Sagas>(cfg.GetSettings(), storeCreator);
return(cfg);
}