public async Task ClearAsync( CancellationToken ct = default) { await indexClient.DeleteIndexAsync(searchClient.IndexName, ct); await CreateIndexAsync(ct); }
private static async Task <bool> DeleteIndexingResources() { Console.WriteLine("Deleting Data Source, Index, Indexer, Skillset and SynonymMap if they exist..."); try { await _searchIndexerClient.DeleteDataSourceConnectionAsync(DataSourceName); await _searchIndexClient.DeleteIndexAsync(IndexName); await _searchIndexerClient.DeleteIndexerAsync(IndexerName); await _searchIndexerClient.DeleteSkillsetAsync(SkillsetName); await _searchIndexClient.DeleteSynonymMapAsync(SynonymMapName); } catch (Exception ex) { if (DebugMode) { Console.WriteLine("Error deleting resources: {0}", ex.Message); } return(false); } return(true); }
public static async Task DeleteIndexIfExistsAsync(string name, SearchIndexClient idxclient) { Console.WriteLine($"Deleting search index {name}..."); idxclient.GetIndexNames(); { await idxclient.DeleteIndexAsync(name); } }
public async Task DeleteAllAsync <T>(IGraphRequestContext graphRequestContext) where T : class { var client = Get <T>(graphRequestContext); _logger.LogInformation($"Removing search index: {client.IndexName}"); await _searchServiceClient.DeleteIndexAsync(client.IndexName); var fields = GetTypeFields(typeof(T), true); await _searchServiceClient.CreateIndexAsync(new SearchIndex(client.IndexName, fields)); }
private static async Task DeleteIndexIfExistsAsync(string indexName, SearchIndexClient indexClient) { try { await indexClient.GetIndexAsync(indexName); await indexClient.DeleteIndexAsync(indexName); } catch (RequestFailedException ex) when(ex.Status == 404) { //if the specified index not exist, 404 will be thrown. } }
public async Task Upload() { var existingSearchTerms = (await _tableStorage.GetAllAsync <GlobalSearchTerm>("searchTerms")).ToList(); var i = 1; Parallel.ForEach(existingSearchTerms, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, async existingSearchTerm => { await _tableStorage.DeleteAsync("searchTerms", existingSearchTerm); Console.WriteLine($"Deleted {i} of {existingSearchTerms.Count} existing search terms."); i++; }); foreach (var globalSearchTerm in _globalSearchTermRepository.SearchTerms) { globalSearchTerm.LanguageEnum = _localization.Language; } await _tableStorage.AddBatchAsync <GlobalSearchTerm>("searchTerms", _globalSearchTermRepository.SearchTerms.Where(s => s.PartitionKey == ContentType.ExpandedContent.ToString()), new BatchOperationOptions { BatchInsertMethod = BatchInsertMethod.Insert }); await _tableStorage.AddBatchAsync <GlobalSearchTerm>("searchTerms", _globalSearchTermRepository.SearchTerms.Where(s => s.PartitionKey == ContentType.Core.ToString()), new BatchOperationOptions { BatchInsertMethod = BatchInsertMethod.Insert }); var index = await _searchIndexClient.GetIndexAsync("searchterms-index"); await _searchIndexClient.DeleteIndexAsync("searchterms-index"); await _searchIndexClient.CreateIndexAsync(index); var oldIndexer = await _searchIndexerClient.GetIndexerAsync("searchterms-indexer"); await _searchIndexerClient.DeleteIndexerAsync(oldIndexer); await _searchIndexerClient.CreateIndexerAsync(oldIndexer); await _searchIndexerClient.RunIndexerAsync("searchterms-indexer"); }
public async Task CreateIndexerAsync() { await using SearchResources resources = await SearchResources.CreateWithBlobStorageAsync(this, populate : true); Environment.SetEnvironmentVariable("SEARCH_ENDPOINT", resources.Endpoint.ToString()); Environment.SetEnvironmentVariable("SEARCH_API_KEY", resources.PrimaryApiKey); Environment.SetEnvironmentVariable("STORAGE_CONNECTION_STRING", resources.StorageAccountConnectionString); Environment.SetEnvironmentVariable("STORAGE_CONTAINER", resources.BlobContainerName); Environment.SetEnvironmentVariable("COGNITIVE_SERVICES_KEY", resources.CognitiveServicesKey); // Define clean up tasks to be invoked in reverse order added. Stack <Func <Task> > cleanUpTasks = new Stack <Func <Task> >(); try { #region Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateSynonymMap // Create a new SearchIndexClient Uri endpoint = new Uri(Environment.GetEnvironmentVariable("SEARCH_ENDPOINT")); AzureKeyCredential credential = new AzureKeyCredential( Environment.GetEnvironmentVariable("SEARCH_API_KEY")); SearchIndexClient indexClient = new SearchIndexClient(endpoint, credential); #if !SNIPPET indexClient = resources.GetIndexClient(new SearchClientOptions()); #endif // Create a synonym map from a file containing country names and abbreviations // using the Solr format with entry on a new line using \n, for example: // United States of America,US,USA\n string synonymMapName = "countries"; #if !SNIPPET synonymMapName = Recording.Random.GetName(); #endif string synonymMapPath = "countries.txt"; #if !SNIPPET synonymMapPath = Path.Combine(TestContext.CurrentContext.TestDirectory, "Samples", "countries.txt"); #endif SynonymMap synonyms; #if SNIPPET using (StreamReader file = File.OpenText(synonymMapPath)) { synonyms = new SynonymMap(synonymMapName, file); } #else synonyms = new SynonymMap(synonymMapName, CountriesSolrSynonymMap); #endif await indexClient.CreateSynonymMapAsync(synonyms); #endregion Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateSynonymMap // Make sure our synonym map gets deleted, which is not deleted when our // index is deleted when our SearchResources goes out of scope. cleanUpTasks.Push(() => indexClient.DeleteSynonymMapAsync(synonymMapName)); #region Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateIndex // Create the index string indexName = "hotels"; #if !SNIPPET indexName = Recording.Random.GetName(); #endif SearchIndex index = new SearchIndex(indexName) { Fields = { new SimpleField("hotelId", SearchFieldDataType.String) { IsKey = true, IsFilterable = true, IsSortable = true }, new SearchableField("hotelName") { IsFilterable = true, IsSortable = true }, new SearchableField("description") { AnalyzerName = LexicalAnalyzerName.EnLucene }, new SearchableField("descriptionFr") { AnalyzerName = LexicalAnalyzerName.FrLucene }, new SearchableField("tags", collection: true) { IsFilterable = true, IsFacetable = true }, new ComplexField("address") { Fields = { new SearchableField("streetAddress"), new SearchableField("city") { IsFilterable = true, IsSortable = true, IsFacetable = true }, new SearchableField("stateProvince") { IsFilterable = true, IsSortable = true, IsFacetable = true }, new SearchableField("country") { SynonymMapNames = new[] { synonymMapName },IsFilterable = true, IsSortable = true,IsFacetable = true }, new SearchableField("postalCode") { IsFilterable = true, IsSortable = true, IsFacetable = true } } } } }; await indexClient.CreateIndexAsync(index); #endregion Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateIndex // Make sure our synonym map gets deleted, which is not deleted when our // index is deleted when our SearchResources goes out of scope. cleanUpTasks.Push(() => indexClient.DeleteIndexAsync(indexName)); #region Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateDataSourceConnection // Create a new SearchIndexerClient SearchIndexerClient indexerClient = new SearchIndexerClient(endpoint, credential); #if !SNIPPET indexerClient = resources.GetIndexerClient(); #endif string dataSourceConnectionName = "hotels"; #if !SNIPPET dataSourceConnectionName = Recording.Random.GetName(); #endif SearchIndexerDataSourceConnection dataSourceConnection = new SearchIndexerDataSourceConnection( dataSourceConnectionName, SearchIndexerDataSourceType.AzureBlob, Environment.GetEnvironmentVariable("STORAGE_CONNECTION_STRING"), new SearchIndexerDataContainer(Environment.GetEnvironmentVariable("STORAGE_CONTAINER"))); await indexerClient.CreateDataSourceConnectionAsync(dataSourceConnection); #endregion Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateDataSourceConnection // Make sure our data source gets deleted, which is not deleted when our // index is deleted when our SearchResources goes out of scope. cleanUpTasks.Push(() => indexerClient.DeleteDataSourceConnectionAsync(dataSourceConnectionName)); #region Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_Skillset // Translate English descriptions to French. // See https://docs.microsoft.com/azure/search/cognitive-search-skill-text-translation for details of the Text Translation skill. TextTranslationSkill translationSkill = new TextTranslationSkill( inputs: new[] { new InputFieldMappingEntry("text") { Source = "/document/description" } }, outputs: new[] { new OutputFieldMappingEntry("translatedText") { TargetName = "descriptionFrTranslated" } }, TextTranslationSkillLanguage.Fr) { Name = "descriptionFrTranslation", Context = "/document", DefaultFromLanguageCode = TextTranslationSkillLanguage.En }; // Use the human-translated French description if available; otherwise, use the translated description. // See https://docs.microsoft.com/azure/search/cognitive-search-skill-conditional for details of the Conditional skill. ConditionalSkill conditionalSkill = new ConditionalSkill( inputs: new[] { new InputFieldMappingEntry("condition") { Source = "= $(/document/descriptionFr) == null" }, new InputFieldMappingEntry("whenTrue") { Source = "/document/descriptionFrTranslated" }, new InputFieldMappingEntry("whenFalse") { Source = "/document/descriptionFr" } }, outputs: new[] { new OutputFieldMappingEntry("output") { TargetName = "descriptionFrFinal" } }) { Name = "descriptionFrConditional", Context = "/document", }; // Create a SearchIndexerSkillset that processes those skills in the order given below. string skillsetName = "translations"; #if !SNIPPET skillsetName = Recording.Random.GetName(); #endif SearchIndexerSkillset skillset = new SearchIndexerSkillset( skillsetName, new SearchIndexerSkill[] { translationSkill, conditionalSkill }) { CognitiveServicesAccount = new CognitiveServicesAccountKey( Environment.GetEnvironmentVariable("COGNITIVE_SERVICES_KEY")), KnowledgeStore = new SearchIndexerKnowledgeStore( Environment.GetEnvironmentVariable("STORAGE_CONNECTION_STRING"), new List <SearchIndexerKnowledgeStoreProjection>()), }; await indexerClient.CreateSkillsetAsync(skillset); #endregion Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_Skillset // Make sure our skillset gets deleted, which is not deleted when our // index is deleted when our SearchResources goes out of scope. cleanUpTasks.Push(() => indexerClient.DeleteSkillsetAsync(skillsetName)); #region Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateIndexer string indexerName = "hotels"; #if !SNIPPET indexerName = Recording.Random.GetName(); #endif SearchIndexer indexer = new SearchIndexer( indexerName, dataSourceConnectionName, indexName) { // We only want to index fields defined in our index, excluding descriptionFr if defined. FieldMappings = { new FieldMapping("hotelId"), new FieldMapping("hotelName"), new FieldMapping("description"), new FieldMapping("tags"), new FieldMapping("address") }, OutputFieldMappings = { new FieldMapping("/document/descriptionFrFinal") { TargetFieldName = "descriptionFr" } }, Parameters = new IndexingParameters { // Tell the indexer to parse each blob as a separate JSON document. IndexingParametersConfiguration = new IndexingParametersConfiguration { ParsingMode = BlobIndexerParsingMode.Json } }, SkillsetName = skillsetName }; // Create the indexer which, upon successful creation, also runs the indexer. await indexerClient.CreateIndexerAsync(indexer); #endregion Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_CreateIndexer // Make sure our indexer gets deleted, which is not deleted when our // index is deleted when our SearchResources goes out of scope. cleanUpTasks.Push(() => indexerClient.DeleteIndexerAsync(indexerName)); // Wait till the indexer is done. await WaitForIndexingAsync(indexerClient, indexerName); #region Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_Query // Get a SearchClient from the SearchIndexClient to share its pipeline. SearchClient searchClient = indexClient.GetSearchClient(indexName); #if !SNIPPET searchClient = InstrumentClient(new SearchClient(endpoint, indexName, credential, GetSearchClientOptions())); #endif // Query for hotels with an ocean view. SearchResults <Hotel> results = await searchClient.SearchAsync <Hotel>("ocean view"); #if !SNIPPET bool found = false; #endif await foreach (SearchResult <Hotel> result in results.GetResultsAsync()) { Hotel hotel = result.Document; #if !SNIPPET if (hotel.HotelId == "6") { Assert.IsNotNull(hotel.DescriptionFr); found = true; } #endif Console.WriteLine($"{hotel.HotelName} ({hotel.HotelId})"); Console.WriteLine($" Description (English): {hotel.Description}"); Console.WriteLine($" Description (French): {hotel.DescriptionFr}"); } #endregion Snippet:Azure_Search_Tests_Samples_CreateIndexerAsync_Query Assert.IsTrue(found, "Expected hotel #6 not found in search results"); } finally { // We want to await these individual to create a deterministic order for playing back tests. foreach (Func <Task> cleanUpTask in cleanUpTasks) { await cleanUpTask(); } } }
static async Task CreateSearchResources(AppSettings settings) { SearchIndexClient indexClient = new SearchIndexClient(settings.SearchEndpointUri, settings.SearchKeyCredential); Console.WriteLine("Deleting search index {0} if exists...", SEARCH_ACL_INDEX_NAME); try { await indexClient.GetIndexAsync(SEARCH_ACL_INDEX_NAME); await indexClient.DeleteIndexAsync(SEARCH_ACL_INDEX_NAME); } catch (RequestFailedException) { // Index didn't exist - continue } Console.WriteLine("Creating search index {0}...", SEARCH_ACL_INDEX_NAME); await indexClient.CreateOrUpdateIndexAsync( new SearchIndex(SEARCH_ACL_INDEX_NAME, fields : new[] { new SearchField("key", SearchFieldDataType.String) { IsKey = true }, new SearchField("metadata_storage_path", SearchFieldDataType.String), new SearchField("content", SearchFieldDataType.String) })); Console.WriteLine("Creating search data source {0}...", SEARCH_ACL_DATASOURCE_NAME); SearchIndexerClient indexerClient = new SearchIndexerClient(settings.SearchEndpointUri, settings.SearchKeyCredential); await indexerClient.CreateOrUpdateDataSourceConnectionAsync( new SearchIndexerDataSourceConnection( name : SEARCH_ACL_DATASOURCE_NAME, type : SearchIndexerDataSourceType.AzureBlob, connectionString : "ResourceId=" + settings.DataLakeResourceID, container : new SearchIndexerDataContainer(name : DATA_LAKE_FILESYSTEM_NAME))); Console.WriteLine("Deleting search indexer {0} if exists...", SEARCH_ACL_INDEXER_NAME); try { await indexerClient.GetIndexerAsync(SEARCH_ACL_INDEXER_NAME); await indexerClient.DeleteIndexerAsync(SEARCH_ACL_INDEXER_NAME); } catch (RequestFailedException) { // Indexer didn't exist - continue } Console.WriteLine("Creating search indexer {0}...", SEARCH_ACL_INDEXER_NAME); await indexerClient.CreateIndexerAsync( new SearchIndexer( name : SEARCH_ACL_INDEXER_NAME, dataSourceName : SEARCH_ACL_DATASOURCE_NAME, targetIndexName : SEARCH_ACL_INDEX_NAME) { Parameters = new IndexingParameters { MaxFailedItems = -1, IndexingParametersConfiguration = new IndexingParametersConfiguration { ParsingMode = BlobIndexerParsingMode.Text } } }); }
/// <summary> /// Executes code that runs exactly once at the end of test execution. /// </summary> /// <returns>Task representing the global cleanup work.</returns> public override async Task GlobalCleanupAsync() { await _searchIndexClient.DeleteIndexAsync(_indexName); }
public async Task DeleteIndex() { await _searchIndexClient.DeleteIndexAsync(_index).ConfigureAwait(false); }
public async Task <bool> DeleteIndexAsync() { var index = await _indexClient.DeleteIndexAsync(_indexName); return(index.Status == (int)HttpStatusCode.OK); }
public async Task DeleteIndex(string indexName) { await _searchIndexClient.DeleteIndexAsync(indexName).ConfigureAwait(false); }
public async Task DeleteSearchIndexes() { var key = _configuration["Search:ApiKey"]; var serviceName = _configuration["Search:ServiceName"]; var searchCredentials = new AzureKeyCredential(key); var searchServiceClient = new SearchIndexClient(serviceName.GetSearchServiceUri(), searchCredentials); // Unable to use GetIndexNamesAsync due to the following: https://github.com/Azure/azure-sdk-for-net/issues/15590 var result = searchServiceClient.GetIndexesAsync(); await foreach (var index in result) { await searchServiceClient.DeleteIndexAsync(index.Name); } }