示例#1
0
  /**
   * @param writer
   * @param task the task
   * @param taskData may be null for local tasks
   * @throws CorruptIndexException
   * @throws IOException
   */
  private void add(IndexWriter writer, ITask task, TaskData taskData)
      throws CorruptIndexException, IOException {
    if (!taskIsIndexable(task, taskData)) {
      return;
    }

    Document document = new Document();

    document.add(
        new Field(
            FIELD_IDENTIFIER.getIndexKey(),
            task.getHandleIdentifier(),
            Store.YES,
            org.apache.lucene.document.Field.Index.ANALYZED));
    if (taskData == null) {
      if ("local".equals(((AbstractTask) task).getConnectorKind())) { // $NON-NLS-1$
        addIndexedAttributes(document, task);
      } else {
        return;
      }
    } else {
      addIndexedAttributes(document, task, taskData.getRoot());
    }
    writer.addDocument(document);
  }
示例#2
0
  /**
   * Indicates if the given task matches the given pattern string. Uses the backing index to detect
   * a match by looking for tasks that match the given pattern string. The results of the search are
   * cached such that future calls to this method using the same pattern string do not require use
   * of the backing index, making this method very efficient for multiple calls with the same
   * pattern string. Cached results for a given pattern string are discarded if this method is
   * called with a different pattern string.
   *
   * @param task the task to match
   * @param patternString the pattern used to detect a match
   */
  public boolean matches(ITask task, String patternString) {
    if (patternString.equals(COMMAND_RESET_INDEX)) {
      reindex();
    }
    Lock readLock = indexReaderLock.readLock();
    readLock.lock();
    try {

      IndexReader indexReader = getIndexReader();
      if (indexReader != null) {
        Set<String> hits;

        final boolean needIndexHit;
        synchronized (this) {
          needIndexHit =
              lastResults == null
                  || (lastPatternString == null || !lastPatternString.equals(patternString));
        }
        if (needIndexHit) {
          this.lastPatternString = patternString;

          hits = new HashSet<String>();

          IndexSearcher indexSearcher = new IndexSearcher(indexReader);
          try {
            Query query = computeQuery(patternString);
            TopDocs results = indexSearcher.search(query, maxMatchSearchHits);
            for (ScoreDoc scoreDoc : results.scoreDocs) {
              Document document = indexReader.document(scoreDoc.doc);
              hits.add(document.get(FIELD_IDENTIFIER.getIndexKey()));
            }
          } catch (IOException e) {
            StatusHandler.log(
                new Status(
                    IStatus.ERROR,
                    TasksIndexCore.ID_PLUGIN,
                    "Unexpected failure within task list index",
                    e)); //$NON-NLS-1$
          } finally {
            try {
              indexSearcher.close();
            } catch (IOException e) {
              // ignore
            }
          }

        } else {
          hits = lastResults;
        }
        synchronized (this) {
          if (this.indexReader == indexReader) {
            this.lastPatternString = patternString;
            this.lastResults = hits;
          }
        }
        String taskIdentifier = task.getHandleIdentifier();
        return hits != null && hits.contains(taskIdentifier);
      }

    } finally {
      readLock.unlock();
    }
    return false;
  }
示例#3
0
  private void indexQueuedTasks(SubMonitor monitor)
      throws CorruptIndexException, LockObtainFailedException, IOException, CoreException {

    synchronized (reindexQueue) {
      if (reindexQueue.isEmpty()) {
        return;
      }

      monitor.beginTask(Messages.TaskListIndex_task_rebuilding_index, reindexQueue.size());
    }

    try {
      IndexWriter writer = null;
      try {
        Map<ITask, TaskData> workingQueue = new HashMap<ITask, TaskData>();

        // reindex tasks that are in the reindexQueue, making multiple passes so that we catch
        // anything
        // added/changed while we were reindexing
        for (; ; ) {
          workingQueue.clear();

          synchronized (reindexQueue) {
            if (reindexQueue.isEmpty()) {
              break;
            }
            // move items from the reindexQueue to the temporary working queue
            workingQueue.putAll(reindexQueue);
            reindexQueue.keySet().removeAll(workingQueue.keySet());
          }

          if (writer == null) {
            try {
              writer = createIndexWriter(false);
            } catch (CorruptIndexException e) {
              rebuildIndex = true;
              synchronized (reindexQueue) {
                reindexQueue.clear();
              }
              rebuildIndexCompletely(monitor);
              return;
            }
          }

          monitor.setWorkRemaining(workingQueue.size());

          for (Entry<ITask, TaskData> entry : workingQueue.entrySet()) {
            ITask task = entry.getKey();
            TaskData taskData = entry.getValue();

            writer.deleteDocuments(
                new Term(FIELD_IDENTIFIER.getIndexKey(), task.getHandleIdentifier()));

            add(writer, task, taskData);

            monitor.worked(1);
          }
        }
      } finally {
        if (writer != null) {
          writer.close();
        }
      }
    } finally {
      monitor.done();
    }
  }