public Hits search(
      long companyId, long groupId, long[] categoryIds, long threadId, String keywords)
      throws SystemException {

    Searcher searcher = null;

    try {
      HitsImpl hits = new HitsImpl();

      BooleanQuery contextQuery = new BooleanQuery();

      LuceneUtil.addRequiredTerm(contextQuery, LuceneFields.PORTLET_ID, Indexer.PORTLET_ID);

      if (groupId > 0) {
        LuceneUtil.addRequiredTerm(contextQuery, LuceneFields.GROUP_ID, groupId);
      }

      if ((categoryIds != null) && (categoryIds.length > 0)) {
        BooleanQuery categoryIdsQuery = new BooleanQuery();

        for (int i = 0; i < categoryIds.length; i++) {
          Term term = new Term("categoryId", String.valueOf(categoryIds[i]));
          TermQuery termQuery = new TermQuery(term);

          categoryIdsQuery.add(termQuery, BooleanClause.Occur.SHOULD);
        }

        contextQuery.add(categoryIdsQuery, BooleanClause.Occur.MUST);
      }

      if (threadId > 0) {
        LuceneUtil.addTerm(contextQuery, "threadId", threadId);
      }

      BooleanQuery searchQuery = new BooleanQuery();

      if (Validator.isNotNull(keywords)) {
        LuceneUtil.addTerm(searchQuery, LuceneFields.USER_NAME, keywords);
        LuceneUtil.addTerm(searchQuery, LuceneFields.TITLE, keywords);
        LuceneUtil.addTerm(searchQuery, LuceneFields.CONTENT, keywords);
        LuceneUtil.addTerm(searchQuery, LuceneFields.TAG_ENTRY, keywords);
      }

      BooleanQuery fullQuery = new BooleanQuery();

      fullQuery.add(contextQuery, BooleanClause.Occur.MUST);

      if (searchQuery.clauses().size() > 0) {
        fullQuery.add(searchQuery, BooleanClause.Occur.MUST);
      }

      searcher = LuceneUtil.getSearcher(companyId);

      hits.recordHits(searcher.search(fullQuery), searcher);

      return hits;
    } catch (Exception e) {
      return LuceneUtil.closeSearcher(searcher, keywords, e);
    }
  }
