*

* Part of the InfoGlue Content Management Platform (www.infoglue.org)

*

* ===============================================================================

*

*  Copyright (C)

*

* This program is free software; you can redistribute it and/or modify it under

* the terms of the GNU General Public License version 2, as published by the

* Free Software Foundation. See the file LICENSE.html for more information.

*

* This program is distributed in the hope that it will be useful, but WITHOUT

* ANY WARRANTY, including the implied warranty of MERCHANTABILITY or FITNESS

* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License along with

* this program; if not, write to the Free Software Foundation, Inc. / 59 Temple

* Place, Suite 330 / Boston, MA 02111-1307 / USA.

*

* ===============================================================================

*/

  private static Directory directory = null;

  private static IndexWriter writer = null;

  private static IndexReader indexReader = null;

  private static int reopened = 0;

 

    private final static Logger logger = Logger.getLogger(LuceneController.class.getName());

    private static int indexedDocumentsSinceLastOptimize = 0;

    private Integer lastCommitedContentVersionId = -1;

   

    private static Integer numberOfVersionToIndexInBatch = 1000;

    private static AtomicBoolean indexingInitialized = new AtomicBoolean(false);

    private static AtomicBoolean stopIndexing = new AtomicBoolean(false);

    private static AtomicBoolean deleteIndexOnStop = new AtomicBoolean(false);

   

  public static void setNumberOfVersionToIndexInBatch(Integer numberOfVersionToIndexInBatch)

  {

    numberOfVersionToIndexInBatch = numberOfVersionToIndexInBatch;

  }

    public static void stopIndexing()

    {

      stopIndexing.set(true);

    }

   

  /**

   * Default Constructor 

   */

 

  public static LuceneController getController()

  {

    return new LuceneController();

  }

 

  private static List<NotificationMessage> qeuedMessages = new ArrayList<NotificationMessage>();

 

  private StandardAnalyzer getStandardAnalyzer() throws Exception

  {

    return new StandardAnalyzer(Version.LUCENE_34);

  }

 

  private Directory getDirectory() throws Exception

  {

    if(LuceneController.directory != null)

      return directory;

   

    String index = CmsPropertyHandler.getContextDiskPath() + File.separator + "lucene" + File.separator + "index";

    index = index.replaceAll("//", "/");

    //System.out.println("index:" + index);

      File INDEX_DIR = new File(index);

    directory = new NIOFSDirectory(INDEX_DIR);

    directory.setLockFactory(new SingleInstanceLockFactory());

    boolean indexExists = IndexReader.indexExists(directory);

    if(!indexExists)

    {

      createIndex(directory);

    }

   

    return directory;

  }

  private void createIndex(Directory directory) throws Exception

  {

    IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_34, getStandardAnalyzer());

    IndexWriter indexWriter = new IndexWriter(directory, config);

      indexWriter.deleteDocuments(new Term("initializer", "true"));

    indexWriter.close(true);

  }

 

  private IndexWriter getIndexWriter() throws Exception

  {

    //Singleton returns

    if(writer != null)

      return writer;

    Timer t = new Timer();

    Directory directory = getDirectory();

      StandardAnalyzer analyzer = new StandardAnalyzer(Version.LUCENE_34);

    IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_34, analyzer);

    if(getIsIndexedLocked(true))

    {

      logger.warn("Directory is locked - leaving the messages in the qeuedMessages list...");

      throw new Exception("Lock not granted");

    }

    else

    {

      writer = new IndexWriter(directory, config);

        return writer;

    }

  }

  private IndexReader getIndexReader() throws Exception

  {

    if(indexReader == null)

    {

      indexReader = IndexReader.open(getDirectory(), true);

    }

    synchronized (indexReader)

    {

      if(!indexReader.isCurrent())

      {

        reopened++;

        indexReader.close();

        indexReader = IndexReader.open(getDirectory(), true);

        //indexReader = IndexReader.openIfChanged(indexReader, true);

        logger.info("reopened:" + reopened);

      }

    }

    return indexReader;

  }

  private IndexSearcher getIndexSearcher() throws Exception

  {

    return new IndexSearcher(getIndexReader());

  }

 

  private Boolean getIsIndexedLocked() throws Exception

  {

    return getIsIndexedLocked(false);

  }

  private Boolean getIsIndexedLocked(boolean returnIfFileLockException) throws Exception

  {

    Directory directory = getDirectory();

    try

    {

      return IndexWriter.isLocked(directory);

    }

    catch (OverlappingFileLockException e)

    {

      return returnIfFileLockException;

    }

  }

  private void unlockIndex() throws Exception

  {

    Directory directory = getDirectory();

    IndexWriter.unlock(directory);

  }

 

  public Map<String,Object> getIndexInformation() throws Exception

  {

    Map<String,Object> info = new HashMap<String,Object>();

   

    try

      {

      Directory directory = getDirectory();

     

        IndexReader reader = getIndexReader();

        int maxDoc = reader.maxDoc();

        int numDoc = reader.numDocs();

        long lastModified = getIndexReader().lastModified(directory);

        info.put("maxDoc", new Integer(maxDoc));

        info.put("numDoc", new Integer(numDoc));

        info.put("lastModified", new Date(lastModified));

        info.put("lastCommitedContentVersionId", getLastCommitedContentVersionId());

       

      List<LanguageVO> languageVOList = LanguageController.getController().getLanguageVOList();

      Iterator<LanguageVO> languageVOListIterator = languageVOList.iterator();

      outer:while(languageVOListIterator.hasNext())

      {

        LanguageVO languageVO = (LanguageVO)languageVOListIterator.next();

          info.put("indexAllLastCommittedContentVersionId_" + languageVO.getId(), getIndexAllLastCommittedContentVersionId(languageVO.getId()));

          info.put("indexAllLastCommittedMetaContentVersionId_" + languageVO.getId(), getIndexAllLastCommittedMetaContentVersionId(languageVO.getId()));

      }

     

        //reader.close();

        //directory.close();

      }

      catch (Exception e)

      {

        logger.error("Error creating index:" + e.getMessage(), e);

        throw e;

      }

     

      return info;

  }

  public Integer getIndexAllLastCommittedContentVersionId(Integer languageId) throws Exception

  {

    Integer indexAllLastCommittedContentVersionId = null;

    try

      {

      Document indexAllDocumentMetaData = getIndexAllStatusDocument();

      if(indexAllDocumentMetaData != null && indexAllDocumentMetaData.get("lastCommitedContentVersionId_" + languageId) != null && !indexAllDocumentMetaData.get("lastCommitedContentVersionId_" + languageId).equals("null"))

        indexAllLastCommittedContentVersionId = new Integer(indexAllDocumentMetaData.get("lastCommitedContentVersionId_" + languageId));

      }

      catch (Exception e)

      {

        logger.error("Error creating index:" + e.getMessage(), e);

        throw e;

      }

     

      return indexAllLastCommittedContentVersionId;

  }

  public Integer getIndexAllLastCommittedMetaContentVersionId(Integer languageId) throws Exception

  {

    Integer indexAllLastCommittedSiteNodeVersionId = null;

    try

      {

      Document indexAllDocumentMetaData = getIndexAllStatusDocument();

      if(indexAllDocumentMetaData != null && indexAllDocumentMetaData.get("lastCommitedMetaContentVersionId_" + languageId) != null && !indexAllDocumentMetaData.get("lastCommitedMetaContentVersionId_" + languageId).equals("null"))

         indexAllLastCommittedSiteNodeVersionId = new Integer(indexAllDocumentMetaData.get("lastCommitedMetaContentVersionId_" + languageId));

      }

      catch (Exception e)

      {

        logger.error("Error creating index:" + e.getMessage(), e);

        throw e;

      }

     

      return indexAllLastCommittedSiteNodeVersionId;

  }

  public Document createStatusDocument(Integer lastCommitedContentVersionId) throws Exception

  {

    Document doc = new Document();

    doc.add(new Field("lastCommitedContentVersionId", "" + lastCommitedContentVersionId, Field.Store.YES, Field.Index.NOT_ANALYZED));

    doc.add(new Field("lastCommitedModifiedDate", "" + new Date().getTime(), Field.Store.YES, Field.Index.NOT_ANALYZED));

    doc.add(new Field("meta", new StringReader("lastCommitedContentVersionId")));

    return doc;

  }

  public Document getStatusDocument() throws Exception

  {

      List<Document> docs = queryDocuments("meta", "lastCommitedContentVersionId", 5);

    logger.info(docs.size() + " total matching documents for 'lastCommitedContentVersionId'");

    return (docs != null && docs.size() > 0 ? docs.get(0) : null);

  }

  public Document getIndexAllStatusDocument() throws Exception

  {

      List<Document> docs = queryDocuments(new Term("meta", "indexAllRunning"), 5);

    logger.info(docs.size() + " total matching documents for 'indexAllRunning'");

    return (docs != null && docs.size() > 0 ? docs.get(0) : null);

  }

  public Integer getLastCommitedContentVersionId() throws Exception

  {

    Integer lastCommitedContentVersionId = -1;

   

    Document doc = getStatusDocument();

    logger.info("STATUS doc:" + doc);

    if(doc != null)

    {

      String lastCommitedContentVersionIdString = doc.get("lastCommitedContentVersionId");

     

      logger.info("doc:" + doc);

      logger.info("lastCommitedContentVersionId:" + lastCommitedContentVersionIdString);

     

      lastCommitedContentVersionId = Integer.parseInt(lastCommitedContentVersionIdString);

    }

   

    return lastCommitedContentVersionId;

  }

  private void setLastCommitedContentVersionId(IndexWriter writer, Integer lastCommitedContentVersionId) throws Exception

  {

    Integer prevLastCommitedContentVersionId = getLastCommitedContentVersionId();

    logger.info("prevLastCommitedContentVersionId:" + prevLastCommitedContentVersionId);

    logger.info("lastCommitedContentVersionId:" + lastCommitedContentVersionId);

    if(lastCommitedContentVersionId == -1 || prevLastCommitedContentVersionId > lastCommitedContentVersionId)

      return;

   

    logger.info("setLastCommitedContentVersionId:" + lastCommitedContentVersionId);

    Query query = new QueryParser(Version.LUCENE_34, "meta", getStandardAnalyzer()).parse("lastCommitedContentVersionId");

    writer.deleteDocuments(query);

    writer.addDocument(createStatusDocument(lastCommitedContentVersionId));

  }

 

  public Date getLastCommitedModifiedDate() throws Exception

  {

    Date lastCommitedModifiedDate = new Date(10000);

   

    Document doc = getStatusDocument();

    if(doc != null)

    {

      String lastCommitedModifiedDateString = doc.get("lastCommitedModifiedDate");

 

      logger.info("doc:" + doc);

      logger.info("lastCommitedModifiedDate:" + lastCommitedModifiedDateString);

     

      Date d = new Date();

      d.setTime(Long.parseLong(lastCommitedModifiedDateString));

      lastCommitedModifiedDate = d;

    }

   

    return lastCommitedModifiedDate;

  }

  private void registerIndexAllProcessOngoing(Integer lastCommitedContentVersionId, Integer lastCommitedSiteNodeVersionId, Integer languageId) throws Exception

  {

    //M�ste skrivas om f�r att uppdatera b�ttre....

   

    //Document doc = new Document();

    IndexWriter writer = getIndexWriter();

    IndexSearcher searcher = getIndexSearcher();

    Term term = new Term("meta", "indexAllRunning");

    TermQuery query = new TermQuery(term);

   

    //Query query = new QueryParser(Version.LUCENE_34, "meta", getStandardAnalyzer()).parse("indexAllRunning");

    TopDocs hits = searcher.search(query, 50);

    //System.out.println("hits:" + hits);

    //System.out.println("hits.scoreDocs.length:" + hits.scoreDocs.length);

   

    if(hits.scoreDocs.length > 1)

      System.out.println("Must be wrong - should only be one of these docs:" + hits.scoreDocs.length);

   

    if(hits.scoreDocs.length > 0)

    {

      for(ScoreDoc scoreDoc : hits.scoreDocs)

      {

        org.apache.lucene.document.Document docExisting = searcher.doc(scoreDoc.doc);

        //System.out.println("Updating doc...:" + docExisting);

        //System.out.println("lastCommitedContentVersionId:" + lastCommitedContentVersionId);

        //System.out.println("lastCommitedSiteNodeVersionId:" + lastCommitedSiteNodeVersionId);

        //System.out.println("languageId:" + languageId);

        if(lastCommitedContentVersionId != null && lastCommitedContentVersionId != -1)

        {

          docExisting.removeFields("lastCommitedContentVersionId_" + languageId);

          docExisting.add(new Field("lastCommitedContentVersionId_" + languageId, "" + lastCommitedContentVersionId, Field.Store.YES, Field.Index.NOT_ANALYZED));

        }

       

        if(lastCommitedSiteNodeVersionId != null && lastCommitedSiteNodeVersionId != -1)

        {

          docExisting.removeFields("lastCommitedMetaContentVersionId_" + languageId);

          docExisting.add(new Field("lastCommitedMetaContentVersionId_" + languageId, "" + lastCommitedSiteNodeVersionId, Field.Store.YES, Field.Index.NOT_ANALYZED));

        }

        docExisting.removeFields("lastCommitedModifiedDate");

        docExisting.add(new Field("lastCommitedModifiedDate", "" + new Date().getTime(), Field.Store.YES, Field.Index.NOT_ANALYZED));

        //docExisting.add(new Field("meta", new StringReader("indexAllRunning")));

        //docExisting.add(new Field("meta", "indexAllRunning", Field.Store.YES, Field.Index.NOT_ANALYZED));

         

        writer.updateDocument(term, docExisting);

        //System.out.println("Updating doc...:" + docExisting);

        //Term t = new Term("meta", "indexAllRunning");

        break;

      }

    }

    else

    {

      Document docExisting = new Document();

      //System.out.println("lastCommitedContentVersionId:" + lastCommitedContentVersionId);

      //System.out.println("lastCommitedSiteNodeVersionId:" + lastCommitedSiteNodeVersionId);

      //System.out.println("languageId:" + languageId);

     

      if(lastCommitedContentVersionId != null)

        docExisting.add(new Field("lastCommitedContentVersionId_" + languageId, "" + lastCommitedContentVersionId, Field.Store.YES, Field.Index.NOT_ANALYZED));

      if(lastCommitedSiteNodeVersionId != null)

        docExisting.add(new Field("lastCommitedMetaContentVersionId_" + languageId, "" + lastCommitedSiteNodeVersionId, Field.Store.YES, Field.Index.NOT_ANALYZED));

      docExisting.add(new Field("lastCommitedModifiedDate", "" + new Date().getTime(), Field.Store.YES, Field.Index.NOT_ANALYZED));

      //docExisting.add(new Field("meta", new StringReader("indexAllRunning")));

      docExisting.add(new Field("meta", "indexAllRunning", Field.Store.YES, Field.Index.NOT_ANALYZED));

     

      writer.addDocument(docExisting);

    }

    searcher.close();

   

    //Query query = new QueryParser(Version.LUCENE_34, "meta", getStandardAnalyzer()).parse("indexAllRunning");

    //writer.deleteDocuments(query);

   

    //writer.updateDocument(term, doc);

    //writer.addDocument(doc);

    //writer.close(true);

    writer.commit();

  }

  private void registerIndexAllProcessDone() throws Exception

  {

    IndexWriter writer = getIndexWriter();

    //Query query = new QueryParser(Version.LUCENE_34, "meta", getStandardAnalyzer()).parse("indexAllRunning");

    Term term = new Term("meta", "indexAllRunning");

    TermQuery query = new TermQuery(term);

   

    writer.deleteDocuments(query);   

    writer.commit();

  }

  public void clearIndex() throws Exception

  {

    if (indexingInitialized.compareAndSet(false, true))

    {

      logger.warn("Clearing index..");

      try

      {

        logger.info("NumDocs:" + getIndexReader().numDocs());

        IndexWriter writer = getIndexWriter();

        writer.deleteAll();

        //writer.close(true);

        writer.commit();

        logger.info("NumDocs after delete:" + getIndexReader().numDocs());

      }

      catch (Exception e)

      {

        stopIndexing.set(true);

        deleteIndexOnStop.set(true);

        logger.error("Error clearing index:" + e.getMessage(), e);

      }

      finally

      {

        logger.info("Releasing indexing flag");

        this.indexingInitialized.set(false);

        stopIndexing.set(false);

      }

    }

    else

    {

      stopIndexing.set(true);

      deleteIndexOnStop.set(true);

      logger.error("Could not delete index while indexing. Queueing it....");

    }

  }

  public TopDocs query(String text, Integer numberOfHits) throws Exception

  {

    return query("contents", text, numberOfHits);

  }

  public TopDocs query(String field, String text, Integer numberOfHits) throws Exception

  {

    IndexSearcher searcher = getIndexSearcher();

    Query query = new QueryParser(Version.LUCENE_34, "contents", getStandardAnalyzer()).parse(text);

    TopDocs hits = searcher.search(query, numberOfHits);

    logger.info(hits.totalHits + " total matching documents for '" + text + "'");

    return hits;

  }

  public List<Document> queryDocuments(Term term, Integer numberOfHits) throws Exception

  {

    IndexSearcher searcher = getIndexSearcher();

    Query query = new TermQuery(term);

    TopDocs hits = searcher.search(query, numberOfHits);

    logger.info(hits.totalHits + " total matching documents for '" + term.field() + ":" + term.text() + "'");

    List<Document> docs = new ArrayList<Document>();

    for(ScoreDoc scoreDoc : hits.scoreDocs)

    {

      org.apache.lucene.document.Document doc = searcher.doc(scoreDoc.doc);

      docs.add(doc);

    }

    searcher.close();

    return docs;

  }

  public List<Document> queryDocuments(String field, String text, Integer numberOfHits) throws Exception

  {

    IndexSearcher searcher = getIndexSearcher();

    Query query = new QueryParser(Version.LUCENE_34, field, getStandardAnalyzer()).parse(text);

    logger.info("query:" + query);

    TopDocs hits = searcher.search(query, numberOfHits);

    logger.info(hits.totalHits + " total matching documents for '" + field + ":" + text + "'");

    List<Document> docs = new ArrayList<Document>();

    for(ScoreDoc scoreDoc : hits.scoreDocs)

    {

      org.apache.lucene.document.Document doc = searcher.doc(scoreDoc.doc);

      docs.add(doc);

    }

    searcher.close();

    return docs;

  }

  public TopDocs query(String[] fields, BooleanClause.Occur[] flags, String[] queries, Sort sort, Integer numberOfHits) throws Exception

  {

    IndexSearcher searcher = getIndexSearcher();

    Query query = MultiFieldQueryParser.parse(Version.LUCENE_34, queries, fields, flags, getStandardAnalyzer());

    //Query query = new QueryParser(Version.LUCENE_34, "contents", getStandardAnalyzer()).parse(text);

    TopDocs hits = searcher.search(query, numberOfHits);

    logger.info(hits.totalHits + " total matching documents for '" + queries + "'");

    return hits;

  }

  public List<Document> queryDocuments(String[] fields, BooleanClause.Occur[] flags, String[] queries, Sort sort, Integer numberOfHits, Map searchMetaData) throws Exception

  {

    IndexSearcher searcher = getIndexSearcher();

    Query query = MultiFieldQueryParser.parse(Version.LUCENE_34, queries, fields, flags, getStandardAnalyzer());

    logger.info("query:" + query);

   

    //Query query = new QueryParser(Version.LUCENE_34, "contents", getStandardAnalyzer()).parse(text);

    TopDocs hits = searcher.search(query, numberOfHits);

    searchMetaData.put("totalHits", hits.totalHits);

    logger.info(hits.totalHits + " total matching documents for '" + query + "'");

    //System.out.println(hits.totalHits + " total matching documents for '" + queries + "'");

    List<Document> docs = new ArrayList<Document>();

    for(ScoreDoc scoreDoc : hits.scoreDocs)

    {

      org.apache.lucene.document.Document doc = searcher.doc(scoreDoc.doc);

      docs.add(doc);

    }

    searcher.close();

    return docs;

  }

 

  private void query(IndexSearcher searcher, Analyzer analyzer, String text) throws Exception

  {

    Query query = new QueryParser(Version.LUCENE_34, "contents", analyzer).parse(text);

    TopDocs hits = searcher.search(query, 50);

    logger.info(hits.totalHits + " total matching documents for '" + text + "'");

    for(ScoreDoc scoreDoc : hits.scoreDocs)

    {

      org.apache.lucene.document.Document doc = searcher.doc(scoreDoc.doc);

      String cvId = doc.get("contentVersionId");

      logger.info("cvId: " + cvId);

    }

  }

  public boolean indexAll() throws Exception

  {

    if(!CmsPropertyHandler.getInternalSearchEngine().equalsIgnoreCase("lucene"))

      return false;

   

    logger.warn("INDEXING ALL - correct: " + indexingInitialized + "/" + deleteIndexOnStop + "/" + stopIndexing + "?");

    Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

   

    if(deleteIndexOnStop.get())

    {

      clearIndex();

      deleteIndexOnStop.set(false);

      stopIndexing.set(false);

    }

    else

    {

      stopIndexing.set(false);

    }

   

    logger.warn("Resetting stopIndexing to false....");

    logger.warn("------------------------------Got indexAll directive....");

    if (indexingInitialized.compareAndSet(false, true))

    {

      //createTestIndex();

      //indexingInitialized.set(false);

      //if(true)

      //  return true;

      try

      {

        Timer t = new Timer();

        Timer t2 = new Timer();

   

        //Indexing all normal contents now

        logger.info("Indexing all normal contents: " + CmsPropertyHandler.getContextDiskPath());

        List<LanguageVO> languageVOList = LanguageController.getController().getLanguageVOList();

        Iterator<LanguageVO> languageVOListIterator = languageVOList.iterator();

       

        outer:while(languageVOListIterator.hasNext())

        {

          LanguageVO languageVO = (LanguageVO)languageVOListIterator.next();

          logger.info("Getting notification messages for " + languageVO.getName());

          Integer previousIndexAllLastContentVersionId = getIndexAllLastCommittedContentVersionId(languageVO.getId());

          int startID = 0;

          if(previousIndexAllLastContentVersionId != null)

            startID = previousIndexAllLastContentVersionId;

         

          logger.info("Starting from " + startID);

          int newLastContentVersionId = getContentNotificationMessages(languageVO, startID);

          logger.info("newLastContentVersionId: " + newLastContentVersionId + " on " + languageVO.getName());

         

          registerIndexAllProcessOngoing(newLastContentVersionId, null, languageVO.getId());

          //previousIndexAllLastContentVersionId = newLastContentVersionId;

          RequestAnalyser.getRequestAnalyser().registerComponentStatistics("getNotificationMessages", t.getElapsedTime());

          logger.info("newLastContentVersionId " + newLastContentVersionId);

          while(newLastContentVersionId != -1)

          {

            logger.info("stopIndexing.get():" + stopIndexing.get());

            if(stopIndexing.get())

              break outer;

           

            Thread.sleep(5000);

            newLastContentVersionId = getContentNotificationMessages(languageVO, newLastContentVersionId);

            logger.info("newLastContentVersionId: " + newLastContentVersionId + " on " + languageVO.getName());

            registerIndexAllProcessOngoing(newLastContentVersionId, null, languageVO.getId());

            //previousIndexAllLastContentVersionId = newLastContentVersionId;

            RequestAnalyser.getRequestAnalyser().registerComponentStatistics("getNotificationMessages 2", t.getElapsedTime());

            logger.info("newLastContentVersionId " + newLastContentVersionId);

          }

        }

       

        languageVOList = LanguageController.getController().getLanguageVOList();

        languageVOListIterator = languageVOList.iterator();

        outer:while(languageVOListIterator.hasNext())

        {

          LanguageVO languageVO = (LanguageVO)languageVOListIterator.next();

          logger.info("languageVO from " + languageVO);

         

          List<NotificationMessage> notificationMessages = new ArrayList<NotificationMessage>();

         

          Integer previousIndexAllLastMetaContentVersionId = getIndexAllLastCommittedMetaContentVersionId(languageVO.getId());

          logger.info("previousIndexAllLastMetaContentVersionId: " + previousIndexAllLastMetaContentVersionId);

          int startID = 0;

          if(previousIndexAllLastMetaContentVersionId != null)

            startID = previousIndexAllLastMetaContentVersionId;

          logger.info("Starting from " + startID);

          int newLastMetaContentVersionId = getPageNotificationMessages(notificationMessages, languageVO, startID);

          logger.info("newLastSiteNodeVersionId " + newLastMetaContentVersionId + " on " + languageVO.getName());

          logger.info("notificationMessages: " + notificationMessages.size());

          registerIndexAllProcessOngoing(null, newLastMetaContentVersionId, languageVO.getId());

          //previousIndexAllLastMetaContentVersionId = newLastMetaContentVersionId;

          RequestAnalyser.getRequestAnalyser().registerComponentStatistics("getNotificationMessagesForStructure", t.getElapsedTime());

          logger.info("newLastMetaContentVersionId " + newLastMetaContentVersionId);

          while(newLastMetaContentVersionId != -1)

          {

            logger.info("stopIndexing.get():" + stopIndexing.get());

            if(stopIndexing.get())

              break outer;

            Thread.sleep(5000);

            newLastMetaContentVersionId = getPageNotificationMessages(notificationMessages, languageVO, newLastMetaContentVersionId);

            logger.info("newLastMetaContentVersionId " + newLastMetaContentVersionId + " on " + languageVO.getName());

            logger.info("notificationMessages: " + notificationMessages.size());

            registerIndexAllProcessOngoing(null, newLastMetaContentVersionId, languageVO.getId());

            //previousIndexAllLastMetaContentVersionId = newLastMetaContentVersionId;

            RequestAnalyser.getRequestAnalyser().registerComponentStatistics("getNotificationMessages 2", t.getElapsedTime());

            logger.info("newLastMetaContentVersionId " + newLastMetaContentVersionId);

          }

        }

       

        registerIndexAllProcessDone();

       

        t2.printElapsedTime("All indexing took");

      }

      catch (Exception e)

      {

        logger.error("Error indexing notifications:" + e.getMessage(), e);

      }

      finally

      {

        logger.error("Releasing indexing flag");

        this.indexingInitialized.set(false);

      }

    }

    else

    {