Synnefo

import java.io.StringWriter;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.transform.OutputKeys;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerConfigurationException;

import javax.xml.transform.TransformerException;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import org.apache.commons.configuration.Configuration;

import org.apache.commons.httpclient.HttpClient;

import org.apache.commons.httpclient.HttpException;

import org.apache.commons.httpclient.NameValuePair;

import org.apache.commons.httpclient.methods.GetMethod;

import org.apache.commons.httpclient.methods.PostMethod;

import org.apache.commons.httpclient.methods.StringRequestEntity;

import org.w3c.dom.DOMException;

import org.w3c.dom.Document;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.xml.sax.SAXException;

	 * We have to use the dismax query type (instead of the

	 * standard) because it allows for search time field boosting. This is because we can't use indexing

	 * time field boosting due to the patched rich indexing API that does not allow it

	 *

			HttpClient httpClient = new HttpClient();

			GetMethod method = new GetMethod(getConfiguration().getString("solrSelectUrl"));

			NameValuePair[] params = {new NameValuePair("qt", "dismax"),

										new NameValuePair("q", query),

										new NameValuePair("sort", "score desc"),

										new NameValuePair("indent", "on")};

			method.setQueryString(params);

			int retryCount = 0;

			int statusCode = 0;

			String response = null;

			do {

				statusCode = httpClient.executeMethod(method);

				logger.debug("HTTP status: " + statusCode);

				response = method.getResponseBodyAsString();

				logger.debug(response);

				retryCount++;

				if (statusCode != 200 && retryCount < 3)

					try {

						Thread.sleep(3000); //Give Solr a little time to be available

					} catch (InterruptedException e) {

					}

			} while (statusCode != 200 && retryCount < 3);

			if (statusCode != 200)

				throw new EJBException("Search query return error:\n" + response);

			DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

			DocumentBuilder db = dbf.newDocumentBuilder();

			Document doc = db.parse(method.getResponseBodyAsStream());

			method.releaseConnection();

			Node root = doc.getElementsByTagName("response").item(0);

			Node lst = root.getFirstChild().getNextSibling();

			Node status = lst.getFirstChild().getNextSibling();

			if (status.getAttributes().getNamedItem("name").getNodeValue().equals("status") &&

				status.getTextContent().equals("0")) {

				List<FileHeader> fileResult = new ArrayList<FileHeader>();

				Node result = lst.getNextSibling().getNextSibling();

				NodeList docs = result.getChildNodes();

				User user = getUser(userId);

				for (int i=1; i<docs.getLength(); i=i+2) {

					Node d = docs.item(i);

					NodeList docData = d.getChildNodes();

					for (int j=1; j<docData.getLength(); j=j+2) {

						Node dd = docData.item(j);

						if (dd.getAttributes().item(0).getNodeName().equals("name") &&

							dd.getAttributes().item(0).getNodeValue().equals("id")) {

							Long fileId = Long.valueOf(dd.getTextContent());

							try {

								FileHeader file = dao.getEntityById(FileHeader.class, fileId);

								if (file.hasReadPermission(user)) {

									fileResult.add(file);

									logger.debug("File added " + fileId);

								}

							} catch (ObjectNotFoundException e) {

								logger.warn("Search result not found", e);

							}

						}

					}

				return fileResult;

			throw new EJBException();

		} catch (HttpException e) {

			throw new EJBException(e);

		} catch (IOException e) {

			throw new EJBException(e);

		} catch (SAXException e) {

		} catch (ParserConfigurationException e) {

	/**

	 * Sends a optimize message to the solr server

	 *

	 * @param httpClient

	 * @param retryCount If the commit fails, it is retried three times. This parameter is passed in the recursive

	 * 					calls to stop the recursion

	 * @throws UnsupportedEncodingException

	 * @throws IOException

	 * @throws HttpException

	 */

	private void sendOptimize(HttpClient httpClient, int retryCount) throws UnsupportedEncodingException, IOException, HttpException {

		PostMethod method = null;

		try {

			logger.debug("Optimize retry: " + retryCount);

			method = new PostMethod(getConfiguration().getString("solrUpdateUrl"));

			method.setRequestEntity(new StringRequestEntity("<optimize/>", "text/xml", "iso8859-1"));

			int statusCode = httpClient.executeMethod(method);

			logger.debug("HTTP status: " + statusCode);

			String response = method.getResponseBodyAsString();

			logger.debug(response);

			if (statusCode != 200 && retryCount < 2) {

				try {

					Thread.sleep(10000); //Give Solr a little time to be available

				} catch (InterruptedException e) {

				}

				sendOptimize(httpClient, retryCount + 1);

			}

		}

		finally {

			if (method != null)

				method.releaseConnection();

		}

	}

	/**

	 * @param id

	 * @param config

	 * @throws ObjectNotFoundException

	 * @throws SolrServerException

	 * @throws IOException

	 * @throws MalformedURLException

	 */