BaseSearchServiceImpl.java

/**********************************************************************************
 * $URL: https://source.sakaiproject.org/svn/search/trunk/search-impl/impl/src/java/org/sakaiproject/search/component/service/impl/BaseSearchServiceImpl.java $
 * $Id: BaseSearchServiceImpl.java 118402 2013-01-16 21:32:11Z jbush@rsmart.com $
 ***********************************************************************************
 *
 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008 The Sakai Foundation
 *
 * Licensed under the Educational Community 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.opensource.org/licenses/ECL-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.sakaiproject.search.component.service.impl;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.security.GeneralSecurityException;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.httpclient.HostConfiguration;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpConnectionManager;
import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.params.HttpConnectionManagerParams;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermFreqVector;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.Filter;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.util.Version;
import org.sakaiproject.component.cover.ServerConfigurationService;
import org.sakaiproject.event.api.EventTrackingService;
import org.sakaiproject.event.api.NotificationEdit;
import org.sakaiproject.event.api.NotificationService;
import org.sakaiproject.search.api.InvalidSearchQueryException;
import org.sakaiproject.search.api.SearchIndexBuilder;
import org.sakaiproject.search.api.SearchList;
import org.sakaiproject.search.api.SearchResult;
import org.sakaiproject.search.api.SearchService;
import org.sakaiproject.search.api.SearchStatus;
import org.sakaiproject.search.api.TermFrequency;
import org.sakaiproject.search.component.Messages;
import org.sakaiproject.search.filter.SearchItemFilter;
import org.sakaiproject.search.index.IndexReloadListener;
import org.sakaiproject.search.index.IndexStorage;
import org.sakaiproject.search.journal.impl.JournalSettings;
import org.sakaiproject.search.model.SearchBuilderItem;
import org.sakaiproject.search.util.DidYouMeanParser;
import org.sakaiproject.tool.api.SessionManager;
import org.sakaiproject.user.api.User;
import org.sakaiproject.user.api.UserDirectoryService;

/**
 * The search service
 * 
 * @author ieb
 */
public abstract class BaseSearchServiceImpl implements SearchService
{

	private static Log log = LogFactory.getLog(BaseSearchServiceImpl.class);

	/**
	 * The index builder dependency
	 */
	private SearchIndexBuilder searchIndexBuilder;
	/**
	 * dependency
	 */
	private NotificationService notificationService;
	/**
	 * dependency
	 */
	private EventTrackingService eventTrackingService;

	/**
	 * dependency
	 */
	private UserDirectoryService userDirectoryService;

	/**
	 * dependency
	 */
	private SessionManager sessionManager;

	private static final String DIGEST_STORE_FOLDER = "/searchdigest/";

	/**
	 * Optional dependencies
	 */
	private List<String> triggerFunctions;

	/**
	 * the notification object
	 */
	private NotificationEdit notification = null;

	protected IndexStorage indexStorage;

	/**
	 * init completed
	 */
	protected boolean initComplete = false;




	private SearchItemFilter filter;

	private Map luceneFilters = new HashMap();

	private Map luceneSorters = new HashMap();

	private String defaultFilter = null;

	private String defaultSorter = null;


	private String sharedKey = null;

	private String searchServerUrl = null;

	private boolean searchServer = false;

	private ThreadLocal<String> localSearch = new ThreadLocal<String>();

	private HttpClient httpClient;

	private HttpConnectionManagerParams httpParams = new HttpConnectionManagerParams();

	private HttpConnectionManager httpConnectionManager = new MultiThreadedHttpConnectionManager();
	
	/** Configuration: to run the ddl on init or not. */
	protected boolean autoDdl = false;

	
	private boolean diagnostics;

	private boolean enabled;

	private JournalSettings journalSettings;
	
	public void setJournalSettings(JournalSettings journalSettings) {
		this.journalSettings = journalSettings;
	}

	public abstract String getStatus();
	
	public abstract SearchStatus getSearchStatus();

	public abstract boolean removeWorkerLock();

