Exemplo n.º 1
0
        override protected void DoTaskReal()
        {
            DirectoryModel dir;

            lock (big_lock) {
                if (to_be_crawled.Count == 0)
                {
                    DoneCrawling();
                    return;
                }
                dir = to_be_crawled.Dequeue() as DirectoryModel;

                if (FileSystemQueryable.Debug)
                {
                    Log.Debug("Running tree crawl task");
                }

                SetIsActive(true, dir);
            }

            LuceneQueryable queryable = (LuceneQueryable)Source;

            if (dir.IsAttached)
            {
                if (FileSystemQueryable.Debug)
                {
                    Logger.Log.Debug("Scanning '{0}' for subdirectories", dir.FullName);
                }

                try {
                    foreach (string name in DirectoryWalker.GetDirectoryNames(dir.FullName))
                    {
                        string path;
                        path = Path.Combine(dir.FullName, name);
                        if (!FileSystem.IsSpecialFile(path))
                        {
                            handler(dir, name);
                        }
                    }
                } catch (DirectoryNotFoundException ex) {
                    Logger.Log.Debug("Couldn't scan '{0}' for subdirectories", dir.FullName);
                }
            }

            lock (big_lock) {
                if (to_be_crawled.Count != 0)
                {
                    Reschedule = true;
                }
                else
                {
                    DoneCrawling();
                }
            }
        }
        private ResponseMessage HandleMessage(RequestMessage msg)
        {
            IndexingServiceRequest isr = (IndexingServiceRequest)msg;

            LuceneQueryable backend = this;

            if (isr.Source != null)
            {
                Queryable target = QueryDriver.GetQueryable(isr.Source);

                if (target == null)
                {
                    string err = String.Format("Unable to find backend matching '{0}'", isr.Source);

                    Log.Error(err);
                    return(new ErrorResponse(err));
                }

                if (!(target.IQueryable is LuceneQueryable))
                {
                    string err = String.Format("Backend '{0}' is not an indexed backend", isr.Source);

                    Log.Error(err);
                    return(new ErrorResponse(err));
                }

                backend = (LuceneQueryable)target.IQueryable;
                Log.Debug("Found backend for IndexingServiceRequest: {0}", backend.IndexName);
            }

            // FIXME: There should be a way for the request to control the
            // scheduler priority of the task.

            if (isr.ToAdd.Count > 0 || isr.ToRemove.Count > 0)
            {
                Log.Debug("IndexingService: Adding {0} indexables, removing {1} indexables.", isr.ToAdd.Count, isr.ToRemove.Count);

                IndexableGenerator ind_gen;
                ind_gen = new IndexableGenerator(isr.ToAdd, isr.ToRemove, this);
                Scheduler.Task task = backend.NewAddTask(ind_gen);
                task.Priority = Scheduler.Priority.Immediate;
                ThisScheduler.Add(task);
            }

            // FIXME: There should be an asynchronous response  (fired by a Scheduler.Hook)
            // that fires when all of the items have been added to the index.

            // No response
            return(new EmptyResponse());
        }
            public IndexableGenerator(ICollection to_add, ICollection to_remove_uris, LuceneQueryable submitter_queryable)
            {
                this.count = 0;
                this.submitter_queryable = submitter_queryable;

                if (to_add != null)
                {
                    this.to_add_enumerator = to_add.GetEnumerator();
                    this.count            += to_add.Count;
                }

                if (to_remove_uris != null)
                {
                    this.to_remove_uris_enumerator = to_remove_uris.GetEnumerator();
                    this.count += to_remove_uris.Count;
                }
            }
 public SchedulingIndexableGenerator(LuceneQueryable queryable, string name)
 {
     this.queryable = queryable;
     this.name      = name;
 }
		public SchedulingIndexableGenerator (LuceneQueryable queryable, string name)
		{
			this.queryable = queryable;
			this.name = name;
		}