diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs index 9aff73e4e83..abf9104e83f 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs @@ -8,16 +8,20 @@ //------------------------------------------------------------------------------ -using NUnit.Framework; using NHibernate.Id.Enhanced; -using System.Collections; +using NHibernate.Test.MultiTenancy; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Forcedtable { using System.Threading.Tasks; - [TestFixture] - public class HiLoForcedTableSequenceTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class HiLoForcedTableSequenceTestAsync : TestCaseWithMultiTenancy { + public HiLoForcedTableSequenceTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Forcedtable.HiLo.hbm.xml" }; } @@ -54,9 +58,9 @@ public async Task TestNormalBoundaryAsync() long expectedId = i + 1; Assert.That(entities[i].Id, Is.EqualTo(expectedId)); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1)); } // now force a "clock over" @@ -64,9 +68,9 @@ public async Task TestNormalBoundaryAsync() await (session.SaveAsync(entities[increment])); Assert.That(entities[optimizer.IncrementSize].Id, Is.EqualTo(optimizer.IncrementSize + 1)); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization + clock-over - Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); // initialization + clock-over - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); // initialization + clock-over + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); await (transaction.CommitAsync()); } @@ -85,4 +89,4 @@ public async Task TestNormalBoundaryAsync() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs index f792da88124..9f5f3a4168a 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs @@ -8,16 +8,20 @@ //------------------------------------------------------------------------------ -using NUnit.Framework; using NHibernate.Id.Enhanced; -using System.Collections; +using NHibernate.Test.MultiTenancy; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Forcedtable { using System.Threading.Tasks; - [TestFixture] - public class PooledForcedTableSequenceTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledForcedTableSequenceTestAsync : TestCaseWithMultiTenancy { + public PooledForcedTableSequenceTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Forcedtable.Pooled.hbm.xml" }; } @@ -55,8 +59,8 @@ public async Task TestNormalBoundaryAsync() Assert.That(entities[i].Id, Is.EqualTo(expectedId)); // NOTE : initialization calls table twice Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" @@ -66,8 +70,8 @@ public async Task TestNormalBoundaryAsync() Assert.That(entities[optimizer.IncrementSize].Id, Is.EqualTo(optimizer.IncrementSize + 1)); // initialization (2) + clock over Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(3)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment*2 + 1)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment*2 + 1)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); await (transaction.CommitAsync()); } @@ -86,4 +90,4 @@ public async Task TestNormalBoundaryAsync() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/OptimizerTests.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/OptimizerTests.cs index e7e5c23fad0..a047e3aec35 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/OptimizerTests.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/OptimizerTests.cs @@ -8,8 +8,8 @@ //------------------------------------------------------------------------------ -using NUnit.Framework; using NHibernate.Id.Enhanced; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced { diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs index cb185e72c6f..4b1606cf330 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs @@ -11,13 +11,18 @@ using System.Collections; using NUnit.Framework; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; namespace NHibernate.Test.IdGen.Enhanced.Sequence { using System.Threading.Tasks; - [TestFixture] - public class HiLoSequenceTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class HiLoSequenceTestAsync : TestCaseWithMultiTenancy { + public HiLoSequenceTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Sequence.HiLo.hbm.xml" }; } @@ -51,18 +56,18 @@ public async Task TestNormalBoundaryAsync() entities[i] = new Entity("" + (i + 1)); await (session.SaveAsync(entities[i])); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); await (session.SaveAsync(entities[increment])); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); await (transaction.CommitAsync()); } @@ -80,4 +85,4 @@ public async Task TestNormalBoundaryAsync() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/PooledSequenceTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/PooledSequenceTest.cs index 7d0d4d11763..1d06ae11d89 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/PooledSequenceTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/PooledSequenceTest.cs @@ -8,16 +8,20 @@ //------------------------------------------------------------------------------ -using System.Collections; -using NUnit.Framework; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Sequence { using System.Threading.Tasks; - [TestFixture] - public class PooledSequenceTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledSequenceTestAsync : TestCaseWithMultiTenancy { + public PooledSequenceTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Sequence.Pooled.hbm.xml" }; } @@ -51,16 +55,16 @@ public async Task TestNormalBoundaryAsync() entities[i] = new Entity("" + (i + 1)); await (session.SaveAsync(entities[i])); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization calls seq twice - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization calls seq twice + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); await (session.SaveAsync(entities[increment])); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(3)); // initialization (2) + clock over - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); await (transaction.CommitAsync()); } @@ -79,4 +83,4 @@ public async Task TestNormalBoundaryAsync() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/SourceMock.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/SourceMock.cs index 0f9615a2ccd..85fc9520c87 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/SourceMock.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/SourceMock.cs @@ -46,4 +46,4 @@ public Task GetNextValueAsync(CancellationToken cancellationToken) } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Table/HiLoTableTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Table/HiLoTableTest.cs index 962460f90e0..2e53c916aea 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Table/HiLoTableTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Table/HiLoTableTest.cs @@ -10,14 +10,19 @@ using System.Collections; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Table { using System.Threading.Tasks; - [TestFixture] - public class HiLoTableTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class HiLoTableTestAsync : TestCaseWithMultiTenancy { + public HiLoTableTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Table.HiLo.hbm.xml" }; } @@ -50,18 +55,18 @@ public async Task TestNormalBoundaryAsync() entities[i] = new Entity("" + (i + 1)); await (s.SaveAsync(entities[i])); Assert.That(generator.TableAccessCount, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); await (s.SaveAsync(entities[increment])); Assert.That(generator.TableAccessCount, Is.EqualTo(2)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo((increment * 2) + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo((increment * 2) + 1)); await (transaction.CommitAsync()); } diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledLoTableTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledLoTableTest.cs index d721443bdd6..af309699513 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledLoTableTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledLoTableTest.cs @@ -10,14 +10,19 @@ using System.Collections; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Table { using System.Threading.Tasks; - [TestFixture] - public class PooledLoTableTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledLoTableTestAsync : TestCaseWithMultiTenancy { + public PooledLoTableTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Table.PooledLo.hbm.xml" }; } @@ -50,16 +55,16 @@ public async Task TestNormalBoundaryAsync() entities[i] = new Entity("" + (i + 1)); await (s.SaveAsync(entities[i])); Assert.That(generator.TableAccessCount, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); await (s.SaveAsync(entities[increment])); Assert.That(generator.TableAccessCount, Is.EqualTo(2)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); await (transaction.CommitAsync()); } diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledTableTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledTableTest.cs index 00c921da834..15be48dccaa 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledTableTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledTableTest.cs @@ -8,16 +8,20 @@ //------------------------------------------------------------------------------ -using System.Collections; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Table { using System.Threading.Tasks; - [TestFixture] - public class PooledTableTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledTableTestAsync : TestCaseWithMultiTenancy { + public PooledTableTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Table.Pooled.hbm.xml" }; } @@ -50,16 +54,16 @@ public async Task TestNormalBoundaryAsync() entities[i] = new Entity("" + (i + 1)); await (s.SaveAsync(entities[i])); Assert.That(generator.TableAccessCount, Is.EqualTo(2)); // initialization calls seq twice - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization calls seq twice + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); await (s.SaveAsync(entities[increment])); Assert.That(generator.TableAccessCount, Is.EqualTo(3)); // initialization (2) + clock over - Assert.That(optimizer.LastSourceValue, Is.EqualTo((increment * 2) + 1)); // initialization (2) + clock over - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo((increment * 2) + 1)); // initialization (2) + clock over + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); await (transaction.CommitAsync()); } diff --git a/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs index c2ba2b1f589..e8647f3858f 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs @@ -1,12 +1,16 @@ -using NUnit.Framework; using NHibernate.Id.Enhanced; -using System.Collections; +using NHibernate.Test.MultiTenancy; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Forcedtable { - [TestFixture] - public class HiLoForcedTableSequenceTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class HiLoForcedTableSequenceTest : TestCaseWithMultiTenancy { + public HiLoForcedTableSequenceTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Forcedtable.HiLo.hbm.xml" }; } @@ -43,9 +47,9 @@ public void TestNormalBoundary() long expectedId = i + 1; Assert.That(entities[i].Id, Is.EqualTo(expectedId)); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1)); } // now force a "clock over" @@ -53,9 +57,9 @@ public void TestNormalBoundary() session.Save(entities[increment]); Assert.That(entities[optimizer.IncrementSize].Id, Is.EqualTo(optimizer.IncrementSize + 1)); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization + clock-over - Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); // initialization + clock-over - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); // initialization + clock-over + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); transaction.Commit(); } @@ -74,4 +78,4 @@ public void TestNormalBoundary() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs index 91839abf07f..39598c9d591 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs @@ -1,12 +1,16 @@ -using NUnit.Framework; using NHibernate.Id.Enhanced; -using System.Collections; +using NHibernate.Test.MultiTenancy; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Forcedtable { - [TestFixture] - public class PooledForcedTableSequenceTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledForcedTableSequenceTest : TestCaseWithMultiTenancy { + public PooledForcedTableSequenceTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Forcedtable.Pooled.hbm.xml" }; } @@ -44,8 +48,8 @@ public void TestNormalBoundary() Assert.That(entities[i].Id, Is.EqualTo(expectedId)); // NOTE : initialization calls table twice Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" @@ -55,8 +59,8 @@ public void TestNormalBoundary() Assert.That(entities[optimizer.IncrementSize].Id, Is.EqualTo(optimizer.IncrementSize + 1)); // initialization (2) + clock over Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(3)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment*2 + 1)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment*2 + 1)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); transaction.Commit(); } @@ -75,4 +79,4 @@ public void TestNormalBoundary() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/IdGen/Enhanced/OptimizerTests.cs b/src/NHibernate.Test/IdGen/Enhanced/OptimizerTests.cs index 8f0fd01986f..90842a1048e 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/OptimizerTests.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/OptimizerTests.cs @@ -1,5 +1,5 @@ -using NUnit.Framework; -using NHibernate.Id.Enhanced; +using NHibernate.Id.Enhanced; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced { diff --git a/src/NHibernate.Test/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs index 3cac164ec72..7cd6161bc02 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs @@ -1,12 +1,17 @@ using System.Collections; using NUnit.Framework; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; namespace NHibernate.Test.IdGen.Enhanced.Sequence { - [TestFixture] - public class HiLoSequenceTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class HiLoSequenceTest : TestCaseWithMultiTenancy { + public HiLoSequenceTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Sequence.HiLo.hbm.xml" }; } @@ -40,18 +45,18 @@ public void TestNormalBoundary() entities[i] = new Entity("" + (i + 1)); session.Save(entities[i]); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); session.Save(entities[increment]); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); transaction.Commit(); } @@ -69,4 +74,4 @@ public void TestNormalBoundary() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/IdGen/Enhanced/Sequence/PooledSequenceTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Sequence/PooledSequenceTest.cs index 3e73cc21a9d..b18c211b7ba 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Sequence/PooledSequenceTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Sequence/PooledSequenceTest.cs @@ -1,12 +1,16 @@ -using System.Collections; -using NUnit.Framework; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Sequence { - [TestFixture] - public class PooledSequenceTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledSequenceTest : TestCaseWithMultiTenancy { + public PooledSequenceTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Sequence.Pooled.hbm.xml" }; } @@ -40,16 +44,16 @@ public void TestNormalBoundary() entities[i] = new Entity("" + (i + 1)); session.Save(entities[i]); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization calls seq twice - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization calls seq twice + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); session.Save(entities[increment]); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(3)); // initialization (2) + clock over - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); transaction.Commit(); } @@ -68,4 +72,4 @@ public void TestNormalBoundary() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/IdGen/Enhanced/SourceMock.cs b/src/NHibernate.Test/IdGen/Enhanced/SourceMock.cs index d7fcce2f9ec..3097d3f3814 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/SourceMock.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/SourceMock.cs @@ -6,15 +6,20 @@ public partial class SourceMock : IAccessCallback { private long _val; private readonly long _initialValue; + private readonly string _tenantId; private readonly int _increment; private int _timesCalled; public SourceMock(long initialValue) : this(initialValue, 1) { } - public SourceMock(long initialValue, int increment) : this(initialValue, increment, 0) { } + public SourceMock(long initialValue, int increment) : this(null, initialValue, increment, 0) { } - public SourceMock(long initialValue, int increment, int timesCalled) + public SourceMock(long initialValue, int increment, int timesCalled): this(null, initialValue, increment, timesCalled) { + } + public SourceMock(string tenantId, long initialValue, int increment, int timesCalled) + { + _tenantId = tenantId; _increment = increment; _timesCalled = timesCalled; @@ -57,6 +62,8 @@ private void InitValue() _val = _initialValue; } + public string GetTenantIdentifier() => _tenantId; + public int TimesCalled { get { return _timesCalled; } @@ -71,4 +78,4 @@ public long CurrentValue } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/IdGen/Enhanced/Table/HiLoTableTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Table/HiLoTableTest.cs index 878252ce3dd..014788d6570 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Table/HiLoTableTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Table/HiLoTableTest.cs @@ -1,12 +1,17 @@ using System.Collections; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Table { - [TestFixture] - public class HiLoTableTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class HiLoTableTest : TestCaseWithMultiTenancy { + public HiLoTableTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Table.HiLo.hbm.xml" }; } @@ -39,18 +44,18 @@ public void TestNormalBoundary() entities[i] = new Entity("" + (i + 1)); s.Save(entities[i]); Assert.That(generator.TableAccessCount, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); s.Save(entities[increment]); Assert.That(generator.TableAccessCount, Is.EqualTo(2)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo((increment * 2) + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo((increment * 2) + 1)); transaction.Commit(); } diff --git a/src/NHibernate.Test/IdGen/Enhanced/Table/PooledLoTableTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Table/PooledLoTableTest.cs index bd5245dbe9a..e56c2fed120 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Table/PooledLoTableTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Table/PooledLoTableTest.cs @@ -1,12 +1,17 @@ using System.Collections; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Table { - [TestFixture] - public class PooledLoTableTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledLoTableTest : TestCaseWithMultiTenancy { + public PooledLoTableTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Table.PooledLo.hbm.xml" }; } @@ -39,16 +44,16 @@ public void TestNormalBoundary() entities[i] = new Entity("" + (i + 1)); s.Save(entities[i]); Assert.That(generator.TableAccessCount, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); s.Save(entities[increment]); Assert.That(generator.TableAccessCount, Is.EqualTo(2)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); transaction.Commit(); } diff --git a/src/NHibernate.Test/IdGen/Enhanced/Table/PooledTableTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Table/PooledTableTest.cs index 3a7ca042514..4f357bc6066 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Table/PooledTableTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Table/PooledTableTest.cs @@ -1,12 +1,16 @@ -using System.Collections; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Table { - [TestFixture] - public class PooledTableTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledTableTest : TestCaseWithMultiTenancy { + public PooledTableTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Table.Pooled.hbm.xml" }; } @@ -39,16 +43,16 @@ public void TestNormalBoundary() entities[i] = new Entity("" + (i + 1)); s.Save(entities[i]); Assert.That(generator.TableAccessCount, Is.EqualTo(2)); // initialization calls seq twice - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization calls seq twice + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); s.Save(entities[increment]); Assert.That(generator.TableAccessCount, Is.EqualTo(3)); // initialization (2) + clock over - Assert.That(optimizer.LastSourceValue, Is.EqualTo((increment * 2) + 1)); // initialization (2) + clock over - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo((increment * 2) + 1)); // initialization (2) + clock over + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); transaction.Commit(); } diff --git a/src/NHibernate.Test/MultiTenancy/TestCaseWithMultiTenancy.cs b/src/NHibernate.Test/MultiTenancy/TestCaseWithMultiTenancy.cs new file mode 100644 index 00000000000..056f3c0ccac --- /dev/null +++ b/src/NHibernate.Test/MultiTenancy/TestCaseWithMultiTenancy.cs @@ -0,0 +1,56 @@ +using System.Data.Common; +using NHibernate.Cfg; +using NHibernate.Dialect; +using NHibernate.Driver; +using NHibernate.MultiTenancy; + +namespace NHibernate.Test.MultiTenancy +{ + public abstract class TestCaseWithMultiTenancy : TestCase + { + protected TestCaseWithMultiTenancy(string tenantIdentifier) + { + TenantIdentifier = tenantIdentifier; + } + + public string TenantIdentifier { get; } + + protected override void Configure(Configuration configuration) + { + if (TenantIdentifier != null) + { + configuration.DataBaseIntegration( + x => + { + x.MultiTenancy = MultiTenancyStrategy.Database; + x.MultiTenancyConnectionProvider(); + }); + } + base.Configure(configuration); + } + + protected override DbConnection OpenConnectionForSchemaExport() + { + return Sfi.Settings.MultiTenancyConnectionProvider + .GetConnectionAccess(GetTenantConfig("defaultTenant"), Sfi).GetConnection(); + } + + private TenantConfiguration GetTenantConfig(string tenantId) + { + return new TestTenantConfiguration(tenantId, IsSqlServerDialect); + } + + protected override ISession OpenSession() + { + if (TenantIdentifier != null) + { + return Sfi.WithOptions().Tenant(new TestTenantConfiguration(TenantIdentifier, IsSqlServerDialect)).OpenSession(); + } + return base.OpenSession(); + } + + //Create extension method for this? + private bool IsSqlServerDialect => Sfi.Dialect is MsSql2000Dialect && !(Sfi.ConnectionProvider.Driver is OdbcDriver); + + } +} diff --git a/src/NHibernate.Test/TestCase.cs b/src/NHibernate.Test/TestCase.cs index c58d819ed64..581459294f8 100644 --- a/src/NHibernate.Test/TestCase.cs +++ b/src/NHibernate.Test/TestCase.cs @@ -21,6 +21,8 @@ using NHibernate.SqlTypes; using NHibernate.Util; using NSubstitute; +using NHibernate.MultiTenancy; +using NHibernate.Test.MultiTenancy; namespace NHibernate.Test { diff --git a/src/NHibernate/Async/Id/Enhanced/IAccessCallback.cs b/src/NHibernate/Async/Id/Enhanced/IAccessCallback.cs index b52c3e524b5..8fbb5c27826 100644 --- a/src/NHibernate/Async/Id/Enhanced/IAccessCallback.cs +++ b/src/NHibernate/Async/Id/Enhanced/IAccessCallback.cs @@ -20,4 +20,4 @@ public partial interface IAccessCallback /// A cancellation token that can be used to cancel the work Task GetNextValueAsync(CancellationToken cancellationToken); } -} \ No newline at end of file +} diff --git a/src/NHibernate/Async/Id/Enhanced/OptimizerFactory.cs b/src/NHibernate/Async/Id/Enhanced/OptimizerFactory.cs index 5ba08f4a31e..84f66d725ce 100644 --- a/src/NHibernate/Async/Id/Enhanced/OptimizerFactory.cs +++ b/src/NHibernate/Async/Id/Enhanced/OptimizerFactory.cs @@ -9,8 +9,8 @@ using System; +using System.Collections.Concurrent; using System.Reflection; -using System.Runtime.CompilerServices; using NHibernate.Util; namespace NHibernate.Id.Enhanced @@ -30,27 +30,29 @@ public override async Task GenerateAsync(IAccessCallback callback, Cance cancellationToken.ThrowIfCancellationRequested(); using (await (_asyncLock.LockAsync()).ConfigureAwait(false)) { - if (_lastSourceValue < 0) + var generationState = _stateStore.LocateGenerationState(callback.GetTenantIdentifier()); + + if (generationState.LastSourceValue < 0) { - _lastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); - while (_lastSourceValue <= 0) + generationState.LastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + while (generationState.LastSourceValue <= 0) { - _lastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + generationState.LastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); } // upperLimit defines the upper end of the bucket values - _upperLimit = (_lastSourceValue * IncrementSize) + 1; + generationState.UpperLimit = (generationState.LastSourceValue * IncrementSize) + 1; // initialize value to the low end of the bucket - _value = _upperLimit - IncrementSize; + generationState.Value = generationState.UpperLimit - IncrementSize; } - else if (_upperLimit <= _value) + else if (generationState.UpperLimit <= generationState.Value) { - _lastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); - _upperLimit = (_lastSourceValue * IncrementSize) + 1; + generationState.LastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + generationState.UpperLimit = (generationState.LastSourceValue * IncrementSize) + 1; } - return Make(_value++); + return Make(generationState.Value++); } } } @@ -106,37 +108,38 @@ public override async Task GenerateAsync(IAccessCallback callback, Cance cancellationToken.ThrowIfCancellationRequested(); using (await (_asyncLock.LockAsync()).ConfigureAwait(false)) { - if (_hiValue < 0) + var generationState = _stateStore.LocateGenerationState(callback.GetTenantIdentifier()); + + if (generationState.HiValue < 0) { - _value = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); - if (_value < 1) + generationState.Value = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + if (generationState.Value < 1) { // unfortunately not really safe to normalize this // to 1 as an initial value like we do the others // because we would not be able to control this if // we are using a sequence... - Log.Info("pooled optimizer source reported [{0}] as the initial value; use of 1 or greater highly recommended", _value); + Log.Info("pooled optimizer source reported [{0}] as the initial value; use of 1 or greater highly recommended", generationState.Value); } - if ((_initialValue == -1 && _value < IncrementSize) || _value == _initialValue) - _hiValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + if ((_initialValue == -1 && generationState.Value < IncrementSize) || generationState.Value == _initialValue) + generationState.HiValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); else { - _hiValue = _value; - _value = _hiValue - IncrementSize; + generationState.HiValue = generationState.Value; + generationState.Value = generationState.HiValue - IncrementSize; } } - else if (_value >= _hiValue) + else if (generationState.Value >= generationState.HiValue) { - _hiValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); - _value = _hiValue - IncrementSize; + generationState.HiValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + generationState.Value = generationState.HiValue - IncrementSize; } - return Make(_value++); + return Make(generationState.Value++); } } } - #endregion #region Nested type: PooledLoOptimizer @@ -149,16 +152,18 @@ public override async Task GenerateAsync(IAccessCallback callback, Cance cancellationToken.ThrowIfCancellationRequested(); using (await (_asyncLock.LockAsync()).ConfigureAwait(false)) { - if (_lastSourceValue < 0 || _value >= (_lastSourceValue + IncrementSize)) + var generationState = _stateStore.LocateGenerationState(callback.GetTenantIdentifier()); + + if (generationState.LastSourceValue < 0 || generationState.Value >= (generationState.LastSourceValue + IncrementSize)) { - _lastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); - _value = _lastSourceValue; + generationState.LastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + generationState.Value = generationState.LastSourceValue; // handle cases where initial-value is less than one (hsqldb for instance). - while (_value < 1) - _value++; + while (generationState.Value < 1) + generationState.Value++; } - return Make(_value++); + return Make(generationState.Value++); } } } diff --git a/src/NHibernate/Async/Id/Enhanced/TableGenerator.cs b/src/NHibernate/Async/Id/Enhanced/TableGenerator.cs index 0ca2de00611..0dd7c2dd019 100644 --- a/src/NHibernate/Async/Id/Enhanced/TableGenerator.cs +++ b/src/NHibernate/Async/Id/Enhanced/TableGenerator.cs @@ -9,16 +9,14 @@ using System; -using System.Data.Common; using System.Collections.Generic; using System.Data; -using System.Runtime.CompilerServices; +using System.Data.Common; +using NHibernate.AdoNet.Util; using NHibernate.Engine; -using NHibernate.Mapping; +using NHibernate.SqlCommand; using NHibernate.Type; using NHibernate.Util; -using NHibernate.SqlCommand; -using NHibernate.AdoNet.Util; namespace NHibernate.Id.Enhanced { @@ -44,7 +42,7 @@ private partial class TableAccessCallback : IAccessCallback public async Task GetNextValueAsync(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); - return Convert.ToInt64(await (owner.DoWorkInNewTransactionAsync(session, cancellationToken)).ConfigureAwait(false)); + return Convert.ToInt64(await (_owner.DoWorkInNewTransactionAsync(_session, cancellationToken)).ConfigureAwait(false)); } #endregion diff --git a/src/NHibernate/Async/Id/SequenceHiLoGenerator.cs b/src/NHibernate/Async/Id/SequenceHiLoGenerator.cs index 75992f456ed..7ed2b4a2ef4 100644 --- a/src/NHibernate/Async/Id/SequenceHiLoGenerator.cs +++ b/src/NHibernate/Async/Id/SequenceHiLoGenerator.cs @@ -10,6 +10,7 @@ using System; using System.Collections; +using System.Collections.Concurrent; using System.Collections.Generic; using System.Runtime.CompilerServices; @@ -39,6 +40,8 @@ public override async Task GenerateAsync(ISessionImplementor session, ob cancellationToken.ThrowIfCancellationRequested(); using (await (_asyncLock.LockAsync()).ConfigureAwait(false)) { + var generationState = _stateStore.LocateGenerationState(session.GetTenantIdentifier()); + if (maxLo < 1) { //keep the behavior consistent even for boundary usages @@ -48,15 +51,15 @@ public override async Task GenerateAsync(ISessionImplementor session, ob return IdentifierGeneratorFactory.CreateNumber(val, returnClass); } - if (lo > maxLo) + if (generationState.Lo > maxLo) { long hival = Convert.ToInt64(await (base.GenerateAsync(session, obj, cancellationToken)).ConfigureAwait(false)); - lo = (hival == 0) ? 1 : 0; - hi = hival * (maxLo + 1); + generationState.Lo = (hival == 0) ? 1 : 0; + generationState.Hi = hival * (maxLo + 1); if (log.IsDebugEnabled()) log.Debug("new hi value: {0}", hival); } - return IdentifierGeneratorFactory.CreateNumber(hi + lo++, returnClass); + return IdentifierGeneratorFactory.CreateNumber(generationState.Hi + generationState.Lo++, returnClass); } } diff --git a/src/NHibernate/Async/Id/TableGenerator.cs b/src/NHibernate/Async/Id/TableGenerator.cs index 3ad468a09be..bc579a777db 100644 --- a/src/NHibernate/Async/Id/TableGenerator.cs +++ b/src/NHibernate/Async/Id/TableGenerator.cs @@ -46,7 +46,7 @@ public virtual async Task GenerateAsync(ISessionImplementor session, obj using (await (_asyncLock.LockAsync()).ConfigureAwait(false)) { // This has to be done using a different connection to the containing - // transaction becase the new hi value must remain valid even if the + // transaction because the new hi value must remain valid even if the // containing transaction rolls back. return await (DoWorkInNewTransactionAsync(session, cancellationToken)).ConfigureAwait(false); } @@ -62,7 +62,7 @@ public override async Task DoWorkInCurrentTransactionAsync(ISessionImple int rows; do { - //the loop ensure atomicitiy of the + //the loop ensures atomicity of the //select + update even for no transaction //or read committed isolation level (needed for .net?) diff --git a/src/NHibernate/Async/Id/TableHiLoGenerator.cs b/src/NHibernate/Async/Id/TableHiLoGenerator.cs index 663733f6b39..760556da853 100644 --- a/src/NHibernate/Async/Id/TableHiLoGenerator.cs +++ b/src/NHibernate/Async/Id/TableHiLoGenerator.cs @@ -16,6 +16,7 @@ using NHibernate.Type; using NHibernate.Util; using System.Collections.Generic; +using System.Collections.Concurrent; namespace NHibernate.Id { @@ -38,6 +39,8 @@ public override async Task GenerateAsync(ISessionImplementor session, ob cancellationToken.ThrowIfCancellationRequested(); using (await (_asyncLock.LockAsync()).ConfigureAwait(false)) { + var generationState = _stateStore.LocateGenerationState(session.GetTenantIdentifier()); + if (maxLo < 1) { //keep the behavior consistent even for boundary usages @@ -46,15 +49,15 @@ public override async Task GenerateAsync(ISessionImplementor session, ob val = Convert.ToInt64(await (base.GenerateAsync(session, obj, cancellationToken)).ConfigureAwait(false)); return IdentifierGeneratorFactory.CreateNumber(val, returnClass); } - if (lo > maxLo) + if (generationState.Lo > maxLo) { long hival = Convert.ToInt64(await (base.GenerateAsync(session, obj, cancellationToken)).ConfigureAwait(false)); - lo = (hival == 0) ? 1 : 0; - hi = hival * (maxLo + 1); + generationState.Lo = (hival == 0) ? 1 : 0; + generationState.Hi = hival * (maxLo + 1); log.Debug("New high value: {0}", hival); } - return IdentifierGeneratorFactory.CreateNumber(hi + lo++, returnClass); + return IdentifierGeneratorFactory.CreateNumber(generationState.Hi + generationState.Lo++, returnClass); } } diff --git a/src/NHibernate/Id/Enhanced/IAccessCallback.cs b/src/NHibernate/Id/Enhanced/IAccessCallback.cs index f072ab68fb8..ec585a2b9c9 100644 --- a/src/NHibernate/Id/Enhanced/IAccessCallback.cs +++ b/src/NHibernate/Id/Enhanced/IAccessCallback.cs @@ -10,5 +10,10 @@ public partial interface IAccessCallback /// Retrieve the next value from the underlying source. /// long GetNextValue(); + + /// + /// Obtain the tenant identifier (multi-tenancy), if one, associated with this callback. + /// + string GetTenantIdentifier(); } -} \ No newline at end of file +} diff --git a/src/NHibernate/Id/Enhanced/OptimizerFactory.cs b/src/NHibernate/Id/Enhanced/OptimizerFactory.cs index 0adf3695551..c54c53fbafe 100644 --- a/src/NHibernate/Id/Enhanced/OptimizerFactory.cs +++ b/src/NHibernate/Id/Enhanced/OptimizerFactory.cs @@ -1,6 +1,6 @@ using System; +using System.Collections.Concurrent; using System.Reflection; -using System.Runtime.CompilerServices; using NHibernate.Util; namespace NHibernate.Id.Enhanced @@ -70,9 +70,9 @@ private static IOptimizer BuildOptimizer(string type, System.Type returnClass, i ConstructorInfo ctor = optimizerClass.GetConstructor(CtorSignature); if (ctor == null) - throw new HibernateException("Optimizer does not have expected contructor"); + throw new HibernateException("Optimizer does not have expected constructor"); - return (IOptimizer)ctor.Invoke(new object[] { returnClass, incrementSize }); + return (IOptimizer) ctor.Invoke(new object[] { returnClass, incrementSize }); } catch (Exception ex) { @@ -89,7 +89,7 @@ public static IOptimizer BuildOptimizer(string type, System.Type returnClass, in IOptimizer optimizer = BuildOptimizer(type, returnClass, incrementSize); if (optimizer is IInitialValueAwareOptimizer) - ((IInitialValueAwareOptimizer)optimizer).InjectInitialValue(explicitInitialValue); + ((IInitialValueAwareOptimizer) optimizer).InjectInitialValue(explicitInitialValue); return optimizer; } @@ -98,10 +98,8 @@ public static IOptimizer BuildOptimizer(string type, System.Type returnClass, in public partial class HiLoOptimizer : OptimizerSupport { - private long _upperLimit; - private long _lastSourceValue = -1; - private long _value; private readonly AsyncLock _asyncLock = new AsyncLock(); + private readonly TenantStateStore _stateStore = new TenantStateStore(); public HiLoOptimizer(System.Type returnClass, int incrementSize) : base(returnClass, incrementSize) { @@ -115,17 +113,24 @@ public HiLoOptimizer(System.Type returnClass, int incrementSize) : base(returnCl } } + public class GenerationState + { + public long LastSourceValue { get; internal set; } = -1; + public long Value { get; internal set; } + public long UpperLimit { get; internal set; } + } + /// /// Exposure intended for testing purposes. /// public override long LastSourceValue { - get { return _lastSourceValue; } + get { return _stateStore.NoTenantGenerationState.LastSourceValue; } } public long LastValue { - get { return _value - 1; } + get { return _stateStore.NoTenantGenerationState.Value - 1; } } /// @@ -133,7 +138,21 @@ public long LastValue /// public long HiValue { - get { return _upperLimit; } + get { return _stateStore.NoTenantGenerationState.UpperLimit; } + } + + public long GetHiValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).UpperLimit; + } + + public long GetLastSourceValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).LastSourceValue; + } + public long GetLastValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).Value - 1; } public override bool ApplyIncrementSizeToSourceValues @@ -145,27 +164,29 @@ public override object Generate(IAccessCallback callback) { using (_asyncLock.Lock()) { - if (_lastSourceValue < 0) + var generationState = _stateStore.LocateGenerationState(callback.GetTenantIdentifier()); + + if (generationState.LastSourceValue < 0) { - _lastSourceValue = callback.GetNextValue(); - while (_lastSourceValue <= 0) + generationState.LastSourceValue = callback.GetNextValue(); + while (generationState.LastSourceValue <= 0) { - _lastSourceValue = callback.GetNextValue(); + generationState.LastSourceValue = callback.GetNextValue(); } // upperLimit defines the upper end of the bucket values - _upperLimit = (_lastSourceValue * IncrementSize) + 1; + generationState.UpperLimit = (generationState.LastSourceValue * IncrementSize) + 1; // initialize value to the low end of the bucket - _value = _upperLimit - IncrementSize; + generationState.Value = generationState.UpperLimit - IncrementSize; } - else if (_upperLimit <= _value) + else if (generationState.UpperLimit <= generationState.Value) { - _lastSourceValue = callback.GetNextValue(); - _upperLimit = (_lastSourceValue * IncrementSize) + 1; + generationState.LastSourceValue = callback.GetNextValue(); + generationState.UpperLimit = (generationState.LastSourceValue * IncrementSize) + 1; } - return Make(_value++); + return Make(generationState.Value++); } } } @@ -268,11 +289,9 @@ protected virtual object Make(long value) /// public partial class PooledOptimizer : OptimizerSupport, IInitialValueAwareOptimizer { - private long _hiValue = -1; - private long _value; private long _initialValue; private readonly AsyncLock _asyncLock = new AsyncLock(); - + private readonly TenantStateStore _stateStore = new TenantStateStore(); public PooledOptimizer(System.Type returnClass, int incrementSize) : base(returnClass, incrementSize) { if (incrementSize < 1) @@ -285,17 +304,28 @@ public PooledOptimizer(System.Type returnClass, int incrementSize) : base(return } } + public class GenerationState + { + public long Value { get; internal set; } + public long HiValue { get; internal set; } = -1; + } + public override long LastSourceValue { - get { return _hiValue; } + get { return _stateStore.NoTenantGenerationState.HiValue; } } /// /// Exposure intended for testing purposes. /// - public long LastValue + /// + public long GetLastSourceValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).HiValue; + } + public long GetLastValue(string tenantIdentifier) { - get { return _value - 1; } + return _stateStore.LocateGenerationState(tenantIdentifier).Value - 1; } public override bool ApplyIncrementSizeToSourceValues @@ -312,46 +342,46 @@ public override object Generate(IAccessCallback callback) { using (_asyncLock.Lock()) { - if (_hiValue < 0) + var generationState = _stateStore.LocateGenerationState(callback.GetTenantIdentifier()); + + if (generationState.HiValue < 0) { - _value = callback.GetNextValue(); - if (_value < 1) + generationState.Value = callback.GetNextValue(); + if (generationState.Value < 1) { // unfortunately not really safe to normalize this // to 1 as an initial value like we do the others // because we would not be able to control this if // we are using a sequence... - Log.Info("pooled optimizer source reported [{0}] as the initial value; use of 1 or greater highly recommended", _value); + Log.Info("pooled optimizer source reported [{0}] as the initial value; use of 1 or greater highly recommended", generationState.Value); } - if ((_initialValue == -1 && _value < IncrementSize) || _value == _initialValue) - _hiValue = callback.GetNextValue(); + if ((_initialValue == -1 && generationState.Value < IncrementSize) || generationState.Value == _initialValue) + generationState.HiValue = callback.GetNextValue(); else { - _hiValue = _value; - _value = _hiValue - IncrementSize; + generationState.HiValue = generationState.Value; + generationState.Value = generationState.HiValue - IncrementSize; } } - else if (_value >= _hiValue) + else if (generationState.Value >= generationState.HiValue) { - _hiValue = callback.GetNextValue(); - _value = _hiValue - IncrementSize; + generationState.HiValue = callback.GetNextValue(); + generationState.Value = generationState.HiValue - IncrementSize; } - return Make(_value++); + return Make(generationState.Value++); } } } - #endregion #region Nested type: PooledLoOptimizer public partial class PooledLoOptimizer : OptimizerSupport { - private long _lastSourceValue = -1; // last value read from db source - private long _value; // the current generator value private readonly AsyncLock _asyncLock = new AsyncLock(); + private readonly TenantStateStore _stateStore = new TenantStateStore(); public PooledLoOptimizer(System.Type returnClass, int incrementSize) : base(returnClass, incrementSize) { @@ -365,26 +395,35 @@ public PooledLoOptimizer(System.Type returnClass, int incrementSize) : base(retu } } + public class GenerationState + { + public long LastSourceValue { get; internal set; } = -1; + public long Value { get; internal set; } + } + public override object Generate(IAccessCallback callback) { using (_asyncLock.Lock()) { - if (_lastSourceValue < 0 || _value >= (_lastSourceValue + IncrementSize)) + var generationState = _stateStore.LocateGenerationState(callback.GetTenantIdentifier()); + + if (generationState.LastSourceValue < 0 || generationState.Value >= (generationState.LastSourceValue + IncrementSize)) { - _lastSourceValue = callback.GetNextValue(); - _value = _lastSourceValue; + generationState.LastSourceValue = callback.GetNextValue(); + generationState.Value = generationState.LastSourceValue; // handle cases where initial-value is less than one (hsqldb for instance). - while (_value < 1) - _value++; + while (generationState.Value < 1) + generationState.Value++; } - return Make(_value++); + return Make(generationState.Value++); } } + public override long LastSourceValue { - get { return _lastSourceValue; } + get { return _stateStore.NoTenantGenerationState.LastSourceValue; } } public override bool ApplyIncrementSizeToSourceValues @@ -397,7 +436,17 @@ public override bool ApplyIncrementSizeToSourceValues /// public long LastValue { - get { return _value - 1; } + get { return _stateStore.NoTenantGenerationState.Value - 1; } + } + + public long GetLastSourceValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).LastSourceValue; + } + + public long GetLastValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).Value - 1; } } diff --git a/src/NHibernate/Id/Enhanced/SequenceStructure.cs b/src/NHibernate/Id/Enhanced/SequenceStructure.cs index 50d70e54964..b035158eba5 100644 --- a/src/NHibernate/Id/Enhanced/SequenceStructure.cs +++ b/src/NHibernate/Id/Enhanced/SequenceStructure.cs @@ -136,6 +136,8 @@ public virtual long GetNextValue() } } + public string GetTenantIdentifier() => _session.GetTenantIdentifier(); + #endregion } diff --git a/src/NHibernate/Id/Enhanced/TableGenerator.cs b/src/NHibernate/Id/Enhanced/TableGenerator.cs index 60a287db13f..fc6148fee5f 100644 --- a/src/NHibernate/Id/Enhanced/TableGenerator.cs +++ b/src/NHibernate/Id/Enhanced/TableGenerator.cs @@ -1,14 +1,12 @@ using System; -using System.Data.Common; using System.Collections.Generic; using System.Data; -using System.Runtime.CompilerServices; +using System.Data.Common; +using NHibernate.AdoNet.Util; using NHibernate.Engine; -using NHibernate.Mapping; +using NHibernate.SqlCommand; using NHibernate.Type; using NHibernate.Util; -using NHibernate.SqlCommand; -using NHibernate.AdoNet.Util; namespace NHibernate.Id.Enhanced { @@ -389,22 +387,24 @@ public virtual object Generate(ISessionImplementor session, object obj) private partial class TableAccessCallback : IAccessCallback { - private TableGenerator owner; - private readonly ISessionImplementor session; + private TableGenerator _owner; + private readonly ISessionImplementor _session; public TableAccessCallback(ISessionImplementor session, TableGenerator owner) { - this.session = session; - this.owner = owner; + _session = session; + _owner = owner; } #region IAccessCallback Members public long GetNextValue() { - return Convert.ToInt64(owner.DoWorkInNewTransaction(session)); + return Convert.ToInt64(_owner.DoWorkInNewTransaction(_session)); } + public string GetTenantIdentifier() => _session.GetTenantIdentifier(); + #endregion } diff --git a/src/NHibernate/Id/Enhanced/TableStructure.cs b/src/NHibernate/Id/Enhanced/TableStructure.cs index 82c36b43a65..bc59e8e081b 100644 --- a/src/NHibernate/Id/Enhanced/TableStructure.cs +++ b/src/NHibernate/Id/Enhanced/TableStructure.cs @@ -181,6 +181,8 @@ public virtual long GetNextValue() return Convert.ToInt64(_owner.DoWorkInNewTransaction(_session)); } + public string GetTenantIdentifier() => _session.GetTenantIdentifier(); + #endregion } diff --git a/src/NHibernate/Id/SequenceHiLoGenerator.cs b/src/NHibernate/Id/SequenceHiLoGenerator.cs index 2d9fca0b85b..475027dde93 100644 --- a/src/NHibernate/Id/SequenceHiLoGenerator.cs +++ b/src/NHibernate/Id/SequenceHiLoGenerator.cs @@ -1,5 +1,6 @@ using System; using System.Collections; +using System.Collections.Concurrent; using System.Collections.Generic; using System.Runtime.CompilerServices; @@ -29,7 +30,7 @@ namespace NHibernate.Id ///