	/**
	 * Configuration: to run the ddl on init or not.
	 * 
	 * @param value
	 *        the auto ddl value.
	 */
	public void setAutoDdl(String value)
	{
		autoDdl = Boolean.valueOf(value).booleanValue();
	}
	/**
	 */
	public String getAutoDdl()
	{
		return String.valueOf(autoDdl);
	}
	/**
	 * Register a notification action to listen to events and modify the search
	 * index
	 */
	public void init()
	{

		try
		{

			// register a transient notification for resources
			notification = notificationService.addTransientNotification();

			// add all the functions that are registered to trigger search index
			// modification

			notification.setFunction(SearchService.EVENT_TRIGGER_SEARCH);
			if (triggerFunctions != null)
			{
				for (Iterator<String> ifn = triggerFunctions.iterator(); ifn.hasNext();)
				{
					String function = (String) ifn.next();
					notification.addFunction(function);
					if (log.isDebugEnabled())
					{
						log.debug("Adding Search Register " + function); //$NON-NLS-1$
					}
				}
			}

			// set the filter to any site related resource
			notification.setResourceFilter("/"); //$NON-NLS-1$

			// set the action
			notification.setAction(new SearchNotificationAction(searchIndexBuilder));

			// Configure params for the Connection Manager
			httpParams.setDefaultMaxConnectionsPerHost(20);
			httpParams.setMaxTotalConnections(30);

			// This next line may not be necessary since we specified default 2
			// lines ago, but here it is anyway
			httpParams.setMaxConnectionsPerHost(HostConfiguration.ANY_HOST_CONFIGURATION,
					20);

			// Set up the connection manager
			httpConnectionManager.setParams(httpParams);

			// Finally set up the static multithreaded HttpClient
			httpClient = new HttpClient(httpConnectionManager);
			
			if (diagnostics)
			{
				indexStorage.enableDiagnostics();
			}
			else
			{
				indexStorage.disableDiagnostics();
			}
				
			indexStorage.addReloadListener(new IndexReloadListener() {

				public void reloaded(long reloadStart, long reloadEnd)
				{
					if (diagnostics)
					{
						log.info("Index Reloaded containing " + getNDocs()
								+ " active documents and  " + getPendingDocs()
								+ " pending documents in " + (reloadEnd - reloadStart)
								+ "ms");
					}
				}
				
			});

			
		}
		catch (Throwable t)
		{
			log.error("Failed to start ", t); //$NON-NLS-1$
		}
		
	}

	/**
	 * @return Returns the triggerFunctions.
	 */
	public List<String> getTriggerFunctions()
	{
		return triggerFunctions;
	}

	/**
	 * @param triggerFunctions
	 *        The triggerFunctions to set.
	 */
	public void setTriggerFunctions(List<String> triggerFunctions)
	{
		if (initComplete)
			throw new RuntimeException(
					" use register function at runtime, setTriggerFucntions is for Spring IoC only"); //$NON-NLS-1$
		this.triggerFunctions = triggerFunctions;
	}

