private static void ConfigureIndexingParameters(ISearchFactoryImplementor searchFactoryImplementor, IDictionary<string, string> indexProps, IDirectoryProvider provider)
        {
            LuceneIndexingParameters indexingParams = new LuceneIndexingParameters();

            ConfigureProp(
                    TRANSACTION + MERGE_FACTOR,
                    indexProps,
                    delegate(int value)
                    {
                        indexingParams.BatchIndexParameters.MergeFactor = value;
                        indexingParams.TransactionIndexParameters.MergeFactor = value;
                    });

            ConfigureProp(
                    TRANSACTION + MAX_MERGE_DOCS,
                    indexProps,
                    delegate(int value)
                    {
                        indexingParams.BatchIndexParameters.MaxMergeDocs = value;
                        indexingParams.TransactionIndexParameters.MaxMergeDocs = value;
                    });

            ConfigureProp(
                    TRANSACTION + MAX_BUFFERED_DOCS,
                    indexProps,
                    delegate(int value)
                    {
                        indexingParams.BatchIndexParameters.MaxBufferedDocs = value;
                        indexingParams.TransactionIndexParameters.MaxBufferedDocs = value;
                    });

            ConfigureProp(
                    TRANSACTION + RAM_BUFFER_SIZE,
                    indexProps,
                    delegate(int value)
                    {
                        indexingParams.BatchIndexParameters.RamBufferSizeMb = value;
                        indexingParams.TransactionIndexParameters.RamBufferSizeMb = value;
                    });

            ConfigureProp(
                    TRANSACTION + TERM_INDEX_INTERVAL,
                    indexProps,
                    delegate(int value)
                    {
                        indexingParams.BatchIndexParameters.TermIndexInterval = value;
                        indexingParams.TransactionIndexParameters.TermIndexInterval = value;
                    });

            ConfigureProp(
                    BATCH + MERGE_FACTOR,
                    indexProps,
                    delegate(int value)
                    {
                        indexingParams.BatchIndexParameters.MergeFactor = value;
                    });

            ConfigureProp(
                    BATCH + MAX_MERGE_DOCS,
                    indexProps,
                    delegate(int value)
                    {
                        indexingParams.BatchIndexParameters.MaxMergeDocs = value;
                    });

            ConfigureProp(
                    BATCH + MAX_BUFFERED_DOCS,
                    indexProps,
                    delegate(int value)
                    {
                        indexingParams.BatchIndexParameters.MaxBufferedDocs = value;
                    });

            ConfigureProp(
                    BATCH + RAM_BUFFER_SIZE,
                    indexProps,
                    delegate(int value)
                    {
                        indexingParams.BatchIndexParameters.RamBufferSizeMb = value;
                    });

            ConfigureProp(
                    BATCH + TERM_INDEX_INTERVAL,
                    indexProps,
                    delegate(int value)
                    {
                        indexingParams.BatchIndexParameters.TermIndexInterval = value;
                    });

            searchFactoryImplementor.AddIndexingParameters(provider, indexingParams);
        }
Example #2
0
        /// <summary>
        /// Retrieve a read/write <see cref="IndexWriter" />
        /// </summary>
        /// <param name="provider"></param>
        /// <param name="entity"></param>
        /// <param name="modificationOperation"></param>
        /// <returns></returns>
        public IndexWriter GetIndexWriter(IDirectoryProvider provider, System.Type entity, bool modificationOperation)
        {
            // Have to close the reader before the writer is accessed.
            IndexReader reader;

            readers.TryGetValue(provider, out reader);
            if (reader != null)
            {
                try
                {
                    reader.Close();
                }
                catch (IOException ex)
                {
                    throw new SearchException("Exception while closing IndexReader", ex);
                }
                finally
                {
                    readers.Remove(provider);

                    // PH - Moved the exit lock out of the try otherwise it won't take place when we have an error closing the reader.
                    // Exit Lock added by Kailuo Wang, because the lock needs to be obtained immediately afterwards
                    object syncLock = searchFactoryImplementor.GetLockableDirectoryProviders()[provider];
                    Monitor.Exit(syncLock);
                }
            }

            if (writers.ContainsKey(provider))
            {
                return(writers[provider]);
            }

            LockProvider(provider);

            if (modificationOperation)
            {
                dpStatistics[provider].Operations++;
            }

            try
            {
                Analyzer analyzer = entity != null
                                        ? searchFactoryImplementor.DocumentBuilders[entity].Analyzer
                                        : new StandardAnalyzer(Environment.LuceneVersion);
                IndexWriter writer = new IndexWriter(provider.Directory, analyzer, IndexWriter.MaxFieldLength.UNLIMITED);

                LuceneIndexingParameters indexingParams = searchFactoryImplementor.GetIndexingParameters(provider);
                if (IsBatch)
                {
                    indexingParams.BatchIndexParameters.ApplyToWriter(writer);
                }
                else
                {
                    indexingParams.TransactionIndexParameters.ApplyToWriter(writer);
                }

                writers.Add(provider, writer);

                return(writer);
            }
            catch (IOException ex)
            {
                CleanUp(new SearchException("Unable to open IndexWriter" + (entity != null ? " for " + entity : ""), ex));
            }

            return(null);
        }
 public void AddIndexingParameters(IDirectoryProvider provider, LuceneIndexingParameters indexingParameters)
 {
     dirProviderIndexingParams[provider] = indexingParameters;
 }