public bool IndexExist()
{
using var dir = FSDirectory.Open(musicConfiguration.IndexPath);
var exist = DirectoryReader.IndexExists(dir);
return(exist);
}
public virtual void ResetIndexDirectory()
{
try
{
string folderPath = ConfigurationManager.AppSettings["lucene:BlobConnectionString"];
var serverPath = HttpRuntime.AppDomainAppPath;
folderPath = serverPath + folderPath;
var fsDirectory = FSDirectory.Open(folderPath);
if (IndexWriter.IsLocked(fsDirectory))
{
IndexWriter.Unlock(fsDirectory);
}
string[] files = System.IO.Directory.GetFiles(folderPath);
foreach (string file in files)
{
File.Delete(file);
}
if (!DirectoryReader.IndexExists(fsDirectory))
{
using (new IndexWriter(fsDirectory, new StandardAnalyzer(LuceneConfiguration.LuceneVersion), true, IndexWriter.MaxFieldLength.UNLIMITED))
{
}
}
}
catch (Exception ex)
{
_logger.Error("ResetIndexDirectory error", ex);
}
}
public void VerifyThatInitializationWorks()
{
Assert.IsNotNull(this.IndexDirectory);
Assert.IsNotNull(this.RamIndexDirectory);
Assert.IsNotNull(this.Analyzer);
Assert.IsNotNull(this.IndexWriter);
Assert.IsNotNull(this.IndexWriterSuggest);
Assert.IsNotNull(this.SearcherManager);
Assert.IsNotNull(this.QueryParser);
// Check that indexes exist.
Assert.IsTrue(DirectoryReader.IndexExists(this.IndexDirectory));
Assert.IsTrue(DirectoryReader.IndexExists(this.RamIndexDirectory));
// Check all files have been indexed in the file system directory and there is no doubles.
var readerFsd = this.IndexWriter.Reader;
Assert.That(this.IndexWriter.NumDocs(), Is.EqualTo(5));
Assert.That(readerFsd.GetDocCount("name"), Is.EqualTo(5));
Assert.That(readerFsd.GetDocCount("path"), Is.EqualTo(5));
// Check all file names and file paths have been indexed in the ram directory and there is no doubles.
var readerRam = this.IndexWriterSuggest.Reader;
Assert.That(this.IndexWriterSuggest.NumDocs(), Is.EqualTo(5));
Assert.That(readerRam.GetDocCount("name"), Is.EqualTo(5));
Assert.That(readerRam.GetDocCount("path"), Is.EqualTo(5));
this.documentationSearches.IndexWriter.Dispose();
}
/// <summary>
/// Constructor with the given index directory and callback to notify when the indexes were updated.
/// </summary>
/// <exception cref="System.IO.IOException"></exception>
public IndexAndTaxonomyReplicationHandler(Directory indexDirectory, Directory taxonomyDirectory, Func <bool?> callback)
{
this.indexDirectory = indexDirectory;
this.taxonomyDirectory = taxonomyDirectory;
this.callback = callback;
currentVersion = null;
currentRevisionFiles = null;
bool indexExists = DirectoryReader.IndexExists(indexDirectory);
bool taxonomyExists = DirectoryReader.IndexExists(taxonomyDirectory);
if (indexExists != taxonomyExists)
{
throw new InvalidOperationException(string.Format("search and taxonomy indexes must either both exist or not: index={0} taxo={1}", indexExists, taxonomyExists));
}
if (indexExists)
{
IndexCommit indexCommit = IndexReplicationHandler.GetLastCommit(indexDirectory);
IndexCommit taxonomyCommit = IndexReplicationHandler.GetLastCommit(taxonomyDirectory);
currentRevisionFiles = IndexAndTaxonomyRevision.RevisionFiles(indexCommit, taxonomyCommit);
currentVersion = IndexAndTaxonomyRevision.RevisionVersion(indexCommit, taxonomyCommit);
WriteToInfoStream(
string.Format("constructor(): currentVersion={0} currentRevisionFiles={1}", currentVersion, currentRevisionFiles),
string.Format("constructor(): indexCommit={0} taxoCommit={1}", indexCommit, taxonomyCommit));
}
}
public static BoboMultiReader NewIndexReader(Directory idxDir)
{
if (!DirectoryReader.IndexExists(idxDir))
{
return(null);
}
long start = System.Environment.TickCount;
DirectoryReader directoryReader = DirectoryReader.Open(idxDir);
BoboMultiReader reader;
try
{
reader = BoboMultiReader.GetInstance(directoryReader);
}
catch (IOException ioe)
{
throw ioe;
}
finally
{
directoryReader.Dispose();
}
long end = System.Environment.TickCount;
if (logger.IsDebugEnabled())
{
logger.Debug("New index loading took: " + (end - start));
}
return(reader);
}
public IndexReadyCallback(Directory indexDir)
{
this.indexDir = indexDir;
if (DirectoryReader.IndexExists(indexDir))
{
reader = DirectoryReader.Open(indexDir);
lastGeneration = reader.IndexCommit.Generation;
}
}
private static void InitDirectory(Directory directory)
{
if (!DirectoryReader.IndexExists(directory))
{
using (new IndexWriter(_directory, new StandardAnalyzer(LuceneVersion), true, IndexWriter.MaxFieldLength.UNLIMITED))
{
}
}
}
public static bool IndexExists(string luceneIndex)
{
luceneIndex.RequireNotNullOrEmpty(nameof(luceneIndex));
using var dir = FSDirectory.Open(luceneIndex);
var indexExist = DirectoryReader.IndexExists(dir);
return(indexExist);
}
public bool IndexExistsOrEmpty()
{
if (!DirectoryReader.IndexExists(_directory))
{
return(false);
}
return(DirectoryReader.Open(_directory).NumDocs > 0);
}
public ParrotEyes(Wings wings, string indexname) : base(wings, indexname)
{
if (!DirectoryReader.IndexExists(LuceneDirectory))
{
throw new NoIndexException(IndexName, LuceneDirectory.Directory.FullName);
}
indexReader = DirectoryReader.Open(LuceneDirectory);
searcher = new IndexSearcher(indexReader);
}
public void Ini()
{
if (UseAzureDirectory)
{
var azureBlobConnectionString = config.GetValue <string>("AzureDirectoryConnectionString");
var azureDirectoryCachePath = ReplacePathTokens(config.GetValue <string>("AzureDirectoryCachePath"));
var azureDirectoryContainerName = config.GetValue <string>("AzureDirectoryContainerName");
//if empty string, ensure value is null
if (string.IsNullOrEmpty(azureDirectoryContainerName))
{
azureDirectoryContainerName = null;
}
var cloudStorageAccount = CloudStorageAccount.Parse(azureBlobConnectionString);
Directory = new AzureDirectory(cloudStorageAccount, azureDirectoryCachePath, containerName: azureDirectoryContainerName);
}
else
{
if (!System.IO.Directory.Exists(INDEXPATH))
{
System.IO.Directory.CreateDirectory(INDEXPATH);
}
Directory = FSDirectory.Open(INDEXPATH);
}
bool create = !DirectoryReader.IndexExists(Directory);
lock (write_lock)
{
try
{
if (CanWrite)
{
SetWriter(create);
if (Writer != null && !UseAzureDirectory)
{
CloseWriter();
}
//Writer.Optimize();
}
}
catch (Lucene.Net.Store.LockObtainFailedException ex)
{
logger.Log(ex);
}
catch (Exception ex)
{
throw;
//logger.Log(ex);
}
finally
{
//CloseWriter();
}
}
SetSearcher();
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
isOpen = false;
if (checkIndexOnClose && DirectoryReader.IndexExists(this))
{
TestUtil.CheckIndex(this, crossCheckTermVectorsOnClose);
}
base.Dispose(disposing);
}
}
private static SearcherManager BuildSearcherManagerReader(Directory directory, Analyzer analyzer)
{
if (!DirectoryReader.IndexExists(directory))
{
// this index doesn't exist... make it!
using (new IndexWriter(directory, new IndexWriterConfig(LeoLuceneVersion.Version, analyzer)
{
OpenMode = OpenMode.CREATE_OR_APPEND
})) { }
}
return(new SearcherManager(directory, null));
}
public IndexAndTaxonomyReadyCallback(MockDirectoryWrapper indexDir, MockDirectoryWrapper taxoDir)
{
this.indexDir = indexDir;
this.taxoDir = taxoDir;
config = new FacetsConfig();
config.SetHierarchical("A", true);
if (DirectoryReader.IndexExists(indexDir))
{
indexReader = DirectoryReader.Open(indexDir);
lastIndexGeneration = indexReader.IndexCommit.Generation;
taxoReader = new DirectoryTaxonomyReader(taxoDir);
}
}
private static Directory GetIndexDirectory(string subIndex)
{
var directory = FSDirectory.Open(subIndex);
if (!DirectoryReader.IndexExists(directory))//判断是否存在索引文件夹
{
System.IO.Directory.CreateDirectory(subIndex);
}
if (IndexWriter.IsLocked(directory))//判断是否被锁定，如果锁定则解锁
{
IndexWriter.Unlock(directory);
}
return(directory);
}
/// <summary>
/// The get searcher.
/// </summary>
/// <returns>
/// The <see cref="IndexSearcher"/>.
/// </returns>
private IndexSearcher GetSearcher()
{
if (!DirectoryReader.IndexExists(FSDirectory.Open(SearchIndexFolder)))
{
return(null);
}
this.searcherManager = this.indexWriter != null
? new SearcherManager(this.indexWriter, false, null)
: new SearcherManager(FSDirectory.Open(SearchIndexFolder), null);
this.searcherManager.MaybeRefreshBlocking();
return(this.searcherManager.Acquire());
}
/// <summary>
/// Returns the last <see cref="IndexCommit"/> found in the <see cref="Directory"/>, or
/// <c>null</c> if there are no commits.
/// </summary>
/// <exception cref="IOException"></exception>
public static IndexCommit GetLastCommit(Directory directory)
{
try
{
// IndexNotFoundException which we handle below
return(DirectoryReader.IndexExists(directory)
? DirectoryReader.ListCommits(directory).Last()
: null);
}
catch (IndexNotFoundException)
{
// ignore the exception and return null
}
return(null);
}
public Task DeleteAll()
{
if (_isDisposed)
{
throw new ObjectDisposedException("LuceneIndex");
}
if (DirectoryReader.IndexExists(_directory))
{
var writer = GetWriter();
writer.DeleteAll();
}
return(Task.FromResult(0));
}
/// <summary>
/// Sets a different index as the spell checker index or re-open
/// the existing index if <code>spellIndex</code> is the same value
/// as given in the constructor. </summary>
/// <param name="spellIndexDir"> the spell directory to use </param>
/// <exception cref="ObjectDisposedException"> if the Spellchecker is already closed </exception>
/// <exception cref="IOException"> if spellchecker can not open the directory </exception>
// TODO: we should make this final as it is called in the constructor
public virtual void SetSpellIndex(Directory spellIndexDir)
{
// this could be the same directory as the current spellIndex
// modifications to the directory should be synchronized
lock (modifyCurrentIndexLock)
{
EnsureOpen();
if (!DirectoryReader.IndexExists(spellIndexDir))
{
#pragma warning disable 612, 618
using var writer = new IndexWriter(spellIndexDir, new IndexWriterConfig(LuceneVersion.LUCENE_CURRENT, null));
#pragma warning restore 612, 618
}
SwapSearcher(spellIndexDir);
}
}
/// <summary>
/// Deletes all
/// </summary>
/// <returns>True if operation was successful</returns>
public bool ClearLuceneIndex()
{
if (DirectoryReader.IndexExists(LuceneDirectory))
{
try
{
// remove older index entries
writer.DeleteAll();
writer.Commit();
}
catch (Exception)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Returns the last <see cref="IndexCommit"/> found in the <see cref="Directory"/>, or
/// <c>null</c> if there are no commits.
/// </summary>
/// <exception cref="IOException"></exception>
public static IndexCommit GetLastCommit(Directory directory)
{
try
{
// IndexNotFoundException which we handle below
if (DirectoryReader.IndexExists(directory))
{
var commits = DirectoryReader.ListCommits(directory);
return(commits[commits.Count - 1]);
}
}
catch (IndexNotFoundException)
{
// ignore the exception and return null
}
return(null);
}
public virtual void TestCommit()
{
// Verifies that nothing is committed to the underlying Directory, if
// commit() wasn't called.
Directory dir = NewDirectory();
var ltw = new DirectoryTaxonomyWriter(dir, OpenMode.CREATE_OR_APPEND, NO_OP_CACHE);
Assert.False(DirectoryReader.IndexExists(dir));
ltw.Commit(); // first commit, so that an index will be created
ltw.AddCategory(new FacetLabel("a"));
IndexReader r = DirectoryReader.Open(dir);
Assert.AreEqual(1, r.NumDocs, "No categories should have been committed to the underlying directory");
r.Dispose();
ltw.Dispose();
dir.Dispose();
}
public HashSet <String> GetAllValuesByField(string field_name)
{
HashSet <String> uniqueTerms = new HashSet <string>();
if (DirectoryReader.IndexExists(indexDirectory))
{
var reader = DirectoryReader.Open(indexDirectory);
for (int i = 0; i < reader.MaxDoc; i++)
{
HashSet <string> field_names = new HashSet <string>();
field_names.Add(field_name);
Document doc = reader.Document(i, field_names);
String field_value = doc.Get(field_name);
uniqueTerms.Add(field_value);
}
}
return(uniqueTerms);
}
/// <summary>
/// Creates the index for a given type if it doesn't exist
/// </summary>
/// <param name="indexName"></param>
/// <returns></returns>
public Task CreateIndexIfNotExists(string indexName)
{
bool exists = DirectoryReader.IndexExists(GetDirectory(indexName));
if (exists)
{
return(Task.FromResult(0));
}
return(Task.Run(() =>
{
using (var analyzer = new StandardAnalyzer(_luceneConfig.LuceneVersion))
{
var config = new IndexWriterConfig(_luceneConfig.LuceneVersion, analyzer);
using (new IndexWriter(GetDirectory(indexName), config))
{
}
}
}));
}
/// <summary>
/// Create a new instance, loading from a previously built
/// AnalyzingInfixSuggester directory, if it exists. This directory must be
/// private to the infix suggester (i.e., not an external
/// Lucene index). Note that <seealso cref="#close"/>
/// will also close the provided directory.
/// </summary>
/// <param name="minPrefixChars"> Minimum number of leading characters
/// before PrefixQuery is used (default 4).
/// Prefixes shorter than this are indexed as character
/// ngrams (increasing index size but making lookups
/// faster). </param>
public AnalyzingInfixSuggester(Version matchVersion, Directory dir, Analyzer indexAnalyzer, Analyzer queryAnalyzer, int minPrefixChars)
{
if (minPrefixChars < 0)
{
throw new System.ArgumentException("minPrefixChars must be >= 0; got: " + minPrefixChars);
}
this.queryAnalyzer = queryAnalyzer;
this.indexAnalyzer = indexAnalyzer;
this.matchVersion = matchVersion;
this.dir = dir;
this.minPrefixChars = minPrefixChars;
if (DirectoryReader.IndexExists(dir))
{
// Already built; open it:
writer = new IndexWriter(dir, GetIndexWriterConfig(matchVersion, GramAnalyzer, IndexWriterConfig.OpenMode.APPEND));
searcherMgr = new SearcherManager(writer, true, null);
}
}
/// <summary>
/// Constructor with the given index directory and callback to notify when the
/// indexes were updated.
/// </summary>
public IndexReplicationHandler(Directory indexDirectory, Func <bool?> callback) // LUCENENET TODO: API - shouldn't this be Action ?
{
this.InfoStream = InfoStream.Default;
this.callback = callback;
this.indexDirectory = indexDirectory;
currentVersion = null;
currentRevisionFiles = null;
if (DirectoryReader.IndexExists(indexDirectory))
{
IList <IndexCommit> commits = DirectoryReader.ListCommits(indexDirectory);
IndexCommit commit = commits[commits.Count - 1];
currentVersion = IndexRevision.RevisionVersion(commit);
currentRevisionFiles = IndexRevision.RevisionFiles(commit);
WriteToInfoStream(
string.Format("constructor(): currentVersion={0} currentRevisionFiles={1}", currentVersion, currentRevisionFiles),
string.Format("constructor(): commit={0}", commit));
}
}
public static bool OpenIndex()
{
OpenDirectory();
if (Dir != null)
{
if (DirectoryReader.IndexExists(Dir))
{
OpenAnalyzers();
OpenReader();
OpenParser();
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
/// <summary>
/// Create a new instance, loading from a previously built
/// <see cref="AnalyzingInfixSuggester"/> directory, if it exists. This directory must be
/// private to the infix suggester (i.e., not an external
/// Lucene index). Note that <see cref="Dispose()"/>
/// will also dispose the provided directory.
/// </summary>
/// <param name="minPrefixChars"> Minimum number of leading characters
/// before <see cref="PrefixQuery"/> is used (default 4).
/// Prefixes shorter than this are indexed as character
/// ngrams (increasing index size but making lookups
/// faster). </param>
/// <param name="commitOnBuild"> Call commit after the index has finished building. This
/// would persist the suggester index to disk and future instances of this suggester can
/// use this pre-built dictionary. </param>
// LUCENENET specific - LUCENE-5889, a 4.11.0 feature. (Code moved from other constructor to here.)
public AnalyzingInfixSuggester(LuceneVersion matchVersion, Directory dir, Analyzer indexAnalyzer,
Analyzer queryAnalyzer, int minPrefixChars, bool commitOnBuild)
{
if (minPrefixChars < 0)
{
throw new ArgumentOutOfRangeException("minPrefixChars must be >= 0; got: " + minPrefixChars);// LUCENENET specific - changed from IllegalArgumentException to ArgumentOutOfRangeException (.NET convention)
}
this.m_queryAnalyzer = queryAnalyzer;
this.m_indexAnalyzer = indexAnalyzer;
this.matchVersion = matchVersion;
this.dir = dir;
this.minPrefixChars = minPrefixChars;
this.commitOnBuild = commitOnBuild;
if (DirectoryReader.IndexExists(dir))
{
// Already built; open it:
writer = new IndexWriter(dir, GetIndexWriterConfig(matchVersion, GetGramAnalyzer(), OpenMode.APPEND));
m_searcherMgr = new SearcherManager(writer, true, null);
}
}
public void Initialize(String directoryProviderName, IDictionary <string, string> properties, ISearchFactoryImplementor searchFactory)
{
DirectoryInfo indexDir = DirectoryProviderHelper.DetermineIndexDir(directoryProviderName, (IDictionary)properties);
try
{
indexName = indexDir.FullName;
directory = FSDirectory.Open(indexDir.FullName);
if (DirectoryReader.IndexExists(directory))
{
return;
}
var config = new IndexWriterConfig(LuceneVersion.LUCENE_48, new StandardAnalyzer(LuceneVersion.LUCENE_48));
var writer = new IndexWriter(directory, config);
writer.Dispose();
}
catch (IOException e)
{
throw new HibernateException("Unable to initialize index: " + directoryProviderName, e);
}
}
public void Initialize(string directoryProviderName, IDictionary <string, string> properties, ISearchFactoryImplementor searchFactory)
{
this.properties = properties;
this.directoryProviderName = directoryProviderName;
// source guessing
source = DirectoryProviderHelper.GetSourceDirectory(Environment.SourceBase, Environment.Source, directoryProviderName, (IDictionary)properties);
if (source == null)
{
throw new ArgumentException("FSMasterDirectoryProvider requires a viable source directory");
}
log.Debug("Source directory: " + source);
indexDir = DirectoryProviderHelper.DetermineIndexDir(directoryProviderName, (IDictionary)properties);
indexName = indexDir.FullName;
log.Debug("Index directory: " + indexDir);
try
{
// NB Do we need to do this since we are passing the create flag to Lucene?
directory = FSDirectory.Open(indexName);
if (!DirectoryReader.IndexExists(directory))
{
log.DebugFormat("Index directory not found, creating '{0}'", indexDir.FullName);
indexDir.Create();
indexName = indexDir.FullName;
var config = new IndexWriterConfig(LuceneVersion.LUCENE_48, new StandardAnalyzer(LuceneVersion.LUCENE_48));
IndexWriter iw = new IndexWriter(directory, config);
iw.Dispose();
}
}
catch (IOException e)
{
throw new HibernateException("Unable to initialize index: " + directoryProviderName, e);
}
this.searchFactory = searchFactory;
}
