public void Rebuild()
        {
            Event.RaiseEvent("indexing:start", new object[] { Name, true });

            var indexingStartEvent = new IndexingStartedEvent
            {
                IndexName   = Name,
                FullRebuild = true
            };

            EventManager.QueueEvent(indexingStartEvent);

            Client.DeleteIndex(Name);

            using (var context = CreateUpdateContext())
            {
                foreach (var crawler in Crawlers)
                {
                    crawler.RebuildFromRoot(context);
                }
                context.Commit();
                context.Optimize();
            }

            Event.RaiseEvent("indexing:end", new object[] { Name, true });
            var indexingEndEvent = new IndexingFinishedEvent
            {
                IndexName   = Name,
                FullRebuild = true
            };

            EventManager.QueueEvent(indexingEndEvent);
        }
Ejemplo n.º 2
0
        public virtual void Rebuild()
        {
            Event.RaiseEvent("indexing:start", new object[] { this.Name, true });
            var event2 = new IndexingStartedEvent
            {
                IndexName   = this.Name,
                FullRebuild = true
            };

            EventManager.QueueEvent <IndexingStartedEvent>(event2);
            this.Reset();
            this.DoRebuild();
            Event.RaiseEvent("indexing:end", new object[] { this.Name, true });
            var event3 = new IndexingFinishedEvent
            {
                IndexName   = this.Name,
                FullRebuild = true
            };

            EventManager.QueueEvent <IndexingFinishedEvent>(event3);
        }
        private void PerformUpdate(IEnumerable<IIndexableUniqueId> indexableUniqueIds, IndexingOptions indexingOptions)
        {
            if (!this.ShouldStartIndexing(indexingOptions))
                return;

            var instance1 = this.Locator.GetInstance<IEvent>();
            instance1.RaiseEvent("indexing:start", new object[2]
            {
                this.Name,
                false
            });
            var instance2 = this.Locator.GetInstance<IEventManager>();
            var indexingStartedEvent1 = new IndexingStartedEvent();
            indexingStartedEvent1.IndexName = this.Name;
            indexingStartedEvent1.FullRebuild = false;
            var indexingStartedEvent2 = indexingStartedEvent1;
            instance2.QueueEvent<IndexingStartedEvent>(indexingStartedEvent2);
            var context = this.CreateUpdateContext();
            try
            {
                if (context.IsParallel)
                {
                    Parallel.ForEach<IIndexableUniqueId>(indexableUniqueIds, context.ParallelOptions, (Action<IIndexableUniqueId>)(uniqueId =>
                    {
                        if (!this.ShouldStartIndexing(indexingOptions))
                            return;
                        foreach (var providerCrawler in (IEnumerable<IProviderCrawler>)this.Crawlers)
                            providerCrawler.Update(context, uniqueId, indexingOptions);
                    }));
                    if (!this.ShouldStartIndexing(indexingOptions))
                    {
                        context.Commit();
                        return;
                    }
                }
                else
                {
                    foreach (var indexableUniqueId in indexableUniqueIds)
                    {
                        if (!this.ShouldStartIndexing(indexingOptions))
                        {
                            context.Commit();
                            return;
                        }
                        foreach (IProviderCrawler providerCrawler in (IEnumerable<IProviderCrawler>)this.Crawlers)
                            providerCrawler.Update(context, indexableUniqueId, indexingOptions);
                    }
                }
                context.Commit();
            }
            finally
            {
                if (context != null)
                    context.Dispose();
            }
            instance1.RaiseEvent("indexing:end", new object[2]
            {
                this.Name,
                false
            });
            var instance3 = this.Locator.GetInstance<IEventManager>();
            var indexingFinishedEvent1 = new IndexingFinishedEvent();
            indexingFinishedEvent1.IndexName = this.Name;
            indexingFinishedEvent1.FullRebuild = false;
            var indexingFinishedEvent2 = indexingFinishedEvent1;
            instance3.QueueEvent<IndexingFinishedEvent>(indexingFinishedEvent2);
        }
        private void PerformUpdate(IEnumerable <IIndexableUniqueId> indexableUniqueIds, IndexingOptions indexingOptions)
        {
            if (!this.ShouldStartIndexing(indexingOptions))
            {
                return;
            }

            var instance1 = this.Locator.GetInstance <IEvent>();

            instance1.RaiseEvent("indexing:start", new object[2]
            {
                this.Name,
                false
            });
            var instance2             = this.Locator.GetInstance <IEventManager>();
            var indexingStartedEvent1 = new IndexingStartedEvent();

            indexingStartedEvent1.IndexName   = this.Name;
            indexingStartedEvent1.FullRebuild = false;
            var indexingStartedEvent2 = indexingStartedEvent1;

            instance2.QueueEvent <IndexingStartedEvent>(indexingStartedEvent2);
            var context = this.CreateUpdateContext();

            try
            {
                if (context.IsParallel)
                {
                    Parallel.ForEach <IIndexableUniqueId>(indexableUniqueIds, context.ParallelOptions, (Action <IIndexableUniqueId>)(uniqueId =>
                    {
                        if (!this.ShouldStartIndexing(indexingOptions))
                        {
                            return;
                        }
                        foreach (var providerCrawler in (IEnumerable <IProviderCrawler>) this.Crawlers)
                        {
                            providerCrawler.Update(context, uniqueId, indexingOptions);
                        }
                    }));
                    if (!this.ShouldStartIndexing(indexingOptions))
                    {
                        context.Commit();
                        return;
                    }
                }
                else
                {
                    foreach (var indexableUniqueId in indexableUniqueIds)
                    {
                        if (!this.ShouldStartIndexing(indexingOptions))
                        {
                            context.Commit();
                            return;
                        }
                        foreach (IProviderCrawler providerCrawler in (IEnumerable <IProviderCrawler>) this.Crawlers)
                        {
                            providerCrawler.Update(context, indexableUniqueId, indexingOptions);
                        }
                    }
                }
                context.Commit();
            }
            finally
            {
                if (context != null)
                {
                    context.Dispose();
                }
            }
            instance1.RaiseEvent("indexing:end", new object[2]
            {
                this.Name,
                false
            });
            var instance3 = this.Locator.GetInstance <IEventManager>();
            var indexingFinishedEvent1 = new IndexingFinishedEvent();

            indexingFinishedEvent1.IndexName   = this.Name;
            indexingFinishedEvent1.FullRebuild = false;
            var indexingFinishedEvent2 = indexingFinishedEvent1;

            instance3.QueueEvent <IndexingFinishedEvent>(indexingFinishedEvent2);
        }
 public virtual void Rebuild()
 {
     Event.RaiseEvent("indexing:start", new object[] { this.Name, true });
     var event2 = new IndexingStartedEvent
     {
         IndexName = this.Name,
         FullRebuild = true
     };
     EventManager.QueueEvent<IndexingStartedEvent>(event2);
     this.Reset();
     this.DoRebuild();
     Event.RaiseEvent("indexing:end", new object[] { this.Name, true });
     var event3 = new IndexingFinishedEvent
     {
         IndexName = this.Name,
         FullRebuild = true
     };
     EventManager.QueueEvent<IndexingFinishedEvent>(event3);
 }