diff --git a/Directory.Build.props b/Directory.Build.props index 5ff9fc2..40941ee 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -58,17 +58,17 @@ 15.7.179 2.8.2 - 2.1.1 - 2.1.1 - 2.1.1 - 2.1.1 - 2.1.1 - 2.0.0 - 2.0.0 - 2.1.1 - 2.1.1 - 2.1.0 - 2.1.0 + 3.0.0 + 3.0.0 + 3.0.0 + 3.0.0 + 3.0.0 + 3.0.0 + 3.0.0 + 3.0.0 + 3.0.0 + 3.0.0 + 3.0.0 2.4.0 2.2.1 @@ -104,7 +104,7 @@ 2.3.1 2.4.1 2.2.2 - 3.0.0-beta* + 3.4.2 2.7.6 diff --git a/src/Orleans.Indexing/Core/Utils/ApplicationPartsIndexableGrainLoader.cs b/src/Orleans.Indexing/Core/Utils/ApplicationPartsIndexableGrainLoader.cs index 4a0dfb7..0081ad1 100644 --- a/src/Orleans.Indexing/Core/Utils/ApplicationPartsIndexableGrainLoader.cs +++ b/src/Orleans.Indexing/Core/Utils/ApplicationPartsIndexableGrainLoader.cs @@ -50,7 +50,7 @@ internal IndexRegistry CreateIndexRegistry() /// registered to the IServiceCollection before Silo construction and the rest of Index creation requires the IServiceProvider which /// is created as part of Silo construction. /// An index registry for the silo. - internal static void RegisterGrainServices(HostBuilderContext context, IServiceCollection services, IndexingOptions indexingOptions) + internal static void RegisterGrainServices(Microsoft.Extensions.Hosting.HostBuilderContext context, IServiceCollection services, IndexingOptions indexingOptions) { var indexedClasses = new HashSet(); var indexedInterfaces = new HashSet(); @@ -189,7 +189,7 @@ bool isInDict(string propName) foreach (var indexableBaseInterface in indexableBaseInterfaces) { - // ... and its generic argument is a class (TProperties)... + // ... and its generic argument is a class (TProperties)... var propertiesClassType = indexableBaseInterface.GetGenericArguments()[0]; if (propertiesClassType.GetTypeInfo().IsClass) { diff --git a/src/Orleans.Indexing/Extensions/PersistentStateIndexExtensions.cs b/src/Orleans.Indexing/Extensions/PersistentStateIndexExtensions.cs new file mode 100644 index 0000000..cd7650d --- /dev/null +++ b/src/Orleans.Indexing/Extensions/PersistentStateIndexExtensions.cs @@ -0,0 +1,32 @@ +using System.Threading.Tasks; +using Orleans.Runtime; + +namespace Orleans.Indexing +{ + + public static class PersistentStateIndexExtensions + { + + public static Task WriteIndexAsync(this IPersistentState state) + { + return Task.CompletedTask; + } + + public static Task ClearIndexAsync(this IPersistentState state) + { + return Task.CompletedTask; + } + + public static Task WriteActiveIndexAsync(this IPersistentState state) + { + return Task.CompletedTask; + } + + public static Task ClearActiveIndexAsync(this IPersistentState state) + { + return Task.CompletedTask; + } + + } + +} \ No newline at end of file diff --git a/src/Orleans.Indexing/Hosting/SiloBuilderExtensions.cs b/src/Orleans.Indexing/Hosting/SiloBuilderExtensions.cs index bb74858..623d5f1 100644 --- a/src/Orleans.Indexing/Hosting/SiloBuilderExtensions.cs +++ b/src/Orleans.Indexing/Hosting/SiloBuilderExtensions.cs @@ -14,9 +14,11 @@ public static class SiloBuilderExtensions /// /// Configure silo to use indexing using a configure action. /// - public static ISiloHostBuilder UseIndexing(this ISiloHostBuilder builder, Action configureOptions = null) + public static ISiloBuilder UseIndexing(this ISiloBuilder builder, Action configureOptions = null) { + // This is necessary to get the configured NumWorkflowQueuesPerInterface for IndexFactory.RegisterIndexWorkflowQueueGrainServices. + var indexingOptions = new IndexingOptions(); configureOptions?.Invoke(indexingOptions); @@ -28,7 +30,7 @@ public static ISiloHostBuilder UseIndexing(this ISiloHostBuilder builder, Action .AddMemoryGrainStorage(IndexingConstants.MEMORY_STORAGE_PROVIDER_NAME) .ConfigureApplicationParts(parts => parts.AddFrameworkPart(typeof(SiloBuilderExtensions).Assembly)) .ConfigureServices(services => services.UseIndexing(indexingOptions)) - .ConfigureServices((context, services) => ApplicationPartsIndexableGrainLoader.RegisterGrainServices(context, services, indexingOptions)) + //.ConfigureServices((context, services) => ApplicationPartsIndexableGrainLoader.RegisterGrainServices(context, services, indexingOptions)) .UseTransactions(); } diff --git a/src/Orleans.Indexing/Orleans.Indexing.csproj b/src/Orleans.Indexing/Orleans.Indexing.csproj index eaf3f65..94abbce 100644 --- a/src/Orleans.Indexing/Orleans.Indexing.csproj +++ b/src/Orleans.Indexing/Orleans.Indexing.csproj @@ -24,6 +24,11 @@ + + + + + all diff --git a/src/Orleans.Indexing/newversion/IndexService.cs b/src/Orleans.Indexing/newversion/IndexService.cs new file mode 100644 index 0000000..76e6800 --- /dev/null +++ b/src/Orleans.Indexing/newversion/IndexService.cs @@ -0,0 +1,114 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq.Expressions; +using System.Threading.Tasks; +using Lucene.Net.Analysis; +using Lucene.Net.Analysis.Standard; +using Lucene.Net.Documents; +using Lucene.Net.Index; +using Lucene.Net.QueryParsers.Classic; +using Lucene.Net.Search; +using Lucene.Net.Store; +using Lucene.Net.Util; +using Orleans.Concurrency; +using Orleans.Placement; +using Orleans.Runtime; +using Orleans.Services; +using Directory = System.IO.Directory; + +namespace Orleans.Indexing +{ + + public class GrainDocument + { + public static string GrainIdFieldName = "___grainId"; + public GrainDocument(string grainId) + { + this.LuceneDocument = new Document(); + this.LuceneDocument.Add(new StringField(GrainIdFieldName, grainId, Field.Store.NO)); + } + public Document LuceneDocument { get; } + } + + public interface IIndexService : IGrainService + { + + } + + + public interface IIndexGrain : IGrainWithStringKey + { + Task WriteIndex(GrainDocument document); + Task QueryByField(string field, string query, int take = 1000); + } + + + [Reentrant] + public class IndexService : GrainService, IIndexService + { + + } + + [PreferLocalPlacement] + public class IndexGrain : Grain, IIndexGrain + { + // Ensures index backward compatibility + private const LuceneVersion AppLuceneVersion = LuceneVersion.LUCENE_48; + // private static string indexPath = "indexPath"; + private BaseDirectory indexDirectory; + private DirectoryReader directoryReader; + private Analyzer analyzer; + private IndexWriter indexWriter; + private IndexSearcher indexSearcher; + + public override Task OnActivateAsync() + { + this.indexDirectory = GetDirectory(); + this.analyzer = new StandardAnalyzer(AppLuceneVersion); + var config = new IndexWriterConfig(AppLuceneVersion, this.analyzer); + this.indexWriter = new IndexWriter(this.indexDirectory, config); + this.indexWriter.Commit(); + + this.directoryReader = DirectoryReader.Open(this.indexDirectory); + this.indexSearcher = new IndexSearcher(this.directoryReader); + + return Task.CompletedTask; + } + + public override Task OnDeactivateAsync() + { + this.indexWriter?.Dispose(); + this.analyzer?.Dispose(); + this.directoryReader?.Dispose(); + return Task.CompletedTask; + } + + private BaseDirectory GetDirectory() + { + return new RAMDirectory(); + // return FSDirectory.Open(indexPath); + } + + public Task WriteIndex(GrainDocument document) => Task.Run(() => + { + var parser = new QueryParser(AppLuceneVersion, GrainDocument.GrainIdFieldName, this.analyzer); + var query = parser.Parse(document.LuceneDocument.GetField(GrainDocument.GrainIdFieldName).GetStringValue()); + this.indexWriter.DeleteDocuments(query); + this.indexWriter.AddDocument(document.LuceneDocument); + this.indexWriter.Commit(); + + this.directoryReader = DirectoryReader.OpenIfChanged(this.directoryReader) ?? this.directoryReader; + this.indexSearcher = new IndexSearcher(this.directoryReader); + + return Task.CompletedTask; + }); + + public Task QueryByField(string field, string query, int take = 1000) => Task.Run(() => + { + var parser = new QueryParser(AppLuceneVersion, GrainDocument.GrainIdFieldName, this.analyzer); + var result = this.indexSearcher.Search(parser.Parse(query), null, take); + return result; + }); + } +} \ No newline at end of file diff --git a/test/Orleans.Indexing.Tests/BaseIndexingFixture.cs b/test/Orleans.Indexing.Tests/BaseIndexingFixture.cs index 2d9f1a7..e7c982e 100644 --- a/test/Orleans.Indexing.Tests/BaseIndexingFixture.cs +++ b/test/Orleans.Indexing.Tests/BaseIndexingFixture.cs @@ -7,6 +7,7 @@ using System.Collections.Generic; using System.Linq; using System.Reflection; +using Microsoft.Extensions.Hosting; using TestExtensions; namespace Orleans.Indexing.Tests @@ -20,18 +21,8 @@ protected TestClusterBuilder ConfigureTestClusterForIndexing(TestClusterBuilder return builder; } - internal static ISiloHostBuilder Configure(ISiloHostBuilder hostBuilder, string databaseName = null) + internal static ISiloBuilder Configure(ISiloBuilder hostBuilder, string databaseName = null) { - string cosmosDBEndpoint = string.Empty, cosmosDBKey = string.Empty; - if (databaseName != null) - { - if (!TestDefaultConfiguration.GetValue("CosmosDBEndpoint", out cosmosDBEndpoint) - || !TestDefaultConfiguration.GetValue("CosmosDBKey", out cosmosDBKey)) - { - throw new IndexConfigurationException("CosmosDB connection values are not specified"); - } - } - hostBuilder.AddMemoryGrainStorage(IndexingTestConstants.GrainStore) .AddMemoryGrainStorage("PubSubStore") // PubSubStore service is needed for the streams underlying OrleansQueryResults .ConfigureLogging(loggingBuilder => @@ -43,20 +34,7 @@ internal static ISiloHostBuilder Configure(ISiloHostBuilder hostBuilder, string { parts.AddApplicationPart(typeof(BaseIndexingFixture).Assembly).WithReferences(); }); - return databaseName != null - ? hostBuilder.AddCosmosDBGrainStorage(IndexingTestConstants.CosmosDBGrainStorage, opt => - { - opt.AccountEndpoint = cosmosDBEndpoint; - opt.AccountKey = cosmosDBKey; - opt.ConnectionMode = Microsoft.Azure.Documents.Client.ConnectionMode.Gateway; - opt.DropDatabaseOnInit = true; - opt.AutoUpdateStoredProcedures = true; - opt.CanCreateResources = true; - opt.DB = databaseName; - opt.InitStage = ServiceLifecycleStage.RuntimeStorageServices; - opt.StateFieldsToIndex.AddRange(GetDSMIStateFieldsToIndex()); - }) - : hostBuilder; + return hostBuilder; } internal static IClientBuilder Configure(IClientBuilder clientBuilder) @@ -71,35 +49,5 @@ internal static IClientBuilder Configure(IClientBuilder clientBuilder) parts.AddApplicationPart(typeof(BaseIndexingFixture).Assembly); }); } - - // Code below adapted from ApplicationPartsIndexableGrainLoader to identify the necessary fields for the DSMI storage - // provider to index. - - private static IEnumerable GetDSMIStateFieldsToIndex() - { - var grainClassTypes = typeof(BaseIndexingFixture).Assembly.GetConcreteGrainClasses().ToArray(); - - // Orleans.CosmosDB appends the field names to "State."; thus we do not prepend the interface names. - var interfacesToIndexedPropertyNames = new Dictionary(); - foreach (var grainClassType in grainClassTypes) - { - GetDSMIFieldsForASingleGrainType(grainClassType, interfacesToIndexedPropertyNames); - } - return new HashSet(interfacesToIndexedPropertyNames.Where(kvp => kvp.Value.Length > 0).SelectMany(kvp => kvp.Value)); - } - - internal static void GetDSMIFieldsForASingleGrainType(Type grainClassType, Dictionary interfacesToIndexedPropertyNames) - { - foreach (var (grainInterfaceType, propertiesClassType) in ApplicationPartsIndexableGrainLoader.EnumerateIndexedInterfacesForAGrainClassType(grainClassType) - .Where(tup => !interfacesToIndexedPropertyNames.ContainsKey(tup.interfaceType))) - { - // TODO: See comments in DSMIGrain.LookupGrainReferences; get the path with and without the transactional storage wrapper prefix. - interfacesToIndexedPropertyNames[grainInterfaceType] = propertiesClassType.GetProperties() - .Where(propInfo => propInfo.GetCustomAttributes(inherit: false).Any()) - .Select(propInfo => IndexingConstants.UserStatePrefix + propInfo.Name) - .SelectMany(path => new[] {path, $"{nameof(TransactionalStateRecord.CommittedState)}.{path}"}) - .ToArray(); - } - } } } diff --git a/test/Orleans.Indexing.Tests/BaseIndexingTestRunnerBase.cs b/test/Orleans.Indexing.Tests/BaseIndexingTestRunnerBase.cs new file mode 100644 index 0000000..f7f8e2b --- /dev/null +++ b/test/Orleans.Indexing.Tests/BaseIndexingTestRunnerBase.cs @@ -0,0 +1,59 @@ +using Xunit.Abstractions; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.DependencyInjection; +using Orleans.TestingHost; +using System.Threading.Tasks; +using System.Linq; +using System; +using Xunit; + +namespace Orleans.Indexing.Tests +{ + + public class BaseIndexingTestRunnerBase : IDisposable + { + private BaseIndexingFixture fixture; + + internal readonly ITestOutputHelper Output; + internal IClusterClient ClusterClient => this.fixture.Client; + + internal IGrainFactory GrainFactory => this.fixture.GrainFactory; + + + internal ILoggerFactory LoggerFactory { get; } + + protected TestCluster HostedCluster => this.fixture.HostedCluster; + + protected BaseIndexingTestRunnerBase(BaseIndexingFixture fixture, ITestOutputHelper output) + { + this.fixture = fixture; + this.Output = output; + this.LoggerFactory = this.ClusterClient.ServiceProvider.GetRequiredService(); + } + + protected TInterface GetGrain(long primaryKey) where TInterface : IGrainWithIntegerKey + => this.GrainFactory.GetGrain(primaryKey); + + protected TInterface GetGrain(long primaryKey) where TInterface : IGrainWithIntegerKey + => this.GetGrain(primaryKey, typeof(TImplClass)); + + protected TInterface GetGrain(long primaryKey, Type grainImplType) where TInterface : IGrainWithIntegerKey + => this.GrainFactory.GetGrain(primaryKey, grainImplType.FullName.Replace("+", ".")); + + + protected Task StartAndWaitForSecondSilo() + { + if (this.HostedCluster.SecondarySilos.Count == 0) + { + this.HostedCluster.StartAdditionalSilo(); + return this.HostedCluster.WaitForLivenessToStabilizeAsync(); + } + return Task.CompletedTask; + } + + public void Dispose() + { + this.HostedCluster.StopAllSilos(); + } + } +} diff --git a/test/Orleans.Indexing.Tests/LuceneTests/IndexTests.cs b/test/Orleans.Indexing.Tests/LuceneTests/IndexTests.cs new file mode 100644 index 0000000..db48d75 --- /dev/null +++ b/test/Orleans.Indexing.Tests/LuceneTests/IndexTests.cs @@ -0,0 +1,121 @@ +using System; +using System.IO; +using System.Threading.Tasks; +using FluentAssertions; +using Lucene.Net.Analysis; +using Lucene.Net.Analysis.Standard; +using Lucene.Net.Documents; +using Lucene.Net.Index; +using Lucene.Net.QueryParsers.Classic; +using Lucene.Net.Search; +using Lucene.Net.Store; +using Lucene.Net.Util; +using Xunit; +using Directory = Lucene.Net.Store.Directory; + +namespace Orleans.Indexing.Tests.LuceneTests +{ + public class IndexTests + { + private const LuceneVersion AppLuceneVersion = LuceneVersion.LUCENE_48; + // RAM + private string indexPath = $"indexPath-{Guid.NewGuid().ToString("N")}.luc"; + string Text = "This is the text to be indexed."; + string FieldName = "fieldname"; + Analyzer analyzer = new StandardAnalyzer(AppLuceneVersion); + + [Fact] + public void Index_Write_Query() + { + var RamDirectory = FSDirectory.Open(indexPath); + + Analyzer analyzer = new StandardAnalyzer(AppLuceneVersion); + + // Parse a simple query that searches for "text": + var parser = new QueryParser(AppLuceneVersion, FieldName, analyzer); + var query = parser.Parse("text"); + + var config = new IndexWriterConfig(AppLuceneVersion, analyzer); + var indexWriter = new IndexWriter(RamDirectory, config); + + var doc1 = new Document(); + doc1.Add(new Field(FieldName, Text, TextField.TYPE_STORED)); + indexWriter.AddDocument(doc1); + indexWriter.Commit(); + // indexWriter.Flush(true,true); + + + var indexReader = DirectoryReader.Open(RamDirectory); + var indexSearcher = new IndexSearcher(indexReader); + + var hits = indexSearcher.Search(query, null, 1000).ScoreDocs; + hits.Length.Should().Be(1); + + // Iterate through the results: + foreach (var t in hits) + { + var hitDoc = indexSearcher.Doc(t.Doc); + hitDoc.Get(FieldName).Should().Be(Text); + } + + + indexWriter.DeleteDocuments(query); + indexWriter.Commit(); + // indexWriter.Flush(true,true); + + var indexReader2 = DirectoryReader.Open(RamDirectory); + var indexSearcher2 = new IndexSearcher(indexReader2); + hits = indexSearcher2.Search(query, null, 1000).ScoreDocs; + hits.Length.Should().Be(0); + + hits = indexSearcher.Search(query, null, 1000).ScoreDocs; + hits.Length.Should().Be(1); + + + indexReader2.Dispose(); + indexReader.Dispose(); + } + + [Fact] + public async Task GrainTest() + { + var grain = new IndexGrain(); + + await grain.OnActivateAsync(); + + int count = 0; + int foundCont = 0; + + await Task.WhenAll(Task.Run(async () => + { + for (int i = 0; i < 150; i++) + { + var doc = new GrainDocument(i.ToString()); + doc.LuceneDocument.Add(new StringField("property",$"i={i}", Field.Store.YES)); + await grain.WriteIndex(doc); + count++; + } + }), Task.Run( async () => + { + await Task.Delay(1000); + for (int i = 0; i < 300; i++) + { + var doc = await grain.QueryByField("property",$"i={i}"); + count++; + + if (doc.TotalHits > 0) + { + foundCont += 1; + } + + } + })); + + await grain.OnDeactivateAsync(); + + count.Should().Be(450); + foundCont.Should().Be(150); + + } + } +} \ No newline at end of file diff --git a/test/Orleans.Indexing.Tests/Orleans.Indexing.Tests.csproj b/test/Orleans.Indexing.Tests/Orleans.Indexing.Tests.csproj index 3db9cf0..d07fae4 100644 --- a/test/Orleans.Indexing.Tests/Orleans.Indexing.Tests.csproj +++ b/test/Orleans.Indexing.Tests/Orleans.Indexing.Tests.csproj @@ -3,21 +3,26 @@ Orleans.Indexing.Tests Orleans.Indexing.Tests true - - net461 + net5.0 + latest - + + + + + + all runtime; build; native; contentfiles; analyzers; buildtransitive - + @@ -31,5 +36,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/test/Orleans.Indexing.Tests/Tester/DSMIndexingTestFixture.cs b/test/Orleans.Indexing.Tests/Tester/DSMIndexingTestFixture.cs index ebeabae..8e0ffff 100644 --- a/test/Orleans.Indexing.Tests/Tester/DSMIndexingTestFixture.cs +++ b/test/Orleans.Indexing.Tests/Tester/DSMIndexingTestFixture.cs @@ -6,14 +6,14 @@ namespace Orleans.Indexing.Tests { public class DSMIndexingTestFixture : IndexingTestFixture { - internal class SiloBuilderConfiguratorDSMI : ISiloBuilderConfigurator + internal class SiloBuilderConfiguratorDSMI : ISiloConfigurator { // Each class is an Xunit collection receiving the class fixture; we drop the database, so must // use a different DB name for each class. protected const string DatabaseNamePrefix = "IndexStorageTest_"; internal virtual string GetDatabaseName() => throw new NotImplementedException(); - public void Configure(ISiloHostBuilder hostBuilder) => + public void Configure(ISiloBuilder hostBuilder) => BaseIndexingFixture.Configure(hostBuilder, GetDatabaseName()) .UseIndexing(indexingOptions => ConfigureBasicOptions(indexingOptions)); } diff --git a/test/Orleans.Indexing.Tests/Tester/IndexingRecoveryTestFixture.cs b/test/Orleans.Indexing.Tests/Tester/IndexingRecoveryTestFixture.cs index a146dbc..c4726c5 100644 --- a/test/Orleans.Indexing.Tests/Tester/IndexingRecoveryTestFixture.cs +++ b/test/Orleans.Indexing.Tests/Tester/IndexingRecoveryTestFixture.cs @@ -14,9 +14,9 @@ internal override void AddSiloBuilderConfigurator(TestClusterBuilder builder) base.AddSiloBuilderConfigurator(builder); } - internal class GrainRecoverySiloBuilderConfigurator : ISiloBuilderConfigurator + internal class GrainRecoverySiloBuilderConfigurator : ISiloConfigurator { - public void Configure(ISiloHostBuilder hostBuilder) => + public void Configure(ISiloBuilder hostBuilder) => hostBuilder.ConfigureServices(services => services.AddSingleton(_ => new TestInjectableCode { SkipQueueThread = true })); } } @@ -29,9 +29,9 @@ internal override void AddSiloBuilderConfigurator(TestClusterBuilder builder) base.AddSiloBuilderConfigurator(builder); } - internal class QueueRecoverySiloBuilderConfigurator : ISiloBuilderConfigurator + internal class QueueRecoverySiloBuilderConfigurator : ISiloConfigurator { - public void Configure(ISiloHostBuilder hostBuilder) => + public void Configure(ISiloBuilder hostBuilder) => hostBuilder.ConfigureServices(services => services.AddSingleton(_ => new TestInjectableCode { ForceReincarnatedQueue = true })); } } diff --git a/test/Orleans.Indexing.Tests/Tester/IndexingTestFixture.cs b/test/Orleans.Indexing.Tests/Tester/IndexingTestFixture.cs index a494d13..8b4c078 100644 --- a/test/Orleans.Indexing.Tests/Tester/IndexingTestFixture.cs +++ b/test/Orleans.Indexing.Tests/Tester/IndexingTestFixture.cs @@ -16,9 +16,9 @@ protected override void ConfigureTestCluster(TestClusterBuilder builder) builder.AddClientBuilderConfigurator(); } - private class SiloBuilderConfigurator : ISiloBuilderConfigurator + private class SiloBuilderConfigurator : ISiloConfigurator { - public void Configure(ISiloHostBuilder hostBuilder) => + public void Configure(ISiloBuilder hostBuilder) => BaseIndexingFixture.Configure(hostBuilder) .UseIndexing(indexingOptions => ConfigureBasicOptions(indexingOptions)); } diff --git a/test/Orleans.Indexing.Tests/Tester/IndexingTests.cs b/test/Orleans.Indexing.Tests/Tester/IndexingTests.cs index 57a993a..bece8c4 100644 --- a/test/Orleans.Indexing.Tests/Tester/IndexingTests.cs +++ b/test/Orleans.Indexing.Tests/Tester/IndexingTests.cs @@ -1,184 +1,21 @@ +using System; +using System.Threading.Tasks; +using Orleans.Indexing.Tests.Grains; using Xunit.Abstractions; using Xunit; -using Orleans.Indexing.Tests.MultiInterface; -using Orleans.Indexing.Tests.SharedGrainInterfaces; namespace Orleans.Indexing.Tests { - #region Players - [TestCategory("BVT"), TestCategory("Indexing")] - public class SimpleIndexingSingleSiloTests : SimpleIndexingSingleSiloRunner, IClassFixture + [TestCategory("BVT"), TestCategory("Indexing1")] + public class SomeTests : SimpleIndexingSingleSiloRunner, IClassFixture { - public SimpleIndexingSingleSiloTests(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class SimpleIndexingTwoSiloTests : SimpleIndexingTwoSiloRunner, IClassFixture - { - public SimpleIndexingTwoSiloTests(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class ChainedBucketIndexingSingleSiloTests : ChainedBucketIndexingSingleSiloRunner, IClassFixture - { - public ChainedBucketIndexingSingleSiloTests(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class ChainedBucketIndexingTwoSiloTests : ChainedBucketIndexingTwoSiloRunner, IClassFixture - { - public ChainedBucketIndexingTwoSiloTests(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class FaultTolerantIndexingSingleSiloTests : FaultTolerantIndexingSingleSiloRunner, IClassFixture - { - public FaultTolerantIndexingSingleSiloTests(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class FaultTolerantIndexingTwoSiloTests : FaultTolerantIndexingTwoSiloRunner, IClassFixture - { - public FaultTolerantIndexingTwoSiloTests(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class LazyIndexingSingleSiloTests : LazyIndexingSingleSiloRunner, IClassFixture - { - public LazyIndexingSingleSiloTests(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class LazyIndexingTwoSiloTests : LazyIndexingTwoSiloRunner, IClassFixture - { - public LazyIndexingTwoSiloTests(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class NoIndexingTests : NoIndexingRunner, IClassFixture - { - public NoIndexingTests(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } + public SomeTests(IndexingTestFixture fixture) : base(fixture, null) { } - [TestCategory("BVT"), TestCategory("Indexing")] - public class TransactionalPlayerTests : TransactionalPlayerRunner, IClassFixture - { - public TransactionalPlayerTests(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - #endregion Players - - #region MultiIndex - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiIndex_AI_EG : MultiIndex_AI_EG_Runner, IClassFixture - { - public MultiIndex_AI_EG(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } + [Fact] + public async Task DoIt() + { + await base.StartAndWaitForSecondSilo(); - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiIndex_AI_LZ : MultiIndex_AI_LZ_Runner, IClassFixture - { - public MultiIndex_AI_LZ(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiIndex_TI_EG : MultiIndex_TI_EG_Runner, IClassFixture - { - public MultiIndex_TI_EG(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiIndex_TI_LZ : MultiIndex_TI_LZ_Runner, IClassFixture - { - public MultiIndex_TI_LZ(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiIndex_XI_EG : MultiIndex_XI_EG_Runner, IClassFixture - { - public MultiIndex_XI_EG(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiIndex_XI_LZ : MultiIndex_XI_LZ_Runner, IClassFixture - { - public MultiIndex_XI_LZ(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiIndex_All : MultiIndex_All_Runner, IClassFixture - { - public MultiIndex_All(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - #endregion MultiIndex - - #region MultiInterface - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiInterface_AI_EG : MultiInterface_AI_EG_Runner, IClassFixture - { - public MultiInterface_AI_EG(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiInterface_AI_LZ : MultiInterface_AI_LZ_Runner, IClassFixture - { - public MultiInterface_AI_LZ(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiInterface_TI_EG : MultiInterface_TI_EG_Runner, IClassFixture - { - public MultiInterface_TI_EG(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiInterface_TI_LZ : MultiInterface_TI_LZ_Runner, IClassFixture - { - public MultiInterface_TI_LZ(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiInterface_XI_EG : MultiInterface_XI_EG_Runner, IClassFixture - { - public MultiInterface_XI_EG(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiInterface_XI_LZ : MultiInterface_XI_LZ_Runner, IClassFixture - { - public MultiInterface_XI_LZ(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiInterface_All : MultiInterface_All_Runner, IClassFixture - { - public MultiInterface_All(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - #endregion MultiInterface - - #region DirectStorageManagedIndexes - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiIndex_DSMI_EG : MultiIndex_DSMI_EG_Runner, IClassFixture - { - public MultiIndex_DSMI_EG(DSMI_EG_IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - [TestCategory("BVT"), TestCategory("Indexing")] - public class MultiIndex_DSMI_LZ : MultiIndex_DSMI_LZ_Runner, IClassFixture - { - public MultiIndex_DSMI_LZ(DSMI_LZ_IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } - } - - #endregion // DirectStorageManagedIndexes - - [TestCategory("BVT"), TestCategory("Indexing")] - public class SharedGrainInterface : SharedGrainInterfaceRunner, IClassFixture - { - public SharedGrainInterface(IndexingTestFixture fixture, ITestOutputHelper output) : base(fixture, output) { } + } } } diff --git a/test/TestInfrastructure/TestExtensions/BaseClusterFixture.cs b/test/TestInfrastructure/TestExtensions/BaseClusterFixture.cs index b05f763..53b4dcc 100644 --- a/test/TestInfrastructure/TestExtensions/BaseClusterFixture.cs +++ b/test/TestInfrastructure/TestExtensions/BaseClusterFixture.cs @@ -34,7 +34,7 @@ protected BaseTestClusterFixture() var builder = new TestClusterBuilder(); TestDefaultConfiguration.ConfigureTestCluster(builder); ConfigureTestCluster(builder); - + builder.Options.ServiceId = Guid.NewGuid().ToString(); var testCluster = builder.Build(); if (testCluster?.Primary == null) { @@ -62,7 +62,7 @@ protected virtual void ConfigureTestCluster(TestClusterBuilder builder) public IClusterClient Client => this.HostedCluster?.Client; public ILogger Logger { get; } - + public virtual void Dispose() { this.HostedCluster?.StopAllSilos(); diff --git a/test/TestInfrastructure/TestExtensions/OrleansTestingBase.cs b/test/TestInfrastructure/TestExtensions/OrleansTestingBase.cs index 35c6e2e..867ddd3 100644 --- a/test/TestInfrastructure/TestExtensions/OrleansTestingBase.cs +++ b/test/TestInfrastructure/TestExtensions/OrleansTestingBase.cs @@ -1,4 +1,5 @@ using System; +using Orleans.Internal; using Orleans.Runtime; namespace TestExtensions diff --git a/test/TestInfrastructure/TestExtensions/TestConstants.cs b/test/TestInfrastructure/TestExtensions/TestConstants.cs index 9990404..ddc80d6 100644 --- a/test/TestInfrastructure/TestExtensions/TestConstants.cs +++ b/test/TestInfrastructure/TestExtensions/TestConstants.cs @@ -2,6 +2,7 @@ using System.Diagnostics; using System.IO; using System.Net; +using Orleans.Internal; using Orleans.Runtime; namespace TestExtensions @@ -13,6 +14,6 @@ internal static class TestConstants public static readonly TimeSpan InitTimeout = Debugger.IsAttached ? TimeSpan.FromMinutes(10) : TimeSpan.FromMinutes(1); - + } }