public void GivenPreviouslySerializedMessage_WhenDeserializingWithNewSettings_ThenDeserializeSuccessfully()
        {
            var queryTags = new List <ExtendedQueryTagStoreEntry>
            {
                new ExtendedQueryTagStoreEntry(1, "01", "DT", "foo", QueryTagLevel.Instance, ExtendedQueryTagStatus.Adding, QueryStatus.Enabled, 0),
                new ExtendedQueryTagStoreEntry(2, "02", "DT", "bar", QueryTagLevel.Study, ExtendedQueryTagStatus.Adding, QueryStatus.Enabled, 0),
            };
            var       range       = new WatermarkRange(5, 10);
            const int threadCount = 7;

            var    before = new ReindexBatchArguments(queryTags, range, threadCount);
            string json   = JsonConvert.SerializeObject(
                before,
                new JsonSerializerSettings
            {
                TypeNameHandling = TypeNameHandling.Objects,
                TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple,
            });

            ReindexBatchArguments actual = JsonConvert.DeserializeObject <ReindexBatchArguments>(json, JsonSerializerSettings);

            Assert.Equal(before.QueryTags, actual.QueryTags, new TagEntryComparer());
            Assert.Equal(before.ThreadCount, actual.ThreadCount);
            Assert.Equal(before.WatermarkRange, actual.WatermarkRange);
        }
        public void GivenValues_WhenConstructing_ThenAssignProperties()
        {
            var queryTags = new List <ExtendedQueryTagStoreEntry>
            {
                new ExtendedQueryTagStoreEntry(1, "01", "DT", "foo", QueryTagLevel.Instance, ExtendedQueryTagStatus.Adding, QueryStatus.Enabled, 0),
                new ExtendedQueryTagStoreEntry(2, "02", "DT", "bar", QueryTagLevel.Study, ExtendedQueryTagStatus.Adding, QueryStatus.Enabled, 0),
            };
            var       range       = new WatermarkRange(5, 10);
            const int threadCount = 7;

            var actual = new ReindexBatchArguments(queryTags, range, threadCount);

            Assert.Same(queryTags, actual.QueryTags);
            Assert.Equal(range, actual.WatermarkRange);
            Assert.Equal(threadCount, actual.ThreadCount);
        }
Ejemplo n.º 3
0
        public async Task GivenBatch_WhenReindexing_ThenShouldReindexEachInstance()
        {
            const int threadCount = 7;
            var       args        = new ReindexBatchArguments(
                new List <ExtendedQueryTagStoreEntry>
            {
                new ExtendedQueryTagStoreEntry(1, "01", "DT", "foo", QueryTagLevel.Instance, ExtendedQueryTagStatus.Adding, QueryStatus.Enabled, 0),
                new ExtendedQueryTagStoreEntry(2, "02", "DT", null, QueryTagLevel.Series, ExtendedQueryTagStatus.Adding, QueryStatus.Enabled, 0),
                new ExtendedQueryTagStoreEntry(3, "03", "AS", "bar", QueryTagLevel.Study, ExtendedQueryTagStatus.Adding, QueryStatus.Enabled, 0),
            },
                new WatermarkRange(3, 10),
                threadCount);

            var expected = new List <VersionedInstanceIdentifier>
            {
                new VersionedInstanceIdentifier(TestUidGenerator.Generate(), TestUidGenerator.Generate(), TestUidGenerator.Generate(), 3),
                new VersionedInstanceIdentifier(TestUidGenerator.Generate(), TestUidGenerator.Generate(), TestUidGenerator.Generate(), 4),
                new VersionedInstanceIdentifier(TestUidGenerator.Generate(), TestUidGenerator.Generate(), TestUidGenerator.Generate(), 5),
                new VersionedInstanceIdentifier(TestUidGenerator.Generate(), TestUidGenerator.Generate(), TestUidGenerator.Generate(), 6),
                new VersionedInstanceIdentifier(TestUidGenerator.Generate(), TestUidGenerator.Generate(), TestUidGenerator.Generate(), 7),
                new VersionedInstanceIdentifier(TestUidGenerator.Generate(), TestUidGenerator.Generate(), TestUidGenerator.Generate(), 8),
                new VersionedInstanceIdentifier(TestUidGenerator.Generate(), TestUidGenerator.Generate(), TestUidGenerator.Generate(), 9),
            };

            // Arrange input
            _instanceStore
            .GetInstanceIdentifiersByWatermarkRangeAsync(args.WatermarkRange, IndexStatus.Created, CancellationToken.None)
            .Returns(expected);

            foreach (VersionedInstanceIdentifier identifier in expected)
            {
                _instanceReindexer.ReindexInstanceAsync(args.QueryTags, identifier).Returns(true);
            }

            // Call the activity
            await _reindexDurableFunction.ReindexBatchV2Async(args, NullLogger.Instance);

            // Assert behavior
            await _instanceStore
            .Received(1)
            .GetInstanceIdentifiersByWatermarkRangeAsync(args.WatermarkRange, IndexStatus.Created, CancellationToken.None);

            foreach (VersionedInstanceIdentifier identifier in expected)
            {
                await _instanceReindexer.Received(1).ReindexInstanceAsync(args.QueryTags, identifier);
            }
        }
        public async Task ReindexBatchV2Async([ActivityTrigger] ReindexBatchArguments arguments, ILogger logger)
        {
            EnsureArg.IsNotNull(arguments, nameof(arguments));
            EnsureArg.IsNotNull(logger, nameof(logger));

            logger.LogInformation("Re-indexing instances in the range {Range} for the {TagCount} query tags {{{Tags}}}",
                                  arguments.WatermarkRange,
                                  arguments.QueryTags.Count,
                                  string.Join(", ", arguments.QueryTags.Select(x => x.Path)));

            IReadOnlyList <VersionedInstanceIdentifier> instanceIdentifiers =
                await _instanceStore.GetInstanceIdentifiersByWatermarkRangeAsync(arguments.WatermarkRange, IndexStatus.Created);

            for (int i = 0; i < instanceIdentifiers.Count; i += arguments.ThreadCount)
            {
                var tasks = new List <Task>();
                for (int j = i; j < Math.Min(instanceIdentifiers.Count, i + arguments.ThreadCount); j++)
                {
                    tasks.Add(_instanceReindexer.ReindexInstanceAsync(arguments.QueryTags, instanceIdentifiers[j]));
                }

                await Task.WhenAll(tasks);
            }
        }