Java tutorial
/* * Copyright 2004-2009 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.compass.needle.terracotta.transaction.processor; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.concurrent.BlockingQueue; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.lucene.index.IndexWriter; import org.apache.lucene.store.LockObtainFailedException; import org.compass.core.CompassException; import org.compass.core.config.CompassConfigurable; import org.compass.core.config.CompassSettings; import org.compass.core.config.SearchEngineFactoryAware; import org.compass.core.engine.SearchEngineFactory; import org.compass.core.lucene.engine.LuceneSearchEngine; import org.compass.core.lucene.engine.LuceneSearchEngineFactory; import org.compass.core.lucene.engine.transaction.TransactionProcessor; import org.compass.core.lucene.engine.transaction.TransactionProcessorFactory; import org.compass.core.lucene.engine.transaction.support.job.TransactionJob; import org.compass.core.lucene.engine.transaction.support.job.TransactionJobs; import org.compass.core.transaction.context.TransactionContextCallback; import org.compass.core.util.StringUtils; /** * The terracotta transaction processor factory allows to add {@link org.compass.core.lucene.engine.transaction.support.job.TransactionJobs TransactionJobs} * to a shared work queue (partitioned by sub index) to be processed later by worker processors. * * <p>By default, the transaction processor factory acts as a worker processor as well. In order to disable it (and make * it only a producer node) set the {@link TerracottaTransactionProcessorEnvironment#PROCESS} to <code>false</code>. * * <p>By default, each worker processor node will try and processes jobs from all sub indexes (you can start as many * as you like). In order to pin down the worker processor to work only on specific sub indexes, set then using * {@link TerracottaTransactionProcessorEnvironment#SUB_INDEXES} setting. * * <p>The processor itself, once it identifies that there is a transactional job to be processed, will try and get * more transactional jobs in a non blocking manner for better utilization of an already opened IndexWriter. By default * it will try and get 5 more, and it can be controlled using {@link TerracottaTransactionProcessorEnvironment#NON_BLOCKING_BATCH_JOBS_SIZE}. * * <p>Transactions visibility (once a transaction commits, how long till the other nodes, including the one that committed * will see the result) can be controlld using {@link org.compass.core.lucene.LuceneEnvironment.SearchEngineIndex#CACHE_INTERVAL_INVALIDATION}. * Note, by default, refreshing to a new index happens in the background and does not affect the search nodes. * * <p>When working with several machines, the index should probably be shared between all nodes. The terracotta based * directory store can be used to share the index as well. * * @author kimchy */ public class TerracottaTransactionProcessorFactory implements TransactionProcessorFactory, CompassConfigurable, SearchEngineFactoryAware { private static transient final Log logger = LogFactory.getLog(TerracottaTransactionProcessorFactory.class); private final TerracottaHolder holder = new TerracottaHolder(); private transient LuceneSearchEngineFactory searchEngineFactory; private transient CompassSettings settings; private final transient Map<String, TerracottaProcessor> currentProcessors = new ConcurrentHashMap<String, TerracottaProcessor>(); private int batchJobsSize; private long batchJobTimeout; private int nonBlockingBatchSize; public void setSearchEngineFactory(SearchEngineFactory searchEngineFactory) { this.searchEngineFactory = (LuceneSearchEngineFactory) searchEngineFactory; } public void configure(CompassSettings settings) throws CompassException { this.settings = settings; batchJobsSize = settings.getSettingAsInt(TerracottaTransactionProcessorEnvironment.BATCH_JOBS_SIZE, 5); batchJobTimeout = settings .getSettingAsTimeInMillis(TerracottaTransactionProcessorEnvironment.BATCH_JOBS_SIZE, 100); if (logger.isDebugEnabled()) { logger.debug("Terracotta Transaction Processor blocking batch size is [" + batchJobsSize + "] with timeout of [" + batchJobTimeout + "ms]"); } nonBlockingBatchSize = settings .getSettingAsInt(TerracottaTransactionProcessorEnvironment.NON_BLOCKING_BATCH_JOBS_SIZE, 5); if (logger.isDebugEnabled()) { logger.debug( "Terracotta Transaction Processor non blocking batch size is [" + nonBlockingBatchSize + "]"); } holder.getInitializationLock().lock(); try { for (String subIndex : searchEngineFactory.getIndexManager().getSubIndexes()) { BlockingQueue<TransactionJobs> subIndexJobs = holder.getJobsPerSubIndex().get(subIndex); if (subIndexJobs == null) { subIndexJobs = new LinkedBlockingQueue<TransactionJobs>(); holder.getJobsPerSubIndex().put(subIndex, subIndexJobs); } Lock processorLock = holder.getProcessorLocks().get(subIndex); if (processorLock == null) { processorLock = new ReentrantLock(); holder.getProcessorLocks().put(subIndex, processorLock); } } } finally { holder.getInitializationLock().unlock(); } if (settings.getSettingAsBoolean(TerracottaTransactionProcessorEnvironment.PROCESS, true)) { String[] subIndexesSetting = StringUtils.commaDelimitedListToStringArray( settings.getSetting(TerracottaTransactionProcessorEnvironment.SUB_INDEXES)); if (subIndexesSetting.length == 0) { subIndexesSetting = null; } String[] aliasesSetting = StringUtils.commaDelimitedListToStringArray( settings.getSetting(TerracottaTransactionProcessorEnvironment.ALIASES)); if (aliasesSetting.length == 0) { aliasesSetting = null; } String[] subIndexes = searchEngineFactory.getIndexManager().calcSubIndexes(subIndexesSetting, aliasesSetting, null); logger.info("Terracotta Transaction Processor Worker started. Sub indexes to process: " + Arrays.toString(subIndexes)); for (String subIndex : subIndexes) { TerracottaProcessor processor = new TerracottaProcessor(subIndex, holder.getJobsPerSubIndex().get(subIndex)); searchEngineFactory.getExecutorManager().submit(processor); currentProcessors.put(subIndex, processor); } } else { logger.info( "Terracotta transaction processor will only submit transactions to be processed (none worker mode)"); } } public TransactionProcessor create(LuceneSearchEngine searchEngine) { return new TerracottaTransactionProcessor(searchEngine, this); } public void close() { for (TerracottaProcessor processor : currentProcessors.values()) { processor.stop(); } } /** * The terracotta transaction processor is not thread safe. */ public boolean isThreadSafe() { return false; } public Map<String, TransactionJobs> add(TransactionJobs jobs) { Map<String, TransactionJobs> subIndexesJobs = jobs.buildJobsPerSubIndex(); for (Map.Entry<String, TransactionJobs> entry : subIndexesJobs.entrySet()) { holder.getJobsPerSubIndex().get(entry.getKey()).add(entry.getValue()); } return subIndexesJobs; } public void remove(Map<String, TransactionJobs> subIndexesJobs) { for (Map.Entry<String, TransactionJobs> entry : subIndexesJobs.entrySet()) { holder.getJobsPerSubIndex().get(entry.getKey()).remove(entry.getValue()); } } private class TerracottaProcessor implements Runnable { private final BlockingQueue<TransactionJobs> jobsToProcess; private final String subIndex; private volatile boolean running = true; private TerracottaProcessor(String subIndex, BlockingQueue<TransactionJobs> jobsToProcess) { this.subIndex = subIndex; this.jobsToProcess = jobsToProcess; } public String getSubIndex() { return subIndex; } public void stop() { running = false; } private String message(String message) { return "Processor [" + subIndex + "]: " + message; } public void run() { while (running) { // each node locks and waits for jobs. This means that there are never // two processors for the same sub index waiting for (and potentially taking) jobs. // This also allows for several JVMs to run and be able to share the load for a specific // sub index (if they are handling more than one sub index) Lock processLock = holder.getProcessorLocks().get(subIndex); boolean locked = false; // create a shared lock for terracotta to process try { locked = processLock.tryLock(1000, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { // we geto interupted, bail out running = false; } if (!locked) { continue; } try { TransactionJobs jobs = null; try { jobs = jobsToProcess.poll(1000, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { // we geto interupted, bail out running = false; } if (jobs == null) { continue; } final List<TransactionJobs> jobsList = new ArrayList<TransactionJobs>(); jobsList.add(jobs); for (int i = 0; i < batchJobsSize; i++) { try { jobs = jobsToProcess.poll(batchJobTimeout, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { // we geto interupted, bail out in the next run running = false; } if (jobs == null) { break; } if (logger.isTraceEnabled()) { logger.trace("Batching additional Jobs [" + System.identityHashCode(jobs) + "]"); } jobsList.add(jobs); } jobsToProcess.drainTo(jobsList, nonBlockingBatchSize); if (logger.isDebugEnabled()) { int totalJobs = 0; for (TransactionJobs x : jobsList) { totalJobs += x.getJobs().size(); } logger.debug(message( "procesing [" + jobsList.size() + "] transactions with [" + totalJobs + "] jobs")); } final TransactionJobs finalJobs = jobs; searchEngineFactory.getTransactionContext().execute(new TransactionContextCallback<Boolean>() { public Boolean doInTransaction() throws CompassException { IndexWriter writer; try { writer = searchEngineFactory.getLuceneIndexManager().getIndexWritersManager() .openIndexWriter(settings, subIndex); searchEngineFactory.getLuceneIndexManager().getIndexWritersManager() .trackOpenIndexWriter(subIndex, writer); } catch (LockObtainFailedException e) { // we failed to get a lock, probably another one running and getting it, which is bad! logger.error(message( "Another instance is running on the sub index, make sure it does not. Should not happen really...")); return false; } catch (IOException e) { logger.error(message("Failed to open index writer, dismissing jobs [" + finalJobs + "]. Should not happen really..."), e); return false; } try { for (TransactionJobs xJobs : jobsList) { for (TransactionJob job : xJobs.getJobs()) { job.execute(writer, searchEngineFactory); } } writer.commit(); } catch (Exception e) { logger.error(message("Failed to process jobs [" + finalJobs + "]"), e); try { writer.rollback(); } catch (IOException e1) { logger.warn( message("Failed to rollback transaction on jobs [" + finalJobs + "]"), e); } } finally { try { writer.close(); } catch (IOException e) { logger.warn(message("Failed to close writer, ignoring"), e); } finally { searchEngineFactory.getLuceneIndexManager().getIndexWritersManager() .trackCloseIndexWriter(subIndex, writer); } } return null; } }); } finally { processLock.unlock(); } } } } }