private async Task SetupIndexAsync(IElasticClient connection, string indexName, string entityName, bool forceCreate) { var exists = Wrap(await connection.IndexExistsAsync(x => x.Index(indexName)).ConfigureAwait(false)).Exists; if (exists && forceCreate) { Wrap(await connection.DeleteIndexAsync(x => x.Index(indexName)).ConfigureAwait(false)); exists = false; } if (!exists) { var createResponse = Wrap(await connection.CreateIndexAsync(createIndexDescriptor => createIndexDescriptor .Index(indexName) .Analysis(a => a .Analyzers(x => x.Add("lowercaseKeyword", new CustomAnalyzer { Tokenizer = "keyword", Filter = new[] { "standard", "lowercase" } })) ) .AddMapping <TUser>(m => m .MapFromAttributes() .IncludeInAll(false) .IdField(x => x.Path("id")) .Type(entityName) ) ).ConfigureAwait(false)); AssertIndexCreateSuccess(createResponse); await SeedAsync().ConfigureAwait(false); } }
/// <summary> /// The delete index API allows to delete an existing index. /// <para> </para>http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-delete-index.html /// </summary> /// <param name="client"></param> /// <param name="index">The name of the index to be deleted</param> /// <param name="deleteIndexSelector">A descriptor that further describes the parameters for the delete index operation</param> public static Task <IIndicesResponse> DeleteIndexAsync(this IElasticClient client, string index, Func <DeleteIndexDescriptor, DeleteIndexDescriptor> deleteIndexSelector) { index.ThrowIfNullOrEmpty("index"); deleteIndexSelector = deleteIndexSelector ?? (d => d); return(client.DeleteIndexAsync(d => deleteIndexSelector(d).Index(index))); }
private async Task RemoveIndexIfNeeded(IElasticClient client) { if ((await client.IndexExistsAsync(_setup.IndexName)).Exists) { await client.DeleteIndexAsync(_setup.IndexName); } }
public async Task DeleteIndexAsync(string indexName) { using ( BusyStateManager.Start( $"Deleting {indexName} triggered by '{UmbracoContext.Current.Security.CurrentUser.Name}'", indexName)) { await client.DeleteIndexAsync(indexName); } }
/// <summary> /// Delete ElasticSearch index. /// </summary> public async Task <IDeleteIndexResponse> DeleteIndex() { if ((await _client.IndexExistsAsync(_serviceConfig.IndexName)).Exists) { return(await _client.DeleteIndexAsync(_serviceConfig.IndexName)); } return(null); }
public async Task DeleteIndexAsync(string indexName) { var existsResponse = await _elasticClient.IndexExistsAsync(new IndexExistsRequest(indexName)); if (existsResponse.Exists) { await _elasticClient.DeleteIndexAsync(indexName); } }
public static Task <DeleteIndexResponse> DeleteIndexAsync( this IElasticClient client, string index, CancellationToken cancellationToken = default(CancellationToken)) { return(client.DeleteIndexAsync( index, cancellationToken )); }
public static Task <DeleteIndexResponse> DeleteIndexAsync <TDocument>( this IElasticClient client, CancellationToken cancellationToken = default(CancellationToken), string indexSuffix = null) where TDocument : class { var index = GetIndex <TDocument>(indexSuffix); return(client.DeleteIndexAsync( index, cancellationToken)); }
public override async Task DestroyAsync(CancellationToken cancellationToken) { // The request. IDeleteIndexRequest request = new DeleteIndexDescriptor(Indices.Index <T>()); // Delete and return the response. IDeleteIndexResponse response = await ElasticClient .DeleteIndexAsync(request, cancellationToken).ConfigureAwait(false); // If it failed, throw an exception. response.ThrowIfError(); }
public async Task UpdateDataZeroDownTime(List <Feature> names, List <Feature> highways) { // init var currentNameIndex = OSM_NAMES_INDEX1; var currentHighwayIndex = OSM_HIGHWAYS_INDEX1; var newNameIndex = OSM_NAMES_INDEX2; var newHighwayIndex = OSM_HIGHWAYS_INDEX2; if (_elasticClient.IndexExists(OSM_NAMES_INDEX2).Exists) { currentNameIndex = OSM_NAMES_INDEX2; currentHighwayIndex = OSM_HIGHWAYS_INDEX2; newNameIndex = OSM_NAMES_INDEX1; newHighwayIndex = OSM_HIGHWAYS_INDEX1; } // create new indexes await CreateNamesIndex(newNameIndex); await CreateHighwaysIndex(newHighwayIndex); // update data await UpdateUsingPaging(names, newNameIndex); await UpdateUsingPaging(highways, newHighwayIndex); // change alias await _elasticClient.AliasAsync(a => a .Remove(i => i.Alias(OSM_NAMES_ALIAS).Index(currentNameIndex)) .Remove(i => i.Alias(OSM_HIGHWAYS_ALIAS).Index(currentHighwayIndex)) .Add(i => i.Alias(OSM_NAMES_ALIAS).Index(newNameIndex)) .Add(i => i.Alias(OSM_HIGHWAYS_ALIAS).Index(newHighwayIndex)) ); // delete old indexes await _elasticClient.DeleteIndexAsync(currentNameIndex); await _elasticClient.DeleteIndexAsync(currentHighwayIndex); }
public async Task ReIndex <T>(IReadOnlyCollection <T> items) where T : class, IEntity { var exists = await _elasticClient.IndexExistsAsync(_indexName); if (exists.Exists) { await _elasticClient.DeleteIndexAsync(_indexName); await _elasticClient.CreateIndexAsync(_indexName); } await Task.WhenAll(items.Select(async item => await AddItem(item))); await _elasticClient.RefreshAsync(new RefreshRequest(_indexName)); }
public async Task DeleteAllAsync( CancellationToken cancellationToken) { var readModelDescription = _readModelDescriptionProvider.GetReadModelDescription <TReadModel>(); _log.Information($"Deleting ALL '{typeof(TReadModel).PrettyPrint()}' by DELETING INDEX '{readModelDescription.IndexName}'!"); await _elasticClient.DeleteIndexAsync( readModelDescription.IndexName.Value, d => d .RequestConfiguration(c => c .AllowedStatusCodes((int)HttpStatusCode.NotFound)), cancellationToken) .ConfigureAwait(false); }
/// <summary> /// 删除索引 /// </summary> /// <param name="client"></param> /// <param name="indexName"></param> /// <returns></returns> public static async Task DeleteIndexIfExistsAsync(this IElasticClient client, string indexName) { indexName = indexName.ToLower(); var exist_response = await client.IndexExistsAsync(indexName); exist_response.ThrowIfException(); if (!exist_response.Exists) { return; } var response = await client.DeleteIndexAsync(indexName); response.ThrowIfException(); }
public static async Task <IEnumerable <IDeleteIndexResponse> > DeleteIndexByAliasAsync( this IElasticClient client, string alias) { var indicesForAlias = await client.GetIndicesPointingToAliasAsync(alias); var responses = new List <IDeleteIndexResponse>(indicesForAlias.Count); foreach (var index in indicesForAlias) { var response = await client.DeleteIndexAsync(index); responses.Add(response); } return(responses); }
public void SwitchAliasToIndex(string indexName) { var catAliases = _client.CatAliases(new CatAliasesRequest(_aliasName)); var oldIndexes = catAliases.Records.Select(x => x.Index); var response = _client.Alias(a => RemoveIndexesFromAlias(a, oldIndexes).Add(i => i.Index(indexName).Alias(_aliasName))); if (!response.IsValid) { throw new Exception("Failed while switching index alias.", response.OriginalException); } foreach (var index in oldIndexes) { _client.DeleteIndexAsync(new DeleteIndexRequest(index)); } }
private async Task IndexMockData(IElasticClient c, int requestsPerIteration) { var tokenSource = new CancellationTokenSource(); await c.DeleteIndexAsync(Index <Project>(), cancellationToken : tokenSource.Token); var observableBulk = c.BulkAll(this.MockDataGenerator(100000), f => f .MaxDegreeOfParallelism(10) .BackOffTime(TimeSpan.FromSeconds(10)) .BackOffRetries(2) .Size(1000) .RefreshOnCompleted() , tokenSource.Token); await observableBulk.ForEachAsync(x => { }, tokenSource.Token); var statsRequest = new NodesStatsRequest(NodesStatsMetric.Http); var nodeStats = await c.NodesStatsAsync(statsRequest, tokenSource.Token); AssertHttpStats(c, nodeStats, -1, requestsPerIteration); }
private async Task UpdateZeroDownTime(string index1, string index2, string alias, Func <string, Task> createIndexDelegate, List <Feature> features) { var currentIndex = index1; var newIndex = index2; if (_elasticClient.IndexExists(index2).Exists) { currentIndex = index2; newIndex = index1; } await createIndexDelegate(newIndex); await UpdateUsingPaging(features, newIndex); await _elasticClient.AliasAsync(a => a .Remove(i => i.Alias(alias).Index(currentIndex)) .Add(i => i.Alias(alias).Index(newIndex)) ); await _elasticClient.DeleteIndexAsync(currentIndex); }
public async Task DeleteAllAsync( CancellationToken cancellationToken) { var readModelDescription = _readModelDescriptionProvider.GetReadModelDescription <TReadModel>(); _log.Information($"Deleting ALL '{typeof(TReadModel).PrettyPrint()}' by DELETING INDEX '{readModelDescription.IndexName}'!"); var aliasResponse = await _elasticClient.GetAliasAsync(x => x.Name(readModelDescription.IndexName.Value), cancellationToken) .ConfigureAwait(false); if (aliasResponse.ApiCall.Success) { foreach (var indicesKey in aliasResponse.Indices.Keys) { await _elasticClient.DeleteIndexAsync(indicesKey, d => d.RequestConfiguration(c => c.AllowedStatusCodes((int)HttpStatusCode.NotFound)), cancellationToken) .ConfigureAwait(false); } } }
public async Task <IActionResult> DelIndex([FromForm] string indexName) { await _esClient.DeleteIndexAsync(new DeleteIndexRequest(Indices.Index(indexName))); return(Ok()); }
public async Task RecreateIndex() { await _elasticClient.DeleteIndexAsync(PagesIndexName); await EnsureIndexesExist(); }