protected IndexWriter GetIndexWriter(FSDirectory directory) { return new IndexWriter( this.GetDirectory(), LuceneEngineBase.GetAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED); }
public LuceneWriter(string folder) { _folder = folder; _indexDirectory = FSDirectory.Open(new DirectoryInfo(folder)); _standardAnalyzer = new StandardAnalyzer(Version.LUCENE_30); _indexWriter = new IndexWriter(_indexDirectory, _standardAnalyzer, IndexWriter.MaxFieldLength.UNLIMITED); }
protected override Directory GetDirectory() { if(this._directory == null) this._directory = FSDirectory.Open(new System.IO.DirectoryInfo(this._path)); return this._directory; }
/// <summary> /// Constructor. /// </summary> /// <param name="index">Index path.</param> public LuceneUpdater(FSDirectory index) { this.index = index; // Debug messages log.DebugFormat("Testing if '{0}' index exists...",this.index.Directory.Name); if (!IndexReader.IndexExists(this.index)) { // Debug messages log.Debug("Index doesn't exist!"); log.Debug("Creating one..."); try { Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); this.CreateIndex(); stopwatch.Stop(); // Debug messages log.DebugFormat("Index created at {0} in {1:00}:{2:00}:{3:00}!", index, stopwatch.Elapsed.Hours, stopwatch.Elapsed.Minutes,stopwatch.Elapsed.Seconds); } catch (Exception e) { log.Fatal(string.Format("Error creating index '{0}'!",this.index.Directory.Name), e); } } // Debug messages log.Debug("Lucene updater initialized!"); }
public void Initialize(String directoryProviderName, IDictionary<string, string> properties, ISearchFactoryImplementor searchFactory) { DirectoryInfo indexDir = DirectoryProviderHelper.DetermineIndexDir(directoryProviderName, (IDictionary) properties); try { bool create = !IndexReader.IndexExists(indexDir.FullName); indexName = indexDir.FullName; directory = FSDirectory.GetDirectory(indexName, create); if (create) { IndexWriter iw = new IndexWriter(directory, new StandardAnalyzer(), create, new KeepOnlyLastCommitDeletionPolicy(), IndexWriter.MaxFieldLength.UNLIMITED); iw.Close(); } //searchFactory.RegisterDirectoryProviderForLocks(this); } catch (IOException e) { throw new HibernateException("Unable to initialize index: " + directoryProviderName, e); } }
/// <summary> /// Performs the explanation. /// </summary> /// <param name="luceneVersion">The lucene version.</param> /// <param name="fsDirectory">The fs directory.</param> /// <param name="searchQuery">The search query.</param> /// <param name="resultId">The result identifier.</param> /// <returns></returns> protected virtual string PerformExplain(Version luceneVersion, FSDirectory fsDirectory, string searchQuery, int resultId) { /* * The obvious problem here is that we're not using the exact same search as the real one. */ var explanation = string.Empty; using (var indexSearcher = new IndexSearcher(fsDirectory, false)) { var analyzer = new StandardAnalyzer(luceneVersion); var queryParser = new MultiFieldQueryParser(luceneVersion, new[] { "Id".ToLowerInvariant() }, analyzer) { DefaultOperator = QueryParser.Operator.AND }; var query = this.searchQueryParser.ParseQuery(searchQuery, queryParser); explanation = indexSearcher.Explain(query, resultId).ToHtml(); analyzer.Close(); } return explanation; }
public MultiIndexLockFactory(FSDirectory master, FSDirectory child) { if (master == null) throw new ArgumentNullException("master"); if (child == null) throw new ArgumentNullException("child"); _master = master; _child = child; }
static void Main(string[] args) { //Analyzer analyzer = new StandardAnalyzer(); Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_23); Directory directory = null; //directory.CreateOutput(@"D:\workspace\C#\lucene\lucene\lucene\IndexDirectory"); while (true) { Console.Write("id:"); string id = Console.ReadLine().ToString(); Console.Write("title:"); string title = Console.ReadLine().ToString(); Console.Write("content:"); string content = Console.ReadLine().ToString(); Console.WriteLine("================================="); string indexPath = @"D:\workspace\C#\lucene\lucene\lucene\IndexDirectory"; directory = FSDirectory.Open(new System.IO.DirectoryInfo(indexPath)); IndexWriter writer = new IndexWriter(directory, analyzer, true, IndexWriter.MaxFieldLength.UNLIMITED); AddDocument(writer, id, title, content); writer.Optimize(); writer.Dispose(); } //AddDocument(writer,"1","name","ada"); //AddDocument(writer, "2","SQL Server 2008 的发布ada", "SQL Server 2008 的新特性"); //AddDocument(writer, "3","ASP.Net MVC框架配置与分析", "而今,微软推出了新的MVC开发框架,也就是Microsoft ASP.NET 3.5 Extensions"); }
public ContentSearcher(string indexPath) { this._indexPath = indexPath; this._directory = FSDirectory.Open(new DirectoryInfo(indexPath)); this._indexReader = IndexReader.Open(this._directory, readOnly: true); this._analyzer = new StandardAnalyzer(global::Lucene.Net.Util.Version.LUCENE_29); this._indexSearcher = new IndexSearcher(this._indexReader); }
public LuceneSearcher(string searchIndex) { DirectoryInfo indexDirectory = GetIndexPath(searchIndex); directory = FSDirectory.Open(indexDirectory); reader = IndexReader.Open(directory, true); searcher = new IndexSearcher(reader); searchFields = GetSearchFields(reader); }
public SearchIndexer(FSDirectory directory, Analyzer analyzer) { _directory = directory; EnsureThatIndexIsUnlocked(); _analyzer = analyzer; _indexWriter = new IndexWriter(directory, _analyzer, IndexWriter.MaxFieldLength.UNLIMITED); _open = true; }
public TwitterFeedSearcher(string directoryPath) { dir = FSDirectory.GetDirectory(directoryPath); searcher = new IndexSearcher(dir); var positiveReviews = new Evidence("Positive", "Repository\\Positive.Evidence.csv"); var negativeReviews = new Evidence("Negative", "Repository\\Negative.Evidence.csv"); classifier = new Classifier(positiveReviews, negativeReviews); }
protected AbstractSearchDirectory(string dataFolder) { this.dataFolder = dataFolder; var di = new DirectoryInfo(Path.Combine(dataFolder,LuceneIndexFolder)); if (!di.Exists) { di.Create(); } luceneDirectory = FSDirectory.Open(di.FullName); }
public void Dispose() { Log.App.DebugFormat("Fechando indice"); writer.Dispose(); directory.Dispose(); writer = null; directory = null; }
/// <summary> /// Optimizes the Lucene index. /// </summary> /// <param name="luceneVersion">The lucene version.</param> /// <param name="fsDirectory">The fs directory.</param> /// <param name="maxFieldLength">Maximum length of the field.</param> public virtual void Optimize(Version luceneVersion, FSDirectory fsDirectory, IndexWriter.MaxFieldLength maxFieldLength) { var analyzer = new StandardAnalyzer(luceneVersion); using (var indexWriter = new IndexWriter(fsDirectory, analyzer, maxFieldLength)) { analyzer.Close(); indexWriter.Optimize(); } }
public LocalTempStorageDirectory GetDirectory(DirectoryInfo dir, FSDirectory realDir, bool disable = false) { var resolved = _directories.GetOrAdd(dir.FullName, s => new LocalTempStorageDirectory(dir, realDir)); if (disable) { resolved.Enabled = false; } return resolved; }
/// <summary> /// Clears the entire index. /// </summary> /// <param name="luceneVersion">The lucene version.</param> /// <param name="fsDirectory">The fs directory.</param> /// <param name="maxFieldLength">Maximum length of the field.</param> public virtual void ClearIndex(Version luceneVersion, FSDirectory fsDirectory, IndexWriter.MaxFieldLength maxFieldLength) { var analyzer = new StandardAnalyzer(luceneVersion); using (var indexWriter = new IndexWriter(fsDirectory, analyzer, maxFieldLength)) { indexWriter.DeleteAll(); analyzer.Close(); } }
public void Initialize() { directory = FSDirectory.Open(new DirectoryInfo(path)); if (IndexWriter.IsLocked(directory)) IndexWriter.Unlock(directory); analyzer = new LowerCaseKeywordAnalyzer(); writer = new IndexWriter(directory, analyzer, IndexWriter.MaxFieldLength.UNLIMITED); writer.SetMergeScheduler(new ErrorLoggingConcurrentMergeScheduler()); currentIndexSearcherHolder.SetIndexSearcher(new IndexSearcher(directory, true)); }
/// <summary> /// Before doing anything with the search index, first make sure there's no existing /// write lock on the directory. (This can happen if the application crashes and restarts) /// </summary> static SearchIndex() { _directory = FSDirectory.Open(new DirectoryInfo(_luceneDir)); if (IndexWriter.IsLocked(_directory)) IndexWriter.Unlock(_directory); var lockFilePath = Path.Combine(_luceneDir, "write.lock"); if (File.Exists(lockFilePath)) File.Delete(lockFilePath); }
public static long CalcTotalFileSize(FSDirectory dir) { long totalFileSize = 0; foreach (string file in dir.ListAll()) { totalFileSize += dir.FileLength(file); // FileInfo fi = new FileInfo(file); // totalFileSize += fi.Length; } return totalFileSize; }
public bool TryLoad(string path, IndexLoadOptions options) { try { _directory = FSDirectory.Open(path); _reader = IndexReader.Open(_directory, options.ReadOnly); if (options.ForceUnlock && _directory.FileExists(IndexWriter.WRITE_LOCK_NAME)) { _directory.ClearLock(IndexWriter.WRITE_LOCK_NAME); } var fields = _reader.GetFieldNames(IndexReader.FieldOption.ALL); _numFields = fields.Count; CountTerms(); foreach (var file in _directory.ListAll()) { try { string fpath = Path.Combine(_directory.Directory.ToString(), file); if (_lastModified == null) _lastModified = File.GetLastWriteTimeUtc(fpath); else { var mod = File.GetLastWriteTimeUtc(fpath); if (mod > _lastModified.Value) _lastModified = mod; } } catch { // ignore } } _loaded = true; return true; } catch { _directory = null; _reader = null; _numFields = 0; _numTerms = 0; _loaded = false; _lastModified = null; return false; } }
/// <summary> /// Clears an item from the index. /// </summary> /// <param name="id">The identifier.</param> /// <param name="luceneVersion">The lucene version.</param> /// <param name="fsDirectory">The fs directory.</param> /// <param name="maxFieldLength">Maximum length of the field.</param> public void ClearIndex(string id, Version luceneVersion, FSDirectory fsDirectory, IndexWriter.MaxFieldLength maxFieldLength) { var analyzer = new StandardAnalyzer(luceneVersion); using (var indexWriter = new IndexWriter(fsDirectory, analyzer, maxFieldLength)) { var searchQuery = new TermQuery(new Term("Key", id)); indexWriter.DeleteDocuments(searchQuery); analyzer.Close(); } }
public LuceneIndexerSession Begin(string indexDirectory) { Log.App.DebugFormat("Abrindo indice em {0}", indexDirectory); directory = FSDirectory.Open(new DirectoryInfo(indexDirectory)); writer = new IndexWriter( directory, LuceneEngineBase.GetAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED); return this; }
public LocalTempStorageDirectory( DirectoryInfo tempStorageDir, FSDirectory realDirectory) { if (tempStorageDir == null) throw new ArgumentNullException("tempStorageDir"); if (realDirectory == null) throw new ArgumentNullException("realDirectory"); _tempStorageDir = new SimpleFSDirectory(tempStorageDir); _realDirectory = realDirectory; _lockFactory = new MultiIndexLockFactory(_realDirectory, _tempStorageDir); Enabled = true; }
public Searcher(string indexDirectory) { _indexDirectory = indexDirectory; if (!Directory.Exists(indexDirectory)) Directory.CreateDirectory(indexDirectory); try { _directory = FSDirectory.GetDirectory(_indexDirectory, false); searcher = new IndexSearcher(_directory); } catch (Exception) { IsOperational = false; } }
public void Setup() { var dirProvider = new Mock<IDataDirectoryProvider>(); dirProvider.Setup(x => x.DataDirectoryPath).Returns(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\MyJobLeadsTestIndex"); _provider = new LuceneSearchProvider(dirProvider.Object); // Load the index and delete all documents so it's fresh for the test _indexDirectory = Lucene.Net.Store.FSDirectory.Open(new DirectoryInfo(_provider.LuceneIndexBaseDirectory)); bool createNewIndex = !IndexReader.IndexExists(_indexDirectory); var writer = new IndexWriter(_indexDirectory, new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29), createNewIndex, IndexWriter.MaxFieldLength.UNLIMITED); writer.DeleteAll(); writer.Close(); }
public void Initialize() { if (System.IO.Directory.Exists(path) == false) System.IO.Directory.CreateDirectory(path); directory = FSDirectory.Open(new DirectoryInfo(path)); if (IndexWriter.IsLocked(directory)) IndexWriter.Unlock(directory); analyzer = new LowerCaseKeywordAnalyzer(); snapshotter = new SnapshotDeletionPolicy(new KeepOnlyLastCommitDeletionPolicy()); writer = new IndexWriter(directory, analyzer, snapshotter, IndexWriter.MaxFieldLength.UNLIMITED); writer.SetMergeScheduler(new ErrorLoggingConcurrentMergeScheduler()); currentIndexSearcherHolder.SetIndexSearcher(new IndexSearcher(directory, true)); }
private LuceneStore() { string indexPath = Path.Combine( Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "LuceneIndex"); this.luceneIndexDirectory = FSDirectory.Open(indexPath); this.analyzer = new StandardAnalyzer(Version); this.writer = new IndexWriter( luceneIndexDirectory, this.analyzer, !System.IO.Directory.Exists(indexPath), IndexWriter.MaxFieldLength.UNLIMITED); this.searcher = new IndexSearcher(this.luceneIndexDirectory); }
public SearchManager(string indexLocation) { if (string.IsNullOrEmpty(indexLocation)) throw new FileNotFoundException("The lucene index could not be found."); _luceneVersion = Version.LUCENE_30; var resolvedServerLocation = HttpContext.Current.Server.MapPath(string.Format("~{0}", indexLocation)); _directory = FSDirectory.Open(new DirectoryInfo(resolvedServerLocation)); var createIndex = !IndexReader.IndexExists(_directory); _writer = new IndexWriter(_directory, new StandardAnalyzer(_luceneVersion), createIndex, IndexWriter.MaxFieldLength.UNLIMITED); _analyzer = new PerFieldAnalyzerWrapper(new StandardAnalyzer(_luceneVersion)); }
/// <summary> /// This will load a file based index into RAM /// </summary> protected virtual RAMDirectory CreateDirectory(string folder) { FileUtil.EnsureFolder(folder); Lucene.Net.Store.FSDirectory tempDirectory = Lucene.Net.Store.FSDirectory.GetDirectory(folder, false); var directory = new RAMDirectory(tempDirectory); using (new IndexLocker(directory.MakeLock("write.lock"))) { if (!IndexReader.IndexExists(directory)) { new IndexWriter(directory, this._analyzer, true).Close(); } } return(directory); }
/// <summary> /// Initializes a new instance of the <see cref="MoreUmbracoDocsLikeThis"/> class. /// </summary> /// <param name="DocId">The doc id.</param> /// <param name="IndexToSearch">The index to search.</param> /// <param name="MaxNo">The max no.</param> /// <param name="FieldsToSearch">The fields to search.</param> public MoreUmbracoDocsLikeThis(int DocId, string IndexToSearch, int MaxNo, IEnumerable<string> FieldsToSearch) { docId = DocId; indexToSearch = IndexToSearch; maxNo = MaxNo; fieldsToSearch = FieldsToSearch; try { directory = FSDirectory.Open(new DirectoryInfo(GetIndexPath(indexToSearch))); reader = IndexReader.Open(directory, true); searcher = new IndexSearcher(reader); } catch (Exception ex) { ex.ToString(); } }
protected override void Dispose(bool disposing) { if (isDisposed) { return; } if (disposing) { if (fsDir != null) { fsDir.Close(); } } fsDir = null; isDisposed = true; }
//--- Constructors --- public SearchInstanceData(string indexPath, Analyzer analyzer, UpdateDelayQueue queue) { _analyzer = analyzer; _directory = FSDirectory.GetDirectory(indexPath); // Note (arnec): Needed with 2.4.0 SimpleFSLock, since a hard shutdown will have left the lock dangling IndexWriter.Unlock(_directory); try { _writer = new IndexWriter(_directory, _analyzer, IndexWriter.MaxFieldLength.UNLIMITED); } catch(CorruptIndexException e) { _log.WarnFormat("The Search index at {0} is corrupt. You must repair or delete it before restarting the service. If you delete it, you must rebuild your index after service restart.", indexPath); if(e.Message.StartsWith("Unknown format version")) { _log.Warn("The index is considered corrupt because it's an unknown version. Did you accidentally downgrade your install?"); } throw; } _reader = IndexReader.Open(_directory); _searcher = new IndexSearcher(_reader); _queue = queue; }
static void Main(string[] args) { Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_23); //IndexWriter writer = new IndexWriter("IndexDirectory", analyzer, true); //AddDocument(writer, "SQL Server 2008 的发布", "SQL Server 2008 的新特性"); //AddDocument(writer, "ASP.Net MVC框架配置与分析", "而今,微软推出了新的MVC开发框架,也就是Microsoft ASP.NET 3.5 Extensions"); //writer.Optimize(); //writer.Close(); while (true) { Console.Write("key:"); string key = Console.ReadLine().ToString(); string indexPath = @"D:\workspace\C#\lucene\lucene\lucene\IndexDirectory"; Directory directory = null; directory = FSDirectory.Open(new System.IO.DirectoryInfo(indexPath)); IndexSearcher searcher = new IndexSearcher(directory); MultiFieldQueryParser parser = new MultiFieldQueryParser(Version.LUCENE_23, new string[] { "title", "content" }, analyzer); Query query = parser.Parse(key); TopDocs hits = searcher.Search(query, (Filter)null, 1000); foreach (ScoreDoc hit in hits.ScoreDocs) { Document doc = searcher.Doc(hit.Doc); string id = doc.Get("id"); string title = doc.Get("title"); string content = doc.Get("content"); Console.WriteLine("title:{0},content:{1},id:{2}", title, content, id); } searcher.Dispose(); Console.WriteLine("================================="); } Console.ReadKey(); }
public virtual void TestNorms() { // tmp dir System.String tempDir = System.IO.Path.GetTempPath(); if (tempDir == null) { throw new System.IO.IOException("java.io.tmpdir undefined, cannot run test"); } // test with a single index: index1 System.IO.DirectoryInfo indexDir1 = new System.IO.DirectoryInfo(System.IO.Path.Combine(tempDir, "lucenetestindex1")); Directory dir1 = FSDirectory.Open(indexDir1); IndexWriter.Unlock(dir1); norms = new System.Collections.ArrayList(); modifiedNorms = new System.Collections.ArrayList(); CreateIndex(dir1); DoTestNorms(dir1); // test with a single index: index2 System.Collections.ArrayList norms1 = norms; System.Collections.ArrayList modifiedNorms1 = modifiedNorms; int numDocNorms1 = numDocNorms; norms = new System.Collections.ArrayList(); modifiedNorms = new System.Collections.ArrayList(); numDocNorms = 0; System.IO.DirectoryInfo indexDir2 = new System.IO.DirectoryInfo(System.IO.Path.Combine(tempDir, "lucenetestindex2")); Directory dir2 = FSDirectory.Open(indexDir2); CreateIndex(dir2); DoTestNorms(dir2); // add index1 and index2 to a third index: index3 System.IO.DirectoryInfo indexDir3 = new System.IO.DirectoryInfo(System.IO.Path.Combine(tempDir, "lucenetestindex3")); Directory dir3 = FSDirectory.Open(indexDir3); CreateIndex(dir3); IndexWriter iw = new IndexWriter(dir3, anlzr, false, IndexWriter.MaxFieldLength.LIMITED); iw.SetMaxBufferedDocs(5); iw.MergeFactor = 3; iw.AddIndexesNoOptimize(new Directory[] { dir1, dir2 }); iw.Optimize(); iw.Close(); norms1.AddRange(norms); norms = norms1; modifiedNorms1.AddRange(modifiedNorms); modifiedNorms = modifiedNorms1; numDocNorms += numDocNorms1; // test with index3 VerifyIndex(dir3); DoTestNorms(dir3); // now with optimize iw = new IndexWriter(dir3, anlzr, false, IndexWriter.MaxFieldLength.LIMITED); iw.SetMaxBufferedDocs(5); iw.MergeFactor = 3; iw.Optimize(); iw.Close(); VerifyIndex(dir3); dir1.Close(); dir2.Close(); dir3.Close(); }
public virtual void TestDirectInstantiation() { DirectoryInfo path = CreateTempDir("testDirectInstantiation"); byte[] largeBuffer = new byte[Random.Next(256 * 1024)], largeReadBuffer = new byte[largeBuffer.Length]; for (int i = 0; i < largeBuffer.Length; i++) { largeBuffer[i] = (byte)i; // automatically loops with modulo } var dirs = new FSDirectory[] { new SimpleFSDirectory(path, null), new NIOFSDirectory(path, null), new MMapDirectory(path, null) }; for (int i = 0; i < dirs.Length; i++) { FSDirectory dir = dirs[i]; dir.EnsureOpen(); string fname = "foo." + i; string lockname = "foo" + i + ".lck"; IndexOutput @out = dir.CreateOutput(fname, NewIOContext(Random)); @out.WriteByte((byte)(sbyte)i); @out.WriteBytes(largeBuffer, largeBuffer.Length); @out.Dispose(); for (int j = 0; j < dirs.Length; j++) { FSDirectory d2 = dirs[j]; d2.EnsureOpen(); Assert.IsTrue(SlowFileExists(d2, fname)); Assert.AreEqual(1 + largeBuffer.Length, d2.FileLength(fname)); // LUCENENET specific - unmap hack not needed //// don't do read tests if unmapping is not supported! //if (d2 is MMapDirectory && !((MMapDirectory)d2).UseUnmap) //{ // continue; //} IndexInput input = d2.OpenInput(fname, NewIOContext(Random)); Assert.AreEqual((byte)i, input.ReadByte()); // read array with buffering enabled Arrays.Fill(largeReadBuffer, (byte)0); input.ReadBytes(largeReadBuffer, 0, largeReadBuffer.Length, true); Assert.AreEqual(largeBuffer, largeReadBuffer); // read again without using buffer input.Seek(1L); Arrays.Fill(largeReadBuffer, (byte)0); input.ReadBytes(largeReadBuffer, 0, largeReadBuffer.Length, false); Assert.AreEqual(largeBuffer, largeReadBuffer); input.Dispose(); } // delete with a different dir dirs[(i + 1) % dirs.Length].DeleteFile(fname); for (int j = 0; j < dirs.Length; j++) { FSDirectory d2 = dirs[j]; Assert.IsFalse(SlowFileExists(d2, fname)); } Lock @lock = dir.MakeLock(lockname); Assert.IsTrue(@lock.Obtain()); for (int j = 0; j < dirs.Length; j++) { FSDirectory d2 = dirs[j]; Lock lock2 = d2.MakeLock(lockname); try { Assert.IsFalse(lock2.Obtain(1)); } #pragma warning disable 168 catch (LockObtainFailedException e) #pragma warning restore 168 { // OK } } @lock.Dispose(); // now lock with different dir @lock = dirs[(i + 1) % dirs.Length].MakeLock(lockname); Assert.IsTrue(@lock.Obtain()); @lock.Dispose(); } for (int i = 0; i < dirs.Length; i++) { FSDirectory dir = dirs[i]; dir.EnsureOpen(); dir.Dispose(); Assert.IsFalse(dir.IsOpen); } }
public virtual void TestFSDirectoryFilter() { CheckDirectoryFilter(FSDirectory.Open(new System.IO.FileInfo("test"))); }
public static int Main(System.String[] args) { bool doFix = false; var onlySegments = new List <string>(); System.String indexPath = null; int i = 0; while (i < args.Length) { if (args[i].Equals("-fix")) { doFix = true; i++; } else if (args[i].Equals("-segment")) { if (i == args.Length - 1) { System.Console.Out.WriteLine("ERROR: missing name for -segment option"); return(1); } onlySegments.Add(args[i + 1]); i += 2; } else { if (indexPath != null) { System.Console.Out.WriteLine("ERROR: unexpected extra argument '" + args[i] + "'"); return(1); } indexPath = args[i]; i++; } } if (indexPath == null) { System.Console.Out.WriteLine("\nERROR: index path not specified"); System.Console.Out.WriteLine("\nUsage: java Lucene.Net.Index.CheckIndex pathToIndex [-fix] [-segment X] [-segment Y]\n" + "\n" + " -fix: actually write a new segments_N file, removing any problematic segments\n" + " -segment X: only check the specified segments. This can be specified multiple\n" + " times, to check more than one segment, eg '-segment _2 -segment _a'.\n" + " You can't use this with the -fix option\n" + "\n" + "**WARNING**: -fix should only be used on an emergency basis as it will cause\n" + "documents (perhaps many) to be permanently removed from the index. Always make\n" + "a backup copy of your index before running this! Do not run this tool on an index\n" + "that is actively being written to. You have been warned!\n" + "\n" + "Run without -fix, this tool will open the index, report version information\n" + "and report any exceptions it hits and what action it would take if -fix were\n" + "specified. With -fix, this tool will remove any segments that have issues and\n" + "write a new segments_N file. This means all documents contained in the affected\n" + "segments will be removed.\n" + "\n" + "This tool exits with exit code 1 if the index cannot be opened or has any\n" + "corruption, else 0.\n"); return(1); } if (!AssertsOn()) { System.Console.Out.WriteLine("\nNOTE: testing will be more thorough if you run java with '-ea:Lucene.Net...', so assertions are enabled"); } if (onlySegments.Count == 0) { onlySegments = null; } else if (doFix) { System.Console.Out.WriteLine("ERROR: cannot specify both -fix and -segment"); return(1); } System.Console.Out.WriteLine("\nOpening index @ " + indexPath + "\n"); Directory dir = null; try { dir = FSDirectory.Open(new System.IO.DirectoryInfo(indexPath)); } catch (Exception t) { Console.Out.WriteLine("ERROR: could not open directory \"" + indexPath + "\"; exiting"); Console.Out.WriteLine(t.StackTrace); return(1); } var checker = new CheckIndex(dir); var tempWriter = new System.IO.StreamWriter(System.Console.OpenStandardOutput(), System.Console.Out.Encoding) { AutoFlush = true }; checker.SetInfoStream(tempWriter); Status result = checker.CheckIndex_Renamed_Method(onlySegments, null); if (result.missingSegments) { return(1); } if (!result.clean) { if (!doFix) { System.Console.Out.WriteLine("WARNING: would write new segments file, and " + result.totLoseDocCount + " documents would be lost, if -fix were specified\n"); } else { Console.Out.WriteLine("WARNING: " + result.totLoseDocCount + " documents will be lost\n"); Console.Out.WriteLine("NOTE: will write new segments file in 5 seconds; this will remove " + result.totLoseDocCount + " docs from the index. THIS IS YOUR LAST CHANCE TO CTRL+C!"); for (var s = 0; s < 5; s++) { System.Threading.Thread.Sleep(new System.TimeSpan((System.Int64) 10000 * 1000)); System.Console.Out.WriteLine(" " + (5 - s) + "..."); } Console.Out.WriteLine("Writing..."); checker.FixIndex(result, null); Console.Out.WriteLine("OK"); Console.Out.WriteLine("Wrote new segments file \"" + result.newSegments.GetCurrentSegmentFileName() + "\""); } } System.Console.Out.WriteLine(""); int exitCode; if (result != null && result.clean == true) { exitCode = 0; } else { exitCode = 1; } return(exitCode); }
public AnonymousClassLock(System.IO.FileInfo lockFile, FSDirectory enclosingInstance) { InitBlock(lockFile, enclosingInstance); }
public RAMDirectory(System.String dir) : this(FSDirectory.GetDirectory(dir), true) { }
public virtual void TestLazyPerformance() { System.String tmpIODir = AppSettings.Get("tempDir", Path.GetTempPath()); System.String path = tmpIODir + System.IO.Path.DirectorySeparatorChar.ToString() + "lazyDir" + Guid.NewGuid(); System.IO.DirectoryInfo file = new System.IO.DirectoryInfo(path); _TestUtil.RmDir(file); FSDirectory tmpDir = FSDirectory.Open(file); Assert.IsTrue(tmpDir != null); IndexWriter writer = new IndexWriter(tmpDir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED, null); writer.UseCompoundFile = false; writer.AddDocument(testDoc, null); writer.Close(); Assert.IsTrue(fieldInfos != null); FieldsReader reader; long lazyTime = 0; long regularTime = 0; int length = 50; ISet <string> lazyFieldNames = Support.Compatibility.SetFactory.CreateHashSet <string>(); lazyFieldNames.Add(DocHelper.LARGE_LAZY_FIELD_KEY); SetBasedFieldSelector fieldSelector = new SetBasedFieldSelector(Support.Compatibility.SetFactory.CreateHashSet <string>(), lazyFieldNames); for (int i = 0; i < length; i++) { reader = new FieldsReader(tmpDir, TEST_SEGMENT_NAME, fieldInfos, null); Assert.IsTrue(reader != null); Assert.IsTrue(reader.Size() == 1); Document doc; doc = reader.Doc(0, null, null); //Load all of them Assert.IsTrue(doc != null, "doc is null and it shouldn't be"); IFieldable field = doc.GetFieldable(DocHelper.LARGE_LAZY_FIELD_KEY); Assert.IsTrue(field.IsLazy == false, "field is lazy"); System.String value_Renamed; long start; long finish; start = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond); //On my machine this was always 0ms. value_Renamed = field.StringValue(null); finish = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond); Assert.IsTrue(value_Renamed != null, "value is null and it shouldn't be"); Assert.IsTrue(field != null, "field is null and it shouldn't be"); regularTime += (finish - start); reader.Dispose(); reader = null; doc = null; //Hmmm, are we still in cache??? System.GC.Collect(); reader = new FieldsReader(tmpDir, TEST_SEGMENT_NAME, fieldInfos, null); doc = reader.Doc(0, fieldSelector, null); field = doc.GetFieldable(DocHelper.LARGE_LAZY_FIELD_KEY); Assert.IsTrue(field.IsLazy == true, "field is not lazy"); start = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond); //On my machine this took around 50 - 70ms value_Renamed = field.StringValue(null); finish = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond); Assert.IsTrue(value_Renamed != null, "value is null and it shouldn't be"); lazyTime += (finish - start); reader.Dispose(); } System.Console.Out.WriteLine("Average Non-lazy time (should be very close to zero): " + regularTime / length + " ms for " + length + " reads"); System.Console.Out.WriteLine("Average Lazy Time (should be greater than zero): " + lazyTime / length + " ms for " + length + " reads"); }
public FaultyFSDirectory(System.IO.DirectoryInfo dir) { fsDir = FSDirectory.Open(dir); interalLockFactory = fsDir.LockFactory; }
public RAMDirectory(System.IO.FileInfo dir) : this(FSDirectory.GetDirectory(dir), true) { }
private void InitBlock(System.IO.FileInfo lockFile, FSDirectory enclosingInstance) { this.lockFile = lockFile; this.enclosingInstance = enclosingInstance; }