///

/// The user may specify a max_lo value to determine how often new hi values are - /// fetched. If sequences are not avaliable, TableHiLoGenerator might be an + /// fetched. If sequences are not available, TableHiLoGenerator might be an /// alternative. ///

/// @@ -43,11 +44,16 @@ public partial class SequenceHiLoGenerator : SequenceGenerator public const string MaxLo = "max_lo"; private int maxLo; - private int lo; - private long hi; private System.Type returnClass; + private TenantStateStore _stateStore; private readonly AsyncLock _asyncLock = new AsyncLock(); + private class GenerationState + { + public long Lo { get; internal set; } + public long Hi { get; internal set; } + } + #region IConfigurable Members /// @@ -61,8 +67,8 @@ public override void Configure(IType type, IDictionary parms, Di { base.Configure(type, parms, dialect); maxLo = PropertiesHelper.GetInt32(MaxLo, parms, 9); - lo = maxLo + 1; // so we "clock over" on the first invocation returnClass = type.ReturnedClass; + _stateStore = new TenantStateStore(state => state.Lo = maxLo + 1);// so we "clock over" on the first invocation } #endregion @@ -80,6 +86,8 @@ public override object Generate(ISessionImplementor session, object obj) { using (_asyncLock.Lock()) { + var generationState = _stateStore.LocateGenerationState(session.GetTenantIdentifier()); + if (maxLo < 1) { //keep the behavior consistent even for boundary usages @@ -89,15 +97,15 @@ public override object Generate(ISessionImplementor session, object obj) return IdentifierGeneratorFactory.CreateNumber(val, returnClass); } - if (lo > maxLo) + if (generationState.Lo > maxLo) { long hival = Convert.ToInt64(base.Generate(session, obj)); - lo = (hival == 0) ? 1 : 0; - hi = hival * (maxLo + 1); + generationState.Lo = (hival == 0) ? 1 : 0; + generationState.Hi = hival * (maxLo + 1); if (log.IsDebugEnabled()) log.Debug("new hi value: {0}", hival); } - return IdentifierGeneratorFactory.CreateNumber(hi + lo++, returnClass); + return IdentifierGeneratorFactory.CreateNumber(generationState.Hi + generationState.Lo++, returnClass); } } diff --git a/src/NHibernate/Id/TableGenerator.cs b/src/NHibernate/Id/TableGenerator.cs index 09180687efc..3fbd16e4015 100644 --- a/src/NHibernate/Id/TableGenerator.cs +++ b/src/NHibernate/Id/TableGenerator.cs @@ -157,7 +157,7 @@ public virtual object Generate(ISessionImplementor session, object obj) using (_asyncLock.Lock()) { // This has to be done using a different connection to the containing - // transaction becase the new hi value must remain valid even if the + // transaction because the new hi value must remain valid even if the // containing transaction rolls back. return DoWorkInNewTransaction(session); } @@ -220,7 +220,7 @@ public override object DoWorkInCurrentTransaction(ISessionImplementor session, D int rows; do { - //the loop ensure atomicitiy of the + //the loop ensures atomicity of the //select + update even for no transaction //or read committed isolation level (needed for .net?) diff --git a/src/NHibernate/Id/TableHiLoGenerator.cs b/src/NHibernate/Id/TableHiLoGenerator.cs index c64de1d3323..2ab763bf78e 100644 --- a/src/NHibernate/Id/TableHiLoGenerator.cs +++ b/src/NHibernate/Id/TableHiLoGenerator.cs @@ -6,6 +6,7 @@ using NHibernate.Type; using NHibernate.Util; using System.Collections.Generic; +using System.Collections.Concurrent; namespace NHibernate.Id { @@ -48,12 +49,17 @@ public partial class TableHiLoGenerator : TableGenerator /// public const string MaxLo = "max_lo"; - private long hi; - private long lo; private long maxLo; private System.Type returnClass; + private TenantStateStore _stateStore; private readonly AsyncLock _asyncLock = new AsyncLock(); + private class GenerationState + { + public long Lo { get; internal set; } + public long Hi { get; internal set; } + } + #region IConfigurable Members /// @@ -67,8 +73,8 @@ public override void Configure(IType type, IDictionary parms, Di { base.Configure(type, parms, dialect); maxLo = PropertiesHelper.GetInt64(MaxLo, parms, Int16.MaxValue); - lo = maxLo + 1; // so we "clock over" on the first invocation returnClass = type.ReturnedClass; + _stateStore = new TenantStateStore(state => state.Lo = maxLo + 1);// so we "clock over" on the first invocation } #endregion @@ -85,6 +91,8 @@ public override object Generate(ISessionImplementor session, object obj) { using (_asyncLock.Lock()) { + var generationState = _stateStore.LocateGenerationState(session.GetTenantIdentifier()); + if (maxLo < 1) { //keep the behavior consistent even for boundary usages @@ -93,18 +101,61 @@ public override object Generate(ISessionImplementor session, object obj) val = Convert.ToInt64(base.Generate(session, obj)); return IdentifierGeneratorFactory.CreateNumber(val, returnClass); } - if (lo > maxLo) + if (generationState.Lo > maxLo) { long hival = Convert.ToInt64(base.Generate(session, obj)); - lo = (hival == 0) ? 1 : 0; - hi = hival * (maxLo + 1); + generationState.Lo = (hival == 0) ? 1 : 0; + generationState.Hi = hival * (maxLo + 1); log.Debug("New high value: {0}", hival); } - return IdentifierGeneratorFactory.CreateNumber(hi + lo++, returnClass); + return IdentifierGeneratorFactory.CreateNumber(generationState.Hi + generationState.Lo++, returnClass); } } #endregion } + + internal class TenantStateStore where TState : new() + { + private TState _noTenantState; + private Action _initializer; + private readonly Lazy> _tenantSpecificState = new Lazy>(() => new ConcurrentDictionary()); + + public TenantStateStore(Action initializer) + { + _initializer = initializer; + } + + public TenantStateStore() + { + } + + internal TState LocateGenerationState(string tenantIdentifier) + { + if (tenantIdentifier == null) + { + if (_noTenantState == null) + { + _noTenantState = CreateNewState(); + } + return _noTenantState; + } + else + { + return _tenantSpecificState.Value.GetOrAdd(tenantIdentifier, _ => CreateNewState()); + } + } + + internal TState NoTenantGenerationState => _noTenantState ?? + throw new HibernateException("Could not locate previous generation state for no-tenant"); + + + private TState CreateNewState() + { + var state = new TState(); + _initializer?.Invoke(state); + return state; + } + } }