Пример #2
0
  public TopFieldDocsSearchResult searchBySession(String queryStr, int startFrom, String operator) {

    try {
      queryStr = queryStr.trim();
      QueryParser parser = new QueryParser("contents", analyzer);
      Operator op = QueryParser.AND_OPERATOR;
      if (QueryParser.AND_OPERATOR.toString().equalsIgnoreCase(operator)) {
        parser.setDefaultOperator(QueryParser.AND_OPERATOR);
      } else {
        parser.setDefaultOperator(QueryParser.OR_OPERATOR);
      }

      Query query;
      query = parser.parse(queryStr);
      Sort sort = new Sort("summary", true);

      TopFieldDocs tfd = searcher.search(query, null, startFrom + 10, sort);
      TopFieldDocsSearchResult result = new TopFieldDocsSearchResult(tfd, searcher);
      return result;
    } catch (ParseException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    return null;
  }
 private void testQuery(Expression<?> expr, String expectedQuery, int expectedHits)
     throws Exception {
   Query query = serializer.toQuery(expr, metadata);
   TopDocs docs = searcher.search(query, 100);
   assertEquals(expectedHits, docs.totalHits);
   assertEquals(expectedQuery, query.toString());
 }
Пример #4
0
  /**
   * Returns a number of random songs.
   *
   * @param criteria Search criteria.
   * @return List of random songs.
   */
  public List<MediaFile> getRandomSongs(RandomSearchCriteria criteria) {
    List<MediaFile> result = new ArrayList<MediaFile>();

    IndexReader reader = null;
    try {
      reader = createIndexReader(SONG);
      Searcher searcher = new IndexSearcher(reader);

      BooleanQuery query = new BooleanQuery();
      query.add(
          new TermQuery(new Term(FIELD_MEDIA_TYPE, MediaFile.MediaType.MUSIC.name().toLowerCase())),
          BooleanClause.Occur.MUST);
      if (criteria.getGenre() != null) {
        String genre = normalizeGenre(criteria.getGenre());
        query.add(new TermQuery(new Term(FIELD_GENRE, genre)), BooleanClause.Occur.MUST);
      }
      if (criteria.getFromYear() != null || criteria.getToYear() != null) {
        NumericRangeQuery<Integer> rangeQuery =
            NumericRangeQuery.newIntRange(
                FIELD_YEAR, criteria.getFromYear(), criteria.getToYear(), true, true);
        query.add(rangeQuery, BooleanClause.Occur.MUST);
      }

      List<SpanTermQuery> musicFolderQueries = new ArrayList<SpanTermQuery>();
      for (MusicFolder musicFolder : criteria.getMusicFolders()) {
        musicFolderQueries.add(
            new SpanTermQuery(new Term(FIELD_FOLDER, musicFolder.getPath().getPath())));
      }
      query.add(
          new SpanOrQuery(musicFolderQueries.toArray(new SpanQuery[musicFolderQueries.size()])),
          BooleanClause.Occur.MUST);

      TopDocs topDocs = searcher.search(query, null, Integer.MAX_VALUE);
      List<ScoreDoc> scoreDocs = Lists.newArrayList(topDocs.scoreDocs);
      Random random = new Random(System.currentTimeMillis());

      while (!scoreDocs.isEmpty() && result.size() < criteria.getCount()) {
        int index = random.nextInt(scoreDocs.size());
        Document doc = searcher.doc(scoreDocs.remove(index).doc);
        int id = Integer.valueOf(doc.get(FIELD_ID));
        try {
          addIfNotNull(mediaFileService.getMediaFile(id), result);
        } catch (Exception x) {
          LOG.warn("Failed to get media file " + id);
        }
      }

    } catch (Throwable x) {
      LOG.error("Failed to search or random songs.", x);
    } finally {
      FileUtil.closeQuietly(reader);
    }
    return result;
  }
Пример #5
0
  protected Hits query(String db, String defaultField, String queryString)
      throws IOException, CorruptIndexException, ParseException {
    Directory directory = FSDirectory.getDirectory(indexPath(db));
    IndexReader reader = IndexReader.open(directory);

    Searcher searcher = new IndexSearcher(reader);
    Analyzer analyzer = new StandardAnalyzer();
    QueryParser qp = new QueryParser(defaultField, analyzer);
    Query query = qp.parse(queryString);
    return searcher.search(query);
  }
Пример #6
0
  private TopDocCollector doPagingSearch(Query query, int startFrom) throws IOException {

    TopDocCollector collector = new TopDocCollector(startFrom + 10);
    searcher.search(query, collector);
    if (logger.isDebugEnabled()) {
      logger.debug(query.toString());
      logger.debug(collector.toString());
    }

    return collector;
  }
 // Make sure the documents returned by the search match the expected list
 // Copied from TestSort.java
 private void assertMatches(Searcher searcher, Query query, Sort sort, String expectedResult)
     throws IOException {
   ScoreDoc[] result = searcher.search(query, null, 1000, sort).scoreDocs;
   StringBuilder buff = new StringBuilder(10);
   int n = result.length;
   for (int i = 0; i < n; ++i) {
     Document doc = searcher.doc(result[i].doc);
     String[] v = doc.getValues("tracer");
     for (int j = 0; j < v.length; ++j) {
       buff.append(v[j]);
     }
   }
   assertEquals(expectedResult, buff.toString());
 }
Пример #8
0
  /** @see org.wyona.yarep.impl.repo.vfs.DateIndexerSearcher#getRevisionYoungerThan(Date) */
  public Revision getRevisionYoungerThan(Date date) throws Exception {
    // log.debug("Get revision younger than: " + DateIndexerSearcherImplV1.format(date));
    Date youngerThanDate = new Date(date.getTime() + 1);

    // log.debug("Get revision for date: " + DateIndexerSearcherImplV1.format(youngerThanDate));
    try {
      org.apache.lucene.search.Searcher searcher = new IndexSearcher(indexDir.getAbsolutePath());
      if (searcher != null) {
        org.apache.lucene.search.Query query =
            org.apache.lucene.search.NumericRangeQuery.newLongRange(
                CREATION_DATE_FIELD_NAME,
                new Long(youngerThanDate.getTime()),
                new Long(new Date().getTime()),
                true,
                true);

        org.apache.lucene.search.Hits hits =
            searcher.search(
                query, new Sort(new SortField(CREATION_DATE_FIELD_NAME, SortField.LONG)));
        // log.debug("Query \"" + query + "\" on field '" + CREATION_DATE_FIELD_NAME + "' returned "
        // + hits.length() + " hits");
        String revisionName = null;
        if (hits != null && hits.length() > 0) {
          /* DEBUG
                              for (int i = 0; i < hits.length();i++) {
                                  revisionName = hits.doc(i).getField(REVISION_NAME_FIELD_NAME).stringValue();
                                  log.warn("DEBUG: Found revision name '" + revisionName + "' (Creation date: " + new Date(new Long(revisionName).longValue()) + ")");
                              }
          */
          revisionName = hits.doc(0).getField(REVISION_NAME_FIELD_NAME).stringValue();
        }
        searcher.close();
        if (revisionName != null) {
          return node.getRevision(revisionName);
        } else {
          return null;
        }
      } else {
        log.error("Searcher could not be initialized for index directory '" + indexDir + "'!");
        return null;
      }
    } catch (Exception e) {
      log.error(e, e);
      return null;
    }
  }
Пример #9
0
  /**
   * Performs a search using Lucene
   *
   * @param index with the documents to search
   * @param query to search
   * @param fieldName field where search inside the documents
   * @return the search result
   */
  public static LuceneSearchResult search(LuceneIndex index, String query, String fieldName) {
    try {

      Searcher searcher = new IndexSearcher(index.getDirectory());
      Analyzer analyzer = new StandardAnalyzer();
      QueryParser parser = new QueryParser(fieldName, analyzer);
      Query q = parser.parse(query);
      Hits hits = searcher.search(q);
      LuceneSearchResult lsr = new LuceneSearchResult(hits, index);
      searcher.close();
      return lsr;

    } catch (Exception e) {
      org.apache.commons.logging.LogFactory.getLog(LuceneSearcher.class).error(e);
    }
    return null;
  }
Пример #10
0
  private Document findByKey(IndexReader reader, Field keyField)
      throws ParseException, IOException {
    Searcher searcher = new IndexSearcher(reader);
    QueryParser queryParser = new QueryParser(luceneVersion, keyField.name(), queryAnalyzer);
    queryParser.setDefaultOperator(QueryParser.Operator.AND);

    String queryString = keyField.name() + ":" + keyField.stringValue();
    Query query = queryParser.parse(queryString);

    TopDocs docs = searcher.search(query, 10000);
    ScoreDoc[] scoreDocs = docs.scoreDocs;
    if (scoreDocs.length != 1) {
      return null;
    }

    ScoreDoc doc = scoreDocs[0];
    return searcher.doc(doc.doc);
  }
Пример #11
0
  public void run() {

    try {

      String searchQuery =
          (new BufferedReader(new InputStreamReader(searchSocket.getInputStream())))
              .readLine()
              .trim();

      IndexReader reader = writer.getReader();
      Searcher searcher = new IndexSearcher(reader);

      QueryParser indexParser = new QueryParser(Version.LUCENE_30, "data", analyzer);

      SortField hitSortField = new SortField("date", SortField.LONG);
      Sort hitSort = new Sort(hitSortField);

      TopFieldDocs hits = searcher.search(indexParser.parse(searchQuery), null, 1000, hitSort);

      PrintWriter searchReply = new PrintWriter(searchSocket.getOutputStream(), true);

      searchReply.println(hits.totalHits + " Hits for " + searchQuery);

      for (int i = 0; i < hits.totalHits; i++) {
        Document document = searcher.doc(hits.scoreDocs[i].doc);

        String host = document.get("hostname");
        String date = document.get("date");
        String data = document.get("data");

        searchReply.print("host: " + host + ", date: " + date + ", data: " + data + "\n\n");
      }

      searchReply.close();
      searcher.close();
      reader.close();
      searchSocket.close();
    } catch (Exception ex) {
      System.out.print("Exception: " + ex + "\n");
    }
  }
Пример #12
0
 /** @see org.wyona.yarep.impl.repo.vfs.DateIndexerSearcher#getMostRecentRevision() */
 public Revision getMostRecentRevision() {
   // log.debug("Get most recent revision...");
   try {
     org.apache.lucene.search.Searcher searcher = new IndexSearcher(indexDir.getAbsolutePath());
     if (searcher != null) {
       /*
                       String q = "*:*";
                       org.apache.lucene.search.Query query = new org.apache.lucene.queryParser.QueryParser(CREATION_DATE_FIELD_NAME, getAnalyzer()).parse(q);
       */
       org.apache.lucene.search.Query query = new org.apache.lucene.search.MatchAllDocsQuery();
       org.apache.lucene.search.Hits hits =
           searcher.search(
               query, new Sort(new SortField(CREATION_DATE_FIELD_NAME, SortField.LONG)));
       // log.debug("Query \"" + query + "\" on field '" + CREATION_DATE_FIELD_NAME + "' returned "
       // + hits.length() + " hits");
       String revisionName = null;
       if (hits != null && hits.length() > 0) {
         /* DEBUG
                             for (int i = 0; i < hits.length();i++) {
                                 revisionName = hits.doc(i).getField(REVISION_NAME_FIELD_NAME).stringValue();
                                 log.warn("DEBUG: Found revision name '" + revisionName + "' (Creation date: " + new Date(new Long(revisionName).longValue()) + ")");
                             }
         */
         revisionName =
             hits.doc(hits.length() - 1).getField(REVISION_NAME_FIELD_NAME).stringValue();
       }
       searcher.close();
       if (revisionName != null) {
         return node.getRevision(revisionName);
       } else {
         return null;
       }
     } else {
       log.error("Searcher could not be initialized for index directory '" + indexDir + "'!");
       return null;
     }
   } catch (Exception e) {
     log.error(e, e);
     return null;
   }
 }
Пример #13
0
  /**
   * Returns a number of random albums, using ID3 tag.
   *
   * @param count Number of albums to return.
   * @param musicFolders Only return albums from these folders.
   * @return List of random albums.
   */
  public List<Album> getRandomAlbumsId3(int count, List<MusicFolder> musicFolders) {
    List<Album> result = new ArrayList<Album>();

    IndexReader reader = null;
    try {
      reader = createIndexReader(ALBUM_ID3);
      Searcher searcher = new IndexSearcher(reader);

      List<SpanTermQuery> musicFolderQueries = new ArrayList<SpanTermQuery>();
      for (MusicFolder musicFolder : musicFolders) {
        musicFolderQueries.add(
            new SpanTermQuery(
                new Term(FIELD_FOLDER_ID, NumericUtils.intToPrefixCoded(musicFolder.getId()))));
      }
      Query query =
          new SpanOrQuery(musicFolderQueries.toArray(new SpanQuery[musicFolderQueries.size()]));
      TopDocs topDocs = searcher.search(query, null, Integer.MAX_VALUE);
      List<ScoreDoc> scoreDocs = Lists.newArrayList(topDocs.scoreDocs);
      Random random = new Random(System.currentTimeMillis());

      while (!scoreDocs.isEmpty() && result.size() < count) {
        int index = random.nextInt(scoreDocs.size());
        Document doc = searcher.doc(scoreDocs.remove(index).doc);
        int id = Integer.valueOf(doc.get(FIELD_ID));
        try {
          addIfNotNull(albumDao.getAlbum(id), result);
        } catch (Exception x) {
          LOG.warn("Failed to get album file " + id, x);
        }
      }

    } catch (Throwable x) {
      LOG.error("Failed to search for random albums.", x);
    } finally {
      FileUtil.closeQuietly(reader);
    }
    return result;
  }
Пример #14
0
 /**
  * Do the search.
  *
  * @param conn the database connection
  * @param text the query
  * @param limit the limit
  * @param offset the offset
  * @param data whether the raw data should be returned
  * @return the result set
  */
 protected static ResultSet search(
     Connection conn, String text, int limit, int offset, boolean data) throws SQLException {
   SimpleResultSet result = createResultSet(data);
   if (conn.getMetaData().getURL().startsWith("jdbc:columnlist:")) {
     // this is just to query the result set columns
     return result;
   }
   if (text == null || text.trim().length() == 0) {
     return result;
   }
   try {
     IndexAccess access = getIndexAccess(conn);
     /*## LUCENE2 ##
     access.modifier.flush();
     String path = getIndexPath(conn);
     IndexReader reader = IndexReader.open(path);
     Analyzer analyzer = new StandardAnalyzer();
     Searcher searcher = new IndexSearcher(reader);
     QueryParser parser = new QueryParser(LUCENE_FIELD_DATA, analyzer);
     Query query = parser.parse(text);
     Hits hits = searcher.search(query);
     int max = hits.length();
     if (limit == 0) {
         limit = max;
     }
     for (int i = 0; i < limit && i + offset < max; i++) {
         Document doc = hits.doc(i + offset);
         float score = hits.score(i + offset);
     //*/
     // ## LUCENE3 ##
     // take a reference as the searcher may change
     Searcher searcher = access.searcher;
     // reuse the same analyzer; it's thread-safe;
     // also allows subclasses to control the analyzer used.
     Analyzer analyzer = access.writer.getAnalyzer();
     QueryParser parser = new QueryParser(Version.LUCENE_30, LUCENE_FIELD_DATA, analyzer);
     Query query = parser.parse(text);
     // Lucene 3 insists on a hard limit and will not provide
     // a total hits value. Take at least 100 which is
     // an optimal limit for Lucene as any more
     // will trigger writing results to disk.
     int maxResults = (limit == 0 ? 100 : limit) + offset;
     TopDocs docs = searcher.search(query, maxResults);
     if (limit == 0) {
       limit = docs.totalHits;
     }
     for (int i = 0, len = docs.scoreDocs.length;
         i < limit && i + offset < docs.totalHits && i + offset < len;
         i++) {
       ScoreDoc sd = docs.scoreDocs[i + offset];
       Document doc = searcher.doc(sd.doc);
       float score = sd.score;
       // */
       String q = doc.get(LUCENE_FIELD_QUERY);
       if (data) {
         int idx = q.indexOf(" WHERE ");
         JdbcConnection c = (JdbcConnection) conn;
         Session session = (Session) c.getSession();
         Parser p = new Parser(session);
         String tab = q.substring(0, idx);
         ExpressionColumn expr = (ExpressionColumn) p.parseExpression(tab);
         String schemaName = expr.getOriginalTableAliasName();
         String tableName = expr.getColumnName();
         q = q.substring(idx + " WHERE ".length());
         Object[][] columnData = parseKey(conn, q);
         result.addRow(schemaName, tableName, columnData[0], columnData[1], score);
       } else {
         result.addRow(q, score);
       }
     }
     /*## LUCENE2 ##
     // TODO keep it open if possible
     reader.close();
     //*/
   } catch (Exception e) {
     throw convertException(e);
   }
   return result;
 }
Пример #15
0
  public SearchResult search(
      SearchCriteria criteria, List<MusicFolder> musicFolders, IndexType indexType) {
    SearchResult result = new SearchResult();
    int offset = criteria.getOffset();
    int count = criteria.getCount();
    result.setOffset(offset);

    IndexReader reader = null;
    try {
      reader = createIndexReader(indexType);
      Searcher searcher = new IndexSearcher(reader);
      Analyzer analyzer = new SubsonicAnalyzer();

      MultiFieldQueryParser queryParser =
          new MultiFieldQueryParser(
              LUCENE_VERSION, indexType.getFields(), analyzer, indexType.getBoosts());

      BooleanQuery query = new BooleanQuery();
      query.add(queryParser.parse(analyzeQuery(criteria.getQuery())), BooleanClause.Occur.MUST);

      List<SpanTermQuery> musicFolderQueries = new ArrayList<SpanTermQuery>();
      for (MusicFolder musicFolder : musicFolders) {
        if (indexType == ALBUM_ID3 || indexType == ARTIST_ID3) {
          musicFolderQueries.add(
              new SpanTermQuery(
                  new Term(FIELD_FOLDER_ID, NumericUtils.intToPrefixCoded(musicFolder.getId()))));
        } else {
          musicFolderQueries.add(
              new SpanTermQuery(new Term(FIELD_FOLDER, musicFolder.getPath().getPath())));
        }
      }
      query.add(
          new SpanOrQuery(musicFolderQueries.toArray(new SpanQuery[musicFolderQueries.size()])),
          BooleanClause.Occur.MUST);

      TopDocs topDocs = searcher.search(query, null, offset + count);
      result.setTotalHits(topDocs.totalHits);

      int start = Math.min(offset, topDocs.totalHits);
      int end = Math.min(start + count, topDocs.totalHits);
      for (int i = start; i < end; i++) {
        Document doc = searcher.doc(topDocs.scoreDocs[i].doc);
        switch (indexType) {
          case SONG:
          case ARTIST:
          case ALBUM:
            MediaFile mediaFile = mediaFileService.getMediaFile(Integer.valueOf(doc.get(FIELD_ID)));
            addIfNotNull(mediaFile, result.getMediaFiles());
            break;
          case ARTIST_ID3:
            Artist artist = artistDao.getArtist(Integer.valueOf(doc.get(FIELD_ID)));
            addIfNotNull(artist, result.getArtists());
            break;
          case ALBUM_ID3:
            Album album = albumDao.getAlbum(Integer.valueOf(doc.get(FIELD_ID)));
            addIfNotNull(album, result.getAlbums());
            break;
          default:
            break;
        }
      }

    } catch (Throwable x) {
      LOG.error("Failed to execute Lucene search.", x);
    } finally {
      FileUtil.closeQuietly(reader);
    }
    return result;
  }
Пример #16
0
  /**
   * Index the fileset.
   *
   * @exception IOException if Lucene I/O exception TODO: refactor!!!!!
   */
  private void indexDocs() throws IOException {
    Date start = new Date();

    boolean create = overwrite;
    // If the index directory doesn't exist,
    // create it and force create mode
    if (indexDir.mkdirs() && !overwrite) {
      create = true;
    }

    FSDirectory dir = FSDirectory.open(indexDir);
    try {
      Searcher searcher = null;
      boolean checkLastModified = false;
      if (!create) {
        try {
          searcher = new IndexSearcher(dir, true);
          checkLastModified = true;
        } catch (IOException ioe) {
          log("IOException: " + ioe.getMessage());
          // Empty - ignore, which indicates to index all
          // documents
        }
      }

      log("checkLastModified = " + checkLastModified, Project.MSG_VERBOSE);

      IndexWriterConfig conf =
          new IndexWriterConfig(Version.LUCENE_CURRENT, analyzer)
              .setOpenMode(create ? OpenMode.CREATE : OpenMode.APPEND);
      LogMergePolicy lmp = (LogMergePolicy) conf.getMergePolicy();
      lmp.setUseCompoundFile(useCompoundIndex);
      lmp.setMergeFactor(mergeFactor);
      IndexWriter writer = new IndexWriter(dir, conf);
      int totalFiles = 0;
      int totalIndexed = 0;
      int totalIgnored = 0;
      try {

        for (int i = 0; i < rcs.size(); i++) {
          ResourceCollection rc = rcs.elementAt(i);
          if (rc.isFilesystemOnly()) {
            Iterator resources = rc.iterator();
            while (resources.hasNext()) {
              Resource r = (Resource) resources.next();
              if (!r.isExists() || !(r instanceof FileResource)) {
                continue;
              }

              totalFiles++;

              File file = ((FileResource) r).getFile();

              if (!file.exists() || !file.canRead()) {
                throw new BuildException(
                    "File \"" + file.getAbsolutePath() + "\" does not exist or is not readable.");
              }

              boolean indexIt = true;

              if (checkLastModified) {
                Term pathTerm = new Term("path", file.getPath());
                TermQuery query = new TermQuery(pathTerm);
                ScoreDoc[] hits = searcher.search(query, null, 1).scoreDocs;

                // if document is found, compare the
                // indexed last modified time with the
                // current file
                // - don't index if up to date
                if (hits.length > 0) {
                  Document doc = searcher.doc(hits[0].doc);
                  String indexModified = doc.get("modified").trim();
                  if (indexModified != null) {
                    long lastModified = 0;
                    try {
                      lastModified = DateTools.stringToTime(indexModified);
                    } catch (ParseException e) {
                      // if modified time is not parsable, skip
                    }
                    if (lastModified == file.lastModified()) {
                      // TODO: remove existing document
                      indexIt = false;
                    }
                  }
                }
              }

              if (indexIt) {
                try {
                  log("Indexing " + file.getPath(), Project.MSG_VERBOSE);
                  Document doc = handler.getDocument(file);

                  if (doc == null) {
                    totalIgnored++;
                  } else {
                    // Add the path of the file as a field named "path".  Use a Keyword field, so
                    // that the index stores the path, and so that the path is searchable
                    doc.add(
                        new Field(
                            "path", file.getPath(), Field.Store.YES, Field.Index.NOT_ANALYZED));

                    // Add the last modified date of the file a field named "modified".  Use a
                    // Keyword field, so that it's searchable, but so that no attempt is made
                    // to tokenize the field into words.
                    doc.add(
                        new Field(
                            "modified",
                            DateTools.timeToString(
                                file.lastModified(), DateTools.Resolution.MILLISECOND),
                            Field.Store.YES,
                            Field.Index.NOT_ANALYZED));

                    writer.addDocument(doc);
                    totalIndexed++;
                  }
                } catch (DocumentHandlerException e) {
                  throw new BuildException(e);
                }
              }
            }
            // for j
          }
          // if (fs != null)
        }
        // for i

        writer.optimize();
      }
      // try
      finally {
        // always make sure everything gets closed,
        // no matter how we exit.
        writer.close();
        if (searcher != null) {
          searcher.close();
        }
      }

      Date end = new Date();

      log(
          totalIndexed
              + " out of "
              + totalFiles
              + " indexed ("
              + totalIgnored
              + " ignored) in "
              + (end.getTime() - start.getTime())
              + " milliseconds");
    } finally {
      dir.close();
    }
  }