	/**
	 * {@inheritDoc}
	 */
	public void registerFunction(String function)
	{
		notification.addFunction(function);
		if (log.isDebugEnabled())
		{
			log.debug("Adding Function " + function); //$NON-NLS-1$
		}
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @param indexFilter
	 */
	public SearchList search(String searchTerms, List<String> contexts, int start, int end) throws InvalidSearchQueryException
	{
		return search(searchTerms, contexts, start, end, defaultFilter, defaultSorter);
	}

	public SearchList search(String searchTerms, List<String> contexts, int start, int end,
			String filterName, String sorterName) throws InvalidSearchQueryException
	{
		try
		{
			BooleanQuery query = new BooleanQuery();

			QueryParser qp = new QueryParser(Version.LUCENE_29,SearchService.FIELD_CONTENTS, getAnalyzer());
			Query textQuery = qp.parse(searchTerms);
			                       
		    // Support cross context searches
			if (contexts != null && contexts.size() > 0)
			{
				BooleanQuery contextQuery = new BooleanQuery();
				for (Iterator<String> i = contexts.iterator(); i.hasNext();)
				{
					// Setup query so that it will allow results from any
					// included site, not all included sites.
					contextQuery.add(new TermQuery(new Term(SearchService.FIELD_SITEID,
							(String) i.next())), BooleanClause.Occur.SHOULD);
					// This would require term to be in all sites :-(
					// contextQuery.add(new TermQuery(new Term(
					// SearchService.FIELD_SITEID, (String) i.next())),
					// BooleanClause.Occur.MUST);
				}

				query.add(contextQuery, BooleanClause.Occur.MUST);
			}
			query.add(textQuery, BooleanClause.Occur.MUST);
			log.debug("Compiled Query is " + query.toString()); //$NON-NLS-1$

			if (localSearch.get() == null && searchServerUrl != null
					&& searchServerUrl.length() > 0)
			{
				try
				{
					PostMethod post = new PostMethod(searchServerUrl);
					String userId = sessionManager.getCurrentSessionUserId();
					StringBuilder sb = new StringBuilder();
					for (Iterator<String> ci = contexts.iterator(); ci.hasNext();)
					{
						sb.append(ci.next()).append(";"); //$NON-NLS-1$
					}
					String contextParam = sb.toString();
					post.setParameter(REST_CHECKSUM, digestCheck(userId, searchTerms));
					post.setParameter(REST_CONTEXTS, contextParam);
					post.setParameter(REST_END, String.valueOf(end));
					post.setParameter(REST_START, String.valueOf(start));
					post.setParameter(REST_TERMS, searchTerms);
					post.setParameter(REST_USERID, userId);

					int status = httpClient.executeMethod(post);
					if (status != 200)
					{
						throw new RuntimeException(
								"Failed to perform remote search, http status was " + status); //$NON-NLS-1$
					}

					String response = post.getResponseBodyAsString();
					return new SearchListResponseImpl(response, textQuery, start, end,
							getAnalyzer(), filter, searchIndexBuilder, this);
				}
				catch (Exception ex)
				{

					log.error("Remote Search Failed ", ex); //$NON-NLS-1$
					throw new IOException(ex.getMessage());
				}

			}
			else
			{

				IndexSearcher indexSearcher = getIndexSearcher(false);
				int MAX_RESULTS = 1000000;
				if (indexSearcher != null)
				{
					TopDocs topDocs = null;
					Filter indexFilter = (Filter) luceneFilters.get(filterName);
					Sort indexSorter = (Sort) luceneSorters.get(sorterName);
					if (log.isDebugEnabled())
					{
						log.debug("Using Filter " + filterName + ":" //$NON-NLS-1$ //$NON-NLS-2$
								+ indexFilter + " and " + sorterName + ":" //$NON-NLS-1$ //$NON-NLS-2$
								+ indexSorter);
					}
					if (indexFilter != null && indexSorter != null)
					{
						topDocs = indexSearcher.search(query, indexFilter, MAX_RESULTS, indexSorter);
					}
					else if (indexFilter != null)
					{
						topDocs = indexSearcher.search(query, indexFilter, MAX_RESULTS);
					}
					else if (indexSorter != null)
					{
						topDocs = indexSearcher.search(query, null, MAX_RESULTS, indexSorter);
					}
					else
					{
						topDocs = indexSearcher.search(query, MAX_RESULTS);
					}
					if (log.isDebugEnabled())
					{
						log.debug("Got " + topDocs.totalHits + " hits"); //$NON-NLS-1$ //$NON-NLS-2$
					}
					String context = null;
					if (contexts != null && contexts.size() > 0)
					{
						//seeing events doesn't support multi context use the first
						context = contexts.get(0);
					}
					eventTrackingService.post(eventTrackingService.newEvent(EVENT_SEARCH,
							EVENT_SEARCH_REF + textQuery.toString(), context, true,
							NotificationService.PREF_IMMEDIATE));
					return new SearchListImpl(topDocs, indexSearcher, textQuery, start, end, 
							getAnalyzer(), filter, searchIndexBuilder, this);
				}
				else
				{
					throw new RuntimeException(
							"Failed to start the Lucene Searche Engine"); //$NON-NLS-1$
				}
			}

		}
		catch (ParseException e)
		{
			throw new InvalidSearchQueryException("Failed to parse Query ", e); //$NON-NLS-1$
		}
		catch (IOException e)
		{
			throw new RuntimeException("Failed to run Search ", e); //$NON-NLS-1$
		}
	}

	

	public void refreshInstance()
	{
		searchIndexBuilder.refreshIndex();

	}

	public void rebuildInstance()
	{
		searchIndexBuilder.rebuildIndex();
	}

	public void refreshSite(String currentSiteId)
	{
		searchIndexBuilder.refreshIndex(currentSiteId);
	}

	public void rebuildSite(String currentSiteId)
	{
		searchIndexBuilder.rebuildIndex(currentSiteId);

	}

	/**
	 * {@inheritDoc}
	 */
	public void reload()
	{
		getIndexSearcher(true);
	}

	public void forceReload()
	{
		indexStorage.forceNextReload();
	}

	/**
	 * The sequence is, peform reload,
	 * 
	 * @param reload
	 * @return
	 */

	public IndexSearcher getIndexSearcher(boolean reload)
	{
		try
		{
			return indexStorage.getIndexSearcher(reload);
		}
		catch (Exception ex)
		{
			log.error("Failed to get an index searcher ", ex);
			throw new RuntimeException("Failed to get an index searcher ", ex);
		}
	}


	public int getNDocs()
	{
		try
		{
			return getIndexSearcher(false).getIndexReader().numDocs();
		}
		catch (Exception e)
		{
			return -1;
		}
	}

	public int getPendingDocs()
	{
		return searchIndexBuilder.getPendingDocuments();
	}

	public List<SearchBuilderItem> getAllSearchItems()
	{
		return searchIndexBuilder.getAllSearchItems();
	}

	public List<SearchBuilderItem> getSiteMasterSearchItems()
	{
		return searchIndexBuilder.getSiteMasterSearchItems();
	}

	public List<SearchBuilderItem> getGlobalMasterSearchItems()
	{
		return searchIndexBuilder.getGlobalMasterSearchItems();
	}




	/**
	 * @return Returns the filter.
	 */
	public SearchItemFilter getFilter()
	{
		return filter;
	}

	/**
	 * @param filter
	 *        The filter to set.
	 */
	public void setFilter(SearchItemFilter filter)
	{
		this.filter = filter;
	}

	/**
	 * @return Returns the defaultFilter.
	 */
	public String getDefaultFilter()
	{
		return defaultFilter;
	}

	/**
	 * @param defaultFilter
	 *        The defaultFilter to set.
	 */
	public void setDefaultFilter(String defaultFilter)
	{
		this.defaultFilter = defaultFilter;
	}

	/**
	 * @return Returns the defaultSorter.
	 */
	public String getDefaultSorter()
	{
		return defaultSorter;
	}

	/**
	 * @param defaultSorter
	 *        The defaultSorter to set.
	 */
	public void setDefaultSorter(String defaultSorter)
	{
		this.defaultSorter = defaultSorter;
	}

	/**
	 * @return Returns the luceneFilters.
	 */
	public Map getLuceneFilters()
	{
		return luceneFilters;
	}

	/**
	 * @param luceneFilters
	 *        The luceneFilters to set.
	 */
	public void setLuceneFilters(Map luceneFilters)
	{
		this.luceneFilters = luceneFilters;
	}

	/**
	 * @return Returns the luceneSorters.
	 */
	public Map getLuceneSorters()
	{
		return luceneSorters;
	}

	/**
	 * @param luceneSorters
	 *        The luceneSorters to set.
	 */
	public void setLuceneSorters(Map luceneSorters)
	{
		this.luceneSorters = luceneSorters;
	}

	

	public TermFrequency getTerms(int documentId) throws IOException
	{
		final TermFreqVector tf = getIndexSearcher(false).getIndexReader()
				.getTermFreqVector(documentId, FIELD_CONTENTS);
		return new TermFrequency()
		{
			public String[] getTerms()
			{
				if (tf != null)
				{
					return tf.getTerms();
				}
				return new String[0];
			}

			public int[] getFrequencies()
			{
				if (tf != null)
				{
					return tf.getTermFrequencies();
				}
				return new int[0];
			}
		};
	}

	public String searchXML(Map parameterMap)
	{
		String userid = null;
		String searchTerms = null;
		String checksum = null;
		String contexts = null;
		String ss = null;
		String se = null;
		try
		{
			if (!searchServer)
			{
				throw new Exception(Messages.getString("SearchServiceImpl.49")); //$NON-NLS-1$
			}
			String[] useridA = (String[]) parameterMap.get(REST_USERID);
			String[] searchTermsA = (String[]) parameterMap.get(REST_TERMS);
			String[] checksumA = (String[]) parameterMap.get(REST_CHECKSUM);
			String[] contextsA = (String[]) parameterMap.get(REST_CONTEXTS);
			String[] ssA = (String[]) parameterMap.get(REST_START);
			String[] seA = (String[]) parameterMap.get(REST_END);

			StringBuilder sb = new StringBuilder();
			sb.append("<?xml version=\"1.0\"?>"); //$NON-NLS-1$

			boolean requestError = false;
			if (useridA == null || useridA.length != 1)
			{
				requestError = true;
			}
			else
			{
				userid = useridA[0];
			}
			if (searchTermsA == null || searchTermsA.length != 1)
			{
				requestError = true;
			}
			else
			{
				searchTerms = searchTermsA[0];
			}
			if (checksumA == null || checksumA.length != 1)
			{
				requestError = true;
			}
			else
			{
				checksum = checksumA[0];
			}
			if (contextsA == null || contextsA.length != 1)
			{
				requestError = true;
			}
			else
			{
				contexts = contextsA[0];
			}
			if (ssA == null || ssA.length != 1)
			{
				requestError = true;
			}
			else
			{
				ss = ssA[0];
			}
			if (seA == null || seA.length != 1)
			{
				requestError = true;
			}
			else
			{
				se = seA[0];
			}

			if (requestError)
			{
				throw new Exception(Messages.getString("SearchServiceImpl.34")); //$NON-NLS-1$

			}

			int searchStart = Integer.parseInt(ss);
			int searchEnd = Integer.parseInt(se);
			String[] ctxa = contexts.split(";"); //$NON-NLS-1$
			List<String> ctx = new ArrayList<String>(ctxa.length);
			for (int i = 0; i < ctxa.length; i++)
			{
				ctx.add(ctxa[i]);
			}

			if (sharedKey != null && sharedKey.length() > 0)
			{
				String check = digestCheck(userid, searchTerms);
				if (!check.equals(checksum))
				{
					throw new Exception(Messages.getString("SearchServiceImpl.53")); //$NON-NLS-1$
				}
			}

			org.sakaiproject.tool.api.Session s = sessionManager.startSession();
			User u = userDirectoryService.getUser("admin"); //$NON-NLS-1$
			s.setUserId(u.getId());
			sessionManager.setCurrentSession(s);
			localSearch.set("localsearch"); //$NON-NLS-1$
			try
			{

				SearchList sl = search(searchTerms, ctx, searchStart, searchEnd);
				sb.append("<results "); //$NON-NLS-1$
				sb.append(" fullsize=\"").append(sl.getFullSize()) //$NON-NLS-1$
						.append("\" "); //$NON-NLS-1$
				sb.append(" start=\"").append(sl.getStart()).append("\" "); //$NON-NLS-1$ //$NON-NLS-2$
				sb.append(" size=\"").append(sl.size()).append("\" "); //$NON-NLS-1$ //$NON-NLS-2$
				sb.append(" >"); //$NON-NLS-1$
				for (Iterator<SearchResult> si = sl.iterator(); si.hasNext();)
				{
					SearchResult sr = (SearchResult) si.next();
					sr.toXMLString(sb);
				}
				sb.append("</results>"); //$NON-NLS-1$
				return sb.toString();
			}
			finally
			{
				sessionManager.setCurrentSession(null);
				localSearch.set(null);
			}
		}
		catch (Exception ex)
		{
			log.error("Search Service XML response failed ",ex);
			StringBuilder sb = new StringBuilder();
			sb.append("<?xml version=\"1.0\"?>"); //$NON-NLS-1$
			sb.append("<fault>"); //$NON-NLS-1$
			sb.append("<request>"); //$NON-NLS-1$
			sb.append("<![CDATA["); //$NON-NLS-1$
			sb.append(" userid = ").append(StringEscapeUtils.escapeXml(userid)).append("\n"); //$NON-NLS-1$ //$NON-NLS-2$
			sb
					.append(" searchTerms = ").append(StringEscapeUtils.escapeXml(searchTerms)).append("\n"); //$NON-NLS-1$ //$NON-NLS-2$
			sb
					.append(" checksum = ").append(StringEscapeUtils.escapeXml(checksum)).append("\n"); //$NON-NLS-1$ //$NON-NLS-2$
			sb
					.append(" contexts = ").append(StringEscapeUtils.escapeXml(contexts)).append("\n"); //$NON-NLS-1$ //$NON-NLS-2$
			sb.append(" ss = ").append(StringEscapeUtils.escapeXml(ss)).append("\n"); //$NON-NLS-1$ //$NON-NLS-2$
			sb.append(" se = ").append(StringEscapeUtils.escapeXml(se)).append("\n"); //$NON-NLS-1$ //$NON-NLS-2$
			sb.append("]]>"); //$NON-NLS-1$
			sb.append("</request>"); //$NON-NLS-1$
			sb.append("<error>"); //$NON-NLS-1$
			sb.append("<![CDATA["); //$NON-NLS-1$
			try
			{
				StringWriter sw = new StringWriter();
				PrintWriter pw = new PrintWriter(sw);
				ex.printStackTrace(pw);
				pw.flush();
				sb.append(sw.toString());
				pw.close();
				sw.close();
			}
			catch (Exception ex2)
			{
				sb.append("Failed to serialize exception " + ex.getMessage()) //$NON-NLS-1$
						.append("\n"); //$NON-NLS-1$
				sb.append("Case:  " + ex2.getMessage()); //$NON-NLS-1$

			}
			sb.append("]]>"); //$NON-NLS-1$
			sb.append("</error>"); //$NON-NLS-1$
			sb.append("</fault>"); //$NON-NLS-1$
			return sb.toString();
		}
	}

	private String digestCheck(String userid, String searchTerms)
			throws GeneralSecurityException, IOException
	{
		MessageDigest sha1 = MessageDigest.getInstance("SHA1"); //$NON-NLS-1$
		String chstring = sharedKey + userid + searchTerms;
		return byteArrayToHexStr(sha1.digest(chstring.getBytes("UTF-8"))); //$NON-NLS-1$
	}

	private static String byteArrayToHexStr(byte[] data)
	{
		char[] chars = new char[data.length * 2];
		for (int i = 0; i < data.length; i++)
		{
			byte current = data[i];
			int hi = (current & 0xF0) >> 4;
			int lo = current & 0x0F;
			chars[2 * i] = (char) (hi < 10 ? ('0' + hi) : ('A' + hi - 10));
			chars[2 * i + 1] = (char) (lo < 10 ? ('0' + lo) : ('A' + lo - 10));
		}
		return new String(chars);
	}

	/**
	 * @return the sharedKey
	 */
	public String getSharedKey()
	{
		return sharedKey;
	}

	/**
	 * @param sharedKey
	 *        the sharedKey to set
	 */
	public void setSharedKey(String sharedKey)
	{
		this.sharedKey = sharedKey;
	}

	/**
	 * @return the searchServerUrl
	 */
	public String getSearchServerUrl()
	{
		return searchServerUrl;
	}

	/**
	 * @param searchServerUrl
	 *        the searchServerUrl to set
	 */
	public void setSearchServerUrl(String searchServerUrl)
	{
		this.searchServerUrl = searchServerUrl;
	}

	/**
	 * @return the searchServer
	 */
	public boolean isSearchServer()
	{
		return searchServer;
	}

	/**
	 * @param searchServer
	 *        the searchServer to set
	 */
	public void setSearchServer(boolean searchServer)
	{
		this.searchServer = searchServer;
	}


	public boolean getDiagnostics()
	{
		return hasDiagnostics();
	}

	public void setDiagnostics(boolean diagnostics)
	{
		if (diagnostics)
		{
			enableDiagnostics();
		}
		else
		{
			disableDiagnostics();
		}
	}
	

		
	
	/**
	 * @return the eventTrackingService
	 */
	public EventTrackingService getEventTrackingService()
	{
		return eventTrackingService;
	}
	/**
	 * @param eventTrackingService the eventTrackingService to set
	 */
	public void setEventTrackingService(EventTrackingService eventTrackingService)
	{
		this.eventTrackingService = eventTrackingService;
	}
	/**
	 * @return the notificationService
	 */
	public NotificationService getNotificationService()
	{
		return notificationService;
	}
	/**
	 * @param notificationService the notificationService to set
	 */
	public void setNotificationService(NotificationService notificationService)
	{
		this.notificationService = notificationService;
	}
	/**
	 * @return the searchIndexBuilder
	 */
	public SearchIndexBuilder getSearchIndexBuilder()
	{
		return searchIndexBuilder;
	}
	/**
	 * @param searchIndexBuilder the searchIndexBuilder to set
	 */
	public void setSearchIndexBuilder(SearchIndexBuilder searchIndexBuilder)
	{
		this.searchIndexBuilder = searchIndexBuilder;
	}
	/**
	 * @return the sessionManager
	 */
	public SessionManager getSessionManager()
	{
		return sessionManager;
	}
	/**
	 * @param sessionManager the sessionManager to set
	 */
	public void setSessionManager(SessionManager sessionManager)
	{
		this.sessionManager = sessionManager;
	}
	/**
	 * @return the userDirectoryService
	 */
	public UserDirectoryService getUserDirectoryService()
	{
		return userDirectoryService;
	}
	/**
	 * @param userDirectoryService the userDirectoryService to set
	 */
	public void setUserDirectoryService(UserDirectoryService userDirectoryService)
	{
		this.userDirectoryService = userDirectoryService;
	}
	
	
	/**
	 * @return Returns the indexStorage.
	 */
	public IndexStorage getIndexStorage()
	{
		return indexStorage;
	}

	/**
	 * @param indexStorage
	 *        The indexStorage to set.
	 */
	public void setIndexStorage(IndexStorage indexStorage)
	{
		this.indexStorage = indexStorage;
	}

	protected Analyzer getAnalyzer()
	{
		return indexStorage.getAnalyzer();
	}
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.sakaiproject.search.api.Diagnosable#disableDiagnostics()
	 */
	public void disableDiagnostics()
	{
		diagnostics = false;
		if (indexStorage != null)
		{
			indexStorage.disableDiagnostics();
		}

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.sakaiproject.search.api.Diagnosable#enableDiagnostics()
	 */
	public void enableDiagnostics()
	{
		diagnostics = true;
		if (indexStorage != null)
		{
			indexStorage.enableDiagnostics();
		}
	}

	/**
	 * @see org.sakaiproject.search.api.Diagnosable#hasDiagnostics()
	 */
	public boolean hasDiagnostics()
	{
		return diagnostics;
	}
	
	public List getSegmentInfo()
	{
		return indexStorage.getSegmentInfoList();
	}


	/* (non-Javadoc)
	 * @see org.sakaiproject.search.api.SearchService#isEnabled()
	 */
	public boolean isEnabled()
	{
		enabled = ServerConfigurationService.getBoolean("search.enable",false);

		log.info("Enable = "
				+ ServerConfigurationService.getString("search.enable", "false"));

		enabled = enabled && ServerConfigurationService.getBoolean("search.indexbuild",true);
		return enabled;
	}
	
	


	public String getDigestStoragePath() {
		String customPath = ServerConfigurationService.getString("search.digestPath");
		String storePath = null;
		if (customPath == null || "".equals(customPath)) {
			storePath = ServerConfigurationService.getString("bodyPath@org.sakaiproject.content.api.ContentHostingService");
			if (storePath == null || "".equals(storePath)) {
				return null;
			}
		} else {
			storePath = customPath;
		}
		return storePath + "/" + DIGEST_STORE_FOLDER;
	}
	
	Directory spellIndexDirectory = null;

    public String[] getSearchSuggestions(String searchString, String currentSiteId, boolean allMySites) {
        String suggestion = getSearchSuggestion(searchString);
        if (suggestion != null && suggestion.length() > 0) {
            return new String[]{searchString};
        }
        return new String[]{};
    }

	public String getSearchSuggestion(String queryString) {
		log.info("getSearchSuggestion( " + queryString + ")");
		
		if (!ServerConfigurationService.getBoolean("search.experimental.didyoumean", false)) {
			log.info("did you mean feature is not enabled");
			return null;
		}
		
		if (spellIndexDirectory == null) {
			spellIndexDirectory = indexStorage.getSpellDirectory();
			
		}
		
		//if its still null we we'rent able to create a spellindex
		if (spellIndexDirectory == null) {
			log.info("Spell index is not available");
			return null;
		}
		
		
		//the reader to the original index:
		IndexReader indexReaderOrigional = null;
		try {
			indexReaderOrigional = indexStorage.getIndexReader();
		} catch (CorruptIndexException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		
		DidYouMeanParser parser = new DidYouMeanParser(SearchService.FIELD_CONTENTS, spellIndexDirectory, indexReaderOrigional);
		
		try {
			Query query = parser.suggest(queryString);
			//the service may have no suggestions
			if (query != null) {
				log.debug("got suggestion: " + query.toString(SearchService.FIELD_CONTENTS));
				return query.toString(SearchService.FIELD_CONTENTS);
			}
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;

	}

	


}