public virtual Task ReindexAsync(Func <int, string, Task> progressCallbackAsync = null)
        {
            var reindexWorkItem = new ReindexWorkItem {
                OldIndex  = Name,
                NewIndex  = Name,
                DeleteOld = false
            };

            var reindexer = new ElasticReindexer(Configuration.Client, Configuration.Cache, _logger);

            return(reindexer.ReindexAsync(reindexWorkItem, progressCallbackAsync));
        }
Beispiel #2
0
        public override async Task ReindexAsync(Func <int, string, Task> progressCallbackAsync = null)
        {
            int currentVersion = await GetCurrentVersionAsync().AnyContext();

            if (currentVersion < 0 || currentVersion >= Version)
            {
                return;
            }

            var reindexWorkItem = CreateReindexWorkItem(currentVersion);
            var reindexer       = new ElasticReindexer(Configuration.Client, _logger);
            await reindexer.ReindexAsync(reindexWorkItem, progressCallbackAsync).AnyContext();
        }
Beispiel #3
0
        public override async Task ReindexAsync(Func <int, string, Task> progressCallbackAsync = null)
        {
            int currentVersion = await GetCurrentVersionAsync().AnyContext();

            if (currentVersion < 0 || currentVersion >= Version)
            {
                return;
            }

            var indexes = await GetIndexesAsync(currentVersion).AnyContext();

            if (indexes.Count == 0)
            {
                return;
            }

            var reindexer = new ElasticReindexer(Configuration.Client, _logger);

            foreach (var index in indexes)
            {
                if (SystemClock.UtcNow > GetIndexExpirationDate(index.DateUtc))
                {
                    continue;
                }

                if (index.CurrentVersion > Version)
                {
                    continue;
                }

                var reindexWorkItem = new ReindexWorkItem {
                    OldIndex       = index.Index,
                    NewIndex       = GetVersionedIndex(GetIndexDate(index.Index), Version),
                    Alias          = Name,
                    TimestampField = GetTimeStampField()
                };

                reindexWorkItem.DeleteOld = DiscardIndexesOnReindex && reindexWorkItem.OldIndex != reindexWorkItem.NewIndex;

                // attempt to create the index. If it exists the index will not be created.
                await CreateIndexAsync(reindexWorkItem.NewIndex, ConfigureIndex).AnyContext();

                // TODO: progress callback will report 0-100% multiple times...
                await reindexer.ReindexAsync(reindexWorkItem, progressCallbackAsync).AnyContext();
            }
        }
        public override async Task ReindexAsync(Func<int, string, Task> progressCallbackAsync = null) {
            int currentVersion = await GetCurrentVersionAsync().AnyContext();
            if (currentVersion < 0 || currentVersion >= Version)
                return;

            var reindexWorkItem = CreateReindexWorkItem(currentVersion);
            var reindexer = new ElasticReindexer(Configuration.Client, Configuration.Cache, _logger);
            await reindexer.ReindexAsync(reindexWorkItem, progressCallbackAsync).AnyContext();
        }
 public ReindexWorkItemHandler(IElasticClient client, ILockProvider lockProvider, ICacheClient cache = null, ILoggerFactory loggerFactory = null) {
     _reindexer = new ElasticReindexer(client, cache, loggerFactory.CreateLogger<ReindexWorkItemHandler>());
     _lockProvider = lockProvider;
     AutoRenewLockOnProgress = true;
 }
 public ReindexWorkItemHandler(IElasticClient client, ILockProvider lockProvider, ILoggerFactory loggerFactory = null)
 {
     _reindexer              = new ElasticReindexer(client, loggerFactory.CreateLogger <ReindexWorkItemHandler>());
     _lockProvider           = lockProvider;
     AutoRenewLockOnProgress = true;
 }